tickmarkr 1.67.0 → 1.68.0

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

@@ -1,5 +1,25 @@
+import { type Task, type TaskStatus } from "../../graph/schema.js";
+import { type JournalEvent } from "../../run/journal.js";
 export type StatusOpts = {
     iterations?: number;
     sleep?: (ms: number) => Promise<void>;
 };
+export declare const GATE_KEYS: {
+    readonly build: "B";
+    readonly test: "T";
+    readonly lint: "L";
+    readonly evidence: "E";
+    readonly scope: "S";
+    readonly acceptance: "A";
+    readonly review: "R";
+};
+export declare const taskBox: (status: TaskStatus) => string;
+export declare const gateBox: (state: "open" | "pass" | "fail" | "skip", unicode: boolean) => string;
+export type GateState = "open" | "pass" | "fail" | "skip";
+export declare const defaultGateStates: (task: Task) => GateState[];
+export declare const gateStates: (task: Task, events: JournalEvent[]) => GateState[];
+export declare const gateChain: (states: GateState[], unicode: boolean) => string;
+export declare const failedGates: (states: GateState[]) => string[];
+export declare const humanGateSuffix: (t: Task, st: TaskStatus, states: GateState[]) => string;
+export declare const shortGoal: (goal: string, max: number) => string;
 export declare function status(argv: string[], cwd?: string, opts?: StatusOpts): Promise<string>;

package/dist/cli/commands/status.js

@@ -9,7 +9,7 @@ const NOT_COMPARABLE_NOTICE = "graph recompiled since this run — task states n
 // The timer must keep the process ALIVE: an unref'd timer here let the event loop drain after the
 // first frame, so a live `--watch` printed once and exited 0 (OBS-11). Never unref this.
 const defaultSleep = (ms) => new Promise((r) => setTimeout(r, ms));
-const GATE_KEYS = { build: "B", test: "T", lint: "L", evidence: "E", scope: "S", acceptance: "A", review: "R" };
+export const GATE_KEYS = { build: "B", test: "T", lint: "L", evidence: "E", scope: "S", acceptance: "A", review: "R" };
 const attemptStartIdx = (events, taskId) => {
     let idx = -1;
     for (let i = 0; i < events.length; i++) {
@@ -21,22 +21,22 @@ const attemptStartIdx = (events, taskId) => {
 };
 const visual = () => process.stdout.isTTY === true && process.env.NO_COLOR === undefined;
 // non-TTY machine surface only — the TTY frame draws task verdicts via statusRow
-const taskBox = (status) => {
+export const taskBox = (status) => {
     if (status === "done")
         return "[x]";
     if (status === "failed" || status === "human")
         return "[!]";
     return "[ ]";
 };
-const gateBox = (state, unicode) => {
+export const gateBox = (state, unicode) => {
     if (unicode) {
         // shared glyph vocabulary: pass/fail verdicts, dash for skip, dim circle for not-yet-run
         return state === "pass" ? GLYPHS.pass : state === "fail" ? GLYPHS.fail : state === "skip" ? GLYPHS.neutral : GLYPHS.toggleInactive;
     }
     return state === "pass" ? "[x]" : state === "fail" ? "[!]" : state === "skip" ? "." : "[ ]";
 };
-const defaultGateStates = (task) => GATE_NAMES.map((gate) => task.gates.includes(gate) ? "open" : "skip");
-const gateStates = (task, events) => {
+export const defaultGateStates = (task) => GATE_NAMES.map((gate) => task.gates.includes(gate) ? "open" : "skip");
+export const gateStates = (task, events) => {
     const outcomes = new Map();
     const start = attemptStartIdx(events, task.id);
     if (start >= 0) {
@@ -57,10 +57,10 @@ const gateStates = (task, events) => {
 const GATE_STATE_TOKEN = { pass: ok, fail, skip: dim, open: dim };
 // TTY cells are bare glyphs in fixed GATE_NAMES order — gate identity lives once in the frame
 // legend, and in words on a failing row; non-TTY keeps the letter+box chips (byte-pinned surface)
-const gateChain = (states, unicode) => GATE_NAMES.map((gate, i) => unicode
+export const gateChain = (states, unicode) => GATE_NAMES.map((gate, i) => unicode
     ? GATE_STATE_TOKEN[states[i]](gateBox(states[i], true))
     : `${GATE_KEYS[gate]}${gateBox(states[i], false)}`).join(" ");
-const failedGates = (states) => GATE_NAMES.filter((_, i) => states[i] === "fail");
+export const failedGates = (states) => GATE_NAMES.filter((_, i) => states[i] === "fail");
 // plain-text form of the failed-gate words for column math; rendered with a dim dot + red names
 const failedSuffix = (states) => {
     const f = failedGates(states);
@@ -70,8 +70,8 @@ const failedSuffix = (states) => {
 // awaited approval is named from task state alone — never from gate results. Failed gates win the
 // cell when present: a post-approval park is not awaiting the designed gate. Plain text for column
 // math; rendered with a dim dot + warn words. TTY-only — the non-TTY surface stays byte-pinned.
-const humanGateSuffix = (t, st, states) => st === "human" && t.humanGate && failedGates(states).length === 0 ? " · awaiting approval" : "";
-const shortGoal = (goal, max) => {
+export const humanGateSuffix = (t, st, states) => st === "human" && t.humanGate && failedGates(states).length === 0 ? " · awaiting approval" : "";
+export const shortGoal = (goal, max) => {
     const clause = goal.split(/[,;.?!]/, 1)[0].trim();
     if (clause.length <= max)
         return clause;

package/dist/run/daemon.js

@@ -4,7 +4,7 @@ import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { stringify } from "yaml";
-import { classifyDeadChannel, trailerPattern, writePrompt } from "../adapters/prompt.js";
+import { classifyDeadChannel, NO_TRAILER_SUMMARY, trailerPattern, UNPARSEABLE_TRAILER_SUMMARY, writePrompt } from "../adapters/prompt.js";
 import { allAdapters, discoverChannels, getAdapter, probeAll, readDoctor } from "../adapters/registry.js";
 import { addUsage, channelKey, matchesTrustDialog, QUOTA_RE } from "../adapters/types.js";
 import { bannerShell, paneDispatchCommand } from "../brand.js";
@@ -658,6 +658,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                 let output;
                 let exitCode;
                 let timedOut = false;
+                let settleParsed;
                 if (interactive) {
                     // v1.2 interactive: the TUI doesn't exit on completion — the trailer is the finish line.
                     // The exit wrapper still fires if the TUI dies (crash/quit): fast-fail instead of burning the timeout.
@@ -748,6 +749,29 @@ export async function runDaemon(repoRoot, opts = {}) {
                         await driver.waitAgentStatus(slot, "idle", 5_000); // settle, then re-harvest the final render
                         output = await driver.read(slot, 1000);
                     }
+                    // T5 / OBS-111: an interactive harvest can race the TUI's final paint. When the pane
+                    // contains the nonce token but the JSON hasn't balanced yet, settle and re-read through
+                    // the existing pane-read seam once or twice before recording a malformed-trailer cause.
+                    if (interactive) {
+                        const stallWindowMs = taskTimeoutMinutes * 60_000;
+                        const settleDeadline = attemptStart + stallWindowMs;
+                        const settleDelayMs = 1_000;
+                        const maxSettleRetries = 2;
+                        let settleTries = 0;
+                        settleParsed = adapter.parse(output, nonce);
+                        while (settleParsed.summary === UNPARSEABLE_TRAILER_SUMMARY && settleTries < maxSettleRetries) {
+                            const remaining = settleDeadline - Date.now();
+                            if (remaining <= 0)
+                                break;
+                            await new Promise((r) => setTimeout(r, Math.min(settleDelayMs, remaining)));
+                            output = await driver.read(slot, 1000);
+                            settleParsed = adapter.parse(output, nonce);
+                            settleTries++;
+                        }
+                        if (settleParsed.summary !== UNPARSEABLE_TRAILER_SUMMARY) {
+                            finished = settleParsed.summary !== NO_TRAILER_SUMMARY;
+                        }
+                    }
                 }
                 else {
                     await driver.run(slot, paneDispatchCommand(dispatchScript));
@@ -800,7 +824,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                     tokens = addUsage(tokens, attemptUsage);
                     metered++;
                 }
-                const result = adapter.parse(output, nonce);
+                const result = settleParsed ?? adapter.parse(output, nonce);
                 const cause = classifyWorkerResultCause({ output, ok: result.ok, finished, exitCode, summary: result.summary, timedOut });
                 journal.append("worker-result", t.id, {
                     ok: result.ok, summary: result.summary, deviations: result.deviations, finished, exitCode,

package/dist/run/git.d.ts

@@ -1,5 +1,7 @@
 import { ROUTING_ENV_SEAMS } from "../route/router.js";
 export { ROUTING_ENV_SEAMS };
+export declare const FORK_CAP_ENV = "VITEST_MAX_FORKS";
+export declare const DEFAULT_FORK_CAP = "6";
 export interface ShResult {
     code: number;
     stdout: string;

package/dist/run/git.js

@@ -5,6 +5,12 @@ import { shq } from "../adapters/types.js";
 import { tickmarkrDir } from "../graph/graph.js";
 import { ROUTING_ENV_SEAMS } from "../route/router.js";
 export { ROUTING_ENV_SEAMS };
+// OBS-110: gate/baseline/tip-verify children are vitest suites; without a fork cap, concurrent
+// full-suite gate runs fork a worker-per-core pool per worktree and saturate the operator box.
+// Default to a modest cap through the environment so vitest honors it natively; never pass it
+// as argv (OBS-55) so child test oracles stay intact. The operator's own export wins.
+export const FORK_CAP_ENV = "VITEST_MAX_FORKS";
+export const DEFAULT_FORK_CAP = "6";
 // stdin "ignore": same class as HARD-05 / SubprocessDriver — never leave an open pipe a child can block on
 // (pi -p / codex exec wait for stdin EOF). timedOut distinguishes SIGKILL-timeout from a real nonzero exit.
 function shell(cmd, cwd, timeoutMs, login) {
@@ -15,6 +21,9 @@ function shell(cmd, cwd, timeoutMs, login) {
     const env = { ...process.env };
     for (const k of ROUTING_ENV_SEAMS)
         delete env[k];
+    // OBS-110: apply the default fork cap only when the operator has not already set one.
+    if (!(FORK_CAP_ENV in env))
+        env[FORK_CAP_ENV] = DEFAULT_FORK_CAP;
     return new Promise((resolve) => {
         // detached: bash gets its own process group so a timeout can kill the whole tree —
         // SIGKILLing bash alone orphans grandchildren (codex/pi) that hold the stdio pipes

package/dist/tui/app.d.ts

@@ -9,6 +9,8 @@ export type View = {
         cols: number;
         rows: number;
     }): string[];
+    /** Optional per-view key handler (e.g. up/down cursor movement). */
+    key?(name: string): void;
 };
 export type StudioOptions = {
     input: InputStream;
@@ -59,6 +61,7 @@ export declare class StudioApp {
     private closeSave;
     private handleRevert;
     private setView;
+    private forwardViewKey;
     private showNotice;
     private paint;
     private buildFrame;

package/dist/tui/app.js

@@ -3,6 +3,7 @@ import { createFleetView } from "./views/fleet-view.js";
 import { createPreviewView } from "./views/preview-view.js";
 import { createProfileView } from "./views/profile-view.js";
 import { createRoutingView } from "./views/routing-view.js";
+import { createRunsView } from "./views/runs-view.js";
 import { renderDiffModal } from "./views/diff-modal.js";
 import { buildSaveProposal, confirmSave } from "./save.js";
 import { FleetStaging } from "./staging.js";
@@ -42,7 +43,7 @@ export class StudioApp {
         this.repoRoot = opts.repoRoot ?? process.cwd();
         this.globalDir = opts.globalDir;
         this.staging = new FleetStaging(opts.loaded ?? emptyFleetEditable());
-        this.views = [createFleetView(), createRoutingView(), createPreviewView(), createProfileView()];
+        this.views = [createFleetView(), createRoutingView(), createPreviewView(), createProfileView(), createRunsView()];
         this.exited = new Promise((resolve) => {
             this.resolveExit = resolve;
         });
@@ -91,6 +92,13 @@ export class StudioApp {
                     this.setView(idx);
             });
         }
+        // per-view navigation
+        for (const name of ["up", "down"]) {
+            this.engine.key(name, () => {
+                if (!this.isModalOpen)
+                    this.forwardViewKey(name);
+            });
+        }
         // help overlay
         this.engine.key("?", () => {
             if (!this.confirmingQuit && !this.showingSave) {
@@ -250,6 +258,10 @@ export class StudioApp {
         this.notice = null;
         this.paint();
     }
+    forwardViewKey(name) {
+        this.views[this.active]?.key?.(name);
+        this.paint();
+    }
     showNotice() {
         this.notice = READONLY_NOTICE;
         this.paint();
@@ -305,7 +317,7 @@ export class StudioApp {
     renderHelp() {
         return [
             "Key bindings",
-            "1-4      switch view",
+            "1-5      switch view",
             "tab      cycle views",
             "?        show this help",
             "esc / q  quit",

package/dist/tui/views/consult-dossier.d.ts

@@ -0,0 +1,49 @@
+import type { ConsultVerdict } from "../../run/consult.js";
+import type { JournalEvent } from "../../run/journal.js";
+/** Placeholder marker surfaced in the Runs detail panel until T2 fills the viewer. */
+export declare const DOSSIER_PLACEHOLDER = "consult dossier viewer \u2014 stub, filled by T2";
+/** Placeholder renderer — returns one dim line. */
+export declare function renderDossierPlaceholder(): string;
+export type ConsultAction = ConsultVerdict["action"];
+/** One recorded consult verdict, with its persisted prompt content injected by the caller. */
+export interface DossierVerdict {
+    action: ConsultAction;
+    reason?: string;
+    notes?: string;
+    guidance?: string;
+    /** Persisted prompt content (the consults/<task>-<n>.md artifact), loaded by the caller. */
+    prompt?: string;
+}
+/** Everything the dossier panel renders — loaded by the caller, never by the render path. */
+export interface ConsultDossierData {
+    taskId: string;
+    /** Verdicts in dispatch order (journal order). */
+    verdicts: DossierVerdict[];
+}
+export interface ConsultDossierPanel {
+    /** Change the selected task. Any selection change invalidates every cached prompt render. */
+    select(data: ConsultDossierData | undefined): void;
+    /** "up"/"down" move the verdict cursor; "enter" toggles the selected verdict's dossier. */
+    key(name: string): void;
+    /** Render the panel body lines (chrome/divider lines are the host view's job). */
+    render(): string[];
+    /** Index of the expanded verdict, or null when collapsed. */
+    readonly expandedIndex: number | null;
+}
+/** Fold one task's consult-verdict journal events into dossier verdicts, in dispatch order.
+ *  Pure function over injected events. opts.prompts carries the persisted prompt contents in
+ *  the same dispatch order (the caller reads the consults/ artifacts); a verdict whose artifact
+ *  was not loaded simply has no prompt. Malformed events are skipped, never fatal. */
+export declare function foldConsultVerdicts(events: JournalEvent[], taskId: string, opts?: {
+    prompts?: string[];
+}): DossierVerdict[];
+/** Translate persisted prompt content into styled terminal lines. Pure. */
+export declare function translatePromptContent(content: string): string[];
+/** A verdict's guidance field is "imperative steps for the worker (newline-separated ok)" —
+ *  already list-shaped, so it renders as a bullet list, never a wall of prose. Pure. */
+export declare function renderGuidanceSteps(guidance: string): string[];
+/** The consult dossier panel. Stateful over injected data: a verdict cursor, at most one
+ *  expanded dossier, and a per-verdict render cache cleared only when the selection changes. */
+export declare function createConsultDossierPanel(initial?: ConsultDossierData, opts?: {
+    translate?: (content: string) => string[];
+}): ConsultDossierPanel;

package/dist/tui/views/consult-dossier.js

@@ -0,0 +1,169 @@
+// T2 (v1.68): consult dossier viewer — the Runs cockpit's detail panel.
+// Lists every consult verdict recorded for the selected task (action + reason, dispatch order)
+// and expands one verdict's persisted prompt content on request. Pure render over INJECTED data:
+// this module never touches the filesystem — the caller folds journal events and loads the
+// consults/ artifacts, then hands both in. The prompt-content translator is a hand-written
+// line-oriented pass over a known narrow subset (headings, blockquotes, bullets, fenced blocks),
+// never a markdown-AST dependency. Rendered prompt lines are cached per verdict and invalidated
+// only on selection change — never re-parsed on repaint (opencode's opentui regression lesson).
+// Read-only by construction: there is no edit or delete path for a dossier or a verdict.
+import { GLYPHS, bold, dim, warn } from "../../brand.js";
+/** Placeholder marker surfaced in the Runs detail panel until T2 fills the viewer. */
+export const DOSSIER_PLACEHOLDER = "consult dossier viewer — stub, filled by T2";
+/** Placeholder renderer — returns one dim line. */
+export function renderDossierPlaceholder() {
+    return `  ${DOSSIER_PLACEHOLDER}`;
+}
+const ACTIONS = ["retry", "reroute", "decompose", "human"];
+/** Fold one task's consult-verdict journal events into dossier verdicts, in dispatch order.
+ *  Pure function over injected events. opts.prompts carries the persisted prompt contents in
+ *  the same dispatch order (the caller reads the consults/ artifacts); a verdict whose artifact
+ *  was not loaded simply has no prompt. Malformed events are skipped, never fatal. */
+export function foldConsultVerdicts(events, taskId, opts = {}) {
+    const verdicts = [];
+    for (const e of events) {
+        if (e.taskId !== taskId || e.event !== "consult-verdict")
+            continue;
+        const d = e.data;
+        if (typeof d.action !== "string" || !ACTIONS.includes(d.action))
+            continue;
+        verdicts.push({
+            action: d.action,
+            ...(typeof d.reason === "string" ? { reason: d.reason } : {}),
+            ...(typeof d.notes === "string" ? { notes: d.notes } : {}),
+            ...(typeof d.guidance === "string" ? { guidance: d.guidance } : {}),
+        });
+    }
+    if (opts.prompts) {
+        for (const [i, prompt] of opts.prompts.entries()) {
+            if (verdicts[i])
+                verdicts[i].prompt = prompt;
+        }
+    }
+    return verdicts;
+}
+// ── prompt-content translator ────────────────────────────────────────────────
+// Hand-written, line-oriented, pure. Known subset only: ATX headings (# = bold, deeper = dim),
+// `> ` blockquotes (dim `│ ` bar prefix), `- `/`* ` bullets (• marker), ``` fenced blocks
+// (dim, indented), everything else passes through plain. No markdown-AST dependency.
+const HEADING_RE = /^(#{1,6})[ \t]+(.*)$/;
+const QUOTE_RE = /^>[ \t]?(.*)$/;
+const BULLET_RE = /^[-*][ \t]+(.*)$/;
+const FENCE_RE = /^\s*```/;
+/** Translate persisted prompt content into styled terminal lines. Pure. */
+export function translatePromptContent(content) {
+    const out = [];
+    let fenced = false;
+    for (const raw of content.split("\n")) {
+        const line = raw.replace(/\s+$/, "");
+        if (FENCE_RE.test(line)) {
+            fenced = !fenced;
+            continue;
+        }
+        if (fenced) {
+            out.push(line.trim() ? dim(`    ${line}`) : "");
+            continue;
+        }
+        const heading = HEADING_RE.exec(line);
+        if (heading) {
+            out.push(heading[1].length === 1 ? bold(heading[2]) : dim(heading[2]));
+            continue;
+        }
+        const quote = QUOTE_RE.exec(line);
+        if (quote) {
+            out.push(dim(`│ ${quote[1]}`));
+            continue;
+        }
+        const bullet = BULLET_RE.exec(line);
+        if (bullet) {
+            out.push(`• ${bullet[1]}`);
+            continue;
+        }
+        out.push(line);
+    }
+    return out;
+}
+/** A verdict's guidance field is "imperative steps for the worker (newline-separated ok)" —
+ *  already list-shaped, so it renders as a bullet list, never a wall of prose. Pure. */
+export function renderGuidanceSteps(guidance) {
+    return guidance
+        .split(/\n+/)
+        .map((s) => s.trim())
+        .filter(Boolean)
+        .map((s) => `• ${s}`);
+}
+/** The consult dossier panel. Stateful over injected data: a verdict cursor, at most one
+ *  expanded dossier, and a per-verdict render cache cleared only when the selection changes. */
+export function createConsultDossierPanel(initial, opts = {}) {
+    const translate = opts.translate ?? translatePromptContent;
+    let data = initial;
+    let cursor = 0;
+    let expanded = null;
+    // Per-verdict cached render of the expanded dossier block — parsed once, reused on every
+    // later expand of the same verdict within the same selection; never re-parsed per repaint.
+    const cache = new Map();
+    const dossierBlock = (verdict, index) => {
+        const hit = cache.get(index);
+        if (hit)
+            return hit;
+        const lines = [];
+        lines.push(dim(`── persisted prompt · consult · ${data?.taskId ?? "?"} · verdict ${index + 1} ──`));
+        if (verdict.prompt !== undefined)
+            lines.push(...translate(verdict.prompt));
+        else
+            lines.push(dim("(no persisted prompt content recorded for this verdict)"));
+        lines.push(`action: ${verdict.action}`);
+        const steps = verdict.guidance ? renderGuidanceSteps(verdict.guidance) : [];
+        if (steps.length > 0) {
+            lines.push("guidance:");
+            for (const s of steps)
+                lines.push(`  ${s}`);
+        }
+        cache.set(index, lines);
+        return lines;
+    };
+    return {
+        get expandedIndex() {
+            return expanded;
+        },
+        select(next) {
+            data = next;
+            cursor = 0;
+            expanded = null;
+            cache.clear();
+        },
+        key(name) {
+            if (!data || data.verdicts.length === 0)
+                return;
+            if (name === "up")
+                cursor = Math.max(cursor - 1, 0);
+            else if (name === "down")
+                cursor = Math.min(cursor + 1, data.verdicts.length - 1);
+            else if (name === "enter")
+                expanded = expanded === cursor ? null : cursor;
+        },
+        render() {
+            if (!data)
+                return [];
+            if (data.verdicts.length === 0) {
+                return [
+                    `  no consult verdicts recorded for ${data.taskId} — every attempt finished without needing a consult.`,
+                ];
+            }
+            const lines = [];
+            data.verdicts.forEach((verdict, i) => {
+                const pointer = i === cursor ? `${GLYPHS.pointer} ` : "  ";
+                // Consult actions are not pass/fail: human → warn (needs the operator), the rest plain.
+                const actionWord = verdict.action === "human" ? warn(verdict.action) : verdict.action;
+                const reason = verdict.reason ?? verdict.notes;
+                const hint = dim(i === expanded ? "[enter: collapse]" : "[enter: expand]");
+                lines.push(`  ${pointer}${i + 1}. ${actionWord}${reason ? ` — ${reason}` : ""}  ${hint}`);
+                if (i === expanded) {
+                    for (const l of dossierBlock(verdict, i))
+                        lines.push(`     ${l}`);
+                }
+            });
+            return lines;
+        },
+    };
+}

package/dist/tui/views/runs-view.d.ts

@@ -0,0 +1,70 @@
+import { type RunGraph, type Task, type TaskStatus } from "../../graph/schema.js";
+import { type JournalEvent, type TelemetryRow, type WorkerResultCause } from "../../run/journal.js";
+import { type GateState } from "../../cli/commands/status.js";
+import type { View } from "../app.js";
+export type AttemptRecord = {
+    attempt: number;
+    channel: string;
+    outcome: "clean" | "failed" | "in-flight" | "aborted";
+    /** typed worker-result failure reason when the attempt did not finish cleanly */
+    cause?: WorkerResultCause;
+    /** worker-result summary or consult-verdict reason, when present */
+    note?: string;
+};
+export type RunsTask = {
+    task: Task;
+    status: TaskStatus;
+    states: GateState[];
+    channel: string;
+    ctx?: number;
+    activity?: string;
+    attempts: AttemptRecord[];
+};
+/** Everything the Runs cockpit renders — loaded by the caller, never by the render path. */
+export type RunsViewData = {
+    runId?: string;
+    events: JournalEvent[];
+    graph: RunGraph;
+    /** Whether the journal is comparable with the loaded graph. Defaults to true. */
+    comparable?: boolean;
+    /** Per-tier per-task pricing from config, rendered ONLY through the shared costSignal formatter. */
+    pricing?: Record<string, number>;
+    /** This run's observed usage rows (telemetry.jsonl), folded per channel by the cost ticker. */
+    telemetry?: TelemetryRow[];
+};
+/** Options for creating a Runs view. Backward-compatible: plain `createRunsView(data)` still works. */
+export type RunsViewOptions = {
+    data?: RunsViewData;
+    repoRoot?: string;
+    /** Notify the caller of a single-line notice change (confirmation, refusal, progress, result). */
+    onNotice?: (message: string | null) => void;
+    /** Refresh injected data after a mutation. Called after a successful approval. */
+    reload?: () => RunsViewData | Promise<RunsViewData>;
+};
+export type RunsView = View & {
+    /** Handle a decoded key name ("up" | "down" | "a" | "y"). */
+    key(name: string): void;
+    /** Index of the cursor in the task list. */
+    cursor: number;
+    /** The currently selected task, if any. */
+    selectedTask(): RunsTask | undefined;
+    /** Promise of an in-flight approval, exposed for tests. */
+    approval?: Promise<void>;
+};
+/** Build the injected raw data into task rows. Pure function, no filesystem access. */
+export declare function foldRunsTasks(data: RunsViewData): RunsTask[];
+export type CostTickerRow = {
+    /** adapter:model */
+    key: string;
+    /** verbatim output of the shared cost-signal formatter */
+    signal: string;
+    /** distinct tasks dispatched on this channel */
+    tasks: number;
+    /** summed observed token usage for this channel; undefined when nothing was metered */
+    tokens?: number;
+};
+/** Sum observed token usage per channel for the loaded run. Dispatch events name the channel's
+ *  full assignment (billing channel + tier); telemetry rows contribute the metered tokens. A
+ *  telemetry-only channel degrades costSignal to "api metered" — never an invented price. */
+export declare function foldCostTicker(data: RunsViewData): CostTickerRow[];
+export declare function createRunsView(data?: RunsViewData, opts?: Omit<RunsViewOptions, "data">): RunsView;

package/dist/tui/views/runs-view.js

@@ -0,0 +1,387 @@
+// T1 (v1.68): Runs cockpit — journal timeline, per-task gate ladder, attempt history.
+// Pure render over INJECTED data: this module never touches the filesystem. The caller hands in
+// a journal event list and a compiled graph; the view folds them into task cards and a dispatch-
+// ordered attempt history itself. The task card language and gate ladder reuse the existing status
+// command helpers verbatim rather than reimplementing them.
+import { GLYPHS, dim, fail, legend, ok, statusRow, warn } from "../../brand.js";
+import { channelKey } from "../../adapters/types.js";
+import { GATE_NAMES, } from "../../graph/schema.js";
+import { foldActivity } from "../../run/activity.js";
+import { formatJournalNarration } from "../../run/journal.js";
+import { costSignal } from "../../cli/commands/fleet-picker.js";
+import { approve } from "../../cli/commands/approve.js";
+import { gateChain, gateStates, defaultGateStates, humanGateSuffix, shortGoal, failedGates, } from "../../cli/commands/status.js";
+import { renderDossierPlaceholder } from "./consult-dossier.js";
+const channelOf = (assignment) => {
+    const a = assignment;
+    return typeof a?.adapter === "string" && typeof a.model === "string" ? `${a.adapter}:${a.model}` : "unknown channel";
+};
+const taskVerdict = (st) => st === "done" ? "pass" : st === "failed" ? "fail" : st === "human" ? "warn" : "neutral";
+/** Local replay of task statuses from events only — mirrors Journal.replayStatuses but keeps the
+ *  view filesystem-free. */
+function replayStatuses(events) {
+    const s = new Map();
+    for (const e of events) {
+        if (!e.taskId)
+            continue;
+        if (e.event === "task-dispatch")
+            s.set(e.taskId, "running");
+        else if (e.event === "task-done")
+            s.set(e.taskId, "done");
+        else if (e.event === "task-failed")
+            s.set(e.taskId, "failed");
+        else if (e.event === "task-human")
+            s.set(e.taskId, "human");
+        else if (e.event === "task-approved")
+            s.set(e.taskId, "pending");
+    }
+    for (const [id, st] of s)
+        if (st === "running")
+            s.set(id, "pending");
+    return s;
+}
+/** Fold one task's dispatch-ordered attempt history. Each task-dispatch opens an attempt; a
+ *  worker-result sets the attempt's outcome; task-done/task-failed/task-approved finish it. A new
+ *  dispatch while the previous attempt is still in-flight marks it aborted. */
+function foldAttempts(events, taskId) {
+    const attempts = [];
+    let open;
+    const finish = () => {
+        if (open) {
+            attempts.push(open);
+            open = undefined;
+        }
+    };
+    for (const e of events) {
+        if (e.taskId !== taskId)
+            continue;
+        if (e.event === "task-dispatch" || e.event === "escalation") {
+            if (open) {
+                if (open.outcome === "in-flight")
+                    open.outcome = "aborted";
+                finish();
+            }
+            const attempt = (Number.isInteger(e.data.attempt) ? e.data.attempt : 0) + 1;
+            open = { attempt, channel: channelOf(e.data.assignment), outcome: "in-flight" };
+        }
+        else if (e.event === "worker-result" && open) {
+            const ok = e.data.ok === true;
+            const finished = e.data.finished === true;
+            if (ok && finished) {
+                open.outcome = "clean";
+            }
+            else {
+                open.outcome = "failed";
+                open.cause = e.data.cause ?? undefined;
+                open.note = typeof e.data.summary === "string" ? e.data.summary : undefined;
+            }
+        }
+        else if (e.event === "task-done" || e.event === "task-approved") {
+            if (open && open.outcome === "in-flight")
+                open.outcome = "clean";
+            finish();
+        }
+        else if (e.event === "task-failed") {
+            if (open && open.outcome === "in-flight")
+                open.outcome = "failed";
+            finish();
+        }
+    }
+    finish();
+    return attempts;
+}
+/** Build the injected raw data into task rows. Pure function, no filesystem access. */
+export function foldRunsTasks(data) {
+    const { events, graph, comparable = true } = data;
+    const statuses = replayStatuses(events);
+    const assignments = new Map();
+    const contexts = new Map();
+    for (const e of events) {
+        if (e.event === "task-dispatch" && e.taskId) {
+            assignments.set(e.taskId, channelOf(e.data.assignment));
+        }
+        if (e.event === "context-sample" && e.taskId && typeof e.data.tokens === "number" && Number.isFinite(e.data.tokens)) {
+            contexts.set(e.taskId, e.data.tokens);
+        }
+    }
+    const activityTasks = graph.tasks.map((t) => ({
+        id: t.id,
+        gates: t.gates,
+        deps: t.deps,
+        status: statuses.get(t.id) ?? t.status,
+    }));
+    const activity = foldActivity(comparable ? events : [], activityTasks);
+    return graph.tasks.map((t) => {
+        const status = statuses.get(t.id) ?? t.status;
+        const states = comparable ? gateStates(t, events) : defaultGateStates(t);
+        const channel = assignments.get(t.id) ?? "-";
+        return {
+            task: t,
+            status,
+            states,
+            channel,
+            ctx: contexts.get(t.id),
+            activity: activity.cells.get(t.id),
+            attempts: foldAttempts(events, t.id),
+        };
+    });
+}
+const CARD_LINES = 3; // 2 content lines + 1 blank separator
+const usageTotal = (u) => u.input + u.output + (u.cacheRead ?? 0) + (u.cacheWrite ?? 0) + (u.reasoning ?? 0);
+/** Sum observed token usage per channel for the loaded run. Dispatch events name the channel's
+ *  full assignment (billing channel + tier); telemetry rows contribute the metered tokens. A
+ *  telemetry-only channel degrades costSignal to "api metered" — never an invented price. */
+export function foldCostTicker(data) {
+    const pricing = data.pricing ?? {};
+    const rows = new Map();
+    const rowFor = (key) => {
+        let r = rows.get(key);
+        if (!r) {
+            r = { tasks: new Set(), tokens: 0, metered: false };
+            rows.set(key, r);
+        }
+        return r;
+    };
+    for (const e of data.events) {
+        if (e.event !== "task-dispatch" || !e.taskId)
+            continue;
+        const a = e.data.assignment;
+        if (!a || typeof a.adapter !== "string" || typeof a.model !== "string")
+            continue;
+        const r = rowFor(channelKey(a));
+        r.tasks.add(e.taskId);
+        if ((a.channel === "sub" || a.channel === "api") && typeof a.tier === "string")
+            r.assignment = a;
+    }
+    for (const t of data.telemetry ?? []) {
+        const r = rowFor(channelKey(t));
+        if (t.tokens) {
+            r.tokens += usageTotal(t.tokens);
+            r.metered = true;
+        }
+        if (!r.assignment && (t.channel === "sub" || t.channel === "api")) {
+            r.assignment = { adapter: t.adapter, model: t.model, channel: t.channel, tier: "" };
+        }
+    }
+    return [...rows.entries()].map(([key, r]) => ({
+        key,
+        signal: r.assignment ? costSignal(r.assignment, pricing) : "channel unknown",
+        tasks: r.tasks.size,
+        tokens: r.metered ? r.tokens : undefined,
+    }));
+}
+/** Last tip-verify event wins; none recorded yet ⇒ pending — never a false pass or fail. */
+function tipVerifyState(events) {
+    for (let i = events.length - 1; i >= 0; i--) {
+        const e = events[i];
+        if (e.event === "tip-verify" || e.event === "tip-verify-failed") {
+            return {
+                state: e.event === "tip-verify" ? "passed" : "failed",
+                gate: typeof e.data.gate === "string" ? e.data.gate : undefined,
+            };
+        }
+    }
+    return { state: "pending" };
+}
+function tipVerifyLine(events) {
+    const tip = tipVerifyState(events);
+    const word = tip.state === "passed" ? ok("passed") : tip.state === "failed" ? fail("failed") : dim("pending");
+    return legend(`   tip-verify: ${tip.gate ? `${tip.gate} ` : ""}`) + word;
+}
+/** Cost values stay plain (CLI-DESIGN "data plain"): costSignal's output verbatim, never colorized. */
+function costTickerPanel(data) {
+    const rows = foldCostTicker(data);
+    const lines = ["", dim("── cost ticker ──")];
+    if (rows.length === 0) {
+        lines.push("  no channel usage observed yet");
+        return lines;
+    }
+    const keyW = Math.max(...rows.map((r) => r.key.length));
+    for (const r of rows) {
+        const parts = [r.signal, `${r.tasks} task${r.tasks === 1 ? "" : "s"}`];
+        if (r.tokens !== undefined)
+            parts.push(`${r.tokens} tokens`);
+        lines.push(`  ${r.key.padEnd(keyW)}  ${parts.join(" · ")}`);
+    }
+    return lines;
+}
+export function createRunsView(data, opts) {
+    let currentData = data;
+    let tasks = currentData ? foldRunsTasks(currentData) : [];
+    let cursor = 0;
+    let confirming = null;
+    let notice = null;
+    let busy = false;
+    let approvalPromise;
+    const repoRoot = opts?.repoRoot;
+    const onNotice = opts?.onNotice ?? (() => { });
+    const reload = opts?.reload;
+    const setNotice = (message) => {
+        notice = message;
+        onNotice(message);
+    };
+    const refresh = async () => {
+        if (!reload)
+            return;
+        currentData = await reload();
+        tasks = currentData ? foldRunsTasks(currentData) : [];
+    };
+    const runApprove = async (taskId) => {
+        if (!repoRoot || !currentData?.runId) {
+            setNotice("approval not available — no run loaded");
+            return;
+        }
+        busy = true;
+        setNotice("approving…");
+        try {
+            const message = await approve([currentData.runId, taskId], repoRoot);
+            await refresh();
+            setNotice(message);
+        }
+        catch (e) {
+            setNotice(e instanceof Error ? e.message : String(e));
+        }
+        finally {
+            busy = false;
+            approvalPromise = undefined;
+        }
+    };
+    const view = {
+        id: "runs",
+        label: "Runs",
+        cursor: 0,
+        key(name) {
+            if (busy)
+                return;
+            if (confirming) {
+                const taskId = confirming.taskId;
+                confirming = null;
+                if (name === "y") {
+                    approvalPromise = runApprove(taskId);
+                    return;
+                }
+                setNotice("approval cancelled");
+                return;
+            }
+            if (!tasks.length)
+                return;
+            if (name === "up")
+                cursor = Math.max(cursor - 1, 0);
+            else if (name === "down")
+                cursor = Math.min(cursor + 1, tasks.length - 1);
+            else if (name === "a") {
+                if (!repoRoot || !currentData?.runId) {
+                    setNotice("approval not available — no run loaded");
+                    return;
+                }
+                const task = tasks[cursor];
+                if (!task)
+                    return;
+                if (task.status === "human") {
+                    confirming = { taskId: task.task.id };
+                    setNotice(`approve ${task.task.id}? releases the parked human gate and resumes the run.   [y] confirm   [any key] cancel`);
+                    return;
+                }
+                approvalPromise = runApprove(task.task.id);
+            }
+            this.cursor = cursor;
+        },
+        selectedTask() {
+            return tasks[cursor];
+        },
+        render(props) {
+            if (!currentData || !currentData.runId) {
+                return emptyState();
+            }
+            const last = currentData.events.at(-1);
+            const now = last ? formatJournalNarration(last) : undefined;
+            const lines = [];
+            if (now)
+                lines.push(legend(`   now: ${now}`));
+            else
+                lines.push(legend("   now: —"));
+            lines.push(tipVerifyLine(currentData.events));
+            lines.push(legend(`   gates: ${GATE_NAMES.join(" · ")}`));
+            lines.push("");
+            const { rows } = props;
+            const ticker = costTickerPanel(currentData);
+            // Reserve space for: now, tip-verify, gates legend, blank, detail panel (blank + divider +
+            // content + attempts), cost ticker panel, optional notice line, trailing blank
+            const detailReserve = 6 + ticker.length + (notice ? 1 : 0);
+            const cardBudget = Math.max(0, rows - lines.length - detailReserve);
+            const visibleCount = Math.max(1, Math.floor(cardBudget / CARD_LINES));
+            const maxStart = Math.max(0, tasks.length - visibleCount);
+            let start = cursor - Math.floor(visibleCount / 2);
+            if (start < 0)
+                start = 0;
+            if (start > maxStart)
+                start = maxStart;
+            const end = Math.min(tasks.length, start + visibleCount);
+            const width = Math.min(props.cols, 100);
+            const idW = Math.max(2, ...tasks.map((c) => c.task.id.length));
+            const goalAvail = Math.max(8, width - (idW + 12));
+            const goals = tasks.map((c) => shortGoal(c.task.goal, goalAvail));
+            const goalW = Math.max(8, ...goals.map((s) => s.length));
+            const indent = " ".repeat(idW + 5);
+            for (let i = start; i < end; i++) {
+                const t = tasks[i];
+                const goal = goals[i];
+                const pointer = i === cursor ? `${GLYPHS.pointer} ` : "  ";
+                const f = failedGates(t.states);
+                const human = humanGateSuffix(t.task, t.status, t.states);
+                const statusCell = renderStatusCell(t.status, f, human);
+                const line1 = `  ${pointer}${statusRow(taskVerdict(t.status), `${t.task.id.padEnd(idW)} ${goal.padEnd(goalW)}  ${statusCell}`)}`;
+                const detailParts = [t.activity ?? t.channel];
+                if (t.ctx !== undefined)
+                    detailParts.push(`ctx ${t.ctx}`);
+                const line2 = `${indent}${gateChain(t.states, true)}  ${dim(detailParts.join(" · "))}`;
+                lines.push(line1, line2, "");
+            }
+            lines.push(...detailPanel(tasks[cursor]));
+            lines.push(...ticker);
+            if (notice)
+                lines.push(legend(`   ${notice}`));
+            return lines;
+        },
+    };
+    Object.defineProperty(view, "approval", {
+        get: () => approvalPromise,
+        configurable: true,
+    });
+    return view;
+}
+function renderStatusCell(status, failed, human) {
+    const stWord = status === "done" ? ok(String(status))
+        : status === "failed" ? fail(String(status))
+            : status === "human" ? warn(String(status))
+                : String(status);
+    const dot = dim(" · ");
+    return stWord +
+        (failed.length ? dot + fail(failed.join(", ")) : "") +
+        (human ? dot + warn("awaiting approval") : "");
+}
+function detailPanel(task) {
+    if (!task)
+        return [];
+    const lines = ["", dim(`── ${task.task.id} — attempts & consult dossier ──`)];
+    if (task.attempts.length === 0) {
+        lines.push(`  no attempts recorded for ${task.task.id}`);
+        return lines;
+    }
+    for (const a of task.attempts) {
+        const reason = a.cause ? ` — ${a.cause}` : a.note ? ` — ${a.note}` : "";
+        const statusWord = a.outcome === "clean" ? "done" : a.outcome === "failed" ? "failed" : "in flight";
+        lines.push(`  attempt ${a.attempt}  ${a.channel}  ${statusWord}${reason}`);
+    }
+    lines.push("");
+    lines.push(dim(renderDossierPlaceholder()));
+    return lines;
+}
+function emptyState() {
+    return [
+        "",
+        "  no run loaded — run `tickmarkr run` or `tickmarkr resume <runId>` to start one.",
+        "  the Runs cockpit reads the active or most recent run's journal; nothing to show yet.",
+        "",
+    ];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tickmarkr",
-  "version": "1.67.0",
+  "version": "1.68.0",
   "description": "Spec in, verified work out.",
   "type": "module",
   "license": "MIT",