footprintjs 4.14.0 → 4.16.0

package/CLAUDE.md

@@ -268,6 +268,158 @@ const llmCommit = findCommit(commitLog, 'call-llm', 'adapterRawResponse');
 | `findLastWriter(commitLog, key, beforeIdx?)` | `CommitBundle \| undefined` | Search backwards for who wrote a key |
 | `KeyedRecorder<T>` | abstract class | Base for 1:1 Map-based recorders |
 | `SequenceRecorder<T>` | abstract class | Base for 1:N ordered sequence recorders (has `getEntryRanges()` for O(1) time-travel) |
+| `topologyRecorder()` / `TopologyRecorder` | factory / class | Live composition graph for streaming consumers (subflow nodes + control-flow edges) |
+| `inOutRecorder()` / `InOutRecorder` | factory / class | Chart in/out stream — `entry`/`exit` pairs at every chart boundary (top-level run + every subflow) |
+
+### TopologyRecorder — Composition Graph for Streaming Consumers
+
+**One-liner:** reconstructs a live, queryable mini-flowchart of what your run actually traced, built from the 3 primitive recorder channels during traversal.
+
+**Mental model:**
+
+```
+flowChart() builder      →  STATIC flowchart (design-time definition)
+                                       │
+                                       ▼ executor runs it
+                         Traversal emits events on 3 channels:
+                            Recorder · FlowRecorder · EmitRecorder
+                                       │
+                                       ▼ TopologyRecorder listens
+                         DYNAMIC flowchart (runtime shape):
+                            Nodes = composition points
+                               (subflow / fork-branch / decision-branch)
+                            Edges = transitions
+                               (next / fork / decision / loop)
+                            Queryable any moment — during or after run
+```
+
+**What it IS:**
+- Live composition graph derived from 3 primitive channels
+- Each node = one composition-significant moment (subflow entered, fork child, decision chosen)
+- Each edge = a control-flow transition, timestamped with `runtimeStageId`
+- Works identically during or after a run
+
+**What it ISN'T:**
+- Not a full execution tree — that's `StageContext` / `executor.getSnapshot()`
+- Not per-stage data — that's `MetricRecorder` / custom `KeyedRecorder<T>`
+- Not agent-specific — agentfootprint composes it; footprintjs owns it
+
+**Why live consumers need it:** The executor already has the topology internally (execution tree in `StageContext`). But streaming consumers can't access that tree mid-run — they only see events. `TopologyRecorder` = "the tree, reconstructed from events, live-queryable."
+
+Fills the gap between "post-run snapshot (full tree available)" and "live event stream (only point observations)." Attach once; query `getTopology()` anytime during or after a run.
+
+```typescript
+import { topologyRecorder } from 'footprintjs/trace';
+
+const topo = topologyRecorder();
+executor.attachCombinedRecorder(topo); // auto-routes to FlowRecorder channel
+
+await executor.run({ input });
+
+const { nodes, edges, activeNodeId, rootId } = topo.getTopology();
+topo.getSubflowNodes();          // agent-centric view
+topo.getByKind('fork-branch');   // all parallel branches
+topo.getParallelSiblings(id);    // siblings of a parallel branch
+```
+
+**Three node kinds — complete composition coverage:**
+
+| Kind | Fires on | Represents |
+|---|---|---|
+| `subflow` | `onSubflowEntry` | Mounted subflow boundary (with stable `subflowId`) |
+| `fork-branch` | `onFork` (synthesized one per child) | One branch of a parallel split — works for plain stages AND subflows |
+| `decision-branch` | `onDecision` (synthesized for chosen) | The chosen branch of a conditional |
+
+When a fork-branch or decision-branch target is also a subflow, the subsequent `onSubflowEntry` creates a subflow CHILD of the synthetic node. Layered shape preserves both "who branched" and "what the branch ran."
+
+**Edges:** one per control-flow transition. `edge.kind ∈ 'next' | 'fork-branch' | 'decision-branch' | 'loop-iteration'`. Each carries `at: runtimeStageId` for time correlation.
+
+**Correlation rules:**
+- `onFork({ parent, children })` → N `fork-branch` nodes synthesized up-front; subsequent matching `onSubflowEntry` nests under the right fork-branch
+- `onDecision({ chosen })` → `decision-branch` node synthesized up-front; matching `onSubflowEntry` nests under it
+- Pending correlation clears on `onSubflowExit` so state doesn't leak across scopes
+- `onLoop` → self-edge on the currently-active subflow (synthetic nodes don't participate)
+- Re-entry of same `subflowId` (loop body) disambiguates via `id#n` suffix
+
+**What it does NOT track:** plain sequential stages. Use `MetricRecorder` / `StageContext` for per-stage data. Topology is a graph of control-flow branching, not a full execution tree.
+
+**For downstream libraries:** compose, don't duplicate. An agent-shaped recorder should wrap a `topologyRecorder()` internally and translate topology nodes into agent semantics — not re-implement subflow-stack + fork + decision tracking.
+
+Example: [examples/runtime-features/flow-recorder/06-topology.ts](examples/runtime-features/flow-recorder/06-topology.ts)
+
+### InOutRecorder — Chart In/Out Stream (every chart boundary, root + subflows)
+
+**One-liner:** captures every chart execution (top-level run AND every subflow) as an `entry`/`exit` boundary pair, with the `inputMapper`/`outputMapper` payloads attached. Combined with `TopologyRecorder` (composition shape) this gives downstream layers the universal "step" primitive — `runtimeStageId` binds them.
+
+**Mental model:**
+
+```
+   user input ─►┌───────────────── run ─────────────────┐ ◄─ user output
+                │  __root__#0   onRunStart / onRunEnd   │
+                │                                        │
+                │   inputMapper          outputMapper    │
+                │       │                     │          │
+                │  parent ──►┤ subflow ├──► parent       │
+                │       │                     │          │
+                │       └── runtimeStageId ───┘          │
+                │                                        │
+                └────────────────────────────────────────┘
+```
+
+Each chart execution → 2 boundaries:
+- **Root** — `onRunStart` / `onRunEnd` fire ONCE per `executor.run()`. `subflowId: '__root__'`, `depth: 0`, `isRoot: true`.
+- **Subflow** — `onSubflowEntry` / `onSubflowExit` fire once per mounted subflow. Nested under root in the path tree (`['__root__', 'sf-x']`, depth 1+).
+
+Loop re-entry produces distinct pairs because the parent stage's executionIndex increments.
+
+**What it IS:**
+- `SequenceRecorder<InOutEntry>` — flat ordered list + per-`runtimeStageId` index
+- Captures the **payloads** at every chart boundary (what flowed IN and OUT)
+- Path-aware: `subflowPath` is decomposed from the engine's path-prefixed `subflowId` and rooted under `__root__`
+- Domain-agnostic — knows nothing about LLMs, tools, agents
+
+**What it ISN'T:**
+- Not a composition graph — that's `TopologyRecorder` (shape) vs this (data crossing each boundary)
+- Not a full execution tree — that's `StageContext`
+- Not agent-specific — domain libraries (e.g. agentfootprint) compose it; footprintjs owns it
+
+```typescript
+import { inOutRecorder, ROOT_SUBFLOW_ID } from 'footprintjs/trace';
+
+const inOut = inOutRecorder();
+executor.attachCombinedRecorder(inOut);
+
+await executor.run({ input });
+
+inOut.getSteps();                    // entry boundaries (timeline; root is first step)
+inOut.getBoundary(runtimeStageId);   // { entry, exit } pair for one execution
+inOut.getRootBoundary();             // { entry, exit } for the top-level run
+inOut.getBoundaries();               // flat list (entry+exit interleaved)
+inOut.getEntryRanges();              // O(1) per-step range index for time-travel
+```
+
+**`InOutEntry` shape:**
+
+| Field | Description |
+|---|---|
+| `runtimeStageId` | Same value for the entry/exit pair of one execution. Top-level run uses `'__root__#0'`. |
+| `subflowId` | Path-prefixed engine id. Top-level → `'__root__'`. Subflow → `'sf-outer'` or `'sf-outer/sf-inner'`. |
+| `localSubflowId` | Last segment of `subflowId` |
+| `subflowName` | Human-readable display name (`'Run'` for the top-level run) |
+| `description` | Build-time description (carries taxonomy markers like `'Agent: ReAct loop'`). Undefined for root. |
+| `subflowPath` | Decomposition of `subflowId` rooted under `__root__`: `['__root__']` for root, `['__root__', 'sf-x']` for top-level subflow |
+| `depth` | Root → 0. First-level subflow → 1. |
+| `phase` | `'entry'` or `'exit'` |
+| `payload` | `entry`: `inputMapper` result (subflow) or `run({input})` (root); `exit`: shared state at exit (subflow) or chart return value (root) |
+| `isRoot` | True only for the synthetic root pair from `onRunStart` / `onRunEnd` |
+
+**Pause semantics:** when a stage pauses inside a subflow, the engine re-throws without firing `onSubflowExit` (or `onRunEnd`). The chart has an `entry` with no matching `exit` until resume completes. `getBoundary()` returns `{ entry, exit: undefined }` in that case.
+
+**Engine events:** `FlowRecorder.onRunStart(event)` and `onRunEnd(event)` carry `event.payload` (the run's input or output). Fire ONCE per top-level `executor.run()` — not for subflow traversers (those fire `onSubflowEntry`/`onSubflowExit` instead). Available on the `IControlFlowNarrative` interface and the `FlowRecorderDispatcher`.
+
+**For downstream libraries:** compose, don't duplicate. A domain-flavored step graph (e.g., agentfootprint's `StepGraph`) should consume `InOutRecorder` output and label each entry by inspecting the payload through domain semantics — not re-walk subflow events.
+
+Example: [examples/runtime-features/flow-recorder/07-inout.ts](examples/runtime-features/flow-recorder/07-inout.ts)
 
 **Two recorder base classes** — choose based on data shape:
 

package/dist/esm/lib/engine/handlers/SubflowExecutor.js

@@ -29,16 +29,24 @@ export class SubflowExecutor {
      * 5. Stores execution data for debugging/visualization
      */
     async executeSubflow(node, parentContext, breakFlag, branchPath, subflowResultsMap, parentTraversalContext) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d, _e, _f, _g;
         const subflowId = node.subflowId;
         const subflowName = (_a = node.subflowName) !== null && _a !== void 0 ? _a : node.name;
         parentContext.addFlowDebugMessage('subflow', `Entering ${subflowName} subflow`, {
             targetStage: subflowId,
         });
         // ─── Input Mapping ───
+        //
+        // RESUME PATH NOTE: when `deps.subflowStatesForResume` carries a
+        // capture for THIS subflow id, we SKIP the inputMapper entirely.
+        // The capture is the post-input pre-pause memory — running the
+        // mapper again would clobber post-input writes (history,
+        // pausedToolCallId, etc.) with the parent's start-of-subflow view.
         const mountOptions = node.subflowMountOptions;
         let mappedInput = {};
-        if (mountOptions) {
+        const resumeCapture = (_b = this.deps.subflowStatesForResume) === null || _b === void 0 ? void 0 : _b[subflowId];
+        const isResumeForThisSubflow = resumeCapture !== undefined;
+        if (mountOptions && !isResumeForThisSubflow) {
             try {
                 const parentScope = parentContext.getScope();
                 mappedInput = getInitialScopeValues(parentScope, mountOptions);
@@ -55,25 +63,45 @@ export class SubflowExecutor {
         // Narrative receives mapped input. inputMapper is a consumer function that may inject
         // values not from the scope (bypassing redaction). The recorder renders per includeValues.
         const narrativeInput = mappedInput;
-        this.deps.narrativeGenerator.onSubflowEntry(subflowName, subflowId, node.description, parentTraversalContext, narrativeInput);
+        // `FlowSubflowEvent.description` is semantically "what this subflow does" — sourced from
+        // the subflow's own root stage, not the parent mount point. The mount node never carries
+        // a description (builders don't copy it), so reading `node.description` here returns
+        // `undefined` and taxonomy markers set on the subflow root (e.g. agentfootprint's
+        // `'Agent: ReAct loop'` / `'LLMCall: one-shot'`) never reach downstream consumers.
+        const rootDescription = (_e = (_d = (_c = this.deps.subflows) === null || _c === void 0 ? void 0 : _c[subflowId]) === null || _d === void 0 ? void 0 : _d.root) === null || _e === void 0 ? void 0 : _e.description;
+        this.deps.narrativeGenerator.onSubflowEntry(subflowName, subflowId, rootDescription !== null && rootDescription !== void 0 ? rootDescription : node.description, parentTraversalContext, narrativeInput);
         // Create isolated runtime via dynamic construction (avoids circular import)
         const ExecutionRuntimeClass = this.deps.executionRuntime.constructor;
         const nestedRuntime = new ExecutionRuntimeClass(node.name, node.id);
         let nestedRootContext = nestedRuntime.rootStageContext;
-        // Seed GlobalStore with input
-        if (Object.keys(mappedInput).length > 0) {
-            seedSubflowGlobalStore(nestedRuntime, mappedInput);
+        // Seed GlobalStore with the right shape for the path:
+        //   • Resume into THIS subflow → seed from the captured pre-pause
+        //     scope so resume handlers see history, pausedToolCallId, etc.
+        //   • Normal entry → seed from the inputMapper's mappedInput.
+        const seedValues = isResumeForThisSubflow ? resumeCapture : mappedInput;
+        if (Object.keys(seedValues).length > 0) {
+            seedSubflowGlobalStore(nestedRuntime, seedValues);
             // Refresh rootStageContext so WriteBuffer sees committed data
             const StageContextClass = nestedRootContext.constructor;
             nestedRootContext = new StageContextClass('', nestedRootContext.stageName, nestedRootContext.stageId, nestedRuntime.globalStore, '', nestedRuntime.executionHistory);
             nestedRuntime.rootStageContext = nestedRootContext;
         }
-        // Prepare subflow root node — strip isSubflowRoot to prevent re-delegation
-        const hasChildren = Boolean(node.children && node.children.length > 0);
+        // Prepare subflow root node — strip isSubflowRoot to prevent re-delegation.
+        //
+        // PRESERVE `next`. Earlier revisions stripped `next` whenever the
+        // subflow root had children, on the assumption that `next` was
+        // always the OUTER mount's continuation leaking into the inner
+        // tree. That assumption was wrong: the resolved subflow root's
+        // `next` is the INNER join stage (e.g., Parallel's Merge after a
+        // fan-out, ToT's Pruner). Stripping it broke composite subflows —
+        // the join stage never ran, so the subflow returned partial state.
+        //
+        // The outer mount's post-subflow continuation is handled separately
+        // by the parent traverser via `parentContext.nextNode` and is never
+        // conflated with the inner subflow's `next` chain.
         const subflowNode = {
             ...node,
             isSubflowRoot: false,
-            next: hasChildren ? undefined : node.next,
         };
         // ─── Execute via factory traverser ───
         // The factory creates a full FlowchartTraverser with the same 7-phase algorithm,
@@ -91,9 +119,31 @@ export class SubflowExecutor {
             subflowOutput = await traverserHandle.execute();
         }
         catch (error) {
-            // PauseSignal is not an error — prepend subflow ID and re-throw immediately.
-            // No error logging, no subflowResult recording — the pause is control flow.
+            // PauseSignal is not an error — prepend subflow ID and re-throw
+            // immediately. No error logging, no subflowResult recording —
+            // the pause is control flow.
+            //
+            // BEFORE re-throw, snapshot the nested runtime's `sharedState`
+            // onto the signal. This is the only chance — once we re-throw,
+            // the outer traverser unwinds and the nested runtime is GC'd. On
+            // resume, we'll re-seed a fresh nested runtime from this capture
+            // so resume handlers can read the pre-pause subflow scope.
+            //
+            // Capture is keyed by the SAME path-prefixed `subflowId` used in
+            // `subflowPath`, so resume can look up "scope for sf-foo" by id.
             if (isPauseSignal(error)) {
+                try {
+                    const snap = nestedRuntime.getSnapshot();
+                    // `sharedState` is the subflow's working memory at pause
+                    // time (after every committed write up to the pause). Cast
+                    // is safe — SharedMemory snapshot returns a plain object.
+                    error.captureSubflowScope(subflowId, snap.sharedState);
+                }
+                catch (_h) {
+                    // Snapshot failure shouldn't mask the pause — let the pause
+                    // bubble up; resume will fall back to checkpoint.sharedState
+                    // (the parent scope) for this subflow's keys.
+                }
                 error.prependSubflow(subflowId);
                 throw error;
             }
@@ -172,7 +222,7 @@ export class SubflowExecutor {
             },
             parentStageId: parentContext.getStageId(),
         };
-        const subflowDef = (_b = this.deps.subflows) === null || _b === void 0 ? void 0 : _b[subflowId];
+        const subflowDef = (_f = this.deps.subflows) === null || _f === void 0 ? void 0 : _f[subflowId];
         if (subflowDef && subflowDef.buildTimeStructure) {
             subflowResult.pipelineStructure = subflowDef.buildTimeStructure;
         }
@@ -180,7 +230,7 @@ export class SubflowExecutor {
         parentContext.addFlowDebugMessage('subflow', `Exiting ${subflowName} subflow`, {
             targetStage: subflowId,
         });
-        this.deps.narrativeGenerator.onSubflowExit(subflowName, subflowId, parentTraversalContext, (_c = subflowResult.treeContext) === null || _c === void 0 ? void 0 : _c.globalContext);
+        this.deps.narrativeGenerator.onSubflowExit(subflowName, subflowId, parentTraversalContext, (_g = subflowResult.treeContext) === null || _g === void 0 ? void 0 : _g.globalContext);
         parentContext.commit();
         if (subflowError) {
             throw subflowError;
@@ -188,4 +238,4 @@ export class SubflowExecutor {
         return subflowOutput;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SubflowExecutor.js","sourceRoot":"","sources":["../../../../../src/lib/engine/handlers/SubflowExecutor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAGH,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAUrD,OAAO,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,MAAM,yBAAyB,CAAC;AAG5G,MAAM,OAAO,eAAe;IAC1B,YACU,IAA+B,EAC/B,gBAAuD;QADvD,SAAI,GAAJ,IAAI,CAA2B;QAC/B,qBAAgB,GAAhB,gBAAgB,CAAuC;IAC9D,CAAC;IAEJ;;;;;;;;OAQG;IACH,KAAK,CAAC,cAAc,CAClB,IAA6B,EAC7B,aAA2B,EAC3B,SAAoB,EACpB,UAA8B,EAC9B,iBAA6C,EAC7C,sBAAyC;;QAEzC,MAAM,SAAS,GAAG,IAAI,CAAC,SAAU,CAAC;QAClC,MAAM,WAAW,GAAG,MAAA,IAAI,CAAC,WAAW,mCAAI,IAAI,CAAC,IAAI,CAAC;QAElD,aAAa,CAAC,mBAAmB,CAAC,SAAS,EAAE,YAAY,WAAW,UAAU,EAAE;YAC9E,WAAW,EAAE,SAAS;SACvB,CAAC,CAAC;QAEH,wBAAwB;QACxB,MAAM,YAAY,GAAG,IAAI,CAAC,mBAAmB,CAAC;QAC9C,IAAI,WAAW,GAA4B,EAAE,CAAC;QAE9C,IAAI,YAAY,EAAE,CAAC;YACjB,IAAI,CAAC;gBACH,MAAM,WAAW,GAAG,aAAa,CAAC,QAAQ,EAAE,CAAC;gBAC7C,WAAW,GAAG,qBAAqB,CAAC,WAAW,EAAE,YAAY,CAAC,CAAC;gBAC/D,IAAI,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;oBACxC,qEAAqE;gBACvE,CAAC;YACH,CAAC;YAAC,OAAO,KAAU,EAAE,CAAC;gBACpB,aAAa,CAAC,QAAQ,CAAC,kBAAkB,EAAE,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC;gBAC7D,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,qCAAqC,SAAS,IAAI,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;gBACtF,MAAM,KAAK,CAAC;YACd,CAAC;QACH,CAAC;QAED,sFAAsF;QACtF,2FAA2F;QAC3F,MAAM,cAAc,GAAG,WAAW,CAAC;QACnC,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAAC,cAAc,CACzC,WAAW,EACX,SAAS,EACT,IAAI,CAAC,WAAW,EAChB,sBAAsB,EACtB,cAAc,CACf,CAAC;QAEF,4EAA4E;QAC5E,MAAM,qBAAqB,GAAG,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC,WAGnC,CAAC;QACvB,MAAM,aAAa,GAAG,IAAI,qBAAqB,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,EAAE,CAAC,CAAC;QACpE,IAAI,iBAAiB,GAAG,aAAa,CAAC,gBAAgB,CAAC;QAEvD,8BAA8B;QAC9B,IAAI,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACxC,sBAAsB,CAAC,aAAa,EAAE,WAAW,CAAC,CAAC;YACnD,8DAA8D;YAC9D,MAAM,iBAAiB,GAAG,iBAAiB,CAAC,WAAmD,CAAC;YAChG,iBAAiB,GAAG,IAAI,iBAAiB,CACvC,EAAE,EACF,iBAAiB,CAAC,SAAS,EAC3B,iBAAiB,CAAC,OAAO,EACzB,aAAa,CAAC,WAAW,EACzB,EAAE,EACF,aAAa,CAAC,gBAAgB,CAC/B,CAAC;YACF,aAAa,CAAC,gBAAgB,GAAG,iBAAiB,CAAC;QACrD,CAAC;QAED,2EAA2E;QAC3E,MAAM,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;QACvE,MAAM,WAAW,GAA4B;YAC3C,GAAG,IAAI;YACP,aAAa,EAAE,KAAK;YACpB,IAAI,EAAE,WAAW,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI;SAC1C,CAAC;QAEF,wCAAwC;QACxC,iFAAiF;QACjF,yEAAyE;QACzE,IAAI,aAAkB,CAAC;QACvB,IAAI,YAA+B,CAAC;QACpC,IAAI,eAAiE,CAAC;QAEtE,IAAI,CAAC;YACH,eAAe,GAAG,IAAI,CAAC,gBAAgB,CAAC;gBACtC,IAAI,EAAE,WAAW;gBACjB,gBAAgB,EAAE,aAAa;gBAC/B,eAAe,EAAE,WAAW;gBAC5B,SAAS;aACV,CAAC,CAAC;YAEH,aAAa,GAAG,MAAM,eAAe,CAAC,OAAO,EAAE,CAAC;QAClD,CAAC;QAAC,OAAO,KAAU,EAAE,CAAC;YACpB,6EAA6E;YAC7E,4EAA4E;YAC5E,IAAI,aAAa,CAAC,KAAK,CAAC,EAAE,CAAC;gBACzB,KAAK,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC;gBAChC,MAAM,KAAK,CAAC;YACd,CAAC;YACD,YAAY,GAAG,KAAK,CAAC;YACrB,aAAa,CAAC,QAAQ,CAAC,cAAc,EAAE,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC;YACzD,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,qBAAqB,SAAS,IAAI,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;QACxE,CAAC;QAED,sFAAsF;QACtF,IAAI,eAAe,EAAE,CAAC;YACpB,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,eAAe,CAAC,iBAAiB,EAAE,EAAE,CAAC;gBAC/D,iBAAiB,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;YACpC,CAAC;QACH,CAAC;QAED,2EAA2E;QAC3E,EAAE;QACF,iEAAiE;QACjE,yEAAyE;QACzE,gEAAgE;QAChE,8DAA8D;QAC9D,EAAE;QACF,qEAAqE;QACrE,wDAAwD;QACxD,EAAE;QACF,wEAAwE;QACxE,qEAAqE;QACrE,sEAAsE;QACtE,0EAA0E;QAC1E,gEAAgE;QAChE,IAAI,eAAe,IAAI,CAAA,YAAY,aAAZ,YAAY,uBAAZ,YAAY,CAAE,cAAc,MAAK,IAAI,EAAE,CAAC;YAC7D,MAAM,UAAU,GAAG,eAAe,CAAC,aAAa,EAAE,CAAC;YACnD,IAAI,UAAU,CAAC,WAAW,EAAE,CAAC;gBAC3B,SAAS,CAAC,WAAW,GAAG,IAAI,CAAC;gBAC7B,IAAI,UAAU,CAAC,MAAM,KAAK,SAAS,IAAI,SAAS,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;oBACtE,SAAS,CAAC,MAAM,GAAG,UAAU,CAAC,MAAM,CAAC;gBACvC,CAAC;gBACD,kEAAkE;gBAClE,mEAAmE;gBACnE,2DAA2D;gBAC3D,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC,WAAW,EAAE,sBAAsB,EAAE,UAAU,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;YAC1G,CAAC;QACH,CAAC;QAED,MAAM,kBAAkB,GAAG,aAAa,CAAC,WAAW,EAAE,CAAC;QAEvD,yBAAyB;QACzB,IAAI,CAAC,YAAY,KAAI,YAAY,aAAZ,YAAY,uBAAZ,YAAY,CAAE,YAAY,CAAA,EAAE,CAAC;YAChD,IAAI,CAAC;gBACH,IAAI,aAAa,GAAG,aAAa,CAAC;gBAClC,IAAI,aAAa,CAAC,QAAQ,IAAI,aAAa,CAAC,QAAQ,KAAK,EAAE,IAAI,aAAa,CAAC,MAAM,EAAE,CAAC;oBACpF,aAAa,GAAG,aAAa,CAAC,MAAM,CAAC;gBACvC,CAAC;gBAED,MAAM,WAAW,GAAG,aAAa,CAAC,QAAQ,EAAE,CAAC;gBAC7C,sFAAsF;gBACtF,oFAAoF;gBACpF,wFAAwF;gBACxF,iFAAiF;gBACjF,qDAAqD;gBACrD,4FAA4F;gBAC5F,sFAAsF;gBACtF,iFAAiF;gBACjF,+DAA+D;gBAC/D,MAAM,eAAe,GAAG,aAAa,aAAb,aAAa,cAAb,aAAa,GAAI,EAAE,GAAG,kBAAkB,CAAC,WAAW,EAAE,CAAC;gBAC/E,MAAM,YAAY,GAAG,kBAAkB,CAAC,eAAe,EAAE,WAAW,EAAE,aAAa,EAAE,YAAY,CAAC,CAAC;gBAEnG,aAAa,CAAC,MAAM,EAAE,CAAC;YACzB,CAAC;YAAC,OAAO,KAAU,EAAE,CAAC;gBACpB,aAAa,CAAC,QAAQ,CAAC,mBAAmB,EAAE,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC;gBAC9D,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,sCAAsC,SAAS,IAAI,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;YACzF,CAAC;QACH,CAAC;QAED,MAAM,aAAa,GAAkB;YACnC,SAAS;YACT,WAAW;YACX,WAAW,EAAE;gBACX,aAAa,EAAE,kBAAkB,CAAC,WAAW;gBAC7C,aAAa,EAAE,kBAAkB,CAAC,aAAmD;gBACrF,OAAO,EAAE,kBAAkB,CAAC,SAAS;aACtC;YACD,aAAa,EAAE,aAAa,CAAC,UAAU,EAAE;SAC1C,CAAC;QAEF,MAAM,UAAU,GAAG,MAAA,IAAI,CAAC,IAAI,CAAC,QAAQ,0CAAG,SAAS,CAAC,CAAC;QACnD,IAAI,UAAU,IAAK,UAAkB,CAAC,kBAAkB,EAAE,CAAC;YACzD,aAAa,CAAC,iBAAiB,GAAI,UAAkB,CAAC,kBAAkB,CAAC;QAC3E,CAAC;QAED,iBAAiB,CAAC,GAAG,CAAC,SAAS,EAAE,aAAa,CAAC,CAAC;QAEhD,aAAa,CAAC,mBAAmB,CAAC,SAAS,EAAE,WAAW,WAAW,UAAU,EAAE;YAC7E,WAAW,EAAE,SAAS;SACvB,CAAC,CAAC;QACH,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAAC,aAAa,CACxC,WAAW,EACX,SAAS,EACT,sBAAsB,EACtB,MAAA,aAAa,CAAC,WAAW,0CAAE,aAAa,CACzC,CAAC;QAEF,aAAa,CAAC,MAAM,EAAE,CAAC;QAEvB,IAAI,YAAY,EAAE,CAAC;YACjB,MAAM,YAAY,CAAC;QACrB,CAAC;QAED,OAAO,aAAa,CAAC;IACvB,CAAC;CACF","sourcesContent":["/**\n * SubflowExecutor — Isolation boundary for subflow execution.\n *\n * Responsibilities:\n * - Create isolated ExecutionRuntime for each subflow\n * - Apply input/output mapping via SubflowInputMapper\n * - Delegate traversal to a factory-created FlowchartTraverser\n * - Track subflow results for debugging/visualization\n *\n * Each subflow gets its own GlobalStore for isolation.\n * Traversal uses the SAME 7-phase algorithm as the top-level traverser\n * (via SubflowTraverserFactory), so deciders, selectors, loops, lazy subflows,\n * and abort signals all work inside subflows automatically.\n */\n\nimport type { StageContext } from '../../memory/StageContext.js';\nimport { isPauseSignal } from '../../pause/types.js';\nimport type { StageNode } from '../graph/StageNode.js';\nimport type { TraversalContext } from '../narrative/types.js';\nimport type {\n  HandlerDeps,\n  IExecutionRuntime,\n  SubflowResult,\n  SubflowTraverserFactory,\n  SubflowTraverserHandle,\n} from '../types.js';\nimport { applyOutputMapping, getInitialScopeValues, seedSubflowGlobalStore } from './SubflowInputMapper.js';\nimport type { BreakFlag } from './types.js';\n\nexport class SubflowExecutor<TOut = any, TScope = any> {\n  constructor(\n    private deps: HandlerDeps<TOut, TScope>,\n    private traverserFactory: SubflowTraverserFactory<TOut, TScope>,\n  ) {}\n\n  /**\n   * Execute a subflow with isolated context.\n   *\n   * 1. Creates a fresh ExecutionRuntime for the subflow\n   * 2. Applies input mapping to seed the subflow's GlobalStore\n   * 3. Delegates traversal to a factory-created FlowchartTraverser\n   * 4. Applies output mapping to write results back to parent scope\n   * 5. Stores execution data for debugging/visualization\n   */\n  async executeSubflow(\n    node: StageNode<TOut, TScope>,\n    parentContext: StageContext,\n    breakFlag: BreakFlag,\n    branchPath: string | undefined,\n    subflowResultsMap: Map<string, SubflowResult>,\n    parentTraversalContext?: TraversalContext,\n  ): Promise<any> {\n    const subflowId = node.subflowId!;\n    const subflowName = node.subflowName ?? node.name;\n\n    parentContext.addFlowDebugMessage('subflow', `Entering ${subflowName} subflow`, {\n      targetStage: subflowId,\n    });\n\n    // ─── Input Mapping ───\n    const mountOptions = node.subflowMountOptions;\n    let mappedInput: Record<string, unknown> = {};\n\n    if (mountOptions) {\n      try {\n        const parentScope = parentContext.getScope();\n        mappedInput = getInitialScopeValues(parentScope, mountOptions);\n        if (Object.keys(mappedInput).length > 0) {\n          // mappedInput is captured in SubflowResult.treeContext for debugging\n        }\n      } catch (error: any) {\n        parentContext.addError('inputMapperError', error.toString());\n        this.deps.logger.error(`Error in inputMapper for subflow (${subflowId}):`, { error });\n        throw error;\n      }\n    }\n\n    // Narrative receives mapped input. inputMapper is a consumer function that may inject\n    // values not from the scope (bypassing redaction). The recorder renders per includeValues.\n    const narrativeInput = mappedInput;\n    this.deps.narrativeGenerator.onSubflowEntry(\n      subflowName,\n      subflowId,\n      node.description,\n      parentTraversalContext,\n      narrativeInput,\n    );\n\n    // Create isolated runtime via dynamic construction (avoids circular import)\n    const ExecutionRuntimeClass = this.deps.executionRuntime.constructor as new (\n      name: string,\n      id: string,\n    ) => IExecutionRuntime;\n    const nestedRuntime = new ExecutionRuntimeClass(node.name, node.id);\n    let nestedRootContext = nestedRuntime.rootStageContext;\n\n    // Seed GlobalStore with input\n    if (Object.keys(mappedInput).length > 0) {\n      seedSubflowGlobalStore(nestedRuntime, mappedInput);\n      // Refresh rootStageContext so WriteBuffer sees committed data\n      const StageContextClass = nestedRootContext.constructor as new (...args: any[]) => StageContext;\n      nestedRootContext = new StageContextClass(\n        '',\n        nestedRootContext.stageName,\n        nestedRootContext.stageId,\n        nestedRuntime.globalStore,\n        '',\n        nestedRuntime.executionHistory,\n      );\n      nestedRuntime.rootStageContext = nestedRootContext;\n    }\n\n    // Prepare subflow root node — strip isSubflowRoot to prevent re-delegation\n    const hasChildren = Boolean(node.children && node.children.length > 0);\n    const subflowNode: StageNode<TOut, TScope> = {\n      ...node,\n      isSubflowRoot: false,\n      next: hasChildren ? undefined : node.next,\n    };\n\n    // ─── Execute via factory traverser ───\n    // The factory creates a full FlowchartTraverser with the same 7-phase algorithm,\n    // sharing the parent's stageMap, subflows dict, and narrative generator.\n    let subflowOutput: any;\n    let subflowError: Error | undefined;\n    let traverserHandle: SubflowTraverserHandle<TOut, TScope> | undefined;\n\n    try {\n      traverserHandle = this.traverserFactory({\n        root: subflowNode,\n        executionRuntime: nestedRuntime,\n        readOnlyContext: mappedInput,\n        subflowId,\n      });\n\n      subflowOutput = await traverserHandle.execute();\n    } catch (error: any) {\n      // PauseSignal is not an error — prepend subflow ID and re-throw immediately.\n      // No error logging, no subflowResult recording — the pause is control flow.\n      if (isPauseSignal(error)) {\n        error.prependSubflow(subflowId);\n        throw error;\n      }\n      subflowError = error;\n      parentContext.addError('subflowError', error.toString());\n      this.deps.logger.error(`Error in subflow (${subflowId}):`, { error });\n    }\n\n    // Always merge nested subflow results (even on error — partial results aid debugging)\n    if (traverserHandle) {\n      for (const [key, value] of traverserHandle.getSubflowResults()) {\n        subflowResultsMap.set(key, value);\n      }\n    }\n\n    // ─── Break propagation (opt-in via SubflowMountOptions.propagateBreak) ──\n    //\n    // If the subflow's inner traversal broke (because a stage called\n    // `scope.$break(reason)`) AND the mount declared `propagateBreak: true`,\n    // forward the break state to the PARENT's breakFlag. The parent\n    // traverser will see `shouldBreak` on its next step and stop.\n    //\n    // Without this, inner breaks are locally scoped to the subflow — the\n    // parent continues as if the subflow returned normally.\n    //\n    // IMPORTANT: this runs BEFORE `outputMapping` below, intentionally. The\n    // outputMapper still executes, so the subflow's partial result still\n    // lands in the parent scope. Consumers who need to suppress output on\n    // break check the break state inside their outputMapper and early-return.\n    // See `SubflowMountOptions.propagateBreak` JSDoc for rationale.\n    if (traverserHandle && mountOptions?.propagateBreak === true) {\n      const innerBreak = traverserHandle.getBreakState();\n      if (innerBreak.shouldBreak) {\n        breakFlag.shouldBreak = true;\n        if (innerBreak.reason !== undefined && breakFlag.reason === undefined) {\n          breakFlag.reason = innerBreak.reason;\n        }\n        // Raise a parent-level onBreak event so recorders can distinguish\n        // the inner originating break (fired inside the subflow) from this\n        // propagated one (fired at the mount level on the parent).\n        this.deps.narrativeGenerator.onBreak(subflowName, parentTraversalContext, innerBreak.reason, subflowId);\n      }\n    }\n\n    const subflowTreeContext = nestedRuntime.getSnapshot();\n\n    // ─── Output Mapping ───\n    if (!subflowError && mountOptions?.outputMapper) {\n      try {\n        let outputContext = parentContext;\n        if (parentContext.branchId && parentContext.branchId !== '' && parentContext.parent) {\n          outputContext = parentContext.parent;\n        }\n\n        const parentScope = outputContext.getScope();\n        // For TypedScope subflows, stage functions return void — fall back to a shallow clone\n        // of the subflow's shared state so outputMapper can access all scope values written\n        // during the subflow. We shallow-clone to avoid aliasing the live SharedMemory context.\n        // NOTE: the full scope is passed (not just declared outputs) — outputMapper must\n        // explicitly select what to propagate to the parent.\n        // Redaction: the subflow shares the parent's _redactedKeys Set (via the same ScopeFactory),\n        // so any key marked redacted in the subflow is already visible in the parent's scope.\n        // ScopeFacade.setValue checks _redactedKeys.has(key), so writes via outputMapper\n        // automatically inherit the subflow's dynamic redaction state.\n        const effectiveOutput = subflowOutput ?? { ...subflowTreeContext.sharedState };\n        const mappedOutput = applyOutputMapping(effectiveOutput, parentScope, outputContext, mountOptions);\n\n        outputContext.commit();\n      } catch (error: any) {\n        parentContext.addError('outputMapperError', error.toString());\n        this.deps.logger.error(`Error in outputMapper for subflow (${subflowId}):`, { error });\n      }\n    }\n\n    const subflowResult: SubflowResult = {\n      subflowId,\n      subflowName,\n      treeContext: {\n        globalContext: subflowTreeContext.sharedState,\n        stageContexts: subflowTreeContext.executionTree as unknown as Record<string, unknown>,\n        history: subflowTreeContext.commitLog,\n      },\n      parentStageId: parentContext.getStageId(),\n    };\n\n    const subflowDef = this.deps.subflows?.[subflowId];\n    if (subflowDef && (subflowDef as any).buildTimeStructure) {\n      subflowResult.pipelineStructure = (subflowDef as any).buildTimeStructure;\n    }\n\n    subflowResultsMap.set(subflowId, subflowResult);\n\n    parentContext.addFlowDebugMessage('subflow', `Exiting ${subflowName} subflow`, {\n      targetStage: subflowId,\n    });\n    this.deps.narrativeGenerator.onSubflowExit(\n      subflowName,\n      subflowId,\n      parentTraversalContext,\n      subflowResult.treeContext?.globalContext,\n    );\n\n    parentContext.commit();\n\n    if (subflowError) {\n      throw subflowError;\n    }\n\n    return subflowOutput;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SubflowExecutor.js","sourceRoot":"","sources":["../../../../../src/lib/engine/handlers/SubflowExecutor.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * SubflowExecutor — Isolation boundary for subflow execution.\n *\n * Responsibilities:\n * - Create isolated ExecutionRuntime for each subflow\n * - Apply input/output mapping via SubflowInputMapper\n * - Delegate traversal to a factory-created FlowchartTraverser\n * - Track subflow results for debugging/visualization\n *\n * Each subflow gets its own GlobalStore for isolation.\n * Traversal uses the SAME 7-phase algorithm as the top-level traverser\n * (via SubflowTraverserFactory), so deciders, selectors, loops, lazy subflows,\n * and abort signals all work inside subflows automatically.\n */\n\nimport type { StageContext } from '../../memory/StageContext.js';\nimport { isPauseSignal } from '../../pause/types.js';\nimport type { StageNode } from '../graph/StageNode.js';\nimport type { TraversalContext } from '../narrative/types.js';\nimport type {\n  HandlerDeps,\n  IExecutionRuntime,\n  SubflowResult,\n  SubflowTraverserFactory,\n  SubflowTraverserHandle,\n} from '../types.js';\nimport { applyOutputMapping, getInitialScopeValues, seedSubflowGlobalStore } from './SubflowInputMapper.js';\nimport type { BreakFlag } from './types.js';\n\nexport class SubflowExecutor<TOut = any, TScope = any> {\n  constructor(\n    private deps: HandlerDeps<TOut, TScope>,\n    private traverserFactory: SubflowTraverserFactory<TOut, TScope>,\n  ) {}\n\n  /**\n   * Execute a subflow with isolated context.\n   *\n   * 1. Creates a fresh ExecutionRuntime for the subflow\n   * 2. Applies input mapping to seed the subflow's GlobalStore\n   * 3. Delegates traversal to a factory-created FlowchartTraverser\n   * 4. Applies output mapping to write results back to parent scope\n   * 5. Stores execution data for debugging/visualization\n   */\n  async executeSubflow(\n    node: StageNode<TOut, TScope>,\n    parentContext: StageContext,\n    breakFlag: BreakFlag,\n    branchPath: string | undefined,\n    subflowResultsMap: Map<string, SubflowResult>,\n    parentTraversalContext?: TraversalContext,\n  ): Promise<any> {\n    const subflowId = node.subflowId!;\n    const subflowName = node.subflowName ?? node.name;\n\n    parentContext.addFlowDebugMessage('subflow', `Entering ${subflowName} subflow`, {\n      targetStage: subflowId,\n    });\n\n    // ─── Input Mapping ───\n    //\n    // RESUME PATH NOTE: when `deps.subflowStatesForResume` carries a\n    // capture for THIS subflow id, we SKIP the inputMapper entirely.\n    // The capture is the post-input pre-pause memory — running the\n    // mapper again would clobber post-input writes (history,\n    // pausedToolCallId, etc.) with the parent's start-of-subflow view.\n    const mountOptions = node.subflowMountOptions;\n    let mappedInput: Record<string, unknown> = {};\n    const resumeCapture = this.deps.subflowStatesForResume?.[subflowId];\n    const isResumeForThisSubflow = resumeCapture !== undefined;\n\n    if (mountOptions && !isResumeForThisSubflow) {\n      try {\n        const parentScope = parentContext.getScope();\n        mappedInput = getInitialScopeValues(parentScope, mountOptions);\n        if (Object.keys(mappedInput).length > 0) {\n          // mappedInput is captured in SubflowResult.treeContext for debugging\n        }\n      } catch (error: any) {\n        parentContext.addError('inputMapperError', error.toString());\n        this.deps.logger.error(`Error in inputMapper for subflow (${subflowId}):`, { error });\n        throw error;\n      }\n    }\n\n    // Narrative receives mapped input. inputMapper is a consumer function that may inject\n    // values not from the scope (bypassing redaction). The recorder renders per includeValues.\n    const narrativeInput = mappedInput;\n    // `FlowSubflowEvent.description` is semantically \"what this subflow does\" — sourced from\n    // the subflow's own root stage, not the parent mount point. The mount node never carries\n    // a description (builders don't copy it), so reading `node.description` here returns\n    // `undefined` and taxonomy markers set on the subflow root (e.g. agentfootprint's\n    // `'Agent: ReAct loop'` / `'LLMCall: one-shot'`) never reach downstream consumers.\n    const rootDescription = this.deps.subflows?.[subflowId]?.root?.description;\n    this.deps.narrativeGenerator.onSubflowEntry(\n      subflowName,\n      subflowId,\n      rootDescription ?? node.description,\n      parentTraversalContext,\n      narrativeInput,\n    );\n\n    // Create isolated runtime via dynamic construction (avoids circular import)\n    const ExecutionRuntimeClass = this.deps.executionRuntime.constructor as new (\n      name: string,\n      id: string,\n    ) => IExecutionRuntime;\n    const nestedRuntime = new ExecutionRuntimeClass(node.name, node.id);\n    let nestedRootContext = nestedRuntime.rootStageContext;\n\n    // Seed GlobalStore with the right shape for the path:\n    //   • Resume into THIS subflow → seed from the captured pre-pause\n    //     scope so resume handlers see history, pausedToolCallId, etc.\n    //   • Normal entry → seed from the inputMapper's mappedInput.\n    const seedValues: Record<string, unknown> = isResumeForThisSubflow ? resumeCapture! : mappedInput;\n    if (Object.keys(seedValues).length > 0) {\n      seedSubflowGlobalStore(nestedRuntime, seedValues);\n      // Refresh rootStageContext so WriteBuffer sees committed data\n      const StageContextClass = nestedRootContext.constructor as new (...args: any[]) => StageContext;\n      nestedRootContext = new StageContextClass(\n        '',\n        nestedRootContext.stageName,\n        nestedRootContext.stageId,\n        nestedRuntime.globalStore,\n        '',\n        nestedRuntime.executionHistory,\n      );\n      nestedRuntime.rootStageContext = nestedRootContext;\n    }\n\n    // Prepare subflow root node — strip isSubflowRoot to prevent re-delegation.\n    //\n    // PRESERVE `next`. Earlier revisions stripped `next` whenever the\n    // subflow root had children, on the assumption that `next` was\n    // always the OUTER mount's continuation leaking into the inner\n    // tree. That assumption was wrong: the resolved subflow root's\n    // `next` is the INNER join stage (e.g., Parallel's Merge after a\n    // fan-out, ToT's Pruner). Stripping it broke composite subflows —\n    // the join stage never ran, so the subflow returned partial state.\n    //\n    // The outer mount's post-subflow continuation is handled separately\n    // by the parent traverser via `parentContext.nextNode` and is never\n    // conflated with the inner subflow's `next` chain.\n    const subflowNode: StageNode<TOut, TScope> = {\n      ...node,\n      isSubflowRoot: false,\n    };\n\n    // ─── Execute via factory traverser ───\n    // The factory creates a full FlowchartTraverser with the same 7-phase algorithm,\n    // sharing the parent's stageMap, subflows dict, and narrative generator.\n    let subflowOutput: any;\n    let subflowError: Error | undefined;\n    let traverserHandle: SubflowTraverserHandle<TOut, TScope> | undefined;\n\n    try {\n      traverserHandle = this.traverserFactory({\n        root: subflowNode,\n        executionRuntime: nestedRuntime,\n        readOnlyContext: mappedInput,\n        subflowId,\n      });\n\n      subflowOutput = await traverserHandle.execute();\n    } catch (error: any) {\n      // PauseSignal is not an error — prepend subflow ID and re-throw\n      // immediately. No error logging, no subflowResult recording —\n      // the pause is control flow.\n      //\n      // BEFORE re-throw, snapshot the nested runtime's `sharedState`\n      // onto the signal. This is the only chance — once we re-throw,\n      // the outer traverser unwinds and the nested runtime is GC'd. On\n      // resume, we'll re-seed a fresh nested runtime from this capture\n      // so resume handlers can read the pre-pause subflow scope.\n      //\n      // Capture is keyed by the SAME path-prefixed `subflowId` used in\n      // `subflowPath`, so resume can look up \"scope for sf-foo\" by id.\n      if (isPauseSignal(error)) {\n        try {\n          const snap = nestedRuntime.getSnapshot();\n          // `sharedState` is the subflow's working memory at pause\n          // time (after every committed write up to the pause). Cast\n          // is safe — SharedMemory snapshot returns a plain object.\n          error.captureSubflowScope(subflowId, snap.sharedState as Record<string, unknown>);\n        } catch {\n          // Snapshot failure shouldn't mask the pause — let the pause\n          // bubble up; resume will fall back to checkpoint.sharedState\n          // (the parent scope) for this subflow's keys.\n        }\n        error.prependSubflow(subflowId);\n        throw error;\n      }\n      subflowError = error;\n      parentContext.addError('subflowError', error.toString());\n      this.deps.logger.error(`Error in subflow (${subflowId}):`, { error });\n    }\n\n    // Always merge nested subflow results (even on error — partial results aid debugging)\n    if (traverserHandle) {\n      for (const [key, value] of traverserHandle.getSubflowResults()) {\n        subflowResultsMap.set(key, value);\n      }\n    }\n\n    // ─── Break propagation (opt-in via SubflowMountOptions.propagateBreak) ──\n    //\n    // If the subflow's inner traversal broke (because a stage called\n    // `scope.$break(reason)`) AND the mount declared `propagateBreak: true`,\n    // forward the break state to the PARENT's breakFlag. The parent\n    // traverser will see `shouldBreak` on its next step and stop.\n    //\n    // Without this, inner breaks are locally scoped to the subflow — the\n    // parent continues as if the subflow returned normally.\n    //\n    // IMPORTANT: this runs BEFORE `outputMapping` below, intentionally. The\n    // outputMapper still executes, so the subflow's partial result still\n    // lands in the parent scope. Consumers who need to suppress output on\n    // break check the break state inside their outputMapper and early-return.\n    // See `SubflowMountOptions.propagateBreak` JSDoc for rationale.\n    if (traverserHandle && mountOptions?.propagateBreak === true) {\n      const innerBreak = traverserHandle.getBreakState();\n      if (innerBreak.shouldBreak) {\n        breakFlag.shouldBreak = true;\n        if (innerBreak.reason !== undefined && breakFlag.reason === undefined) {\n          breakFlag.reason = innerBreak.reason;\n        }\n        // Raise a parent-level onBreak event so recorders can distinguish\n        // the inner originating break (fired inside the subflow) from this\n        // propagated one (fired at the mount level on the parent).\n        this.deps.narrativeGenerator.onBreak(subflowName, parentTraversalContext, innerBreak.reason, subflowId);\n      }\n    }\n\n    const subflowTreeContext = nestedRuntime.getSnapshot();\n\n    // ─── Output Mapping ───\n    if (!subflowError && mountOptions?.outputMapper) {\n      try {\n        let outputContext = parentContext;\n        if (parentContext.branchId && parentContext.branchId !== '' && parentContext.parent) {\n          outputContext = parentContext.parent;\n        }\n\n        const parentScope = outputContext.getScope();\n        // For TypedScope subflows, stage functions return void — fall back to a shallow clone\n        // of the subflow's shared state so outputMapper can access all scope values written\n        // during the subflow. We shallow-clone to avoid aliasing the live SharedMemory context.\n        // NOTE: the full scope is passed (not just declared outputs) — outputMapper must\n        // explicitly select what to propagate to the parent.\n        // Redaction: the subflow shares the parent's _redactedKeys Set (via the same ScopeFactory),\n        // so any key marked redacted in the subflow is already visible in the parent's scope.\n        // ScopeFacade.setValue checks _redactedKeys.has(key), so writes via outputMapper\n        // automatically inherit the subflow's dynamic redaction state.\n        const effectiveOutput = subflowOutput ?? { ...subflowTreeContext.sharedState };\n        const mappedOutput = applyOutputMapping(effectiveOutput, parentScope, outputContext, mountOptions);\n\n        outputContext.commit();\n      } catch (error: any) {\n        parentContext.addError('outputMapperError', error.toString());\n        this.deps.logger.error(`Error in outputMapper for subflow (${subflowId}):`, { error });\n      }\n    }\n\n    const subflowResult: SubflowResult = {\n      subflowId,\n      subflowName,\n      treeContext: {\n        globalContext: subflowTreeContext.sharedState,\n        stageContexts: subflowTreeContext.executionTree as unknown as Record<string, unknown>,\n        history: subflowTreeContext.commitLog,\n      },\n      parentStageId: parentContext.getStageId(),\n    };\n\n    const subflowDef = this.deps.subflows?.[subflowId];\n    if (subflowDef && (subflowDef as any).buildTimeStructure) {\n      subflowResult.pipelineStructure = (subflowDef as any).buildTimeStructure;\n    }\n\n    subflowResultsMap.set(subflowId, subflowResult);\n\n    parentContext.addFlowDebugMessage('subflow', `Exiting ${subflowName} subflow`, {\n      targetStage: subflowId,\n    });\n    this.deps.narrativeGenerator.onSubflowExit(\n      subflowName,\n      subflowId,\n      parentTraversalContext,\n      subflowResult.treeContext?.globalContext,\n    );\n\n    parentContext.commit();\n\n    if (subflowError) {\n      throw subflowError;\n    }\n\n    return subflowOutput;\n  }\n}\n"]}