💾 🧩 Feat, Refactor(Workflow, Contract): 工作流执行输出透传至活动日志 & 转换器修复

StardustSeemsInk · StardustSeemsInk · commit 228cb826318b · 2026-06-19T18:47:07.000+02:00
1. PluginCall 内置形式嵌套展开修复
   - PluginCallFunction.IsNonExtractable: true → false
   - 8 个值产生型内置函数（InstallPlugin/ListPluginNames/RunWorkflow/
     CreateWorkflow/ReadTextFile/JsonGetField/GetPluginInfoByName/ListWorks）
     同步修正为 false，使其可作为嵌套表达式展开为临时 PubVar
   - 新增 Test T 验证 Set("x", PluginCall(...)) 嵌套展开

2. BuildPluginCallExpression 双形式支持
   - 区分点号形式 Plugin.Method(args) 与内置形式
     PluginCall(pluginName, methodName, args...)，后者前两个参数为插件名/
     方法名（之前误从 FullFunctionName 提取导致插件名="PluginCall"）

3. BS2CFGConverter.BinaryExpression 嵌套展开
   - ExpandExpression 增加 BinaryExpressionSyntax 处理，递归展开
     "prefix" + Get("var") + "suffix" 中嵌套的内置调用

4. Get 按声明类型返回
   - BuildGetInvocation 增加 typeName 参数，按 ConstBlock 变量声明类型
     生成 G.Get&lt;string&gt;("name") 而非总是 G.Get&lt;object&gt;
   - InferPubVarTypes 从 Script.ConstBlock 提取变量类型（BS→CFG→CS 路径
     ConstNodes 为空）；Get 展开的临时 PubVar 继承被读变量类型

5. 工作流执行输出透传
   - WorkflowExecutionResultEventArgs 加 Output 字段
   - IWorkflowManagementService 加 RunWorkflowWithDetailsAsync → WorkflowRunResult
   - WorkflowManagementService/TriggerManager 改用新方法，Output 随事件传出

6. 编译诊断透传（保留诊断透传改动）
   - ScriptCompilationBackend/CSCompiler/BlockScriptExecutor 把 Roslyn
     诊断沿调用链传出，编译失败时 ErrorMessage 含具体错误而非仅
     "Script compilation failed"

7. --kcs &lt;path&gt; 测试功能
   - 可编译任意 .kcs 文件并报告诊断，无需启动 Dashboard
diff --git a/KitX Clients/KitX Core/KitX.Core.BluePrint.Test/KcsCompileTest.cs b/KitX Clients/KitX Core/KitX.Core.BluePrint.Test/KcsCompileTest.cs
@@ -0,0 +1,88 @@
+using System;
+using System.IO;
+using System.Text.Json;
+using Microsoft.Extensions.DependencyInjection;
+using KitX.Core.DI;
+using KitX.Core.Contract.Workflow;
+using KitX.Workflow.BlockScripting;
+using KitX.Workflow.Contract;
+using KitX.Workflow.Contract.Models;
+
+namespace KitX.Core.BluePrint.Test;
+
+/// <summary>
+/// Compiles a .kcs workflow file end-to-end (parse + BS→CFG→CS→assembly) and reports
+/// diagnostics. Invoked via <c>--kcs &lt;path&gt;</c>. Useful for validating real workflow
+/// scripts without running the Dashboard.
+/// </summary>
+public partial class Program
+{
+    public static void RunKcsCompileTest(string kcsPath)
+    {
+        Console.WriteLine($"=== KCS Compile Test: {kcsPath} ===");
+
+        if (!File.Exists(kcsPath))
+        {
+            Console.WriteLine($"FAIL: File not found: {kcsPath}");
+            return;
+        }
+
+        var services = new ServiceCollection();
+        services.AddCoreServices();
+        var sp = services.BuildServiceProvider();
+        var parser = sp.GetRequiredService<IBlockScriptParser>();
+
+        KcsFileFormat? kcs;
+        try
+        {
+            kcs = JsonSerializer.Deserialize<KcsFileFormat>(File.ReadAllText(kcsPath));
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"FAIL: JSON parse error: {ex.Message}");
+            return;
+        }
+        if (kcs == null || string.IsNullOrEmpty(kcs.BlockScriptSource))
+        {
+            Console.WriteLine("FAIL: Empty BlockScriptSource");
+            return;
+        }
+
+        Console.WriteLine($"Name: {kcs.Name}");
+        Console.WriteLine($"Id: {kcs.Id}");
+        Console.WriteLine($"Trigger: {kcs.TriggerType}");
+        Console.WriteLine($"UseBlockMode: {kcs.UseBlockMode}");
+        Console.WriteLine($"Helpers: {(kcs.HelperFunctions?.Count ?? 0)}");
+        Console.WriteLine();
+
+        var sourceCode = kcs.BlockScriptSource;
+        Console.WriteLine("--- BlockScript source ---");
+        Console.WriteLine(sourceCode);
+        Console.WriteLine("--- end ---\n");
+
+        // Parse
+        var pr = parser.Parse(sourceCode);
+        Console.WriteLine($"Parse: {(pr.IsSuccess ? "OK" : "FAIL")}, err: {pr.ErrorMessage}");
+        if (pr.Script == null)
+        {
+            Console.WriteLine("FAIL: Script is null after parse");
+            return;
+        }
+
+        // Attach helper functions from the kcs file
+        if (kcs.HelperFunctions != null)
+            pr.Script.HelperFunctions = kcs.HelperFunctions;
+
+        // Compile
+        var compiler = new CSCompiler();
+        var result = compiler.CompileScript(pr.Script, workflowId: kcs.Id, out var errors);
+        Console.WriteLine($"Compiled: {(result == null ? "NULL" : "OK")}, errors: {errors.Count}");
+        foreach (var e in errors)
+            Console.WriteLine("  ERR: " + e);
+
+        if (result != null && errors.Count == 0)
+            Console.WriteLine("\nRESULT: PASS");
+        else
+            Console.WriteLine("\nRESULT: FAIL");
+    }
+}
diff --git a/KitX Clients/KitX Core/KitX.Core.BluePrint.Test/Program.cs b/KitX Clients/KitX Core/KitX.Core.BluePrint.Test/Program.cs
@@ -14,7 +14,7 @@
 
 namespace KitX.Core.BluePrint.Test;
 
-public class Program
+public partial class Program
 {
     // Test selection: --test A,D,K or --test all (default: all)
     private static HashSet<string> _selectedTests = new(StringComparer.OrdinalIgnoreCase) { "ALL" };
@@ -24,6 +24,15 @@ public static void Main(string[] args)
     {
         ParseArgs(args);
 
+        // --kcs <path>: compile a .kcs workflow file and report diagnostics.
+        // Useful for validating real workflow scripts without running the Dashboard.
+        var kcsIdx = Array.IndexOf(args, "--kcs");
+        if (kcsIdx >= 0 && kcsIdx + 1 < args.Length)
+        {
+            RunKcsCompileTest(args[kcsIdx + 1]);
+            return;
+        }
+
         Console.WriteLine("=== KitX BlockScript → Blueprint Pipeline Test ===\n");
 
         if (_selectedTests.Contains("ALL"))
diff --git a/KitX Clients/KitX Dashboard b/KitX Clients/KitX Dashboard
@@ -1 +1 @@
-Subproject commit bbf4ce23676d4ef615582a26f36567784ac44f2f
+Subproject commit 3622125becc8e412bf19a581a882a6ecc46f068d
diff --git a/KitX Clients/KitX Workflow/KitX.Workflow/BuiltinFunctions/CreateWorkflowFunction.cs b/KitX Clients/KitX Workflow/KitX.Workflow/BuiltinFunctions/CreateWorkflowFunction.cs
@@ -12,7 +12,7 @@ public class CreateWorkflowFunction : IBuiltinFunctionDefinition
         public string FunctionName => "CreateWorkflow";
         public string DisplayName => "Create Workflow";
         public bool IsFlowControl => false;
-        public bool IsNonExtractable => true;
+        public bool IsNonExtractable => false; // Value-producing (has Return pin) — can be nested as an expression
         public CFGStatementKind StatementKind => CFGStatementKind.Expression;
         public double NodeWidth => 180;
         public double NodeHeight => 80;
diff --git a/KitX Clients/KitX Workflow/KitX.Workflow/BuiltinFunctions/GetFunction.cs b/KitX Clients/KitX Workflow/KitX.Workflow/BuiltinFunctions/GetFunction.cs
@@ -37,7 +37,11 @@ public class GetFunction : IBuiltinFunctionDefinition
     public List<StatementSyntax> EmitStatements(CFGStatement stmt, CSEmitContext ctx)
     {
         var varName = stmt.Arguments?.Count > 0 ? stmt.Arguments[0].Trim('"') : "";
-        return ctx.EmitValueAssignment(stmt.PubVarTarget, CFG2CSGenerator.BuildGetInvocation(varName));
+        // Look up the ConstBlock variable's declared type so Get<T> returns the right type.
+        // Without this, Get always returns object, and passing it to a function expecting
+        // string/int/bool causes CS1503. Falls back to object if the variable is unknown.
+        var typeName = ctx.PubVarTypes.GetValueOrDefault(varName, "object");
+        return ctx.EmitValueAssignment(stmt.PubVarTarget, CFG2CSGenerator.BuildGetInvocation(varName, typeName));
     }
 
     public List<CFGStatement> LowerToCFG(
diff --git a/KitX Clients/KitX Workflow/KitX.Workflow/BuiltinFunctions/GetPluginInfoByNameFunction.cs b/KitX Clients/KitX Workflow/KitX.Workflow/BuiltinFunctions/GetPluginInfoByNameFunction.cs
@@ -14,7 +14,7 @@ public class GetPluginInfoByNameFunction : IBuiltinFunctionDefinition
         public string FunctionName => "GetPluginInfoByName";
         public string DisplayName => "Get Plugin Info";
         public bool IsFlowControl => false;
-        public bool IsNonExtractable => true;
+        public bool IsNonExtractable => false; // Value-producing (has Return pin) — can be nested as an expression
         public CFGStatementKind StatementKind => CFGStatementKind.Expression;
         public double NodeWidth => 160;
         public double NodeHeight => 60;
diff --git a/KitX Clients/KitX Workflow/KitX.Workflow/BuiltinFunctions/InstallPluginFunction.cs b/KitX Clients/KitX Workflow/KitX.Workflow/BuiltinFunctions/InstallPluginFunction.cs
@@ -13,7 +13,7 @@ public class InstallPluginFunction : IBuiltinFunctionDefinition
         public string FunctionName => "InstallPlugin";
         public string DisplayName => "Install Plugin";
         public bool IsFlowControl => false;
-        public bool IsNonExtractable => true;
+        public bool IsNonExtractable => false; // Value-producing (has Return pin) — can be nested as an expression
         public CFGStatementKind StatementKind => CFGStatementKind.Expression;
         public double NodeWidth => 140;
         public double NodeHeight => 60;
diff --git a/KitX Clients/KitX Workflow/KitX.Workflow/BuiltinFunctions/JsonGetFieldFunction.cs b/KitX Clients/KitX Workflow/KitX.Workflow/BuiltinFunctions/JsonGetFieldFunction.cs
@@ -13,7 +13,7 @@ public class JsonGetFieldFunction : IBuiltinFunctionDefinition
         public string FunctionName => "JsonGetField";
         public string DisplayName => "JSON Get Field";
         public bool IsFlowControl => false;
-        public bool IsNonExtractable => true;
+        public bool IsNonExtractable => false; // Value-producing (has Return pin) — can be nested as an expression
         public CFGStatementKind StatementKind => CFGStatementKind.Expression;
         public double NodeWidth => 160;
         public double NodeHeight => 80;
diff --git a/KitX Clients/KitX Workflow/KitX.Workflow/BuiltinFunctions/ListPluginNamesFunction.cs b/KitX Clients/KitX Workflow/KitX.Workflow/BuiltinFunctions/ListPluginNamesFunction.cs
@@ -14,7 +14,7 @@ public class ListPluginNamesFunction : IBuiltinFunctionDefinition
         public string FunctionName => "ListPluginNames";
         public string DisplayName => "List Plugin Names";
         public bool IsFlowControl => false;
-        public bool IsNonExtractable => true;
+        public bool IsNonExtractable => false; // Value-producing (has Return pin) — can be nested as an expression
         public CFGStatementKind StatementKind => CFGStatementKind.Expression;
         public double NodeWidth => 140;
         public double NodeHeight => 60;
diff --git a/KitX Clients/KitX Workflow/KitX.Workflow/BuiltinFunctions/ListWorkflowsFunction.cs b/KitX Clients/KitX Workflow/KitX.Workflow/BuiltinFunctions/ListWorkflowsFunction.cs
@@ -13,7 +13,7 @@ public class ListWorkflowsFunction : IBuiltinFunctionDefinition
         public string FunctionName => "ListWorkflows";
         public string DisplayName => "List Workflows";
         public bool IsFlowControl => false;
-        public bool IsNonExtractable => true;
+        public bool IsNonExtractable => false; // Value-producing (has Return pin) — can be nested as an expression
         public CFGStatementKind StatementKind => CFGStatementKind.Expression;
         public double NodeWidth => 140;
         public double NodeHeight => 60;
diff --git a/KitX Clients/KitX Workflow/KitX.Workflow/BuiltinFunctions/ReadTextFileFunction.cs b/KitX Clients/KitX Workflow/KitX.Workflow/BuiltinFunctions/ReadTextFileFunction.cs
@@ -12,7 +12,7 @@ public class ReadTextFileFunction : IBuiltinFunctionDefinition
         public string FunctionName => "ReadTextFile";
         public string DisplayName => "Read Text File";
         public bool IsFlowControl => false;
-        public bool IsNonExtractable => true;
+        public bool IsNonExtractable => false; // Value-producing (has Return pin) — can be nested as an expression
         public CFGStatementKind StatementKind => CFGStatementKind.Expression;
         public double NodeWidth => 140;
         public double NodeHeight => 60;
diff --git a/KitX Clients/KitX Workflow/KitX.Workflow/BuiltinFunctions/RunWorkflowFunction.cs b/KitX Clients/KitX Workflow/KitX.Workflow/BuiltinFunctions/RunWorkflowFunction.cs
@@ -12,7 +12,7 @@ public class RunWorkflowFunction : IBuiltinFunctionDefinition
         public string FunctionName => "RunWorkflow";
         public string DisplayName => "Run Workflow";
         public bool IsFlowControl => false;
-        public bool IsNonExtractable => true;
+        public bool IsNonExtractable => false; // Value-producing (has Return pin) — can be nested as an expression
         public CFGStatementKind StatementKind => CFGStatementKind.Expression;
         public double NodeWidth => 140;
         public double NodeHeight => 60;
diff --git a/KitX Clients/KitX Workflow/KitX.Workflow/Conversion/BS2CFGConverter.cs b/KitX Clients/KitX Workflow/KitX.Workflow/Conversion/BS2CFGConverter.cs
@@ -444,6 +444,22 @@ private List<CFGStatement> LowerAndPostProcess(
         if (expr is ParenthesizedExpressionSyntax paren)
             return ExpandExpression(paren.Expression, blockName, context);
 
+        // Binary expression (e.g. "prefix" + Get("var") + "suffix"):
+        // Recurse into both operands so nested calls inside concatenations are
+        // expanded into temp PubVars. Without this, the default branch below would
+        // stringify the whole expression verbatim, leaving Get/PluginCall/etc. as
+        // unresolved identifiers in the generated C# (CS0103).
+        if (expr is BinaryExpressionSyntax binary)
+        {
+            var (leftStmts, leftExpr) = ExpandExpression(binary.Left, blockName, context);
+            var (rightStmts, rightExpr) = ExpandExpression(binary.Right, blockName, context);
+            var combined = new List<CFGStatement>(leftStmts);
+            combined.AddRange(rightStmts);
+            var op = binary.OperatorToken.Text;
+            var rebuilt = $"{leftExpr} {op} {rightExpr}";
+            return (combined, rebuilt);
+        }
+
         // Default: return as-is
         return (new(), expr.ToString());
     }
diff --git a/KitX Clients/KitX Workflow/KitX.Workflow/Conversion/CFG2CSGenerator.cs b/KitX Clients/KitX Workflow/KitX.Workflow/Conversion/CFG2CSGenerator.cs
@@ -50,10 +50,21 @@ internal static Dictionary<string, string> InferPubVarTypes(
         foreach (var name in context.PubVarNames)
             pubVarTypes[name] = "object";
 
-        // Add ConstBlock variables (accessible as identifiers in expressions)
+        // Add ConstBlock variables (accessible as identifiers in expressions).
+        // ConstNodes is populated by BS→BP but NOT by BS→CFG→CS, so also read directly
+        // from the source script's ConstBlock to cover the compilation-only path.
         foreach (var kvp in context.ConstNodes)
             pubVarTypes[kvp.Key] = kvp.Value.ConstType ?? "object";
 
+        if (context.Script.ConstBlock != null)
+        {
+            foreach (var variable in context.Script.ConstBlock.Variables)
+            {
+                if (!pubVarTypes.ContainsKey(variable.Name))
+                    pubVarTypes[variable.Name] = variable.Type ?? "object";
+            }
+        }
+
         // First pass: SOURCE types
         foreach (var block in formattedScript.Blocks)
         {
@@ -65,6 +76,15 @@ internal static Dictionary<string, string> InferPubVarTypes(
                 {
                     pubVarTypes[stmt.PubVarTarget] = helper.ReturnType;
                 }
+                // Get("varName") returns the same type as the ConstBlock variable it reads.
+                // Without this, Get's temp PubVar defaults to "object", causing CS1503 when
+                // passed to functions expecting typed arguments (e.g. InstallPlugin(string)).
+                else if (stmt.FunctionName == "Get" && stmt.Arguments.Count > 0)
+                {
+                    var varName = stmt.Arguments[0].Trim('"');
+                    if (pubVarTypes.TryGetValue(varName, out var varType) && varType != "object")
+                        pubVarTypes[stmt.PubVarTarget] = varType;
+                }
             }
         }
 
@@ -716,16 +736,49 @@ internal static List<StatementSyntax> EmitDefaultStatements(CFGStatement stmt, C
     }
 
     /// <summary>
-    /// Builds <c>G.Get&lt;object&gt;("varName")</c> expression.
+    /// Builds <c>G.Get&lt;T&gt;("varName")</c> expression. The type parameter T is looked
+    /// up from the inferred type map (which includes ConstBlock declarations). Falls back
+    /// to <c>object</c> if the variable is unknown or untyped. This ensures that a
+    /// <c>Get("installUrl")</c> where <c>installUrl</c> is declared as <c>string</c> in
+    /// ConstBlock produces <c>G.Get&lt;string&gt;("installUrl")</c> — so the result can
+    /// be passed directly to functions expecting <c>string</c> without CS1503.
     /// </summary>
     internal static InvocationExpressionSyntax BuildGetInvocation(string varName)
+        => BuildGetInvocation(varName, "object");
+
+    /// <summary>
+    /// Builds <c>G.Get&lt;T&gt;("varName")</c> with an explicit type argument.
+    /// </summary>
+    internal static InvocationExpressionSyntax BuildGetInvocation(string varName, string typeName)
     {
+        // Map BS type keywords to C# type syntax. "object" → object, "string" → string, etc.
+        // "dynamic" stays dynamic (it suppresses compile-time type checking).
+        TypeSyntax typeArg;
+        if (typeName == "dynamic")
+            typeArg = IdentifierName("dynamic");
+        else
+            typeArg = PredefinedType(Token(SyntaxKind.ObjectKeyword)) // fallback
+                .WithKeyword(Token(SyntaxKind.ObjectKeyword));
+
+        // Use the correct C# keyword for primitive types declared in ConstBlock.
+        typeArg = typeName switch
+        {
+            "string" => PredefinedType(Token(SyntaxKind.StringKeyword)),
+            "int" => PredefinedType(Token(SyntaxKind.IntKeyword)),
+            "bool" => PredefinedType(Token(SyntaxKind.BoolKeyword)),
+            "double" => PredefinedType(Token(SyntaxKind.DoubleKeyword)),
+            "float" => PredefinedType(Token(SyntaxKind.FloatKeyword)),
+            "char" => PredefinedType(Token(SyntaxKind.CharKeyword)),
+            "object" => PredefinedType(Token(SyntaxKind.ObjectKeyword)),
+            "dynamic" => IdentifierName("dynamic"),
+            _ => ParseTypeName(typeName) // custom types (unlikely for ConstBlock but safe)
+        };
+
         return InvocationExpression(
             MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
                 IdentifierName("G"),
                 GenericName(Identifier("Get"),
-                    TypeArgumentList(SeparatedList(new TypeSyntax[]
-                        { PredefinedType(Token(SyntaxKind.ObjectKeyword)) })))),
+                    TypeArgumentList(SeparatedList(new TypeSyntax[] { typeArg })))),
             ArgumentList(SeparatedList(new[]
             {
                 Argument(LiteralExpression(SyntaxKind.StringLiteralExpression, Literal(varName)))
@@ -734,20 +787,52 @@ internal static InvocationExpressionSyntax BuildGetInvocation(string varName)
 
     /// <summary>
     /// Builds <c>G.PluginCall("pluginName", "methodName", args...)</c> expression.
+    /// Handles two forms:
+    ///   - Dotted: <c>Plugin.Method(args)</c> — plugin/method extracted from FullFunctionName.
+    ///   - Builtin: <c>PluginCall(pluginName, methodName, args...)</c> — plugin/method are
+    ///     the first two positional Arguments (matching the runtime signature
+    ///     G.PluginCall(string, string, params object[])).
     /// </summary>
     internal static InvocationExpressionSyntax BuildPluginCallExpression(
         CFGStatement stmt, Dictionary<string, string> pubVarTypes)
     {
-        var lastDot = (stmt.FullFunctionName ?? "").LastIndexOf('.');
-        var pluginName = lastDot >= 0 ? stmt.FullFunctionName![..lastDot] : stmt.FullFunctionName ?? "";
-        var methodName = lastDot >= 0 ? stmt.FullFunctionName![(lastDot + 1)..] : "";
+        var fullFn = stmt.FullFunctionName ?? "";
+        var lastDot = fullFn.LastIndexOf('.');
 
-        var pluginCallArgs = new List<ArgumentSyntax>
+        List<ArgumentSyntax> pluginCallArgs;
+        List<string> remainingArgs;
+
+        if (lastDot >= 0)
         {
-            Argument(LiteralExpression(SyntaxKind.StringLiteralExpression, Literal(pluginName))),
-            Argument(LiteralExpression(SyntaxKind.StringLiteralExpression, Literal(methodName)))
-        };
-        pluginCallArgs.AddRange(stmt.Arguments.Select(a =>
+            // Dotted form: Plugin.Method(args)
+            var pluginName = fullFn[..lastDot];
+            var methodName = fullFn[(lastDot + 1)..];
+            pluginCallArgs = new()
+            {
+                Argument(LiteralExpression(SyntaxKind.StringLiteralExpression, Literal(pluginName))),
+                Argument(LiteralExpression(SyntaxKind.StringLiteralExpression, Literal(methodName)))
+            };
+            remainingArgs = stmt.Arguments ?? new();
+        }
+        else
+        {
+            // Builtin form: PluginCall(pluginName, methodName, args...)
+            // The first two Arguments ARE the plugin/method names (they may be ConstBlock
+            // variable references like `uiPlugin` or string literals like `"KitX.AI.Plugin"`).
+            // Resolve them as expressions so variable refs become C# identifiers.
+            var pluginNameArg = stmt.Arguments.Count > 0 ? stmt.Arguments[0] : "\"\"";
+            var methodNameArg = stmt.Arguments.Count > 1 ? stmt.Arguments[1] : "\"\"";
+            pluginCallArgs = new()
+            {
+                Argument(ResolveArgumentExpression(pluginNameArg, pubVarTypes)),
+                Argument(ResolveArgumentExpression(methodNameArg, pubVarTypes))
+            };
+            remainingArgs = stmt.Arguments.Count > 2
+                ? stmt.Arguments.Skip(2).ToList()
+                : new();
+        }
+
+        pluginCallArgs.AddRange(remainingArgs.Select(a =>
             Argument(ResolveArgumentExpression(a, pubVarTypes))));
 
         return InvocationExpression(
diff --git a/KitX Clients/KitX Workflow/KitX.Workflow/TriggerManager.cs b/KitX Clients/KitX Workflow/KitX.Workflow/TriggerManager.cs
@@ -179,12 +179,14 @@ private void OnPluginMessageReceived(object? sender, PluginMessageReceivedEventA
                 Log.Information("[TriggerManager] Triggering workflow: {WorkflowId}", workflowId);
                 _ = System.Threading.Tasks.Task.Run(async () =>
                 {
-                    bool success = await ServiceLocator.GetRequiredService<IWorkflowManagementService>().RunWorkflowAsync(workflowId);
+                    var runResult = await ServiceLocator.GetRequiredService<IWorkflowManagementService>()
+                        .RunWorkflowWithDetailsAsync(workflowId);
                     ServiceLocator.GetRequiredService<IEventService>().Publish(
                         WorkflowEventNames.WorkflowExecutionResult,
                         new WorkflowExecutionResultEventArgs(
-                            workflowId, success,
-                            success ? null : "Workflow execution failed"));
+                            workflowId, runResult.IsSuccess,
+                            runResult.IsSuccess ? null : runResult.ErrorMessage ?? "Workflow execution failed",
+                            runResult.Output));
                 });
             }
         }
diff --git a/KitX Clients/KitX Workflow/KitX.Workflow/WorkflowManagementService.cs b/KitX Clients/KitX Workflow/KitX.Workflow/WorkflowManagementService.cs
diff --git a/KitX Clients/KitX Workflow/KitX.Workflow/WorkflowScriptService.cs b/KitX Clients/KitX Workflow/KitX.Workflow/WorkflowScriptService.cs
diff --git a/KitX Standard b/KitX Standard

Original file line number	Diff line number	Diff line change
`@@ -37,7 +37,11 @@ public class GetFunction : IBuiltinFunctionDefinition`
`37`	`37`	`public List<StatementSyntax> EmitStatements(CFGStatement stmt, CSEmitContext ctx)`
`38`	`38`	`{`
`39`	`39`	`var varName = stmt.Arguments?.Count > 0 ? stmt.Arguments[0].Trim('"') : "";`
`40`		`- return ctx.EmitValueAssignment(stmt.PubVarTarget, CFG2CSGenerator.BuildGetInvocation(varName));`
	`40`	`+ // Look up the ConstBlock variable's declared type so Get<T> returns the right type.`
	`41`	`+ // Without this, Get always returns object, and passing it to a function expecting`
	`42`	`+ // string/int/bool causes CS1503. Falls back to object if the variable is unknown.`
	`43`	`+ var typeName = ctx.PubVarTypes.GetValueOrDefault(varName, "object");`
	`44`	`+ return ctx.EmitValueAssignment(stmt.PubVarTarget, CFG2CSGenerator.BuildGetInvocation(varName, typeName));`
`41`	`45`	`}`
`42`	`46`
`43`	`47`	`public List<CFGStatement> LowerToCFG(`