tickmarkr 1.87.0 → 1.90.0

package/dist/cli/commands/status.js

@@ -1,18 +1,27 @@
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { BANNER, GLYPHS, dim, fail, legend, ok, rule, statusRow, title, warn } from "../../brand.js";
+import { DEFAULT_CONFIG, loadConfig } from "../../config/config.js";
 import { HerdrDriver } from "../../drivers/herdr.js";
-import { formatOwnedName, } from "../../drivers/types.js";
+import { formatOwnedName, parseOwnedName, } from "../../drivers/types.js";
 import { blockedTasks, graphDefinitionHash, loadGraph, stateDirName } from "../../graph/graph.js";
 import { GATE_NAMES } from "../../graph/schema.js";
 import { foldActivity } from "../../run/activity.js";
 import { Journal, engagementComparable, isQualityFailureParkKind, recordedTaskFailureKind, runHasEnded, } from "../../run/journal.js";
+import { desiredPanes } from "../../run/reconcile.js";
 import { normalizeStallSnapshot } from "../../run/stall.js";
+import { readSupervision, supervisionText } from "../../run/supervision.js";
 import { deriveRunCockpitData, } from "../../tui/cockpit/derive.js";
-import { cellWidth, fitCells } from "../../tui/cockpit/width.js";
+import { COCKPIT_COLUMN_FLOOR, LAYOUT_PRIORITY } from "../../tui/cockpit/layout.js";
+import { cellWidth, fitCells, wrapCells } from "../../tui/cockpit/width.js";
 // ponytail: fixed 2s refresh; promote to config.visibility.* only when an operator asks.
 const REFRESH_MS = 2000;
-const NOT_COMPARABLE_NOTICE = "graph recompiled since this run — task states not comparable; resume with `--graph-changed` to audit this recompile";
+// The claim leads, the guidance follows: an incomparable journal is named in three words a wrapped
+// board keeps on one row, and the remedy trails it. Both surfaces state the claim; nothing derived
+// from such a journal — task states, gate outcomes, tip verification — may be presented as this
+// run's, so the verify claim beside it reads `unavailable` rather than the recorded verdict.
+const NOT_COMPARABLE_CLAIM = "graph not comparable";
+const NOT_COMPARABLE_NOTICE = `${NOT_COMPARABLE_CLAIM} — recompiled since this run; resume with \`--graph-changed\` to audit this recompile`;
 const PRIOR_GRAPH_MARKER = "prior graph";
 // One compact host-zone label per screen. Each event below is still converted from its own
 // complete UTC instant, so the zone's historical rules — including a transition within one frame
@@ -160,6 +169,11 @@ const postWebhookFireAndForget = (post, url, event) => {
         // Webhooks are observational. A synchronous bridge failure is as inert as a rejected request.
     }
 };
+// `phase` is a coarse word — the daemon writes "judge" for the acceptance gate and, for a review
+// round, whatever phaseForGate() maps that gate to. The gate a row must NAME is the event's own
+// `gate` field; a value that is not one of the seven declared gates is not a gate name and is
+// ignored rather than printed.
+const recordedGate = (value) => typeof value === "string" && GATE_NAMES.includes(value) ? value : undefined;
 const taskPhase = (value) => {
     if (value === "worker" || value === "gates" || value === "judge" || value === "review" || value === "merge")
         return value;
@@ -191,8 +205,10 @@ const livePhases = (events) => {
             const attempt = typeof event.data.attempt === "number" && Number.isInteger(event.data.attempt) && event.data.attempt >= 0
                 ? event.data.attempt
                 : 0;
-            if (phase && Number.isFinite(startedAt))
-                live.set(event.taskId, { taskId: event.taskId, phase, startedAt, order, attempt });
+            const gate = recordedGate(event.data.gate);
+            if (phase && Number.isFinite(startedAt)) {
+                live.set(event.taskId, { taskId: event.taskId, phase, startedAt, order, attempt, ...(gate ? { gate } : {}) });
+            }
             continue;
         }
         if (!event.taskId)
@@ -200,7 +216,7 @@ const livePhases = (events) => {
         const active = live.get(event.taskId);
         if (!active)
             continue;
-        const gate = phaseGate(active.phase);
+        const gate = active.gate ?? phaseGate(active.phase);
         const matched = (active.phase === "worker" && event.event === "worker-result")
             || (active.phase === "gates" && event.event === "gate-result")
             || (gate !== undefined && event.event === "gate-result" && event.data.gate === gate)
@@ -215,7 +231,14 @@ const livePhases = (events) => {
     }
     return live;
 };
-const phaseLabel = (phase) => phase.startsWith("gate:") ? `gate ${phase.slice("gate:".length)}` : phase;
+// A gate the journal named is rendered by that name. Only a phase the journal left ungated falls
+// back to the phase word — the word alone cannot tell an acceptance round from a review one, since
+// the daemon records both under a phase of its own choosing (phaseForGate).
+const phaseLabel = (phase) => {
+    if (typeof phase !== "string")
+        return phase.gate ? `gate ${phase.gate}` : phaseLabel(phase.phase);
+    return phase.startsWith("gate:") ? `gate ${phase.slice("gate:".length)}` : phase;
+};
 const fmtElapsed = (ms) => {
     const seconds = Math.max(0, Math.floor(ms / 1000));
     if (seconds < 60)
@@ -230,7 +253,7 @@ const workerOutputAge = (phase, now, worker) => now - (worker?.phaseStartedAt ==
 const phaseDetail = (phase, now, worker) => {
     const elapsed = fmtElapsed(now - phase.startedAt);
     if (phase.phase !== "worker")
-        return `${phaseLabel(phase.phase)} · ${elapsed} elapsed`;
+        return `${phaseLabel(phase)} · ${elapsed} elapsed`;
     const age = fmtElapsed(workerOutputAge(phase, now, worker));
     const output = worker?.phaseStartedAt === phase.startedAt && worker.hasOutput
         ? `last output ${age} ago`
@@ -335,6 +358,26 @@ export const shortGoal = (goal, max) => {
         return fitCells(clause, cells).trimEnd();
     return `${fitCells(clause, cells - 3).trimEnd()}...`;
 };
+const detailText = (segments, budget) => {
+    const shedOrder = LAYOUT_PRIORITY.slice(LAYOUT_PRIORITY.indexOf("journal") + 1).reverse();
+    const shed = new Set();
+    const compose = () => segments
+        .filter((segment) => segment.text.length > 0 && !shed.has(segment.element))
+        .map((segment) => segment.text)
+        .join(" · ");
+    for (const element of shedOrder) {
+        if (cellWidth(compose()) <= budget)
+            break;
+        shed.add(element);
+    }
+    return compose();
+};
+/**
+ * Every board line leaves through the cockpit's own wrap, measured in display cells: no drawn line
+ * exceeds the board's columns, and nothing is shortened into a count to get there. Blank separators
+ * stay blank — `wrapCells` always answers at least one row.
+ */
+const boardRows = (lines, columns) => lines.flatMap((line) => wrapCells(line, columns, { continuationPrefix: "  " }));
 // VIS-11 (v1.13): a liveness header for renderFrame — last journal event age + whether the recorded
 // daemon pid is still alive. Honest about unknowns: a pre-v1.13 journal with no pid renders "unknown",
 // never fabricated (garbage pid data fails toward unknown too). kill(pid,0) is a signal probe, not a
@@ -446,15 +489,93 @@ const tipVerifyPhase = (events) => {
 };
 const tipVerifyText = (phase) => {
     if (phase.state === "pending")
-        return "tip-verify: pending";
+        return "verify pending";
     const gates = phase.gates.length ? phase.gates.join(", ") : "gate unknown";
-    const failed = `tip-verify: FAILED (${gates})`;
+    const failed = `verify FAILED (${gates})`;
     const reverify = phase.state === "re-verifying" ? ` → re-verifying (run attempt ${phase.attempt})` : "";
     const fingerprints = phase.fingerprints === undefined
         ? ""
         : ` · ${phase.fingerprints} fingerprint${phase.fingerprints === 1 ? "" : "s"}`;
     return `${failed}${reverify}${fingerprints}`;
 };
+// The only tip-verification verdicts a run-end can RECORD. Anything else in that field — absent, a
+// value carrying a newline or terminal controls, a word from some other vocabulary — records no
+// verdict, and the surfaces say so instead of echoing it or counting `tip-verify` events to guess
+// (an operator-local reimplementation counted them and scored two failed runs as verified).
+const RECORDED_VERIFY = new Set(["passed", "failed"]);
+const recordedVerify = (events) => {
+    for (let i = events.length - 1; i >= 0; i--) {
+        const event = events[i];
+        if (event.event !== "run-end")
+            continue;
+        const recorded = event.data.tipVerify;
+        return typeof recorded === "string" && RECORDED_VERIFY.has(recorded)
+            ? recorded
+            : "unrecorded";
+    }
+    return "unrecorded"; // no run-end: this run's record names no verdict yet
+};
+/**
+ * What the board may CLAIM about tip verification, in one place for both surfaces.
+ *
+ * An incomparable journal yields no claim about this graph at all, so it reads `unavailable` rather
+ * than the recorded verdict. A live phase (failed, re-verifying, pending) keeps its own richer
+ * phrase. Otherwise the run-end field is READ: `passed` is stated positively — silence used to be
+ * the only sign of a passed tip, which reads identically to a surface that simply hides it — and a
+ * record that ends without naming a verdict is `unrecorded`. A run still in flight claims nothing.
+ */
+const verifyClaim = (events, comparable, tipPhase) => {
+    if (!comparable)
+        return "verify unavailable";
+    if (tipPhase)
+        return tipVerifyText(tipPhase);
+    if (!runHasEnded(events))
+        return undefined;
+    return `verify ${recordedVerify(events)}`;
+};
+/**
+ * Where an operator can still look, per task — folded from the daemon's OWN pane authority
+ * (`desiredPanes`, the reconcile fold that decides which owned panes should exist right now) and
+ * the visibility setting that governs when a worker pane closes. A locator built from dispatch
+ * history alone survives the events that retire a pane — `task-done` closes a merged task's worker
+ * pane, `run-end` retires every pane of the run — and sends the operator to a pane that is gone.
+ *
+ * Under `keepPanes: "attempt"` the daemon closes a worker pane as soon as it harvests that attempt,
+ * before the gates run and before `worker-result` is journaled (daemon.ts), so a harvested attempt
+ * has no pane left however desirable the fold finds it.
+ */
+const workerPaneLocators = (events, runId, keepPanes) => {
+    const locators = new Map();
+    for (const name of desiredPanes(events, runId)) {
+        const owned = parseOwnedName(name);
+        if (owned?.role === "worker")
+            locators.set(owned.taskId, name);
+    }
+    if (keepPanes !== "attempt")
+        return locators;
+    const harvested = new Set();
+    for (const event of events) {
+        if (!event.taskId)
+            continue;
+        if (event.event === "task-dispatch")
+            harvested.delete(event.taskId);
+        else if (event.event === "worker-result")
+            harvested.add(event.taskId);
+    }
+    for (const taskId of harvested)
+        locators.delete(taskId);
+    return locators;
+};
+// status is a reader of the repo it reports on: the same resolved config every other command loads.
+// A config that will not load is not a reason to fail a frame — the shipped default keeps the fold.
+const keepPanesSetting = (cwd) => {
+    try {
+        return loadConfig(cwd).visibility.keepPanes;
+    }
+    catch {
+        return DEFAULT_CONFIG.visibility.keepPanes;
+    }
+};
 const liveness = (events, now = Date.now()) => {
     const last = events.at(-1);
     if (!last)
@@ -507,58 +628,82 @@ const parseJournalSnapshot = (raw) => raw.split("\n").flatMap((line) => {
         return [];
     }
 });
+/**
+ * ONE journal read per answer, and every claim about the run folded from THOSE bytes — the board's
+ * task rows, activity, phases, gates, liveness and tip verification, and the compact one-line form
+ * alike. A second read is what lets two snapshots be presented as one state: a line the daemon
+ * appends between them pairs a task count from one instant with a verdict from another.
+ *
+ * An explicit <runId> is a resolution, not a hint: `Journal.open` refuses an id without a readable
+ * journal, so status fails loudly naming that id instead of rendering any other run.
+ */
+const readRunRecord = (cwd, graph, namedRunId) => {
+    const runId = namedRunId ?? Journal.latestRunId(cwd, { withJournal: true });
+    if (!runId)
+        return undefined;
+    const raw = readFileSync(join(Journal.open(cwd, runId).dir, "journal.jsonl"), "utf8");
+    const events = parseJournalSnapshot(raw);
+    // The resume comparator is the fail-closed baseline; a matching graph-rehash is the daemon's
+    // append-only audit that authorizes this status replay after stop-amend-resume.
+    const engagement = statusEngagement(events, graphDefinitionHash(graph));
+    return {
+        runId,
+        raw,
+        events,
+        comparable: engagement.comparable,
+        ...(engagement.rehashAt === undefined ? {} : { rehashAt: engagement.rehashAt }),
+    };
+};
+/**
+ * The cockpit fold over those same bytes — the journal-backed task authority both forms read.
+ *
+ * The daemon creates journal.jsonl with lock-reclaimed before run-start, and a reader may also
+ * catch an empty or torn first write. Those snapshots own no task fold yet; once run-start exists,
+ * however, a fold failure is unexpected and must surface instead of becoming a false empty run.
+ */
+const recordTaskRows = (record, graph) => record.comparable && record.events.some((event) => event.event === "run-start")
+    ? new Map(deriveRunCockpitData({ fileName: `${record.runId}.journal.jsonl`, raw: record.raw }, "status", { graph }).taskRows.map((row) => [row.taskId, row]))
+    : new Map();
+/** The graph tasks this run's record actually speaks about — a row with no recorded fact is silence. */
+const recordedTasks = (graph, rows) => graph.tasks.filter((task) => {
+    const row = rows.get(task.id);
+    return row !== undefined && (row.state !== undefined
+        || row.lastEventTime !== undefined
+        || row.attempts !== undefined
+        || row.actor !== undefined
+        || row.merged === true
+        || row.parkKind !== undefined);
+});
+const recordedDone = (tasks, rows) => tasks.filter((task) => graphTaskStatus(rows.get(task.id)?.state, task.status) === "done").length;
 const renderFrame = (cwd, now = Date.now(), animationFrame = 0, workerLiveness = new Map(), journalRowsOnly = false, namedRunId) => {
     const g = loadGraph(cwd);
-    // An explicit <runId> is a resolution, not a hint: Journal.open below refuses an id without a
-    // readable journal, so status fails loudly naming that id instead of rendering any other run.
-    const runId = namedRunId ?? Journal.latestRunId(cwd, { withJournal: true });
+    const record = readRunRecord(cwd, g, namedRunId);
+    const runId = record?.runId;
+    const events = record?.events ?? [];
+    const comparable = record?.comparable ?? false;
+    const rehashAt = record?.rehashAt;
     const assignments = new Map();
     let replayed = null;
-    let cockpit;
-    let events = [];
     const contexts = new Map();
-    let comparable = false;
-    let rehashAt;
-    let supersededBy; // v1.53 T5: this run is dead — a newer run replaced it
-    if (runId) {
-        const j = Journal.open(cwd, runId);
-        // ONE byte snapshot per frame. The cockpit fold and every decoration below — foldActivity,
-        // livePhases, tipVerifyPhase, gateSnapshot, the failure and liveness readings — fold THESE
-        // bytes and nothing else, so a line the daemon appends mid-frame can never pair newer task
-        // rows against older activity, phases, gates or tip state. `Journal.open` refuses a run
-        // without a journal, so the file is there to read.
-        const raw = readFileSync(join(j.dir, "journal.jsonl"), "utf8");
-        events = parseJournalSnapshot(raw);
-        // The daemon creates journal.jsonl with lock-reclaimed before run-start and a reader may also
-        // catch an empty/torn first write. Those snapshots own no task fold yet; once run-start exists,
-        // however, a fold failure is unexpected and must surface instead of becoming a false empty run.
-        if (journalRowsOnly && events.some((event) => event.event === "run-start")) {
-            cockpit = deriveRunCockpitData({ fileName: `${runId}.journal.jsonl`, raw }, "status", { graph: g });
-        }
-        const sup = [...events].reverse().find((e) => e.event === "superseded" && typeof e.data.by === "string");
-        supersededBy = sup?.data.by;
-        // The resume comparator is the fail-closed baseline; a matching graph-rehash is the daemon's
-        // append-only audit that authorizes this status replay after stop-amend-resume.
-        const engagement = statusEngagement(events, graphDefinitionHash(g));
-        comparable = engagement.comparable;
-        rehashAt = engagement.rehashAt;
-        if (comparable) {
-            if (!journalRowsOnly)
-                replayed = j.replayStatuses();
-            for (const e of events) {
-                if (!journalRowsOnly && e.event === "task-dispatch" && e.taskId) {
-                    const a = e.data.assignment;
-                    if (typeof a.adapter === "string" && typeof a.model === "string") {
-                        assignments.set(e.taskId, `${a.adapter}:${a.model}`);
-                    }
-                }
-                if (e.event === "context-sample" && e.taskId && typeof e.data.tokens === "number" && Number.isFinite(e.data.tokens)) {
-                    contexts.set(e.taskId, e.data.tokens); // last write wins
+    // v1.53 T5: this run is dead — a newer run replaced it
+    const supersededBy = [...events].reverse()
+        .find((e) => e.event === "superseded" && typeof e.data.by === "string")?.data.by;
+    if (record && comparable) {
+        if (!journalRowsOnly)
+            replayed = Journal.open(cwd, record.runId).replayStatuses();
+        for (const e of events) {
+            if (!journalRowsOnly && e.event === "task-dispatch" && e.taskId) {
+                const a = e.data.assignment;
+                if (typeof a.adapter === "string" && typeof a.model === "string") {
+                    assignments.set(e.taskId, `${a.adapter}:${a.model}`);
                 }
             }
+            if (e.event === "context-sample" && e.taskId && typeof e.data.tokens === "number" && Number.isFinite(e.data.tokens)) {
+                contexts.set(e.taskId, e.data.tokens); // last write wins
+            }
         }
     }
-    const taskRows = new Map(cockpit?.taskRows.map((row) => [row.taskId, row]) ?? []);
+    const taskRows = record && journalRowsOnly ? recordTaskRows(record, g) : new Map();
     const clockFallback = new Date(now);
     const recordedClock = new Date(events.at(-1)?.ts ?? now);
     const zoneReference = Number.isFinite(recordedClock.getTime()) ? recordedClock : clockFallback;
@@ -573,19 +718,7 @@ const renderFrame = (cwd, now = Date.now(), animationFrame = 0, workerLiveness =
                 : task.status,
         })),
     };
-    const renderedTasks = journalRowsOnly
-        ? cockpit !== undefined && comparable
-            ? g.tasks.filter((task) => {
-                const row = taskRows.get(task.id);
-                return row !== undefined && (row.state !== undefined
-                    || row.lastEventTime !== undefined
-                    || row.attempts !== undefined
-                    || row.actor !== undefined
-                    || row.merged === true
-                    || row.parkKind !== undefined);
-            })
-            : []
-        : g.tasks;
+    const renderedTasks = journalRowsOnly ? recordedTasks(g, taskRows) : g.tasks;
     const starved = new Set(blockedTasks(effective).map((t) => t.id));
     // OBS-104: ONE activity fold feeds both surfaces — never re-derived here. Comparable events only
     // (a recompiled graph's journal must not animate the wrong tasks); with no or stale journal the
@@ -593,13 +726,21 @@ const renderFrame = (cwd, now = Date.now(), animationFrame = 0, workerLiveness =
     const activity = foldActivity(comparable ? events : [], effective.tasks);
     const unicode = visual();
     const divider = unicode ? " · " : " / ";
+    // SUP-01: derived by stat() alone, from THIS frame's clock. status stays a reader — nothing here
+    // creates, touches or reaps a beat file, so an absent supervision dir stays absent.
+    const supervision = readSupervision(cwd, now);
     const width = process.stdout.columns ?? 120;
     const done = journalRowsOnly
-        ? renderedTasks.filter((task) => graphTaskStatus(taskRows.get(task.id)?.state, task.status) === "done").length
+        ? recordedDone(renderedTasks, taskRows)
         : effective.tasks.filter((task) => task.status === "done").length;
     const total = g.tasks.length;
     const ended = comparable && runHasEnded(events);
     const tipPhase = comparable ? tipVerifyPhase(events) : undefined;
+    const verify = runId ? verifyClaim(events, comparable, tipPhase) : undefined;
+    // Where an operator can still look: only panes this run's record leaves open (see workerPaneLocators).
+    const panes = runId && comparable
+        ? workerPaneLocators(events, runId, keepPanesSetting(cwd))
+        : new Map();
     const taskIds = new Set(g.tasks.map((task) => task.id));
     const phases = comparable ? livePhases(events) : new Map();
     for (const taskId of phases.keys())
@@ -632,24 +773,25 @@ const renderFrame = (cwd, now = Date.now(), animationFrame = 0, workerLiveness =
         const gates = comparable
             ? gateSnapshot(t, events, rehashAt)
             : { states: defaultGateStates(t), priorGraph: false };
-        return { t, st, merged, failureKind, redTier, label, assignCol, isStarved, phrase, channel, ctx, livePhase, ...gates };
+        const pane = panes.get(t.id);
+        return { t, st, merged, failureKind, redTier, label, assignCol, isStarved, phrase, channel, ctx, livePhase, pane, ...gates };
     });
     if (!unicode) {
         // machine/CI surface — journals without phase-start stay byte-identical; new phase-aware frames
         // use an ASCII spinner so pipes never receive terminal-only braille/ANSI.
-        const rows = cells.map(({ t, st, merged, label, assignCol, livePhase, states, priorGraph }) => {
+        const rows = cells.map(({ t, st, merged, label, assignCol, livePhase, states, priorGraph, pane }) => {
             const chain = gateChain(states, false);
             const prefix = livePhase ? `  ${ASCII_SPINNER[animationFrame % ASCII_SPINNER.length]} ${t.id} ` : `  ${surfaceTaskBox(st, merged)} ${t.id} `;
-            const suffix = `  ${chain}${priorGraph ? ` ${PRIOR_GRAPH_MARKER}` : ""}  ${livePhase ? "running" : surfaceStatusWord(st)}${label}  ${assignCol}`;
+            const suffix = `  ${chain}${priorGraph ? ` ${PRIOR_GRAPH_MARKER}` : ""}  ${livePhase ? "running" : surfaceStatusWord(st)}${label}  ${assignCol}${pane ? `  pane ${pane}` : ""}`;
             return `${prefix}${shortGoal(t.title, Math.max(0, width - prefix.length - suffix.length))}${suffix}`;
         });
         const zone = journalRowsOnly ? `${divider}zone ${localZoneLabel(zoneReference)}` : "";
         const header = runId
-            ? `tickmarkr status${divider}run ${runId}${zone}${supersededBy ? `${divider}superseded by ${supersededBy}` : ""}${!comparable ? `${divider}${NOT_COMPARABLE_NOTICE}` : ""}${divider}${liveness(events, now).replaceAll(" · ", divider)}${tipPhase ? `${divider}${tipVerifyText(tipPhase)}` : ""}${divider}${tipPhase ? `${done}/${total} tasks done${divider}run not verified` : `${done}/${total} done`}`
+            ? `tickmarkr status${divider}run ${runId}${zone}${supersededBy ? `${divider}superseded by ${supersededBy}` : ""}${!comparable ? `${divider}${NOT_COMPARABLE_NOTICE}` : ""}${divider}${liveness(events, now).replaceAll(" · ", divider)}${verify ? `${divider}${verify}` : ""}${divider}${tipPhase ? `${done}/${total} tasks done${divider}run not verified` : `${done}/${total} done`}`
             : `tickmarkr status${zone}${divider}no runs yet${divider}${done}/${total} done`;
         const legendLine = `  gates: ${GATE_NAMES.map((gate) => `${GATE_KEYS[gate]} ${gate}`).join(divider)}`;
         return {
-            content: [header, legendLine, ...rows].join("\n"),
+            content: [header, legendLine, `  ${supervisionText(supervision, divider)}`, ...rows].join("\n"),
             ...(hotPhase ? { hotPhase } : {}),
             ...(runId ? { runId } : {}),
             workerPhases: [...phases.values()].filter((phase) => phase.phase === "worker"),
@@ -659,6 +801,10 @@ const renderFrame = (cwd, now = Date.now(), animationFrame = 0, workerLiveness =
     // dim chrome, semantic color only on verdicts, completion gauge, and column-aligned status
     // rows (pad plain text FIRST, colorize after: ANSI has zero display width and would corrupt
     // padEnd math)
+    // The cockpit owns this board's column contract: `COCKPIT_COLUMN_FLOOR` is the narrowest board it
+    // plans, so below it the terminal — not a second floor stated here — decides what happens to the
+    // drawn rows. Every column figure below is derived from this one.
+    const boardColumns = Math.max(COCKPIT_COLUMN_FLOOR, width);
     const dot = dim(" · ");
     const anyFailed = cells.some((c) => c.redTier);
     const gaugeCells = 10;
@@ -674,38 +820,51 @@ const renderFrame = (cwd, now = Date.now(), animationFrame = 0, workerLiveness =
     const tally = tipPhase
         ? `${progressTone(`${done}/${total} tasks done`)}${dot}${progressTone("run not verified")}`
         : `${done}/${total} done`;
-    const tipStatus = tipPhase
-        ? `${tipFailed ? fail(tipVerifyText(tipPhase)) : warn(tipVerifyText(tipPhase))}${dot}`
-        : "";
-    const zone = journalRowsOnly ? `zone ${localZoneLabel(zoneReference)}${dot}` : "";
-    const header = ` ${title(runId ? `run ${runId}` : "tickmarkr")}${dot}${zone}` +
-        (runId
-            ? `${supersededBy ? `${warn(`superseded by ${supersededBy}`)}${dot}` : ""}${!comparable ? `${warn(NOT_COMPARABLE_NOTICE)}${dot}` : ""}${live}${dot}${tipStatus}`
-            : `no runs yet${dot}`) +
-        `${gauge} ${tipPhase ? tally : done === total && total > 0 ? ok(tally) : tally}`;
-    const hr = rule(Math.min(width, 100));
+    // The prototype's header order, ported: identity, then what the run is worth (verdict and
+    // tally), then the instruments that decorate it. A board that must wrap keeps the decisive
+    // segments on the row an operator reads first; nothing is dropped to get there.
+    const header = ` ${[
+        title(runId ? `run ${runId}` : "tickmarkr"),
+        ...(runId ? [] : ["no runs yet"]),
+        ...(runId && supersededBy ? [warn(`superseded by ${supersededBy}`)] : []),
+        ...(runId && !comparable ? [warn(NOT_COMPARABLE_NOTICE)] : []),
+        ...(verify === undefined
+            ? []
+            : [verify === "verify passed" ? ok(verify) : tipFailed ? fail(verify) : warn(verify)]),
+        `${gauge} ${tipPhase ? tally : done === total && total > 0 ? ok(tally) : tally}`,
+        ...(runId ? [live] : []),
+        ...(journalRowsOnly ? [`zone ${localZoneLabel(zoneReference)}`] : []),
+    ].join(dot)}`;
+    const hr = rule(Math.min(boardColumns, 100));
     // OBS-104 run-level now line: names the most recent journal event. TTY frame only — the non-TTY
     // machine surface is byte-pinned (status-brand golden) and must not drift. Rendered BELOW the task
     // rows: the line names task ids, and rows must stay the first id-bearing lines for grep consumers.
     const nowLine = activity.now ? [legend(`   now: ${activity.now}`)] : [];
     const gatesLegend = legend(`   gates: ${GATE_NAMES.join(" · ")}`);
+    // Every known tier, beaten or not: a tier missing from this line would read as a healthy one.
+    const supervisionLegend = legend(`   ${supervisionText(supervision)}`);
     // Two-line card per task (operator request, v1.67): line 1 carries identity + verdict — glyph,
     // id, title at full width, and only SHORT status words. Line 2 carries the machinery, dim and
     // aligned under the title: gate chain, live activity phrase (or channel), ctx. Long channel names
     // and activity phrases live on line 2 only, so they can never squeeze the title or wrap line 1.
     const taskVerdict = (c) => c.merged ? "pass" : c.redTier ? "fail" : c.st === "failed" || c.st === "human" ? "warn" : "neutral";
     const statusWord = (c) => c.livePhase ? "running" : c.redTier ? "failed" : c.st === "failed" ? "warn" : surfaceStatusWord(c.st);
-    const idW = Math.max(...cells.map((c) => c.t.id.length), 2);
+    // Every column figure is display cells through the cockpit's width authority — never String
+    // length, which over-charges a wide cluster and bills a combining mark that draws nothing.
+    const idW = Math.max(...cells.map((c) => cellWidth(c.t.id)), 2);
     // plain-text status suffixes for width math only — starved / failed gate names / approval hint
     const suffixPlain = (c) => (c.isStarved ? " · starved" : "") + failedSuffix(c.states)
         + humanGateSuffix(c.t, graphTaskStatus(c.st, c.t.status), c.states);
-    const stW = Math.max(...cells.map((c) => statusWord(c).length + suffixPlain(c).length));
-    const avail = Math.max(8, width - (5 + idW) - 2 - stW);
+    const stW = Math.max(...cells.map((c) => cellWidth(statusWord(c) + suffixPlain(c))));
+    const avail = Math.max(8, boardColumns - (5 + idW) - 2 - stW);
     const titles = cells.map((c) => shortGoal(c.t.title, avail));
     const titleW = Math.max(8, ...titles.map(cellWidth));
-    const indent = " ".repeat(idW + 5); // line 2 starts under the title column
+    // Line 2 starts under the title column — but never past what the board can pay for: an id near
+    // the schema's 64-character maximum would otherwise indent the machinery clean off a narrow row.
+    const chainCells = cellWidth(gateChain(GATE_NAMES.map(() => "open"), true));
+    const indent = " ".repeat(Math.max(0, Math.min(idW + 5, boardColumns - chainCells - 2)));
     const rows = cells.map((c, i) => {
-        const { t, st, merged, failureKind, redTier, states, priorGraph, isStarved, phrase, channel, ctx, livePhase } = c;
+        const { t, st, merged, failureKind, redTier, states, priorGraph, isStarved, phrase, channel, ctx, livePhase, pane } = c;
         const word = statusWord(c);
         const staleWorker = livePhase?.phase === "worker"
             && workerOutputAge(livePhase, now, workerLiveness.get(t.id)) >= 60_000;
@@ -723,25 +882,68 @@ const renderFrame = (cwd, now = Date.now(), animationFrame = 0, workerLiveness =
             ? `  ${(staleWorker ? warn : dim)(SPINNER[animationFrame % SPINNER.length])} ${taskLabel}`
             : `  ${statusRow(taskVerdict(c), taskLabel)}`;
         // activity already names its channel for in-flight attempts — never repeat it
-        const detail = [
-            ...(priorGraph ? [PRIOR_GRAPH_MARKER] : []),
-            ...(phrase ? [phrase, ...(phrase.includes(channel) || channel === "-" ? [] : [channel])] : [channel]),
-            ...(failureKind && !phrase?.includes(failureKind) ? [failureKind] : []),
-            ...(ctx !== undefined ? [`ctx ${ctx}`] : []),
-        ].join(" · ");
-        return [line1, `${indent}${gateChain(states, true)}  ${dim(detail)}`, ""];
+        const chain = gateChain(states, true);
+        const segments = [
+            ...(priorGraph ? [{ element: "progressCaption", text: PRIOR_GRAPH_MARKER }] : []),
+            ...(phrase
+                ? [
+                    { element: "journal", text: phrase },
+                    ...(phrase.includes(channel) || channel === "-"
+                        ? []
+                        : [{ element: "secondaryHeader", text: channel }]),
+                ]
+                : [{ element: "secondaryHeader", text: channel }]),
+            ...(failureKind && !phrase?.includes(failureKind)
+                ? [{ element: "progressCaption", text: failureKind }]
+                : []),
+            // A pane an operator can still open is structure, not decoration: it wraps like the blockers
+            // above it rather than being shed, because half an address is no address.
+            ...(pane ? [{ element: "journal", text: `pane ${pane}` }] : []),
+            ...(ctx !== undefined ? [{ element: "statTiles", text: `ctx ${ctx}` }] : []),
+        ];
+        const detail = detailText(segments, boardColumns - cellWidth(indent) - cellWidth(chain) - 2);
+        // A board narrow enough to surrender every detail segment ends the row at the gate chain: the
+        // separator is part of the segment it separates, never chrome left standing on its own.
+        const line2 = detail ? `${indent}${chain}  ${dim(detail)}` : `${indent}${chain}`;
+        return [line1, line2, ""];
     }).flat();
     if (!nowLine.length)
         rows.pop(); // cards end blank-separated; drop the dangling one
     return {
-        content: [header, hr, gatesLegend, "", ...rows, ...nowLine].join("\n"),
+        content: boardRows([header, hr, gatesLegend, supervisionLegend, "", ...rows, ...nowLine], boardColumns).join("\n"),
         ...(hotPhase ? { hotPhase } : {}),
         ...(runId ? { runId } : {}),
         workerPhases: [...phases.values()].filter((phase) => phase.phase === "worker"),
     };
 };
+/**
+ * The compact form a statusline calls, so journal interpretation happens ONCE, inside the product.
+ * (An operator-local bash reimplementation counted `tip-verify` events instead of reading the
+ * run-end field and scored two runs whose tip verification had FAILED as verified.)
+ *
+ * One line, one journal read, and every word from the run's own record: the tally and the verdict
+ * are folded from the same bytes, so a completion appended between two reads can never be paired
+ * with a verdict the other read never saw. Plain text through the task-text sanitizer — a statusline
+ * embeds this, so no recorded value may carry a control byte or a row break into its host.
+ */
+const oneLine = (cwd, namedRunId) => {
+    const graph = loadGraph(cwd);
+    const record = readRunRecord(cwd, graph, namedRunId);
+    if (!record)
+        return sanitizeTaskText(`tickmarkr · no runs yet · 0/${graph.tasks.length} done`);
+    const rows = recordTaskRows(record, graph);
+    const claims = record.comparable
+        ? [
+            `${recordedDone(recordedTasks(graph, rows), rows)}/${graph.tasks.length} done`,
+            `verify ${recordedVerify(record.events)}`,
+        ]
+        : [NOT_COMPARABLE_CLAIM, "verify unavailable"];
+    return sanitizeTaskText([record.runId, ...claims].join(" · "));
+};
 export async function status(argv, cwd = process.cwd(), opts = {}) {
     const namedRunId = positionalRunId(argv);
+    if (argv.includes("--oneline"))
+        return oneLine(cwd, namedRunId);
     // cockpit surface: banner + frame on a TTY (doctor's pattern); pipes get the bare frame
     if (!argv.includes("--watch")) {
         const { content } = renderFrame(cwd, opts.now?.() ?? Date.now(), 0, undefined, false, namedRunId);
@@ -849,7 +1051,7 @@ export async function status(argv, cwd = process.cwd(), opts = {}) {
             titleSaved = true;
             process.once("exit", restoreTitle);
         }
-        process.stdout.write(`\x1b]0;⏳ ${hotPhase.taskId} ${phaseLabel(hotPhase.phase)} ${fmtElapsed(nowMs - hotPhase.startedAt)}\x07`);
+        process.stdout.write(`\x1b]0;⏳ ${hotPhase.taskId} ${phaseLabel(hotPhase)} ${fmtElapsed(nowMs - hotPhase.startedAt)}\x07`);
     };
     try {
         for (let i = 0; i < iterations; i++) {

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

@@ -0,0 +1,9 @@
+import { type Assignment, type BillingChannel } from "../../adapters/types.js";
+import { type AcceptanceItem } from "../../graph/schema.js";
+export declare function parseCriteria(text: string): AcceptanceItem[];
+export declare const HUMAN_CHANNEL: BillingChannel;
+export declare const HUMAN_AUTHOR: Assignment;
+export declare function verify(argv: string[], cwd?: string): Promise<{
+    out: string;
+    code: number;
+}>;