footprintjs 9.7.0 → 9.9.0

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

@@ -53,6 +53,7 @@
  * console.log(formatCausalChain(dag));     // human-readable
  * ```
  */
+import { isDevMode } from '../scope/detectCircular.js';
 import { findLastWriter } from './commitLogUtils.js';
 // ── Staged optimization: writer lookup strategies ──────────────────────
 /**
@@ -127,6 +128,16 @@ function createWriterLookup(commitLog) {
     return reverseIndexLookup(commitLog);
 }
 // ── Core algorithm ─────────────────────────────────────────────────────
+/**
+ * RFC-003 D2: the `incompleteSources` node fragment for a commit — `{}`
+ * when the stage consumed no untracked read paths, keeping the field
+ * ABSENT (not empty-array-valued) for fully-tracked stages.
+ */
+function incompleteSourcesFragment(commit) {
+    if (!commit.untrackedSources || commit.untrackedSources.length === 0)
+        return {};
+    return { incompleteSources: commit.untrackedSources };
+}
 /**
  * Build the causal DAG rooted at `startId` by walking backwards
  * through read→write dependencies in the commit log.
@@ -147,6 +158,13 @@ function createWriterLookup(commitLog) {
 export function causalChain(commitLog, startId, getKeysRead, options) {
     const maxDepth = options?.maxDepth ?? 20;
     const maxNodes = options?.maxNodes ?? 100;
+    const controlDeps = options?.controlDeps;
+    const weigh = options?.weigh;
+    // RFC-003 D4 — truncation visibility. Set only when a limit actually
+    // cuts the slice; surfaced on the root as `truncated` so a consumer can
+    // never mistake a truncated slice for a complete one.
+    let truncatedByDepth = false;
+    let truncatedByNodes = false;
     // Build position index: runtimeStageId → array position (O(n) once)
     const idxMap = new Map();
     for (let i = 0; i < commitLog.length; i++) {
@@ -168,52 +186,111 @@ export function causalChain(commitLog, startId, getKeysRead, options) {
         linkedBy: '',
         depth: 0,
         parents: [],
+        parentEdges: [],
+        ...incompleteSourcesFragment(startCommit),
     };
     nodeMap.set(startId, root);
     // BFS queue: [node, commitIdx, depth]
     const queue = [[root, startIdx, 0]];
     let visited = 1;
+    /**
+     * Link `node → parent` (creating + enqueueing the parent when new).
+     * Shared by data-edge expansion (read→write) and control-edge expansion
+     * (D3). One CausalEdge per distinct (parent, kind, key) link; `parents`
+     * keeps its historical one-entry-per-parent dedup.
+     */
+    function linkParent(node, parentCommit, kind, key, depth) {
+        const parentId = parentCommit.runtimeStageId;
+        let parentNode = nodeMap.get(parentId);
+        if (!parentNode) {
+            // New node — create and enqueue (respecting the node budget)
+            if (visited >= maxNodes) {
+                truncatedByNodes = true; // D4: a discovered parent was dropped
+                return;
+            }
+            const parentIdx = idxMap.get(parentId);
+            if (parentIdx === undefined)
+                return;
+            parentNode = {
+                runtimeStageId: parentId,
+                stageId: parentCommit.stageId,
+                stageName: parentCommit.stage,
+                keysWritten: parentCommit.trace.map((t) => t.path),
+                // linkedBy stays a DATA-key concept (back-compat) — control-linked
+                // nodes carry their label on the edge instead.
+                linkedBy: kind === 'data' ? key ?? '' : '',
+                depth: depth + 1,
+                parents: [],
+                parentEdges: [],
+                ...incompleteSourcesFragment(parentCommit),
+            };
+            nodeMap.set(parentId, parentNode);
+            visited++;
+            queue.push([parentNode, parentIdx, depth + 1]);
+        }
+        // DAG merge: one parents[] entry per distinct parent (historical shape)
+        if (!node.parents.some((p) => p.runtimeStageId === parentId)) {
+            node.parents.push(parentNode);
+        }
+        // One edge per distinct (parent, kind, key) link. The weigher (D4)
+        // stamps the weight at creation; `undefined` → 1.0 — the engine never
+        // computes weights itself.
+        if (!node.parentEdges.some((e) => e.parent.runtimeStageId === parentId && e.kind === kind && e.key === key)) {
+            // Error isolation (review finding): a consumer weigher that throws
+            // must degrade to the default weight, never crash the slice — the
+            // same contract every other consumer callback in the library gets.
+            let weight = 1.0;
+            if (weigh) {
+                try {
+                    weight = weigh(node, parentNode, key, kind) ?? 1.0;
+                }
+                catch {
+                    /* weigher threw — keep 1.0, the slice stays usable */
+                }
+            }
+            node.parentEdges.push({ parent: parentNode, kind, key, weight });
+        }
+    }
     while (queue.length > 0) {
         const [node, commitIdx, depth] = queue.shift();
-        if (depth >= maxDepth)
+        if (depth >= maxDepth) {
+            // D4: only a node that still HAD something to expand counts as a cut
+            // (a leaf at the horizon truncates nothing).
+            if (getKeysRead(node.runtimeStageId).length > 0 || controlDeps?.(node.runtimeStageId) !== undefined) {
+                truncatedByDepth = true;
+            }
             continue;
+        }
+        // Data edges: for each key read, find who wrote it
         const keysRead = getKeysRead(node.runtimeStageId);
-        if (keysRead.length === 0)
-            continue;
-        // For each key read, find who wrote it
         for (const key of keysRead) {
             const writer = findWriter(key, commitIdx);
             if (!writer)
                 continue;
-            const writerId = writer.runtimeStageId;
-            // Check if we already have a node for this writer
-            let parentNode = nodeMap.get(writerId);
-            if (parentNode) {
-                // DAG merge: add as parent if not already linked
-                if (!node.parents.some((p) => p.runtimeStageId === writerId)) {
-                    node.parents.push(parentNode);
+            linkParent(node, writer, 'data', key, depth);
+        }
+        // Control edge (RFC-003 D3): link the governing decider, labeled by the
+        // decide() rule label when present. The decider node then expands
+        // normally through its own data reads (and its own control parent).
+        if (controlDeps) {
+            const dep = controlDeps(node.runtimeStageId);
+            if (dep) {
+                const deciderIdx = idxMap.get(dep.deciderId);
+                if (deciderIdx !== undefined) {
+                    linkParent(node, commitLog[deciderIdx], 'control', dep.label, depth);
                 }
-                continue;
             }
-            // New node — create and enqueue
-            if (visited >= maxNodes)
-                continue;
-            const writerIdx = idxMap.get(writerId);
-            if (writerIdx === undefined)
-                continue;
-            parentNode = {
-                runtimeStageId: writerId,
-                stageId: writer.stageId,
-                stageName: writer.stage,
-                keysWritten: writer.trace.map((t) => t.path),
-                linkedBy: key,
-                depth: depth + 1,
-                parents: [],
-            };
-            nodeMap.set(writerId, parentNode);
-            node.parents.push(parentNode);
-            visited++;
-            queue.push([parentNode, writerIdx, depth + 1]);
+        }
+    }
+    // RFC-003 D4 — truncation visibility on the root (absent when complete).
+    if (truncatedByDepth || truncatedByNodes) {
+        root.truncated = { byDepth: truncatedByDepth, byNodes: truncatedByNodes };
+        if (isDevMode()) {
+            // eslint-disable-next-line no-console
+            console.warn(`[footprint] causalChain('${startId}') truncated by ` +
+                `${[truncatedByDepth && `maxDepth (${maxDepth})`, truncatedByNodes && `maxNodes (${maxNodes})`]
+                    .filter(Boolean)
+                    .join(' + ')} — the slice is incomplete. Raise the limits or narrow keysRead.`);
         }
     }
     return root;
@@ -245,27 +322,60 @@ export function flattenCausalDAG(root) {
 /**
  * Format a causal DAG as human-readable indented text.
  * Shows the dependency chain with depth indentation and linked-by keys.
+ *
+ * RFC-003 D2: nodes that consumed untracked read paths render an extra
+ * `⚠ also consumed … — slice may be incomplete here` line, so a consumer
+ * (human or LLM) debugging from the slice is TOLD when it is incomplete.
+ *
+ * RFC-003 D3: control edges render as `← [control: <rule label>]`
+ * (label omitted when the decision carried none). Data rendering is
+ * byte-identical to the pre-D3 output — `← via <key>` from the node's
+ * discovery-time `linkedBy`.
+ *
+ * RFC-003 D4: edge weights from the `weigh` hook render as a suffix —
+ * `← via systemPrompt (0.18)` — only when ≠ 1.0, so unweighted output is
+ * unchanged. A truncated slice (root.truncated) appends a final
+ * `⚠ slice truncated …` line.
  */
 export function formatCausalChain(root) {
     const lines = [];
     const visited = new Set();
-    function walk(node, indent) {
+    const weightSuffix = (edge) => edge !== undefined && edge.weight !== 1 ? ` (${edge.weight})` : '';
+    function walk(node, indent, edgesFromChild) {
         if (visited.has(node.runtimeStageId)) {
             lines.push(`${'  '.repeat(indent)}↳ ${node.runtimeStageId} (see above)`);
             return;
         }
         visited.add(node.runtimeStageId);
-        const link = node.linkedBy ? ` ← via ${node.linkedBy}` : '';
+        const linkParts = [];
+        if (node.linkedBy) {
+            const dataEdge = edgesFromChild?.find((e) => e.kind === 'data');
+            linkParts.push(`via ${node.linkedBy}${weightSuffix(dataEdge)}`);
+        }
+        const controlEdge = edgesFromChild?.find((e) => e.kind === 'control');
+        if (controlEdge) {
+            linkParts.push(`[control${controlEdge.key ? `: ${controlEdge.key}` : ''}]${weightSuffix(controlEdge)}`);
+        }
+        const link = linkParts.length > 0 ? ` ← ${linkParts.join(' ← ')}` : '';
         const writes = node.keysWritten.length > 0 ? ` [wrote: ${node.keysWritten.join(', ')}]` : '';
         lines.push(`${'  '.repeat(indent)}${node.stageName} (${node.runtimeStageId})${link}${writes}`);
+        if (node.incompleteSources && node.incompleteSources.length > 0) {
+            lines.push(`${'  '.repeat(indent + 1)}⚠ also consumed ${node.incompleteSources.join('/')} — slice may be incomplete here`);
+        }
         for (const parent of node.parents) {
-            walk(parent, indent + 1);
+            walk(parent, indent + 1, node.parentEdges.filter((e) => e.parent === parent));
         }
     }
     walk(root, 0);
+    if (root.truncated) {
+        const causes = [root.truncated.byDepth && 'maxDepth reached', root.truncated.byNodes && 'maxNodes reached']
+            .filter(Boolean)
+            .join(', ');
+        lines.push(`⚠ slice truncated (${causes}) — older causes exist beyond this horizon`);
+    }
     return lines.join('\n');
 }
 // ── Exported for testing (internal) ────────────────────────────────────
 /** @internal Exposed for testing the strategy selection. */
 export const _REVERSE_INDEX_THRESHOLD = REVERSE_INDEX_THRESHOLD;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"backtrack.js","sourceRoot":"","sources":["../../../../src/lib/memory/backtrack.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * backtrack.ts — Backward causal chain analysis on the commit log.\n *\n * Implements **backward program slicing** (Weiser 1984, thin-slice variant):\n * given a starting execution step, walk backwards through read→write\n * dependencies to build the causal DAG that produced the data at that step.\n *\n * ## Algorithm\n *\n * BFS on the implicit dependency graph where edges run from reader → writer.\n *\n * 1. Locate startId in commitLog → root node\n * 2. Get keysRead for root via `getKeysRead` callback\n * 3. For each key read, find who last wrote it before this step → parent commit\n * 4. Create parent CausalNode, link to root.parents\n * 5. Enqueue parent. Repeat until queue empty or limits hit.\n *\n * Output is a **DAG** (not a linked list): a stage reading `creditScore` AND `dti`\n * from different writers has two parents.\n *\n * ## Staged Optimization\n *\n * Two writer-lookup strategies, chosen automatically by commit log size:\n *\n * | Strategy | When | Complexity per lookup |\n * |----------|------|----------------------|\n * | Linear scan | N ≤ 256 | O(N) — simple backward scan |\n * | Reverse index | N > 256 | O(K log N) — prebuilt key→[indices], binary search |\n *\n * The threshold (256) is chosen so the O(N) build cost of the reverse index\n * is amortized over the BFS traversal. Below 256, linear scan wins because\n * there's no index build overhead. The consumer never sees this — `causalChain()`\n * picks the right strategy internally (like a query optimizer choosing between\n * sequential scan vs index scan based on table size).\n *\n * ## Complexity\n *\n * - **Small logs (N ≤ 256):** O(V × K × N) total. V=visited, K=avg keys/node.\n * - **Large logs (N > 256):** O(N × U) index build + O(V × K × log N) lookups.\n *   U = unique keys. Amortized over all BFS hops.\n *\n * ## References\n *\n * - Weiser, M. (1984). \"Program Slicing.\" IEEE TSE.\n * - Sridharan, M. et al. (2007). \"Thin Slicing.\" PLDI.\n *\n * @example\n * ```typescript\n * import { causalChain, flattenCausalDAG, formatCausalChain } from 'footprintjs/trace';\n *\n * const dag = causalChain(commitLog, 'decide#2', (id) => recorder.getKeysRead(id));\n * const flat = flattenCausalDAG(dag);     // BFS-ordered flat list\n * console.log(formatCausalChain(dag));     // human-readable\n * ```\n */\n\nimport { findLastWriter } from './commitLogUtils.js';\nimport type { CommitBundle } from './types.js';\n\n// ── Types ──────────────────────────────────────────────────────────────\n\n/** A single node in the causal DAG. */\nexport interface CausalNode {\n  /** Unique execution step identifier. */\n  runtimeStageId: string;\n  /** Stable stage identifier. */\n  stageId: string;\n  /** Human-readable stage name. */\n  stageName: string;\n  /** Keys this stage wrote (from its CommitBundle.trace). */\n  keysWritten: string[];\n  /** The key whose read→write dependency linked this node to its child. Empty for the root. */\n  linkedBy: string;\n  /** BFS depth from the starting node (0 = start). */\n  depth: number;\n  /** Parent nodes — stages that wrote data this node read. DAG: multiple parents possible. */\n  parents: CausalNode[];\n}\n\n/** Options for causalChain(). */\nexport interface CausalChainOptions {\n  /** Maximum BFS depth (default: 20). Prevents runaway traversal. */\n  maxDepth?: number;\n  /** Maximum total nodes to visit (default: 100). Hard cap for safety. */\n  maxNodes?: number;\n}\n\n/**\n * Callback that returns the keys a stage read during execution.\n * The backtracker calls this for each visited node to determine\n * which read→write edges to follow.\n *\n * Implementors: QualityRecorder tracks keysRead per step,\n * or build a Map<runtimeStageId, string[]> from ScopeRecorder.onRead events.\n */\nexport type KeysReadLookup = (runtimeStageId: string) => string[];\n\n// ── Staged optimization: writer lookup strategies ──────────────────────\n\n/**\n * Threshold for switching from linear scan to reverse index.\n * Below this, O(N) scan is faster (no index build cost).\n * Above this, O(log N) binary search wins.\n */\nconst REVERSE_INDEX_THRESHOLD = 256;\n\n/**\n * Writer lookup function signature.\n * Returns the CommitBundle that last wrote `key` before position `beforeIdx`.\n */\ntype WriterLookup = (key: string, beforeIdx: number) => CommitBundle | undefined;\n\n/** Strategy 1: Linear scan — O(N) per lookup, zero setup cost. */\nfunction linearScanLookup(commitLog: CommitBundle[]): WriterLookup {\n  return (key, beforeIdx) => findLastWriter(commitLog, key, beforeIdx);\n}\n\n/**\n * Strategy 2: Reverse index — O(N×U) build, O(log N) per lookup.\n * Builds a Map<key, sortedIndices[]> where indices are commit positions\n * that wrote that key. Lookup uses binary search to find the last writer\n * before a given position.\n */\nfunction reverseIndexLookup(commitLog: CommitBundle[]): WriterLookup {\n  // Build: key → sorted array of commit indices that wrote this key\n  const index = new Map<string, number[]>();\n  for (let i = 0; i < commitLog.length; i++) {\n    for (const t of commitLog[i].trace) {\n      let arr = index.get(t.path);\n      if (!arr) {\n        arr = [];\n        index.set(t.path, arr);\n      }\n      arr.push(i); // already sorted (we iterate in order)\n    }\n  }\n\n  return (key: string, beforeIdx: number): CommitBundle | undefined => {\n    const indices = index.get(key);\n    if (!indices || indices.length === 0) return undefined;\n\n    // Binary search: find largest index < beforeIdx\n    let lo = 0;\n    let hi = indices.length - 1;\n    let result = -1;\n\n    while (lo <= hi) {\n      const mid = (lo + hi) >>> 1;\n      if (indices[mid] < beforeIdx) {\n        result = indices[mid];\n        lo = mid + 1;\n      } else {\n        hi = mid - 1;\n      }\n    }\n\n    return result >= 0 ? commitLog[result] : undefined;\n  };\n}\n\n/**\n * Staged optimization: pick the right writer-lookup strategy based on data size.\n *\n * Like a database query optimizer choosing between sequential scan and index scan:\n *\n * - **Small log (≤ 256):** Linear scan wins. Zero setup cost, good cache locality.\n *   The overhead of building a reverse index isn't worth it for short logs.\n *\n * - **Large log (> 256):** Reverse index wins. O(N×U) upfront build cost is amortized\n *   across all BFS hops. Each lookup becomes O(log N) via binary search instead of O(N).\n *   For an agent loop with 500 iterations and 5 keys per hop, this is 500×5×log(500)≈22K ops\n *   vs 500×5×500=1.25M ops with linear scan.\n *\n * The caller never sees this — `causalChain()` picks automatically.\n */\nfunction createWriterLookup(commitLog: CommitBundle[]): WriterLookup {\n  if (commitLog.length <= REVERSE_INDEX_THRESHOLD) {\n    return linearScanLookup(commitLog);\n  }\n  return reverseIndexLookup(commitLog);\n}\n\n// ── Core algorithm ─────────────────────────────────────────────────────\n\n/**\n * Build the causal DAG rooted at `startId` by walking backwards\n * through read→write dependencies in the commit log.\n *\n * Automatically selects the optimal writer lookup strategy:\n * - Linear scan for small logs (≤ 256 commits)\n * - Reverse index with binary search for large logs (> 256 commits)\n *\n * Produces a DAG (not a tree): if two children both read from the same\n * parent, the parent node is shared (deduped by runtimeStageId).\n *\n * @param commitLog   Ordered commit bundles from executor.getSnapshot().commitLog\n * @param startId     runtimeStageId to start backtracking from\n * @param getKeysRead Callback returning keys read by a given execution step\n * @param options     Depth and node limits\n * @returns Root CausalNode with .parents forming the DAG, or undefined if startId not found\n */\nexport function causalChain(\n  commitLog: CommitBundle[],\n  startId: string,\n  getKeysRead: KeysReadLookup,\n  options?: CausalChainOptions,\n): CausalNode | undefined {\n  const maxDepth = options?.maxDepth ?? 20;\n  const maxNodes = options?.maxNodes ?? 100;\n\n  // Build position index: runtimeStageId → array position (O(n) once)\n  const idxMap = new Map<string, number>();\n  for (let i = 0; i < commitLog.length; i++) {\n    idxMap.set(commitLog[i].runtimeStageId, i);\n  }\n\n  const startIdx = idxMap.get(startId);\n  if (startIdx === undefined) return undefined;\n\n  const startCommit = commitLog[startIdx];\n\n  // Pick writer lookup strategy based on log size\n  const findWriter = createWriterLookup(commitLog);\n\n  // Node dedup map: runtimeStageId → CausalNode (ensures DAG, not tree)\n  const nodeMap = new Map<string, CausalNode>();\n\n  const root: CausalNode = {\n    runtimeStageId: startId,\n    stageId: startCommit.stageId,\n    stageName: startCommit.stage,\n    keysWritten: startCommit.trace.map((t) => t.path),\n    linkedBy: '',\n    depth: 0,\n    parents: [],\n  };\n  nodeMap.set(startId, root);\n\n  // BFS queue: [node, commitIdx, depth]\n  const queue: Array<[CausalNode, number, number]> = [[root, startIdx, 0]];\n  let visited = 1;\n\n  while (queue.length > 0) {\n    const [node, commitIdx, depth] = queue.shift()!;\n\n    if (depth >= maxDepth) continue;\n\n    const keysRead = getKeysRead(node.runtimeStageId);\n    if (keysRead.length === 0) continue;\n\n    // For each key read, find who wrote it\n    for (const key of keysRead) {\n      const writer = findWriter(key, commitIdx);\n      if (!writer) continue;\n\n      const writerId = writer.runtimeStageId;\n\n      // Check if we already have a node for this writer\n      let parentNode = nodeMap.get(writerId);\n      if (parentNode) {\n        // DAG merge: add as parent if not already linked\n        if (!node.parents.some((p) => p.runtimeStageId === writerId)) {\n          node.parents.push(parentNode);\n        }\n        continue;\n      }\n\n      // New node — create and enqueue\n      if (visited >= maxNodes) continue;\n\n      const writerIdx = idxMap.get(writerId);\n      if (writerIdx === undefined) continue;\n\n      parentNode = {\n        runtimeStageId: writerId,\n        stageId: writer.stageId,\n        stageName: writer.stage,\n        keysWritten: writer.trace.map((t) => t.path),\n        linkedBy: key,\n        depth: depth + 1,\n        parents: [],\n      };\n      nodeMap.set(writerId, parentNode);\n      node.parents.push(parentNode);\n      visited++;\n\n      queue.push([parentNode, writerIdx, depth + 1]);\n    }\n  }\n\n  return root;\n}\n\n// ── Utilities ──────────────────────────────────────────────────────────\n\n/**\n * Flatten the causal DAG into a BFS-ordered list of nodes.\n * Each node appears exactly once (first occurrence by BFS order).\n * Useful for linear display or iteration.\n */\nexport function flattenCausalDAG(root: CausalNode): CausalNode[] {\n  const result: CausalNode[] = [];\n  const visited = new Set<string>();\n  const queue: CausalNode[] = [root];\n\n  while (queue.length > 0) {\n    const node = queue.shift()!;\n    if (visited.has(node.runtimeStageId)) continue;\n    visited.add(node.runtimeStageId);\n    result.push(node);\n\n    for (const parent of node.parents) {\n      if (!visited.has(parent.runtimeStageId)) {\n        queue.push(parent);\n      }\n    }\n  }\n\n  return result;\n}\n\n/**\n * Format a causal DAG as human-readable indented text.\n * Shows the dependency chain with depth indentation and linked-by keys.\n */\nexport function formatCausalChain(root: CausalNode): string {\n  const lines: string[] = [];\n  const visited = new Set<string>();\n\n  function walk(node: CausalNode, indent: number): void {\n    if (visited.has(node.runtimeStageId)) {\n      lines.push(`${'  '.repeat(indent)}↳ ${node.runtimeStageId} (see above)`);\n      return;\n    }\n    visited.add(node.runtimeStageId);\n\n    const link = node.linkedBy ? ` ← via ${node.linkedBy}` : '';\n    const writes = node.keysWritten.length > 0 ? ` [wrote: ${node.keysWritten.join(', ')}]` : '';\n    lines.push(`${'  '.repeat(indent)}${node.stageName} (${node.runtimeStageId})${link}${writes}`);\n\n    for (const parent of node.parents) {\n      walk(parent, indent + 1);\n    }\n  }\n\n  walk(root, 0);\n  return lines.join('\\n');\n}\n\n// ── Exported for testing (internal) ────────────────────────────────────\n\n/** @internal Exposed for testing the strategy selection. */\nexport const _REVERSE_INDEX_THRESHOLD = REVERSE_INDEX_THRESHOLD;\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"backtrack.js","sourceRoot":"","sources":["../../../../src/lib/memory/backtrack.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * backtrack.ts — Backward causal chain analysis on the commit log.\n *\n * Implements **backward program slicing** (Weiser 1984, thin-slice variant):\n * given a starting execution step, walk backwards through read→write\n * dependencies to build the causal DAG that produced the data at that step.\n *\n * ## Algorithm\n *\n * BFS on the implicit dependency graph where edges run from reader → writer.\n *\n * 1. Locate startId in commitLog → root node\n * 2. Get keysRead for root via `getKeysRead` callback\n * 3. For each key read, find who last wrote it before this step → parent commit\n * 4. Create parent CausalNode, link to root.parents\n * 5. Enqueue parent. Repeat until queue empty or limits hit.\n *\n * Output is a **DAG** (not a linked list): a stage reading `creditScore` AND `dti`\n * from different writers has two parents.\n *\n * ## Staged Optimization\n *\n * Two writer-lookup strategies, chosen automatically by commit log size:\n *\n * | Strategy | When | Complexity per lookup |\n * |----------|------|----------------------|\n * | Linear scan | N ≤ 256 | O(N) — simple backward scan |\n * | Reverse index | N > 256 | O(K log N) — prebuilt key→[indices], binary search |\n *\n * The threshold (256) is chosen so the O(N) build cost of the reverse index\n * is amortized over the BFS traversal. Below 256, linear scan wins because\n * there's no index build overhead. The consumer never sees this — `causalChain()`\n * picks the right strategy internally (like a query optimizer choosing between\n * sequential scan vs index scan based on table size).\n *\n * ## Complexity\n *\n * - **Small logs (N ≤ 256):** O(V × K × N) total. V=visited, K=avg keys/node.\n * - **Large logs (N > 256):** O(N × U) index build + O(V × K × log N) lookups.\n *   U = unique keys. Amortized over all BFS hops.\n *\n * ## References\n *\n * - Weiser, M. (1984). \"Program Slicing.\" IEEE TSE.\n * - Sridharan, M. et al. (2007). \"Thin Slicing.\" PLDI.\n *\n * @example\n * ```typescript\n * import { causalChain, flattenCausalDAG, formatCausalChain } from 'footprintjs/trace';\n *\n * const dag = causalChain(commitLog, 'decide#2', (id) => recorder.getKeysRead(id));\n * const flat = flattenCausalDAG(dag);     // BFS-ordered flat list\n * console.log(formatCausalChain(dag));     // human-readable\n * ```\n */\n\nimport { isDevMode } from '../scope/detectCircular.js';\nimport { findLastWriter } from './commitLogUtils.js';\nimport type { CommitBundle, UntrackedSource } from './types.js';\n\n// ── Types ──────────────────────────────────────────────────────────────\n\n/** A single node in the causal DAG. */\nexport interface CausalNode {\n  /** Unique execution step identifier. */\n  runtimeStageId: string;\n  /** Stable stage identifier. */\n  stageId: string;\n  /** Human-readable stage name. */\n  stageName: string;\n  /** Keys this stage wrote (from its CommitBundle.trace). */\n  keysWritten: string[];\n  /** The key whose read→write dependency linked this node to its child. Empty for the root. */\n  linkedBy: string;\n  /** BFS depth from the starting node (0 = start). */\n  depth: number;\n  /**\n   * Parent nodes — stages this node depends on. DAG: multiple parents\n   * possible. KEPT for compatibility; with the `controlDeps` option\n   * (RFC-003 D3) governing deciders appear here too. For typed/keyed/\n   * weighted detail use {@link parentEdges}.\n   */\n  parents: CausalNode[];\n  /**\n   * RFC-003 D3 — one edge per dependency LINK (not per parent): a node\n   * reading two keys from the same writer has ONE entry in {@link parents}\n   * but TWO `'data'` edges here. Control dependencies (via the\n   * `controlDeps` option) add a `'control'` edge to the governing decider.\n   */\n  parentEdges: CausalEdge[];\n  /**\n   * RFC-003 D2 honesty marker — stamped from the stage's\n   * `CommitBundle.untrackedSources`. Present when this stage ALSO consumed\n   * untracked read paths (`args` / `env` / unshadowed `silent` reads): the\n   * backward slice through this node may be incomplete, because those reads\n   * produce no read→write edge to follow. `formatCausalChain` renders this\n   * as a `⚠ … slice may be incomplete here` line. Absent when the stage's\n   * reads were fully tracked.\n   */\n  incompleteSources?: ReadonlyArray<UntrackedSource>;\n  /**\n   * RFC-003 D4 truncation visibility — set on the ROOT node only, and only\n   * when a limit actually cut the slice: `byDepth` when a node at the\n   * `maxDepth` horizon still had edges to expand, `byNodes` when the\n   * `maxNodes` budget blocked creating a discovered parent. Absent when the\n   * slice is complete. Dev mode (`enableDevMode()`) also warns on\n   * truncation, and `formatCausalChain` appends a `⚠ slice truncated …`\n   * line — a consumer must never mistake a truncated slice for a full one.\n   */\n  truncated?: { byDepth: boolean; byNodes: boolean };\n}\n\n/**\n * RFC-003 D3 — a typed dependency edge from a child node to one parent.\n *\n * - `kind: 'data'`    — read→write dependency; `key` is the state key.\n * - `kind: 'control'` — the parent is the decider/selector whose decision\n *   allowed the child to run; `key` is the decide() rule label when present.\n *\n * `weight` defaults to 1.0; the `weigh` hook (RFC-003 D4) can override it.\n * The engine itself NEVER computes weights — semantics belong to the\n * consumer-injected weigher.\n */\nexport interface CausalEdge {\n  parent: CausalNode;\n  kind: 'data' | 'control';\n  key?: string;\n  weight: number;\n}\n\n/**\n * RFC-003 D3 — a control dependency resolved for one execution step:\n * which decider/selector execution allowed this stage to run.\n */\nexport interface ControlDependency {\n  /** runtimeStageId of the governing decider/selector execution step. */\n  deciderId: string;\n  /** The decide() rule label for the chosen branch, when present. */\n  label?: string;\n}\n\n/**\n * RFC-003 D3 — callback resolving the governing decider for an execution\n * step. Return `undefined` when the step is not control-dependent on any\n * recorded decision. Build one with `controlDepRecorder()` from\n * `footprintjs/trace`, or supply your own.\n */\nexport type ControlDepLookup = (runtimeStageId: string) => ControlDependency | undefined;\n\n/**\n * RFC-003 D4 — consumer-injected edge weigher. Called once per created\n * edge; return a weight, or `undefined` to keep the default 1.0. The\n * ENGINE never computes weights (zero new dependencies — semantics like\n * embedding similarity or FDL influence belong to downstream libraries,\n * the same plug-in pattern as `NarrativeFormatter`). Weights render in\n * `formatCausalChain` as `← via systemPrompt (0.18)`.\n */\nexport type EdgeWeigher = (\n  child: CausalNode,\n  parent: CausalNode,\n  key: string | undefined,\n  kind: 'data' | 'control',\n) => number | undefined;\n\n/** Options for causalChain(). */\nexport interface CausalChainOptions {\n  /** Maximum BFS depth (default: 20). Prevents runaway traversal. */\n  maxDepth?: number;\n  /** Maximum total nodes to visit (default: 100). Hard cap for safety. */\n  maxNodes?: number;\n  /**\n   * RFC-003 D3 — control-dependence lookup. When provided, expanding a node\n   * ALSO links a `'control'` edge to its governing decider (labeled by the\n   * decide() rule label when present); the decider node then expands\n   * normally through its own data reads, so chains like\n   * `status ← [control] ClassifyRisk ← [data: creditScore] PullBureau`\n   * resolve end-to-end. Without this option behavior is unchanged.\n   */\n  controlDeps?: ControlDepLookup;\n  /**\n   * RFC-003 D4 — edge weigher. Stamps `CausalEdge.weight` at edge creation;\n   * `undefined` (or no weigher) → 1.0. See {@link EdgeWeigher}.\n   */\n  weigh?: EdgeWeigher;\n}\n\n/**\n * Callback that returns the keys a stage read during execution.\n * The backtracker calls this for each visited node to determine\n * which read→write edges to follow.\n *\n * Implementors: QualityRecorder tracks keysRead per step,\n * or build a Map<runtimeStageId, string[]> from ScopeRecorder.onRead events.\n */\nexport type KeysReadLookup = (runtimeStageId: string) => string[];\n\n// ── Staged optimization: writer lookup strategies ──────────────────────\n\n/**\n * Threshold for switching from linear scan to reverse index.\n * Below this, O(N) scan is faster (no index build cost).\n * Above this, O(log N) binary search wins.\n */\nconst REVERSE_INDEX_THRESHOLD = 256;\n\n/**\n * Writer lookup function signature.\n * Returns the CommitBundle that last wrote `key` before position `beforeIdx`.\n */\ntype WriterLookup = (key: string, beforeIdx: number) => CommitBundle | undefined;\n\n/** Strategy 1: Linear scan — O(N) per lookup, zero setup cost. */\nfunction linearScanLookup(commitLog: CommitBundle[]): WriterLookup {\n  return (key, beforeIdx) => findLastWriter(commitLog, key, beforeIdx);\n}\n\n/**\n * Strategy 2: Reverse index — O(N×U) build, O(log N) per lookup.\n * Builds a Map<key, sortedIndices[]> where indices are commit positions\n * that wrote that key. Lookup uses binary search to find the last writer\n * before a given position.\n */\nfunction reverseIndexLookup(commitLog: CommitBundle[]): WriterLookup {\n  // Build: key → sorted array of commit indices that wrote this key\n  const index = new Map<string, number[]>();\n  for (let i = 0; i < commitLog.length; i++) {\n    for (const t of commitLog[i].trace) {\n      let arr = index.get(t.path);\n      if (!arr) {\n        arr = [];\n        index.set(t.path, arr);\n      }\n      arr.push(i); // already sorted (we iterate in order)\n    }\n  }\n\n  return (key: string, beforeIdx: number): CommitBundle | undefined => {\n    const indices = index.get(key);\n    if (!indices || indices.length === 0) return undefined;\n\n    // Binary search: find largest index < beforeIdx\n    let lo = 0;\n    let hi = indices.length - 1;\n    let result = -1;\n\n    while (lo <= hi) {\n      const mid = (lo + hi) >>> 1;\n      if (indices[mid] < beforeIdx) {\n        result = indices[mid];\n        lo = mid + 1;\n      } else {\n        hi = mid - 1;\n      }\n    }\n\n    return result >= 0 ? commitLog[result] : undefined;\n  };\n}\n\n/**\n * Staged optimization: pick the right writer-lookup strategy based on data size.\n *\n * Like a database query optimizer choosing between sequential scan and index scan:\n *\n * - **Small log (≤ 256):** Linear scan wins. Zero setup cost, good cache locality.\n *   The overhead of building a reverse index isn't worth it for short logs.\n *\n * - **Large log (> 256):** Reverse index wins. O(N×U) upfront build cost is amortized\n *   across all BFS hops. Each lookup becomes O(log N) via binary search instead of O(N).\n *   For an agent loop with 500 iterations and 5 keys per hop, this is 500×5×log(500)≈22K ops\n *   vs 500×5×500=1.25M ops with linear scan.\n *\n * The caller never sees this — `causalChain()` picks automatically.\n */\nfunction createWriterLookup(commitLog: CommitBundle[]): WriterLookup {\n  if (commitLog.length <= REVERSE_INDEX_THRESHOLD) {\n    return linearScanLookup(commitLog);\n  }\n  return reverseIndexLookup(commitLog);\n}\n\n// ── Core algorithm ─────────────────────────────────────────────────────\n\n/**\n * RFC-003 D2: the `incompleteSources` node fragment for a commit — `{}`\n * when the stage consumed no untracked read paths, keeping the field\n * ABSENT (not empty-array-valued) for fully-tracked stages.\n */\nfunction incompleteSourcesFragment(commit: CommitBundle): { incompleteSources?: ReadonlyArray<UntrackedSource> } {\n  if (!commit.untrackedSources || commit.untrackedSources.length === 0) return {};\n  return { incompleteSources: commit.untrackedSources };\n}\n\n/**\n * Build the causal DAG rooted at `startId` by walking backwards\n * through read→write dependencies in the commit log.\n *\n * Automatically selects the optimal writer lookup strategy:\n * - Linear scan for small logs (≤ 256 commits)\n * - Reverse index with binary search for large logs (> 256 commits)\n *\n * Produces a DAG (not a tree): if two children both read from the same\n * parent, the parent node is shared (deduped by runtimeStageId).\n *\n * @param commitLog   Ordered commit bundles from executor.getSnapshot().commitLog\n * @param startId     runtimeStageId to start backtracking from\n * @param getKeysRead Callback returning keys read by a given execution step\n * @param options     Depth and node limits\n * @returns Root CausalNode with .parents forming the DAG, or undefined if startId not found\n */\nexport function causalChain(\n  commitLog: CommitBundle[],\n  startId: string,\n  getKeysRead: KeysReadLookup,\n  options?: CausalChainOptions,\n): CausalNode | undefined {\n  const maxDepth = options?.maxDepth ?? 20;\n  const maxNodes = options?.maxNodes ?? 100;\n  const controlDeps = options?.controlDeps;\n  const weigh = options?.weigh;\n\n  // RFC-003 D4 — truncation visibility. Set only when a limit actually\n  // cuts the slice; surfaced on the root as `truncated` so a consumer can\n  // never mistake a truncated slice for a complete one.\n  let truncatedByDepth = false;\n  let truncatedByNodes = false;\n\n  // Build position index: runtimeStageId → array position (O(n) once)\n  const idxMap = new Map<string, number>();\n  for (let i = 0; i < commitLog.length; i++) {\n    idxMap.set(commitLog[i].runtimeStageId, i);\n  }\n\n  const startIdx = idxMap.get(startId);\n  if (startIdx === undefined) return undefined;\n\n  const startCommit = commitLog[startIdx];\n\n  // Pick writer lookup strategy based on log size\n  const findWriter = createWriterLookup(commitLog);\n\n  // Node dedup map: runtimeStageId → CausalNode (ensures DAG, not tree)\n  const nodeMap = new Map<string, CausalNode>();\n\n  const root: CausalNode = {\n    runtimeStageId: startId,\n    stageId: startCommit.stageId,\n    stageName: startCommit.stage,\n    keysWritten: startCommit.trace.map((t) => t.path),\n    linkedBy: '',\n    depth: 0,\n    parents: [],\n    parentEdges: [],\n    ...incompleteSourcesFragment(startCommit),\n  };\n  nodeMap.set(startId, root);\n\n  // BFS queue: [node, commitIdx, depth]\n  const queue: Array<[CausalNode, number, number]> = [[root, startIdx, 0]];\n  let visited = 1;\n\n  /**\n   * Link `node → parent` (creating + enqueueing the parent when new).\n   * Shared by data-edge expansion (read→write) and control-edge expansion\n   * (D3). One CausalEdge per distinct (parent, kind, key) link; `parents`\n   * keeps its historical one-entry-per-parent dedup.\n   */\n  function linkParent(\n    node: CausalNode,\n    parentCommit: CommitBundle,\n    kind: 'data' | 'control',\n    key: string | undefined,\n    depth: number,\n  ): void {\n    const parentId = parentCommit.runtimeStageId;\n\n    let parentNode = nodeMap.get(parentId);\n    if (!parentNode) {\n      // New node — create and enqueue (respecting the node budget)\n      if (visited >= maxNodes) {\n        truncatedByNodes = true; // D4: a discovered parent was dropped\n        return;\n      }\n\n      const parentIdx = idxMap.get(parentId);\n      if (parentIdx === undefined) return;\n\n      parentNode = {\n        runtimeStageId: parentId,\n        stageId: parentCommit.stageId,\n        stageName: parentCommit.stage,\n        keysWritten: parentCommit.trace.map((t) => t.path),\n        // linkedBy stays a DATA-key concept (back-compat) — control-linked\n        // nodes carry their label on the edge instead.\n        linkedBy: kind === 'data' ? key ?? '' : '',\n        depth: depth + 1,\n        parents: [],\n        parentEdges: [],\n        ...incompleteSourcesFragment(parentCommit),\n      };\n      nodeMap.set(parentId, parentNode);\n      visited++;\n      queue.push([parentNode, parentIdx, depth + 1]);\n    }\n\n    // DAG merge: one parents[] entry per distinct parent (historical shape)\n    if (!node.parents.some((p) => p.runtimeStageId === parentId)) {\n      node.parents.push(parentNode);\n    }\n    // One edge per distinct (parent, kind, key) link. The weigher (D4)\n    // stamps the weight at creation; `undefined` → 1.0 — the engine never\n    // computes weights itself.\n    if (!node.parentEdges.some((e) => e.parent.runtimeStageId === parentId && e.kind === kind && e.key === key)) {\n      // Error isolation (review finding): a consumer weigher that throws\n      // must degrade to the default weight, never crash the slice — the\n      // same contract every other consumer callback in the library gets.\n      let weight = 1.0;\n      if (weigh) {\n        try {\n          weight = weigh(node, parentNode, key, kind) ?? 1.0;\n        } catch {\n          /* weigher threw — keep 1.0, the slice stays usable */\n        }\n      }\n      node.parentEdges.push({ parent: parentNode, kind, key, weight });\n    }\n  }\n\n  while (queue.length > 0) {\n    const [node, commitIdx, depth] = queue.shift()!;\n\n    if (depth >= maxDepth) {\n      // D4: only a node that still HAD something to expand counts as a cut\n      // (a leaf at the horizon truncates nothing).\n      if (getKeysRead(node.runtimeStageId).length > 0 || controlDeps?.(node.runtimeStageId) !== undefined) {\n        truncatedByDepth = true;\n      }\n      continue;\n    }\n\n    // Data edges: for each key read, find who wrote it\n    const keysRead = getKeysRead(node.runtimeStageId);\n    for (const key of keysRead) {\n      const writer = findWriter(key, commitIdx);\n      if (!writer) continue;\n      linkParent(node, writer, 'data', key, depth);\n    }\n\n    // Control edge (RFC-003 D3): link the governing decider, labeled by the\n    // decide() rule label when present. The decider node then expands\n    // normally through its own data reads (and its own control parent).\n    if (controlDeps) {\n      const dep = controlDeps(node.runtimeStageId);\n      if (dep) {\n        const deciderIdx = idxMap.get(dep.deciderId);\n        if (deciderIdx !== undefined) {\n          linkParent(node, commitLog[deciderIdx], 'control', dep.label, depth);\n        }\n      }\n    }\n  }\n\n  // RFC-003 D4 — truncation visibility on the root (absent when complete).\n  if (truncatedByDepth || truncatedByNodes) {\n    root.truncated = { byDepth: truncatedByDepth, byNodes: truncatedByNodes };\n    if (isDevMode()) {\n      // eslint-disable-next-line no-console\n      console.warn(\n        `[footprint] causalChain('${startId}') truncated by ` +\n          `${[truncatedByDepth && `maxDepth (${maxDepth})`, truncatedByNodes && `maxNodes (${maxNodes})`]\n            .filter(Boolean)\n            .join(' + ')} — the slice is incomplete. Raise the limits or narrow keysRead.`,\n      );\n    }\n  }\n\n  return root;\n}\n\n// ── Utilities ──────────────────────────────────────────────────────────\n\n/**\n * Flatten the causal DAG into a BFS-ordered list of nodes.\n * Each node appears exactly once (first occurrence by BFS order).\n * Useful for linear display or iteration.\n */\nexport function flattenCausalDAG(root: CausalNode): CausalNode[] {\n  const result: CausalNode[] = [];\n  const visited = new Set<string>();\n  const queue: CausalNode[] = [root];\n\n  while (queue.length > 0) {\n    const node = queue.shift()!;\n    if (visited.has(node.runtimeStageId)) continue;\n    visited.add(node.runtimeStageId);\n    result.push(node);\n\n    for (const parent of node.parents) {\n      if (!visited.has(parent.runtimeStageId)) {\n        queue.push(parent);\n      }\n    }\n  }\n\n  return result;\n}\n\n/**\n * Format a causal DAG as human-readable indented text.\n * Shows the dependency chain with depth indentation and linked-by keys.\n *\n * RFC-003 D2: nodes that consumed untracked read paths render an extra\n * `⚠ also consumed … — slice may be incomplete here` line, so a consumer\n * (human or LLM) debugging from the slice is TOLD when it is incomplete.\n *\n * RFC-003 D3: control edges render as `← [control: <rule label>]`\n * (label omitted when the decision carried none). Data rendering is\n * byte-identical to the pre-D3 output — `← via <key>` from the node's\n * discovery-time `linkedBy`.\n *\n * RFC-003 D4: edge weights from the `weigh` hook render as a suffix —\n * `← via systemPrompt (0.18)` — only when ≠ 1.0, so unweighted output is\n * unchanged. A truncated slice (root.truncated) appends a final\n * `⚠ slice truncated …` line.\n */\nexport function formatCausalChain(root: CausalNode): string {\n  const lines: string[] = [];\n  const visited = new Set<string>();\n\n  const weightSuffix = (edge: CausalEdge | undefined): string =>\n    edge !== undefined && edge.weight !== 1 ? ` (${edge.weight})` : '';\n\n  function walk(node: CausalNode, indent: number, edgesFromChild?: CausalEdge[]): void {\n    if (visited.has(node.runtimeStageId)) {\n      lines.push(`${'  '.repeat(indent)}↳ ${node.runtimeStageId} (see above)`);\n      return;\n    }\n    visited.add(node.runtimeStageId);\n\n    const linkParts: string[] = [];\n    if (node.linkedBy) {\n      const dataEdge = edgesFromChild?.find((e) => e.kind === 'data');\n      linkParts.push(`via ${node.linkedBy}${weightSuffix(dataEdge)}`);\n    }\n    const controlEdge = edgesFromChild?.find((e) => e.kind === 'control');\n    if (controlEdge) {\n      linkParts.push(`[control${controlEdge.key ? `: ${controlEdge.key}` : ''}]${weightSuffix(controlEdge)}`);\n    }\n    const link = linkParts.length > 0 ? ` ← ${linkParts.join(' ← ')}` : '';\n\n    const writes = node.keysWritten.length > 0 ? ` [wrote: ${node.keysWritten.join(', ')}]` : '';\n    lines.push(`${'  '.repeat(indent)}${node.stageName} (${node.runtimeStageId})${link}${writes}`);\n\n    if (node.incompleteSources && node.incompleteSources.length > 0) {\n      lines.push(\n        `${'  '.repeat(indent + 1)}⚠ also consumed ${node.incompleteSources.join('/')} — slice may be incomplete here`,\n      );\n    }\n\n    for (const parent of node.parents) {\n      walk(\n        parent,\n        indent + 1,\n        node.parentEdges.filter((e) => e.parent === parent),\n      );\n    }\n  }\n\n  walk(root, 0);\n\n  if (root.truncated) {\n    const causes = [root.truncated.byDepth && 'maxDepth reached', root.truncated.byNodes && 'maxNodes reached']\n      .filter(Boolean)\n      .join(', ');\n    lines.push(`⚠ slice truncated (${causes}) — older causes exist beyond this horizon`);\n  }\n\n  return lines.join('\\n');\n}\n\n// ── Exported for testing (internal) ────────────────────────────────────\n\n/** @internal Exposed for testing the strategy selection. */\nexport const _REVERSE_INDEX_THRESHOLD = REVERSE_INDEX_THRESHOLD;\n"]}

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

@@ -14,4 +14,4 @@ export { TransactionBuffer } from './TransactionBuffer.js';
 export { READ_PREVIEW_LENGTH, SUMMARY_PREVIEW_LENGTH } from './types.js';
 // Utilities
 export { applySmartMerge, deepSmartMerge, DELIM, getNestedValue, getRunAndGlobalPaths, normalisePath, redactPatch, setNestedValue, updateNestedValue, updateValue, } from './utils.js';
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -8,4 +8,4 @@
  * implementation).
  */
 export { READ_PREVIEW_LENGTH, SUMMARY_PREVIEW_LENGTH } from '../capture/summarize.js';
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../src/lib/memory/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAgFH,OAAO,EAAE,mBAAmB,EAAE,sBAAsB,EAAE,MAAM,yBAAyB,CAAC","sourcesContent":["/**\n * types.ts — Core type definitions for the memory library\n *\n * Zero dependencies on old code or other libraries in this package, with one\n * deliberate exception: `capture/` — the standalone leaf module holding the\n * shared retention-policy family and summary-marker builders (extracted from\n * here in #13c-A so the read and write dials, and later RFC-001, share one\n * implementation).\n */\n\nimport type { RetentionPolicy } from '../capture/policies.js';\n\n// ── Patch & Trace ──────────────────────────────────────────────────────────\n\n/** A flat key-value bag representing a state patch (overwrite or merge). */\nexport interface MemoryPatch {\n  [key: string]: any;\n}\n\n/** A single entry in the chronological operation trace. */\nexport interface TraceEntry {\n  /** Canonical path string (segments joined by DELIM). */\n  path: string;\n  /**\n   * - `'set'`    — hard overwrite; `overwrite[path]` holds the full final value.\n   * - `'merge'`  — deep union merge; `updates[path]` holds the accumulated delta.\n   * - `'append'` — (#13c-B, produced only under {@link CommitValuesMode}\n   *   `'delta'`) the path's final value is its base value plus a tail of new\n   *   trailing elements; `overwrite[path]` holds ONLY the tail. Replay\n   *   reconstructs by concatenation. NOT idempotent — delta-mode bundles\n   *   carry exactly one trace entry per surviving path.\n   * - `'delete'` — (#13c-B, produced only under `'delta'`; absorbs backlog\n   *   B8) the key was explicitly removed via `deleteValue()`. Replay removes\n   *   the key. `overwrite[path]` still ENUMERATES the path (value\n   *   `undefined`) so key-set consumers keep seeing the changed key.\n   *\n   * `overwrite` values are therefore VERB-QUALIFIED: consumers that read\n   * `bundle.overwrite[key]` as \"the full value written\" must use\n   * `commitValueAt(commitLog, idx, key)` (from `footprintjs/trace`) when the\n   * log may contain delta-mode bundles.\n   */\n  verb: 'set' | 'merge' | 'append' | 'delete';\n}\n\n/** The atomic bundle produced by TransactionBuffer.commit(). */\nexport interface CommitBundle {\n  /** Auto-assigned step index (set by EventLog.record). */\n  idx?: number;\n  /** Human-readable stage name. */\n  stage: string;\n  /** Stable stage identifier (matches spec node id). */\n  stageId: string;\n  /** Unique per-execution-step identifier. Format: [subflowPath/]stageId#executionIndex */\n  runtimeStageId: string;\n  /** Chronological write log for deterministic replay. */\n  trace: TraceEntry[];\n  /** Paths that should be redacted in UI (sensitive data). */\n  redactedPaths: string[];\n  /** Hard overwrite patches. */\n  overwrite: MemoryPatch;\n  /** Deep merge patches. */\n  updates: MemoryPatch;\n}\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 write dial and, later, RFC-001's deferred-observer capture tier).\n// Re-exported here so every pre-extraction import path keeps working.\n\nexport type { RetentionPolicy } from '../capture/policies.js';\nexport type { ReadSummaryMarker, WriteSummaryMarker } from '../capture/summarize.js';\nexport { READ_PREVIEW_LENGTH, SUMMARY_PREVIEW_LENGTH } from '../capture/summarize.js';\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/**\n * Policy for how commit-bundle VALUES are encoded into the commit log\n * (#13c-B) — completes the `readTracking`/`writeTracking` dial family.\n * Unlike those two (which gate lossy snapshot bookkeeping), this dial is\n * **lossless in both modes** — it changes the commit log's *encoding*,\n * never its *information*; any step's full state stays exactly\n * reconstructable by replay.\n *\n * - `'full'` (default) — every surviving `set` path stores the full final\n *   value, one trace entry per operation. Byte-identical to the historical\n *   behavior.\n * - `'delta'` — two changes, both replay-covered by `applySmartMerge`:\n *   1. **`append` detection**: when a path's net change is \"the base array\n *      plus new trailing elements\" (strict prefix), the bundle records ONLY\n *      the tail under a `verb: 'append'` trace entry — the growing-history\n *      commit log becomes linear in tail size instead of O(N²) retained.\n *      A real `verb: 'delete'` entry replaces the `set: undefined` flattening\n *      for `deleteValue()` (closes the documented MemoryPatch limitation).\n *   2. **One trace entry per surviving path** (append is not idempotent on\n *      replay): the verb is resolved from the path's base→final relationship\n *      and op mix; entries are ordered by each path's LAST touch.\n *\n * Honest cost note: append detection is NEW wall work — an O(|base|)\n * structural prefix compare per array-set path per commit (today's\n * `deepEqual` fast-fails on length in O(1) for a grown array). On a hit the\n * commit gets cheaper in both wall and heap (the O(|final|) clone shrinks to\n * O(|tail|)); on a miss it pays compare + full clone. `'full'` pays zero —\n * the detection branch is mode-gated.\n *\n * Set via `new FlowChartExecutor(chart, { commitValues })` or\n * `executor.setCommitValues(mode)` (before `run()`). The active mode is\n * surfaced as the snapshot discriminant `RuntimeSnapshot.commitValues`.\n */\nexport type CommitValuesMode = 'full' | 'delta';\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  next?: StageSnapshot;\n  children?: StageSnapshot[];\n};\n\n// ── Scope Factory ──────────────────────────────────────────────────────────\n\n/** Forward-declared so StageContext can accept it without importing scope/. */\nexport type ScopeFactory<TScope> = (core: StageContext, stageName: string, readOnlyContext?: unknown) => TScope;\n\n// ── StageContext (forward reference for ScopeFactory) ──────────────────────\n\n// The actual class lives in StageContext.ts; we just need the type here for\n// the ScopeFactory generic. TypeScript's import-type handles this:\nimport type { StageContext } from './StageContext.js';\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../src/lib/memory/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAuGH,OAAO,EAAE,mBAAmB,EAAE,sBAAsB,EAAE,MAAM,yBAAyB,CAAC","sourcesContent":["/**\n * types.ts — Core type definitions for the memory library\n *\n * Zero dependencies on old code or other libraries in this package, with one\n * deliberate exception: `capture/` — the standalone leaf module holding the\n * shared retention-policy family and summary-marker builders (extracted from\n * here in #13c-A so the read and write dials, and later RFC-001, share one\n * implementation).\n */\n\nimport type { RetentionPolicy } from '../capture/policies.js';\n\n// ── Patch & Trace ──────────────────────────────────────────────────────────\n\n/** A flat key-value bag representing a state patch (overwrite or merge). */\nexport interface MemoryPatch {\n  [key: string]: any;\n}\n\n/** A single entry in the chronological operation trace. */\nexport interface TraceEntry {\n  /** Canonical path string (segments joined by DELIM). */\n  path: string;\n  /**\n   * - `'set'`    — hard overwrite; `overwrite[path]` holds the full final value.\n   * - `'merge'`  — deep union merge; `updates[path]` holds the accumulated delta.\n   * - `'append'` — (#13c-B, produced only under {@link CommitValuesMode}\n   *   `'delta'`) the path's final value is its base value plus a tail of new\n   *   trailing elements; `overwrite[path]` holds ONLY the tail. Replay\n   *   reconstructs by concatenation. NOT idempotent — delta-mode bundles\n   *   carry exactly one trace entry per surviving path.\n   * - `'delete'` — (#13c-B, produced only under `'delta'`; absorbs backlog\n   *   B8) the key was explicitly removed via `deleteValue()`. Replay removes\n   *   the key. `overwrite[path]` still ENUMERATES the path (value\n   *   `undefined`) so key-set consumers keep seeing the changed key.\n   *\n   * `overwrite` values are therefore VERB-QUALIFIED: consumers that read\n   * `bundle.overwrite[key]` as \"the full value written\" must use\n   * `commitValueAt(commitLog, idx, key)` (from `footprintjs/trace`) when the\n   * log may contain delta-mode bundles.\n   */\n  verb: 'set' | 'merge' | 'append' | 'delete';\n}\n\n/**\n * RFC-003 D2 — read paths that BYPASS read tracking:\n * - `'args'`   — the stage called `getArgs()` / `$getArgs()` with non-empty\n *   run input (frozen, untracked by design)\n * - `'env'`    — the stage called `getEnv()` / `$getEnv()` with a non-empty\n *   execution environment (frozen, untracked by design)\n * - `'silent'` — the stage performed a silent read (`getValueSilent` /\n *   `getValueDirect`) of a key it never tracked-read in the same stage.\n *   Silent reads SHADOWED by a tracked read of the same key in the same\n *   stage (TypedScope array-proxy internals, `$batchArray`) are NOT\n *   flagged — their read→write edge is already captured.\n */\nexport type UntrackedSource = 'args' | 'env' | 'silent';\n\n/** The atomic bundle produced by TransactionBuffer.commit(). */\nexport interface CommitBundle {\n  /** Auto-assigned step index (set by EventLog.record). */\n  idx?: number;\n  /** Human-readable stage name. */\n  stage: string;\n  /** Stable stage identifier (matches spec node id). */\n  stageId: string;\n  /** Unique per-execution-step identifier. Format: [subflowPath/]stageId#executionIndex */\n  runtimeStageId: string;\n  /** Chronological write log for deterministic replay. */\n  trace: TraceEntry[];\n  /** Paths that should be redacted in UI (sensitive data). */\n  redactedPaths: string[];\n  /** Hard overwrite patches. */\n  overwrite: MemoryPatch;\n  /** Deep merge patches. */\n  updates: MemoryPatch;\n  /**\n   * RFC-003 D2 honesty markers — untracked read paths this stage consumed\n   * (see {@link UntrackedSource}). ABSENT when the stage used none, so\n   * charts that never touch those paths keep byte-identical commit logs.\n   * Causal-slice consumers (`causalChain`/`formatCausalChain`) surface this\n   * as \"slice may be incomplete here\". Residual limitation (by design):\n   * values smuggled through JS closures are undetectable.\n   */\n  untrackedSources?: ReadonlyArray<UntrackedSource>;\n}\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 write dial and, later, RFC-001's deferred-observer capture tier).\n// Re-exported here so every pre-extraction import path keeps working.\n\nexport type { RetentionPolicy } from '../capture/policies.js';\nexport type { ReadSummaryMarker, WriteSummaryMarker } from '../capture/summarize.js';\nexport { READ_PREVIEW_LENGTH, SUMMARY_PREVIEW_LENGTH } from '../capture/summarize.js';\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/**\n * Policy for how commit-bundle VALUES are encoded into the commit log\n * (#13c-B) — completes the `readTracking`/`writeTracking` dial family.\n * Unlike those two (which gate lossy snapshot bookkeeping), this dial is\n * **lossless in both modes** — it changes the commit log's *encoding*,\n * never its *information*; any step's full state stays exactly\n * reconstructable by replay.\n *\n * - `'full'` (default) — every surviving `set` path stores the full final\n *   value, one trace entry per operation. Byte-identical to the historical\n *   behavior.\n * - `'delta'` — two changes, both replay-covered by `applySmartMerge`:\n *   1. **`append` detection**: when a path's net change is \"the base array\n *      plus new trailing elements\" (strict prefix), the bundle records ONLY\n *      the tail under a `verb: 'append'` trace entry — the growing-history\n *      commit log becomes linear in tail size instead of O(N²) retained.\n *      A real `verb: 'delete'` entry replaces the `set: undefined` flattening\n *      for `deleteValue()` (closes the documented MemoryPatch limitation).\n *   2. **One trace entry per surviving path** (append is not idempotent on\n *      replay): the verb is resolved from the path's base→final relationship\n *      and op mix; entries are ordered by each path's LAST touch.\n *\n * Honest cost note: append detection is NEW wall work — an O(|base|)\n * structural prefix compare per array-set path per commit (today's\n * `deepEqual` fast-fails on length in O(1) for a grown array). On a hit the\n * commit gets cheaper in both wall and heap (the O(|final|) clone shrinks to\n * O(|tail|)); on a miss it pays compare + full clone. `'full'` pays zero —\n * the detection branch is mode-gated.\n *\n * Set via `new FlowChartExecutor(chart, { commitValues })` or\n * `executor.setCommitValues(mode)` (before `run()`). The active mode is\n * surfaced as the snapshot discriminant `RuntimeSnapshot.commitValues`.\n */\nexport type CommitValuesMode = 'full' | 'delta';\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  next?: StageSnapshot;\n  children?: StageSnapshot[];\n};\n\n// ── Scope Factory ──────────────────────────────────────────────────────────\n\n/** Forward-declared so StageContext can accept it without importing scope/. */\nexport type ScopeFactory<TScope> = (core: StageContext, stageName: string, readOnlyContext?: unknown) => TScope;\n\n// ── StageContext (forward reference for ScopeFactory) ──────────────────────\n\n// The actual class lives in StageContext.ts; we just need the type here for\n// the ScopeFactory generic. TypeScript's import-type handles this:\nimport type { StageContext } from './StageContext.js';\n"]}