@miller-tech/uap 1.175.13 → 1.178.0

package/dist/delivery/edit-match.d.ts

@@ -0,0 +1,134 @@
+/**
+ * Edit-tool matching (harness plan area A, 2026-07-31).
+ *
+ * WHY this file exists: the harness-disclosure literature reports that changing
+ * ONLY the edit-tool format moved a fixed model from 6.7% to 68.3% on SWE-bench
+ * (Pi Research / Grok Code Fast, cited in arXiv 2605.23950). The same paper
+ * measures harness variance at 7.8x model variance. The edit tool is the single
+ * highest-leverage surface in the tool layer, and ours was strict-exact-match:
+ * one whitespace character off and the turn was dead, with an error message that
+ * told the model to "match exactly" — which is precisely the thing it had just
+ * failed to do.
+ *
+ * The strategy ladder implemented here:
+ *
+ *   1. EXACT      — byte-identical substring. Unchanged, always tried first, so
+ *                   a model that gets it right sees identical behaviour.
+ *   2. TOLERANT   — line-aligned match after per-line whitespace normalisation
+ *                   (leading/trailing trimmed, internal runs collapsed). Catches
+ *                   the dominant real miss: right code, wrong indentation.
+ *   3. NEAREST    — no match at all, so instead of "not found" we return the
+ *                   closest region of the file with line numbers, turning a dead
+ *                   turn into a corrective one.
+ *
+ * Everything here is PURE (string in, decision out) so the ladder is unit
+ * testable without a model, a file system, or a delivery run.
+ */
+/** How a needle was located in the haystack. */
+export type EditMatchKind = 
+/** Byte-identical substring found (possibly several — see `count`). */
+'exact'
+/** Found only after per-line whitespace normalisation. */
+ | 'tolerant'
+/** Found more than once and the caller gave no disambiguator. */
+ | 'ambiguous'
+/** Not found by any strategy. */
+ | 'miss';
+export interface EditMatch {
+    kind: EditMatchKind;
+    /** Character offset of the matched span. -1 when `kind` is 'miss'/'ambiguous'. */
+    index: number;
+    /** Length of the matched span in characters. 0 when there is no span. */
+    length: number;
+    /** How many candidate matches the winning strategy found. */
+    count: number;
+    /**
+     * Operator/model-facing explanation. For 'tolerant' this names the whitespace
+     * drift so the model learns; for 'miss' it carries the nearest-match report.
+     */
+    note?: string;
+    /**
+     * Leading whitespace of the FILE line the tolerant span starts on, and of the
+     * needle's first line. `applyEditMatch` re-indents the replacement by their
+     * delta: without it a tolerant match splices the model's (wrong) indentation
+     * in at the target site, which is cosmetic in C-like languages and a syntax
+     * error in Python.
+     */
+    targetIndent?: string;
+    needleIndent?: string;
+    /**
+     * True when the matched span excludes the trailing newline (the tolerant rung
+     * is line-aligned). `applyEditMatch` strips one trailing newline from the
+     * replacement so the exact and tolerant rungs cannot produce different line
+     * counts for the same (old, new) pair.
+     */
+    lineAligned?: boolean;
+}
+export interface EditMatchOptions {
+    /** 1-based occurrence selector, as the `edit_file` tool exposes it. */
+    occurrence?: number | null;
+    /**
+     * Allow the whitespace-tolerant rung. Defaults to true. This is a harness
+     * KNOB, deliberately: `ToolMod` in the self-harness search space flips it so
+     * the paired bench can measure whether tolerance helps or hurts, rather than
+     * us asserting that it helps.
+     */
+    tolerant?: boolean;
+    /** Include the nearest-match report on a miss. Defaults to true. */
+    diagnostics?: boolean;
+    /**
+     * Treat leading whitespace as significant (Python/YAML/Make/...). Callers pass
+     * `isIndentSensitive(path)`. Defaults to false.
+     */
+    indentSensitive?: boolean;
+}
+export declare function isIndentSensitive(path: string): boolean;
+/**
+ * Build the nearest-match report shown when nothing matched.
+ *
+ * The model's failure is almost always "my memory of the file is stale", so the
+ * single most useful thing we can hand back is the CURRENT text of the region it
+ * was aiming at, with line numbers it can feed straight into `edit_range`.
+ */
+export declare function nearestMatchReport(haystack: string, needle: string, maxLines?: number): string;
+/**
+ * Locate `oldStr` in `current` using the exact -> tolerant -> miss ladder.
+ *
+ * Contract: a returned 'exact' or 'tolerant' match is safe to apply verbatim by
+ * slicing at [index, index+length). 'ambiguous' and 'miss' carry a `note` that
+ * is already model-facing prose.
+ */
+export declare function resolveEditMatch(current: string, oldStr: string, options?: EditMatchOptions): EditMatch;
+/**
+ * Apply a resolved match. Caller must have checked `kind` is exact/tolerant.
+ *
+ * Two corrections happen only on the line-aligned (tolerant) path, because only
+ * there does the matched span differ in shape from what the model sent:
+ *
+ *  - RE-INDENT. The span starts at column 0 of the matched line while the needle
+ *    may have been unindented, so splicing verbatim would move the code to
+ *    column 0. We rebase the replacement onto the target's indentation.
+ *  - TRAILING NEWLINE. The span excludes the line break that follows it, so a
+ *    `new_string` ending in "\n" would add a blank line — making the same
+ *    (old, new) pair produce different files depending on which rung fired.
+ */
+export declare function applyEditMatch(current: string, match: EditMatch, newStr: string): string;
+export interface RangeEditResult {
+    ok: boolean;
+    /** Updated text when ok. */
+    text?: string;
+    /** Model-facing reason when not ok. */
+    error?: string;
+    /** Number of lines the range covered, for the success note. */
+    replacedLines?: number;
+}
+/**
+ * Replace an inclusive 1-based LINE RANGE.
+ *
+ * Why this exists alongside `edit_file`: a model that cannot reproduce exact
+ * whitespace can still count lines, and `read_file` hands it numbered context.
+ * This gives the ladder a rung that does not depend on reproducing file bytes at
+ * all — the failure mode the tolerant rung only softens.
+ */
+export declare function applyRangeEdit(current: string, startLine: number, endLine: number, newText: string): RangeEditResult;
+//# sourceMappingURL=edit-match.d.ts.map

package/dist/delivery/edit-match.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edit-match.d.ts","sourceRoot":"","sources":["../../src/delivery/edit-match.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,gDAAgD;AAChD,MAAM,MAAM,aAAa;AACvB,uEAAuE;AACrE,OAAO;AACT,0DAA0D;GACxD,UAAU;AACZ,iEAAiE;GAC/D,WAAW;AACb,iCAAiC;GAC/B,MAAM,CAAC;AAEX,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,aAAa,CAAC;IACpB,kFAAkF;IAClF,KAAK,EAAE,MAAM,CAAC;IACd,yEAAyE;IACzE,MAAM,EAAE,MAAM,CAAC;IACf,6DAA6D;IAC7D,KAAK,EAAE,MAAM,CAAC;IACd;;;OAGG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;;;;OAMG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;;OAKG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED,MAAM,WAAW,gBAAgB;IAC/B,uEAAuE;IACvE,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,oEAAoE;IACpE,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB;;;OAGG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AA0CD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEvD;AA4ED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,SAAI,GAAG,MAAM,CAkCzF;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,gBAAqB,GAC7B,SAAS,CAoFX;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAqBxF;AAED,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,OAAO,CAAC;IACZ,4BAA4B;IAC5B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,uCAAuC;IACvC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,+DAA+D;IAC/D,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,GACd,eAAe,CAuBjB"}

package/dist/delivery/edit-match.js

@@ -0,0 +1,331 @@
+/**
+ * Edit-tool matching (harness plan area A, 2026-07-31).
+ *
+ * WHY this file exists: the harness-disclosure literature reports that changing
+ * ONLY the edit-tool format moved a fixed model from 6.7% to 68.3% on SWE-bench
+ * (Pi Research / Grok Code Fast, cited in arXiv 2605.23950). The same paper
+ * measures harness variance at 7.8x model variance. The edit tool is the single
+ * highest-leverage surface in the tool layer, and ours was strict-exact-match:
+ * one whitespace character off and the turn was dead, with an error message that
+ * told the model to "match exactly" — which is precisely the thing it had just
+ * failed to do.
+ *
+ * The strategy ladder implemented here:
+ *
+ *   1. EXACT      — byte-identical substring. Unchanged, always tried first, so
+ *                   a model that gets it right sees identical behaviour.
+ *   2. TOLERANT   — line-aligned match after per-line whitespace normalisation
+ *                   (leading/trailing trimmed, internal runs collapsed). Catches
+ *                   the dominant real miss: right code, wrong indentation.
+ *   3. NEAREST    — no match at all, so instead of "not found" we return the
+ *                   closest region of the file with line numbers, turning a dead
+ *                   turn into a corrective one.
+ *
+ * Everything here is PURE (string in, decision out) so the ladder is unit
+ * testable without a model, a file system, or a delivery run.
+ */
+/**
+ * Normalise ONE line for tolerant comparison: collapse internal whitespace runs
+ * and drop trailing whitespace. Leading whitespace is dropped only when the file
+ * is not indentation-sensitive.
+ *
+ * `preserveIndent` exists because INDENTATION IS SEMANTIC in Python, YAML,
+ * Makefiles and Nim. Without it,
+ *
+ *     if x:          if x:
+ *         a()            a()
+ *     b()                b()
+ *
+ * normalise identically, and a tolerant match binds an anchor in one block to
+ * the other — a silent wrong-block edit on a default-on path. For those files we
+ * keep the indent exact and only forgive internal/trailing spacing.
+ *
+ * Deliberately NOT normalising anything else. Case, punctuation and quote style
+ * are all semantic in code — a match that ignored them would apply an edit the
+ * model did not ask for, which is far worse than a failed edit.
+ */
+function normalizeLine(line, preserveIndent = false) {
+    // Split indent from body FIRST. Collapsing the whole line would squash the
+    // leading run to a single space too, so 4-space and 8-space indents would
+    // normalise identically and `preserveIndent` would preserve nothing.
+    const indent = indentOf(line);
+    const body = line.slice(indent.length).replace(/\s+/g, ' ').trimEnd();
+    return preserveIndent ? indent + body : body;
+}
+/** Leading-whitespace prefix of a line. */
+function indentOf(line) {
+    return /^[ \t]*/.exec(line)?.[0] ?? '';
+}
+/**
+ * Extensions whose semantics depend on leading whitespace. A tolerant match in
+ * one of these must not forgive indentation.
+ */
+const INDENT_SENSITIVE = /\.(py|pyi|yaml|yml|nim|coffee|haml|slim|sass|pug|jade)$|(^|\/)Makefile$/i;
+export function isIndentSensitive(path) {
+    return INDENT_SENSITIVE.test(path);
+}
+/** Character offset at which each line starts, plus a terminating sentinel. */
+function lineOffsets(text) {
+    const offsets = [0];
+    for (let i = 0; i < text.length; i++) {
+        if (text[i] === '\n')
+            offsets.push(i + 1);
+    }
+    return offsets;
+}
+/**
+ * Token-overlap similarity in [0,1] between two normalised lines. Used only to
+ * RANK candidates for the nearest-match report — never to decide an edit.
+ */
+function similarity(a, b) {
+    if (a === b)
+        return 1;
+    const at = a.split(' ').filter(Boolean);
+    const bt = b.split(' ').filter(Boolean);
+    if (at.length === 0 || bt.length === 0)
+        return 0;
+    const bCounts = new Map();
+    for (const t of bt)
+        bCounts.set(t, (bCounts.get(t) ?? 0) + 1);
+    let shared = 0;
+    for (const t of at) {
+        const n = bCounts.get(t) ?? 0;
+        if (n > 0) {
+            shared++;
+            bCounts.set(t, n - 1);
+        }
+    }
+    return (2 * shared) / (at.length + bt.length);
+}
+/**
+ * Find every line-window in `haystack` whose whitespace-normalised form equals
+ * the normalised `needle`. Returns character spans.
+ *
+ * Line-aligned by construction: a needle that starts or ends mid-line simply
+ * finds nothing here and falls through to the miss rung. That is the safe
+ * direction — a mid-line tolerant match would have to guess where the span ends.
+ */
+function tolerantSpans(haystack, needle, preserveIndent) {
+    const needleLines = needle.split('\n');
+    // A needle with a trailing newline yields an empty final element; dropping it
+    // lets "block plus newline" match the same lines as "block".
+    if (needleLines.length > 1 && needleLines[needleLines.length - 1] === '')
+        needleLines.pop();
+    const wanted = needleLines.map((l) => normalizeLine(l, preserveIndent));
+    if (wanted.length === 0 || wanted.every((l) => l === ''))
+        return [];
+    const hayLines = haystack.split('\n');
+    const offsets = lineOffsets(haystack);
+    const spans = [];
+    for (let start = 0; start + wanted.length <= hayLines.length; start++) {
+        let ok = true;
+        for (let k = 0; k < wanted.length; k++) {
+            if (normalizeLine(hayLines[start + k], preserveIndent) !== wanted[k]) {
+                ok = false;
+                break;
+            }
+        }
+        if (!ok)
+            continue;
+        const index = offsets[start];
+        const lastLine = start + wanted.length - 1;
+        // End of the span = end of the last matched line, newline NOT included, so
+        // the replacement cannot swallow the line break that follows it.
+        const end = offsets[lastLine] + hayLines[lastLine].length;
+        spans.push({ index, length: end - index, indent: indentOf(hayLines[start]) });
+    }
+    return spans;
+}
+/**
+ * Build the nearest-match report shown when nothing matched.
+ *
+ * The model's failure is almost always "my memory of the file is stale", so the
+ * single most useful thing we can hand back is the CURRENT text of the region it
+ * was aiming at, with line numbers it can feed straight into `edit_range`.
+ */
+export function nearestMatchReport(haystack, needle, maxLines = 8) {
+    const needleLines = needle
+        .split('\n')
+        .map((l) => normalizeLine(l))
+        .filter((l) => l !== '');
+    if (needleLines.length === 0)
+        return '';
+    const hayLines = haystack.split('\n');
+    const anchor = needleLines[0];
+    let bestLine = -1;
+    let bestScore = 0;
+    for (let i = 0; i < hayLines.length; i++) {
+        const score = similarity(anchor, normalizeLine(hayLines[i]));
+        if (score > bestScore) {
+            bestScore = score;
+            bestLine = i;
+        }
+    }
+    // Below this the "nearest" line is noise and quoting it would mislead.
+    if (bestLine < 0 || bestScore < 0.34)
+        return '';
+    const from = Math.max(0, bestLine - 2);
+    // Bounded by maxLines, NOT by the needle length: this text goes straight back
+    // into the model's context, and a 200-line old_string must not echo 200 lines.
+    const to = Math.min(hayLines.length - 1, bestLine + Math.max(1, maxLines - 2));
+    const excerpt = hayLines
+        .slice(from, to + 1)
+        .map((l, i) => `${String(from + i + 1).padStart(5)}| ${l}`)
+        .join('\n');
+    return (`Nearest region in the CURRENT file (lines ${from + 1}-${to + 1}, ` +
+        `best anchor line ${bestLine + 1}):\n${excerpt}\n` +
+        `Copy the exact text above, or use edit_range with start_line/end_line.`);
+}
+/**
+ * Locate `oldStr` in `current` using the exact -> tolerant -> miss ladder.
+ *
+ * Contract: a returned 'exact' or 'tolerant' match is safe to apply verbatim by
+ * slicing at [index, index+length). 'ambiguous' and 'miss' carry a `note` that
+ * is already model-facing prose.
+ */
+export function resolveEditMatch(current, oldStr, options = {}) {
+    const { occurrence = null, tolerant = true, diagnostics = true, indentSensitive = false, } = options;
+    // --- Rung 1: exact -------------------------------------------------------
+    const exactCount = oldStr.length === 0 ? 0 : current.split(oldStr).length - 1;
+    if (exactCount > 0) {
+        if (exactCount > 1 && occurrence == null) {
+            return {
+                kind: 'ambiguous',
+                index: -1,
+                length: 0,
+                count: exactCount,
+                note: `old_string matches ${exactCount} times — add surrounding context or pass occurrence (1-based).`,
+            };
+        }
+        const which = occurrence ?? 1;
+        if (!Number.isInteger(which) || which < 1 || which > exactCount) {
+            return {
+                kind: 'ambiguous',
+                index: -1,
+                length: 0,
+                count: exactCount,
+                note: `occurrence ${String(occurrence)} out of range (1..${exactCount}).`,
+            };
+        }
+        let idx = -1;
+        for (let i = 0; i < which; i++)
+            idx = current.indexOf(oldStr, idx + 1);
+        return { kind: 'exact', index: idx, length: oldStr.length, count: exactCount };
+    }
+    // --- Rung 2: whitespace-tolerant ----------------------------------------
+    if (tolerant) {
+        const spans = tolerantSpans(current, oldStr, indentSensitive);
+        if (spans.length > 0) {
+            // UNIQUENESS IS REQUIRED here, and `occurrence` is deliberately NOT used to
+            // disambiguate. The model chose its occurrence index against what it
+            // believed the EXACT matches were; the normalised candidate list has
+            // different membership and ordering, so honouring it would silently land
+            // the edit at an unrelated site and still report success.
+            if (spans.length > 1) {
+                return {
+                    kind: 'ambiguous',
+                    index: -1,
+                    length: 0,
+                    count: spans.length,
+                    note: `old_string did not match exactly, and matches ${spans.length} places once whitespace ` +
+                        `is normalised — that is too ambiguous to guess at. Re-read the file and copy the exact ` +
+                        `text, or use edit_range with explicit line numbers.`,
+                };
+            }
+            const span = spans[0];
+            const needleFirst = oldStr.split('\n')[0] ?? '';
+            return {
+                kind: 'tolerant',
+                index: span.index,
+                length: span.length,
+                count: 1,
+                targetIndent: span.indent,
+                needleIndent: indentOf(needleFirst),
+                lineAligned: true,
+                note: 'old_string did not match byte-for-byte; matched after normalising whitespace. ' +
+                    'The edit was applied — re-read the file before the next edit so your anchors are current.',
+            };
+        }
+    }
+    // --- Rung 3: miss, with diagnostics -------------------------------------
+    const report = diagnostics ? nearestMatchReport(current, oldStr) : '';
+    return {
+        kind: 'miss',
+        index: -1,
+        length: 0,
+        count: 0,
+        note: report
+            ? `old_string not found.\n${report}`
+            : 'old_string not found — re-read the file and match the CURRENT content.',
+    };
+}
+/**
+ * Apply a resolved match. Caller must have checked `kind` is exact/tolerant.
+ *
+ * Two corrections happen only on the line-aligned (tolerant) path, because only
+ * there does the matched span differ in shape from what the model sent:
+ *
+ *  - RE-INDENT. The span starts at column 0 of the matched line while the needle
+ *    may have been unindented, so splicing verbatim would move the code to
+ *    column 0. We rebase the replacement onto the target's indentation.
+ *  - TRAILING NEWLINE. The span excludes the line break that follows it, so a
+ *    `new_string` ending in "\n" would add a blank line — making the same
+ *    (old, new) pair produce different files depending on which rung fired.
+ */
+export function applyEditMatch(current, match, newStr) {
+    let replacement = newStr;
+    if (match.lineAligned) {
+        if (replacement.endsWith('\n'))
+            replacement = replacement.slice(0, -1);
+        const target = match.targetIndent ?? '';
+        const needle = match.needleIndent ?? '';
+        if (target !== needle) {
+            replacement = replacement
+                .split('\n')
+                .map((line, i) => {
+                // Blank lines stay blank — indenting them just adds trailing whitespace.
+                if (line.trim() === '')
+                    return line;
+                const stripped = needle && line.startsWith(needle) ? line.slice(needle.length) : line;
+                // The first line is always rebased; later lines keep their relative
+                // indentation, which stripping the common needle prefix preserves.
+                return i === 0 ? target + stripped.trimStart() : target + stripped;
+            })
+                .join('\n');
+        }
+    }
+    return current.slice(0, match.index) + replacement + current.slice(match.index + match.length);
+}
+/**
+ * Replace an inclusive 1-based LINE RANGE.
+ *
+ * Why this exists alongside `edit_file`: a model that cannot reproduce exact
+ * whitespace can still count lines, and `read_file` hands it numbered context.
+ * This gives the ladder a rung that does not depend on reproducing file bytes at
+ * all — the failure mode the tolerant rung only softens.
+ */
+export function applyRangeEdit(current, startLine, endLine, newText) {
+    const lines = current.split('\n');
+    if (!Number.isInteger(startLine) || !Number.isInteger(endLine)) {
+        return { ok: false, error: 'start_line and end_line must be integers (1-based, inclusive).' };
+    }
+    if (startLine < 1 || endLine < startLine) {
+        return { ok: false, error: `invalid range ${startLine}..${endLine} (need 1 <= start_line <= end_line).` };
+    }
+    if (endLine > lines.length) {
+        return {
+            ok: false,
+            error: `end_line ${endLine} is past the end of the file (${lines.length} lines) — re-read it.`,
+        };
+    }
+    // A trailing newline on new_text would inject a blank line, because the join
+    // below re-adds the separator. Strip exactly one.
+    const replacement = newText.endsWith('\n') ? newText.slice(0, -1) : newText;
+    const updated = [
+        ...lines.slice(0, startLine - 1),
+        ...replacement.split('\n'),
+        ...lines.slice(endLine),
+    ].join('\n');
+    return { ok: true, text: updated, replacedLines: endLine - startLine + 1 };
+}
+//# sourceMappingURL=edit-match.js.map

package/dist/delivery/edit-match.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"edit-match.js","sourceRoot":"","sources":["../../src/delivery/edit-match.ts"],"names":[],"mappings":"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"}

package/dist/memory/dynamic-retrieval.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dynamic-retrieval.d.ts","sourceRoot":"","sources":["../../src/memory/dynamic-retrieval.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"dynamic-retrieval.d.ts","sourceRoot":"","sources":["../../src/memory/dynamic-retrieval.ts"],"names":[],"mappings":"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"}

package/dist/memory/dynamic-retrieval.js

@@ -471,6 +471,19 @@ async function queryAllMemorySources(taskInstruction, classification, entities,
             source: 'terminal-bench-knowledge',
         });
     }
+    // Source 7: ACTIVE RECONSTRUCTION (harness plan E, agent path).
+    //
+    // An ADDITIONAL source, never a replacement. Review of the CLI wiring caught
+    // the opposite shape — `--active` replaced two-tier retrieval with a graph
+    // over one tier, silently narrowing the corpus. Here every passive source
+    // above has already run; this contributes the associative hops they cannot
+    // make (reaching a memory the query never names, via a shared tag), and its
+    // results flow through the same dedup + budget as everything else.
+    //
+    // Opt-in and fail-open: off unless UAP_MEMORY_ACTIVE=1 with a non-empty
+    // graph, and any error leaves the other sources untouched.
+    const activeMemories = await queryActiveReconstruction(taskInstruction, projectRoot, depth);
+    memories.push(...activeMemories);
     // Deduplicate and sort by relevance
     const uniqueMemories = deduplicateMemories(memories);
     uniqueMemories.sort((a, b) => b.relevance - a.relevance);
@@ -488,6 +501,50 @@ async function queryAllMemorySources(taskInstruction, classification, entities,
     }
     return budgeted;
 }
+/**
+ * Recall by traversing the cue-tag-content graph while reasoning (harness plan E).
+ *
+ * Refreshes only when the index is STALE. A full store scan on every model turn
+ * would put a latency regression on the hot path of every agent, paid whether or
+ * not the graph helped; never refreshing would serve an index that silently ages
+ * out. The TTL is the compromise.
+ *
+ * Relevance is deliberately capped below the top of the passive range. These are
+ * associative hops — genuinely useful, but reached by structure rather than by
+ * direct match — so they should fill remaining budget, not displace a memory the
+ * query named outright.
+ */
+async function queryActiveReconstruction(taskInstruction, projectRoot, depth) {
+    try {
+        const { shouldUseActiveRecall, recallActive } = await import('./reconstruct-store.js');
+        if (!shouldUseActiveRecall(projectRoot))
+            return [];
+        const result = await recallActive(projectRoot, taskInstruction, {
+            refresh: 'if-stale',
+            // Bounded by the same adaptive depth as every other source, so a complex
+            // query gets more hops and a simple one cannot balloon the context.
+            maxContext: Math.max(3, Math.min(12, depth.longTerm)),
+            maxSteps: 4,
+        });
+        return result.context.map((node, i) => ({
+            // Truncated like EVERY other source. The merged budget loop `break`s on
+            // the first item that overflows, so one multi-KB node landing mid-list
+            // would discard every lower-ranked memory beneath it — including real
+            // passive hits. No other source can produce an item large enough to do
+            // that, and this one must not either.
+            content: node.text.slice(0, 500),
+            type: node.layer === 'semantic' ? 'lesson' : 'context',
+            // Decay with admission order: earlier nodes were reached in earlier hops
+            // and sit closer to what the query actually asked about.
+            relevance: Math.max(0.35, 0.7 - i * 0.03),
+            source: 'active-reconstruction',
+        }));
+    }
+    catch {
+        // Fail open — a broken or missing graph must never degrade the passive path.
+        return [];
+    }
+}
 /**
  * Query short-term SQLite memory using FTS5 full-text search with LIKE fallback
  * OPTIMIZATION 12: Use FTS5 index (memories_fts) for better semantic matching