@rigour-labs/core 6.7.9 → 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/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);
@@ -334,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);
@@ -347,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'] } } });
@@ -326,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);
     });
 });
@@ -625,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.9",
+  "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.9",
-    "@rigour-labs/brain-linux-arm64": "6.7.9",
-    "@rigour-labs/brain-linux-x64": "6.7.9",
-    "@rigour-labs/brain-darwin-x64": "6.7.9",
-    "@rigour-labs/brain-win-x64": "6.7.9"
+    "@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",