tickmarkr 1.30.0

package/dist/drivers/types.js

@@ -0,0 +1,77 @@
+// ---- Ownership contract (T1: OBS-17 pane-hygiene) --------------------------------------------
+// Every pane/tab drovr creates is identified by exactly one parseable token:
+//   drovr:<role>:<taskId>:<attempt>:<runId>
+// role ∈ OWNED_ROLES; attempt is a non-negative integer; taskId/runId never contain ":" (task and
+// run ids are alphanumeric/dash by construction elsewhere). formatOwnedName/parseOwnedName round-trip
+// exactly. parseOwnedName (or isForeignName) is the ONLY way reconcile.ts may decide a live pane name
+// is drovr-owned — anything that doesn't parse is foreign and is never a candidate for closing.
+export const OWNED_ROLES = ["worker", "judge", "review", "consult", "watch", "other"];
+const OWNED_PREFIX = "drovr";
+const OWNED_RE = new RegExp(`^${OWNED_PREFIX}:(${OWNED_ROLES.join("|")}):([^:]+):(\\d+):([^:]+)$`);
+export function formatOwnedName(o) {
+    return `${OWNED_PREFIX}:${o.role}:${o.taskId}:${o.attempt}:${o.runId}`;
+}
+export function parseOwnedName(name) {
+    const m = OWNED_RE.exec(name);
+    if (!m)
+        return null;
+    return { role: m[1], taskId: m[2], attempt: Number(m[3]), runId: m[4] };
+}
+export function isForeignName(name) {
+    return parseOwnedName(name) === null;
+}
+// v1.22b T1: workspace-aware fold over a fleet snapshot — decides which owned panes are garbage
+// right now. In-workspace: the existing desired-set/spareLiveLlm sweep (OBS-17 T2). Out-of-workspace:
+// an owned pane from a DIFFERENT run is a misplaced leftover (bug, foreign actor, pre-VIS-10 relic)
+// and closes regardless of `desired`; an owned pane from THIS run elsewhere is left alone — a live
+// run can legitimately hold panes across workspaces, so only run age marks a misplaced pane garbage.
+// Foreign names (parseOwnedName fails) are never candidates, in any workspace.
+export function panesToClose(agents, desired, ws, runId, opts) {
+    const out = [];
+    for (const a of agents) {
+        if (typeof a.name !== "string" || typeof a.paneId !== "string")
+            continue;
+        const owned = parseOwnedName(a.name);
+        if (!owned)
+            continue;
+        if (a.workspaceId === ws) {
+            if (desired.has(a.name))
+                continue;
+            if (opts?.spareLiveLlm && owned.runId === runId && (owned.role === "judge" || owned.role === "review" || owned.role === "consult"))
+                continue;
+        }
+        else if (owned.runId === runId) {
+            continue; // this run's own pane in another workspace — never touched
+        }
+        out.push({ paneId: a.paneId, tabId: a.tabId });
+    }
+    return out;
+}
+// Legacy raw name shapes daemon.ts/gates/llm.ts/consult.ts/herdr.ts's narrator() build today (daemon.ts
+// and gates/llm.ts are out of this task's file scope): "<taskId>-worker-<adapter>-a<attempt>-<runTag>"
+// (daemon.ts), "<role> · <taskId>[-r1]" (gates/llm.ts gatePaneName, also covers consult.ts), and
+// "narrator-watch-<pid>" (herdr.ts). This is the ONE place that knows their shapes — used by
+// HerdrDriver's internal bookkeeping (renameGroupTab/glyphFor) and by reconcile.ts to recognize what
+// a live pane's REAL name decodes to, without requiring a call-site migration yet. Callers that
+// already have the structured fields should pass `owned` directly instead (T2 retires this parsing).
+// runId is supplied by the caller's own run context, not read out of the string — none of today's
+// legacy shapes lexically carry it except the worker shape's runTag.
+const WORKER_RE = /^(.+)-worker-.+-a(\d+)-(.+)$/;
+const GATE_ROLE_RE = /^(judge|review|consult) · (.+)$/;
+const NARRATOR_RE = /^narrator-watch-\d+$/;
+export function canonicalizeLegacyName(name, runId) {
+    const already = parseOwnedName(name);
+    if (already)
+        return already;
+    const w = WORKER_RE.exec(name);
+    if (w)
+        return { role: "worker", taskId: w[1], attempt: Number(w[2]), runId: `run-${w[3]}` };
+    const g = GATE_ROLE_RE.exec(name);
+    if (g) {
+        const retry = g[2].endsWith("-r1");
+        return { role: g[1], taskId: retry ? g[2].slice(0, -3) : g[2], attempt: retry ? 1 : 0, runId };
+    }
+    if (NARRATOR_RE.test(name))
+        return { role: "watch", taskId: "run", attempt: 0, runId };
+    return { role: "other", taskId: name, attempt: 0, runId };
+}

package/dist/gates/acceptance.d.ts

@@ -0,0 +1,19 @@
+import { type WorkerAdapter } from "../adapters/types.js";
+import { type Task } from "../graph/schema.js";
+import { type LlmVia } from "./llm.js";
+import type { GateResult } from "./types.js";
+export interface JudgeVerdict {
+    pass: boolean;
+    criteria: Array<{
+        criterion: string;
+        met: boolean;
+        reason: string;
+    }>;
+}
+export interface AcceptanceGateOpts {
+    testCmd?: string;
+}
+export declare function acceptanceGate(task: Task, worktree: string, baseRef: string, judge: {
+    adapter: WorkerAdapter;
+    model: string;
+}, via?: LlmVia, opts?: AcceptanceGateOpts): Promise<GateResult>;

package/dist/gates/acceptance.js

@@ -0,0 +1,92 @@
+import { channelKey, shq } from "../adapters/types.js";
+import { renderAcceptanceItem } from "../graph/schema.js";
+import { sh, shOk } from "../run/git.js";
+import { extractJson, runLlm } from "./llm.js";
+const DIFF_CAP = 60_000; // judge sees diff + criteria only, and not unboundedly (spec §12)
+const isCommand = (a) => typeof a === "object" && a.oracle === "command";
+const isTest = (a) => typeof a === "object" && a.oracle === "test";
+const isJudge = (a) => typeof a === "string" || (typeof a === "object" && a.oracle === "judge");
+// npm/yarn/pnpm/npx script wrappers need `--` to forward -t to the underlying vitest/jest runner; a bare
+// runner (vitest/jest) takes -t directly. -t is the shared testNamePattern shorthand both honor.
+function testFiltered(testCmd, name) {
+    const fwd = /^\s*(npm|yarn|pnpm|npx)\b/.test(testCmd) ? "-- " : "";
+    return `${testCmd} ${fwd}-t ${shq(name)}`;
+}
+// last few non-empty output lines, for context on a failing oracle (capped so details stay readable)
+function tail(out, n = 8) {
+    const t = out.trim();
+    if (!t)
+        return "";
+    return "\n" + t.split("\n").slice(-n).join("\n");
+}
+export async function acceptanceGate(task, worktree, baseRef, judge, via, opts = {}) {
+    // 1. deterministic oracles — exit code decides, fail-closed, zero LLM calls (spec §2, T2).
+    //    A failure returns here, before any runLlm() call: a judge can never override it.
+    const passedDet = [];
+    for (const a of task.acceptance) {
+        if (isCommand(a)) {
+            const r = await sh(a.command, worktree);
+            if (r.code !== 0) {
+                return { gate: "acceptance", pass: false,
+                    details: `oracle failed: $ ${a.command} (exit ${r.code})${tail(r.stderr || r.stdout)}` };
+            }
+            passedDet.push(`✓ $ ${a.command} (exit 0)`);
+        }
+        else if (isTest(a)) {
+            if (!opts.testCmd) {
+                return { gate: "acceptance", pass: false,
+                    details: `oracle failed: test "${a.test}" — no test command configured to run it (failing closed)` };
+            }
+            const r = await sh(testFiltered(opts.testCmd, a.test), worktree);
+            if (r.code !== 0) {
+                return { gate: "acceptance", pass: false,
+                    details: `oracle failed: test "${a.test}" (exit ${r.code})${tail(r.stderr || r.stdout)}` };
+            }
+            passedDet.push(`✓ test: ${a.test} (exit 0)`);
+        }
+    }
+    // 2. judge items — only after every deterministic oracle passed (a failed one returned above).
+    const judgeItems = task.acceptance.filter(isJudge);
+    const detBlock = passedDet.length ? passedDet.join("\n") + "\n" : "";
+    if (!judgeItems.length) {
+        // deterministic oracles alone decided the gate — no LLM spend.
+        return { gate: "acceptance", pass: true, details: passedDet.join("\n") || "no acceptance oracles" };
+    }
+    // spec §2: deterministic oracles preferred; an only-judge task gets an explicit warning in details.
+    const onlyJudge = passedDet.length === 0;
+    const warn = onlyJudge
+        ? "WARNING: only judge oracles — no deterministic command/test oracle guards this task (deterministic preferred, spec §2).\n"
+        : "";
+    const diff = (await shOk(`git diff '${baseRef}..HEAD'`, worktree)).slice(0, DIFF_CAP);
+    const prompt = `DROVR-JUDGE
+You are a strict acceptance judge. Decide whether the diff satisfies EVERY acceptance criterion.
+Judge only what the diff proves — plausible-but-wrong must fail. Do not award partial credit.
+Deterministic command/test oracles have already passed mechanically; judge ONLY the rubric items below.
+
+## Task ${task.id}: ${task.title}
+Goal: ${task.goal}
+
+## Acceptance criteria (judge)
+${judgeItems.map((a) => `- ${renderAcceptanceItem(a)}`).join("\n")}
+
+## Diff (vs base)
+\`\`\`diff
+${diff}
+\`\`\`
+
+Respond with ONLY this JSON (no prose before or after):
+{"pass": true|false, "criteria": [{"criterion": "...", "met": true|false, "reason": "..."}]}
+`;
+    const raw = await runLlm(judge.adapter, judge.model, prompt, worktree, via);
+    const v = extractJson(raw);
+    if (!v || typeof v.pass !== "boolean" || !Array.isArray(v.criteria)) {
+        // GATE-09: structured meta names the flaked judge channel (mirrors review.ts:99 meta precedent) so
+        // run-gates can retry the judge on a failover channel without string-matching details (D-03).
+        // The parsed-verdict paths below are untouched — the flake signal is exactly extractJson→null here.
+        return { gate: "acceptance", pass: false,
+            details: warn + detBlock + "judge output unparseable — failing closed",
+            meta: { unparseable: true, judge: channelKey({ adapter: judge.adapter.id, model: judge.model }) } };
+    }
+    const lines = v.criteria.map((c) => `${c.met ? "✓" : "✗"} ${c.criterion}: ${c.reason}`);
+    return { gate: "acceptance", pass: v.pass, details: warn + detBlock + (lines.join("\n") || (v.pass ? "judge passed" : "judge failed")) };
+}

package/dist/gates/baseline.d.ts

@@ -0,0 +1,12 @@
+import type { DrovrConfig } from "../config/config.js";
+import type { GateResult } from "./types.js";
+export interface Baseline {
+    commands: Record<string, {
+        exitCode: number;
+        fingerprints: string[];
+    }>;
+}
+export declare function fingerprint(output: string): string[];
+export declare function detectGateCommands(repoRoot: string, cfg: DrovrConfig): Record<string, string>;
+export declare function captureBaseline(cwd: string, commands: Record<string, string>): Promise<Baseline>;
+export declare function compareToBaseline(cwd: string, commands: Record<string, string>, baseline: Baseline, enabled: string[]): Promise<GateResult[]>;

package/dist/gates/baseline.js

@@ -0,0 +1,97 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { sh } from "../run/git.js";
+// incident #2 (run-20260709-104447): a vitest ✓ PASS line with "error" in the test NAME, wrapped in ANSI
+// codes that varied between baseline and worktree runs, was reported as a "new failure". Strip ANSI first;
+// a pass-marker line is never a failure. [\d;#] covers raw ANSI and digit-normalized ANSI ("\x1b[#m") from
+// baselines stored by pre-hardening code.
+const ANSI_RE = /\x1b\[[\d;#]*[A-Za-z]/g;
+// ponytail: only leading ✓/✔ after optional "label:" prefixes (turbo/vitest) counts as a pass line — other
+// runners' pass markers (PASS, ok) stay fingerprintable; extend the regex when a real one bites
+const PASS_LINE_RE = /^\s*(?:[\w@./-]+:\s*)*[✓✔]/;
+// HYG-08 (D-01, incident run-20260711-154920): a failing test went unnamed for 3 attempts because details
+// headlined benign fingerprint-diff noise. These anchors harvest the runner's OWN failure naming from fresh
+// output to headline it. \s is fine in a TS regex — the BSD [[:space:]] rule binds shell grep only.
+const FAIL_ANCHOR_RE = /^\s*FAIL\s+/; // vitest/jest: " FAIL  <file> > <suite> > <test>"
+const SUMMARY_FAIL_RE = /^\s*Tests?\s+(?:Files?\s+)?\d+\s+failed/; // " Tests  N failed | M passed (T)"
+const normalizeLine = (l) => l.replace(/\d+/g, "#").replace(/\s+/g, " ").trim();
+export function fingerprint(output) {
+    const lines = output
+        .split("\n")
+        .map((l) => l.replace(ANSI_RE, ""))
+        .filter((l) => !PASS_LINE_RE.test(l) && /\b(error|fail(ed|ure|ing)?)\b/i.test(l))
+        .map(normalizeLine);
+    return [...new Set(lines)];
+}
+// stored baselines may predate ANSI/pass-marker hardening — renormalize at compare time so existing
+// on-disk baseline.json files stay comparable without recapture (compat invariant, CLAUDE.md)
+const renormalize = (fp) => normalizeLine(fp.replace(ANSI_RE, ""));
+export function detectGateCommands(repoRoot, cfg) {
+    const out = {};
+    const pkgPath = join(repoRoot, "package.json");
+    const scripts = existsSync(pkgPath)
+        ? (JSON.parse(readFileSync(pkgPath, "utf8")).scripts ?? {})
+        : {};
+    for (const name of ["build", "test", "lint"]) {
+        if (cfg.gates[name])
+            out[name] = cfg.gates[name];
+        else if (scripts[name])
+            out[name] = `npm run -s ${name}`;
+    }
+    return out;
+}
+export async function captureBaseline(cwd, commands) {
+    const base = { commands: {} };
+    for (const [name, cmd] of Object.entries(commands)) {
+        const r = await sh(cmd, cwd);
+        // ponytail: strip the executing cwd so repo-root capture and worktree compare fingerprint identically; /private-vs-/tmp symlink variance is out of scope
+        base.commands[name] = { exitCode: r.code, fingerprints: fingerprint((r.stdout + "\n" + r.stderr).split(cwd).join("")) };
+    }
+    return base;
+}
+// HYG-08 (D-01): headline the runner's own failure naming; demote the fingerprint diff to a secondary
+// section. Extracts from `raw` — the SAME cwd-stripped, per-line ANSI_RE-stripped string that was
+// fingerprinted, digits UN-normalized (Pitfall 2: normalization mangles test names, and the diff set could
+// drop a FAIL line that fingerprint-collides with baseline noise). No headline anchors → byte-identical
+// fallback to today's text (non-vitest runners lose nothing). RED-pinned by tests/gates/baseline.test.ts
+// "HYG-08: details headlines the failing test, not the noise".
+function headlineDetails(raw, fresh) {
+    const headlines = raw
+        .split("\n")
+        .map((l) => l.replace(ANSI_RE, ""))
+        .filter((l) => FAIL_ANCHOR_RE.test(l) || SUMMARY_FAIL_RE.test(l));
+    if (!headlines.length)
+        return { details: `new failures vs baseline:\n${fresh.join("\n")}` };
+    return {
+        details: `failing tests:\n${headlines.join("\n")}\n\nnew failure fingerprints vs baseline (secondary):\n${fresh.join("\n")}`,
+        meta: { failingTests: headlines.filter((l) => FAIL_ANCHOR_RE.test(l)) },
+    };
+}
+export async function compareToBaseline(cwd, commands, baseline, enabled) {
+    const results = [];
+    for (const name of enabled) {
+        const cmd = commands[name];
+        if (!cmd)
+            continue; // nothing detected for this gate in the target repo
+        const r = await sh(cmd, cwd);
+        if (r.code === 0) {
+            results.push({ gate: name, pass: true, details: "exit 0" });
+            continue;
+        }
+        const raw = (r.stdout + "\n" + r.stderr).split(cwd).join("");
+        const known = new Set((baseline.commands[name]?.fingerprints ?? []).map(renormalize));
+        const fresh = fingerprint(raw).filter((f) => !known.has(f));
+        if (!fresh.length && (baseline.commands[name]?.exitCode ?? 1) === 0) {
+            results.push({
+                gate: name,
+                pass: false,
+                details: `command was green at baseline but now exits ${r.code} with no recognizable failure lines — failing closed`,
+            });
+            continue;
+        }
+        results.push(fresh.length
+            ? { gate: name, pass: false, ...headlineDetails(raw, fresh) }
+            : { gate: name, pass: true, details: `exit ${r.code} but only pre-existing failures (forgiven)` });
+    }
+    return results;
+}

package/dist/gates/evidence.d.ts

@@ -0,0 +1,4 @@
+import type { GateResult } from "./types.js";
+export declare function evidenceGate(worktree: string, baseRef: string): Promise<GateResult & {
+    commits: string[];
+}>;

package/dist/gates/evidence.js

@@ -0,0 +1,12 @@
+import { shOk } from "../run/git.js";
+export async function evidenceGate(worktree, baseRef) {
+    const commits = (await shOk(`git rev-list '${baseRef}..HEAD'`, worktree)).trim().split("\n").filter(Boolean);
+    if (!commits.length) {
+        return { gate: "evidence", pass: false, details: "no commits — worker claimed work but committed nothing", commits: [] };
+    }
+    const stat = (await shOk(`git diff --stat '${baseRef}..HEAD'`, worktree)).trim();
+    if (!stat) {
+        return { gate: "evidence", pass: false, details: "commits exist but the cumulative diff is empty", commits };
+    }
+    return { gate: "evidence", pass: true, details: `${commits.length} commit(s):\n${stat}`, commits };
+}

package/dist/gates/llm.d.ts

@@ -0,0 +1,25 @@
+import type { WorkerAdapter } from "../adapters/types.js";
+import { type ExecutorDriver, type Slot } from "../drivers/types.js";
+export declare const GATE_PANE_SEP = " \u00B7 ";
+export type GatePaneRole = "judge" | "review" | "consult";
+/** T8: role-first pane name for fleet visibility — judge · T4, review · T3, consult · T2. */
+export declare function gatePaneName(role: GatePaneRole, taskId: string, suffix?: string): string;
+export declare function rolePaneNameFromPrompt(prompt: string, fallback: string): string;
+export interface LlmVia {
+    driver: ExecutorDriver;
+    name: string;
+    label?: string;
+    keep?: boolean;
+    onSlot?: (slot: Slot) => void;
+}
+export interface GateVia {
+    driver: ExecutorDriver;
+    keep?: boolean;
+    onSlot?: (slot: Slot) => void;
+    nameFor: (role: "judge" | "review", adapter: string) => string;
+    labelFor: (role: "judge" | "review") => string;
+}
+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 runLlm(adapter: WorkerAdapter, model: string, prompt: string, cwd: string, via?: LlmVia, timeoutMs?: number): Promise<string>;
+export declare function extractJson<T>(raw: string): T | null;

package/dist/gates/llm.js

@@ -0,0 +1,101 @@
+import { mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { formatOwnedName, parseOwnedName } from "../drivers/types.js";
+import { sh } from "../run/git.js";
+export const GATE_PANE_SEP = " · ";
+/** T8: role-first pane name for fleet visibility — judge · T4, review · T3, consult · T2. */
+export function gatePaneName(role, taskId, suffix = "") {
+    return `${role}${GATE_PANE_SEP}${taskId}${suffix}`;
+}
+// T8: gate prompts carry ## Task <id>: — derive the role-first pane name from the marker + header;
+// via.name remains the fallback for non-gate runViaDriver callers and carries -r1 retry suffixes.
+// T2 ownership contract: a canonical owned fallback (the daemon's nameFor now emits one) passes
+// through untouched; run-gates' "-r1" judge-retry suffix becomes attempt+1 so the retry pane's name
+// stays contract-parseable (drovr:judge:<task>:1:<runId>) instead of a corrupted-runId shape.
+export function rolePaneNameFromPrompt(prompt, fallback) {
+    const retry = fallback.endsWith("-r1");
+    const base = retry ? fallback.slice(0, -3) : fallback;
+    const owned = parseOwnedName(base);
+    if (owned)
+        return retry ? formatOwnedName({ ...owned, attempt: owned.attempt + 1 }) : base;
+    const id = prompt.match(/## Task ([^\n:]+):/)?.[1];
+    if (!id)
+        return fallback;
+    if (prompt.startsWith("DROVR-JUDGE"))
+        return gatePaneName("judge", id, retry ? "-r1" : "");
+    if (prompt.startsWith("DROVR-REVIEW"))
+        return gatePaneName("review", id, retry ? "-r1" : "");
+    return fallback;
+}
+export async function runHeadless(adapter, model, prompt, cwd, timeoutMs = 300000) {
+    const pf = join(mkdtempSync(join(tmpdir(), "drovr-llm-")), "prompt.md");
+    writeFileSync(pf, prompt);
+    const r = await sh(adapter.headlessCommand(pf, model), cwd, timeoutMs);
+    return r.stdout + "\n" + r.stderr;
+}
+// v1.1 default path: the same headless CLI call, but dispatched through the driver
+// as a visible named agent (herdr pane), with the quote-split completion wrapper.
+export async function runViaDriver(adapter, model, prompt, cwd, via, timeoutMs = 300000) {
+    const pf = join(mkdtempSync(join(tmpdir(), "drovr-llm-")), "prompt.md");
+    writeFileSync(pf, prompt);
+    const slot = await via.driver.slot(cwd, rolePaneNameFromPrompt(prompt, via.name), via.label ? { label: via.label } : undefined);
+    via.onSlot?.(slot);
+    await via.driver.run(slot, `${adapter.headlessCommand(pf, model)}; printf '\\nDROVR_''EXIT:%s\\n' $?`);
+    // wait for the digit-suffixed marker (a real $? exit code), never a bare "DROVR_EXIT:" that a
+    // self-referential diff under review merely DISPLAYS — same guard the worker path uses (daemon.ts:193).
+    // Without it, a judge/review pane echoing drovr's own source false-completes before its verdict lands.
+    await via.driver.waitOutput(slot, "DROVR_EXIT:\\d", timeoutMs, { regex: true });
+    const out = await via.driver.read(slot, 400);
+    if (!via.keep)
+        await via.driver.close(slot);
+    return out;
+}
+export function runLlm(adapter, model, prompt, cwd, via, timeoutMs = 300000) {
+    return via
+        ? runViaDriver(adapter, model, prompt, cwd, via, timeoutMs)
+        : runHeadless(adapter, model, prompt, cwd, timeoutMs);
+}
+export function extractJson(raw) {
+    const fenced = [...raw.matchAll(/```json\s*\n([\s\S]*?)```/g)].at(-1);
+    if (fenced) {
+        try {
+            const v = JSON.parse(fenced[1]);
+            if (v && typeof v === "object")
+                return v;
+        }
+        catch {
+            /* fall through to bare objects */
+        }
+    }
+    // Find the last balanced {...} object by scanning backwards from the last }
+    let pos = raw.length - 1;
+    while (pos >= 0) {
+        const end = raw.lastIndexOf("}", pos);
+        if (end === -1)
+            return null;
+        let depth = 1;
+        for (let i = end - 1; i >= 0; i--) {
+            if (raw[i] === "}")
+                depth++;
+            else if (raw[i] === "{") {
+                depth--;
+                if (depth === 0) {
+                    try {
+                        const v = JSON.parse(raw.slice(i, end + 1));
+                        if (v && typeof v === "object")
+                            return v;
+                    }
+                    catch {
+                        /* keep scanning */
+                    }
+                    pos = i - 1;
+                    break;
+                }
+            }
+        }
+        if (depth !== 0)
+            return null; // No matching brace found
+    }
+    return null;
+}

package/dist/gates/review.d.ts

@@ -0,0 +1,12 @@
+import { type Assignment, type BillingChannel, type WorkerAdapter } from "../adapters/types.js";
+import { type DrovrConfig } from "../config/config.js";
+import { type Task } from "../graph/schema.js";
+import { type GateVia } from "./llm.js";
+import type { GateResult } from "./types.js";
+export interface ReviewVerdict {
+    approve: boolean;
+    issues: string[];
+}
+export declare function modelId(model: string): string;
+export declare function pickReviewer(author: Assignment, channels: BillingChannel[], exclude?: string[]): BillingChannel | null;
+export declare function reviewGate(task: Task, worktree: string, baseRef: string, author: Assignment, channels: BillingChannel[], adapters: WorkerAdapter[], cfg: DrovrConfig, via?: GateVia, excludeReviewers?: string[]): Promise<GateResult>;

package/dist/gates/review.js

@@ -0,0 +1,80 @@
+import { channelKey } from "../adapters/types.js";
+import { TIER_RANK } from "../config/config.js";
+import { renderAcceptanceItem } from "../graph/schema.js";
+import { getAdapter } from "../adapters/registry.js";
+import { shOk } from "../run/git.js";
+import { marginalCostRank } from "../route/router.js";
+import { extractJson, runLlm } from "./llm.js";
+// FLEET-05: canonical model identity = the segment after the last "/". Provider-prefixed ids name ONE
+// base model behind two harnesses (zai-coding-plan/glm-5.2, zai/glm-5.2 → "glm-5.2"); vendor alone (mixed vs
+// zhipu) is not a diversity signal. Suffix-stripping over-excludes only if two genuinely different
+// models share a bare suffix — that errs fail-closed, acceptable per "gates never trust". Local to
+// review.ts (not a global identity concept).
+export function modelId(model) {
+    return model.slice(model.lastIndexOf("/") + 1);
+}
+export function pickReviewer(author, channels, exclude = []) {
+    // FLEET-05 success criterion 2: an author not resolvable in the channel list yields NO reviewer.
+    // The old `?? author.adapter` fallback compared an adapter id to vendor names, matched nothing, and
+    // admitted every reviewer — including the author's own channel (fail-OPEN). null lands on reviewGate's
+    // fail-closed branch under review.required.
+    const authorChannel = channels.find((c) => c.adapter === author.adapter && c.model === author.model);
+    if (!authorChannel)
+        return null;
+    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).
+        .filter((c) => c.vendor !== authorChannel.vendor && modelId(c.model) !== modelId(author.model) && !exclude.includes(channelKey(c)))
+        .sort((a, b) => TIER_RANK[b.tier] - TIER_RANK[a.tier] || marginalCostRank(a) - marginalCostRank(b))[0] ?? null);
+}
+const DIFF_CAP = 60_000;
+export async function reviewGate(task, worktree, baseRef, author, channels, adapters, cfg, via, excludeReviewers) {
+    if (task.complexity < cfg.review.complexityThreshold) {
+        return { gate: "review", pass: true, details: `skipped — complexity ${task.complexity} < threshold ${cfg.review.complexityThreshold}` };
+    }
+    const reviewer = pickReviewer(author, channels, excludeReviewers ?? []);
+    if (!reviewer) {
+        return cfg.review.required
+            ? { gate: "review", pass: false, details: "no cross-vendor reviewer available (diversity rule); set review.required:false to waive" }
+            : { gate: "review", pass: true, details: "WARNING: no cross-vendor reviewer available — review waived by config" };
+    }
+    const diff = (await shOk(`git diff '${baseRef}..HEAD'`, worktree)).slice(0, DIFF_CAP);
+    const prompt = `DROVR-REVIEW
+You are a skeptical cross-vendor code reviewer. Another agent (vendor: ${author.adapter}) authored this diff.
+Look for correctness bugs, security issues, and acceptance-criteria gaps. Approve only if you would merge it.
+
+## Task ${task.id}: ${task.title} (complexity ${task.complexity})
+## Acceptance criteria
+${task.acceptance.map((a) => `- ${renderAcceptanceItem(a)}`).join("\n")}
+
+## Diff
+\`\`\`diff
+${diff}
+\`\`\`
+
+Respond with ONLY this JSON:
+{"approve": true|false, "issues": ["..."]}
+`;
+    const raw = await runLlm(getAdapter(reviewer.adapter, adapters), reviewer.model, prompt, worktree, via ? { driver: via.driver, keep: via.keep, onSlot: via.onSlot, name: via.nameFor("review", reviewer.adapter), label: via.labelFor("review") } : undefined, 
+    // frontier reviewers routinely need >5min on a DIFF_CAP-sized diff, and `claude -p` buffers all
+    // output until completion — runLlm's 300s default killed reviews mid-flight, returning empty
+    // stdout that read as "unparseable" and escalated to re-implementation of green code
+    // (run-20260709-104447 P87-09). ponytail: literal 15min; make it cfg.review.timeoutMs if a
+    // second knob-turner appears.
+    900_000);
+    const v = extractJson(raw);
+    if (!v || typeof v.approve !== "boolean") {
+        return {
+            gate: "review",
+            pass: false,
+            details: `review output unparseable (reviewer ${reviewer.adapter}:${reviewer.model}) — failing closed`,
+            meta: { reviewer: channelKey(reviewer) },
+        };
+    }
+    return {
+        gate: "review",
+        pass: v.approve,
+        details: `reviewer ${reviewer.adapter}:${reviewer.model} (${reviewer.vendor}): ${v.approve ? "approved" : "requested changes"}${v.issues?.length ? "\n" + v.issues.map((i) => `- ${i}`).join("\n") : ""}`,
+        meta: { reviewer: channelKey(reviewer) },
+    };
+}

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

@@ -0,0 +1,34 @@
+import { type Assignment, type BillingChannel, type WorkerAdapter, type WorkerResult } from "../adapters/types.js";
+import { type DrovrConfig } 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 { GateResult } from "./types.js";
+export type GateEvent = {
+    phase: "start";
+    gate: GateName;
+    index: number;
+    total: number;
+} | {
+    phase: "end";
+    gate: GateName;
+    result: GateResult;
+};
+export interface GateContext {
+    worktree: string;
+    baseRef: string;
+    result: WorkerResult;
+    author: Assignment;
+    commands: Record<string, string>;
+    baseline: Baseline;
+    channels: BillingChannel[];
+    adapters: WorkerAdapter[];
+    cfg: DrovrConfig;
+    via?: GateVia;
+    excludeReviewers?: string[];
+    onGate?: (e: GateEvent) => void | Promise<void>;
+}
+export declare function runGates(task: Task, ctx: GateContext): Promise<{
+    results: GateResult[];
+    commits: string[];
+}>;