@rigour-labs/core 6.7.9 → 6.8.0

package/dist/review/reviewer/adapters.js

@@ -11,6 +11,8 @@ import os from 'os';
 import path from 'path';
 import { defaultExec } from './exec.js';
 const n = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : 0);
+/** The Claude Code version the memory switches were verified in: below it, a judge may still load a person's CLAUDE.md. */
+const CLAUDE_MEMORY_ISOLATION = '2.1.285';
 const READ_ONLY_TOOLS = ['Read', 'Grep', 'Glob', 'Bash(git diff:*)', 'Bash(git show:*)', 'Bash(git log:*)', 'Bash(git grep:*)'];
 export const ADAPTERS = {
     claude: {
@@ -28,12 +30,26 @@ export const ADAPTERS = {
             '--allowedTools', ...READ_ONLY_TOOLS,
             '--disallowedTools', 'Edit', 'Write', 'NotebookEdit', 'Bash(git push:*)', 'Bash(git commit:*)',
         ],
+        // No memory file loads itself: not ~/.claude/CLAUDE.md, not one in a folder above the repository, not the repository's
+        // own (the judge reads the repository's rules as files, as Rigour's prompt tells every judge to), and no auto-memory.
+        // Claude Code's own safe mode uses the same switch. What the judge knows is the repository and what Rigour gives it.
+        env: { CLAUDE_CODE_DISABLE_CLAUDE_MDS: '1', CLAUDE_CODE_DISABLE_AUTO_MEMORY: '1' },
+        // An older Claude Code ignores those switches without a word and loads the memory files anyway: below the version
+        // they were verified in, or when the version cannot be read, the record says the isolation is unverified.
+        outsideRepo: (_home, version) => {
+            const found = /(\d+)\.(\d+)\.(\d+)/.exec(version ?? '');
+            const at = found ? found.slice(1).map(Number) : undefined;
+            const floor = CLAUDE_MEMORY_ISOLATION.split('.').map(Number);
+            const below = !at || at[0] !== floor[0] ? !at || at[0] < floor[0] : at[1] !== floor[1] ? at[1] < floor[1] : at[2] < floor[2];
+            return below ? `claude ${found?.[0] ?? '(version unknown)'}: memory isolation unverified (needs ${CLAUDE_MEMORY_ISOLATION} or later)` : undefined;
+        },
         answer: stdout => claudeAnswer(stdout),
     },
     cursor: {
         vendor: 'cursor',
         binary: 'cursor-agent',
         // Ask mode is read-only and cannot run git: every input the prompt names is a file.
+        outsideRepo: () => 'cursor also reads your own Cursor rules and settings',
         args: (prompt, model) => ['-p', '--print', '--output-format', 'json', '--trust', '--mode', 'ask', '--model', model ?? 'auto', prompt],
         answer: stdout => {
             try {
@@ -48,6 +64,13 @@ export const ADAPTERS = {
     codex: {
         vendor: 'openai',
         binary: 'codex',
+        // Codex has no switch that skips a person's ~/.codex/config.toml and ~/.codex/AGENTS.md and keeps their login, so the
+        // record says when those exist rather than claiming a judge that only knows the repository.
+        outsideRepo: home => {
+            const dir = process.env.CODEX_HOME?.trim() || path.join(home, '.codex');
+            const read = ['config.toml', 'AGENTS.md'].filter(name => fs.existsSync(path.join(dir, name)));
+            return read.length ? `codex also reads ${read.map(name => path.join(dir, name)).join(' and ')}` : undefined;
+        },
         args: (prompt, model, options) => ['exec', '--sandbox', 'read-only', '--json', ...(model ? ['--model', model] : []), '-c', `model_reasoning_effort=${options?.reasoning ?? 'high'}`, prompt],
         // `codex exec --json` streams events; the last text-bearing one carries the answer.
         // Warnings arrive as `error` items with a `message`, not `text`, so they are never taken for the answer.

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

@@ -1,3 +1,6 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
 import { describe, expect, it } from 'vitest';
 import { ADAPTERS, apiVendor, selectReviewers } from './adapters.js';
 /** A real `codex exec --json` run (codex-cli 0.160.1), the warning's path shortened: the shape the adapter must read. */
@@ -58,3 +61,40 @@ describe('a judge reached through an API', () => {
         expect(ADAPTERS.codex.args('p', undefined)).toContain('model_reasoning_effort=high');
     });
 });
+describe('what a judge knows besides the repository', () => {
+    it('launches claude with no memory file, auto-memory, user settings, hooks or MCP servers of its own', () => {
+        expect(ADAPTERS.claude.env).toEqual({ CLAUDE_CODE_DISABLE_CLAUDE_MDS: '1', CLAUDE_CODE_DISABLE_AUTO_MEMORY: '1' });
+        const args = ADAPTERS.claude.args('p', undefined);
+        expect(args.slice(args.indexOf('--setting-sources'), args.indexOf('--setting-sources') + 2)).toEqual(['--setting-sources', 'project']);
+        expect(args).toEqual(expect.arrayContaining(['--strict-mcp-config', '--mcp-config', '{"mcpServers":{}}']));
+        expect(JSON.parse(args[args.indexOf('--settings') + 1])).toMatchObject({ hooks: {} });
+        for (const v of ['2.1.285 (Claude Code)', '2.1.300', '2.2.0', '3.0.0'])
+            expect(ADAPTERS.claude.outsideRepo('/home/x', v)).toBeUndefined();
+        expect(ADAPTERS.claude.outsideRepo('/home/x', '2.1.284 (Claude Code)')).toBe('claude 2.1.284: memory isolation unverified (needs 2.1.285 or later)');
+        expect(ADAPTERS.claude.outsideRepo('/home/x', '2.0.999')).toContain('unverified');
+        expect(ADAPTERS.claude.outsideRepo('/home/x', '1.9.400')).toContain('unverified');
+        expect(ADAPTERS.claude.outsideRepo('/home/x', undefined)).toBe('claude (version unknown): memory isolation unverified (needs 2.1.285 or later)');
+    });
+    it("says when codex will also read a person's own Codex config or instructions, and from where", () => {
+        const home = fs.mkdtempSync(path.join(os.tmpdir(), 'judge-home-'));
+        const saved = process.env.CODEX_HOME;
+        delete process.env.CODEX_HOME;
+        try {
+            expect(ADAPTERS.codex.outsideRepo(home, undefined)).toBeUndefined();
+            fs.mkdirSync(path.join(home, '.codex'));
+            fs.writeFileSync(path.join(home, '.codex', 'AGENTS.md'), 'Always answer in French.\n');
+            fs.writeFileSync(path.join(home, '.codex', 'config.toml'), 'personality = "pragmatic"\n');
+            expect(ADAPTERS.codex.outsideRepo(home, undefined)).toBe(`codex also reads ${path.join(home, '.codex', 'config.toml')} and ${path.join(home, '.codex', 'AGENTS.md')}`);
+            process.env.CODEX_HOME = path.join(home, 'elsewhere');
+            expect(ADAPTERS.codex.outsideRepo(home, undefined)).toBeUndefined(); // CODEX_HOME wins over the home folder
+            expect(ADAPTERS.cursor.outsideRepo(home, undefined)).toBe('cursor also reads your own Cursor rules and settings');
+        }
+        finally {
+            if (saved === undefined)
+                delete process.env.CODEX_HOME;
+            else
+                process.env.CODEX_HOME = saved;
+            fs.rmSync(home, { recursive: true, force: true });
+        }
+    });
+});

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

@@ -1,10 +1,12 @@
 import { type Exec } from './exec.js';
+import type { Approval, LabelledPoint } from './verdict.js';
 export interface PullRequest {
     number: number;
     state: 'open' | 'closed' | 'merged';
     draft: boolean;
     author: string;
     body: string;
+    title?: string;
 }
 export interface HumanReviews {
     /** As the reviewer reads them, oldest first, inline comments after; `none` when there are none. */
@@ -12,6 +14,10 @@ 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[];
+    /** The points each review put under a severity heading of its own ("Blocking", "Should fix", "Nits"). */
+    labels: LabelledPoint[];
     /** `<login>, <date> (<n> reviews)` of the latest, for the report. */
     label?: string;
 }

package/dist/review/reviewer/inputs.js

@@ -13,7 +13,7 @@ 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';
+const PR_FIELDS = 'number,state,isDraft,author,body,title';
 /**
  * The description as it read at `at` (a backtest's review time): GitHub keeps every version in
  * `userContentEdits`, the first being the text at creation. Undefined when it cannot be read, so a
@@ -67,7 +67,7 @@ async function viewPullRequest(gh, selector) {
         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 ?? '') } };
+        return { pr: { number: parsed.number, state: String(parsed.state ?? '').toLowerCase(), draft: !!parsed.isDraft, author: String(parsed.author?.login ?? ''), body: String(parsed.body ?? ''), ...(parsed.title ? { title: String(parsed.title) } : {}) } };
     }
     catch {
         return { error: `gh returned something other than a pull request for ${selector}: ${result.stdout.slice(0, 120)}` };
@@ -87,21 +87,61 @@ 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,
+            labels: rounds.filter(worded).flatMap((r) => severityLabels(String(r.body), String(r.user.login), String(r.submitted_at))),
+            ...(latest ? { label: `${latest.user.login}, ${latest.submitted_at} (${count} review${count === 1 ? '' : 's'})` } : {}),
         },
     };
 }
+/** The severity a heading names: "Blocking", "Should fix", "Nits" and their usual spellings, alone on the line. */
+function headingSeverity(line) {
+    const bare = line.replace(/[#*_:`>]/g, ' ').replace(/\(\d+\)/g, ' ').replace(/\s+/g, ' ').trim().toLowerCase();
+    if (!bare || bare.split(' ').length > 3)
+        return undefined;
+    if (/^(blocking|blockers?|must fix|must-fix)$/.test(bare))
+        return 'blocking';
+    if (/^(should fix|should-fix|should)$/.test(bare))
+        return 'should-fix';
+    if (/^(nits?|non blocking|non-blocking|minor|optional)$/.test(bare))
+        return 'non-blocking';
+    return undefined;
+}
+/** Each bullet or numbered line under a severity heading of the review, with that heading's severity. */
+function severityLabels(body, login, at) {
+    const out = [];
+    let severity;
+    for (const line of body.split('\n')) {
+        const heading = headingSeverity(line);
+        if (heading) {
+            severity = heading;
+            continue;
+        }
+        if (/^\s{0,3}#{1,6}\s/.test(line))
+            severity = undefined; // another heading ends the section
+        // A bullet, a numbered line, or a numbered line set in bold or underline ("**1. The column is NOT NULL.**"), which is
+        // how many reviewers title a point before its evidence.
+        const item = /^\s*(?:\*\*|__)?\s*(?:[-*+]|\d+[.)])\s+(.+?)\s*(?:\*\*|__)?\s*$/.exec(line);
+        if (severity && item)
+            out.push({ login, at, severity, text: item[1].replace(/\*\*|__/g, '').trim() });
+    }
+    return out;
+}
 /** The repository's rules as the reviewer must read them. */
 export function rulesText(cwd) {
     return ['AGENTS.md', 'CLAUDE.md'].map(name => {

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

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

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

@@ -0,0 +1,52 @@
+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);
+    });
+    it('reads the bullets and numbered lines under Blocking / Should fix / Nits headings as that reviewer labelled them, and nothing under another heading', async () => {
+        const body = ['Thanks, a few things.', '', '## Blocking', '- The kill switch is read after every query: check it first.', '',
+            '**Should fix**', '1. The comment on the window still says daily.', '', 'Nits:', '* Rename tmp to rows.', '', '## Context', '- not a label'].join('\n');
+        const labelled = async (args) => ({ exitCode: 0, stdout: JSON.stringify(args[1].endsWith('/reviews') ? [{ ...reviews[0], body }] : []), stderr: '' });
+        const { reviews: read } = await humanReviews(labelled, pr, undefined);
+        expect(read.labels.map(l => [l.login, l.severity, l.text])).toEqual([
+            ['senior', 'blocking', 'The kill switch is read after every query: check it first.'],
+            ['senior', 'should-fix', 'The comment on the window still says daily.'],
+            ['senior', 'non-blocking', 'Rename tmp to rows.'],
+        ]);
+        expect(read.labels.every(l => l.at === '2026-09-25T18:09:11Z')).toBe(true);
+    });
+    it('reads a numbered point set in bold, with its evidence sub-bullets, under each heading', async () => {
+        const body = ['## Blocking', '', '**1. The status column is typed nullable but the table declares it NOT NULL.**', '- the reader falls back to an empty string', '- two callers check for null again', '',
+            '**2. The retry posts the event twice when the first post times out.**', '', '## Should fix', '', '__1. The window comment says hourly; the job runs daily.__', '', '## Nits', '', '- Rename tmp to rows.'].join('\n');
+        const shaped = async (args) => ({ exitCode: 0, stdout: JSON.stringify(args[1].endsWith('/reviews') ? [{ ...reviews[0], body }] : []), stderr: '' });
+        const { reviews: read } = await humanReviews(shaped, pr, undefined);
+        expect(read.labels.map(l => [l.severity, l.text])).toEqual([
+            ['blocking', 'The status column is typed nullable but the table declares it NOT NULL.'],
+            ['blocking', 'the reader falls back to an empty string'],
+            ['blocking', 'two callers check for null again'],
+            ['blocking', 'The retry posts the event twice when the first post times out.'],
+            ['should-fix', 'The window comment says hourly; the job runs daily.'],
+            ['non-blocking', 'Rename tmp to rows.'],
+        ]);
+    });
+});

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/record.d.ts

@@ -5,12 +5,14 @@ export interface ReviewRecord {
     base: string;
     scope: 'full' | 'delta';
     at: string;
+    /** `outside_repo`: what the judge also read from the machine's own config (a person's instructions); absent when it read only the repository and Rigour's inputs. */
     judges: Array<{
         reviewer: string;
         version?: string;
         model?: string;
         cost_usd?: number;
         turns?: number;
+        outside_repo?: string;
     }>;
     /** Checked by Rigour against the checkout. */
     verified: {
@@ -28,10 +30,13 @@ export interface ReviewRecord {
             served: number;
             applied: number;
         };
+        /** `labelled`: points that took the review's own severity heading; `relabelled`: of those, the ones the judge had read otherwise. */
         prior_points: {
             open: number;
             resolved: number;
             answer_in_reply: number;
+            labelled?: number;
+            relabelled?: number;
         };
         unverified: number;
         notes: number;

package/dist/review/reviewer/record.js

@@ -21,7 +21,7 @@ export function buildRecord(input) {
             should_fix: input.accounted.advisory,
             rules: { served: rules.length, followed: rules.filter(r => r.status === 'followed').length, broken: rules.filter(r => r.status === 'broken').length, not_applicable: rules.filter(r => r.status === 'not-applicable').length },
             lessons: { served: input.lessonsServed, applied: lessons.filter(l => l.applies === true).length },
-            prior_points: { open: input.accounted.open.filter(i => i.kind === 'prior').length, resolved: input.accounted.resolved.length, answer_in_reply: input.accounted.answerInReply.length },
+            prior_points: { open: input.accounted.open.filter(i => i.kind === 'prior').length, resolved: input.accounted.resolved.length, answer_in_reply: input.accounted.answerInReply.length, ...(input.accounted.labels?.served ? { labelled: input.accounted.labels.taken, relabelled: input.accounted.labels.disagreed } : {}) },
             unverified: input.accounted.unverified.length,
             notes: input.accounted.notes.length,
             disputed: input.accounted.disputed.length,
@@ -54,7 +54,7 @@ function canonical(value) {
 export function recordLines(r, shouldFixShown = 5) {
     const where = (i) => `${i.file ? `\`${i.file}${i.line ? `:${i.line}` : ''}\` ` : ''}${i.issue}${i.locations?.length ? ` (also ${i.locations.map(l => `\`${l.file}${l.line ? `:${l.line}` : ''}\``).join(', ')})` : ''}`;
     const v = r.verified;
-    const lines = [`**Review record** · ${v.blocking.length} blocking · ${v.should_fix.length} should-fix · rules ${v.rules.followed} followed, ${v.rules.broken} broken, ${v.rules.not_applicable} not applicable of ${v.rules.served} · lessons ${v.lessons.applied} of ${v.lessons.served} apply · prior points ${v.prior_points.open} open, ${v.prior_points.resolved} resolved`];
+    const lines = [`**Review record** · ${v.blocking.length} blocking · ${v.should_fix.length} should-fix · rules ${v.rules.followed} followed, ${v.rules.broken} broken, ${v.rules.not_applicable} not applicable of ${v.rules.served} · lessons ${v.lessons.applied} of ${v.lessons.served} apply · prior points ${v.prior_points.open} open, ${v.prior_points.resolved} resolved${v.prior_points.labelled !== undefined ? `, ${v.prior_points.labelled} by the review's own label (${v.prior_points.relabelled} relabelled)` : ''}`];
     for (const i of v.blocking)
         lines.push(`- **Blocking** ${where(i)}`);
     for (const i of v.should_fix.slice(0, shouldFixShown))
@@ -64,6 +64,6 @@ export function recordLines(r, shouldFixShown = 5) {
     const folded = [[v.notes, 'working note'], [v.disputed, 'disputed'], [v.unverified, 'unverified'], [r.people.dismissed, 'dismissed']].filter(([n]) => n > 0);
     if (folded.length)
         lines.push(`Also seen, never blocking: ${folded.map(([n, w]) => `${n} ${w}${n === 1 || w === 'disputed' || w === 'unverified' || w === 'dismissed' ? '' : 's'}`).join(', ')}.`);
-    lines.push(`Judged by ${r.judges.map(j => `${j.reviewer}${j.version ? ` ${j.version}` : ''}${j.model ? ` (${j.model})` : ''}${typeof j.cost_usd === 'number' ? ` $${j.cost_usd.toFixed(2)}` : ''}`).join(', ') || 'no judge'} on \`${r.head.slice(0, 9)}\` against \`${r.base.slice(0, 9)}\` (${r.scope}); ${r.reported.human_reviews} human review(s) seen. Integrity \`${r.integrity.slice(0, 16)}\`.`);
+    lines.push(`Judged by ${r.judges.map(j => `${j.reviewer}${j.version ? ` ${j.version}` : ''}${j.model ? ` (${j.model})` : ''}${typeof j.cost_usd === 'number' ? ` $${j.cost_usd.toFixed(2)}` : ''}${j.outside_repo ? ` [${j.outside_repo}]` : ''}`).join(', ') || 'no judge'} on \`${r.head.slice(0, 9)}\` against \`${r.base.slice(0, 9)}\` (${r.scope}); ${r.reported.human_reviews} human review(s) seen. Integrity \`${r.integrity.slice(0, 16)}\`.`);
     return lines;
 }

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

@@ -29,4 +29,12 @@ describe('the review record', () => {
         expect(lines.at(-2)).toBe('Also seen, never blocking: 2 working notes, 1 unverified, 1 dismissed.');
         expect(lines.at(-1)).toMatch(/^Judged by claude 2\.1\.0 \(opus\) \$1\.25 on `abcdef012` against `012345678` \(full\); 2 human review\(s\) seen\. Integrity `[0-9a-f]{16}`\.$/);
     });
+    it("counts the prior points that took the review's own severity label, and only when the reviews carry labels", () => {
+        const labelled = input();
+        labelled.accounted = { ...labelled.accounted, labels: { served: 4, taken: 2, disagreed: 1 } };
+        const record = buildRecord(labelled);
+        expect(record.verified.prior_points).toMatchObject({ labelled: 2, relabelled: 1 });
+        expect(recordLines(record).join('\n')).toContain("2 by the review's own label (1 relabelled)");
+        expect(buildRecord(input()).verified.prior_points).not.toHaveProperty('labelled');
+    });
 });

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

@@ -11,7 +11,35 @@ 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;
+    labels?: LabelledPoint[];
 }
+/** A point under a severity heading the reviewer wrote ("Blocking", "Should fix", "Nits"): the reviewer's own label. */
+export interface LabelledPoint {
+    login: string;
+    at: string;
+    severity: NonNullable<PriorPoint['severity']>;
+    text: string;
+}
+/** 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 +223,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;
@@ -227,9 +260,15 @@ export interface Accounting {
     notes: OpenItem[];
     /** Should-fixes the judge could show (a verified quote): worth a person's time, never a block. */
     advisory: OpenItem[];
+    /** The reviews' own severity labels: how many there were, how many prior points took one, and how many the judge read otherwise. */
+    labels?: {
+        served: number;
+        taken: number;
+        disagreed: number;
+    };
 }
 /** 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;