footprintjs 10.0.1 → 10.2.0

package/dist/esm/lib/engine/narrative/recorders/index.js

@@ -7,4 +7,4 @@ export { RLENarrativeFlowRecorder } from './RLENarrativeFlowRecorder.js';
 export { SeparateNarrativeFlowRecorder } from './SeparateNarrativeFlowRecorder.js';
 export { SilentNarrativeFlowRecorder } from './SilentNarrativeFlowRecorder.js';
 export { WindowedNarrativeFlowRecorder } from './WindowedNarrativeFlowRecorder.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvbGliL2VuZ2luZS9uYXJyYXRpdmUvcmVjb3JkZXJzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLDBCQUEwQjtBQUMxQixPQUFPLEVBQUUsNkJBQTZCLEVBQUUsTUFBTSxvQ0FBb0MsQ0FBQztBQUVuRixPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUNqRSxPQUFPLEVBQUUsOEJBQThCLEVBQUUsTUFBTSxxQ0FBcUMsQ0FBQztBQUNyRixPQUFPLEVBQUUsZ0NBQWdDLEVBQUUsTUFBTSx1Q0FBdUMsQ0FBQztBQUN6RixPQUFPLEVBQUUsd0JBQXdCLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQztBQUN6RSxPQUFPLEVBQUUsNkJBQTZCLEVBQUUsTUFBTSxvQ0FBb0MsQ0FBQztBQUNuRixPQUFPLEVBQUUsMkJBQTJCLEVBQUUsTUFBTSxrQ0FBa0MsQ0FBQztBQUMvRSxPQUFPLEVBQUUsNkJBQTZCLEVBQUUsTUFBTSxvQ0FBb0MsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qIGlzdGFuYnVsIGlnbm9yZSBmaWxlICovXG5leHBvcnQgeyBBZGFwdGl2ZU5hcnJhdGl2ZUZsb3dSZWNvcmRlciB9IGZyb20gJy4vQWRhcHRpdmVOYXJyYXRpdmVGbG93UmVjb3JkZXIuanMnO1xuZXhwb3J0IHR5cGUgeyBNYW5pZmVzdEVudHJ5IH0gZnJvbSAnLi9NYW5pZmVzdEZsb3dSZWNvcmRlci5qcyc7XG5leHBvcnQgeyBNYW5pZmVzdEZsb3dSZWNvcmRlciB9IGZyb20gJy4vTWFuaWZlc3RGbG93UmVjb3JkZXIuanMnO1xuZXhwb3J0IHsgTWlsZXN0b25lTmFycmF0aXZlRmxvd1JlY29yZGVyIH0gZnJvbSAnLi9NaWxlc3RvbmVOYXJyYXRpdmVGbG93UmVjb3JkZXIuanMnO1xuZXhwb3J0IHsgUHJvZ3Jlc3NpdmVOYXJyYXRpdmVGbG93UmVjb3JkZXIgfSBmcm9tICcuL1Byb2dyZXNzaXZlTmFycmF0aXZlRmxvd1JlY29yZGVyLmpzJztcbmV4cG9ydCB7IFJMRU5hcnJhdGl2ZUZsb3dSZWNvcmRlciB9IGZyb20gJy4vUkxFTmFycmF0aXZlRmxvd1JlY29yZGVyLmpzJztcbmV4cG9ydCB7IFNlcGFyYXRlTmFycmF0aXZlRmxvd1JlY29yZGVyIH0gZnJvbSAnLi9TZXBhcmF0ZU5hcnJhdGl2ZUZsb3dSZWNvcmRlci5qcyc7XG5leHBvcnQgeyBTaWxlbnROYXJyYXRpdmVGbG93UmVjb3JkZXIgfSBmcm9tICcuL1NpbGVudE5hcnJhdGl2ZUZsb3dSZWNvcmRlci5qcyc7XG5leHBvcnQgeyBXaW5kb3dlZE5hcnJhdGl2ZUZsb3dSZWNvcmRlciB9IGZyb20gJy4vV2luZG93ZWROYXJyYXRpdmVGbG93UmVjb3JkZXIuanMnO1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvbGliL2VuZ2luZS9uYXJyYXRpdmUvcmVjb3JkZXJzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLDBCQUEwQjtBQUMxQixPQUFPLEVBQUUsNkJBQTZCLEVBQUUsTUFBTSxvQ0FBb0MsQ0FBQztBQUVuRixPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUNqRSxPQUFPLEVBQUUsOEJBQThCLEVBQUUsTUFBTSxxQ0FBcUMsQ0FBQztBQUNyRixPQUFPLEVBQUUsZ0NBQWdDLEVBQUUsTUFBTSx1Q0FBdUMsQ0FBQztBQUN6RixPQUFPLEVBQUUsd0JBQXdCLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQztBQUN6RSxPQUFPLEVBQUUsNkJBQTZCLEVBQUUsTUFBTSxvQ0FBb0MsQ0FBQztBQUNuRixPQUFPLEVBQUUsMkJBQTJCLEVBQUUsTUFBTSxrQ0FBa0MsQ0FBQztBQUMvRSxPQUFPLEVBQUUsNkJBQTZCLEVBQUUsTUFBTSxvQ0FBb0MsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qIGlzdGFuYnVsIGlnbm9yZSBmaWxlICovXG5leHBvcnQgeyBBZGFwdGl2ZU5hcnJhdGl2ZUZsb3dSZWNvcmRlciB9IGZyb20gJy4vQWRhcHRpdmVOYXJyYXRpdmVGbG93UmVjb3JkZXIuanMnO1xuZXhwb3J0IHR5cGUgeyBNYW5pZmVzdEF0dGVtcHRSb3csIE1hbmlmZXN0RW50cnkgfSBmcm9tICcuL01hbmlmZXN0Rmxvd1JlY29yZGVyLmpzJztcbmV4cG9ydCB7IE1hbmlmZXN0Rmxvd1JlY29yZGVyIH0gZnJvbSAnLi9NYW5pZmVzdEZsb3dSZWNvcmRlci5qcyc7XG5leHBvcnQgeyBNaWxlc3RvbmVOYXJyYXRpdmVGbG93UmVjb3JkZXIgfSBmcm9tICcuL01pbGVzdG9uZU5hcnJhdGl2ZUZsb3dSZWNvcmRlci5qcyc7XG5leHBvcnQgeyBQcm9ncmVzc2l2ZU5hcnJhdGl2ZUZsb3dSZWNvcmRlciB9IGZyb20gJy4vUHJvZ3Jlc3NpdmVOYXJyYXRpdmVGbG93UmVjb3JkZXIuanMnO1xuZXhwb3J0IHsgUkxFTmFycmF0aXZlRmxvd1JlY29yZGVyIH0gZnJvbSAnLi9STEVOYXJyYXRpdmVGbG93UmVjb3JkZXIuanMnO1xuZXhwb3J0IHsgU2VwYXJhdGVOYXJyYXRpdmVGbG93UmVjb3JkZXIgfSBmcm9tICcuL1NlcGFyYXRlTmFycmF0aXZlRmxvd1JlY29yZGVyLmpzJztcbmV4cG9ydCB7IFNpbGVudE5hcnJhdGl2ZUZsb3dSZWNvcmRlciB9IGZyb20gJy4vU2lsZW50TmFycmF0aXZlRmxvd1JlY29yZGVyLmpzJztcbmV4cG9ydCB7IFdpbmRvd2VkTmFycmF0aXZlRmxvd1JlY29yZGVyIH0gZnJvbSAnLi9XaW5kb3dlZE5hcnJhdGl2ZUZsb3dSZWNvcmRlci5qcyc7XG4iXX0=

package/dist/esm/lib/engine/narrative/types.d.ts

@@ -6,8 +6,10 @@
  *
  * @module
  */
+import type { AttemptRecord, RunCorrelation } from '../../attempt/types.js';
 import type { DecisionEvidence, SelectionEvidence } from '../../decide/types.js';
 import type { StructuredErrorInfo } from '../../errors/errorInfo.js';
+import type { TerminalFailureContext } from '../../errors/terminalFailure.js';
 /**
  *
  * Uses Null Object pattern: NullControlFlowNarrativeGenerator satisfies this
@@ -63,11 +65,28 @@ export interface IControlFlowNarrative {
      * `RedactionRule.retainStageError` (the diagnostic policy applied once), elsewhere `extractErrorInfo`.
      */
     onError(stageName: string, errorMessage: string, structuredError: StructuredErrorInfo, traversalContext?: TraversalContext): void;
+    /**
+     * Called at the END of every attempt (10.1) — every outcome, with the
+     * attempt's {@link AttemptRecord} (timing, outcome, category, the
+     * retry-or-stop decision): a stage's own (`record.kind === 'stage'`, under a
+     * retry policy, a `timeoutMs` or a run deadline), and the calls it makes
+     * (`'call'`, `scope.$call`) and outside attempts it reports (`'observed'`)
+     * during the stage (P2). A stage attempt fires before `onStageRetry` when it
+     * is retried, and before `onError` / `onStageExecuted` for the last.
+     * `structuredError` is the attempt's served error (`raw` included unless the
+     * policy masked it; never for an observed attempt); absent for a success or
+     * a pause.
+     *
+     * Event arithmetic: one per attempt — for a stage, the number of attempts it
+     * made plus one per call or observed attempt (filter on `record.kind`).
+     */
+    onAttempt(stageName: string, stageId: string, record: AttemptRecord, structuredError: StructuredErrorInfo | undefined, traversalContext?: TraversalContext): void;
     /**
      * Called when an attempt at a stage with a declared `retry` policy failed
-     * AND another attempt will run. Fires after the failed attempt's staged
-     * writes are discarded and BEFORE the backoff wait, so a live monitor learns
-     * "retrying in 500 ms" when the decision is made, not after the wait.
+     * AND another attempt will run. Fires after that attempt's `onAttempt`,
+     * after its staged writes are discarded and BEFORE the backoff wait, so a
+     * live monitor learns "retrying in 500 ms" when the decision is made, not
+     * after the wait.
      *
      * Event arithmetic: an exhausted policy fires `attempts - 1` of these and
      * then one `onError`; a `retryOn` that declines fires ZERO of these and one
@@ -113,7 +132,7 @@ export interface IControlFlowNarrative {
      * error, so it does not fire this. Subflow-traversers do NOT fire it;
      * their errors propagate to the parent and surface at the top level.
      */
-    onRunFailed(error: StructuredErrorInfo, traversalContext?: TraversalContext): void;
+    onRunFailed(error: StructuredErrorInfo, traversalContext?: TraversalContext, failure?: TerminalFailureContext): void;
     /** Returns accumulated narrative sentences in execution order. */
     getSentences(): string[];
 }
@@ -193,6 +212,12 @@ export interface TraversalContext {
      * checkpoint predates 9.37.0 (it did not record the paused execution).
      */
     readonly resumedFrom?: ResumeLink;
+    /**
+     * The run's correlation (10.1) — `env.traceparent`, or `env.traceId` + `env.operationId`, resolved once per
+     * leg. The SAME frozen object, by reference, on every stamp of the leg (subflows included) and on
+     * `getSnapshot().correlation`. Absent — no key — when the env gives none.
+     */
+    readonly correlation?: RunCorrelation;
 }
 /**
  * The paused execution a resume continues — `TraversalContext.resumedFrom`.
@@ -339,6 +364,39 @@ export interface FlowThrottledEvent {
     /** Explicit channel discriminant — see {@link FlowErrorEvent.channel}. */
     channel?: 'flow';
 }
+/**
+ * Event passed to FlowRecorder.onAttempt — one attempt, at its end (10.1): a
+ * stage's own under its retry policy, a `timeoutMs` or a run deadline
+ * (`record.kind === 'stage'`), or — during the stage — a call it made
+ * (`'call'`, `scope.$call`) or an outside attempt it reported (`'observed'`,
+ * P2). `stageName` / `stageId` / `traversalContext` are the stage's in every
+ * case; filter on `record.kind` to count one kind.
+ *
+ * WHY this event exists: `onStageRetry` says "attempt N failed, retrying" and
+ * nothing else — not how long a try took, not why the series stopped, and
+ * nothing at all when `retryOn` declined. Every attempt is an
+ * {@link AttemptRecord} instead, whatever its outcome, with the decision that
+ * followed it in the shape `decide()` records — the same records the stage's
+ * execution-tree node keeps (`StageSnapshot.attempts`).
+ *
+ * Fires once per attempt, before `onStageRetry` (when the attempt is retried)
+ * and before `onError` / `onStageExecuted` (for the last). The record is
+ * frozen and survives `structuredClone`; `structuredError` is the served error
+ * with `raw`, as on {@link FlowStageRetryEvent} — except for an observed
+ * attempt, whose error the library never threw (`raw` is undefined).
+ */
+export interface FlowAttemptEvent {
+    stageName: string;
+    /** Stable stage identifier from the builder (matches spec node id). */
+    stageId: string;
+    /** The attempt: timing, outcome, category, decision, and the served error without `raw`. */
+    record: AttemptRecord;
+    /** The attempt's served error with `raw` — absent for a success or a pause. */
+    structuredError?: StructuredErrorInfo;
+    traversalContext?: TraversalContext;
+    /** Explicit channel discriminant — see {@link FlowErrorEvent.channel}. */
+    channel?: 'flow';
+}
 /**
  * Event passed to FlowRecorder.onStageRetry — one failed attempt at a stage
  * that carries a declared {@link import('../types.js').RetryPolicy}, and which
@@ -352,7 +410,9 @@ export interface FlowThrottledEvent {
  * Fires only for attempts followed by another attempt. The final failure takes
  * the ordinary error path (`onError`), so the two never double-report the same
  * failure: an exhausted `attempts: 3` policy emits 2 retry events + 1 error
- * event; a `retryOn` that declines emits 0 retry events + 1 error event.
+ * event; a `retryOn` that declines emits 0 retry events + 1 error event. Each
+ * attempt — retried or not — also fires {@link FlowAttemptEvent} first (10.1),
+ * which is where a declined stop is recorded (`reason: 'declined'`).
  */
 export interface FlowStageRetryEvent {
     stageName: string;
@@ -428,6 +488,8 @@ export interface FlowRunFailedEvent {
     /** Structured details of the error that terminated the run. */
     structuredError: StructuredErrorInfo;
     traversalContext?: TraversalContext;
+    /** Native terminal ownership, independent of served error details. Absent on legacy manually emitted events. */
+    readonly failure?: TerminalFailureContext;
 }
 /**
  * FlowRecorder — Pluggable observer for control flow events.
@@ -461,6 +523,13 @@ export interface FlowRecorder {
     onLoop?(event: FlowLoopEvent): void;
     onBreak?(event: FlowBreakEvent): void;
     onError?(event: FlowErrorEvent): void;
+    /**
+     * Called at the end of EVERY attempt — a stage's own, and the calls and
+     * observed attempts it makes during the stage (filter on `record.kind`) —
+     * with its record and the decision that followed (10.1). See
+     * {@link FlowAttemptEvent}.
+     */
+    onAttempt?(event: FlowAttemptEvent): void;
     /**
      * Called once per failed attempt that WILL be retried, for stages carrying a
      * declared `retry` policy. The final failure arrives via `onError` instead,

package/dist/esm/lib/engine/narrative/types.js

@@ -7,4 +7,4 @@
  * @module
  */
 export {};
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../../src/lib/engine/narrative/types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG","sourcesContent":["/**\n * IControlFlowNarrative — Interface for control flow narrative generation.\n *\n * Captures FLOW events during traversal: decisions, forks, loops, subflows.\n * Complementary to scope/recorders/NarrativeRecorder which captures DATA events.\n *\n * @module\n */\n\nimport type { DecisionEvidence, SelectionEvidence } from '../../decide/types.js';\nimport type { StructuredErrorInfo } from '../../errors/errorInfo.js';\n\n/**\n *\n * Uses Null Object pattern: NullControlFlowNarrativeGenerator satisfies this\n * interface with empty methods for zero-cost disabled path.\n */\n\n/**\n * The kind of stage that completed. Lets consumers route uniform\n * \"did this stage execute\" handling without a side-table lookup into\n * the chart spec. Required on every `onStageExecuted` event since\n * proposal #003 unified the event to fire for ALL stage kinds.\n */\nexport type StageType = 'linear' | 'decider' | 'fork' | 'selector' | 'subflow-mount';\n\nexport interface IControlFlowNarrative {\n  /**\n   * Called when a stage completes its main work. Fires for ALL stage\n   * kinds (`'linear'`, `'decider'`, `'fork'`, `'selector'`, `'subflow-mount'`)\n   * AFTER the corresponding specialized event (`onDecision`, `onFork`,\n   * `onSelected`, `onSubflowEntry`). For linear stages, fires after\n   * the stage function returns.\n   *\n   * Consumers tracking \"did this stage run?\" use this event uniformly\n   * and switch on `stageType` for kind-specific work.\n   */\n  onStageExecuted(\n    stageName: string,\n    description: string | undefined,\n    traversalContext: TraversalContext | undefined,\n    stageType: StageType,\n  ): void;\n\n  /** Called on linear continuation from one stage to the next. */\n  onNext(fromStage: string, toStage: string, description?: string, traversalContext?: TraversalContext): void;\n\n  /** Called when a decider selects a branch. Most valuable for LLM context. */\n  onDecision(\n    deciderName: string,\n    chosenBranch: string,\n    rationale?: string,\n    deciderDescription?: string,\n    traversalContext?: TraversalContext,\n    evidence?: DecisionEvidence,\n  ): void;\n\n  /** Called when a fork executes all children in parallel. */\n  onFork(parentStage: string, childNames: string[], traversalContext?: TraversalContext): void;\n\n  /** Called when a selector picks a subset of children. */\n  onSelected(\n    parentStage: string,\n    selectedNames: string[],\n    totalCount: number,\n    traversalContext?: TraversalContext,\n    evidence?: SelectionEvidence,\n  ): void;\n\n  /** Called when entering a subflow (nested context boundary). */\n  onSubflowEntry(\n    subflowName: string,\n    subflowId?: string,\n    description?: string,\n    traversalContext?: TraversalContext,\n    mappedInput?: Record<string, unknown>,\n  ): void;\n\n  /** Called when exiting a subflow. */\n  onSubflowExit(\n    subflowName: string,\n    subflowId?: string,\n    traversalContext?: TraversalContext,\n    outputState?: Record<string, unknown>,\n  ): void;\n\n  /** Called when a dynamic subflow is registered during traversal. */\n  onSubflowRegistered(subflowId: string, name: string, description?: string, specStructure?: unknown): void;\n\n  /** Called on loop iteration (back-edge traversal). */\n  onLoop(targetStage: string, iteration: number, description?: string, traversalContext?: TraversalContext): void;\n\n  /**\n   * Called when a stage triggers break (early termination).\n   *\n   * @param reason - Optional string passed to `scope.$break(reason)`.\n   * @param propagatedFromSubflow - When set, this break was raised on the\n   *   parent because an inner subflow (this id) broke with `propagateBreak`\n   *   enabled. Used by recorders to distinguish originating vs propagated\n   *   breaks and render them accordingly.\n   */\n  onBreak(\n    stageName: string,\n    traversalContext?: TraversalContext,\n    reason?: string,\n    propagatedFromSubflow?: string,\n  ): void;\n\n  /**\n   * Called when a stage throws an error, with its SERVED form: for a stage's own failure that is\n   * `RedactionRule.retainStageError` (the diagnostic policy applied once), elsewhere `extractErrorInfo`.\n   */\n  onError(\n    stageName: string,\n    errorMessage: string,\n    structuredError: StructuredErrorInfo,\n    traversalContext?: TraversalContext,\n  ): void;\n\n  /**\n   * Called when an attempt at a stage with a declared `retry` policy failed\n   * AND another attempt will run. Fires after the failed attempt's staged\n   * writes are discarded and BEFORE the backoff wait, so a live monitor learns\n   * \"retrying in 500 ms\" when the decision is made, not after the wait.\n   *\n   * Event arithmetic: an exhausted policy fires `attempts - 1` of these and\n   * then one `onError`; a `retryOn` that declines fires ZERO of these and one\n   * `onError`. The final attempt never fires this event.\n   */\n  onStageRetry(\n    stageName: string,\n    stageId: string,\n    attempt: number,\n    maxAttempts: number,\n    delayMs: number,\n    structuredError: StructuredErrorInfo,\n    traversalContext?: TraversalContext,\n  ): void;\n\n  /**\n   * Called when a fork child failed and the run's `throttlingErrorChecker`\n   * classified its error as throttling (9.39.0). The child's failure takes\n   * its ordinary path too; this only names it as throttling.\n   */\n  onThrottled?(\n    stageName: string,\n    stageId: string,\n    structuredError: StructuredErrorInfo,\n    traversalContext?: TraversalContext,\n  ): void;\n\n  /** Called when a pausable stage pauses execution. */\n  onPause(\n    stageName: string,\n    stageId: string,\n    pauseData: unknown,\n    subflowPath: readonly string[],\n    traversalContext?: TraversalContext,\n  ): void;\n\n  /** Called when a paused stage is resumed. */\n  onResume(stageName: string, stageId: string, hasInput: boolean, traversalContext?: TraversalContext): void;\n\n  /**\n   * Called once per top-level `executor.run()`, BEFORE the first stage executes.\n   * `input` is the retained form of `run({input})` after schema validation;\n   * the run's key/path redaction applies before dispatch. See {@link FlowRunEvent}.\n   * Subflow-traversers do NOT fire this event — they fire `onSubflowEntry`.\n   */\n  onRunStart(input: unknown, traversalContext?: TraversalContext): void;\n\n  /**\n   * Called once per top-level `executor.run()`, AFTER the last stage commits.\n   * `output` is the retained form of the chart's return. NOT fired on pause (the run\n   * didn't end; it suspended) or on uncaught error. Subflow-traversers do\n   * NOT fire this event — they fire `onSubflowExit`.\n   */\n  onRunEnd(output: unknown, traversalContext?: TraversalContext): void;\n\n  /**\n   * Called once per top-level `executor.run()` when traversal throws a\n   * NON-pause error, BEFORE the exception propagates to `run()`'s caller.\n   *\n   * This is the TERMINAL counterpart to `onRunEnd` — it closes the run\n   * boundary symmetrically so every `onRunStart` is followed by exactly\n   * one of `onRunEnd` (clean) or `onRunFailed` (error). Without it, a\n   * live monitor sees `onRunStart` then silence on a failed run and can't\n   * tell \"still running\" from \"crashed.\"\n   *\n   * Errors STILL throw — this is the observable terminal signal, not a\n   * recovery mechanism (no routing, no error-subflow). Pause is NOT an\n   * error, so it does not fire this. Subflow-traversers do NOT fire it;\n   * their errors propagate to the parent and surface at the top level.\n   */\n  onRunFailed(error: StructuredErrorInfo, traversalContext?: TraversalContext): void;\n\n  /** Returns accumulated narrative sentences in execution order. */\n  getSentences(): string[];\n}\n\n// ============================================================================\n// TraversalContext — read-only execution context from the traverser.\n// ============================================================================\n\n/**\n * Traversal context attached to every FlowRecorder event.\n * Created by the traverser during DFS, passed to recorders as read-only data.\n * Enables recorders to build trees, group by subflow, and correlate events\n * without maintaining their own stacks or post-processing.\n *\n * Like OpenTelemetry's span context: stageId + parentStageId form a tree.\n */\nexport interface TraversalContext {\n  /**\n   * Per-`executor.run()` identifier. Generated once at the start of every\n   * `run()` (and again on `resume()`); shared by every event of that run;\n   * differs across consecutive runs of the same executor.\n   *\n   * Format: `${Date.now()}-${counter}` — sortable lexicographically (==\n   * chronologically for runs > 1ms apart). Process-local — for cross-\n   * process correlation use `getEnv().traceId` (consumer-supplied).\n   *\n   * Recorders that accumulate state across runs (fork bookkeeping,\n   * sibling-handoff state, etc.) detect \"new run\" via\n   * `event.traversalContext.runId !== this.lastRunId` and reset\n   * transient bookkeeping. Recorders that don't care about scoping\n   * ignore the field.\n   */\n  readonly runId: string;\n  /** Stable stage identifier from the builder (matches spec node id). */\n  readonly stageId: string;\n  /** Unique per-execution-step identifier. Format: [subflowPath/]stageId#executionIndex.\n   *  Counter resets per executor — combine with `runId` for globally unique step keys. */\n  readonly runtimeStageId: string;\n  /** Human-readable stage name. */\n  readonly stageName: string;\n  /** Parent stage ID — walk up to reconstruct the tree. Undefined at root. */\n  readonly parentStageId?: string;\n  /**\n   * The parent EXECUTION step's runtimeStageId — the runtime twin of\n   * `parentStageId` (RFC-003 D1). Walk up to reconstruct the runtime\n   * ancestor chain; loop re-entries stay unambiguous because runtime ids\n   * (`stageId#executionIndex`) differ per iteration even when stage ids\n   * repeat. Crosses subflow boundaries: the first stage inside a subflow\n   * points at the MOUNT stage's runtimeStageId in the parent traverser.\n   * Undefined only at the first stage of the top-level chart.\n   */\n  readonly parentRuntimeStageId?: string;\n  /** Subflow ID when inside a subflow. Undefined at root level. */\n  readonly subflowId?: string;\n  /** Full subflow path for nested subflows (e.g., \"sf-outer/sf-inner\"). */\n  readonly subflowPath?: string;\n  /**\n   * Subflow nesting depth of the stage's ADDRESS: how many subflow segments its\n   * `runtimeStageId` carries (0 = top level, 1 = inside a subflow or a\n   * `parallelForEach` branch, 2 = a subflow inside that, …). One meaning on\n   * every stamp — stage events, the run-boundary root (0) and `onResume`\n   * (9.37.0; until 9.36.0 stage events stamped the parent-chain length of the\n   * stage's context instead).\n   */\n  readonly depth: number;\n  /**\n   * How many times this stage has executed BEFORE in this run — the loop\n   * iteration count when a node is revisited (e.g. via `loopTo`). Absent on the\n   * first execution; `1` on the first loop-back, `2` on the next, … (i.e.\n   * `visitCount - 1`). Run-scoped (resets each `run()`/`resume()`) and monotonic\n   * across subflow re-mounts. Populated for every stage kind. Mirrors the\n   * narrative recorder's \"pass N\" count.\n   */\n  readonly loopIteration?: number;\n  /** Fork branch ID when inside a parallel or decider branch. */\n  readonly forkBranch?: string;\n  /**\n   * On the `onResume` event only (9.37.0): the PAUSED execution this resumed\n   * run continues — a link in the OpenTelemetry sense, not a parent. A resume\n   * is a new `runId`, so the paused `(runId, runtimeStageId)` cannot be a\n   * parent of anything in it; it is named here instead. Absent when the\n   * checkpoint predates 9.37.0 (it did not record the paused execution).\n   */\n  readonly resumedFrom?: ResumeLink;\n}\n\n/**\n * The paused execution a resume continues — `TraversalContext.resumedFrom`.\n * Both ids are the PAUSED run's: `runId` is that run's, `runtimeStageId` the\n * execution of the stage that paused (as its `onPause` event stamped it).\n */\nexport interface ResumeLink {\n  readonly runId: string;\n  readonly runtimeStageId: string;\n}\n\n// ============================================================================\n// FlowRecorder — Pluggable observer for control flow events.\n// ============================================================================\n\n/** Event passed to FlowRecorder.onStageExecuted. */\nexport interface FlowStageEvent {\n  stageName: string;\n  description?: string;\n  /** Traversal context from the engine — read-only, set by traverser. */\n  traversalContext?: TraversalContext;\n  /**\n   * Which kind of stage completed. The engine fires `onStageExecuted`\n   * uniformly for every stage kind (proposal #003); consumers route by\n   * `stageType` without a chart-spec lookup.\n   */\n  stageType: StageType;\n}\n\n/** Event passed to FlowRecorder.onNext. */\nexport interface FlowNextEvent {\n  from: string;\n  to: string;\n  description?: string;\n  traversalContext?: TraversalContext;\n}\n\n/** Event passed to FlowRecorder.onDecision. */\nexport interface FlowDecisionEvent {\n  decider: string;\n  chosen: string;\n  rationale?: string;\n  description?: string;\n  traversalContext?: TraversalContext;\n  /** Structured decision evidence from decide() helper. */\n  evidence?: DecisionEvidence;\n}\n\n/** Event passed to FlowRecorder.onFork. */\nexport interface FlowForkEvent {\n  parent: string;\n  children: string[];\n  traversalContext?: TraversalContext;\n}\n\n/** Event passed to FlowRecorder.onSelected. */\nexport interface FlowSelectedEvent {\n  parent: string;\n  selected: string[];\n  total: number;\n  traversalContext?: TraversalContext;\n  /** Structured selection evidence from select() helper. */\n  evidence?: SelectionEvidence;\n}\n\n/** Event passed to FlowRecorder.onSubflow. */\nexport interface FlowSubflowEvent {\n  name: string;\n  /** Subflow identifier — use this to look up the full spec via the manifest. */\n  subflowId?: string;\n  /** Build-time description of what this subflow does. */\n  description?: string;\n  traversalContext?: TraversalContext;\n  /** Mapped input values sent INTO the subflow (from inputMapper/inputKeys). Present on entry events. */\n  mappedInput?: Record<string, unknown>;\n  /** Subflow shared state at exit. Present on exit events. */\n  outputState?: Record<string, unknown>;\n}\n\n/** Event passed to FlowRecorder.onSubflowRegistered (dynamic subflow attachment). */\nexport interface FlowSubflowRegisteredEvent {\n  /** Subflow identifier. */\n  subflowId: string;\n  /** Human-readable name. */\n  name: string;\n  /** Build-time description. */\n  description?: string;\n  /** Full spec structure (when available from buildTimeStructure). */\n  specStructure?: unknown;\n  traversalContext?: TraversalContext;\n}\n\n/** Event passed to FlowRecorder.onLoop. */\nexport interface FlowLoopEvent {\n  target: string;\n  iteration: number;\n  description?: string;\n  traversalContext?: TraversalContext;\n}\n\n/** Event passed to FlowRecorder.onBreak. */\nexport interface FlowBreakEvent {\n  stageName: string;\n  traversalContext?: TraversalContext;\n  /**\n   * Optional free-form reason supplied by `scope.$break(reason)`. Absent\n   * when the stage invoked `$break()` without an argument. Propagates when\n   * a subflow is mounted with `propagateBreak: true` — the outer break\n   * event carries the inner break's reason too.\n   */\n  reason?: string;\n  /**\n   * When true, this break event was raised on the PARENT because an inner\n   * subflow's break propagated up (via `SubflowMountOptions.propagateBreak`).\n   * The originating inner break fires its own `onBreak` event separately\n   * — this flag lets recorders distinguish the two.\n   */\n  propagatedFromSubflow?: string;\n}\n\n/** Event passed to FlowRecorder.onError. */\nexport interface FlowErrorEvent {\n  stageName: string;\n  message: string;\n  /** Structured error details — preserves field-level issues, error codes, etc. */\n  structuredError: StructuredErrorInfo;\n  traversalContext?: TraversalContext;\n  /**\n   * Explicit channel discriminant — `'flow'` on every engine-dispatched\n   * event. `isFlowEvent()` checks it first (backlog B3); optional so\n   * consumer-fabricated events (tests, replays) remain type-valid and fall\n   * back to the legacy pipelineId-absence heuristic.\n   */\n  channel?: 'flow';\n}\n\n/**\n * Event passed to FlowRecorder.onThrottled — a fork child failed and the\n * executor's `throttlingErrorChecker` said its error is throttling (9.39.0).\n *\n * WHY an event: the checker used to write `monitor.isThrottled` into the\n * child's frame AFTER the child's last commit, so the flag landed nowhere —\n * not in state, not in the log. Throttling is telemetry, so it travels the\n * way telemetry does: as an event a recorder can count, alert on, or back off\n * from. The child's failure still takes its ordinary path (the fan-out\n * records it as `{ isError: true }`); this event only classifies it.\n */\nexport interface FlowThrottledEvent {\n  /** The fork child whose error was classified as throttling. */\n  stageName: string;\n  /** Stable stage identifier of that child (matches spec node id). */\n  stageId: string;\n  /** Human-readable message of the child's error. */\n  message: string;\n  /** Structured details of the child's error. */\n  structuredError: StructuredErrorInfo;\n  /** The FORK's stamp — the fan-out is where the classification is made. */\n  traversalContext?: TraversalContext;\n  /** Explicit channel discriminant — see {@link FlowErrorEvent.channel}. */\n  channel?: 'flow';\n}\n\n/**\n * Event passed to FlowRecorder.onStageRetry — one failed attempt at a stage\n * that carries a declared {@link import('../types.js').RetryPolicy}, and which\n * WILL be attempted again.\n *\n * WHY this event exists: a retry hand-rolled inside a stage function leaves no\n * mark on the trace at all. This event is what makes a declared retry part of\n * the record — which attempt failed, why, how long the engine waited, and how\n * many attempts the policy allows.\n *\n * Fires only for attempts followed by another attempt. The final failure takes\n * the ordinary error path (`onError`), so the two never double-report the same\n * failure: an exhausted `attempts: 3` policy emits 2 retry events + 1 error\n * event; a `retryOn` that declines emits 0 retry events + 1 error event.\n */\nexport interface FlowStageRetryEvent {\n  stageName: string;\n  /** Stable stage identifier from the builder (matches spec node id). */\n  stageId: string;\n  /** Which attempt just FAILED, 1-based. */\n  attempt: number;\n  /** Total attempts the policy allows, including the first. */\n  maxAttempts: number;\n  /** Milliseconds the engine will wait before the next attempt. `0` = immediate. */\n  delayMs: number;\n  /** Human-readable message — the same string `onError` would carry. */\n  message: string;\n  /** Structured details of the error that ended this attempt. */\n  structuredError: StructuredErrorInfo;\n  traversalContext?: TraversalContext;\n  /** Explicit channel discriminant — see {@link FlowErrorEvent.channel}. */\n  channel?: 'flow';\n}\n\n/** Event passed to FlowRecorder.onPause. */\nexport interface FlowPauseEvent {\n  stageName: string;\n  stageId: string;\n  /** Data from the pause signal (question, reason, metadata). */\n  pauseData?: unknown;\n  /** Path through subflows to the paused stage. Empty at root level. */\n  subflowPath: readonly string[];\n  traversalContext?: TraversalContext;\n  /** Explicit channel discriminant — see {@link FlowErrorEvent.channel}. */\n  channel?: 'flow';\n}\n\n/** Event passed to FlowRecorder.onResume. */\nexport interface FlowResumeEvent {\n  stageName: string;\n  stageId: string;\n  /** Whether resume input was provided. */\n  hasInput: boolean;\n  traversalContext?: TraversalContext;\n  /** Explicit channel discriminant — see {@link FlowErrorEvent.channel}. */\n  channel?: 'flow';\n}\n\n/**\n * Event passed to FlowRecorder.onRunStart / onRunEnd.\n *\n * Brackets the top-level `executor.run()` call. Subflows have their own\n * pair (`onSubflowEntry` / `onSubflowExit`); the run pair is the OUTERMOST\n * boundary, so consumers building \"every step has an in/out\" views can\n * close the chain at the top level.\n *\n *   - `onRunStart` payload → the input passed to `run({input})`\n *   - `onRunEnd`   payload → the chart's return value\n *\n * Both are retained at runtime before dispatch/deferred capture using the\n * run's RedactionRule (`retainBoundary`): own string keys at every depth (by\n * name or dotted path) and explicit nested fields. Scalars pass through; fork\n * child-ID envelopes need explicit paths such as fields: { childId: ['result.secret'] }.\n * Values are not scanned. Live execution inputs and return values stay unchanged.\n */\nexport interface FlowRunEvent {\n  /** Retained input after validation (`onRunStart`) or retained chart return\n   *  (`onRunEnd`), under the key/path contract above. Undefined if neither. */\n  payload?: unknown;\n  traversalContext?: TraversalContext;\n}\n\n/**\n * Event passed to FlowRecorder.onRunFailed — the TERMINAL failure boundary\n * for a top-level run. Mirror of `onRunEnd` for the error path: it fires\n * once, during traversal, when the run throws a non-pause error, before\n * the exception propagates. Carries the structured error (field-level\n * issues, codes) rather than a flattened string.\n */\nexport interface FlowRunFailedEvent {\n  /** Structured details of the error that terminated the run. */\n  structuredError: StructuredErrorInfo;\n  traversalContext?: TraversalContext;\n}\n\n/**\n * FlowRecorder — Pluggable observer for control flow events.\n *\n * Mirrors the scope-level ScopeRecorder pattern for the engine layer.\n * All methods are optional — implement only the hooks you need.\n * Recorders are invoked synchronously in attachment order.\n * If a recorder throws, the error is caught and swallowed; execution continues.\n *\n * @example\n * ```typescript\n * const metricsRecorder: FlowRecorder = {\n *   id: 'metrics',\n *   onLoop: (event) => recordMetric('loop.iteration', event.iteration),\n *   onDecision: (event) => recordMetric('decision', event.chosen),\n * };\n * executor.attachFlowRecorder(metricsRecorder);\n * ```\n */\nexport interface FlowRecorder {\n  readonly id: string;\n  onStageExecuted?(event: FlowStageEvent): void;\n  onNext?(event: FlowNextEvent): void;\n  onDecision?(event: FlowDecisionEvent): void;\n  onFork?(event: FlowForkEvent): void;\n  onSelected?(event: FlowSelectedEvent): void;\n  onSubflowEntry?(event: FlowSubflowEvent): void;\n  onSubflowExit?(event: FlowSubflowEvent): void;\n  /** Called when a dynamic subflow is registered during traversal. */\n  onSubflowRegistered?(event: FlowSubflowRegisteredEvent): void;\n  onLoop?(event: FlowLoopEvent): void;\n  onBreak?(event: FlowBreakEvent): void;\n  onError?(event: FlowErrorEvent): void;\n  /**\n   * Called once per failed attempt that WILL be retried, for stages carrying a\n   * declared `retry` policy. The final failure arrives via `onError` instead,\n   * so a stage never reports the same failure twice. See\n   * {@link FlowStageRetryEvent} for the exact event arithmetic.\n   */\n  onStageRetry?(event: FlowStageRetryEvent): void;\n  /**\n   * Called when a fork child's error is classified as throttling by the\n   * executor's `throttlingErrorChecker` — see {@link FlowThrottledEvent}.\n   */\n  onThrottled?(event: FlowThrottledEvent): void;\n  onPause?(event: FlowPauseEvent): void;\n  onResume?(event: FlowResumeEvent): void;\n  /**\n   * Called once per top-level `executor.run()` BEFORE traversal begins.\n   * Carries `event.payload = run({input})`. Subflow-traversers don't fire it.\n   */\n  onRunStart?(event: FlowRunEvent): void;\n  /**\n   * Called once per top-level `executor.run()` AFTER traversal completes\n   * cleanly. Carries `event.payload = chart's return value`. NOT fired on\n   * pause (the run didn't end) or uncaught error.\n   */\n  onRunEnd?(event: FlowRunEvent): void;\n  /**\n   * Called once per top-level `executor.run()` when the run throws a\n   * non-pause error, BEFORE the exception propagates. The TERMINAL\n   * counterpart to `onRunEnd` — lets a monitor close the run boundary on\n   * failure instead of waiting forever. NOT fired on pause.\n   */\n  onRunFailed?(event: FlowRunFailedEvent): void;\n  /** Called before each run to reset per-run state. Implement for stateful recorders. */\n  clear?(): void;\n  /** Optional: expose collected data for inclusion in snapshots. */\n  toSnapshot?(): import('../../recorder/snapshot.js').RecorderBundle;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../../src/lib/engine/narrative/types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG","sourcesContent":["/**\n * IControlFlowNarrative — Interface for control flow narrative generation.\n *\n * Captures FLOW events during traversal: decisions, forks, loops, subflows.\n * Complementary to scope/recorders/NarrativeRecorder which captures DATA events.\n *\n * @module\n */\n\nimport type { AttemptRecord, RunCorrelation } from '../../attempt/types.js';\nimport type { DecisionEvidence, SelectionEvidence } from '../../decide/types.js';\nimport type { StructuredErrorInfo } from '../../errors/errorInfo.js';\nimport type { TerminalFailureContext } from '../../errors/terminalFailure.js';\n\n/**\n *\n * Uses Null Object pattern: NullControlFlowNarrativeGenerator satisfies this\n * interface with empty methods for zero-cost disabled path.\n */\n\n/**\n * The kind of stage that completed. Lets consumers route uniform\n * \"did this stage execute\" handling without a side-table lookup into\n * the chart spec. Required on every `onStageExecuted` event since\n * proposal #003 unified the event to fire for ALL stage kinds.\n */\nexport type StageType = 'linear' | 'decider' | 'fork' | 'selector' | 'subflow-mount';\n\nexport interface IControlFlowNarrative {\n  /**\n   * Called when a stage completes its main work. Fires for ALL stage\n   * kinds (`'linear'`, `'decider'`, `'fork'`, `'selector'`, `'subflow-mount'`)\n   * AFTER the corresponding specialized event (`onDecision`, `onFork`,\n   * `onSelected`, `onSubflowEntry`). For linear stages, fires after\n   * the stage function returns.\n   *\n   * Consumers tracking \"did this stage run?\" use this event uniformly\n   * and switch on `stageType` for kind-specific work.\n   */\n  onStageExecuted(\n    stageName: string,\n    description: string | undefined,\n    traversalContext: TraversalContext | undefined,\n    stageType: StageType,\n  ): void;\n\n  /** Called on linear continuation from one stage to the next. */\n  onNext(fromStage: string, toStage: string, description?: string, traversalContext?: TraversalContext): void;\n\n  /** Called when a decider selects a branch. Most valuable for LLM context. */\n  onDecision(\n    deciderName: string,\n    chosenBranch: string,\n    rationale?: string,\n    deciderDescription?: string,\n    traversalContext?: TraversalContext,\n    evidence?: DecisionEvidence,\n  ): void;\n\n  /** Called when a fork executes all children in parallel. */\n  onFork(parentStage: string, childNames: string[], traversalContext?: TraversalContext): void;\n\n  /** Called when a selector picks a subset of children. */\n  onSelected(\n    parentStage: string,\n    selectedNames: string[],\n    totalCount: number,\n    traversalContext?: TraversalContext,\n    evidence?: SelectionEvidence,\n  ): void;\n\n  /** Called when entering a subflow (nested context boundary). */\n  onSubflowEntry(\n    subflowName: string,\n    subflowId?: string,\n    description?: string,\n    traversalContext?: TraversalContext,\n    mappedInput?: Record<string, unknown>,\n  ): void;\n\n  /** Called when exiting a subflow. */\n  onSubflowExit(\n    subflowName: string,\n    subflowId?: string,\n    traversalContext?: TraversalContext,\n    outputState?: Record<string, unknown>,\n  ): void;\n\n  /** Called when a dynamic subflow is registered during traversal. */\n  onSubflowRegistered(subflowId: string, name: string, description?: string, specStructure?: unknown): void;\n\n  /** Called on loop iteration (back-edge traversal). */\n  onLoop(targetStage: string, iteration: number, description?: string, traversalContext?: TraversalContext): void;\n\n  /**\n   * Called when a stage triggers break (early termination).\n   *\n   * @param reason - Optional string passed to `scope.$break(reason)`.\n   * @param propagatedFromSubflow - When set, this break was raised on the\n   *   parent because an inner subflow (this id) broke with `propagateBreak`\n   *   enabled. Used by recorders to distinguish originating vs propagated\n   *   breaks and render them accordingly.\n   */\n  onBreak(\n    stageName: string,\n    traversalContext?: TraversalContext,\n    reason?: string,\n    propagatedFromSubflow?: string,\n  ): void;\n\n  /**\n   * Called when a stage throws an error, with its SERVED form: for a stage's own failure that is\n   * `RedactionRule.retainStageError` (the diagnostic policy applied once), elsewhere `extractErrorInfo`.\n   */\n  onError(\n    stageName: string,\n    errorMessage: string,\n    structuredError: StructuredErrorInfo,\n    traversalContext?: TraversalContext,\n  ): void;\n\n  /**\n   * Called at the END of every attempt (10.1) — every outcome, with the\n   * attempt's {@link AttemptRecord} (timing, outcome, category, the\n   * retry-or-stop decision): a stage's own (`record.kind === 'stage'`, under a\n   * retry policy, a `timeoutMs` or a run deadline), and the calls it makes\n   * (`'call'`, `scope.$call`) and outside attempts it reports (`'observed'`)\n   * during the stage (P2). A stage attempt fires before `onStageRetry` when it\n   * is retried, and before `onError` / `onStageExecuted` for the last.\n   * `structuredError` is the attempt's served error (`raw` included unless the\n   * policy masked it; never for an observed attempt); absent for a success or\n   * a pause.\n   *\n   * Event arithmetic: one per attempt — for a stage, the number of attempts it\n   * made plus one per call or observed attempt (filter on `record.kind`).\n   */\n  onAttempt(\n    stageName: string,\n    stageId: string,\n    record: AttemptRecord,\n    structuredError: StructuredErrorInfo | undefined,\n    traversalContext?: TraversalContext,\n  ): void;\n\n  /**\n   * Called when an attempt at a stage with a declared `retry` policy failed\n   * AND another attempt will run. Fires after that attempt's `onAttempt`,\n   * after its staged writes are discarded and BEFORE the backoff wait, so a\n   * live monitor learns \"retrying in 500 ms\" when the decision is made, not\n   * after the wait.\n   *\n   * Event arithmetic: an exhausted policy fires `attempts - 1` of these and\n   * then one `onError`; a `retryOn` that declines fires ZERO of these and one\n   * `onError`. The final attempt never fires this event.\n   */\n  onStageRetry(\n    stageName: string,\n    stageId: string,\n    attempt: number,\n    maxAttempts: number,\n    delayMs: number,\n    structuredError: StructuredErrorInfo,\n    traversalContext?: TraversalContext,\n  ): void;\n\n  /**\n   * Called when a fork child failed and the run's `throttlingErrorChecker`\n   * classified its error as throttling (9.39.0). The child's failure takes\n   * its ordinary path too; this only names it as throttling.\n   */\n  onThrottled?(\n    stageName: string,\n    stageId: string,\n    structuredError: StructuredErrorInfo,\n    traversalContext?: TraversalContext,\n  ): void;\n\n  /** Called when a pausable stage pauses execution. */\n  onPause(\n    stageName: string,\n    stageId: string,\n    pauseData: unknown,\n    subflowPath: readonly string[],\n    traversalContext?: TraversalContext,\n  ): void;\n\n  /** Called when a paused stage is resumed. */\n  onResume(stageName: string, stageId: string, hasInput: boolean, traversalContext?: TraversalContext): void;\n\n  /**\n   * Called once per top-level `executor.run()`, BEFORE the first stage executes.\n   * `input` is the retained form of `run({input})` after schema validation;\n   * the run's key/path redaction applies before dispatch. See {@link FlowRunEvent}.\n   * Subflow-traversers do NOT fire this event — they fire `onSubflowEntry`.\n   */\n  onRunStart(input: unknown, traversalContext?: TraversalContext): void;\n\n  /**\n   * Called once per top-level `executor.run()`, AFTER the last stage commits.\n   * `output` is the retained form of the chart's return. NOT fired on pause (the run\n   * didn't end; it suspended) or on uncaught error. Subflow-traversers do\n   * NOT fire this event — they fire `onSubflowExit`.\n   */\n  onRunEnd(output: unknown, traversalContext?: TraversalContext): void;\n\n  /**\n   * Called once per top-level `executor.run()` when traversal throws a\n   * NON-pause error, BEFORE the exception propagates to `run()`'s caller.\n   *\n   * This is the TERMINAL counterpart to `onRunEnd` — it closes the run\n   * boundary symmetrically so every `onRunStart` is followed by exactly\n   * one of `onRunEnd` (clean) or `onRunFailed` (error). Without it, a\n   * live monitor sees `onRunStart` then silence on a failed run and can't\n   * tell \"still running\" from \"crashed.\"\n   *\n   * Errors STILL throw — this is the observable terminal signal, not a\n   * recovery mechanism (no routing, no error-subflow). Pause is NOT an\n   * error, so it does not fire this. Subflow-traversers do NOT fire it;\n   * their errors propagate to the parent and surface at the top level.\n   */\n  onRunFailed(error: StructuredErrorInfo, traversalContext?: TraversalContext, failure?: TerminalFailureContext): void;\n\n  /** Returns accumulated narrative sentences in execution order. */\n  getSentences(): string[];\n}\n\n// ============================================================================\n// TraversalContext — read-only execution context from the traverser.\n// ============================================================================\n\n/**\n * Traversal context attached to every FlowRecorder event.\n * Created by the traverser during DFS, passed to recorders as read-only data.\n * Enables recorders to build trees, group by subflow, and correlate events\n * without maintaining their own stacks or post-processing.\n *\n * Like OpenTelemetry's span context: stageId + parentStageId form a tree.\n */\nexport interface TraversalContext {\n  /**\n   * Per-`executor.run()` identifier. Generated once at the start of every\n   * `run()` (and again on `resume()`); shared by every event of that run;\n   * differs across consecutive runs of the same executor.\n   *\n   * Format: `${Date.now()}-${counter}` — sortable lexicographically (==\n   * chronologically for runs > 1ms apart). Process-local — for cross-\n   * process correlation use `getEnv().traceId` (consumer-supplied).\n   *\n   * Recorders that accumulate state across runs (fork bookkeeping,\n   * sibling-handoff state, etc.) detect \"new run\" via\n   * `event.traversalContext.runId !== this.lastRunId` and reset\n   * transient bookkeeping. Recorders that don't care about scoping\n   * ignore the field.\n   */\n  readonly runId: string;\n  /** Stable stage identifier from the builder (matches spec node id). */\n  readonly stageId: string;\n  /** Unique per-execution-step identifier. Format: [subflowPath/]stageId#executionIndex.\n   *  Counter resets per executor — combine with `runId` for globally unique step keys. */\n  readonly runtimeStageId: string;\n  /** Human-readable stage name. */\n  readonly stageName: string;\n  /** Parent stage ID — walk up to reconstruct the tree. Undefined at root. */\n  readonly parentStageId?: string;\n  /**\n   * The parent EXECUTION step's runtimeStageId — the runtime twin of\n   * `parentStageId` (RFC-003 D1). Walk up to reconstruct the runtime\n   * ancestor chain; loop re-entries stay unambiguous because runtime ids\n   * (`stageId#executionIndex`) differ per iteration even when stage ids\n   * repeat. Crosses subflow boundaries: the first stage inside a subflow\n   * points at the MOUNT stage's runtimeStageId in the parent traverser.\n   * Undefined only at the first stage of the top-level chart.\n   */\n  readonly parentRuntimeStageId?: string;\n  /** Subflow ID when inside a subflow. Undefined at root level. */\n  readonly subflowId?: string;\n  /** Full subflow path for nested subflows (e.g., \"sf-outer/sf-inner\"). */\n  readonly subflowPath?: string;\n  /**\n   * Subflow nesting depth of the stage's ADDRESS: how many subflow segments its\n   * `runtimeStageId` carries (0 = top level, 1 = inside a subflow or a\n   * `parallelForEach` branch, 2 = a subflow inside that, …). One meaning on\n   * every stamp — stage events, the run-boundary root (0) and `onResume`\n   * (9.37.0; until 9.36.0 stage events stamped the parent-chain length of the\n   * stage's context instead).\n   */\n  readonly depth: number;\n  /**\n   * How many times this stage has executed BEFORE in this run — the loop\n   * iteration count when a node is revisited (e.g. via `loopTo`). Absent on the\n   * first execution; `1` on the first loop-back, `2` on the next, … (i.e.\n   * `visitCount - 1`). Run-scoped (resets each `run()`/`resume()`) and monotonic\n   * across subflow re-mounts. Populated for every stage kind. Mirrors the\n   * narrative recorder's \"pass N\" count.\n   */\n  readonly loopIteration?: number;\n  /** Fork branch ID when inside a parallel or decider branch. */\n  readonly forkBranch?: string;\n  /**\n   * On the `onResume` event only (9.37.0): the PAUSED execution this resumed\n   * run continues — a link in the OpenTelemetry sense, not a parent. A resume\n   * is a new `runId`, so the paused `(runId, runtimeStageId)` cannot be a\n   * parent of anything in it; it is named here instead. Absent when the\n   * checkpoint predates 9.37.0 (it did not record the paused execution).\n   */\n  readonly resumedFrom?: ResumeLink;\n  /**\n   * The run's correlation (10.1) — `env.traceparent`, or `env.traceId` + `env.operationId`, resolved once per\n   * leg. The SAME frozen object, by reference, on every stamp of the leg (subflows included) and on\n   * `getSnapshot().correlation`. Absent — no key — when the env gives none.\n   */\n  readonly correlation?: RunCorrelation;\n}\n\n/**\n * The paused execution a resume continues — `TraversalContext.resumedFrom`.\n * Both ids are the PAUSED run's: `runId` is that run's, `runtimeStageId` the\n * execution of the stage that paused (as its `onPause` event stamped it).\n */\nexport interface ResumeLink {\n  readonly runId: string;\n  readonly runtimeStageId: string;\n}\n\n// ============================================================================\n// FlowRecorder — Pluggable observer for control flow events.\n// ============================================================================\n\n/** Event passed to FlowRecorder.onStageExecuted. */\nexport interface FlowStageEvent {\n  stageName: string;\n  description?: string;\n  /** Traversal context from the engine — read-only, set by traverser. */\n  traversalContext?: TraversalContext;\n  /**\n   * Which kind of stage completed. The engine fires `onStageExecuted`\n   * uniformly for every stage kind (proposal #003); consumers route by\n   * `stageType` without a chart-spec lookup.\n   */\n  stageType: StageType;\n}\n\n/** Event passed to FlowRecorder.onNext. */\nexport interface FlowNextEvent {\n  from: string;\n  to: string;\n  description?: string;\n  traversalContext?: TraversalContext;\n}\n\n/** Event passed to FlowRecorder.onDecision. */\nexport interface FlowDecisionEvent {\n  decider: string;\n  chosen: string;\n  rationale?: string;\n  description?: string;\n  traversalContext?: TraversalContext;\n  /** Structured decision evidence from decide() helper. */\n  evidence?: DecisionEvidence;\n}\n\n/** Event passed to FlowRecorder.onFork. */\nexport interface FlowForkEvent {\n  parent: string;\n  children: string[];\n  traversalContext?: TraversalContext;\n}\n\n/** Event passed to FlowRecorder.onSelected. */\nexport interface FlowSelectedEvent {\n  parent: string;\n  selected: string[];\n  total: number;\n  traversalContext?: TraversalContext;\n  /** Structured selection evidence from select() helper. */\n  evidence?: SelectionEvidence;\n}\n\n/** Event passed to FlowRecorder.onSubflow. */\nexport interface FlowSubflowEvent {\n  name: string;\n  /** Subflow identifier — use this to look up the full spec via the manifest. */\n  subflowId?: string;\n  /** Build-time description of what this subflow does. */\n  description?: string;\n  traversalContext?: TraversalContext;\n  /** Mapped input values sent INTO the subflow (from inputMapper/inputKeys). Present on entry events. */\n  mappedInput?: Record<string, unknown>;\n  /** Subflow shared state at exit. Present on exit events. */\n  outputState?: Record<string, unknown>;\n}\n\n/** Event passed to FlowRecorder.onSubflowRegistered (dynamic subflow attachment). */\nexport interface FlowSubflowRegisteredEvent {\n  /** Subflow identifier. */\n  subflowId: string;\n  /** Human-readable name. */\n  name: string;\n  /** Build-time description. */\n  description?: string;\n  /** Full spec structure (when available from buildTimeStructure). */\n  specStructure?: unknown;\n  traversalContext?: TraversalContext;\n}\n\n/** Event passed to FlowRecorder.onLoop. */\nexport interface FlowLoopEvent {\n  target: string;\n  iteration: number;\n  description?: string;\n  traversalContext?: TraversalContext;\n}\n\n/** Event passed to FlowRecorder.onBreak. */\nexport interface FlowBreakEvent {\n  stageName: string;\n  traversalContext?: TraversalContext;\n  /**\n   * Optional free-form reason supplied by `scope.$break(reason)`. Absent\n   * when the stage invoked `$break()` without an argument. Propagates when\n   * a subflow is mounted with `propagateBreak: true` — the outer break\n   * event carries the inner break's reason too.\n   */\n  reason?: string;\n  /**\n   * When true, this break event was raised on the PARENT because an inner\n   * subflow's break propagated up (via `SubflowMountOptions.propagateBreak`).\n   * The originating inner break fires its own `onBreak` event separately\n   * — this flag lets recorders distinguish the two.\n   */\n  propagatedFromSubflow?: string;\n}\n\n/** Event passed to FlowRecorder.onError. */\nexport interface FlowErrorEvent {\n  stageName: string;\n  message: string;\n  /** Structured error details — preserves field-level issues, error codes, etc. */\n  structuredError: StructuredErrorInfo;\n  traversalContext?: TraversalContext;\n  /**\n   * Explicit channel discriminant — `'flow'` on every engine-dispatched\n   * event. `isFlowEvent()` checks it first (backlog B3); optional so\n   * consumer-fabricated events (tests, replays) remain type-valid and fall\n   * back to the legacy pipelineId-absence heuristic.\n   */\n  channel?: 'flow';\n}\n\n/**\n * Event passed to FlowRecorder.onThrottled — a fork child failed and the\n * executor's `throttlingErrorChecker` said its error is throttling (9.39.0).\n *\n * WHY an event: the checker used to write `monitor.isThrottled` into the\n * child's frame AFTER the child's last commit, so the flag landed nowhere —\n * not in state, not in the log. Throttling is telemetry, so it travels the\n * way telemetry does: as an event a recorder can count, alert on, or back off\n * from. The child's failure still takes its ordinary path (the fan-out\n * records it as `{ isError: true }`); this event only classifies it.\n */\nexport interface FlowThrottledEvent {\n  /** The fork child whose error was classified as throttling. */\n  stageName: string;\n  /** Stable stage identifier of that child (matches spec node id). */\n  stageId: string;\n  /** Human-readable message of the child's error. */\n  message: string;\n  /** Structured details of the child's error. */\n  structuredError: StructuredErrorInfo;\n  /** The FORK's stamp — the fan-out is where the classification is made. */\n  traversalContext?: TraversalContext;\n  /** Explicit channel discriminant — see {@link FlowErrorEvent.channel}. */\n  channel?: 'flow';\n}\n\n/**\n * Event passed to FlowRecorder.onAttempt — one attempt, at its end (10.1): a\n * stage's own under its retry policy, a `timeoutMs` or a run deadline\n * (`record.kind === 'stage'`), or — during the stage — a call it made\n * (`'call'`, `scope.$call`) or an outside attempt it reported (`'observed'`,\n * P2). `stageName` / `stageId` / `traversalContext` are the stage's in every\n * case; filter on `record.kind` to count one kind.\n *\n * WHY this event exists: `onStageRetry` says \"attempt N failed, retrying\" and\n * nothing else — not how long a try took, not why the series stopped, and\n * nothing at all when `retryOn` declined. Every attempt is an\n * {@link AttemptRecord} instead, whatever its outcome, with the decision that\n * followed it in the shape `decide()` records — the same records the stage's\n * execution-tree node keeps (`StageSnapshot.attempts`).\n *\n * Fires once per attempt, before `onStageRetry` (when the attempt is retried)\n * and before `onError` / `onStageExecuted` (for the last). The record is\n * frozen and survives `structuredClone`; `structuredError` is the served error\n * with `raw`, as on {@link FlowStageRetryEvent} — except for an observed\n * attempt, whose error the library never threw (`raw` is undefined).\n */\nexport interface FlowAttemptEvent {\n  stageName: string;\n  /** Stable stage identifier from the builder (matches spec node id). */\n  stageId: string;\n  /** The attempt: timing, outcome, category, decision, and the served error without `raw`. */\n  record: AttemptRecord;\n  /** The attempt's served error with `raw` — absent for a success or a pause. */\n  structuredError?: StructuredErrorInfo;\n  traversalContext?: TraversalContext;\n  /** Explicit channel discriminant — see {@link FlowErrorEvent.channel}. */\n  channel?: 'flow';\n}\n\n/**\n * Event passed to FlowRecorder.onStageRetry — one failed attempt at a stage\n * that carries a declared {@link import('../types.js').RetryPolicy}, and which\n * WILL be attempted again.\n *\n * WHY this event exists: a retry hand-rolled inside a stage function leaves no\n * mark on the trace at all. This event is what makes a declared retry part of\n * the record — which attempt failed, why, how long the engine waited, and how\n * many attempts the policy allows.\n *\n * Fires only for attempts followed by another attempt. The final failure takes\n * the ordinary error path (`onError`), so the two never double-report the same\n * failure: an exhausted `attempts: 3` policy emits 2 retry events + 1 error\n * event; a `retryOn` that declines emits 0 retry events + 1 error event. Each\n * attempt — retried or not — also fires {@link FlowAttemptEvent} first (10.1),\n * which is where a declined stop is recorded (`reason: 'declined'`).\n */\nexport interface FlowStageRetryEvent {\n  stageName: string;\n  /** Stable stage identifier from the builder (matches spec node id). */\n  stageId: string;\n  /** Which attempt just FAILED, 1-based. */\n  attempt: number;\n  /** Total attempts the policy allows, including the first. */\n  maxAttempts: number;\n  /** Milliseconds the engine will wait before the next attempt. `0` = immediate. */\n  delayMs: number;\n  /** Human-readable message — the same string `onError` would carry. */\n  message: string;\n  /** Structured details of the error that ended this attempt. */\n  structuredError: StructuredErrorInfo;\n  traversalContext?: TraversalContext;\n  /** Explicit channel discriminant — see {@link FlowErrorEvent.channel}. */\n  channel?: 'flow';\n}\n\n/** Event passed to FlowRecorder.onPause. */\nexport interface FlowPauseEvent {\n  stageName: string;\n  stageId: string;\n  /** Data from the pause signal (question, reason, metadata). */\n  pauseData?: unknown;\n  /** Path through subflows to the paused stage. Empty at root level. */\n  subflowPath: readonly string[];\n  traversalContext?: TraversalContext;\n  /** Explicit channel discriminant — see {@link FlowErrorEvent.channel}. */\n  channel?: 'flow';\n}\n\n/** Event passed to FlowRecorder.onResume. */\nexport interface FlowResumeEvent {\n  stageName: string;\n  stageId: string;\n  /** Whether resume input was provided. */\n  hasInput: boolean;\n  traversalContext?: TraversalContext;\n  /** Explicit channel discriminant — see {@link FlowErrorEvent.channel}. */\n  channel?: 'flow';\n}\n\n/**\n * Event passed to FlowRecorder.onRunStart / onRunEnd.\n *\n * Brackets the top-level `executor.run()` call. Subflows have their own\n * pair (`onSubflowEntry` / `onSubflowExit`); the run pair is the OUTERMOST\n * boundary, so consumers building \"every step has an in/out\" views can\n * close the chain at the top level.\n *\n *   - `onRunStart` payload → the input passed to `run({input})`\n *   - `onRunEnd`   payload → the chart's return value\n *\n * Both are retained at runtime before dispatch/deferred capture using the\n * run's RedactionRule (`retainBoundary`): own string keys at every depth (by\n * name or dotted path) and explicit nested fields. Scalars pass through; fork\n * child-ID envelopes need explicit paths such as fields: { childId: ['result.secret'] }.\n * Values are not scanned. Live execution inputs and return values stay unchanged.\n */\nexport interface FlowRunEvent {\n  /** Retained input after validation (`onRunStart`) or retained chart return\n   *  (`onRunEnd`), under the key/path contract above. Undefined if neither. */\n  payload?: unknown;\n  traversalContext?: TraversalContext;\n}\n\n/**\n * Event passed to FlowRecorder.onRunFailed — the TERMINAL failure boundary\n * for a top-level run. Mirror of `onRunEnd` for the error path: it fires\n * once, during traversal, when the run throws a non-pause error, before\n * the exception propagates. Carries the structured error (field-level\n * issues, codes) rather than a flattened string.\n */\nexport interface FlowRunFailedEvent {\n  /** Structured details of the error that terminated the run. */\n  structuredError: StructuredErrorInfo;\n  traversalContext?: TraversalContext;\n  /** Native terminal ownership, independent of served error details. Absent on legacy manually emitted events. */\n  readonly failure?: TerminalFailureContext;\n}\n\n/**\n * FlowRecorder — Pluggable observer for control flow events.\n *\n * Mirrors the scope-level ScopeRecorder pattern for the engine layer.\n * All methods are optional — implement only the hooks you need.\n * Recorders are invoked synchronously in attachment order.\n * If a recorder throws, the error is caught and swallowed; execution continues.\n *\n * @example\n * ```typescript\n * const metricsRecorder: FlowRecorder = {\n *   id: 'metrics',\n *   onLoop: (event) => recordMetric('loop.iteration', event.iteration),\n *   onDecision: (event) => recordMetric('decision', event.chosen),\n * };\n * executor.attachFlowRecorder(metricsRecorder);\n * ```\n */\nexport interface FlowRecorder {\n  readonly id: string;\n  onStageExecuted?(event: FlowStageEvent): void;\n  onNext?(event: FlowNextEvent): void;\n  onDecision?(event: FlowDecisionEvent): void;\n  onFork?(event: FlowForkEvent): void;\n  onSelected?(event: FlowSelectedEvent): void;\n  onSubflowEntry?(event: FlowSubflowEvent): void;\n  onSubflowExit?(event: FlowSubflowEvent): void;\n  /** Called when a dynamic subflow is registered during traversal. */\n  onSubflowRegistered?(event: FlowSubflowRegisteredEvent): void;\n  onLoop?(event: FlowLoopEvent): void;\n  onBreak?(event: FlowBreakEvent): void;\n  onError?(event: FlowErrorEvent): void;\n  /**\n   * Called at the end of EVERY attempt — a stage's own, and the calls and\n   * observed attempts it makes during the stage (filter on `record.kind`) —\n   * with its record and the decision that followed (10.1). See\n   * {@link FlowAttemptEvent}.\n   */\n  onAttempt?(event: FlowAttemptEvent): void;\n  /**\n   * Called once per failed attempt that WILL be retried, for stages carrying a\n   * declared `retry` policy. The final failure arrives via `onError` instead,\n   * so a stage never reports the same failure twice. See\n   * {@link FlowStageRetryEvent} for the exact event arithmetic.\n   */\n  onStageRetry?(event: FlowStageRetryEvent): void;\n  /**\n   * Called when a fork child's error is classified as throttling by the\n   * executor's `throttlingErrorChecker` — see {@link FlowThrottledEvent}.\n   */\n  onThrottled?(event: FlowThrottledEvent): void;\n  onPause?(event: FlowPauseEvent): void;\n  onResume?(event: FlowResumeEvent): void;\n  /**\n   * Called once per top-level `executor.run()` BEFORE traversal begins.\n   * Carries `event.payload = run({input})`. Subflow-traversers don't fire it.\n   */\n  onRunStart?(event: FlowRunEvent): void;\n  /**\n   * Called once per top-level `executor.run()` AFTER traversal completes\n   * cleanly. Carries `event.payload = chart's return value`. NOT fired on\n   * pause (the run didn't end) or uncaught error.\n   */\n  onRunEnd?(event: FlowRunEvent): void;\n  /**\n   * Called once per top-level `executor.run()` when the run throws a\n   * non-pause error, BEFORE the exception propagates. The TERMINAL\n   * counterpart to `onRunEnd` — lets a monitor close the run boundary on\n   * failure instead of waiting forever. NOT fired on pause.\n   */\n  onRunFailed?(event: FlowRunFailedEvent): void;\n  /** Called before each run to reset per-run state. Implement for stateful recorders. */\n  clear?(): void;\n  /** Optional: expose collected data for inclusion in snapshots. */\n  toSnapshot?(): import('../../recorder/snapshot.js').RecorderBundle;\n}\n"]}

package/dist/esm/lib/engine/traversal/FlowchartTraverser.d.ts

@@ -22,6 +22,7 @@
  * Break semantics: If a stage calls breakFn(), commit and STOP.
  * Patch model: Stage writes into local patch; commitPatch() after return or throw.
  */
+import type { RunCorrelation } from '../../attempt/types.js';
 import type { ScopeProtectionMode } from '../../scope/protection/types.js';
 import type { QueuedPause, ResumeEntry } from '../handlers/ResumeEntry.js';
 import { FlowRecorderDispatcher } from '../narrative/FlowRecorderDispatcher.js';
@@ -128,6 +129,11 @@ export interface TraverserOptions<TOut = any, TScope = any> {
      * needs it. See `runner/runId.ts`.
      */
     runId: string;
+    /**
+     * The leg's correlation (10.1, `attempt/correlation.ts · resolveCorrelation`) — stamped onto every
+     * TraversalContext and the snapshot, inherited by subflow traversers BY REFERENCE. Absent when the env gave none.
+     */
+    correlation?: RunCorrelation;
 }
 /**
  * Traverser-local overlay entry for a node whose stage function returned a
@@ -173,6 +179,11 @@ export declare class FlowchartTraverser<TOut = any, TScope = any> {
     private subflows;
     private readonly logger;
     private readonly signal?;
+    /**
+     * The run's deadline, epoch ms (`env.deadline`, stamped by the executor's `armRun`; a subflow inherits the env).
+     * Under one, EVERY stage runs on the attempt runner, so a lone stage the deadline cuts still leaves its attempt.
+     */
+    private readonly deadline?;
     private readonly parentSubflowId?;
     /** RFC-003 D1: runtimeStageId of the subflow mount stage in the parent
      *  traverser. Fallback `parentRuntimeStageId` for stages whose context has
@@ -187,6 +198,8 @@ export declare class FlowchartTraverser<TOut = any, TScope = any> {
     /** Per-`executor.run()` identifier. Stamped onto every TraversalContext.
      *  Inherited by subflow traversers so all events of one run share one runId. */
     private readonly runId;
+    /** The leg's correlation — one frozen object, stamped on every TraversalContext; inherited by subflows. */
+    private readonly correlation?;
     private readonly nodeResolver;
     private readonly childrenExecutor;
     private readonly subflowExecutor;
@@ -327,6 +340,7 @@ export declare class FlowchartTraverser<TOut = any, TScope = any> {
     getSnapshot(options?: {
         redact?: boolean;
     }): {
+        correlation?: RunCorrelation | undefined;
         runId: string;
         sharedState: Record<string, unknown>;
         executionTree: unknown;
@@ -383,29 +397,55 @@ export declare class FlowchartTraverser<TOut = any, TScope = any> {
      * this method as `runStage`), and by extension fork children and
      * subflow-internal stages, which re-enter Phase 3 in their own traverser.
      *
-     * Which is exactly why the declarative retry loop lives HERE and nowhere
-     * else: one implementation gives `retry` to every stage kind that has a
-     * function to retry. (Putting it in `StageRunner` would have been wrong —
-     * the runner owns the scope and the interrupt boundary, but not the
-     * `StageContext` whose staged writes a failed attempt must discard.)
+     * Which is exactly why a declared `retry` policy is honoured HERE and
+     * nowhere else: one call gives `retry` to every stage kind that has a
+     * function to retry. The loop itself is the attempt runner's
+     * (`attempt/runner.ts · runAttempts`, 10.1 — one runner, one record); this
+     * method hands it the engine's half: one attempt (`StageRunner · run`, a
+     * fresh scope each time), the discard between attempts
+     * (`StageContext · discardStaged` — the runner cannot reach a frame), the
+     * served form of an attempt's error (`servedStageError`, the run's
+     * redaction rule), and where each record goes (the frame, for the
+     * execution tree; `onAttempt` and `onStageRetry`, for recorders).
      *
-     * With no `retry` policy this is a single call, byte-identical to the
-     * pre-9.15 path.
+     * NOT `async`, on purpose — the microtask shape of a stage is part of what
+     * the engine keeps byte-identical (parallel siblings settle in the order
+     * they always did):
+     *   - no policy (or `attempts: 1`, a declared-but-off policy): one call
+     *     through an async frame ({@link runStageOnce}), exactly the pre-10.1
+     *     shape — and no attempt is recorded;
+     *   - a policy: the runner's own promise, whose one await per attempt is the
+     *     same one await the 9.15 loop had.
      */
     private executeStage;
     /**
-     * R5 for ids a stage ADOPTS at run time (a returned StageNode's `next` chain,
-     * `children` and subflow ids): the same refusal the builder's doors apply —
-     * `ids/reservedIds.ts · refuseReservedId` — so "no user id carries a
-     * grammar delimiter" stays true by construction. Loop-ref stubs (they name an
-     * existing node) and the chart's own nodes (admitted at build; a prefixed id
-     * carries `/` on purpose) are not new ids and are skipped. A subflow
-     * definition's own tree is a built chart and is not walked.
-     */
-    private admitDynamicIds;
-    /** `retryOn` gate. A throwing predicate counts as "do not retry" — a broken
-     *  predicate must never turn a failing stage into an endless retry loop. */
-    private shouldRetry;
+     * A touching stage's side-effect target for THIS execution (P3, design §3.3). The law first — a chart edited
+     * after `build()` reaches the stage without the builder's refusal, so the stage asks `touchesProblem` itself (the
+     * last door). Then the key: the declared rule runs ONCE per execution, before attempt 1, handed the frozen input,
+     * the run id and this execution's id; its answer is admitted (`admitIdempotencyKey` — the format, never echoed) and
+     * served under the run's diagnostic rule as `{ idempotencyKey }` for the records. Throws on any refusal.
+     */
+    private effectTarget;
+    /** One call of a stage with no retry policy, through an async frame — the pre-10.1 microtask shape. */
+    private runStageOnce;
+    /**
+     * The run-time door for nodes a stage RETURNS (its `next` chain, `children`
+     * and subflow ids) — the builder never saw them, so this applies the
+     * builder's refusals:
+     *   - R5, ids: `ids/reservedIds.ts · refuseReservedId`, so "no user id
+     *     carries a grammar delimiter" stays true by construction. Loop-ref stubs
+     *     (they name an existing node) and the chart's own nodes (admitted at
+     *     build; a prefixed id carries `/` on purpose) are not new ids and are
+     *     skipped.
+     *   - a declared `retry`: `attempt/policy.ts · retryPolicyProblem`, the rule
+     *     `FlowChartBuilder · applyRetryPolicy` applies at build — `attempts`
+     *     must be a whole number >= 1, never `NaN`, `Infinity` or `0`.
+     *   - a declared `touches`: `attempt/effect.ts · touchesProblem`, the rule
+     *     `FlowChartBuilder · applyTouches` applies at build — a node that
+     *     touches an outside system and may retry must declare a key rule.
+     * A subflow definition's own tree is a built chart and is not walked.
+     */
+    private admitDynamicNodes;
     /**
      * Trampoline driver — pre-order DFS traversal entry point.
      *