@rigour-labs/core 6.7.9 → 6.8.0

package/dist/review/reviewer/verdict.js

@@ -7,10 +7,83 @@
  * 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';
+/** How alike a judge's prior point and a labelled line of the review must read to take the reviewer's label. */
+const LABEL_SIMILARITY = 0.4;
+/**
+ * The point with the severity its reviewer wrote, when the review labels it; the judge's reading otherwise. The reviewer
+ * is matched by login; the review by the date the judge names (judges write a timestamp, a date, or reformat it), and
+ * when no review of that reviewer has that date, by that reviewer's latest labelled review. A disagreement is said.
+ */
+function labelled(p, labels) {
+    const [login, ...rest] = (p.review ?? '').trim().split(/\s+/);
+    const day = /\d{4}-\d{2}-\d{2}/.exec(rest.join(' '))?.[0];
+    const theirs = login ? labels.filter(l => l.login === login) : [];
+    const sameDay = day ? theirs.filter(l => l.at.startsWith(day)) : [];
+    const latest = theirs.reduce((max, l) => (l.at > max ? l.at : max), '');
+    const candidates = sameDay.length ? sameDay : theirs.filter(l => l.at === latest);
+    const asItem = (issue) => ({ id: '', kind: 'prior', class: 'prior point', issue });
+    let best;
+    for (const label of candidates) {
+        const score = textSimilarity(asItem(p.point), asItem(label.text));
+        if (score >= LABEL_SIMILARITY && (!best || score > best.score))
+            best = { label, score };
+    }
+    if (!best)
+        return { point: p, took: false, disagreed: false };
+    if (best.label.severity === p.severity)
+        return { point: p, took: true, disagreed: false };
+    const note = `the review labels it ${best.label.severity}${p.severity ? `; the judge read ${p.severity}` : ''}`;
+    return { point: { ...p, severity: best.label.severity, evidence: p.evidence ? `${p.evidence}; ${note}` : note }, took: true, disagreed: true };
+}
+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 +117,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,13 +236,16 @@ 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 = [];
     const advisory = [];
     const seen = new Set();
-    const accepted = verdict.prior_points.filter(p => p.severity === 'non-blocking');
+    // The reviewer's own label wins over the judge's reading of it: a judge that calls a blocker a should-fix would demote it silently.
+    const read = verdict.prior_points.map(p => labelled(p, prior.labels ?? []));
+    const points = read.map(r => r.point);
+    const accepted = points.filter(p => p.severity === 'non-blocking');
     // A should-fix is shown only when the judge could show it: a quote Rigour finds. One that cannot be checked is not a claim worth a person's time.
     const advise = (item) => {
         if (seen.has(item.id))
@@ -159,17 +263,49 @@ 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) {
+    for (const p of 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.
+        // A should-fix keeps the tier its reviewer gave it: shown with its quote, never a block, like a should-fix finding.
+        if (p.severity === 'should-fix')
+            advise(item);
         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)
@@ -273,7 +409,7 @@ export function account(verdict, previousOpen, verify) {
             }
         }
     }
-    return { open: onePerRootCause(open), unverified, resolved, answerInReply, notes, advisory: onePerRootCause(advisory) };
+    return { open: onePerRootCause(open), unverified, resolved, answerInReply, notes, advisory: onePerRootCause(advisory), labels: { served: prior.labels?.length ?? 0, taken: read.filter(r => r.took).length, disagreed: read.filter(r => r.disagreed).length } };
 }
 /** How alike two items' words must be to be the same point made in two places; and, on the same lines, to be one point said two ways. */
 const SAME_POINT = 0.6;
@@ -286,9 +422,14 @@ const SAME_LINES = 3;
 function onePerRootCause(items) {
     const kept = [];
     for (const item of items) {
-        // The same class in the same words anywhere, or any two non-human items on the same lines that read alike (a rule break and the finding it caused).
+        // The same class in the same words anywhere, or any two non-human items on the same lines that read alike (a rule break and
+        // the finding it caused). A human's point owns its lines: a rule break or finding there in like words is that point found
+        // again and folds into it; the human's words stay. One in other words is a different problem and stays its own item, so
+        // fixing the human's point does not leave it for the next round. Two human points never merge.
         const nearby = (k) => !!k.file && k.file === item.file && k.line !== undefined && item.line !== undefined && Math.abs(k.line - item.line) <= SAME_LINES;
-        const same = item.kind === 'prior' ? undefined : kept.find(k => k.kind !== 'prior' && ((k.class === item.class && textSimilarity(k, item) >= SAME_POINT) || (nearby(k) && textSimilarity(k, item) >= SAME_PLACE)));
+        const same = item.kind === 'prior' ? undefined : kept.find(k => k.kind === 'prior'
+            ? nearby(k) && textSimilarity(k, item) >= SAME_PLACE
+            : (k.class === item.class && textSimilarity(k, item) >= SAME_POINT) || (nearby(k) && textSimilarity(k, item) >= SAME_PLACE));
         if (!same) {
             kept.push(item);
             continue;

package/dist/review/reviewer.d.ts

@@ -84,6 +84,8 @@ export interface ReviewerResult {
     /** The latest human review it worked from (`<login>, <date> (<n> reviews)`). */
     previousReview?: string;
     pr?: number;
+    /** The pull request's title, when one was read. */
+    prTitle?: string;
 }
 export interface ModeRecord {
     asked: 'single' | 'cross' | 'full' | 'panel';

package/dist/review/reviewer.js

@@ -34,8 +34,9 @@ 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';
+import { appendTaskEvent } from '../task/thread.js';
 export { defaultExec, githubEnv, githubToken, parseJsonArrays } from './reviewer/exec.js';
 export { itemLine } from './reviewer/verdict.js';
 /** Findings and no verdict stop a push; a skipped review does not, and is reported as owed. */
@@ -48,7 +49,16 @@ const MAX_DELTA_LINES = 400;
 /** The reviewer, and one anonymous usage event for what it did (only when the person opted in to telemetry). */
 export async function runReviewer(cwd, base, config, exec = defaultExec, progress = message => process.stderr.write(`${message}\n`), options = {}) {
     const result = await review(cwd, base, config, exec, progress, options);
-    await trackUsage('reviewer_completed', reviewerUsage(result, options.trigger ?? (options.reviewsBefore ? 'backtest' : 'review')));
+    const trigger = options.trigger ?? (options.reviewsBefore ? 'backtest' : 'review');
+    await trackUsage('reviewer_completed', reviewerUsage(result, trigger));
+    // On the task's thread, unless it replays history: a backtest's worktree is not anyone's task.
+    if (trigger !== 'backtest' && result.outcome !== 'skipped')
+        appendTaskEvent(cwd, {
+            kind: 'review', trigger, outcome: result.outcome, blocking: result.items.length, should_fix: result.advisory.length,
+            ...(result.pr ? { pr: result.pr } : {}),
+            ...(result.prTitle ? { pr_title: result.prTitle } : {}),
+            ...(result.record ? { integrity: result.record.integrity, cost_usd: result.record.judges.reduce((sum, j) => sum + (j.cost_usd ?? 0), 0), judges: result.record.judges.map(j => j.reviewer) } : {}),
+        });
     return result;
 }
 async function review(cwd, base, config, exec, progress, options) {
@@ -107,7 +117,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: [], labels: [] };
     if (gh && pr) {
         const read = await humanReviews(gh, pr, options.reviewsBefore);
         if (read.error)
@@ -187,11 +197,17 @@ 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), labels: reviews.labels };
     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.
+    // What a judge reads besides the repository and Rigour's inputs, on this machine: on the record, so "the same judge" is a claim it can check.
+    const outsideOf = (reviewer) => {
+        const outside = ADAPTERS[reviewer]?.outsideRepo?.(os.homedir(), installed.get(reviewer)?.version);
+        return outside ? { outside_repo: outside } : {};
+    };
     const withRecord = (accounted, verdict, cached) => {
         const res = result(accounted, verdict, reviewers, scope, why, cached, reviews, pr, modeRecord, settings.dismissals);
-        const judges = (verdict.reviewers ?? []).map(r => ({ reviewer: r.reviewer, ...(installed.get(r.reviewer)?.version ? { version: installed.get(r.reviewer).version } : {}), ...(modelFor(r.reviewer) ? { model: modelFor(r.reviewer) } : {}), ...(typeof r.cost_usd === 'number' ? { cost_usd: r.cost_usd } : {}), ...(r.trace?.turns ? { turns: r.trace.turns } : {}) }));
+        const judges = (verdict.reviewers ?? []).map(r => ({ reviewer: r.reviewer, ...(installed.get(r.reviewer)?.version ? { version: installed.get(r.reviewer).version } : {}), ...(modelFor(r.reviewer) ? { model: modelFor(r.reviewer) } : {}), ...(typeof r.cost_usd === 'number' ? { cost_usd: r.cost_usd } : {}), ...(r.trace?.turns ? { turns: r.trace.turns } : {}), ...outsideOf(r.reviewer) }));
         const recordPath = store.recordPath(verdictFile);
         const record = (cached && store.readJson(recordPath)) || buildRecord({ head, base: baseSha, scope, verdict, accounted, judges, lessonsServed: context.lessons, humanReviews: reviews.count });
         if (!cached || !fs.existsSync(recordPath))
@@ -200,7 +216,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);
@@ -211,7 +227,7 @@ async function review(cwd, base, config, exec, progress, options) {
     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], 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) });
+        : 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), ...(ADAPTERS[name].env ? { env: ADAPTERS[name].env } : {}) });
     try {
         const file = (name, text) => {
             const target = path.join(work, name);
@@ -334,7 +350,10 @@ 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);
+        // Said every run where the reviews carry labels, so a matcher that takes none is visible rather than silent.
+        if (accounted.labels?.served)
+            progress(`Rigour reviewer: ${accounted.labels.taken} of ${verdict.prior_points.length} prior point(s) took the review's own severity label (${accounted.labels.served} labelled line(s)); the judge read ${accounted.labels.disagreed} otherwise`);
         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 +366,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
@@ -461,5 +480,6 @@ function result(accounted, verdict, reviewers, scope, why, cached, reviews, pr,
         cached,
         ...(reviews.label ? { previousReview: reviews.label } : {}),
         ...(pr ? { pr: pr.number } : {}),
+        ...(pr?.title ? { prTitle: pr.title } : {}),
     };
 }

package/dist/review/reviewer.test.js

@@ -8,8 +8,9 @@ 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 { recordIntact } from './reviewer/record.js';
+import { account, attachServedRules, carryResolved, changedLinesOf, checkoutSearch, checkoutVerifier, mergeVerdicts, parseVerdict } from './reviewer/verdict.js';
+import { recordIntact, recordLines } from './reviewer/record.js';
+import { readThread } from '../task/thread.js';
 let repo;
 const config = ConfigSchema.parse({ version: 1, review: { github_account: 'reviewer-account', reviewer: { enabled: true, reviewers: ['claude', 'cursor'] } } });
 const git = (...args) => execFileSync('git', ['-C', repo, ...args], { encoding: 'utf8' }).trim();
@@ -51,6 +52,7 @@ function fakes(answer, seen, pr = PR) {
         seen.ran.push(command);
         (seen.args ??= []).push(args);
         (seen.unset ??= []).push(options.unset);
+        (seen.env ??= []).push(options.env);
         const name = binary === 'claude' ? 'claude' : binary === 'cursor-agent' ? 'cursor' : 'codex';
         const prompt = binary === 'claude' ? args[args.indexOf('-p') + 1] : args[args.length - 1];
         seen.prompts.push(prompt);
@@ -326,7 +328,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);
     });
 });
@@ -446,18 +449,32 @@ describe('verdicts', () => {
         expect(unknown.verdict.rules).toEqual([]); // an answer naming no served rule is dropped, whatever it claims
         expect(unknown.open).toEqual([]);
     });
-    it('shows the same point found in several places as one item with every location, and never merges human points', () => {
+    it("shows the same point found in several places as one item with every location; a judge item on a human point's lines folds into it, and human points never merge", () => {
         const scan = (file, line, quote) => ({ class: 'production-cost', file, line, issue: `the ${file.split('/').pop()} scan has no upper bound on updated_at`, input: 'a week of rows', consequence: 'rows read grow with time', quote });
         const verdict = { ...EMPTY, prior_points: [
-                { point: 'bound the window', severity: 'blocking', resolved: false, file: 'src/job.ts', line: 1, quote: 'export function job() {' },
+                { point: 'the scan has no upper bound on updated_at', severity: 'blocking', resolved: false, file: 'src/job.ts', line: 1, quote: 'export function job() {' },
                 { point: 'bound the window again', severity: 'blocking', resolved: false, file: 'src/job.ts', line: 1, quote: 'export function job() {' },
             ], findings: [scan('src/job.ts', 1, 'export function job() {'), scan('a.ts', 1, 'export const a = 1;'), { ...scan('src/job.ts', 2, 'return 1;'), class: 'correctness' }] };
         const { open } = account(verdict, undefined, checkoutVerifier(repo));
         expect(open.map(i => [i.kind, i.class, i.locations ?? []])).toEqual([
-            ['prior', 'prior point', []], ['prior', 'prior point', []],
-            // The same point in another file, and the same point said as another class on the next line: one item, every place.
-            ['finding', 'production-cost', [{ file: 'a.ts', line: 1 }, { file: 'src/job.ts', line: 2 }]],
+            // The judge's scan on the human's lines, in like words, is the human's point found again, and so is the same point said as another class on the next line.
+            // The same scan in another file is not on the human's lines: its own item.
+            ['prior', 'prior point', [{ file: 'src/job.ts', line: 1 }, { file: 'src/job.ts', line: 2 }]], ['prior', 'prior point', []], ['finding', 'production-cost', []],
         ]);
+        // On other lines than any human point: the same point in another file, and said as another class on the next line, is one item, every place.
+        const apart = account({ ...verdict, prior_points: [] }, undefined, checkoutVerifier(repo));
+        expect(apart.open.map(i => [i.kind, i.class, i.locations ?? []])).toEqual([['finding', 'production-cost', [{ file: 'a.ts', line: 1 }, { file: 'src/job.ts', line: 2 }]]]);
+        // On a human point's lines: a rule break in like words is that point found again; a different rule, or a finding in other
+        // words, stays its own item, so fixing the human's point does not leave it for the next round.
+        const human = { point: 'null guards on columns the query makes non-null are dead fallbacks', severity: 'blocking', resolved: false, file: 'src/job.ts', line: 2, quote: 'return 1;' };
+        const onHuman = account({ ...EMPTY, prior_points: [human],
+            findings: [{ class: 'correctness', file: 'src/job.ts', line: 3, issue: 'the retry re-sends the email', input: 'a timeout', consequence: 'two emails', quote: '}' }],
+            rules: [
+                { id: 'r1', status: 'broken', file: 'src/job.ts', line: 2, quote: 'return 1;', rule: 'No dead fallbacks or null guards on non-null columns.', source: 'AGENTS.md', requirement: true },
+                { id: 'r2', status: 'broken', file: 'src/job.ts', line: 3, quote: '}', rule: 'Import the JOBS_TABLE constant; do not inline the raw table name.', source: 'AGENTS.md', requirement: true },
+            ] }, undefined, checkoutVerifier(repo));
+        expect(onHuman.open.map(i => [i.kind, i.locations ?? []])).toEqual([['prior', [{ file: 'src/job.ts', line: 2 }]], ['rule', []], ['finding', []]]);
+        expect(onHuman.open[1].issue).toContain('JOBS_TABLE');
         // A rule break and the finding it caused, on the same lines and in like words, are one item.
         const twice = account({ ...EMPTY, prior_points: [], findings: [{ class: 'correctness', file: 'src/job.ts', line: 2, issue: 'the raw table name is inlined instead of the JOBS_TABLE constant', input: 'any run', consequence: 'a rename misses it', quote: 'return 1;' }],
             rules: [{ id: 'r', status: 'broken', file: 'src/job.ts', line: 2, quote: 'return 1;', rule: 'Import the JOBS_TABLE constant; do not inline the raw table name again.', source: 'AGENTS.md', requirement: true }] }, undefined, checkoutVerifier(repo));
@@ -625,3 +642,151 @@ 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);
+    });
+});
+describe("a human's should-fix point", () => {
+    it('is shown with its quote and never blocks, like a should-fix finding', () => {
+        const verdict = { ...EMPTY, prior_points: [{ point: 'a reopened deck reads as a return every day', review: 'senior 2026-10-01', severity: 'should-fix', resolved: false, file: 'src/job.ts', line: 2, quote: 'return 1;' }] };
+        const { open, advisory, unverified } = account(verdict, undefined, checkoutVerifier(repo));
+        expect(open).toEqual([]);
+        expect(advisory.map(i => [i.kind, i.issue])).toEqual([['prior', 'a reopened deck reads as a return every day']]);
+        expect(unverified).toEqual([]);
+        const unplaced = account({ ...verdict, prior_points: [{ ...verdict.prior_points[0], quote: 'not in the file' }] }, undefined, checkoutVerifier(repo));
+        expect(unplaced.advisory).toEqual([]); // a should-fix the judge cannot show is not worth a person's time
+        expect(unplaced.unverified).toHaveLength(1);
+    });
+});
+describe("the reviewer's own severity label", () => {
+    const at = '2026-10-01T10:00:00Z';
+    const labels = [
+        { login: 'senior', at, severity: 'blocking', text: 'The kill switch is read after every query: check it first.' },
+        { login: 'senior', at, severity: 'should-fix', text: 'The comment on the window still says daily.' },
+    ];
+    const point = (over) => ({ ...EMPTY, prior_points: [{ point: 'the kill switch is read after every query', review: 'senior 2026-10-01T10:00:00Z', severity: 'should-fix', resolved: false, file: 'src/job.ts', line: 2, quote: 'return 1;', ...over }] });
+    it('wins over the judge: a blocker the judge read as a should-fix blocks, and the disagreement is said', () => {
+        const { open, advisory } = account(point({}), undefined, checkoutVerifier(repo), { approvals: [], inCheckout: () => undefined, labels });
+        expect(advisory).toEqual([]);
+        expect(open).toMatchObject([{ kind: 'prior', evidence: 'the review labels it blocking; the judge read should-fix' }]);
+    });
+    it('matches the review by its date however the judge writes the time, and falls back to the reviewer\'s latest labelled review', () => {
+        const later = { login: 'senior', at: '2026-10-03T09:00:00Z', severity: 'should-fix', text: 'The kill switch is read after every query: check it first.' };
+        for (const review of ['senior 2026-10-01', 'senior 2026-10-01 10:00', 'senior']) {
+            const { open, labels: counted } = account(point({ review }), undefined, checkoutVerifier(repo), { approvals: [], inCheckout: () => undefined, labels });
+            expect(open).toHaveLength(1);
+            expect(counted).toEqual({ served: 2, taken: 1, disagreed: 1 });
+        }
+        // No review of that reviewer on the judge's date: the reviewer's latest labelled review decides (here, a should-fix).
+        const { open, advisory } = account(point({ review: 'senior 2026-09-30', severity: 'blocking' }), undefined, checkoutVerifier(repo), { approvals: [], inCheckout: () => undefined, labels: [...labels, later] });
+        expect([open.length, advisory.length]).toEqual([0, 1]);
+    });
+    it('applies only to the same reviewer, and only to a point that reads like the labelled line; the counts say so', () => {
+        for (const over of [{ review: 'peer 2026-10-01T10:00:00Z' }, { point: 'the email retry sends twice' }]) {
+            const { open, advisory, labels: counted } = account(point(over), undefined, checkoutVerifier(repo), { approvals: [], inCheckout: () => undefined, labels });
+            expect([open.length, advisory.length]).toEqual([0, 1]); // the judge's should-fix stands
+            expect(counted).toEqual({ served: 2, taken: 0, disagreed: 0 });
+        }
+    });
+});
+describe('the judge Rigour launches', () => {
+    it('runs claude with every memory file switched off, and records the isolation as unverified below the version it was verified in', async () => {
+        const seen = seenNow();
+        const result = await runReviewer(repo, 'main', ConfigSchema.parse({ version: 1, review: { reviewer: { enabled: true, reviewers: ['claude'] } } }), fakes(() => JSON.stringify(EMPTY), seen, null), () => undefined, { trigger: 'review' });
+        expect(result.outcome).toBe('passed');
+        const claude = seen.ran.findIndex(command => path.basename(command).startsWith('claude'));
+        expect(seen.env?.[claude]).toEqual({ CLAUDE_CODE_DISABLE_CLAUDE_MDS: '1', CLAUDE_CODE_DISABLE_AUTO_MEMORY: '1' });
+        // The fake reports version 1.0.0, older than the one the switches were verified in: the record says so.
+        expect(result.record?.judges.map(j => j.outside_repo)).toEqual(['claude 1.0.0: memory isolation unverified (needs 2.1.285 or later)']);
+        expect(recordLines(result.record).join('\n')).toContain('[claude 1.0.0: memory isolation unverified (needs 2.1.285 or later)]');
+        const current = seenNow();
+        // The installed fake is claude on Unix and claude.cmd on Windows: name both.
+        current.versions = { [path.join(bins[0], 'claude')]: '2.1.285 (Claude Code)', [path.join(bins[0], 'claude.cmd')]: '2.1.285 (Claude Code)' };
+        const verified = await runReviewer(repo, 'main', ConfigSchema.parse({ version: 1, review: { reviewer: { enabled: true, reviewers: ['claude'] } } }), fakes(() => JSON.stringify(EMPTY), current, null), () => undefined, { trigger: 'review', force: true });
+        expect(verified.record?.judges.map(j => j.outside_repo)).toEqual([undefined]);
+    });
+});
+describe("the review on the task's thread", () => {
+    it('appends each review of a branch to its task, and never a backtest replaying history', async () => {
+        const seen = seenNow();
+        await runReviewer(repo, 'main', ConfigSchema.parse({ version: 1, review: { reviewer: { enabled: true, reviewers: ['claude'] } } }), fakes(() => JSON.stringify(EMPTY), seen, null), () => undefined, { trigger: 'review' });
+        const thread = readThread(repo, 'feature');
+        expect(thread?.events.map(e => [e.kind, e.trigger, e.outcome, e.blocking])).toEqual([['review', 'review', 'passed', 0]]);
+        expect(thread?.events[0].integrity).toEqual(expect.any(String));
+        await runReviewer(repo, 'main', config, fakes(() => JSON.stringify({ ...EMPTY, prior_points: [] }), seenNow()), () => undefined, { pr: 42, reviewsBefore: '2026-10-03', force: true });
+        expect(readThread(repo, 'feature')?.events).toHaveLength(1);
+    });
+});

package/dist/review-learning/repo-rules.d.ts

@@ -5,14 +5,26 @@ export interface RepoRule {
     text: string;
     /** Paths the rule names (files or directories). */
     paths: string[];
+    /** Where the rule applies: the folder of the nested rules file it came from (`services/billing/`); the whole repository when absent. */
+    scope?: string;
     /** Identifiers the rule names. */
     symbols: string[];
     /** Worded as a requirement: a break can block. Guidance otherwise: a break is shown. */
     requirement: boolean;
 }
+/**
+ * Every rule file of the repository: the root ones, the AGENTS.md and CLAUDE.md files in folders below it (outside
+ * vendored folders), the rule directories, and every file a rule file imports with an `@path` line (relative to the
+ * importing file, inside the repository). A judge does not load these by itself; this is how the repository's rules
+ * reach it. A nested file's rules apply to its own folder only, and so do the rules of the files it imports.
+ */
 export declare function readRepoRules(cwd: string): RepoRule[];
 /** One rule per top-level bullet or paragraph; headings and import lines are not rules. */
 export declare function splitRules(source: string, text: string): RepoRule[];
 export declare function rulesSection(rules: RepoRule[]): string;
-/** The rules that apply to a diff's changed files and added identifiers, the top `limit`. */
-export declare function rulesForDiff(cwd: string, diff: string, enabled?: boolean, limit?: number): RepoRule[];
+/**
+ * The rules that apply to a diff's changed files and added identifiers, the top `limit`. `namedOnly`: only rules that
+ * name a path or identifier the change touches (a briefing has no code to judge applicability against, so a rule that
+ * merely shares words with a large change is noise there).
+ */
+export declare function rulesForDiff(cwd: string, diff: string, enabled?: boolean, limit?: number, namedOnly?: boolean): RepoRule[];