@nexrall/code-core 1.4.0 → 1.4.2

package/dist/agent/claimEvidence.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Claim-vs-Evidence Guard — deterministic verification-hallucination detection.
+ *
+ * THE PROBLEM (the core of "verification hallucination", unsolved by every
+ * frontier coding agent):
+ *   When an agent finishes, it writes a natural-language summary. Under pressure
+ *   to appear done, it frequently CLAIMS verification it never performed:
+ *       "I ran the full test suite and all 42 tests pass."
+ *       "Verified the build succeeds and the feature works correctly."
+ *   …while in this session it ran NO test/build command at all, or the one it
+ *   ran FAILED. The user reads the confident claim and believes the work is
+ *   done. Prompt instructions ("don't lie") don't fix it — there is no
+ *   structural check that a stated verification actually happened and passed.
+ *
+ * THE APPROACH (deterministic — the evidence side is machine-tracked):
+ *   The ProgressLedger already records, from structured tool data (not model
+ *   output), every verification command that ran this session and whether it
+ *   PASSED or FAILED. This guard scans the agent's FINAL message for explicit
+ *   verification claims ("tests pass", "build succeeds", "verified it works")
+ *   and compares them against that ledger:
+ *     - claim present + NO passing verification on record  → contradiction
+ *     - claim present + the latest matching run FAILED      → contradiction
+ *   A contradiction triggers a one-shot nudge asking the agent to either run a
+ *   real verification and let it pass, or remove the unsupported claim. It is a
+ *   nudge (not a hard block): the ledger only knows about recognised verify
+ *   commands, so a legitimate manual/out-of-band check should be allowed to
+ *   stand once the agent says so.
+ *
+ *   Only the CLAIM detection is heuristic (text). The EVIDENCE is fully
+ *   deterministic, so the guard never fabricates a contradiction out of thin
+ *   air — it can only flag a claim that the machine record does not support.
+ */
+/** A single verification record as kept by the ProgressLedger. */
+export interface VerificationRecord {
+    /** The command (or tool) that ran, e.g. "npm test" / "run_api_tests". */
+    cmd: string;
+    /** true = the verification PASSED, false = it FAILED. */
+    ok: boolean;
+    /** Mutation epoch it ran at (bumped on each source write). */
+    epoch: number;
+}
+export interface ClaimEvidenceResult {
+    /** The agent's text contains a concrete verification claim. */
+    claimed: boolean;
+    /** The claim is NOT backed by a passing verification in the ledger. */
+    contradicted: boolean;
+    /** Short phrases from the text that read as verification claims (for the nudge). */
+    claimPhrases: string[];
+    /** Human-readable reason for the contradiction (empty when not contradicted). */
+    reason: string;
+}
+/**
+ * Does the agent's final text make a concrete verification claim? Returns the
+ * matched phrases (deduped, capped) so the nudge can quote them back. Phrases
+ * preceded by a hedge/conditional within the same clause are ignored.
+ */
+export declare function detectVerificationClaims(text: string): string[];
+/**
+ * Compare the agent's final message against the deterministic verification
+ * ledger. `currentEpoch` is the ledger's current mutation epoch; a passing
+ * verification only counts as current evidence if no source write happened
+ * after it (i.e. its epoch === currentEpoch) — a pass from BEFORE the latest
+ * edit no longer proves the current code works.
+ */
+export declare function checkClaimEvidence(finalText: string, verifications: VerificationRecord[], currentEpoch: number): ClaimEvidenceResult;
+/** Build the one-shot nudge message body for a contradicted claim. */
+export declare function claimEvidenceNudgeText(result: ClaimEvidenceResult): string;
+//# sourceMappingURL=claimEvidence.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"claimEvidence.d.ts","sourceRoot":"","sources":["../../src/agent/claimEvidence.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,kEAAkE;AAClE,MAAM,WAAW,kBAAkB;IACjC,yEAAyE;IACzE,GAAG,EAAE,MAAM,CAAC;IACZ,yDAAyD;IACzD,EAAE,EAAE,OAAO,CAAC;IACZ,8DAA8D;IAC9D,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,mBAAmB;IAClC,+DAA+D;IAC/D,OAAO,EAAE,OAAO,CAAC;IACjB,uEAAuE;IACvE,YAAY,EAAE,OAAO,CAAC;IACtB,oFAAoF;IACpF,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,iFAAiF;IACjF,MAAM,EAAE,MAAM,CAAC;CAChB;AAiCD;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAwB/D;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,MAAM,EACjB,aAAa,EAAE,kBAAkB,EAAE,EACnC,YAAY,EAAE,MAAM,GACnB,mBAAmB,CA4BrB;AAED,sEAAsE;AACtE,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,mBAAmB,GAAG,MAAM,CAQ1E"}

package/dist/agent/claimEvidence.js

@@ -0,0 +1,146 @@
+"use strict";
+/**
+ * Claim-vs-Evidence Guard — deterministic verification-hallucination detection.
+ *
+ * THE PROBLEM (the core of "verification hallucination", unsolved by every
+ * frontier coding agent):
+ *   When an agent finishes, it writes a natural-language summary. Under pressure
+ *   to appear done, it frequently CLAIMS verification it never performed:
+ *       "I ran the full test suite and all 42 tests pass."
+ *       "Verified the build succeeds and the feature works correctly."
+ *   …while in this session it ran NO test/build command at all, or the one it
+ *   ran FAILED. The user reads the confident claim and believes the work is
+ *   done. Prompt instructions ("don't lie") don't fix it — there is no
+ *   structural check that a stated verification actually happened and passed.
+ *
+ * THE APPROACH (deterministic — the evidence side is machine-tracked):
+ *   The ProgressLedger already records, from structured tool data (not model
+ *   output), every verification command that ran this session and whether it
+ *   PASSED or FAILED. This guard scans the agent's FINAL message for explicit
+ *   verification claims ("tests pass", "build succeeds", "verified it works")
+ *   and compares them against that ledger:
+ *     - claim present + NO passing verification on record  → contradiction
+ *     - claim present + the latest matching run FAILED      → contradiction
+ *   A contradiction triggers a one-shot nudge asking the agent to either run a
+ *   real verification and let it pass, or remove the unsupported claim. It is a
+ *   nudge (not a hard block): the ledger only knows about recognised verify
+ *   commands, so a legitimate manual/out-of-band check should be allowed to
+ *   stand once the agent says so.
+ *
+ *   Only the CLAIM detection is heuristic (text). The EVIDENCE is fully
+ *   deterministic, so the guard never fabricates a contradiction out of thin
+ *   air — it can only flag a claim that the machine record does not support.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectVerificationClaims = detectVerificationClaims;
+exports.checkClaimEvidence = checkClaimEvidence;
+exports.claimEvidenceNudgeText = claimEvidenceNudgeText;
+// Verification-claim phrases. Each must assert that a check RAN and SUCCEEDED —
+// not a mere intention ("you should run the tests") or a request. We require an
+// outcome word (pass/succeed/green/works/confirmed) tied to a verification noun
+// (test/suite/build/lint/typecheck/compile) OR a small set of standalone idioms
+// ("all tests pass", "everything works", "verified"). Kept deliberately tight to
+// avoid flagging hedged language ("this should work", "the tests would pass").
+const CLAIM_RES = [
+    // "(all) tests pass / passed / are passing / pass successfully"
+    /\b(?:all\s+)?(?:unit\s+|integration\s+|the\s+)?tests?\s+(?:now\s+)?(?:pass(?:es|ed|ing)?|are\s+passing|succeed(?:ed|s)?|are\s+green)\b/i,
+    // "the test suite passes / passed"
+    /\btest\s+suite\s+(?:now\s+)?(?:pass(?:es|ed)?|succeed(?:ed|s)?|is\s+green)\b/i,
+    // "the build succeeds / passes / is green / compiles (cleanly)"
+    /\b(?:the\s+)?build\s+(?:now\s+)?(?:succeed(?:ed|s)?|pass(?:es|ed)?|is\s+green|compiles?(?:\s+clean(?:ly)?)?)\b/i,
+    // "compiles / compiled without errors", "type-checks pass", "lint passes"
+    /\b(?:compil(?:es|ed)|type[-\s]?check(?:s|ed|ing)?|typecheck(?:s|ed|ing)?|lint(?:s|ing)?)\s+(?:pass(?:es|ed)?|succeed(?:ed|s)?|clean(?:ly)?|without\s+(?:errors?|warnings?))\b/i,
+    // "I ran/verified/confirmed the tests|build" (past-tense execution + a check noun)
+    /\b(?:i\s+|we\s+)?(?:ran|executed|verified|confirmed)\s+(?:the\s+|all\s+)?(?:tests?|test\s+suite|build|lint|typecheck|type\s+check)\b/i,
+    // strong standalone idioms
+    /\ball\s+(?:tests?\s+)?(?:pass|passing|green)\b/i,
+    /\beverything\s+(?:passes|works|is\s+working|is\s+green)\b/i,
+    /\bverified\s+(?:that\s+)?(?:it|the\s+\w+)\s+works?\b/i,
+    /\bconfirmed\s+(?:that\s+)?(?:it|everything|the\s+\w+)\s+works?\b/i,
+];
+// Hedge / conditional markers that turn a "pass" phrase into an intention rather
+// than a claim of fact ("this WOULD make the tests pass", "you SHOULD run the
+// tests", "hopefully the build succeeds"). If one appears shortly BEFORE the
+// matched phrase, we don't treat it as a concrete claim.
+const HEDGE_RE = /\b(?:should|would|could|might|may|will|to\s+make|so\s+that|in\s+theory|hopefully|expect(?:ed)?\s+to|meant\s+to|supposed\s+to|need\s+to|please|make\s+sure|ensure|let'?s|if\s+)\b/i;
+/**
+ * Does the agent's final text make a concrete verification claim? Returns the
+ * matched phrases (deduped, capped) so the nudge can quote them back. Phrases
+ * preceded by a hedge/conditional within the same clause are ignored.
+ */
+function detectVerificationClaims(text) {
+    if (!text || typeof text !== 'string')
+        return [];
+    const found = new Set();
+    for (const re of CLAIM_RES) {
+        const flags = re.flags.includes('g') ? re.flags : re.flags + 'g';
+        const g = new RegExp(re.source, flags);
+        let m;
+        while ((m = g.exec(text))) {
+            if (!m[0]) {
+                if (g.lastIndex === m.index)
+                    g.lastIndex++;
+                continue;
+            }
+            // Look back a short window for a hedge marker in the same clause (stop at a
+            // sentence/clause boundary so a hedge in a PRIOR sentence doesn't suppress a
+            // genuine claim here).
+            const from = Math.max(0, m.index - 60);
+            const before = text.slice(from, m.index);
+            const clause = before.split(/[.!?;\n]/).pop() ?? before;
+            if (!HEDGE_RE.test(clause)) {
+                found.add(m[0].trim().replace(/\s+/g, ' ').toLowerCase());
+            }
+            if (g.lastIndex === m.index)
+                g.lastIndex++;
+            if (found.size >= 5)
+                break;
+        }
+        if (found.size >= 5)
+            break;
+    }
+    return [...found];
+}
+/**
+ * Compare the agent's final message against the deterministic verification
+ * ledger. `currentEpoch` is the ledger's current mutation epoch; a passing
+ * verification only counts as current evidence if no source write happened
+ * after it (i.e. its epoch === currentEpoch) — a pass from BEFORE the latest
+ * edit no longer proves the current code works.
+ */
+function checkClaimEvidence(finalText, verifications, currentEpoch) {
+    const claimPhrases = detectVerificationClaims(finalText);
+    if (claimPhrases.length === 0) {
+        return { claimed: false, contradicted: false, claimPhrases: [], reason: '' };
+    }
+    const recognised = verifications ?? [];
+    // Evidence that supports a "it works now" claim: a PASS at the CURRENT epoch
+    // (no edit invalidated it since). Passes at an older epoch are stale.
+    const currentPasses = recognised.filter((v) => v.ok && v.epoch === currentEpoch);
+    const currentFails = recognised.filter((v) => !v.ok && v.epoch === currentEpoch);
+    if (currentPasses.length > 0) {
+        // There is a fresh passing verification — the claim is supported.
+        return { claimed: true, contradicted: false, claimPhrases, reason: '' };
+    }
+    let reason;
+    if (recognised.length === 0) {
+        reason = 'no build/test/lint/typecheck command was run this session';
+    }
+    else if (currentFails.length > 0) {
+        reason = `the most recent verification (${currentFails[currentFails.length - 1].cmd}) FAILED and has not since passed`;
+    }
+    else {
+        // Only stale passes (from before the latest edit) exist.
+        reason = 'the last passing verification predates your most recent code change, so it no longer proves the current code works';
+    }
+    return { claimed: true, contradicted: true, claimPhrases, reason };
+}
+/** Build the one-shot nudge message body for a contradicted claim. */
+function claimEvidenceNudgeText(result) {
+    const quoted = result.claimPhrases.map((p) => `"${p}"`).join(', ');
+    return ('STOP — verification check. Your summary claims verification ' +
+        `(${quoted}) but ${result.reason}. ` +
+        'Do not state that tests pass / the build succeeds / it works unless a command actually proved it THIS session on the CURRENT code. ' +
+        'Either: (1) run the real build/test/lint/typecheck command now and fix anything that fails, then finish — or (2) if you genuinely cannot run it here (no test suite, environment limitation, out of scope), remove/soften the claim and state plainly what you did and did NOT verify. Do not repeat an unverified pass claim.');
+}
+//# sourceMappingURL=claimEvidence.js.map

package/dist/agent/loop.d.ts

@@ -53,7 +53,7 @@ export interface ProgressLedger {
 }
 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;
+export declare function ledgerRecord(ledger: ProgressLedger, toolName: string, input: Record<string, unknown> | undefined, ok: boolean, output?: string, exitCode?: number): void;
 /** Render the ledger as a compact, verbatim block for the compaction preamble. */
 export declare function ledgerSummary(ledger: ProgressLedger): string;
 /**

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;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"}
+{"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;AAsKlB,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,EACX,MAAM,CAAC,EAAE,MAAM,EACf,QAAQ,CAAC,EAAE,MAAM,GAChB,IAAI,CAoDN;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,CAqhBpB"}

package/dist/agent/loop.js

@@ -51,6 +51,7 @@ const sandbox_1 = require("../tools/sandbox");
 const index_1 = require("../plugins/index");
 const testIntegrity_1 = require("./testIntegrity");
 const flaky_1 = require("./flaky");
+const claimEvidence_1 = require("./claimEvidence");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const child_process_1 = require("child_process");
@@ -551,7 +552,7 @@ function createLedger() {
     return { filesTouched: new Map(), verifications: [], testIntegrity: [], epoch: 0 };
 }
 /** Record one tool call's effect on the ledger (deterministic, no model call). */
-function ledgerRecord(ledger, toolName, input, ok) {
+function ledgerRecord(ledger, toolName, input, ok, output, exitCode) {
     if (exports.WRITE_TOOL_NAMES.has(toolName)) {
         if (!ok)
             return; // a FAILED write changed nothing — not a durable fact
@@ -565,10 +566,22 @@ function ledgerRecord(ledger, toolName, input, ok) {
         }
         // Reward-hacking guard: if this write WEAKENED a test file, record it so the
         // signal survives compaction and can be surfaced before the agent finishes.
-        const ti = (0, testIntegrity_1.analyzeWriteToolForTestIntegrity)(toolName, input);
-        if (ti?.suspicious && p) {
-            for (const f of ti.findings) {
-                ledger.testIntegrity.push({ path: p, reason: f.reason });
+        const reasons = [];
+        // write_file overwrites carry a marker computed by the executor (which had the
+        // prior on-disk content) — it detects REMOVED assertions/cases, not just
+        // additive skips/tautologies. Prefer it when present.
+        const markerReasons = toolName === 'write_file' ? (0, testIntegrity_1.decodeTestIntegrityMarker)(output) : [];
+        if (markerReasons.length) {
+            reasons.push(...markerReasons);
+        }
+        else {
+            const ti = (0, testIntegrity_1.analyzeWriteToolForTestIntegrity)(toolName, input);
+            if (ti?.suspicious)
+                reasons.push(...ti.findings.map((f) => f.reason));
+        }
+        if (reasons.length && p) {
+            for (const reason of reasons) {
+                ledger.testIntegrity.push({ path: p, reason });
             }
             if (ledger.testIntegrity.length > LEDGER_MAX_NOTES * 2) {
                 ledger.testIntegrity.splice(0, ledger.testIntegrity.length - LEDGER_MAX_NOTES);
@@ -580,8 +593,16 @@ function ledgerRecord(ledger, toolName, input, ok) {
         if (cmd && exports.VERIFY_CMD_RE.test(cmd)) {
             // Record BOTH outcomes: a FAILED test/build is the single most important
             // fact to carry across a compaction (it tells the agent work is NOT done).
-            // ok===true means the command exited 0 (executor sets error on non-zero).
-            ledger.verifications.push({ cmd: cmd.slice(0, 120), ok, epoch: ledger.epoch });
+            //
+            // CRITICAL: `ok` is `result.error === undefined`, which is TRUE even when a
+            // test suite exits non-zero (the executor doesn't set `error` for a plain
+            // command failure — only for timeout/abort/spawn-fail). So `ok` alone would
+            // record a FAILING `npm test` as PASSED. The executor now reports the real
+            // process exit code via `exitCode`; a non-zero exit means the verification
+            // FAILED regardless of `ok`. Fall back to `ok` only when no exitCode is
+            // available (older tools / non-bash paths).
+            const passed = exitCode !== undefined ? exitCode === 0 : ok;
+            ledger.verifications.push({ cmd: cmd.slice(0, 120), ok: passed, epoch: ledger.epoch });
             if (ledger.verifications.length > LEDGER_MAX_NOTES * 2) {
                 ledger.verifications.splice(0, ledger.verifications.length - LEDGER_MAX_NOTES);
             }
@@ -809,6 +830,10 @@ async function runAgentLoop(initialMessages, options) {
     // Flaky-test guard: commands already nudged about, so we only warn about a
     // newly-detected flaky command once.
     const flakyNudgedCmds = new Set();
+    // Claim-vs-evidence guard: fire the "you claimed verified but there's no
+    // passing verification" nudge at most once, so a genuinely un-testable task
+    // (the agent explains it can't run tests) still ends instead of looping.
+    let claimEvidenceNudged = false;
     // GAP E — deterministic progress ledger, preserved verbatim across compactions.
     const ledger = createLedger();
     try {
@@ -1029,6 +1054,27 @@ async function runAgentLoop(initialMessages, options) {
                     });
                     continue;
                 }
+                // Claim-vs-evidence guard: the core of verification-hallucination. The agent
+                // is about to finish; if its final message CLAIMS a verification ("tests
+                // pass", "build succeeds", "verified it works") that the deterministic ledger
+                // does NOT back with a PASSING run on the current code, challenge it once.
+                // The claim side is heuristic text; the evidence side is machine-tracked, so
+                // we only flag claims the record actively contradicts.
+                if (!claimEvidenceNudged) {
+                    const finalText = assistantMessage.content
+                        .filter((b) => b.type === 'text' && typeof b.text === 'string')
+                        .map((b) => b.text)
+                        .join('\n');
+                    const ce = (0, claimEvidence_1.checkClaimEvidence)(finalText, ledger.verifications, ledger.epoch);
+                    if (ce.contradicted) {
+                        claimEvidenceNudged = true;
+                        messages.push({
+                            role: 'user',
+                            content: [{ type: 'text', text: (0, claimEvidence_1.claimEvidenceNudgeText)(ce) }],
+                        });
+                        continue;
+                    }
+                }
                 runSimpleHooks(hooks.PostMessageComplete, options.workDir);
                 completedCleanly = true;
                 break;
@@ -1110,23 +1156,38 @@ async function runAgentLoop(initialMessages, options) {
                         }
                     }
                 }
+                // Capture the raw output (may carry the invisible test-integrity
+                // marker from a write_file overwrite) for the ledger, then strip the
+                // marker so neither the UI (onToolResult) nor the model ever see it.
+                let rawOutput;
+                if (name === 'write_file' && result.output) {
+                    rawOutput = result.output;
+                    result.output = (0, testIntegrity_1.stripTestIntegrityMarker)(result.output);
+                }
                 // Notify caller about result
                 options.onToolResult(name, result);
-                return { block: { ...block, id }, result };
+                return { block: { ...block, id }, result, rawOutput };
             }));
             // Track whether files were mutated / verified this run, for the one-shot
             // end-of-task nudge below (GAP D — see declaration above).
-            for (const { block, result } of toolResults) {
+            for (const { block, result, rawOutput } of toolResults) {
                 const ok = result.error === undefined;
                 // GAP E — feed every successful effect into the deterministic ledger.
-                ledgerRecord(ledger, block.name, block.input, ok);
+                // rawOutput carries the (already-stripped-from-view) test-integrity marker.
+                // exitCode lets the ledger tell a PASSED verification from a FAILED one
+                // (a `npm test` that exits non-zero is not an `error`, but it IS a fail).
+                ledgerRecord(ledger, block.name, block.input, ok, rawOutput ?? result.output, result.exitCode);
                 if (!ok)
                     continue; // failed calls don't count either way
                 if (exports.WRITE_TOOL_NAMES.has(block.name))
                     filesMutatedSinceVerify = true;
                 else if (block.name === 'bash' && exports.VERIFY_CMD_RE.test(String(block.input?.command ?? ''))) {
-                    ranVerificationCmd = true;
-                    filesMutatedSinceVerify = false; // verified — reset until the next mutation
+                    // Only a PASSING verification satisfies the verify-nudge. A test suite that
+                    // ran but FAILED (non-zero exit) must NOT count as "verified" — otherwise the
+                    // agent could run a failing build once and then finish unchallenged.
+                    ranVerificationCmd = result.exitCode === undefined ? true : result.exitCode === 0;
+                    if (ranVerificationCmd)
+                        filesMutatedSinceVerify = false; // verified — reset until the next mutation
                 }
             }
             // 6. Build tool_result message and append to history

package/dist/agent/testIntegrity.d.ts

@@ -53,4 +53,10 @@ export declare function analyzeTestEdit(path: string, oldText: string, newText:
  * - write_file: ('', content) — additive-only detection (no prior content here)
  */
 export declare function analyzeWriteToolForTestIntegrity(toolName: string, input: Record<string, unknown> | undefined): TestIntegrityResult | null;
+/** Encode findings as an invisible marker to append to a tool's output string. */
+export declare function encodeTestIntegrityMarker(findings: TestEditFinding[]): string;
+/** Extract weakening reasons from a tool output that may carry the marker. */
+export declare function decodeTestIntegrityMarker(output: string | undefined): string[];
+/** Strip the (invisible) marker from output before it is shown to the model. */
+export declare function stripTestIntegrityMarker(output: string | undefined): string;
 //# sourceMappingURL=testIntegrity.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"testIntegrity.d.ts","sourceRoot":"","sources":["../../src/agent/testIntegrity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,MAAM,WAAW,eAAe;IAC9B,gEAAgE;IAChE,MAAM,EAAE,MAAM,CAAC;IACf,0CAA0C;IAC1C,IAAI,EAAE,YAAY,GAAG,mBAAmB,GAAG,iBAAiB,GAAG,kBAAkB,GAAG,gBAAgB,CAAC;CACtG;AAED,MAAM,WAAW,mBAAmB;IAClC,UAAU,EAAE,OAAO,CAAC;IACpB,UAAU,EAAE,OAAO,CAAC;IACpB,QAAQ,EAAE,eAAe,EAAE,CAAC;CAC7B;AAQD,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAGhD;AA4ED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,mBAAmB,CAmDnG;AAED;;;;;;;GAOG;AACH,wBAAgB,gCAAgC,CAC9C,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,GACzC,mBAAmB,GAAG,IAAI,CA2B5B"}
+{"version":3,"file":"testIntegrity.d.ts","sourceRoot":"","sources":["../../src/agent/testIntegrity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,MAAM,WAAW,eAAe;IAC9B,gEAAgE;IAChE,MAAM,EAAE,MAAM,CAAC;IACf,0CAA0C;IAC1C,IAAI,EAAE,YAAY,GAAG,mBAAmB,GAAG,iBAAiB,GAAG,kBAAkB,GAAG,gBAAgB,CAAC;CACtG;AAED,MAAM,WAAW,mBAAmB;IAClC,UAAU,EAAE,OAAO,CAAC;IACpB,UAAU,EAAE,OAAO,CAAC;IACpB,QAAQ,EAAE,eAAe,EAAE,CAAC;CAC7B;AAQD,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAGhD;AA4ED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,mBAAmB,CAmDnG;AAED;;;;;;;GAOG;AACH,wBAAgB,gCAAgC,CAC9C,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,GACzC,mBAAmB,GAAG,IAAI,CA8B5B;AAcD,kFAAkF;AAClF,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,eAAe,EAAE,GAAG,MAAM,CAI7E;AAED,8EAA8E;AAC9E,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,EAAE,CAQ9E;AAED,gFAAgF;AAChF,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAQ3E"}

package/dist/agent/testIntegrity.js

@@ -32,6 +32,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.isTestFile = isTestFile;
 exports.analyzeTestEdit = analyzeTestEdit;
 exports.analyzeWriteToolForTestIntegrity = analyzeWriteToolForTestIntegrity;
+exports.encodeTestIntegrityMarker = encodeTestIntegrityMarker;
+exports.decodeTestIntegrityMarker = decodeTestIntegrityMarker;
+exports.stripTestIntegrityMarker = stripTestIntegrityMarker;
 // ── Is this a test file? ──────────────────────────────────────────────────────
 // Covers the common conventions across JS/TS, Python, Go, Java/Kotlin, Ruby,
 // Rust, PHP, C#. Path-based (fast, language-agnostic).
@@ -192,8 +195,55 @@ function analyzeWriteToolForTestIntegrity(toolName, input) {
     if (toolName === 'write_file') {
         const content = typeof input.content === 'string' ? input.content : '';
         // No prior content available at this layer → additive-only ('' → content).
+        // The executor closes this gap: when write_file OVERWRITES an existing test
+        // file it has the prior on-disk content, runs the full old→new analysis, and
+        // embeds a TEST_INTEGRITY_MARKER in its output which ledgerRecord parses.
         return analyzeTestEdit(path, '', content);
     }
     return null;
 }
+// ── write_file overwrite bridge ────────────────────────────────────────────────
+// A write_file that overwrites an existing test file can silently REMOVE
+// assertions / test cases — invisible to analyzeWriteToolForTestIntegrity above
+// because the prior content isn't available at the loop layer. The executor DOES
+// have the prior content (it reads it to preserve mode / run the cross-file
+// check), so it runs analyzeTestEdit(path, priorContent, newContent) and, when
+// suspicious, appends a machine-readable marker to its tool output. ledgerRecord
+// parses that marker so a write_file overwrite gets the exact same ledger entry
+// and pre-finish nudge as an edit_file weakening would.
+const TEST_INTEGRITY_MARKER_OPEN = '\u0000NEXRALL_TEST_INTEGRITY\u0000';
+const TEST_INTEGRITY_MARKER_CLOSE = '\u0000/NEXRALL_TEST_INTEGRITY\u0000';
+/** Encode findings as an invisible marker to append to a tool's output string. */
+function encodeTestIntegrityMarker(findings) {
+    if (!findings.length)
+        return '';
+    const payload = findings.map((f) => f.reason).join('\u0001');
+    return `${TEST_INTEGRITY_MARKER_OPEN}${payload}${TEST_INTEGRITY_MARKER_CLOSE}`;
+}
+/** Extract weakening reasons from a tool output that may carry the marker. */
+function decodeTestIntegrityMarker(output) {
+    if (!output)
+        return [];
+    const start = output.indexOf(TEST_INTEGRITY_MARKER_OPEN);
+    if (start === -1)
+        return [];
+    const from = start + TEST_INTEGRITY_MARKER_OPEN.length;
+    const end = output.indexOf(TEST_INTEGRITY_MARKER_CLOSE, from);
+    if (end === -1)
+        return [];
+    return output.slice(from, end).split('\u0001').filter(Boolean);
+}
+/** Strip the (invisible) marker from output before it is shown to the model. */
+function stripTestIntegrityMarker(output) {
+    if (!output)
+        return output ?? '';
+    const start = output.indexOf(TEST_INTEGRITY_MARKER_OPEN);
+    if (start === -1)
+        return output;
+    const end = output.indexOf(TEST_INTEGRITY_MARKER_CLOSE, start);
+    if (end === -1)
+        return output;
+    const cleaned = output.slice(0, start) + output.slice(end + TEST_INTEGRITY_MARKER_CLOSE.length);
+    return cleaned.replace(/\n{3,}/g, '\n\n').trimEnd();
+}
 //# sourceMappingURL=testIntegrity.js.map

package/dist/index.d.ts

@@ -7,6 +7,7 @@ export * from './agent/testIntegrity';
 export * from './agent/editCompleteness';
 export * from './agent/crossFile';
 export * from './agent/flaky';
+export * from './agent/claimEvidence';
 export * from './mcp/client';
 export * from './mcp/httpClient';
 export * from './mcp/manager';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,kBAAkB,CAAC;AACjC,cAAc,cAAc,CAAC;AAC7B,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,mBAAmB,CAAC;AAClC,cAAc,eAAe,CAAC;AAC9B,cAAc,cAAc,CAAC;AAC7B,cAAc,kBAAkB,CAAC;AACjC,cAAc,eAAe,CAAC;AAC9B,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,iBAAiB,CAAC;AAChC,cAAc,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,kBAAkB,CAAC;AACjC,cAAc,cAAc,CAAC;AAC7B,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,mBAAmB,CAAC;AAClC,cAAc,eAAe,CAAC;AAC9B,cAAc,uBAAuB,CAAC;AACtC,cAAc,cAAc,CAAC;AAC7B,cAAc,kBAAkB,CAAC;AACjC,cAAc,eAAe,CAAC;AAC9B,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,iBAAiB,CAAC;AAChC,cAAc,qBAAqB,CAAC"}

package/dist/index.js

@@ -23,6 +23,7 @@ __exportStar(require("./agent/testIntegrity"), exports);
 __exportStar(require("./agent/editCompleteness"), exports);
 __exportStar(require("./agent/crossFile"), exports);
 __exportStar(require("./agent/flaky"), exports);
+__exportStar(require("./agent/claimEvidence"), exports);
 __exportStar(require("./mcp/client"), exports);
 __exportStar(require("./mcp/httpClient"), exports);
 __exportStar(require("./mcp/manager"), exports);

package/dist/tools/executor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"executor.d.ts","sourceRoot":"","sources":["../../src/tools/executor.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAC3C,OAAO,EAAyB,KAAK,aAAa,EAAE,MAAM,WAAW,CAAC;AAy8DtE,wBAAsB,WAAW,CAC/B,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,WAAW,CAAC,EAAE;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE,EAClC,OAAO,CAAC,EAAE,aAAa,EACvB,OAAO,CAAC,EAAE,MAAM,EAChB,UAAU,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,UAAU,CAAC,CAiBrB"}
+{"version":3,"file":"executor.d.ts","sourceRoot":"","sources":["../../src/tools/executor.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAC3C,OAAO,EAAyB,KAAK,aAAa,EAAE,MAAM,WAAW,CAAC;AAw9DtE,wBAAsB,WAAW,CAC/B,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,WAAW,CAAC,EAAE;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE,EAClC,OAAO,CAAC,EAAE,aAAa,EACvB,OAAO,CAAC,EAAE,MAAM,EAChB,UAAU,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,UAAU,CAAC,CAiBrB"}

package/dist/tools/executor.js

@@ -44,6 +44,7 @@ const child_process_1 = require("child_process");
 const sandbox_1 = require("./sandbox");
 const auth_1 = require("../auth");
 const editCompleteness_1 = require("../agent/editCompleteness");
+const testIntegrity_1 = require("../agent/testIntegrity");
 const crossFile_1 = require("../agent/crossFile");
 const client_1 = require("../api/client");
 const symbols_1 = require("./symbols");
@@ -370,7 +371,16 @@ async function writeFile(input, workDir) {
             return { output: `Created ${resolved} (${lines} lines, ${bytes} bytes)` };
         }
         const xfile = crossFileBreakageWarning(resolved, normalizeLF(priorContent), normalizeLF(content), workDir ?? process.cwd());
-        return { output: `Overwrote ${resolved} (${lines} lines, ${bytes} bytes)${xfile}` };
+        // Reward-hacking guard: a write_file that OVERWRITES an existing test file can
+        // silently drop assertions / test cases. The loop layer can't see the prior
+        // content — but we can (we just read it). Run the full old→new analysis and
+        // embed an invisible marker that ledgerRecord parses, so this path gets the
+        // same ledger entry + pre-finish nudge as an edit_file weakening would.
+        let tiMarker = '';
+        const ti = (0, testIntegrity_1.analyzeTestEdit)(resolved, normalizeLF(priorContent), normalizeLF(content));
+        if (ti.suspicious)
+            tiMarker = (0, testIntegrity_1.encodeTestIntegrityMarker)(ti.findings);
+        return { output: `Overwrote ${resolved} (${lines} lines, ${bytes} bytes)${xfile}${tiMarker}` };
     }
     catch (err) {
         return { error: err.message };
@@ -725,10 +735,16 @@ async function bash(input, abortSignal, sandbox, workDir) {
                 resolve({ error: 'Command stopped by user', interrupted: true, output: body || undefined });
             }
             else if (code !== 0) {
-                resolve(prependNote({ output: body + `\n[Exit code: ${code ?? signal ?? 'unknown'}]` }));
+                // Non-zero exit = the command FAILED (a test suite reporting failures, a
+                // build error, a lint failure). We deliberately DON'T set `error` here:
+                // the model must see the failing output and react, and treating it as a
+                // hard error would break stall-guard/retry semantics. Instead expose the
+                // exit code as structured data so the ProgressLedger can record this
+                // verification as FAILED (not PASSED). Signal-only exit → code 128+sig-ish.
+                resolve(prependNote({ output: body + `\n[Exit code: ${code ?? signal ?? 'unknown'}]`, exitCode: code ?? 1 }));
             }
             else {
-                resolve(prependNote({ output: body }));
+                resolve(prependNote({ output: body, exitCode: 0 }));
             }
         };
         child.stdout?.on('data', (chunk) => appendOutput(chunk.toString('utf-8')));

package/dist/types.d.ts

@@ -67,6 +67,15 @@ export interface ToolResult {
     output?: string;
     error?: string;
     interrupted?: boolean;
+    /**
+     * Process exit code for bash commands. 0 = success, non-zero = the command
+     * FAILED (e.g. a test suite that reported failures). This is kept SEPARATE
+     * from `error` on purpose: a failing `npm test` is a legitimate, non-error
+     * tool result (the model should see the failures and react) — but the
+     * ProgressLedger needs it to tell a PASSED verification from a FAILED one.
+     * Undefined for non-bash tools or when no exit code is available.
+     */
+    exitCode?: number;
 }
 export interface AuthConfig {
     token: string;

package/dist/types.d.ts.map

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nexrall/code-core",
-  "version": "1.4.0",
+  "version": "1.4.2",
   "description": "Core agent loop, tools, and extension primitives for Nexrall Code — embed an AI coding agent in any Node.js application.",
   "license": "MIT",
   "author": "Nexrall <support@nexrall.com> (https://nexrall.com)",