tickmarkr 2.4.2 → 2.5.1

package/dist/cli/commands/doctor.d.ts

@@ -96,5 +96,239 @@ export declare function selfShadowFinding(ownVersion: string, cwd?: string, reso
  * check) reads it and bumps the constant.
  */
 export declare function liveBenchStalenessFinding(now: Date): string | undefined;
+/**
+ * A no-call disclosure for the action that normal doctor performs.  This is deliberately built
+ * from config alone: opening the disclosure must not turn a cache reader into a model purchase.
+ */
+export declare function doctorProbePreflight(cwd?: string, cfg?: {
+    concurrency: number;
+    driver: "auto" | "herdr" | "subprocess" | "orca";
+    integrationBranchPrefix: string;
+    taskTimeoutMinutes: number;
+    contextWarnTokens: number;
+    routing: {
+        map: Record<string, {
+            pin?: {
+                via: string;
+                model: string;
+            } | undefined;
+            pool?: {
+                mode: "any" | "ordered";
+                channels: string[];
+            } | undefined;
+            tier?: undefined;
+            prefer?: string[] | undefined;
+            escalate?: boolean | undefined;
+        }>;
+        floors: Record<string, "cheap" | "mid" | "frontier">;
+        learned: "on" | "off";
+        allowUnverifiedModels: boolean;
+        mode?: "partner-led" | "risk-based" | "staff-led" | undefined;
+        learnedTuning?: {
+            halfLifeRuns?: number | undefined;
+            availWeight?: number | undefined;
+        } | undefined;
+        explore?: {
+            mode?: "on" | "off" | undefined;
+            excludeShapes?: string[] | undefined;
+            excludeComplexityAtOrAbove?: number | null | undefined;
+            cap?: number | undefined;
+        } | undefined;
+        sla?: Record<string, number> | undefined;
+        allow?: {
+            adapters?: string[] | undefined;
+            models?: string[] | undefined;
+        } | undefined;
+        deny?: {
+            adapters?: string[] | undefined;
+            models?: string[] | undefined;
+            workers?: {
+                adapters?: string[] | undefined;
+                models?: string[] | undefined;
+            } | undefined;
+        } | undefined;
+    };
+    tiers: Record<string, {
+        vendor: string | null;
+        channel: "sub" | "api";
+        models: Record<string, "cheap" | "mid" | "frontier">;
+        modelOverrides?: Record<string, {
+            vendor?: string | undefined;
+            channel?: "sub" | "api" | undefined;
+        }> | undefined;
+        windows?: Record<string, number> | undefined;
+    }>;
+    pricing: Record<string, number>;
+    gates: {
+        build?: string | undefined;
+        test?: string | undefined;
+        lint?: string | undefined;
+        diffCap?: number | undefined;
+        byShape?: Partial<Record<"plan" | "spec" | "implement" | "tests" | "docs" | "migration" | "ui" | "refactor" | "chore", {
+            [x: string]: unknown;
+            acceptance?: boolean | undefined;
+            review?: boolean | undefined;
+        }>> | undefined;
+    };
+    judge: {
+        adapter: string;
+        model: string;
+    };
+    review: {
+        complexityThreshold: number;
+        timeoutMs: number;
+        required: boolean;
+        prefer?: string[] | undefined;
+        policy?: "full" | "judge-only" | undefined;
+        criticalPaths?: string[] | undefined;
+    };
+    consult: {
+        adapter: string;
+        model: string;
+        stallMinutes: number;
+        prefer?: string[] | undefined;
+    };
+    visibility: {
+        llm: "pane" | "headless";
+        keepPanes: "run" | "attempt" | "forever";
+        worker: "interactive" | "print";
+        workersPerTab: number;
+    };
+    setup?: string | undefined;
+    cost?: {
+        models?: Record<string, {
+            inPerMtok: number;
+            outPerMtok: number;
+            cacheReadPerMtok?: number | undefined;
+            rateDate?: string | undefined;
+        }> | undefined;
+        subs?: Record<string, {
+            planMonthly: number;
+            windowsPerMonthLow: number;
+            windowsPerMonthHigh: number;
+        }> | undefined;
+    } | undefined;
+    scope?: {
+        allowDeviations?: string[] | undefined;
+    } | undefined;
+}, adapters?: WorkerAdapter[]): string;
+/**
+ * Health surfaces use this cache-only reader.  It intentionally receives adapters only to render
+ * their configured identities; it never invokes adapter.probe(), listModels(), or a model command.
+ */
+export declare function cachedDoctorDiagnostics(cwd?: string, adapters?: WorkerAdapter[], cfg?: {
+    concurrency: number;
+    driver: "auto" | "herdr" | "subprocess" | "orca";
+    integrationBranchPrefix: string;
+    taskTimeoutMinutes: number;
+    contextWarnTokens: number;
+    routing: {
+        map: Record<string, {
+            pin?: {
+                via: string;
+                model: string;
+            } | undefined;
+            pool?: {
+                mode: "any" | "ordered";
+                channels: string[];
+            } | undefined;
+            tier?: undefined;
+            prefer?: string[] | undefined;
+            escalate?: boolean | undefined;
+        }>;
+        floors: Record<string, "cheap" | "mid" | "frontier">;
+        learned: "on" | "off";
+        allowUnverifiedModels: boolean;
+        mode?: "partner-led" | "risk-based" | "staff-led" | undefined;
+        learnedTuning?: {
+            halfLifeRuns?: number | undefined;
+            availWeight?: number | undefined;
+        } | undefined;
+        explore?: {
+            mode?: "on" | "off" | undefined;
+            excludeShapes?: string[] | undefined;
+            excludeComplexityAtOrAbove?: number | null | undefined;
+            cap?: number | undefined;
+        } | undefined;
+        sla?: Record<string, number> | undefined;
+        allow?: {
+            adapters?: string[] | undefined;
+            models?: string[] | undefined;
+        } | undefined;
+        deny?: {
+            adapters?: string[] | undefined;
+            models?: string[] | undefined;
+            workers?: {
+                adapters?: string[] | undefined;
+                models?: string[] | undefined;
+            } | undefined;
+        } | undefined;
+    };
+    tiers: Record<string, {
+        vendor: string | null;
+        channel: "sub" | "api";
+        models: Record<string, "cheap" | "mid" | "frontier">;
+        modelOverrides?: Record<string, {
+            vendor?: string | undefined;
+            channel?: "sub" | "api" | undefined;
+        }> | undefined;
+        windows?: Record<string, number> | undefined;
+    }>;
+    pricing: Record<string, number>;
+    gates: {
+        build?: string | undefined;
+        test?: string | undefined;
+        lint?: string | undefined;
+        diffCap?: number | undefined;
+        byShape?: Partial<Record<"plan" | "spec" | "implement" | "tests" | "docs" | "migration" | "ui" | "refactor" | "chore", {
+            [x: string]: unknown;
+            acceptance?: boolean | undefined;
+            review?: boolean | undefined;
+        }>> | undefined;
+    };
+    judge: {
+        adapter: string;
+        model: string;
+    };
+    review: {
+        complexityThreshold: number;
+        timeoutMs: number;
+        required: boolean;
+        prefer?: string[] | undefined;
+        policy?: "full" | "judge-only" | undefined;
+        criticalPaths?: string[] | undefined;
+    };
+    consult: {
+        adapter: string;
+        model: string;
+        stallMinutes: number;
+        prefer?: string[] | undefined;
+    };
+    visibility: {
+        llm: "pane" | "headless";
+        keepPanes: "run" | "attempt" | "forever";
+        worker: "interactive" | "print";
+        workersPerTab: number;
+    };
+    setup?: string | undefined;
+    cost?: {
+        models?: Record<string, {
+            inPerMtok: number;
+            outPerMtok: number;
+            cacheReadPerMtok?: number | undefined;
+            rateDate?: string | undefined;
+        }> | undefined;
+        subs?: Record<string, {
+            planMonthly: number;
+            windowsPerMonthLow: number;
+            windowsPerMonthHigh: number;
+        }> | undefined;
+    } | undefined;
+    scope?: {
+        allowDeviations?: string[] | undefined;
+    } | undefined;
+}): string;
+/** Repair is an actuator, but never a reason to run the paid diagnostic sensor. */
+export declare function doctorFixOnly(cwd?: string): string;
 export declare function doctor(_argv: string[], cwd?: string, adapters?: WorkerAdapter[], opts?: DoctorOpts): Promise<string>;
 export {};

package/dist/cli/commands/doctor.js

@@ -4,7 +4,7 @@ import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { detectPackageManager, turboContinueFindings } from "../../gates/baseline.js";
 import { version } from "./version.js";
-import { allAdapters, binaryShadowWarnings, detectCandidateClis, flagDriftWarnings, modelAliasExclusions, modelAliasLine, probeAll, probeModels, resolveShellBinary, servableExclusions, servabilityLine, writeDoctor } from "../../adapters/registry.js";
+import { allAdapters, binaryShadowWarnings, detectCandidateClis, doctorAgeMs, flagDriftWarnings, modelAliasExclusions, modelAliasLine, probeAll, probeModels, readDoctor, resolveShellBinary, servableExclusions, servabilityLine, writeDoctor } from "../../adapters/registry.js";
 import { CLAUDE_ALIAS_IDENTITY_STAMPS, claudeCode, resolveClaudeAliasIdentity } from "../../adapters/claude-code.js";
 import { shq } from "../../adapters/types.js";
 import { BANNER, compactTokens, dim, fail, kvRow, legend, ok, rule, statusRow, title } from "../../brand.js";
@@ -347,8 +347,142 @@ export function liveBenchStalenessFinding(now) {
         return undefined;
     return `LiveBench table pinned at ${LIVEBENCH_TABLE_DATE} is ${days} days old (>${LIVEBENCH_TABLE_MAX_AGE_DAYS}d) — list ${LIVEBENCH_RELEASES_URL} for a newer table_<date>.csv and bump LIVEBENCH_TABLE_DATE (advisory — tickmarkr never fetches that listing)`;
 }
+function configuredModels(cfg, adapters) {
+    const allowed = adapters ? new Set(adapters.map((adapter) => adapter.id)) : undefined;
+    return Object.entries(cfg.tiers).flatMap(([adapter, tier]) => allowed && !allowed.has(adapter) ? [] :
+        Object.keys(tier.models ?? {}).map((model) => ({ adapter, model })));
+}
+function cacheAge(ageMs) {
+    return ageMs === null ? "unavailable" : `${Math.floor(ageMs / 60_000)}m`;
+}
+/**
+ * A no-call disclosure for the action that normal doctor performs.  This is deliberately built
+ * from config alone: opening the disclosure must not turn a cache reader into a model purchase.
+ */
+export function doctorProbePreflight(cwd = process.cwd(), cfg = loadConfig(cwd), adapters = allAdapters()) {
+    const models = configuredModels(cfg, adapters);
+    const scope = models.length
+        ? models.map(({ adapter, model }) => `${adapter}:${model}`).join(", ")
+        : "none (no configured models)";
+    const state = stateDirName(cwd);
+    return [
+        "tickmarkr doctor — probe preflight:",
+        `configured model-call scope: ${models.length} model${models.length === 1 ? "" : "s"} — ${scope}`,
+        `cache policy: explicit probing replaces ${state}/doctor.json; each installed configured model receives one bounded call, with a serial retry only after a first failure (a prior timeout skips that retry)`,
+        `affected destinations: ${state}/doctor.json (adapter and model verdict cache); temporary probe prompts are removed`,
+        "catalog-only alternative: tickmarkr doctor --refresh-catalog refreshes the catalog cache without adapter or model probes",
+    ].join("\n");
+}
+/**
+ * Health surfaces use this cache-only reader.  It intentionally receives adapters only to render
+ * their configured identities; it never invokes adapter.probe(), listModels(), or a model command.
+ */
+export function cachedDoctorDiagnostics(cwd = process.cwd(), adapters = allAdapters(), cfg = loadConfig(cwd)) {
+    const health = readDoctor(cwd);
+    const age = doctorAgeMs(cwd);
+    const configured = configuredModels(cfg, adapters);
+    const state = stateDirName(cwd);
+    const knownAdapters = new Set(adapters.map((adapter) => adapter.id));
+    const rows = configured.map(({ adapter, model }) => {
+        const cachedAdapter = health?.[adapter];
+        const cachedModel = cachedAdapter?.modelAuth?.[model];
+        const status = !health
+            ? "unknown (cache unavailable)"
+            : !knownAdapters.has(adapter)
+                ? "unknown (adapter unavailable to this reader)"
+                : !cachedAdapter
+                    ? "unknown (adapter absent from cache)"
+                    : !cachedAdapter.installed
+                        ? "unavailable (adapter not installed)"
+                        : !cachedAdapter.authed
+                            ? "unavailable (adapter not authenticated)"
+                            : !cachedModel
+                                ? "unknown (never probed)"
+                                : cachedModel.authed
+                                    ? `passed (cached ${cachedModel.probedAt})`
+                                    : `failed (cached ${cachedModel.reason ?? "probe failed"})`;
+        return `  ${adapter}:${model} ${status}`;
+    });
+    return [
+        "tickmarkr doctor — cached diagnostics:",
+        `cache source: ${health ? `${state}/doctor.json` : "unavailable"}`,
+        `cache age: ${cacheAge(age)}`,
+        "cache policy: read-only; adapter and model probes were not called",
+        ...(rows.length ? ["configured model status:", ...rows] : ["configured model status: none (no configured models)"]),
+    ].join("\n");
+}
+const RUNNER_CONFIG_PATHS = [
+    "jest.config.js",
+    "jest.config.cjs",
+    "jest.config.mjs",
+    "jest.config.ts",
+    "jest.config.json",
+    "vitest.config.ts",
+    "vitest.config.js",
+    "vitest.config.mts",
+    "vitest.config.mjs",
+    "vitest.config.cts",
+];
+function runnerConfigSnapshot(cwd) {
+    return new Map(RUNNER_CONFIG_PATHS.flatMap((path) => {
+        const absolute = join(cwd, path);
+        return existsSync(absolute) ? [[path, readFileSync(absolute, "utf8")]] : [];
+    }));
+}
+function actualTextDiff(path, before, after) {
+    const oldLines = before.split("\n");
+    const newLines = after.split("\n");
+    let start = 0;
+    while (start < oldLines.length && start < newLines.length && oldLines[start] === newLines[start])
+        start += 1;
+    let oldEnd = oldLines.length;
+    let newEnd = newLines.length;
+    while (oldEnd > start && newEnd > start && oldLines[oldEnd - 1] === newLines[newEnd - 1]) {
+        oldEnd -= 1;
+        newEnd -= 1;
+    }
+    return [
+        `--- ${path} (before)`,
+        `+++ ${path} (after)`,
+        ...oldLines.slice(start, oldEnd).map((line) => `-${line}`),
+        ...newLines.slice(start, newEnd).map((line) => `+${line}`),
+    ].join("\n");
+}
+/** Repair is an actuator, but never a reason to run the paid diagnostic sensor. */
+export function doctorFixOnly(cwd = process.cwd()) {
+    const before = runnerConfigSnapshot(cwd);
+    const finding = runnerIgnoreFinding(cwd);
+    const repair = finding?.verdict === "warn"
+        ? applyRunnerIgnore(cwd)
+        : { action: "none", detail: finding?.detail ?? "no recognized test runner" };
+    const verified = runnerIgnoreFinding(cwd);
+    const diffs = [...before].flatMap(([path, original]) => {
+        const current = readFileSync(join(cwd, path), "utf8");
+        return current === original ? [] : [actualTextDiff(path, original, current)];
+    });
+    const result = repair.action === "wrote" && verified?.verdict !== "pass"
+        ? "invalid repair result (verification did not pass)"
+        : `${repair.action} — ${repair.detail}`;
+    return [
+        "tickmarkr doctor --fix-only — repair-only:",
+        "model probes: skipped (repair-only; adapters were not called)",
+        "catalog: untouched",
+        `repair result: ${result}`,
+        `repair verification: ${verified?.verdict ?? "unavailable"}`,
+        "repair diff:",
+        ...(diffs.length ? diffs : ["(no runner-config bytes changed)"]),
+    ].join("\n");
+}
 export async function doctor(_argv, cwd = process.cwd(), adapters = allAdapters(), opts = {}) {
-    if (_argv.length === 1 && _argv[0] === "--refresh-catalog") {
+    if (_argv.includes("--fix-only"))
+        return doctorFixOnly(cwd);
+    if (_argv.includes("--cached") || _argv.includes("--cached-only")) {
+        return cachedDoctorDiagnostics(cwd, adapters);
+    }
+    if (_argv.includes("--probe-preflight") || _argv.includes("--preflight")) {
+        return doctorProbePreflight(cwd, loadConfig(cwd), adapters);
+    }
+    if (_argv.length === 1 && (_argv[0] === "--refresh-catalog" || _argv[0] === "--catalog-only")) {
         const refreshed = await refreshCatalogCommand({ repoRoot: cwd, fetcher: opts.catalogFetcher, now: opts.catalogNow });
         return refreshed.updated
             ? `tickmarkr doctor --refresh-catalog: model catalog refreshed — ${formatCatalogRefreshLegs(refreshed.legs)}${refreshed.warning ? `; ${refreshed.warning}` : ""}`
@@ -378,9 +512,9 @@ export async function doctor(_argv, cwd = process.cwd(), adapters = allAdapters(
     // banner at START — the logo greets the operator before the ~60s probe wait, never trailing it (operator report 2026-07-17)
     if (opts.banner !== false && visual())
         process.stdout.write(BANNER);
-    // stderr, live: auth probes are real LLM calls (up to 30s per configured model) and the CLI
-    // otherwise prints nothing until the end — silence here reads as a hang (v1.33.1)
-    console.error("probing installed agent CLIs — one short LLM call per configured model, may take a minute...");
+    // stderr, live: disclose the paid boundary before the first adapter/model call. The separate
+    // --probe-preflight route exposes these same bytes without crossing that boundary.
+    console.error(`${doctorProbePreflight(cwd, cfg, adapters)}\nprobing installed agent CLIs — one short LLM call per configured model, may take a minute...`);
     const probeProgressTTY = process.stderr.isTTY === true;
     const health = await probeAll(adapters, { cwd });
     const kimiAdapter = adapters.find((a) => a.id === kimi.id);

package/dist/cli/commands/init.d.ts

@@ -1,3 +1,5 @@
+export type DetectedHost = "herdr" | "orca" | "subprocess";
+export declare function detectedHost(env?: NodeJS.ProcessEnv): DetectedHost;
 /** Test seam mirroring FleetIO: production callers omit it and get the process streams. */
 export type InitIO = {
     input?: NodeJS.ReadStream;

package/dist/cli/commands/init.js

@@ -4,6 +4,7 @@ import { join, relative } from "node:path";
 import { fileURLToPath } from "node:url";
 import { createInterface } from "node:readline/promises";
 import { parseArgs } from "node:util";
+import { parse as parseYaml } from "yaml";
 import { allAdapters, formatDoctorAgeForInit, formatDoctorReport, initDoctorReuse } from "../../adapters/registry.js";
 import { configTemplate, DEFAULT_CONFIG, globalConfigDir, loadConfig } from "../../config/config.js";
 import { LEGACY_PREFIX, specTemplate } from "../../compile/native.js";
@@ -218,7 +219,14 @@ const describeDrift = (d) => [
 // should not be asked again just because a copy drifted. Staleness is a different question with a
 // different answer (`--agent --force`), and it is reported by name on every init path below.
 const skillsInstalled = (cwd) => hostTargets(cwd).every((t) => AGENT_SKILLS.every((s) => existsSync(join(t.skillsDir, s, "SKILL.md"))));
-const wizardDriverDefault = () => process.env.HERDR_ENV === "1" ? "herdr" : orcaHostDetected() ? "orca" : "auto";
+export function detectedHost(env = process.env) {
+    if (env.HERDR_ENV === "1")
+        return "herdr";
+    if (orcaHostDetected(env))
+        return "orca";
+    return "subprocess";
+}
+const wizardDriverDefault = () => "auto";
 function packageName(cwd) {
     try {
         const parsed = JSON.parse(readFileSync(join(cwd, "package.json"), "utf8"));
@@ -323,6 +331,7 @@ async function runInitWizard(cwd, input, output) {
             visibilityLlm: DEFAULT_CONFIG.visibility.llm,
             offerSkills: !skillsInstalled(cwd),
             skillsDefault: existsSync(join(cwd, ".claude", "skills")) && !skillsInstalled(cwd),
+            detectedHost: detectedHost(),
         },
         input,
         output,
@@ -368,8 +377,37 @@ export async function init(argv, cwd = process.cwd(), io = {}) {
     }
     const repoConfigPath = join(tickmarkrDir(cwd), "config.yaml");
     const repoConfigExists = existsSync(repoConfigPath);
-    if (repoConfigExists)
-        notes.push(`kept existing ${repoConfigPath}`);
+    if (repoConfigExists) {
+        if (values.force) {
+            const currentRaw = readFileSync(repoConfigPath, "utf8");
+            let parsedDriver;
+            try {
+                const parsed = parseYaml(currentRaw);
+                if (typeof parsed?.driver === "string")
+                    parsedDriver = parsed.driver;
+            }
+            catch {
+                // malformed: fall back to regex
+            }
+            if (!parsedDriver) {
+                const m = currentRaw.match(/^\s*driver:\s*([^\s#]+)/m);
+                if (m)
+                    parsedDriver = m[1];
+            }
+            const host = detectedHost();
+            if (parsedDriver && parsedDriver === host) {
+                const rewritten = currentRaw.replace(new RegExp(`^(\\s*driver:\\s*)${parsedDriver}\\b.*$`, "m"), `$1auto            # auto — resolves to ${host} here`);
+                writeFileSync(repoConfigPath, rewritten);
+                notes.push(`rewrote driver: ${parsedDriver} to auto in ${repoConfigPath}`);
+            }
+            else {
+                notes.push(`kept existing ${repoConfigPath}`);
+            }
+        }
+        else {
+            notes.push(`kept existing ${repoConfigPath}`);
+        }
+    }
     const specPath = join(cwd, SCAFFOLD_SPEC);
     if (existsSync(specPath)) {
         notes.push(`kept existing ${specPath}`);
@@ -417,7 +455,9 @@ export async function init(argv, cwd = process.cwd(), io = {}) {
                 // so costs one clause; everything else stops here. Esc and ctrl+c both land here.
                 return `init: wizard quit — nothing further run (scaffolding kept: ${notes.filter((n) => n.startsWith("wrote")).length} file(s) written above). Re-run tickmarkr init to continue.`;
             }
-            writeFileSync(repoConfigPath, configTemplate(wizard.overlay));
+            const host = detectedHost();
+            const renderedConfig = configTemplate(wizard.overlay).replace(/^driver: auto$/m, `driver: auto            # auto — resolves to ${host} here`);
+            writeFileSync(repoConfigPath, renderedConfig);
             notes.push(`wrote ${repoConfigPath}`);
             if (wizard.installSkills) {
                 await installAgentFiles(cwd, values.force ?? false, wizard.installDocs || (values.docs ?? false), notes);
@@ -462,7 +502,7 @@ export async function init(argv, cwd = process.cwd(), io = {}) {
     const next = nextSteps(cwd, SCAFFOLD_SPEC);
     if (!visual())
         return `${notes.join("\n")}\n${doc}\n${next}\n${ENVIRONMENTS_FOOTER}`;
-    const noteRows = notes.map((note) => `  ${statusRow(/^(?:wrote|overwrote|appended)/.test(note) ? "pass" : note.startsWith("skipped") ? "warn" : "neutral", note)}`);
+    const noteRows = notes.map((note) => `  ${statusRow(/^(?:wrote|overwrote|appended|rewrote)/.test(note) ? "pass" : note.startsWith("skipped") ? "warn" : "neutral", note)}`);
     const footerRows = ENVIRONMENTS_FOOTER.split("\n").slice(1).map((line) => {
         const separator = line.indexOf(" — ");
         return kvRow(line.slice(2, separator), line.slice(separator + 1), 12);

package/dist/cli/commands/plan.js

@@ -1,4 +1,4 @@
-import { existsSync } from "node:fs";
+import { existsSync, readdirSync } from "node:fs";
 import { join } from "node:path";
 import { parseArgs } from "node:util";
 import { allAdapters, doctorAgeMs, modelAuthExclusions, probeAll, readDoctor, rolePools, servableExclusions, servabilityLine } from "../../adapters/registry.js";
@@ -7,7 +7,7 @@ import { GLYPHS, dim, rule, title, warn } from "../../brand.js";
 import { collateralLints, sourceScopeLints } from "../../compile/collateral.js";
 import { classifyContextPath } from "../../compile/native.js";
 import { DEFAULT_CONFIG, effectiveReviewPolicy, overlayPreferShapes, ROUTING_MODES, TIER_RANK } from "../../config/config.js";
-import { loadGraph } from "../../graph/graph.js";
+import { graphDefinitionHash, loadGraph, stateDirName } from "../../graph/graph.js";
 import { renderAcceptanceItem } from "../../graph/schema.js";
 import { resolveRunMode } from "../../run/daemon.js";
 import { disallowedBy, excludedChannels, exclusionLine, routingEntrySeatLines } from "../../route/preference.js";
@@ -15,7 +15,7 @@ import { staffLedEvidence } from "../../route/profile.js";
 import { route, RoutingError } from "../../route/router.js";
 import { auditNamedTestOracles, listVitestTests } from "../../gates/acceptance.js";
 import { modelId, modelProvider, pickReviewer } from "../../gates/review.js";
-import { Journal, loadRoutingProfile } from "../../run/journal.js";
+import { Journal, loadRoutingProfile, recordedGraphDefinitionHash } from "../../run/journal.js";
 import { harnessLine, resolveHarness } from "../harness.js";
 import { channelKey, shq } from "../../adapters/types.js";
 import { shGit } from "../../run/git.js";
@@ -40,7 +40,10 @@ const stylizePlan = (out) => {
 const fleetCanCrossVendorReview = (channels) => {
     for (let i = 0; i < channels.length; i++)
         for (let j = 0; j < channels.length; j++)
-            if (i !== j && channels[i].vendor !== channels[j].vendor && modelId(channels[i].model) !== modelId(channels[j].model))
+            if (i !== j
+                && channels[i].vendor !== channels[j].vendor
+                && modelProvider(channels[i].model, channels[i].vendor) !== modelProvider(channels[j].model, channels[j].vendor)
+                && modelId(channels[i].model) !== modelId(channels[j].model))
                 return true;
     return false;
 };
@@ -121,6 +124,43 @@ export async function plan(argv, cwd = process.cwd(), adapters = allAdapters(),
         throw new Error(`--mode must be one of ${ROUTING_MODES.join(" | ")} (got ${values.mode})`);
     }
     const g = loadGraph(cwd);
+    const gHash = graphDefinitionHash(g);
+    const runsRoot = join(cwd, stateDirName(cwd), "runs");
+    let matchingEvents;
+    let matchingRunId;
+    if (existsSync(runsRoot)) {
+        const locked = runLockRunId(cwd);
+        const candidates = readdirSync(runsRoot)
+            .filter((d) => d.startsWith("run-") && existsSync(join(runsRoot, d, "journal.jsonl")))
+            .sort();
+        const ordered = locked && candidates.includes(locked)
+            ? [locked, ...candidates.filter((id) => id !== locked).reverse()]
+            : candidates.reverse();
+        for (const runId of ordered) {
+            try {
+                const events = Journal.open(cwd, runId).read();
+                if (recordedGraphDefinitionHash(events) === gHash) {
+                    matchingEvents = events;
+                    matchingRunId = runId;
+                    break;
+                }
+            }
+            catch {
+                // ignore unreadable or torn journals
+            }
+        }
+    }
+    const hasRun = matchingEvents !== undefined;
+    const reviewHistory = matchingEvents
+        ? matchingEvents
+            .filter((event) => event.event === "gate-result" && event.data.gate === "review" && typeof event.data.reviewer === "string")
+            .map((event) => event.data.reviewer)
+        : [];
+    // OBS-947 repair: a resumed run re-dispatches only tasks whose replayed status is pending (or that the
+    // journal never mentions). done, failed and human are all skipped alike, so rendering their preview
+    // picks must not advance the shared reviewHistory — a phantom draw wraps the LRU and makes a later
+    // pending task print the ranked-first seat while the journal's actual next draw is a later channel.
+    const taskStatuses = matchingRunId ? Journal.open(cwd, matchingRunId).replayStatuses() : new Map();
     const oracleRefusals = new Map();
     const oracleAdvisories = new Map();
     if (g.tasks.some((task) => task.acceptance.some((item) => typeof item === "object" && item.oracle === "test"))) {
@@ -306,10 +346,22 @@ export async function plan(argv, cwd = process.cwd(), adapters = allAdapters(),
         const policy = effectiveReviewPolicy(task.files, cfg.review);
         if (policy === "judge-only")
             return { line: "none — reviewPolicy judge-only: declared leaf paths", cost: 0 };
-        const reviewer = pickReviewer(author, pools.review, [], cfg.review.prefer ?? [], task.routingHints?.floor);
+        let rotationSeat = 1;
+        let rotationCount = 0;
+        const reviewer = pickReviewer(author, pools.review, [], cfg.review.prefer ?? [], task.routingHints?.floor, reviewHistory, (seat, count) => { rotationSeat = seat; rotationCount = count; });
         if (!reviewer)
             return { line: "none — no cross-vendor reviewer available", cost: 0 };
-        return { line: `${channelKey(reviewer)} — reviewPolicy full`, cost: seatCost(reviewer) };
+        // Advance the simulated rotation only for tasks the run would actually dispatch next — the same
+        // rule as readyTasks (src/graph/graph.ts): pending, with every dependency already done. A pending
+        // task behind a parked/failed/pending dependency cannot run, so it consumes no draw (RULING-229-14).
+        const isPending = (id) => { const s = taskStatuses.get(id); return s === undefined || s === "pending"; };
+        const ready = isPending(task.id) && task.deps.every((d) => taskStatuses.get(d) === "done");
+        if (hasRun && ready)
+            reviewHistory.push(channelKey(reviewer));
+        const rotationNote = rotationCount > 1
+            ? (hasRun ? ` (seat ${rotationSeat} of ${rotationCount})` : ` (seat 1 of ${rotationCount} — rotation applies at run time)`)
+            : "";
+        return { line: `${channelKey(reviewer)}${rotationNote} — reviewPolicy full`, cost: seatCost(reviewer) };
     };
     const routed = [];
     for (const t of g.tasks) {