tickmarkr 1.93.0 → 1.97.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 { brandChip, dim, fail, GLYPHS, legend, ok, rule, title, warn } from "../../brand.js";
 import { DEFAULT_CONFIG, loadConfig } from "../../config/config.js";
 import { HerdrDriver } from "../../drivers/herdr.js";
 import { formatOwnedName, parseOwnedName, } from "../../drivers/types.js";
@@ -8,11 +8,12 @@ import { blockedTasks, graphDefinitionHash, loadGraph, stateDirName } from "../.
 import { GATE_NAMES } from "../../graph/schema.js";
 import { foldActivity } from "../../run/activity.js";
 import { Journal, engagementComparable, isQualityFailureParkKind, recordedTaskFailureKind, runHasEnded, } from "../../run/journal.js";
+import { normalizeGateOutcome } from "../../run/outcome.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 { 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;
@@ -216,6 +217,18 @@ const livePhases = (events) => {
         const active = live.get(event.taskId);
         if (!active)
             continue;
+        // The daemon proves a silent worker alive by hashing its worktree and journals that proof as
+        // `worker-contact`. It is evidence ABOUT the live phase, never its outcome, so it decorates the
+        // entry and is deliberately absent from the `matched` set below.
+        if (event.event === "worker-contact" && active.phase === "worker") {
+            const at = Date.parse(event.ts);
+            if (Number.isFinite(at)) {
+                active.lastContactAt = at;
+                if (typeof event.data.evidence === "string")
+                    active.contactEvidence = event.data.evidence;
+            }
+            continue;
+        }
         const gate = active.gate ?? phaseGate(active.phase);
         const matched = (active.phase === "worker" && event.event === "worker-result")
             || (active.phase === "gates" && event.event === "gate-result")
@@ -249,16 +262,44 @@ const fmtElapsed = (ms) => {
     const hours = Math.floor(minutes / 60);
     return `${hours}h${minutes % 60}m${seconds % 60}s`;
 };
-const workerOutputAge = (phase, now, worker) => now - (worker?.phaseStartedAt === phase.startedAt && worker.hasOutput ? worker.lastOutputAt : phase.startedAt);
+/**
+ * The freshest evidence that this worker is alive, and what produced it. ONE derivation, because the
+ * two readers of worker silence drifted apart the first time this was fixed: OBS-538 taught the detail
+ * phrase to read the daemon's journaled `worker-contact` and left the stall ALARM (`staleWorker`)
+ * clocking pane bytes alone. For the exact population OBS-538 is about — a headless channel (codex
+ * `sub`, an API worker) that prints nothing to its pane all run, so `hasOutput` never becomes true —
+ * the alarm then warn-painted every live row from 60s onward while line 2 of the same card read
+ * "last contact 10s ago (worktree)". A card cannot contradict itself if both halves ask this.
+ */
+const workerActivity = (phase, worker) => {
+    const outputAt = worker?.phaseStartedAt === phase.startedAt && worker.hasOutput ? worker.lastOutputAt : undefined;
+    const contactAt = phase.lastContactAt;
+    if (outputAt !== undefined && (contactAt === undefined || outputAt >= contactAt))
+        return { at: outputAt, source: "output" };
+    if (contactAt !== undefined)
+        return { at: contactAt, source: "contact" };
+    // Nothing has been observed since the phase began: silence is the whole phase, which is what both
+    // the phrase ("no output 14m51s") and the alarm's 60s threshold must measure.
+    return { at: phase.startedAt, source: "none" };
+};
+/** How long this worker has been silent by the freshest evidence available — the alarm's clock. */
+const workerSilenceMs = (phase, now, worker) => now - workerActivity(phase, worker).at;
+/**
+ * What a live worker row says about silence. Pane bytes are not more truthful than a worktree delta,
+ * only different, so the row names whichever evidence is fresher AND names its source.
+ */
 const phaseDetail = (phase, now, worker) => {
     const elapsed = fmtElapsed(now - phase.startedAt);
     if (phase.phase !== "worker")
         return `${phaseLabel(phase)} · ${elapsed} elapsed`;
-    const age = fmtElapsed(workerOutputAge(phase, now, worker));
-    const output = worker?.phaseStartedAt === phase.startedAt && worker.hasOutput
-        ? `last output ${age} ago`
-        : `no output ${age}`;
-    return `${phaseLabel(phase.phase)} · ${elapsed} elapsed · ${output}`;
+    const head = `${phaseLabel(phase.phase)} · ${elapsed} elapsed`;
+    const activity = workerActivity(phase, worker);
+    const age = fmtElapsed(now - activity.at);
+    if (activity.source === "output")
+        return `${head} · last output ${age} ago`;
+    if (activity.source === "contact")
+        return `${head} · last contact ${age} ago (${phase.contactEvidence ?? "worktree"})`;
+    return `${head} · no output ${age}`;
 };
 const attemptStartIdx = (events, taskId) => {
     let idx = -1;
@@ -335,11 +376,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
@@ -358,19 +394,48 @@ 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);
+/** Columns the machine row always spends on the task title, however long its machinery segment runs. */
+const MACHINE_TITLE_FLOOR = 24;
+// 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
@@ -378,6 +443,95 @@ const detailText = (segments, budget) => {
  * stay blank — `wrapCells` always answers at least one row.
  */
 const boardRows = (lines, columns) => lines.flatMap((line) => wrapCells(line, columns, { continuationPrefix: "  " }));
+/**
+ * A funded review round is a review that actually returned a verdict. `passed` and `failed` are the
+ * only two arms of the gate vocabulary that carry one (outcome.ts:23) — every other arm states why
+ * nothing ran, so counting it would bill the task for a reviewer it never spent.
+ */
+const REVIEW_VERDICTS = new Set(["passed", "failed"]);
+/**
+ * Fold the panel from parsed JournalEvent rows only. In particular, a review round is every
+ * gate-result whose typed gate field is `review` and whose outcome is a verdict, passed or failed.
+ * `review-raw-*` artifacts are unparseable-verdict captures, not round markers, and neither raw
+ * journal strings nor run-directory filenames participate in this count.
+ *
+ * A decline is not a round, and it is NOT readable off `data.skipped`: that field is one of four
+ * encodings the shipped record already writes, and the two it misses are both live on disk — a
+ * pre-R3 review decline states itself only as `{ pass: true, details: "skipped — …" }`, and a
+ * canonical row states it as `outcome.kind: "declined"`. Reading the flag alone bills both as funded
+ * rounds and can reorder the top four. `normalizeGateOutcome` is the ONE reader of all four
+ * encodings (outcome.ts:125), so the panel asks it rather than re-deriving a fifth answer; a row it
+ * cannot read stays `unavailable` and therefore uncounted, fail-closed. `replayMeasurement` is
+ * orthogonal to the outcome — a resume re-observing an interrupted round reports a real verdict —
+ * so it stays an explicit exclusion, the same clause journal.ts:110 uses.
+ */
+const foldTaskEffort = (tasks, events) => {
+    const order = new Map(tasks.map((task, index) => [task.id, index]));
+    const effort = new Map(tasks.map((task) => [task.id, {
+            taskId: task.id,
+            dispatches: 0,
+            reviews: 0,
+            parks: 0,
+            total: 0,
+        }]));
+    for (const event of events) {
+        if (!event.taskId)
+            continue;
+        const task = effort.get(event.taskId);
+        if (!task)
+            continue;
+        if (event.event === "task-dispatch")
+            task.dispatches += 1;
+        else if (event.event === "gate-result" && event.data.gate === "review"
+            && event.data.replayMeasurement !== true
+            && REVIEW_VERDICTS.has(normalizeGateOutcome(event.data.outcome ?? event.data).kind))
+            task.reviews += 1;
+        else if (event.event === "task-human")
+            task.parks += 1;
+        task.total = task.dispatches + task.reviews + task.parks;
+    }
+    return [...effort.values()].sort((left, right) => right.total - left.total
+        || order.get(left.taskId) - order.get(right.taskId));
+};
+/**
+ * Prototype panel, fitted by the cockpit's display-cell authority before board-wide wrapping.
+ *
+ * `undefined` events mean this run's journal describes a DIFFERENT graph, so it funds no claim here.
+ * Folding it — or folding an empty array in its place — would state zero dispatches, reviews and
+ * parks for a run that recorded all three, which is unavailable evidence dressed as an answer. Same
+ * clause the verify claim uses (`verify unavailable`): no claim beats a false zero.
+ */
+const effortPanel = (tasks, events, columns) => {
+    if (!events) {
+        return [
+            `  ${ok("▌")} ${title("WHERE THE EFFORT WENT")}`,
+            legend(`   dispatch · review · park counts unavailable — ${NOT_COMPARABLE_CLAIM}`),
+        ];
+    }
+    const top = foldTaskEffort(tasks, events).slice(0, 4);
+    const maxTotal = Math.max(1, ...top.map((task) => task.total));
+    const idColumns = Math.max(2, Math.min(16, Math.max(...top.map((task) => cellWidth(task.taskId)))));
+    const rows = top.map((task) => {
+        const counts = `${task.dispatches} dispatch · ${task.reviews} review · ${task.parks} park`;
+        const prefix = `    ${fitCells(task.taskId, idColumns)} `;
+        const barColumns = Math.min(46, Math.max(3, columns - cellWidth(prefix) - 2 - cellWidth(counts)));
+        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)));
+        return `${prefix}${fitCells(stack, barColumns)}  ${counts}`;
+    });
+    return [
+        `  ${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")}`,
+    ];
+};
 // 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
@@ -724,6 +878,17 @@ const renderFrame = (cwd, now = Date.now(), animationFrame = 0, workerLiveness =
     // (a recompiled graph's journal must not animate the wrong tasks); with no or stale journal the
     // dep-waiting cells still derive from the effective graph statuses.
     const activity = foldActivity(comparable ? events : [], effective.tasks);
+    // RULING-v189-scope §14c: a card answers BOTH supervisor questions. `foldActivity` names what a
+    // task waits FOR; this names what waits ON it. Read from `effective.tasks` — whose statuses are
+    // the journal's replay, never the compiled graph's — so a dependent the record says is done stops
+    // being named, and a task all of whose dependents are done acquires no entry at all.
+    const dependents = new Map();
+    for (const task of effective.tasks) {
+        if (task.status === "done")
+            continue;
+        for (const dep of task.deps)
+            dependents.set(dep, [...(dependents.get(dep) ?? []), task.id]);
+    }
     const unicode = visual();
     const divider = unicode ? " · " : " / ";
     // SUP-01: derived by stat() alone, from THIS frame's clock. status stays a reader — nothing here
@@ -783,7 +948,12 @@ const renderFrame = (cwd, now = Date.now(), animationFrame = 0, workerLiveness =
             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}${pane ? `  pane ${pane}` : ""}`;
-            return `${prefix}${shortGoal(t.title, Math.max(0, width - prefix.length - suffix.length))}${suffix}`;
+            // The machine row carries the cockpit's own law (see LAYOUT_PRIORITY and the two-line card):
+            // identity is never what a crowded row sheds. `dep-waiting on …` grows with fan-in and alone
+            // can exceed the terminal width, and the pre-floor math paid for it out of the TITLE — 20 of
+            // 41 rows in a live 41-task run named no task at all. These rows already overflow `width`
+            // (a pane name is 60 columns on its own), so the floor costs wrapping, never the graph.
+            return `${prefix}${shortGoal(t.title, Math.max(MACHINE_TITLE_FLOOR, width - prefix.length - suffix.length))}${suffix}`;
         });
         const zone = journalRowsOnly ? `${divider}zone ${localZoneLabel(zoneReference)}` : "";
         const header = runId
@@ -797,120 +967,148 @@ 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)) : "");
-    const live = liveness(events, now)
-        .replace(/\bdead\b/, fail("dead"))
-        .replace(/\bfinished\b/, dim("finished"))
-        .replace(/\balive\b/, ok("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"]),
+        : done === total && total > 0 ? ok(`${done}/${total} done`) : `${done}/${total} done`;
+    const live = liveness(events, now)
+        .replace(/\bdead\b/u, fail("dead"))
+        .replace(/\bfinished\b/u, dim("finished"))
+        .replace(/\balive\b/u, ok("alive"))
+        .replaceAll(" · ", dot);
+    const header = [
+        brandChip(" tickmarkr "),
+        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}`,
         ...(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);
     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);
-        const staleWorker = livePhase?.phase === "worker"
-            && workerOutputAge(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 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 failed = 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);
-        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 [
+            livePhase ? `${SPINNER[animationFrame % SPINNER.length]} ${phrase ?? "running"}` : "",
+            !livePhase && isStarved ? "starved" : "",
+            !livePhase && !isStarved && !merged ? redTier ? "failed" : phrase ?? (st === "failed" ? "warn" : 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 : 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 : 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], boardColumns).join("\n"),
+        content: boardRows([
+            header,
+            ...nowLine,
+            supervisionLegend,
+            "",
+            taskSection,
+            "",
+            ...tableRows(),
+            gatesLegend,
+            "",
+            rule(boardColumns),
+            "",
+            ...effort,
+        ], boardColumns).join("\n"),
         ...(hotPhase ? { hotPhase } : {}),
         ...(runId ? { runId } : {}),
         workerPhases: [...phases.values()].filter((phase) => phase.phase === "worker"),
@@ -944,10 +1142,10 @@ 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
+    // The task-table frame owns its compact one-line brand chip; 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, 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
@@ -1070,7 +1268,7 @@ export async function status(argv, cwd = process.cwd(), opts = {}) {
                 frame = renderFrame(cwd, 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 ${REFRESH_MS / 1000}s · ^C to quit`)}`);
                 }
                 else {
                     process.stdout.write(frame.content + sep);