tickmarkr 2.2.0 → 2.3.0

package/dist/gates/baseline.d.ts

@@ -23,6 +23,8 @@ export interface BaselineCommand {
     exitCode?: number;
     fingerprints: string[];
     missingCommand?: boolean;
+    /** Why a capture returned no verdict. */
+    invalidCause?: "ceiling-kill" | "resource-exhaustion";
     /** What this command actually took at capture, on a pristine tree. Absent in pre-v1.90 baselines. */
     durationMs?: number;
     /** Sum of the per-file durations named by the runner; null when its output names none. */
@@ -45,6 +47,8 @@ export interface BaselineCommand {
      * verdict: no exit code, no fingerprints, nothing forgivable.
      */
     infra?: true;
+    /** Runner-level exhaustion lines that invalidated a completed capture. */
+    invalidatingLines?: string[];
 }
 export interface BaselineFileDuration {
     file: string;

package/dist/gates/baseline.js

@@ -85,7 +85,7 @@ const TURBO_FAIL_RE = /^\s*(?:[\w@./-]+:\s*)*ELIFECYCLE\s+Command failed\b|^\s*F
 // at least TWO colon-joined segments (`<pkg>:<task>:`, tasks may nest — `pkg:test:unit:`), every
 // segment after the first starting with a letter — so `Error: boom` (one segment), `src/x.ts:12:`
 // (digit segment) and `12:34 error` (eslint stylish) are never stripped.
-const TURBO_PREFIX_RE = /^\s*[\w@./-]+(?::[A-Za-z_][\w.-]*)+:\s+/;
+const TURBO_PREFIX_RE = /^\s*[\w@./-]+(?::[A-Za-z_][\w.-]*)+:(?:\s+|$)/;
 const stripTurboPrefix = (l) => {
     const m = TURBO_PREFIX_RE.exec(l);
     return m ? l.slice(m[0].length) : undefined;
@@ -161,11 +161,36 @@ export function classifyFailureOutput(output) {
  * no failure in that incomplete environment can safely become pre-existing forgiveness. Keep this
  * separate from `classifyFailureOutput` so changing capture policy cannot move gate verdicts.
  */
-const captureHasInvalidatingInfra = (output) => output
-    .split("\n")
-    .map((l) => l.replace(ANSI_RE, ""))
-    .filter((l) => !PASS_LINE_RE.test(l))
-    .some((l) => CAPTURE_EXHAUSTION_RE.test(l));
+const VITEST_ECHO_BLOCK_RE = /^\s*std(?:out|err)\s+\|\s+\S+\.(?:test|spec)\.[cm]?[jt]sx?\s+>\s+\S/;
+/** Keep runner output while omitting Vitest's echoed test-owned stdout/stderr diagnostic blocks. */
+const withoutVitestEchoBlocks = (output) => {
+    const outside = [];
+    let inVitestEchoBlock = false;
+    for (const line of output.split("\n")) {
+        const clean = line.replace(ANSI_RE, "");
+        const runnerLine = stripTurboPrefix(clean) ?? clean;
+        if (inVitestEchoBlock) {
+            if (runnerLine.trim() === "")
+                inVitestEchoBlock = false;
+            continue;
+        }
+        if (VITEST_ECHO_BLOCK_RE.test(runnerLine)) {
+            inVitestEchoBlock = true;
+            continue;
+        }
+        outside.push(line);
+    }
+    return outside;
+};
+const captureInvalidatingLines = (output) => {
+    const invalidating = [];
+    for (const line of withoutVitestEchoBlocks(output)) {
+        const clean = line.replace(ANSI_RE, "");
+        if (!PASS_LINE_RE.test(clean) && CAPTURE_EXHAUSTION_RE.test(clean))
+            invalidating.push(line);
+    }
+    return invalidating;
+};
 const normalizeLine = (l) => l.replace(/\d+/g, "#").replace(/\s+/g, " ").trim();
 // Vitest's default reporter names file durations as
 // `✓ |project| tests/example.test.ts (12 tests) 1.23s` (❯ for a red file). The runner may be
@@ -203,8 +228,7 @@ export const UNRECOGNIZED_FAILURE = "<unrecognized failure output>";
 // renders "zone +3 · run attempt 2 · 1 failed" (what T9 is chartered to draw) contributes nothing, with
 // or without box glyphs, so it cannot manufacture a fresh-fingerprint rejection on any future attempt.
 export function fingerprint(output) {
-    const lines = output
-        .split("\n")
+    const lines = withoutVitestEchoBlocks(output)
         .map((l) => l.replace(ANSI_RE, ""))
         .filter((l) => !PASS_LINE_RE.test(l));
     // GATE-FIX-4 DEFECT 4: every line is read twice — as printed, and with a turbo `<pkg>:<task>:`
@@ -403,14 +427,16 @@ export function ceilingKillResult(gate, r, ceilingMs) {
  * shell asks it to finish faster than the thing it is measuring.
  */
 export const CAPTURE_CEILING_MS = 1_800_000;
-const invalidCaptureEntry = (durationMs) => ({
+const invalidCaptureEntry = (durationMs, invalidCause, invalidatingLines = []) => ({
     infra: true,
+    invalidCause,
     fingerprints: [],
     durationMs,
     fileDurationSumMs: null,
     impliedParallelism: null,
     longestFile: null,
     ceilingMs: effectiveCeilingMs({ durationMs }),
+    ...(invalidatingLines.length ? { invalidatingLines } : {}),
 });
 export async function captureBaseline(cwd, commands) {
     const base = { commands: {} };
@@ -438,20 +464,23 @@ 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);
+            base.commands[name] = invalidCaptureEntry(durationMs, "ceiling-kill");
             continue;
         }
-        const raw = (r.stdout + "\n" + r.stderr).split(cwd).join("");
+        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
         // being taken. A capture cannot know which red lines predated that shortage and which it caused,
         // so none may become a fingerprint every later task gets to forgive.
-        if (captureHasInvalidatingInfra(raw)) {
+        const invalidatingLines = captureInvalidatingLines(combinedOutput);
+        if (invalidatingLines.length) {
             console.error(`tickmarkr: baseline capture for "${name}" completed with process/resource-exhaustion evidence — `
                 + `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.`);
-            base.commands[name] = invalidCaptureEntry(durationMs);
+                + `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);
             continue;
         }
         base.commands[name] = {
@@ -530,7 +559,14 @@ export async function compareToBaseline(cwd, commands, baseline, enabled) {
         if (!cmd) {
             // nothing detected for this gate in the target repo — journal an explicit skip instead of
             // vanishing silently (a lint gate with no lint script rendered as forever-open in status)
-            results.push({ gate: name, pass: true, details: `no ${name} command detected — skipped`, meta: { skipped: true } });
+            const reason = `no ${name} command detected`;
+            const outcome = { kind: "skipped", reason };
+            results.push({
+                gate: name,
+                pass: true,
+                details: `${reason} — skipped`,
+                meta: { skipped: true, outcome },
+            });
             continue;
         }
         const entry = baseline.commands[name];
@@ -556,6 +592,19 @@ export async function compareToBaseline(cwd, commands, baseline, enabled) {
             record(killed);
             continue;
         }
+        const runner = shellToken(cmd) ?? name;
+        if (entry?.missingCommand === true || r.code === 127) {
+            const cause = entry?.missingCommand === true && r.code !== 127
+                ? "the baseline capture recorded this runner as missing"
+                : `the head command exited 127${/\bENOENT\b/i.test(`${r.stdout}\n${r.stderr}`) ? " (spawn ENOENT)" : ""}`;
+            record({
+                gate: name,
+                pass: false,
+                details: `unreadable — ${cause}; runner ${JSON.stringify(runner)} did not produce a trustworthy verdict`,
+                meta: { unreadable: true, runner },
+            });
+            continue;
+        }
         if (r.code === 0) {
             record({ gate: name, pass: true, details: "exit 0" });
             continue;
@@ -594,8 +643,11 @@ export async function compareToBaseline(cwd, commands, baseline, enabled) {
         // 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 closed = entry?.infra === true
-                ? `the baseline capture for this command was killed at its ceiling and recorded no verdict, so nothing here is forgivable — it now exits ${r.code} with no recognizable failure lines — failing closed`
+                ? `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`;
             const evidence = unrecognizedEvidence(raw);
             record({

package/dist/gates/llm.d.ts

@@ -1,4 +1,4 @@
-import type { WorkerAdapter } from "../adapters/types.js";
+import { type WorkerAdapter } from "../adapters/types.js";
 import { type ExecutorDriver, type Slot } from "../drivers/types.js";
 export declare const GATE_PANE_SEP = " \u00B7 ";
 export declare const COMPLETION_FAKING_CHECKLIST = "## Completion-faking checklist\nHunt for these concrete completion-faking shortcuts before ruling on any criterion:\n- hardcoded-result: output or fixture hardcoded to satisfy the stated criterion instead of real logic\n- test-weakening: tests skipped, deleted, or assertions loosened until failing behavior looks green\n- vacuous-assertion: a test that cannot fail (asserts a constant, asserts its own setup, no assertion)\n- fixture-overfit: implementation narrowed to the exact test inputs rather than the described behavior\n- echo-not-implement: criterion text echoed in names, comments, or strings without the behavior itself\n- stub-left-behind: TODO, throw, or no-op stub where the real implementation should be\n- error-swallowing: catch or fallback that hides failures instead of handling them\n- self-mocking: the code under test mocked or faked so the test exercises the mock\n- check-bypass: lint, type, or CI checks disabled, relaxed, or excluded to get green\n- rename-as-work: code moved or renamed and presented as the requested change\n- scope-padding: unrelated edits padding the diff while the criterion's behavior is untouched\nWhen a criterion fails, the verdict MUST name which shortcut above it matches, or state that none does.";
@@ -57,9 +57,15 @@ export declare function captureLlmOutput<T>(run: () => Promise<T>): Promise<{
     value: T;
     outputs: string[];
 }>;
+export interface LlmRunResult {
+    output: string;
+    exitCode?: number;
+    timedOut: boolean;
+}
 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>;
 export declare function dewrapPaneVerdict(out: string, nonce: string): string;
+export declare function runLlmDetailed(adapter: WorkerAdapter, model: string, prompt: string, cwd: string, via?: LlmVia, timeoutMs?: number): Promise<LlmRunResult>;
 export declare function runLlm(adapter: WorkerAdapter, model: string, prompt: string, cwd: string, via?: LlmVia, timeoutMs?: number): Promise<string>;
 export declare function extractJson<T>(raw: string): T | null;
 /** Fable F3: verdict JSON must echo the call nonce — skip unbound or mismatched objects. */

package/dist/gates/llm.js

@@ -3,6 +3,7 @@ import { randomBytes } from "node:crypto";
 import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { matchesTrustDialog } from "../adapters/types.js";
 import { formatOwnedName, parseOwnedName } from "../drivers/types.js";
 import { bannerShell, paneDispatchCommand } from "../brand.js";
 import { sh } from "../run/git.js";
@@ -128,21 +129,24 @@ export async function captureLlmOutput(run) {
     const value = await llmOutputCapture.run(outputs, run);
     return { value, outputs };
 }
-export async function runHeadless(adapter, model, prompt, cwd, timeoutMs = 300000) {
+async function runHeadlessDetailed(adapter, model, prompt, cwd, timeoutMs = 300000) {
     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;
+        return { output: r.stdout + "\n" + r.stderr, exitCode: r.code, timedOut: r.timedOut === true };
     }
     finally {
         rmSync(dir, { recursive: true, force: true });
     }
 }
+export async function runHeadless(adapter, model, prompt, cwd, timeoutMs = 300000) {
+    return (await runHeadlessDetailed(adapter, model, prompt, cwd, timeoutMs)).output;
+}
 // 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) {
+async function runViaDriverDetailed(adapter, model, prompt, cwd, via, timeoutMs = 300000) {
     const dir = mkdtempSync(join(tmpdir(), "tickmarkr-llm-"));
     let slot;
     let accountant;
@@ -161,10 +165,21 @@ export async function runViaDriver(adapter, model, prompt, cwd, via, timeoutMs =
         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));
+        if (via.driver.sendKey) {
+            try {
+                if (matchesTrustDialog(await via.driver.read(slot, 400), adapter.trustDialog)) {
+                    await via.driver.sendKey(slot, adapter.trustDialog.key);
+                }
+            }
+            catch {
+                /* a failed pre-wait read must not replace the verdict wait */
+            }
+        }
         // 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).
         const exitPattern = `TICKMARKR_EXIT_${nonce}:\\d`;
         let out;
+        let timedOut = false;
         const gatePrompt = prompt.startsWith("TICKMARKR-JUDGE") || prompt.startsWith("TICKMARKR-REVIEW");
         if (!gatePrompt) {
             await via.driver.waitOutput(slot, exitPattern, timeoutMs, { regex: true });
@@ -230,8 +245,14 @@ export async function runViaDriver(adapter, model, prompt, cwd, via, timeoutMs =
                     break;
                 }
             }
+            timedOut = Date.now() - startedAt >= timeoutMs && !new RegExp(exitPattern).test(out);
         }
-        return dewrapPaneVerdict(out, nonce);
+        const exitCode = Number(new RegExp(`TICKMARKR_EXIT_${nonce}:(\\d+)`).exec(out)?.[1]);
+        return {
+            output: dewrapPaneVerdict(out, nonce),
+            ...(Number.isFinite(exitCode) ? { exitCode } : {}),
+            timedOut,
+        };
     }
     finally {
         try {
@@ -245,6 +266,9 @@ export async function runViaDriver(adapter, model, prompt, cwd, via, timeoutMs =
         }
     }
 }
+export async function runViaDriver(adapter, model, prompt, cwd, via, timeoutMs = 300000) {
+    return (await runViaDriverDetailed(adapter, model, prompt, cwd, via, timeoutMs)).output;
+}
 // 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
 // literals and ZERO lines begin with `{`. `--source recent-unwrapped` cannot undo it: the wrap is
@@ -304,12 +328,15 @@ export function dewrapPaneVerdict(out, nonce) {
     }
     return out;
 }
+export async function runLlmDetailed(adapter, model, prompt, cwd, via, timeoutMs = 300000) {
+    const result = await (via
+        ? runViaDriverDetailed(adapter, model, prompt, cwd, via, timeoutMs)
+        : runHeadlessDetailed(adapter, model, prompt, cwd, timeoutMs));
+    llmOutputCapture.getStore()?.push(result.output);
+    return result;
+}
 export async function runLlm(adapter, model, prompt, cwd, via, timeoutMs = 300000) {
-    const out = await (via
-        ? runViaDriver(adapter, model, prompt, cwd, via, timeoutMs)
-        : runHeadless(adapter, model, prompt, cwd, timeoutMs));
-    llmOutputCapture.getStore()?.push(out);
-    return out;
+    return (await runLlmDetailed(adapter, model, prompt, cwd, via, timeoutMs)).output;
 }
 export function extractJson(raw) {
     const fenced = [...raw.matchAll(/```json\s*\n([\s\S]*?)```/g)].at(-1);
@@ -369,37 +396,41 @@ export function extractVerdictJson(raw, nonce) {
             /* fall through */
         }
     }
-    let pos = raw.length - 1;
-    while (pos >= 0) {
-        const end = raw.lastIndexOf("}", pos);
-        if (end === -1)
-            return null;
-        let depth = 1;
-        let stepped = false;
-        for (let i = end - 1; i >= 0; i--) {
-            if (raw[i] === "}")
+    for (let start = raw.lastIndexOf("{"); start >= 0;) {
+        const nextStart = start === 0 ? -1 : raw.lastIndexOf("{", start - 1);
+        let depth = 0;
+        let quoted = false;
+        let escaped = false;
+        for (let i = start; i < raw.length; i++) {
+            const char = raw[i];
+            if (quoted) {
+                if (escaped)
+                    escaped = false;
+                else if (char === "\\")
+                    escaped = true;
+                else if (char === '"')
+                    quoted = false;
+                continue;
+            }
+            if (char === '"')
+                quoted = true;
+            else if (char === "{")
                 depth++;
-            else if (raw[i] === "{") {
-                depth--;
-                if (depth === 0) {
-                    stepped = true;
-                    try {
-                        const v = JSON.parse(raw.slice(i, end + 1));
-                        if (v && typeof v === "object" && v.nonce === nonce) {
-                            const { nonce: _n, ...rest } = v;
-                            return rest;
-                        }
+            else if (char === "}" && --depth === 0) {
+                try {
+                    const v = JSON.parse(raw.slice(start, i + 1));
+                    if (v && typeof v === "object" && v.nonce === nonce) {
+                        const { nonce: _n, ...rest } = v;
+                        return rest;
                     }
-                    catch {
-                        /* keep scanning */
-                    }
-                    pos = i - 1;
-                    break;
                 }
+                catch {
+                    /* keep scanning */
+                }
+                break;
             }
         }
-        if (!stepped)
-            return null;
+        start = nextStart;
     }
     return null;
 }

package/dist/gates/review.d.ts

@@ -41,13 +41,15 @@ export type TaskDiffMeasurement = {
     readonly fullMeasurement: ArtifactDiffMeasurement;
     readonly capMeasurement: ArtifactDiffMeasurement;
 };
-export declare function fetchTaskDiff(worktree: string, baseRef: string): Promise<TaskDiffMeasurement>;
+export declare function fetchTaskDiff(worktree: string, baseRef: string, files?: readonly 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;
+/** Provider identity comes from the served model, not a gateway adapter's stamped vendor. */
+export declare function modelProvider(model: string, fallback?: string): string;
 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): BillingChannel | null;

package/dist/gates/review.js

@@ -2,12 +2,13 @@ import { 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";
+import { filesGlob } from "../graph/files-glob.js";
 import { renderAcceptanceItem } from "../graph/schema.js";
 import { getAdapter } from "../adapters/registry.js";
 import { shOk } from "../run/git.js";
 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 { appendAnchoredReview, COMPLETION_FAKING_CHECKLIST, extractVerdictJson, generateVerdictNonce, runLlmDetailed, 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";
@@ -99,12 +100,14 @@ export async function mirrorsVersionOnly(worktree, baseRef, path) {
     const changed = diff.split("\n").filter((l) => /^[+-]/.test(l) && !/^(?:\+\+\+|---)/.test(l));
     return changed.length > 0 && changed.every((l) => VERSION_FIELD_LINE_RE.test(l));
 }
-export async function fetchTaskDiff(worktree, baseRef) {
+export async function fetchTaskDiff(worktree, baseRef, files = []) {
     // --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 matched = files.length ? (await changedPaths(worktree, baseRef)).filter(filesGlob([...files])) : [];
+    const pathspec = matched.length ? ` -- ${matched.map(shq).join(" ")}` : "";
+    const [rawFull, rawForCap] = files.length && matched.length === 0 ? ["", ""] : await Promise.all([
+        shOk(`git diff --full-index '${baseRef}..HEAD'${pathspec}`, worktree),
+        shOk(`git diff --full-index -U0 '${baseRef}..HEAD'${pathspec}`, worktree),
     ]);
     const fullMeasurement = measureArtifactDiff(rawFull);
     const capMeasurement = measureArtifactDiff(rawForCap);
@@ -162,6 +165,24 @@ export function diffCapParkReason(results) {
 export function modelId(model) {
     return model.slice(model.lastIndexOf("/") + 1);
 }
+/** Provider identity comes from the served model, not a gateway adapter's stamped vendor. */
+export function modelProvider(model, fallback = "unknown") {
+    const id = model.toLowerCase();
+    const prefix = id.includes("/") ? id.slice(0, id.indexOf("/")) : "";
+    if (prefix === "openai" || prefix === "openai-codex" || /^(?:gpt|o\d)/.test(id))
+        return "openai";
+    if (prefix === "anthropic" || /^(?:claude|opus|sonnet|haiku|fable)(?:-|$)/.test(id))
+        return "anthropic";
+    if (prefix === "google" || /^gemini(?:-|$)/.test(id))
+        return "google";
+    if (prefix === "xai" || /^grok(?:-|$)/.test(id))
+        return "xai";
+    if (["zai", "zhipu", "zai-coding-plan"].includes(prefix) || /^glm(?:-|$)/.test(id))
+        return "zhipu";
+    if (["kimi-code", "moonshot"].includes(prefix) || /^kimi(?:-|$)/.test(id))
+        return "moonshot";
+    return fallback;
+}
 // 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.
@@ -179,11 +200,14 @@ floor) {
     const authorChannel = channels.find((c) => c.adapter === author.adapter && c.model === author.model);
     if (!authorChannel)
         return null;
+    // Failover also guards true provider; the initial pick keeps the established stamped-vendor contract.
+    const authorProvider = modelProvider(author.model, authorChannel.vendor);
     return (channels
         // two independent axes: different vendor AND different base-model identity (ADDED TO the vendor
         // rule, never replacing it — a future edit can't silently drop either). The diversity filter runs
         // BEFORE preference ranking: prefer sorts survivors only, so no entry can resurrect an excluded channel.
         .filter((c) => c.vendor !== authorChannel.vendor
+        && (exclude.length === 0 || modelProvider(c.model, c.vendor) !== authorProvider)
         && modelId(c.model) !== modelId(author.model)
         && !exclude.includes(channelKey(c))
         && (floor === undefined || TIER_RANK[c.tier] >= TIER_RANK[floor]))
@@ -285,10 +309,10 @@ artifactDir) {
             ? `no cross-vendor reviewer available at or above task-declared ${reviewerFloor} floor (diversity rule)`
             : "no cross-vendor reviewer available (diversity rule)";
         return cfg.review.required
-            ? { gate: "review", pass: false, details: `${reason}; set review.required:false to waive`, meta: { noEligibleReviewer: true, ...(reviewerFloor ? { reviewerFloor } : {}) } }
+            ? { gate: "review", pass: false, details: `unreadable — ${reason}; set review.required:false to waive`, meta: { noEligibleReviewer: true, unreadable: true, ...(reviewerFloor ? { reviewerFloor } : {}) } }
             : { gate: "review", pass: true, details: `WARNING: ${reason} — review waived by config`, meta: { noEligibleReviewer: true, ...(reviewerFloor ? { reviewerFloor } : {}) } };
     }
-    const measuredDiff = await fetchTaskDiff(worktree, baseRef);
+    const measuredDiff = await fetchTaskDiff(worktree, baseRef, task.files);
     // 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);
@@ -327,7 +351,7 @@ Approve iff no material finding remains; an empty findings list is a clean appro
 The top-level comments array is optional. Use it only for actionable line-anchored feedback.
 `;
     let concludedOnInactivity = false;
-    const raw = await runLlm(getAdapter(reviewer.adapter, adapters), reviewer.model, prompt, worktree, via ? {
+    const llm = await runLlmDetailed(getAdapter(reviewer.adapter, adapters), reviewer.model, prompt, worktree, via ? {
         driver: via.driver,
         keep: via.keep,
         onSlot: via.onSlot,
@@ -341,13 +365,16 @@ The top-level comments array is optional. Use it only for actionable line-anchor
     // (run-20260709-104447 P87-09). ponytail: literal 15min; make it cfg.review.timeoutMs if a
     // second knob-turner appears.
     900_000);
+    const raw = llm.output;
+    const provider = modelProvider(reviewer.model, reviewer.vendor);
     const v = extractVerdictJson(raw, nonce);
     const findings = v && Array.isArray(v.findings) ? v.findings : null;
     // findings decides the verdict on its own; the legacy path still needs approve + issues to parse.
     if (!v || (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
         // evidence cannot be audited, and a cutoff must never be indistinguishable from a parse defect.
-        const cause = classifyVerdictCause(raw, nonce, "approve");
+        const cause = classifyVerdictCause(raw, nonce, "approve", llm);
+        const bytes = Buffer.byteLength(raw, "utf8");
         let saved;
         if (artifactDir) {
             try {
@@ -366,12 +393,15 @@ The top-level comments array is optional. Use it only for actionable line-anchor
         return {
             gate: "review",
             pass: false,
-            details: `${failure} (reviewer ${reviewer.adapter}:${reviewer.model}; cause: ${cause}${saved ? `; raw saved: ${saved}` : ""}) — failing closed`,
+            details: `${failure} (reviewer ${reviewer.adapter}:${reviewer.model}; vendor: ${reviewer.vendor}; provider: ${provider}; cause: ${cause}${saved ? `; raw saved: ${saved}` : ""}) — failing closed`,
             meta: {
                 ...policyMeta,
                 reviewer: channelKey(reviewer),
+                vendor: reviewer.vendor,
+                provider,
                 unparseable: true,
                 cause,
+                ...(cause === "empty-output" ? { bytes } : {}),
                 ...(concludedOnInactivity ? { classification: "infra", infra: true } : {}),
             },
         };
@@ -379,11 +409,11 @@ 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 prose = `reviewer ${reviewer.adapter}:${reviewer.model} (${reviewer.vendor}): ${decided.headline}${decided.lines.length ? "\n" + decided.lines.join("\n") : ""}`;
+    const prose = `reviewer ${reviewer.adapter}:${reviewer.model} (vendor: ${reviewer.vendor}; provider: ${provider}): ${decided.headline}${decided.lines.length ? "\n" + decided.lines.join("\n") : ""}`;
     return {
         gate: "review",
         pass: decided.pass,
         details: appendAnchoredReview(prose, v),
-        meta: { ...policyMeta, reviewer: channelKey(reviewer) },
+        meta: { ...policyMeta, reviewer: channelKey(reviewer), vendor: reviewer.vendor, provider },
     };
 }

package/dist/gates/run-gates.d.ts

@@ -31,6 +31,12 @@ export type GateEvent = {
     phase: "end";
     gate: GateName;
     result: GateResult;
+} | {
+    phase: "note";
+    gate: GateName;
+    name: string;
+    payload: Record<string, unknown>;
+    result: GateResult;
 };
 export interface GateContext {
     worktree: string;

package/dist/gates/run-gates.js

@@ -11,7 +11,7 @@ import { evidenceGate } from "./evidence.js";
 import { captureLlmOutput } from "./llm.js";
 import { disallowedBy } from "../route/preference.js";
 import { marginalCostRank } from "../route/router.js";
-import { reviewGate } from "./review.js";
+import { pickReviewer, reviewGate } from "./review.js";
 import { scopeGate } from "./scope.js";
 import { shGit } from "../run/git.js";
 import { withJudgeInvocationEvidence } from "../run/journal.js";
@@ -540,7 +540,7 @@ export async function runGates(task, ctx) {
                 .sort((x, y) => TIER_RANK[y.tier] - TIER_RANK[x.tier] || marginalCostRank(x) - marginalCostRank(y))[0];
             // v1.87 T2: the failover seat obeys the same policy the primary judge just passed — a denied
             // channel is refused here too, never reached by falling through the exclusion arms below.
-            const judgePool = (ctx.judgeChannels ?? ctx.channels).filter((c) => disallowedBy(c, ctx.cfg.routing, "judge") === null);
+            const judgePool = (ctx.judgeChannels ?? []).filter((c) => disallowedBy(c, ctx.cfg.routing, "judge") === null);
             const crossAdapter = pick(judgePool.filter((c) => c.adapter !== flakedAdapter));
             const sameAdapter = pick(judgePool.filter((c) => c.adapter === flakedAdapter && channelKey(c) !== flakedKey));
             // Prefer a different adapter; if the fleet only has one adapter, retry on a different channel of
@@ -576,25 +576,40 @@ export async function runGates(task, ctx) {
             return captured.value;
         };
         let rv = await dispatch((adapters) => reviewGate(task, ctx.worktree, ctx.baseRef, ctx.author, ctx.channels, adapters, ctx.cfg, ctx.via, ctx.excludeReviewers, ctx.artifactDir));
-        // OBS-193: an unparseable review verdict retries the REVIEW exactly once on a different reviewer —
-        // never the worker (GATE-09's judge-retry shape: straight-line single `if`, meta-only detection,
-        // the flaked verdict never enters results). The exclusion rides reviewGate's own excludeReviewers
-        // parameter, so pickReviewer's diversity rules still govern the retry seat; a fleet with no second
-        // eligible seat keeps the ORIGINAL result so the recorded cause stays truthful (OBS-196).
+        // OBS-193/574: an unparseable review verdict retries the REVIEW exactly once, preferring a
+        // different adapter. Only a single-adapter eligible pool may fall back to another channel on the
+        // flaked adapter. The flaked verdict never enters results; an exhausted pool preserves its cause.
         if (rv.meta?.unparseable === true && typeof rv.meta.reviewer === "string") {
             const flaked = rv.meta.reviewer;
+            const emptyOutput = rv.meta.cause === "empty-output";
+            if (emptyOutput) {
+                await ctx.onGate?.({
+                    phase: "note", gate: "review", name: "reviewer-empty-output",
+                    payload: { reviewer: flaked, bytes: typeof rv.meta.bytes === "number" ? rv.meta.bytes : 0 },
+                    result: { ...rv, meta: { ...rv.meta, skipped: true } },
+                });
+            }
             const retryVia = ctx.via
                 ? { ...ctx.via, nameFor: (role, adapter) => ctx.via.nameFor(role, adapter) + "-r1" }
                 : undefined;
-            const second = await dispatch((adapters) => reviewGate(task, ctx.worktree, ctx.baseRef, ctx.author, ctx.channels, adapters, ctx.cfg, retryVia, [...(ctx.excludeReviewers ?? []), flaked], ctx.artifactDir));
+            const priorExclusions = ctx.excludeReviewers ?? [];
+            const flakedAdapter = flaked.slice(0, flaked.indexOf(":"));
+            const adapterExclusions = ctx.channels.filter((c) => c.adapter === flakedAdapter).map(channelKey);
+            const crossAdapter = pickReviewer(ctx.author, ctx.channels, [...priorExclusions, ...adapterExclusions], ctx.cfg.review.prefer ?? [], task.routingHints?.floor);
+            const exclusion = crossAdapter ? "adapter" : "channel";
+            const retryExclusions = [...priorExclusions, ...(crossAdapter ? adapterExclusions : [flaked])];
+            const second = await dispatch((adapters) => reviewGate(task, ctx.worktree, ctx.baseRef, ctx.author, ctx.channels, adapters, ctx.cfg, retryVia, retryExclusions, ctx.artifactDir));
             if (second.meta?.noEligibleReviewer !== true) {
                 const retried = typeof second.meta?.reviewer === "string" ? second.meta.reviewer : "none";
+                const route = exclusion === "adapter"
+                    ? `different-adapter retry; excluded flaked adapter ${flakedAdapter}`
+                    : `same-adapter fallback; excluded flaked channel ${flaked}`;
                 rv = {
                     ...second,
                     // `details` is lifted onto the journal's gate-result row; meta.reviewRetry is not. Keep the
                     // re-route visible in the result text a reader actually opens, including on a red retry.
-                    details: `review re-route: ${flaked} produced no parseable verdict; replaced by ${retried}\n${second.details}`,
-                    meta: { ...second.meta, reviewRetry: { flaked, retried } },
+                    details: `review re-route (${route}): ${flaked} produced ${emptyOutput ? "EMPTY output" : "no parseable verdict"}; replaced by ${retried}\n${second.details}`,
+                    meta: { ...second.meta, reviewRetry: { flaked, retried, exclusion } },
                 };
             }
             else if (task.routingHints?.floor) {

package/dist/gates/verdict-cause.d.ts

@@ -1,4 +1,8 @@
 export type VerdictDiscriminator = "approve" | "pass" | "ok" | "action";
-export type VerdictUnparseableCause = "empty-output" | "no-verdict" | "malformed-verdict";
+export type VerdictUnparseableCause = "empty-output" | "no-verdict" | "malformed-verdict" | "timeout" | "startup-failure";
+export interface VerdictProcessFacts {
+    timedOut?: boolean;
+    exitCode?: number;
+}
 export declare function hasVerdictParticipationWitness(raw: string, nonce: string, discriminator: VerdictDiscriminator): boolean;
-export declare function classifyVerdictCause(raw: string, nonce: string, discriminator: VerdictDiscriminator): VerdictUnparseableCause;
+export declare function classifyVerdictCause(raw: string, nonce: string, discriminator: VerdictDiscriminator, process?: VerdictProcessFacts): VerdictUnparseableCause;