tickmarkr 1.66.0 → 1.68.0

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

@@ -1,7 +1,8 @@
 import { channelsFromConfig } from "../../adapters/types.js";
 import { candidateRow, shapeCandidates } from "../../cli/commands/fleet-picker.js";
-import { INTEGRITY_FLOOR_SHAPES, loadConfigWithMode, } from "../../config/config.js";
+import { DEFAULT_CONFIG, fleetEditableFromConfig, INTEGRITY_FLOOR_SHAPES, loadConfigWithMode, ROUTING_MODES, TIER_RANK, } from "../../config/config.js";
 import { SHAPES } from "../../graph/schema.js";
+import { FleetStaging } from "../staging.js";
 // Same preview task fleet.ts's picker ranks (one per shape, complexity 3): the inspector must
 // rank the exact inputs the fleet editor ranks, or the two surfaces could disagree.
 export function routingPreviewTask(shape) {
@@ -22,6 +23,43 @@ export function routingPreviewTask(shape) {
     };
 }
 const isIntegrity = (shape) => INTEGRITY_FLOOR_SHAPES.includes(shape);
+// Staged-cell glyph — the same ● the shell status bar counts staged changes with (app.ts).
+const STAGED_MARK = "●";
+const lowerTier = (t) => (t === "frontier" ? "mid" : "cheap");
+const maxTier = (a, b) => (TIER_RANK[a] >= TIER_RANK[b] ? a : b);
+// config.ts presetFloor mirrored (module-private there): a mode compiles into floors at load,
+// so staging a mode stages exactly this table.
+function presetFloor(mode, shape) {
+    const dflt = DEFAULT_CONFIG.routing.floors[shape] ?? "cheap";
+    if (mode === "partner-led")
+        return "frontier";
+    if (mode === "staff-led")
+        return maxTier(lowerTier(dflt), isIntegrity(shape) ? "frontier" : "cheap");
+    return dflt;
+}
+function floorsEqual(a, b) {
+    const keys = new Set([...Object.keys(a), ...Object.keys(b)]);
+    for (const k of keys)
+        if (a[k] !== b[k])
+            return false;
+    return true;
+}
+/** The header mode is DERIVED from the buffer, never stored: clean floors show the loaded mode;
+ *  floors matching a preset show that mode (staged); anything else reads "custom". */
+function deriveMode(loadedMode, loaded, buffer) {
+    if (floorsEqual(loaded.floors, buffer.floors))
+        return { mode: loadedMode, staged: false };
+    for (const mode of ROUTING_MODES) {
+        if (SHAPES.every((s) => buffer.floors[s] === presetFloor(mode, s)))
+            return { mode, staged: true };
+    }
+    return { mode: "custom", staged: true };
+}
+/** The config the router would see with the staged policy applied: map + floors ride the buffer
+ *  (deny/tier edits are the fleet view's lane, T3). The buffer snapshot is already detached. */
+function effectiveConfig(cfg, buffer) {
+    return { ...cfg, routing: { ...cfg.routing, map: buffer.map, floors: buffer.floors } };
+}
 // No-arg shell path (app.ts constructs views without deps): load the operator's resolved config
 // and derive channels from the configured tier table. Best-effort — a load failure degrades the
 // view to an explanatory note instead of breaking the studio.
@@ -37,60 +75,158 @@ function loadDefaultData(repoRoot) {
 }
 export function createRoutingView(deps = {}) {
     const data = deps.data ?? loadDefaultData(deps.repoRoot ?? process.cwd());
+    // The one edit authority: every mutating method below is a staging.apply()/revert() over this
+    // buffer, so a staged change can never hide in private view state.
+    const staging = deps.staging ??
+        new FleetStaging(data ? fleetEditableFromConfig(data.cfg) : { denyAdapters: [], denyModels: [], tiers: {}, map: {}, floors: {} });
     let cursor = 0;
     let inspector = null;
+    const rankInspector = (shape) => {
+        if (!data)
+            return [];
+        // THE parity seam: rank through the same shared picker glue the fleet editor uses — no
+        // comparator lives here. Clean buffer ⇒ the injected config by reference (the delegation
+        // tests pin that identity); staged edits ⇒ the effective config, what the router would
+        // choose given the staged inputs.
+        const cfgNow = staging.isDirty ? effectiveConfig(data.cfg, staging.current) : data.cfg;
+        return shapeCandidates(routingPreviewTask(shape), cfgNow, data.channels, data.profile);
+    };
+    const rowOf = (c) => candidateRow(c, data?.cfg.pricing ?? {});
+    // Re-rank the open inspector after a staging mutation changed the ranking inputs.
+    const refreshInspector = () => {
+        if (!inspector)
+            return;
+        inspector.ranked = rankInspector(inspector.shape);
+        inspector.cursor = Math.min(inspector.cursor, Math.max(inspector.ranked.length - 1, 0));
+    };
     return {
         id: "routing",
         label: "Routing",
         get selectedShape() {
             return SHAPES[cursor];
         },
+        get selectedMode() {
+            const loadedMode = data?.mode ?? data?.cfg.routing.mode ?? "risk-based";
+            return deriveMode(loadedMode, staging.loadedState, staging.current).mode;
+        },
+        get staging() {
+            return staging;
+        },
         moveCursor(delta) {
             cursor = (cursor + delta + SHAPES.length) % SHAPES.length;
         },
+        moveInspectorCursor(delta) {
+            if (!inspector || inspector.ranked.length === 0)
+                return;
+            const n = inspector.ranked.length;
+            inspector.cursor = (inspector.cursor + delta + n) % n;
+        },
         openInspector(shape) {
             if (!data)
                 return;
             const target = shape ?? SHAPES[cursor];
-            // THE parity seam: rank through the same shared picker glue the fleet editor uses — no
-            // comparator lives here — so rows, cost signals, and provenance match the router's choice.
-            const ranked = shapeCandidates(routingPreviewTask(target), data.cfg, data.channels, data.profile);
-            inspector = { shape: target, rows: ranked.map((c) => candidateRow(c, data.cfg.pricing)) };
+            inspector = { shape: target, cursor: 0, ranked: rankInspector(target) };
         },
         closeInspector() {
             inspector = null;
         },
+        stageInspectorPin() {
+            if (!data || !inspector)
+                return;
+            const target = inspector.shape;
+            const chosen = inspector.ranked[inspector.cursor];
+            if (!chosen)
+                return;
+            const { adapter, model } = chosen.assignment;
+            staging.apply((buffer) => {
+                buffer.map[target] = { ...buffer.map[target], pin: { via: adapter, model } };
+            });
+            // No re-rank: shapeCandidates strips the shape's own pin from the ranking inputs.
+        },
+        stageFloor(tier) {
+            if (!data)
+                return;
+            const target = SHAPES[cursor];
+            staging.apply((buffer) => {
+                buffer.floors[target] = tier;
+            });
+            refreshInspector();
+        },
+        stagePrefer(chain) {
+            if (!data)
+                return;
+            const target = SHAPES[cursor];
+            staging.apply((buffer) => {
+                const entry = { ...buffer.map[target] };
+                if (chain.length)
+                    entry.prefer = [...chain];
+                else
+                    delete entry.prefer;
+                // an emptied entry leaves no phantom delta behind
+                if (Object.keys(entry).length)
+                    buffer.map[target] = entry;
+                else
+                    delete buffer.map[target];
+            });
+            refreshInspector();
+        },
+        stageMode(mode) {
+            if (!data)
+                return;
+            staging.apply((buffer) => {
+                for (const shape of SHAPES)
+                    buffer.floors[shape] = presetFloor(mode, shape);
+            });
+            refreshInspector();
+        },
+        revert() {
+            staging.revert();
+            refreshInspector();
+        },
         inspectorRows() {
-            return inspector ? [...inspector.rows] : null;
+            return inspector ? inspector.ranked.map(rowOf) : null;
         },
         render: () => {
-            const lines = ["Routing view — per-shape policy grid (read-only)"];
+            const lines = ["Routing view — per-shape policy grid"];
             if (!data) {
                 lines.push("routing data unavailable — see `tickmarkr fleet --print` for the line-mode surface");
                 return lines;
             }
             const { cfg } = data;
-            const mode = data.mode ?? cfg.routing.mode ?? "risk-based";
-            lines.push(`mode: ${mode}`);
+            const buffer = staging.current;
+            const loaded = staging.loadedState;
+            const loadedMode = data.mode ?? cfg.routing.mode ?? "risk-based";
+            const { mode, staged: modeStaged } = deriveMode(loadedMode, loaded, buffer);
+            lines.push(`mode: ${mode}${modeStaged ? ` ${STAGED_MARK} (staged)` : ""}`);
             lines.push(`  ${"shape".padEnd(10)}${"floor".padEnd(10)}${"pin".padEnd(20)}prefer`);
             for (const [i, shape] of SHAPES.entries()) {
-                const entry = cfg.routing.map[shape];
-                const floor = cfg.routing.floors[shape] ?? "—";
+                const entry = buffer.map[shape];
+                const loadedEntry = loaded.map[shape];
+                const floor = buffer.floors[shape] ?? "—";
+                const floorStaged = loaded.floors[shape] !== buffer.floors[shape];
                 const marker = isIntegrity(shape) ? "*" : "";
                 const pin = entry?.pin ? `${entry.pin.via}:${entry.pin.model}` : "—";
                 const prefer = entry?.prefer?.length ? entry.prefer.join(", ") : "—";
+                const pinStaged = JSON.stringify(loadedEntry?.pin ?? null) !== JSON.stringify(entry?.pin ?? null);
+                const preferStaged = JSON.stringify(loadedEntry?.prefer ?? null) !== JSON.stringify(entry?.prefer ?? null);
                 const sel = i === cursor ? "❯" : " ";
-                lines.push(`${sel} ${shape.padEnd(10)}${`${floor}${marker}`.padEnd(10)}${pin.padEnd(20)}${prefer}`);
+                const floorCell = `${floor}${marker}${floorStaged ? STAGED_MARK : ""}`.padEnd(10);
+                const pinCell = `${pin}${pinStaged ? STAGED_MARK : ""}`.padEnd(20);
+                const preferCell = `${prefer}${preferStaged ? STAGED_MARK : ""}`;
+                lines.push(`${sel} ${shape.padEnd(10)}${floorCell}${pinCell}${preferCell}`);
             }
             lines.push("* integrity set: never below frontier");
-            lines.push(`pick: ${SHAPES[cursor]} — enter opens the candidate inspector (read-only)`);
+            if (staging.isDirty)
+                lines.push(`${STAGED_MARK} staged — not saved`);
+            lines.push(`pick: ${SHAPES[cursor]} — enter opens the candidate inspector`);
             if (inspector) {
                 lines.push(`─ candidates: ${inspector.shape} — the fleet picker ranking for the same inputs ──`);
-                if (inspector.rows.length === 0)
+                if (inspector.ranked.length === 0)
                     lines.push("  (no routable candidates)");
-                for (const [j, row] of inspector.rows.entries()) {
-                    lines.push(`${j === 0 ? "❯ " : "  "}${row}`);
+                for (const [j, c] of inspector.ranked.entries()) {
+                    lines.push(`${j === inspector.cursor ? "❯ " : "  "}${rowOf(c)}`);
                 }
+                lines.push("select stages the highlighted candidate as this shape's pin");
             }
             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.",
+        "",
+    ];
+}