tickmarkr 2.5.1 → 2.5.3

package/dist/gates/baseline.js

@@ -30,7 +30,7 @@ const FAIL_ANCHOR_RE = /^\s*(?:FAIL\s+|[^\w]*(?:Unhandled Errors|Uncaught Except
 // to render. Digits are written (?:\d+|#) so a shape matches both raw and digit-normalized lines.
 // Run summaries: " Tests  N failed | M passed (T)" (vitest), "# fail N" (TAP / node:test),
 // "ℹ fail N" (node:test's spec reporter) and "test result: FAILED. …" (cargo / libtest).
-const SUMMARY_FAIL_RE = /^\s*(?:Tests?\s+(?:Files?\s+)?(?:\d+|#)\s+failed|#\s+fail\s+(?!0\b)(?:\d+|#)\b|ℹ\s+fail\s+(?!0\b)(?:\d+|#)\b|test result:\s+FAILED\b)/;
+const SUMMARY_FAIL_RE = /^\s*(?:Tests?\s+(?:Files?\s+)?(?!0\b)(?:\d+|#)\s+failed|#\s+fail\s+(?!0\b)(?:\d+|#)\b|ℹ\s+fail\s+(?!0\b)(?:\d+|#)\b|test result:\s+FAILED\b)/;
 const ERROR_ANCHOR_RE = /^\s*(?:Error|[A-Za-z_$][\w$]*Error):\s+\S/;
 const TSC_ERROR_RE = /^\s*\S.*\((?:\d+|#),(?:\d+|#)\):\s+error\s+[A-Z]+(?:\d+|#):/i; // tsc
 const LINTER_ERROR_RE = /^\s*(?:\d+|#):(?:\d+|#)\s+error\s+\S/; // eslint stylish
@@ -103,9 +103,8 @@ const stripTurboPrefix = (l) => {
 // Lines that NAME a failing test — the ones worth headlining to the operator. One list, so recognition
 // and reporting cannot drift apart (a shape that blocks but never gets named cost 3 attempts once).
 const namesFailure = (l) => FAIL_ANCHOR_RE.test(l) || RUNNER_FAIL_RE.test(l) || TRAILING_FAIL_RE.test(l) || GLYPH_FAIL_RE.test(l) || TURBO_FAIL_RE.test(l);
-// The stripped form is a second READ of the same line, for the recognition/headline paths that ask
-// "does anything here name a failure" — verdict classification (isInfraLine/namesRegression) keeps
-// reading the raw line only, so infra/regression verdicts are byte-unchanged by the prefix pass.
+// The stripped form lets recognition and headlines read the runner beneath a turbo prefix.
+// Classification applies the same prefix stripping before its infra/regression vetoes.
 const namesFailureEitherForm = (l) => {
     if (namesFailure(l))
         return true;
@@ -163,9 +162,13 @@ export function classifyFailureOutput(output) {
     // token inside a test's echoed stdout/stderr block must be as invisible to this classifier as it is
     // to fingerprint(): test-owned output is never runner evidence about the work.
     const lines = withoutVitestEchoBlocks(output).map((l) => l.replace(ANSI_RE, "")).filter((l) => !PASS_LINE_RE.test(l) && !OPERATOR_LINE_RE.test(l));
-    if (lines.some(namesRegression))
+    const evidence = lines.map((line) => stripTurboPrefix(line) ?? line).filter((line) => !PASS_LINE_RE.test(line) && !OPERATOR_LINE_RE.test(line));
+    const infra = evidence.some(isInfraLine);
+    // A diagnostic section heading names no failing test. It cannot outvote the RPC death
+    // beneath it, but an actual FAIL/AssertionError anywhere still takes precedence.
+    if (evidence.some((line) => !(infra && UNHANDLED_HEADER_RE.test(line)) && namesRegression(line)))
         return "regression";
-    return lines.some(isInfraLine) ? "infra" : undefined;
+    return infra ? "infra" : undefined;
 }
 /**
  * Capture validity asks a different question from gate classification. At a gate, one genuine
@@ -338,6 +341,8 @@ export function detectGateCommands(repoRoot, cfg) {
         else if (scripts[name])
             out[name] = `${runPrefix} ${name}`;
     }
+    if (cfg.gates.tipTest)
+        out.tipTest = cfg.gates.tipTest;
     return out;
 }
 /**
@@ -452,6 +457,7 @@ const invalidCaptureEntry = (durationMs, invalidCause, invalidatingLines = []) =
     fingerprints: [],
     durationMs,
     fileDurationSumMs: null,
+    fileCount: null,
     impliedParallelism: null,
     longestFile: null,
     ceilingMs: effectiveCeilingMs({ durationMs }),
@@ -460,11 +466,16 @@ const invalidCaptureEntry = (durationMs, invalidCause, invalidatingLines = []) =
 export async function captureBaseline(cwd, commands) {
     const base = { commands: {} };
     for (const [name, cmd] of Object.entries(commands)) {
+        if (name === "tipTest" && commands.test !== undefined && cmd === commands.test) {
+            continue;
+        }
         const r = await sh(cmd, cwd, CAPTURE_CEILING_MS);
         // 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;
+        const combinedOutput = r.stdout + "\n" + r.stderr;
+        const raw = combinedOutput.split(cwd).join("");
         // OBS-534 (T2): a capture SIGKILLed at its ceiling never returned a verdict, so `r.code` is the
         // kill and not evidence about the command. Run 1501 recorded `test: {durationMs: 600007,
         // exitCode: 1}` for exactly this — a kill written down as a red baseline. There the accident
@@ -483,11 +494,9 @@ export async function captureBaseline(cwd, commands) {
             console.error(`tickmarkr: baseline capture for "${name}" was killed at its ${CAPTURE_CEILING_MS}ms ceiling — `
                 + `it recorded NO fingerprints, so nothing is forgiven and every gate will treat a pre-existing `
                 + `failure as a fresh one. Raise the ceiling or shorten the command.`);
-            base.commands[name] = invalidCaptureEntry(durationMs, "ceiling-kill");
+            base.commands[name] = { ...invalidCaptureEntry(durationMs, "ceiling-kill"), fileCount: runnerFileCount(raw) };
             continue;
         }
-        const combinedOutput = r.stdout + "\n" + r.stderr;
-        const raw = combinedOutput.split(cwd).join("");
         // Run 2137: the child exited and printed ordinary FAIL/AssertionError lines, so the gate-side
         // discriminator correctly called the mixed output a regression. But the same output also said
         // `spawn EAGAIN`: the machine had run out of processes while the pristine-tree measurement was
@@ -499,15 +508,15 @@ export async function captureBaseline(cwd, commands) {
                 + `it recorded NO exit-code verdict and NO fingerprints, so nothing is forgiven for this command; `
                 + `the measurement cannot distinguish a pre-existing failure from one caused by exhaustion. `
                 + `First invalidating line: ${invalidatingLines[0]}`);
-            base.commands[name] = invalidCaptureEntry(durationMs, "resource-exhaustion", invalidatingLines);
+            base.commands[name] = { ...invalidCaptureEntry(durationMs, "resource-exhaustion", invalidatingLines), fileCount: runnerFileCount(raw) };
             continue;
         }
-        // OBS-885/887: capture and gate ask the same classifier. A green summary followed only by the
-        // teardown fingerprint is a pass; infrastructure without a summary is no verdict to forgive.
+        // OBS-966: a worker RPC timeout is infra even beside an all-green summary.
+        // Capture and both gate readers share this discriminator; genuine test failures still dominate.
         const runnerVerdict = classifyRunnerOutput(raw, r.code);
         if (runnerVerdict === "infra") {
-            console.error(`tickmarkr: baseline capture for "${name}" carries runner-infrastructure evidence and no green summary — it recorded NO verdict; nothing is forgiven for this command`);
-            base.commands[name] = invalidCaptureEntry(durationMs, "infra");
+            console.error(`tickmarkr: baseline capture for "${name}" carries runner-infrastructure evidence — it recorded NO verdict; nothing is forgiven for this command`);
+            base.commands[name] = { ...invalidCaptureEntry(durationMs, "infra", withoutVitestEchoBlocks(combinedOutput).filter((line) => isInfraLine(line.replace(ANSI_RE, "")))), fileCount: runnerFileCount(raw) };
             continue;
         }
         base.commands[name] = {
@@ -519,13 +528,14 @@ export async function captureBaseline(cwd, commands) {
             missingCommand: missingConfiguredCommand(cmd, r),
             durationMs,
             ...fileTiming(raw, durationMs),
+            fileCount: runnerFileCount(raw),
             ceilingMs: effectiveCeilingMs({ durationMs }),
             // T7: the world this measurement was taken in, so a later reader can ask whether its own world
             // is the same one. Recorded from THIS command's own shell result, never re-derived here.
             ...(r.capacity ? { capacity: r.capacity } : {}),
         };
     }
-    const names = Object.keys(commands);
+    const names = Object.keys(commands).filter((name) => !(name === "tipTest" && commands.test !== undefined && commands[name] === commands.test));
     const missing = names.filter((name) => base.commands[name]?.missingCommand === true);
     if (names.length > 0 && missing.length === names.length) {
         base.warnings = [{
@@ -609,10 +619,24 @@ export async function compareToBaseline(cwd, commands, baseline, enabled, opts =
             const withReapError = r.reapError ? { ...withReap, meta: { ...withReap.meta, reapError: r.reapError } } : withReap;
             const withRerun = rerunOf ? {
                 ...withReapError,
-                details: `host-starved rerun after waiting ${rerunOf.waitedMs}ms for a calm load window: ${withReapError.details}`,
+                details: `${g.meta?.classification === "infra" ? "infra; " : ""}host-starved rerun after waiting ${rerunOf.waitedMs}ms for a calm load window: ${withReapError.details.replace(/^infra; /, "")}`,
                 meta: { ...withReapError.meta, hostStarvedRerun: rerunOf },
             } : withReapError;
-            results.push(r.capacity ? { ...withRerun, capacity: r.capacity } : withRerun);
+            const final = opts.infraRerun ? {
+                ...withRerun,
+                details: `${g.meta?.classification === "infra" ? "infra; " : ""}runner-infra rerun after waiting ${opts.infraRerun.waitedMs}ms for a calm load window: ${withRerun.details.replace(/^infra; /, "")}`,
+                meta: { ...withRerun.meta, runnerInfraRerun: opts.infraRerun },
+            } : withRerun;
+            const withSelected = name === "test" && opts.selected
+                ? {
+                    ...final,
+                    meta: {
+                        ...final.meta,
+                        ...(Array.isArray(opts.selected) ? { selectedTests: [...opts.selected] } : {}),
+                    },
+                }
+                : final;
+            results.push(r.capacity ? { ...withSelected, capacity: r.capacity } : withSelected);
         };
         // …and whether the entry that would forgive this command was measured in the same world. A
         // baseline captured under a different fork cap forgives nothing: its fingerprints describe a
@@ -641,11 +665,16 @@ export async function compareToBaseline(cwd, commands, baseline, enabled, opts =
             });
             continue;
         }
+        const raw = (r.stdout + "\n" + r.stderr).split(cwd).join("");
+        const deficit = fileCountDeficit(entry, raw, { name, selected: opts.selected });
+        if (deficit) {
+            record({ gate: name, pass: false, details: deficit, meta: { classification: "infra", infra: true } });
+            continue;
+        }
         if (r.code === 0) {
             record({ gate: name, pass: true, details: "exit 0" });
             continue;
         }
-        const raw = (r.stdout + "\n" + r.stderr).split(cwd).join("");
         // OBS-885/887: the same classifier the capture applied names a completed green suite on both sides.
         const runnerVerdict = classifyRunnerOutput(raw, r.code);
         if (runnerVerdict === "green-teardown") {
@@ -665,16 +694,20 @@ export async function compareToBaseline(cwd, commands, baseline, enabled, opts =
         // that known assertion outvote the fresh birpc line turns machine failure into a worker defect.
         // `classifyRunnerOutput` remains the single discriminator. When there is no fresh fingerprint,
         // retain the whole-output read so a repeated infra abort can never be baseline-forgiven as green.
-        const freshVerdict = failing.length ? classifyRunnerOutput(failing.join("\n"), r.code) : undefined;
-        const freshClassification = freshVerdict === "infra" || freshVerdict === "regression" ? freshVerdict : undefined;
-        const classification = freshClassification ?? (!failing.length && (runnerVerdict === "infra" || runnerVerdict === "regression") ? runnerVerdict : undefined);
+        const classification = classifyFreshRunnerOutput(entry, raw, r.code);
+        if (name === "test" && classification === "infra" && !rerunOf && !opts.infraRerun) {
+            const waitedMs = await waitForCalmWindow();
+            const provenance = { durationMs: r.durationMs ?? 0, referenceMs: entry?.durationMs ?? 0, waitedMs };
+            results.push(...await compareToBaseline(cwd, { [name]: cmd }, baseline, [name], { ...opts, infraRerun: provenance }));
+            continue;
+        }
         // OBS-896: every fresh failure must be timeout-class, and the suite must take at least twice its
         // own baseline measurement. The first read buys one calm rerun here, never a worker repair.
-        if (name === "test" && classification !== "infra" && failing.length && !rerunOf
+        if (name === "test" && classification !== "infra" && failing.length && !rerunOf && !opts.infraRerun
             && hostStarved(failing.join("\n"), r.durationMs ?? 0, entry?.durationMs)) {
             const waitedMs = await waitForCalmWindow();
             const provenance = { durationMs: r.durationMs ?? 0, referenceMs: entry?.durationMs ?? 0, waitedMs };
-            results.push(...await compareToBaseline(cwd, { [name]: cmd }, baseline, [name], { rerunOf: provenance }));
+            results.push(...await compareToBaseline(cwd, { [name]: cmd }, baseline, [name], { ...opts, rerunOf: provenance }));
             continue;
         }
         if (classification === "infra") {
@@ -684,7 +717,7 @@ export async function compareToBaseline(cwd, commands, baseline, enabled, opts =
             record({
                 gate: name,
                 pass: false,
-                details: `exit ${r.code}; the fresh failures carry infrastructure evidence alone — the runner never completed a suite, so this gate verified nothing:\n${evidence}`,
+                details: `infra; exit ${r.code}; the fresh failures carry infrastructure evidence alone — the runner never completed a suite, so this gate verified nothing:\n${evidence}`,
                 meta: { classification, infra: true },
             });
             continue;
@@ -695,9 +728,11 @@ export async function compareToBaseline(cwd, commands, baseline, enabled, opts =
         // entries with no exitCode keep the `?? 1` red default both readers share (merge.ts:131).
         const baselineRed = entry?.infra !== true && (entry?.exitCode ?? 1) !== 0;
         if (!failing.length && !baselineRed) {
-            const recordedCause = entry?.invalidCause === "resource-exhaustion" || entry?.invalidatingLines?.length
-                ? `was invalidated by its recorded process/resource-exhaustion cause${entry.invalidatingLines?.[0] ? ` (${entry.invalidatingLines[0]})` : ""}`
-                : "was killed at its ceiling";
+            const recordedCause = entry?.invalidCause === "infra"
+                ? "was invalidated by its recorded runner-infrastructure cause"
+                : entry?.invalidCause === "resource-exhaustion" || entry?.invalidatingLines?.length
+                    ? `was invalidated by its recorded process/resource-exhaustion cause${entry.invalidatingLines?.[0] ? ` (${entry.invalidatingLines[0]})` : ""}`
+                    : "was killed at its ceiling";
             const closed = entry?.infra === true
                 ? `the baseline capture for this command ${recordedCause} and recorded no verdict, so nothing here is forgivable — it now exits ${r.code} with no recognizable failure lines — failing closed`
                 : `command was green at baseline but now exits ${r.code} with no recognizable failure lines — failing closed`;
@@ -742,7 +777,7 @@ export async function compareToBaseline(cwd, commands, baseline, enabled, opts =
     return results;
 }
 const SUMMARY_LINE_RE = /^[^\S\n]*Test Files[^\S\n]+(.+)$/m;
-const TEARDOWN_RE = /\[vitest-worker\]: Timeout calling\b|\[birpc\] rpc is closed, cannot call\b/;
+const TEARDOWN_RE = /\[birpc\] rpc is closed, cannot call\b/;
 const UNHANDLED_HEADER_RE = /^\s*[^\w]*(?:Unhandled Errors|Uncaught Exception)\b/;
 /** One interpretation of runner bytes, shared by baseline capture and every gate consumer. */
 export function classifyRunnerOutput(raw, code) {
@@ -750,6 +785,8 @@ export function classifyRunnerOutput(raw, code) {
         return undefined;
     const lines = withoutVitestEchoBlocks(raw).map((l) => l.replace(ANSI_RE, ""));
     const text = lines.join("\n");
+    if (lines.some((line) => /\[vitest-worker\]: Timeout calling\b/.test(line) && !PASS_LINE_RE.test(line) && !OPERATOR_LINE_RE.test(line)))
+        return classifyFailureOutput(text);
     const summary = SUMMARY_LINE_RE.exec(text);
     if (summary) {
         const failed = [...summary[1].matchAll(/\b(\d+)\s+failed\b/g)].map((match) => Number(match[1]));
@@ -780,14 +817,46 @@ export function hostStarved(fresh, durationMs, referenceMs) {
     const heads = fresh.split("\n").map((line) => line.replace(ANSI_RE, "")).filter((line) => ERROR_HEAD_RE.test(line));
     return heads.length > 0 && heads.every((line) => TIMEOUT_CLASS_RE.test(line));
 }
-const DEFAULT_CALM = { pollMs: 5_000, maxWaitMs: 600_000, loadProvider: () => loadavg()[0] ?? 0, calmLoad: () => availableParallelism() / 2 };
+const DEFAULT_CALM = {
+    pollMs: process.env.VITEST ? 10 : 5_000,
+    maxWaitMs: process.env.VITEST ? 50 : 600_000,
+    loadProvider: () => loadavg()[0] ?? 0,
+    calmLoad: () => availableParallelism() / 2,
+};
 let calm = DEFAULT_CALM;
 export function setCalmWindowForTests(over) { calm = { ...calm, ...over }; }
 export function resetCalmWindowForTests() { calm = DEFAULT_CALM; }
-async function waitForCalmWindow() {
+export async function waitForCalmWindow() {
     const started = Date.now();
     while (calm.loadProvider() > calm.calmLoad() && Date.now() - started < calm.maxWaitMs) {
         await new Promise((resolve) => setTimeout(resolve, calm.pollMs));
     }
     return Date.now() - started;
 }
+/** Summary totals survive digit-normalized fingerprints and exclude test-owned echoed output. */
+export function runnerFileCount(raw) {
+    const counts = withoutVitestEchoBlocks(raw).flatMap((line) => {
+        const clean = line.replace(ANSI_RE, "");
+        const match = /^\s*Test Files\s+.*\((\d+)\)\s*$/.exec(stripTurboPrefix(clean) ?? clean);
+        return match ? [Number(match[1])] : [];
+    });
+    return counts.length ? counts.reduce((sum, count) => sum + count, 0) : null;
+}
+export function fileCountDeficit(entry, raw, opts) {
+    // OBS-985: only a real, named selected-test run of the TEST gate is exempt — a truthy flag or an
+    // empty list named no selection and let a full-suite call opt itself out of the deficit guard.
+    if (opts?.name === "test" && opts.selected !== undefined && opts.selected.length > 0)
+        return undefined;
+    const actual = runnerFileCount(raw);
+    return entry?.fileCount != null && actual !== null && actual < entry.fileCount
+        ? `infra; runner reported ${actual} test files, below baseline ${entry.fileCount} — suite incomplete`
+        : undefined;
+}
+/** Both readers classify fresh evidence first, retaining the whole-output guard against infra forgiveness. */
+export function classifyFreshRunnerOutput(entry, raw, code) {
+    if (classifyRunnerOutput(raw, code) === "green-teardown")
+        return undefined;
+    const { failing } = freshFailures(entry, raw);
+    const verdict = classifyRunnerOutput(failing.length ? failing.join("\n") : raw, code);
+    return verdict === "infra" || verdict === "regression" ? verdict : undefined;
+}

package/dist/gates/llm.d.ts

@@ -65,7 +65,7 @@ export interface LlmRunResult {
     seatAuthoredBytes?: number;
 }
 export declare const PROMPT_GLYPHS: readonly ["➜", "❯", "$", "%", ">>", ">"];
-export declare function reviewSeatOutput(raw: string, nonce: string): string;
+export declare function reviewSeatOutput(raw: string, nonce: string, adapterBannerRows?: readonly string[]): string;
 export declare const REVIEW_FIRST_LIVENESS_MS = 30000;
 export declare function runHeadless(adapter: WorkerAdapter, model: string, prompt: string, cwd: string, timeoutMs?: number): Promise<string>;
 export declare function runViaDriver(adapter: WorkerAdapter, model: string, prompt: string, cwd: string, via: LlmVia, timeoutMs?: number): Promise<string>;

package/dist/gates/llm.js

@@ -204,12 +204,14 @@ const IDENTITY_OPENERS = ["review ·", "tickmarkr"];
 // Stages of the preamble walk. Each complete harness row is accepted only at or after its stage.
 const ECHO = 0, START = 1, BANNER = 2, IDENTITY = 3, SEAT = 4;
 // The char offset where the seat's own text begins, or -1 when the capture ends inside the preamble.
-function seatStart(output) {
+function seatStart(output, adapterBannerRows) {
     const rows = output.split("\n");
     if (rows.length > 1 && rows[rows.length - 1] === "")
         rows.pop(); // the read's own line terminator
     let stage = ECHO;
     let bannerAt; // next banner row expected once the banner has begun
+    let adapterBannerAt;
+    let identitySeen = false;
     let offset = 0;
     for (let i = 0; i < rows.length; i++) {
         const row = rows[i].replace(/[ \t]+$/, "");
@@ -217,7 +219,7 @@ function seatStart(output) {
         const last = i === rows.length - 1;
         // Complete harness rows: equality against the shape the preamble allows at this stage.
         let accepted = false;
-        if (stage < SEAT && t.length === 0)
+        if (!identitySeen && stage < SEAT && t.length === 0)
             accepted = true; // blank rows between preamble rows
         else if (stage <= ECHO && completeEchoRow(row))
             accepted = true;
@@ -225,17 +227,27 @@ function seatStart(output) {
             stage = BANNER;
             accepted = true;
         }
-        else if (stage <= BANNER && bannerAt === undefined && BANNER_ROWS.includes(row)) {
+        else if (!identitySeen && stage <= BANNER && bannerAt === undefined && BANNER_ROWS.includes(row)) {
             stage = BANNER;
             bannerAt = BANNER_ROWS.indexOf(row) + 1;
             accepted = true;
         }
-        else if (stage <= BANNER && bannerAt !== undefined && row === BANNER_ROWS[bannerAt]) {
+        else if (!identitySeen && stage <= BANNER && bannerAt !== undefined && row === BANNER_ROWS[bannerAt]) {
             bannerAt++;
             accepted = true;
         }
-        else if (stage <= IDENTITY && IDENTITY_LINE.test(t)) {
-            stage = SEAT;
+        else if (stage <= IDENTITY && adapterBannerAt === undefined && adapterBannerRows.includes(row)) {
+            stage = BANNER;
+            adapterBannerAt = adapterBannerRows.indexOf(row) + 1;
+            accepted = true;
+        }
+        else if (stage <= IDENTITY && adapterBannerAt !== undefined && row === adapterBannerRows[adapterBannerAt]) {
+            adapterBannerAt++;
+            accepted = true;
+        }
+        else if (!identitySeen && stage <= IDENTITY && IDENTITY_LINE.test(t)) {
+            stage = IDENTITY;
+            identitySeen = true;
             accepted = true;
         }
         if (accepted) {
@@ -253,9 +265,16 @@ function seatStart(output) {
             ? BANNER_ROWS.some((b) => b.startsWith(row))
             : BANNER_ROWS[bannerAt]?.startsWith(row) === true))
             return -1;
+        if (stage <= IDENTITY && (adapterBannerAt === undefined
+            ? adapterBannerRows.some((b) => b.startsWith(row))
+            : adapterBannerRows[adapterBannerAt]?.startsWith(row) === true))
+            return -1;
         // The identity row is painted right after the banner, so its prefix is a partial paint only there;
         // with no banner in the capture, "review" or "tick" alone is the seat's own first row.
-        if (stage <= IDENTITY && bannerAt === BANNER_ROWS.length && IDENTITY_OPENERS.some((o) => o.startsWith(t)))
+        if (!identitySeen && stage <= IDENTITY
+            && (bannerAt === BANNER_ROWS.length
+                || (adapterBannerRows.length > 0 && adapterBannerAt === adapterBannerRows.length))
+            && IDENTITY_OPENERS.some((o) => o.startsWith(t)))
             return -1;
         return offset;
     }
@@ -266,9 +285,9 @@ function seatStart(output) {
 // Every capture taken before the preamble finishes therefore measures ZERO seat-authored bytes,
 // which is what makes the caller's running Math.max safe: a partial banner counted once would be
 // retained for the whole call and buy a silent seat its full ceiling.
-export function reviewSeatOutput(raw, nonce) {
+export function reviewSeatOutput(raw, nonce, adapterBannerRows = []) {
     const output = stripVTControlCharacters(raw).replace(/\r\n?/g, "\n");
-    const start = seatStart(output);
+    const start = seatStart(output, adapterBannerRows);
     if (start < 0)
         return "";
     const seat = output.slice(start);
@@ -287,7 +306,10 @@ async function runHeadlessDetailed(adapter, model, prompt, cwd, timeoutMs = 3000
         const pf = join(dir, "prompt.md");
         writeFileSync(pf, prompt);
         const r = await sh(adapter.headlessCommand(pf, model), cwd, timeoutMs);
-        return { output: r.stdout + "\n" + r.stderr, exitCode: r.code, timedOut: r.timedOut === true, seatAuthoredBytes: Buffer.byteLength(r.stdout + r.stderr) };
+        const output = r.stdout + "\n" + r.stderr;
+        const nonce = extractPromptNonce(prompt) ?? "";
+        return { output, exitCode: r.code, timedOut: r.timedOut === true,
+            seatAuthoredBytes: Buffer.byteLength(reviewSeatOutput(output, nonce, adapter.harnessBannerRows).trim()) };
     }
     finally {
         rmSync(dir, { recursive: true, force: true });
@@ -349,7 +371,7 @@ async function runViaDriverDetailed(adapter, model, prompt, cwd, via, timeoutMs
             const startedAt = Date.now();
             out = await via.driver.read(slot, 400);
             const reviewing = prompt.startsWith("TICKMARKR-REVIEW");
-            seatAuthoredBytes = Buffer.byteLength(reviewSeatOutput(out, nonce));
+            seatAuthoredBytes = Buffer.byteLength(reviewSeatOutput(out, nonce, adapter.harnessBannerRows));
             let firstLivenessObserved = false;
             let priorSnapshot = normalizeStallSnapshot(out);
             const anchoredAt = Date.now();
@@ -365,7 +387,7 @@ async function runViaDriverDetailed(adapter, model, prompt, cwd, via, timeoutMs
                 const matched = await via.driver.waitOutput(slot, exitPattern, sliceMs, { regex: true });
                 const raw = await via.driver.read(slot, 400);
                 out = raw;
-                seatAuthoredBytes = Math.max(seatAuthoredBytes, Buffer.byteLength(reviewSeatOutput(raw, nonce)));
+                seatAuthoredBytes = Math.max(seatAuthoredBytes, Buffer.byteLength(reviewSeatOutput(raw, nonce, adapter.harnessBannerRows)));
                 // waitOutput is the driver's authoritative marker match. The raw check covers drivers whose
                 // wait timed out at the same boundary the marker landed; either way a trailer completes
                 // normally and is never mistaken for inactivity.
@@ -427,7 +449,7 @@ async function runViaDriverDetailed(adapter, model, prompt, cwd, via, timeoutMs
                 }
             }
             timedOut = Date.now() - startedAt >= timeoutMs && !new RegExp(exitPattern).test(out);
-            if (timedOut)
+            if (timedOut && reviewing)
                 forceClose = true;
         }
         const exitCode = Number(new RegExp(`TICKMARKR_EXIT_${nonce}:(\\d+)`).exec(out)?.[1]);

package/dist/gates/review.d.ts

@@ -53,6 +53,17 @@ export declare function isDiffCapPark(result: GateResult): boolean;
 export declare function diffCapParkReason(results: GateResult[]): string | null;
 export declare function modelId(model: string): string;
 export { modelProvider };
+/**
+ * One function decides whether a reviewer's `resolved` or `reraised` id names a carried fingerprint,
+ * comparing both sides with every whitespace run removed (`s.replace(/\s+/g, "")`).
+ */
+export declare function matchClosureId(candidate: unknown, fingerprint: string): boolean;
+export declare function matchClosureId(candidate: unknown, fingerprints: Iterable<string>): string | undefined;
+/**
+ * Validates closure ids in a review verdict: membership, duplication, and coverage of every prior id
+ * all route through matchClosureId.
+ */
+export declare function isReviewClosureInvalid(v: Pick<ReviewVerdict, "resolved" | "reraised"> | null | undefined, priorIds: ReadonlySet<string> | readonly string[]): boolean;
 export declare function pickReviewer(author: Assignment, channels: BillingChannel[], exclude?: string[], // v1.1 failover: reviewer channels that already produced garbage for this task
 prefer?: string[], // v1.53 T2: review.prefer — reorders eligible channels, never changes eligibility
 floor?: Tier, // task-declared only; config floors govern workers and must not silently move review seats

package/dist/gates/review.js

@@ -1,4 +1,4 @@
-import { writeFileSync } from "node:fs";
+import { existsSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { channelKey, shq } from "../adapters/types.js";
 import { criticalPathHits, DEFAULT_DIFF_CAP, DEFAULT_REVIEW_CRITICAL_PATHS, declaredReviewPolicy, isReviewLeafPath, raiseReviewPolicy, REVIEW_VERSION_MIRRORS, TIER_RANK, } from "../config/config.js";
@@ -168,6 +168,31 @@ export function modelId(model) {
     return model.slice(model.lastIndexOf("/") + 1);
 }
 export { modelProvider };
+export function matchClosureId(candidate, target) {
+    if (typeof candidate !== "string")
+        return typeof target === "string" ? false : undefined;
+    const normCandidate = candidate.replace(/\s+/g, "");
+    if (typeof target === "string") {
+        return normCandidate === target.replace(/\s+/g, "");
+    }
+    for (const fp of target) {
+        if (typeof fp === "string" && normCandidate === fp.replace(/\s+/g, ""))
+            return fp;
+    }
+    return undefined;
+}
+/**
+ * Validates closure ids in a review verdict: membership, duplication, and coverage of every prior id
+ * all route through matchClosureId.
+ */
+export function isReviewClosureInvalid(v, priorIds) {
+    const priors = priorIds instanceof Set ? priorIds : new Set(priorIds);
+    const closureLists = [v?.resolved, v?.reraised];
+    const allCandidateIds = [...(v?.resolved ?? []), ...(v?.reraised ?? [])];
+    return !!v && (priors.size > 0 || closureLists.some((list) => list !== undefined)) && (closureLists.some((list) => !Array.isArray(list) || list.some((id) => !matchClosureId(id, priors)))
+        || new Set(allCandidateIds.map((id) => matchClosureId(id, priors) ?? id)).size !== allCandidateIds.length
+        || [...priors].some((id) => !allCandidateIds.some((candidate) => matchClosureId(candidate, id))));
+}
 // v1.53 T2: same entry grammar as routing.map.prefer (router.ts preferIndex — router is out of this
 // module's dependency direction for a private fn, so the 3 lines live here too): `adapter` matches
 // every channel of that adapter, `adapter:model` exactly one; unmatched channels sort after all entries.
@@ -352,7 +377,24 @@ For every prior material, put its fingerprint in exactly one of resolved (verifi
 Approve iff no material finding remains and every prior material is resolved.
 The top-level comments array is optional. Use it only for actionable line-anchored feedback.
 `;
-    const artifactId = `${task.id}-${nonce}`;
+    // Filenames are journaled (daemon.ts lifts meta.rawPath/briefPath onto the gate-result row), so they
+    // must be reproducible from the same inputs — the verdict nonce is cryptographically random and would
+    // make two otherwise-identical runs diverge in their journal bytes. The reviewer channel already
+    // disambiguates every call that matters: a retry always excludes the flaked channel (run-gates.ts),
+    // so it can never collide with the attempt it replaces.
+    const baseArtifactId = `${task.id}-${channelKey(reviewer).replace(/[^a-zA-Z0-9_.-]/g, "-")}`;
+    let artifactId = baseArtifactId;
+    if (artifactDir) {
+        if (existsSync(join(artifactDir, `review-brief-${baseArtifactId}.md`)) ||
+            existsSync(join(artifactDir, `review-raw-${baseArtifactId}.txt`))) {
+            let counter = 2;
+            while (existsSync(join(artifactDir, `review-brief-${baseArtifactId}-${counter}.md`)) ||
+                existsSync(join(artifactDir, `review-raw-${baseArtifactId}-${counter}.txt`))) {
+                counter++;
+            }
+            artifactId = `${baseArtifactId}-${counter}`;
+        }
+    }
     const briefPath = artifactDir ? join(artifactDir, `review-brief-${artifactId}.md`) : undefined;
     // Persistence is evidence, not a gate input: a full disk or a removed run dir never fails the gate.
     let savedBrief;
@@ -378,14 +420,21 @@ The top-level comments array is optional. Use it only for actionable line-anchor
     // (run-20260709-104447 P87-09). The configured ceiling defaults to that measured 15 minutes.
     cfg.review.timeoutMs);
     const raw = llm.output;
+    let saved;
+    if (artifactDir) {
+        try {
+            saved = join(artifactDir, `review-raw-${artifactId}.txt`);
+            writeFileSync(saved, redactSecrets(raw));
+        }
+        catch {
+            saved = undefined; // persistence is evidence, not a gate input — never fail the gate on it
+        }
+    }
     const provider = modelProvider(reviewer.model, reviewer.vendor);
     const v = extractVerdictJson(raw, nonce);
     const findings = v && Array.isArray(v.findings) ? v.findings : null;
     const priorIds = new Set(priorMaterials.map((finding) => finding.fingerprint));
-    const closureLists = [v?.resolved, v?.reraised];
-    const closureInvalid = !!v && (priorIds.size > 0 || closureLists.some((list) => list !== undefined)) && (closureLists.some((list) => !Array.isArray(list) || list.some((id) => typeof id !== "string" || !priorIds.has(id)))
-        || new Set([...(v?.resolved ?? []), ...(v?.reraised ?? [])]).size !== (v?.resolved?.length ?? 0) + (v?.reraised?.length ?? 0)
-        || [...priorIds].some((id) => !v?.resolved?.includes(id) && !v?.reraised?.includes(id)));
+    const closureInvalid = isReviewClosureInvalid(v, priorIds);
     // findings decides the verdict on its own; the legacy path still needs approve + issues to parse.
     if (!v || closureInvalid || (findings === null && (typeof v.approve !== "boolean" || !Array.isArray(v.issues)))) {
         // OBS-196: name the cause and persist the raw bytes — a ruled-on "unparseable" without its
@@ -394,16 +443,6 @@ The top-level comments array is optional. Use it only for actionable line-anchor
         const cause = closureInvalid ? "malformed-verdict" : llm.launchNeverStarted ? "launch-never-started"
             : llm.timedOut ? (bytes > 0 ? "truncated" : "silent")
                 : classifyVerdictCause(raw, nonce, "approve", llm);
-        let saved;
-        if (artifactDir) {
-            try {
-                saved = join(artifactDir, `review-raw-${artifactId}.txt`);
-                writeFileSync(saved, redactSecrets(raw));
-            }
-            catch {
-                saved = undefined; // persistence is evidence, not a gate input — never fail the gate on it
-            }
-        }
         const failure = cause === "malformed-verdict"
             ? "review output unparseable"
             : "review dispatch failed — no structurally valid nonce-bound response";
@@ -429,7 +468,7 @@ The top-level comments array is optional. Use it only for actionable line-anchor
     const decided = findings !== null
         ? classifyReviewFindings(findings)
         : classifyReviewIssues(v.approve, v.issues);
-    const reraised = priorMaterials.filter((finding) => v.reraised?.includes(finding.fingerprint));
+    const reraised = priorMaterials.filter((finding) => v.reraised?.some((id) => matchClosureId(id, finding.fingerprint)));
     if (reraised.length) {
         if (decided.pass)
             decided.headline = "requested changes";
@@ -450,11 +489,21 @@ The top-level comments array is optional. Use it only for actionable line-anchor
         details,
         meta: {
             ...policyMeta, ...rotationMeta, reviewer: channelKey(reviewer), vendor: reviewer.vendor, provider,
-            ...(priorMaterials.length ? { resolved: v.resolved, reraised: v.reraised } : {}),
+            ...(priorMaterials.length ? {
+                resolved: v.resolved,
+                reraised: v.reraised,
+                normalisedMatches: (v.resolved ?? []).map((id) => matchClosureId(id, priorIds)).filter((id) => id !== undefined),
+                resolvedMatches: (v.resolved ?? []).map((id) => matchClosureId(id, priorIds)).filter((id) => id !== undefined),
+                reraisedMatches: (v.reraised ?? []).map((id) => matchClosureId(id, priorIds)).filter((id) => id !== undefined),
+                normalisedResolved: (v.resolved ?? []).map((id) => matchClosureId(id, priorIds)).filter((id) => id !== undefined),
+                normalisedReraised: (v.reraised ?? []).map((id) => matchClosureId(id, priorIds)).filter((id) => id !== undefined),
+            } : {}),
             ...(reraised.length ? { findings: [
                     ...structuredFindings("review", details).filter((finding) => !reraised.some((prior) => prior.note === finding.note)),
                     ...reraised,
                 ] } : {}),
+            ...(saved ? { rawPath: saved } : {}),
+            ...(savedBrief ? { briefPath: savedBrief } : {}),
         },
     };
 }

package/dist/gates/run-gates.js

@@ -366,7 +366,7 @@ export async function runGates(task, ctx) {
             // ponytail: legacy runs adjacent tools in ONE compareToBaseline call, so there is one interval
             // to measure and each of its gates carries it. Split it only if this branch ever stops batching.
             const finish = startMeasurement();
-            const toolResults = await compareToBaseline(ctx.worktree, commands, ctx.baseline, [...gates]);
+            const toolResults = await compareToBaseline(ctx.worktree, commands, ctx.baseline, [...gates], selected ? { selected } : {});
             const batch = finish();
             for (const g of gates)
                 addMeasurement(g, batch);
@@ -386,7 +386,7 @@ export async function runGates(task, ctx) {
         // any later tool before anyone reads its verdict.
         for (const g of gates) {
             await emitStart(g);
-            const [r] = await measure(g, () => compareToBaseline(ctx.worktree, commands, ctx.baseline, [g]));
+            const [r] = await measure(g, () => compareToBaseline(ctx.worktree, commands, ctx.baseline, [g], g === "test" && selected ? { selected } : {}));
             // the screen's interval IS the test gate's first interval, so the split needs no second clock
             if (g === "test" && selected)
                 selectedDurationMs = spans.get("test").durationMs;

package/dist/run/daemon.d.ts

@@ -14,6 +14,8 @@ export interface RunOptions {
     graphChanged?: boolean;
     retryFailed?: boolean;
     concurrency?: number;
+    /** Bounded wait at a drain caused solely by parked tasks. */
+    approvalWindowMs?: number;
     driver?: ExecutorDriver;
     driverOverride?: DriverChoice;
     adapters?: WorkerAdapter[];
@@ -55,9 +57,8 @@ export interface RunSummary {
  * T14, amended by v2.2 T3: approvals the run accepted and never acted on. `approved` above is still
  * built ONCE at startup — replay determinism depends on it — but a live approval is no longer inert:
  * the boundary sweep in the task loop releases what lands while the daemon runs, so an approval
- * written mid-run is normally enacted by this run. ONE window survives, and it is the reason this
- * fold still exists: an approval accepted after the task loop exits — during tip verify, before the
- * run-end sample below — meets no further boundary, so nothing can release it before this run ends.
+ * written mid-run is enacted at a boundary, during the approval window, or by cancelling tip verify.
+ * This fold still exposes decisions that could not enact, including a failure before dispatch.
  * Without this the run-end record stated only buckets and tipVerify, both accurate, over a milestone
  * that was silently incomplete: run …230 ended tipVerify "passed" with two upheld approvals and zero
  * subsequent dispatches. Scored per task on its NEWEST approval: a later approval is the live
@@ -108,6 +109,9 @@ export declare const SUITE_WAIT_CEILING_MS = 600000;
 export declare const setSuiteWaitCeilingForTests: (ms: number) => void;
 export declare const resetSuiteWaitCeilingForTests: () => void;
 export declare const APPROVAL_POLL_MS = 250;
+export declare const APPROVAL_WINDOW_MS = 120000;
+export declare const setApprovalWindowForTests: (ms: number) => void;
+export declare const resetApprovalWindowForTests: () => void;
 export declare const EARLY_LAUNCH_LIVENESS_MS = 60000;
 /** Test seam — lowers the empty-pane liveness window without sleeping 60s per case. */
 export declare function setEarlyLaunchLivenessMsForTests(ms: number): void;
@@ -151,6 +155,7 @@ export declare function commandsHash(commands: Record<string, string>): string;
 export declare function verifyIntegrationTipCached(intWt: string, commands: Record<string, string>, journal: Journal, opts?: {
     lastMergedTask?: string;
     baseline?: Baseline;
+    signal?: AbortSignal;
 }): Promise<boolean>;
 type SuitePidProbe = (pid: number) => number | undefined;
 /** Count full-suite roots in one process-table snapshot. The probes are arguments so the ownership