footprintjs 4.11.0 → 4.12.0

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

@@ -0,0 +1,272 @@
+/**
+ * backtrack.ts — Backward causal chain analysis on the commit log.
+ *
+ * Implements **backward program slicing** (Weiser 1984, thin-slice variant):
+ * given a starting execution step, walk backwards through read→write
+ * dependencies to build the causal DAG that produced the data at that step.
+ *
+ * ## Algorithm
+ *
+ * BFS on the implicit dependency graph where edges run from reader → writer.
+ *
+ * 1. Locate startId in commitLog → root node
+ * 2. Get keysRead for root via `getKeysRead` callback
+ * 3. For each key read, find who last wrote it before this step → parent commit
+ * 4. Create parent CausalNode, link to root.parents
+ * 5. Enqueue parent. Repeat until queue empty or limits hit.
+ *
+ * Output is a **DAG** (not a linked list): a stage reading `creditScore` AND `dti`
+ * from different writers has two parents.
+ *
+ * ## Staged Optimization
+ *
+ * Two writer-lookup strategies, chosen automatically by commit log size:
+ *
+ * | Strategy | When | Complexity per lookup |
+ * |----------|------|----------------------|
+ * | Linear scan | N ≤ 256 | O(N) — simple backward scan |
+ * | Reverse index | N > 256 | O(K log N) — prebuilt key→[indices], binary search |
+ *
+ * The threshold (256) is chosen so the O(N) build cost of the reverse index
+ * is amortized over the BFS traversal. Below 256, linear scan wins because
+ * there's no index build overhead. The consumer never sees this — `causalChain()`
+ * picks the right strategy internally (like a query optimizer choosing between
+ * sequential scan vs index scan based on table size).
+ *
+ * ## Complexity
+ *
+ * - **Small logs (N ≤ 256):** O(V × K × N) total. V=visited, K=avg keys/node.
+ * - **Large logs (N > 256):** O(N × U) index build + O(V × K × log N) lookups.
+ *   U = unique keys. Amortized over all BFS hops.
+ *
+ * ## References
+ *
+ * - Weiser, M. (1984). "Program Slicing." IEEE TSE.
+ * - Sridharan, M. et al. (2007). "Thin Slicing." PLDI.
+ *
+ * @example
+ * ```typescript
+ * import { causalChain, flattenCausalDAG, formatCausalChain } from 'footprintjs/trace';
+ *
+ * const dag = causalChain(commitLog, 'decide#2', (id) => recorder.getKeysRead(id));
+ * const flat = flattenCausalDAG(dag);     // BFS-ordered flat list
+ * console.log(formatCausalChain(dag));     // human-readable
+ * ```
+ */
+import { findLastWriter } from './commitLogUtils.js';
+// ── Staged optimization: writer lookup strategies ──────────────────────
+/**
+ * Threshold for switching from linear scan to reverse index.
+ * Below this, O(N) scan is faster (no index build cost).
+ * Above this, O(log N) binary search wins.
+ */
+const REVERSE_INDEX_THRESHOLD = 256;
+/** Strategy 1: Linear scan — O(N) per lookup, zero setup cost. */
+function linearScanLookup(commitLog) {
+    return (key, beforeIdx) => findLastWriter(commitLog, key, beforeIdx);
+}
+/**
+ * Strategy 2: Reverse index — O(N×U) build, O(log N) per lookup.
+ * Builds a Map<key, sortedIndices[]> where indices are commit positions
+ * that wrote that key. Lookup uses binary search to find the last writer
+ * before a given position.
+ */
+function reverseIndexLookup(commitLog) {
+    // Build: key → sorted array of commit indices that wrote this key
+    const index = new Map();
+    for (let i = 0; i < commitLog.length; i++) {
+        for (const t of commitLog[i].trace) {
+            let arr = index.get(t.path);
+            if (!arr) {
+                arr = [];
+                index.set(t.path, arr);
+            }
+            arr.push(i); // already sorted (we iterate in order)
+        }
+    }
+    return (key, beforeIdx) => {
+        const indices = index.get(key);
+        if (!indices || indices.length === 0)
+            return undefined;
+        // Binary search: find largest index < beforeIdx
+        let lo = 0;
+        let hi = indices.length - 1;
+        let result = -1;
+        while (lo <= hi) {
+            const mid = (lo + hi) >>> 1;
+            if (indices[mid] < beforeIdx) {
+                result = indices[mid];
+                lo = mid + 1;
+            }
+            else {
+                hi = mid - 1;
+            }
+        }
+        return result >= 0 ? commitLog[result] : undefined;
+    };
+}
+/**
+ * Staged optimization: pick the right writer-lookup strategy based on data size.
+ *
+ * Like a database query optimizer choosing between sequential scan and index scan:
+ *
+ * - **Small log (≤ 256):** Linear scan wins. Zero setup cost, good cache locality.
+ *   The overhead of building a reverse index isn't worth it for short logs.
+ *
+ * - **Large log (> 256):** Reverse index wins. O(N×U) upfront build cost is amortized
+ *   across all BFS hops. Each lookup becomes O(log N) via binary search instead of O(N).
+ *   For an agent loop with 500 iterations and 5 keys per hop, this is 500×5×log(500)≈22K ops
+ *   vs 500×5×500=1.25M ops with linear scan.
+ *
+ * The caller never sees this — `causalChain()` picks automatically.
+ */
+function createWriterLookup(commitLog) {
+    if (commitLog.length <= REVERSE_INDEX_THRESHOLD) {
+        return linearScanLookup(commitLog);
+    }
+    return reverseIndexLookup(commitLog);
+}
+// ── Core algorithm ─────────────────────────────────────────────────────
+/**
+ * Build the causal DAG rooted at `startId` by walking backwards
+ * through read→write dependencies in the commit log.
+ *
+ * Automatically selects the optimal writer lookup strategy:
+ * - Linear scan for small logs (≤ 256 commits)
+ * - Reverse index with binary search for large logs (> 256 commits)
+ *
+ * Produces a DAG (not a tree): if two children both read from the same
+ * parent, the parent node is shared (deduped by runtimeStageId).
+ *
+ * @param commitLog   Ordered commit bundles from executor.getSnapshot().commitLog
+ * @param startId     runtimeStageId to start backtracking from
+ * @param getKeysRead Callback returning keys read by a given execution step
+ * @param options     Depth and node limits
+ * @returns Root CausalNode with .parents forming the DAG, or undefined if startId not found
+ */
+export function causalChain(commitLog, startId, getKeysRead, options) {
+    var _a, _b;
+    const maxDepth = (_a = options === null || options === void 0 ? void 0 : options.maxDepth) !== null && _a !== void 0 ? _a : 20;
+    const maxNodes = (_b = options === null || options === void 0 ? void 0 : options.maxNodes) !== null && _b !== void 0 ? _b : 100;
+    // Build position index: runtimeStageId → array position (O(n) once)
+    const idxMap = new Map();
+    for (let i = 0; i < commitLog.length; i++) {
+        idxMap.set(commitLog[i].runtimeStageId, i);
+    }
+    const startIdx = idxMap.get(startId);
+    if (startIdx === undefined)
+        return undefined;
+    const startCommit = commitLog[startIdx];
+    // Pick writer lookup strategy based on log size
+    const findWriter = createWriterLookup(commitLog);
+    // Node dedup map: runtimeStageId → CausalNode (ensures DAG, not tree)
+    const nodeMap = new Map();
+    const root = {
+        runtimeStageId: startId,
+        stageId: startCommit.stageId,
+        stageName: startCommit.stage,
+        keysWritten: startCommit.trace.map((t) => t.path),
+        linkedBy: '',
+        depth: 0,
+        parents: [],
+    };
+    nodeMap.set(startId, root);
+    // BFS queue: [node, commitIdx, depth]
+    const queue = [[root, startIdx, 0]];
+    let visited = 1;
+    while (queue.length > 0) {
+        const [node, commitIdx, depth] = queue.shift();
+        if (depth >= maxDepth)
+            continue;
+        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);
+                }
+                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]);
+        }
+    }
+    return root;
+}
+// ── Utilities ──────────────────────────────────────────────────────────
+/**
+ * Flatten the causal DAG into a BFS-ordered list of nodes.
+ * Each node appears exactly once (first occurrence by BFS order).
+ * Useful for linear display or iteration.
+ */
+export function flattenCausalDAG(root) {
+    const result = [];
+    const visited = new Set();
+    const queue = [root];
+    while (queue.length > 0) {
+        const node = queue.shift();
+        if (visited.has(node.runtimeStageId))
+            continue;
+        visited.add(node.runtimeStageId);
+        result.push(node);
+        for (const parent of node.parents) {
+            if (!visited.has(parent.runtimeStageId)) {
+                queue.push(parent);
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Format a causal DAG as human-readable indented text.
+ * Shows the dependency chain with depth indentation and linked-by keys.
+ */
+export function formatCausalChain(root) {
+    const lines = [];
+    const visited = new Set();
+    function walk(node, indent) {
+        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 writes = node.keysWritten.length > 0 ? ` [wrote: ${node.keysWritten.join(', ')}]` : '';
+        lines.push(`${'  '.repeat(indent)}${node.stageName} (${node.runtimeStageId})${link}${writes}`);
+        for (const parent of node.parents) {
+            walk(parent, indent + 1);
+        }
+    }
+    walk(root, 0);
+    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":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAyCrD,0EAA0E;AAE1E;;;;GAIG;AACH,MAAM,uBAAuB,GAAG,GAAG,CAAC;AAQpC,kEAAkE;AAClE,SAAS,gBAAgB,CAAC,SAAyB;IACjD,OAAO,CAAC,GAAG,EAAE,SAAS,EAAE,EAAE,CAAC,cAAc,CAAC,SAAS,EAAE,GAAG,EAAE,SAAS,CAAC,CAAC;AACvE,CAAC;AAED;;;;;GAKG;AACH,SAAS,kBAAkB,CAAC,SAAyB;IACnD,kEAAkE;IAClE,MAAM,KAAK,GAAG,IAAI,GAAG,EAAoB,CAAC;IAC1C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QAC1C,KAAK,MAAM,CAAC,IAAI,SAAS,CAAC,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC;YACnC,IAAI,GAAG,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;YAC5B,IAAI,CAAC,GAAG,EAAE,CAAC;gBACT,GAAG,GAAG,EAAE,CAAC;gBACT,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;YACzB,CAAC;YACD,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,uCAAuC;QACtD,CAAC;IACH,CAAC;IAED,OAAO,CAAC,GAAW,EAAE,SAAiB,EAA4B,EAAE;QAClE,MAAM,OAAO,GAAG,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAC/B,IAAI,CAAC,OAAO,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,SAAS,CAAC;QAEvD,gDAAgD;QAChD,IAAI,EAAE,GAAG,CAAC,CAAC;QACX,IAAI,EAAE,GAAG,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC;QAC5B,IAAI,MAAM,GAAG,CAAC,CAAC,CAAC;QAEhB,OAAO,EAAE,IAAI,EAAE,EAAE,CAAC;YAChB,MAAM,GAAG,GAAG,CAAC,EAAE,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC;YAC5B,IAAI,OAAO,CAAC,GAAG,CAAC,GAAG,SAAS,EAAE,CAAC;gBAC7B,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;gBACtB,EAAE,GAAG,GAAG,GAAG,CAAC,CAAC;YACf,CAAC;iBAAM,CAAC;gBACN,EAAE,GAAG,GAAG,GAAG,CAAC,CAAC;YACf,CAAC;QACH,CAAC;QAED,OAAO,MAAM,IAAI,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IACrD,CAAC,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,SAAS,kBAAkB,CAAC,SAAyB;IACnD,IAAI,SAAS,CAAC,MAAM,IAAI,uBAAuB,EAAE,CAAC;QAChD,OAAO,gBAAgB,CAAC,SAAS,CAAC,CAAC;IACrC,CAAC;IACD,OAAO,kBAAkB,CAAC,SAAS,CAAC,CAAC;AACvC,CAAC;AAED,0EAA0E;AAE1E;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,WAAW,CACzB,SAAyB,EACzB,OAAe,EACf,WAA2B,EAC3B,OAA4B;;IAE5B,MAAM,QAAQ,GAAG,MAAA,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,QAAQ,mCAAI,EAAE,CAAC;IACzC,MAAM,QAAQ,GAAG,MAAA,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,QAAQ,mCAAI,GAAG,CAAC;IAE1C,oEAAoE;IACpE,MAAM,MAAM,GAAG,IAAI,GAAG,EAAkB,CAAC;IACzC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QAC1C,MAAM,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,cAAc,EAAE,CAAC,CAAC,CAAC;IAC7C,CAAC;IAED,MAAM,QAAQ,GAAG,MAAM,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;IACrC,IAAI,QAAQ,KAAK,SAAS;QAAE,OAAO,SAAS,CAAC;IAE7C,MAAM,WAAW,GAAG,SAAS,CAAC,QAAQ,CAAC,CAAC;IAExC,gDAAgD;IAChD,MAAM,UAAU,GAAG,kBAAkB,CAAC,SAAS,CAAC,CAAC;IAEjD,sEAAsE;IACtE,MAAM,OAAO,GAAG,IAAI,GAAG,EAAsB,CAAC;IAE9C,MAAM,IAAI,GAAe;QACvB,cAAc,EAAE,OAAO;QACvB,OAAO,EAAE,WAAW,CAAC,OAAO;QAC5B,SAAS,EAAE,WAAW,CAAC,KAAK;QAC5B,WAAW,EAAE,WAAW,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;QACjD,QAAQ,EAAE,EAAE;QACZ,KAAK,EAAE,CAAC;QACR,OAAO,EAAE,EAAE;KACZ,CAAC;IACF,OAAO,CAAC,GAAG,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;IAE3B,sCAAsC;IACtC,MAAM,KAAK,GAAwC,CAAC,CAAC,IAAI,EAAE,QAAQ,EAAE,CAAC,CAAC,CAAC,CAAC;IACzE,IAAI,OAAO,GAAG,CAAC,CAAC;IAEhB,OAAO,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACxB,MAAM,CAAC,IAAI,EAAE,SAAS,EAAE,KAAK,CAAC,GAAG,KAAK,CAAC,KAAK,EAAG,CAAC;QAEhD,IAAI,KAAK,IAAI,QAAQ;YAAE,SAAS;QAEhC,MAAM,QAAQ,GAAG,WAAW,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;QAClD,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC;YAAE,SAAS;QAEpC,uCAAuC;QACvC,KAAK,MAAM,GAAG,IAAI,QAAQ,EAAE,CAAC;YAC3B,MAAM,MAAM,GAAG,UAAU,CAAC,GAAG,EAAE,SAAS,CAAC,CAAC;YAC1C,IAAI,CAAC,MAAM;gBAAE,SAAS;YAEtB,MAAM,QAAQ,GAAG,MAAM,CAAC,cAAc,CAAC;YAEvC,kDAAkD;YAClD,IAAI,UAAU,GAAG,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;YACvC,IAAI,UAAU,EAAE,CAAC;gBACf,iDAAiD;gBACjD,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,cAAc,KAAK,QAAQ,CAAC,EAAE,CAAC;oBAC7D,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;gBAChC,CAAC;gBACD,SAAS;YACX,CAAC;YAED,gCAAgC;YAChC,IAAI,OAAO,IAAI,QAAQ;gBAAE,SAAS;YAElC,MAAM,SAAS,GAAG,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;YACvC,IAAI,SAAS,KAAK,SAAS;gBAAE,SAAS;YAEtC,UAAU,GAAG;gBACX,cAAc,EAAE,QAAQ;gBACxB,OAAO,EAAE,MAAM,CAAC,OAAO;gBACvB,SAAS,EAAE,MAAM,CAAC,KAAK;gBACvB,WAAW,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;gBAC5C,QAAQ,EAAE,GAAG;gBACb,KAAK,EAAE,KAAK,GAAG,CAAC;gBAChB,OAAO,EAAE,EAAE;aACZ,CAAC;YACF,OAAO,CAAC,GAAG,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC;YAClC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;YAC9B,OAAO,EAAE,CAAC;YAEV,KAAK,CAAC,IAAI,CAAC,CAAC,UAAU,EAAE,SAAS,EAAE,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC;QACjD,CAAC;IACH,CAAC;IAED,OAAO,IAAI,CAAC;AACd,CAAC;AAED,0EAA0E;AAE1E;;;;GAIG;AACH,MAAM,UAAU,gBAAgB,CAAC,IAAgB;IAC/C,MAAM,MAAM,GAAiB,EAAE,CAAC;IAChC,MAAM,OAAO,GAAG,IAAI,GAAG,EAAU,CAAC;IAClC,MAAM,KAAK,GAAiB,CAAC,IAAI,CAAC,CAAC;IAEnC,OAAO,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACxB,MAAM,IAAI,GAAG,KAAK,CAAC,KAAK,EAAG,CAAC;QAC5B,IAAI,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,cAAc,CAAC;YAAE,SAAS;QAC/C,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;QACjC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAElB,KAAK,MAAM,MAAM,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YAClC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,cAAc,CAAC,EAAE,CAAC;gBACxC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;YACrB,CAAC;QACH,CAAC;IACH,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,iBAAiB,CAAC,IAAgB;IAChD,MAAM,KAAK,GAAa,EAAE,CAAC;IAC3B,MAAM,OAAO,GAAG,IAAI,GAAG,EAAU,CAAC;IAElC,SAAS,IAAI,CAAC,IAAgB,EAAE,MAAc;QAC5C,IAAI,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,cAAc,CAAC,EAAE,CAAC;YACrC,KAAK,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,IAAI,CAAC,cAAc,cAAc,CAAC,CAAC;YACzE,OAAO;QACT,CAAC;QACD,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;QAEjC,MAAM,IAAI,GAAG,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,UAAU,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QAC5D,MAAM,MAAM,GAAG,IAAI,CAAC,WAAW,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,YAAY,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;QAC7F,KAAK,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,SAAS,KAAK,IAAI,CAAC,cAAc,IAAI,IAAI,GAAG,MAAM,EAAE,CAAC,CAAC;QAE/F,KAAK,MAAM,MAAM,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YAClC,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,CAAC,CAAC,CAAC;QAC3B,CAAC;IACH,CAAC;IAED,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;IACd,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAC1B,CAAC;AAED,0EAA0E;AAE1E,4DAA4D;AAC5D,MAAM,CAAC,MAAM,wBAAwB,GAAG,uBAAuB,CAAC","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 Recorder.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"]}

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

@@ -0,0 +1,132 @@
+/**
+ * QualityRecorder — per-step quality scoring keyed by runtimeStageId.
+ *
+ * Collects quality scores during traversal (accumulate pattern).
+ * After execution, use qualityTrace() to backtrack from any low-scoring step.
+ *
+ * Extends KeyedRecorder<QualityEntry> for O(1) lookup and standard operations:
+ *   - **Translate**: `getByKey('call-llm#5')` — quality at this step
+ *   - **Accumulate**: progressive quality up to slider position
+ *   - **Aggregate**: overall pipeline quality score
+ *
+ * @example
+ * ```typescript
+ * const quality = new QualityRecorder((runtimeStageId, event) => {
+ *   // Custom scoring function — return 0.0–1.0
+ *   if (event.stageName.includes('llm')) return 0.7;
+ *   return 1.0;
+ * });
+ * executor.attachRecorder(quality);
+ * await executor.run();
+ *
+ * // Per-step score
+ * quality.getByKey('call-llm#5');  // { score: 0.7, stageName: 'CallLLM', factors: [...] }
+ *
+ * // Overall quality
+ * quality.getOverallScore();  // 0.85
+ *
+ * // Lowest-scoring step
+ * quality.getLowest();  // { runtimeStageId: 'call-llm#5', entry: { score: 0.7, ... } }
+ * ```
+ */
+import { KeyedRecorder } from './KeyedRecorder.js';
+export class QualityRecorder extends KeyedRecorder {
+    constructor(scoringFn, options) {
+        var _a, _b;
+        super();
+        // Per-stage buffers (reset on each stageStart)
+        this.currentRuntimeStageId = '';
+        this.currentStageId = '';
+        this.currentStageName = '';
+        this.currentKeysRead = [];
+        this.currentKeysWritten = [];
+        this.scoringFn = scoringFn;
+        this.id = (_a = options === null || options === void 0 ? void 0 : options.id) !== null && _a !== void 0 ? _a : `quality-${++QualityRecorder._counter}`;
+        this.preferredOperation = (_b = options === null || options === void 0 ? void 0 : options.preferredOperation) !== null && _b !== void 0 ? _b : 'accumulate';
+    }
+    onStageStart(event) {
+        this.currentRuntimeStageId = event.runtimeStageId;
+        this.currentStageId = event.stageId;
+        this.currentStageName = event.stageName;
+        this.currentKeysRead = [];
+        this.currentKeysWritten = [];
+    }
+    onRead(event) {
+        if (event.key)
+            this.currentKeysRead.push(event.key);
+    }
+    onWrite(event) {
+        this.currentKeysWritten.push(event.key);
+    }
+    onStageEnd(event) {
+        const { score, factors } = this.scoringFn(this.currentRuntimeStageId, {
+            stageName: this.currentStageName,
+            stageId: this.currentStageId,
+            keysRead: this.currentKeysRead,
+            keysWritten: this.currentKeysWritten,
+            duration: event.duration,
+        });
+        this.store(this.currentRuntimeStageId, {
+            stageName: this.currentStageName,
+            stageId: this.currentStageId,
+            score: Math.max(0, Math.min(1, score)),
+            factors: factors !== null && factors !== void 0 ? factors : [],
+            keysRead: [...this.currentKeysRead],
+            keysWritten: [...this.currentKeysWritten],
+        });
+    }
+    /** Overall quality score — average of all step scores. */
+    getOverallScore() {
+        if (this.size === 0)
+            return 1.0;
+        const total = this.aggregate((sum, e) => sum + e.score, 0);
+        return total / this.size;
+    }
+    /** Find the lowest-scoring step. */
+    getLowest() {
+        let lowest;
+        for (const [key, entry] of this.getMap()) {
+            if (!lowest || entry.score < lowest.entry.score) {
+                lowest = { runtimeStageId: key, entry };
+            }
+        }
+        return lowest;
+    }
+    /** Progressive quality score up to a slider position. */
+    getScoreUpTo(visibleKeys) {
+        let count = 0;
+        const total = this.accumulate((sum, e) => {
+            count++;
+            return sum + e.score;
+        }, 0, visibleKeys);
+        return count === 0 ? 1.0 : total / count;
+    }
+    toSnapshot() {
+        var _a;
+        const steps = {};
+        for (const [key, value] of this.getMap()) {
+            steps[key] = value;
+        }
+        return {
+            name: 'Quality',
+            description: 'Quality scores per execution step with backtracking support',
+            preferredOperation: this.preferredOperation,
+            data: {
+                numericField: 'score',
+                overallScore: this.getOverallScore(),
+                lowestStep: (_a = this.getLowest()) === null || _a === void 0 ? void 0 : _a.runtimeStageId,
+                steps,
+            },
+        };
+    }
+    clear() {
+        super.clear();
+        this.currentRuntimeStageId = '';
+        this.currentStageId = '';
+        this.currentStageName = '';
+        this.currentKeysRead = [];
+        this.currentKeysWritten = [];
+    }
+}
+QualityRecorder._counter = 0;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"QualityRecorder.js","sourceRoot":"","sources":["../../../../src/lib/recorder/QualityRecorder.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * QualityRecorder — per-step quality scoring keyed by runtimeStageId.\n *\n * Collects quality scores during traversal (accumulate pattern).\n * After execution, use qualityTrace() to backtrack from any low-scoring step.\n *\n * Extends KeyedRecorder<QualityEntry> for O(1) lookup and standard operations:\n *   - **Translate**: `getByKey('call-llm#5')` — quality at this step\n *   - **Accumulate**: progressive quality up to slider position\n *   - **Aggregate**: overall pipeline quality score\n *\n * @example\n * ```typescript\n * const quality = new QualityRecorder((runtimeStageId, event) => {\n *   // Custom scoring function — return 0.0–1.0\n *   if (event.stageName.includes('llm')) return 0.7;\n *   return 1.0;\n * });\n * executor.attachRecorder(quality);\n * await executor.run();\n *\n * // Per-step score\n * quality.getByKey('call-llm#5');  // { score: 0.7, stageName: 'CallLLM', factors: [...] }\n *\n * // Overall quality\n * quality.getOverallScore();  // 0.85\n *\n * // Lowest-scoring step\n * quality.getLowest();  // { runtimeStageId: 'call-llm#5', entry: { score: 0.7, ... } }\n * ```\n */\n\nimport type { ReadEvent, Recorder, StageEvent, WriteEvent } from '../scope/types.js';\nimport { KeyedRecorder } from './KeyedRecorder.js';\nimport type { RecorderOperation } from './RecorderOperation.js';\n\n/** Per-step quality data stored by QualityRecorder. */\nexport interface QualityEntry {\n  /** Human-readable stage name. */\n  stageName: string;\n  /** Stable stage identifier. */\n  stageId: string;\n  /** Quality score for this step (0.0 = worst, 1.0 = best). */\n  score: number;\n  /** What contributed to this score. */\n  factors: string[];\n  /** Keys read during this step (for backtracking). */\n  keysRead: string[];\n  /** Keys written during this step (for backtracking). */\n  keysWritten: string[];\n}\n\n/**\n * Scoring function called at the end of each stage.\n * Receives the runtimeStageId, stage event, and a summary of reads/writes.\n * Return a score (0.0–1.0) and optional factors explaining the score.\n */\nexport type QualityScoringFn = (\n  runtimeStageId: string,\n  context: {\n    stageName: string;\n    stageId: string;\n    keysRead: string[];\n    keysWritten: string[];\n    duration?: number;\n  },\n) => { score: number; factors?: string[] };\n\n/** Options for QualityRecorder. */\nexport interface QualityRecorderOptions {\n  /** Recorder ID. Defaults to auto-increment. */\n  id?: string;\n  /** Preferred UI operation. Defaults to 'accumulate' (progressive quality). */\n  preferredOperation?: RecorderOperation;\n}\n\nexport class QualityRecorder extends KeyedRecorder<QualityEntry> implements Recorder {\n  private static _counter = 0;\n\n  readonly id: string;\n  readonly preferredOperation: RecorderOperation;\n  private readonly scoringFn: QualityScoringFn;\n\n  // Per-stage buffers (reset on each stageStart)\n  private currentRuntimeStageId = '';\n  private currentStageId = '';\n  private currentStageName = '';\n  private currentKeysRead: string[] = [];\n  private currentKeysWritten: string[] = [];\n\n  constructor(scoringFn: QualityScoringFn, options?: QualityRecorderOptions) {\n    super();\n    this.scoringFn = scoringFn;\n    this.id = options?.id ?? `quality-${++QualityRecorder._counter}`;\n    this.preferredOperation = options?.preferredOperation ?? 'accumulate';\n  }\n\n  onStageStart(event: StageEvent): void {\n    this.currentRuntimeStageId = event.runtimeStageId;\n    this.currentStageId = event.stageId;\n    this.currentStageName = event.stageName;\n    this.currentKeysRead = [];\n    this.currentKeysWritten = [];\n  }\n\n  onRead(event: ReadEvent): void {\n    if (event.key) this.currentKeysRead.push(event.key);\n  }\n\n  onWrite(event: WriteEvent): void {\n    this.currentKeysWritten.push(event.key);\n  }\n\n  onStageEnd(event: StageEvent): void {\n    const { score, factors } = this.scoringFn(this.currentRuntimeStageId, {\n      stageName: this.currentStageName,\n      stageId: this.currentStageId,\n      keysRead: this.currentKeysRead,\n      keysWritten: this.currentKeysWritten,\n      duration: event.duration,\n    });\n\n    this.store(this.currentRuntimeStageId, {\n      stageName: this.currentStageName,\n      stageId: this.currentStageId,\n      score: Math.max(0, Math.min(1, score)),\n      factors: factors ?? [],\n      keysRead: [...this.currentKeysRead],\n      keysWritten: [...this.currentKeysWritten],\n    });\n  }\n\n  /** Overall quality score — average of all step scores. */\n  getOverallScore(): number {\n    if (this.size === 0) return 1.0;\n    const total = this.aggregate((sum, e) => sum + e.score, 0);\n    return total / this.size;\n  }\n\n  /** Find the lowest-scoring step. */\n  getLowest(): { runtimeStageId: string; entry: QualityEntry } | undefined {\n    let lowest: { runtimeStageId: string; entry: QualityEntry } | undefined;\n    for (const [key, entry] of this.getMap()) {\n      if (!lowest || entry.score < lowest.entry.score) {\n        lowest = { runtimeStageId: key, entry };\n      }\n    }\n    return lowest;\n  }\n\n  /** Progressive quality score up to a slider position. */\n  getScoreUpTo(visibleKeys: ReadonlySet<string>): number {\n    let count = 0;\n    const total = this.accumulate(\n      (sum, e) => {\n        count++;\n        return sum + e.score;\n      },\n      0,\n      visibleKeys,\n    );\n    return count === 0 ? 1.0 : total / count;\n  }\n\n  toSnapshot() {\n    const steps: Record<string, unknown> = {};\n    for (const [key, value] of this.getMap()) {\n      steps[key] = value;\n    }\n    return {\n      name: 'Quality',\n      description: 'Quality scores per execution step with backtracking support',\n      preferredOperation: this.preferredOperation,\n      data: {\n        numericField: 'score',\n        overallScore: this.getOverallScore(),\n        lowestStep: this.getLowest()?.runtimeStageId,\n        steps,\n      },\n    };\n  }\n\n  override clear(): void {\n    super.clear();\n    this.currentRuntimeStageId = '';\n    this.currentStageId = '';\n    this.currentStageName = '';\n    this.currentKeysRead = [];\n    this.currentKeysWritten = [];\n  }\n}\n"]}

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

@@ -0,0 +1,92 @@
+/**
+ * qualityTrace() — Quality Stack Trace built on causalChain().
+ *
+ * Thin layer over `memory/backtrack.causalChain()` that decorates
+ * each causal node with quality scores from a QualityRecorder.
+ *
+ * ```
+ * Quality Trace (score: 0.3 at call-llm#5):
+ *   at call-llm#5     score=0.3  ← quality dropped here
+ *   at system-prompt#1 score=0.8  ← systemPrompt was good
+ *   at seed#0          score=1.0  ← input was clean
+ *
+ * Root cause: quality dropped at call-llm#5 (0.8 → 0.3, Δ0.5)
+ * ```
+ */
+import { causalChain, flattenCausalDAG } from '../memory/backtrack.js';
+/**
+ * Build a quality stack trace by decorating a causal chain with scores.
+ *
+ * @param commitLog        From executor.getSnapshot().commitLog
+ * @param qualityRecorder  QualityRecorder attached during execution
+ * @param startId          runtimeStageId to start from
+ * @param maxDepth         Maximum backtracking depth (default: 20)
+ */
+export function qualityTrace(commitLog, qualityRecorder, startId, maxDepth = 20) {
+    const startEntry = qualityRecorder.getByKey(startId);
+    if (!startEntry) {
+        return { startId, startScore: -1, frames: [] };
+    }
+    // Use causalChain to build the DAG, providing keysRead from the QualityRecorder
+    const root = causalChain(commitLog, startId, (id) => { var _a, _b; return (_b = (_a = qualityRecorder.getByKey(id)) === null || _a === void 0 ? void 0 : _a.keysRead) !== null && _b !== void 0 ? _b : []; }, { maxDepth });
+    if (!root) {
+        return { startId, startScore: startEntry.score, frames: [] };
+    }
+    // Flatten DAG to BFS-ordered frames, decorate with quality scores
+    const nodes = flattenCausalDAG(root);
+    const frames = nodes.map((node) => {
+        var _a, _b;
+        const entry = qualityRecorder.getByKey(node.runtimeStageId);
+        return {
+            runtimeStageId: node.runtimeStageId,
+            stageName: node.stageName,
+            score: (_a = entry === null || entry === void 0 ? void 0 : entry.score) !== null && _a !== void 0 ? _a : -1,
+            factors: (_b = entry === null || entry === void 0 ? void 0 : entry.factors) !== null && _b !== void 0 ? _b : [],
+            linkedBy: node.linkedBy,
+            depth: node.depth,
+        };
+    });
+    // Find root cause: biggest quality drop between adjacent frames (BFS order)
+    let rootCause;
+    for (let i = 0; i < frames.length; i++) {
+        const frame = frames[i];
+        // Look at each parent (frames at depth + 1)
+        for (const parentFrame of frames.filter((f) => f.depth === frame.depth + 1)) {
+            if (parentFrame.score < 0)
+                continue;
+            const drop = parentFrame.score - frame.score;
+            if (drop > 0 && (!rootCause || drop > rootCause.drop)) {
+                rootCause = { frame, previousFrame: parentFrame, drop };
+            }
+        }
+    }
+    return {
+        startId,
+        startScore: startEntry.score,
+        frames,
+        rootCause,
+    };
+}
+/**
+ * Format a QualityStackTrace as human-readable text.
+ */
+export function formatQualityTrace(trace) {
+    if (trace.frames.length === 0) {
+        return `Quality Trace: no data for ${trace.startId}`;
+    }
+    const lines = [`Quality Trace (score: ${trace.startScore.toFixed(2)} at ${trace.startId}):`];
+    for (const frame of trace.frames) {
+        const scoreStr = frame.score >= 0 ? frame.score.toFixed(2) : '?';
+        const link = frame.linkedBy ? ` (via ${frame.linkedBy})` : '';
+        const factors = frame.factors.length > 0 ? ` — ${frame.factors.join(', ')}` : '';
+        lines.push(`  at ${frame.runtimeStageId.padEnd(30)} score=${scoreStr}${link}${factors}`);
+    }
+    if (trace.rootCause) {
+        lines.push('');
+        lines.push(`Root cause: quality dropped at ${trace.rootCause.frame.runtimeStageId} ` +
+            `(${trace.rootCause.previousFrame.score.toFixed(2)} → ${trace.rootCause.frame.score.toFixed(2)}, ` +
+            `Δ${trace.rootCause.drop.toFixed(2)})`);
+    }
+    return lines.join('\n');
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"qualityTrace.js","sourceRoot":"","sources":["../../../../src/lib/recorder/qualityTrace.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * qualityTrace() — Quality Stack Trace built on causalChain().\n *\n * Thin layer over `memory/backtrack.causalChain()` that decorates\n * each causal node with quality scores from a QualityRecorder.\n *\n * ```\n * Quality Trace (score: 0.3 at call-llm#5):\n *   at call-llm#5     score=0.3  ← quality dropped here\n *   at system-prompt#1 score=0.8  ← systemPrompt was good\n *   at seed#0          score=1.0  ← input was clean\n *\n * Root cause: quality dropped at call-llm#5 (0.8 → 0.3, Δ0.5)\n * ```\n */\n\nimport { causalChain, flattenCausalDAG } from '../memory/backtrack.js';\nimport type { CommitBundle } from '../memory/types.js';\nimport type { KeyedRecorder } from './KeyedRecorder.js';\nimport type { QualityEntry } from './QualityRecorder.js';\n\n/** A single frame in the quality stack trace. */\nexport interface QualityFrame {\n  runtimeStageId: string;\n  stageName: string;\n  score: number;\n  factors: string[];\n  linkedBy: string;\n  depth: number;\n}\n\n/** The full quality stack trace. */\nexport interface QualityStackTrace {\n  startId: string;\n  startScore: number;\n  frames: QualityFrame[];\n  rootCause?: {\n    frame: QualityFrame;\n    previousFrame: QualityFrame;\n    drop: number;\n  };\n}\n\n/**\n * Build a quality stack trace by decorating a causal chain with scores.\n *\n * @param commitLog        From executor.getSnapshot().commitLog\n * @param qualityRecorder  QualityRecorder attached during execution\n * @param startId          runtimeStageId to start from\n * @param maxDepth         Maximum backtracking depth (default: 20)\n */\nexport function qualityTrace(\n  commitLog: CommitBundle[],\n  qualityRecorder: KeyedRecorder<QualityEntry>,\n  startId: string,\n  maxDepth = 20,\n): QualityStackTrace {\n  const startEntry = qualityRecorder.getByKey(startId);\n  if (!startEntry) {\n    return { startId, startScore: -1, frames: [] };\n  }\n\n  // Use causalChain to build the DAG, providing keysRead from the QualityRecorder\n  const root = causalChain(commitLog, startId, (id) => qualityRecorder.getByKey(id)?.keysRead ?? [], { maxDepth });\n\n  if (!root) {\n    return { startId, startScore: startEntry.score, frames: [] };\n  }\n\n  // Flatten DAG to BFS-ordered frames, decorate with quality scores\n  const nodes = flattenCausalDAG(root);\n  const frames: QualityFrame[] = nodes.map((node) => {\n    const entry = qualityRecorder.getByKey(node.runtimeStageId);\n    return {\n      runtimeStageId: node.runtimeStageId,\n      stageName: node.stageName,\n      score: entry?.score ?? -1,\n      factors: entry?.factors ?? [],\n      linkedBy: node.linkedBy,\n      depth: node.depth,\n    };\n  });\n\n  // Find root cause: biggest quality drop between adjacent frames (BFS order)\n  let rootCause: QualityStackTrace['rootCause'];\n  for (let i = 0; i < frames.length; i++) {\n    const frame = frames[i];\n    // Look at each parent (frames at depth + 1)\n    for (const parentFrame of frames.filter((f) => f.depth === frame.depth + 1)) {\n      if (parentFrame.score < 0) continue;\n      const drop = parentFrame.score - frame.score;\n      if (drop > 0 && (!rootCause || drop > rootCause.drop)) {\n        rootCause = { frame, previousFrame: parentFrame, drop };\n      }\n    }\n  }\n\n  return {\n    startId,\n    startScore: startEntry.score,\n    frames,\n    rootCause,\n  };\n}\n\n/**\n * Format a QualityStackTrace as human-readable text.\n */\nexport function formatQualityTrace(trace: QualityStackTrace): string {\n  if (trace.frames.length === 0) {\n    return `Quality Trace: no data for ${trace.startId}`;\n  }\n\n  const lines: string[] = [`Quality Trace (score: ${trace.startScore.toFixed(2)} at ${trace.startId}):`];\n\n  for (const frame of trace.frames) {\n    const scoreStr = frame.score >= 0 ? frame.score.toFixed(2) : '?';\n    const link = frame.linkedBy ? ` (via ${frame.linkedBy})` : '';\n    const factors = frame.factors.length > 0 ? ` — ${frame.factors.join(', ')}` : '';\n    lines.push(`  at ${frame.runtimeStageId.padEnd(30)} score=${scoreStr}${link}${factors}`);\n  }\n\n  if (trace.rootCause) {\n    lines.push('');\n    lines.push(\n      `Root cause: quality dropped at ${trace.rootCause.frame.runtimeStageId} ` +\n        `(${trace.rootCause.previousFrame.score.toFixed(2)} → ${trace.rootCause.frame.score.toFixed(2)}, ` +\n        `Δ${trace.rootCause.drop.toFixed(2)})`,\n    );\n  }\n\n  return lines.join('\\n');\n}\n"]}

package/dist/esm/trace.js

@@ -23,8 +23,11 @@
 export { buildRuntimeStageId, createExecutionCounter, parseRuntimeStageId } from './lib/engine/runtimeStageId.js';
 // Commit log queries — typed utilities for backtracking
 export { findCommit, findCommits, findLastWriter } from './lib/memory/commitLogUtils.js';
+export { causalChain, flattenCausalDAG, formatCausalChain } from './lib/memory/backtrack.js';
 // KeyedRecorder — base class for 1:1 Map-based recorders
 export { KeyedRecorder } from './lib/recorder/KeyedRecorder.js';
 // SequenceRecorder — base class for 1:N ordered sequence recorders with keyed index
 export { SequenceRecorder } from './lib/recorder/SequenceRecorder.js';
-//# sourceMappingURL=data:application/json;base64,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
+export { QualityRecorder } from './lib/recorder/QualityRecorder.js';
+export { formatQualityTrace, qualityTrace } from './lib/recorder/qualityTrace.js';
+//# sourceMappingURL=data:application/json;base64,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