@rigour-labs/core 6.7.10 → 6.8.0

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)}` };
@@ -104,10 +104,44 @@ export async function humanReviews(gh, pr, reviewsBefore) {
             key: [...rounds.map((r) => `${r.id},${r.submitted_at},${r.commit_id},${r.state}`), ...inline.map((c) => `${c.id},${c.updated_at}`)].join('|'),
             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.js

@@ -23,4 +23,30 @@ describe('the human reviews a judge reads', () => {
         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/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

@@ -27,6 +27,14 @@ 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>>;
@@ -252,6 +260,12 @@ 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, prior?: PriorChecks): Accounting;

package/dist/review/reviewer/verdict.js

@@ -12,6 +12,34 @@ 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) {
@@ -214,7 +242,10 @@ export function account(verdict, previousOpen, verify, prior = NO_PRIOR_CHECKS)
     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))
@@ -243,7 +274,7 @@ export function account(verdict, previousOpen, verify, prior = NO_PRIOR_CHECKS)
         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') {
@@ -270,7 +301,11 @@ export function account(verdict, previousOpen, verify, prior = NO_PRIOR_CHECKS)
             continue;
         }
         // Still open only where the judge quotes the code that keeps it open: a point a later commit already fixed never blocks.
-        add(item);
+        // 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(item);
     }
     for (const r of verdict.redundant) {
         if (r.removed === false)
@@ -374,7 +409,7 @@ export function account(verdict, previousOpen, verify, prior = NO_PRIOR_CHECKS)
             }
         }
     }
-    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;
@@ -387,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

@@ -36,6 +36,7 @@ import { buildContext, dismissedAs, readReviewDismissals, relatedDocs } from './
 import { buildRecord } from './reviewer/record.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, approvals: [] };
+    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,12 +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) };
+    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))
@@ -212,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);
@@ -336,6 +351,9 @@ 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, 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);
@@ -462,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

@@ -9,7 +9,8 @@ import { dismissReviewerFinding } from './reviewer/context.js';
 import { reviewStatus } from './reviewer/background.js';
 import { selectReviewers, vendorsOf } from './reviewer/adapters.js';
 import { account, attachServedRules, carryResolved, changedLinesOf, checkoutSearch, checkoutVerifier, mergeVerdicts, parseVerdict } from './reviewer/verdict.js';
-import { recordIntact } from './reviewer/record.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);
@@ -447,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));
@@ -703,3 +719,74 @@ describe('a block sits on a line the change touched', () => {
         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[];