tickmarkr 1.87.0 → 1.90.0

package/dist/gates/baseline.js

@@ -1,6 +1,6 @@
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
-import { sh } from "../run/git.js";
+import { DEFAULT_SHELL_TIMEOUT_MS, sh } from "../run/git.js";
 // incident #2 (run-20260709-104447): a vitest ✓ PASS line with "error" in the test NAME, wrapped in ANSI
 // codes that varied between baseline and worktree runs, was reported as a "new failure". Strip ANSI first;
 // a pass-marker line is never a failure. [\d;#] covers raw ANSI and digit-normalized ANSI ("\x1b[#m") from
@@ -57,6 +57,30 @@ const namesFailure = (l) => FAIL_ANCHOR_RE.test(l) || RUNNER_FAIL_RE.test(l) ||
 const isFailureShaped = (l) => namesFailure(l) || SUMMARY_FAIL_RE.test(l) || ERROR_ANCHOR_RE.test(l)
     || TSC_ERROR_RE.test(l) || LINTER_ERROR_RE.test(l);
 const VOCAB_RE = /\b(?:error|fail(?:ed|ure|ing)?)\b/i;
+// T9 — the infra/regression discriminator. A runner that died because the MACHINE ran out of
+// processes, file descriptors or memory never finished asking the question, so its nonzero exit is
+// not evidence about the work. But the reverse mistake is the expensive one: a real regression that
+// happens to be printed next to an errno token must never be laundered into "infra" and forgiven.
+// So the errno tokens below classify a line as infra only when NOTHING on that line also names a
+// test-level failure — "AssertionError after spawn EAGAIN" names one and is a regression; "spawn
+// EAGAIN" and "Error: spawn EAGAIN" name none and are infra. One regression line anywhere in the
+// output makes the whole output a regression, whatever else the runner printed.
+const INFRA_RE = /\bE(?:AGAIN|MFILE|NFILE|NOMEM|NOSPC)\b|JavaScript heap out of memory|Cannot allocate memory|Resource temporarily unavailable/;
+// A named error CLASS ("AssertionError", "TypeError", "MyDomainError") — never bare "Error", which
+// is what an errno report itself is headed with (`Error: spawn EAGAIN`). The prefix is required.
+const ERROR_CLASS_RE = /\b[A-Za-z][A-Za-z0-9]*Error\b/;
+const isInfraLine = (l) => INFRA_RE.test(l) && !ERROR_CLASS_RE.test(l) && !namesFailure(l) && !SUMMARY_FAIL_RE.test(l);
+const namesRegression = (l) => (isFailureShaped(l) || ERROR_CLASS_RE.test(l)) && !isInfraLine(l);
+/**
+ * What a nonzero runner exit is evidence OF. `undefined` when the output names neither — the
+ * unreadable-runner case the existing fail-closed path already owns.
+ */
+export function classifyFailureOutput(output) {
+    const lines = output.split("\n").map((l) => l.replace(ANSI_RE, "")).filter((l) => !PASS_LINE_RE.test(l));
+    if (lines.some(namesRegression))
+        return "regression";
+    return lines.some(isInfraLine) ? "infra" : undefined;
+}
 const normalizeLine = (l) => l.replace(/\d+/g, "#").replace(/\s+/g, " ").trim();
 // A failing command whose output holds no shape any runner here names. The marker is content-free and
 // constant: downstream consumers (tip verify journals fingerprint counts) still see that the command
@@ -87,6 +111,18 @@ const unrecognizedEvidence = (raw) => raw
 // stored baselines may predate ANSI/pass-marker hardening — renormalize at compare time so existing
 // on-disk baseline.json files stay comparable without recapture (compat invariant, CLAUDE.md)
 const renormalize = (fp) => normalizeLine(fp.replace(ANSI_RE, ""));
+/**
+ * Q121s: the battery's forgiveness math, exported so tip-verify applies the IDENTICAL rule.
+ * Returns the failure fingerprints of `raw` that are NOT in the baseline entry (fresh), and
+ * whether the output carried no recognizable failure shape at all.
+ */
+export function freshFailures(entry, raw) {
+    const known = new Set((entry?.fingerprints ?? []).map(renormalize));
+    // OBS-42: diagnostic headings enrich fingerprints but cannot invalidate legacy baselines.
+    const current = fingerprint(raw);
+    const fresh = current.filter((f) => !known.has(f) && (!FAIL_ANCHOR_RE.test(f) || f.startsWith("FAIL ")));
+    return { failing: fresh.filter((f) => f !== UNRECOGNIZED_FAILURE), unreadable: current.includes(UNRECOGNIZED_FAILURE) };
+}
 export function detectGateCommands(repoRoot, cfg) {
     const out = {};
     const pkgPath = join(repoRoot, "package.json");
@@ -121,17 +157,59 @@ function missingConfiguredCommand(cmd, result) {
     const output = `${result.stdout}\n${result.stderr}`;
     return new RegExp(`(?:^|[:\\s])${reEscape(token)}:\\s+(?:command not found|No such file or directory)`, "i").test(output);
 }
+/**
+ * How much longer than the baseline a battery may legitimately take. Gate batteries run inside a
+ * worktree beside up to `concurrency` siblings, so the same suite is genuinely slower than its
+ * pristine-tree capture — 3× is the headroom, not a performance budget.
+ */
+const CEILING_SLACK = 3;
+/**
+ * The ceiling a battery runs under: whichever is larger of the shipped constant and the slack applied
+ * to what this command actually measured. A pre-v1.90 baseline (no measurement) gets exactly the
+ * shipped constant, so nothing regresses on an existing on-disk baseline.json — the same read-old
+ * compat rule the fingerprint renormalizer follows.
+ */
+export const effectiveCeilingMs = (entry) => entry?.ceilingMs ?? Math.max(DEFAULT_SHELL_TIMEOUT_MS, CEILING_SLACK * (entry?.durationMs ?? 0));
+/**
+ * The ONLY producer of a `ceiling-kill` gate result. It is gated on `timedOut`, which git.ts sets in
+ * exactly one place — inside the timer callback that issues the SIGKILL — so a process that exited on
+ * its own can never reach this text however it exited: a slow red suite, an unreadable runner, exit
+ * 137 from a kill somebody ELSE sent. Returning `undefined` rather than a result keeps that structural:
+ * every caller must go on to the ordinary verdict path, it cannot fall through into this one.
+ *
+ * A kill is not a verdict. The battery was still running when the machine took it away, so its exit
+ * code is evidence about the ceiling and nothing about the work — which is why this reports `infra`
+ * and never enters baseline forgiveness (there is no runner output to forgive).
+ */
+export function ceilingKillResult(gate, r, ceilingMs) {
+    if (r.timedOut !== true)
+        return undefined;
+    // no measurement only when a caller synthesized the result; a real kill fires AT the ceiling
+    const durationMs = r.durationMs ?? ceilingMs;
+    return {
+        gate,
+        pass: false,
+        details: `ceiling-kill: SIGKILLed after ${durationMs}ms at the configured ${ceilingMs}ms ceiling — `
+            + `the battery never returned a verdict, so this gate verified nothing (exit ${r.code} is the kill, not a test result)`,
+        meta: { classification: "infra", infra: true, kind: "ceiling-kill", durationMs, ceilingMs },
+    };
+}
 export async function captureBaseline(cwd, commands) {
     const base = { commands: {} };
     for (const [name, cmd] of Object.entries(commands)) {
         const r = await sh(cmd, cwd);
         // ponytail: strip the executing cwd so repo-root capture and worktree compare fingerprint identically; /private-vs-/tmp symlink variance is out of scope
+        // ponytail: a capture that was itself killed records the ceiling as its "measurement", which
+        // scales the next ceiling up — the right direction for a suite that never finished once.
+        const durationMs = r.durationMs ?? 0;
         base.commands[name] = {
             exitCode: r.code,
             // a command that exits 0 has no failures to fingerprint — recording any would be a lie the
             // compare step then has to forgive
             fingerprints: r.code === 0 ? [] : fingerprint((r.stdout + "\n" + r.stderr).split(cwd).join("")),
             missingCommand: missingConfiguredCommand(cmd, r),
+            durationMs,
+            ceilingMs: effectiveCeilingMs({ durationMs }),
         };
     }
     const names = Object.keys(commands);
@@ -199,16 +277,37 @@ export async function compareToBaseline(cwd, commands, baseline, enabled) {
             results.push({ gate: name, pass: true, details: `no ${name} command detected — skipped`, meta: { skipped: true } });
             continue;
         }
-        const r = await sh(cmd, cwd);
+        const ceilingMs = effectiveCeilingMs(baseline.commands[name]);
+        const r = await sh(cmd, cwd, ceilingMs);
+        // Q24: the kill is read BEFORE the exit code is interpreted at all. A SIGKILLed battery has
+        // whatever partial output it had flushed — typically no failure shape — so every path below
+        // would otherwise turn a timeout into a claim about the work: "no recognizable failure lines"
+        // when the baseline was green, or a forgiven pre-existing red when it was not. Neither is true.
+        const killed = ceilingKillResult(name, r, ceilingMs);
+        if (killed) {
+            results.push(killed);
+            continue;
+        }
         if (r.code === 0) {
             results.push({ gate: name, pass: true, details: "exit 0" });
             continue;
         }
         const raw = (r.stdout + "\n" + r.stderr).split(cwd).join("");
-        const known = new Set((baseline.commands[name]?.fingerprints ?? []).map(renormalize));
-        // OBS-42: diagnostic headings enrich fingerprints but cannot invalidate legacy baselines.
-        const current = fingerprint(raw);
-        const fresh = current.filter((f) => !known.has(f) && (!FAIL_ANCHOR_RE.test(f) || f.startsWith("FAIL ")));
+        // T9: classify BEFORE the baseline diff, and record it on every nonzero result. An infra-only
+        // exit means the runner never completed a suite, so there is nothing to forgive and nothing
+        // verified — it fails, and `meta.infra` marks it so the merge predicate cannot read it as a
+        // satisfied gate even if some future producer reports it as a pass. Baseline forgiveness stays
+        // exactly where it belongs: on failures the runner actually reported and the baseline already had.
+        const classification = classifyFailureOutput(raw);
+        if (classification === "infra") {
+            results.push({
+                gate: name,
+                pass: false,
+                details: `exit ${r.code} on infrastructure alone — the runner never completed a suite, so this gate verified nothing:\n${unrecognizedEvidence(raw) || raw.trim().split("\n").slice(0, 10).join("\n")}`,
+                meta: { classification, infra: true },
+            });
+            continue;
+        }
         // OBS-278: only a failure SHAPE is a verdict — everything fingerprint() keeps is one, except the
         // unrecognized-output marker, which is evidence for the operator and never grounds to reject.
         // ponytail: ceiling — a runner whose failure output holds no shape above and whose baseline is
@@ -216,8 +315,7 @@ export async function compareToBaseline(cwd, commands, baseline, enabled) {
         // below rather than reading as a verified green. Raise the ceiling by teaching isFailureShaped
         // that runner's position rule (leading verdict + identifier, or identifier + separator + trailing
         // verdict); loosening back to vocabulary re-opens OBS-278.
-        const unreadable = current.includes(UNRECOGNIZED_FAILURE);
-        const failing = fresh.filter((f) => f !== UNRECOGNIZED_FAILURE);
+        const { failing, unreadable } = freshFailures(baseline.commands[name], raw);
         if (!failing.length && (baseline.commands[name]?.exitCode ?? 1) === 0) {
             const closed = `command was green at baseline but now exits ${r.code} with no recognizable failure lines — failing closed`;
             const evidence = unrecognizedEvidence(raw);
@@ -225,16 +323,22 @@ export async function compareToBaseline(cwd, commands, baseline, enabled) {
                 gate: name,
                 pass: false,
                 details: evidence ? `${closed}\nunrecognized output:\n${evidence}` : closed,
+                ...(classification ? { meta: { classification } } : {}),
             });
             continue;
         }
-        results.push(failing.length
-            ? { gate: name, pass: false, ...headlineDetails(raw, failing) }
-            : {
-                gate: name,
-                pass: true,
-                details: `exit ${r.code} but only pre-existing failures (forgiven)${unreadable ? " — no failure shape recognized in this output, so a new failure from this runner is invisible to the baseline gate" : ""}`,
-            });
+        if (failing.length) {
+            const headlined = headlineDetails(raw, failing);
+            const meta = { ...headlined.meta, ...(classification ? { classification } : {}) };
+            results.push({ gate: name, pass: false, details: headlined.details, ...(Object.keys(meta).length ? { meta } : {}) });
+            continue;
+        }
+        results.push({
+            gate: name,
+            pass: true,
+            details: `exit ${r.code} but only pre-existing failures (forgiven)${unreadable ? " — no failure shape recognized in this output, so a new failure from this runner is invisible to the baseline gate" : ""}`,
+            ...(classification ? { meta: { classification } } : {}),
+        });
     }
     return results;
 }

package/dist/gates/llm.js

@@ -1,6 +1,6 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import { randomBytes } from "node:crypto";
-import { mkdtempSync, writeFileSync } from "node:fs";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { formatOwnedName, parseOwnedName } from "../drivers/types.js";
@@ -104,36 +104,47 @@ export async function captureLlmOutput(run) {
     return { value, outputs };
 }
 export async function runHeadless(adapter, model, prompt, cwd, timeoutMs = 300000) {
-    const pf = join(mkdtempSync(join(tmpdir(), "tickmarkr-llm-")), "prompt.md");
-    writeFileSync(pf, prompt);
-    const r = await sh(adapter.headlessCommand(pf, model), cwd, timeoutMs);
-    return r.stdout + "\n" + r.stderr;
+    const dir = mkdtempSync(join(tmpdir(), "tickmarkr-llm-"));
+    try {
+        const pf = join(dir, "prompt.md");
+        writeFileSync(pf, prompt);
+        const r = await sh(adapter.headlessCommand(pf, model), cwd, timeoutMs);
+        return r.stdout + "\n" + r.stderr;
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
 }
 // v1.1 default path: the same headless CLI call, but dispatched through the driver
 // as a visible named agent (herdr pane), with the quote-split completion wrapper.
 export async function runViaDriver(adapter, model, prompt, cwd, via, timeoutMs = 300000) {
     const dir = mkdtempSync(join(tmpdir(), "tickmarkr-llm-"));
-    const pf = join(dir, "prompt.md");
-    writeFileSync(pf, prompt);
-    const scriptPath = join(dir, "dispatch.sh");
-    // OBS-50: bootstrap in a script beside the prompt — pane sees one short bash line + banner, not the raw inline command
-    const nonce = extractPromptNonce(prompt) ?? generateVerdictNonce();
-    writeFileSync(scriptPath, [
-        "export BASH_SILENCE_DEPRECATION_WARNING=1",
-        bannerShell(),
-        adapter.headlessCommand(pf, model),
-        gateExitTrailer(nonce),
-    ].join("\n"));
-    const slot = await via.driver.slot(cwd, rolePaneNameFromPrompt(prompt, via.name), via.label ? { label: via.label } : undefined);
-    via.onSlot?.(slot);
-    await via.driver.run(slot, paneDispatchCommand(scriptPath));
-    // nonce-suffixed exit only: a displayed bare "TICKMARKR_EXIT:" or another call's marker must not
-    // false-complete — same guard the worker path uses (daemon.ts:330-331).
-    await via.driver.waitOutput(slot, `TICKMARKR_EXIT_${nonce}:\\d`, timeoutMs, { regex: true });
-    const out = await via.driver.read(slot, 400);
-    if (!via.keep)
-        await via.driver.close(slot);
-    return dewrapPaneVerdict(out, nonce);
+    try {
+        const pf = join(dir, "prompt.md");
+        writeFileSync(pf, prompt);
+        const scriptPath = join(dir, "dispatch.sh");
+        // OBS-50: bootstrap in a script beside the prompt — pane sees one short bash line + banner, not the raw inline command
+        const nonce = extractPromptNonce(prompt) ?? generateVerdictNonce();
+        writeFileSync(scriptPath, [
+            "export BASH_SILENCE_DEPRECATION_WARNING=1",
+            bannerShell(),
+            adapter.headlessCommand(pf, model),
+            gateExitTrailer(nonce),
+        ].join("\n"));
+        const slot = await via.driver.slot(cwd, rolePaneNameFromPrompt(prompt, via.name), via.label ? { label: via.label } : undefined);
+        via.onSlot?.(slot);
+        await via.driver.run(slot, paneDispatchCommand(scriptPath));
+        // nonce-suffixed exit only: a displayed bare "TICKMARKR_EXIT:" or another call's marker must not
+        // false-complete — same guard the worker path uses (daemon.ts:330-331).
+        await via.driver.waitOutput(slot, `TICKMARKR_EXIT_${nonce}:\\d`, timeoutMs, { regex: true });
+        const out = await via.driver.read(slot, 400);
+        if (!via.keep)
+            await via.driver.close(slot);
+        return dewrapPaneVerdict(out, nonce);
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
 }
 // OBS-155: a TUI renders the verdict as a bullet and HARD-wraps it at pane width with a 2-space
 // continuation indent, splitting words mid-token — so literal newlines land inside JSON string

package/dist/gates/review.d.ts

@@ -4,6 +4,8 @@ import { type Task } from "../graph/schema.js";
 import { type GateVia } from "./llm.js";
 import type { GateResult } from "./types.js";
 import { type VerdictUnparseableCause } from "./verdict-cause.js";
+import { type ArtifactDiffMeasurement, type ArtifactDiffSection } from "./artifact-manifest.js";
+export { isProtectedEvidence, PROTECTED_EVIDENCE_PREFIXES, REGENERABLE_CAPTURE_PATHS, setAsideReceiptPath, setAsideRegenerableCaptures, } from "./artifact-manifest.js";
 export type ReviewSeverity = "material" | "minor";
 export interface ReviewFinding {
     note: string;
@@ -21,13 +23,6 @@ export interface ReviewVerdict {
         body: string;
     }>;
 }
-export declare const REGENERABLE_CAPTURE_PATHS: readonly string[];
-export declare const PROTECTED_EVIDENCE_PREFIXES: readonly ["tests/fixtures/cockpit/anchors/", "tests/fixtures/cockpit/sources/", "tests/fixtures/cockpit/colour/sources/"];
-export declare function isProtectedEvidence(path: string): boolean;
-/** The `{path}` a set-aside receipt names, or null if this section carries no receipt. */
-export declare function setAsideReceiptPath(section: string): string | null;
-/** Replace the content of every section confined to the regenerable frame corpora with a receipt. */
-export declare function setAsideRegenerableCaptures(diff: string): string;
 /**
  * The paths this task's diff ACTUALLY touched. `-z` so a path carrying spaces or non-ASCII bytes is
  * never mangled by git's quoting, `--no-renames` so a rename reports BOTH sides: a file renamed OUT of
@@ -35,11 +30,21 @@ export declare function setAsideRegenerableCaptures(diff: string): string;
  */
 export declare function changedPaths(worktree: string, baseRef: string): Promise<string[]>;
 export declare function mirrorsVersionOnly(worktree: string, baseRef: string, path: string): Promise<boolean>;
-export declare function fetchTaskDiff(worktree: string, baseRef: string): Promise<{
-    full: string;
-    forCap: string;
-}>;
+export type TaskDiffMeasurement = {
+    readonly full: string;
+    readonly forCap: string;
+    /** Strict-cap UTF-8 bytes left after capture payloads become receipts. */
+    readonly logicBytes: number;
+    /** UTF-8 bytes withheld by those receipts and charged to the larger cap. */
+    readonly captureBytes: number;
+    readonly classifications: readonly ArtifactDiffSection[];
+    readonly fullMeasurement: ArtifactDiffMeasurement;
+    readonly capMeasurement: ArtifactDiffMeasurement;
+};
+export declare function fetchTaskDiff(worktree: string, baseRef: string): Promise<TaskDiffMeasurement>;
 export declare function checkDiffCap(gate: string, measured: number, cap: number, prefix?: string): GateResult | null;
+/** Apply the strict reviewable-logic cap and the finite, larger capture cap independently. */
+export declare function checkTaskDiffCaps(gate: string, measured: Pick<TaskDiffMeasurement, "logicBytes" | "captureBytes">, logicCap: number, prefix?: string): GateResult | null;
 export declare function isDiffCapPark(result: GateResult): boolean;
 export declare function diffCapParkReason(results: GateResult[]): string | null;
 export declare function modelId(model: string): string;

package/dist/gates/review.js

@@ -9,6 +9,8 @@ import { redactSecrets } from "../run/redact.js";
 import { marginalCostRank } from "../route/router.js";
 import { appendAnchoredReview, COMPLETION_FAKING_CHECKLIST, extractVerdictJson, generateVerdictNonce, runLlm, verdictNonceLine } from "./llm.js";
 import { classifyVerdictCause } from "./verdict-cause.js";
+import { captureDiffCapFor, measureArtifactDiff, reviewableLogicDiff, } from "./artifact-manifest.js";
+export { isProtectedEvidence, PROTECTED_EVIDENCE_PREFIXES, REGENERABLE_CAPTURE_PATHS, setAsideReceiptPath, setAsideRegenerableCaptures, } from "./artifact-manifest.js";
 // legacy flat `issues` shape — every issue blocks; the approve flag must agree with the list.
 function classifyReviewIssues(approve, issues) {
     const inconsistencies = [];
@@ -69,149 +71,6 @@ function classifyReviewFindings(findings) {
 // OBS-48: cap on zero-context diff bytes (git diff -U0), not context-padded full diff — scattered
 // one-line hunks no longer trip at ~370 diff-bytes per changed line. Full diff still goes to the judge.
 const DIFF_CAP_REMEDY = "split the task, or raise gates.diffCap";
-// v1.82 T1 — the cap bounds what a READER MUST READ, not what a run must write. A regeneration of the
-// frame corpora is ~134KB of `-U0` measurement before a source line changes, and nobody reads it: those
-// frames are asserted byte-for-byte by the corpus tests. Counting them is the category error this
-// removes. The two artifacts stay two (OBS-48: the cap measures -U0, the reader receives the full diff);
-// the exclusion is applied to both, identically, right here so BOTH measuring gates inherit it.
-//
-// Clause 1 — membership is an EXACT PATH match against the shipped capture manifest, the same lists the
-// regeneration path itself uses. Location, directory depth and file extension confer nothing: an
-// unmanifested file sitting beside real frames is measured and shown in full. (The anchors deliberately
-// share basenames with the frames; only the full path separates the oracle from its regenerable twin.)
-//
-// The members are LISTED here rather than imported from the manifest module, for one measured reason:
-// that module is the Ink/React renderer, and importing it puts the whole TUI in every gate's module
-// graph — which also memoises chalk's colour level at import time and turns the fleet suite red. A
-// drift test in tests/gates/diff-cap.test.ts asserts this list is exactly GOLDEN_FRAME_CASES +
-// COLOUR_FRAME_CASES and that every entry exists on disk, so it is a copy that cannot drift rather
-// than a second source of truth: add or rename a frame case and that test goes red until this matches.
-export const REGENERABLE_CAPTURE_PATHS = [
-    "tests/fixtures/cockpit/frames/run.width-stacked.80x24.txt",
-    "tests/fixtures/cockpit/frames/run.width-folded-keys.100x24.txt",
-    "tests/fixtures/cockpit/frames/run.width-three-column.140x24.txt",
-    "tests/fixtures/cockpit/frames/run.height-14.140x14.txt",
-    "tests/fixtures/cockpit/frames/run.height-18.140x18.txt",
-    "tests/fixtures/cockpit/frames/run.height-24.140x24.txt",
-    "tests/fixtures/cockpit/frames/run.height-40.140x40.txt",
-    "tests/fixtures/cockpit/frames/run.no-colour.140x24.txt",
-    "tests/fixtures/cockpit/frames/run.non-tty.140x24.txt",
-    "tests/fixtures/cockpit/frames/run.ci.140x24.txt",
-    "tests/fixtures/cockpit/frames/setup.width-stacked.80x24.txt",
-    "tests/fixtures/cockpit/frames/setup.width-folded-keys.100x24.txt",
-    "tests/fixtures/cockpit/frames/setup.width-three-column.140x24.txt",
-    "tests/fixtures/cockpit/frames/setup.height-14.140x14.txt",
-    "tests/fixtures/cockpit/frames/setup.height-18.140x18.txt",
-    "tests/fixtures/cockpit/frames/setup.height-24.140x24.txt",
-    "tests/fixtures/cockpit/frames/setup.height-40.140x40.txt",
-    "tests/fixtures/cockpit/frames/setup.no-colour.140x24.txt",
-    "tests/fixtures/cockpit/frames/setup.non-tty.140x24.txt",
-    "tests/fixtures/cockpit/frames/setup.ci.140x24.txt",
-    "tests/fixtures/cockpit/colour/run-20260718-000943.colour.140x24.txt",
-    "tests/fixtures/cockpit/colour/run-20260718-000943.no-colour.140x24.txt",
-    "tests/fixtures/cockpit/colour/run-20260725-025004.interrupted.colour.140x24.txt",
-];
-const CAPTURE_MANIFEST = new Set(REGENERABLE_CAPTURE_PATHS);
-// Clause 2 — the frozen appearance anchors and the captured engagement journals are NEVER set aside and
-// are exempt from every other reduction too (clause 5): they are reviewed, immutable evidence. The
-// anchors are the oracle this milestone declares, and the fixture law bans editing a captured journal to
-// satisfy an assertion — so both keep counting toward the cap and keep reaching a reader verbatim.
-export const PROTECTED_EVIDENCE_PREFIXES = [
-    "tests/fixtures/cockpit/anchors/",
-    "tests/fixtures/cockpit/sources/",
-    "tests/fixtures/cockpit/colour/sources/",
-];
-export function isProtectedEvidence(path) {
-    return PROTECTED_EVIDENCE_PREFIXES.some((prefix) => path.startsWith(prefix));
-}
-const SET_ASIDE_RECEIPT = /^set aside: regenerable capture (.+?) — \d+ bytes withheld\b/m;
-/** The `{path}` a set-aside receipt names, or null if this section carries no receipt. */
-export function setAsideReceiptPath(section) {
-    return SET_ASIDE_RECEIPT.exec(section)?.[1] ?? null;
-}
-// `--- a/x` / `+++ b/x` → "x"; "/dev/null" → null, which is the ABSENCE of a side, not a membership
-// failure (clause 3). git quotes paths carrying specials, so unquote before stripping the a/ b/ prefix.
-function diffSidePath(raw) {
-    const v = raw.trim();
-    if (v === "/dev/null")
-        return null;
-    const unquoted = v.startsWith('"') && v.endsWith('"') ? v.slice(1, -1) : v;
-    return unquoted.replace(/^[ab]\//, "");
-}
-// The `--- a/x` / `+++ b/x` header pair and the hunk lines below it. Clause 4 — null when the section
-// carries NO content hunk at all (a mode-only change, a pure rename, a binary marker): such a section is
-// left exactly as git wrote it rather than handed a manufactured receipt.
-function parseSection(section) {
-    const lines = section.split("\n");
-    const minus = lines.findIndex((l) => l.startsWith("--- "));
-    if (minus === -1 || !lines[minus + 1]?.startsWith("+++ "))
-        return null;
-    const body = lines.slice(minus + 2);
-    if (!body.some((l) => l.startsWith("@@ ")))
-        return null;
-    return { lines, minus, sides: [diffSidePath(lines[minus].slice(4)), diffSidePath(lines[minus + 1].slice(4))], body };
-}
-// The content a one-sided section carries: its hunk lines with the sign stripped, keeping git's
-// `` markers so a trailing-newline difference still reads as a content
-// difference. Hunk headers are dropped — a delete and an add of the same bytes never share them.
-function hunkPayload(body, sign) {
-    return body.filter((l) => l.startsWith(sign) || l.startsWith("\\")).map((l) => (l[0] === sign ? l.slice(1) : l)).join("\n");
-}
-// Clause 4 — a hunk is NOT proof of a content change. Git spells a KIND change (regular file ⇄ symlink)
-// as a delete plus an add of the SAME path, each carrying a hunk, so when the regular file's bytes are
-// exactly the link target both halves carry identical payloads: the kind changed and the content did
-// not. Nothing was withheld, so neither half earns a receipt — and neither half can see the other, so
-// the pairing is found across sections before any one of them is set aside.
-function kindOnlyPaths(sections) {
-    const removed = new Map();
-    const added = new Map();
-    for (const section of sections) {
-        const parsed = parseSection(section);
-        if (!parsed)
-            continue;
-        const [a, b] = parsed.sides;
-        if (a && !b)
-            removed.set(a, hunkPayload(parsed.body, "-"));
-        else if (b && !a)
-            added.set(b, hunkPayload(parsed.body, "+"));
-    }
-    return new Set([...removed].filter(([path, payload]) => added.get(path) === payload).map(([path]) => path));
-}
-function setAsideSection(section, kindOnly) {
-    const parsed = parseSection(section);
-    if (!parsed)
-        return section;
-    const { lines, minus, sides } = parsed;
-    // Clause 3 — the test is over the sides that name a real file. Requiring BOTH sides to be members
-    // makes every corpus addition (a-side /dev/null) and deletion (b-side /dev/null) ineligible, which is
-    // exactly the frames this milestone adds. A rename crossing the boundary in either direction has two
-    // real sides and one of them is not a member, so it stays whole — `rename from` line included.
-    const named = sides.filter((p) => p !== null);
-    if (!named.length || !named.every((p) => CAPTURE_MANIFEST.has(p)))
-        return section;
-    // Clause 4 — both halves of a content-identical kind change are left exactly as git wrote them. A
-    // kind change that DID move bytes is an ordinary content change and is set aside like any other.
-    if (named.some((p) => kindOnly.has(p)))
-        return section;
-    const withheld = lines.slice(minus).join("\n");
-    // Clause 6 — the claimed size is the UTF-8 BYTE length of what was withheld (the file headers and
-    // hunks this receipt replaces), never a JavaScript string length: box-drawing frames make the two
-    // disagree. And the receipt itself is part of the measured artifact, so N set-aside sections can never
-    // measure as nothing while producing an arbitrarily large reader payload.
-    const receipt = `set aside: regenerable capture ${named.at(-1)} — ${Buffer.byteLength(withheld, "utf8")} bytes withheld (regenerable frame corpus: asserted byte-for-byte by the corpus tests, never read)`;
-    // Clause 4 — everything git said happened survives verbatim: old/new mode, new file mode, deleted file
-    // mode, similarity index, rename from/to, index. Only content is replaced, so a deletion is never
-    // presented as a file that still exists and an addition is never presented as a modification.
-    return `${lines.slice(0, minus).join("\n")}\n${receipt}\n`;
-}
-/** Replace the content of every section confined to the regenerable frame corpora with a receipt. */
-export function setAsideRegenerableCaptures(diff) {
-    if (!diff.includes("diff --git "))
-        return diff;
-    const sections = diff.split(/(?=^diff --git )/m);
-    const kindOnly = kindOnlyPaths(sections);
-    return sections.map((s) => setAsideSection(s, kindOnly)).join("");
-}
 /**
  * The paths this task's diff ACTUALLY touched. `-z` so a path carrying spaces or non-ASCII bytes is
  * never mangled by git's quoting, `--no-renames` so a rename reports BOTH sides: a file renamed OUT of
@@ -232,7 +91,7 @@ const VERSION_FIELD_LINE_RE = /^[+-]\s*"version":\s*"[^"]*",?\s*$/;
 export async function mirrorsVersionOnly(worktree, baseRef, path) {
     let diff;
     try {
-        diff = await shOk(`git diff -U0 '${baseRef}..HEAD' -- ${shq(path)}`, worktree);
+        diff = await shOk(`git diff --full-index -U0 '${baseRef}..HEAD' -- ${shq(path)}`, worktree);
     }
     catch {
         return false;
@@ -241,9 +100,23 @@ export async function mirrorsVersionOnly(worktree, baseRef, path) {
     return changed.length > 0 && changed.every((l) => VERSION_FIELD_LINE_RE.test(l));
 }
 export async function fetchTaskDiff(worktree, baseRef) {
-    const full = setAsideRegenerableCaptures(await shOk(`git diff '${baseRef}..HEAD'`, worktree));
-    const forCap = setAsideRegenerableCaptures(await shOk(`git diff -U0 '${baseRef}..HEAD'`, worktree));
-    return { full, forCap };
+    // --full-index: abbreviated index lines vary with object-store density, so two measurements of
+    // the same diff could disagree by a few bytes between invocations (CI-only red, release 1.89.0).
+    const [rawFull, rawForCap] = await Promise.all([
+        shOk(`git diff --full-index '${baseRef}..HEAD'`, worktree),
+        shOk(`git diff --full-index -U0 '${baseRef}..HEAD'`, worktree),
+    ]);
+    const fullMeasurement = measureArtifactDiff(rawFull);
+    const capMeasurement = measureArtifactDiff(rawForCap);
+    return {
+        full: fullMeasurement.rendered,
+        forCap: capMeasurement.rendered,
+        logicBytes: Buffer.byteLength(reviewableLogicDiff(capMeasurement.rendered), "utf8"),
+        captureBytes: capMeasurement.captureBytes,
+        classifications: capMeasurement.sections,
+        fullMeasurement,
+        capMeasurement,
+    };
 }
 export function checkDiffCap(gate, measured, cap, prefix = "") {
     if (measured <= cap)
@@ -256,8 +129,26 @@ export function checkDiffCap(gate, measured, cap, prefix = "") {
         meta: { park: "human" },
     };
 }
+/** Apply the strict reviewable-logic cap and the finite, larger capture cap independently. */
+export function checkTaskDiffCaps(gate, measured, logicCap, prefix = "") {
+    const logicFail = checkDiffCap(gate, measured.logicBytes, logicCap, prefix);
+    if (logicFail)
+        return logicFail;
+    const captureCap = captureDiffCapFor(logicCap);
+    if (measured.captureBytes <= captureCap)
+        return null;
+    return {
+        gate,
+        pass: false,
+        details: prefix
+            + `captured artifact diff exceeds verifiable capture cap (${measured.captureBytes} > ${captureCap}) — ${DIFF_CAP_REMEDY}`,
+        meta: { park: "human" },
+    };
+}
 export function isDiffCapPark(result) {
-    return result.pass === false && result.meta?.park === "human" && /diff exceeds verifiable cap/i.test(result.details);
+    return result.pass === false
+        && result.meta?.park === "human"
+        && /diff exceeds verifiable (?:capture )?cap/i.test(result.details);
 }
 // ponytail: single policy hook for callers after runGates — skips the escalation ladder on diff-cap trips.
 export function diffCapParkReason(results) {
@@ -374,9 +265,12 @@ artifactDir) {
             ? { gate: "review", pass: false, details: "no cross-vendor reviewer available (diversity rule); set review.required:false to waive", meta: { noEligibleReviewer: true } }
             : { gate: "review", pass: true, details: "WARNING: no cross-vendor reviewer available — review waived by config", meta: { noEligibleReviewer: true } };
     }
-    const { full: diff, forCap } = await fetchTaskDiff(worktree, baseRef);
+    const measuredDiff = await fetchTaskDiff(worktree, baseRef);
+    // Keep the reader payload identical to the text charged to the strict cap:
+    // whole-file source deletions are represented by their citable operation fact.
+    const diff = reviewableLogicDiff(measuredDiff.full);
     const diffCap = cfg.gates.diffCap ?? DEFAULT_DIFF_CAP;
-    const capFail = checkDiffCap("review", forCap.length, diffCap);
+    const capFail = checkTaskDiffCaps("review", measuredDiff, diffCap);
     if (capFail)
         return capFail;
     const nonce = generateVerdictNonce();