tickmarkr 2.5.3 → 2.5.5

package/dist/tui/cockpit/board.js

@@ -0,0 +1,346 @@
+import { GATE_NAMES } from "../../graph/schema.js";
+import { cellWidth, sliceCells } from "./width.js";
+/* ------------------------------------------------------------------------ */
+/* BD-1 — the approved task board (RULING-231-19 §2, OBS-965 add.2).         */
+/*                                                                           */
+/* A pure, Ink-free port of .overseer/design-prototypes/tasks-redesign.mjs.  */
+/* Palette, glyphs and column arithmetic are the prototype's constants; the  */
+/* two contract corrections are the declaration-order subtitle and the       */
+/* four-bucket green run-ended header. Facts come from the fold's snapshot   */
+/* and the graph the Run view already receives — never from the journal.     */
+/* ------------------------------------------------------------------------ */
+// The prototype closes every span with a full reset (ESC[0m). Inside Ink that reset would also drop
+// the shell's own foreground and background for the rest of the row, so spans close with the default
+// foreground/background codes instead — chalk re-opens the enclosing colour after each of them.
+const E = "\x1b[", R = `${E}0m`, CLOSE = `${E}39m`;
+const c = (n) => (s) => `${E}38;5;${n}m${s}${CLOSE}`;
+const bgc = (f, b) => (s) => `${E}38;5;${f};48;5;${b}m${s}${E}39;49m`;
+const boldc = (s) => `${E}1m${s}${E}22m`;
+const plain = (s) => s;
+/** The prototype's palette (tasks-redesign.mjs:24-30): xterm-256 indices, stated once. */
+export const BOARD_PALETTE = { chrome: 238, mute: 243, body: 252, faint: 240, accent: 75, pass: 71, fail: 174, warn: 179, park: 140 };
+/** The seven gates, declaration order; every cell is exactly CELL columns wide. */
+export const BOARD_GATES = GATE_NAMES;
+export const BOARD_CELL = 3;
+export const BOARD_AREA_W = 16;
+export const BOARD_DEPS_W = 14;
+export const BOARD_NOTE_RESERVE = 28;
+export const BOARD_FIXED = 4 + 5 + BOARD_AREA_W + BOARD_DEPS_W + BOARD_CELL * BOARD_GATES.length + 2 + 5;
+export const BOARD_EFFORT_BAR_MAX = 46;
+/** The board's own key hints — only the ones the Run view handles; nothing advertised is inert. */
+export const BOARD_KEYS = ["↑↓ move", "↵ task detail", "q quit"];
+export const boardBand = (columns) => (columns >= 150 ? "full" : columns >= 110 ? "wrap" : "stacked");
+export const stripBoardAnsi = (s) => s.replace(/\x1b\[[0-9;]*m/g, "");
+const vw = (s) => cellWidth(stripBoardAnsi(s));
+const pad = (s, n) => s + " ".repeat(Math.max(0, n - vw(s)));
+/** ANSI-aware clip at `n` visible cells (prototype `clip`), cut on a grapheme boundary so a
+ * double-cell glyph never crosses the limit and an emoji is never emitted as a lone surrogate;
+ * a clipped line closes its own colour. */
+export function clipBoard(s, n) {
+    const { head, tail } = sliceCells(s, n);
+    return tail && head.includes("\x1b") ? `${head}${R}` : head;
+}
+// ── AREA — derived from files[], never declared (prototype :48-94) ────────────────────────────────
+const AREAS = [
+    ["SPEC", [/^src\/(compile|graph|plan)\//]],
+    ["FLEET", [/^src\/(route|config|adapters)\//]],
+    ["RUN", [/^src\/(run|drivers|eval)\//]],
+    ["GATE", [/^src\/gates\//]],
+    ["UI", [/^src\/(cli|tui|report)\//, /^src\/brand\.ts/]],
+    ["DOCS", [/^(docs|skills)\//]],
+    ["REPO", [/^(scripts|schema)\//, /^\.github\//, /^tests\/(lint|repo|helpers)\//, /^(vitest\.config|package\.json|tsconfig)/]],
+];
+export const BOARD_AREA_ORDER = AREAS.map(([n]) => n);
+const expandBraces = (p) => {
+    const m = /^(.*?)\{([^}]*)\}(.*)$/.exec(p);
+    return m ? m[2].split(",").flatMap((alt) => expandBraces(`${m[1]}${alt.trim()}${m[3]}`)) : [p];
+};
+const areaOf = (path) => {
+    for (const [name, res] of AREAS)
+        if (res.some((re) => re.test(path)))
+            return name;
+    return null;
+};
+/** {codes, unmapped} — abstentions applied, set semantics, misses reported rather than dropped. */
+export function areasFor(files) {
+    const unmapped = [];
+    const hit = new Set(), softTest = new Set(), softCli = new Set();
+    for (const f of files.flatMap(expandBraces)) {
+        const a = areaOf(f) ?? areaOf(f.replace(/^tests\//, "src/"));
+        if (!a) {
+            unmapped.push(f);
+            continue;
+        }
+        if (/^tests\//.test(f))
+            softTest.add(a);
+        else if (/^src\/cli\//.test(f))
+            softCli.add(a);
+        else
+            hit.add(a);
+    }
+    let codes = [...hit];
+    if (!codes.length)
+        codes = [...softCli];
+    if (!codes.length)
+        codes = [...softTest];
+    codes.sort((x, y) => BOARD_AREA_ORDER.indexOf(x) - BOARD_AREA_ORDER.indexOf(y));
+    return { codes, unmapped };
+}
+const hm = (ms) => `${Math.floor(ms / 3.6e6)}h${String(Math.floor((ms % 3.6e6) / 6e4)).padStart(2, "0")}m`;
+const ago = (ms) => (ms < 6e4 ? "just now" : ms < 3.6e6 ? `${Math.round(ms / 6e4)}m ago` : `${Math.round(ms / 3.6e6)}h ago`);
+const isDone = (t) => t !== undefined && (t.merged || t.state === "completed");
+/** The prototype's frame, sectioned. `renderBoard` joins it row for row. */
+export function boardFrame(input, width) {
+    const W = Math.max(1, Math.floor(width));
+    const col = input.colour === false ? () => plain : c;
+    const bold = input.colour === false ? plain : boldc;
+    const bg = input.colour === false ? () => plain : bgc;
+    const chrome = col(BOARD_PALETTE.chrome), mute = col(BOARD_PALETTE.mute), body = col(BOARD_PALETTE.body), faint = col(BOARD_PALETTE.faint);
+    const accent = col(BOARD_PALETTE.accent), pass = col(BOARD_PALETTE.pass), fail = col(BOARD_PALETTE.fail), warn = col(BOARD_PALETTE.warn), park = col(BOARD_PALETTE.park);
+    const rule = (n = W) => chrome("─".repeat(n));
+    const s = input.snapshot;
+    const byId = new Map(s.tasks.map((t) => [t.id, t]));
+    // The fold's comparability boundary: a graph whose identity the journal did not record (a
+    // recompile) lends nothing — no titles, deps, declarations or denominator — so the rows are the
+    // journal's tasks alone and every gate reads as declared.
+    const graphTasks = input.graph?.tasks && s.comparable ? input.graph.tasks : s.tasks.map((t) => ({ id: t.id, title: t.title ?? "", deps: [], files: [], gates: undefined }));
+    const uncomparable = input.graph !== undefined && !s.comparable;
+    const doneIds = new Set(s.tasks.filter(isDone).map((t) => t.id));
+    const t0 = s.firstEventAt ? Date.parse(s.firstEventAt) : input.now;
+    const t1 = s.lastEventAt ? Date.parse(s.lastEventAt) : input.now;
+    const wide = W >= 118;
+    const top = [];
+    top.push(`${bg(16, 2)(" tickmarkr ")} ${bold(input.runId)}  ${chrome("│")}  ` +
+        `${pass(`${doneIds.size}/${graphTasks.length} done`)}  ` +
+        (wide
+            ? `${chrome("│")}  ${warn(`${s.resumes} restarts`)}  ${chrome("│")}  ${fail(`${s.escalations} escalations`)}  `
+            : `${chrome("│")}  ${fail(`${s.escalations} esc`)}  `) +
+        `${chrome("│")}  ${mute(`${hm(t1 - t0)}${wide ? ` · ${ago(input.now - t1)}` : ""}`)}` +
+        `${input.live ? `  ${chrome("│")}  ${pass("● LIVE")}` : ""}`);
+    top.push("");
+    // RUN ENDED — the four-bucket rule (RULING-231-19 §2): green needs failed, human, blocked and
+    // pending every one empty AND the tip not failed; "tip verified" alone never borrows the colour.
+    if (s.latestRunEnd) {
+        const buckets = ["failed", "human", "blocked", "pending"].map((k) => [k, s.buckets[k]]);
+        const unknown = buckets.filter(([, v]) => v === undefined).map(([k]) => k);
+        const parked = buckets.filter(([, v]) => v !== undefined && v.length > 0).map(([k, v]) => `${k} ${v.join(",")}`);
+        const tally = `${doneIds.size} merged · ${(s.buckets.human ?? []).length} parked · ${(s.buckets.blocked ?? []).length} dep-blocked`;
+        const green = !unknown.length && !parked.length && (s.currentTip === "passed" || s.currentTip === "not required");
+        const now = green
+            ? `${pass("RUN ENDED — GREEN")}  ${mute(`tip ${s.currentTip} · ${tally}`)}`
+            : s.currentTip === "failed"
+                ? `${fail("RUN ENDED — TIP VERIFY FAILED")}  ${mute(tally)}`
+                : parked.length || unknown.length
+                    ? `${fail("RUN ENDED — NOT GREEN")}  ${mute(`${[...parked, ...unknown.map((k) => `${k} bucket unknown`)].join(" · ")} · ${tally}`)}`
+                    : `${warn("RUN ENDED — TIP NOT VERIFIED")}  ${mute(`tip ${s.currentTip} · ${tally}`)}`;
+        top.push(`  ${accent("▌")} ${bold("NOW")}        ${now}`);
+        top.push("");
+    }
+    top.push(`  ${accent("▌")} ${bold("TASKS")}   ${mute(uncomparable ? `${doneIds.size} of ${graphTasks.length} journal tasks merged · graph not comparable` : `${doneIds.size} of ${graphTasks.length} merged in this graph`)}` +
+        (wide ? mute(" · rows in dispatch order · gates left→right in declaration order") : ""));
+    top.push("");
+    // ── aligned gate header: each label truncated to the cell it owns (prototype :382-394) ──
+    const elastic = Math.max(30, W - BOARD_FIXED - BOARD_NOTE_RESERVE);
+    const LBL = Math.min(46, Math.max(18, Math.round(elastic * 0.62)));
+    const CHAN = Math.min(26, Math.max(12, elastic - LBL));
+    const gateHead = BOARD_GATES.map((g) => faint(pad(g.slice(0, BOARD_CELL - 1), BOARD_CELL))).join("");
+    const gateHeader = {
+        head: `    ${pad("", 5)}${pad(faint("area"), BOARD_AREA_W)}${pad(faint("deps"), BOARD_DEPS_W)}${pad(faint("task"), LBL)}`,
+        strip: gateHead,
+        tail: `  ${pad(faint("channel"), CHAN)}${pad(faint("att"), 5)}${faint("note")}`,
+    };
+    const headerRule = `    ${chrome("─".repeat(Math.min(W - 4, 5 + LBL + BOARD_CELL * BOARD_GATES.length + 2 + CHAN + 5 + 30)))}`;
+    const areaTally = new Set(), unmappedPaths = new Set();
+    const rows = [];
+    for (const g of graphTasks) {
+        const t = byId.get(g.id);
+        const declared = new Set(g.gates ?? BOARD_GATES);
+        const cell = (k) => {
+            const st = t?.gates[k]?.state;
+            return st === "passed" ? true : st === "failed" ? false : undefined;
+        };
+        const strip = BOARD_GATES.map((k) => {
+            const v = cell(k);
+            return pad(v === true ? pass("✔") : v === false ? fail("✖") : !declared.has(k) ? faint("─") : faint("·"), BOARD_CELL);
+        }).join("");
+        const unrun = BOARD_GATES.filter((k) => declared.has(k) && cell(k) === undefined).length;
+        const failedGates = BOARD_GATES.filter((k) => cell(k) === false);
+        const parks = t?.parks ?? 0, reviews = t?.reviewRounds ?? 0, attempts = t?.dispatches ?? 0;
+        const hot = parks > 3 || failedGates.length > 0 || unrun > 2;
+        const marker = input.selection === g.id ? `  ${accent("❯")} ` : "    ";
+        const id = hot ? accent(bold(pad(g.id, 5))) : mute(pad(g.id, 5));
+        const { codes: acodes, unmapped: aun } = areasFor(g.files ?? []);
+        acodes.forEach((a) => areaTally.add(a));
+        aun.forEach((u) => unmappedPaths.add(u));
+        let alabel = acodes.length ? acodes.join("+") : (aun.length ? "UNMAPPED" : "—");
+        if (alabel.length > BOARD_AREA_W - 2) {
+            const keep = [];
+            for (const a of acodes) {
+                if ([...keep, a].join("+").length + 3 > BOARD_AREA_W - 2)
+                    break;
+                keep.push(a);
+            }
+            alabel = `${keep.join("+")}+${acodes.length - keep.length}`;
+        }
+        const area = pad(hot ? body(alabel) : faint(alabel), BOARD_AREA_W);
+        const depIds = g.deps ?? [];
+        const depText = depIds.length ? depIds.join(",") : "—";
+        const depLabel = depText.length <= BOARD_DEPS_W - 2
+            ? depText
+            : depIds.length > 1 ? `${depIds[0]}+${depIds.length - 1}` : `${depIds[0].slice(0, BOARD_DEPS_W - 3)}…`;
+        const deps = pad(faint(depLabel), BOARD_DEPS_W);
+        const titleText = sliceCells(g.title ?? "", LBL - 2).head;
+        const title = hot ? body(pad(titleText, LBL)) : faint(pad(titleText, LBL));
+        const note = [
+            parks >= 3 ? park(`◍ parked ×${parks}`) : "",
+            reviews > 2 ? warn(`↻ ${reviews} review rounds`) : "",
+            failedGates.length ? fail(`✖ ${failedGates.join(",")}`) : "",
+            !attempts
+                ? (() => {
+                    const blockers = depIds.filter((d) => !doneIds.has(d));
+                    if (!blockers.length)
+                        return faint("queued");
+                    const room = Math.max(10, W - BOARD_FIXED - LBL - CHAN);
+                    let shown = blockers, dropped = 0;
+                    while (shown.length > 1 && `waiting on ${shown.join(", ")}`.length + (dropped ? 5 : 0) > room) {
+                        shown = shown.slice(0, -1);
+                        dropped = blockers.length - shown.length;
+                    }
+                    return faint(`waiting on ${shown.join(", ")}${dropped ? ` +${dropped}` : ""}`);
+                })()
+                : unrun === declared.size ? faint("in flight")
+                    : unrun > 2 ? faint(`${declared.size - unrun}/${declared.size} gates run`) : "",
+        ].filter(Boolean);
+        rows.push({
+            id: g.id,
+            head: `${marker}${id}${area}${deps}${title}`,
+            strip,
+            tail: `  ${pad(mute(sliceCells(t?.channel ?? "—", CHAN - 2).head), CHAN)}${pad(mute(String(attempts)), 5)}`,
+            note: note.join(mute(" · ")),
+            noteParts: note,
+        });
+    }
+    const bottom = [];
+    bottom.push("");
+    bottom.push(`    ${faint("area")}    ${BOARD_AREA_ORDER.map((a) => (areaTally.has(a) ? body(a) : faint(a))).join(mute(" · "))}${unmappedPaths.size ? mute("   ") + fail(`${unmappedPaths.size} unmapped`) : ""}`);
+    if (unmappedPaths.size)
+        bottom.push(`    ${pad("", 8)}${fail("UNMAPPED")} ${mute([...unmappedPaths].slice(0, 3).join("  "))}${unmappedPaths.size > 3 ? mute(`  +${unmappedPaths.size - 3}`) : ""}`);
+    bottom.push(`    ${faint("gates")}   ${BOARD_GATES.map((k) => `${body(k.slice(0, BOARD_CELL - 1))} ${mute(k)}`).join("  ")}`);
+    bottom.push(`    ${faint("     ")}   ${pass("✔")} ${mute("passed")}   ${fail("✖")} ${mute("failed")}   ${faint("·")} ${mute("pending")}   ${faint("─")} ${mute("not declared (acceptance and review are the optional two)")}`);
+    bottom.push("");
+    // the gap is stated, never silently skipped — derived, so it cannot go stale
+    const retired = s.tasks.map((t) => t.id).filter((id) => !graphTasks.some((g) => g.id === id)).sort();
+    // A retired task is still one of the fold's tasks, so the selection can land on it: its row carries
+    // the same marker the graph rows do — paint and navigation cannot diverge.
+    for (const id of retired)
+        bottom.push(`${input.selection === id ? `  ${accent("❯")} ` : "    "}${faint(id)}  ${faint("— not in this graph (retired at compile)")}`);
+    if (retired.length)
+        bottom.push("");
+    bottom.push(rule());
+    bottom.push("");
+    // ── where the run actually spent itself, per task (prototype :477-491) ──
+    const worst = graphTasks.map((g) => { const t = byId.get(g.id); return { id: g.id, p: t?.parks ?? 0, r: t?.reviewRounds ?? 0, a: t?.dispatches ?? 0 }; })
+        .sort((x, y) => (y.p + y.r + y.a) - (x.p + x.r + x.a)).slice(0, 4);
+    bottom.push(`  ${accent("▌")} ${bold("WHERE THE EFFORT WENT")}   ${mute(`dispatches · review rounds · human parks — top ${worst.length} of ${graphTasks.length} tasks`)}`);
+    bottom.push("");
+    const maxTot = Math.max(...worst.map((w) => w.a + w.r + w.p), 1);
+    const barw = Math.min(BOARD_EFFORT_BAR_MAX, Math.max(16, W - 60));
+    for (const w of worst) {
+        // The prototype rounds each segment on its own; the three share one budget, so the cells rounding
+        // pushes past barw come off the longest segment (4·1·1 at 46 rounds to 31+8+8) — never past the maximum.
+        const len = [w.a, w.r, w.p].map((n) => Math.round((n / maxTot) * barw));
+        for (let over = len.reduce((x, y) => x + y, 0) - barw; over > 0; over--)
+            len[len.indexOf(Math.max(...len))]--;
+        const seg = (n, paint) => paint("█".repeat(n));
+        bottom.push(`    ${accent(pad(w.id, 6))}${seg(len[0], accent)}${seg(len[1], warn)}${seg(len[2], park)}  ` +
+            `${mute(`${w.a} dispatch`)}${mute(" · ")}${warn(`${w.r} review`)}${mute(" · ")}${park(`${w.p} park`)}`);
+    }
+    bottom.push("");
+    bottom.push(`    ${mute("legend")}  ${accent("█")} ${faint("dispatch")}  ${warn("█")} ${faint("review round")}  ${park("█")} ${faint("human park")}`);
+    bottom.push("");
+    if (input.keys !== false)
+        bottom.push(boardFooter(input.keys ?? BOARD_KEYS, input.colour !== false));
+    return { top: [...top, `${gateHeader.head}${gateHeader.strip}${gateHeader.tail}`, headerRule], rows, gateHeader, bottom, width: W, lbl: LBL, chan: CHAN };
+}
+/** The footer row: the key hints in chrome, the prototype's leading space kept. */
+export const boardFooter = (keys, colour = true) => (colour ? c(BOARD_PALETTE.chrome) : plain)(` ${keys.join(" · ")}`);
+/** The prototype's frame as lines, one row per task, unclipped — exactly what the design signed off. */
+export function renderBoard(input, width) {
+    const f = boardFrame(input, width);
+    return [...f.top, ...f.rows.map((r) => `${r.head}${r.strip}${r.tail}${r.note}`), ...f.bottom];
+}
+/**
+ * The Run view's three width bands over the same frame: full draws the prototype's rows; wrap
+ * puts a note that does not fit on its own second row; stacked draws the gate cells, channel and
+ * attempts under the row so nothing is truncated away.
+ */
+export function renderBoardLines(input, width) {
+    const band = boardBand(width);
+    const f = boardFrame(input, width);
+    const IND = 9, ind = " ".repeat(IND);
+    const sep = (input.colour === false ? plain : c(BOARD_PALETTE.mute))(" · ");
+    const lines = [...f.top];
+    if (band === "stacked") {
+        // The gate header rides with the cells it labels; the title header stays with the title column.
+        lines.splice(lines.length - 2, 1, f.gateHeader.head, `${ind}${f.gateHeader.strip}${f.gateHeader.tail}`);
+    }
+    // A note never truncates: what does not fit beside its row continues on indented rows below it.
+    const noteRows = (r, lead) => {
+        const [first, ...rest] = wrapNote(r.noteParts, sep, Math.max(1, width - vw(lead)), Math.max(1, width - IND));
+        lines.push(`${lead}${first ?? ""}`, ...rest.map((l) => `${ind}${l}`));
+    };
+    for (const r of f.rows) {
+        if (band === "stacked") {
+            lines.push(r.head, `${ind}${r.strip}${r.tail}`);
+            if (r.note)
+                noteRows(r, ind);
+            continue;
+        }
+        const row = `${r.head}${r.strip}${r.tail}`;
+        if (!r.note || vw(row) + vw(r.note) <= width)
+            lines.push(`${row}${r.note}`);
+        else if (band === "full" && vw(row) < width - 12)
+            noteRows(r, row);
+        else {
+            lines.push(row);
+            noteRows(r, ind);
+        }
+    }
+    lines.push(...f.bottom);
+    return lines.map((l) => clipBoard(l, width));
+}
+/** Pack note segments greedily into rows of `avail` cells; a segment wider than a row splits at the cell. */
+export function wrapNote(parts, sep, firstAvail, avail) {
+    const out = [];
+    let cur = "";
+    const room = () => (out.length ? avail : firstAvail);
+    const flush = () => { if (cur)
+        out.push(cur); cur = ""; };
+    for (const part of parts) {
+        const joined = cur ? `${cur}${sep}${part}` : part;
+        if (vw(joined) <= room()) {
+            cur = joined;
+            continue;
+        }
+        flush();
+        let rest = part;
+        while (vw(rest) > room()) {
+            const [head, tail] = splitBoard(rest, room());
+            if (!head)
+                break;
+            out.push(head);
+            rest = tail;
+        }
+        cur = rest;
+    }
+    flush();
+    return out;
+}
+/** ANSI-aware split at `n` visible cells on a grapheme boundary; the tail re-opens the colours the head left active. */
+function splitBoard(s, n) {
+    const { head, tail } = sliceCells(s, n);
+    let active = "";
+    for (const [code] of head.matchAll(/\x1b\[[0-9;]*m/g))
+        active = code === CLOSE || code === R ? "" : active + code;
+    return [head + (active ? CLOSE : ""), active + tail];
+}

package/dist/tui/cockpit/decision-actions.js

@@ -3,6 +3,8 @@ import { APPROVAL_ENACTS, approvalDispositionForRelease, approvalEnactment, appr
 import { stateDirName } from "../../graph/graph.js";
 import { Journal } from "../../run/journal.js";
 const parkDiagnostic = (park) => {
+    if (park.kind === "scope-request")
+        return park.approveCommand ?? "scope-request requires tickmarkr approve with --files <glob,…>";
     if (park.tombstone)
         return "tombstone — permanent by design; no verb releases it";
     if (park.kind === "gate-fail" && park.failedGate === undefined) {

package/dist/tui/cockpit/layout.d.ts

@@ -304,7 +304,11 @@ export type FramePlan = PlannedFrame | PlainFallbackPlan;
  */
 export declare function planFrame(size: MeasuredSize, view?: FrameView, state?: FrameState): FramePlan;
 export declare function resolveCockpitLayout(columns: number, rows: number): CockpitLayout;
-/** FINAL §3.1: one geometry for paint, focus and pointer hit testing. */
+/**
+ * FINAL §3.1: one geometry for paint, focus and pointer hit testing. A ZERO shortcut budget is the
+ * rail-less mount (BD-1, RULING-231-19 §2): the daemon-placed board is a one-view observer, so it
+ * plans no rail and no shortcuts at any width — the budget is honoured, never floored back to 20.
+ */
 export declare function planShell(columns: number, rows: number, shortcutColumns?: number): {
     columns: number;
     rows: number;

package/dist/tui/cockpit/layout.js

@@ -389,12 +389,17 @@ export function resolveCockpitLayout(columns, rows) {
         },
     };
 }
-/** FINAL §3.1: one geometry for paint, focus and pointer hit testing. */
+/**
+ * FINAL §3.1: one geometry for paint, focus and pointer hit testing. A ZERO shortcut budget is the
+ * rail-less mount (BD-1, RULING-231-19 §2): the daemon-placed board is a one-view observer, so it
+ * plans no rail and no shortcuts at any width — the budget is honoured, never floored back to 20.
+ */
 export function planShell(columns, rows, shortcutColumns = 22) {
     columns = Math.max(0, Math.floor(columns));
     rows = Math.max(0, Math.floor(rows));
-    const rail = columns >= 90 ? 15 : 0;
-    const shortcuts = columns >= 120 ? Math.max(20, Math.min(columns - 59, Math.floor(shortcutColumns))) : 0;
+    const railless = shortcutColumns === 0;
+    const rail = columns >= 90 && !railless ? 15 : 0;
+    const shortcuts = columns >= 120 && !railless ? Math.max(20, Math.min(columns - 59, Math.floor(shortcutColumns))) : 0;
     const bodyColumn = 1 + (rail ? rail + 1 : 0);
     return {
         columns, rows, refused: columns < 40 || rows < 14,

package/dist/tui/cockpit/live-runtime.js

@@ -9,7 +9,8 @@ import { render, useInput, useStdin } from "ink";
 import { useLayoutEffect, useSyncExternalStore } from "react";
 import { createLiveStore } from "./live-store.js";
 import { HomeView, deriveHomeView, selectNeedsYouTarget } from "./home-view.js";
-import { RunView, applyRunViewKey, initialRunViewSession, runGateCells, evidenceLookup, runTaskRow, GATE_CELL_LETTERS } from "./run-view.js";
+import { RunView, applyRunViewKey, initialRunViewSession, runGateCells, evidenceLookup } from "./run-view.js";
+import { renderBoardLines, stripBoardAnsi } from "./board.js";
 import { EvidenceView, deriveEvidenceView, defaultExportPath, planEvidenceExport, writeEvidenceExport } from "./evidence-view.js";
 import { ShellGridFlow, ShellJournalSelection } from "./components.js";
 import { CockpitShell, initialShellState } from "./shell.js";
@@ -18,12 +19,11 @@ import { shellBindings } from "./keys.js";
 import { createPointerReportReader, POINTER_TRACKING_ON, POINTER_TRACKING_OFF } from "./pointer.js";
 import { deriveRunDecisions, previewDecision, executeDecision, withDecisionPreview, withDecisionReceipt, decisionConfirmLines } from "./decision-actions.js";
 import { approvalRunOwner } from "../../cli/commands/approve.js";
-import { GATE_NAMES } from "../../graph/schema.js";
 import { GLYPHS } from "../../brand.js";
 import { Journal } from "../../run/journal.js";
-import { observeNamedRun } from "../../run/supervision.js";
+import { observeNamedRun, WATCH_OWNER_ENV } from "../../run/supervision.js";
 import { formatOwnedName } from "../../drivers/types.js";
-import { cellWidth, fitCells, wrapCells } from "./width.js";
+import { cellWidth, wrapCells } from "./width.js";
 import { resolveShellColourMode } from "./theme.js";
 let timelineUsers = 0;
 let timelineObserver;
@@ -100,7 +100,10 @@ export async function runConsolidatedCockpit(options) {
         const source = store;
         if (options.observeRun !== false)
             observation = observeNamedRun(cwd, runId, options.environment);
-        let state = { ...initialShellState(), view: options.initialView ?? "home" };
+        // BD-1 (RULING-231-19 §2): the daemon-placed board carries the watch owner token and mounts
+        // rail-less — a zero shortcut budget the plan honours at every width. The manual cockpit keeps its rail.
+        const railless = Boolean((options.environment ?? process.env)[WATCH_OWNER_ENV]);
+        let state = { ...initialShellState(), view: options.initialView ?? "home", ...(railless ? { shortcutColumns: 0 } : {}) };
         let runSession = initialRunViewSession();
         if (options.initialParks) {
             runSession = { ...runSession, selection: Math.max(0, source.snapshot().operator.tasks.findIndex(t => t.state === "human" || t.state === "blocked")) };
@@ -172,6 +175,29 @@ export async function runConsolidatedCockpit(options) {
             state = { ...state, overlay: [result.status === "focused" ? `Focused ${task.id}` : `Pane ${result.status}`, result.reason, "Enter opens task evidence after Esc"], overlayOffset: 0 };
             publish();
         };
+        // The board is taller than a small body; a selection moved by keys or a park opened from Home
+        // scrolls the shell's viewport just far enough that the selected row (and the rows that wrap
+        // under it) is seen. The rows are the very lines the Run view draws at this body width.
+        const followSelection = () => {
+            const snap = source.snapshot();
+            const task = snap.operator.tasks[runSession.selection];
+            if (!task)
+                return;
+            const g = geometry();
+            const lines = renderBoardLines({ runId, snapshot: snap.operator, graph: snap.graph.value, now: (options.now ?? Date.now)(), selection: task.id, keys: false, colour: false }, g.bodyColumns);
+            const first = lines.findIndex(l => l.startsWith("  ❯ "));
+            if (first < 0)
+                return;
+            let last = first;
+            while (last + 1 < lines.length && lines[last + 1].startsWith(" ".repeat(9)))
+                last++;
+            const top = first + 1, bottom = last + 1; // the RUN summary line sits above the board
+            const scroll = state.scroll;
+            if (top < scroll)
+                state = { ...state, scroll: top };
+            else if (bottom >= scroll + g.bodyRows)
+                state = { ...state, scroll: bottom - g.bodyRows + 1 };
+        };
         const openDetail = () => {
             const snap = source.snapshot();
             const task = state.view === "run" ? snap.operator.tasks[runSession.selection] : undefined;
@@ -189,6 +215,7 @@ export async function runConsolidatedCockpit(options) {
         // from the snapshot. The guard prevents the shell from dispatching its echo.
         let leafInput;
         let forwarding = false;
+        let lastRawInput = "";
         const forwardLeaf = (bytes) => {
             forwarding = true;
             try {
@@ -347,12 +374,15 @@ export async function runConsolidatedCockpit(options) {
                     const task = snap.operator.tasks[runSession.selection];
                     const cells = task ? runGateCells(task, evidenceLookup(snap.journal.history, source.page)) : [];
                     runSession = applyRunViewKey(runSession, event, { tasks: snap.operator.tasks, decisions, verdictLines: cells[runSession.verdictGate]?.verdict.length ?? 0 }).session;
+                    if (k.upArrow || k.downArrow)
+                        followSelection();
                     if (k.pageDown || k.pageUp)
                         state = {
                             ...state,
-                            // The Run leaf owns verdict paging; the shell only moves its
-                            // viewport far enough for that leaf's verdict panel to be seen.
-                            scroll: k.pageDown ? geometry().bodyRows : 0,
+                            // The Run leaf owns verdict paging; the shell only moves its viewport so that leaf's
+                            // verdict panel is seen — it sits below the board and the selected task's cells, so the
+                            // viewport goes to the leaf's end (clamped by the shell), not one page down.
+                            scroll: k.pageDown ? Number.MAX_SAFE_INTEGER : 0,
                         };
                     if (runSession.decisions.menu)
                         state = { ...state, overlay: ["Actions — Enter reviews; Esc cancels", ...runSession.decisions.menu.verbs], overlayOffset: 0 };
@@ -467,18 +497,20 @@ export async function runConsolidatedCockpit(options) {
         const reader = createPointerReportReader();
         const stdin = new Proxy(input, { get(target, property) {
                 if (property === "read")
-                    return (...args) => {
+                    return () => {
                         try {
-                            const chunk = target.read(...args);
-                            if (chunk == null)
-                                return null;
-                            const result = reader(String(chunk));
                             let keys = "";
-                            for (const token of result.tokens) {
-                                if (token.type === "pointer")
-                                    pointer(token.report);
-                                else
-                                    keys += token.bytes;
+                            // OBS-965: drain until the stream itself says empty. A real tty (highWaterMark 0) stops its
+                            // handle after every chunk and only a read() that finds the buffer EMPTY restarts it; Ink's
+                            // loop stops at the first null, so returning null after ONE pointer-only chunk left that
+                            // empty read unmade and every later key queued in the kernel — the deaf board.
+                            for (let chunk = target.read(); chunk != null; chunk = target.read()) {
+                                for (const token of reader(String(chunk)).tokens) {
+                                    if (token.type === "pointer")
+                                        pointer(token.report);
+                                    else
+                                        keys += token.bytes;
+                                }
                             }
                             // A standalone Escape is unambiguous after Ink's own input grace.
                             if (reader.pending() === "\x1b")
@@ -499,16 +531,35 @@ export async function runConsolidatedCockpit(options) {
             useSyncExternalStore(listener => { listeners.add(listener); return () => { listeners.delete(listener); }; }, () => revision);
             const stdinContext = useStdin();
             useLayoutEffect(() => {
-                leafInput = stdinContext.internal_eventEmitter;
-                return () => { leafInput = undefined; };
+                const emitter = stdinContext.internal_eventEmitter;
+                leafInput = emitter;
+                // Ink strips an escape sequence's ESC before useInput sees it, so an unnamed CSI and typed
+                // "[..." look alike there. Its parser emits every escape sequence as its own event, so the RAW
+                // event says which it was. Registered in a layout effect, this listener runs before useInput's.
+                const raw = (data) => { lastRawInput = data; };
+                emitter?.on("input", raw);
+                return () => { leafInput = undefined; emitter?.off("input", raw); };
             }, [stdinContext.internal_eventEmitter]);
             const renderedView = state.view;
             const leafActive = state.editor === undefined && !state.overlay && !state.help && !state.reviewing;
             useInput((text, k) => {
                 if (forwarding || (leafActive && renderedView !== "run" && (k.return || (renderedView === "evidence" && text === "e"))))
                     return;
+                // OBS-1002: Ink hands a coalesced chunk ("a\r", "na\r" — a paste, key repeat under load, a
+                // `pane run` message) to the handler as ONE string with no key flags, and a single-key map
+                // ignores it. Split every non-escape chunk into one event per code point; an escape sequence
+                // (arrows, page keys) is one key and already carries its flags.
+                const flagged = k.ctrl || k.meta || k.upArrow || k.downArrow || k.leftArrow || k.rightArrow || k.pageUp || k.pageDown || k.return || k.escape || k.tab || k.backspace || k.delete;
+                const points = !flagged && !lastRawInput.startsWith("\x1b") && [...text].length > 1 ? [...text] : [text];
                 try {
-                    key({ input: text, key: k }, true);
+                    for (const point of points) {
+                        const event = points.length === 1 ? { input: text, key: k }
+                            : point === "\r" || point === "\n" ? { input: "", key: { return: true } }
+                                : point === "\t" ? { input: "", key: { tab: true } }
+                                    : point === "\x1b" ? { input: "", key: { escape: true } }
+                                        : { input: point, key: { shift: /[A-Z]/.test(point) } };
+                        key(event, true);
+                    }
                 }
                 catch (error) {
                     stop(error);
@@ -562,10 +613,9 @@ export async function runConsolidatedCockpit(options) {
             return _jsx(CockpitShell, { snapshot: options.observeRun === false ? { ...snap, journal: { ...snap.journal, source: "no run/journal.jsonl" } } : snap, state: state, columns: p.columns, rows: p.rows, version: options.binaryVersion, colour: colour, onCommit: plan => {
                     committed = plan;
                     const targets = [];
-                    const taskRows = snap.operator.tasks.map((task, index) => ({
-                        id: task.id,
-                        text: fitCells(`${index === Math.min(runSession.selection, snap.operator.tasks.length - 1) ? `${GLYPHS.pointer} ` : "  "}${runTaskRow(task, GATE_NAMES.map(gate => ({ letter: GATE_CELL_LETTERS[task.gates[gate].state] })))}`, Math.max(1, plan.bodyColumns - 4)),
-                    }));
+                    // A board row opens with the prototype's four-cell indent or the focus marker, then the id;
+                    // the first painted row naming a task is that task's target (the effort fold names it again, later).
+                    const boardRowId = (text) => /^(?: {4}| {2}❯ )(\S+)/u.exec(stripBoardAnsi(text))?.[1];
                     const usedTasks = new Set();
                     for (const row of plan.paintedRows) {
                         if (row.row < plan.bodyRow && (row.text.startsWith("1 Home") || row.text.startsWith("1H"))) {
@@ -597,10 +647,12 @@ export async function runConsolidatedCockpit(options) {
                             continue;
                         }
                         if (state.view === "run") {
-                            const task = taskRows.find(task => !usedTasks.has(task.id) && row.text === task.text);
-                            if (task) {
-                                usedTasks.add(task.id);
-                                targets.push({ ...row, kind: "task", id: task.id });
+                            const drawn = boardRowId(row.text);
+                            // A narrow body clips the row inside a long id; the drawn prefix still names one task.
+                            const id = drawn === undefined ? undefined : (snap.operator.tasks.find(task => task.id === drawn) ?? snap.operator.tasks.find(task => task.id.startsWith(drawn)))?.id;
+                            if (id !== undefined && !usedTasks.has(id)) {
+                                usedTasks.add(id);
+                                targets.push({ ...row, kind: "task", id });
                             }
                         }
                         else {
@@ -623,8 +675,8 @@ export async function runConsolidatedCockpit(options) {
                         }
                     }
                     committedTargets = targets;
-                }, children: state.view === "home" ? _jsx(ShellGridFlow, { width: p.bodyColumns, columns: p.columns < 120 ? 2 : 3, rowHeight: p.rows < 20 ? 1 : p.columns < 120 ? 2 : 3, children: _jsx(HomeView, { width: p.bodyColumns, model: homeModel, focused: focused, onOpenPark: id => { runSession = { ...runSession, selection: Math.max(0, snap.operator.tasks.findIndex(t => t.id === id)) }; state = { ...state, view: "run", scroll: 0 }; publish(); }, onOpenDiagnostic: id => { state = { ...state, overlay: [id], overlayOffset: 0 }; publish(); }, onOpenEvidence: openEvidence, onSelectNeedsYou: reportHomeNeedsYouSelection }, String(homeModel.needsYou.length > 0)) }) :
-                    state.view === "run" ? _jsx(RunView, { snapshot: snap.operator, rows: snap.journal.history, page: source.page, graph: snap.graph.value, decisions: visibleDecisions, session: runSession, columns: p.bodyColumns, run: approvalRunOwner(cwd, runId) }) :
+                }, children: state.view === "home" ? _jsx(ShellGridFlow, { width: p.bodyColumns, columns: p.columns < 120 ? 2 : 3, rowHeight: p.rows < 20 ? 1 : p.columns < 120 ? 2 : 3, children: _jsx(HomeView, { width: p.bodyColumns, model: homeModel, focused: focused, onOpenPark: id => { runSession = { ...runSession, selection: Math.max(0, snap.operator.tasks.findIndex(t => t.id === id)) }; state = { ...state, view: "run", scroll: 0 }; followSelection(); publish(); }, onOpenDiagnostic: id => { state = { ...state, overlay: [id], overlayOffset: 0 }; publish(); }, onOpenEvidence: openEvidence, onSelectNeedsYou: reportHomeNeedsYouSelection }, String(homeModel.needsYou.length > 0)) }) :
+                    state.view === "run" ? _jsx(RunView, { snapshot: snap.operator, rows: snap.journal.history, page: source.page, graph: snap.graph.value, decisions: visibleDecisions, session: runSession, columns: p.bodyColumns, run: approvalRunOwner(cwd, runId), now: options.now }) :
                         _jsx(ShellJournalSelection.Provider, { value: reportEvidenceSelection, children: _jsx(EvidenceView, { width: p.bodyColumns, model: { ...model, journal: evidenceRows }, focusEvidence: selectedEvidence, focused: focused, onExport: beginExport, onSelect: id => { selectedEvidence = id; openDetail(); publish(); } }, `${state.query}:${evidenceNavigation}`) }) });
         }
         app = render(_jsx(App, {}), { stdin, stdout: output, debug: options.debug, exitOnCtrlC: false, patchConsole: false });

package/dist/tui/cockpit/run-view.d.ts

@@ -1,4 +1,4 @@
-import type { ReactElement } from "react";
+import { type ReactElement } from "react";
 import type { ApprovalRunOwner } from "../../cli/commands/approve.js";
 import { type GateName, type RunGraph } from "../../graph/schema.js";
 import type { JournalEvent } from "../../run/journal.js";
@@ -83,8 +83,8 @@ export declare function applyRunViewKey(session: RunViewSession, event: RunViewK
  * a closed run whose record lacks a bucket says so rather than reading absence as empty.
  */
 export declare function runSummaryLine(s: OperatorSnapshot): string;
-/** One matrix row: id, state, the seven letters in declaration order, the recorded attempt. */
-export declare function runTaskRow(t: OperatorTask, cells: readonly Pick<RunGateCell, "letter">[]): string;
+/** The board's footer keys merged with the cockpit's own — every one of them handled by this view or the shell. */
+export declare const RUN_VIEW_KEYS: readonly string[];
 export interface RunViewProps {
     readonly snapshot: OperatorSnapshot;
     /** Journal rows the store retains (C2 `journal.history`); evidence outside them reaches `page`. */
@@ -95,6 +95,8 @@ export interface RunViewProps {
     readonly session: RunViewSession;
     readonly columns: number;
     readonly run: ApprovalRunOwner;
+    /** The clock the board header reads; injectable so a pinned frame does not drift. */
+    readonly now?: () => number;
 }
-/** The Run body. Every line is measured through the width module; nothing overflows its column. */
-export declare function RunView({ snapshot, rows, page, graph, decisions, session, columns, run }: RunViewProps): ReactElement;
+/** The Run body: the approved board (BD-1) over the fold, then the selected task's detail panels. */
+export declare function RunView({ snapshot, rows, page, graph, decisions, session, columns, run, now }: RunViewProps): ReactElement;