tickmarkr 2.4.1 → 2.5.0

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/report.js

@@ -8,34 +8,19 @@ import { modelProvider } from "../../gates/review.js";
 import { buildProofBundle, gateDeclined } from "../../report/bundle.js";
 import { compareRuns } from "../../report/compare.js";
 import { estimateCosts } from "../../report/cost.js";
+import { assignmentChannel, buildOperatorRecord, formatChannelMoney, formatChannelTokens, formatTokenUsage as fields, totalTokens as total, } from "../../report/operator-record.js";
 import { cellsOf, cellSummary } from "../../route/profile.js";
 import { Journal, loadRoutingProfile } from "../../run/journal.js";
 import { deriveRunCockpitData } from "../../tui/cockpit/derive.js";
 const n = (x) => x.toLocaleString("en-US"); // explicit locale — CI/darwin flake guard
 const EM = "—";
-// TokenUsage fields that are actually present — filtered, never coalesced to zero (absent ⇒ unmetered).
-const fields = (u) => {
-    const parts = [`in ${n(u.input)}`, `out ${n(u.output)}`];
-    if (u.cacheRead !== undefined && u.cacheWrite !== undefined)
-        parts.push(`cache r/w ${n(u.cacheRead)}/${n(u.cacheWrite)}`);
-    if (u.reasoning !== undefined)
-        parts.push(`reasoning ${n(u.reasoning)}`);
-    return parts.join("  ");
-};
-const total = (u) => [u.input, u.output, u.cacheRead, u.cacheWrite, u.reasoning].filter((x) => x !== undefined).reduce((a, b) => a + b, 0);
 const firstLine = (s) => {
     if (typeof s !== "string" || !s)
         return EM;
     const i = s.indexOf("\n");
     return (i < 0 ? s : s.slice(0, i)) || EM;
 };
-const channelLabel = (data) => {
-    const a = data.assignment;
-    if (!a || typeof a !== "object")
-        return EM;
-    const { adapter, model } = a;
-    return typeof adapter === "string" && typeof model === "string" ? `${adapter}:${model}` : EM;
-};
+const channelLabel = (data) => assignmentChannel(data) ?? EM;
 const modelFromChannel = (channel) => channel.slice(channel.indexOf(":") + 1);
 const reviewerIdentity = (data) => {
     const details = typeof data.details === "string" ? data.details : "";
@@ -52,35 +37,10 @@ const reviewerIdentity = (data) => {
         : modelProvider(modelFromChannel(reviewer), vendor ?? "unknown");
     return { reviewer, provider, ...(vendor ? { vendor } : {}) };
 };
-const rateBasis = (row) => {
-    if (!row.rate)
-        return EM;
-    const cache = row.rate.cacheReadPerMtok === undefined ? "" : `; cache-read $${row.rate.cacheReadPerMtok}/Mtok`;
-    const date = row.rate.rateDate === undefined ? "" : `; rate date ${row.rate.rateDate}`;
-    return `in/out $${row.rate.inPerMtok}/$${row.rate.outPerMtok}/Mtok${cache}${date}`;
-};
 const priceLine = (row) => {
     const windows = row.channel === "sub" && row.subPlan ? `windows: ${n(row.attempts)}` : `attempts/windows: ${n(row.attempts)}`;
-    const tokenText = row.tokens
-        ? `tokens: ${row.partialMetering ? "≥ " : ""}${fields(row.tokens)} (${n(total(row.tokens))} tokens)`
-        : "tokens: unmetered";
-    const prices = [];
-    const bases = [];
-    if (row.apiUsd !== undefined)
-        prices.push(`price: $${row.apiUsd.toFixed(6)}`);
-    if (row.amortizedUsd !== undefined && row.subPlan !== undefined) {
-        const [low, high] = row.amortizedUsd;
-        prices.push(`price: $${low.toFixed(6)}–$${high.toFixed(6)} amortized`);
-        bases.push(`${n(row.attempts)} windows × $${row.subPlan.planMonthly}/month ÷ ${row.subPlan.windowsPerMonthHigh}–${row.subPlan.windowsPerMonthLow} windows/month`);
-    }
-    if (row.counterfactualUsd !== undefined)
-        prices.push(`API-equivalent: $${row.counterfactualUsd.toFixed(6)}`);
-    if (row.rate)
-        bases.push(rateBasis(row));
-    if (!prices.length)
-        prices.push("price: not measurable");
-    if (!bases.length)
-        bases.push(row.reason || "not recorded");
+    const tokenText = `tokens: ${formatChannelTokens(row)}`;
+    const { prices, bases } = formatChannelMoney(row);
     return `- **${row.adapter}:${row.model}** — ${windows}; ${tokenText}; ${prices.join("; ")}; basis: ${bases.join("; ")}`;
 };
 const journalUsage = (events, known) => {
@@ -257,6 +217,17 @@ export function renderMarkdownRecord(runId, events, prices = [], rows = []) {
         `- **escalations:** ${events.filter((e) => e.event === "escalation").length}`,
         "",
     ];
+    lines.push("## Channels", "");
+    const operatorRecords = buildOperatorRecord(events, prices);
+    if (operatorRecords.length) {
+        for (const row of operatorRecords) {
+            lines.push(`- **${row.channel}** — worker: ${row.worker}, review: ${row.review}, consult: ${row.consult}; tokens: ${row.tokens}; money: ${row.money}`);
+        }
+    }
+    else {
+        lines.push("- no channel activity recorded");
+    }
+    lines.push("");
     lines.push("## Audit trail", "");
     for (const taskId of taskIds(events)) {
         const dispatches = events.filter((e) => e.taskId === taskId && e.event === "task-dispatch");

package/dist/cli/commands/scope.js

@@ -1,21 +1,51 @@
+import { createInterface } from "node:readline/promises";
 import { isAbsolute, join, relative } from "node:path";
 import { parseArgs } from "node:util";
 import { allAdapters } from "../../adapters/registry.js";
 import { loadConfig } from "../../config/config.js";
-import { scopeIntent } from "../../plan/scope.js";
+import { formatScopePreview, previewScope, scopeIntent } from "../../plan/scope.js";
+// R11/R16/R45 (C10): --preview is a read-only disclosure (cached candidate, destination, call
+// budget) — it never probes, never calls a model, and never writes. Active scope reuses that same
+// disclosure to build a confirmation question, then requires TTY "y" or --yes before it invokes the
+// unchanged production authoring path (scopeIntent); a non-TTY shell without --yes refuses rather
+// than silently proceeding (the unlock.ts confirm() convention).
 export async function scope(argv, cwd = process.cwd(), adapters = allAdapters(), driver) {
     const { values, positionals } = parseArgs({
         args: argv,
-        options: { force: { type: "boolean" } },
+        options: { force: { type: "boolean" }, preview: { type: "boolean" }, yes: { type: "boolean" } },
         allowPositionals: true,
     });
     if (positionals.length !== 1)
-        throw new Error("usage: tickmarkr scope <intent-file> [--force]");
+        throw new Error("usage: tickmarkr scope <intent-file> [--preview] [--yes] [--force]");
     const source = positionals[0];
     const intentFile = isAbsolute(source) ? source : join(cwd, source);
-    const result = await scopeIntent(intentFile, cwd, {
-        cfg: loadConfig(cwd), adapters, driver, force: values.force,
-    });
+    const cfg = loadConfig(cwd);
+    const preview = previewScope(intentFile, cwd, { cfg, adapters });
+    if (values.preview)
+        return formatScopePreview(preview);
+    const confirm = async (question) => {
+        if (values.yes)
+            return true;
+        if (process.stdin.isTTY !== true || process.stdout.isTTY !== true)
+            return false;
+        const rl = createInterface({ input: process.stdin, output: process.stdout });
+        try {
+            return /^(?:y|yes)$/i.test((await rl.question(`${question} [y/N] `)).trim());
+        }
+        finally {
+            rl.close();
+        }
+    };
+    const candidateLabel = preview.candidate
+        ? `${preview.candidate.adapter}:${preview.candidate.model}`
+        : `an unknown candidate (${preview.cached ? "no verified channel in the doctor cache" : "no doctor cache"})`;
+    const question = `Draft ${relative(cwd, preview.specFile)} via ${candidateLabel} using up to ${preview.authoringBudget} authoring call${preview.authoringBudget === 1 ? "" : "s"} plus ${preview.probeCalls} probe call${preview.probeCalls === 1 ? "" : "s"}?`;
+    if (!(await confirm(question))) {
+        throw new Error("scope: not confirmed (pass --yes or confirm at a TTY)");
+    }
+    // Bind dispatch to exactly the candidate just disclosed and confirmed (R11/R45 repair) — scopeIntent
+    // fails loud rather than silently authoring against a different channel a fresh probe turns up.
+    const result = await scopeIntent(intentFile, cwd, { cfg, adapters, driver, force: values.force, candidate: preview.candidate });
     const tasks = `${result.tasks} task${result.tasks === 1 ? "" : "s"}`;
     const calls = `${result.attempts} LLM call${result.attempts === 1 ? "" : "s"}`;
     return `scoped ${source} → ${relative(cwd, result.specFile)} (${tasks}, ${calls})`;

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

@@ -1,3 +1,4 @@
+import { type OperatorRecordRow } from "../../report/operator-record.js";
 export declare const STATS_COLUMNS: readonly ["author", "reviewer", "dispatches", "deliveries", "delivery rate", "attempts to green", "real reds", "infra reds", "within-task rescues"];
 export interface ChannelStats {
     author: string;
@@ -14,6 +15,7 @@ export interface ChannelStats {
 export interface StatsReport {
     runs: number;
     channels: ChannelStats[];
+    operatorRecords?: OperatorRecordRow[];
 }
 /** Reduce every readable run journal under the repository's state directory. */
 export declare function collectChannelStats(cwd?: string): StatsReport;