@humanbased/crosscheck 1.3.1-beta.7 → 1.6.0-beta.11

package/dist/lib/board.js

@@ -1,5 +1,6 @@
 import chalk from 'chalk';
 import { selectTip } from './tips.js';
+const OUTCOME_ORDER = ['APPROVE', 'NEEDS WORK', 'BLOCK', 'no verdict', 'skipped', 'error'];
 // ── Constants ─────────────────────────────────────────────────────────────────
 const FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
 const BAR_FILLED = '█';
@@ -27,6 +28,44 @@ function fmtDuration(ms) {
 function fmtStartTime(epochMs) {
     return new Date(epochMs).toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit', hour12: true });
 }
+// Session age in hours and minutes: "3h32m", or "12m" under the hour. Deliberately
+// not fmtDuration: that renders MM:SS shaped output under an hour, which reads as
+// hours:minutes on a long-running watch and understates the session by 60x.
+export function fmtUptime(ms) {
+    const totalMin = Math.max(0, Math.floor(ms / 60_000));
+    const h = Math.floor(totalMin / 60);
+    const m = totalMin % 60;
+    return h > 0 ? `${h}h${String(m).padStart(2, '0')}m` : `${m}m`;
+}
+/**
+ * Whole percentages summing to exactly 100, by the largest-remainder method.
+ * Plain rounding drifts — three equal shares render as 33/33/33 — and a
+ * distribution that visibly fails to add up reads as a bug in the numbers.
+ *
+ * A non-zero count too small to earn a point comes back as 0; the caller
+ * renders those as "<1%" rather than claiming the outcome never happened.
+ */
+export function distribute(counts) {
+    const total = counts.reduce((a, b) => a + b, 0);
+    if (total === 0)
+        return counts.map(() => 0);
+    const exact = counts.map(c => (c * 100) / total);
+    const out = exact.map(Math.floor);
+    // Exact shares sum to 100, so the floors leave fewer whole points than there
+    // are entries: one pass in remainder order always places every last one.
+    let remaining = 100 - out.reduce((a, b) => a + b, 0);
+    const byRemainder = exact
+        .map((e, i) => ({ i, rem: e - Math.floor(e) }))
+        .filter(({ i }) => counts[i] > 0)
+        .sort((a, b) => b.rem - a.rem);
+    for (const { i } of byRemainder) {
+        if (remaining <= 0)
+            break;
+        out[i]++;
+        remaining--;
+    }
+    return out;
+}
 // Format token count as a compact suffix: "(900)", "(1.2K)", "(1.5M)". Returns '' when undefined.
 export function fmtTokens(n) {
     if (n == null)
@@ -38,7 +77,7 @@ export function fmtTokens(n) {
     return `(${(n / 1_000_000).toFixed(1).replace(/\.0$/, '')}M)`;
 }
 // Raw token count without surrounding parens: "900", "1.2K", "1.5M". Returns '' when undefined.
-function fmtTokensRaw(n) {
+export function fmtTokensRaw(n) {
     if (n == null)
         return '';
     if (n < 1_000)
@@ -55,6 +94,104 @@ function stripAnsi(s) {
 function truncate(s, max) {
     return s.length <= max ? s : s.slice(0, max - 1) + '…';
 }
+// Cut a rendered line to `max` visible columns, keeping the ANSI sequences it
+// passes over (they have no width) and closing with a reset so a cut mid-colour
+// cannot bleed into the next line. Folded rows are clamped with this so they
+// always occupy exactly one terminal row — history pagination counts on it.
+function truncateVisible(s, max) {
+    if (max <= 0)
+        return '';
+    if (stripAnsi(s).length <= max)
+        return s;
+    let out = '';
+    let width = 0;
+    for (let i = 0; i < s.length; i++) {
+        const ch = s[i];
+        if (ch === '\x1B') {
+            const end = s.indexOf('m', i);
+            if (end === -1)
+                break;
+            out += s.slice(i, end + 1);
+            i = end;
+            continue;
+        }
+        if (width >= max - 1)
+            break;
+        out += ch;
+        width++;
+    }
+    return out + '…\x1B[0m';
+}
+// Lines the runner hands to its log callback are prefixed ⚠ or ✗ when they
+// report something an operator must act on. Everything else is progress
+// narration that the board's own PR rows already carry, and a multi-line
+// message is a dump (an unposted review, a dry-run comment) that always
+// follows one of those notices. Only these earn a line of terminal scrollback
+// beside the board; the rest goes to the file log.
+// eslint-disable-next-line no-control-regex -- matching the ESC byte is the point
+const NOTICE_PREFIX = /^(?:\x1B\[[0-9;]*m)*\s*[⚠✗]/;
+export function isNoticeLine(msg) {
+    return NOTICE_PREFIX.test(msg) || msg.includes('\n');
+}
+// Bare `<`/`>` (and their unshifted `,`/`.`) always work. Terminals cannot agree
+// on how to report ctrl/cmd with a punctuation key, so every encoding they do
+// emit is accepted: meta-prefixed, CSI-u (kitty / xterm modifyOtherKeys) and
+// modified arrows. macOS Terminal swallows cmd entirely — there the bare keys,
+// or ctrl+arrow, are the way through.
+const PAGE_OLDER_KEYS = new Set(['<', ',', '\u001b<', '\u001b,', '\u001b[D', '\u001b[5~']);
+const PAGE_NEWER_KEYS = new Set(['>', '.', '\u001b>', '\u001b.', '\u001b[C', '\u001b[6~']);
+// eslint-disable-next-line no-control-regex -- the ESC byte is the sequence
+const CSI_U = /^\u001b\[(\d+);\d+u$/; // ESC [ <codepoint> ; <modifiers> u
+// eslint-disable-next-line no-control-regex -- the ESC byte is the sequence
+const CSI_ARROW = /^\u001b\[1;\d+([DC])$/; // ESC [ 1 ; <modifiers> D|C
+/** Map a raw stdin key sequence to a page direction, or null when it is not a page key. */
+export function pageKeyAction(seq) {
+    if (PAGE_OLDER_KEYS.has(seq))
+        return 'older';
+    if (PAGE_NEWER_KEYS.has(seq))
+        return 'newer';
+    const csiU = CSI_U.exec(seq);
+    if (csiU) {
+        const codepoint = Number(csiU[1]);
+        if (codepoint === 44 || codepoint === 60)
+            return 'older'; // , <
+        if (codepoint === 46 || codepoint === 62)
+            return 'newer'; // . >
+        return null;
+    }
+    const arrow = CSI_ARROW.exec(seq);
+    if (arrow)
+        return arrow[1] === 'D' ? 'older' : 'newer';
+    return null;
+}
+// Keep every active slot plus the newest `budget` settled ones. Anything older
+// cannot fit the live page (one row minimum per slot), so the fitting loop need
+// never consider it.
+function trimToBudget(pool, budget) {
+    const settled = pool.filter(s => s.completedAt !== undefined);
+    if (settled.length <= budget)
+        return pool.slice();
+    const keep = new Set(settled.slice(settled.length - budget));
+    return pool.filter(s => s.completedAt === undefined || keep.has(s));
+}
+/**
+ * The one outcome a settled slot counts toward. A recheck verdict supersedes
+ * the review verdict — it is the later word on the same PR — and `null` from
+ * either step means a reviewer ran but returned nothing parseable, which is a
+ * different event from never having run at all.
+ */
+function outcomeOf(slot) {
+    if (slot.error !== undefined)
+        return 'error';
+    const final = typeof slot.recheckVerdict === 'string'
+        ? slot.recheckVerdict
+        : typeof slot.verdict === 'string' ? slot.verdict : null;
+    if (final === 'APPROVE' || final === 'NEEDS WORK' || final === 'BLOCK')
+        return final;
+    if (slot.recheckVerdict === null || slot.verdict === null)
+        return 'no verdict';
+    return 'skipped';
+}
 function makeBar(filled, total, fillFn, emptyFn) {
     const f = Math.max(0, Math.min(total, Math.round(filled)));
     return fillFn(BAR_FILLED.repeat(f)) + emptyFn(BAR_EMPTY.repeat(total - f));
@@ -154,7 +291,7 @@ function buildTheme(cfg) {
 const CONN_LOG_MAX = 6; // max connectivity log lines kept in memory
 const COMPACT_CONN_LOG_LINES = 2; // conn log lines shown when the live block must shrink to fit the viewport
 const FOLD_THRESHOLD = 3; // when completed count exceeds this, fold all completed PRs to 1 line
-const WORKSPACE_MAX = 25; // when total slots exceed this, evict oldest completed to scrollback
+const HISTORY_MAX = 2000; // hard cap on retained slots — oldest settled rows drop out beyond it
 const LAYOUT_NORMAL = { foldAll: false, connLogLines: CONN_LOG_MAX, showTip: true };
 const LAYOUT_COMPACT = { foldAll: true, connLogLines: COMPACT_CONN_LOG_LINES, showTip: false };
 export class PRBoard {
@@ -165,6 +302,10 @@ export class PRBoard {
     liveContent = '';
     isTTY = Boolean(process.stdout.isTTY);
     connLog = [];
+    page = 0; // 0 = live page (newest); higher = further back in history
+    pageCount = 1; // recomputed every render; page keys clamp against it
+    keyHandler = null;
+    stdinWasRaw = false;
     stats = {
         prsReceived: 0,
         crsCompleted: 0,
@@ -172,6 +313,7 @@ export class PRBoard {
         errorsOccurred: 0,
         crTotalMs: 0,
         sessionStart: Date.now(),
+        outcomes: { 'APPROVE': 0, 'NEEDS WORK': 0, 'BLOCK': 0, 'no verdict': 0, 'skipped': 0, 'error': 0 },
     };
     tunnel = {
         type: 'none', url: null, alive: false,
@@ -195,6 +337,7 @@ export class PRBoard {
     start() {
         if (!this.isTTY)
             return;
+        this.attachKeys();
         this.timer = setInterval(() => {
             this.frameIdx = (this.frameIdx + 1) % FRAMES.length;
             this.redraw();
@@ -205,18 +348,34 @@ export class PRBoard {
             clearInterval(this.timer);
             this.timer = null;
         }
+        this.detachKeys();
         this.eraseLive();
     }
+    /** Flip one page toward older history. No-op when already at the oldest page. */
+    pageOlder() {
+        const next = Math.min(this.page + 1, Math.max(0, this.pageCount - 1));
+        if (next === this.page)
+            return;
+        this.page = next;
+        this.redraw();
+    }
+    /** Flip one page toward the live page. No-op when already on it. */
+    pageNewer() {
+        if (this.page === 0)
+            return;
+        this.page--;
+        this.redraw();
+    }
     addPR(key, prNumber, repo, branch, round) {
         // When a new round starts for a PR that already has a completed slot in the
-        // workspace, evict the prior-round slot to scrollback so only the current
-        // round is shown. Prior-round slots always have a different key (different
-        // SHA suffix) but the same prNumber + repo combination.
+        // workspace, mark the prior-round slot superseded so only the current round
+        // shows on the live page. It stays in the map: history pages still carry it.
+        // Prior-round slots always have a different key (different SHA suffix) but
+        // the same prNumber + repo combination.
         if ((round ?? 1) >= 2) {
             for (const [existingKey, slot] of this.slots) {
                 if (existingKey !== key && slot.prNumber === prNumber && slot.repo === repo && slot.completedAt !== undefined) {
-                    this.printStatic(this.renderPRSlotFolded(slot));
-                    this.slots.delete(existingKey);
+                    slot.superseded = true;
                 }
             }
         }
@@ -271,19 +430,32 @@ export class PRBoard {
         }
         if (fixCount !== undefined && fixCount > 0)
             this.stats.fixesApplied++;
+        this.stats.outcomes[outcomeOf(slot)]++;
         // Non-TTY has no live block to re-render — emit the folded line to scrollback and drop the slot.
         if (!this.isTTY) {
             process.stdout.write(this.renderPRSlotFolded(slot) + '\n');
             this.slots.delete(key);
         }
     }
+    /**
+     * Settle a slot that ended in an error. The slot stays in the workspace as a
+     * settled row, the same as a completed one: a failed run is a session record,
+     * and deleting it here was what pushed reviewer timeouts out of the table and
+     * into raw scrollback, where a long watch session showed 43 errors above an
+     * empty workspace reading "no PRs yet".
+     */
     failPR(key, error) {
         const slot = this.slots.get(key);
-        this.slots.delete(key);
         this.stats.errorsOccurred++;
-        if (slot) {
-            const ts = fmtTime();
-            this.printStatic(`${chalk.dim(ts)}  PR #${slot.prNumber}  ${chalk.red('✗')} ${error}`);
+        if (!slot || slot.completedAt !== undefined)
+            return;
+        slot.completedAt = Date.now();
+        slot.error = error;
+        slot.label = 'failed';
+        this.stats.outcomes.error++;
+        if (!this.isTTY) {
+            process.stdout.write(this.renderPRSlotFolded(slot) + '\n');
+            this.slots.delete(key);
         }
     }
     /** Print 1–2 static lines to scrollback (above the live block). */
@@ -353,14 +525,43 @@ export class PRBoard {
         return t.barCRNeedsWork;
     }
     // ── Private: render ────────────────────────────────────────────────────────
-    uptime() {
-        const totalSec = Math.floor((Date.now() - this.stats.sessionStart) / 1000);
-        const h = Math.floor(totalSec / 3600);
-        const m = Math.floor((totalSec % 3600) / 60);
-        const s = totalSec % 60;
-        if (h > 0)
-            return `${String(h).padStart(2, '0')}:${String(m).padStart(2, '0')}`;
-        return `${String(m).padStart(2, '0')}:${String(s).padStart(2, '0')}`;
+    /** "since 08:25 PM · up 3h32m" — when watch started, and how long it has run. */
+    sessionRow() {
+        const t = this.theme;
+        const started = fmtStartTime(this.stats.sessionStart);
+        const age = fmtUptime(Date.now() - this.stats.sessionStart);
+        return `${t.dim('since')} ${started}  ${t.dim('·')}  ${t.dim('up')} ${age}`;
+    }
+    /**
+     * Outcome shares across every PR that settled this session, e.g.
+     * "APPROVE 45% · BLOCK 30% · error 25%". Empty when nothing has settled yet.
+     */
+    outcomeRow() {
+        const t = this.theme;
+        const counts = OUTCOME_ORDER.map(o => this.stats.outcomes[o]);
+        const total = counts.reduce((a, b) => a + b, 0);
+        if (total === 0)
+            return '';
+        const pcts = distribute(counts);
+        const mixed = counts.filter(c => c > 0).length > 1;
+        const parts = OUTCOME_ORDER.map((outcome, i) => {
+            if (counts[i] === 0)
+                return null;
+            // A share too small to earn a whole point still happened; "<1%" says so
+            // where "0%" would read as never. Its complement is then not a whole 100
+            // either — "error 100%" beside "APPROVE <1%" contradicts itself — so the
+            // rounded-up bucket reads ">99%" whenever some other outcome is non-zero.
+            const pct = pcts[i] === 0 ? '<1%'
+                : pcts[i] === 100 && mixed ? '>99%'
+                    : `${pcts[i]}%`;
+            const paint = outcome === 'APPROVE' ? t.barCRApprove
+                : outcome === 'BLOCK' ? t.barCRBlock
+                    : outcome === 'NEEDS WORK' ? t.barCRNeedsWork
+                        : outcome === 'error' ? t.error
+                            : t.dim;
+            return `${paint(outcome)} ${t.dim(pct)}`;
+        }).filter((p) => p !== null);
+        return parts.join(t.dim(' · '));
     }
     statsRow() {
         const { prsReceived, crsCompleted, fixesApplied, errorsOccurred, crTotalMs } = this.stats;
@@ -523,29 +724,62 @@ export class PRBoard {
     render() {
         if (!this.config)
             return '';
-        // When the workspace overflows, evict oldest completed slots to scrollback.
-        this.evictOverflow();
+        this.trimHistory();
         const w = process.stdout.columns || 80;
         // The live block must never be taller than the viewport: lines that scroll
         // out the top cannot be erased on the next frame (cursor-up clamps at the
         // viewport top), leaving permanent duplicates in scrollback. Reserve one
         // row for the trailing newline writeLive appends.
         const budget = (process.stdout.rows || 24) - 1;
-        const normal = this.renderLayout(w, LAYOUT_NORMAL);
-        if (this.countRenderedLines(normal, w) <= budget)
-            return normal;
-        let compact = this.renderLayout(w, LAYOUT_COMPACT);
-        // Still too tall: flush oldest completed slots to scrollback until it fits.
-        while (this.countRenderedLines(compact, w) > budget && this.evictOldestCompleted()) {
-            compact = this.renderLayout(w, LAYOUT_COMPACT);
+        const entries = [...this.slots.values()];
+        // The live page carries every active slot plus the newest settled ones that
+        // fit. What it cannot show is not dropped — it moves into the history pages.
+        const live = this.fitLivePage(entries.filter(s => s.superseded !== true), w, budget);
+        const onLivePage = new Set(live.visible);
+        const history = entries.filter(s => !onLivePage.has(s)); // oldest → newest
+        // History rows are always folded, and a folded row is clamped to one
+        // terminal row, so a history page holds exactly the rows the panels leave.
+        const perPage = Math.max(1, budget - this.chromeRows(w, LAYOUT_COMPACT));
+        this.pageCount = 1 + Math.ceil(history.length / perPage);
+        this.page = Math.max(0, Math.min(this.page, this.pageCount - 1));
+        if (this.page === 0)
+            return this.fitToBudget(this.renderLayout(w, live.opts, live.visible, entries.length), w, budget);
+        // Page 1 is the newest history page, so it ends where the live page begins.
+        const end = history.length - (this.page - 1) * perPage;
+        const slice = history.slice(Math.max(0, end - perPage), end);
+        return this.fitToBudget(this.renderLayout(w, LAYOUT_COMPACT, slice, entries.length), w, budget);
+    }
+    /**
+     * Pick the slots the live page shows: the expanded layout when it fits, then
+     * the compact one, then compact with the oldest settled slots handed over to
+     * history until the block fits the viewport. Active slots are never handed
+     * over — a running review must stay on screen.
+     */
+    fitLivePage(pool, w, budget) {
+        // Bound the work: a slot costs at least one row, so a settled slot older
+        // than the last `budget` of them can never fit on the live page anyway.
+        const visible = trimToBudget(pool, budget);
+        const fits = (opts) => this.countRenderedLines(this.renderLayout(w, opts, visible, pool.length), w) <= budget;
+        if (fits(LAYOUT_NORMAL))
+            return { visible, opts: LAYOUT_NORMAL };
+        while (!fits(LAYOUT_COMPACT)) {
+            const oldestSettled = visible.findIndex(s => s.completedAt !== undefined);
+            if (oldestSettled === -1)
+                break; // only active slots left — truncateTop takes it from here
+            visible.splice(oldestSettled, 1);
         }
-        if (this.countRenderedLines(compact, w) <= budget)
-            return compact;
-        // Only active slots remain and they still overflow (tiny terminal):
-        // drop rows from the top, keeping the most recent activity visible.
-        return this.truncateTop(compact, w, budget);
+        return { visible, opts: LAYOUT_COMPACT };
+    }
+    /** Rows the panels and footer cost, i.e. everything but the PR rows. */
+    chromeRows(w, opts) {
+        return this.countRenderedLines(this.renderLayout(w, opts, [], this.slots.size), w);
     }
-    renderLayout(w, opts) {
+    fitToBudget(content, w, budget) {
+        return this.countRenderedLines(content, w) <= budget
+            ? content
+            : this.truncateTop(content, w, budget);
+    }
+    renderLayout(w, opts, visible, total) {
         const t = this.theme;
         // Use w-1 to prevent the exact-terminal-width cursor wrap ambiguity that
         // causes the first char of the next line to appear at the end of the separator.
@@ -555,20 +789,25 @@ export class PRBoard {
             sep,
             ...this.renderStatsPanel(opts.connLogLines, opts.showTip),
             sep,
-            ...this.renderPRWorkspace(opts.foldAll),
+            ...this.renderPRWorkspace(visible, opts.foldAll, w),
             sep,
+            // Clamped: the footer is counted as exactly one row when sizing a page.
+            truncateVisible(this.renderFooter(visible.length, total), w - 1),
         ].join('\n');
     }
-    /** Evict the oldest completed slot to scrollback. Returns false when none left. */
-    evictOldestCompleted() {
+    /** Drop the oldest settled slots once the session history outgrows the cap. */
+    trimHistory() {
+        if (this.slots.size <= HISTORY_MAX)
+            return;
+        let excess = this.slots.size - HISTORY_MAX;
         for (const [key, slot] of this.slots) {
+            if (excess <= 0)
+                break;
             if (slot.completedAt === undefined)
-                continue;
-            this.printStatic(this.renderPRSlotFolded(slot));
+                continue; // never drop an active slot
             this.slots.delete(key);
-            return true;
+            excess--;
         }
-        return false;
     }
     /** Drop rows from the top until the content (plus an indicator line) fits the budget. */
     truncateTop(content, w, budget) {
@@ -601,7 +840,11 @@ export class PRBoard {
     renderStatsPanel(connLogLines, showTip) {
         const t = this.theme;
         const lines = [];
-        lines.push(`  ${this.statsRow()}  ${t.dim('│')}  ${t.dim('↑')} ${this.uptime()}`);
+        lines.push(`  ${this.statsRow()}`);
+        // Session line: start time + age, and the outcome split when anything has
+        // settled. One row, because every row here costs a PR row on the live page.
+        const outcomes = this.outcomeRow();
+        lines.push(`  ${this.sessionRow()}${outcomes ? `  ${t.dim('│')}  ${outcomes}` : ''}`);
         const { type: tunnelType, url, alive } = this.tunnel;
         if (tunnelType !== 'none') {
             const tunnelLabel = tunnelType === 'serve' ? 'endpoint:' : 'tunnel:  ';
@@ -630,14 +873,14 @@ export class PRBoard {
         const formatted = parts.map(p => p.startsWith('`') ? t.accent(p) : t.dim(p)).join('');
         return `  ${badge}${formatted}`;
     }
-    renderPRWorkspace(foldAll) {
+    renderPRWorkspace(visible, foldAll, w) {
         const t = this.theme;
         const frame = FRAMES[this.frameIdx];
-        if (this.slots.size === 0) {
-            return [t.dim('  waiting for PRs...')];
+        if (visible.length === 0) {
+            return this.slots.size === 0 ? [t.dim('  waiting for PRs...')] : [];
         }
         let completedCount = 0;
-        for (const slot of this.slots.values()) {
+        for (const slot of visible) {
             if (slot.completedAt !== undefined)
                 completedCount++;
         }
@@ -645,7 +888,7 @@ export class PRBoard {
         const lines = [];
         let prevWasExpanded = false;
         let first = true;
-        for (const slot of this.slots.values()) {
+        for (const slot of visible) {
             const isCompleted = slot.completedAt !== undefined;
             // Sticky fold: once a completed slot folds because the count crossed
             // FOLD_THRESHOLD, keep it folded. Otherwise a later recheck round drops
@@ -655,9 +898,14 @@ export class PRBoard {
             // should re-expand.
             if (isCompleted && foldByCount)
                 slot.stickyFolded = true;
-            const useFolded = isCompleted && (foldAll || slot.stickyFolded === true);
+            // A failed slot is always folded: its pipeline bars are frozen wherever the
+            // run died ("CR queued", "Fix queued"), which describes work that will
+            // never happen. The folded row carries the error instead.
+            const useFolded = isCompleted && (foldAll || slot.stickyFolded === true || slot.error !== undefined);
             if (useFolded) {
-                lines.push(this.renderPRSlotFolded(slot));
+                // Clamped so the row never wraps: history pagination sizes a page by
+                // counting one terminal row per folded slot.
+                lines.push(truncateVisible(this.renderPRSlotFolded(slot), w - 1));
                 prevWasExpanded = false;
             }
             else {
@@ -670,6 +918,22 @@ export class PRBoard {
         }
         return lines;
     }
+    /** Footer: where in the retained history this page sits, and how to move. */
+    renderFooter(shown, total) {
+        const t = this.theme;
+        if (total === 0)
+            return t.dim('  no PRs yet');
+        const position = this.page === 0
+            ? `${t.success('live')}${this.pageCount > 1 ? t.dim(` · page 1/${this.pageCount}`) : ''}`
+            : t.dim(`history · page ${this.page + 1}/${this.pageCount}`);
+        // "shown of retained", not of stats.prsReceived: rounds add rows, and the
+        // history cap eventually drops the oldest, so the two counts diverge.
+        const counts = t.dim(`showing ${shown} of ${total}`);
+        const keys = this.pageCount > 1
+            ? `  ${t.dim('│')}  ${t.accent('ctrl+<')} ${t.dim('older')}  ${t.accent('ctrl+>')} ${t.dim('newer')}`
+            : '';
+        return `  ${position}  ${t.dim('│')}  ${counts}${keys}`;
+    }
     // ── Folded PR slot ─────────────────────────────────────────────────────────
     renderPRSlotFolded(slot) {
         const t = this.theme;
@@ -697,29 +961,57 @@ export class PRBoard {
             const rFn = this.crLabelFn(slot.recheckVerdict);
             parts.push(`recheck ${rFn(slot.recheckVerdict)}`);
         }
+        // A failed run reports the error in place of the verdict trail: whatever the
+        // pipeline had reached is what it never got to finish, and the reason it
+        // stopped is the only thing worth the row.
+        if (slot.error !== undefined) {
+            parts.push(t.error(slot.error));
+        }
         const urlPart = slot.url ? `  ${t.dim('→')} ${t.accent(slot.url)}` : '';
         const partsStr = parts.length > 0 ? parts.join(t.dim(' · ')) : t.dim('—');
-        return `  ${t.success('✓')} ${t.dim(`#${slot.prNumber}`)}  ${t.dim(slot.repo)}  ${t.dim(branch)}  ${partsStr}  ${t.dim(`(${elapsed})`)}${urlPart}`;
-    }
-    // ── Overflow eviction ──────────────────────────────────────────────────────
-    evictOverflow() {
-        if (this.slots.size <= WORKSPACE_MAX)
-            return;
-        let toEvict = this.slots.size - WORKSPACE_MAX;
-        for (const [key, slot] of this.slots) {
-            if (toEvict <= 0)
-                break;
-            if (slot.completedAt === undefined)
-                continue; // never evict active
-            this.printStatic(this.renderPRSlotFolded(slot));
-            this.slots.delete(key);
-            toEvict--;
-        }
+        const icon = slot.error !== undefined ? t.error('✗') : t.success('✓');
+        return `  ${icon} ${t.dim(`#${slot.prNumber}`)}  ${t.dim(slot.repo)}  ${t.dim(branch)}  ${partsStr}  ${t.dim(`(${elapsed})`)}${urlPart}`;
     }
     redraw() {
         const content = this.render();
         if (content)
             this.writeLive(content);
     }
+    // ── Private: key input ─────────────────────────────────────────────────────
+    attachKeys() {
+        const stdin = process.stdin;
+        if (this.keyHandler || !stdin.isTTY)
+            return;
+        this.stdinWasRaw = stdin.isRaw === true;
+        stdin.setRawMode(true);
+        stdin.resume();
+        const handler = (data) => {
+            const seq = data.toString('utf8');
+            // Raw mode suppresses the terminal's own ctrl-c → SIGINT translation, so
+            // the board has to raise it itself or the daemon becomes unkillable.
+            if (seq === '\u0003') {
+                process.kill(process.pid, 'SIGINT');
+                return;
+            }
+            const action = pageKeyAction(seq);
+            if (action === 'older')
+                this.pageOlder();
+            else if (action === 'newer')
+                this.pageNewer();
+        };
+        stdin.on('data', handler);
+        this.keyHandler = handler;
+    }
+    detachKeys() {
+        if (!this.keyHandler)
+            return;
+        process.stdin.off('data', this.keyHandler);
+        this.keyHandler = null;
+        // Hand the terminal back the way it was found: the idle-issue flow and the
+        // interactive prompts read stdin themselves while the board is stopped.
+        if (process.stdin.isTTY && !this.stdinWasRaw)
+            process.stdin.setRawMode(false);
+        process.stdin.pause();
+    }
 }
 //# sourceMappingURL=board.js.map