@rigour-labs/core 6.7.8 → 6.7.10

package/dist/review/backtest-init.js

@@ -40,7 +40,7 @@ export async function roundsForPr(cwd, pr, config, exec = defaultExec, options =
     }
     const approval = options.approvedHead ? byPerson.find((r) => r.state === 'APPROVED' && r.commit_id) : undefined;
     const approved = approval
-        ? { id: `pr${pr}-approved`, commit: String(approval.commit_id), base: await baseAt(cwd, String(approval.commit_id), approval.submitted_at, mainRef, exec), reviewed_at: String(approval.submitted_at), pr, points: [], must_not_flag: [] }
+        ? { id: `pr${pr}-approved`, commit: String(approval.commit_id), base: await baseAt(cwd, String(approval.commit_id), approval.submitted_at, mainRef, exec), reviewed_at: String(approval.submitted_at), approved: true, pr, points: [], must_not_flag: [] }
         : undefined;
     if (rounds.length === 0 && !approved)
         throw new Error(`pull request ${pr} has no review by a person yet`);

package/dist/review/backtest.d.ts

@@ -55,6 +55,8 @@ declare const Round: z.ZodObject<{
     base: z.ZodString;
     /** When the human review was posted: the reviewer sees nothing from then on. */
     reviewed_at: z.ZodOptional<z.ZodString>;
+    /** The head a person approved: `reviewed_at` is the approval, and the reviewer sees it (it closes the points before it). */
+    approved: z.ZodOptional<z.ZodBoolean>;
     pr: z.ZodOptional<z.ZodNumber>;
     points: z.ZodArray<z.ZodObject<{
         /** A regular expression over the finding's file path. */
@@ -123,6 +125,7 @@ declare const Round: z.ZodObject<{
     }[];
     pr?: number | undefined;
     reviewed_at?: string | undefined;
+    approved?: boolean | undefined;
 }, {
     id: string;
     commit: string;
@@ -137,6 +140,7 @@ declare const Round: z.ZodObject<{
     }[];
     pr?: number | undefined;
     reviewed_at?: string | undefined;
+    approved?: boolean | undefined;
     must_not_flag?: {
         file: string;
         text?: string | undefined;
@@ -151,6 +155,8 @@ export declare const LedgerSchema: z.ZodObject<{
         base: z.ZodString;
         /** When the human review was posted: the reviewer sees nothing from then on. */
         reviewed_at: z.ZodOptional<z.ZodString>;
+        /** The head a person approved: `reviewed_at` is the approval, and the reviewer sees it (it closes the points before it). */
+        approved: z.ZodOptional<z.ZodBoolean>;
         pr: z.ZodOptional<z.ZodNumber>;
         points: z.ZodArray<z.ZodObject<{
             /** A regular expression over the finding's file path. */
@@ -219,6 +225,7 @@ export declare const LedgerSchema: z.ZodObject<{
         }[];
         pr?: number | undefined;
         reviewed_at?: string | undefined;
+        approved?: boolean | undefined;
     }, {
         id: string;
         commit: string;
@@ -233,6 +240,7 @@ export declare const LedgerSchema: z.ZodObject<{
         }[];
         pr?: number | undefined;
         reviewed_at?: string | undefined;
+        approved?: boolean | undefined;
         must_not_flag?: {
             file: string;
             text?: string | undefined;
@@ -261,6 +269,7 @@ export declare const LedgerSchema: z.ZodObject<{
         }[];
         pr?: number | undefined;
         reviewed_at?: string | undefined;
+        approved?: boolean | undefined;
     }[];
 }, {
     rounds: {
@@ -277,6 +286,7 @@ export declare const LedgerSchema: z.ZodObject<{
         }[];
         pr?: number | undefined;
         reviewed_at?: string | undefined;
+        approved?: boolean | undefined;
         must_not_flag?: {
             file: string;
             text?: string | undefined;

package/dist/review/backtest.js

@@ -35,6 +35,8 @@ const Round = z.object({
     base: z.string().min(1),
     /** When the human review was posted: the reviewer sees nothing from then on. */
     reviewed_at: z.string().optional(),
+    /** The head a person approved: `reviewed_at` is the approval, and the reviewer sees it (it closes the points before it). */
+    approved: z.boolean().optional(),
     pr: z.number().int().positive().optional(),
     points: z.array(Point),
     must_not_flag: z.array(Match).default([]),
@@ -91,7 +93,7 @@ export async function runBacktest(cwd, config, ledger, options = {}) {
         const started = Date.now();
         const worktree = await worktreeFor(cwd, round.commit, exec);
         const head = (await exec('git', ['rev-parse', 'HEAD'], { cwd: worktree, timeoutMs: GIT_TIMEOUT_MS })).stdout.trim();
-        progress(`backtest ${round.id}: ${head.slice(0, 9)} against ${round.base}${round.reviewed_at ? `, reviews hidden from ${round.reviewed_at}` : ''}`);
+        progress(`backtest ${round.id}: ${head.slice(0, 9)} against ${round.base}${round.reviewed_at ? `, reviews hidden from ${reviewsHiddenFrom(round)}` : ''}`);
         const stale = await staleBase(worktree, head, round.base, exec);
         if (stale)
             progress(`backtest ${round.id}: warning: ${stale}`);
@@ -192,7 +194,7 @@ async function collectItems(worktree, round, config, reviewer, exec, progress) {
     ];
     if (!reviewer)
         return { items };
-    const result = await runReviewer(worktree, round.base, config, exec, progress, { pr: round.pr, reviewsBefore: round.reviewed_at, blind: round.pr === undefined, trigger: 'backtest', force: true, ...reviewerInputs(review) });
+    const result = await runReviewer(worktree, round.base, config, exec, progress, { pr: round.pr, reviewsBefore: reviewsHiddenFrom(round), blind: round.pr === undefined, trigger: 'backtest', force: true, ...reviewerInputs(review) });
     if (result.outcome === 'unavailable' || result.outcome === 'skipped')
         return { items, reviewerError: result.reason ?? result.outcome };
     // The reviewer behind each catch is part of the score, so the gate is `reviewer:<name>`.
@@ -237,3 +239,10 @@ function byGate(result) {
             counts.set(p.by.split(' ')[0], (counts.get(p.by.split(' ')[0]) ?? 0) + 1);
     return counts.size ? `; caught by ${[...counts].map(([gate, n]) => `${gate} ${n}`).join(', ')}` : '';
 }
+/** The moment the reviewer sees nothing from: the review itself for a round, and just after the approval for an approved head. */
+function reviewsHiddenFrom(round) {
+    if (!round.reviewed_at || !round.approved)
+        return round.reviewed_at;
+    const at = Date.parse(round.reviewed_at);
+    return Number.isNaN(at) ? round.reviewed_at : new Date(at + 1000).toISOString();
+}

package/dist/review/backtest.test.js

@@ -92,6 +92,18 @@ describe('rigour backtest on a repository', () => {
         catch { /* the repository may be gone */ }
         fs.rmSync(repo, { recursive: true, force: true });
     });
+    it('hides the review itself for a round, and shows the approval for an approved head', async () => {
+        const commit = git('rev-parse', 'HEAD');
+        const base = git('rev-parse', 'main');
+        const lines = [];
+        const ledger = { rounds: [
+                { id: 'r1', commit, base, reviewed_at: '2026-09-28T15:12:53Z', points: [], must_not_flag: [] },
+                { id: 'pr1-approved', commit, base, reviewed_at: '2026-09-28T15:12:53Z', approved: true, points: [], must_not_flag: [] },
+                { id: 'odd', commit, base, reviewed_at: 'not a date', approved: true, points: [], must_not_flag: [] },
+            ] };
+        await runBacktest(repo, ConfigSchema.parse({ version: 1 }), ledger, { progress: line => lines.push(line), collect: async () => ({ items: [] }) });
+        expect(lines.filter(l => l.includes('reviews hidden from')).map(l => l.replace(/^.*reviews hidden from /, ''))).toEqual(['2026-09-28T15:12:53Z', '2026-09-28T15:12:54.000Z', 'not a date']);
+    }, 60_000);
     it('reviews the reviewed commit in a worktree with the review hidden, scores it, and leaves the checkout alone', async () => {
         const reviewed = git('rev-parse', 'HEAD');
         const base = git('rev-parse', 'main');

package/dist/review/reviewer/api-judge.d.ts

@@ -12,6 +12,11 @@ export interface ApiJudgeOptions {
     roots: string[];
     reasoning?: Reasoning;
     fetchImpl?: typeof fetch;
+    /** The review's input files, given inline in the first message: a model that never calls a tool still has what it needs. */
+    inputs?: Array<{
+        path: string;
+        text: string;
+    }>;
 }
 export interface ApiJudgeRun {
     exitCode: number;

package/dist/review/reviewer/api-judge.js

@@ -11,6 +11,10 @@ import path from 'path';
 import { execa } from 'execa';
 const SYSTEM = 'You review code with read-only tools. Read the files the task names with read_file (the review inputs are named by absolute path), search the repository with search, read history with git. When you are done, reply with the final answer the task asks for and nothing else.';
 const MAX_RESULT_CHARS = 60_000;
+/** Output tokens a turn may use, reasoning included: a review verdict is long, and a reasoning model's thinking counts against the default budget. */
+const MAX_OUTPUT_TOKENS = 32_000;
+/** Characters of the inputs given inline in the first message; the rest stays in the files, for the tools. */
+const MAX_INLINE_CHARS = 240_000;
 const GIT_ALLOWED = new Set(['log', 'show', 'diff', 'blame', 'grep', 'ls-files', 'rev-parse', 'merge-base']);
 /** Git options that write, or point git at another repository. */
 const GIT_REFUSED = /^(--output|-o$|--git-dir|--work-tree|-C$|--exec-path|-c$|--config-env)/;
@@ -24,7 +28,7 @@ const n = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : 0);
 export async function runApiJudge(prompt, o) {
     const fetchImpl = o.fetchImpl ?? fetch;
     const deadline = Date.now() + o.timeoutMs;
-    const messages = [{ role: 'system', content: SYSTEM }, { role: 'user', content: prompt }];
+    const messages = [{ role: 'system', content: SYSTEM }, { role: 'user', content: withInputs(prompt, o.inputs ?? []) }];
     const usage = { input: 0, cacheRead: 0, cacheWrite: 0, output: 0 };
     const calls = [];
     let cost;
@@ -40,7 +44,7 @@ export async function runApiJudge(prompt, o) {
             response = await fetchImpl(`${o.url.replace(/\/$/, '')}/chat/completions`, {
                 method: 'POST',
                 headers: { 'content-type': 'application/json', authorization: `Bearer ${o.key}` },
-                body: JSON.stringify({ model: o.model, messages, tools: TOOLS, tool_choice: 'auto', ...(o.reasoning ? { reasoning_effort: o.reasoning } : {}) }),
+                body: JSON.stringify({ model: o.model, messages, tools: TOOLS, tool_choice: 'auto', max_tokens: MAX_OUTPUT_TOKENS, ...(o.reasoning ? { reasoning_effort: o.reasoning } : {}) }),
                 signal: controller.signal,
             });
         }
@@ -66,13 +70,22 @@ export async function runApiJudge(prompt, o) {
         usage.output += n(u.completion_tokens);
         if (typeof u.cost === 'number')
             cost = (cost ?? 0) + u.cost;
-        const message = body.choices?.[0]?.message;
+        const choice = body.choices?.[0];
+        // A gateway reports a provider's failure inside the choice, with the choice's finish_reason "error": say what it said.
+        if (choice?.error || body.error)
+            return fail(`the API reported an error: ${JSON.stringify(choice?.error ?? body.error).slice(0, 300)}`);
+        const message = choice?.message;
         if (!message)
             return fail('no choices in the answer');
-        messages.push(message);
+        // Echo back what the API needs to continue (reasoning_details carries a reasoning model's chain), not the reasoning prose.
+        messages.push({ role: 'assistant', content: message.content ?? null, ...(message.tool_calls ? { tool_calls: message.tool_calls } : {}), ...(message.reasoning_details ? { reasoning_details: message.reasoning_details } : {}) });
         const toolCalls = Array.isArray(message.tool_calls) ? message.tool_calls : [];
         if (toolCalls.length === 0) {
-            const answer = { result: String(message.content ?? ''), usage, ...(cost !== undefined ? { cost_usd: cost } : {}), trace: { turns: turn, usage, calls } };
+            const text = String(message.content ?? '').trim();
+            // An empty final message is not an answer: say why (the output budget ran out, a refusal), never report it as one.
+            if (!text)
+                return fail(`an empty answer on turn ${turn} (finish_reason ${String(body.choices?.[0]?.finish_reason ?? 'unknown')}${message.refusal ? `, refusal: ${String(message.refusal).slice(0, 120)}` : ''})`);
+            const answer = { result: text, usage, ...(cost !== undefined ? { cost_usd: cost } : {}), trace: { turns: turn, usage, calls } };
             return { exitCode: 0, stdout: JSON.stringify(answer), stderr: '' };
         }
         for (const call of toolCalls) {
@@ -83,6 +96,22 @@ export async function runApiJudge(prompt, o) {
     }
     return fail(`no answer within ${o.maxTurns} turns`);
 }
+/**
+ * The prompt with the inputs it names appended inline, smallest first so the diff takes what budget is left: a judge
+ * is fed, not left to decide whether to read. What does not fit is cut with a note naming the file to read.
+ */
+function withInputs(prompt, inputs) {
+    if (inputs.length === 0)
+        return prompt;
+    const ordered = [...inputs].sort((a, b) => a.text.length - b.text.length);
+    let left = MAX_INLINE_CHARS;
+    const parts = ordered.map(input => {
+        const text = input.text.length > left ? `${input.text.slice(0, Math.max(0, left))}\n…[cut here: read ${input.path} with read_file for the rest]` : input.text;
+        left = Math.max(0, left - input.text.length);
+        return `### ${input.path}\n${text}`;
+    });
+    return `${prompt}\n\nThe inputs named above, inline (the files are also there for your tools):\n\n${parts.join('\n\n')}`;
+}
 /** One tool call, inside the allowed roots only; the trace names tools as the CLI judges do (Read, Grep, Glob, Bash). */
 async function runTool(call, o) {
     const name = String(call?.function?.name ?? '');

package/dist/review/reviewer/api-judge.test.js

@@ -78,6 +78,27 @@ describe('the API judge', () => {
         const slow = (async (_u, init) => new Promise((_r, reject) => init.signal.addEventListener('abort', () => reject(new Error('aborted')))));
         expect(await runApiJudge('p', options(slow, { timeoutMs: 50 }))).toMatchObject({ exitCode: 1, stderr: expect.stringContaining('request failed') });
     });
+    it('fails closed on an empty final message, saying why, and echoes back only what the API needs to continue', async () => {
+        const empty = (async () => new Response(JSON.stringify({ choices: [{ message: { role: 'assistant', content: '', reasoning: 'thinking…' }, finish_reason: 'length' }], usage: {} }), { status: 200 }));
+        expect(await runApiJudge('p', options(empty))).toMatchObject({ exitCode: 1, stderr: expect.stringContaining('an empty answer on turn 1 (finish_reason length)') });
+        const providerError = (async () => new Response(JSON.stringify({ choices: [{ message: { role: 'assistant', content: '' }, finish_reason: 'error', error: { message: 'Provider returned error', code: 502 } }], usage: {} }), { status: 200 }));
+        expect(await runApiJudge('p', options(providerError))).toMatchObject({ exitCode: 1, stderr: expect.stringContaining('the API reported an error: {"message":"Provider returned error","code":502}') });
+        const { fetchImpl, seen } = model([{ tools: [{ name: 'list_dir', args: { path: '.' } }] }, { text: 'ok' }]);
+        await runApiJudge('p', options(fetchImpl));
+        const echoed = seen[1].messages.find((m) => m.role === 'assistant');
+        expect(Object.keys(echoed).sort()).toEqual(['content', 'role', 'tool_calls']); // no reasoning prose sent back
+        expect(seen[0].max_tokens).toBe(32000);
+    });
+    it('gives the judge its inputs inline, smallest first, the diff cut with a note when the budget runs out', async () => {
+        const { fetchImpl, seen } = model([{ text: 'ok' }]);
+        const inputs = [{ path: '/w/full.diff', text: 'x'.repeat(300_000) }, { path: '/w/pr-description.md', text: 'the description' }, { path: '/w/previous-reviews.md', text: 'the reviews' }];
+        await runApiJudge('review this', options(fetchImpl, { inputs }));
+        const first = seen[0].messages[1].content;
+        expect(first.startsWith('review this\n\nThe inputs named above, inline')).toBe(true);
+        expect(first.indexOf('### /w/previous-reviews.md')).toBeLessThan(first.indexOf('### /w/full.diff')); // smallest first
+        expect(first).toContain('…[cut here: read /w/full.diff with read_file for the rest]');
+        expect(first.length).toBeLessThan(241_000);
+    });
     it('passes the reasoning effort when asked', async () => {
         const { fetchImpl, seen } = model([{ text: 'ok' }]);
         await runApiJudge('p', options(fetchImpl, { reasoning: 'low' }));

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

@@ -1,4 +1,5 @@
 import { type Exec } from './exec.js';
+import type { Approval } from './verdict.js';
 export interface PullRequest {
     number: number;
     state: 'open' | 'closed' | 'merged';
@@ -12,6 +13,8 @@ export interface HumanReviews {
     /** Changes when a review or comment is added or edited: part of the verdict fingerprint. */
     key: string;
     count: number;
+    /** Each person's approval, in time order: every point that person raised before it is settled. */
+    approvals: Approval[];
     /** `<login>, <date> (<n> reviews)` of the latest, for the report. */
     label?: string;
 }

package/dist/review/reviewer/inputs.js

@@ -87,18 +87,24 @@ export async function humanReviews(gh, pr, reviewsBefore) {
         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 worded = (r) => !!String(r.body ?? '').trim();
+    // A review with words carries points. An approval without any carries none, and still settles every point its
+    // author raised before it: left out, the judge would see the points and never the approval that closed them.
+    const rounds = parseJsonArrays(reviews.stdout).filter((r) => human(r) && (worded(r) || r.state === 'APPROVED') && 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');
+    const approvals = rounds.filter((r) => r.state === 'APPROVED').map((r) => ({ login: String(r.user.login), at: String(r.submitted_at), commit: String(r.commit_id ?? '') }));
+    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${worded(r) ? String(r.body).trim() : `(approved without comment: every point ${r.user.login} raised before this is settled)`}\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);
+    const count = rounds.filter(worded).length;
     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'})` } : {}),
+            count,
+            approvals,
+            ...(latest ? { label: `${latest.user.login}, ${latest.submitted_at} (${count} review${count === 1 ? '' : 's'})` } : {}),
         },
     };
 }

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

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

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

@@ -0,0 +1,26 @@
+import { describe, expect, it } from 'vitest';
+import { humanReviews } from './inputs.js';
+const pr = { number: 7, state: 'open', draft: false, author: 'author', body: '' };
+const reviews = [
+    { id: 1, user: { login: 'senior', type: 'User' }, body: 'Keep a separate case for a visitor with no account.', state: 'CHANGES_REQUESTED', submitted_at: '2026-09-25T18:09:11Z', commit_id: 'a0a0a0a0a0aa' },
+    { id: 2, user: { login: 'senior', type: 'User' }, body: '', state: 'APPROVED', submitted_at: '2026-09-28T15:12:53Z', commit_id: 'b1b1b1b1b1bb' },
+    { id: 3, user: { login: 'author', type: 'User' }, body: '', state: 'APPROVED', submitted_at: '2026-09-28T16:00:00Z', commit_id: 'b1b1b1b1b1bb' },
+];
+const gh = async (args) => ({ exitCode: 0, stdout: JSON.stringify(args[1].endsWith('/reviews') ? reviews : []), stderr: '' });
+describe('the human reviews a judge reads', () => {
+    it('keeps an approval without words: it settles the points its author raised before it', async () => {
+        const { reviews: read } = await humanReviews(gh, pr, undefined);
+        expect(read.markdown).toContain('## Review by senior, 2026-09-25T18:09:11Z, CHANGES_REQUESTED (on a0a0a0a0a)');
+        expect(read.markdown).toContain('## Review by senior, 2026-09-28T15:12:53Z, APPROVED (on b1b1b1b1b)\n\n(approved without comment: every point senior raised before this is settled)');
+        expect(read.approvals).toEqual([{ login: 'senior', at: '2026-09-28T15:12:53Z', commit: 'b1b1b1b1b1bb' }]); // the author's own approval is not a review
+        expect(read.count).toBe(1); // reviews with points: the judge must answer those, and an approval has none
+        expect(read.label).toBe('senior, 2026-09-28T15:12:53Z (1 review)');
+    });
+    it('hides the approval like any review from the reviewed moment on', async () => {
+        const { reviews: read } = await humanReviews(gh, pr, '2026-09-28T15:12:53Z');
+        expect(read.approvals).toEqual([]);
+        expect(read.markdown).not.toContain('APPROVED');
+        const later = await humanReviews(gh, pr, '2026-09-28T15:12:54.000Z');
+        expect(later.reviews.approvals).toHaveLength(1);
+    });
+});

package/dist/review/reviewer/prompt.js

@@ -39,7 +39,13 @@ Do these steps in order. Report only what you verified in the code, with file:li
    description. Give each point the severity its reviewer gave it. For a point you say is NOT
    resolved, give file, line and quote: the code at this commit that shows it is still open, copied
    exactly. Rigour checks the quote; a point you cannot show still open that way is not open. Check the
-   code at THIS commit: a later commit may already have done what the point asked.
+   code at THIS commit: a later commit may already have done what the point asked. A reviewer's
+   APPROVED review settles every point that reviewer raised before it, with or without words: report
+   such a point resolved, citing the approval; the same class coming back in code written after the
+   approved commit is a finding of your own (step 11), with its own input and consequence. When a point
+   asks for something to exist (a test case, a guard, a call) and you say it is still missing, search
+   the WHOLE checkout for it, not only the file the point names: a reply or a later commit may have put
+   it elsewhere. Give absent: the exact code or test text you searched for. Rigour searches too.
 
 2. Redundancy. A fix often leaves behind what it made unnecessary. For every hunk in the reviewed
    range that moves a condition into a query (.not, .gte, .lte, .gt, .lt, .in, .like, .eq added),
@@ -152,7 +158,7 @@ and no material cost is an opinion: leave consequence empty and it is shown, nev
 report style preferences or trade-offs you would not request changes for.
 
 Your final message must be ONLY this JSON, starting with { and ending with }, nothing before or after it:
-{"prior_points":[{"point":"...","review":"<login> <submitted_at>","severity":"blocking"|"should-fix"|"non-blocking","resolved":true|false,"evidence":"file:line ...","file":"<when not resolved>","line":0,"quote":"<when not resolved: the code that shows it still open>","checked_siblings":["file:line"]}],
+{"prior_points":[{"point":"...","review":"<login> <submitted_at>","severity":"blocking"|"should-fix"|"non-blocking","resolved":true|false,"evidence":"file:line ...","file":"<when not resolved>","line":0,"quote":"<when not resolved: the code that shows it still open>","absent":"<when not resolved because something is missing: the exact text you searched the checkout for>","checked_siblings":["file:line"]}],
  "redundant":[{"file":"...","line":0,"what":"...","made_redundant_by":"file:line","removed":true|false}],
  "reads":[{"file":"...","line":0,"read":"...","rules":[{"rule":"...","known_before_read":true|false,"applied_before_read":true|false}],"consumer":{"file":"...","line":0,"uses":"ids-only"|"rows"|"aggregate"},"narrower_source":null|"...","keys":[{"name":"...","inputs":"...","stable_under_edit":true|false}],"window_bounded":true|false|null,"keyset":true|false|null,"index":"..."}],
  "scans":[{"file":"...","line":0,"function":"...","outer":"...","inner":"...","fix":"..."}],

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

@@ -11,7 +11,27 @@ export interface PriorPoint {
     file?: string;
     line?: number;
     quote?: string;
+    absent?: string;
+}
+/** A person's approval of the pull request: every point they raised before `at` is settled. */
+export interface Approval {
+    login: string;
+    at: string;
+    commit?: string;
 }
+/**
+ * What an item is checked against besides its quote: who approved (a prior point), whether the checkout has what a
+ * point calls missing, and which lines the change touched (a block must sit on one; unknown when absent).
+ */
+export interface PriorChecks {
+    approvals: Approval[];
+    inCheckout: (text: string) => string | undefined;
+    changed?: ChangedLines;
+}
+/** The lines a change touched, per file: every line added, and the place of every deletion, in the new file's numbering. */
+export type ChangedLines = Map<string, Set<number>>;
+/** The touched lines of a unified diff (`git diff base...head`). */
+export declare function changedLinesOf(diff: string): ChangedLines;
 interface Redundant {
     file: string;
     line?: number;
@@ -195,6 +215,11 @@ export type Verify = (file: string, line: number | undefined, quote?: string) =>
  * that is not where the judge says it is never blocks, whichever model made it.
  */
 export declare function checkoutVerifier(cwd: string): Verify;
+/**
+ * Searches the whole checkout for a line of text (the first non-empty line of `text`, whitespace aside): `file:line` of
+ * the first place it is, or undefined. A `git grep` so the tracked tree is searched and nothing else.
+ */
+export declare function checkoutSearch(cwd: string): (text: string) => string | undefined;
 /** The verdict in a reviewer's answer, or why it is not one. `needsPriorPoints`: a human review exists and none of its points is carried. */
 export declare function parseVerdict(text: string, needsPriorPoints: boolean, reviewer: string, spend: Spend): {
     verdict: Verdict;
@@ -229,7 +254,7 @@ export interface Accounting {
     advisory: OpenItem[];
 }
 /** Everything the reviewers reported blocks; in delta mode, previous open items carry unless resolved with evidence. */
-export declare function account(verdict: Verdict, previousOpen: OpenItem[] | undefined, verify: Verify): Accounting;
+export declare function account(verdict: Verdict, previousOpen: OpenItem[] | undefined, verify: Verify, prior?: PriorChecks): Accounting;
 export declare function itemLine(item: OpenItem): string;
 /** The rules Rigour served, onto the judge's answers by id: an answer naming no served rule is dropped. */
 export declare function attachServedRules(verdict: Verdict, served: ServedRule[]): void;

package/dist/review/reviewer/verdict.js

@@ -7,10 +7,55 @@
  * checked against the checkout before it can block: a file not in the repository, or a line past
  * its end, is a reviewer's slip, reported apart and never a block.
  */
+import { execFileSync } from 'child_process';
 import { createHash } from 'crypto';
 import fs from 'fs';
 import path from 'path';
 import { textSimilarity } from './consensus.js';
+const NO_PRIOR_CHECKS = { approvals: [], inCheckout: () => undefined };
+/** The touched lines of a unified diff (`git diff base...head`). */
+export function changedLinesOf(diff) {
+    const changed = new Map();
+    let file;
+    let line = 0;
+    for (const raw of diff.split('\n')) {
+        if (raw.startsWith('diff --git ') || /^--- (a\/|\/dev\/null)/.test(raw)) {
+            file = undefined; // headers, until the new file's name
+        }
+        else if (/^\+\+\+ (b\/|\/dev\/null)/.test(raw)) {
+            const name = raw.slice(4).replace(/^b\//, '').replace(/\t.*$/, '');
+            file = name === '/dev/null' ? undefined : (changed.get(name) ?? new Set());
+            if (file)
+                changed.set(name, file);
+        }
+        else if (raw.startsWith('@@ ')) {
+            line = Number(/\+(\d+)/.exec(raw)?.[1] ?? 0);
+        }
+        else if (raw.startsWith('+')) {
+            file?.add(line);
+            line++;
+        }
+        else if (raw.startsWith('-')) {
+            file?.add(line);
+        }
+        else if (raw.startsWith(' ') || raw === '') {
+            line++;
+        }
+    }
+    return changed;
+}
+/** Whether a line of a file is within CHANGED_WINDOW lines of one the change touched. */
+function nearChanged(changed, file, line) {
+    const lines = changed.get(file);
+    if (!lines)
+        return false;
+    for (let l = line - CHANGED_WINDOW; l <= line + CHANGED_WINDOW; l++)
+        if (lines.has(l))
+            return true;
+    return false;
+}
+/** How far from a touched line a block may sit: a judge names the statement, the diff names the line. */
+const CHANGED_WINDOW = 3;
 /**
  * A file in the checkout, and a line it has: an item naming anything else is a reviewer's slip. With a quote, the
  * quoted code must also be there, within QUOTE_WINDOW lines of the line named (whitespace aside): a claim about code
@@ -44,6 +89,34 @@ export function checkoutVerifier(cwd) {
 }
 /** How far from the line it names a finding's quote may sit: judges count lines loosely. */
 const QUOTE_WINDOW = 3;
+/** The approval, if any, the point's own reviewer gave after raising it (`review` reads `<login> <submitted_at>`). */
+function settledBy(point, approvals) {
+    const [login, ...rest] = (point.review ?? '').trim().split(/\s+/);
+    if (!login)
+        return undefined;
+    const at = rest.join(' ');
+    return approvals.find(a => a.login === login && (!at || a.at > at));
+}
+/**
+ * Searches the whole checkout for a line of text (the first non-empty line of `text`, whitespace aside): `file:line` of
+ * the first place it is, or undefined. A `git grep` so the tracked tree is searched and nothing else.
+ */
+export function checkoutSearch(cwd) {
+    return text => {
+        const line = text.split('\n').map(l => l.trim()).find(Boolean);
+        if (!line)
+            return undefined;
+        try {
+            const out = execFileSync('git', ['grep', '-n', '-I', '-F', '-e', line, '--', '.'], { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: 10_000 });
+            const hit = out.split('\n').find(Boolean);
+            const m = hit?.match(/^(.*?):(\d+):/);
+            return m ? `${m[1]}:${m[2]}` : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    };
+}
 /** How alike a finding and a point a human accepted as non-blocking must read to be that point again. */
 const ACCEPTED_SIMILARITY = 0.4;
 /** The reviewer's working steps: shown so a person can follow the reasoning, never a block on their own. */
@@ -135,7 +208,7 @@ export function evidenceTouched(evidence, touched) {
 }
 const id = (...parts) => createHash('sha1').update(parts.map(p => String(p ?? '')).join('|').toLowerCase().replace(/\s+/g, ' ')).digest('hex').slice(0, 10);
 /** Everything the reviewers reported blocks; in delta mode, previous open items carry unless resolved with evidence. */
-export function account(verdict, previousOpen, verify) {
+export function account(verdict, previousOpen, verify, prior = NO_PRIOR_CHECKS) {
     const open = [];
     const unverified = [];
     const notes = [];
@@ -159,17 +232,45 @@ export function account(verdict, previousOpen, verify) {
         if (WORKING_NOTES.has(item.kind))
             return void notes.push(item);
         const placed = !!item.file && !!item.quote?.trim() && verify(item.file, item.line, item.quote);
-        (placed ? open : unverified).push(item);
+        if (!placed)
+            return void unverified.push(item);
+        // A block is about this change. A finding or rule break in a touched file but on lines the change did not touch is
+        // what the code already had: shown as a note, never a block on this change. A human's point is about the change by
+        // definition. Without the diff (a judge's own items for a panel, a test) nothing is known and nothing is moved.
+        if (item.kind !== 'prior' && prior.changed && (item.line === undefined || !nearChanged(prior.changed, item.file, item.line))) {
+            return void notes.push({ ...item, evidence: `${item.evidence ? `${item.evidence}; ` : ''}${item.line === undefined ? 'names no line' : 'on a line this change did not touch'}: what the code already had, never a block on this change` });
+        }
+        open.push(item);
     };
     const answerInReply = [];
     for (const p of verdict.prior_points) {
         if (p.resolved)
             continue;
-        if (p.severity === 'non-blocking')
+        if (p.severity === 'non-blocking') {
             answerInReply.push(p);
+            continue;
+        }
+        const item = { id: id('prior', p.review, p.point), kind: 'prior', class: 'prior point', issue: p.point, evidence: p.evidence, reviewer: p.reviewer, ...(p.file ? { file: p.file } : {}), ...(p.line ? { line: p.line } : {}), ...(p.quote ? { quote: p.quote } : {}) };
+        // The person who raised it approved afterwards: settled, whatever the judge makes of the code now. The same class
+        // coming back in later code is a finding of the judge's own, with its own input and consequence.
+        const approval = settledBy(p, prior.approvals);
+        if (approval) {
+            if (!seen.has(item.id))
+                notes.push({ ...item, evidence: `${approval.login} approved on ${approval.at}, after raising it: settled` });
+            seen.add(item.id);
+            continue;
+        }
+        // A point that says something is still missing names what it searched for, and the checkout is searched for it: the
+        // reply or a later commit may have put it in another file than the one the point named.
+        const found = p.absent?.trim() ? prior.inCheckout(p.absent) : undefined;
+        if (found) {
+            if (!seen.has(item.id))
+                unverified.push({ ...item, evidence: `says "${p.absent.trim()}" is missing, and the checkout has it at ${found}` });
+            seen.add(item.id);
+            continue;
+        }
         // Still open only where the judge quotes the code that keeps it open: a point a later commit already fixed never blocks.
-        else
-            add({ id: id('prior', p.review, p.point), kind: 'prior', class: 'prior point', issue: p.point, evidence: p.evidence, reviewer: p.reviewer, ...(p.file ? { file: p.file } : {}), ...(p.line ? { line: p.line } : {}), ...(p.quote ? { quote: p.quote } : {}) });
+        add(item);
     }
     for (const r of verdict.redundant) {
         if (r.removed === false)

package/dist/review/reviewer.js

@@ -34,7 +34,7 @@ import { trackUsage } from '../telemetry/telemetry.js';
 import { reviewerUsage } from './reviewer/usage.js';
 import { buildContext, dismissedAs, readReviewDismissals, relatedDocs } from './reviewer/context.js';
 import { buildRecord } from './reviewer/record.js';
-import { account, attachServedRules, checkoutVerifier, carryResolved, evidenceTouched, mergeVerdicts, parseVerdict } from './reviewer/verdict.js';
+import { account, attachServedRules, changedLinesOf, checkoutSearch, checkoutVerifier, carryResolved, evidenceTouched, mergeVerdicts, parseVerdict } from './reviewer/verdict.js';
 import { judgeUnset } from './reviewer/judge-env.js';
 export { defaultExec, githubEnv, githubToken, parseJsonArrays } from './reviewer/exec.js';
 export { itemLine } from './reviewer/verdict.js';
@@ -107,7 +107,7 @@ async function review(cwd, base, config, exec, progress, options) {
         if (skip)
             return none('skipped', skip, { reviewers, pr: pr?.number });
     }
-    let reviews = { markdown: 'none\n', key: '', count: 0 };
+    let reviews = { markdown: 'none\n', key: '', count: 0, approvals: [] };
     if (gh && pr) {
         const read = await humanReviews(gh, pr, options.reviewsBefore);
         if (read.error)
@@ -187,6 +187,7 @@ async function review(cwd, base, config, exec, progress, options) {
     const openFile = store.openPath(verdictFile);
     const previousOpen = scope === 'delta' ? store.readJson(store.openPath(previous.verdict)) ?? [] : undefined;
     const verify = checkoutVerifier(cwd);
+    const prior = { approvals: reviews.approvals, inCheckout: checkoutSearch(cwd), changed: changedLinesOf(fullDiff) };
     const modelFor = (name) => settings.models[name] ?? (name === 'claude' ? settings.model : undefined);
     // The record of the review, written beside the verdict once and rebuilt from the same verdict on a cached read.
     const withRecord = (accounted, verdict, cached) => {
@@ -200,7 +201,7 @@ async function review(cwd, base, config, exec, progress, options) {
     };
     if (!options.force && fs.existsSync(verdictFile) && fs.existsSync(openFile)) {
         const verdict = store.readJson(verdictFile);
-        return withRecord(decide(verdict, previousOpen, verify, dismissals), verdict, true);
+        return withRecord(decide(verdict, previousOpen, verify, prior, dismissals), verdict, true);
     }
     // The daily caps, before any judge starts: a cached or reused verdict above cost nothing and never reaches here.
     const over = overBudget(store.spend(), settings, reviewers.length);
@@ -208,8 +209,9 @@ async function review(cwd, base, config, exec, progress, options) {
         return none(settings.required.panel || settings.required.mode ? 'unavailable' : 'skipped', over, { reviewers, scope, why, pr: pr?.number });
     const work = fs.mkdtempSync(path.join(os.tmpdir(), 'rigour-reviewer-'));
     // One judge run, by CLI or by API: the same prompt, the same cost accounting, the same trace.
+    let inlineInputs = [];
     const runJudge = (name, prompt, model) => name === 'api'
-        ? runApiJudge(prompt, { url: settings.api.url, model: settings.api.model, key: process.env[settings.api.key_env] ?? '', maxTurns: settings.api.max_turns, timeoutMs: settings.timeout_ms, cwd, roots: [cwd, work], ...(settings.reasoning[name] ? { reasoning: settings.reasoning[name] } : {}), ...(options.fetch ? { fetchImpl: options.fetch } : {}) })
+        ? runApiJudge(prompt, { url: settings.api.url, model: settings.api.model, key: process.env[settings.api.key_env] ?? '', maxTurns: settings.api.max_turns, timeoutMs: settings.timeout_ms, cwd, roots: [cwd, work], inputs: inlineInputs, ...(settings.reasoning[name] ? { reasoning: settings.reasoning[name] } : {}), ...(options.fetch ? { fetchImpl: options.fetch } : {}) })
         : exec(installed.get(name).binary, ADAPTERS[name].args(prompt, model, { reasoning: settings.reasoning[name] }), { cwd, timeoutMs: settings.timeout_ms, unset: judgeUnset(name, settings.judge_env) });
     try {
         const file = (name, text) => {
@@ -223,6 +225,7 @@ async function review(cwd, base, config, exec, progress, options) {
         const diffFile = file('full.diff', fullDiff);
         const contextFile = file('team-knowledge.md', context.text);
         const hintsFile = file('hints.txt', options.hints?.trim() || 'none\n');
+        inlineInputs = [[reviewsFile, reviews.markdown], [prBodyFile, body], [diffstatFile, await git(['diff', '--stat', `${baseSha}...HEAD`])], [diffFile, fullDiff], [contextFile, context.text], [hintsFile, options.hints?.trim() || 'none\n']].map(([p, text]) => ({ path: p, text }));
         let delta = '';
         // A reviewer must report on the human reviews, unless every point was settled by the previous verdict and is carried.
         let needsPriorPoints = reviews.count > 0;
@@ -258,13 +261,29 @@ async function review(cwd, base, config, exec, progress, options) {
                     return { run, answer, verdict: run.exitCode === 0 || answer.text.trim() ? parseVerdict(answer.text, needsPriorPoints, name, answer) : undefined };
                 };
                 let first = await ask();
-                // An answer that is not a verdict is a slip, not a decision: asked once more, inside the caps, before the review is unavailable.
-                if (first.verdict && 'error' in first.verdict && !overBudget(store.spend(), settings, 1)) {
-                    progress(`Rigour reviewer: ${name} gave no valid verdict; asking once more`);
+                // No verdict, whether a malformed answer or a run that died, is a slip, not a decision: asked once more, inside the caps.
+                if ((!first.verdict || 'error' in first.verdict) && !overBudget(store.spend(), settings, 1)) {
+                    progress(`Rigour reviewer: ${name} gave no ${first.verdict ? 'valid verdict' : 'answer'}; asking once more`);
                     first = await ask();
                 }
                 return first.verdict ?? { error: `${name}: no answer (exit ${first.run.exitCode}): ${first.run.stderr.trim().slice(-200)}` };
             }));
+            // A judge that gives nothing is replaced by the next one installed, so the boundary stays up: a review ends unavailable only when every judge failed.
+            const spare = candidates.filter(c => installed.has(c) && !reviewers.includes(c));
+            for (let i = 0; i < answers.length; i++) {
+                let answer = answers[i];
+                while ('error' in answer && spare.length && !overBudget(store.spend(), settings, 1)) {
+                    const next = spare.shift();
+                    progress(`Rigour reviewer: ${reviewers[i]} gave no verdict (${answer.error}); ${next} judges instead`);
+                    modeRecord = { ...modeRecord, degraded: `${modeRecord.degraded ? `${modeRecord.degraded}; ` : ''}${reviewers[i]} gave no verdict, ${next} judged instead` };
+                    reviewers[i] = next;
+                    const run = await runJudge(next, prompt, modelFor(next));
+                    const got = ADAPTERS[next].answer(run.stdout);
+                    store.addSpend(1, got.costUsd);
+                    answer = run.exitCode === 0 || got.text.trim() ? parseVerdict(got.text, needsPriorPoints, next, got) : { error: `${next}: no answer (exit ${run.exitCode}): ${run.stderr.trim().slice(-200)}` };
+                }
+                answers[i] = answer;
+            }
             const failed = answers.find(a => 'error' in a);
             if (failed && 'error' in failed)
                 return none('unavailable', failed.error, { reviewers, scope, why, pr: pr?.number });
@@ -316,7 +335,7 @@ async function review(cwd, base, config, exec, progress, options) {
             });
             verdict = { ...verdict, panel: { judgeItemIds: judgeItems.flat().map(item => item.id), items }, reviewers: [...(verdict.reviewers ?? []), ...cross] };
         }
-        const accounted = decide(verdict, previousOpen, verify, dismissals);
+        const accounted = decide(verdict, previousOpen, verify, prior, dismissals);
         store.writeJson(verdictFile, { ...verdict, inputs: { head, base: baseSha, scope, why, mode: modeRecord, reviewers, versions: reviewerVersions, authors: [...authors], fingerprint, human_reviews: reviews.count, reviews_before: options.reviewsBefore ?? null, since: previous?.head ?? null, at: new Date().toISOString() } });
         store.writeJson(openFile, accounted.open);
         store.writeJson(store.decidedPath(verdictFile), accounted);
@@ -329,8 +348,8 @@ async function review(cwd, base, config, exec, progress, options) {
     }
 }
 /** The accounting a verdict leads to: with a panel, only what it confirmed blocks; a finding the team dismissed never blocks. */
-function decide(verdict, previousOpen, verify, dismissals) {
-    const accounted = account(verdict, previousOpen, verify);
+function decide(verdict, previousOpen, verify, prior, dismissals) {
+    const accounted = account(verdict, previousOpen, verify, prior);
     // An item an earlier round confirmed stays open until it is resolved with evidence, whatever this panel says of it.
     const earlier = new Set((previousOpen ?? []).map(item => item.id));
     const decided = verdict.panel

package/dist/review/reviewer.test.js

@@ -8,7 +8,7 @@ import { reviewerBlocks, runReviewer } from './reviewer.js';
 import { dismissReviewerFinding } from './reviewer/context.js';
 import { reviewStatus } from './reviewer/background.js';
 import { selectReviewers, vendorsOf } from './reviewer/adapters.js';
-import { account, attachServedRules, carryResolved, checkoutVerifier, mergeVerdicts, parseVerdict } from './reviewer/verdict.js';
+import { account, attachServedRules, carryResolved, changedLinesOf, checkoutSearch, checkoutVerifier, mergeVerdicts, parseVerdict } from './reviewer/verdict.js';
 import { recordIntact } from './reviewer/record.js';
 let repo;
 const config = ConfigSchema.parse({ version: 1, review: { github_account: 'reviewer-account', reviewer: { enabled: true, reviewers: ['claude', 'cursor'] } } });
@@ -170,7 +170,7 @@ describe('the reviewer', () => {
         expect(hidden.outcome).toBe('passed');
         const shown = await runReviewer(repo, 'main', config, fakes(() => JSON.stringify({ ...EMPTY, prior_points: [] }), seen), () => undefined, { pr: 42, reviewsBefore: '2026-10-04', force: true });
         expect(seen.files['previous-reviews.md']).toContain('Review by senior');
-        expect(shown).toMatchObject({ outcome: 'unavailable', reason: 'claude did not report on the human reviews' });
+        expect(shown).toMatchObject({ outcome: 'unavailable', reason: expect.stringContaining('did not report on the human reviews') });
     });
     it('for a backtest, gives the description as it read at the review, never a later edit', async () => {
         const versions = { lastEditedAt: '2026-10-06T00:00:00Z', body: 'today: refunds are issued by the nightly job', userContentEdits: { totalCount: 3, nodes: [
@@ -200,7 +200,7 @@ describe('the reviewer', () => {
     });
     it('never passes without a verdict: a crash, a malformed answer, an unreadable pull request or no installed reviewer', async () => {
         const crashed = await runReviewer(repo, 'main', config, fakes(() => ({ exitCode: 1, stdout: '', stderr: 'API error' }), seenNow()), () => undefined);
-        expect(crashed).toMatchObject({ outcome: 'unavailable', reason: expect.stringContaining('claude: no answer (exit 1)') });
+        expect(crashed).toMatchObject({ outcome: 'unavailable', reason: expect.stringContaining('cursor: no answer (exit 1)'), mode: { degraded: expect.stringContaining('claude gave no verdict, cursor judged instead') } }); // asked twice, then the spare judge, which failed too
         const prose = await runReviewer(repo, 'main', config, fakes(() => 'Looks good to me!', seenNow()), () => undefined);
         expect(prose).toMatchObject({ outcome: 'unavailable', reason: expect.stringContaining('no valid verdict') });
         const broken = async (command, args, options) => command === 'gh' && args[0] === 'pr' ? { exitCode: 1, stdout: '', stderr: 'HTTP 500' } : fakes(() => '', seenNow())(command, args, options);
@@ -283,16 +283,34 @@ describe('the reviewer', () => {
             delete process.env.TEST_JUDGE_KEY;
         }
     });
+    it('replaces a judge that gives nothing with the next one installed, and says so', async () => {
+        const seen = seenNow();
+        const silent = (async () => new Response(JSON.stringify({ choices: [{ message: { role: 'assistant', content: '' }, finish_reason: 'stop' }], usage: { prompt_tokens: 5, completion_tokens: 0 } }), { status: 200 }));
+        const twoJudges = ConfigSchema.parse({ version: 1, review: { reviewer: { enabled: true, reviewers: ['api', 'claude'], api: { url: 'https://example.test/v1', model: 'silent-model', key_env: 'TEST_JUDGE_KEY' } } } });
+        process.env.TEST_JUDGE_KEY = 'secret';
+        try {
+            const result = await runReviewer(repo, 'main', twoJudges, fakes(() => JSON.stringify(EMPTY), seen), () => undefined, { fetch: silent, force: true });
+            expect(result).toMatchObject({ outcome: 'passed', reviewers: ['claude'], mode: { degraded: expect.stringContaining('api gave no verdict, claude judged instead') } });
+            expect(seen.prompts).toHaveLength(1); // claude ran once, after the api judge's two empty answers
+        }
+        finally {
+            delete process.env.TEST_JUDGE_KEY;
+        }
+    });
     it('asks a judge once more after an answer that is not a verdict, and is unavailable only when the second is not one either', async () => {
         const seen = seenNow();
         let calls = 0;
         const slipOnce = await runReviewer(repo, 'main', config, fakes(() => (++calls === 1 ? '{"prior_points":[], "findings":[{"class"' : JSON.stringify(EMPTY)), seen), () => undefined, { force: true });
         expect(slipOnce.outcome).toBe('passed');
         expect(seen.prompts).toHaveLength(2);
+        let crashes = 0;
+        const crashOnce = seenNow();
+        const recovered = await runReviewer(repo, 'main', config, fakes(() => (++crashes === 1 ? { exitCode: 1, stdout: '', stderr: 'API error' } : JSON.stringify(EMPTY)), crashOnce), () => undefined, { force: true });
+        expect(recovered.outcome).toBe('passed'); // a run that died is asked once more too
         const twice = seenNow();
         const slipTwice = await runReviewer(repo, 'main', config, fakes(() => 'not json', twice), () => undefined, { force: true });
         expect(slipTwice).toMatchObject({ outcome: 'unavailable', reason: expect.stringContaining('no valid verdict') });
-        expect(twice.prompts).toHaveLength(2); // once more, never a loop
+        expect(twice.prompts).toHaveLength(3); // once more, then the spare judge once: never a loop
     });
     it('says what was asked and that nothing ran when a review ends early, with why a judge is missing', async () => {
         const seen = { ...seenNow(), installed: ['claude'] }; // cursor is listed but not installed
@@ -308,7 +326,8 @@ describe('the reviewer', () => {
         const by = (name) => JSON.stringify({ ...EMPTY, prior_points: [{ point: 'lock before read', severity: 'blocking', resolved: name === 'claude', evidence: 'src/job.ts:2', file: 'src/job.ts', line: 2, quote: 'export function job() {' }], findings: name === 'cursor' ? [{ class: 'dead-code', file: 'a.ts', line: 1, issue: 'a is unused', consequence: 'a second run reads stale rows', quote: 'export const a = 1;' }] : [] });
         const result = await runReviewer(repo, 'main', config, fakes(by, seen), () => undefined, { full: true });
         expect(result.reviewers).toEqual(['claude', 'cursor']);
-        expect(result.items.map(i => [i.kind, i.reviewer])).toEqual([['prior', 'cursor'], ['finding', 'cursor']]);
+        expect(result.items.map(i => [i.kind, i.reviewer])).toEqual([['prior', 'cursor']]);
+        expect(result.notes.map(i => [i.kind, i.file, i.reviewer])).toEqual([['finding', 'a.ts', 'cursor']]); // a.ts is not in the change: what the code already had
         expect(seen.prompts).toHaveLength(2);
     });
 });
@@ -607,3 +626,80 @@ describe('what the team already knows', () => {
         expect(result.notes).toEqual([]);
     });
 });
+describe("a human's prior point", () => {
+    const point = (over) => ({ point: 'keep a separate case for a visitor with no account', review: 'senior 2026-09-25T18:09:11Z', severity: 'blocking', resolved: false, evidence: 'tests/e2e/gate.ts:137', file: 'tests/e2e/gate.ts', line: 137, quote: 'expect(href).toMatch(/account_id=/)', ...over });
+    const verdict = (p) => ({ ...EMPTY, prior_points: [p] });
+    const approvals = [{ login: 'senior', at: '2026-09-28T15:12:53Z' }];
+    it('blocks where the judge quotes the code that keeps it open and no one approved since', () => {
+        const { open } = account(verdict(point({})), undefined, () => true, { approvals: [], inCheckout: () => undefined });
+        expect(open.map(i => i.issue)).toEqual(['keep a separate case for a visitor with no account']);
+    });
+    it('is settled by its own reviewer approving after raising it: a note, never a block', () => {
+        const { open, notes } = account(verdict(point({})), undefined, () => true, { approvals, inCheckout: () => undefined });
+        expect(open).toEqual([]);
+        expect(notes).toMatchObject([{ kind: 'prior', issue: 'keep a separate case for a visitor with no account', evidence: 'senior approved on 2026-09-28T15:12:53Z, after raising it: settled' }]);
+    });
+    it('is not settled by an approval before it, by another person, or when the judge names no reviewer', () => {
+        const before = account(verdict(point({})), undefined, () => true, { approvals: [{ login: 'senior', at: '2026-09-20T00:00:00Z' }], inCheckout: () => undefined });
+        const other = account(verdict(point({})), undefined, () => true, { approvals: [{ login: 'peer', at: '2026-09-28T15:12:53Z' }], inCheckout: () => undefined });
+        const unnamed = account(verdict(point({ review: undefined })), undefined, () => true, { approvals, inCheckout: () => undefined });
+        for (const result of [before, other, unnamed])
+            expect(result.open).toHaveLength(1);
+        const undated = account(verdict(point({ review: 'senior' })), undefined, () => true, { approvals, inCheckout: () => undefined });
+        expect(undated.open).toEqual([]); // the reviewer named and approved: settled
+    });
+    it('that calls something missing is unverified when the checkout has it elsewhere', () => {
+        const searched = [];
+        const found = account(verdict(point({ absent: 'origin=native&returnTo=' })), undefined, () => true, { approvals: [], inCheckout: text => (searched.push(text), 'src/lib/Upsell.test.ts:128') });
+        expect(searched).toEqual(['origin=native&returnTo=']);
+        expect(found.open).toEqual([]);
+        expect(found.unverified).toMatchObject([{ kind: 'prior', evidence: 'says "origin=native&returnTo=" is missing, and the checkout has it at src/lib/Upsell.test.ts:128' }]);
+        const missing = account(verdict(point({ absent: 'origin=native&returnTo=' })), undefined, () => true, { approvals: [], inCheckout: () => undefined });
+        expect(missing.open).toHaveLength(1); // searched, not there: the point stands on its quote
+    });
+});
+describe('searching the checkout for what a point calls missing', () => {
+    it('finds the first line of the text anywhere in the tracked tree, and nothing untracked', () => {
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'rigour-search-'));
+        execFileSync('git', ['-C', dir, 'init', '-q']);
+        fs.mkdirSync(path.join(dir, 'src'));
+        fs.writeFileSync(path.join(dir, 'src', 'a.test.ts'), 'it("no account", () => {\n  expect(href).toBe("/checkout?origin=native");\n});\n');
+        fs.writeFileSync(path.join(dir, 'untracked.ts'), 'const ghost = 1;\n');
+        execFileSync('git', ['-C', dir, 'add', 'src']);
+        const search = checkoutSearch(dir);
+        expect(search('  expect(href).toBe("/checkout?origin=native");\n  more')).toBe('src/a.test.ts:2');
+        expect(search('const ghost = 1;')).toBeUndefined();
+        expect(search('   \n')).toBeUndefined();
+    });
+});
+describe('a block sits on a line the change touched', () => {
+    const diff = [
+        'diff --git a/src/player.ts b/src/player.ts', '--- a/src/player.ts', '+++ b/src/player.ts',
+        '@@ -10,4 +10,5 @@ function resume() {', '   const a = 1;', '-  old();', '+  report(a);', '+  report(b);', '   return a;', '   }',
+        'diff --git a/src/gone.ts b/src/gone.ts', '--- a/src/gone.ts', '+++ /dev/null', '@@ -1,2 +0,0 @@', '-export const x = 1;', '-export const y = 2;',
+        'diff --git a/src/new.ts b/src/new.ts', '--- /dev/null', '+++ b/src/new.ts', '@@ -0,0 +1,2 @@', '+export const z = 1;', '+export const w = 2;', '',
+    ].join('\n');
+    const changed = changedLinesOf(diff);
+    const rule = (file, line) => ({ ...EMPTY, prior_points: [], rules: [{ id: 'r1', status: 'broken', rule: 'wrap every navigation target in resolve()', source: 'AGENTS.md', requirement: true, file, line, quote: 'preloadCode(target)' }] });
+    const checks = { approvals: [], inCheckout: () => undefined, changed };
+    it('reads the touched lines of a diff: added lines, the place of a deletion, nothing for a deleted file', () => {
+        expect([...changed.get('src/player.ts')].sort((a, b) => a - b)).toEqual([11, 12]); // the deletion's place, then the two added lines (11 is both)
+        expect([...changed.get('src/new.ts')]).toEqual([1, 2]);
+        expect(changed.has('src/gone.ts')).toBe(false);
+    });
+    it('blocks a verified rule break near a touched line, and notes one on lines the change did not touch, or with no line', () => {
+        expect(account(rule('src/player.ts', 14), undefined, () => true, checks).open).toHaveLength(1); // within the window of line 12
+        const far = account(rule('src/player.ts', 1819), undefined, () => true, checks);
+        expect(far.open).toEqual([]);
+        expect(far.notes).toMatchObject([{ kind: 'rule', line: 1819, evidence: expect.stringContaining('on a line this change did not touch: what the code already had, never a block on this change') }]);
+        const unplaced = account(rule('src/player.ts', undefined), undefined, () => true, checks);
+        expect(unplaced.open).toEqual([]);
+        expect(unplaced.notes[0].evidence).toContain('names no line');
+        expect(account(rule('src/other.ts', 3), undefined, () => true, checks).open).toEqual([]); // a file the change did not touch at all
+    });
+    it("leaves a human's point, and every item when the diff is unknown, as before", () => {
+        const point = { ...EMPTY, prior_points: [{ point: 'wrap the target', review: 'senior 2026-10-01', severity: 'blocking', resolved: false, file: 'src/player.ts', line: 1819, quote: 'preloadCode(target)' }] };
+        expect(account(point, undefined, () => true, checks).open).toHaveLength(1);
+        expect(account(rule('src/player.ts', 1819), undefined, () => true, { approvals: [], inCheckout: () => undefined }).open).toHaveLength(1);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rigour-labs/core",
-  "version": "6.7.8",
+  "version": "6.7.10",
   "description": "Rigour's review engine: deterministic gates on changed lines, rules and lessons learned from your team's fixes, and per-check precision from what you fix versus dismiss, across TypeScript, JavaScript, Python, Go, Ruby and C#.",
   "engines": {
     "node": ">=22.13"
@@ -72,11 +72,11 @@
     "@anthropic-ai/sdk": "^0.30.1",
     "pg": "^8.16.3",
     "openai": "^5.23.2",
-    "@rigour-labs/brain-darwin-arm64": "6.7.8",
-    "@rigour-labs/brain-darwin-x64": "6.7.8",
-    "@rigour-labs/brain-linux-x64": "6.7.8",
-    "@rigour-labs/brain-linux-arm64": "6.7.8",
-    "@rigour-labs/brain-win-x64": "6.7.8"
+    "@rigour-labs/brain-darwin-arm64": "6.7.10",
+    "@rigour-labs/brain-darwin-x64": "6.7.10",
+    "@rigour-labs/brain-linux-x64": "6.7.10",
+    "@rigour-labs/brain-win-x64": "6.7.10",
+    "@rigour-labs/brain-linux-arm64": "6.7.10"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",