tickmarkr 2.5.3 → 2.5.5

package/dist/gates/review.js

@@ -3,7 +3,7 @@ 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 { renderAcceptanceItem, TIERS } from "../graph/schema.js";
 import { getAdapter } from "../adapters/registry.js";
 import { shOk } from "../run/git.js";
 import { structuredFindings } from "../run/journal.js";
@@ -200,9 +200,52 @@ function reviewPreferIndex(c, prefer) {
     const i = prefer.findIndex((p) => p === c.adapter || p === channelKey(c));
     return i === -1 ? prefer.length : i;
 }
+/**
+ * RF-1 (OBS-922 add.2/3): the tier a reviewer must meet is the maximum of the author's tier, the
+ * task-declared floor, a configured `review.floor` tier and, on a second round or a retry, the prior
+ * reviewer's tier. The cause names the input that reached the maximum (earlier inputs win a tie, so a
+ * floor the author's tier already satisfies is attributed to the author).
+ */
+export function resolveReviewerFloor(authorTier, taskFloor, configFloor, priorReviewerTier) {
+    const inputs = [
+        [authorTier, "author-tier"], [taskFloor, "task-floor"], [configFloor, "config"], [priorReviewerTier, "prior-reviewer"],
+    ];
+    let best = { floor: authorTier, cause: "author-tier" };
+    for (const [tier, cause] of inputs) {
+        if (tier !== undefined && TIER_RANK[tier] > TIER_RANK[best.floor])
+            best = { floor: tier, cause };
+    }
+    return best;
+}
+/**
+ * The highest tier among the task's prior reviewers — the prior reviewer's tier for RF-1. A recorded
+ * dispatch tier is historical evidence and wins over the current pool; an unrecorded one falls back to
+ * the seat's channel; a seat neither establishes (it left the pool on resume, or the journal holds
+ * garbage) holds frontier — fail closed, never silently dropped.
+ */
+export function priorReviewerTier(channels, priorReviewers = []) {
+    let top;
+    for (const p of priorReviewers) {
+        const key = typeof p === "string" ? p : p.reviewer;
+        const seen = (typeof p === "string" ? undefined : p.tier) ?? channels.find((ch) => channelKey(ch) === key)?.tier;
+        const tier = TIERS.includes(seen) ? seen : "frontier";
+        if (top === undefined || TIER_RANK[tier] > TIER_RANK[top])
+            top = tier;
+    }
+    return top;
+}
+/**
+ * The gate's floor: author tier, task floor, review.floor (a tier — `worker` names none) and the seats
+ * the caller names as THIS TASK's prior reviewers (earlier rounds' seats, a flaked seat). Eligibility
+ * exclusions are NOT evidence — a retry bans a flaked seat's whole adapter, and those sibling channels
+ * never reviewed — and neither is the run-scoped LRU rotation history, which names unrelated tasks' seats.
+ */
+export function gateReviewerFloor(task, cfg, author, channels, priorReviewers = []) {
+    return resolveReviewerFloor(author.tier, task.routingHints?.floor, cfg.review.floor === "worker" ? undefined : cfg.review.floor, priorReviewerTier(channels, priorReviewers));
+}
 export function pickReviewer(author, channels, exclude = [], // v1.1 failover: reviewer channels that already produced garbage for this task
 prefer = [], // v1.53 T2: review.prefer — reorders eligible channels, never changes eligibility
-floor, // task-declared only; config floors govern workers and must not silently move review seats
+floor, // task/config/prior floor from the caller; the author's own tier is ALWAYS applied here (RF-1)
 history = [], // run-scoped picks, oldest to newest; empty preserves the established ranking
 onSeat, demoted = new Set()) {
     // FLEET-05 success criterion 2: an author not resolvable in the channel list yields NO reviewer.
@@ -213,6 +256,8 @@ onSeat, demoted = new Set()) {
     if (!authorChannel)
         return null;
     const authorProvider = modelProvider(author.model, authorChannel.vendor);
+    // RF-1: every caller inherits the author-tier floor — a reviewer is never seated below its author.
+    const effectiveFloor = resolveReviewerFloor(author.tier, floor).floor;
     const ranked = channels
         // Three independent axes: different vendor, different resolved provider identity (OBS-946: on initial pick
         // as well as failover, so an aggregator channel stamped "mixed" never seats the author's own provider),
@@ -222,7 +267,7 @@ onSeat, demoted = new Set()) {
         && 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]))
+        && TIER_RANK[c.tier] >= TIER_RANK[effectiveFloor])
         .sort((a, b) => reviewPreferIndex(a, prefer) - reviewPreferIndex(b, prefer) || TIER_RANK[b.tier] - TIER_RANK[a.tier] || marginalCostRank(a) - marginalCostRank(b));
     const reviewer = [...ranked].sort((a, b) => Number(demoted.has(channelKey(a))) - Number(demoted.has(channelKey(b)))
         || history.lastIndexOf(channelKey(a)) - history.lastIndexOf(channelKey(b))
@@ -247,7 +292,10 @@ ${files.map((path) => `- ${path}`).join("\n")}`;
 export async function reviewGate(task, worktree, baseRef, author, channels, adapters, cfg, via, excludeReviewers, 
 // OBS-196: run dir for raw-output persistence on an unparseable verdict; absent (older callers,
 // direct tests) skips persistence and changes nothing else.
-artifactDir, reviewHistory, demotedReviewers, carriedFindings = []) {
+artifactDir, reviewHistory, demotedReviewers, carriedFindings = [], 
+// RF-1: channel keys of THIS task's prior reviewers (earlier rounds, a flaked seat) — task-scoped,
+// never the run-wide rotation history nor excludeReviewers; the seat holds the highest of their tiers.
+priorReviewers = []) {
     // R3 (OBS-186): participation is keyed on PATHS. The compiler's assignment comes from the DECLARED
     // files[]; the operator's floor may RAISE it to full and can never lower it. `complexityThreshold` is
     // retired — the branch that returned a green skip on a complexity comparison is gone, and with it the
@@ -317,20 +365,19 @@ artifactDir, reviewHistory, demotedReviewers, carriedFindings = []) {
         policy: "full",
         ...(promotedBy ? { promotedFrom: declaredPolicy, promotedBy } : {}),
     };
-    // A reviewer floor is opt-in at the task. Applying cfg.routing.floors here would change the
-    // historical seat for every task that never asked for review-tier coupling.
-    const reviewerFloor = task.routingHints?.floor;
+    // RF-1: the floor is max(author tier, task floor, review.floor tier, prior reviewer's tier). Only
+    // review.floor is read from config — cfg.routing.floors governs workers and never moves review seats.
+    const { floor: reviewerFloor, cause: reviewerFloorCause } = gateReviewerFloor(task, cfg, author, channels, priorReviewers);
+    const floorMeta = { reviewerFloor, reviewerFloorCause };
     let rotationSeat;
     const reviewer = pickReviewer(author, channels, excludeReviewers ?? [], cfg.review.prefer ?? [], reviewerFloor, reviewHistory, reviewHistory ? (seat) => { rotationSeat = seat; } : undefined, demotedReviewers);
     if (!reviewer) {
         // meta.noEligibleReviewer lets run-gates' review-retry keep the ORIGINAL unparseable result when
         // the retry finds no second seat — a truthful cause beats a synthetic no-reviewer failure.
-        const reason = reviewerFloor
-            ? `no cross-vendor reviewer available at or above task-declared ${reviewerFloor} floor (diversity rule)`
-            : "no cross-vendor reviewer available (diversity rule)";
+        const reason = `no cross-vendor reviewer available at or above ${reviewerFloor} floor (${reviewerFloorCause}; diversity rule)`;
         return cfg.review.required || priorMaterials.length > 0
-            ? { gate: "review", pass: false, details: `unreadable — ${reason}; ${priorMaterials.length ? "carried materials require a review verdict" : "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 } : {}) } };
+            ? { gate: "review", pass: false, details: `unreadable — ${reason}; ${priorMaterials.length ? "carried materials require a review verdict" : "set review.required:false to waive"}`, meta: { noEligibleReviewer: true, unreadable: true, ...floorMeta } }
+            : { gate: "review", pass: true, details: `WARNING: ${reason} — review waived by config`, meta: { noEligibleReviewer: true, ...floorMeta } };
     }
     reviewHistory?.push(channelKey(reviewer));
     const rotationMeta = rotationSeat === undefined ? {} : { rotationSeat };
@@ -369,6 +416,7 @@ Classify every concern as "material" (a correctness, security, or acceptance-cri
 block the merge) or "minor" (style, naming, or preference that should not block). ONLY material findings
 block approval. For a minor concern you have decided not to block on, set "defer": true and give a
 one-line "rationale" — it is recorded in the review, never dropped.
+A fix you prescribe that would break suites outside the task's declared write scope (files[]) is a scope finding, never a material one.
 
 Respond with ONLY this JSON:
 {"nonce": "${nonce}", "approve": true|false, "resolved": [], "reraised": [], "findings": [{"note": "...", "severity": "material"|"minor", "defer": false, "rationale": ""}], "comments": [{"path": "path/to/file", "line": 42, "body": "actionable feedback"}]}
@@ -453,7 +501,9 @@ The top-level comments array is optional. Use it only for actionable line-anchor
             meta: {
                 ...policyMeta,
                 ...rotationMeta,
+                ...floorMeta,
                 reviewer: channelKey(reviewer),
+                reviewerTier: reviewer.tier,
                 vendor: reviewer.vendor,
                 provider,
                 ...(cause === "malformed-verdict" ? { unparseable: true } : { noVerdict: true, classification: "infra", infra: true }),
@@ -488,15 +538,13 @@ The top-level comments array is optional. Use it only for actionable line-anchor
         pass: decided.pass,
         details,
         meta: {
-            ...policyMeta, ...rotationMeta, reviewer: channelKey(reviewer), vendor: reviewer.vendor, provider,
+            ...policyMeta, ...rotationMeta, ...floorMeta, reviewer: channelKey(reviewer), reviewerTier: reviewer.tier, vendor: reviewer.vendor, provider,
+            // OBS-990 b: the verbatim ids plus ONE normalised copy of each list — never a third alias.
             ...(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)),

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

@@ -3,8 +3,10 @@ import { type TickmarkrConfig } from "../config/config.js";
 import { type GateName, type Task } from "../graph/schema.js";
 import { type Baseline } from "./baseline.js";
 import { type GateVia } from "./llm.js";
+import { type PriorReviewer } from "./review.js";
 import type { GateResult } from "./types.js";
 import { type StructuredFinding } from "../run/journal.js";
+import { type VerificationScope } from "./cache.js";
 export type LoadProvider = () => number;
 /** Test seam — inject deterministic load samples; production always reads os.loadavg. */
 export declare function setLoadProviderForTests(provider: LoadProvider): void;
@@ -42,6 +44,7 @@ export type GateEvent = {
     result: GateResult;
 };
 export interface GateContext {
+    verificationScope?: VerificationScope;
     worktree: string;
     baseRef: string;
     result: WorkerResult;
@@ -57,11 +60,13 @@ export interface GateContext {
     excludeReviewers?: string[];
     demotedReviewers?: Set<string>;
     reviewHistory?: string[];
+    priorReviewers?: PriorReviewer[];
     artifactDir?: string;
     pipeline?: "v185" | "legacy";
     selectTests?: boolean;
     collateral?: ReadonlyArray<string>;
     onGate?: (e: GateEvent) => void | Promise<void>;
+    stateDir?: string;
 }
 /**
  * The configured test command narrowed to these files. Mirrors testFiltered's `--` rule (acceptance.ts:104):

package/dist/gates/run-gates.js

@@ -6,15 +6,17 @@ import { TIER_RANK } from "../config/config.js";
 import { getAdapter } from "../adapters/registry.js";
 import { GATE_NAMES } from "../graph/schema.js";
 import { acceptanceGate } from "./acceptance.js";
-import { compareToBaseline } from "./baseline.js";
+import { compareToBaseline, effectiveCeilingMs } from "./baseline.js";
 import { evidenceGate } from "./evidence.js";
 import { captureLlmOutput } from "./llm.js";
 import { disallowedBy } from "../route/preference.js";
 import { marginalCostRank } from "../route/router.js";
-import { pickReviewer, reviewGate } from "./review.js";
+import { gateReviewerFloor, pickReviewer, reviewGate } from "./review.js";
 import { scopeGate } from "./scope.js";
-import { shGit } from "../run/git.js";
+import { evaluateManifestedTest, isVitestTestCommand } from "./test-manifest.js";
+import { shGit, resolvedCapacity } from "../run/git.js";
 import { withJudgeInvocationEvidence } from "../run/journal.js";
+import { computeVerificationIdentity, formatReusedRow, getVerdictStore, isInfraResult, resolveStateDir, reusedIdentity, } from "./cache.js";
 const productionLoadProvider = () => loadavg()[0] ?? 0;
 let loadProvider = productionLoadProvider;
 /** Test seam — inject deterministic load samples; production always reads os.loadavg. */
@@ -192,9 +194,45 @@ export function testCommandForFiles(testCmd, files) {
     const fwd = wrapped && !/\s--\s/.test(testCmd) ? " --" : "";
     return `${testCmd}${fwd} ${files.map(shq).join(" ")}`;
 }
+/** The manifest-report path for a detected vitest test command — never the stdout-count/file-count path. */
+async function runVitestManifestGate(worktree, cmd, baseline, selected, artifactDir) {
+    const entry = baseline.commands.test;
+    const outcome = await evaluateManifestedTest(cmd, worktree, {
+        baselineDurations: entry?.fileDurations,
+        longestFile: entry?.longestFile,
+        overallCeilingMs: effectiveCeilingMs(entry),
+        artifactDir,
+    });
+    const reportPath = outcome.reportPath;
+    return {
+        gate: "test",
+        pass: outcome.pass,
+        details: outcome.details,
+        meta: { ...outcome.meta, reportPath, ...(selected ? { selectedTests: [...selected] } : {}) },
+    };
+}
+const SIGNAL_EXIT_RE = /\b(?:SIGTERM|SIGKILL|signal\s+(?:9|15)|exit(?:s|ed|\s+code)?\s+(?:137|143))\b/i;
+const FAILURE_IDENTITY_RE = /\b(?:AssertionError|FAIL\s+\S|Tests?\s+\d+\s+failed|expected\s+.+\s+to\s+)\b/i;
+/** D1: apply the daemon's signal-only rider before either battery cache read or write. Its onGate
+ * classification happens after persistence, too late to keep a scripted runner's non-verdict out.
+ * Keep named failures as work verdicts and preserve details for failure-policy fingerprinting. */
+function classifySignalOnlyTest(g) {
+    if (g.gate !== "test" || g.pass || g.meta?.infra === true || !SIGNAL_EXIT_RE.test(g.details))
+        return;
+    const named = Array.isArray(g.meta?.failingTests) && g.meta.failingTests.length > 0;
+    if (named || FAILURE_IDENTITY_RE.test(g.details))
+        return;
+    g.meta = { ...g.meta, classification: "infra", infra: true, retryable: false, kind: "signal-exit" };
+}
 export async function runGates(task, ctx) {
     const results = [];
     let commits = [];
+    const stateDir = ctx.stateDir ?? resolveStateDir(ctx.worktree, ctx.artifactDir);
+    const verdictStore = getVerdictStore(stateDir);
+    // VC-1: a reused verdict is journaled as its own row (the daemon appends every note by name) so
+    // the ledger names the reuse and the identity even where the gate-result row's details must stay
+    // the fresh verdict's (see formatReusedRow).
+    const noteReuse = (gate, r, id) => ctx.onGate?.({ phase: "note", gate, name: "gate-reused-verdict", payload: { gate, pass: r.pass, details: r.meta?.reusedDetails, ...reusedIdentity(id) }, result: r });
     const shapeGates = ctx.cfg.gates.byShape?.[task.shape];
     const enabled = (g) => task.gates.includes(g) && (g !== "acceptance" && g !== "review" || shapeGates?.[g] !== false);
     const failed = () => results.some((r) => !r.pass);
@@ -359,7 +397,7 @@ export async function runGates(task, ctx) {
     const runBattery = async (commands, selected, gates = toolGates) => {
         if (!gates.length)
             return;
-        if (!v185) {
+        if (!v185 && !(commands.test && isVitestTestCommand(commands.test, ctx.worktree))) {
             // ponytail: compareToBaseline batches adjacent tools — their starts are emitted at iteration,
             // not at true execution start. They are collectively sub-second (measured), so the debounce
             // suppresses them anyway; split compareToBaseline only if a tool gate ever gets slow.
@@ -386,25 +424,60 @@ 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], g === "test" && selected ? { selected } : {}));
+            const cmd = commands[g];
+            let r;
+            let cached = false;
+            let identity;
+            if (cmd !== undefined) {
+                identity = await computeVerificationIdentity({
+                    worktree: ctx.worktree,
+                    gate: g,
+                    scope: ctx.verificationScope,
+                    command: cmd,
+                    baseline: ctx.baseline,
+                    selectedSet: g === "test" ? selected : undefined,
+                    capacity: resolvedCapacity(),
+                });
+                const hit = verdictStore.get(identity);
+                if (hit)
+                    classifySignalOnlyTest(hit); // Older entries predate classification at the write seam.
+                if (hit && identity && !isInfraResult(hit) && (hit.pass || (ctx.verificationScope ?? "battery") === "battery")) {
+                    r = formatReusedRow(hit, identity);
+                    cached = true;
+                    await noteReuse(g, r, identity);
+                }
+            }
+            if (!r) {
+                // VL-1: a detected vitest test command is judged by its own invocation-bound report — the
+                // stdout-count/file-count path (compareToBaseline's fileCountDeficit) never runs for it. Any
+                // other scripted test command keeps today's exit-code contract byte-identically.
+                const useManifest = g === "test" && commands.test !== undefined && isVitestTestCommand(commands.test, ctx.worktree);
+                r = useManifest
+                    ? await measure(g, () => runVitestManifestGate(ctx.worktree, commands.test, ctx.baseline, selected, ctx.artifactDir))
+                    : (await measure(g, () => compareToBaseline(ctx.worktree, commands, ctx.baseline, [g], g === "test" && selected ? { selected } : {})))[0];
+            }
             // 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;
+                selectedDurationMs = spans.get("test")?.durationMs ?? 0;
             // The pre-battery check proves the tree clean ONCE; a command that exits 0 having rewritten a
             // tracked file makes it dirty again, and every gate after it — including the next shell gate,
             // which would then run against bytes HEAD does not hold — inherits that. So re-check after each
             // command, the last one included, and fail the gate whose command did it. (A red command needs
             // no check: it already ends the round, and its own output is the truer verdict.)
-            if (r.pass && commands[g]) {
+            if (!cached && r.pass && commands[g]) {
                 const dirt = await dirtyWorktree();
                 if (dirt) {
                     await record(dirtyRefusal(g, dirt, commands[g]));
                     return;
                 }
             }
+            if (r)
+                classifySignalOnlyTest(r);
+            if (!cached && identity && r && !isInfraResult(r)) {
+                verdictStore.set(identity, { ...r, meta: { ...r.meta, source: "gate", runDir: ctx.artifactDir } });
+            }
             if (g === "test" && selected) {
                 const screened = { ...r, meta: { ...r.meta, selectedTests: selected } };
-                // green: held (see heldTest) so the full suite below can supersede it with ONE verdict.
                 if (!screened.pass)
                     await record(screened);
                 else {
@@ -602,7 +675,11 @@ export async function runGates(task, ctx) {
             }
             return rv;
         };
-        let rv = await dispatch((adapters) => reviewGate(task, ctx.worktree, ctx.baseRef, ctx.author, ctx.channels, adapters, ctx.cfg, ctx.via, ctx.excludeReviewers, ctx.artifactDir, ctx.reviewHistory, ctx.demotedReviewers, ctx.carriedFindings));
+        // RF-1: THIS task's prior reviewers — earlier rounds' seats plus the seats that produced garbage for
+        // it (excludeReviewers names only dispatched seats). Kept apart from the eligibility exclusions the
+        // retry below adds for a flaked seat's whole adapter: those sibling channels never reviewed.
+        const priorReviewers = [...(ctx.priorReviewers ?? []), ...(ctx.excludeReviewers ?? [])];
+        let rv = await dispatch((adapters) => reviewGate(task, ctx.worktree, ctx.baseRef, ctx.author, ctx.channels, adapters, ctx.cfg, ctx.via, ctx.excludeReviewers, ctx.artifactDir, ctx.reviewHistory, ctx.demotedReviewers, ctx.carriedFindings, priorReviewers));
         // 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.
@@ -622,10 +699,14 @@ export async function runGates(task, ctx) {
             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);
+            // RF-1: the retry filters by the floor reviewGate resolves — author tier, task floor, review.floor
+            // and the prior reviewers' tiers, the flaked seat's own included, so a retry never drops a tier.
+            const retryPrior = [...priorReviewers, flaked];
+            const retryFloor = gateReviewerFloor(task, ctx.cfg, ctx.author, ctx.channels, retryPrior).floor;
+            const crossAdapter = pickReviewer(ctx.author, ctx.channels, [...priorExclusions, ...adapterExclusions], ctx.cfg.review.prefer ?? [], retryFloor);
             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, ctx.reviewHistory, ctx.demotedReviewers, ctx.carriedFindings));
+            const second = await dispatch((adapters) => reviewGate(task, ctx.worktree, ctx.baseRef, ctx.author, ctx.channels, adapters, ctx.cfg, retryVia, retryExclusions, ctx.artifactDir, ctx.reviewHistory, ctx.demotedReviewers, ctx.carriedFindings, retryPrior));
             if (second.meta?.noEligibleReviewer !== true) {
                 const retried = typeof second.meta?.reviewer === "string" ? second.meta.reviewer : "none";
                 const route = exclusion === "adapter"
@@ -639,10 +720,11 @@ export async function runGates(task, ctx) {
                     meta: { ...second.meta, reviewRetry: { flaked, retried, exclusion } },
                 };
             }
-            else if (task.routingHints?.floor) {
-                // Preserve the original no-answer cause when no replacement exists, but name the declared
-                // floor that correctly refused a lower-tier fallback.
-                rv = { ...rv, details: `${rv.details}\nreview re-route refused: ${second.details}` };
+            else {
+                // Preserve the original no-answer cause when no replacement exists, but name the resolved
+                // floor that correctly refused a lower-tier fallback — in details AND in the row's meta.
+                const { reviewerFloor, reviewerFloorCause } = second.meta ?? {};
+                rv = { ...rv, details: `${rv.details}\nreview re-route refused: ${second.details}`, meta: { ...rv.meta, reviewerFloor, reviewerFloorCause } };
             }
         }
         return invocations.length ? { ...rv, meta: { ...rv.meta, invocations } } : rv;
@@ -739,9 +821,43 @@ export async function runGates(task, ctx) {
         // This is the last shell command a round can run — the judge's named-test oracle (acceptance.ts)
         // may have run one before it, and every gate between the battery and here reads commits only, so
         // a clean tree HERE is what makes "the gated commit is the tested tree" true at merge time.
-        const [full] = await measure("test", () => compareToBaseline(ctx.worktree, ctx.commands, ctx.baseline, ["test"]));
-        fullDurationMs = spans.get("test").durationMs - (selectedDurationMs ?? 0);
-        const dirt = full.pass ? await dirtyWorktree() : undefined;
+        // VL-1: the merge-candidate's manifest is the FULL set — a full suite whose report lacks one
+        // manifest file never reaches the pass branch below, so a selected-only green can never merge.
+        let full;
+        let cached = false;
+        let identity;
+        if (ctx.commands.test !== undefined) {
+            identity = await computeVerificationIdentity({
+                worktree: ctx.worktree,
+                gate: "test",
+                scope: ctx.verificationScope,
+                command: ctx.commands.test,
+                baseline: ctx.baseline,
+                selectedSet: undefined,
+                capacity: resolvedCapacity(),
+            });
+            const hit = verdictStore.get(identity);
+            if (hit)
+                classifySignalOnlyTest(hit);
+            if (hit && identity && !isInfraResult(hit) && (hit.pass || (ctx.verificationScope ?? "battery") === "battery")) {
+                full = formatReusedRow(hit, identity);
+                cached = true;
+                await noteReuse("test", full, identity);
+            }
+        }
+        if (!full) {
+            const fullUsesManifest = ctx.commands.test !== undefined && isVitestTestCommand(ctx.commands.test, ctx.worktree);
+            full = fullUsesManifest
+                ? await measure("test", () => runVitestManifestGate(ctx.worktree, ctx.commands.test, ctx.baseline, undefined, ctx.artifactDir))
+                : (await measure("test", () => compareToBaseline(ctx.worktree, ctx.commands, ctx.baseline, ["test"])))[0];
+        }
+        fullDurationMs = spans.get("test") ? spans.get("test").durationMs - (selectedDurationMs ?? 0) : 0;
+        const dirt = (!cached && full.pass) ? await dirtyWorktree() : undefined;
+        if (full)
+            classifySignalOnlyTest(full);
+        if (!cached && identity && full && !dirt && !isInfraResult(full)) {
+            verdictStore.set(identity, { ...full, meta: { ...full.meta, source: "gate", runDir: ctx.artifactDir } });
+        }
         const merged = withTelemetry(dirt
             ? dirtyRefusal("test", dirt, ctx.commands.test)
             : { ...full, meta: { ...full.meta, fullSuite: true, selectedTests: selected } });

package/dist/gates/test-manifest.d.ts

@@ -0,0 +1,99 @@
+import type { BaselineFileDuration } from "./baseline.js";
+export declare function isVitestTestCommand(cmd: string, cwd: string): boolean;
+/** One identity for every path this module compares: repo-relative, forward-slash. `vitest list
+ * --json` and `TestModule.moduleId` both hand back an absolute filesystem path already resolved
+ * through any symlink in it (e.g. macOS's `/var` -> `/private/var`, under which every OS temp dir —
+ * and so every test fixture worktree — lives); `cwd` as tickmarkr holds it may not be. Resolving cwd
+ * before computing the relative path is what makes the two actually comparable. Manifests built from
+ * a selected-test screen are already repo-relative and pass through unchanged. */
+export declare function toManifestPath(file: string, cwd: string): string;
+export interface TestReportCompletion {
+    at: number;
+    status: "passed" | "failed";
+    /** Failure fingerprints for this file; absent/empty on a passed file. */
+    failures?: string[];
+}
+/** The runner's own machine report — requested/started/completed are the runner's claims about ITSELF. */
+export interface TestReport {
+    nonce: string;
+    requested: string[];
+    started: Record<string, number>;
+    completed: Record<string, TestReportCompletion>;
+    /** Files the reporter observed complete MORE than once — `completed`'s object keys cannot show
+     * this themselves (a second write silently overwrites the first), so the reporter records the
+     * evidence separately before it is lost. */
+    duplicateCompletions?: string[];
+    /** Written last, once, when the runner reaches its own terminal state. Its absence means the run
+     * never certified completion — killed, crashed, or still in flight — and is never a verdict. */
+    certificate?: {
+        at: number;
+        exitCode: number;
+    };
+}
+/** Reads and structurally validates the report; a missing or malformed file is `undefined` — never a partial parse. */
+export declare function readTestReport(path: string): TestReport | undefined;
+export type ManifestVerdictKind = "pass" | "infra" | "work" | "fail-closed";
+export interface ManifestVerdict {
+    kind: ManifestVerdictKind;
+    pass: boolean;
+    details: string;
+    meta: Record<string, unknown>;
+}
+/**
+ * The independent validator: given the manifest THIS invocation was asked to prove, its bound nonce
+ * and the independently observed process exit code, decide the
+ * verdict from the report alone. `killedFile` short-circuits every report-shaped check — a job this
+ * module killed for a per-file hang never reaches its report.
+ */
+export declare function verifyManifestReport(opts: {
+    manifest: readonly string[];
+    nonce: string;
+    exitCode: number | undefined;
+    report: TestReport | undefined;
+    killedFile?: string;
+    hangBudgetMs?: number;
+}): ManifestVerdict;
+/** How much longer than its baseline measurement one file may legitimately run before it is a hang. */
+export declare const FILE_HANG_SLACK = 3;
+export declare const DEFAULT_FILE_HANG_BUDGET_MS = 60000;
+export declare function fileHangBudgetMs(file: string, baselineDurations?: readonly BaselineFileDuration[] | null, ceilingMs?: number, longestFile?: BaselineFileDuration | null): number;
+export interface ManifestRunResult {
+    exitCode: number | undefined;
+    stdout: string;
+    stderr: string;
+    report: TestReport | undefined;
+    killedFile?: string;
+    hangBudgetMs?: number;
+    /** The child's own pid (its process GROUP id too, since it is spawned detached) — for a caller
+     * that wants to prove the group is really gone after a hang kill (`process.kill(-pid, 0)` throws). */
+    pid?: number;
+}
+/** Supervise the configured command and poll the runner's atomic lifecycle snapshots. Every
+ * timeout kills the detached process group, including descendants holding the output pipes. */
+export declare function runManifestedTest(cmd: string, cwd: string, opts: {
+    manifest: readonly string[];
+    nonce: string;
+    reportPath: string;
+    env?: NodeJS.ProcessEnv;
+    baselineDurations?: readonly BaselineFileDuration[] | null;
+    longestFile?: BaselineFileDuration | null;
+    pollMs?: number;
+    overallCeilingMs?: number;
+}): Promise<ManifestRunResult>;
+export interface ManifestGateOutcome {
+    pass: boolean;
+    kind: ManifestVerdictKind;
+    details: string;
+    classification?: "infra" | "regression";
+    meta: Record<string, unknown>;
+    exitCode: number;
+    reportPath: string;
+}
+/** One configured runner execution, and its own collection under the same arguments and environment.
+ * The installed runner is trusted (R28 add.1 option B); the nonce catches stale artifacts, not forgery. */
+export declare function evaluateManifestedTest(cmd: string, cwd: string, opts: {
+    baselineDurations?: readonly BaselineFileDuration[] | null;
+    longestFile?: BaselineFileDuration | null;
+    overallCeilingMs?: number;
+    artifactDir?: string;
+}): Promise<ManifestGateOutcome>;