@ema.co/mcp-toolkit 2026.2.19 → 2026.2.23-2

package/dist/cli/index.js

@@ -11,7 +11,7 @@
  *   config validate       - Validate config file
  */
 import { loadConfig } from "../sdk/config.js";
-import { EmaClient } from "../sdk/client.js";
+import { EmaClientAdapter } from "../sdk/client-adapter.js";
 import { SyncSDK } from "../sync/sdk.js";
 function printUsage() {
     console.log(`
@@ -220,7 +220,7 @@ async function runAgentsCommand(subcommand, args, options) {
         baseUrl: master.baseUrl,
         bearerToken: getEnvOrThrow(master.bearerTokenEnv),
     };
-    const client = new EmaClient(env);
+    const client = new EmaClientAdapter(env);
     switch (subcommand) {
         case "list": {
             const actions = await client.listAgents();

package/dist/mcp/domain/loop-detection.js

@@ -1,31 +1,18 @@
 /**
  * Loop Detection for Workflow Graphs
  *
- * Extracted from workflow-execution-analyzer.ts — only the parts
- * used by live validation code (detectLoops + LoopInfo).
+ * Uses the shared WorkflowGraph representation from workflow-graph.ts
+ * for cycle and re-entry detection in workflow validation.
  */
-import { parseWorkflowDef } from "../knowledge.js";
-function buildGraphMaps(nodes) {
-    const forward = new Map();
-    const nodeMap = new Map();
-    for (const node of nodes) {
-        nodeMap.set(node.id, node);
-        forward.set(node.id, new Set());
-    }
-    for (const node of nodes) {
-        if (node.incoming_edges) {
-            for (const edge of node.incoming_edges) {
-                const sourceId = edge.source_node_id;
-                forward.get(sourceId)?.add(node.id);
-            }
-        }
-    }
-    return { forward, nodeMap };
-}
+import { buildWorkflowGraph } from "./workflow-graph.js";
 export function detectLoops(workflowDef) {
-    const nodes = parseWorkflowDef(workflowDef);
+    if (!workflowDef || typeof workflowDef !== "object")
+        return [];
+    const graph = buildWorkflowGraph(workflowDef);
+    if (graph.nodes.size === 0)
+        return [];
     const loops = [];
-    const { forward, nodeMap } = buildGraphMaps(nodes);
+    const { forward } = graph;
     const visited = new Set();
     const recursionStack = new Set();
     const path = [];
@@ -33,7 +20,7 @@ export function detectLoops(workflowDef) {
         visited.add(nodeId);
         recursionStack.add(nodeId);
         path.push(nodeId);
-        for (const neighbor of (forward.get(nodeId) || [])) {
+        for (const neighbor of (forward.get(nodeId) ?? [])) {
             if (!visited.has(neighbor)) {
                 if (dfs(neighbor))
                     return true;
@@ -56,42 +43,47 @@ export function detectLoops(workflowDef) {
         recursionStack.delete(nodeId);
         return false;
     }
-    const trigger = nodes.find(n => n.action_name === 'trigger' || n.id === 'trigger');
-    if (trigger)
-        dfs(trigger.id);
-    for (const node of nodes) {
-        if (!visited.has(node.id))
-            dfs(node.id);
+    if (graph.trigger)
+        dfs(graph.trigger);
+    for (const nodeId of graph.nodes.keys()) {
+        if (!visited.has(nodeId))
+            dfs(nodeId);
     }
     // Detect categorizer routing back to upstream (re-entry)
-    for (const node of nodes) {
-        if (node.action_name === 'chat_categorizer') {
-            const downstream = forward.get(node.id) || new Set();
-            const upstream = new Set();
-            function findUpstream(nId, depth = 0) {
-                if (depth > 20)
-                    return;
-                const nodeInfo = nodeMap.get(nId);
-                if (!nodeInfo?.incoming_edges)
-                    return;
-                for (const edge of nodeInfo.incoming_edges) {
-                    upstream.add(edge.source_node_id);
-                    findUpstream(edge.source_node_id, depth + 1);
+    detectReentryLoops(graph, loops);
+    return loops;
+}
+/**
+ * Detect categorizer nodes routing back to upstream nodes (re-entry risk).
+ * Uses the graph's reverse adjacency map instead of manual edge traversal.
+ */
+function detectReentryLoops(graph, loops) {
+    for (const [nodeId, graphNode] of graph.nodes) {
+        if (graphNode.actionType !== 'chat_categorizer')
+            continue;
+        const downstream = graph.forward.get(nodeId) ?? new Set();
+        const upstream = new Set();
+        function collectUpstream(nId, depth = 0) {
+            if (depth > 20)
+                return;
+            for (const parent of (graph.reverse.get(nId) ?? [])) {
+                if (!upstream.has(parent)) {
+                    upstream.add(parent);
+                    collectUpstream(parent, depth + 1);
                 }
             }
-            findUpstream(node.id);
-            for (const downNode of downstream) {
-                if (upstream.has(downNode)) {
-                    loops.push({
-                        type: 'reentry_loop',
-                        nodes: [node.id, downNode],
-                        description: `Categorizer "${node.display_name || node.id}" routes to "${downNode}" which is upstream - can cause re-processing`,
-                        severity: 'warning',
-                        fixSuggestion: `Add state tracking or one-time-execution gate to prevent re-processing.`,
-                    });
-                }
+        }
+        collectUpstream(nodeId);
+        for (const downNode of downstream) {
+            if (upstream.has(downNode)) {
+                loops.push({
+                    type: 'reentry_loop',
+                    nodes: [nodeId, downNode],
+                    description: `Categorizer "${graphNode.displayName || nodeId}" routes to "${downNode}" which is upstream - can cause re-processing`,
+                    severity: 'warning',
+                    fixSuggestion: `Add state tracking or one-time-execution gate to prevent re-processing.`,
+                });
             }
         }
     }
-    return loops;
 }

package/dist/mcp/domain/sanitizer.js

@@ -896,7 +896,7 @@ export function applySessionMappings(text, session) {
  * Content fields that SHOULD be sanitized (allowlist approach).
  * Only these fields contain user-facing content that may have PII.
  *
- * TODO: Generate this from OpenAPI spec or gRPC definitions
+ * Manually maintained — candidate for auto-generation from OpenAPI/gRPC definitions.
  */
 const CONTENT_FIELDS = new Set([
     // Persona-level

package/dist/mcp/domain/workflow-graph-optimizer.js

@@ -12,7 +12,7 @@ import { AUTO_TRANSFORMS, ADVISORY_TRANSFORMS, } from "./workflow-graph-transfor
 function deepClone(obj) {
     return JSON.parse(JSON.stringify(obj));
 }
-function calculateMetrics(workflowDef, graph) {
+function calculateMetrics(graph) {
     const nodeCount = graph.nodes.size;
     const edgeCount = graph.edges.length;
     // Dead nodes: total - reachable from trigger
@@ -50,6 +50,83 @@ function generateImprovementSummary(before, after) {
     summary += `. ${before.nodeCount} \u2192 ${after.nodeCount} nodes.`;
     return summary;
 }
+/**
+ * Show the immediate neighborhood (parents → node → children) of a set of nodes
+ * from the graph state BEFORE a transform ran. Used to explain why nodes were
+ * classified as dead/trailing so the viewer can verify the reasoning.
+ *
+ * Example output:
+ *   orphaned_search (search)
+ *     ← (no parents — unreachable from trigger)
+ *     → respond_unused
+ *   respond_unused (respond_for_external_actions)
+ *     ← orphaned_search
+ *     → (no children — does not reach any output)
+ */
+function buildNodeNeighborhood(nodeIds, graph) {
+    if (nodeIds.length === 0)
+        return undefined;
+    const resultNodeIds = new Set(graph.outputMappings.map((m) => m.nodeId));
+    const lines = [];
+    for (const nodeId of nodeIds) {
+        const node = graph.nodes.get(nodeId);
+        if (!node)
+            continue;
+        const parents = [...(graph.reverse.get(nodeId) ?? [])];
+        const children = [...(graph.forward.get(nodeId) ?? [])];
+        const parentStr = parents.length > 0
+            ? parents.join(" · ")
+            : "(no parents)";
+        const childStr = children.length > 0
+            ? children.map((c) => resultNodeIds.has(c) ? `${c} [→OUTPUT]` : c).join(" · ")
+            : "(no children — does not reach any output)";
+        lines.push(`  ${nodeId} (${node.actionType})`);
+        lines.push(`    ← ${parentStr}`);
+        lines.push(`    → ${childStr}`);
+    }
+    return lines.join("\n") || undefined;
+}
+/**
+ * Build a compact edge-list flow diagram of the workflow graph.
+ *
+ * Lists nodes in topological order (or declaration order for triggerless workflows),
+ * showing depth, type, children, and which nodes map to outputs.
+ */
+function buildFlowDiagram(graph) {
+    if (graph.nodes.size === 0)
+        return "(empty workflow — no nodes)";
+    const resultNodeIds = new Set(graph.outputMappings.map((m) => m.nodeId));
+    const lines = [];
+    // Header line
+    const triggerNote = graph.trigger
+        ? `entry: ${graph.trigger}`
+        : "no recognized trigger (dashboard/document workflow — all nodes kept)";
+    lines.push(`${graph.nodes.size} nodes · ${graph.edges.length} edges · ${triggerNote}`);
+    // Topological order for consistent depth-first traversal; fall back to declaration order
+    const topoOrder = getTopologicalOrder(graph);
+    const nodeOrder = topoOrder.length === graph.nodes.size ? topoOrder : [...graph.nodes.keys()];
+    for (const nodeId of nodeOrder) {
+        const node = graph.nodes.get(nodeId);
+        if (!node)
+            continue;
+        const children = [...(graph.forward.get(nodeId) ?? [])];
+        const tags = [];
+        if (node.isTrigger)
+            tags.push("ENTRY");
+        if (resultNodeIds.has(nodeId))
+            tags.push("→OUTPUT");
+        if (node.hasSideEffects && !node.isTrigger)
+            tags.push("side-effect");
+        const tagStr = tags.length ? `  [${tags.join(", ")}]` : "";
+        // Indent up to 6 levels to avoid runaway indentation on deep graphs
+        const indent = "  ".repeat(Math.min(node.depth, 6));
+        lines.push(`${indent}${nodeId} (${node.actionType})${tagStr}`);
+        if (children.length > 0) {
+            lines.push(`${indent}  └─► ${children.join(" · ")}`);
+        }
+    }
+    return lines.join("\n");
+}
 function validateWorkflow(workflowDef) {
     const errors = [];
     const warnings = [];
@@ -97,7 +174,7 @@ export function optimizeWorkflow(workflowDef, options) {
     // Graceful handling of invalid input
     if (!workflowDef || typeof workflowDef !== "object") {
         return {
-            workflowDef: workflowDef ?? {},
+            workflowDef: (workflowDef ?? {}),
             modified: false,
             appliedTransforms: [],
             advisories: [],
@@ -107,6 +184,7 @@ export function optimizeWorkflow(workflowDef, options) {
                 improvement: "No changes needed.",
             },
             validation: { valid: false, errors: ["Invalid workflow_def input"], warnings: [] },
+            flow_diagram: "(no workflow_def provided)",
         };
     }
     try {
@@ -114,14 +192,16 @@ export function optimizeWorkflow(workflowDef, options) {
         let currentWorkflowDef = deepClone(workflowDef);
         // Step 2: Calculate "before" metrics
         let graph = buildWorkflowGraph(currentWorkflowDef);
-        const beforeMetrics = calculateMetrics(currentWorkflowDef, graph);
+        const beforeMetrics = calculateMetrics(graph);
         // Step 3: Auto-apply transforms (convergence loop)
+        // Captures pass number and before-graph neighborhood for each change.
         const appliedTransforms = [];
         if (autoApply && maxPasses > 0) {
             for (let pass = 0; pass < maxPasses; pass++) {
                 let anyApplied = false;
                 for (const transform of AUTO_TRANSFORMS) {
                     try {
+                        const graphBefore = graph; // snapshot before this transform
                         const result = transform.apply(currentWorkflowDef, graph);
                         if (result && result.applied) {
                             currentWorkflowDef = result.workflowDef;
@@ -131,6 +211,12 @@ export function optimizeWorkflow(workflowDef, options) {
                                 description: result.description,
                                 nodesRemoved: result.nodesRemoved,
                                 nodesModified: result.nodesModified,
+                                pass: pass + 1,
+                                // Show neighborhood of affected nodes in the before-graph so the
+                                // viewer can verify why each node was classified as removable.
+                                flow_context: result.nodesRemoved.length > 0
+                                    ? buildNodeNeighborhood(result.nodesRemoved, graphBefore)
+                                    : undefined,
                             });
                             anyApplied = true;
                         }
@@ -143,17 +229,15 @@ export function optimizeWorkflow(workflowDef, options) {
                     break; // Converged
             }
         }
-        // Step 4: Calculate "after" metrics
+        // Step 4: Calculate "after" metrics and rebuild final graph
         graph = buildWorkflowGraph(currentWorkflowDef);
-        const afterMetrics = calculateMetrics(currentWorkflowDef, graph);
+        const afterMetrics = calculateMetrics(graph);
         // Step 5: Run advisory transforms
         const advisories = [];
         for (const transform of ADVISORY_TRANSFORMS) {
             try {
                 const result = transform.apply(currentWorkflowDef, graph);
                 if (result && !result.applied) {
-                    // Advisory: applied=false means it's a finding, not a fix
-                    // Extract affected nodes from the description or result fields
                     const affectedNodes = extractAffectedNodes(result);
                     advisories.push({
                         id: transform.id,
@@ -166,21 +250,18 @@ export function optimizeWorkflow(workflowDef, options) {
                 // Advisory failure: skip
             }
         }
-        // Step 6: Generate improvement summary
+        // Step 6: Generate improvement summary + validation + flow diagram
         const improvement = generateImprovementSummary(beforeMetrics, afterMetrics);
-        // Step 7: Post-optimization validation
         const validation = validateWorkflow(currentWorkflowDef);
+        const flow_diagram = buildFlowDiagram(graph);
         return {
             workflowDef: currentWorkflowDef,
             modified: appliedTransforms.length > 0,
             appliedTransforms,
             advisories,
-            metrics: {
-                before: beforeMetrics,
-                after: afterMetrics,
-                improvement,
-            },
+            metrics: { before: beforeMetrics, after: afterMetrics, improvement },
             validation,
+            flow_diagram,
         };
     }
     catch {
@@ -196,6 +277,7 @@ export function optimizeWorkflow(workflowDef, options) {
                 improvement: "No changes needed.",
             },
             validation: { valid: false, errors: ["Optimization failed unexpectedly"], warnings: [] },
+            flow_diagram: "(optimization failed)",
         };
     }
 }

package/dist/mcp/domain/workflow-graph-transforms.js

@@ -66,32 +66,46 @@ function nodeSignature(action) {
     }
     return JSON.stringify({ actionType, version, inputWiring });
 }
-/** Check if an action has side effects based on its type. */
-function hasSideEffects(action) {
-    const actionType = extractActionType(action);
-    const SIDE_EFFECT_FREE = new Set([
-        "search", "call_llm", "entity_extraction", "respond_with_sources",
-        "respond_for_external_actions", "conversation_to_search_query",
-        "combine_search_results", "text_categorizer", "chat_categorizer",
-        "response_validator", "fixed_response", "live_web_search",
-        "ai_web_search", "json_mapper", "custom_agent",
-    ]);
-    const TRIGGER_TYPES = new Set(["chat_trigger", "voice_trigger", "document_trigger"]);
-    if (TRIGGER_TYPES.has(actionType))
-        return false;
-    if (SIDE_EFFECT_FREE.has(actionType))
-        return false;
-    return true;
-}
-/** Check if an action is a trigger node. */
-function isTriggerAction(action) {
-    const actionType = extractActionType(action);
-    return actionType === "chat_trigger" || actionType === "voice_trigger" || actionType === "document_trigger";
-}
 /** Get all node names from actions array. */
 function getActionNames(actions) {
     return new Set(actions.map((a) => a.name).filter(Boolean));
 }
+/**
+ * Recursively rewire actionOutput references from oldName → newName in a binding.
+ * Mirrors extractEdgesFromBinding in workflow-graph.ts: handles the same nesting
+ * depth so graph construction and reference rewiring stay symmetric.
+ *
+ * Handles:
+ *   actionOutput         → base case: mutate actionName if matches
+ *   multiBinding         → recurse into elements[]
+ *   namedBinding         → recurse into .value
+ */
+function rewireBinding(binding, oldName, newName) {
+    if (!binding || typeof binding !== "object")
+        return;
+    if (binding.actionOutput) {
+        const ao = binding.actionOutput;
+        if (ao.actionName === oldName) {
+            ao.actionName = newName;
+        }
+        return;
+    }
+    if (binding.multiBinding) {
+        const mb = binding.multiBinding;
+        const elements = mb.elements ?? [];
+        for (const elem of elements) {
+            rewireBinding(elem, oldName, newName);
+        }
+        return;
+    }
+    if (binding.namedBinding) {
+        const nb = binding.namedBinding;
+        const value = nb.value;
+        if (value) {
+            rewireBinding(value, oldName, newName);
+        }
+    }
+}
 /**
  * Rewire all references from oldName to newName in the actions array.
  * This updates actionOutput bindings, multiBinding refs, and runIf refs.
@@ -101,35 +115,7 @@ function rewireReferences(actions, oldName, newName) {
         const inputs = action.inputs;
         if (inputs) {
             for (const val of Object.values(inputs)) {
-                const binding = val;
-                if (binding?.actionOutput) {
-                    const ao = binding.actionOutput;
-                    if (ao.actionName === oldName) {
-                        ao.actionName = newName;
-                    }
-                }
-                if (binding?.multiBinding) {
-                    const mb = binding.multiBinding;
-                    const elements = mb.elements ?? [];
-                    for (const elem of elements) {
-                        if (elem.namedBinding) {
-                            const nb = elem.namedBinding;
-                            const value = nb.value;
-                            if (value?.actionOutput) {
-                                const ao = value.actionOutput;
-                                if (ao.actionName === oldName) {
-                                    ao.actionName = newName;
-                                }
-                            }
-                        }
-                        else if (elem.actionOutput) {
-                            const ao = elem.actionOutput;
-                            if (ao.actionName === oldName) {
-                                ao.actionName = newName;
-                            }
-                        }
-                    }
-                }
+                rewireBinding(val, oldName, newName);
             }
         }
         // Rewire runIf
@@ -187,7 +173,7 @@ const removeDeadNodes = {
                 const node = graph.nodes.get(nodeId);
                 const hasDisplayName = node.displayName && node.displayName !== nodeId;
                 const isReferencedInResults = Object.values(results).some((r) => r.actionName === nodeId);
-                const hasActionOutputInputs = [...node.inputs.values()].some((ref) => ref.type === "action_output");
+                const hasActionOutputInputs = [...node.inputs.values()].some((ref) => ref.type === "action_output" || ref.type === "multi_binding");
                 if (hasDisplayName || isReferencedInResults || hasActionOutputInputs) {
                     // Intentional node: skip removal (could attempt wiring, but
                     // wiring heuristics are risky so we just keep it)
@@ -310,9 +296,10 @@ const mergeIdenticalNodes = {
             // Group by signature, skipping triggers and side-effect nodes
             const groups = new Map();
             for (const action of actions) {
-                if (isTriggerAction(action))
+                const graphNode = graph.nodes.get(action.name);
+                if (graphNode?.isTrigger)
                     continue;
-                if (hasSideEffects(action))
+                if (graphNode?.hasSideEffects ?? true)
                     continue;
                 const sig = nodeSignature(action);
                 if (!groups.has(sig))
@@ -521,6 +508,15 @@ const removeTrailingNodes = {
         try {
             if (graph.nodes.size === 0)
                 return null;
+            // Dashboard/document workflows have no recognized trigger action.
+            // Without a trigger, every supplier node (which has no forward path to a result
+            // because it IS an upstream input) would be incorrectly classified as trailing.
+            if (!graph.trigger)
+                return null;
+            // Without any result mappings we cannot identify what contributes to output,
+            // so every non-trigger side-effect-free node would appear trailing.
+            if (graph.outputMappings.length === 0)
+                return null;
             // Build set of nodes that contribute to output mappings
             const resultNodes = new Set(graph.outputMappings.map((m) => m.nodeId));
             // Find nodes that are downstream of result nodes but don't contribute to results

package/dist/mcp/domain/workflow-graph.js

@@ -4,8 +4,8 @@
  * Single source of truth for parsing workflow_def JSON into a typed graph.
  * Used by the workflow optimizer for static analysis.
  *
- * NOTE: `loop-detection.ts` has its own `buildGraphMaps()` for validation
- * (cycle/re-entry detection). Future work: consolidate both into this module.
+ * `loop-detection.ts` uses `buildWorkflowGraph()` from this module for
+ * cycle and re-entry detection (consolidated from a prior local `buildGraphMaps`).
  */
 // ─────────────────────────────────────────────────────────────────────────────
 // Constants
@@ -117,23 +117,8 @@ export function buildWorkflowGraph(workflowDef) {
             }
             else if (binding.multiBinding) {
                 inputRefs.set(inputName, { type: "multi_binding" });
-                // Parse elements for nested actionOutput refs
-                const mb = binding.multiBinding;
-                const elements = mb.elements ?? [];
-                for (const elem of elements) {
-                    if (elem.namedBinding) {
-                        const nb = elem.namedBinding;
-                        const value = nb.value;
-                        if (value?.actionOutput) {
-                            const ao = value.actionOutput;
-                            addEdge(edges, forward, reverse, ao.actionName, nodeId, ao.output, inputName);
-                        }
-                    }
-                    else if (elem.actionOutput) {
-                        const ao = elem.actionOutput;
-                        addEdge(edges, forward, reverse, ao.actionName, nodeId, ao.output, inputName);
-                    }
-                }
+                // Recursively traverse nested multiBinding/namedBinding structures to find all actionOutput refs
+                extractEdgesFromBinding(binding, nodeId, inputName, edges, forward, reverse);
             }
             else if (binding.widgetConfig) {
                 inputRefs.set(inputName, { type: "widget" });
@@ -363,6 +348,43 @@ function extractEnumTypeName(et) {
     }
     return undefined;
 }
+/**
+ * Recursively extract actionOutput edges from an arbitrarily nested binding structure.
+ *
+ * Handles:
+ *   actionOutput         → base case: emit edge
+ *   multiBinding         → recurse into elements[]
+ *   namedBinding         → recurse into .value
+ *
+ * This covers nested proto patterns like:
+ *   { multiBinding: { elements: [{ namedBinding: { value: { multiBinding: { elements: [{ actionOutput: {...} }] } } } }] } }
+ */
+function extractEdgesFromBinding(binding, targetNode, targetInput, edges, forward, reverse) {
+    if (!binding || typeof binding !== "object")
+        return;
+    if (binding.actionOutput) {
+        const ao = binding.actionOutput;
+        if (ao.actionName) {
+            addEdge(edges, forward, reverse, ao.actionName, targetNode, ao.output ?? "", targetInput);
+        }
+        return;
+    }
+    if (binding.multiBinding) {
+        const mb = binding.multiBinding;
+        const elements = mb.elements ?? [];
+        for (const elem of elements) {
+            extractEdgesFromBinding(elem, targetNode, targetInput, edges, forward, reverse);
+        }
+        return;
+    }
+    if (binding.namedBinding) {
+        const nb = binding.namedBinding;
+        const value = nb.value;
+        if (value) {
+            extractEdgesFromBinding(value, targetNode, targetInput, edges, forward, reverse);
+        }
+    }
+}
 function addEdge(edges, forward, reverse, source, target, sourceOutput, targetInput) {
     edges.push({ source, target, sourceOutput, targetInput });
     if (!forward.has(source))

package/dist/mcp/domain/workflow-path-enumerator.js

@@ -50,7 +50,7 @@ export function enumeratePaths(workflow, options) {
                 throw new Error("Branch outcome without branch_point");
             }
             for (const value of result.branch_point.possible_values) {
-                const forkedSession = forkSessionForBranching(session, result.branch_point, value);
+                const forkedSession = forkSessionForBranching(session, result.branch_point, value, workflow);
                 sessionsToProcess.push(forkedSession);
             }
         }
@@ -80,7 +80,7 @@ function createInitialSession(workflow) {
         action_states: new Map(),
     };
 }
-function forkSessionForBranching(session, branchInfo, chosenValue) {
+function forkSessionForBranching(session, branchInfo, chosenValue, workflow) {
     // Deep copy session
     const forked = {
         completed_actions: [...session.completed_actions],
@@ -102,8 +102,11 @@ function forkSessionForBranching(session, branchInfo, chosenValue) {
         node_id: branchInfo.action_that_branched,
         output_name: branchInfo.branching_output_name,
     });
-    // TODO: Generate dummy outputs for other outputs of branching action
-    // TODO: Generate dummy outputs for non-branching actions
+    // Add remaining outputs from the branching action (e.g. categorizer also produces confidence)
+    const branchingNode = workflow.nodes?.find(n => n.id === branchInfo.action_that_branched);
+    if (branchingNode) {
+        addActionOutputs(forked, branchingNode);
+    }
     return forked;
 }
 // ─────────────────────────────────────────────────────────────────────────────