tickmarkr 2.4.1 → 2.5.0

package/dist/drivers/orca.js

@@ -997,12 +997,51 @@ export class OrcaDriver {
             return false;
         }
     }
-    async narrator(cwd, command, runId) {
+    async narrator(_cwd, _command, runId) {
         if (!runId)
             throw new OrcaError("create", "Orca narrator requires a run identity", "");
-        const slot = await this.slot(cwd, formatOwnedName({ role: "watch", taskId: "run", attempt: 0, runId }), { owned: { role: "watch", taskId: "run", attempt: 0, runId } });
-        await this.run(slot, command);
-        return slot;
+        // The recorded Orca API can create a tab but provides no right/no-focus
+        // placement receipt. Creating one would advertise a board we did not place.
+        throw new OrcaError("create", "Orca narrator placement unsupported: right/no-focus board placement is not available", "");
+    }
+    async focus(target) {
+        const { slot, runId, taskId, attempt } = target;
+        const cwd = canonicalWorktreePath(slot.cwd);
+        if (slot.name !== formatOwnedName({ role: "worker", taskId, attempt, runId })) {
+            return { status: "foreign", reason: "Recorded run/task/attempt ownership does not match" };
+        }
+        try {
+            const env = await this.listAll(cwd);
+            const rows = env.result.terminals;
+            const layouts = env.result.visualLayouts;
+            if (!Array.isArray(rows) || !Array.isArray(layouts))
+                return { status: "unsupported", reason: "Cannot verify Orca terminal ownership" };
+            const handles = [];
+            for (const layout of layouts) {
+                if (typeof layout !== "object" || layout === null)
+                    continue;
+                const lo = layout;
+                if (!sameWorktree(terminalWorktree(lo), cwd))
+                    continue;
+                const tabs = [];
+                collectTabs(lo.root, tabs);
+                for (const tab of tabs) {
+                    if (typeof tab === "object" && tab !== null && str(tab.title) === slot.name)
+                        collectPaneHandles(tab.panes, handles);
+                }
+            }
+            if (handles.length !== 1)
+                return { status: rows.length ? "foreign" : "closed", reason: "No unique owned terminal in the recorded worktree" };
+            const matches = rows.filter(row => typeof row === "object" && row !== null && str(row.handle) === handles[0] && sameWorktree(terminalWorktree(row), cwd));
+            if (matches.length !== 1)
+                return { status: "foreign", reason: "Terminal worktree ownership is unverified" };
+            if (matches[0].connected === false || matches[0].orphaned === true)
+                return { status: "closed", reason: "Recorded terminal is no longer running; open task evidence" };
+            return { status: "unsupported", reason: "Owned terminal verified; this Orca API has no focus operation. Open task evidence with Enter" };
+        }
+        catch (error) {
+            return { status: "unsupported", reason: `Cannot verify Orca focus target: ${String(error)}` };
+        }
     }
     async project(taskId, state) {
         const worktree = this.taskWorktrees.get(taskId);

package/dist/drivers/subprocess.d.ts

@@ -24,6 +24,7 @@ export declare class SubprocessDriver implements ExecutorDriver {
     waitAgentStatus(slot: Slot, status: string, timeoutMs: number): Promise<boolean>;
     status(_slot: Slot): Promise<string>;
     read(slot: Slot, lines: number): Promise<string>;
+    focus(): Promise<import("./types.js").FocusResult>;
     notify(msg: string, _opts?: NotifyOpts): Promise<void>;
     close(slot: Slot): Promise<void>;
     worktree(repo: string, branch: string, baseRef: string): Promise<string>;

package/dist/drivers/subprocess.js

@@ -107,6 +107,9 @@ export class SubprocessDriver {
     async read(slot, lines) {
         return this.state(slot).buf.split("\n").slice(-lines).join("\n");
     }
+    async focus() {
+        return { status: "unsupported", reason: "Subprocess workers have no visible pane; open task evidence with Enter" };
+    }
     async notify(msg, _opts) {
         if (_opts?.tier === "routine")
             return;

package/dist/drivers/types.d.ts

@@ -66,6 +66,18 @@ export declare function panesToClose(agents: FleetAgent[], desired: Set<string>,
     tabId?: string;
 }[];
 export declare function canonicalizeLegacyName(name: string, runId: string): OwnedName;
+export interface FocusTarget {
+    repo: string;
+    runId: string;
+    taskId: string;
+    attempt: number;
+    slot: Slot;
+    workspace?: string;
+}
+export type FocusResult = {
+    status: "focused" | "foreign" | "closed" | "unsupported";
+    reason: string;
+};
 export interface SlotPlacement {
     surface?: string;
     hostPlatform?: string;
@@ -76,6 +88,8 @@ export interface ExecutorDriver {
     /** The exact terminal read surface used for liveness evidence. */
     readSource?: string;
     /** Placement facts returned by drivers whose terminal host exposes them. */
+    /** Verify the recorded identity against the live host before any focus mutation. */
+    focus?(target: FocusTarget): Promise<FocusResult>;
     describe?(slot: Slot): SlotPlacement | Promise<SlotPlacement> | undefined;
     slot(cwd: string, name: string, opts?: SlotOpts): Promise<Slot>;
     run(slot: Slot, cmd: string): Promise<void>;

package/dist/gates/artifact-manifest.d.ts

@@ -23,6 +23,27 @@ export type CaptureArtifactManifest = {
     readonly artifacts: readonly CaptureArtifactManifestEntry[];
 };
 export declare const CAPTURE_PRODUCERS: readonly [{
+    readonly id: "screen-soak";
+    readonly provenance: {
+        readonly source: "tests/fixtures/screen-soak/soak.mjs";
+        readonly entrypoint: "sample";
+        readonly revision: "C6-four-hour-production-v1";
+    };
+}, {
+    readonly id: "screen-soak-archive";
+    readonly provenance: {
+        readonly source: "tests/fixtures/screen-soak/archive.mjs";
+        readonly entrypoint: "archiveRecord";
+        readonly revision: "C6-lossless-gzip-v1";
+    };
+}, {
+    readonly id: "cockpit-final-shell";
+    readonly provenance: {
+        readonly source: "src/tui/cockpit/capture.ts";
+        readonly entrypoint: "captureShellOutput";
+        readonly revision: "final-shell-v1";
+    };
+}, {
     readonly id: "cockpit-golden-frames";
     readonly provenance: {
         readonly source: "src/tui/cockpit/capture.ts";
@@ -40,6 +61,27 @@ export declare const CAPTURE_PRODUCERS: readonly [{
 export declare const CAPTURE_ARTIFACT_MANIFEST: {
     readonly version: 1;
     readonly producers: readonly [{
+        readonly id: "screen-soak";
+        readonly provenance: {
+            readonly source: "tests/fixtures/screen-soak/soak.mjs";
+            readonly entrypoint: "sample";
+            readonly revision: "C6-four-hour-production-v1";
+        };
+    }, {
+        readonly id: "screen-soak-archive";
+        readonly provenance: {
+            readonly source: "tests/fixtures/screen-soak/archive.mjs";
+            readonly entrypoint: "archiveRecord";
+            readonly revision: "C6-lossless-gzip-v1";
+        };
+    }, {
+        readonly id: "cockpit-final-shell";
+        readonly provenance: {
+            readonly source: "src/tui/cockpit/capture.ts";
+            readonly entrypoint: "captureShellOutput";
+            readonly revision: "final-shell-v1";
+        };
+    }, {
         readonly id: "cockpit-golden-frames";
         readonly provenance: {
             readonly source: "src/tui/cockpit/capture.ts";
@@ -62,6 +104,14 @@ export declare const CAPTURE_ARTIFACT_MANIFEST: {
         path: string;
         producer: string;
         provenance: CaptureProducerProvenance;
+    } | {
+        path: string;
+        producer: string;
+        provenance: CaptureProducerProvenance;
+    } | {
+        path: string;
+        producer: string;
+        provenance: CaptureProducerProvenance;
     })[];
 };
 /** Compatibility name for the pre-manifest gate API; now derived from one manifest. */

package/dist/gates/artifact-manifest.js

@@ -13,7 +13,19 @@ const COLOUR_PROVENANCE = {
     entrypoint: "regenerateColourFrames",
     revision: "colour-frame-v1",
 };
+const SHELL_PROVENANCE = {
+    source: "src/tui/cockpit/capture.ts", entrypoint: "captureShellOutput", revision: "final-shell-v1",
+};
+const SOAK_PROVENANCE = {
+    source: "tests/fixtures/screen-soak/soak.mjs", entrypoint: "sample", revision: "C6-four-hour-production-v1",
+};
+const SOAK_ARCHIVE_PROVENANCE = {
+    source: "tests/fixtures/screen-soak/archive.mjs", entrypoint: "archiveRecord", revision: "C6-lossless-gzip-v1",
+};
 export const CAPTURE_PRODUCERS = [
+    { id: "screen-soak", provenance: SOAK_PROVENANCE },
+    { id: "screen-soak-archive", provenance: SOAK_ARCHIVE_PROVENANCE },
+    { id: "cockpit-final-shell", provenance: SHELL_PROVENANCE },
     { id: "cockpit-golden-frames", provenance: GOLDEN_PROVENANCE },
     { id: "cockpit-colour-frames", provenance: COLOUR_PROVENANCE },
 ];
@@ -49,6 +61,17 @@ export const CAPTURE_ARTIFACT_MANIFEST = {
     version: 1,
     producers: CAPTURE_PRODUCERS,
     artifacts: [
+        // Exact measured artifacts only. Neighbouring harnesses, notes and unknown
+        // records remain logic; duration evidence never grants a directory exemption.
+        ...["static", "growth", "cutover-static", "cutover-growth", "final-static", "final-growth", "retry-static", "retry-growth"].flatMap(attempt => ["build.json", "metadata.json", "samples.jsonl", "last-frame.ansi", "journal.jsonl.gz", "result.json.gz"].map(file => ({
+            path: `tests/fixtures/screen-soak/records/${attempt}/${file}`,
+            producer: file.endsWith(".gz") ? "screen-soak-archive" : "screen-soak",
+            provenance: provenanceCopy(file.endsWith(".gz") ? SOAK_ARCHIVE_PROVENANCE : SOAK_PROVENANCE),
+        }))),
+        ...["home", "run", "evidence"].flatMap(view => ["120x40", "80x24"].map(size => ({
+            path: `tests/fixtures/cockpit/final/${view}.${size}.txt`,
+            producer: "cockpit-final-shell", provenance: provenanceCopy(SHELL_PROVENANCE),
+        }))),
         ...goldenFrameNames.map((fixture) => ({
             path: `tests/fixtures/cockpit/frames/${fixture}`,
             producer: "cockpit-golden-frames",

package/dist/plan/scope.d.ts

@@ -1,12 +1,14 @@
 import type { WorkerAdapter } from "../adapters/types.js";
 import type { TickmarkrConfig } from "../config/config.js";
 import type { ExecutorDriver } from "../drivers/types.js";
+export declare const MAX_SCOPE_ATTEMPTS = 3;
 export declare function clarificationGate(intent: string): string[];
 export interface ScopeOptions {
     cfg: TickmarkrConfig;
     adapters: WorkerAdapter[];
     driver?: ExecutorDriver;
     force?: boolean;
+    candidate?: ScopeCandidate;
 }
 export interface ScopeResult {
     specFile: string;
@@ -14,4 +16,27 @@ export interface ScopeResult {
     attempts: number;
 }
 export declare function specPathForIntent(intentFile: string): string;
+export interface ScopeCandidate {
+    adapter: string;
+    model: string;
+}
+export interface ScopePreview {
+    intentFile: string;
+    specFile: string;
+    specExists: boolean;
+    cached: boolean;
+    candidate?: ScopeCandidate;
+    authoringBudget: number;
+    probeCalls: number;
+}
+/**
+ * R11/R45 (C10): local-only disclosure — intent/clarification checks and a candidate read off the
+ * doctor cache, never a fresh probe or a model turn. `readDoctor` and `discoverChannels`/`route` are
+ * pure reads over that cache, so this never touches an adapter.
+ */
+export declare function previewScope(intentFile: string, repoRoot: string, options: {
+    cfg: TickmarkrConfig;
+    adapters: WorkerAdapter[];
+}): ScopePreview;
+export declare function formatScopePreview(preview: ScopePreview): string;
 export declare function scopeIntent(intentFile: string, repoRoot: string, options: ScopeOptions): Promise<ScopeResult>;

package/dist/plan/scope.js

@@ -1,13 +1,16 @@
 import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { basename, dirname, extname, join } from "node:path";
-import { discoverChannels, getAdapter, probeAll } from "../adapters/registry.js";
+import { discoverChannels, getAdapter, probeAll, readDoctor } from "../adapters/registry.js";
 import { compileNative, LEGACY_PREFIX } from "../compile/native.js";
 import { pickDriver } from "../drivers/index.js";
 import { extractJson, runLlm } from "../gates/llm.js";
 import { TaskSchema } from "../graph/schema.js";
 import { route } from "../route/router.js";
 import { scopePrompt } from "./prompt.js";
+// R11/R45 (C10): the drafting loop's hard ceiling — shared by the loop itself and the preview
+// disclosure so the two can never state different budgets.
+export const MAX_SCOPE_ATTEMPTS = 3;
 const HEADING_RE = /^#{1,6}\s+(.+?)\s*$/;
 const ITEM_RE = /^\s*(?:[-*+]\s+|\d+[.)]\s+)(?:\[[ xX]\]\s*)?(?:[QA]\d*:\s*)?(.+?)\s*$/;
 function sectionItems(source, heading) {
@@ -95,7 +98,13 @@ function validateDraft(draft) {
         rmSync(dir, { recursive: true, force: true });
     }
 }
-export async function scopeIntent(intentFile, repoRoot, options) {
+function scopePlanningTask() {
+    return TaskSchema.parse({
+        id: "SCOPE", title: "Draft native spec", goal: "Draft a compiled native spec", shape: "spec", complexity: 7,
+        acceptance: [{ oracle: "judge", text: "Every requirement maps to a task with typed acceptance oracles" }],
+    });
+}
+function localValidate(intentFile) {
     if (!existsSync(intentFile))
         throw new Error(`no such intent file: ${intentFile}`);
     const intent = readFileSync(intentFile, "utf8");
@@ -103,21 +112,92 @@ export async function scopeIntent(intentFile, repoRoot, options) {
     if (unanswered.length) {
         throw new Error(`unanswered blocking questions (${unanswered.length}):\n${unanswered.map((q, i) => `${i + 1}. ${q}`).join("\n")}`);
     }
-    const specFile = specPathForIntent(intentFile);
+    return { intent, specFile: specPathForIntent(intentFile) };
+}
+/**
+ * R11/R45 (C10): local-only disclosure — intent/clarification checks and a candidate read off the
+ * doctor cache, never a fresh probe or a model turn. `readDoctor` and `discoverChannels`/`route` are
+ * pure reads over that cache, so this never touches an adapter.
+ */
+export function previewScope(intentFile, repoRoot, options) {
+    const { specFile } = localValidate(intentFile);
+    const cachedHealth = readDoctor(repoRoot);
+    let candidate;
+    if (cachedHealth) {
+        const channels = discoverChannels(options.cfg, options.adapters, cachedHealth);
+        if (channels.length) {
+            try {
+                const assignment = route(scopePlanningTask(), options.cfg, channels).assignment;
+                // Review fix (finding 1): routing.allowUnverifiedModels lets discoverChannels/route pick a
+                // channel whose modelAuth is simply absent (unknown) — that is routing PERMISSION, not proof
+                // of health. Only disclose a candidate when the doctor cache actually marked this exact model
+                // authed; otherwise this stays the "unknown" case below, never "installed/authed".
+                if (cachedHealth[assignment.adapter]?.modelAuth?.[assignment.model]?.authed === true) {
+                    candidate = { adapter: assignment.adapter, model: assignment.model };
+                }
+            }
+            catch {
+                // no eligible candidate in the cached snapshot — stays unknown, never "unreachable"
+            }
+        }
+    }
+    return {
+        intentFile, specFile, specExists: existsSync(specFile), cached: cachedHealth !== null,
+        candidate, authoringBudget: MAX_SCOPE_ATTEMPTS, probeCalls: options.adapters.length,
+    };
+}
+export function formatScopePreview(preview) {
+    const candidateLine = preview.candidate
+        ? `cached candidate: ${preview.candidate.adapter}:${preview.candidate.model} (installed/authed at last doctor run)`
+        : `cached candidate: unknown (${preview.cached ? "no eligible channel in the doctor cache" : "no doctor cache — run tickmarkr doctor"})`;
+    return [
+        `tickmarkr scope --preview ${preview.intentFile}:`,
+        candidateLine,
+        `output destination: ${preview.specFile}${preview.specExists ? " (exists — active scope needs --force)" : ""}`,
+        `authoring-call budget: up to ${preview.authoringBudget} call${preview.authoringBudget === 1 ? "" : "s"} if confirmed`,
+        `probe calls: ${preview.probeCalls} (disclosed separately — one per configured adapter, only on confirmed active scope)`,
+        "cache policy: read-only; no adapter was probed and no model was called",
+    ].join("\n");
+}
+// R11/R45 (C10 repair): a confirmed candidate is a promise made to the operator — find that exact
+// adapter:model in the freshly probed channels, or fail loud. Never let a stale-cache candidate
+// silently fall through to a fresh route() that could reroute to a different channel unconfirmed.
+function bindCandidate(candidate, channels) {
+    const c = channels.find((ch) => ch.adapter === candidate.adapter && ch.model === candidate.model);
+    if (!c) {
+        throw new Error(`confirmed candidate ${candidate.adapter}:${candidate.model} is no longer available after a fresh probe ` +
+            `(doctor found: ${channels.map((ch) => `${ch.adapter}:${ch.model}`).join(", ") || "(nothing)"}) — ` +
+            "re-run scope --preview and confirm again");
+    }
+    return { adapter: c.adapter, model: c.model, channel: c.channel, tier: c.tier };
+}
+// Adapter-level probes establish the current installation/auth state, but shipped adapters do not
+// return per-model verdicts from probe(). Preserve cached verdicts only where that fresh snapshot is
+// silent; an explicit fresh per-model verdict still wins, as do fresh adapter-level failures.
+function mergeCachedModelAuth(freshHealth, cachedHealth) {
+    if (!cachedHealth)
+        return freshHealth;
+    return Object.fromEntries(Object.entries(freshHealth).map(([adapter, fresh]) => {
+        const cachedModelAuth = cachedHealth[adapter]?.modelAuth;
+        if (!cachedModelAuth)
+            return [adapter, fresh];
+        return [adapter, { ...fresh, modelAuth: { ...cachedModelAuth, ...fresh.modelAuth } }];
+    }));
+}
+export async function scopeIntent(intentFile, repoRoot, options) {
+    const { intent, specFile } = localValidate(intentFile);
     if (existsSync(specFile) && !options.force)
         throw new Error(`${specFile} already exists; pass --force to overwrite it`);
-    const health = await probeAll(options.adapters);
+    const health = mergeCachedModelAuth(await probeAll(options.adapters), readDoctor(repoRoot));
     const channels = discoverChannels(options.cfg, options.adapters, health);
-    const planningTask = TaskSchema.parse({
-        id: "SCOPE", title: "Draft native spec", goal: "Draft a compiled native spec", shape: "spec", complexity: 7,
-        acceptance: [{ oracle: "judge", text: "Every requirement maps to a task with typed acceptance oracles" }],
-    });
-    const assignment = route(planningTask, options.cfg, channels).assignment;
+    const assignment = options.candidate
+        ? bindCandidate(options.candidate, channels)
+        : route(scopePlanningTask(), options.cfg, channels).assignment;
     const adapter = getAdapter(assignment.adapter, options.adapters);
     const driver = options.cfg.visibility.llm === "pane" ? options.driver ?? pickDriver(options.cfg) : undefined;
     const name = basename(specFile, ".spec.md");
     let prompt = scopePrompt(intent);
-    for (let attempts = 1; attempts <= 3; attempts++) {
+    for (let attempts = 1; attempts <= MAX_SCOPE_ATTEMPTS; attempts++) {
         const via = driver ? {
             driver, name: `scope-${name}-${attempts}-${adapter.id}`, label: "SCOPE",
             keep: options.cfg.visibility.keepPanes === "forever",
@@ -129,8 +209,8 @@ export async function scopeIntent(intentFile, repoRoot, options) {
         }
         catch (error) {
             const message = error.message;
-            if (attempts === 3)
-                throw new Error(`scope draft failed after 2 repair retries:\n${message}`);
+            if (attempts === MAX_SCOPE_ATTEMPTS)
+                throw new Error(`scope draft failed after ${MAX_SCOPE_ATTEMPTS - 1} repair retries:\n${message}`);
             prompt = scopePrompt(intent, { draft, error: message });
             continue;
         }

package/dist/report/operator-record.d.ts

@@ -0,0 +1,49 @@
+import type { TokenUsage } from "../adapters/types.js";
+import type { JournalEvent } from "../run/journal.js";
+import type { ChannelCost } from "./cost.js";
+export declare function formatTokenUsage(u: TokenUsage): string;
+export declare function totalTokens(u: TokenUsage): number;
+/** The channel a journal event's `assignment` names, or absent — never coalesced to a placeholder
+ * string here, so a caller decides its own absent-channel reading. */
+export declare function assignmentChannel(data: Record<string, unknown>): string | undefined;
+/** Worker token coverage: "unmetered" when the adapter reported no usage at all — distinct from a
+ * channel with no telemetry row whatsoever, which `labelChannelUsage` below calls "unknown". */
+export declare function formatChannelTokens(row: ChannelCost): string;
+export declare function formatRateBasis(row: ChannelCost): string | undefined;
+/** Nonmeasurable money always says so explicitly (`row.reason`, or "not recorded") — never a $0. */
+export declare function formatChannelMoney(row: ChannelCost): {
+    readonly prices: string[];
+    readonly bases: string[];
+};
+export interface ChannelUsageLabel {
+    readonly channel: string;
+    /** "unmetered" (metered run, adapter reported nothing), a real total, or "unknown" (no telemetry
+     *  row exists for this channel at all — missing metadata, never invented). */
+    readonly tokens: string;
+    /** "not measurable" (metered but unpriced/partial), a real dollar figure, or "unknown" (no row). */
+    readonly money: string;
+}
+/** Labels one channel's metered/priced facts. `row` absent means journal evidence names this
+ *  channel (e.g. a pre-telemetry run) but no telemetry row was ever recorded for it — missing
+ *  metadata, distinct from a recorded-but-unpriced/unmetered row. */
+export declare function labelChannelUsage(channel: string, row: ChannelCost | undefined): ChannelUsageLabel;
+export interface ChannelRoleCounts {
+    readonly channel: string;
+    /** Dispatches recorded for this channel as the task's worker. */
+    readonly worker: number;
+    /** Review gate-results whose reviewer identity resolved to this channel. */
+    readonly review: number;
+    /** Consult verdicts recorded against the task this channel was last dispatched on. */
+    readonly consult: number;
+}
+/** Recorded worker/review/consult appearances per channel, read only from journal evidence — no
+ *  extrapolation to an all-role invoice. A channel that only ever reviewed still gets a row with
+ *  worker:0, never a fabricated dispatch. */
+export declare function channelRoleCounts(events: readonly JournalEvent[]): ChannelRoleCounts[];
+export interface OperatorRecordRow extends ChannelRoleCounts, Omit<ChannelUsageLabel, "channel"> {
+}
+/** The shared record: one row per channel journal evidence actually names (role counts), joined
+ *  with that channel's metered/priced facts. A channel `costs` prices but journal evidence never
+ *  names gets no row here — this never invents a role from cost data alone. */
+export declare function buildOperatorRecord(events: readonly JournalEvent[], costs?: readonly ChannelCost[]): OperatorRecordRow[];
+export declare function formatOperatorRecordRow(row: OperatorRecordRow): string;

package/dist/report/operator-record.js

@@ -0,0 +1,137 @@
+const n = (x) => x.toLocaleString("en-US");
+export function formatTokenUsage(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("  ");
+}
+export function totalTokens(u) {
+    return [u.input, u.output, u.cacheRead, u.cacheWrite, u.reasoning].filter((x) => x !== undefined).reduce((a, b) => a + b, 0);
+}
+/** The channel a journal event's `assignment` names, or absent — never coalesced to a placeholder
+ * string here, so a caller decides its own absent-channel reading. */
+export function assignmentChannel(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;
+}
+/** Worker token coverage: "unmetered" when the adapter reported no usage at all — distinct from a
+ * channel with no telemetry row whatsoever, which `labelChannelUsage` below calls "unknown". */
+export function formatChannelTokens(row) {
+    return row.tokens
+        ? `${row.partialMetering ? "≥ " : ""}${formatTokenUsage(row.tokens)} (${n(totalTokens(row.tokens))} tokens)`
+        : "unmetered";
+}
+export function formatRateBasis(row) {
+    if (!row.rate)
+        return undefined;
+    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}`;
+}
+/** Nonmeasurable money always says so explicitly (`row.reason`, or "not recorded") — never a $0. */
+export function formatChannelMoney(row) {
+    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)}`);
+    const basis = formatRateBasis(row);
+    if (basis)
+        bases.push(basis);
+    if (!prices.length)
+        prices.push("price: not measurable");
+    if (!bases.length)
+        bases.push(row.reason || "not recorded");
+    return { prices, bases };
+}
+/** Labels one channel's metered/priced facts. `row` absent means journal evidence names this
+ *  channel (e.g. a pre-telemetry run) but no telemetry row was ever recorded for it — missing
+ *  metadata, distinct from a recorded-but-unpriced/unmetered row. */
+export function labelChannelUsage(channel, row) {
+    if (!row)
+        return { channel, tokens: "unknown", money: "unknown" };
+    const { prices } = formatChannelMoney(row);
+    return { channel, tokens: formatChannelTokens(row), money: prices.join("; ") };
+}
+const REVIEWER_PATTERN = /reviewer\s+([^\s;()]+:[^\s;()]+)/i;
+function reviewerChannel(data) {
+    if (typeof data.reviewer === "string" && data.reviewer.includes(":"))
+        return data.reviewer;
+    const meta = typeof data.meta === "object" && data.meta !== null ? data.meta : undefined;
+    if (meta && "reviewer" in meta && typeof meta.reviewer === "string" && meta.reviewer.includes(":"))
+        return meta.reviewer;
+    return typeof data.details === "string" ? REVIEWER_PATTERN.exec(data.details)?.[1] : undefined;
+}
+/** The channel a `consult-verdict` event names as ITS OWN consultant identity (daemon.ts always
+ *  appends `adapter`/`model` on every verdict) — never the task's worker dispatch, which is a
+ *  different channel a consult can (and typically does) disagree with. */
+function consultChannel(data) {
+    const { adapter, model } = data;
+    return typeof adapter === "string" && typeof model === "string" ? `${adapter}:${model}` : undefined;
+}
+/** Recorded worker/review/consult appearances per channel, read only from journal evidence — no
+ *  extrapolation to an all-role invoice. A channel that only ever reviewed still gets a row with
+ *  worker:0, never a fabricated dispatch. */
+export function channelRoleCounts(events) {
+    const counts = new Map();
+    const ensure = (channel) => {
+        let row = counts.get(channel);
+        if (!row) {
+            row = { worker: 0, review: 0, consult: 0 };
+            counts.set(channel, row);
+        }
+        return row;
+    };
+    for (const e of events) {
+        if (e.event === "task-dispatch") {
+            const channel = assignmentChannel(e.data);
+            if (channel)
+                ensure(channel).worker++;
+            continue;
+        }
+        if (e.event === "gate-result" && e.data.gate === "review") {
+            const channel = reviewerChannel(e.data);
+            if (channel)
+                ensure(channel).review++;
+            continue;
+        }
+        if (e.event === "review-leg2") {
+            const channel = reviewerChannel(e.data);
+            if (channel)
+                ensure(channel).review++;
+            continue;
+        }
+        if (e.event === "consult-verdict") {
+            const channel = consultChannel(e.data);
+            if (channel)
+                ensure(channel).consult++;
+        }
+    }
+    return [...counts.entries()]
+        .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
+        .map(([channel, role]) => ({ channel, ...role }));
+}
+/** The shared record: one row per channel journal evidence actually names (role counts), joined
+ *  with that channel's metered/priced facts. A channel `costs` prices but journal evidence never
+ *  names gets no row here — this never invents a role from cost data alone. */
+export function buildOperatorRecord(events, costs = []) {
+    const byChannel = new Map(costs.map((c) => [`${c.adapter}:${c.model}`, c]));
+    return channelRoleCounts(events).map((role) => {
+        const usage = labelChannelUsage(role.channel, byChannel.get(role.channel));
+        return { ...role, tokens: usage.tokens, money: usage.money };
+    });
+}
+export function formatOperatorRecordRow(row) {
+    return `${row.channel} — worker: ${row.worker}, review: ${row.review}, consult: ${row.consult}; tokens: ${row.tokens}; money: ${row.money}`;
+}

package/dist/run/daemon.d.ts

@@ -64,10 +64,9 @@ export interface RunSummary {
  */
 export declare function outstandingApprovals(events: JournalEvent[]): string[];
 export declare function formatSummary(s: RunSummary): string;
-/** The narrator's command, bound to THIS run. `status` takes exactly one positional and it is the
- *  run id (cli/commands/status.ts positionalRunId), so naming it here is what stops the board from
- *  following the newest journal in a repo that already carries a second, newer run — a board showing
- *  the wrong run is a recorded incident (skills/tickmarkr-overseer/SKILL.md). */
+/** The narrator enters the production Run cockpit for this exact run. The
+ *  completed static/growing four-hour records precede this default cutover;
+ *  an explicit ID prevents a newer journal from redirecting the owned board. */
 export declare const daemonEntrypoint: string;
 export declare const watchCommand: (runId: string) => string;
 /**