footprintjs 9.3.0 → 9.4.0

package/dist/index.js

@@ -122,4 +122,4 @@ Object.defineProperty(exports, "isDevMode", { enumerable: true, get: function ()
 // `defineScopeFromZod` and the other zod-based scope helpers moved to the opt-in
 // `footprintjs/zod` entry — keeping zod out of the core load path (it is an
 // optional peer). Import them from 'footprintjs/zod'.
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;;AASH,4BAA4B;AAC5B,mDAAwF;AAA/E,qGAAA,SAAS,OAAA;AAAE,4GAAA,gBAAgB,OAAA;AAAE,6GAAA,iBAAiB,OAAA;AAmBvD,4BAA4B;AAC5B,+CAA2C;AAAlC,yGAAA,SAAS,OAAA;AAmBlB,mCAAmC;AACnC,kDAAuD;AAA9C,kGAAA,MAAM,OAAA;AAAE,kGAAA,MAAM,OAAA;AAYvB,oBAAoB;AACpB,kDAA0D;AAAjD,6GAAA,iBAAiB,OAAA;AAE1B,oBAAoB;AACpB,kDAAmD;AAA1C,sGAAA,UAAU,OAAA;AAqBnB,+BAA+B;AAC/B,iDAAsD;AAA7C,0GAAA,cAAc,OAAA;AAEvB,+BAA+B;AAC/B,iDAAqD;AAA5C,yGAAA,aAAa,OAAA;AAEtB,oCAAoC;AACpC,oDAA4D;AAAnD,6GAAA,iBAAiB,OAAA;AAI1B,qEAAqE;AACrE,oDAKiC;AAJ/B,kHAAA,sBAAsB,OAAA;AACtB,kHAAA,sBAAsB,OAAA;AACtB,8GAAA,kBAAkB,OAAA;AAClB,uGAAA,WAAW,OAAA;AAiDb,+BAA+B;AAC/B,kDAA8D;AAArD,iHAAA,qBAAqB,OAAA;AAK9B,+BAA+B;AAC/B,mDAA6D;AAApD,iHAAA,oBAAoB,OAAA;AAE7B,+BAA+B;AAC/B,mDAAsE;AAA7D,0HAAA,6BAA6B,OAAA;AAEtC,+BAA+B;AAC/B,mDAAuE;AAA9D,2HAAA,8BAA8B,OAAA;AAEvC,+BAA+B;AAC/B,mDAAyE;AAAhE,6HAAA,gCAAgC,OAAA;AAEzC,+BAA+B;AAC/B,mDAAiE;AAAxD,qHAAA,wBAAwB,OAAA;AAEjC,+BAA+B;AAC/B,mDAAsE;AAA7D,0HAAA,6BAA6B,OAAA;AAEtC,+BAA+B;AAC/B,mDAAoE;AAA3D,wHAAA,2BAA2B,OAAA;AAEpC,+BAA+B;AAC/B,mDAAsE;AAA7D,0HAAA,6BAA6B,OAAA;AAyBtC,uCAAuC;AACvC,mDAA6E;AAApE,+GAAA,kBAAkB,OAAA;AAAE,6GAAA,gBAAgB,OAAA;AAE7C,+EAA+E;AAC/E,4EAA4E;AAC5E,+EAA+E;AAE/E,8BAA8B;AAC9B,qDAA4D;AAAnD,8GAAA,iBAAiB,OAAA;AAyC1B,sCAAsC;AACtC,mDAA2E;AAAlE,yGAAA,YAAY,OAAA;AAAE,0GAAA,aAAa,OAAA;AAAE,kGAAA,KAAK,OAAA;AAE3C,sCAAsC;AACtC,mDAAqG;AAA5F,iHAAA,oBAAoB,OAAA;AAAE,kHAAA,qBAAqB,OAAA;AAAE,4GAAA,eAAe,OAAA;AASrE,gCAAgC;AAChC,mDAA0E;AAAjE,6GAAA,gBAAgB,OAAA;AAAE,4GAAA,eAAe,OAAA;AAE1C,+EAA+E;AAC/E,iDAAiD;AACjD,+EAA+E;AAE/E;;;;;;;;;;;GAWG;AACH,mEAAyF;AAAhF,mHAAA,cAAc,OAAA;AAAE,kHAAA,aAAa,OAAA;AAAE,8GAAA,SAAS,OAAA;AAEjD,iFAAiF;AACjF,4EAA4E;AAC5E,sDAAsD","sourcesContent":["/**\n * FootPrint — Public API (v3)\n *\n * The flowchart pattern for backend code.\n * Build → Run → Observe.\n *\n * **Three import paths:**\n * ```ts\n * import { flowChart, decide, narrative } from 'footprintjs';           // main — start here\n * import { metrics, debug, manifest }     from 'footprintjs/recorders'; // recorder factories\n * import { SharedMemory, StageContext }   from 'footprintjs/advanced';  // internals\n * ```\n *\n * @module\n */\n\n// ============================================================================\n// Quick Start — Everything you need for 90% of use cases\n// ============================================================================\n\n/** @category Quick Start */\nexport type { FlowChart, StageFunction as StageHandler, StreamHandlers } from './lib/builder/index.js';\n\n/** @category Quick Start */\nexport { flowChart, FlowChartBuilder, flowChartSelector } from './lib/builder/index.js';\n\n/** @category Quick Start — build-time observer (twin of FlowRecorder) */\nexport type {\n  StructureDeciderCompleteEvent,\n  StructureEdgeAddedEvent,\n  StructureEdgeKind,\n  StructureLoopEdgeAddedEvent,\n  StructureRecorder,\n  StructureStageAddedEvent,\n  StructureSubflowMountedEvent,\n} from './lib/builder/index.js';\n\n/** @category Quick Start */\nexport type { TypedStageFunction } from './lib/builder/typedFlowChart.js';\n\n/** @category Quick Start */\nexport type { ScopeMethods, TypedScope } from './lib/reactive/index.js';\n\n/** @category Quick Start */\nexport { narrative } from './recorders.js';\n\n// ============================================================================\n// Decision Branching — decide() / select() with evidence capture\n// ============================================================================\n\n/** @category Decision Branching */\nexport type {\n  DecideRule,\n  DecisionEvidence,\n  DecisionResult,\n  FilterOps,\n  RuleEvidence,\n  SelectionEvidence,\n  SelectionResult,\n  WhenClause,\n  WhereFilter,\n} from './lib/decide/index.js';\n\n/** @category Decision Branching */\nexport { decide, select } from './lib/decide/index.js';\n\n// ============================================================================\n// Run — Execute charts and collect results\n// ============================================================================\n\n/** @category Run */\nexport type { RunResult } from './lib/runner/index.js';\n\n/** @category Run */\nexport type { FlowChartExecutorOptions } from './lib/runner/index.js';\n\n/** @category Run */\nexport { FlowChartExecutor } from './lib/runner/index.js';\n\n/** @category Run */\nexport { RunContext } from './lib/runner/index.js';\n\n/** @category Run */\nexport type { ChartOpenAPIOptions, MCPToolDescription, RunnableFlowChart } from './lib/runner/RunnableChart.js';\n\n// ============================================================================\n// Observe — Data (scope recorders, fire during stage execution)\n// ============================================================================\n\n/** @category Observe — Data */\nexport type {\n  CommitEvent,\n  ErrorEvent,\n  ReadEvent,\n  RedactionPolicy,\n  RedactionReport,\n  ScopeRecorder,\n  StageEvent,\n  WriteEvent,\n} from './lib/scope/index.js';\n\n/** @category Observe — Data */\nexport { MetricRecorder } from './lib/scope/index.js';\n\n/** @category Observe — Data */\nexport { DebugRecorder } from './lib/scope/index.js';\n\n/** @category Observe — Operation */\nexport { RecorderOperation } from './lib/recorder/index.js';\n\n/** @category Observe — Combined (both data-flow and control-flow) */\nexport type { CombinedRecorder } from './lib/recorder/index.js';\n/** @category Observe — Combined (both data-flow and control-flow) */\nexport {\n  hasEmitRecorderMethods,\n  hasFlowRecorderMethods,\n  hasRecorderMethods,\n  isFlowEvent,\n} from './lib/recorder/index.js';\n\n/**\n * @category Observe — Emit (user-authored structured events)\n *\n * Third observer channel (alongside `ScopeRecorder` and `FlowRecorder`). Consumer\n * code calls `scope.$emit(name, payload)` from inside a stage; every attached\n * `EmitRecorder.onEmit(event)` fires synchronously with stage-context\n * enrichment. Pass-through — no buffering, zero allocation when no recorder\n * is attached.\n */\nexport type { EmitEvent, EmitRecorder } from './lib/recorder/index.js';\n\n// ============================================================================\n// Observe — Flow (FlowRecorder, fires after stage execution)\n// ============================================================================\n\n/** @category Observe — Flow */\nexport type {\n  FlowBreakEvent,\n  FlowDecisionEvent,\n  FlowErrorEvent,\n  FlowForkEvent,\n  FlowLoopEvent,\n  FlowNextEvent,\n  FlowRecorder,\n  FlowRunEvent,\n  FlowRunFailedEvent,\n  FlowSelectedEvent,\n  FlowStageEvent,\n  FlowSubflowEvent,\n  FlowSubflowRegisteredEvent,\n  TraversalContext,\n} from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport type { CombinedNarrativeEntry } from './lib/engine/index.js';\n\n/**\n * @category Observe — Flow\n *\n * `NarrativeFormatter` — pluggable formatter that converts event context\n * objects into the text lines of the narrative. Prefer this name in new\n * code; `NarrativeRenderer` is a deprecated alias that will be removed in\n * the next major release.\n */\nexport type { NarrativeFormatter, NarrativeRenderer } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { NarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport type { ManifestEntry } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { ManifestFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { AdaptiveNarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { MilestoneNarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { ProgressiveNarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { RLENarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { SeparateNarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { SilentNarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { WindowedNarrativeFlowRecorder } from './lib/engine/index.js';\n\n// ============================================================================\n// Self-Describing — .contract(), toOpenAPI(), toMCPTool()\n// ============================================================================\n\n/** @category Self-Describing */\nexport type {\n  FlowChartContract,\n  FlowChartContractOptions,\n  JsonSchema,\n  OpenAPIOptions,\n  OpenAPISpec,\n} from './lib/contract/index.js';\n\n// ============================================================================\n// Snapshot & Composition — Subflow navigation and ComposableRunner\n// ============================================================================\n\n/** @category Snapshot & Composition */\nexport type { ComposableRunner } from './lib/runner/index.js';\n\n/** @category Snapshot & Composition */\nexport type { RecorderSnapshot, RuntimeSnapshot, SubtreeSnapshot } from './lib/runner/index.js';\n\n/** @category Snapshot & Composition */\nexport { getSubtreeSnapshot, listSubflowPaths } from './lib/runner/index.js';\n\n// ============================================================================\n// ScopeRecorder Composition — Bundle multiple recorders into domain presets\n// ============================================================================\n\n/** @category ScopeRecorder */\nexport { CompositeRecorder } from './lib/recorder/index.js';\n\n// ============================================================================\n// Pause/Resume — Serializable checkpoints for long-running or human-in-the-loop flows\n// ============================================================================\n\n/** @category Pause/Resume */\n/** @category Pause/Resume */\nexport type { FlowchartCheckpoint, PausableHandler } from './lib/pause/index.js';\n\n/** @category ScopeRecorder */\nexport type { CompositeSnapshot } from './lib/recorder/index.js';\n\n// ============================================================================\n// Configuration — Types passed to FlowChartExecutor and run()\n// ============================================================================\n\n/** @category Configuration */\nexport type { ExecutionEnv, ExecutorResult, PausedResult, RunOptions } from './lib/engine/index.js';\n\n/** @category Configuration */\nexport type { ScopeFactory } from './lib/engine/index.js';\n\n/**\n * @category Configuration\n *\n * Read-tracking policy for `StageSnapshot.stageReads` (#14):\n * `'full'` (default — per-read value clone, historical behavior) /\n * `'summary'` (cheap `ReadSummaryMarker` per read) / `'off'` (no tracking,\n * zero per-read clone). Pass as `new FlowChartExecutor(chart, { readTracking })`\n * or call `executor.setReadTracking(mode)` before `run()`.\n */\nexport type { ReadSummaryMarker, ReadTrackingMode } from './lib/memory/index.js';\n\n// ============================================================================\n// Contract & Validation\n// ============================================================================\n\n/** @category Contract & Validation */\nexport type { SchemaKind, ValidationIssue, ValidationResult } from './lib/schema/index.js';\n\n/** @category Contract & Validation */\nexport { detectSchema, isValidatable, isZod } from './lib/schema/index.js';\n\n/** @category Contract & Validation */\nexport { InputValidationError, validateAgainstSchema, validateOrThrow } from './lib/schema/index.js';\n\n// ============================================================================\n// Error Utilities\n// ============================================================================\n\n/** @category Error Utilities */\nexport type { StructuredErrorInfo } from './lib/engine/index.js';\n\n/** @category Error Utilities */\nexport { extractErrorInfo, formatErrorInfo } from './lib/engine/index.js';\n\n// ============================================================================\n// Dev Tools — Mode flags and Zod scope utilities\n// ============================================================================\n\n/**\n * @category Dev Tools\n *\n * Global dev-mode flag. Call `enableDevMode()` at application startup to\n * turn on developer-only diagnostics across the library — circular-reference\n * detection in scope writes, warnings when a recorder has no observer\n * methods, suspicious-predicate warnings in decide/select, structural\n * checks in `getSubtreeSnapshot`, and any future dev-only diagnostic.\n *\n * Production leaves it OFF by default (zero overhead). See the JSDoc on\n * `enableDevMode` for the full list and usage example.\n */\nexport { disableDevMode, enableDevMode, isDevMode } from './lib/scope/detectCircular.js';\n\n// `defineScopeFromZod` and the other zod-based scope helpers moved to the opt-in\n// `footprintjs/zod` entry — keeping zod out of the core load path (it is an\n// optional peer). Import them from 'footprintjs/zod'.\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;;AASH,4BAA4B;AAC5B,mDAAwF;AAA/E,qGAAA,SAAS,OAAA;AAAE,4GAAA,gBAAgB,OAAA;AAAE,6GAAA,iBAAiB,OAAA;AAmBvD,4BAA4B;AAC5B,+CAA2C;AAAlC,yGAAA,SAAS,OAAA;AAmBlB,mCAAmC;AACnC,kDAAuD;AAA9C,kGAAA,MAAM,OAAA;AAAE,kGAAA,MAAM,OAAA;AAYvB,oBAAoB;AACpB,kDAA0D;AAAjD,6GAAA,iBAAiB,OAAA;AAE1B,oBAAoB;AACpB,kDAAmD;AAA1C,sGAAA,UAAU,OAAA;AAqBnB,+BAA+B;AAC/B,iDAAsD;AAA7C,0GAAA,cAAc,OAAA;AAEvB,+BAA+B;AAC/B,iDAAqD;AAA5C,yGAAA,aAAa,OAAA;AAEtB,oCAAoC;AACpC,oDAA4D;AAAnD,6GAAA,iBAAiB,OAAA;AAI1B,qEAAqE;AACrE,oDAKiC;AAJ/B,kHAAA,sBAAsB,OAAA;AACtB,kHAAA,sBAAsB,OAAA;AACtB,8GAAA,kBAAkB,OAAA;AAClB,uGAAA,WAAW,OAAA;AAiDb,+BAA+B;AAC/B,kDAA8D;AAArD,iHAAA,qBAAqB,OAAA;AAK9B,+BAA+B;AAC/B,mDAA6D;AAApD,iHAAA,oBAAoB,OAAA;AAE7B,+BAA+B;AAC/B,mDAAsE;AAA7D,0HAAA,6BAA6B,OAAA;AAEtC,+BAA+B;AAC/B,mDAAuE;AAA9D,2HAAA,8BAA8B,OAAA;AAEvC,+BAA+B;AAC/B,mDAAyE;AAAhE,6HAAA,gCAAgC,OAAA;AAEzC,+BAA+B;AAC/B,mDAAiE;AAAxD,qHAAA,wBAAwB,OAAA;AAEjC,+BAA+B;AAC/B,mDAAsE;AAA7D,0HAAA,6BAA6B,OAAA;AAEtC,+BAA+B;AAC/B,mDAAoE;AAA3D,wHAAA,2BAA2B,OAAA;AAEpC,+BAA+B;AAC/B,mDAAsE;AAA7D,0HAAA,6BAA6B,OAAA;AAyBtC,uCAAuC;AACvC,mDAA6E;AAApE,+GAAA,kBAAkB,OAAA;AAAE,6GAAA,gBAAgB,OAAA;AAE7C,+EAA+E;AAC/E,4EAA4E;AAC5E,+EAA+E;AAE/E,8BAA8B;AAC9B,qDAA4D;AAAnD,8GAAA,iBAAiB,OAAA;AAuD1B,sCAAsC;AACtC,mDAA2E;AAAlE,yGAAA,YAAY,OAAA;AAAE,0GAAA,aAAa,OAAA;AAAE,kGAAA,KAAK,OAAA;AAE3C,sCAAsC;AACtC,mDAAqG;AAA5F,iHAAA,oBAAoB,OAAA;AAAE,kHAAA,qBAAqB,OAAA;AAAE,4GAAA,eAAe,OAAA;AASrE,gCAAgC;AAChC,mDAA0E;AAAjE,6GAAA,gBAAgB,OAAA;AAAE,4GAAA,eAAe,OAAA;AAE1C,+EAA+E;AAC/E,iDAAiD;AACjD,+EAA+E;AAE/E;;;;;;;;;;;GAWG;AACH,mEAAyF;AAAhF,mHAAA,cAAc,OAAA;AAAE,kHAAA,aAAa,OAAA;AAAE,8GAAA,SAAS,OAAA;AAEjD,iFAAiF;AACjF,4EAA4E;AAC5E,sDAAsD","sourcesContent":["/**\n * FootPrint — Public API (v3)\n *\n * The flowchart pattern for backend code.\n * Build → Run → Observe.\n *\n * **Three import paths:**\n * ```ts\n * import { flowChart, decide, narrative } from 'footprintjs';           // main — start here\n * import { metrics, debug, manifest }     from 'footprintjs/recorders'; // recorder factories\n * import { SharedMemory, StageContext }   from 'footprintjs/advanced';  // internals\n * ```\n *\n * @module\n */\n\n// ============================================================================\n// Quick Start — Everything you need for 90% of use cases\n// ============================================================================\n\n/** @category Quick Start */\nexport type { FlowChart, StageFunction as StageHandler, StreamHandlers } from './lib/builder/index.js';\n\n/** @category Quick Start */\nexport { flowChart, FlowChartBuilder, flowChartSelector } from './lib/builder/index.js';\n\n/** @category Quick Start — build-time observer (twin of FlowRecorder) */\nexport type {\n  StructureDeciderCompleteEvent,\n  StructureEdgeAddedEvent,\n  StructureEdgeKind,\n  StructureLoopEdgeAddedEvent,\n  StructureRecorder,\n  StructureStageAddedEvent,\n  StructureSubflowMountedEvent,\n} from './lib/builder/index.js';\n\n/** @category Quick Start */\nexport type { TypedStageFunction } from './lib/builder/typedFlowChart.js';\n\n/** @category Quick Start */\nexport type { ScopeMethods, TypedScope } from './lib/reactive/index.js';\n\n/** @category Quick Start */\nexport { narrative } from './recorders.js';\n\n// ============================================================================\n// Decision Branching — decide() / select() with evidence capture\n// ============================================================================\n\n/** @category Decision Branching */\nexport type {\n  DecideRule,\n  DecisionEvidence,\n  DecisionResult,\n  FilterOps,\n  RuleEvidence,\n  SelectionEvidence,\n  SelectionResult,\n  WhenClause,\n  WhereFilter,\n} from './lib/decide/index.js';\n\n/** @category Decision Branching */\nexport { decide, select } from './lib/decide/index.js';\n\n// ============================================================================\n// Run — Execute charts and collect results\n// ============================================================================\n\n/** @category Run */\nexport type { RunResult } from './lib/runner/index.js';\n\n/** @category Run */\nexport type { FlowChartExecutorOptions } from './lib/runner/index.js';\n\n/** @category Run */\nexport { FlowChartExecutor } from './lib/runner/index.js';\n\n/** @category Run */\nexport { RunContext } from './lib/runner/index.js';\n\n/** @category Run */\nexport type { ChartOpenAPIOptions, MCPToolDescription, RunnableFlowChart } from './lib/runner/RunnableChart.js';\n\n// ============================================================================\n// Observe — Data (scope recorders, fire during stage execution)\n// ============================================================================\n\n/** @category Observe — Data */\nexport type {\n  CommitEvent,\n  ErrorEvent,\n  ReadEvent,\n  RedactionPolicy,\n  RedactionReport,\n  ScopeRecorder,\n  StageEvent,\n  WriteEvent,\n} from './lib/scope/index.js';\n\n/** @category Observe — Data */\nexport { MetricRecorder } from './lib/scope/index.js';\n\n/** @category Observe — Data */\nexport { DebugRecorder } from './lib/scope/index.js';\n\n/** @category Observe — Operation */\nexport { RecorderOperation } from './lib/recorder/index.js';\n\n/** @category Observe — Combined (both data-flow and control-flow) */\nexport type { CombinedRecorder } from './lib/recorder/index.js';\n/** @category Observe — Combined (both data-flow and control-flow) */\nexport {\n  hasEmitRecorderMethods,\n  hasFlowRecorderMethods,\n  hasRecorderMethods,\n  isFlowEvent,\n} from './lib/recorder/index.js';\n\n/**\n * @category Observe — Emit (user-authored structured events)\n *\n * Third observer channel (alongside `ScopeRecorder` and `FlowRecorder`). Consumer\n * code calls `scope.$emit(name, payload)` from inside a stage; every attached\n * `EmitRecorder.onEmit(event)` fires synchronously with stage-context\n * enrichment. Pass-through — no buffering, zero allocation when no recorder\n * is attached.\n */\nexport type { EmitEvent, EmitRecorder } from './lib/recorder/index.js';\n\n// ============================================================================\n// Observe — Flow (FlowRecorder, fires after stage execution)\n// ============================================================================\n\n/** @category Observe — Flow */\nexport type {\n  FlowBreakEvent,\n  FlowDecisionEvent,\n  FlowErrorEvent,\n  FlowForkEvent,\n  FlowLoopEvent,\n  FlowNextEvent,\n  FlowRecorder,\n  FlowRunEvent,\n  FlowRunFailedEvent,\n  FlowSelectedEvent,\n  FlowStageEvent,\n  FlowSubflowEvent,\n  FlowSubflowRegisteredEvent,\n  TraversalContext,\n} from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport type { CombinedNarrativeEntry } from './lib/engine/index.js';\n\n/**\n * @category Observe — Flow\n *\n * `NarrativeFormatter` — pluggable formatter that converts event context\n * objects into the text lines of the narrative. Prefer this name in new\n * code; `NarrativeRenderer` is a deprecated alias that will be removed in\n * the next major release.\n */\nexport type { NarrativeFormatter, NarrativeRenderer } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { NarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport type { ManifestEntry } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { ManifestFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { AdaptiveNarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { MilestoneNarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { ProgressiveNarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { RLENarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { SeparateNarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { SilentNarrativeFlowRecorder } from './lib/engine/index.js';\n\n/** @category Observe — Flow */\nexport { WindowedNarrativeFlowRecorder } from './lib/engine/index.js';\n\n// ============================================================================\n// Self-Describing — .contract(), toOpenAPI(), toMCPTool()\n// ============================================================================\n\n/** @category Self-Describing */\nexport type {\n  FlowChartContract,\n  FlowChartContractOptions,\n  JsonSchema,\n  OpenAPIOptions,\n  OpenAPISpec,\n} from './lib/contract/index.js';\n\n// ============================================================================\n// Snapshot & Composition — Subflow navigation and ComposableRunner\n// ============================================================================\n\n/** @category Snapshot & Composition */\nexport type { ComposableRunner } from './lib/runner/index.js';\n\n/** @category Snapshot & Composition */\nexport type { RecorderSnapshot, RuntimeSnapshot, SubtreeSnapshot } from './lib/runner/index.js';\n\n/** @category Snapshot & Composition */\nexport { getSubtreeSnapshot, listSubflowPaths } from './lib/runner/index.js';\n\n// ============================================================================\n// ScopeRecorder Composition — Bundle multiple recorders into domain presets\n// ============================================================================\n\n/** @category ScopeRecorder */\nexport { CompositeRecorder } from './lib/recorder/index.js';\n\n// ============================================================================\n// Pause/Resume — Serializable checkpoints for long-running or human-in-the-loop flows\n// ============================================================================\n\n/** @category Pause/Resume */\n/** @category Pause/Resume */\nexport type { FlowchartCheckpoint, PausableHandler } from './lib/pause/index.js';\n\n/** @category ScopeRecorder */\nexport type { CompositeSnapshot } from './lib/recorder/index.js';\n\n// ============================================================================\n// Configuration — Types passed to FlowChartExecutor and run()\n// ============================================================================\n\n/** @category Configuration */\nexport type { ExecutionEnv, ExecutorResult, PausedResult, RunOptions } from './lib/engine/index.js';\n\n/** @category Configuration */\nexport type { ScopeFactory } from './lib/engine/index.js';\n\n/**\n * @category Configuration\n *\n * Read-tracking policy for `StageSnapshot.stageReads` (#14):\n * `'full'` (default — per-read value clone, historical behavior) /\n * `'summary'` (cheap `ReadSummaryMarker` per read) / `'off'` (no tracking,\n * zero per-read clone). Pass as `new FlowChartExecutor(chart, { readTracking })`\n * or call `executor.setReadTracking(mode)` before `run()`.\n */\nexport type { ReadSummaryMarker, ReadTrackingMode } from './lib/memory/index.js';\n\n/**\n * @category Configuration\n *\n * Write-tracking policy for `StageSnapshot.stageWrites` (#13c-A) — the\n * sibling of `ReadTrackingMode`; both alias the shared `RetentionPolicy`\n * family from `lib/capture`. `'full'` (default — per-write value clone,\n * historical behavior) / `'summary'` (cheap `WriteSummaryMarker` per write)\n * / `'off'` (no tracking; `stageWrites` absent and the `onCommit` mutations\n * payload is empty — writes themselves still commit, and the commit log is\n * unaffected). Pass as `new FlowChartExecutor(chart, { writeTracking })` or\n * call `executor.setWriteTracking(mode)` before `run()`.\n */\nexport type { RetentionPolicy, WriteSummaryMarker, WriteTrackingMode } from './lib/memory/index.js';\n\n// ============================================================================\n// Contract & Validation\n// ============================================================================\n\n/** @category Contract & Validation */\nexport type { SchemaKind, ValidationIssue, ValidationResult } from './lib/schema/index.js';\n\n/** @category Contract & Validation */\nexport { detectSchema, isValidatable, isZod } from './lib/schema/index.js';\n\n/** @category Contract & Validation */\nexport { InputValidationError, validateAgainstSchema, validateOrThrow } from './lib/schema/index.js';\n\n// ============================================================================\n// Error Utilities\n// ============================================================================\n\n/** @category Error Utilities */\nexport type { StructuredErrorInfo } from './lib/engine/index.js';\n\n/** @category Error Utilities */\nexport { extractErrorInfo, formatErrorInfo } from './lib/engine/index.js';\n\n// ============================================================================\n// Dev Tools — Mode flags and Zod scope utilities\n// ============================================================================\n\n/**\n * @category Dev Tools\n *\n * Global dev-mode flag. Call `enableDevMode()` at application startup to\n * turn on developer-only diagnostics across the library — circular-reference\n * detection in scope writes, warnings when a recorder has no observer\n * methods, suspicious-predicate warnings in decide/select, structural\n * checks in `getSubtreeSnapshot`, and any future dev-only diagnostic.\n *\n * Production leaves it OFF by default (zero overhead). See the JSDoc on\n * `enableDevMode` for the full list and usage example.\n */\nexport { disableDevMode, enableDevMode, isDevMode } from './lib/scope/detectCircular.js';\n\n// `defineScopeFromZod` and the other zod-based scope helpers moved to the opt-in\n// `footprintjs/zod` entry — keeping zod out of the core load path (it is an\n// optional peer). Import them from 'footprintjs/zod'.\n"]}

package/dist/lib/capture/index.js

@@ -0,0 +1,23 @@
+"use strict";
+/* istanbul ignore file */
+/**
+ * capture/ — Shared value-capture / retention primitives (zero deps, leaf
+ * module — `memory/` imports it, never the reverse).
+ *
+ * One home for "what do we keep about a tracked operation's value?":
+ *   - `RetentionPolicy` — the `'full' | 'summary' | 'off'` family behind the
+ *     #14 `readTracking` and #13c-A `writeTracking` dials.
+ *   - `summarizeReadValue` / `summarizeWriteValue` — the parameterized
+ *     summary-marker builders sharing one classification path.
+ *
+ * RFC-001 (deferred observer delivery) builds its capture tier on this
+ * module — see the mapping notes in `policies.ts`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.summarizeWriteValue = exports.summarizeReadValue = exports.SUMMARY_PREVIEW_LENGTH = exports.READ_PREVIEW_LENGTH = void 0;
+var summarize_js_1 = require("./summarize.js");
+Object.defineProperty(exports, "READ_PREVIEW_LENGTH", { enumerable: true, get: function () { return summarize_js_1.READ_PREVIEW_LENGTH; } });
+Object.defineProperty(exports, "SUMMARY_PREVIEW_LENGTH", { enumerable: true, get: function () { return summarize_js_1.SUMMARY_PREVIEW_LENGTH; } });
+Object.defineProperty(exports, "summarizeReadValue", { enumerable: true, get: function () { return summarize_js_1.summarizeReadValue; } });
+Object.defineProperty(exports, "summarizeWriteValue", { enumerable: true, get: function () { return summarize_js_1.summarizeWriteValue; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbGliL2NhcHR1cmUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLDBCQUEwQjtBQUMxQjs7Ozs7Ozs7Ozs7O0dBWUc7OztBQUlILCtDQUFzSDtBQUE3RyxtSEFBQSxtQkFBbUIsT0FBQTtBQUFFLHNIQUFBLHNCQUFzQixPQUFBO0FBQUUsa0hBQUEsa0JBQWtCLE9BQUE7QUFBRSxtSEFBQSxtQkFBbUIsT0FBQSIsInNvdXJjZXNDb250ZW50IjpbIi8qIGlzdGFuYnVsIGlnbm9yZSBmaWxlICovXG4vKipcbiAqIGNhcHR1cmUvIOKAlCBTaGFyZWQgdmFsdWUtY2FwdHVyZSAvIHJldGVudGlvbiBwcmltaXRpdmVzICh6ZXJvIGRlcHMsIGxlYWZcbiAqIG1vZHVsZSDigJQgYG1lbW9yeS9gIGltcG9ydHMgaXQsIG5ldmVyIHRoZSByZXZlcnNlKS5cbiAqXG4gKiBPbmUgaG9tZSBmb3IgXCJ3aGF0IGRvIHdlIGtlZXAgYWJvdXQgYSB0cmFja2VkIG9wZXJhdGlvbidzIHZhbHVlP1wiOlxuICogICAtIGBSZXRlbnRpb25Qb2xpY3lgIOKAlCB0aGUgYCdmdWxsJyB8ICdzdW1tYXJ5JyB8ICdvZmYnYCBmYW1pbHkgYmVoaW5kIHRoZVxuICogICAgICMxNCBgcmVhZFRyYWNraW5nYCBhbmQgIzEzYy1BIGB3cml0ZVRyYWNraW5nYCBkaWFscy5cbiAqICAgLSBgc3VtbWFyaXplUmVhZFZhbHVlYCAvIGBzdW1tYXJpemVXcml0ZVZhbHVlYCDigJQgdGhlIHBhcmFtZXRlcml6ZWRcbiAqICAgICBzdW1tYXJ5LW1hcmtlciBidWlsZGVycyBzaGFyaW5nIG9uZSBjbGFzc2lmaWNhdGlvbiBwYXRoLlxuICpcbiAqIFJGQy0wMDEgKGRlZmVycmVkIG9ic2VydmVyIGRlbGl2ZXJ5KSBidWlsZHMgaXRzIGNhcHR1cmUgdGllciBvbiB0aGlzXG4gKiBtb2R1bGUg4oCUIHNlZSB0aGUgbWFwcGluZyBub3RlcyBpbiBgcG9saWNpZXMudHNgLlxuICovXG5cbmV4cG9ydCB0eXBlIHsgUmV0ZW50aW9uUG9saWN5IH0gZnJvbSAnLi9wb2xpY2llcy5qcyc7XG5leHBvcnQgdHlwZSB7IFJlYWRTdW1tYXJ5TWFya2VyLCBTdW1tYXJ5VmFsdWVUeXBlLCBXcml0ZVN1bW1hcnlNYXJrZXIgfSBmcm9tICcuL3N1bW1hcml6ZS5qcyc7XG5leHBvcnQgeyBSRUFEX1BSRVZJRVdfTEVOR1RILCBTVU1NQVJZX1BSRVZJRVdfTEVOR1RILCBzdW1tYXJpemVSZWFkVmFsdWUsIHN1bW1hcml6ZVdyaXRlVmFsdWUgfSBmcm9tICcuL3N1bW1hcml6ZS5qcyc7XG4iXX0=

package/dist/lib/capture/policies.js

@@ -0,0 +1,30 @@
+"use strict";
+/**
+ * policies.ts — The retention policy family shared by every snapshot-tracking
+ * dial (#14 `readTracking`, #13c-A `writeTracking`).
+ *
+ * RETENTION answers "what does the engine KEEP in its own snapshot state
+ * (`StageSnapshot.stageReads` / `stageWrites`, and therefore the commit
+ * observer's mutations payload) after the moment of the operation?" It is
+ * distinct from DELIVERY — what an observer receives at event time
+ * (`ScopeRecorder.onRead`/`onWrite` always deliver the live value, in every
+ * retention mode).
+ *
+ * ── RFC-001 (deferred observer delivery) mapping ──────────────────────────
+ * RFC-001's capture tier uses the vocabulary `'clone' | 'summary' | 'ref'`.
+ * When its Block 1 lands it builds on THIS module:
+ *
+ *   - RFC capture `'clone'`   ≈ retention `'full'` (alias at the module
+ *     boundary — same semantics: structuredClone at capture time).
+ *   - RFC capture `'summary'` ≈ retention `'summary'` (same marker shapes —
+ *     see `summarize.ts`).
+ *   - RFC capture `'ref'` is DELIVERY-tier only and is NOT implemented here
+ *     — reserved. Retention must never hold live references into engine
+ *     state: retained entries outlive the stage (the execution tree keeps
+ *     them for the whole run), while a `'ref'` is only safe within the
+ *     immutability window of the captured value. Holding one in retention
+ *     would either pin state generations (the #18 leak) or expose
+ *     later-mutated values as if they were point-in-time captures.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG9saWNpZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbGliL2NhcHR1cmUvcG9saWNpZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztHQTBCRyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogcG9saWNpZXMudHMg4oCUIFRoZSByZXRlbnRpb24gcG9saWN5IGZhbWlseSBzaGFyZWQgYnkgZXZlcnkgc25hcHNob3QtdHJhY2tpbmdcbiAqIGRpYWwgKCMxNCBgcmVhZFRyYWNraW5nYCwgIzEzYy1BIGB3cml0ZVRyYWNraW5nYCkuXG4gKlxuICogUkVURU5USU9OIGFuc3dlcnMgXCJ3aGF0IGRvZXMgdGhlIGVuZ2luZSBLRUVQIGluIGl0cyBvd24gc25hcHNob3Qgc3RhdGVcbiAqIChgU3RhZ2VTbmFwc2hvdC5zdGFnZVJlYWRzYCAvIGBzdGFnZVdyaXRlc2AsIGFuZCB0aGVyZWZvcmUgdGhlIGNvbW1pdFxuICogb2JzZXJ2ZXIncyBtdXRhdGlvbnMgcGF5bG9hZCkgYWZ0ZXIgdGhlIG1vbWVudCBvZiB0aGUgb3BlcmF0aW9uP1wiIEl0IGlzXG4gKiBkaXN0aW5jdCBmcm9tIERFTElWRVJZIOKAlCB3aGF0IGFuIG9ic2VydmVyIHJlY2VpdmVzIGF0IGV2ZW50IHRpbWVcbiAqIChgU2NvcGVSZWNvcmRlci5vblJlYWRgL2BvbldyaXRlYCBhbHdheXMgZGVsaXZlciB0aGUgbGl2ZSB2YWx1ZSwgaW4gZXZlcnlcbiAqIHJldGVudGlvbiBtb2RlKS5cbiAqXG4gKiDilIDilIAgUkZDLTAwMSAoZGVmZXJyZWQgb2JzZXJ2ZXIgZGVsaXZlcnkpIG1hcHBpbmcg4pSA4pSA4pSA4pSA4pSA4pSA4pSA4pSA4pSA4pSA4pSA4pSA4pSA4pSA4pSA4pSA4pSA4pSA4pSA4pSA4pSA4pSA4pSA4pSA4pSA4pSAXG4gKiBSRkMtMDAxJ3MgY2FwdHVyZSB0aWVyIHVzZXMgdGhlIHZvY2FidWxhcnkgYCdjbG9uZScgfCAnc3VtbWFyeScgfCAncmVmJ2AuXG4gKiBXaGVuIGl0cyBCbG9jayAxIGxhbmRzIGl0IGJ1aWxkcyBvbiBUSElTIG1vZHVsZTpcbiAqXG4gKiAgIC0gUkZDIGNhcHR1cmUgYCdjbG9uZSdgICAg4omIIHJldGVudGlvbiBgJ2Z1bGwnYCAoYWxpYXMgYXQgdGhlIG1vZHVsZVxuICogICAgIGJvdW5kYXJ5IOKAlCBzYW1lIHNlbWFudGljczogc3RydWN0dXJlZENsb25lIGF0IGNhcHR1cmUgdGltZSkuXG4gKiAgIC0gUkZDIGNhcHR1cmUgYCdzdW1tYXJ5J2Ag4omIIHJldGVudGlvbiBgJ3N1bW1hcnknYCAoc2FtZSBtYXJrZXIgc2hhcGVzIOKAlFxuICogICAgIHNlZSBgc3VtbWFyaXplLnRzYCkuXG4gKiAgIC0gUkZDIGNhcHR1cmUgYCdyZWYnYCBpcyBERUxJVkVSWS10aWVyIG9ubHkgYW5kIGlzIE5PVCBpbXBsZW1lbnRlZCBoZXJlXG4gKiAgICAg4oCUIHJlc2VydmVkLiBSZXRlbnRpb24gbXVzdCBuZXZlciBob2xkIGxpdmUgcmVmZXJlbmNlcyBpbnRvIGVuZ2luZVxuICogICAgIHN0YXRlOiByZXRhaW5lZCBlbnRyaWVzIG91dGxpdmUgdGhlIHN0YWdlICh0aGUgZXhlY3V0aW9uIHRyZWUga2VlcHNcbiAqICAgICB0aGVtIGZvciB0aGUgd2hvbGUgcnVuKSwgd2hpbGUgYSBgJ3JlZidgIGlzIG9ubHkgc2FmZSB3aXRoaW4gdGhlXG4gKiAgICAgaW1tdXRhYmlsaXR5IHdpbmRvdyBvZiB0aGUgY2FwdHVyZWQgdmFsdWUuIEhvbGRpbmcgb25lIGluIHJldGVudGlvblxuICogICAgIHdvdWxkIGVpdGhlciBwaW4gc3RhdGUgZ2VuZXJhdGlvbnMgKHRoZSAjMTggbGVhaykgb3IgZXhwb3NlXG4gKiAgICAgbGF0ZXItbXV0YXRlZCB2YWx1ZXMgYXMgaWYgdGhleSB3ZXJlIHBvaW50LWluLXRpbWUgY2FwdHVyZXMuXG4gKi9cblxuLyoqXG4gKiBIb3cgYSB0cmFja2VkIG9wZXJhdGlvbidzIHZhbHVlIGlzIHJldGFpbmVkIGluIHRoZSBwZXItc3RhZ2Ugc25hcHNob3Qgdmlldy5cbiAqXG4gKiAtIGAnZnVsbCdgIOKAlCBgc3RydWN0dXJlZENsb25lYCB0aGUgdmFsdWUgYXQgdGhlIG1vbWVudCBvZiB0aGUgb3BlcmF0aW9uXG4gKiAgICh0aGUgaGlzdG9yaWNhbCBkZWZhdWx0IGZvciBib3RoIGRpYWxzOyBwb2ludC1pbi10aW1lLCBkZXRhY2hlZCBjb3B5KS5cbiAqIC0gYCdzdW1tYXJ5J2Ag4oCUIHJldGFpbiBhIGNoZWFwIG1hcmtlciAodHlwZSArIHNpemUgcHJveHkgKyBzaG9ydCBwcmV2aWV3KVxuICogICBpbnN0ZWFkIG9mIHRoZSB2YWx1ZS4gTygxKS1pc2ggcGVyIG9wZXJhdGlvbjsgbm8gdmFsdWUgY2xvbmUuXG4gKiAtIGAnb2ZmJ2Ag4oCUIHJldGFpbiBub3RoaW5nLiBUaGUgb3BlcmF0aW9uIGl0c2VsZiBpcyB1bmFmZmVjdGVkIChyZWFkc1xuICogICBzdGlsbCByZXR1cm4gdmFsdWVzLCB3cml0ZXMgc3RpbGwgY29tbWl0KTsgb25seSB0aGUgc25hcHNob3QgYm9va2tlZXBpbmdcbiAqICAgaXMgc2tpcHBlZC5cbiAqXG4gKiBgUmVhZFRyYWNraW5nTW9kZWAgKCMxNCkgYW5kIGBXcml0ZVRyYWNraW5nTW9kZWAgKCMxM2MtQSkgYXJlIHB1YmxpY1xuICogYWxpYXNlcyBvZiB0aGlzIHR5cGUg4oCUIHNlZSBgbWVtb3J5L3R5cGVzLnRzYC5cbiAqL1xuZXhwb3J0IHR5cGUgUmV0ZW50aW9uUG9saWN5ID0gJ2Z1bGwnIHwgJ3N1bW1hcnknIHwgJ29mZic7XG4iXX0=

package/dist/lib/capture/summarize.js

@@ -0,0 +1,63 @@
+"use strict";
+/**
+ * summarize.ts — Cheap value summarization for `'summary'` retention.
+ *
+ * Extracted from `StageContext` (#14's `summarizeReadValue`) into a shared,
+ * brand-parameterized helper so both snapshot-tracking dials (#14
+ * `readTracking`, #13c-A `writeTracking`) — and later RFC-001's deferred
+ * observer capture tier — produce identical summaries from ONE code path.
+ *
+ * Deliberately avoids every O(value) operation: no clone, no serialization.
+ * See {@link ReadSummaryMarker} for the honest-cost contract.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.summarizeWriteValue = exports.summarizeReadValue = exports.READ_PREVIEW_LENGTH = exports.SUMMARY_PREVIEW_LENGTH = void 0;
+/** Max characters captured in a summary marker's `preview`. */
+exports.SUMMARY_PREVIEW_LENGTH = 80;
+/**
+ * Compat alias for {@link SUMMARY_PREVIEW_LENGTH} — the name shipped with
+ * #14, kept so existing import paths (`memory/types`, the memory barrel)
+ * stay valid. Same constant; reads and writes share one preview cap.
+ */
+exports.READ_PREVIEW_LENGTH = exports.SUMMARY_PREVIEW_LENGTH;
+/**
+ * The one classification path both brands share — every per-type rule
+ * (including the Map/Set real-entry-count handling) lives here exactly once.
+ */
+function classifyValue(value) {
+    if (value === null)
+        return { type: 'null' };
+    if (typeof value === 'string') {
+        return { type: 'string', size: value.length, preview: value.slice(0, exports.SUMMARY_PREVIEW_LENGTH) };
+    }
+    if (Array.isArray(value))
+        return { type: 'array', size: value.length };
+    if (value instanceof Map || value instanceof Set) {
+        // Object.keys() on a Map/Set is always [] — report the real entry count.
+        return { type: 'object', size: value.size };
+    }
+    if (typeof value === 'object') {
+        return { type: 'object', size: Object.keys(value).length };
+    }
+    if (typeof value === 'function')
+        return { type: 'function' };
+    // number | boolean | bigint | symbol — String() is O(rendered length)
+    return { type: typeof value, preview: String(value).slice(0, exports.SUMMARY_PREVIEW_LENGTH) };
+}
+/**
+ * Summarize a tracked READ for `readTracking: 'summary'` (#14). Byte-identical
+ * output to the pre-extraction `StageContext`-local implementation.
+ */
+function summarizeReadValue(value) {
+    return { __readSummary: true, ...classifyValue(value) };
+}
+exports.summarizeReadValue = summarizeReadValue;
+/**
+ * Summarize a tracked WRITE for `writeTracking: 'summary'` (#13c-A). Sibling
+ * of {@link summarizeReadValue} — same classification, distinct brand.
+ */
+function summarizeWriteValue(value) {
+    return { __writeSummary: true, ...classifyValue(value) };
+}
+exports.summarizeWriteValue = summarizeWriteValue;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -109,6 +109,14 @@ class SubflowExecutor {
         if (parentReadTracking !== undefined && parentReadTracking !== 'full') {
             nestedRootContext.useReadTracking(parentReadTracking);
         }
+        // Write-tracking policy (#13c-A): same inheritance hop as readTracking
+        // above — subflow runtimes are isolated, so the parent-mount context's
+        // mode is pushed into the FINAL nested root with the same duck-type
+        // guard and the same skip-at-default fast path.
+        const parentWriteTracking = parentContext.getWriteTracking?.();
+        if (parentWriteTracking !== undefined && parentWriteTracking !== 'full') {
+            nestedRootContext.useWriteTracking(parentWriteTracking);
+        }
         // Prepare subflow root node — strip isSubflowRoot to prevent re-delegation.
         //
         // PRESERVE `next`. Earlier revisions stripped `next` whenever the
@@ -262,4 +270,4 @@ class SubflowExecutor {
     }
 }
 exports.SubflowExecutor = SubflowExecutor;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SubflowExecutor.js","sourceRoot":"","sources":["../../../../src/lib/engine/handlers/SubflowExecutor.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;GAaG;;;AAGH,mDAAqD;AAUrD,mEAA4G;AAG5G,MAAa,eAAe;IAEhB;IACA;IAFV,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,IAAI,CAAC,WAAW,IAAI,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,EAAE;QACF,iEAAiE;QACjE,iEAAiE;QACjE,+DAA+D;QAC/D,yDAAyD;QACzD,mEAAmE;QACnE,MAAM,YAAY,GAAG,IAAI,CAAC,mBAAmB,CAAC;QAC9C,IAAI,WAAW,GAA4B,EAAE,CAAC;QAC9C,MAAM,aAAa,GAAG,IAAI,CAAC,IAAI,CAAC,sBAAsB,EAAE,CAAC,SAAS,CAAC,CAAC;QACpE,MAAM,sBAAsB,GAAG,aAAa,KAAK,SAAS,CAAC;QAE3D,IAAI,YAAY,IAAI,CAAC,sBAAsB,EAAE,CAAC;YAC5C,IAAI,CAAC;gBACH,MAAM,WAAW,GAAG,aAAa,CAAC,QAAQ,EAAE,CAAC;gBAC7C,WAAW,GAAG,IAAA,6CAAqB,EAAC,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,yFAAyF;QACzF,yFAAyF;QACzF,qFAAqF;QACrF,kFAAkF;QAClF,mFAAmF;QACnF,MAAM,eAAe,GAAG,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,SAAS,CAAC,EAAE,IAAI,EAAE,WAAW,CAAC;QAC3E,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAAC,cAAc,CACzC,WAAW,EACX,SAAS,EACT,eAAe,IAAI,IAAI,CAAC,WAAW,EACnC,sBAAsB,EACtB,cAAc,CACf,CAAC;QACF,+DAA+D;QAC/D,iEAAiE;QACjE,uEAAuE;QACvE,4DAA4D;QAC5D,uDAAuD;QACvD,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAAC,eAAe,CAC1C,IAAI,CAAC,IAAI,EACT,eAAe,IAAI,IAAI,CAAC,WAAW,EACnC,sBAAsB,EACtB,eAAe,CAChB,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,sDAAsD;QACtD,kEAAkE;QAClE,mEAAmE;QACnE,8DAA8D;QAC9D,MAAM,UAAU,GAA4B,sBAAsB,CAAC,CAAC,CAAC,aAAc,CAAC,CAAC,CAAC,WAAW,CAAC;QAClG,IAAI,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACvC,IAAA,8CAAsB,EAAC,aAAa,EAAE,UAAU,CAAC,CAAC;YAClD,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,uEAAuE;QACvE,uEAAuE;QACvE,wEAAwE;QACxE,uEAAuE;QACvE,sEAAsE;QACtE,uEAAuE;QACvE,qEAAqE;QACrE,wEAAwE;QACxE,yEAAyE;QACzE,MAAM,kBAAkB,GAAG,aAAa,CAAC,eAAe,EAAE,EAAE,CAAC;QAC7D,IAAI,kBAAkB,KAAK,SAAS,IAAI,kBAAkB,KAAK,MAAM,EAAE,CAAC;YACtE,iBAAiB,CAAC,eAAe,CAAC,kBAAkB,CAAC,CAAC;QACxD,CAAC;QAED,4EAA4E;QAC5E,EAAE;QACF,kEAAkE;QAClE,+DAA+D;QAC/D,+DAA+D;QAC/D,+DAA+D;QAC/D,iEAAiE;QACjE,kEAAkE;QAClE,mEAAmE;QACnE,EAAE;QACF,oEAAoE;QACpE,oEAAoE;QACpE,mDAAmD;QACnD,MAAM,WAAW,GAA4B;YAC3C,GAAG,IAAI;YACP,aAAa,EAAE,KAAK;SACrB,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,gEAAgE;YAChE,8DAA8D;YAC9D,6BAA6B;YAC7B,EAAE;YACF,+DAA+D;YAC/D,+DAA+D;YAC/D,iEAAiE;YACjE,iEAAiE;YACjE,2DAA2D;YAC3D,EAAE;YACF,iEAAiE;YACjE,iEAAiE;YACjE,IAAI,IAAA,wBAAa,EAAC,KAAK,CAAC,EAAE,CAAC;gBACzB,IAAI,CAAC;oBACH,MAAM,IAAI,GAAG,aAAa,CAAC,WAAW,EAAE,CAAC;oBACzC,yDAAyD;oBACzD,2DAA2D;oBAC3D,0DAA0D;oBAC1D,KAAK,CAAC,mBAAmB,CAAC,SAAS,EAAE,IAAI,CAAC,WAAsC,CAAC,CAAC;gBACpF,CAAC;gBAAC,MAAM,CAAC;oBACP,4DAA4D;oBAC5D,6DAA6D;oBAC7D,8CAA8C;gBAChD,CAAC;gBACD,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,YAAY,EAAE,cAAc,KAAK,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,IAAI,YAAY,EAAE,YAAY,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,IAAI,EAAE,GAAG,kBAAkB,CAAC,WAAW,EAAE,CAAC;gBAC/E,MAAM,YAAY,GAAG,IAAA,0CAAkB,EAAC,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,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,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,aAAa,CAAC,WAAW,EAAE,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;AAvSD,0CAuSC","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    // Proposal #003: fire onStageExecuted for the mount node AFTER\n    // onSubflowEntry so consumers tracking \"did this stage run\" work\n    // uniformly across linear / decider / fork / selector / subflow-mount.\n    // Fires on ENTRY (not exit) — entry = \"this mount ran\"; the\n    // subflow's children execute after as separate stages.\n    this.deps.narrativeGenerator.onStageExecuted(\n      node.name,\n      rootDescription ?? node.description,\n      parentTraversalContext,\n      'subflow-mount',\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    // Read-tracking policy (#14): subflows get an ISOLATED runtime, so the\n    // executor-level policy doesn't reach them via the root context chain.\n    // Inherit it from the parent-mount context (which inherited it from ITS\n    // root via createNext/createChild) — applied to the FINAL nested root,\n    // after the seeding block above may have replaced it. Nested subflows\n    // chain the same way, one hop per mount. Optional-chained because this\n    // section is duck-typed by design (dynamic construction to avoid the\n    // circular import) — and skipped at the default 'full', where the fresh\n    // nested context is already correct, so the default path does zero work.\n    const parentReadTracking = parentContext.getReadTracking?.();\n    if (parentReadTracking !== undefined && parentReadTracking !== 'full') {\n      nestedRootContext.useReadTracking(parentReadTracking);\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"]}
+//# 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    // Proposal #003: fire onStageExecuted for the mount node AFTER\n    // onSubflowEntry so consumers tracking \"did this stage run\" work\n    // uniformly across linear / decider / fork / selector / subflow-mount.\n    // Fires on ENTRY (not exit) — entry = \"this mount ran\"; the\n    // subflow's children execute after as separate stages.\n    this.deps.narrativeGenerator.onStageExecuted(\n      node.name,\n      rootDescription ?? node.description,\n      parentTraversalContext,\n      'subflow-mount',\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    // Read-tracking policy (#14): subflows get an ISOLATED runtime, so the\n    // executor-level policy doesn't reach them via the root context chain.\n    // Inherit it from the parent-mount context (which inherited it from ITS\n    // root via createNext/createChild) — applied to the FINAL nested root,\n    // after the seeding block above may have replaced it. Nested subflows\n    // chain the same way, one hop per mount. Optional-chained because this\n    // section is duck-typed by design (dynamic construction to avoid the\n    // circular import) — and skipped at the default 'full', where the fresh\n    // nested context is already correct, so the default path does zero work.\n    const parentReadTracking = parentContext.getReadTracking?.();\n    if (parentReadTracking !== undefined && parentReadTracking !== 'full') {\n      nestedRootContext.useReadTracking(parentReadTracking);\n    }\n\n    // Write-tracking policy (#13c-A): same inheritance hop as readTracking\n    // above — subflow runtimes are isolated, so the parent-mount context's\n    // mode is pushed into the FINAL nested root with the same duck-type\n    // guard and the same skip-at-default fast path.\n    const parentWriteTracking = parentContext.getWriteTracking?.();\n    if (parentWriteTracking !== undefined && parentWriteTracking !== 'full') {\n      nestedRootContext.useWriteTracking(parentWriteTracking);\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"]}