@humanbased/crosscheck 1.6.0-beta.5 → 1.6.0

package/README.md

@@ -257,6 +257,8 @@ Classification may set a **floor**, or promote on **consequence** — a security
 
 Class tier, effort, **and** step set are all applied. The class is resolved once per workflow, not per step — the fix step pushes commits, so re-classifying could make the review and recheck comments cite different tiers for the same PR.
 
+`crosscheck review <pr>` classifies the same way and runs at the class's tier and effort. It is an explicit request for one review, so the step set does not apply, and a class that would skip the PR is overridden: the review runs at the configured `quality.tier`, as `crosscheck run --steps review` does.
+
 The step set **narrows** the configured pipeline and never widens it: a repo pinned to review-only with `crosscheck alter` stays review-only whatever the class says.
 
 Rounds beyond the first escalate on measured non-convergence rather than prediction — effort rises where the model supports it, the tier is promoted where it does not, and the model never weakens.

package/crosscheck.config.example.yml

@@ -21,6 +21,8 @@ mode: cross-vendor
 # Pick https if you have a multi-account SSH setup or your default SSH key
 # cannot access target repos. Independent of `gh config get git_protocol`.
 clone_protocol: ssh
+# Reuse fetched Git objects; set false to always clone from scratch.
+repository_cache: true
 
 # ─── Vendors ─────────────────────────────────────────────────────────────────
 vendors:
@@ -39,6 +41,8 @@ vendors:
 
 # ─── Quality & Focus ─────────────────────────────────────────────────────────
 quality:
+  # Structured findings and incremental follow-ups; set false for legacy prose reviews.
+  review_memory: true
   mode: smart               # smart (default) | fixed
   #
   # smart  - dynamically adjust model + effort based on task type. The PR is
@@ -67,7 +71,9 @@ quality:
   tier: balanced            # fast | balanced | thorough
   #
   # Under `fixed` this is the tier for every call. Under `smart` it is the
-  # fallback used when a PR's file list cannot be read.
+  # fallback used when a PR's file list cannot be read, and when an explicit
+  # request (`crosscheck review`, `run --steps`) overrides a class that would
+  # skip the PR.
   #
   # Cost is output-token cost at 48k output tokens, the measured median for one
   # review. A review is an agentic session, so it takes 10-16 minutes of wall
@@ -254,12 +260,19 @@ post_review:
 #     timeout_min: 30     # minutes of no PR activity before the idle prompt fires (min: 5)
 
 # ─── Backtrace ───────────────────────────────────────────────────────────────
-# On startup, scan all open PRs in the monitored scope and review any that have
-# never received a [crosscheck] comment. Ensures coverage for PRs opened while
+# Scan all open PRs in the monitored scope and review any that have never
+# received a [crosscheck] comment. Ensures coverage for PRs opened while
 # crosscheck was offline or before it was first set up.
 # Off by default — enable with the config below or pass --backtrace at startup.
+#
+# Webhook delivery is best-effort, so the scan is also the recovery path for PRs
+# no future event will mention: opened while watch was down, an org hook that
+# failed to register, a smee reconnect gap, or a push dropped while the PR was
+# locked. Set interval_min to re-run it on a cadence, not just at startup.
 # backtrace:
-#   enabled: true   # set to true to enable the startup scan (or pass --backtrace)
+#   enabled: true       # set to true to enable the scan (or pass --backtrace)
+#   interval_min: 30    # re-scan every N minutes while watch is up; 0 = startup only
+#   concurrency: 2      # max reviews the scan starts at once (default 2)
 
 # ─── Issue enrichment ────────────────────────────────────────────────────────
 # Recover the linked tracker issue (e.g. IN-2017) from the PR title / branch /

package/dist/__tests__/board.test.js

@@ -1,6 +1,7 @@
 import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
 import { EventEmitter } from 'events';
-import { PRBoard, fmtTokens, pageKeyAction, isNoticeLine } from '../lib/board.js';
+import chalk from 'chalk';
+import { PRBoard, fmtEnteredAt, fmtTokens, pageKeyAction, isNoticeLine, distribute, fmtUptime } from '../lib/board.js';
 describe('fmtTokens', () => {
     it('returns empty string for undefined', () => {
         expect(fmtTokens(undefined)).toBe('');
@@ -87,6 +88,14 @@ describe('PRBoard — TTY workspace retention', () => {
     const invokeRender = () => board.render();
     const invokeFolded = (key) => board.renderPRSlotFolded(slots().get(key));
     const superseded = (key) => slots().get(key)?.superseded === true;
+    // The PR rows only. Layout is config │ stats │ workspace │ footer, separated by
+    // rules, so the third block is the workspace. Assertions about which PRs are on
+    // screen scope to this: the stats panel names verdicts too (outcome shares), so
+    // searching the whole frame for "BLOCK" no longer answers "is that row shown?".
+    const workspaceOf = (output) => {
+        const blocks = output.split(/^─+$/m);
+        return blocks[2] ?? '';
+    };
     it('keeps completed slot in the workspace (no auto-clear)', () => {
         board.addPR('k1', 1, 'a/b', 'main');
         board.completePR('k1', { elapsedMs: 1000, url: 'https://github.com/a/b/pull/1' });
@@ -167,9 +176,9 @@ describe('PRBoard — TTY workspace retention', () => {
         expect(slots().has('k1@sha2')).toBe(true); // new round present
         board.updatePR('k1@sha2', { recheckVerdict: 'APPROVE' });
         board.completePR('k1@sha2', { elapsedMs: 362_000, url: 'https://github.com/owner/repo/pull/214' });
-        const output = stripAnsi(invokeRender());
-        expect(output).not.toContain('BLOCK');
-        expect(output).toContain('APPROVE');
+        const workspace = workspaceOf(stripAnsi(invokeRender()));
+        expect(workspace).not.toContain('BLOCK');
+        expect(workspace).toContain('APPROVE');
     });
     it('does not supersede active slots when round 2 starts', () => {
         // Active round 1 for a different PR — must not be touched
@@ -319,6 +328,27 @@ describe('PRBoard — viewport height fitting', () => {
         const residue = scrollback.filter(l => liveOnlyMarkers.some(m => l.includes(m)));
         expect(residue).toEqual([]);
     });
+    // failPR settles into the live block now rather than printing a static line
+    // per failure. This pins that: a long run of failures on a short viewport must
+    // stay a redraw, never scrollback. (It is an invariant guard, not a reproducer
+    // — the doubled header operators report comes from a viewport resize, which
+    // strands rows above the cursor-up clamp regardless of what wrote them.)
+    it('keeps a long run of failures in the live block, not scrollback', () => {
+        const ROWS = 14, COLS = 100;
+        setViewport(ROWS, COLS);
+        board.setTunnel('smee', 'https://smee.io/test', true);
+        invokeRedraw();
+        for (let i = 0; i < 20; i++) {
+            board.addPR(`k${i}`, 4600 + i, 'humanbased-ai/monorepo', `codex/branch-${i}`);
+            invokeRedraw();
+            board.failPR(`k${i}`, 'codex: timed out after 1200s (retried once) — PR diff may be too large');
+            invokeRedraw();
+        }
+        const { scrollback } = emulateVT(captured.join(''), ROWS, COLS);
+        const liveOnlyMarkers = ['crosscheck', 'workflow:', 'vendors:', 'PRs:', 'tunnel:'];
+        const residue = scrollback.filter(l => liveOnlyMarkers.some(m => l.includes(m)));
+        expect(residue).toEqual([]);
+    });
 });
 // ── History pagination ────────────────────────────────────────────────────────
 //
@@ -353,6 +383,7 @@ describe('PRBoard — history pagination', () => {
     const page = () => board.page;
     const pageCount = () => board.pageCount;
     // The footer is the last line — the tip line also names the page keys.
+    const slotsOf = (b) => b.slots;
     const footerOf = (content) => stripAnsi(content).split('\n').at(-1) ?? '';
     const addCompleted = (n) => {
         for (let i = 0; i < n; i++) {
@@ -402,7 +433,7 @@ describe('PRBoard — history pagination', () => {
         board.pageOlder();
         const older = footerOf(invokeRender());
         expect(older).toContain('history · page 2/');
-        expect(older).toContain('ctrl+<');
+        expect(older).toContain('→');
     });
     it('keeps a history page inside the viewport', () => {
         addCompleted(60);
@@ -412,11 +443,50 @@ describe('PRBoard — history pagination', () => {
             .reduce((sum, l) => sum + Math.max(1, Math.ceil(l.length / 120)), 0);
         expect(rows).toBeLessThanOrEqual(19);
     });
+    it('mutes the page key that has nowhere to go', () => {
+        const level = chalk.level;
+        chalk.level = 3;
+        try {
+            addCompleted(60);
+            const rawFooter = () => invokeRender().split('\n').at(-1) ?? '';
+            const muted = (k) => chalk.gray.dim(k);
+            // Live page: nothing newer, so ← fades; → still leads somewhere.
+            expect(rawFooter()).toContain(muted('← newer'));
+            expect(rawFooter()).not.toContain(muted('→ older'));
+            board.pageOlder();
+            expect(rawFooter()).not.toContain(muted('← newer'));
+            expect(rawFooter()).not.toContain(muted('→ older'));
+            for (let i = 0; i < 50; i++)
+                board.pageOlder();
+            expect(rawFooter()).toContain(muted('→ older'));
+            expect(rawFooter()).not.toContain(muted('← newer'));
+        }
+        finally {
+            chalk.level = level;
+        }
+    });
+    it('shows when each PR entered, in a column after the PR number', () => {
+        board.addPR('a', 7, 'acme/api', 'branch-a');
+        board.addPR('b', 4880, 'acme/api', 'branch-b');
+        for (const k of ['a', 'b']) {
+            board.updatePR(k, { verdict: 'APPROVE', commentCount: 0 });
+            board.completePR(k, { elapsedMs: 60_000, url: `https://github.com/acme/api/pull/${k}` });
+        }
+        const rows = stripAnsi(invokeRender()).split('\n').filter(l => l.includes('branch-'));
+        expect(rows).toHaveLength(2);
+        const stampOf = (k) => fmtEnteredAt(slotsOf(board).get(k).startedAt);
+        const [sa, sb] = [stampOf('a'), stampOf('b')];
+        expect(rows[0]).toContain(sa);
+        expect(rows[1]).toContain(sb);
+        // #7 is padded to #4880's width, so the timestamp starts in the same column.
+        expect(rows[0].indexOf(sa)).toBe(rows[1].indexOf(sb));
+        expect(rows[0].indexOf('#7')).toBeLessThan(rows[0].indexOf(sa));
+    });
     it('has one page when everything fits on the live page', () => {
         addCompleted(2);
         invokeRender();
         expect(pageCount()).toBe(1);
-        expect(footerOf(invokeRender())).not.toContain('ctrl+<'); // no keys offered with nowhere to go
+        expect(footerOf(invokeRender())).not.toContain('older'); // no keys offered with nowhere to go
         expect(footerOf(invokeRender())).toContain('showing 2 of 2');
     });
 });
@@ -477,16 +547,16 @@ describe('PRBoard — key input', () => {
         fillHistory();
         board.start();
         expect(fake.isRaw).toBe(true);
-        fake.emit('data', Buffer.from('<'));
+        fake.emit('data', Buffer.from('\u001b[C'));
         expect(page()).toBe(1);
-        fake.emit('data', Buffer.from('<'));
+        fake.emit('data', Buffer.from('\u001b[C'));
         expect(page()).toBe(2);
-        fake.emit('data', Buffer.from('>'));
+        fake.emit('data', Buffer.from('\u001b[D'));
         expect(page()).toBe(1);
         board.stop();
         expect(fake.isRaw).toBe(false); // terminal handed back
         expect(fake.listenerCount('data')).toBe(0);
-        fake.emit('data', Buffer.from('<'));
+        fake.emit('data', Buffer.from('\u001b[C'));
         expect(page()).toBe(1); // no longer listening
     });
     it('raises SIGINT itself, since raw mode suppresses the terminal ctrl-c', () => {
@@ -505,29 +575,17 @@ describe('PRBoard — key input', () => {
     });
 });
 describe('pageKeyAction', () => {
-    it('maps bare < and > and their unshifted keys', () => {
-        expect(pageKeyAction('<')).toBe('older');
-        expect(pageKeyAction(',')).toBe('older');
-        expect(pageKeyAction('>')).toBe('newer');
-        expect(pageKeyAction('.')).toBe('newer');
-    });
-    it('maps the CSI-u encodings terminals use for ctrl/cmd + punctuation', () => {
-        expect(pageKeyAction('\u001b[44;5u')).toBe('older'); // ctrl+,
-        expect(pageKeyAction('\u001b[46;5u')).toBe('newer'); // ctrl+.
-        expect(pageKeyAction('\u001b[60;9u')).toBe('older'); // cmd+<
-        expect(pageKeyAction('\u001b[62;9u')).toBe('newer'); // cmd+>
-    });
-    it('maps plain and modified arrows', () => {
-        expect(pageKeyAction('\u001b[D')).toBe('older');
-        expect(pageKeyAction('\u001b[C')).toBe('newer');
-        expect(pageKeyAction('\u001b[1;5D')).toBe('older');
-        expect(pageKeyAction('\u001b[1;5C')).toBe('newer');
-    });
-    it('ignores everything else', () => {
-        expect(pageKeyAction('a')).toBe(null);
-        expect(pageKeyAction('\u0003')).toBe(null);
-        expect(pageKeyAction('\u001b[A')).toBe(null);
-        expect(pageKeyAction('\u001b[48;5u')).toBe(null);
+    it('maps the left and right arrows, in normal and application cursor mode', () => {
+        expect(pageKeyAction('\u001b[D')).toBe('newer');
+        expect(pageKeyAction('\u001b[C')).toBe('older');
+        expect(pageKeyAction('\u001bOD')).toBe('newer');
+        expect(pageKeyAction('\u001bOC')).toBe('older');
+    });
+    it('ignores every other key, including the retired < > , . and modified-arrow bindings', () => {
+        for (const seq of ['<', '>', ',', '.', '\u001b[1;5D', '\u001b[1;5C', '\u001bb', '\u001bf',
+            '\u001b\u001b[D', '\u001b[44;5u', '\u001b[5~', '\u001b[6~', 'a', '\u0003', '\u001b[A']) {
+            expect(pageKeyAction(seq)).toBe(null);
+        }
     });
 });
 describe('isNoticeLine', () => {
@@ -544,6 +602,247 @@ describe('isNoticeLine', () => {
         expect(isNoticeLine('  skills: typescript')).toBe(false);
     });
 });
+describe('distribute', () => {
+    it('returns all zeroes when nothing has been counted', () => {
+        expect(distribute([0, 0, 0])).toEqual([0, 0, 0]);
+    });
+    it('sums to exactly 100 where plain rounding would not', () => {
+        // Three equal shares floor to 33 each; the leftover point goes to a remainder.
+        const out = distribute([1, 1, 1]);
+        expect(out.reduce((a, b) => a + b, 0)).toBe(100);
+        expect(out.sort((a, b) => a - b)).toEqual([33, 33, 34]);
+    });
+    it('sums to 100 across a spread of awkward splits', () => {
+        const cases = [[1, 2], [1, 1, 1, 1, 1, 1], [7, 11, 13], [95, 1, 1, 1, 1, 1], [1, 999]];
+        for (const c of cases) {
+            expect(distribute(c).reduce((a, b) => a + b, 0)).toBe(100);
+        }
+    });
+    it('gives a lone outcome the whole 100%', () => {
+        expect(distribute([43, 0, 0])).toEqual([100, 0, 0]);
+    });
+    it('reports 0 for a share too small to earn a point, so callers can say "<1%"', () => {
+        const out = distribute([999, 1]);
+        expect(out[1]).toBe(0);
+        expect(out.reduce((a, b) => a + b, 0)).toBe(100);
+    });
+});
+describe('fmtUptime', () => {
+    it('renders minutes only under an hour', () => {
+        expect(fmtUptime(0)).toBe('0m');
+        expect(fmtUptime(59_000)).toBe('0m');
+        expect(fmtUptime(12 * 60_000)).toBe('12m');
+    });
+    it('renders hours and zero-padded minutes past the hour', () => {
+        expect(fmtUptime(60 * 60_000)).toBe('1h00m');
+        expect(fmtUptime((3 * 60 + 32) * 60_000)).toBe('3h32m');
+        expect(fmtUptime((11 * 60 + 57) * 60_000)).toBe('11h57m');
+    });
+    it('never renders a negative age if the clock steps backwards', () => {
+        expect(fmtUptime(-5000)).toBe('0m');
+    });
+});
+describe('PRBoard \u2014 failed PRs stay in the workspace', () => {
+    let board;
+    let originalIsTTY;
+    let originalRows;
+    let originalWrite;
+    let written;
+    beforeEach(() => {
+        originalIsTTY = process.stdout.isTTY;
+        originalRows = process.stdout.rows;
+        Object.defineProperty(process.stdout, 'isTTY', { value: true, configurable: true });
+        Object.defineProperty(process.stdout, 'rows', { value: 200, configurable: true });
+        originalWrite = process.stdout.write.bind(process.stdout);
+        written = [];
+        process.stdout.write = ((chunk) => { written.push(String(chunk)); return true; });
+        board = new PRBoard();
+        board.setConfig(baseConfig, [reviewStep]);
+    });
+    afterEach(() => {
+        board.stop();
+        process.stdout.write = originalWrite;
+        Object.defineProperty(process.stdout, 'isTTY', { value: originalIsTTY, configurable: true });
+        Object.defineProperty(process.stdout, 'rows', { value: originalRows, configurable: true });
+    });
+    const slots = () => board.slots;
+    const invokeRender = () => board.render();
+    it('keeps the slot instead of deleting it', () => {
+        board.addPR('k1', 4641, 'a/b', 'feat/x');
+        board.failPR('k1', 'codex: timed out after 600s');
+        expect(slots().size).toBe(1);
+        expect(slots().has('k1')).toBe(true);
+    });
+    it('renders the failed PR as a row carrying its error, not as scrollback', () => {
+        board.addPR('k1', 4641, 'a/b', 'feat/x');
+        board.failPR('k1', 'codex: timed out after 600s');
+        const output = stripAnsi(invokeRender());
+        expect(output).toContain('#4641');
+        expect(output).toContain('codex: timed out after 600s');
+        // The regression: the row went to scrollback and the table read "no PRs yet".
+        expect(output).not.toContain('no PRs yet');
+        expect(written.join('')).not.toContain('codex: timed out after 600s');
+    });
+    it('folds a failed row even when it is the only one on the page', () => {
+        board.addPR('k1', 4641, 'a/b', 'feat/x');
+        board.failPR('k1', 'codex: timed out after 600s');
+        const output = stripAnsi(invokeRender());
+        // Folded rows carry no pipeline bars; an expanded row would show "CR" queued
+        // against work the failed run will never do.
+        expect(output).not.toMatch(/CR [\u2588\u2591]/);
+        expect(output).toContain('\u2717 #4641');
+    });
+    it('flattens a multi-line subprocess dump into a single row', () => {
+        board.addPR('k1', 4823, 'a/b', 'feat/x');
+        board.failPR('k1', 'claude: Command failed with exit code 1: claude --print\n\n{"is_error":true,\n"result":"limit reached"}');
+        const rows = stripAnsi(invokeRender()).split('\n').filter(l => l.includes('#4823'));
+        // One row per folded slot is what history pagination sizes a page by.
+        expect(rows).toHaveLength(1);
+        expect(rows[0]).not.toContain('{');
+        expect(rows[0]).toContain('claude: Command failed');
+    });
+    it('counts a failure once, toward errors and the outcome split', () => {
+        board.addPR('k1', 1, 'a/b', 'feat/x');
+        board.failPR('k1', 'boom');
+        const stats = board.stats;
+        expect(stats.errorsOccurred).toBe(1);
+        expect(stats.outcomes.error).toBe(1);
+    });
+    it('still counts the error when the slot is already gone', () => {
+        board.failPR('never-added', 'boom');
+        const stats = board.stats;
+        expect(stats.errorsOccurred).toBe(1);
+        // No slot means no row, so nothing should be added to the distribution.
+        expect(stats.outcomes.error).toBe(0);
+    });
+    it('pages failed rows into history like any other settled row', () => {
+        for (let i = 0; i < 40; i++) {
+            board.addPR(`k${i}`, 4600 + i, 'a/b', `feat/${i}`);
+            board.failPR(`k${i}`, 'codex: timed out after 600s');
+        }
+        invokeRender();
+        expect(slots().size).toBe(40);
+        const pageCount = board.pageCount;
+        expect(pageCount).toBeGreaterThan(0);
+    });
+    it('emits the folded line to scrollback and drops the slot when not a TTY', () => {
+        Object.defineProperty(process.stdout, 'isTTY', { value: false, configurable: true });
+        const nonTty = new PRBoard();
+        nonTty.setConfig(baseConfig, [reviewStep]);
+        nonTty.addPR('k1', 4641, 'a/b', 'feat/x');
+        nonTty.failPR('k1', 'codex: timed out after 600s');
+        expect(stripAnsi(written.join(''))).toContain('codex: timed out after 600s');
+        expect(nonTty.slots.size).toBe(0);
+    });
+});
+describe('PRBoard \u2014 session stats panel', () => {
+    let board;
+    let originalIsTTY;
+    let originalRows;
+    let originalWrite;
+    beforeEach(() => {
+        originalIsTTY = process.stdout.isTTY;
+        originalRows = process.stdout.rows;
+        Object.defineProperty(process.stdout, 'isTTY', { value: true, configurable: true });
+        Object.defineProperty(process.stdout, 'rows', { value: 200, configurable: true });
+        originalWrite = process.stdout.write.bind(process.stdout);
+        process.stdout.write = (() => true);
+        board = new PRBoard();
+        board.setConfig(baseConfig, [reviewStep]);
+    });
+    afterEach(() => {
+        board.stop();
+        process.stdout.write = originalWrite;
+        Object.defineProperty(process.stdout, 'isTTY', { value: originalIsTTY, configurable: true });
+        Object.defineProperty(process.stdout, 'rows', { value: originalRows, configurable: true });
+    });
+    const invokeRender = () => board.render();
+    const setStart = (ms) => (board.stats.sessionStart = ms);
+    it('shows the local start time and the session age', () => {
+        const start = Date.now() - (3 * 60 + 32) * 60_000;
+        setStart(start);
+        const output = stripAnsi(invokeRender());
+        const expected = new Date(start).toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit', hour12: true });
+        expect(output).toContain(`since ${expected}`);
+        expect(output).toContain('up 3h32m');
+    });
+    it('omits the outcome split until something settles', () => {
+        const output = stripAnsi(invokeRender());
+        expect(output).toContain('since');
+        expect(output).not.toContain('%');
+    });
+    it('reports the outcome split as percentages that sum to 100', () => {
+        const verdicts = ['APPROVE', 'APPROVE', 'BLOCK', 'NEEDS WORK'];
+        verdicts.forEach((v, i) => {
+            board.addPR(`k${i}`, i, 'a/b', `b${i}`);
+            board.updatePR(`k${i}`, { verdict: v });
+            board.completePR(`k${i}`, { elapsedMs: 1000, url: `u${i}` });
+        });
+        const output = stripAnsi(invokeRender());
+        expect(output).toContain('APPROVE 50%');
+        expect(output).toContain('BLOCK 25%');
+        expect(output).toContain('NEEDS WORK 25%');
+    });
+    it('counts a failure in the split alongside verdicts', () => {
+        board.addPR('ok', 1, 'a/b', 'b1');
+        board.updatePR('ok', { verdict: 'APPROVE' });
+        board.completePR('ok', { elapsedMs: 1000, url: 'u1' });
+        board.addPR('bad', 2, 'a/b', 'b2');
+        board.failPR('bad', 'codex: timed out after 600s');
+        const output = stripAnsi(invokeRender());
+        expect(output).toContain('APPROVE 50%');
+        expect(output).toContain('error 50%');
+    });
+    it('takes the recheck verdict as the outcome when a recheck ran', () => {
+        board.addPR('k1', 1, 'a/b', 'b1');
+        board.updatePR('k1', { verdict: 'BLOCK', recheckVerdict: 'APPROVE' });
+        board.completePR('k1', { elapsedMs: 1000, url: 'u1' });
+        // Scoped to the stats block: the PR row still shows the round's own BLOCK in
+        // its CR bar, which is correct — only the split should read APPROVE.
+        const stats = stripAnsi(invokeRender()).split(/^─+$/m)[1] ?? '';
+        expect(stats).toContain('APPROVE 100%');
+        expect(stats).not.toContain('BLOCK');
+    });
+    it('separates a reviewer that returned nothing from one that never ran', () => {
+        board.addPR('noverdict', 1, 'a/b', 'b1');
+        board.updatePR('noverdict', { verdict: null });
+        board.completePR('noverdict', { elapsedMs: 1000, url: 'u1' });
+        board.addPR('skipped', 2, 'a/b', 'b2');
+        board.completePR('skipped', { elapsedMs: 900, url: 'u2', label: 'skipped \u00b7 generated' });
+        const output = stripAnsi(invokeRender());
+        expect(output).toContain('no verdict 50%');
+        expect(output).toContain('skipped 50%');
+    });
+    it('never pairs a "<1%" outcome with a flat 100%', () => {
+        for (let i = 0; i < 999; i++) {
+            board.addPR(`e${i}`, i, 'a/b', 'x');
+            board.failPR(`e${i}`, 'boom');
+        }
+        board.addPR('ok', 9999, 'a/b', 'y');
+        board.updatePR('ok', { verdict: 'APPROVE' });
+        board.completePR('ok', { elapsedMs: 1, url: 'u' });
+        const output = stripAnsi(invokeRender());
+        expect(output).toContain('APPROVE <1%');
+        expect(output).toContain('error >99%');
+        expect(output).not.toContain('error 100%');
+    });
+    it('still reads a clean 100% when one outcome is the only one', () => {
+        for (let i = 0; i < 5; i++) {
+            board.addPR(`e${i}`, i, 'a/b', 'x');
+            board.failPR(`e${i}`, 'boom');
+        }
+        expect(stripAnsi(invokeRender())).toContain('error 100%');
+    });
+    it('keeps the cumulative split after the slot history cap drops old rows', () => {
+        const stats = board.stats;
+        board.addPR('k1', 1, 'a/b', 'b1');
+        board.updatePR('k1', { verdict: 'APPROVE' });
+        board.completePR('k1', { elapsedMs: 1000, url: 'u1' });
+        board.slots.clear();
+        expect(stats.outcomes.APPROVE).toBe(1);
+        expect(stripAnsi(invokeRender())).toContain('APPROVE 100%');
+    });
+});
 // Minimal VT emulator: LF scrolls at the bottom row, CUU clamps at the viewport
 // top, ED-0J clears cursor→end-of-screen, autowrap is deferred at the last
 // column. Rows pushed off the top are collected as scrollback.