tickmarkr 2.3.0 → 2.4.0

package/dist/drivers/types.d.ts

@@ -66,9 +66,17 @@ export declare function panesToClose(agents: FleetAgent[], desired: Set<string>,
     tabId?: string;
 }[];
 export declare function canonicalizeLegacyName(name: string, runId: string): OwnedName;
+export interface SlotPlacement {
+    surface?: string;
+    hostPlatform?: string;
+}
 export interface ExecutorDriver {
     id: string;
     interactive: boolean;
+    /** The exact terminal read surface used for liveness evidence. */
+    readSource?: string;
+    /** Placement facts returned by drivers whose terminal host exposes them. */
+    describe?(slot: Slot): SlotPlacement | Promise<SlotPlacement>;
     slot(cwd: string, name: string, opts?: SlotOpts): Promise<Slot>;
     run(slot: Slot, cmd: string): Promise<void>;
     waitOutput(slot: Slot, pattern: string, timeoutMs: number, opts?: {
@@ -84,5 +92,7 @@ export interface ExecutorDriver {
     narrateWith?(narrate: (event: JournalEvent) => void): void;
     worktree(repo: string, branch: string, baseRef: string): Promise<string>;
     narrator?: (cwd: string, command: string, runId?: string) => Promise<Slot>;
+    /** Best-effort projection of a task's lifecycle onto the execution host. */
+    project?: (taskId: string, state: "in-progress" | "in-review" | "completed") => Promise<void>;
     reconcile?: (desired: Set<string>, runId: string, opts?: PanesToCloseOpts) => Promise<void>;
 }

package/dist/gates/baseline.js

@@ -5,10 +5,19 @@ import { DEFAULT_SHELL_TIMEOUT_MS, describeCapacity, sameCapacity, sh } from "..
 // 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;
+// OBS-891 (run 3372): vitest toggles the cursor (`\x1b[?25l` / `\x1b[?25h`) around its progress
+// output, and the private-mode parameter byte `?` never matched [\d;#], so an echo-block HEADER glued
+// to a cursor-show sequence stayed invisible to withoutVitestEchoBlocks and its whole block leaked as
+// runner evidence — seven prose-only "infra" parks in one night. Full CSI grammar: parameter bytes
+// 0x30–0x3F (plus `#` for digit-normalized stored baselines), intermediates 0x20–0x2F, final 0x40–0x7E.
+const ANSI_RE = /\x1b\[[0-?#]*[ -/]*[@-~]/g;
 // ponytail: only leading ✓/✔ after optional "label:" prefixes (turbo/vitest), or tickmarkr's own run
 // summary, counts as a pass line — other runners' pass markers (PASS, ok) stay fingerprintable
 const PASS_LINE_RE = /^\s*(?:(?:[\w@./-]+:\s*)*[✓✔]|(?:\[tickmarkr\]\s+)?(?:tickmarkr\s+[\w.-]+:\s+)?(?:\d+|#)\s+done,\s+(?:\d+|#)\s+failed(?:,\s+(?:\d+|#)\s+awaiting human)?\b)/;
+// OBS-888: tickmarkr's own operator lines (`tickmarkr: baseline capture for "test" … spawn EAGAIN`)
+// are printed by this product, never by a runner about the work. When this repository's tests exercise
+// the capture path they print them too, carrying errno tokens INFRA_RE would read as host evidence.
+const OPERATOR_LINE_RE = /^\s*tickmarkr: /;
 // 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.
@@ -149,7 +158,10 @@ const isFingerprintShaped = (l) => isFailureShaped(l) || INFRA_RE.test(l);
  * unreadable-runner case the existing fail-closed path already owns.
  */
 export function classifyFailureOutput(output) {
-    const lines = output.split("\n").map((l) => l.replace(ANSI_RE, "")).filter((l) => !PASS_LINE_RE.test(l));
+    // OBS-891: the gate reads the WHOLE output here when the fresh-fingerprint diff is empty, so an errno
+    // token inside a test's echoed stdout/stderr block must be as invisible to this classifier as it is
+    // to fingerprint(): test-owned output is never runner evidence about the work.
+    const lines = withoutVitestEchoBlocks(output).map((l) => l.replace(ANSI_RE, "")).filter((l) => !PASS_LINE_RE.test(l) && !OPERATOR_LINE_RE.test(l));
     if (lines.some(namesRegression))
         return "regression";
     return lines.some(isInfraLine) ? "infra" : undefined;
@@ -161,7 +173,11 @@ 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 VITEST_ECHO_BLOCK_RE = /^\s*std(?:out|err)\s+\|\s+\S+\.(?:test|spec)\.[cm]?[jt]sx?\s+>\s+\S/;
+// OBS-888 row 1: vitest 3.2.7 heads an echo block `std{out,err} | <file> > <test>` when the log is
+// attributed to a test, `stderr | unknown test` when it is not, `stderr | <file>` for file-level output
+// and `stderr | <task id>` (digits and underscores) when the reporter no longer knows the task
+// (dist/chunks/index.*.js, `headerText`). The stripper knew only the first form.
+const VITEST_ECHO_BLOCK_RE = /^\s*std(?:out|err)\s+\|\s+(?:unknown test\s*$|\d+_[\d_]+\s*$|\S+\.(?:test|spec)\.[cm]?[jt]sx?(?:\s*$|\s+>\s+\S))/;
 /** Keep runner output while omitting Vitest's echoed test-owned stdout/stderr diagnostic blocks. */
 const withoutVitestEchoBlocks = (output) => {
     const outside = [];
@@ -186,7 +202,7 @@ 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))
+        if (!PASS_LINE_RE.test(clean) && !OPERATOR_LINE_RE.test(clean) && CAPTURE_EXHAUSTION_RE.test(clean))
             invalidating.push(line);
     }
     return invalidating;
@@ -230,16 +246,18 @@ export const UNRECOGNIZED_FAILURE = "<unrecognized failure output>";
 export function fingerprint(output) {
     const lines = withoutVitestEchoBlocks(output)
         .map((l) => l.replace(ANSI_RE, ""))
-        .filter((l) => !PASS_LINE_RE.test(l));
+        .filter((l) => !PASS_LINE_RE.test(l) && !OPERATOR_LINE_RE.test(l));
     // GATE-FIX-4 DEFECT 4: every line is read twice — as printed, and with a turbo `<pkg>:<task>:`
     // prefix removed. A recognized stripped line fingerprints as its STRIPPED text, so the same
     // failure fingerprints identically whether turbo prefixed it or a bare runner printed it; the
     // prefixed form keeps fingerprinting too (baseline-recorded package-level reds stay forgivable).
     const shaped = [];
     for (const l of lines) {
+        const stripped = stripTurboPrefix(l);
+        if (stripped !== undefined && OPERATOR_LINE_RE.test(stripped))
+            continue; // OBS-888: operator prose under a turbo prefix
         if (isFingerprintShaped(l))
             shaped.push(l);
-        const stripped = stripTurboPrefix(l);
         if (stripped !== undefined && !PASS_LINE_RE.test(stripped) && isFingerprintShaped(stripped))
             shaped.push(stripped);
     }
@@ -576,7 +594,8 @@ export async function compareToBaseline(cwd, commands, baseline, enabled) {
         // result rather than re-derived after the fact. The skip row above ran no command and therefore
         // states no capacity — a row that never divided the machine must not claim that it did.
         const record = (g) => {
-            results.push(r.capacity ? { ...g, capacity: r.capacity } : g);
+            const withReap = r.reapedGroup ? { ...g, meta: { ...g.meta, reapedGroup: true } } : g;
+            results.push(r.capacity ? { ...withReap, capacity: r.capacity } : withReap);
         };
         // …and whether the entry that would forgive this command was measured in the same world. A
         // baseline captured under a different fork cap forgives nothing: its fingerprints describe a

package/dist/gates/review.d.ts

@@ -52,7 +52,9 @@ export declare function modelId(model: string): string;
 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;
+floor?: Tier, // task-declared only; config floors govern workers and must not silently move review seats
+history?: string[], // run-scoped picks, oldest to newest; empty preserves the established ranking
+onSeat?: (seat: number) => void): BillingChannel | null;
 export type ReviewUnparseableCause = VerdictUnparseableCause;
 /**
  * This shows the reviewer what the task DECLARED, never what the diff may actually reach. The diff
@@ -60,4 +62,4 @@ export type ReviewUnparseableCause = VerdictUnparseableCause;
  * judgement rather than a guarantee made by this renderer.
  */
 export declare function renderDeclaredWriteScope(files: ReadonlyArray<string>): string;
-export declare function reviewGate(task: Task, worktree: string, baseRef: string, author: Assignment, channels: BillingChannel[], adapters: WorkerAdapter[], cfg: TickmarkrConfig, via?: GateVia, excludeReviewers?: string[], artifactDir?: string): Promise<GateResult>;
+export declare function reviewGate(task: Task, worktree: string, baseRef: string, author: Assignment, channels: BillingChannel[], adapters: WorkerAdapter[], cfg: TickmarkrConfig, via?: GateVia, excludeReviewers?: string[], artifactDir?: string, reviewHistory?: string[]): Promise<GateResult>;

package/dist/gates/review.js

@@ -192,7 +192,9 @@ function reviewPreferIndex(c, prefer) {
 }
 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) {
+floor, // task-declared only; config floors govern workers and must not silently move review seats
+history = [], // run-scoped picks, oldest to newest; empty preserves the established ranking
+onSeat) {
     // 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
@@ -200,18 +202,23 @@ 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
+    const ranked = 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.
+        // rule, never replacing it — a future edit can't silently drop either). Failover additionally guards
+        // true provider identity; the initial pick keeps the established stamped-vendor contract. The diversity
+        // filter runs BEFORE preference ranking, so prefer cannot 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]))
-        .sort((a, b) => reviewPreferIndex(a, prefer) - reviewPreferIndex(b, prefer) || TIER_RANK[b.tier] - TIER_RANK[a.tier] || marginalCostRank(a) - marginalCostRank(b))[0] ?? null);
+        .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) => history.lastIndexOf(channelKey(a)) - history.lastIndexOf(channelKey(b))
+        || ranked.indexOf(a) - ranked.indexOf(b))[0] ?? null;
+    if (reviewer)
+        onSeat?.(ranked.indexOf(reviewer) + 1);
+    return reviewer;
 }
 /**
  * This shows the reviewer what the task DECLARED, never what the diff may actually reach. The diff
@@ -229,7 +236,7 @@ ${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) {
+artifactDir, reviewHistory) {
     // 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
@@ -301,7 +308,8 @@ artifactDir) {
     // 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;
-    const reviewer = pickReviewer(author, channels, excludeReviewers ?? [], cfg.review.prefer ?? [], reviewerFloor);
+    let rotationSeat;
+    const reviewer = pickReviewer(author, channels, excludeReviewers ?? [], cfg.review.prefer ?? [], reviewerFloor, reviewHistory, reviewHistory ? (seat) => { rotationSeat = seat; } : undefined);
     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.
@@ -312,6 +320,8 @@ artifactDir) {
             ? { 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 } : {}) } };
     }
+    reviewHistory?.push(channelKey(reviewer));
+    const rotationMeta = rotationSeat === undefined ? {} : { rotationSeat };
     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.
@@ -362,9 +372,8 @@ The top-level comments array is optional. Use it only for actionable line-anchor
     // frontier reviewers routinely need >5min on a configured-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);
+    // (run-20260709-104447 P87-09). The configured ceiling defaults to that measured 15 minutes.
+    cfg.review.timeoutMs);
     const raw = llm.output;
     const provider = modelProvider(reviewer.model, reviewer.vendor);
     const v = extractVerdictJson(raw, nonce);
@@ -393,15 +402,17 @@ 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}; vendor: ${reviewer.vendor}; provider: ${provider}; cause: ${cause}${saved ? `; raw saved: ${saved}` : ""}) — failing closed`,
+            details: `${failure} (reviewer ${reviewer.adapter}:${reviewer.model}; vendor: ${reviewer.vendor}; provider: ${provider}; cause: ${cause}${cause === "timeout" ? `; killed at configured review timeout ${cfg.review.timeoutMs}ms` : ""}${saved ? `; raw saved: ${saved}` : ""}) — failing closed`,
             meta: {
                 ...policyMeta,
+                ...rotationMeta,
                 reviewer: channelKey(reviewer),
                 vendor: reviewer.vendor,
                 provider,
                 unparseable: true,
                 cause,
                 ...(cause === "empty-output" ? { bytes } : {}),
+                ...(cause === "timeout" ? { timeoutMs: cfg.review.timeoutMs } : {}),
                 ...(concludedOnInactivity ? { classification: "infra", infra: true } : {}),
             },
         };
@@ -414,6 +425,6 @@ The top-level comments array is optional. Use it only for actionable line-anchor
         gate: "review",
         pass: decided.pass,
         details: appendAnchoredReview(prose, v),
-        meta: { ...policyMeta, reviewer: channelKey(reviewer), vendor: reviewer.vendor, provider },
+        meta: { ...policyMeta, ...rotationMeta, reviewer: channelKey(reviewer), vendor: reviewer.vendor, provider },
     };
 }

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

@@ -13,13 +13,15 @@ export declare function resetLoadProviderForTests(): void;
  * intervals and nothing between them, so the composite `test` gate (a selected screen, then other
  * gates, then the full suite) reports the two suites' cost rather than the span containing them —
  * and no consumer has to re-derive a duration by subtracting journal timestamps, which measures the
- * queue as well as the work. The load samples bracket the FIRST interval's start and the LAST
- * interval's end: start is what a scheduler would have decided on, end is the state it left behind.
+ * queue as well as the work. Load is sampled at each interval's endpoints and every second within it;
+ * start preserves the scheduling input while max and mean retain sustained interior saturation.
  */
 export interface GateTelemetry {
     durationMs: number;
     load1Start: number;
     load1End: number;
+    load1Max: number;
+    load1Mean: number;
 }
 export type GateEvent = {
     phase: "start";
@@ -51,6 +53,7 @@ export interface GateContext {
     cfg: TickmarkrConfig;
     via?: GateVia;
     excludeReviewers?: string[];
+    reviewHistory?: string[];
     artifactDir?: string;
     pipeline?: "v185" | "legacy";
     selectTests?: boolean;

package/dist/gates/run-gates.js

@@ -208,24 +208,42 @@ export async function runGates(task, ctx) {
     // executing is added HERE, at the call site that runs it, so a gate that runs twice (the test
     // gate's screen and its full suite) sums to its own cost and never to the span between them.
     const spans = new Map();
+    const loadSamples = new Map();
     // The test gate's two halves, kept apart as well as summed: `durationMs` alone cannot say whether
     // a slow round was a slow subset or a slow full suite, and the parked scheduler's threshold is
     // defined over the full-suite cost.
     let selectedDurationMs;
     let fullDurationMs;
-    const measure = async (gate, run) => {
+    const startMeasurement = () => {
         const at = Date.now();
-        const load1Start = loadProvider();
+        const samples = [loadProvider()];
+        const timer = setInterval(() => samples.push(loadProvider()), 1_000);
+        timer.unref();
+        return () => {
+            clearInterval(timer);
+            samples.push(loadProvider());
+            return { durationMs: Date.now() - at, samples };
+        };
+    };
+    const addMeasurement = (gate, measured) => {
+        const prior = spans.get(gate);
+        const samples = [...(loadSamples.get(gate) ?? []), ...measured.samples];
+        loadSamples.set(gate, samples);
+        spans.set(gate, {
+            durationMs: (prior?.durationMs ?? 0) + measured.durationMs,
+            load1Start: samples[0],
+            load1End: samples[samples.length - 1],
+            load1Max: Math.max(...samples),
+            load1Mean: samples.reduce((sum, value) => sum + value, 0) / samples.length,
+        });
+    };
+    const measure = async (gate, run) => {
+        const finish = startMeasurement();
         try {
             return await run();
         }
         finally {
-            const prior = spans.get(gate);
-            spans.set(gate, {
-                durationMs: (prior?.durationMs ?? 0) + (Date.now() - at),
-                load1Start: prior?.load1Start ?? load1Start,
-                load1End: loadProvider(),
-            });
+            addMeasurement(gate, finish());
         }
     };
     // The measurement is attached at the ONE seam every result leaves this function through, so a
@@ -347,12 +365,11 @@ export async function runGates(task, ctx) {
             // suppresses them anyway; split compareToBaseline only if a tool gate ever gets slow.
             // ponytail: legacy runs adjacent tools in ONE compareToBaseline call, so there is one interval
             // to measure and each of its gates carries it. Split it only if this branch ever stops batching.
-            const batchAt = Date.now();
-            const batchLoadStart = loadProvider();
+            const finish = startMeasurement();
             const toolResults = await compareToBaseline(ctx.worktree, commands, ctx.baseline, [...gates]);
-            const batch = { durationMs: Date.now() - batchAt, load1Start: batchLoadStart, load1End: loadProvider() };
+            const batch = finish();
             for (const g of gates)
-                spans.set(g, batch);
+                addMeasurement(g, batch);
             // The same refusal AFTER the commands, because a green command can dirty the tree the check
             // above just proved clean. Batched, legacy cannot say WHICH command did it, so the refusal
             // lands on the last gate that had one — the round dies there either way. A red battery is
@@ -575,7 +592,7 @@ export async function runGates(task, ctx) {
             invocations.push(...captured.invocations);
             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));
+        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));
         // 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.
@@ -598,7 +615,7 @@ export async function runGates(task, ctx) {
             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));
+            const second = await dispatch((adapters) => reviewGate(task, ctx.worktree, ctx.baseRef, ctx.author, ctx.channels, adapters, ctx.cfg, retryVia, retryExclusions, ctx.artifactDir, ctx.reviewHistory));
             if (second.meta?.noEligibleReviewer !== true) {
                 const retried = typeof second.meta?.reviewer === "string" ? second.meta.reviewer : "none";
                 const route = exclusion === "adapter"
@@ -630,11 +647,11 @@ export async function runGates(task, ctx) {
     // The check runs BEFORE any gate, so on a clean tree it belongs to no gate: charging every round's
     // first gate for it would inflate the one measurement the parked recalibrations key on. It becomes
     // that gate's interval only on the path where it IS what the gate did — the refusal below.
-    const entryAt = Date.now();
-    const entryLoad = loadProvider();
+    const finishEntry = startMeasurement();
     const entryDirt = sequence.length ? await dirtyWorktree() : undefined;
+    const entryMeasurement = finishEntry();
     if (entryDirt) {
-        spans.set(sequence[0], { durationMs: Date.now() - entryAt, load1Start: entryLoad, load1End: loadProvider() });
+        addMeasurement(sequence[0], entryMeasurement);
         await emitStart(sequence[0]);
         await record(dirtyRefusal(sequence[0], entryDirt));
         return done();

package/dist/route/preference.d.ts

@@ -5,6 +5,10 @@ export interface Disallowed {
     entry: string;
 }
 export type PreferenceRole = "worker" | "judge" | "review" | "consult";
+export declare function routingModelProvider(model: string, fallback?: string): string;
+export declare const modelRouteIdentity: (model: string, fallback?: string) => string;
+export declare const channelRouteIdentity: (key: string, fallback?: string) => string;
+export declare function routingEntrySeatLines(cfg: TickmarkrConfig): string[];
 export declare function excludedChannels(cfg: TickmarkrConfig, adapters: {
     id: string;
 }[] | string[], health: Record<string, AuthHealth>): {

package/dist/route/preference.js

@@ -1,6 +1,46 @@
 import { channelKey, channelsFromConfig } from "../adapters/types.js";
 import { validateGraph } from "../graph/schema.js";
 import { route, RoutingError } from "./router.js";
+const PREFERENCE_ROLES = ["worker", "judge", "review", "consult"];
+// Keep routing retries on the same identity review diversity uses: the served provider plus the
+// unprefixed model id. Gate review owns the original modelProvider policy; this dependency-leaf copy
+// avoids importing gates back into route/run and must move with that helper when the scope permits.
+export function routingModelProvider(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;
+}
+export const modelRouteIdentity = (model, fallback = "unknown") => `${routingModelProvider(model, fallback)}/${model.slice(model.lastIndexOf("/") + 1).toLowerCase()}`;
+export const channelRouteIdentity = (key, fallback = "unknown") => {
+    const i = key.indexOf(":");
+    return i < 0 ? key : modelRouteIdentity(key.slice(i + 1), fallback);
+};
+export function routingEntrySeatLines(cfg) {
+    const lines = [];
+    const add = (path, entries, roles) => {
+        for (const entry of entries ?? [])
+            lines.push(`${path} '${entry}' reaches seats: ${roles.join(", ")}`);
+    };
+    add("routing.allow.adapters", cfg.routing.allow?.adapters, PREFERENCE_ROLES);
+    add("routing.allow.models", cfg.routing.allow?.models, PREFERENCE_ROLES);
+    add("routing.deny.adapters", cfg.routing.deny?.adapters, PREFERENCE_ROLES);
+    add("routing.deny.models", cfg.routing.deny?.models, PREFERENCE_ROLES);
+    add("routing.deny.workers.adapters", cfg.routing.deny?.workers?.adapters, ["worker"]);
+    add("routing.deny.workers.models", cfg.routing.deny?.workers?.models, ["worker"]);
+    return lines;
+}
 const adapterIds = (adapters) => typeof adapters[0] === "string" ? adapters : adapters.map((a) => a.id);
 export function excludedChannels(cfg, adapters, health) {
     const { allow, deny } = cfg.routing;

package/dist/route/router.js

@@ -1,6 +1,6 @@
 import { channelKey, channelsFromConfig } from "../adapters/types.js";
 import { TIER_RANK } from "../config/config.js";
-import { disallowedBy } from "./preference.js";
+import { channelRouteIdentity, disallowedBy, modelRouteIdentity, routingModelProvider } from "./preference.js";
 import { cellOf, EXPLORE_CAP, explorationBonus, learnedScore, MIN_SAMPLES } from "./profile.js";
 export const NO_EXPLORE_ENV = "TICKMARKR_NO_EXPLORE";
 // OBS-89 (v1.60): the TICKMARKR_QUALITY variable is RETIRED — nothing in src reads it anymore and
@@ -337,7 +337,20 @@ export function nextChannel(current, task, cfg, channels, tried, profile, exclud
     // profile-dependent filter. NO exploration bonus here (route():110 has one; a probe on the
     // failure path would spend a real retry). Absent profile ⇒ every score is 0 ⇒ third key
     // all-ties ⇒ the stable sort preserves the exact v1.7 candidate ORDER.
-    const pool = channels.filter((c) => !tried.includes(channelKey(c)) && TIER_RANK[c.tier] >= TIER_RANK[current.tier]);
+    const triedKeys = new Set(tried);
+    const triedIdentities = new Set(tried.map((key) => {
+        const channel = channels.find((c) => channelKey(c) === key);
+        return channel ? modelRouteIdentity(channel.model, channel.vendor) : channelRouteIdentity(key);
+    }));
+    // excludeAdapter is expanded by the daemon into every channel key of the failed adapter. Once that
+    // complete set is present, the outage follows the current served provider across gateway aliases.
+    const currentAdapterExcluded = channels.some((c) => c.adapter === current.adapter)
+        && channels.filter((c) => c.adapter === current.adapter).every((c) => triedKeys.has(channelKey(c)));
+    const currentChannel = channels.find((c) => c.adapter === current.adapter && c.model === current.model);
+    const excludedProvider = currentAdapterExcluded ? routingModelProvider(current.model, currentChannel?.vendor) : undefined;
+    const pool = channels.filter((c) => !triedIdentities.has(modelRouteIdentity(c.model, c.vendor))
+        && (!excludedProvider || routingModelProvider(c.model, c.vendor) !== excludedProvider)
+        && TIER_RANK[c.tier] >= TIER_RANK[current.tier]);
     const scores = new Map(pool.map((c) => [channelKey(c), profile ? learnedScore(profile, task.shape, channelKey(c), c.channel, { availWeight: cfg.routing.learnedTuning?.availWeight }) : 0]));
     const scoreOf = (c) => scores.get(channelKey(c));
     const candidates = pool.sort((a, b) => TIER_RANK[a.tier] - TIER_RANK[b.tier] || marginalCostRank(a) - marginalCostRank(b) || scoreOf(b) - scoreOf(a));

package/dist/run/consult.d.ts

@@ -9,6 +9,7 @@ export interface ConsultVerdict {
     reason?: string;
     guidance?: string;
     excludeAdapter?: string;
+    excludeProvider?: string;
     adapter?: string;
     model?: string;
     vendor?: string;

package/dist/run/consult.js

@@ -4,7 +4,7 @@ import { getAdapter } from "../adapters/registry.js";
 import { bannerShell, paneDispatchCommand } from "../brand.js";
 import { dewrapPaneVerdict, extractVerdictJson, gateExitTrailer, gatePaneName, generateVerdictNonce, verdictNonceLine } from "../gates/llm.js";
 import { classifyVerdictCause } from "../gates/verdict-cause.js";
-import { disallowedBy } from "../route/preference.js";
+import { disallowedBy, routingModelProvider } from "../route/preference.js";
 import { sh } from "./git.js";
 import { redactSecrets } from "./redact.js";
 import { filterLlmTranscript } from "./stall.js";
@@ -59,6 +59,22 @@ export function augmentRetryBrief(feedback, opts) {
     return parts.join("\n\n");
 }
 const ACTIONS = ["retry", "reroute", "decompose", "human"];
+function excludedProviderFromDossier(d, adapter) {
+    try {
+        const events = JSON.parse(d.journalTail);
+        const assignment = [...events].reverse().find((event) => event.event === "task-dispatch"
+            && event.data?.assignment?.adapter === adapter
+            && typeof event.data.assignment.model === "string")?.data?.assignment;
+        if (typeof assignment?.model !== "string")
+            return undefined;
+        const provider = routingModelProvider(assignment.model);
+        return provider === "unknown" ? undefined : provider;
+    }
+    catch {
+        // Legacy/non-JSON dossier tails retain the adapter exclusion without inventing a provider.
+        return undefined;
+    }
+}
 export function parseConsultVerdict(out, nonce) {
     const v = extractVerdictJson(out, nonce);
     if (!v)
@@ -110,10 +126,10 @@ ${d.journalTail}
 Verdict meanings: retry = same assignment with your notes as feedback; reroute = different CLI/model;
 decompose = task too big, needs human re-planning; human = a person must look at this.
 
-On reroute only, optional excludeAdapter is an adapter id (e.g. "cursor-agent") that bans EVERY
-channel of that adapter for this task. Use it for environmental failures ("the CLI is blocked",
-trust dialog, broken install) — not when a single model produced bad code. Omit for model-level
-reroutes so other models of the same adapter remain eligible.
+On reroute only, optional excludeAdapter is the failed adapter id (e.g. "cursor-agent"). Tickmarkr
+resolves the adapter's current model to its provider and bans that provider for this task. Use it for
+environmental/provider failures ("the CLI is blocked", trust dialog, broken install) — not when a
+single model produced bad code. Omit for model-level reroutes so other models remain eligible.
 
 ${verdictNonceLine(nonce)}
 
@@ -230,8 +246,19 @@ opts = {}) {
     for (const [i, seat] of allowedSeats.entries()) {
         try {
             const parsed = await invokeSeat(seat.adapter, seat.model, i);
-            if (parsed.verdict)
-                return { ...parsed.verdict, ...seatIdentity(seat) };
+            if (parsed.verdict) {
+                const excludeProvider = parsed.verdict.excludeAdapter
+                    ? excludedProviderFromDossier(d, parsed.verdict.excludeAdapter)
+                    : undefined;
+                return {
+                    ...parsed.verdict,
+                    ...(excludeProvider ? {
+                        excludeProvider,
+                        notes: `${parsed.verdict.notes} — excluded provider ${excludeProvider}`,
+                    } : {}),
+                    ...seatIdentity(seat),
+                };
+            }
         }
         catch {
             // failed seat (unknown adapter, dead driver/pane, shell error) — fall to the next entry

package/dist/run/daemon.d.ts

@@ -68,6 +68,7 @@ export declare function formatSummary(s: RunSummary): string;
  *  run id (cli/commands/status.ts positionalRunId), so naming it here is what stops the board from
  *  following the newest journal in a repo that already carries a second, newer run — a board showing
  *  the wrong run is a recorded incident (skills/tickmarkr-overseer/SKILL.md). */
+export declare const daemonEntrypoint: string;
 export declare const watchCommand: (runId: string) => string;
 /**
  * R3 (OBS-186): a gate that DECLINED to run is not a gate that failed. The review gate's skip branch
@@ -103,6 +104,9 @@ export declare const gateSatisfied: (g: GateResult) => boolean;
  */
 export declare function decisiveReviewRounds(events: JournalEvent[]): JournalEvent[];
 export declare const SUITE_POLL_MS = 250;
+export declare const SUITE_WAIT_CEILING_MS = 600000;
+export declare const setSuiteWaitCeilingForTests: (ms: number) => void;
+export declare const resetSuiteWaitCeilingForTests: () => void;
 export declare const APPROVAL_POLL_MS = 250;
 export declare const EARLY_LAUNCH_LIVENESS_MS = 60000;
 /** Test seam — lowers the empty-pane liveness window without sleeping 60s per case. */