tickmarkr 2.4.2 → 2.5.0

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;

package/dist/cli/commands/stats.js

@@ -1,6 +1,7 @@
 import { existsSync, readdirSync } from "node:fs";
 import { join } from "node:path";
 import { stateDirName } from "../../graph/graph.js";
+import { assignmentChannel, buildOperatorRecord, formatOperatorRecordRow } from "../../report/operator-record.js";
 import { Journal } from "../../run/journal.js";
 import { normalizeGateOutcome } from "../../run/outcome.js";
 // The operator-facing schema is deliberately closed. Adding a fact to the table therefore requires
@@ -17,20 +18,15 @@ export const STATS_COLUMNS = [
     "infra reds",
     "within-task rescues",
 ];
-const assignmentAuthor = (data) => {
-    const assignment = data.assignment;
-    if (!assignment || typeof assignment !== "object")
-        return undefined;
-    const { adapter, model } = assignment;
-    return typeof adapter === "string" && typeof model === "string"
-        ? `${adapter}:${model}`
-        : undefined;
-};
+const assignmentAuthor = assignmentChannel;
 // Current journals write the reviewer into review prose; the structured field is also accepted so
 // journals produced through gateResultJournalData retain their stronger identity representation.
 const reviewerFrom = (data) => {
     if (typeof data.reviewer === "string" && data.reviewer.trim())
         return data.reviewer.trim();
+    const meta = typeof data.meta === "object" && data.meta !== null ? data.meta : undefined;
+    if (meta && "reviewer" in meta && typeof meta.reviewer === "string" && meta.reviewer.trim())
+        return meta.reviewer.trim();
     if (typeof data.details !== "string")
         return undefined;
     return /\breviewer(?:\s+|:\s*)([\w@./+-]+:[\w@./+-]+)/iu.exec(data.details)?.[1];
@@ -79,8 +75,10 @@ export function collectChannelStats(cwd = process.cwd()) {
         }
         return channel;
     };
+    const allEvents = [];
     for (const runId of runIds) {
         const events = Journal.open(cwd, runId).read();
+        allEvents.push(...events);
         const tasks = new Map();
         for (const [eventIndex, event] of events.entries()) {
             if (!event.taskId)
@@ -124,6 +122,16 @@ export function collectChannelStats(cwd = process.cwd()) {
                 }
                 continue;
             }
+            if (event.event === "review-leg2") {
+                const author = dispatchedAuthorFor(history, event.data)
+                    ?? (typeof event.data.author === "string" && event.data.author.includes(":") ? event.data.author : undefined);
+                if (author) {
+                    const reviewer = reviewerFrom(event.data);
+                    if (reviewer)
+                        channelFor(author).reviewers.add(reviewer);
+                }
+                continue;
+            }
             if (event.event !== "gate-result")
                 continue;
             const author = dispatchedAuthorFor(history, event.data);
@@ -170,26 +178,37 @@ export function collectChannelStats(cwd = process.cwd()) {
             infraReds: channel.infraReds,
             rescues: [...channel.rescues].sort((a, b) => a.localeCompare(b, "en")),
         })),
+        operatorRecords: buildOperatorRecord(allEvents),
     };
 }
 const percent = (rate) => `${Number((rate * 100).toFixed(1))}%`;
 export function renderStats(report) {
     const lines = [`tickmarkr stats — ${report.runs} run${report.runs === 1 ? "" : "s"}`];
-    if (report.channels.length === 0)
+    if (report.channels.length === 0 && (!report.operatorRecords || report.operatorRecords.length === 0)) {
         return [...lines, "no channels"].join("\n");
-    lines.push(STATS_COLUMNS.join(" | "));
-    for (const channel of report.channels) {
-        lines.push([
-            channel.author,
-            channel.reviewers.join(", ") || "—",
-            channel.dispatches,
-            channel.deliveries,
-            percent(channel.deliveryRate),
-            channel.attemptsToGreen === null ? "—" : Number(channel.attemptsToGreen.toFixed(2)),
-            channel.realReds,
-            channel.infraReds,
-            channel.rescues.join("; ") || "—",
-        ].join(" | "));
+    }
+    if (report.channels.length > 0) {
+        lines.push(STATS_COLUMNS.join(" | "));
+        for (const channel of report.channels) {
+            lines.push([
+                channel.author,
+                channel.reviewers.join(", ") || "—",
+                channel.dispatches,
+                channel.deliveries,
+                percent(channel.deliveryRate),
+                channel.attemptsToGreen === null ? "—" : Number(channel.attemptsToGreen.toFixed(2)),
+                channel.realReds,
+                channel.infraReds,
+                channel.rescues.join("; ") || "—",
+            ].join(" | "));
+        }
+    }
+    if (report.operatorRecords && report.operatorRecords.length > 0) {
+        lines.push("");
+        lines.push("channels:");
+        for (const row of report.operatorRecords) {
+            lines.push(`  ${formatOperatorRecordRow(row)}`);
+        }
     }
     return lines.join("\n");
 }

package/dist/cli/commands/status.js

@@ -13,9 +13,8 @@ import { isPidLive, runLockRunId, runStatusLine } from "../../run/lock.js";
 import { normalizeGateOutcome } from "../../run/outcome.js";
 import { desiredPanes } from "../../run/reconcile.js";
 import { normalizeStallSnapshot } from "../../run/stall.js";
-import { armWatchSupervision, readSupervision, supervisionText } from "../../run/supervision.js";
+import { armWatchSupervision, observeNamedRun, WATCH_OWNER_ENV, readSupervision, supervisionText } from "../../run/supervision.js";
 import { deriveRunCockpitData, } from "../../tui/cockpit/derive.js";
-import { COCKPIT_COLUMN_FLOOR } from "../../tui/cockpit/layout.js";
 import { cellWidth, fitCells, wrapCells } from "../../tui/cockpit/width.js";
 import { version } from "./version.js";
 // The board is a LIVE surface, so it draws through brand.ts's operator role map and never the vivid
@@ -1093,7 +1092,7 @@ binaryVersion, now = Date.now(), animationFrame = 0, workerLiveness = new Map(),
     }
     // TTY: the operator-approved task table. The daemon gives this surface a ~110-column pane first;
     // narrower terminals keep the same facts in stacked rows. Every cut/wrap goes through width.ts.
-    const boardColumns = Math.max(COCKPIT_COLUMN_FLOOR, width);
+    const boardColumns = Math.max(40, width);
     const dot = dim(" · ");
     const separator = `  ${dim("│")}  `;
     const tipFailed = tipPhase?.state === "failed";
@@ -1343,6 +1342,15 @@ export async function status(argv, cwd = process.cwd(), opts = {}) {
     const sleep = opts.sleep ?? defaultSleep;
     const now = opts.now ?? Date.now;
     const bounded = Number.isFinite(iterations);
+    // Bounded snapshots and printed twins never import Ink. Public interactive watch
+    // selects its run once through the same launcher as manual UI.
+    if (!bounded && !eventStream && !argv.includes("--plain") && process.stdin.isTTY === true && process.stdout.isTTY === true) {
+        const { ui } = await import("./ui.js");
+        const result = await ui([...(namedRunId ? [namedRunId] : []), "--view", "run"], {}, cwd);
+        if (typeof result !== "string")
+            throw new Error(result.out);
+        return "";
+    }
     const frames = [];
     const eventLines = [];
     const sep = "\n---\n";
@@ -1455,7 +1463,8 @@ export async function status(argv, cwd = process.cwd(), opts = {}) {
     // it INVERTS it: armSupervision's interval outlives the board in any host that outlives one board, so
     // a dead board keeps writing and reads ARMED. That is the over-claiming direction, the one an operator
     // acts on, and the one this instrument exists to close.
-    const armed = bounded ? undefined : armWatchSupervision(cwd, opts.supervisionBeatMs);
+    const boardObservation = !bounded && namedRunId && process.env[WATCH_OWNER_ENV] ? observeNamedRun(cwd, namedRunId) : undefined;
+    const armed = bounded || boardObservation ? undefined : armWatchSupervision(cwd, opts.supervisionBeatMs);
     let alternateScreen = false;
     const leaveAlternateScreen = () => {
         if (!alternateScreen)
@@ -1491,6 +1500,8 @@ export async function status(argv, cwd = process.cwd(), opts = {}) {
         if (exitingFromSignal)
             return;
         exitingFromSignal = true;
+        armed?.disarm();
+        boardObservation?.close();
         if (titleSaved) {
             process.removeListener("exit", restoreTitle);
             restoreTitle();
@@ -1507,6 +1518,8 @@ export async function status(argv, cwd = process.cwd(), opts = {}) {
         process.stdout.write(ENTER_ALTERNATE_SCREEN);
         alternateScreen = true;
         process.once("exit", leaveAlternateScreen);
+    }
+    if (!bounded) {
         for (const [signal, code] of [["SIGINT", 130], ["SIGTERM", 143]]) {
             const handler = exitFromSignal(code);
             signalHandlers.push([signal, handler]);
@@ -1515,6 +1528,8 @@ export async function status(argv, cwd = process.cwd(), opts = {}) {
     }
     try {
         for (let i = 0; i < iterations; i++) {
+            if (boardObservation?.stopRequested())
+                break;
             const nowMs = now();
             const decisionEvents = eventStream || webhookUrl ? consumeDecisionEvents() : [];
             let frame;
@@ -1558,6 +1573,7 @@ export async function status(argv, cwd = process.cwd(), opts = {}) {
         // armSupervision's presence files). Otherwise the first pane closed would render the second
         // pane's own tier down while it is drawing frames.
         armed?.disarm();
+        boardObservation?.close();
         if (titleSaved) {
             process.removeListener("exit", restoreTitle);
             restoreTitle();

package/dist/cli/commands/ui.js

@@ -1,64 +1,53 @@
+import { join } from "node:path";
+import { Journal, parseRunId } from "../../run/journal.js";
+import { stateDirName } from "../../graph/graph.js";
+import { JournalTail } from "../../tui/cockpit/live-store.js";
 const NON_TTY_MSG = "tickmarkr ui: the cockpit requires a TTY — use `tickmarkr fleet --print` or `tickmarkr status --watch` for line-mode output";
-/**
- * The setup surface's own flag. `tickmarkr ui --setup [run-id]` opens the one
- * surface that writes — parked human decisions, approved or upheld through the
- * production command path behind an explicit confirm.
- */
-const SETUP_FLAG = "--setup";
 export async function ui(argv, io = {}, cwd = process.cwd()) {
     const input = io.input ?? process.stdin;
     const output = io.output ?? process.stdout;
-    if (input.isTTY !== true || output.isTTY !== true) {
+    if (input.isTTY !== true || output.isTTY !== true)
         return { out: NON_TTY_MSG, code: 1 };
-    }
-    if (argv.includes("--demo")) {
-        const { runCockpitDemo } = await import("../../tui/cockpit/demo.js");
-        const { version } = await import("./version.js");
-        await runCockpitDemo({
-            input,
-            output,
-            binaryVersion: await version(),
-        });
-        return "ui: closed";
-    }
-    const setup = argv.includes(SETUP_FLAG);
-    const unknownFlag = argv.find((arg) => arg.startsWith("-") && arg !== SETUP_FLAG);
-    if (unknownFlag) {
-        return { out: `tickmarkr ui: unknown flag ${unknownFlag}`, code: 1 };
-    }
-    const live = await import("../../tui/cockpit/live.js");
-    const { version } = await import("./version.js");
-    const binaryVersion = await version();
-    const explicit = argv.find((arg) => !arg.startsWith("-"));
-    let runId;
+    let explicit;
+    let view = "home";
+    let setup = false;
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === "--setup")
+            setup = true;
+        else if (arg === "--view") {
+            const value = argv[++i];
+            if (value !== "home" && value !== "run" && value !== "evidence")
+                return { out: "tickmarkr ui: --view must be home, run or evidence", code: 1 };
+            view = value;
+        }
+        else if (arg.startsWith("-"))
+            return { out: `tickmarkr ui: unknown flag ${arg}`, code: 1 };
+        else if (explicit !== undefined)
+            return { out: "tickmarkr ui: expected at most one run ID", code: 1 };
+        else
+            explicit = arg;
+    }
+    let runId = null;
     try {
-        runId = live.selectEngagementRunId(cwd, explicit);
+        runId = explicit === undefined ? Journal.latestRunId(cwd, { withJournal: true }) : parseRunId(explicit);
+        // Refuse an invalid explicit target before importing or borrowing the terminal.
+        if (runId) {
+            const initial = new JournalTail(join(cwd, stateDirName(cwd), "runs", runId, "journal.jsonl")).poll();
+            if (initial.status === "unreadable" || initial.status === "corrupt")
+                throw new Error(initial.error?.error ?? initial.errors[0]?.error ?? "journal corrupt");
+        }
     }
     catch (error) {
-        return { out: `tickmarkr ui: ${error.message}`, code: 1 };
-    }
-    if (runId === null) {
-        return {
-            out: "tickmarkr ui: no engagement found — start one with `tickmarkr run` first",
-            code: 1,
-        };
+        return { out: `tickmarkr ui: cannot read engagement ${runId ?? explicit ?? "latest"}: ${error.message}`, code: 1 };
     }
-    // Refuse before drawing anything: unreadable journal bytes must never
-    // become a plausible surface derived from nothing.
-    try {
-        live.deriveLiveRunCockpitData(live.loadEngagementSource(cwd, runId), binaryVersion);
-    }
-    catch (error) {
-        return {
-            out: `tickmarkr ui: cannot read engagement ${runId}: ${error.message}`,
-            code: 1,
-        };
-    }
-    if (setup) {
-        const { runSetupDecisionsCockpit } = await import("../../tui/cockpit/setup-cockpit.js");
-        await runSetupDecisionsCockpit({ input, output, cwd, runId });
-        return "ui: closed";
-    }
-    await live.runLiveCockpit({ input, output, cwd, runId, binaryVersion });
+    const { runLiveCockpit } = await import("../../tui/cockpit/live.js");
+    const { version } = await import("./version.js");
+    const options = {
+        input, output, cwd, runId: runId ?? "run-no-run", binaryVersion: await version(),
+        observeRun: runId !== null, initialView: runId === null ? "home" : setup ? "run" : view,
+        initialParks: setup,
+    };
+    await runLiveCockpit(options);
     return "ui: closed";
 }

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

@@ -1 +1 @@
-export declare function unlock(_argv: string[], cwd?: string): Promise<string>;
+export declare function unlock(argv: string[], cwd?: string): Promise<string>;