tickmarkr 1.90.5 → 1.90.7

package/dist/cli/commands/doctor.js

@@ -2,7 +2,7 @@ import { writeFileSync } from "node:fs";
 import { spawnSync } from "node:child_process";
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
-import { detectPackageManager } from "../../gates/baseline.js";
+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 { CLAUDE_ALIAS_IDENTITY_STAMPS, claudeCode, resolveClaudeAliasIdentity } from "../../adapters/claude-code.js";
@@ -212,6 +212,8 @@ export async function doctor(_argv, cwd = process.cwd(), adapters = allAdapters(
             ? `tickmarkr doctor --refresh-catalog: model catalog refreshed${refreshed.warning ? `; ${refreshed.warning}` : ""}`
             : `tickmarkr doctor --refresh-catalog: catalog refresh unavailable — ${refreshed.warning ?? "unknown failure"}; retained ${refreshed.catalog.source} catalog`;
     }
+    // Operator directive 2026-08-12 (declutter): long per-model lists render only when asked for.
+    const listAllModels = _argv.includes("--models");
     const cfg = loadConfig(cwd);
     // T17: synchronous/cache-only by operator ruling. The only network-bearing catalog function is the
     // separately invoked refreshCatalogCommand; ordinary doctor never calls it.
@@ -300,6 +302,11 @@ export async function doctor(_argv, cwd = process.cwd(), adapters = allAdapters(
     const pmRow = packageManagerFinding(cwd);
     if (pmRow)
         rows.push(alignedStatusRow(pmRow.verdict, "package-manager", pmRow.detail));
+    // GATE-FIX-4 §3 (dossier, 2026-08-13): an early-abort runner leaves later packages unverified
+    // yet baseline-forgiven — surface it BEFORE a run pays for it.
+    for (const f of turboContinueFindings(cwd, cfg)) {
+        rows.push(alignedStatusRow("warn", `gates.${f.gate}`, f.detail));
+    }
     // Q142s: tickmarkr's own binary gets the shadow check every adapter binary already had.
     const shadowRow = selfShadowFinding(await version(), cwd);
     if (shadowRow)
@@ -436,9 +443,24 @@ export async function doctor(_argv, cwd = process.cwd(), adapters = allAdapters(
             // Keep the historical count as an index, but it is no longer the whole report: every model gets
             // a cache-backed evidence or explicit uncovered line. Neither branch changes cfg, health, or route().
             rows.push(`    ${dim(`(${unclassified.length} more listed, unclassified)`)}`);
-            for (const model of unclassified) {
-                const advisory = catalogModelAdvisory(cfg, catalog, a.id, model, resolvedCatalogModel(a.id, model));
+            const advisories = unclassified.map((model) => catalogModelAdvisory(cfg, catalog, a.id, model, resolvedCatalogModel(a.id, model)));
+            // Q128s exhibit #4 / operator directive 2026-08-12: ~600 per-model advisory rows buried the six
+            // decision-grade flags on a real machine. Default view keeps ONLY rows that ask the operator for a
+            // decision (tier suggestions); the no-decision bulk (uncovered + covered evidence-only) compresses
+            // to one counted line per adapter. `doctor --models` restores every row — asked-for, not ambient.
+            const decisive = advisories.filter((adv) => adv.suggestion);
+            const bulk = advisories.filter((adv) => !adv.suggestion);
+            const shown = listAllModels ? advisories : decisive;
+            for (const advisory of shown)
                 rows.push(`    ${dim(`catalog · ${advisory.display}`)}`);
+            if (!listAllModels && bulk.length) {
+                const uncovered = bulk.filter((adv) => adv.coverage === "uncovered").length;
+                const evidenceOnly = bulk.length - uncovered;
+                const parts = [
+                    ...(uncovered ? [`${uncovered} uncovered by ${catalog.source === "cache" ? "cached catalogs" : "vendored catalog"}`] : []),
+                    ...(evidenceOnly ? [`${evidenceOnly} covered without a tier suggestion`] : []),
+                ];
+                rows.push(`    ${dim(`catalog · ${parts.join(" · ")} — tickmarkr doctor --models lists each`)}`);
             }
         }
         return rows;

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

@@ -1,4 +1,6 @@
 import type { WorkerAdapter } from "../../adapters/types.js";
+import type { FleetEditorResult } from "../../tui/ink/fleet-app.js";
+type FleetEditorProps = Parameters<typeof import("../../tui/ink/fleet-app.js").runFleetInkEditor>[0];
 export type FleetInput = NodeJS.ReadableStream & {
     isTTY?: boolean;
     setRawMode?: (mode: boolean) => unknown;
@@ -26,3 +28,19 @@ export declare function fleet(argv: string[], cwd?: string, adapters?: WorkerAda
     out: string;
     code: number;
 }>;
+/** Everything between the doctor-reuse gate and the Ink render, packaged for reuse: `tickmarkr init`
+ * runs the same editor (preset-first) without re-owning the assembly or the write funnel. `commit`
+ * remains the single config actuator — it maps editor results to the command's exact result strings
+ * and performs the one guarded overlay write. */
+export declare function assembleFleetEditor(cwd: string, adapters: WorkerAdapter[], io: FleetIO, opts: {
+    globalDir: string;
+    entry?: "presets" | "probe";
+    fresh?: boolean;
+}): Promise<{
+    props: FleetEditorProps;
+    commit: (result: FleetEditorResult) => string;
+    renderWhy: () => string;
+} | {
+    unavailable: string;
+}>;
+export {};

package/dist/cli/commands/fleet.js

@@ -104,12 +104,57 @@ export async function fleet(argv, cwd = process.cwd(), adapters = allAdapters(),
     }
     if (!why && !interactive)
         return { out: NON_TTY_MSG, code: 1 };
-    const fresh = values.fresh ?? false;
-    const { reuse, health: cached } = initDoctorReuse(cwd, fresh);
+    const assembled = await assembleFleetEditor(cwd, adapters, io, {
+        globalDir,
+        fresh: values.fresh ?? false,
+    });
+    if ("unavailable" in assembled)
+        return { out: assembled.unavailable, code: 1 };
+    if (why)
+        return assembled.renderWhy();
+    // Keep Ink out of print, non-TTY, and missing-probe paths: the component runtime belongs
+    // exclusively to the interactive editor. The capture window brackets only the dynamic Ink
+    // import — keys typed while the module loads land in props.initialInput, never get dropped.
+    const initialInput = [];
+    const productionInput = input;
+    const captureStartupInput = typeof productionInput.ref === "function"
+        && typeof productionInput.unref === "function";
+    const onStartupInput = (chunk) => {
+        initialInput.push(typeof chunk === "string" ? chunk : chunk.toString("utf8"));
+    };
+    if (captureStartupInput) {
+        input.on("data", onStartupInput);
+        input.resume();
+    }
+    let runFleetInkEditor;
+    try {
+        ({ runFleetInkEditor } = await import("../../tui/ink/fleet-app.js"));
+    }
+    catch (error) {
+        if (captureStartupInput) {
+            input.off("data", onStartupInput);
+            input.pause();
+        }
+        throw error;
+    }
+    if (captureStartupInput) {
+        input.off("data", onStartupInput);
+        input.pause();
+    }
+    assembled.props.initialInput = initialInput;
+    const result = await runFleetInkEditor(assembled.props);
+    return assembled.commit(result);
+}
+/** Everything between the doctor-reuse gate and the Ink render, packaged for reuse: `tickmarkr init`
+ * runs the same editor (preset-first) without re-owning the assembly or the write funnel. `commit`
+ * remains the single config actuator — it maps editor results to the command's exact result strings
+ * and performs the one guarded overlay write. */
+export async function assembleFleetEditor(cwd, adapters, io, opts) {
+    const globalDir = opts.globalDir;
+    const { reuse, health: cached } = initDoctorReuse(cwd, opts.fresh ?? false);
     if (!reuse || !cached) {
         return {
-            out: "tickmarkr fleet: probe data missing or stale — run `tickmarkr doctor` first (fleet never re-probes; doctor is the sensor)",
-            code: 1,
+            unavailable: "tickmarkr fleet: probe data missing or stale — run `tickmarkr doctor` first (fleet never re-probes; doctor is the sensor)",
         };
     }
     const rm = resolveRunMode(cwd, { globalDir });
@@ -231,8 +276,6 @@ export async function fleet(argv, cwd = process.cwd(), adapters = allAdapters(),
         return projectFleetWhy(values, { repoRoot: cwd, globalDir });
     };
     const routedShapeRows = (mode, map) => projectedShapeRows(mode, map).map(({ id, label }) => ({ id, label }));
-    if (why)
-        return renderFleetWhy(projectedShapeRows(rm.mode.mode, editable.map));
     const candidatesForShape = (shape, mode, map) => shapeCandidates(previewTask(shape), previewCfg(mode, map), channels, profile).map((candidate) => ({
         id: `${candidate.assignment.adapter}:${candidate.assignment.model}`,
         label: candidateRow(candidate, cfg.pricing),
@@ -255,6 +298,9 @@ export async function fleet(argv, cwd = process.cwd(), adapters = allAdapters(),
         const discovered = which === "review" ? [...reviewAdapters, ...seats] : seats;
         return [...discovered, ...current.filter((entry) => !discovered.includes(entry))];
     };
+    // The judge is one seat by schema (config.judge: { adapter, model }); the editor offers the same
+    // discovered seats universe plus a keep-default row, and a write is staged only on a real change.
+    const initialJudge = `${cfg.judge.adapter}:${cfg.judge.model}`;
     let pendingWrite = null;
     const reviewOverlay = (state) => {
         const staged = structuredClone(initial);
@@ -275,7 +321,10 @@ export async function fleet(argv, cwd = process.cwd(), adapters = allAdapters(),
         const path = repoOverlayPath(cwd);
         const modeChanged = state.selectedMode !== rm.mode.mode;
         const steeringChanged = ["review", "consult"].some((key) => JSON.stringify(state.steering[key]) !== JSON.stringify(initialSteering[key]));
-        if (!modeChanged && !steeringChanged && fleetEditableEquals(initial, staged)) {
+        const judgeSeat = state.judgeSeat;
+        const judgeChanged = judgeSeat !== undefined
+            && `${judgeSeat.adapter}:${judgeSeat.model}` !== initialJudge;
+        if (!modeChanged && !steeringChanged && !judgeChanged && fleetEditableEquals(initial, staged)) {
             pendingWrite = null;
             return { kind: "empty" };
         }
@@ -283,6 +332,7 @@ export async function fleet(argv, cwd = process.cwd(), adapters = allAdapters(),
             initial,
             edited: staged,
             ...(modeChanged ? { mode: state.selectedMode } : {}),
+            ...(judgeChanged && judgeSeat ? { judge: judgeSeat } : {}),
             steering: { initial: initialSteering, edited: state.steering },
         };
         const after = renderFleetOverlayWrite(before, write);
@@ -301,35 +351,7 @@ export async function fleet(argv, cwd = process.cwd(), adapters = allAdapters(),
     };
     const reloadGuard = io.reloadGuard
         ?? ((bytes) => overlayBytesLoadError(cwd, bytes, { globalDir }));
-    // Keep Ink out of print, non-TTY, and missing-probe paths: the component runtime belongs
-    // exclusively to the interactive editor.
-    const initialInput = [];
-    const productionInput = input;
-    const captureStartupInput = typeof productionInput.ref === "function"
-        && typeof productionInput.unref === "function";
-    const onStartupInput = (chunk) => {
-        initialInput.push(typeof chunk === "string" ? chunk : chunk.toString("utf8"));
-    };
-    if (captureStartupInput) {
-        input.on("data", onStartupInput);
-        input.resume();
-    }
-    let runFleetInkEditor;
-    try {
-        ({ runFleetInkEditor } = await import("../../tui/ink/fleet-app.js"));
-    }
-    catch (error) {
-        if (captureStartupInput) {
-            input.off("data", onStartupInput);
-            input.pause();
-        }
-        throw error;
-    }
-    if (captureStartupInput) {
-        input.off("data", onStartupInput);
-        input.pause();
-    }
-    const result = await runFleetInkEditor({
+    const props = {
         ageMs: doctorAgeMs(cwd),
         adapters,
         health,
@@ -350,25 +372,35 @@ export async function fleet(argv, cwd = process.cwd(), adapters = allAdapters(),
         steeringOptionsFor,
         reviewOverlay,
         reloadGuard,
-        initialInput,
-        input: input,
-        output: output,
+        entry: opts.entry,
+        initialJudge,
+        judgeSeats: seats,
+        initialInput: [],
+        input: (io.input ?? process.stdin),
+        output: (io.output ?? process.stdout),
         debug: io.debug,
-    });
-    if (result.kind === "quit")
-        return QUIT;
-    if (result.kind === "refresh") {
-        return "fleet: run `tickmarkr doctor` to refresh probe data, then re-run `tickmarkr fleet` (doctor is the sensor; fleet never re-probes)";
-    }
-    if (result.kind === "no-changes")
-        return "fleet: no overlay changes (empty diff)";
-    if (result.kind === "discard")
-        return "fleet: discarded overlay changes";
-    // The command remains the single config actuator. Every interactive edit reaches this
-    // one write only after the component-rendered diff confirm and the production reload guard.
-    const write = pendingWrite;
-    if (!write)
-        throw new Error("fleet write reached confirmation without a staged overlay mutation");
-    writeFleetOverlay(result.review.path, (prior) => renderFleetOverlayWrite(prior, write));
-    return `fleet: wrote ${result.review.path}`;
+    };
+    const commit = (result) => {
+        if (result.kind === "quit")
+            return QUIT;
+        if (result.kind === "refresh") {
+            return "fleet: run `tickmarkr doctor` to refresh probe data, then re-run `tickmarkr fleet` (doctor is the sensor; fleet never re-probes)";
+        }
+        if (result.kind === "no-changes")
+            return "fleet: no overlay changes (empty diff)";
+        if (result.kind === "discard")
+            return "fleet: discarded overlay changes";
+        // The command remains the single config actuator. Every interactive edit reaches this
+        // one write only after the component-rendered diff confirm and the production reload guard.
+        const write = pendingWrite;
+        if (!write)
+            throw new Error("fleet write reached confirmation without a staged overlay mutation");
+        writeFleetOverlay(result.review.path, (prior) => renderFleetOverlayWrite(prior, write));
+        return `fleet: wrote ${result.review.path}`;
+    };
+    return {
+        props,
+        commit,
+        renderWhy: () => renderFleetWhy(projectedShapeRows(rm.mode.mode, editable.map)),
+    };
 }

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

@@ -1 +1,6 @@
-export declare function init(argv: string[], cwd?: string): Promise<string>;
+/** Test seam mirroring FleetIO: production callers omit it and get the process streams. */
+export type InitIO = {
+    input?: NodeJS.ReadStream;
+    output?: NodeJS.WriteStream;
+};
+export declare function init(argv: string[], cwd?: string, io?: InitIO): Promise<string>;

package/dist/cli/commands/init.js

@@ -10,6 +10,7 @@ import { BANNER, kvRow, legend, rule, statusRow, title } from "../../brand.js";
 import { tickmarkrDir } from "../../graph/graph.js";
 import { Journal } from "../../run/journal.js";
 import { doctor } from "./doctor.js";
+import { assembleFleetEditor } from "./fleet.js";
 const SCAFFOLD_SPEC = "tickmarkr.spec.md";
 // Operator-approved (2026-07-17) environments footer — three rows; no npm install for herdr
 // (npm package "herdr" is a reserved 0.0.0 placeholder as of that date).
@@ -214,6 +215,11 @@ async function installAgentFiles(cwd, force, docs, notes) {
     const confirm = async (question) => {
         if (!interactive)
             return false;
+        // Post-wizard hardening: an Ink act that ran earlier in this process leaves stdin paused and
+        // unref'd on unmount, and readline revives neither — the process exits mid-question (found by
+        // the consolidated-init smoke). Revive explicitly before asking.
+        process.stdin.resume();
+        process.stdin.ref();
         prompt ??= createInterface({ input: process.stdin, output: process.stdout });
         return /^(?:y|yes)$/i.test((await prompt.question(`${question} [y/N] `)).trim());
     };
@@ -268,43 +274,31 @@ async function installAgentFiles(cwd, force, docs, notes) {
         prompt?.close();
     }
 }
-const askDefault = async (rl, label, def) => {
-    const answer = (await rl.question(`${label} [${def}] `)).trim();
-    return answer || def;
-};
-const askYesNo = async (rl, label, def) => {
-    const hint = def ? "Y/n" : "y/N";
-    const answer = (await rl.question(`${label} [${hint}] `)).trim();
-    if (!answer)
-        return def;
-    return /^(?:y|yes)$/i.test(answer);
-};
-async function runInitWizard(cwd) {
-    const rl = createInterface({ input: process.stdin, output: process.stdout });
-    try {
-        const driverDef = wizardDriverDefault();
-        const driverRaw = await askDefault(rl, "Driver (auto|herdr|subprocess)", driverDef);
-        const driver = ["auto", "herdr", "subprocess"].includes(driverRaw)
-            ? driverRaw
-            : driverDef;
-        const concRaw = await askDefault(rl, "Concurrency", String(DEFAULT_CONFIG.concurrency));
-        const parsed = Number.parseInt(concRaw, 10);
-        const concurrency = Number.isInteger(parsed) && parsed > 0 ? parsed : DEFAULT_CONFIG.concurrency;
-        const llmDef = DEFAULT_CONFIG.visibility.llm;
-        const llmRaw = await askDefault(rl, "visibility.llm (pane|headless)", llmDef);
-        const llm = llmRaw === "pane" || llmRaw === "headless" ? llmRaw : llmDef;
-        let installSkills = false;
-        if (!skillsInstalled(cwd)) {
-            const skillsDef = existsSync(join(cwd, ".claude", "skills")) && !skillsInstalled(cwd);
-            installSkills = await askYesNo(rl, "Install agent skills (tickmarkr-loop/tickmarkr-auto/tickmarkr-overseer)?", skillsDef);
-        }
-        return { overlay: { driver, concurrency, visibility: { llm } }, installSkills };
-    }
-    finally {
-        rl.close();
-    }
+// The consolidated wizard (operator directive 2026-08-12): init walks three acts in one
+// command — preferences (Ink form) → discovery (doctor, the sensor) → fleet (presets or the
+// full editor). The readline asks this replaced live on in git history; the Ink act keeps the
+// same four questions and the same defaults, so `--yes` and non-TTY paths are unchanged.
+async function runInitWizard(cwd, input, output) {
+    // Dynamic import, deliberately (same seam as fleet.ts): the Ink/React runtime must stay out of
+    // the non-TTY and --yes paths — init runs in CI and agent shells where importing Ink at module
+    // load would drag a renderer into paths that never draw.
+    const { runInitWizardApp } = await import("../../tui/ink/init-app.js");
+    const result = await runInitWizardApp({
+        fields: {
+            driver: wizardDriverDefault(),
+            concurrency: DEFAULT_CONFIG.concurrency,
+            visibilityLlm: DEFAULT_CONFIG.visibility.llm,
+            offerSkills: !skillsInstalled(cwd),
+            skillsDefault: existsSync(join(cwd, ".claude", "skills")) && !skillsInstalled(cwd),
+        },
+        input,
+        output,
+    });
+    if (result.kind === "quit")
+        return null;
+    return { overlay: result.overlay, installSkills: result.installSkills, installDocs: result.installDocs };
 }
-export async function init(argv, cwd = process.cwd()) {
+export async function init(argv, cwd = process.cwd(), io = {}) {
     let bannerEmitted = false;
     const emitBanner = () => {
         if (visual() && !bannerEmitted) {
@@ -363,26 +357,58 @@ export async function init(argv, cwd = process.cwd()) {
             notes.push(`stale ${join(d.dir, "SKILL.md")} — ${describeDrift(d)}; run tickmarkr init --agent --force to refresh it`);
         }
     }
-    const fresh = values.fresh ?? false;
-    const { reuse, ageMs, health } = initDoctorReuse(cwd, fresh);
-    const doc = reuse && health && ageMs !== null
-        ? `using probe results from ${formatDoctorAgeForInit(ageMs)} ago — run tickmarkr doctor to refresh (or init --fresh)\n${formatDoctorReport(cwd, loadConfig(cwd), health, allAdapters(), { wrote: false })}`
-        : await doctor([], cwd, undefined, { banner: false });
-    const interactive = process.stdin.isTTY === true && process.stdout.isTTY === true && !(values.yes ?? false);
+    const input = io.input ?? process.stdin;
+    const output = io.output ?? process.stdout;
+    const interactive = input.isTTY === true && output.isTTY === true && !(values.yes ?? false);
+    // Act 1 — preferences. Only when the repo config does not exist yet: init never rewrites an
+    // operator's config; re-tuning is `tickmarkr fleet` (act 3 below still runs and writes overlays).
+    let wizardQuit = false;
     if (!repoConfigExists) {
         if (interactive) {
             emitBanner();
-            const wizard = await runInitWizard(cwd);
-            writeFileSync(repoConfigPath, configTemplate(wizard.overlay));
-            notes.push(`wrote ${repoConfigPath}`);
-            if (wizard.installSkills)
-                await installAgentFiles(cwd, values.force ?? false, values.docs ?? false, notes);
+            const wizard = await runInitWizard(cwd, input, output);
+            if (wizard === null) {
+                wizardQuit = true;
+                notes.push("wizard quit — no repo config written; re-run tickmarkr init (or tickmarkr fleet after a manual config)");
+            }
+            else {
+                writeFileSync(repoConfigPath, configTemplate(wizard.overlay));
+                notes.push(`wrote ${repoConfigPath}`);
+                if (wizard.installSkills) {
+                    await installAgentFiles(cwd, values.force ?? false, wizard.installDocs || (values.docs ?? false), notes);
+                }
+            }
         }
         else {
             writeFileSync(repoConfigPath, configTemplate());
             notes.push(`wrote ${repoConfigPath}`);
         }
     }
+    // Act 2 — discovery. Doctor is the sensor (fleet never re-probes); runs after preferences so the
+    // probe reads the config the operator just chose. Reuse keeps init fast; --fresh forces the probe.
+    const fresh = values.fresh ?? false;
+    const { reuse, ageMs, health } = initDoctorReuse(cwd, fresh);
+    let doc = reuse && health && ageMs !== null
+        ? `using probe results from ${formatDoctorAgeForInit(ageMs)} ago — run tickmarkr doctor to refresh (or init --fresh)\n${formatDoctorReport(cwd, loadConfig(cwd), health, allAdapters(), { wrote: false })}`
+        : await doctor([], cwd, undefined, { banner: false });
+    // Act 3 — fleet. Interactive only, and never after a wizard quit ("stop" means stop). The
+    // discovery report prints BETWEEN the acts so the operator reads what the presets screen
+    // ranks with; the final summary then carries a pointer instead of the same bytes twice.
+    if (interactive && !wizardQuit) {
+        output.write(`${doc}\n`);
+        doc = "discovery report shown above — re-print any time with `tickmarkr doctor`";
+        // Same lazy-Ink seam as fleet.ts: load the editor runtime up front so the assembler's
+        // returned props need no startup-input capture window on this path.
+        const { runFleetInkEditor } = await import("../../tui/ink/fleet-app.js");
+        const editor = await assembleFleetEditor(cwd, allAdapters(), { input, output }, { globalDir: gdir, entry: "presets" });
+        if ("unavailable" in editor) {
+            notes.push(`fleet: ${editor.unavailable}`);
+        }
+        else {
+            const result = await runFleetInkEditor(editor.props);
+            notes.push(editor.commit(result));
+        }
+    }
     if (values.agent)
         await installAgentFiles(cwd, values.force ?? false, values.docs ?? false, notes);
     const next = nextSteps(cwd, SCAFFOLD_SPEC);

package/dist/cli/commands/run.js

@@ -67,8 +67,9 @@ export async function run(argv, cwd = process.cwd()) {
         console.warn(`tickmarkr: !! ${conflict}`);
     }
     // OBS-107 (v1.67 T5): advisory only — a stale compiled graph with prior terminal statuses and no
-    // live daemon will otherwise finish with zero work and confuse the operator. The recompile remedy
-    // is named; dispatch proceeds unchanged.
+    // live daemon will otherwise confuse the operator. The recompile remedy is named; dispatch
+    // proceeds unchanged when anything is still dispatchable. When NOTHING is (all-terminal graph),
+    // runDaemon's no-op refusal (GATE-FIX-4 defect 4) turns the old zero-work "finished" into an error.
     const TERMINAL_STATUSES = ["done", "failed", "human"];
     if (graph.tasks.some((t) => TERMINAL_STATUSES.includes(t.status)) && !isRunLockLive(cwd)) {
         console.warn("tickmarkr: compiled graph carries terminal statuses from a prior run and no daemon is active — "

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

@@ -3,6 +3,7 @@ import { type AcceptanceItem } from "../../graph/schema.js";
 export declare function parseCriteria(text: string): AcceptanceItem[];
 export declare const HUMAN_CHANNEL: BillingChannel;
 export declare const HUMAN_AUTHOR: Assignment;
+export declare function verifyStateDir(cwd: string): string;
 export declare function verify(argv: string[], cwd?: string): Promise<{
     out: string;
     code: number;

package/dist/cli/commands/verify.js

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { parseArgs } from "node:util";
@@ -42,6 +42,16 @@ export function parseCriteria(text) {
 // verify models the author as a "human" vendor channel — resolvable, excludes nothing real.
 export const HUMAN_CHANNEL = { adapter: "human", vendor: "human", model: "human", channel: "sub", tier: "frontier" };
 export const HUMAN_AUTHOR = { adapter: "human", model: "human", channel: "sub", tier: "frontier" };
+// GATE-FIX-4 defect 1 (false-RED on macOS): os.tmpdir() returns /var/folders/…, a symlink into
+// /private/var — so a baseline captured under the repo path and a head battery run under the tmp
+// path disagree on every path-bearing fingerprint, and verify reds a green diff. graph.ts's
+// saveGraph carries the standing precedent ("never os.tmpdir()" — rename(2) atomicity there, path
+// identity here): tmpdir is fine for verify's disposable state, but only through realpathSync so
+// every path verify hands to gates is already canonical. Exported for the unit test that pins the
+// realpath (CI cannot rely on the macOS symlink).
+export function verifyStateDir(cwd) {
+    return join(realpathSync(tmpdir()), "tickmarkr-verify", createHash("sha256").update(cwd).digest("hex").slice(0, 12));
+}
 export async function verify(argv, cwd = process.cwd()) {
     const { values } = parseArgs({
         args: argv,
@@ -100,7 +110,7 @@ export async function verify(argv, cwd = process.cwd()) {
     // ALL verify state (cache, base worktree, artifacts) lives OUTSIDE the repo: verify gates the repo
     // root itself, so any file it wrote there would trip the battery's own dirty-worktree refusal.
     // ponytail: tmpdir means the baseline cache dies on reboot/cleanup — worst case is one re-capture.
-    const stateDir = join(tmpdir(), "tickmarkr-verify", createHash("sha256").update(cwd).digest("hex").slice(0, 12));
+    const stateDir = verifyStateDir(cwd);
     mkdirSync(stateDir, { recursive: true });
     let baseline;
     const cachePath = join(stateDir, `baseline-${mergeBase.slice(0, 12)}.json`);

package/dist/config/fleet-overlay.d.ts

@@ -5,6 +5,10 @@ export type FleetOverlayWrite = {
     initial: FleetEditable;
     edited: FleetEditable;
     mode?: RoutingMode;
+    judge?: {
+        adapter: string;
+        model: string;
+    };
     steering?: {
         initial: {
             review?: string[];

package/dist/config/fleet-overlay.js

@@ -170,6 +170,10 @@ export function renderFleetOverlayWrite(priorBytes, write) {
     if (write.mode !== undefined) {
         setScalarPreservingComment(doc, ["routing", "mode"], write.mode);
     }
+    if (write.judge) {
+        setScalarPreservingComment(doc, ["judge", "adapter"], write.judge.adapter);
+        setScalarPreservingComment(doc, ["judge", "model"], write.judge.model);
+    }
     if (write.steering) {
         for (const key of ["review", "consult"]) {
             const before = write.steering.initial[key];

package/dist/gates/baseline.d.ts

@@ -47,6 +47,21 @@ export type PackageManager = "npm" | "pnpm" | "yarn" | "bun";
  */
 export declare function detectPackageManager(repoRoot: string): PackageManager;
 export declare function detectGateCommands(repoRoot: string, cfg: TickmarkrConfig): Record<string, string>;
+/**
+ * Dossier GATE-FIX-4 §3 (2026-08-13): turbo schedules per-package tasks and ABORTS the whole
+ * run at the first failing package, so every package after the abort goes unverified — and the
+ * baseline gate then forgives the truncated output as "matching". The class appeared in three
+ * gates and four syntaxes on one repo (turbo's scheduler, `&&`, a JS for-loop process.exit, and
+ * turbo nested inside two of them). This preflight names only what it can see textually: the
+ * resolved gate command, and — for the synthesized `<pm> run <script>` form — that script's own
+ * body. The remedy deliberately demands a forwarding check first: the same repo's lint wrapper
+ * branched on argv.length, so a blind `-- --continue` silently replaced the gate with a
+ * different command (the trap their overseer caught by reading, not by symmetry).
+ */
+export declare function turboContinueFindings(repoRoot: string, cfg: TickmarkrConfig): Array<{
+    gate: string;
+    detail: string;
+}>;
 /**
  * The ceiling a battery runs under: whichever is larger of the shipped constant and the slack applied
  * to what this command actually measured. A pre-v1.90 baseline (no measurement) gets exactly the