@rigour-labs/core 6.7.10 → 6.8.1-rc.1

package/dist/brief/briefing.d.ts

@@ -0,0 +1,59 @@
+import { type LessonMode } from '../review-learning/team-lessons.js';
+/** The most items a briefing gives: past about ten, a briefing is a wall nobody reads. */
+export declare const BRIEFING_MAX_ITEMS = 10;
+/** The most items a briefing for one file gives, the first time an agent edits it: a word in passing, not a wall. */
+export declare const FILE_BRIEFING_MAX_ITEMS = 3;
+export interface BriefingItem {
+    kind: 'rule' | 'lesson' | 'settled';
+    /** What to do, in the team's words (a rule's text, a lesson's rule). */
+    text: string;
+    /** Where it came from: the rules file, or the pull requests the lesson was learned and proven on. */
+    cite: string;
+    /** A rule the team worded as a requirement: a break blocks at review. */
+    requirement?: boolean;
+    id: string;
+}
+export interface Briefing {
+    task?: string;
+    goal: string;
+    files: string[];
+    items: BriefingItem[];
+}
+export interface BriefingInput {
+    /** What the task is for: the agent's first prompt, a ticket's summary, the pull request's title. The branch name when absent. */
+    goal?: string;
+    /** The files the task will touch, when known; otherwise the branch's own changes and the files the goal names. */
+    files?: string[];
+    lessons?: LessonMode;
+    limit?: number;
+}
+/**
+ * The briefing for a task in this checkout: requirement rules first (a break of one blocks later), then the team's
+ * verified lessons, then the points the team settled against, then guidance rules; `limit` items at most.
+ */
+export declare function buildBriefing(cwd: string, input?: BriefingInput): Briefing;
+/** The briefing as an agent reads it: short, numbered, each item with where it came from. Empty when there is nothing to say. */
+export declare function briefingText(briefing: Briefing): string;
+/**
+ * The briefing for one file, the first time an agent edits it: the requirement rules that name it (or its folder), the
+ * lessons the team learned on it, and the points the team settled against on it; at most three. At session start the
+ * task's files are often unknown; the first edit of a file is when they are, and when a briefing can be specific.
+ */
+export declare function buildFileBriefing(cwd: string, file: string, input?: {
+    lessons?: LessonMode;
+    limit?: number;
+}): Briefing;
+/** A file's briefing as an agent reads it, just before it edits that file. Empty when there is nothing to say. */
+export declare function fileBriefingText(briefing: Briefing): string;
+/** Builds a file's briefing and records it on the task's thread, with the file. */
+export declare function briefFile(cwd: string, file: string, input?: {
+    lessons?: LessonMode;
+    limit?: number;
+    session?: string;
+    agent?: string;
+}): Briefing;
+/** Builds the briefing and records it on the task's thread (what was briefed, by id, so a later review can be read against it). */
+export declare function briefTask(cwd: string, input: BriefingInput & {
+    session?: string;
+    agent?: string;
+}): Briefing;

package/dist/brief/briefing.js

@@ -0,0 +1,126 @@
+/**
+ * The briefing: before an agent writes, what a senior on this team would tell it about the task. The repository's own
+ * rules and the team's verified lessons for the files the task will likely touch, and the points the team settled
+ * against (so the agent does not re-raise or re-do them), at most `limit` items, each cited to where it came from.
+ *
+ * Nothing here is new knowledge: the same rules and lessons the reviewer checks a change against, selected by the same
+ * matchers, before the code exists instead of after. It is deterministic (no model call), local, and it never blocks.
+ */
+import { spawnSync } from 'child_process';
+import { rulesForDiff } from '../review-learning/repo-rules.js';
+import { describeLesson, lessonsForDiff, lessonView, rejectedForDiff } from '../review-learning/team-lessons.js';
+import { appendTaskEvent, taskOf } from '../task/thread.js';
+/** The most items a briefing gives: past about ten, a briefing is a wall nobody reads. */
+export const BRIEFING_MAX_ITEMS = 10;
+/** The most items a briefing for one file gives, the first time an agent edits it: a word in passing, not a wall. */
+export const FILE_BRIEFING_MAX_ITEMS = 3;
+/** The most files a briefing reads the task's likely reach from. */
+const LIKELY_FILES = 20;
+/**
+ * The briefing for a task in this checkout: requirement rules first (a break of one blocks later), then the team's
+ * verified lessons, then the points the team settled against, then guidance rules; `limit` items at most.
+ */
+export function buildBriefing(cwd, input = {}) {
+    const task = taskOf(cwd);
+    const goal = (input.goal?.trim() || (task ? task.branch.replace(/[/_-]+/g, ' ') : '')).slice(0, 2000);
+    const files = (input.files?.length ? input.files : likelyFiles(cwd, goal)).slice(0, LIKELY_FILES);
+    const limit = Math.max(0, Math.min(input.limit ?? BRIEFING_MAX_ITEMS, BRIEFING_MAX_ITEMS));
+    // The rule and lesson matchers read a change: the task's files and the goal's words stand in for the code to come.
+    const shape = shapeOf(files, goal);
+    // Only rules that name a path or identifier of the task: the reviewer can judge a rule against code; a briefing cannot.
+    const rules = rulesForDiff(cwd, shape, true, limit, true);
+    const lessons = lessonsForDiff(cwd, shape, input.lessons ?? 'verified', 5, limit, 3).filter(l => l.state === 'verified' || input.lessons === 'all');
+    const settled = rejectedForDiff(cwd, shape);
+    const cited = (prs) => (prs.length ? `learned in PR ${prs.map(p => `#${p}`).join(', ')}` : 'the team\'s decision');
+    const items = [
+        ...rules.filter(r => r.requirement).map(r => ({ kind: 'rule', text: r.text, cite: ruleCite(r.source, r.scope), requirement: true, id: `rule:${r.id}` })),
+        ...lessons.map(l => {
+            const view = lessonView(l);
+            return { kind: 'lesson', text: describeLesson({ ...view, prs: [] }), cite: cited(view.prs), id: `lesson:${l.id}` };
+        }),
+        ...settled.map(l => ({ kind: 'settled', text: `settled against, do not do or raise it: ${lessonView(l).text}`, cite: cited(lessonView(l).prs), id: `settled:${l.id}` })),
+        ...rules.filter(r => !r.requirement).map(r => ({ kind: 'rule', text: r.text, cite: ruleCite(r.source, r.scope), id: `rule:${r.id}` })),
+    ];
+    return { ...(task ? { task: task.key } : {}), goal, files, items: items.slice(0, limit) };
+}
+/** The briefing as an agent reads it: short, numbered, each item with where it came from. Empty when there is nothing to say. */
+export function briefingText(briefing) {
+    if (briefing.items.length === 0)
+        return '';
+    const lines = briefing.items.map((item, i) => `${i + 1}. ${item.requirement ? '[must] ' : item.kind === 'settled' ? '[settled] ' : ''}${item.text} (${item.cite})`);
+    return [`Rigour briefing${briefing.task ? ` for ${briefing.task}` : ''}: how this team builds the code this task will likely touch. Follow these; a [must] broken in your change blocks at review.`, ...lines].join('\n');
+}
+/**
+ * The briefing for one file, the first time an agent edits it: the requirement rules that name it (or its folder), the
+ * lessons the team learned on it, and the points the team settled against on it; at most three. At session start the
+ * task's files are often unknown; the first edit of a file is when they are, and when a briefing can be specific.
+ */
+export function buildFileBriefing(cwd, file, input = {}) {
+    const task = taskOf(cwd);
+    const limit = Math.max(0, Math.min(input.limit ?? FILE_BRIEFING_MAX_ITEMS, FILE_BRIEFING_MAX_ITEMS));
+    const shape = shapeOf([file], '');
+    const mode = input.lessons ?? 'verified';
+    const rules = rulesForDiff(cwd, shape, true, BRIEFING_MAX_ITEMS, true).filter(r => r.requirement);
+    const lessons = lessonsForDiff(cwd, shape, mode, 0, BRIEFING_MAX_ITEMS, BRIEFING_MAX_ITEMS).filter(l => l.file === file && (l.state === 'verified' || mode === 'all'));
+    const settled = rejectedForDiff(cwd, shape).filter(l => l.file === file);
+    const cited = (prs) => (prs.length ? `learned in PR ${prs.map(p => `#${p}`).join(', ')}` : 'the team\'s decision');
+    const items = [
+        ...rules.map(r => ({ kind: 'rule', text: r.text, cite: ruleCite(r.source, r.scope), requirement: true, id: `rule:${r.id}` })),
+        ...lessons.map(l => ({ kind: 'lesson', text: lessonView(l).text, cite: cited(lessonView(l).prs), id: `lesson:${l.id}` })),
+        ...settled.map(l => ({ kind: 'settled', text: `settled against, do not do or raise it: ${lessonView(l).text}`, cite: cited(lessonView(l).prs), id: `settled:${l.id}` })),
+    ];
+    return { ...(task ? { task: task.key } : {}), goal: '', files: [file], items: items.slice(0, limit) };
+}
+/** A file's briefing as an agent reads it, just before it edits that file. Empty when there is nothing to say. */
+export function fileBriefingText(briefing) {
+    if (briefing.items.length === 0)
+        return '';
+    const lines = briefing.items.map((item, i) => `${i + 1}. ${item.requirement ? '[must] ' : item.kind === 'settled' ? '[settled] ' : ''}${item.text} (${item.cite})`);
+    return [`Rigour, before you edit ${briefing.files[0]}: what this team asks of this file.`, ...lines].join('\n');
+}
+/** Builds a file's briefing and records it on the task's thread, with the file. */
+export function briefFile(cwd, file, input = {}) {
+    const briefing = buildFileBriefing(cwd, file, input);
+    appendTaskEvent(cwd, { kind: 'brief', file, ...(input.session ? { session: input.session } : {}), ...(input.agent ? { agent: input.agent } : {}), items: briefing.items.length, ids: briefing.items.map(i => i.id), files: [file] });
+    return briefing;
+}
+/** Builds the briefing and records it on the task's thread (what was briefed, by id, so a later review can be read against it). */
+export function briefTask(cwd, input) {
+    const briefing = buildBriefing(cwd, input);
+    appendTaskEvent(cwd, { kind: 'brief', ...(input.session ? { session: input.session } : {}), ...(input.agent ? { agent: input.agent } : {}), items: briefing.items.length, ids: briefing.items.map(i => i.id), files: briefing.files });
+    return briefing;
+}
+function ruleCite(source, scope) {
+    return scope ? `${source}, for ${scope}` : source;
+}
+/** A stand-in change for the matchers: each file as touched, the goal's words as the added line. */
+function shapeOf(files, goal) {
+    const words = goal.replace(/\s+/g, ' ');
+    const touched = files.length ? files : ['.'];
+    return touched.map(f => `diff --git a/${f} b/${f}\n--- a/${f}\n+++ b/${f}\n@@ -0,0 +1,1 @@\n+${words}\n`).join('');
+}
+/** The files a task will likely touch: what the branch already changed, then tracked files whose path names a word of the goal. */
+function likelyFiles(cwd, goal) {
+    const files = [];
+    const main = ['origin/main', 'main', 'origin/master', 'master'].find(ref => git(cwd, ['rev-parse', '--verify', '-q', ref]) !== undefined);
+    const base = main ? git(cwd, ['merge-base', 'HEAD', main]) : undefined;
+    if (base)
+        files.push(...(git(cwd, ['diff', '--name-only', `${base}...HEAD`]) ?? '').split('\n').filter(Boolean));
+    const words = [...new Set(goal.toLowerCase().match(/[a-z][a-z0-9]{3,}/g) ?? [])].filter(w => !STOP.has(w));
+    if (words.length) {
+        const tracked = (git(cwd, ['ls-files']) ?? '').split('\n').filter(Boolean);
+        for (const file of tracked) {
+            if (files.length >= LIKELY_FILES)
+                break;
+            const name = file.toLowerCase();
+            if (!files.includes(file) && words.some(w => name.includes(w)))
+                files.push(file);
+        }
+    }
+    return files;
+}
+const STOP = new Set(['this', 'that', 'with', 'from', 'into', 'when', 'then', 'than', 'have', 'make', 'should', 'would', 'could', 'please', 'there', 'their', 'what', 'which', 'about', 'feat', 'test', 'tests', 'code', 'file', 'files', 'change', 'update']);
+function git(cwd, args) {
+    const result = spawnSync('git', args, { cwd, encoding: 'utf8', timeout: 5000, maxBuffer: 16 * 1024 * 1024 });
+    return result.status === 0 ? result.stdout.trim() : undefined;
+}

package/dist/index.d.ts

@@ -119,3 +119,5 @@ export type { SemanticFinding } from './semantic/types.js';
 export type { ModelUsage } from './storage/index.js';
 export type { CheckpointMetric } from './storage/index.js';
 export type { CursorUsageSyncOptions } from './services/cursor-usage-client.js';
+export { appendTaskEvent, readThread, taskOf, threadText, threadsDir, THREADS_DIR, type TaskEvent, type TaskEventKind, type ThreadEvent } from './task/thread.js';
+export { briefFile, briefingText, briefTask, buildBriefing, buildFileBriefing, fileBriefingText, BRIEFING_MAX_ITEMS, FILE_BRIEFING_MAX_ITEMS, type Briefing, type BriefingInput, type BriefingItem } from './brief/briefing.js';

package/dist/index.js

@@ -101,3 +101,5 @@ export { learnFromFix, learnFromFileChange } from './semantic/learn/learn.js';
 export { extractFixTrees } from './semantic/learn/git-trees.js';
 export { saveLearnedRule, loadLearnedRules, LEARNED_RULES_DIR } from './semantic/learn/store.js';
 export { recordContextEvent, recordModelUsage, recordCheckpointMetric, getContextEvents, getModelUsages, getCheckpointMetrics, } from './storage/index.js';
+export { appendTaskEvent, readThread, taskOf, threadText, threadsDir, THREADS_DIR } from './task/thread.js';
+export { briefFile, briefingText, briefTask, buildBriefing, buildFileBriefing, fileBriefingText, BRIEFING_MAX_ITEMS, FILE_BRIEFING_MAX_ITEMS } from './brief/briefing.js';

package/dist/inference/cloud-provider.js

@@ -107,7 +107,7 @@ export class CloudProvider {
         const response = await this.client.messages.create({
             model: this.modelName,
             max_tokens: options?.maxTokens || 4096,
-            temperature: options?.temperature ?? 0.1,
+            ...claudeSampling(this.modelName, options?.temperature ?? 0.1),
             messages: cacheFirstPrompt(toAnthropicMessages(messages)),
             ...(tools.length ? { tools: tools.map(t => ({ name: t.name, description: t.description, input_schema: t.parameters })) } : {}),
             ...(tools.length && options?.toolChoice === 'none' ? { tool_choice: { type: 'none' } } : {}),
@@ -157,7 +157,7 @@ export class CloudProvider {
         const response = await this.client.messages.create({
             model: this.modelName,
             max_tokens: options?.maxTokens || 2048,
-            temperature: options?.temperature || 0.1,
+            ...claudeSampling(this.modelName, options?.temperature ?? 0.1),
             messages: [
                 { role: 'user', content: prompt }
             ],
@@ -203,6 +203,16 @@ export class CloudProvider {
         this.client = null;
     }
 }
+/**
+ * Claude models that take no sampling parameters: Anthropic's model guide lists temperature, top_p and top_k as removed
+ * (a 400) on Fable, Mythos, Opus 5.5, Opus 5, Opus 4.8 and 4.7 and Sonnet 5, and non-default values as a 400 on Sonnet 5.5
+ * and Haiku 5.5; OpenRouter's model list marks temperature unsupported on them too. Older Claude models still take it.
+ */
+const CLAUDE_WITHOUT_SAMPLING = /claude-(?:fable|mythos|opus-5|opus-4-[78]|sonnet-5|haiku-5)/;
+/** The temperature to send a Claude model: none to one that rejects sampling parameters. */
+function claudeSampling(model, temperature) {
+    return CLAUDE_WITHOUT_SAMPLING.test(model) ? {} : { temperature };
+}
 /** The per-call timeout, honoured by both SDKs (their default is minutes, with retries). */
 function requestOptions(options) {
     return options?.timeout ? { timeout: options.timeout } : {};

package/dist/review/backtest-init.d.ts

@@ -11,11 +11,14 @@ export interface PrRounds {
 export declare function roundsForPr(cwd: string, pr: number, config: Config, exec?: Exec, options?: {
     approvedHead?: boolean;
 }): Promise<PrRounds>;
-/** The last `n` merged pull requests, newest merge first. */
-export declare function mergedPrs(cwd: string, n: number, config: Config, exec?: Exec): Promise<Array<{
-    number: number;
-    mergedAt: string;
-}>>;
+/** The last `n` merged pull requests, newest merge first; `incomplete` when the listing could not prove it has them all. */
+export declare function mergedPrs(cwd: string, n: number, config: Config, exec?: Exec): Promise<{
+    prs: Array<{
+        number: number;
+        mergedAt: string;
+    }>;
+    incomplete: boolean;
+}>;
 export declare function scaffoldLedger(cwd: string, pr: number, config: Config, exec?: Exec): Promise<{
     file: string;
     rounds: LedgerRound[];

package/dist/review/backtest-init.js

@@ -46,17 +46,35 @@ export async function roundsForPr(cwd, pr, config, exec = defaultExec, options =
         throw new Error(`pull request ${pr} has no review by a person yet`);
     return { rounds, ...(approved ? { approved } : {}) };
 }
-/** The last `n` merged pull requests, newest merge first. */
+/** How many merged pull requests to list per one wanted, first: gh applies its limit before any sort of ours. */
+const MERGED_OVERFETCH = 4;
+/** The most merged pull requests listed per one wanted before Rigour stops and says the list may be incomplete. */
+const MERGED_OVERFETCH_MAX = 32;
+/** The last `n` merged pull requests, newest merge first; `incomplete` when the listing could not prove it has them all. */
 export async function mergedPrs(cwd, n, config, exec = defaultExec) {
     const env = await githubEnv(cwd, config.review?.github_account ?? process.env.RIGOUR_GITHUB_ACCOUNT, exec);
-    const list = await exec('gh', ['pr', 'list', '--state', 'merged', '--limit', String(n), '--json', 'number,mergedAt'], { cwd, timeoutMs: GH_TIMEOUT_MS, env });
-    if (list.exitCode !== 0)
-        throw new Error(`could not list merged pull requests: ${list.stderr.trim() || 'is gh signed in?'}`);
-    try {
-        return JSON.parse(list.stdout).sort((a, b) => (a.mergedAt < b.mergedAt ? 1 : -1)).slice(0, n);
-    }
-    catch {
-        throw new Error('could not read the list of merged pull requests');
+    // Listed by last update and sorted by merge date here. A merged pull request is updated at or after its merge, so once the
+    // oldest update listed is no later than the Nth merge kept, nothing unlisted can be among the last N (its merge is no later
+    // than its update, which is no later than that). Until then the listing doubles: bots that touch old pull requests after
+    // merge (backports, labels, stale comments) can crowd a window.
+    for (let limit = n * MERGED_OVERFETCH;; limit *= 2) {
+        const list = await exec('gh', ['pr', 'list', '--state', 'merged', '--limit', String(limit), '--search', 'sort:updated-desc', '--json', 'number,mergedAt,updatedAt'], { cwd, timeoutMs: GH_TIMEOUT_MS, env });
+        if (list.exitCode !== 0)
+            throw new Error(`could not list merged pull requests: ${list.stderr.trim() || 'is gh signed in?'}`);
+        let listed;
+        try {
+            listed = JSON.parse(list.stdout);
+        }
+        catch {
+            throw new Error('could not read the list of merged pull requests');
+        }
+        const prs = [...listed].sort((a, b) => (a.mergedAt < b.mergedAt ? 1 : -1)).slice(0, n).map(({ number, mergedAt }) => ({ number, mergedAt }));
+        const oldestUpdate = listed.reduce((min, p) => (p.updatedAt < min ? p.updatedAt : min), listed[0]?.updatedAt ?? '');
+        const complete = listed.length < limit || (prs.length === n && oldestUpdate <= prs[n - 1].mergedAt);
+        if (complete)
+            return { prs, incomplete: false };
+        if (limit >= n * MERGED_OVERFETCH_MAX)
+            return { prs, incomplete: true };
     }
 }
 /** Lines either side of an inline comment that a finding for the same point may land on. */

package/dist/review/backtest-last.js

@@ -17,7 +17,9 @@ const GIT_TIMEOUT_MS = 5 * 60_000;
 export async function backtestLast(cwd, config, options) {
     const exec = options.exec ?? defaultExec;
     const progress = options.progress ?? (() => undefined);
-    const prs = await mergedPrs(cwd, options.last, config, exec);
+    const { prs, incomplete } = await mergedPrs(cwd, options.last, config, exec);
+    if (incomplete)
+        progress(`backtest: warning: the listing could not prove these are the last ${options.last} merged pull requests (many old pull requests were updated after merge); the result may miss recent ones`);
     const rounds = [];
     const skipped = [];
     for (const pr of prs) {

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

@@ -13,6 +13,10 @@ export interface Adapter {
     answer(stdout: string): {
         text: string;
     } & Spend;
+    /** Variables the judge runs with, on top of what it inherits: what keeps a person's own instructions out of it. */
+    env?: Record<string, string>;
+    /** What this judge still reads from outside the repository on this machine (a person's own config), or undefined: said on the record, never hidden. */
+    outsideRepo?(home: string, version: string | undefined): string | undefined;
 }
 /** What a run used: dollars when the CLI reports them (Claude Code), tokens otherwise (Codex reports only tokens). */
 export interface Spend {

package/dist/review/reviewer/adapters.js

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

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

@@ -1,11 +1,12 @@
 import { type Exec } from './exec.js';
-import type { Approval } from './verdict.js';
+import type { Approval, LabelledPoint } from './verdict.js';
 export interface PullRequest {
     number: number;
     state: 'open' | 'closed' | 'merged';
     draft: boolean;
     author: string;
     body: string;
+    title?: string;
 }
 export interface HumanReviews {
     /** As the reviewer reads them, oldest first, inline comments after; `none` when there are none. */
@@ -15,6 +16,8 @@ export interface HumanReviews {
     count: number;
     /** Each person's approval, in time order: every point that person raised before it is settled. */
     approvals: Approval[];
+    /** The points each review put under a severity heading of its own ("Blocking", "Should fix", "Nits"). */
+    labels: LabelledPoint[];
     /** `<login>, <date> (<n> reviews)` of the latest, for the report. */
     label?: string;
 }

package/dist/review/reviewer/inputs.js

@@ -13,7 +13,7 @@ import { GH_TIMEOUT_MS, parseJsonArrays } from './exec.js';
 export function ghFor(cwd, exec, env) {
     return args => exec('gh', args, { cwd, timeoutMs: GH_TIMEOUT_MS, env });
 }
-const PR_FIELDS = 'number,state,isDraft,author,body';
+const PR_FIELDS = 'number,state,isDraft,author,body,title';
 /**
  * The description as it read at `at` (a backtest's review time): GitHub keeps every version in
  * `userContentEdits`, the first being the text at creation. Undefined when it cannot be read, so a
@@ -67,7 +67,7 @@ async function viewPullRequest(gh, selector) {
         const parsed = JSON.parse(result.stdout);
         if (!Number.isInteger(parsed.number))
             return { error: `gh returned no pull request number for ${selector}` };
-        return { pr: { number: parsed.number, state: String(parsed.state ?? '').toLowerCase(), draft: !!parsed.isDraft, author: String(parsed.author?.login ?? ''), body: String(parsed.body ?? '') } };
+        return { pr: { number: parsed.number, state: String(parsed.state ?? '').toLowerCase(), draft: !!parsed.isDraft, author: String(parsed.author?.login ?? ''), body: String(parsed.body ?? ''), ...(parsed.title ? { title: String(parsed.title) } : {}) } };
     }
     catch {
         return { error: `gh returned something other than a pull request for ${selector}: ${result.stdout.slice(0, 120)}` };
@@ -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/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/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;