🧩 Refactor(Workflow): 管道符号切换\->>+嵌套弃用+模板去嵌套+测试适配+AI_*清理+语法文档v4.0-L18

符号切换:
- PipelinePreScanner: \- 改为 > 作为管道操作符(单字符,无 JSON 转义,BS 无泛型歧义)
- 测试 X/Y: 管道语法从 \- 更新为 >

嵌套调用弃用:
- BlockStatementExtractor.ExtractStatements: 检测嵌套函数调用(InvocationExpressionSyntax
  出现在另一个调用的参数列表中)并发 BS_DEPRECATED_NESTING 警告(非致命)
- ContainsNestedCall 辅助方法:递归扫描表达式树,跳过 __pipe/__seg 哨兵

默认模板去嵌套(WorkflowStorageService.GetDefaultBlockScriptTemplate):
- 循环条件:展开为显式 PubVar 赋值(vaaa0002=Get(...); vaaa0001=HelperFuncCompare(...))
- 简单数据流:用管道语法(Get > Print, Get > HelperFuncAdd > Set)
- 分支条件:预计算到 PubVar 后供 Branch 读取
- 全程零嵌套,管道仅用于安全的线性链

测试适配:
- H/I: 重写为预展开 PubVar 形式(vaaa#### 命名,无嵌套),往返一致性测试通过
- T: 改写为展开形式(PluginCall 赋值给 PubVar,无嵌套)
- U1: 改用 GetSequentialScript(无嵌套,clean script 零警告)
- B/K/L/Q/R: 保留嵌套形式——直接编译正常,仅发弃用警告;预展开形式经往返后
  CFG2CS 存在变量声明排序问题(CS0841),需编译后端修复后才能去嵌套

工作流清理:
- 删除 12 个 AI_* .kcs 文件(SDK 6 + 运行时 a0000001-* 6)
  (AI 插件重写后脚本将过时,无保留价值)
- Chatbot.kcs 保留(AI 插件重写时一并更新)

文档:
- BlockScriptGrammarRule.md: v3.1→v4.0
  - 新增 §5.5 管道操作符(>):语法规则、语义规则、占位符 _、示例
  - §5.6 嵌套调用标记为 DEPRECATED:迁移指南(管道/显式赋值)
  - EBNF 新增 PipelineStatement/SourceList/PipelineTarget/Placeholder 产生式
  - §8 完整示例更新

验证: KitX.Workflow.Test --test all (A-Y, 25 场景) 全绿,零回归。

Author: StardustSeemsInk

KitX Clients/KitX Workflow/KitX.Workflow.Test/Program.cs

@@ -275,15 +275,15 @@ public static void Main(string[] args)
         if (ShouldRunTest("X"))
         {
             Console.WriteLine("\n┌──────────────────────────────────────────────────────────┐");
-            Console.WriteLine("│ Test X: Pipeline (\\-) parse + flatten + compile + exec   │");
+            Console.WriteLine("│ Test X: Pipeline (>) parse + flatten + compile + exec    │");
             Console.WriteLine("└──────────────────────────────────────────────────────────┘\n");
             RunPipelineExecutionTest(parser, converter);
         }
 
         if (ShouldRunTest("Y"))
         {
             Console.WriteLine("\n┌──────────────────────────────────────────────────────────┐");
-            Console.WriteLine("│ Test Y: Pipeline (\\-) round-trip fidelity                │");
+            Console.WriteLine("│ Test Y: Pipeline (>) round-trip fidelity                 │");
             Console.WriteLine("└──────────────────────────────────────────────────────────┘\n");
             RunPipelineRoundTripTest(parser, converter, reverseConverter);
         }
@@ -301,10 +301,12 @@ private static void RunDiagnosticsTest(
     {
         bool allPassed = true;
 
-        // U1: a valid script produces NO diagnostics.
+        // U1: a valid, nesting-free script produces NO diagnostics.
+        // (GetSequentialScript is used because the deprecated nested form now emits
+        // BS_DEPRECATED_NESTING warnings, which is correct behaviour, not a clean script.)
         try
         {
-            converter.Convert(GetRawNestedScript(), helpers);
+            converter.Convert(GetSequentialScript(), helpers);
             var diag = converter.LastDiagnostics;
             bool clean = diag == null || (!diag.HasErrors && !diag.HasWarnings);
             Console.WriteLine($"  [U1] Clean script diagnostics: {(clean ? "none (expected)" : diag!.Format())}");
@@ -734,7 +736,10 @@ private static string GetPreExpandedScript() => @"#ConstBlock
 Print(""示例工作流结束"");";
 
     // ──────────────────────────────────────────────
-    // Test B: Raw nested format (BS2CFGConverter must expand)
+    // Test B: Raw nested format — exercises the BS2CFGConverter nested-call expander. Nested
+    // calls are deprecated (BS_DEPRECATED_NESTING warning) but still supported; this test guards
+    // the expander until nesting is fully removed in a future commit (pending a CFG2CS variable-
+    // ordering fix that the pre-expanded form needs to compile cleanly through round-trip).
     // ──────────────────────────────────────────────
     private static string GetRawNestedScript() => @"#ConstBlock
 int guessNum = 5;
@@ -1072,54 +1077,72 @@ private static string GetNoConstScript() => @"#MainBlock
 Print(""Done"");";
 
     // ──────────────────────────────────────────────
-    // Test H: Break inside Loop
+    // Test H: Break inside Loop (pre-expanded PubVar form, no nested calls)
     // ──────────────────────────────────────────────
     private static string GetBreakScript() => @"#ConstBlock
 int maxIter = 10;
 int target = 3;
 
+#PubVarBlock
+bool vaaa0001;
+int vaaa0002;
+
 #MainBlock
 Set(""i"", 0);
-NextBlock = Loop(HelperFuncCompare(""BLE"", Get(""i""), maxIter), ""LoopBody"", ""AfterLoop"");
+vaaa0002 = Get(""i"");
+vaaa0001 = HelperFuncCompare(""BLE"", vaaa0002, maxIter);
+NextBlock = Loop(vaaa0001, ""LoopBody"", ""AfterLoop"");
 
 #Block LoopBody
-NextBlock = Branch(
-    HelperFuncCompare(""BEQ"", Get(""i""), target),
-    ""BreakBlock"",
-    ""ContinueBlock""
-);
+vaaa0002 = Get(""i"");
+vaaa0001 = HelperFuncCompare(""BEQ"", vaaa0002, target);
+NextBlock = Branch(vaaa0001, ""BreakBlock"", ""ContinueBlock"");
 
 #Block BreakBlock
 Break();
 
 #Block ContinueBlock
-Set(""i"", HelperFuncAdd(Get(""i""), 1));
+vaaa0002 = Get(""i"");
+vaaa0002 = HelperFuncAdd(vaaa0002, 1);
+Set(""i"", vaaa0002);
 NextBlock = ToLoopCond(""MainBlock"");
 
 #Block AfterLoop
 Print(""Loop finished with break"");";
 
     // ──────────────────────────────────────────────
-    // Test I: Nested Loop
+    // Test I: Nested Loop (pre-expanded PubVar form, no nested calls)
     // ──────────────────────────────────────────────
     private static string GetNestedLoopScript() => @"#ConstBlock
 int outerMax = 2;
 int innerMax = 3;
 
+#PubVarBlock
+bool vaaa0001;
+int vaaa0002;
+
 #MainBlock
 Set(""outer"", 0);
-NextBlock = Loop(HelperFuncCompare(""BLT"", Get(""outer""), outerMax), ""OuterBody"", ""Done"");
+vaaa0002 = Get(""outer"");
+vaaa0001 = HelperFuncCompare(""BLT"", vaaa0002, outerMax);
+NextBlock = Loop(vaaa0001, ""OuterBody"", ""Done"");
 
 #Block OuterBody
 Set(""inner"", 0);
-NextBlock = Loop(HelperFuncCompare(""BLT"", Get(""inner""), innerMax), ""InnerBody"", ""OuterEnd"");
+vaaa0002 = Get(""inner"");
+vaaa0001 = HelperFuncCompare(""BLT"", vaaa0002, innerMax);
+NextBlock = Loop(vaaa0001, ""InnerBody"", ""OuterEnd"");
 
 #Block InnerBody
-Set(""inner"", HelperFuncAdd(Get(""inner""), 1));
+vaaa0002 = Get(""inner"");
+vaaa0002 = HelperFuncAdd(vaaa0002, 1);
+Set(""inner"", vaaa0002);
 NextBlock = ToLoopCond(""OuterBody"");
 
 #Block OuterEnd
-Set(""outer"", HelperFuncAdd(Get(""outer""), 1));
+vaaa0002 = Get(""outer"");
+vaaa0002 = HelperFuncAdd(vaaa0002, 1);
+Set(""outer"", vaaa0002);
 NextBlock = ToLoopCond(""MainBlock"");
 
 #Block Done
@@ -2009,33 +2032,31 @@ private static void RunQualifiedPluginCallTest(IBlockScriptParser parser)
         }
     }
 
-    // Test T: Nested PluginCall inside Set — does the BS→CFG expander flatten it
-    // into a temp PubVar + standalone PluginCall, the way it does for Helper functions
-    // (Test B/C exercise HelperFuncAdd(Get(...), 1))? If yes, the generated C# should
-    // compile cleanly. If no, the nested PluginCall is emitted verbatim and fails with
-    // CS0103 'PluginCall does not exist' — a real converter gap worth fixing.
+    // Test T: PluginCall assigned to a PubVar — does the BS→CFG converter lower a value-producing
+    // PluginCall (builtin or dotted) into a temp PubVar + the call, so the generated C# compiles
+    // cleanly? The expanded form is the nesting-free successor to the former nested Set.
     private static void RunNestedPluginCallTest(IBlockScriptParser parser)
     {
-        Console.WriteLine("[Test T] Nested PluginCall as Set argument — expander coverage check");
+        Console.WriteLine("[Test T] PluginCall assigned to PubVar — expander coverage check");
 
-        // Form 1: builtin PluginCall(plugin, method, args) nested in Set.
+        // Form 1: builtin PluginCall(plugin, method, args) assigned to a PubVar.
         var sourceBuiltin = @"
 #PubVarBlock
 dynamic result;
 
 #MainBlock
-Set(""result"", PluginCall(""TestPlugin"", ""Echo"", ""hello""));
-Print(Get(""result""));
+result = PluginCall(""TestPlugin"", ""Echo"", ""hello"");
+Print(result);
 ";
 
-        // Form 2: dotted Plugin.Method(args) nested in Set.
+        // Form 2: dotted Plugin.Method(args) assigned to a PubVar.
         var sourceDotted = @"
 #PubVarBlock
 dynamic result;
 
 #MainBlock
-Set(""result"", TestPlugin.Echo(""hello""));
-Print(Get(""result""));
+result = TestPlugin.Echo(""hello"");
+Print(result);
 ";
 
         int fails = 0;
@@ -2202,14 +2223,14 @@ private static void RunStringConcatRoundTripTest(
     }
 
     // ──────────────────────────────────────────────
-    // Test X: Pipeline (\-) parse + flatten + compile + execute.
+    // Test X: Pipeline (>) parse + flatten + compile + execute.
     // Exercises linear chains, diamond (multi-source) dependency, and the _ placeholder.
     // ──────────────────────────────────────────────
     private static void RunPipelineExecutionTest(
         IBlockScriptParser parser,
         BlockScriptToBlueprintConverter converter)
     {
-        Console.WriteLine("[Test X] Pipeline (\\-): parse, flatten, compile, execute");
+        Console.WriteLine("[Test X] Pipeline (>): parse, flatten, compile, execute");
         int fails = 0;
 
         // X1: linear chain — Get → StringConcat → Print. Verifies single-source pipeline compiles
@@ -2222,7 +2243,7 @@ private static void RunPipelineExecutionTest(
 dynamic greeting;
 
 #MainBlock
-Get(""name"") \- StringConcat(""Hello, "", _) \- Print;
+Get(""name"") > StringConcat(""Hello, "", _) > Print;
 ";
 
         // X2: diamond dependency — two sources (Get + literal) feed StringConcat positionally.
@@ -2232,7 +2253,7 @@ private static void RunPipelineExecutionTest(
 string b = ""World"";
 
 #MainBlock
-Get(""a""), Get(""b"") \- StringConcat \- Print;
+Get(""a""), Get(""b"") > StringConcat > Print;
 ";
 
         foreach (var (label, src, expectedInOutput) in new[]
@@ -2291,27 +2312,27 @@ private static void RunPipelineExecutionTest(
     }
 
     // ──────────────────────────────────────────────
-    // Test Y: Pipeline (\-) round-trip.
+    // Test Y: Pipeline (>) round-trip.
     // BS → BP → BS. The pipeline flattens across the blueprint boundary (BlueprintNode does not
     // carry CFG PipelineId provenance), so the round-tripped BS is the equivalent flat PubVar
     // form — which must still parse and compile, and execute to the same output. Preserving the
-    // literal \- syntax through the blueprint is a future enhancement (storing pipeline grouping
+    // literal > syntax through the blueprint is a future enhancement (storing pipeline grouping
     // on blueprint nodes); for now the contract is semantic equivalence + re-compilability.
     // ──────────────────────────────────────────────
     private static void RunPipelineRoundTripTest(
         IBlockScriptParser parser,
         BlockScriptToBlueprintConverter converter,
         IBlueprintToBlockScriptConverter reverseConverter)
     {
-        Console.WriteLine("[Test Y] Pipeline (\\-): BS↔BP round-trip (semantic equivalence)");
+        Console.WriteLine("[Test Y] Pipeline (>): BS↔BP round-trip (semantic equivalence)");
         int fails = 0;
 
         var src = @"
 #ConstBlock
 string name = ""World"";
 
 #MainBlock
-Get(""name"") \- StringConcat(""Hi "", _) \- Print;
+Get(""name"") > StringConcat(""Hi "", _) > Print;
 ";
 
         try

KitX Clients/KitX Workflow/KitX.Workflow/BlockScripting/BlockStatementExtractor.cs

@@ -133,6 +133,23 @@ private void ExtractStatements(
             Log.Debug("  - Expression type: {ExprType}, Text: {Text}", es.Expression.GetType().Name, es.Expression.ToString());
         }
 
+        // Nested-call deprecation: warn when a function call appears as an argument of another
+        // call (e.g. Outer(Inner(x))). The pipeline operator (>) is the preferred replacement;
+        // nested calls are slated for removal. Non-fatal — the expander still handles them.
+        if (diagnostics != null)
+        {
+            foreach (var es in exprStatements)
+            {
+                if (ContainsNestedCall(es))
+                {
+                    diagnostics.AddWarning("BS_DEPRECATED_NESTING",
+                        "Nested function calls are deprecated; use the pipeline operator (>) instead. " +
+                        "For example, rewrite 'Print(Get(\"x\"))' as 'Get(\"x\") > Print'.",
+                        es.GetLineNumber());
+                }
+            }
+        }
+
         foreach (var node in root.DescendantNodes())
         {
             switch (node)
@@ -311,7 +328,7 @@ private static ExpressionStatement BuildExpressionStatement(
     };
 
     // ─── Pipeline (\-) support ────────────────────────────────────────
-    // PipelinePreScanner rewrites `src \- t1 \- t2;` to `__pipe(src, __seg(t1), __seg(t2));`.
+    // PipelinePreScanner rewrites `src > t1 > t2;` to `__pipe(src, __seg(t1), __seg(t2));`.
     // These helpers detect that sentinel form and rebuild a BSPipeline AST node whose Sources
     // are the leading non-__seg args and whose Targets are the __seg-wrapped calls.
 
@@ -380,4 +397,25 @@ private static bool IsPipeSentinel(InvocationExpressionSyntax invoke)
     private static bool IsSegSentinel(InvocationExpressionSyntax invoke)
         => invoke.Expression is IdentifierNameSyntax id
            && id.Identifier.Text == PipelinePreScanner.SegSentinel;
+
+    /// <summary>
+    /// Returns true when <paramref name="node"/> contains a nested function call — i.e. an
+    /// <see cref="InvocationExpressionSyntax"/> whose arguments themselves contain another
+    /// invocation (e.g. <c>Outer(Inner(x))</c>). Used to emit the BS_DEPRECATED_NESTING warning.
+    /// The top-level call itself does not count; only a call nested inside another call's args.
+    /// </summary>
+    private static bool ContainsNestedCall(SyntaxNode node)
+    {
+        // Find every invocation; if any invocation has an invocation among its argument
+        // descendants, it's a nested call.
+        foreach (var invoke in node.DescendantNodes().OfType<InvocationExpressionSyntax>())
+        {
+            // Skip the __pipe/__seg sentinels (pipeline rewrites — not user nesting).
+            if (IsPipeSentinel(invoke) || IsSegSentinel(invoke))
+                continue;
+            if (invoke.ArgumentList.Arguments.Any(a => a.DescendantNodes().OfType<InvocationExpressionSyntax>().Any()))
+                return true;
+        }
+        return false;
+    }
 }