tickmarkr 1.96.0 → 2.0.0

package/dist/cli/commands/status.js

@@ -1,6 +1,6 @@
 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 { GLYPHS, LIVE } from "../../brand.js";
 import { DEFAULT_CONFIG, loadConfig } from "../../config/config.js";
 import { HerdrDriver } from "../../drivers/herdr.js";
 import { formatOwnedName, parseOwnedName, } from "../../drivers/types.js";
@@ -13,10 +13,44 @@ 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 { COCKPIT_COLUMN_FLOOR, LAYOUT_PRIORITY } from "../../tui/cockpit/layout.js";
+import { COCKPIT_COLUMN_FLOOR } 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;
+import { version } from "./version.js";
+// The board is a LIVE surface, so it draws through brand.ts's operator role map and never the vivid
+// one-shot tokens. Semantic aliases can share a colour, but every board cell, gate mark, effort bar,
+// header and footer styles through one of the five exported authorities.
+const ok = LIVE.pass;
+const running = LIVE.running;
+const information = LIVE.information;
+const fail = LIVE.failure;
+const warn = LIVE.attention;
+const dim = LIVE.secondaryText;
+const title = LIVE.primaryText;
+const legend = LIVE.secondaryText;
+const rule = (columns) => LIVE.chrome("─".repeat(columns));
+// Two clocks, deliberately unequal. The journal frame is cheap — a single file read and a fold — so
+// it redraws on a 500ms cadence and the board feels live. Scraping a worker's pane is neither cheap
+// nor bounded: it crosses the herdr socket and can hang on a wedged pane, so it keeps its own 2s
+// budget and runs OFF the redraw path (see scheduleWorkerScrape). A slow scrape updates liveness
+// one frame late; it never delays a frame, and it never overlaps itself.
+// ponytail: fixed cadences; promote to config.visibility.* only when an operator asks.
+const FRAME_MS = 500;
+const SCRAPE_MS = 2000;
+// The binary's own version, read ONCE when status starts (see `status`), then carried into every
+// frame: a board redrawing twice a second must not pay a manifest read per frame, and the version
+// it names must not change under the operator mid-run. It reads through the SAME manifest reader
+// `tickmarkr version` prints from — one version answer for the whole CLI — and a manifest that
+// cannot be read, cannot be parsed, or names no version PROPAGATES rather than resolving to a
+// placeholder: a board that cannot name its own binary is a broken installation, and the board's
+// whole job is to state what is true. A rendered `vunknown` would be a claim about the binary
+// nobody could check.
+const readBinaryVersion = async () => {
+    const semver = await version();
+    if (typeof semver !== "string" || semver === "") {
+        throw new Error("package.json names no version — reinstall tickmarkr");
+    }
+    return semver;
+};
 // 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
@@ -368,7 +402,7 @@ const gateSnapshot = (task, events, rehashAt) => {
     };
 };
 export const gateStates = (task, events) => gateSnapshot(task, events).states;
-// verdict semantics only: pass brand green, fail red, skip/open dim chrome — everything else stays quiet
+// Verdict semantics only: pass uses brand teal, failure uses amethyst, and skip/open use chrome.
 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)
@@ -376,11 +410,6 @@ export const gateChain = (states, unicode) => GATE_NAMES.map((gate, i) => unicod
     ? GATE_STATE_TOKEN[states[i]](gateBox(states[i], true))
     : `${GATE_KEYS[gate]}${gateBox(states[i], false)}`).join(" ");
 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);
-    return f.length ? ` · ${f.join(", ")}` : "";
-};
 // a designed human gate parks the task BEFORE any gate result exists (daemon.ts execTask), so the
 // 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
@@ -401,19 +430,46 @@ export const shortGoal = (goal, max) => {
 };
 /** Columns the machine row always spends on the task title, however long its machinery segment runs. */
 const MACHINE_TITLE_FLOOR = 24;
-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);
+// The approved task board derives an area from files[] rather than adding another graph field.
+// Known tickmarkr domains keep their reviewed names; other repositories fall back to their first
+// meaningful path segment so the shipped surface never turns a foreign project into UNMAPPED rows.
+const TASK_AREA_RULES = [
+    ["SPEC", [/^src\/(compile|graph|plan)\//u]],
+    ["FLEET", [/^src\/(route|config|adapters)\//u]],
+    ["RUN", [/^src\/(run|drivers|eval)\//u]],
+    ["GATE", [/^src\/gates\//u]],
+    ["UI", [/^src\/(cli|tui|report)\//u, /^src\/brand\.ts/u]],
+    ["DOCS", [/^(docs|skills)\//u]],
+    ["REPO", [/^(scripts|schema)\//u, /^\.github\//u, /^tests\/(lint|repo|helpers)\//u, /^(vitest\.config|package\.json|tsconfig)/u]],
+];
+const expandAreaBraces = (path) => {
+    const match = /^(.*?)\{([^}]*)\}(.*)$/u.exec(path);
+    return match
+        ? match[2].split(",").flatMap((part) => expandAreaBraces(`${match[1]}${part.trim()}${match[3]}`))
+        : [path];
+};
+const areaForPath = (path) => {
+    const candidates = [path, path.replace(/^tests\//u, "src/")];
+    for (const candidate of candidates) {
+        for (const [name, patterns] of TASK_AREA_RULES) {
+            if (patterns.some((pattern) => pattern.test(candidate)))
+                return name;
+        }
     }
-    return compose();
+    const parts = path.replace(/^[!./]+/u, "").split("/").filter((part) => part && !/[*?[\]]/u.test(part));
+    const root = parts[0];
+    if (!root)
+        return "UNMAPPED";
+    const domain = ["src", "app", "packages", "tests"].includes(root) && parts[1] ? parts[1] : root;
+    return domain.replace(/\.[^.]+$/u, "").toUpperCase();
+};
+const taskArea = (task) => {
+    const paths = task.files.flatMap(expandAreaBraces);
+    if (paths.length === 0)
+        return "—";
+    const primary = paths.filter((path) => !path.startsWith("tests/") && !path.startsWith("src/cli/"));
+    const source = primary.length ? primary : paths;
+    return [...new Set(source.map(areaForPath))].join("+");
 };
 /**
  * Every board line leaves through the cockpit's own wrap, measured in display cells: no drawn line
@@ -471,6 +527,10 @@ const foldTaskEffort = (tasks, events) => {
     return [...effort.values()].sort((left, right) => right.total - left.total
         || order.get(left.taskId) - order.get(right.taskId));
 };
+// Attention (review) and failure (park) wear the ONE amethyst, so the bar segments and their legend
+// markers carry the distinction in SHAPE: a full block for dispatch, light shade for a review round,
+// dark shade for a human park. Same display width, so the fitted bar keeps its measured columns.
+const EFFORT_GLYPH = { dispatch: "\u2588", review: "\u2592", park: "\u2593" };
 /**
  * Prototype panel, fitted by the cockpit's display-cell authority before board-wide wrapping.
  *
@@ -482,7 +542,7 @@ const foldTaskEffort = (tasks, events) => {
 const effortPanel = (tasks, events, columns) => {
     if (!events) {
         return [
-            ` ${title("WHERE THE EFFORT WENT")}`,
+            `  ${ok("▌")} ${title("WHERE THE EFFORT WENT")}`,
             legend(`   dispatch · review · park counts unavailable — ${NOT_COMPARABLE_CLAIM}`),
         ];
     }
@@ -496,18 +556,18 @@ const effortPanel = (tasks, events, columns) => {
         const dispatchEnd = Math.round((task.dispatches / maxTotal) * barColumns);
         const reviewEnd = Math.round(((task.dispatches + task.reviews) / maxTotal) * barColumns);
         const parkEnd = Math.round((task.total / maxTotal) * barColumns);
-        const stack = ok("█".repeat(dispatchEnd))
-            + warn("█".repeat(Math.max(0, reviewEnd - dispatchEnd)))
-            + fail("█".repeat(Math.max(0, parkEnd - reviewEnd)));
+        const stack = ok(EFFORT_GLYPH.dispatch.repeat(dispatchEnd))
+            + warn(EFFORT_GLYPH.review.repeat(Math.max(0, reviewEnd - dispatchEnd)))
+            + fail(EFFORT_GLYPH.park.repeat(Math.max(0, parkEnd - reviewEnd)));
         return `${prefix}${fitCells(stack, barColumns)}  ${counts}`;
     });
     return [
-        ` ${title("WHERE THE EFFORT WENT")}`,
+        `  ${ok("▌")} ${title("WHERE THE EFFORT WENT")}`,
         legend(`   dispatches · review rounds · human parks · top ${top.length} of ${tasks.length} tasks`),
         "",
         ...rows,
         "",
-        `   ${ok("█")} ${dim("dispatch")}  ${warn("█")} ${dim("review round")}  ${fail("█")} ${dim("human park")}`,
+        `   ${ok(EFFORT_GLYPH.dispatch)} ${dim("dispatch")}  ${warn(EFFORT_GLYPH.review)} ${dim("review round")}  ${fail(EFFORT_GLYPH.park)} ${dim("human park")}`,
     ];
 };
 // VIS-11 (v1.13): a liveness header for renderFrame — last journal event age + whether the recorded
@@ -807,7 +867,10 @@ const recordedTasks = (graph, rows) => graph.tasks.filter((task) => {
         || 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 renderFrame = (cwd, 
+// No default: the version is the binary's, resolved once by its caller, and a frame that had to
+// invent one would be naming a version nobody can check.
+binaryVersion, now = Date.now(), animationFrame = 0, workerLiveness = new Map(), journalRowsOnly = false, namedRunId) => {
     const g = loadGraph(cwd);
     const record = readRunRecord(cwd, g, namedRunId);
     const runId = record?.runId;
@@ -945,129 +1008,198 @@ const renderFrame = (cwd, now = Date.now(), animationFrame = 0, workerLiveness =
             workerPhases: [...phases.values()].filter((phase) => phase.phase === "worker"),
         };
     }
-    // TTY: cockpit frame composed through src/brand.ts (CLI-DESIGN.md) — dominant run title,
-    // 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.
+    // TTY: the operator-approved task table. The daemon gives this surface a ~110-column pane first;
+    // narrower terminals keep the same facts in stacked rows. Every cut/wrap goes through width.ts.
     const boardColumns = Math.max(COCKPIT_COLUMN_FLOOR, width);
     const dot = dim(" · ");
-    const anyFailed = cells.some((c) => c.redTier);
-    const gaugeCells = 10;
-    const fill = total ? Math.round((done / total) * gaugeCells) : 0;
+    const separator = `  ${dim("│")}  `;
     const tipFailed = tipPhase?.state === "failed";
+    const anyFailed = cells.some((cell) => cell.redTier);
     const progressTone = anyFailed || tipFailed ? fail : tipPhase ? warn : ok;
-    const gauge = (fill ? progressTone("█".repeat(fill)) : "") + (fill < gaugeCells ? dim("░".repeat(gaugeCells - fill)) : "");
+    // Attention and failure wear the ONE amethyst here too, so the header leads with its own glyph:
+    // ✗ once a verdict is in, ! while the tip is still unverified. Colour cannot carry this.
+    const progressGlyph = anyFailed || tipFailed ? GLYPHS.fail : GLYPHS.attention;
+    const tally = tipPhase
+        ? `${progressTone(`${progressGlyph} ${done}/${total} tasks done`)}${dot}${progressTone("run not verified")}`
+        : done === total && total > 0 ? ok(`${done}/${total} done`) : information(`${done}/${total} done`);
     const live = liveness(events, now)
-        .replace(/\bdead\b/, fail("dead"))
-        .replace(/\bfinished\b/, dim("finished"))
-        .replace(/\balive\b/, ok("alive"))
+        .replace(/\bdead\b/u, fail("dead"))
+        .replace(/\bfinished\b/u, dim("finished"))
+        .replace(/\balive\b/u, running("alive"))
         .replaceAll(" · ", dot);
-    const tally = tipPhase
-        ? `${progressTone(`${done}/${total} tasks done`)}${dot}${progressTone("run not verified")}`
-        : `${done}/${total} done`;
-    // 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"]),
+    const facts = [
+        title(runId ?? "no runs yet"),
+        tally,
+        ...(events.length ? [`${events.filter((event) => event.event === "run-resume").length} restarts`] : []),
+        ...(events.length ? [`${events.filter((event) => event.event === "escalation").length} escalations`] : []),
         ...(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}`,
+            : [verify === "verify passed"
+                    ? ok(verify)
+                    : tipFailed ? fail(`${GLYPHS.fail} ${verify}`) : warn(`${GLYPHS.attention} ${verify}`)]),
         ...(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.
+    ].join(separator);
+    // The brand lockup is two rows and stays two rows at every width: the muted chip, and the running
+    // binary's version directly beneath it. The run's own facts continue to the right of both rows and
+    // wrap under themselves — the version can never be pushed off its row by a fact that grew, which
+    // is the whole point of wrapping the facts against their own column rather than the board's.
+    const chipText = " tickmarkr ";
+    const versionText = ` v${binaryVersion}`;
+    const chipCells = cellWidth(chipText);
+    const versionCells = cellWidth(versionText);
+    const lockupCells = Math.max(chipCells, versionCells);
+    const lockupGap = "  ";
+    const lockupGapCells = cellWidth(lockupGap);
+    const factColumns = Math.max(1, boardColumns - lockupCells - lockupGapCells);
+    // No continuation prefix: the lockup gutter below already indents every fact row, so the fact
+    // column starts at the same cell on all of them.
+    const factLines = wrapCells(facts, factColumns);
+    const besideLockup = (lead, factLine) => factLine === undefined ? lead : `${lead}${lockupGap}${factLine}`;
+    const fillLockup = (lead, cells) => `${lead}${" ".repeat(lockupCells - cells)}`;
+    const headerRows = [
+        besideLockup(fillLockup(LIVE.chip(chipText), chipCells), factLines[0]),
+        besideLockup(fillLockup(dim(versionText), versionCells), factLines[1]),
+        ...factLines.slice(2).map((line) => `${" ".repeat(lockupCells + lockupGapCells)}${line}`),
+    ];
     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);
-    // 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) => 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));
-    // 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, pane } = c;
-        const word = statusWord(c);
-        // The alarm reads the SAME evidence the detail phrase names — a worktree delta the daemon proved
-        // counts, or the card would flag a worker it just called alive one line below (OBS-538 review).
-        const staleWorker = livePhase?.phase === "worker"
-            && workerSilenceMs(livePhase, now, workerLiveness.get(t.id)) >= 60_000;
-        const stWord = staleWorker ? warn(word) : merged ? ok(word) : redTier ? fail(word) : st === "failed" || st === "human" ? warn(word) : word;
-        // a fail names its gate in words right here — the one moment gate identity is needed on a row
-        const f = failedGates(states);
-        const human = humanGateSuffix(t, graphTaskStatus(st, t.status), states);
-        const statusCell = stWord +
-            (isStarved ? dot + fail("starved") : "") +
-            (f.length ? dot + fail(f.join(", ")) : "") +
-            (human ? dot + warn("awaiting approval") : "");
-        const taskTitle = titles[i];
-        const taskLabel = `${t.id.padEnd(idW)} ${taskTitle}${" ".repeat(titleW - cellWidth(taskTitle))}  ${statusCell}`;
-        const line1 = livePhase
-            ? `  ${(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 chain = gateChain(states, true);
-        // A finished task blocks nobody — the same journal-folded done-ness the map was built on.
+    const taskSectionSummary = `${done} of ${total} merged · rows in graph order · gates left→right in pipeline order`;
+    const taskSection = `  ${ok("▌")} ${title("TASKS")}   ${dim(taskSectionSummary)}`;
+    const effortByTask = new Map(foldTaskEffort(g.tasks, record && !comparable ? [] : events)
+        .map((task) => [task.taskId, task]));
+    const gateMatrix = (states) => states.map((state) => {
+        const glyph = gateBox(state, true);
+        const tone = state === "pass" ? ok : state === "fail" ? fail : dim;
+        return `${tone(glyph)}  `;
+    }).join("");
+    const gateHeader = GATE_NAMES.map((gate) => fitCells(gate.slice(0, 2), 3)).join("");
+    const noteFor = (cell) => {
+        const { t, st, merged, failureKind, redTier, states, priorGraph, isStarved, phrase, ctx, livePhase, pane } = cell;
+        const effort = effortByTask.get(t.id);
         const blocking = graphTaskStatus(st, t.status) === "done" ? [] : dependents.get(t.id) ?? [];
-        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 }]),
-            // The waiting phrase's reverse direction, and structure for the same reason: a supervisor
-            // deciding what to unblock needs the names, so it wraps beside the blockers rather than being
-            // shed or folded into a count. A finished task blocks nobody.
-            ...(blocking.length ? [{ element: "journal", text: `blocks ${blocking.join(", ")}` }] : []),
-            ...(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
+        const failed = failedGates(states);
+        const human = humanGateSuffix(t, graphTaskStatus(st, t.status), states);
+        return [
+            livePhase ? `${SPINNER[animationFrame % SPINNER.length]} ${phrase ?? "running"}` : "",
+            !livePhase && isStarved ? "starved" : "",
+            // Attention and failure wear the ONE amethyst, so the tier word leads with its own glyph —
+            // ! for warn, ✗ for failed. That is the distinction that survives NO_COLOR and a pipe.
+            !livePhase && !isStarved && !merged
+                ? redTier
+                    ? `${GLYPHS.fail} failed`
+                    : st === "failed" || st === "human"
+                        ? `${GLYPHS.attention} ${phrase ?? (st === "failed" ? "warn" : surfaceStatusWord(st))}`
+                        : phrase ?? surfaceStatusWord(st)
+                : "",
+            redTier && phrase ? phrase : "",
+            priorGraph ? PRIOR_GRAPH_MARKER : "",
+            failed.length ? `failed · ${failed.join(", ")}` : "",
+            human ? "awaiting approval" : "",
+            !merged && failureKind && !phrase?.includes(failureKind) ? failureKind : "",
+            (effort?.parks ?? 0) >= 3 ? `parked ×${effort.parks}` : "",
+            (effort?.reviews ?? 0) > 2 ? `${effort.reviews} review rounds` : "",
+            blocking.length ? `blocks ${blocking.join(", ")}` : "",
+            pane ? `pane ${pane}` : "",
+            ctx !== undefined ? `ctx ${ctx}` : "",
+        ].filter(Boolean).join(" · ");
+    };
+    const staleWorker = (cell) => cell.livePhase?.phase === "worker"
+        && workerSilenceMs(cell.livePhase, now, workerLiveness.get(cell.t.id)) >= 60_000;
+    const tableRows = () => {
+        const idWidth = Math.min(8, Math.max(5, ...cells.map((cell) => cellWidth(cell.t.id))));
+        const areaWidth = 16;
+        const depsWidth = 14;
+        const gatesWidth = GATE_NAMES.length * 3;
+        const channelWidth = boardColumns >= 140 ? 22 : 12;
+        const attemptWidth = 5;
+        const noteWidth = boardColumns >= 140 ? 24 : boardColumns >= 120 ? 20 : 14;
+        const fixed = 4 + idWidth + areaWidth + depsWidth + gatesWidth + 2 + channelWidth + attemptWidth + noteWidth;
+        const taskWidth = boardColumns - fixed;
+        const fitColumn = (text, columns, gap = 2) => fitCells(text, Math.max(1, columns - gap)) + " ".repeat(Math.min(gap, columns - 1));
+        if (taskWidth < 12) {
+            return cells.flatMap((cell) => {
+                const effort = effortByTask.get(cell.t.id);
+                const deps = cell.t.deps.length ? cell.t.deps.join(", ") : "—";
+                const tone = cell.redTier
+                    ? fail
+                    : cell.merged
+                        ? ok
+                        : staleWorker(cell) || cell.st === "failed" || cell.st === "human"
+                            ? warn
+                            : cell.livePhase || cell.st === "running"
+                                ? running
+                                : dim;
+                const machinery = [
+                    `deps ${deps}`,
+                    gateMatrix(cell.states),
+                    cell.channel,
+                    `att ${effort?.dispatches ?? 0}`,
+                ].join("  ");
+                return [
+                    `    ${tone(cell.t.id)}  ${dim(taskArea(cell.t))}  ${sanitizeTaskText(cell.t.title)}`,
+                    ...wrapCells(`    ${dim(machinery)}`, boardColumns, { continuationPrefix: "      " }),
+                    ...wrapCells(`    ${dim(noteFor(cell))}`, boardColumns, { continuationPrefix: "      " }).filter((line) => line.trim()),
+                    "",
+                ];
+            });
+        }
+        const headerRow = `    ${fitColumn("", idWidth, 1)}${fitColumn("area", areaWidth)}${fitColumn("deps", depsWidth)}${fitColumn("task", taskWidth)}${gateHeader}  ${fitColumn("channel", channelWidth)}${fitColumn("att", attemptWidth, 1)}note`;
+        const ruleRow = `    ${"─".repeat(boardColumns - 4)}`;
+        const rows = cells.flatMap((cell) => {
+            const effort = effortByTask.get(cell.t.id);
+            const columns = [
+                wrapCells(cell.t.id, idWidth - 1),
+                wrapCells(taskArea(cell.t), areaWidth - 2),
+                wrapCells(cell.t.deps.length ? cell.t.deps.join(", ") : "—", depsWidth - 2),
+                [sanitizeTaskText(cell.t.title)],
+                [gateMatrix(cell.states)],
+                [cell.channel],
+                [String(effort?.dispatches ?? 0)],
+                wrapCells(noteFor(cell), noteWidth),
+            ];
+            const height = Math.max(...columns.map((column) => column.length));
+            const idTone = cell.redTier
+                ? fail
+                : cell.merged
+                    ? ok
+                    : staleWorker(cell) || cell.st === "failed" || cell.st === "human"
+                        ? warn
+                        : cell.livePhase || cell.st === "running"
+                            ? running
+                            : dim;
+            const titleTone = cell.redTier || cell.livePhase || (effort?.parks ?? 0) >= 3 ? title : dim;
+            return Array.from({ length: height }, (_, index) => `    ${idTone(fitColumn(columns[0][index] ?? "", idWidth, 1))}`
+                + dim(fitColumn(columns[1][index] ?? "", areaWidth))
+                + dim(fitColumn(columns[2][index] ?? "", depsWidth))
+                + titleTone(fitColumn(columns[3][index] ?? "", taskWidth))
+                + fitCells(columns[4][index] ?? "", gatesWidth)
+                + "  "
+                + dim(fitColumn(columns[5][index] ?? "", channelWidth))
+                + dim(fitColumn(columns[6][index] ?? "", attemptWidth, 1))
+                + dim(fitCells(columns[7][index] ?? "", noteWidth)));
+        });
+        return [legend(headerRow), dim(ruleRow), ...rows];
+    };
+    const gatesLegend = legend(`    gates   ${GATE_NAMES.map((gate) => `${gate.slice(0, 2)} ${gate}`).join("  ")}`);
     const effort = effortPanel(g.tasks, record && !comparable ? undefined : events, boardColumns);
     return {
-        content: boardRows([header, hr, gatesLegend, supervisionLegend, "", ...rows, ...nowLine, "", hr, "", ...effort], boardColumns).join("\n"),
+        content: boardRows([
+            ...headerRows,
+            ...nowLine,
+            supervisionLegend,
+            "",
+            taskSection,
+            "",
+            ...tableRows(),
+            gatesLegend,
+            "",
+            rule(boardColumns),
+            "",
+            ...effort,
+        ], boardColumns).join("\n"),
         ...(hotPhase ? { hotPhase } : {}),
         ...(runId ? { runId } : {}),
         workerPhases: [...phases.values()].filter((phase) => phase.phase === "worker"),
@@ -1101,10 +1233,12 @@ 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
+    // ONE manifest read per invocation, here — every frame below names this same version.
+    const binaryVersion = await readBinaryVersion();
+    // The task-table frame owns its own two-row brand lockup; the four-row global banner would
+    // create the second header the approved replacement removes.
     if (!argv.includes("--watch")) {
-        const { content } = renderFrame(cwd, opts.now?.() ?? Date.now(), 0, undefined, false, namedRunId);
-        return visual() ? BANNER + content : content;
+        return renderFrame(cwd, binaryVersion, opts.now?.() ?? Date.now(), 0, undefined, false, namedRunId).content;
     }
     const eventStream = argv.some((arg) => arg === "--events" || arg === "--jsonl" || arg === "--decision-events");
     const webhookUrl = opts.webhookUrl
@@ -1132,14 +1266,21 @@ export async function status(argv, cwd = process.cwd(), opts = {}) {
             }
         }
         : undefined);
-    const observeWorkerOutput = async (active, runId, observedAt) => {
+    // Retiring a task that is no longer running is bookkeeping over data already in hand, so it stays
+    // on the frame path where the board can rely on it every redraw.
+    const retireInactiveWorkers = (active) => {
         const activeIds = new Set(active.map((phase) => phase.taskId));
         for (const taskId of workerLiveness.keys())
             if (!activeIds.has(taskId))
                 workerLiveness.delete(taskId);
+    };
+    const scrapeWorkerOutput = async (active, runId, observedAt) => {
         if (!readWorkerOutput || !runId)
             return;
-        await Promise.all(active.map(async (phase) => {
+        // allSettled, never all: Promise.all resolves the moment ONE pane read rejects, which would
+        // clear the single-flight guard while a sibling read is still hung on its socket and let the
+        // next budget start a second, overlapping scrape. Every read must settle before the guard drops.
+        await Promise.allSettled(active.map(async (phase) => {
             const output = await readWorkerOutput(phase.taskId, phase.attempt, runId);
             if (output === undefined)
                 return;
@@ -1162,6 +1303,21 @@ export async function status(argv, cwd = process.cwd(), opts = {}) {
             prior.snapshot = snapshot;
         }));
     };
+    // The scrape's own clock, and the reason a hung pane cannot freeze the board: it is STARTED here
+    // and never awaited, so the frame loop walks straight past it. `scrapeInFlight` is what keeps a
+    // scrape that outlives its budget from being joined by a second one — a wedged pane read would
+    // otherwise accumulate one outstanding socket read per elapsed budget for as long as it hangs.
+    let scrapeInFlight = false;
+    let lastScrapeAt = Number.NEGATIVE_INFINITY;
+    const scheduleWorkerScrape = (frame, observedAt) => {
+        if (scrapeInFlight || observedAt - lastScrapeAt < SCRAPE_MS)
+            return;
+        scrapeInFlight = true;
+        lastScrapeAt = observedAt;
+        void scrapeWorkerOutput(frame.workerPhases, frame.runId, observedAt)
+            .catch(() => undefined)
+            .finally(() => { scrapeInFlight = false; });
+    };
     let decisionRunId;
     let journalCursor = 0;
     const consumeDecisionEvents = () => {
@@ -1224,10 +1380,10 @@ export async function status(argv, cwd = process.cwd(), opts = {}) {
                 }
             }
             else {
-                frame = renderFrame(cwd, nowMs, i, workerLiveness, true, namedRunId);
+                frame = renderFrame(cwd, binaryVersion, nowMs, i, workerLiveness, true, namedRunId);
                 if (tty) {
                     updateTitle(frame.hotPhase, nowMs);
-                    process.stdout.write(`\x1b[2J\x1b[H${BANNER}${frame.content}\n${legend(` watching · refresh ${REFRESH_MS / 1000}s · ^C to quit`)}`);
+                    process.stdout.write(`\x1b[2J\x1b[H${frame.content}\n${legend(` watching · refresh ${FRAME_MS / 1000}s · ^C to quit`)}`);
                 }
                 else {
                     process.stdout.write(frame.content + sep);
@@ -1236,9 +1392,11 @@ export async function status(argv, cwd = process.cwd(), opts = {}) {
                     frames.push(frame.content);
             }
             if (i + 1 < iterations) {
-                if (frame)
-                    await observeWorkerOutput(frame.workerPhases, frame.runId, nowMs);
-                await sleep(REFRESH_MS);
+                if (frame) {
+                    retireInactiveWorkers(frame.workerPhases);
+                    scheduleWorkerScrape(frame, nowMs);
+                }
+                await sleep(FRAME_MS);
             }
         }
     }

package/dist/compile/collateral.d.ts

@@ -1,5 +1,30 @@
 import { type TickmarkrConfig } from "../config/config.js";
 import { type Task } from "../graph/schema.js";
+/**
+ * OBS-547: the FULL per-task collateral prediction, uncapped. ONE map is computed per run (daemon.ts,
+ * at run start) and handed whole to the scope gate, so a hit the plan display hides is still there
+ * when the gate asks about it. The lint lines below are a capped VIEW of this same map — never a
+ * second scan. Tasks with no hits are absent.
+ */
+export declare function collateralHits(tasks: ReadonlyArray<Pick<Task, "id" | "files">>, repoRoot: string): Map<string, string[]>;
+/** The verbatim repair an authoring defect owes: the files[] lines the spec is missing. */
+export declare function filesRepair(taskId: string, paths: ReadonlyArray<string>): string;
+export interface ScopeCollateralVerdict {
+    /** every hard offender was predicted ⇒ authoring defect, repair pre-written, no attempt charged */
+    authoring: boolean;
+    /** the offenders the map had already named */
+    predicted: string[];
+    /** the offenders it had not — the lint's blind spots, recorded as evidence rather than folklore */
+    missed: string[];
+    repair: string;
+}
+/**
+ * OBS-547: cross-reference at the RED. The gate supplies specificity (the paths actually touched),
+ * the prediction supplies classification — so there are no false positives to fear and no refusal to
+ * author. Feed this the FULL map for the task: a classifier bounded by the display cap calls a
+ * predicted 21st hit a quality failure.
+ */
+export declare function classifyScopeOffenders(taskId: string, hard: ReadonlyArray<string>, predicted: ReadonlyArray<string>): ScopeCollateralVerdict;
 /**
  * Return human-readable scope-lint lines for plan output (no `!` prefix — plan owns that).
  * Each line names the task id and at least one missing collateral test path.