@rigour-labs/core 6.6.5 → 6.7.0

package/dist/review/reviewer/inputs.js

@@ -0,0 +1,107 @@
+/**
+ * What the reviewer works from, gathered before any model runs: the pull request (found by
+ * branch first, since at push time the commit is not on the forge yet; by commit for a detached
+ * checkout such as a backtest; only a number counts), every human review and inline comment
+ * (bots and the author excluded; everything from `reviewsBefore` on hidden for a backtest), the
+ * description, the diff written to a file (a reviewer whose shell is sandboxed still reads it,
+ * and no reviewer spends turns paging it), and whether HEAD merges the base in.
+ */
+import { createHash } from 'crypto';
+import fs from 'fs';
+import path from 'path';
+import { GH_TIMEOUT_MS, parseJsonArrays } from './exec.js';
+export function ghFor(cwd, exec, env) {
+    return args => exec('gh', args, { cwd, timeoutMs: GH_TIMEOUT_MS, env });
+}
+const PR_FIELDS = 'number,state,isDraft,author,body';
+/** The pull request for the branch (or the one named, or the one the commit is on), or none, or why it could not be read. */
+export async function findPullRequest(gh, branch, head, named) {
+    if (named !== undefined)
+        return viewPullRequest(gh, String(named));
+    if (branch !== 'HEAD') {
+        const byBranch = await viewPullRequest(gh, branch);
+        if (byBranch.pr || !byBranch.error)
+            return byBranch;
+        if (!/no pull requests? found|could not resolve/i.test(byBranch.error))
+            return byBranch;
+    }
+    const byCommit = await gh(['api', `repos/{owner}/{repo}/commits/${head}/pulls`, '-q', '.[0].number']);
+    if (byCommit.exitCode !== 0)
+        return branch === 'HEAD' ? { error: `could not look up the pull request for ${head.slice(0, 9)}: ${byCommit.stderr.trim()}` } : {};
+    const number = byCommit.stdout.trim();
+    return /^\d+$/.test(number) ? viewPullRequest(gh, number) : {};
+}
+async function viewPullRequest(gh, selector) {
+    const result = await gh(['pr', 'view', selector, '--json', PR_FIELDS]);
+    if (result.exitCode !== 0) {
+        const message = result.stderr.trim() || result.stdout.trim();
+        return /no pull requests? found/i.test(message) ? {} : { error: `could not read the pull request for ${selector}: ${message.slice(0, 200)}` };
+    }
+    try {
+        const parsed = JSON.parse(result.stdout);
+        if (!Number.isInteger(parsed.number))
+            return { error: `gh returned no pull request number for ${selector}` };
+        return { pr: { number: parsed.number, state: String(parsed.state ?? '').toLowerCase(), draft: !!parsed.isDraft, author: String(parsed.author?.login ?? ''), body: String(parsed.body ?? '') } };
+    }
+    catch {
+        return { error: `gh returned something other than a pull request for ${selector}: ${result.stdout.slice(0, 120)}` };
+    }
+}
+/** Written by a person: not a bot, and not the pull request's author answering their own review. */
+export function isHuman(item, author) {
+    return !!item?.user && item.user.type !== 'Bot' && !/\[bot\]$/.test(item.user.login) && item.user.login !== author;
+}
+/** Every review by a person and every inline comment by a person, hidden from `reviewsBefore` on. */
+export async function humanReviews(gh, pr, reviewsBefore) {
+    const reviews = await gh(['api', `repos/{owner}/{repo}/pulls/${pr.number}/reviews`, '--paginate']);
+    if (reviews.exitCode !== 0)
+        return { error: `could not read the reviews of pull request ${pr.number}: ${reviews.stderr.trim().slice(0, 200)}` };
+    const comments = await gh(['api', `repos/{owner}/{repo}/pulls/${pr.number}/comments`, '--paginate']);
+    if (comments.exitCode !== 0)
+        return { error: `could not read the comments of pull request ${pr.number}: ${comments.stderr.trim().slice(0, 200)}` };
+    const human = (x) => isHuman(x, pr.author);
+    const before = (at) => !reviewsBefore || (typeof at === 'string' && at < reviewsBefore);
+    const rounds = parseJsonArrays(reviews.stdout).filter((r) => human(r) && String(r.body ?? '').trim() && before(r.submitted_at));
+    const inline = parseJsonArrays(comments.stdout).filter((c) => human(c) && before(c.created_at));
+    let markdown = rounds.map((r) => `## Review by ${r.user.login}, ${r.submitted_at}, ${r.state} (on ${String(r.commit_id ?? '').slice(0, 9)})\n\n${String(r.body).trim()}\n`).join('\n');
+    if (inline.length)
+        markdown += `\n## Inline comments\n${inline.map((c) => `- ${c.created_at} ${c.path}:${c.line ?? c.original_line ?? '?'}: ${String(c.body ?? '').trim()}`).join('\n')}\n`;
+    const latest = rounds.at(-1);
+    return {
+        reviews: {
+            markdown: markdown || 'none\n',
+            key: [...rounds.map((r) => `${r.id},${r.submitted_at},${r.commit_id},${r.state}`), ...inline.map((c) => `${c.id},${c.updated_at}`)].join('|'),
+            count: rounds.length,
+            ...(latest ? { label: `${latest.user.login}, ${latest.submitted_at} (${rounds.length} review${rounds.length === 1 ? '' : 's'})` } : {}),
+        },
+    };
+}
+/** The repository's rules as the reviewer must read them. */
+export function rulesText(cwd) {
+    return ['AGENTS.md', 'CLAUDE.md'].map(name => {
+        try {
+            return fs.readFileSync(path.join(cwd, name), 'utf8');
+        }
+        catch {
+            return '';
+        }
+    }).join('\n');
+}
+export function sha(parts) {
+    return createHash('sha256').update(parts.join('\0')).digest('hex').slice(0, 16);
+}
+/** True when HEAD is a merge whose second parent is on the base: the branch merged main in. */
+export async function mergesBaseIn(cwd, baseSha, exec) {
+    const parents = (await exec('git', ['rev-list', '--parents', '-n1', 'HEAD'], { cwd, timeoutMs: GH_TIMEOUT_MS })).stdout.trim().split(/\s+/);
+    if (parents.length <= 2)
+        return false;
+    return (await exec('git', ['merge-base', '--is-ancestor', 'HEAD^2', baseSha], { cwd, timeoutMs: GH_TIMEOUT_MS })).exitCode === 0;
+}
+/** Added and removed lines between two commits. */
+export async function linesChanged(cwd, from, to, exec) {
+    const numstat = (await exec('git', ['diff', '--numstat', `${from}..${to}`], { cwd, timeoutMs: GH_TIMEOUT_MS })).stdout;
+    return numstat.split('\n').reduce((sum, line) => {
+        const [added, removed] = line.split('\t');
+        return sum + (Number(added) || 0) + (Number(removed) || 0);
+    }, 0);
+}

package/dist/review/reviewer/merge-impact.d.ts

@@ -0,0 +1,2 @@
+import { type Exec } from './exec.js';
+export declare function mergeImpact(cwd: string, oldBase: string, newBase: string, head: string, exec: Exec): Promise<string>;

package/dist/review/reviewer/merge-impact.js

@@ -0,0 +1,64 @@
+/**
+ * After a merge from main: which main-side files the branch's changed files import, and how main
+ * changed them. A branch call site written against the old definition is the regression a plain
+ * diff review never shows (main changes how an id is parsed; the branch's link builder keeps
+ * building the old shape). Rendered as Markdown for the reviewer; empty when nothing overlaps.
+ */
+import path from 'path';
+import { GH_TIMEOUT_MS } from './exec.js';
+const CODE = /\.(ts|tsx|js|jsx|mjs|cjs|svelte)$/;
+const TEST = /\.(test|spec|e2e)\.[cm]?[jt]sx?$/;
+const IMPORT = /import\s*(?:type\s*)?(?:\{([^}]*)\}|(\w+))?\s*(?:,\s*\{([^}]*)\})?\s*from\s*['"]([^'"]+)['"]|import\(\s*['"]([^'"]+)['"]\s*\)/g;
+const MAX_DIFF_CHARS = 12_000;
+const withoutExtension = (file) => file.replace(CODE, '').replace(/\/index$/, '');
+export async function mergeImpact(cwd, oldBase, newBase, head, exec) {
+    const git = async (args) => (await exec('git', args, { cwd, timeoutMs: GH_TIMEOUT_MS })).stdout;
+    const files = (text) => text.split('\n').filter(f => f && CODE.test(f));
+    const mainSide = new Set(files(await git(['diff', '--name-only', oldBase, newBase])));
+    const branchFiles = files(await git(['diff', '--name-only', `${newBase}...${head}`]));
+    // A file both sides changed was reconciled by the merge itself; the silent risk is a
+    // main-only change under a branch file that still calls the old shape.
+    for (const file of branchFiles)
+        mainSide.delete(file);
+    const mainByStem = new Map([...mainSide].map(file => [withoutExtension(file), file]));
+    const hits = [];
+    for (const file of branchFiles) {
+        if (TEST.test(file))
+            continue;
+        const shown = await exec('git', ['show', `${head}:${file}`], { cwd, timeoutMs: GH_TIMEOUT_MS });
+        if (shown.exitCode !== 0)
+            continue;
+        for (const match of shown.stdout.matchAll(IMPORT)) {
+            const target = resolve(match[4] ?? match[5], file);
+            const mainFile = target ? mainByStem.get(target) : undefined;
+            if (!mainFile)
+                continue;
+            const names = [match[1], match[3]].filter(Boolean).join(',').split(',').map(s => s.trim().replace(/^type\s+/, '').split(/\s+as\s+/)[0]).filter(Boolean);
+            if (match[2])
+                names.push(match[2]);
+            hits.push({ file, mainFile, names });
+        }
+    }
+    if (hits.length === 0)
+        return '';
+    const out = ['## Merge impact: main-side files the branch imports that main changed', ''];
+    const seen = new Set();
+    for (const hit of hits) {
+        if (seen.has(`${hit.file}|${hit.mainFile}`))
+            continue;
+        seen.add(`${hit.file}|${hit.mainFile}`);
+        const named = hit.names.join(', ') || '(default)';
+        out.push(`### ${hit.file} imports ${named} from ${hit.mainFile}`);
+        const tests = [...mainSide].filter(f => f !== hit.mainFile && f.replace(/\.(test|spec)\./, '.') === hit.mainFile);
+        const diff = await git(['diff', '--unified=3', oldBase, newBase, '--', hit.mainFile, ...tests]);
+        out.push('```diff', diff.trim().slice(0, MAX_DIFF_CHARS), '```', '', `Check every call site of ${named} in ${hit.file} against the new definition and the new tests.`, '');
+    }
+    return out.join('\n');
+}
+function resolve(specifier, from) {
+    if (specifier.startsWith('.'))
+        return withoutExtension(path.posix.normalize(path.posix.join(path.posix.dirname(from), specifier)));
+    if (specifier.startsWith('$lib/'))
+        return withoutExtension(`src/lib/${specifier.slice(5)}`);
+    return undefined;
+}

package/dist/review/reviewer/panel.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Two or three judges as a panel, run around the consensus rules (consensus.ts). The judges' own
+ * items are grouped into findings; a finding a strict majority raised is confirmed. Every other
+ * judge then cross-examines, in one batched call each, only the findings it did not raise: confirm
+ * or refute with file:line evidence; no evidence or no answer is unsure. The calls decide by
+ * majority; a disputed finding is shown and never blocks. A finding disputed before, on a file no
+ * commit has touched since, stays disputed without another call; past the item cap, disputed too.
+ *
+ * Every finding keeps what a later re-scoring needs (who raised it, every judge's call, the
+ * cross-examination answers, each judge's own item and the class), so a probabilistic truth model
+ * can be fitted to the ledger later without running anyone again.
+ */
+import { type Call, type PanelStatus } from './consensus.js';
+import type { OpenItem } from './verdict.js';
+export interface PanelItem {
+    /** The item as its first raiser reported it. */
+    item: OpenItem;
+    /** The judges who raised it unprompted. */
+    judges: string[];
+    /** Every judge's call on it, raised or answered in cross-examination. */
+    calls: Record<string, Call>;
+    /** Every cross-examination answer about it, with the code each judge quoted. */
+    cross?: Array<{
+        by: string;
+        call: Call;
+        evidence?: string;
+    }>;
+    /** Each judge's own item when more than one wrote it: what a later re-scoring of the panel needs. */
+    members?: Array<{
+        judge: string;
+        item: OpenItem;
+    }>;
+    status: PanelStatus;
+    /** Why it is disputed without a cross-examination (over the cap, disputed before and untouched since). */
+    note?: string;
+}
+/** A judge's answer about another judge's items: confirm or refute, each with the code that shows it. */
+export interface Answer {
+    id: string;
+    call: 'confirm' | 'refute' | 'unsure';
+    evidence?: string;
+}
+export interface PanelInput {
+    judges: string[];
+    items: OpenItem[][];
+    /** Items disputed in the previous verdict, and the files changed since it. */
+    previousDisputed: OpenItem[];
+    touched: Set<string>;
+    maxItems: number;
+    /** Asks `judge` about items other judges raised; resolves to its answers (a missing one counts as unsure). */
+    ask: (judge: string, items: OpenItem[]) => Promise<Answer[]>;
+    /** Why no more agent runs may start today (a daily cap), checked before each judge's cross-examination. */
+    capped?: () => string | undefined;
+    /** Whether an answer's evidence quotes real code: a `file:line` the checkout has. */
+    evidenced: (evidence: string) => boolean;
+}
+/** The panel's decision on every finding any judge raised. */
+export declare function runPanel(input: PanelInput): Promise<PanelItem[]>;
+/** The answers in a judge's cross-examination reply; nothing usable is no answers (every item then disputed). */
+export declare function parseAnswers(text: string): Answer[];
+/** The accounting with the panel's decision applied: the judges' own items leave, and only what it confirmed blocks. */
+export declare function applyPanel<T extends {
+    open: OpenItem[];
+}>(accounted: T, judgeItemIds: Set<string>, decided: PanelItem[]): T & {
+    disputed: OpenItem[];
+    dropped: OpenItem[];
+};

package/dist/review/reviewer/panel.js

@@ -0,0 +1,101 @@
+/**
+ * Two or three judges as a panel, run around the consensus rules (consensus.ts). The judges' own
+ * items are grouped into findings; a finding a strict majority raised is confirmed. Every other
+ * judge then cross-examines, in one batched call each, only the findings it did not raise: confirm
+ * or refute with file:line evidence; no evidence or no answer is unsure. The calls decide by
+ * majority; a disputed finding is shown and never blocks. A finding disputed before, on a file no
+ * commit has touched since, stays disputed without another call; past the item cap, disputed too.
+ *
+ * Every finding keeps what a later re-scoring needs (who raised it, every judge's call, the
+ * cross-examination answers, each judge's own item and the class), so a probabilistic truth model
+ * can be fitted to the ledger later without running anyone again.
+ */
+import { clusterItems, MATCH_THRESHOLD, order, similarity, statusOf } from './consensus.js';
+/** The panel's decision on every finding any judge raised. */
+export async function runPanel(input) {
+    const n = input.judges.length;
+    const clusters = clusterItems(input.judges, input.items);
+    const decided = clusters.map(c => {
+        const raisers = [...new Set(c.members.map(m => m.judge))];
+        const calls = Object.fromEntries(raisers.map(j => [j, 'raised']));
+        const item = { ...c.members[0].item, evidence: c.members.map(m => m.item.evidence).find(Boolean) };
+        return { item, judges: raisers, calls, status: statusOf(calls, n), ...(c.members.length > 1 ? { members: c.members } : {}) };
+    });
+    const undecided = decided.filter(d => d.status !== 'confirmed');
+    const disputedBefore = (item) => !!item.file && !input.touched.has(item.file) && input.previousDisputed.some(p => similarity(item, p) >= MATCH_THRESHOLD);
+    for (const d of undecided.filter(d => disputedBefore(d.item))) {
+        for (const judge of input.judges)
+            d.calls[judge] ??= 'not asked';
+        d.status = 'disputed';
+        d.note = 'disputed before; its file is unchanged since';
+    }
+    const toAsk = undecided.filter(d => !d.note).sort((a, b) => order(a.item, b.item));
+    for (const d of toAsk.slice(input.maxItems)) {
+        for (const judge of input.judges)
+            d.calls[judge] ??= 'not asked';
+        d.status = 'disputed';
+        d.note = `over review.reviewer.panel_max_items (${input.maxItems})`;
+    }
+    const asked = toAsk.slice(0, input.maxItems);
+    // One batched call per judge, about every asked finding it did not raise; the calls run together.
+    await Promise.all(input.judges.map(async (judge) => {
+        const mine = asked.filter(d => !d.judges.includes(judge));
+        if (!mine.length)
+            return;
+        const cap = input.capped?.();
+        if (cap) {
+            for (const d of mine) {
+                d.calls[judge] = 'not asked';
+                d.note = cap;
+            }
+            return;
+        }
+        let answers = [];
+        try {
+            answers = await input.ask(judge, mine.map(d => d.item));
+        }
+        catch {
+            answers = [];
+        }
+        for (const d of mine) {
+            const answer = answers.find(x => x.id === d.item.id);
+            const evidenced = !!answer?.evidence && input.evidenced(answer.evidence);
+            d.calls[judge] = answer && evidenced ? answer.call : 'unsure';
+            d.cross = [...(d.cross ?? []), { by: judge, call: d.calls[judge], ...(answer?.evidence ? { evidence: answer.evidence } : {}) }];
+        }
+    }));
+    for (const d of asked)
+        d.status = statusOf(d.calls, n);
+    return decided.sort((x, y) => order(x.item, y.item));
+}
+/** The answers in a judge's cross-examination reply; nothing usable is no answers (every item then disputed). */
+export function parseAnswers(text) {
+    const candidates = [text.trim(), ...[...text.matchAll(/```(?:json)?\s*([\s\S]*?)```/g)].map(m => m[1].trim()), ...[...text.matchAll(/\{\s*"answers"/g)].map(m => text.slice(m.index))];
+    for (const candidate of candidates) {
+        for (let end = candidate.lastIndexOf('}'); end > 0; end = candidate.lastIndexOf('}', end - 1)) {
+            try {
+                const parsed = JSON.parse(candidate.slice(0, end + 1));
+                if (!Array.isArray(parsed?.answers))
+                    continue;
+                return parsed.answers.filter((a) => typeof a?.id === 'string' && ['confirm', 'refute', 'unsure'].includes(a.call))
+                    .map((a) => ({ id: a.id, call: a.call, ...(typeof a.evidence === 'string' ? { evidence: a.evidence } : {}) }));
+            }
+            catch {
+                // not a whole object yet: try a shorter one
+            }
+        }
+    }
+    return [];
+}
+/** The accounting with the panel's decision applied: the judges' own items leave, and only what it confirmed blocks. */
+export function applyPanel(accounted, judgeItemIds, decided) {
+    const withJudges = (d) => ({ ...d.item, reviewer: d.judges.join('+') });
+    const confirmed = decided.filter(d => d.status === 'confirmed').map(withJudges);
+    const open = [...accounted.open.filter(item => !judgeItemIds.has(item.id)), ...confirmed.filter(c => !accounted.open.some(o => o.id === c.id && !judgeItemIds.has(o.id)))];
+    return {
+        ...accounted,
+        open,
+        disputed: decided.filter(d => d.status === 'disputed').map(withJudges),
+        dropped: decided.filter(d => d.status === 'dropped').map(withJudges),
+    };
+}

package/dist/review/reviewer/panel.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/review/reviewer/panel.test.js

@@ -0,0 +1,110 @@
+import { describe, expect, it } from 'vitest';
+import { clusterItems, similarity, statusOf } from './consensus.js';
+import { applyPanel, parseAnswers, runPanel } from './panel.js';
+let n = 0;
+const item = (file, line, cls, issue, consequence = 'wrong rows') => ({ id: `i${++n}`, kind: 'finding', class: cls, file, line, issue, consequence });
+/** Evidence counts only as a real file:line: here, any src/q.ts line. */
+const evidenced = (text) => /src\/q\.ts:\d+/.test(text);
+const members = (judges, items) => clusterItems(judges, items).map(c => c.members.map(m => `${m.judge}:${m.item.issue}`));
+describe('matching findings across judges', () => {
+    it('needs the same file, and shared wording unless it is the same line and class', () => {
+        const a = item('src/a.ts', 10, 'correctness', 'window not bounded at both ends', 'scans every past event');
+        expect(similarity(a, { ...a, file: 'src/b.ts' })).toBe(0);
+        expect(similarity(a, item('src/a.ts', 11, 'correctness', 'dedupe key changes when the user edits', 'duplicate emails go out'))).toBe(0);
+        expect(similarity(a, item('src/a.ts', 10, 'correctness', 'something else entirely', 'duplicate emails go out'))).toBeGreaterThanOrEqual(0.5);
+    });
+    it('keeps two different findings on adjacent lines apart, even listed in a misleading order (first-fit by line would cross them)', () => {
+        const judgeA = [item('src/q.ts', 10, 'production-cost', 'time window not bounded at both ends'), item('src/q.ts', 11, 'correctness', 'dedupe key changes when the user edits')];
+        const judgeB = [item('src/q.ts', 10, 'correctness', 'dedupe key built from updated_at changes when the user edits'), item('src/q.ts', 11, 'production-cost', 'read window has no upper bound at either end')];
+        expect(members(['a', 'b'], [judgeA, judgeB])).toEqual([
+            ['a:time window not bounded at both ends', 'b:read window has no upper bound at either end'],
+            ['a:dedupe key changes when the user edits', 'b:dedupe key built from updated_at changes when the user edits'],
+        ]);
+    });
+    it('matches one bug two judges cite at different lines', () => {
+        const judgeA = [item('src/q.ts', 10, 'correctness', 'lock is checked after the first read of rows')];
+        const judgeB = [item('src/q.ts', 40, 'correctness', 'the first read of rows happens before the lock is checked')];
+        expect(members(['a', 'b'], [judgeA, judgeB])).toHaveLength(1);
+    });
+    it('puts what one judge split under the one item another judge wrote', () => {
+        const judgeA = [item('src/q.ts', 10, 'production-cost', 'both reads, rows and cards, are unbounded')];
+        const judgeB = [item('src/q.ts', 10, 'production-cost', 'rows read is unbounded'), item('src/q.ts', 14, 'production-cost', 'cards read is unbounded')];
+        expect(members(['a', 'b'], [judgeA, judgeB])).toEqual([['a:both reads, rows and cards, are unbounded', 'b:rows read is unbounded', 'b:cards read is unbounded']]);
+    });
+    it('never merges one judge\'s own two findings, however close', () => {
+        const judgeA = [item('src/x.ts', 10, 'correctness', 'session.user may be null when the token expired'), item('src/x.ts', 12, 'correctness', 'session.expires compared as a string, not a date')];
+        expect(members(['a', 'b'], [judgeA, []])).toEqual([['a:session.user may be null when the token expired'], ['a:session.expires compared as a string, not a date']]);
+    });
+    it('groups three judges, and is the same every run', () => {
+        const items = [
+            [item('src/q.ts', 10, 'correctness', 'lock checked after the read')],
+            [item('src/q.ts', 11, 'correctness', 'the read happens before the lock is checked'), item('src/r.ts', 3, 'dead-code', 'export unused')],
+            [item('src/q.ts', 10, 'correctness', 'lock checked only after the read')],
+        ];
+        const once = members(['a', 'b', 'c'], items);
+        expect(once).toEqual(members(['a', 'b', 'c'], items));
+        expect(once.map(c => c.length)).toEqual([3, 1]);
+    });
+});
+describe('deciding a finding', () => {
+    it('confirms on a strict majority, drops on evidence against with nobody unsure, else disputes', () => {
+        expect(statusOf({ a: 'raised', b: 'raised' }, 2)).toBe('confirmed');
+        expect(statusOf({ a: 'raised', b: 'confirm' }, 2)).toBe('confirmed');
+        expect(statusOf({ a: 'raised', b: 'refute' }, 2)).toBe('dropped');
+        expect(statusOf({ a: 'raised', b: 'unsure' }, 2)).toBe('disputed');
+        expect(statusOf({ a: 'raised', b: 'raised' }, 3)).toBe('confirmed');
+        expect(statusOf({ a: 'raised', b: 'confirm', c: 'refute' }, 3)).toBe('confirmed');
+        expect(statusOf({ a: 'raised', b: 'refute', c: 'refute' }, 3)).toBe('dropped');
+        expect(statusOf({ a: 'raised', b: 'refute', c: 'unsure' }, 3)).toBe('disputed');
+    });
+    it('asks each judge once about what it did not raise, needs file:line evidence, and caps what it asks', async () => {
+        const asked = {};
+        const lone = item('src/q.ts', 10, 'correctness', 'lock checked after the read');
+        const refuted = item('src/q.ts', 30, 'correctness', 'the cursor skips the last page');
+        const bare = item('src/q.ts', 50, 'correctness', 'an index is missing on created_at');
+        const overCap = item('src/z.ts', 1, 'correctness', 'retries forever on 429');
+        const answers = { b: [{ id: lone.id, call: 'confirm', evidence: 'src/q.ts:12 reads before lock()' }, { id: refuted.id, call: 'refute', evidence: 'src/q.ts:33 the loop runs once more' }, { id: bare.id, call: 'confirm' }] };
+        const decided = await runPanel({
+            judges: ['a', 'b'], items: [[lone, refuted, bare, overCap], []], previousDisputed: [], touched: new Set(), maxItems: 3, evidenced,
+            ask: async (judge, items) => { asked[judge] = items.map(i => i.issue); return answers[judge] ?? []; },
+        });
+        expect(asked).toEqual({ b: ['lock checked after the read', 'the cursor skips the last page', 'an index is missing on created_at'] });
+        const status = Object.fromEntries(decided.map(d => [d.item.issue, d.status]));
+        expect(status).toEqual({ 'lock checked after the read': 'confirmed', 'the cursor skips the last page': 'dropped', 'an index is missing on created_at': 'disputed', 'retries forever on 429': 'disputed' });
+        expect(decided.find(d => d.item.id === overCap.id)?.note).toContain('panel_max_items');
+        expect(decided.find(d => d.item.id === lone.id)).toMatchObject({ judges: ['a'], calls: { a: 'raised', b: 'confirm' }, cross: [{ by: 'b', call: 'confirm', evidence: 'src/q.ts:12 reads before lock()' }] });
+    });
+    it('does not ask again about a finding disputed before on a file nothing has touched since', async () => {
+        const again = item('src/q.ts', 10, 'correctness', 'lock checked after the read');
+        const asked = [];
+        const ask = async (_judge, items) => { asked.push(...items.map(i => i.id)); return []; };
+        const untouched = await runPanel({ judges: ['a', 'b'], items: [[again], []], previousDisputed: [{ ...again, id: 'old' }], touched: new Set(), maxItems: 20, evidenced, ask });
+        expect(untouched[0]).toMatchObject({ status: 'disputed', note: 'disputed before; its file is unchanged since' });
+        expect(asked).toEqual([]);
+        await runPanel({ judges: ['a', 'b'], items: [[again], []], previousDisputed: [{ ...again, id: 'old' }], touched: new Set(['src/q.ts']), maxItems: 20, evidenced, ask });
+        expect(asked).toEqual([again.id]);
+    });
+    it('a judge that fails to answer leaves the findings disputed, never confirmed', async () => {
+        const lone = item('src/q.ts', 10, 'correctness', 'lock checked after the read');
+        const decided = await runPanel({ judges: ['a', 'b'], items: [[lone], []], previousDisputed: [], touched: new Set(), maxItems: 20, evidenced, ask: async () => { throw new Error('timed out'); } });
+        expect(decided[0]).toMatchObject({ status: 'disputed', calls: { a: 'raised', b: 'unsure' } });
+    });
+});
+describe('the panel in the accounting', () => {
+    it('blocks only on what it confirmed, and lists the rest', () => {
+        const confirmed = item('src/q.ts', 10, 'correctness', 'lock checked after the read');
+        const disputed = item('src/q.ts', 30, 'correctness', 'cursor skips a page');
+        const human = { ...item('', 0, 'prior point', 'a human point'), kind: 'prior' };
+        const result = applyPanel({ open: [confirmed, disputed, human] }, new Set([confirmed.id, disputed.id]), [
+            { item: confirmed, judges: ['a', 'b'], calls: { a: 'raised', b: 'raised' }, status: 'confirmed' },
+            { item: disputed, judges: ['a'], calls: { a: 'raised', b: 'unsure' }, status: 'disputed' },
+        ]);
+        expect(result.open.map(i => i.issue)).toEqual(['a human point', 'lock checked after the read']);
+        expect(result.open[1].reviewer).toBe('a+b');
+        expect(result.disputed.map(i => i.issue)).toEqual(['cursor skips a page']);
+    });
+    it('reads the answers out of a reply with prose around them, and nothing from a reply without them', () => {
+        expect(parseAnswers('Checked.\n```json\n{"answers":[{"id":"x","call":"refute","evidence":"a.ts:3"},{"id":"y","call":"maybe"}]}\n```')).toEqual([{ id: 'x', call: 'refute', evidence: 'a.ts:3' }]);
+        expect(parseAnswers('I could not decide.')).toEqual([]);
+    });
+});

package/dist/review/reviewer/prompt.d.ts

@@ -0,0 +1,32 @@
+export interface PromptInputs {
+    repoRoot: string;
+    branch: string;
+    head: string;
+    base: string;
+    baseSha: string;
+    mode: 'full' | 'delta';
+    reviewsFile: string;
+    humanCount: number;
+    prBodyFile: string;
+    diffstatFile: string;
+    diffFile: string;
+    hintsFile: string;
+    /** What the team already knows (reviewer/context.ts). */
+    contextFile: string;
+    deltaBlock: string;
+    mergeBlock: string;
+}
+export declare function renderPrompt(v: PromptInputs): string;
+export declare function deltaBlock(previousHead: string, previousVerdict: string, previousOpenFile: string, commitsFile: string, deltaDiffFile: string, settledFile: string): string;
+export declare function mergeBlock(base: string, impactFile: string | undefined): string;
+/** Changes when the instructions change, so a cached verdict from older instructions is not reused. */
+export declare const PROMPT_VERSION: string;
+/** One judge's single call on the items the other judge raised alone: confirm or refute each, with the code that shows it. */
+export declare function crossExamPrompt(repoRoot: string, head: string, diffFile: string, items: Array<{
+    id: string;
+    class: string;
+    file?: string;
+    line?: number;
+    issue: string;
+    consequence?: string;
+}>): string;