@nexrall/code-core 1.3.1 → 1.4.0

package/dist/agent/crossFile.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Cross-File Breakage Guard — deterministic dangling-reference detection.
+ *
+ * THE PROBLEM (a top real-world failure of every coding agent):
+ *   The agent edits file A — renames or deletes an exported function/class/
+ *   const — and forgets that files B, C, D still import or call the old name.
+ *   The edit to A succeeds, the agent moves on (often declaring success), and
+ *   the project no longer compiles. Because the tool call itself succeeded and
+ *   the model doesn't re-check the whole repo, this breakage is invisible until
+ *   a build/test runs — which the agent may never do. Frontier agents mitigate
+ *   this only by (sometimes) running a build afterwards; there is no structural
+ *   detector wired into the edit itself.
+ *
+ * THE APPROACH:
+ *   1. Diff the edit payload (old → new) to find EXPORTED top-level symbols that
+ *      were REMOVED or RENAMED (present in old, absent in new). This is a pure,
+ *      language-aware-ish regex pass — deterministic, no model output.
+ *   2. For each removed/renamed symbol, scan the rest of the workspace (ripgrep,
+ *      falling back to a bounded fs walk) for surviving references. If found, we
+ *      surface them as a WARNING appended to the edit's tool result — not a
+ *      refusal: the agent may legitimately be mid-refactor and about to fix the
+ *      call-sites next. The point is to make the blast radius VISIBLE at the
+ *      moment of the edit, so it can't be silently forgotten.
+ *
+ *   Language coverage is JS/TS-first (the primary ecosystem here) plus Python;
+ *   the symbol extractor degrades gracefully (returns nothing) for others rather
+ *   than emitting noise.
+ */
+export interface RemovedSymbol {
+    name: string;
+    kind: string;
+}
+/** Extract named exported/public symbols from a file's content. */
+export declare function extractExportedSymbols(path: string, content: string): RemovedSymbol[];
+/**
+ * Compare old vs new content of an edited file and return exported/public
+ * symbols that DISAPPEARED (removed or renamed). These are the names whose
+ * external call-sites may now be dangling.
+ */
+export declare function findRemovedExports(path: string, oldContent: string, newContent: string): RemovedSymbol[];
+export declare function isCheckableSymbol(name: string): boolean;
+//# sourceMappingURL=crossFile.d.ts.map

package/dist/agent/crossFile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crossFile.d.ts","sourceRoot":"","sources":["../../src/agent/crossFile.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd;AA6BD,mEAAmE;AACnE,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,aAAa,EAAE,CAiCrF;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,aAAa,EAAE,CAKxG;AAKD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAIvD"}

package/dist/agent/crossFile.js

@@ -0,0 +1,119 @@
+"use strict";
+/**
+ * Cross-File Breakage Guard — deterministic dangling-reference detection.
+ *
+ * THE PROBLEM (a top real-world failure of every coding agent):
+ *   The agent edits file A — renames or deletes an exported function/class/
+ *   const — and forgets that files B, C, D still import or call the old name.
+ *   The edit to A succeeds, the agent moves on (often declaring success), and
+ *   the project no longer compiles. Because the tool call itself succeeded and
+ *   the model doesn't re-check the whole repo, this breakage is invisible until
+ *   a build/test runs — which the agent may never do. Frontier agents mitigate
+ *   this only by (sometimes) running a build afterwards; there is no structural
+ *   detector wired into the edit itself.
+ *
+ * THE APPROACH:
+ *   1. Diff the edit payload (old → new) to find EXPORTED top-level symbols that
+ *      were REMOVED or RENAMED (present in old, absent in new). This is a pure,
+ *      language-aware-ish regex pass — deterministic, no model output.
+ *   2. For each removed/renamed symbol, scan the rest of the workspace (ripgrep,
+ *      falling back to a bounded fs walk) for surviving references. If found, we
+ *      surface them as a WARNING appended to the edit's tool result — not a
+ *      refusal: the agent may legitimately be mid-refactor and about to fix the
+ *      call-sites next. The point is to make the blast radius VISIBLE at the
+ *      moment of the edit, so it can't be silently forgotten.
+ *
+ *   Language coverage is JS/TS-first (the primary ecosystem here) plus Python;
+ *   the symbol extractor degrades gracefully (returns nothing) for others rather
+ *   than emitting noise.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractExportedSymbols = extractExportedSymbols;
+exports.findRemovedExports = findRemovedExports;
+exports.isCheckableSymbol = isCheckableSymbol;
+// ── Exported-symbol extraction ────────────────────────────────────────────────
+// Matches the common export forms. We only care about NAMED, top-level exports
+// because those are what other files import by name.
+const JS_EXPORT_RES = [
+    { kind: 'function', re: /\bexport\s+(?:async\s+)?function\s*\*?\s+([A-Za-z_$][\w$]*)/g },
+    { kind: 'class', re: /\bexport\s+(?:abstract\s+)?class\s+([A-Za-z_$][\w$]*)/g },
+    { kind: 'const', re: /\bexport\s+(?:const|let|var)\s+([A-Za-z_$][\w$]*)/g },
+    { kind: 'interface', re: /\bexport\s+interface\s+([A-Za-z_$][\w$]*)/g },
+    { kind: 'type', re: /\bexport\s+type\s+([A-Za-z_$][\w$]*)/g },
+    { kind: 'enum', re: /\bexport\s+(?:const\s+)?enum\s+([A-Za-z_$][\w$]*)/g },
+];
+// export { a, b as c } — the EXPORTED (outward) names are `a` and `c`.
+const JS_EXPORT_LIST_RE = /\bexport\s*\{([^}]*)\}/g;
+// Python: a module-level `def name` / `class Name` is the public surface.
+const PY_DEF_RES = [
+    { kind: 'def', re: /^def\s+([A-Za-z_][\w]*)/gm },
+    { kind: 'class', re: /^class\s+([A-Za-z_][\w]*)/gm },
+];
+function isJsLike(path) {
+    return /\.(?:m?[jt]sx?|cjs|cts|mts)$/.test(path);
+}
+function isPy(path) {
+    return /\.py$/.test(path);
+}
+/** Extract named exported/public symbols from a file's content. */
+function extractExportedSymbols(path, content) {
+    const out = new Map(); // name → kind (first wins)
+    const add = (name, kind) => {
+        if (name && !out.has(name))
+            out.set(name, kind);
+    };
+    if (isJsLike(path)) {
+        for (const { kind, re } of JS_EXPORT_RES) {
+            re.lastIndex = 0;
+            let m;
+            while ((m = re.exec(content)))
+                add(m[1], kind);
+        }
+        JS_EXPORT_LIST_RE.lastIndex = 0;
+        let lm;
+        while ((lm = JS_EXPORT_LIST_RE.exec(content))) {
+            for (const part of lm[1].split(',')) {
+                const seg = part.trim();
+                if (!seg || seg === 'default')
+                    continue;
+                // `orig as exported` → exported name is what matters; plain `name`.
+                const asMatch = /(?:\bas\s+)([A-Za-z_$][\w$]*)\s*$/.exec(seg);
+                const name = asMatch ? asMatch[1] : seg.replace(/\s.*$/, '');
+                if (name && name !== 'default')
+                    add(name, 'export');
+            }
+        }
+    }
+    else if (isPy(path)) {
+        for (const { kind, re } of PY_DEF_RES) {
+            re.lastIndex = 0;
+            let m;
+            while ((m = re.exec(content)))
+                add(m[1], kind);
+        }
+    }
+    return [...out.entries()].map(([name, kind]) => ({ name, kind }));
+}
+/**
+ * Compare old vs new content of an edited file and return exported/public
+ * symbols that DISAPPEARED (removed or renamed). These are the names whose
+ * external call-sites may now be dangling.
+ */
+function findRemovedExports(path, oldContent, newContent) {
+    const before = extractExportedSymbols(path, oldContent);
+    if (before.length === 0)
+        return [];
+    const afterNames = new Set(extractExportedSymbols(path, newContent).map((s) => s.name));
+    return before.filter((s) => !afterNames.has(s.name));
+}
+// Identifier-ish names worth checking. Skip very short / trivial names that would
+// produce noisy matches (e.g. `x`, `id`, `on`), and common words that collide.
+const NOISY_NAMES = new Set(['default', 'index', 'main', 'test', 'get', 'set', 'run', 'app', 'data', 'item', 'value']);
+function isCheckableSymbol(name) {
+    if (name.length < 4)
+        return false;
+    if (NOISY_NAMES.has(name.toLowerCase()))
+        return false;
+    return /^[A-Za-z_$][\w$]*$/.test(name);
+}
+//# sourceMappingURL=crossFile.js.map

package/dist/agent/editCompleteness.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Edit-Completeness Guard — deterministic detection of silent code destruction.
+ *
+ * THE PROBLEM (a failure mode every coding agent still exhibits):
+ *   When an agent rewrites a whole file with `write_file`, it often gets "lazy"
+ *   and replaces large chunks of real code with an elision placeholder:
+ *       // ... rest of the code stays the same
+ *       # ... existing imports unchanged
+ *       /* ... keep the previous implementation ... *\/
+ *   The written file looks plausible and syntactically fine, the agent reports
+ *   "done" — but the elided code is GONE. This is unrecoverable data loss inside
+ *   the user's working tree. Editors mitigate it by preferring diff-style edits,
+ *   but a full-file `write_file` remains a live footgun on every agent.
+ *
+ *   A second, related bug: writing a file that still contains unresolved merge
+ *   conflict markers (<<<<<<<, =======, >>>>>>>) — always a mistake.
+ *
+ * THE APPROACH (deterministic, content-only — cannot be hallucinated away):
+ *   Scan the NEW content for elision placeholders (a comment lead + an explicit
+ *   "rest/remaining/unchanged/existing/keep/omitted…" keyword). A bare `// ...`
+ *   or a `...args` spread never matches — the keyword requirement keeps false
+ *   positives near zero. When such a placeholder is written OVER an existing
+ *   file, it is almost certainly destroying elided code, so we REFUSE the write
+ *   and tell the agent to either send the full content or use edit_file for a
+ *   targeted change. Merge-conflict markers are refused for any write.
+ *
+ *   This is a REFUSAL (not a nudge) because the loss is silent and irreversible
+ *   — exactly the class where failing closed is correct. New-file creation is
+ *   exempt from the elision rule (a brand-new file cannot lose existing code),
+ *   but merge markers are refused even there.
+ */
+export interface CompletenessProblem {
+    kind: 'elision-placeholder' | 'merge-conflict-marker';
+    reason: string;
+    /** The offending line (trimmed, capped) for the error message. */
+    sample: string;
+}
+/**
+ * Inspect NEW file content (optionally against whether it overwrites an existing
+ * file). Returns the FIRST problem found, or null when the write looks complete.
+ *
+ * @param newContent   the content about to be written
+ * @param overwriting  true when an existing file is being replaced (enables the
+ *                     elision-placeholder rule; a new file can't lose code)
+ */
+export declare function checkEditCompleteness(newContent: string, overwriting: boolean): CompletenessProblem | null;
+//# sourceMappingURL=editCompleteness.d.ts.map

package/dist/agent/editCompleteness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"editCompleteness.d.ts","sourceRoot":"","sources":["../../src/agent/editCompleteness.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,qBAAqB,GAAG,uBAAuB,CAAC;IACtD,MAAM,EAAE,MAAM,CAAC;IACf,kEAAkE;IAClE,MAAM,EAAE,MAAM,CAAC;CAChB;AAiCD;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,OAAO,GAAG,mBAAmB,GAAG,IAAI,CAoC1G"}

package/dist/agent/editCompleteness.js

@@ -0,0 +1,109 @@
+"use strict";
+/**
+ * Edit-Completeness Guard — deterministic detection of silent code destruction.
+ *
+ * THE PROBLEM (a failure mode every coding agent still exhibits):
+ *   When an agent rewrites a whole file with `write_file`, it often gets "lazy"
+ *   and replaces large chunks of real code with an elision placeholder:
+ *       // ... rest of the code stays the same
+ *       # ... existing imports unchanged
+ *       /* ... keep the previous implementation ... *\/
+ *   The written file looks plausible and syntactically fine, the agent reports
+ *   "done" — but the elided code is GONE. This is unrecoverable data loss inside
+ *   the user's working tree. Editors mitigate it by preferring diff-style edits,
+ *   but a full-file `write_file` remains a live footgun on every agent.
+ *
+ *   A second, related bug: writing a file that still contains unresolved merge
+ *   conflict markers (<<<<<<<, =======, >>>>>>>) — always a mistake.
+ *
+ * THE APPROACH (deterministic, content-only — cannot be hallucinated away):
+ *   Scan the NEW content for elision placeholders (a comment lead + an explicit
+ *   "rest/remaining/unchanged/existing/keep/omitted…" keyword). A bare `// ...`
+ *   or a `...args` spread never matches — the keyword requirement keeps false
+ *   positives near zero. When such a placeholder is written OVER an existing
+ *   file, it is almost certainly destroying elided code, so we REFUSE the write
+ *   and tell the agent to either send the full content or use edit_file for a
+ *   targeted change. Merge-conflict markers are refused for any write.
+ *
+ *   This is a REFUSAL (not a nudge) because the loss is silent and irreversible
+ *   — exactly the class where failing closed is correct. New-file creation is
+ *   exempt from the elision rule (a brand-new file cannot lose existing code),
+ *   but merge markers are refused even there.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkEditCompleteness = checkEditCompleteness;
+// Comment leads across languages: // # /* * <!-- -- ; %  (best-effort).
+// The placeholder must combine a comment lead, an ellipsis OR an elision verb,
+// and an explicit "the-rest-is-unchanged" keyword. Requiring the keyword is what
+// prevents matching legitimate `// ...` separators, `...spread`, Python `...`,
+// docstrings, or ranges.
+const ELISION_KEYWORD = '(?:rest|remaining|remainder|unchanged|existing|previous|prior|same\\s+as|as\\s+before|keep\\s+(?:the|existing|current)|leave\\s+(?:the|existing)|other\\s+(?:methods|functions|imports|code)|the\\s+(?:same|rest)|omitted|snip(?:ped)?|truncat(?:ed|ion)|no\\s+changes?|implementation\\s+(?:stays|remains|unchanged)|code\\s+(?:here|continues|stays|remains|unchanged)|continues?\\s+(?:as|below|above)|goes?\\s+here)';
+// A comment line that contains an ellipsis/elipsis-ish token AND the keyword.
+// Two shapes:
+//   1. comment + "..." + keyword     → "// ... rest of the code"
+//   2. comment + keyword + "..."     → "# existing imports ..."
+//   3. comment + keyword (no dots)   → "// rest of the file unchanged"
+const COMMENT_LEAD = '(?:\\/\\/+|#+|\\/\\*+|\\*|<!--|--|;+|%+)';
+const ELISION_RES = [
+    new RegExp(`^\\s*${COMMENT_LEAD}\\s*(?:\\.\\.\\.|…)\\s*[\\w\\s'"()-]*?\\b${ELISION_KEYWORD}\\b`, 'i'),
+    new RegExp(`^\\s*${COMMENT_LEAD}\\s*[\\w\\s'"()-]*?\\b${ELISION_KEYWORD}\\b[\\w\\s'"()-]*?(?:\\.\\.\\.|…)`, 'i'),
+    new RegExp(`^\\s*${COMMENT_LEAD}\\s*(?:\\.\\.\\.|…)?\\s*(?:the\\s+)?${ELISION_KEYWORD}\\s+(?:of\\s+)?(?:the\\s+)?(?:code|file|function|method|imports?|class|logic|implementation|content)\\b`, 'i'),
+    // A short comment line that ENDS in a strong "left-out" keyword:
+    //   "// other methods unchanged"  ·  "# rest omitted"  ·  "// snipped"
+    new RegExp(`^\\s*${COMMENT_LEAD}\\s*[\\w\\s'"()-]{0,60}?\\b(?:unchanged|omitted|snip(?:ped)?|truncated|elided|not\\s+shown)\\s*(?:\\*\\/|-->|)?\\s*$`, 'i'),
+];
+// Merge-conflict markers at line start (7 identical chars is the git default).
+// `<<<<<<<` and `>>>>>>>` are effectively never legitimate content. A bare line
+// of `=======` IS common (markdown heading underline, ASCII dividers), so it is
+// only treated as a conflict marker when a `<<<<<<<`/`>>>>>>>` also appears
+// (i.e. a genuine conflict hunk), handled in checkEditCompleteness.
+const CONFLICT_START_RE = /^(?:<{7}|>{7})(?:\s|$)/;
+const CONFLICT_MID_RE = /^={7}(?:\s|$)/;
+/**
+ * Inspect NEW file content (optionally against whether it overwrites an existing
+ * file). Returns the FIRST problem found, or null when the write looks complete.
+ *
+ * @param newContent   the content about to be written
+ * @param overwriting  true when an existing file is being replaced (enables the
+ *                     elision-placeholder rule; a new file can't lose code)
+ */
+function checkEditCompleteness(newContent, overwriting) {
+    if (typeof newContent !== 'string' || newContent.length === 0)
+        return null;
+    const lines = newContent.split('\n');
+    // Merge-conflict markers — refuse for any write (new or overwrite). A `<<<<<<<`
+    // or `>>>>>>>` line alone is conclusive; a `=======` line is only a marker when
+    // it co-occurs with a start/end marker (avoids flagging markdown/ASCII rules).
+    let sawStartOrEnd = null;
+    let sawMid = null;
+    for (const line of lines) {
+        if (CONFLICT_START_RE.test(line)) {
+            sawStartOrEnd = line.trim();
+            break;
+        }
+        if (CONFLICT_MID_RE.test(line) && sawMid === null)
+            sawMid = line.trim();
+    }
+    if (sawStartOrEnd || (sawMid && lines.some((l) => CONFLICT_START_RE.test(l)))) {
+        return {
+            kind: 'merge-conflict-marker',
+            reason: 'content still contains an unresolved merge-conflict marker',
+            sample: (sawStartOrEnd ?? sawMid ?? '').slice(0, 120),
+        };
+    }
+    if (!overwriting)
+        return null; // new file cannot elide pre-existing code
+    for (const line of lines) {
+        for (const re of ELISION_RES) {
+            if (re.test(line)) {
+                return {
+                    kind: 'elision-placeholder',
+                    reason: 'content contains an elision placeholder that would silently delete the omitted code',
+                    sample: line.trim().slice(0, 120),
+                };
+            }
+        }
+    }
+    return null;
+}
+//# sourceMappingURL=editCompleteness.js.map

package/dist/agent/flaky.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Flaky-Test Detection — deterministic non-determinism guard.
+ *
+ * THE PROBLEM (a subtle failure every coding agent shares):
+ *   A test suite that passes and fails intermittently — timing races, ordering
+ *   dependence, RNG without a seed, wall-clock assumptions, network — poisons the
+ *   agent's single most-trusted signal. Two bad outcomes follow:
+ *     1. The agent "fixes" a flaky failure by editing unrelated code, chasing a
+ *        ghost, or worse, by weakening the test (reward hacking).
+ *     2. The agent simply RE-RUNS the suite until it happens to go green and then
+ *        declares success — a green run of a flaky test proves nothing. Frontier
+ *        agents have no structural way to notice they are doing this.
+ *
+ * THE APPROACH (deterministic — derived from the run history, not model output):
+ *   We already record every verification run (command + pass/fail) in the
+ *   progress ledger. Tag each run with a monotonically-increasing "mutation
+ *   epoch" that increments whenever a source file is written. Then: if the SAME
+ *   normalized command produced BOTH a pass and a fail while the epoch never
+ *   changed between them (i.e. NO edit happened in between), the outcome flipped
+ *   with identical inputs → the test is flaky (or environment-dependent). That is
+ *   a mathematical fact about the observed runs, not a guess.
+ *
+ *   On detection we surface a one-shot warning telling the agent to stop trusting
+ *   a green run, investigate the source of non-determinism, and NOT paper over it
+ *   by re-running or by editing the test to pass. Never blocks.
+ */
+export interface VerificationRun {
+    /** Normalized command (already sliced/trimmed by the ledger). */
+    cmd: string;
+    ok: boolean;
+    /** Mutation epoch at the time this run executed (see ledger). */
+    epoch: number;
+}
+export interface FlakyFinding {
+    cmd: string;
+    /** How many passes and fails were observed at the SAME epoch. */
+    passes: number;
+    fails: number;
+}
+export declare function normalizeVerifyCmd(cmd: string): string;
+/**
+ * Scan verification history for commands that produced BOTH pass and fail at the
+ * SAME mutation epoch (no edit between the differing outcomes). Returns one
+ * finding per flaky command.
+ */
+export declare function detectFlaky(runs: VerificationRun[]): FlakyFinding[];
+//# sourceMappingURL=flaky.d.ts.map

package/dist/agent/flaky.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flaky.d.ts","sourceRoot":"","sources":["../../src/agent/flaky.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,MAAM,WAAW,eAAe;IAC9B,iEAAiE;IACjE,GAAG,EAAE,MAAM,CAAC;IACZ,EAAE,EAAE,OAAO,CAAC;IACZ,iEAAiE;IACjE,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,YAAY;IAC3B,GAAG,EAAE,MAAM,CAAC;IACZ,iEAAiE;IACjE,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf;AAKD,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAOtD;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,eAAe,EAAE,GAAG,YAAY,EAAE,CAqBnE"}

package/dist/agent/flaky.js

@@ -0,0 +1,79 @@
+"use strict";
+/**
+ * Flaky-Test Detection — deterministic non-determinism guard.
+ *
+ * THE PROBLEM (a subtle failure every coding agent shares):
+ *   A test suite that passes and fails intermittently — timing races, ordering
+ *   dependence, RNG without a seed, wall-clock assumptions, network — poisons the
+ *   agent's single most-trusted signal. Two bad outcomes follow:
+ *     1. The agent "fixes" a flaky failure by editing unrelated code, chasing a
+ *        ghost, or worse, by weakening the test (reward hacking).
+ *     2. The agent simply RE-RUNS the suite until it happens to go green and then
+ *        declares success — a green run of a flaky test proves nothing. Frontier
+ *        agents have no structural way to notice they are doing this.
+ *
+ * THE APPROACH (deterministic — derived from the run history, not model output):
+ *   We already record every verification run (command + pass/fail) in the
+ *   progress ledger. Tag each run with a monotonically-increasing "mutation
+ *   epoch" that increments whenever a source file is written. Then: if the SAME
+ *   normalized command produced BOTH a pass and a fail while the epoch never
+ *   changed between them (i.e. NO edit happened in between), the outcome flipped
+ *   with identical inputs → the test is flaky (or environment-dependent). That is
+ *   a mathematical fact about the observed runs, not a guess.
+ *
+ *   On detection we surface a one-shot warning telling the agent to stop trusting
+ *   a green run, investigate the source of non-determinism, and NOT paper over it
+ *   by re-running or by editing the test to pass. Never blocks.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeVerifyCmd = normalizeVerifyCmd;
+exports.detectFlaky = detectFlaky;
+// Normalize a command so trivially-different invocations of the same suite group
+// together: collapse whitespace, drop a leading `cd … &&`, strip common
+// non-semantic flags that don't change WHICH tests run.
+function normalizeVerifyCmd(cmd) {
+    let c = cmd.trim().replace(/\s+/g, ' ');
+    c = c.replace(/^cd\s+[^&]+&&\s*/i, '');
+    // Drop reporter/verbosity/color flags that don't change the test SELECTION.
+    c = c.replace(/\s--(?:reporter|reporters|verbose|silent|color|no-color|colors|coverage)(?:=\S+)?/gi, '');
+    c = c.replace(/\s-v\b/g, '');
+    return c.trim();
+}
+/**
+ * Scan verification history for commands that produced BOTH pass and fail at the
+ * SAME mutation epoch (no edit between the differing outcomes). Returns one
+ * finding per flaky command.
+ */
+function detectFlaky(runs) {
+    // Group by (normalized cmd, epoch) → tally pass/fail.
+    const groups = new Map();
+    for (const r of runs) {
+        const norm = normalizeVerifyCmd(r.cmd);
+        const key = `${r.epoch}\u0000${norm}`;
+        let g = groups.get(key);
+        if (!g) {
+            g = { cmd: norm, passes: 0, fails: 0 };
+            groups.set(key, g);
+        }
+        if (r.ok)
+            g.passes += 1;
+        else
+            g.fails += 1;
+    }
+    // A group with BOTH a pass and a fail (same epoch, same command) is flaky.
+    // Aggregate across epochs so we report each command once.
+    const byCmd = new Map();
+    for (const g of groups.values()) {
+        if (g.passes > 0 && g.fails > 0) {
+            const prev = byCmd.get(g.cmd);
+            if (prev) {
+                prev.passes += g.passes;
+                prev.fails += g.fails;
+            }
+            else
+                byCmd.set(g.cmd, { cmd: g.cmd, passes: g.passes, fails: g.fails });
+        }
+    }
+    return [...byCmd.values()];
+}
+//# sourceMappingURL=flaky.js.map

package/dist/agent/loop.d.ts

@@ -1,5 +1,11 @@
 import type { Message, AgentLoopOptions } from '../types';
 export declare function resolveMaxIterations(optionValue: number | undefined, settingsRaw: Record<string, unknown>): number;
+/** Approximate serialised request-body size (bytes) for the messages array. */
+export declare function estimateBodyBytes(messages: Message[]): number;
+/** Tools that mutate the filesystem — used by the verification nudge (GAP D). */
+export declare const WRITE_TOOL_NAMES: Set<string>;
+/** Heuristic: does a bash command look like it's running tests/build/lint/typecheck? (GAP D) */
+export declare const VERIFY_CMD_RE: RegExp;
 /**
  * Find the latest index ≤ maxIdx where history can be cut safely.
  *
@@ -14,5 +20,58 @@ export declare function resolveMaxIterations(optionValue: number | undefined, se
  * exactly when a long task needs it most.
  */
 export declare function findSafeCutIndex(messages: Message[], maxIdx: number): number;
+/**
+ * Render messages to a plain-text transcript for the summariser (tool noise
+ * truncated per-block AND the whole transcript hard-capped). When the transcript
+ * would exceed MAX_TRANSCRIPT_CHARS we keep the HEAD (original task + early
+ * decisions) and the TAIL (most-recent, highest-signal context) and drop the
+ * middle — a middle-out elision that preserves both "what we set out to do" and
+ * "where we are now", which is what the continuation summary needs most.
+ */
+export declare function transcriptOf(messages: Message[]): string;
+export interface ProgressLedger {
+    filesTouched: Map<string, {
+        tool: string;
+        edits: number;
+    }>;
+    verifications: Array<{
+        cmd: string;
+        ok: boolean;
+        epoch: number;
+    }>;
+    /** Test-integrity findings (reward-hacking signals) that must survive compaction. */
+    testIntegrity: Array<{
+        path: string;
+        reason: string;
+    }>;
+    /**
+     * Monotonic mutation epoch: incremented on every successful source write. Two
+     * verification runs sharing an epoch had NO edit between them, so a PASS↔FAIL
+     * flip across that boundary proves the test is flaky (see detectFlaky).
+     */
+    epoch: number;
+}
+export declare function createLedger(): ProgressLedger;
+/** Record one tool call's effect on the ledger (deterministic, no model call). */
+export declare function ledgerRecord(ledger: ProgressLedger, toolName: string, input: Record<string, unknown> | undefined, ok: boolean): void;
+/** Render the ledger as a compact, verbatim block for the compaction preamble. */
+export declare function ledgerSummary(ledger: ProgressLedger): string;
+/**
+ * Lossy-but-structure-preserving prune: shrink OLD, large tool_result blocks in
+ * place, keeping the last PRUNE_KEEP_RECENT messages untouched. This is tried
+ * BEFORE summarisation because it:
+ *   • keeps every turn and every tool_use/tool_result pair (API stays valid),
+ *   • never makes an extra model call (summarisation does — cost + latency),
+ *   • degrades gracefully on repeat (summarise-of-summarise loses the most on
+ *     long runs; pruning just trims already-consumed output further).
+ *
+ * IMPORTANT: pruned state is encoded in the content string (PRUNE_MARKER_TAIL
+ * suffix), NOT as an extra property on the block — a stray field on a content
+ * block is rejected by the Anthropic API as an unknown key (400). This keeps the
+ * serialised body schema-clean while remaining idempotent across repeat calls.
+ *
+ * Returns the number of bytes reclaimed (0 if nothing was prunable).
+ */
+export declare function pruneOldToolResults(messages: Message[]): number;
 export declare function runAgentLoop(initialMessages: Message[], options: AgentLoopOptions): Promise<Message[]>;
 //# sourceMappingURL=loop.d.ts.map

package/dist/agent/loop.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"loop.d.ts","sourceRoot":"","sources":["../../src/agent/loop.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EAMP,gBAAgB,EACjB,MAAM,UAAU,CAAC;AAmKlB,wBAAgB,oBAAoB,CAClC,WAAW,EAAE,MAAM,GAAG,SAAS,EAC/B,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACnC,MAAM,CAWR;AAgRD;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAK5E;AA6ED,wBAAsB,YAAY,CAChC,eAAe,EAAE,OAAO,EAAE,EAC1B,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,OAAO,EAAE,CAAC,CA+WpB"}
+{"version":3,"file":"loop.d.ts","sourceRoot":"","sources":["../../src/agent/loop.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EAMP,gBAAgB,EACjB,MAAM,UAAU,CAAC;AAqKlB,wBAAgB,oBAAoB,CAClC,WAAW,EAAE,MAAM,GAAG,SAAS,EAC/B,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACnC,MAAM,CAWR;AA8RD,+EAA+E;AAC/E,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,MAAM,CAM7D;AAsBD,iFAAiF;AACjF,eAAO,MAAM,gBAAgB,aAA+G,CAAC;AAC7I,gGAAgG;AAChG,eAAO,MAAM,aAAa,QAA2J,CAAC;AAEtL;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAK5E;AAUD;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,MAAM,CAwBxD;AAoBD,MAAM,WAAW,cAAc;IAC7B,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC3D,aAAa,EAAE,KAAK,CAAC;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,OAAO,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAClE,qFAAqF;IACrF,aAAa,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACvD;;;;OAIG;IACH,KAAK,EAAE,MAAM,CAAC;CACf;AAED,wBAAgB,YAAY,IAAI,cAAc,CAE7C;AAED,kFAAkF;AAClF,wBAAgB,YAAY,CAC1B,MAAM,EAAE,cAAc,EACtB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,EAC1C,EAAE,EAAE,OAAO,GACV,IAAI,CAkCN;AAED,kFAAkF;AAClF,wBAAgB,aAAa,CAAC,MAAM,EAAE,cAAc,GAAG,MAAM,CA6B5D;AAmBD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,MAAM,CAmB/D;AA2FD,wBAAsB,YAAY,CAChC,eAAe,EAAE,OAAO,EAAE,EAC1B,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,OAAO,EAAE,CAAC,CA6epB"}