footprintjs 10.1.0 → 10.2.0

package/dist/esm/lib/memory/attention.d.ts

@@ -0,0 +1,26 @@
+/** Engine-owned attention is collected with retained facts; snapshots only copy this bounded projection. */
+import type { Attention } from 'foottrace';
+import type { AttemptRecord, AttemptSummary } from '../attempt/types.js';
+/** One execution's ownership, pending summary, marks and omission accounting stay in this helper. */
+export declare class StageAttention {
+    private marks?;
+    private omitted;
+    private retryPossible;
+    private summary?;
+    private terminal?;
+    /** A new execution starts fresh; an attempt discard never calls this. No collection is reconstructed. */
+    begin(): void;
+    /** Called only after the frame retained this attempt. Raw error, target and decision payloads are never read. */
+    recordAttempt(record: AttemptRecord, owner: string): void;
+    recordSummary(summary: AttemptSummary): void;
+    /** A summary-only cut wait has no phantom final attempt; use its actual retained summary. */
+    private projectSummary;
+    /** Only the explicit retained stage-error path calls this; a diagnostic value never classifies itself. */
+    stageFailed(errors: unknown): void;
+    attemptDropped(): void;
+    /** Keep only bounded exact references; one slot is reserved to disclose omissions. */
+    append(attention: Attention): void;
+    missing(): void;
+    /** Copy already collected bounded marks, never an attempt array, diagnostic bag or execution tree. */
+    snapshot(): readonly Attention[];
+}

package/dist/esm/lib/memory/attention.js

@@ -0,0 +1,171 @@
+import { buildAttemptId, parseAttemptId } from 'foottrace';
+const MAX_MARKS = 32;
+const MAX_REFERENCES = 16;
+const MAX_REFERENCE_LENGTH = 512;
+const STOPPED_REASONS = new Set(['exhausted', 'declined', 'no-time-left']);
+const MISSING_ATTENTION = Object.freeze({
+    kind: 'not-collected',
+    reason: 'EVIDENCE_NOT_COLLECTED',
+    evidence: Object.freeze([]),
+});
+function validReference(reference) {
+    return (typeof reference === 'string' &&
+        reference.length > 0 &&
+        reference.length <= MAX_REFERENCE_LENGTH &&
+        // eslint-disable-next-line no-control-regex -- Match the shared Foottrace evidence-reference boundary.
+        !/[\u0000-\u001f\u007f-\u009f]/.test(reference));
+}
+/** Reuse the one attempt grammar, including nested call addresses; never shorten an unaddressable proof. */
+function attemptReference(record, owner) {
+    if (typeof record.series !== 'string' ||
+        !Number.isSafeInteger(record.attempt) ||
+        record.attempt < 1 ||
+        record.series.length + String(record.attempt).length + 1 > MAX_REFERENCE_LENGTH)
+        return undefined;
+    try {
+        const candidate = record.series + '@' + record.attempt;
+        const parts = parseAttemptId(candidate);
+        if (!parts ||
+            parts.runtimeStageId !== owner ||
+            (record.kind === 'stage' ? parts.call !== undefined : parts.call === undefined))
+            return undefined;
+        const canonical = buildAttemptId(parts.runtimeStageId, parts.attempt, parts.call);
+        return canonical === candidate && validReference(canonical) ? canonical : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** One execution's ownership, pending summary, marks and omission accounting stay in this helper. */
+export class StageAttention {
+    marks;
+    omitted = false;
+    retryPossible = false;
+    summary;
+    terminal;
+    /** A new execution starts fresh; an attempt discard never calls this. No collection is reconstructed. */
+    begin() {
+        this.marks = undefined;
+        this.omitted = false;
+        this.retryPossible = false;
+        this.summary = undefined;
+        this.terminal = undefined;
+    }
+    /** Called only after the frame retained this attempt. Raw error, target and decision payloads are never read. */
+    recordAttempt(record, owner) {
+        const reference = attemptReference(record, owner);
+        if (record.kind === 'stage' && record.series === owner) {
+            if (record.retryLoop === undefined && (record.of ?? 1) > 1)
+                this.retryPossible = true;
+            if (reference && record.next !== 'retry') {
+                this.terminal = { next: record.next, reason: record.reason, effect: record.effect, evidence: reference };
+            }
+        }
+        // The runner calls recordSummary before its final attempt. Finish that pending projection now too.
+        this.projectSummary();
+        const add = (kind, reason) => {
+            if (reference)
+                this.append({ kind, reason, evidence: [reference] });
+            else
+                this.missing();
+        };
+        if (record.effect === 'unknown')
+            add('unknown-effect', 'UNKNOWN_EFFECT_RECORDED');
+        if (record.outcome === 'timeout')
+            add('timeout', 'TIMEOUT_RECORDED');
+        // An SDK's suggested next/reason is not its actual policy; only a later ordinal proves its retry.
+        const observed = record.kind === 'observed';
+        if ((!observed && record.next === 'retry') || record.attempt > 1)
+            add('retried', 'RETRY_RECORDED');
+        if (!observed &&
+            record.next === 'stop' &&
+            STOPPED_REASONS.has(record.reason) &&
+            (record.of ?? 1) > 1 &&
+            record.retryLoop === undefined)
+            add('gave-up', 'RETRY_STOP_RECORDED');
+    }
+    recordSummary(summary) {
+        this.summary = summary;
+        this.projectSummary();
+    }
+    /** A summary-only cut wait has no phantom final attempt; use its actual retained summary. */
+    projectSummary() {
+        const last = this.summary?.last;
+        if (!last)
+            return;
+        const terminal = this.terminal;
+        const matching = terminal?.next === last.next && terminal.reason === last.reason;
+        const add = (kind, reason, proof) => {
+            const reference = proof ?? 'attemptSummary';
+            const key = kind + ':' + reason;
+            const marks = this.marks;
+            const previous = marks?.get(key);
+            if (proof && marks && previous?.evidence.includes('attemptSummary')) {
+                marks.set(key, { ...previous, evidence: previous.evidence.filter((item) => item !== 'attemptSummary') });
+            }
+            this.append({ kind, reason, evidence: [reference] });
+        };
+        if (last.effect === 'unknown')
+            add('unknown-effect', 'UNKNOWN_EFFECT_RECORDED', matching && terminal.effect === 'unknown' ? terminal.evidence : undefined);
+        if (this.retryPossible && last.next === 'stop' && STOPPED_REASONS.has(last.reason))
+            add('gave-up', 'RETRY_STOP_RECORDED', matching ? terminal.evidence : undefined);
+    }
+    /** Only the explicit retained stage-error path calls this; a diagnostic value never classifies itself. */
+    stageFailed(errors) {
+        try {
+            const descriptor = errors && typeof errors === 'object'
+                ? Object.getOwnPropertyDescriptor(errors, 'stageExecutionError')
+                : undefined;
+            if (descriptor && Object.hasOwn(descriptor, 'value')) {
+                this.append({ kind: 'error', reason: 'ERROR_RECORDED', evidence: ['errors:stageExecutionError'] });
+                return;
+            }
+        }
+        catch {
+            /* A malformed evidence bag is unavailable, never another stage failure. */
+        }
+        this.missing();
+    }
+    attemptDropped() {
+        this.append({ kind: 'not-collected', reason: 'EVIDENCE_NOT_COLLECTED', evidence: ['attemptsDropped'] });
+    }
+    /** Keep only bounded exact references; one slot is reserved to disclose omissions. */
+    append(attention) {
+        const key = attention.kind + ':' + attention.reason;
+        const previous = this.marks?.get(key);
+        const references = [...(previous?.evidence ?? [])];
+        for (const reference of attention.evidence) {
+            if (!validReference(reference)) {
+                this.omitted = true;
+                continue;
+            }
+            if (references.includes(reference))
+                continue;
+            if (references.length >= MAX_REFERENCES) {
+                this.omitted = true;
+                continue;
+            }
+            references.push(reference);
+        }
+        if (attention.kind !== 'not-collected' && references.length === 0) {
+            this.omitted = true;
+            return;
+        }
+        if (!previous && (this.marks?.size ?? 0) >= MAX_MARKS - 1) {
+            this.omitted = true;
+            return;
+        }
+        (this.marks ??= new Map()).set(key, { kind: attention.kind, reason: attention.reason, evidence: references });
+    }
+    missing() {
+        this.omitted = true;
+    }
+    /** Copy already collected bounded marks, never an attempt array, diagnostic bag or execution tree. */
+    snapshot() {
+        const result = [...(this.marks?.values() ?? [])].map((attention) => Object.freeze({ ...attention, evidence: Object.freeze([...attention.evidence]) }));
+        if (this.omitted && !result.some((attention) => attention.kind === 'not-collected'))
+            result.push(MISSING_ATTENTION);
+        return Object.freeze(result);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"attention.js","sourceRoot":"","sources":["../../../../src/lib/memory/attention.ts"],"names":[],"mappings":"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","sourcesContent":["/** Engine-owned attention is collected with retained facts; snapshots only copy this bounded projection. */\nimport type { Attention } from 'foottrace';\nimport { buildAttemptId, parseAttemptId } from 'foottrace';\n\nimport type { AttemptRecord, AttemptSummary } from '../attempt/types.js';\n\nconst MAX_MARKS = 32;\nconst MAX_REFERENCES = 16;\nconst MAX_REFERENCE_LENGTH = 512;\nconst STOPPED_REASONS = new Set(['exhausted', 'declined', 'no-time-left']);\nconst MISSING_ATTENTION: Attention = Object.freeze({\n  kind: 'not-collected',\n  reason: 'EVIDENCE_NOT_COLLECTED',\n  evidence: Object.freeze([]),\n});\n\nfunction validReference(reference: unknown): reference is string {\n  return (\n    typeof reference === 'string' &&\n    reference.length > 0 &&\n    reference.length <= MAX_REFERENCE_LENGTH &&\n    // eslint-disable-next-line no-control-regex -- Match the shared Foottrace evidence-reference boundary.\n    !/[\\u0000-\\u001f\\u007f-\\u009f]/.test(reference)\n  );\n}\n\n/** Reuse the one attempt grammar, including nested call addresses; never shorten an unaddressable proof. */\nfunction attemptReference(record: AttemptRecord, owner: string): string | undefined {\n  if (\n    typeof record.series !== 'string' ||\n    !Number.isSafeInteger(record.attempt) ||\n    record.attempt < 1 ||\n    record.series.length + String(record.attempt).length + 1 > MAX_REFERENCE_LENGTH\n  )\n    return undefined;\n  try {\n    const candidate = record.series + '@' + record.attempt;\n    const parts = parseAttemptId(candidate);\n    if (\n      !parts ||\n      parts.runtimeStageId !== owner ||\n      (record.kind === 'stage' ? parts.call !== undefined : parts.call === undefined)\n    )\n      return undefined;\n    const canonical = buildAttemptId(parts.runtimeStageId, parts.attempt, parts.call);\n    return canonical === candidate && validReference(canonical) ? canonical : undefined;\n  } catch {\n    return undefined;\n  }\n}\n\ntype TerminalProof = Pick<AttemptRecord, 'next' | 'reason' | 'effect'> & { readonly evidence: string };\n\n/** One execution's ownership, pending summary, marks and omission accounting stay in this helper. */\nexport class StageAttention {\n  private marks?: Map<string, Attention>;\n  private omitted = false;\n  private retryPossible = false;\n  private summary?: AttemptSummary;\n  private terminal?: TerminalProof;\n\n  /** A new execution starts fresh; an attempt discard never calls this. No collection is reconstructed. */\n  begin(): void {\n    this.marks = undefined;\n    this.omitted = false;\n    this.retryPossible = false;\n    this.summary = undefined;\n    this.terminal = undefined;\n  }\n\n  /** Called only after the frame retained this attempt. Raw error, target and decision payloads are never read. */\n  recordAttempt(record: AttemptRecord, owner: string): void {\n    const reference = attemptReference(record, owner);\n    if (record.kind === 'stage' && record.series === owner) {\n      if (record.retryLoop === undefined && (record.of ?? 1) > 1) this.retryPossible = true;\n      if (reference && record.next !== 'retry') {\n        this.terminal = { next: record.next, reason: record.reason, effect: record.effect, evidence: reference };\n      }\n    }\n    // The runner calls recordSummary before its final attempt. Finish that pending projection now too.\n    this.projectSummary();\n    const add = (kind: Attention['kind'], reason: Attention['reason']) => {\n      if (reference) this.append({ kind, reason, evidence: [reference] });\n      else this.missing();\n    };\n    if (record.effect === 'unknown') add('unknown-effect', 'UNKNOWN_EFFECT_RECORDED');\n    if (record.outcome === 'timeout') add('timeout', 'TIMEOUT_RECORDED');\n    // An SDK's suggested next/reason is not its actual policy; only a later ordinal proves its retry.\n    const observed = record.kind === 'observed';\n    if ((!observed && record.next === 'retry') || record.attempt > 1) add('retried', 'RETRY_RECORDED');\n    if (\n      !observed &&\n      record.next === 'stop' &&\n      STOPPED_REASONS.has(record.reason) &&\n      (record.of ?? 1) > 1 &&\n      record.retryLoop === undefined\n    )\n      add('gave-up', 'RETRY_STOP_RECORDED');\n  }\n\n  recordSummary(summary: AttemptSummary): void {\n    this.summary = summary;\n    this.projectSummary();\n  }\n\n  /** A summary-only cut wait has no phantom final attempt; use its actual retained summary. */\n  private projectSummary(): void {\n    const last = this.summary?.last;\n    if (!last) return;\n    const terminal = this.terminal;\n    const matching = terminal?.next === last.next && terminal.reason === last.reason;\n    const add = (kind: Attention['kind'], reason: Attention['reason'], proof?: string) => {\n      const reference = proof ?? 'attemptSummary';\n      const key = kind + ':' + reason;\n      const marks = this.marks;\n      const previous = marks?.get(key);\n      if (proof && marks && previous?.evidence.includes('attemptSummary')) {\n        marks.set(key, { ...previous, evidence: previous.evidence.filter((item) => item !== 'attemptSummary') });\n      }\n      this.append({ kind, reason, evidence: [reference] });\n    };\n    if (last.effect === 'unknown')\n      add(\n        'unknown-effect',\n        'UNKNOWN_EFFECT_RECORDED',\n        matching && terminal.effect === 'unknown' ? terminal.evidence : undefined,\n      );\n    if (this.retryPossible && last.next === 'stop' && STOPPED_REASONS.has(last.reason))\n      add('gave-up', 'RETRY_STOP_RECORDED', matching ? terminal.evidence : undefined);\n  }\n\n  /** Only the explicit retained stage-error path calls this; a diagnostic value never classifies itself. */\n  stageFailed(errors: unknown): void {\n    try {\n      const descriptor =\n        errors && typeof errors === 'object'\n          ? Object.getOwnPropertyDescriptor(errors, 'stageExecutionError')\n          : undefined;\n      if (descriptor && Object.hasOwn(descriptor, 'value')) {\n        this.append({ kind: 'error', reason: 'ERROR_RECORDED', evidence: ['errors:stageExecutionError'] });\n        return;\n      }\n    } catch {\n      /* A malformed evidence bag is unavailable, never another stage failure. */\n    }\n    this.missing();\n  }\n\n  attemptDropped(): void {\n    this.append({ kind: 'not-collected', reason: 'EVIDENCE_NOT_COLLECTED', evidence: ['attemptsDropped'] });\n  }\n\n  /** Keep only bounded exact references; one slot is reserved to disclose omissions. */\n  append(attention: Attention): void {\n    const key = attention.kind + ':' + attention.reason;\n    const previous = this.marks?.get(key);\n    const references = [...(previous?.evidence ?? [])];\n    for (const reference of attention.evidence) {\n      if (!validReference(reference)) {\n        this.omitted = true;\n        continue;\n      }\n      if (references.includes(reference)) continue;\n      if (references.length >= MAX_REFERENCES) {\n        this.omitted = true;\n        continue;\n      }\n      references.push(reference);\n    }\n    if (attention.kind !== 'not-collected' && references.length === 0) {\n      this.omitted = true;\n      return;\n    }\n    if (!previous && (this.marks?.size ?? 0) >= MAX_MARKS - 1) {\n      this.omitted = true;\n      return;\n    }\n    (this.marks ??= new Map()).set(key, { kind: attention.kind, reason: attention.reason, evidence: references });\n  }\n\n  missing(): void {\n    this.omitted = true;\n  }\n\n  /** Copy already collected bounded marks, never an attempt array, diagnostic bag or execution tree. */\n  snapshot(): readonly Attention[] {\n    const result = [...(this.marks?.values() ?? [])].map((attention) =>\n      Object.freeze({ ...attention, evidence: Object.freeze([...attention.evidence]) }),\n    );\n    if (this.omitted && !result.some((attention) => attention.kind === 'not-collected')) result.push(MISSING_ATTENTION);\n    return Object.freeze(result);\n  }\n}\n"]}

package/dist/esm/lib/memory/frameTypes.d.ts

@@ -12,6 +12,7 @@
  * A `StageSnapshot` is an `ExecutionTree` (`types.ts`), the shape the record's readers walk:
  * `commitStops`, `tagStops` and `keysReadFromExecutionTree` take one.
  */
+import type { Attention } from 'foottrace';
 import type { AttemptRecord, AttemptSummary, LateWrite } from '../attempt/types.js';
 import type { RetentionPolicy } from '../capture/policies.js';
 /** Types of control flow decisions captured by the execution engine. */
@@ -123,6 +124,13 @@ export type StageSnapshot = {
      * there were none.
      */
     lateWrites?: readonly LateWrite[];
+    /**
+     * Fixed-reason marks collected as this execution runs. Absent when no fact needs attention.
+     * Attempt evidence uses canonical Foottrace attempt IDs. Summary-only and stage-error proof resolves within THIS node
+     * through attemptSummary, errors:stageExecutionError or attemptsDropped. Quality marks are read-time recorder work.
+     * Marks retain no error text, values, targets or idempotency keys; omitted proof is disclosed as not-collected.
+     */
+    attention?: readonly Attention[];
     next?: StageSnapshot;
     children?: StageSnapshot[];
 };

package/dist/esm/lib/memory/frameTypes.js

@@ -13,4 +13,4 @@
  * `commitStops`, `tagStops` and `keysReadFromExecutionTree` take one.
  */
 export {};
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"frameTypes.js","sourceRoot":"","sources":["../../../../src/lib/memory/frameTypes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG","sourcesContent":["/**\n * frameTypes.ts — the types of the engine's frame (L4): what one stage inside a run reports.\n *\n * Its snapshot (`StageSnapshot`, one node of the execution tree), its flow messages\n * (`FlowMessage`, `FlowControlType`) and the two retention dials that shape what the snapshot\n * keeps (`ReadTrackingMode`, `WriteTrackingMode`, over `capture/`'s `RetentionPolicy`). They lived\n * in the record's `types.ts` until C6; the record names nothing outside itself now\n * (`RECORD_FILES`, scripts/layering.config.cjs), so they sit beside the frame that writes them.\n *\n * A retried stage's node also carries its attempts (`attempts`, `attemptSummary` — the attempt leaf's types, L0).\n *\n * A `StageSnapshot` is an `ExecutionTree` (`types.ts`), the shape the record's readers walk:\n * `commitStops`, `tagStops` and `keysReadFromExecutionTree` take one.\n */\n\nimport type { AttemptRecord, AttemptSummary, LateWrite } from '../attempt/types.js';\nimport type { RetentionPolicy } from '../capture/policies.js';\n\n// ── Flow Control Narrative ─────────────────────────────────────────────────\n\n/** Types of control flow decisions captured by the execution engine. */\nexport type FlowControlType = 'next' | 'branch' | 'children' | 'selected' | 'subflow' | 'loop';\n\n/** A single flow control narrative entry. */\nexport interface FlowMessage {\n  type: FlowControlType;\n  description: string;\n  targetStage?: string | string[];\n  rationale?: string;\n  count?: number;\n  iteration?: number;\n  timestamp?: number;\n}\n\n// ── Read / Write Tracking (#14, #13c-A) ────────────────────────────────────\n//\n// The policy family and marker shapes are owned by `capture/` (shared with\n// the deferred-observer capture tier).\n\n/**\n * Policy for how tracked reads are recorded into `StageSnapshot.stageReads`.\n *\n * - `'full'` (default) — every tracked read `structuredClone`s the value into\n *   the stage's read view. Byte-identical to the historical behavior; this is\n *   what snapshot consumers (lens, agentfootprint) see today.\n * - `'summary'` — reads record a cheap {@link ReadSummaryMarker} (type + size\n *   proxy + short preview) instead of the cloned value. O(1)-ish per read —\n *   no value clone, no serialization of large objects.\n * - `'off'` — reads are not recorded at all; `stageReads` is absent from the\n *   snapshot. Zero per-read cost. Values are still readable, and the\n *   `ScopeRecorder.onRead` event still fires (it passes the live reference and\n *   never cloned) — so narrative output is identical in every mode. The policy\n *   scopes ONLY the snapshot's `stageReads` payload.\n *\n * Set via `new FlowChartExecutor(chart, { readTracking })` or\n * `executor.setReadTracking(mode)` (before `run()`).\n *\n * Alias of the shared {@link RetentionPolicy} family (#13c-A) — kept as the\n * shipped public name for the read dial.\n */\nexport type ReadTrackingMode = RetentionPolicy;\n\n/**\n * Policy for how tracked writes are recorded into `StageSnapshot.stageWrites`\n * (#13c-A) — the sibling of {@link ReadTrackingMode}.\n *\n * - `'full'` (default) — every tracked write `structuredClone`s the value into\n *   the stage's write view. Byte-identical to the historical behavior.\n * - `'summary'` — writes record a cheap {@link WriteSummaryMarker} instead of\n *   the cloned value.\n * - `'off'` — writes are not recorded at all; `stageWrites` is absent from the\n *   snapshot. The writes themselves still commit to shared state and still\n *   appear in the commit log — only the per-stage snapshot bookkeeping (and\n *   therefore the commit observer's mutations payload) is affected. (The\n *   commit log's own value encoding has its own lossless dial —\n *   {@link CommitValuesMode}, #13c-B.)\n *\n * Set via `new FlowChartExecutor(chart, { writeTracking })` or\n * `executor.setWriteTracking(mode)` (before `run()`). See\n * `FlowChartExecutorOptions.writeTracking` for the full observable-consequence\n * contract (onCommit payload, redaction precedence, what is OUT of scope).\n */\nexport type WriteTrackingMode = RetentionPolicy;\n\n// ── Stage Snapshot ─────────────────────────────────────────────────────────\n\n/** Serialisable representation of a stage's state (for debugging / visualisation). */\nexport type StageSnapshot = {\n  id: string;\n  /** Unique per-execution-step identifier. Format: [subflowPath/]stageId#executionIndex */\n  runtimeStageId?: string;\n  name?: string;\n  /** Human-readable description of what this stage does (from builder). */\n  description?: string;\n  /** Subflow identifier — present when this stage is a subflow entry point. */\n  subflowId?: string;\n  isDecider?: boolean;\n  isFork?: boolean;\n  /** User-level writes made by this stage (pre-namespace keys → values).\n   *  Shape depends on {@link WriteTrackingMode}: cloned values under `'full'`\n   *  (default), {@link WriteSummaryMarker}s under `'summary'`, absent under\n   *  `'off'`. Redacted writes show `'[REDACTED]'` regardless of mode. */\n  stageWrites?: Record<string, unknown>;\n  /** User-level reads made by this stage (pre-namespace keys → values at read\n   *  time). Shape depends on {@link ReadTrackingMode}: cloned values under\n   *  `'full'` (default), {@link ReadSummaryMarker}s under `'summary'`, absent\n   *  under `'off'`. */\n  stageReads?: Record<string, unknown>;\n  logs: Record<string, unknown>;\n  errors: Record<string, unknown>;\n  metrics: Record<string, unknown>;\n  evals: Record<string, unknown>;\n  flowMessages?: FlowMessage[];\n  /**\n   * Every attempt of this execution, in order — when it started, how long it took, how it ended, and the\n   * retry-or-stop decision that followed (`AttemptRecord`): the stage's own under its retry policy, a `timeoutMs`\n   * or a run deadline (10.1, `kind: 'stage'`), and those of the calls it made through `scope.$call` and the\n   * outside attempts it reported through `observed()` (P2, `kind: 'call'` / `'observed'`, the first 1000 —\n   * `StageContext · MAX_CALL_RECORDS`). Absent when there are none. The commit log never carries attempts: a\n   * retried stage is still ONE bundle.\n   */\n  attempts?: readonly AttemptRecord[];\n  /**\n   * Call and observed attempt records this execution made past the first 1000 — counted, not kept (each still\n   * fired `onAttempt`). Absent when none were dropped.\n   */\n  attemptsDropped?: number;\n  /**\n   * The series at a glance — counts per outcome, and how it ended. Stamped when the series ends: absent while it\n   * is still running (a snapshot taken mid-stage) and without a policy.\n   */\n  attemptSummary?: AttemptSummary;\n  /**\n   * Writes (and emits) an attempt tried AFTER it had ended — timed out, aborted or failed — in the order they came\n   * (P1b). Each was dropped at the scope, so none reached the stage's buffer, its commit or a recorder; this is\n   * the record that they were tried — the first 100 (`MAX_LATE_WRITES`). An abandoned function can keep running\n   * after the run ended, so the list can grow after a snapshot was taken. Names only, never values. Absent when\n   * there were none.\n   */\n  lateWrites?: readonly LateWrite[];\n  next?: StageSnapshot;\n  children?: StageSnapshot[];\n};\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"frameTypes.js","sourceRoot":"","sources":["../../../../src/lib/memory/frameTypes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG","sourcesContent":["/**\n * frameTypes.ts — the types of the engine's frame (L4): what one stage inside a run reports.\n *\n * Its snapshot (`StageSnapshot`, one node of the execution tree), its flow messages\n * (`FlowMessage`, `FlowControlType`) and the two retention dials that shape what the snapshot\n * keeps (`ReadTrackingMode`, `WriteTrackingMode`, over `capture/`'s `RetentionPolicy`). They lived\n * in the record's `types.ts` until C6; the record names nothing outside itself now\n * (`RECORD_FILES`, scripts/layering.config.cjs), so they sit beside the frame that writes them.\n *\n * A retried stage's node also carries its attempts (`attempts`, `attemptSummary` — the attempt leaf's types, L0).\n *\n * A `StageSnapshot` is an `ExecutionTree` (`types.ts`), the shape the record's readers walk:\n * `commitStops`, `tagStops` and `keysReadFromExecutionTree` take one.\n */\n\nimport type { Attention } from 'foottrace';\n\nimport type { AttemptRecord, AttemptSummary, LateWrite } from '../attempt/types.js';\nimport type { RetentionPolicy } from '../capture/policies.js';\n\n// ── Flow Control Narrative ─────────────────────────────────────────────────\n\n/** Types of control flow decisions captured by the execution engine. */\nexport type FlowControlType = 'next' | 'branch' | 'children' | 'selected' | 'subflow' | 'loop';\n\n/** A single flow control narrative entry. */\nexport interface FlowMessage {\n  type: FlowControlType;\n  description: string;\n  targetStage?: string | string[];\n  rationale?: string;\n  count?: number;\n  iteration?: number;\n  timestamp?: number;\n}\n\n// ── Read / Write Tracking (#14, #13c-A) ────────────────────────────────────\n//\n// The policy family and marker shapes are owned by `capture/` (shared with\n// the deferred-observer capture tier).\n\n/**\n * Policy for how tracked reads are recorded into `StageSnapshot.stageReads`.\n *\n * - `'full'` (default) — every tracked read `structuredClone`s the value into\n *   the stage's read view. Byte-identical to the historical behavior; this is\n *   what snapshot consumers (lens, agentfootprint) see today.\n * - `'summary'` — reads record a cheap {@link ReadSummaryMarker} (type + size\n *   proxy + short preview) instead of the cloned value. O(1)-ish per read —\n *   no value clone, no serialization of large objects.\n * - `'off'` — reads are not recorded at all; `stageReads` is absent from the\n *   snapshot. Zero per-read cost. Values are still readable, and the\n *   `ScopeRecorder.onRead` event still fires (it passes the live reference and\n *   never cloned) — so narrative output is identical in every mode. The policy\n *   scopes ONLY the snapshot's `stageReads` payload.\n *\n * Set via `new FlowChartExecutor(chart, { readTracking })` or\n * `executor.setReadTracking(mode)` (before `run()`).\n *\n * Alias of the shared {@link RetentionPolicy} family (#13c-A) — kept as the\n * shipped public name for the read dial.\n */\nexport type ReadTrackingMode = RetentionPolicy;\n\n/**\n * Policy for how tracked writes are recorded into `StageSnapshot.stageWrites`\n * (#13c-A) — the sibling of {@link ReadTrackingMode}.\n *\n * - `'full'` (default) — every tracked write `structuredClone`s the value into\n *   the stage's write view. Byte-identical to the historical behavior.\n * - `'summary'` — writes record a cheap {@link WriteSummaryMarker} instead of\n *   the cloned value.\n * - `'off'` — writes are not recorded at all; `stageWrites` is absent from the\n *   snapshot. The writes themselves still commit to shared state and still\n *   appear in the commit log — only the per-stage snapshot bookkeeping (and\n *   therefore the commit observer's mutations payload) is affected. (The\n *   commit log's own value encoding has its own lossless dial —\n *   {@link CommitValuesMode}, #13c-B.)\n *\n * Set via `new FlowChartExecutor(chart, { writeTracking })` or\n * `executor.setWriteTracking(mode)` (before `run()`). See\n * `FlowChartExecutorOptions.writeTracking` for the full observable-consequence\n * contract (onCommit payload, redaction precedence, what is OUT of scope).\n */\nexport type WriteTrackingMode = RetentionPolicy;\n\n// ── Stage Snapshot ─────────────────────────────────────────────────────────\n\n/** Serialisable representation of a stage's state (for debugging / visualisation). */\nexport type StageSnapshot = {\n  id: string;\n  /** Unique per-execution-step identifier. Format: [subflowPath/]stageId#executionIndex */\n  runtimeStageId?: string;\n  name?: string;\n  /** Human-readable description of what this stage does (from builder). */\n  description?: string;\n  /** Subflow identifier — present when this stage is a subflow entry point. */\n  subflowId?: string;\n  isDecider?: boolean;\n  isFork?: boolean;\n  /** User-level writes made by this stage (pre-namespace keys → values).\n   *  Shape depends on {@link WriteTrackingMode}: cloned values under `'full'`\n   *  (default), {@link WriteSummaryMarker}s under `'summary'`, absent under\n   *  `'off'`. Redacted writes show `'[REDACTED]'` regardless of mode. */\n  stageWrites?: Record<string, unknown>;\n  /** User-level reads made by this stage (pre-namespace keys → values at read\n   *  time). Shape depends on {@link ReadTrackingMode}: cloned values under\n   *  `'full'` (default), {@link ReadSummaryMarker}s under `'summary'`, absent\n   *  under `'off'`. */\n  stageReads?: Record<string, unknown>;\n  logs: Record<string, unknown>;\n  errors: Record<string, unknown>;\n  metrics: Record<string, unknown>;\n  evals: Record<string, unknown>;\n  flowMessages?: FlowMessage[];\n  /**\n   * Every attempt of this execution, in order — when it started, how long it took, how it ended, and the\n   * retry-or-stop decision that followed (`AttemptRecord`): the stage's own under its retry policy, a `timeoutMs`\n   * or a run deadline (10.1, `kind: 'stage'`), and those of the calls it made through `scope.$call` and the\n   * outside attempts it reported through `observed()` (P2, `kind: 'call'` / `'observed'`, the first 1000 —\n   * `StageContext · MAX_CALL_RECORDS`). Absent when there are none. The commit log never carries attempts: a\n   * retried stage is still ONE bundle.\n   */\n  attempts?: readonly AttemptRecord[];\n  /**\n   * Call and observed attempt records this execution made past the first 1000 — counted, not kept (each still\n   * fired `onAttempt`). Absent when none were dropped.\n   */\n  attemptsDropped?: number;\n  /**\n   * The series at a glance — counts per outcome, and how it ended. Stamped when the series ends: absent while it\n   * is still running (a snapshot taken mid-stage) and without a policy.\n   */\n  attemptSummary?: AttemptSummary;\n  /**\n   * Writes (and emits) an attempt tried AFTER it had ended — timed out, aborted or failed — in the order they came\n   * (P1b). Each was dropped at the scope, so none reached the stage's buffer, its commit or a recorder; this is\n   * the record that they were tried — the first 100 (`MAX_LATE_WRITES`). An abandoned function can keep running\n   * after the run ended, so the list can grow after a snapshot was taken. Names only, never values. Absent when\n   * there were none.\n   */\n  lateWrites?: readonly LateWrite[];\n  /**\n   * Fixed-reason marks collected as this execution runs. Absent when no fact needs attention.\n   * Attempt evidence uses canonical Foottrace attempt IDs. Summary-only and stage-error proof resolves within THIS node\n   * through attemptSummary, errors:stageExecutionError or attemptsDropped. Quality marks are read-time recorder work.\n   * Marks retain no error text, values, targets or idempotency keys; omitted proof is disclosed as not-collected.\n   */\n  attention?: readonly Attention[];\n  next?: StageSnapshot;\n  children?: StageSnapshot[];\n};\n"]}

package/dist/esm/lib/recorder/ControlDepRecorder.d.ts

@@ -140,6 +140,20 @@ export declare class ControlDepRecorder implements FlowRecorder {
     getAttemptStop(runtimeStageId: string): ControlDecisionRecord | undefined;
     /** All decisions recorded for the current run, in event order — deciders, selectors and attempt stops. */
     getDecisions(): ControlDecisionRecord[];
+    /**
+     * Current-run control evidence for the native snapshot. Project only the
+     * stage identities collected during traversal; never walk the execution tree.
+     * Parentless roots cannot have a governing control edge.
+     */
+    toSnapshot(): {
+        name: string;
+        data: {
+            decisions: ControlDecisionRecord[];
+            controlDeps: {
+                [k: string]: ControlDependency;
+            };
+        };
+    };
     /** Reset all state (also happens automatically on runId change). */
     clear(): void;
     /** Convention 4: a new runId means a new run — reset transient state. */

package/dist/esm/lib/recorder/ControlDepRecorder.js

@@ -206,6 +206,23 @@ export class ControlDepRecorder {
     getDecisions() {
         return [...this.decisions.values()];
     }
+    /**
+     * Current-run control evidence for the native snapshot. Project only the
+     * stage identities collected during traversal; never walk the execution tree.
+     * Parentless roots cannot have a governing control edge.
+     */
+    toSnapshot() {
+        const dependencies = [];
+        for (const runtimeStageId of this.parentOf.keys()) {
+            const dependency = this.lookup(runtimeStageId);
+            if (dependency)
+                dependencies.push([runtimeStageId, dependency]);
+        }
+        return {
+            name: 'control-dependencies',
+            data: { decisions: this.getDecisions(), controlDeps: Object.fromEntries(dependencies) },
+        };
+    }
     /** Reset all state (also happens automatically on runId change). */
     clear() {
         this.parentOf.clear();
@@ -257,4 +274,4 @@ function matchedRuleLabel(evidence) {
     const rule = evidence.rules.find((r) => r.matched && r.branch === evidence.chosen) ?? evidence.rules.find((r) => r.matched);
     return rule?.label;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ControlDepRecorder.js","sourceRoot":"","sources":["../../../../src/lib/recorder/ControlDepRecorder.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * ControlDepRecorder — control-dependence tracking from flow events (RFC-003 D5).\n *\n * The gap this fills:\n *   The backtracker's `controlDeps` option (D3) needs a `ControlDepLookup`:\n *   \"which decider execution allowed this stage to run?\" The engine knows\n *   this during traversal but the commit log doesn't record it — control\n *   flow is a FlowRecorder concern. This recorder is the standard producer:\n *   one subscription, one lookup, plug it straight into `causalChain`.\n *\n * How it works — two correlation structures built during traversal:\n *\n *   1. `parentOf` — the runtime ancestor chain, from every stage event's\n *      `traversalContext.parentRuntimeStageId` (RFC-003 D1). Crosses\n *      subflow boundaries; loop re-entries stay unambiguous because\n *      runtime ids differ per iteration.\n *\n *   2. `branchEntryToDecision` — on `onDecision`/`onSelected` the decision\n *      is recorded as PENDING; the next stage(s) executed whose\n *      `parentRuntimeStageId` IS the decider's runtimeStageId are its\n *      branch entries (1 for a decider, N = selected.length for a\n *      selector). Correlation is by parent-id + count, NOT by stage name —\n *      subflow-mount events carry path-prefixed inner-root names that\n *      don't match `FlowDecisionEvent.chosen`, and selectors emit a\n *      synthetic fork event sharing the selector's own runtimeStageId\n *      (excluded via the self-id guard). A branch that THROWS before\n *      completing consumes its slot via `onError`, so the post-fan-out\n *      convergence stage is never misattributed as a branch entry.\n *\n *   3. attempt stops (10.1) — `onAttempt`: a stage whose retry series STOPPED\n *      (it gave up, or a later attempt paused or was aborted; the shared\n *      predicate `recorder/attemptSeries.ts · isRetryEvidence`) made a decision of its\n *      own — the retry-or-stop decision, in the shape `decide()` produces. It\n *      is recorded beside the deciders as `kind: 'attempt-stop'`\n *      (`getDecisions()`, `getAttemptStop(id)`), `chosen: 'stop'`, the stop\n *      reason as its `ruleLabel`. It is NOT a branch entry: a control edge in\n *      `causalChain` links a stage to ANOTHER execution that governed it, and\n *      the stop governs the stage itself — so `lookup` is unchanged, and a\n *      reader walking a failed stage reads the stop off its decision record.\n *\n *   `lookup(runtimeStageId)` then walks the ancestor chain from the stage\n *   upward; the first ancestor (or the stage itself) registered as a\n *   branch entry yields its governing decider — the NEAREST decision.\n *   Nested decisions compose naturally: the backtracker expands the\n *   decider node and asks again.\n *\n * Convention 4: state resets when `traversalContext.runId` changes — each\n * run (and each resume, which mints a fresh runId) starts clean. Control\n * chains therefore do NOT survive a pause/resume boundary: post-resume\n * stages cannot resolve pre-pause decisions.\n *\n * @example\n * ```typescript\n * import { controlDepRecorder } from 'footprintjs/trace';\nimport { causalChain } from 'foottrace';\n *\n * const ctrl = controlDepRecorder();\n * executor.attachCombinedRecorder(ctrl); // auto-routes to FlowRecorder channel\n *\n * await executor.run({ input });\n *\n * const dag = causalChain(commitLog, 'approve#2', keysRead, {\n *   controlDeps: ctrl.asLookup(),\n * });\n * ```\n */\n\nimport type { ControlDependency, ControlDepLookup } from 'foottrace';\n\nimport type { DecisionEvidence, SelectionEvidence } from '../decide/types.js';\nimport type {\n  FlowAttemptEvent,\n  FlowDecisionEvent,\n  FlowErrorEvent,\n  FlowRecorder,\n  FlowSelectedEvent,\n  FlowStageEvent,\n} from '../engine/narrative/types.js';\nimport { isRetryEvidence } from './attemptSeries.js';\n\n/** One recorded decision/selection event (RFC-003 D5). */\nexport interface ControlDecisionRecord {\n  /**\n   * `'attempt-stop'` for a stage's own retry-or-stop decision that STOPPED its series (10.1) — then\n   * `deciderRuntimeStageId` is the stage's execution, `chosen` is `'stop'`, `evidence` the attempt's decision and\n   * `ruleLabel` the stop reason. Absent for a decider / selector.\n   */\n  kind?: 'attempt-stop';\n  /** runtimeStageId of the decider/selector execution step. */\n  deciderRuntimeStageId: string;\n  /** Chosen branch display name (decider) or selected names (selector). */\n  chosen: string | readonly string[];\n  /** Structured evidence from decide()/select(), when the stage used them. */\n  evidence?: DecisionEvidence | SelectionEvidence;\n  /**\n   * The decide() rule label that produced the decision (e.g. 'Good credit').\n   * Deciders only — a selector picks N branches and no single label\n   * attributes to all of them (inspect `evidence` instead).\n   */\n  ruleLabel?: string;\n}\n\nexport interface ControlDepRecorderOptions {\n  /** Recorder id. Defaults to `control-deps-N` (auto-incremented). */\n  id?: string;\n}\n\n/** A decision awaiting branch-entry correlation. */\ninterface PendingDecision {\n  deciderId: string;\n  /** How many branch entries are still expected (decider: 1, selector: N). */\n  remaining: number;\n}\n\nlet _counter = 0;\n\n/**\n * Factory — matches the `topologyRecorder()` / `inOutRecorder()` style.\n */\nexport function controlDepRecorder(options: ControlDepRecorderOptions = {}): ControlDepRecorder {\n  return new ControlDepRecorder(options);\n}\n\n/**\n * Stateful accumulator that watches FlowRecorder events and answers\n * \"which decision allowed this stage to run?\" Attach via\n * `executor.attachCombinedRecorder(recorder)` (or `attachFlowRecorder`).\n */\nexport class ControlDepRecorder implements FlowRecorder {\n  readonly id: string;\n\n  /** Runtime ancestor chain: runtimeStageId → parentRuntimeStageId (D1). */\n  private readonly parentOf = new Map<string, string>();\n  /** Recorded decisions, keyed by decider runtimeStageId. */\n  private readonly decisions = new Map<string, ControlDecisionRecord>();\n  /** Branch-entry runtimeStageId → governing decider runtimeStageId. */\n  private readonly branchEntryToDecision = new Map<string, string>();\n  /** Decisions whose branch entries have not all been seen yet. */\n  private pending: PendingDecision[] = [];\n  /** Stage ids that already consumed a pending slot (entry OR error). */\n  private readonly consumedSlots = new Set<string>();\n  /** Convention 4 — runId of the run currently being recorded. */\n  private lastRunId?: string;\n\n  constructor(options: ControlDepRecorderOptions = {}) {\n    this.id = options.id ?? `control-deps-${++_counter}`;\n  }\n\n  // ── FlowRecorder hooks ────────────────────────────────────────────────\n\n  onDecision(event: FlowDecisionEvent): void {\n    const ctx = event.traversalContext;\n    if (!ctx) return;\n    this.resetIfNewRun(ctx.runId);\n\n    const deciderId = ctx.runtimeStageId;\n    const ruleLabel = matchedRuleLabel(event.evidence);\n    this.decisions.set(deciderId, {\n      deciderRuntimeStageId: deciderId,\n      chosen: event.chosen,\n      ...(event.evidence && { evidence: event.evidence }),\n      ...(ruleLabel !== undefined && { ruleLabel }),\n    });\n    this.pending.push({ deciderId, remaining: 1 });\n  }\n\n  onAttempt(event: FlowAttemptEvent): void {\n    const ctx = event.traversalContext;\n    const { record } = event;\n    if (!ctx || record.next !== 'stop' || !isRetryEvidence(record)) return;\n    this.resetIfNewRun(ctx.runId);\n    this.decisions.set(record.series, {\n      kind: 'attempt-stop',\n      deciderRuntimeStageId: record.series,\n      chosen: 'stop',\n      evidence: record.decision,\n      ruleLabel: record.reason,\n    });\n  }\n\n  onSelected(event: FlowSelectedEvent): void {\n    const ctx = event.traversalContext;\n    if (!ctx) return;\n    this.resetIfNewRun(ctx.runId);\n    if (event.selected.length === 0) return; // nothing selected → nothing governed\n\n    const deciderId = ctx.runtimeStageId;\n    this.decisions.set(deciderId, {\n      deciderRuntimeStageId: deciderId,\n      chosen: [...event.selected],\n      ...(event.evidence && { evidence: event.evidence }),\n    });\n    this.pending.push({ deciderId, remaining: event.selected.length });\n  }\n\n  onStageExecuted(event: FlowStageEvent): void {\n    const ctx = event.traversalContext;\n    if (!ctx) return;\n    this.resetIfNewRun(ctx.runId);\n\n    const { runtimeStageId, parentRuntimeStageId } = ctx;\n    if (parentRuntimeStageId) {\n      this.parentOf.set(runtimeStageId, parentRuntimeStageId);\n      this.consumePendingSlot(runtimeStageId, parentRuntimeStageId, /* register */ true);\n    }\n  }\n\n  /**\n   * A branch that throws never fires `onStageExecuted` — without this hook\n   * its pending slot would leak and the post-fan-out convergence stage\n   * (whose context also chains to the selector) would be misattributed as\n   * a branch entry under best-effort (`failFast: false`) fan-outs.\n   */\n  onError(event: FlowErrorEvent): void {\n    const ctx = event.traversalContext;\n    if (!ctx) return;\n    this.resetIfNewRun(ctx.runId);\n    if (ctx.parentRuntimeStageId) {\n      // Record the chain AND attribute the failed stage to its decision —\n      // the stage RAN (and may have committed partial writes) because the\n      // decision chose it; failing afterwards doesn't undo the dependency.\n      this.parentOf.set(ctx.runtimeStageId, ctx.parentRuntimeStageId);\n      this.consumePendingSlot(ctx.runtimeStageId, ctx.parentRuntimeStageId, /* register */ true);\n    }\n  }\n\n  // ── Queries ───────────────────────────────────────────────────────────\n\n  /**\n   * Resolve the NEAREST governing decision for an execution step: walks the\n   * runtime ancestor chain (the step itself first) until it hits a\n   * registered branch entry. `undefined` when the step is not downstream of\n   * any recorded decision.\n   */\n  lookup(runtimeStageId: string): ControlDependency | undefined {\n    const seen = new Set<string>();\n    let cur: string | undefined = runtimeStageId;\n    while (cur !== undefined && !seen.has(cur)) {\n      seen.add(cur);\n      const deciderId = this.branchEntryToDecision.get(cur);\n      if (deciderId !== undefined) {\n        const record = this.decisions.get(deciderId);\n        return {\n          deciderId,\n          ...(record?.ruleLabel !== undefined && { label: record.ruleLabel }),\n        };\n      }\n      cur = this.parentOf.get(cur);\n    }\n    return undefined;\n  }\n\n  /** The lookup as a bare function — plug into `causalChain(..., { controlDeps })`. */\n  asLookup(): ControlDepLookup {\n    return (runtimeStageId) => this.lookup(runtimeStageId);\n  }\n\n  /** The attempt-stop decision of a stage execution whose retry series stopped, if it did. */\n  getAttemptStop(runtimeStageId: string): ControlDecisionRecord | undefined {\n    const record = this.decisions.get(runtimeStageId);\n    return record?.kind === 'attempt-stop' ? record : undefined;\n  }\n\n  /** All decisions recorded for the current run, in event order — deciders, selectors and attempt stops. */\n  getDecisions(): ControlDecisionRecord[] {\n    return [...this.decisions.values()];\n  }\n\n  /** Reset all state (also happens automatically on runId change). */\n  clear(): void {\n    this.parentOf.clear();\n    this.decisions.clear();\n    this.branchEntryToDecision.clear();\n    this.pending = [];\n    this.consumedSlots.clear();\n  }\n\n  // ── Internals ─────────────────────────────────────────────────────────\n\n  /** Convention 4: a new runId means a new run — reset transient state. */\n  private resetIfNewRun(runId: string): void {\n    if (runId === this.lastRunId) return;\n    this.clear();\n    this.lastRunId = runId;\n  }\n\n  /**\n   * If `parentRuntimeStageId` is a decider with an unmatched pending slot,\n   * consume one. `register` controls whether the stage is recorded as a\n   * branch entry (stage executed/errored) — both paths consume the slot so\n   * counts stay exact even when a stage produces both events.\n   */\n  private consumePendingSlot(runtimeStageId: string, parentRuntimeStageId: string, register: boolean): void {\n    if (runtimeStageId === parentRuntimeStageId) return; // synthetic self-events\n    if (this.consumedSlots.has(runtimeStageId)) return;\n\n    for (let i = 0; i < this.pending.length; i++) {\n      const p = this.pending[i];\n      if (p.deciderId !== parentRuntimeStageId) continue;\n\n      this.consumedSlots.add(runtimeStageId);\n      if (register) this.branchEntryToDecision.set(runtimeStageId, p.deciderId);\n      p.remaining--;\n      if (p.remaining <= 0) this.pending.splice(i, 1);\n      return;\n    }\n  }\n}\n\n/**\n * The decide() rule label that produced the decision: the matched rule\n * mapping to the chosen branch (first matched rule as fallback).\n */\nfunction matchedRuleLabel(evidence: DecisionEvidence | undefined): string | undefined {\n  if (!evidence) return undefined;\n  const rule =\n    evidence.rules.find((r) => r.matched && r.branch === evidence.chosen) ?? evidence.rules.find((r) => r.matched);\n  return rule?.label;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ControlDepRecorder.js","sourceRoot":"","sources":["../../../../src/lib/recorder/ControlDepRecorder.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * ControlDepRecorder — control-dependence tracking from flow events (RFC-003 D5).\n *\n * The gap this fills:\n *   The backtracker's `controlDeps` option (D3) needs a `ControlDepLookup`:\n *   \"which decider execution allowed this stage to run?\" The engine knows\n *   this during traversal but the commit log doesn't record it — control\n *   flow is a FlowRecorder concern. This recorder is the standard producer:\n *   one subscription, one lookup, plug it straight into `causalChain`.\n *\n * How it works — two correlation structures built during traversal:\n *\n *   1. `parentOf` — the runtime ancestor chain, from every stage event's\n *      `traversalContext.parentRuntimeStageId` (RFC-003 D1). Crosses\n *      subflow boundaries; loop re-entries stay unambiguous because\n *      runtime ids differ per iteration.\n *\n *   2. `branchEntryToDecision` — on `onDecision`/`onSelected` the decision\n *      is recorded as PENDING; the next stage(s) executed whose\n *      `parentRuntimeStageId` IS the decider's runtimeStageId are its\n *      branch entries (1 for a decider, N = selected.length for a\n *      selector). Correlation is by parent-id + count, NOT by stage name —\n *      subflow-mount events carry path-prefixed inner-root names that\n *      don't match `FlowDecisionEvent.chosen`, and selectors emit a\n *      synthetic fork event sharing the selector's own runtimeStageId\n *      (excluded via the self-id guard). A branch that THROWS before\n *      completing consumes its slot via `onError`, so the post-fan-out\n *      convergence stage is never misattributed as a branch entry.\n *\n *   3. attempt stops (10.1) — `onAttempt`: a stage whose retry series STOPPED\n *      (it gave up, or a later attempt paused or was aborted; the shared\n *      predicate `recorder/attemptSeries.ts · isRetryEvidence`) made a decision of its\n *      own — the retry-or-stop decision, in the shape `decide()` produces. It\n *      is recorded beside the deciders as `kind: 'attempt-stop'`\n *      (`getDecisions()`, `getAttemptStop(id)`), `chosen: 'stop'`, the stop\n *      reason as its `ruleLabel`. It is NOT a branch entry: a control edge in\n *      `causalChain` links a stage to ANOTHER execution that governed it, and\n *      the stop governs the stage itself — so `lookup` is unchanged, and a\n *      reader walking a failed stage reads the stop off its decision record.\n *\n *   `lookup(runtimeStageId)` then walks the ancestor chain from the stage\n *   upward; the first ancestor (or the stage itself) registered as a\n *   branch entry yields its governing decider — the NEAREST decision.\n *   Nested decisions compose naturally: the backtracker expands the\n *   decider node and asks again.\n *\n * Convention 4: state resets when `traversalContext.runId` changes — each\n * run (and each resume, which mints a fresh runId) starts clean. Control\n * chains therefore do NOT survive a pause/resume boundary: post-resume\n * stages cannot resolve pre-pause decisions.\n *\n * @example\n * ```typescript\n * import { controlDepRecorder } from 'footprintjs/trace';\nimport { causalChain } from 'foottrace';\n *\n * const ctrl = controlDepRecorder();\n * executor.attachCombinedRecorder(ctrl); // auto-routes to FlowRecorder channel\n *\n * await executor.run({ input });\n *\n * const dag = causalChain(commitLog, 'approve#2', keysRead, {\n *   controlDeps: ctrl.asLookup(),\n * });\n * ```\n */\n\nimport type { ControlDependency, ControlDepLookup } from 'foottrace';\n\nimport type { DecisionEvidence, SelectionEvidence } from '../decide/types.js';\nimport type {\n  FlowAttemptEvent,\n  FlowDecisionEvent,\n  FlowErrorEvent,\n  FlowRecorder,\n  FlowSelectedEvent,\n  FlowStageEvent,\n} from '../engine/narrative/types.js';\nimport { isRetryEvidence } from './attemptSeries.js';\n\n/** One recorded decision/selection event (RFC-003 D5). */\nexport interface ControlDecisionRecord {\n  /**\n   * `'attempt-stop'` for a stage's own retry-or-stop decision that STOPPED its series (10.1) — then\n   * `deciderRuntimeStageId` is the stage's execution, `chosen` is `'stop'`, `evidence` the attempt's decision and\n   * `ruleLabel` the stop reason. Absent for a decider / selector.\n   */\n  kind?: 'attempt-stop';\n  /** runtimeStageId of the decider/selector execution step. */\n  deciderRuntimeStageId: string;\n  /** Chosen branch display name (decider) or selected names (selector). */\n  chosen: string | readonly string[];\n  /** Structured evidence from decide()/select(), when the stage used them. */\n  evidence?: DecisionEvidence | SelectionEvidence;\n  /**\n   * The decide() rule label that produced the decision (e.g. 'Good credit').\n   * Deciders only — a selector picks N branches and no single label\n   * attributes to all of them (inspect `evidence` instead).\n   */\n  ruleLabel?: string;\n}\n\nexport interface ControlDepRecorderOptions {\n  /** Recorder id. Defaults to `control-deps-N` (auto-incremented). */\n  id?: string;\n}\n\n/** A decision awaiting branch-entry correlation. */\ninterface PendingDecision {\n  deciderId: string;\n  /** How many branch entries are still expected (decider: 1, selector: N). */\n  remaining: number;\n}\n\nlet _counter = 0;\n\n/**\n * Factory — matches the `topologyRecorder()` / `inOutRecorder()` style.\n */\nexport function controlDepRecorder(options: ControlDepRecorderOptions = {}): ControlDepRecorder {\n  return new ControlDepRecorder(options);\n}\n\n/**\n * Stateful accumulator that watches FlowRecorder events and answers\n * \"which decision allowed this stage to run?\" Attach via\n * `executor.attachCombinedRecorder(recorder)` (or `attachFlowRecorder`).\n */\nexport class ControlDepRecorder implements FlowRecorder {\n  readonly id: string;\n\n  /** Runtime ancestor chain: runtimeStageId → parentRuntimeStageId (D1). */\n  private readonly parentOf = new Map<string, string>();\n  /** Recorded decisions, keyed by decider runtimeStageId. */\n  private readonly decisions = new Map<string, ControlDecisionRecord>();\n  /** Branch-entry runtimeStageId → governing decider runtimeStageId. */\n  private readonly branchEntryToDecision = new Map<string, string>();\n  /** Decisions whose branch entries have not all been seen yet. */\n  private pending: PendingDecision[] = [];\n  /** Stage ids that already consumed a pending slot (entry OR error). */\n  private readonly consumedSlots = new Set<string>();\n  /** Convention 4 — runId of the run currently being recorded. */\n  private lastRunId?: string;\n\n  constructor(options: ControlDepRecorderOptions = {}) {\n    this.id = options.id ?? `control-deps-${++_counter}`;\n  }\n\n  // ── FlowRecorder hooks ────────────────────────────────────────────────\n\n  onDecision(event: FlowDecisionEvent): void {\n    const ctx = event.traversalContext;\n    if (!ctx) return;\n    this.resetIfNewRun(ctx.runId);\n\n    const deciderId = ctx.runtimeStageId;\n    const ruleLabel = matchedRuleLabel(event.evidence);\n    this.decisions.set(deciderId, {\n      deciderRuntimeStageId: deciderId,\n      chosen: event.chosen,\n      ...(event.evidence && { evidence: event.evidence }),\n      ...(ruleLabel !== undefined && { ruleLabel }),\n    });\n    this.pending.push({ deciderId, remaining: 1 });\n  }\n\n  onAttempt(event: FlowAttemptEvent): void {\n    const ctx = event.traversalContext;\n    const { record } = event;\n    if (!ctx || record.next !== 'stop' || !isRetryEvidence(record)) return;\n    this.resetIfNewRun(ctx.runId);\n    this.decisions.set(record.series, {\n      kind: 'attempt-stop',\n      deciderRuntimeStageId: record.series,\n      chosen: 'stop',\n      evidence: record.decision,\n      ruleLabel: record.reason,\n    });\n  }\n\n  onSelected(event: FlowSelectedEvent): void {\n    const ctx = event.traversalContext;\n    if (!ctx) return;\n    this.resetIfNewRun(ctx.runId);\n    if (event.selected.length === 0) return; // nothing selected → nothing governed\n\n    const deciderId = ctx.runtimeStageId;\n    this.decisions.set(deciderId, {\n      deciderRuntimeStageId: deciderId,\n      chosen: [...event.selected],\n      ...(event.evidence && { evidence: event.evidence }),\n    });\n    this.pending.push({ deciderId, remaining: event.selected.length });\n  }\n\n  onStageExecuted(event: FlowStageEvent): void {\n    const ctx = event.traversalContext;\n    if (!ctx) return;\n    this.resetIfNewRun(ctx.runId);\n\n    const { runtimeStageId, parentRuntimeStageId } = ctx;\n    if (parentRuntimeStageId) {\n      this.parentOf.set(runtimeStageId, parentRuntimeStageId);\n      this.consumePendingSlot(runtimeStageId, parentRuntimeStageId, /* register */ true);\n    }\n  }\n\n  /**\n   * A branch that throws never fires `onStageExecuted` — without this hook\n   * its pending slot would leak and the post-fan-out convergence stage\n   * (whose context also chains to the selector) would be misattributed as\n   * a branch entry under best-effort (`failFast: false`) fan-outs.\n   */\n  onError(event: FlowErrorEvent): void {\n    const ctx = event.traversalContext;\n    if (!ctx) return;\n    this.resetIfNewRun(ctx.runId);\n    if (ctx.parentRuntimeStageId) {\n      // Record the chain AND attribute the failed stage to its decision —\n      // the stage RAN (and may have committed partial writes) because the\n      // decision chose it; failing afterwards doesn't undo the dependency.\n      this.parentOf.set(ctx.runtimeStageId, ctx.parentRuntimeStageId);\n      this.consumePendingSlot(ctx.runtimeStageId, ctx.parentRuntimeStageId, /* register */ true);\n    }\n  }\n\n  // ── Queries ───────────────────────────────────────────────────────────\n\n  /**\n   * Resolve the NEAREST governing decision for an execution step: walks the\n   * runtime ancestor chain (the step itself first) until it hits a\n   * registered branch entry. `undefined` when the step is not downstream of\n   * any recorded decision.\n   */\n  lookup(runtimeStageId: string): ControlDependency | undefined {\n    const seen = new Set<string>();\n    let cur: string | undefined = runtimeStageId;\n    while (cur !== undefined && !seen.has(cur)) {\n      seen.add(cur);\n      const deciderId = this.branchEntryToDecision.get(cur);\n      if (deciderId !== undefined) {\n        const record = this.decisions.get(deciderId);\n        return {\n          deciderId,\n          ...(record?.ruleLabel !== undefined && { label: record.ruleLabel }),\n        };\n      }\n      cur = this.parentOf.get(cur);\n    }\n    return undefined;\n  }\n\n  /** The lookup as a bare function — plug into `causalChain(..., { controlDeps })`. */\n  asLookup(): ControlDepLookup {\n    return (runtimeStageId) => this.lookup(runtimeStageId);\n  }\n\n  /** The attempt-stop decision of a stage execution whose retry series stopped, if it did. */\n  getAttemptStop(runtimeStageId: string): ControlDecisionRecord | undefined {\n    const record = this.decisions.get(runtimeStageId);\n    return record?.kind === 'attempt-stop' ? record : undefined;\n  }\n\n  /** All decisions recorded for the current run, in event order — deciders, selectors and attempt stops. */\n  getDecisions(): ControlDecisionRecord[] {\n    return [...this.decisions.values()];\n  }\n\n  /**\n   * Current-run control evidence for the native snapshot. Project only the\n   * stage identities collected during traversal; never walk the execution tree.\n   * Parentless roots cannot have a governing control edge.\n   */\n  toSnapshot() {\n    const dependencies: [string, ControlDependency][] = [];\n    for (const runtimeStageId of this.parentOf.keys()) {\n      const dependency = this.lookup(runtimeStageId);\n      if (dependency) dependencies.push([runtimeStageId, dependency]);\n    }\n    return {\n      name: 'control-dependencies',\n      data: { decisions: this.getDecisions(), controlDeps: Object.fromEntries(dependencies) },\n    };\n  }\n\n  /** Reset all state (also happens automatically on runId change). */\n  clear(): void {\n    this.parentOf.clear();\n    this.decisions.clear();\n    this.branchEntryToDecision.clear();\n    this.pending = [];\n    this.consumedSlots.clear();\n  }\n\n  // ── Internals ─────────────────────────────────────────────────────────\n\n  /** Convention 4: a new runId means a new run — reset transient state. */\n  private resetIfNewRun(runId: string): void {\n    if (runId === this.lastRunId) return;\n    this.clear();\n    this.lastRunId = runId;\n  }\n\n  /**\n   * If `parentRuntimeStageId` is a decider with an unmatched pending slot,\n   * consume one. `register` controls whether the stage is recorded as a\n   * branch entry (stage executed/errored) — both paths consume the slot so\n   * counts stay exact even when a stage produces both events.\n   */\n  private consumePendingSlot(runtimeStageId: string, parentRuntimeStageId: string, register: boolean): void {\n    if (runtimeStageId === parentRuntimeStageId) return; // synthetic self-events\n    if (this.consumedSlots.has(runtimeStageId)) return;\n\n    for (let i = 0; i < this.pending.length; i++) {\n      const p = this.pending[i];\n      if (p.deciderId !== parentRuntimeStageId) continue;\n\n      this.consumedSlots.add(runtimeStageId);\n      if (register) this.branchEntryToDecision.set(runtimeStageId, p.deciderId);\n      p.remaining--;\n      if (p.remaining <= 0) this.pending.splice(i, 1);\n      return;\n    }\n  }\n}\n\n/**\n * The decide() rule label that produced the decision: the matched rule\n * mapping to the chosen branch (first matched rule as fallback).\n */\nfunction matchedRuleLabel(evidence: DecisionEvidence | undefined): string | undefined {\n  if (!evidence) return undefined;\n  const rule =\n    evidence.rules.find((r) => r.matched && r.branch === evidence.chosen) ?? evidence.rules.find((r) => r.matched);\n  return rule?.label;\n}\n"]}

package/dist/esm/lib/runner/FlowChartExecutor.d.ts

@@ -28,6 +28,7 @@ import type { CombinedNarrativeEntry } from '../engine/narrative/narrativeTypes.
 import type { ManifestEntry } from '../engine/narrative/recorders/ManifestFlowRecorder.js';
 import type { FlowRecorder } from '../engine/narrative/types.js';
 import { type ExecutorResult, type RunOptions, type ScopeFactory, type SerializedPipelineStructure, type StageNode, type SubflowResult } from '../engine/types.js';
+import { type TerminalFailureContext } from '../errors/terminalFailure.js';
 import type { ReadTrackingMode, WriteTrackingMode } from '../memory/frameTypes.js';
 import type { FlowchartCheckpoint } from '../pause/types.js';
 import type { CombinedRecorder } from '../recorder/CombinedRecorder.js';
@@ -64,6 +65,9 @@ export declare class FlowChartExecutor<TOut = any, TScope = any> {
      * See docs/guides/execution-model.md.
      */
     private _isExecuting;
+    private failureState;
+    /** Safe native context for the latest rejected leg; undefined before, during, after success or pause. */
+    getFailureContext(): TerminalFailureContext | undefined;
     private readonly flowChartArgs;
     /**
      * The crash-safe record of the current run (10.1, P6) — the sink every log of the run writes to, its