@rigour-labs/core 6.6.6 → 6.7.0

package/dist/review/fix-scope.js

@@ -0,0 +1,94 @@
+/**
+ * A fix round's scope: the files the branch's own commits changed since the review they answer,
+ * less the files that review cited. A fix round changes what the review asked for and nothing
+ * else, so every extra file is either a point the reviewer never made or work for a follow-up.
+ *
+ * Cited means: the path of an inline comment of that review round (every review a person
+ * submitted on the same commit), or a tracked file the review text names (`src/a.ts:12`,
+ * `a.ts`, a blob link), when the name points at exactly one file. A test of a cited file is in
+ * scope when it sits beside it (or in its `__tests__`). Merges are left out (a merge from main brings main's files, not the round's), and so is
+ * a file the round changed and then put back.
+ */
+import path from 'path';
+import { defaultExec, githubEnv, parseJsonArrays } from './reviewer/exec.js';
+import { findPullRequest, ghFor, isHuman } from './reviewer/inputs.js';
+import { isTestFile } from './test-files.js';
+const GIT_TIMEOUT_MS = 60_000;
+export async function fixScope(cwd, options, exec = defaultExec) {
+    const git = async (args) => exec('git', args, { cwd, timeoutMs: GIT_TIMEOUT_MS });
+    const branch = (await git(['rev-parse', '--abbrev-ref', 'HEAD'])).stdout.trim();
+    const head = (await git(['rev-parse', 'HEAD'])).stdout.trim();
+    if (!head)
+        return { error: 'not a git repository' };
+    const gh = ghFor(cwd, exec, await githubEnv(cwd, options.githubAccount, exec));
+    const found = await findPullRequest(gh, branch, head, options.pr);
+    if (!found.pr)
+        return { error: found.error ?? `no pull request for ${branch}: name one with --scope <number>` };
+    const pr = found.pr;
+    const reviews = await gh(['api', `repos/{owner}/{repo}/pulls/${pr.number}/reviews`, '--paginate']);
+    const comments = await gh(['api', `repos/{owner}/{repo}/pulls/${pr.number}/comments`, '--paginate']);
+    if (reviews.exitCode !== 0 || comments.exitCode !== 0)
+        return { error: `could not read the reviews of pull request ${pr.number}: ${(reviews.stderr || comments.stderr).trim().slice(0, 200)}` };
+    const human = parseJsonArrays(reviews.stdout).filter((r) => isHuman(r, pr.author) && r.commit_id);
+    const target = options.review !== undefined ? human.find((r) => r.id === options.review) : human.at(-1);
+    if (!target)
+        return { error: options.review !== undefined ? `no review ${options.review} by a person on pull request ${pr.number}` : `pull request ${pr.number} has no review by a person yet` };
+    if ((await git(['merge-base', '--is-ancestor', target.commit_id, 'HEAD'])).exitCode !== 0) {
+        return { error: `the reviewed commit ${String(target.commit_id).slice(0, 9)} is not behind HEAD: fetch it, or the branch was rewritten since the review` };
+    }
+    const round = human.filter((r) => r.commit_id === target.commit_id);
+    const roundIds = new Set(round.map((r) => r.id));
+    const inline = parseJsonArrays(comments.stdout).filter((c) => isHuman(c, pr.author) && roundIds.has(c.pull_request_review_id));
+    const tracked = trackedIndex((await git(['ls-files'])).stdout.split('\n').filter(Boolean));
+    const cited = new Set(inline.map((c) => String(c.path)));
+    for (const text of [...round.map((r) => r.body), ...inline.map((c) => c.body)])
+        for (const file of mentioned(String(text ?? ''), tracked))
+            cited.add(file);
+    const changed = await changedByTheRound(git, target.commit_id);
+    const covered = (file) => cited.has(file) || (isTestFile(file) && [...cited].some(c => subject(c) === subject(file)));
+    return {
+        scope: {
+            pr: pr.number,
+            review: { id: target.id, login: target.user.login, submittedAt: String(target.submitted_at ?? ''), commit: target.commit_id },
+            cited: [...cited].sort(),
+            changed,
+            extra: changed.filter(file => !covered(file)),
+        },
+    };
+}
+/** Files the branch's own commits (not its merges) changed since `commit`, and that still differ from it. */
+async function changedByTheRound(git, commit) {
+    const own = new Set((await git(['log', '--first-parent', '--no-merges', '--name-only', '--format=', `${commit}..HEAD`])).stdout.split('\n').filter(Boolean));
+    const differ = (await git(['diff', '--name-only', commit, 'HEAD'])).stdout.split('\n').filter(Boolean);
+    return differ.filter(file => own.has(file)).sort();
+}
+/** Tracked files by base name, built once for every review text. */
+function trackedIndex(files) {
+    const index = new Map();
+    for (const file of files) {
+        const base = path.posix.basename(file);
+        const same = index.get(base);
+        if (same)
+            same.push(file);
+        else
+            index.set(base, [file]);
+    }
+    return index;
+}
+/** Tracked files a review's text names, by path, path suffix or blob link, when the name is unambiguous. */
+function mentioned(text, tracked) {
+    const found = new Set();
+    for (const raw of text.match(/[\w@$./-]+\.[A-Za-z][\w]*/g) ?? []) {
+        const name = raw.replace(/^.*\/blob\/[^/]+\//, '').replace(/^\.\//, '');
+        const matches = (tracked.get(path.posix.basename(name)) ?? []).filter(file => file === name || file.endsWith(`/${name}`));
+        const exact = matches.find(file => file === name);
+        if (exact || matches.length === 1)
+            found.add(exact ?? matches[0]);
+    }
+    return [...found];
+}
+/** What a file is about: `src/a.ts`, `src/a.test.ts` and `src/__tests__/a.spec.ts` are all `src/a`. */
+function subject(file) {
+    const dir = path.posix.dirname(file).replace(/\/(__tests__|tests?)$/, '');
+    return path.posix.join(dir, path.posix.basename(file).replace(/\.(test|spec|test-d)(?=\.)/, '').replace(/\.[^.]+$/, ''));
+}

package/dist/review/fix-scope.test.d.ts

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

package/dist/review/fix-scope.test.js

@@ -0,0 +1,104 @@
+import { execFileSync } from 'child_process';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { fixScope as scopeWith } from './fix-scope.js';
+let repo;
+let reviewed;
+const git = (...args) => execFileSync('git', ['-C', repo, ...args], { encoding: 'utf8' }).trim();
+const write = (rel, body) => {
+    fs.mkdirSync(path.dirname(path.join(repo, rel)), { recursive: true });
+    fs.writeFileSync(path.join(repo, rel), body);
+};
+const commit = (message) => {
+    git('add', '-A');
+    git('commit', '-qm', message);
+};
+const PR = { number: 42, state: 'OPEN', isDraft: false, author: { login: 'author' }, body: '' };
+const user = (login, type = 'User') => ({ login, type });
+let reviews;
+let comments;
+/** Real git; gh answers from `reviews` and `comments`. */
+const exec = async (command, args, options) => {
+    if (command === 'git') {
+        try {
+            return { exitCode: 0, stdout: execFileSync('git', args, { cwd: options.cwd, encoding: 'utf8', stdio: 'pipe' }), stderr: '' };
+        }
+        catch (error) {
+            return { exitCode: 1, stdout: '', stderr: String(error.message) };
+        }
+    }
+    if (args[0] === 'pr')
+        return { exitCode: 0, stdout: JSON.stringify(PR), stderr: '' };
+    if (args[1]?.endsWith('/reviews'))
+        return { exitCode: 0, stdout: JSON.stringify(reviews), stderr: '' };
+    if (args[1]?.endsWith('/comments'))
+        return { exitCode: 0, stdout: JSON.stringify(comments), stderr: '' };
+    return { exitCode: 1, stdout: '', stderr: 'unexpected gh call' };
+};
+beforeEach(() => {
+    repo = fs.mkdtempSync(path.join(os.tmpdir(), 'fix-scope-'));
+    git('init', '-q', '-b', 'main');
+    git('config', 'user.email', 't@example.com');
+    git('config', 'user.name', 't');
+    git('config', 'commit.gpgsign', 'false');
+    for (const file of ['src/job.ts', 'src/job.test.ts', 'src/util.ts', 'src/deep/thing.ts', 'src/other.ts', 'src/temp.ts', 'src/mainside.ts', 'lib/util.ts'])
+        write(file, 'export const x = 1;\n');
+    commit('base');
+    git('checkout', '-qb', 'feature');
+    write('src/job.ts', 'export const x = 2;\n');
+    commit('the change under review');
+    reviewed = git('rev-parse', 'HEAD');
+    reviews = [
+        { id: 1, user: user('ci-bot', 'Bot'), body: 'see src/other.ts', submitted_at: '2026-10-01', commit_id: reviewed },
+        { id: 2, user: user('author'), body: 'I will also tidy src/other.ts', submitted_at: '2026-10-02', commit_id: reviewed },
+        { id: 3, user: user('senior'), body: 'Bound the window in `src/util.ts:4`. The scan in https://github.com/o/r/blob/abc123/src/deep/thing.ts#L3 is quadratic.', submitted_at: '2026-10-03', commit_id: reviewed },
+        { id: 4, user: user('second'), body: '', submitted_at: '2026-10-03', commit_id: reviewed },
+    ];
+    comments = [
+        { id: 9, pull_request_review_id: 4, user: user('second'), path: 'src/job.ts', body: 'Lock before the first read.' },
+        { id: 10, pull_request_review_id: 2, user: user('author'), path: 'src/temp.ts', body: 'my own note' },
+    ];
+});
+afterEach(() => { fs.rmSync(repo, { recursive: true, force: true }); });
+const fixScope = (cwd, named, run) => scopeWith(cwd, { pr: undefined, review: named.review, githubAccount: undefined }, run);
+describe('the scope of a fix round', () => {
+    it('lists the files the round changed that no point of the review cited', async () => {
+        for (const file of ['src/job.ts', 'src/job.test.ts', 'src/util.ts', 'src/deep/thing.ts', 'src/other.ts'])
+            write(file, 'export const x = 3;\n');
+        commit('fix round');
+        write('src/temp.ts', 'export const x = 9;\n');
+        commit('try something');
+        write('src/temp.ts', 'export const x = 1;\n');
+        commit('put it back');
+        git('checkout', '-q', 'main');
+        write('src/mainside.ts', 'export const x = 4;\n');
+        commit('main moves on');
+        git('checkout', '-q', 'feature');
+        git('merge', '-q', '--no-edit', 'main');
+        const { scope, error } = await fixScope(repo, {}, exec);
+        expect(error).toBeUndefined();
+        expect(scope).toMatchObject({ pr: 42, review: { id: 4, login: 'second', commit: reviewed } });
+        expect(scope.cited).toEqual(['src/deep/thing.ts', 'src/job.ts', 'src/util.ts']);
+        expect(scope.changed).toEqual(['src/deep/thing.ts', 'src/job.test.ts', 'src/job.ts', 'src/other.ts', 'src/util.ts']);
+        expect(scope.extra).toEqual(['src/other.ts']);
+    });
+    it('takes a named review as the round, and an ambiguous file name cites nothing', async () => {
+        write('src/job.ts', 'export const x = 3;\n');
+        commit('first fix round');
+        reviews.push({ id: 5, user: user('senior'), body: 'and util.ts too', submitted_at: '2026-10-04', commit_id: git('rev-parse', 'HEAD') });
+        write('src/util.ts', 'export const x = 3;\n');
+        commit('second fix round');
+        const named = await fixScope(repo, { review: 5 }, exec);
+        expect(named.scope.cited).toEqual([]);
+        expect(named.scope.extra).toEqual(['src/util.ts']);
+    });
+    it('says why it cannot answer', async () => {
+        expect((await fixScope(repo, { review: 99 }, exec)).error).toBe('no review 99 by a person on pull request 42');
+        reviews = reviews.filter((r) => r.user.type === 'Bot');
+        expect((await fixScope(repo, {}, exec)).error).toBe('pull request 42 has no review by a person yet');
+        reviews = [{ id: 3, user: user('senior'), body: 'x', submitted_at: '2026-10-03', commit_id: 'f'.repeat(40) }];
+        expect((await fixScope(repo, {}, exec)).error).toMatch(/^the reviewed commit fffffffff is not behind HEAD/);
+    });
+});

package/dist/review/lint-overlay.js

@@ -59,7 +59,7 @@ export default [
     },
     { files: ['**/*.svelte'], rules: typed },
     // A test fake deliberately covers cases the types call impossible.
-    { files: ['**/*.test.ts', '**/*.spec.ts', '**/*.svelte.test.ts', 'tests/**', 'test/**', '**/__tests__/**'], rules: { '@typescript-eslint/no-unnecessary-condition': 'off', '@typescript-eslint/no-floating-promises': 'off' } },
+    { files: ['**/*.test.ts', '**/*.spec.ts', '**/*.test-d.ts', '**/*.svelte.test.ts', 'tests/**', 'test/**', 'test-d/**', '**/__tests__/**', '**/__mocks__/**'], rules: { '@typescript-eslint/no-unnecessary-condition': 'off', '@typescript-eslint/no-floating-promises': 'off' } },
 ];
 `);
     return file;

package/dist/review/orphan-files.js

@@ -16,9 +16,10 @@ import micromatch from 'micromatch';
 import { addedFiles } from './migration-order.js';
 import { sourceStem } from './package-layout.js';
 import { ownOutputs } from './unused-exports.js';
+import { isTestFile } from './test-files.js';
 const GIT_TIMEOUT_MS = 10_000;
 const CODE = /\.(ts|tsx|js|jsx|mjs|cjs|svelte)$/;
-const FOUND_BY_RUNNER = /(^|\/)\+[^/]+$|(^|\/)hooks(\.server|\.client)?\.(ts|js)$|^netlify\/functions\/|^src\/params\/|\.(test|spec|e2e)\.[a-z]+$|\.d\.ts$|^(tests?|e2e|__tests__|migrations|supabase)\/|\.config\.[a-z]+$|^\./;
+const FOUND_BY_RUNNER = /(^|\/)\+[^/]+$|(^|\/)hooks(\.server|\.client)?\.(ts|js)$|^netlify\/functions\/|^src\/params\/|\.d\.ts$|^(migrations|supabase)\/|\.config\.[a-z]+$|^\./;
 /** Files that can run or import another: code, package.json, CI and config. */
 const REFERRER = /\.(ts|tsx|js|jsx|mjs|cjs|svelte|json|ya?ml|toml|sh)$/;
 /** Lockfiles and generated bundles name no source file and can be megabytes. */
@@ -32,7 +33,7 @@ export function orphanFileFailures(cwd, diff, config) {
     const settings = config.gates.orphan_files;
     if (!settings?.enabled)
         return [];
-    const added = addedFiles(diff).filter(file => CODE.test(file) && !FOUND_BY_RUNNER.test(file) && !BUILD_OUTPUT.test(file) && !micromatch.isMatch(file, settings.allow));
+    const added = addedFiles(diff).filter(file => CODE.test(file) && !FOUND_BY_RUNNER.test(file) && !isTestFile(file) && !BUILD_OUTPUT.test(file) && !micromatch.isMatch(file, settings.allow));
     if (added.length === 0)
         return [];
     const excluded = ownOutputs(config);

package/dist/review/partial-wiring.js

@@ -8,8 +8,10 @@
 import { spawnSync } from 'child_process';
 import fs from 'fs';
 import path from 'path';
+import { isTestFile } from './test-files.js';
 const MOUNTING = /\.(svelte|tsx|jsx)$/;
-const SKIPPED = /\.(test|spec|stories)\.|(^|\/)(__tests__|tests?)\//;
+/** Tests and stories mount components to exercise them, not to wire behaviour. */
+const skipped = (file) => isTestFile(file) || /\.stories\./.test(file);
 const GIT_TIMEOUT_MS = 10_000;
 export function partialWiringFailures(cwd, changedLines, config) {
     if (!config.gates.change_sweep?.enabled)
@@ -17,7 +19,7 @@ export function partialWiringFailures(cwd, changedLines, config) {
     const failures = [];
     const seen = new Set();
     for (const [file, lines] of Object.entries(changedLines)) {
-        if (!MOUNTING.test(file) || SKIPPED.test(file) || lines.size === 0)
+        if (!MOUNTING.test(file) || skipped(file) || lines.size === 0)
             continue;
         for (const mount of mountsIn(cwd, file)) {
             for (const { prop, line } of addedProps(cwd, mount, lines)) {
@@ -75,7 +77,7 @@ function mountsOf(cwd, component) {
     if (cached)
         return cached;
     const grep = spawnSync('git', ['grep', '--untracked', '-l', '-F', '-e', `<${component}`], { cwd, encoding: 'utf8', timeout: GIT_TIMEOUT_MS });
-    const files = grep.status === 0 ? grep.stdout.split('\n').filter(f => f && MOUNTING.test(f) && !SKIPPED.test(f)) : [];
+    const files = grep.status === 0 ? grep.stdout.split('\n').filter(f => f && MOUNTING.test(f) && !skipped(f)) : [];
     const mounts = files.flatMap(file => mountsIn(cwd, file).filter(m => m.component === component));
     mountCache.set(key, mounts);
     return mounts;

package/dist/review/query-patterns.js

@@ -14,11 +14,12 @@
  *
  * Read from the syntax tree, so a comment or string never matches.
  */
+import { isTestFile } from './test-files.js';
 import fs from 'fs';
 import path from 'path';
 import ts from 'typescript';
 const CODE = /\.(ts|tsx|js|jsx|mjs|cjs)$/;
-const SKIPPED = /\.(test|spec)\.|\.d\.ts$|(^|\/)(__tests__|tests?|e2e)\//;
+const DECLARATIONS = /\.d\.ts$/;
 const TIME_COLUMN = /(_at|_on|At|On|date|Date|time|Time|timestamp|Timestamp)$|^(at|since|until|created|updated)$/;
 const LOWER = new Set(['gt', 'gte']);
 const UPPER = new Set(['lt', 'lte']);
@@ -27,7 +28,7 @@ export function queryPatternFailures(cwd, changedLines, config) {
         return [];
     const failures = [];
     for (const [file, lines] of Object.entries(changedLines)) {
-        if (!CODE.test(file) || SKIPPED.test(file) || lines.size === 0)
+        if (!CODE.test(file) || DECLARATIONS.test(file) || isTestFile(file) || lines.size === 0)
             continue;
         let text;
         try {

package/dist/review/review.js

@@ -38,7 +38,8 @@ export async function reviewChange(input) {
         return { status: 'PASS', findings: [], fileFindings: [], contextFindings: [], advisory: [], muted: 0, dismissed: 0, dismissedByGate: {}, unlocated: 0, excludedOutsideChangedLines: 0, preexisting: 0, changedLines, report: null, gateErrors: [], controlFilesChanged: controlFiles(diff), hints: [] };
     }
     const deep = input.deep ? { ...input.deep, focusLines: changedLinesByFile(changedLines), removedLines: removedByFile(diff), diff } : undefined;
-    const report = await new GateRunner(input.config).run(input.cwd, await normalizeScopePatterns(input.cwd, targets), deep);
+    // The team's `commands:` run at push (toolchain.ts), where a failure blocks; here they would only cost time.
+    const report = await new GateRunner({ ...input.config, commands: {} }).run(input.cwd, await normalizeScopePatterns(input.cwd, targets), deep);
     const preexisting = await dropPreexisting(input, report, targets);
     if (input.diffTests && deep)
         report.failures.push(...await diffTestFailures(input.cwd, input.source, deep));

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

@@ -1,4 +1,4 @@
-import type { Exec } from './exec.js';
+import { type Exec } from './exec.js';
 export type ReviewerName = 'claude' | 'cursor' | 'codex';
 export type Vendor = 'anthropic' | 'cursor' | 'openai';
 export type ReviewMode = 'single' | 'cross' | 'full';
@@ -7,11 +7,19 @@ export interface Adapter {
     binary: string;
     /** The command line for one review: the prompt is passed as text, never through a shell. */
     args(prompt: string, model: string | undefined): string[];
-    /** The reviewer's final message and, when the CLI reports it, what the run cost. */
+    /** The reviewer's final message and, when the CLI reports them, what the run cost and the tokens it used. */
     answer(stdout: string): {
         text: string;
-        costUsd?: number;
-    };
+    } & Spend;
+}
+/** What a run used: dollars when the CLI reports them (Claude Code), tokens otherwise (Codex reports only tokens). */
+export interface Spend {
+    costUsd?: number;
+    tokens?: Tokens;
+}
+export interface Tokens {
+    input: number;
+    output: number;
 }
 export declare const ADAPTERS: Record<ReviewerName, Adapter>;
 export declare function isReviewerName(name: string): name is ReviewerName;
@@ -29,7 +37,15 @@ export declare function resolveAdapter(adapter: Adapter, cwd: string, exec: Exec
 export declare function vendorsOf(trailers: string): Set<Vendor>;
 /**
  * The reviewers a run uses. single: the first available of the list. cross: the first available
- * whose vendor is not on the trailers, else the first available. full: that one plus the first
- * available of another vendor. Empty when none is installed.
+ * whose vendor is not on the trailers, else the first available. full: that one plus the next
+ * available of each other vendor, up to `judges`. Empty when none is installed.
  */
-export declare function selectReviewers(candidates: ReviewerName[], mode: ReviewMode, authors: Set<Vendor>, available: Set<ReviewerName>): ReviewerName[];
+export declare function selectReviewers(candidates: ReviewerName[], mode: ReviewMode, authors: Set<Vendor>, available: Set<ReviewerName>, judges?: number): ReviewerName[];
+/** Every reviewer Rigour can run, and whether this machine has it: what bounds the judges of a panel. */
+export declare function reviewerAvailability(cwd: string, exec?: Exec): Promise<Array<{
+    name: ReviewerName;
+    vendor: Vendor;
+    binary: string;
+    installed: boolean;
+    version?: string;
+}>>;

package/dist/review/reviewer/adapters.js

@@ -9,6 +9,8 @@
 import fs from 'fs';
 import os from 'os';
 import path from 'path';
+import { defaultExec } from './exec.js';
+const n = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : 0);
 const READ_ONLY_TOOLS = ['Read', 'Grep', 'Glob', 'Bash(git diff:*)', 'Bash(git show:*)', 'Bash(git log:*)', 'Bash(git grep:*)'];
 export const ADAPTERS = {
     claude: {
@@ -29,7 +31,12 @@ export const ADAPTERS = {
         answer: stdout => {
             try {
                 const parsed = JSON.parse(stdout);
-                return { text: String(parsed.result ?? ''), ...(typeof parsed.total_cost_usd === 'number' ? { costUsd: parsed.total_cost_usd } : {}) };
+                const usage = parsed.usage;
+                return {
+                    text: String(parsed.result ?? ''),
+                    ...(typeof parsed.total_cost_usd === 'number' ? { costUsd: parsed.total_cost_usd } : {}),
+                    ...(usage ? { tokens: { input: n(usage.input_tokens) + n(usage.cache_read_input_tokens) + n(usage.cache_creation_input_tokens), output: n(usage.output_tokens) } } : {}),
+                };
             }
             catch {
                 return { text: stdout };
@@ -56,20 +63,25 @@ export const ADAPTERS = {
         binary: 'codex',
         args: (prompt, model) => ['exec', '--sandbox', 'read-only', '--json', ...(model ? ['--model', model] : []), '-c', 'model_reasoning_effort=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.
+        // `turn.completed` carries the tokens (Codex reports no dollars).
         answer: stdout => {
             let text = '';
+            let tokens;
             for (const line of stdout.split('\n').filter(Boolean)) {
                 try {
                     const event = JSON.parse(line);
                     const candidate = event?.item?.text ?? event?.msg?.message ?? event?.text;
                     if (typeof candidate === 'string')
                         text = candidate;
+                    if (event?.type === 'turn.completed' && event.usage)
+                        tokens = { input: n(event.usage.input_tokens), output: n(event.usage.output_tokens) + n(event.usage.reasoning_output_tokens) };
                 }
                 catch {
                     // not an event line
                 }
             }
-            return { text: text || stdout };
+            return { text: text || stdout, ...(tokens ? { tokens } : {}) };
         },
     },
 };
@@ -139,10 +151,10 @@ export function vendorsOf(trailers) {
 }
 /**
  * The reviewers a run uses. single: the first available of the list. cross: the first available
- * whose vendor is not on the trailers, else the first available. full: that one plus the first
- * available of another vendor. Empty when none is installed.
+ * whose vendor is not on the trailers, else the first available. full: that one plus the next
+ * available of each other vendor, up to `judges`. Empty when none is installed.
  */
-export function selectReviewers(candidates, mode, authors, available) {
+export function selectReviewers(candidates, mode, authors, available, judges = 2) {
     const installed = candidates.filter(name => available.has(name));
     if (installed.length === 0)
         return [];
@@ -151,6 +163,19 @@ export function selectReviewers(candidates, mode, authors, available) {
         first = installed.find(name => !authors.has(ADAPTERS[name].vendor)) ?? first;
     if (mode !== 'full')
         return [first];
-    const second = installed.find(name => name !== first && ADAPTERS[name].vendor !== ADAPTERS[first].vendor);
-    return second ? [first, second] : [first];
+    const chosen = [first];
+    for (const name of installed) {
+        if (chosen.length >= judges)
+            break;
+        if (!chosen.some(c => ADAPTERS[c].vendor === ADAPTERS[name].vendor))
+            chosen.push(name);
+    }
+    return chosen;
+}
+/** Every reviewer Rigour can run, and whether this machine has it: what bounds the judges of a panel. */
+export async function reviewerAvailability(cwd, exec = defaultExec) {
+    return Promise.all(Object.keys(ADAPTERS).map(async (name) => {
+        const found = await resolveAdapter(ADAPTERS[name], cwd, exec);
+        return { name, vendor: ADAPTERS[name].vendor, binary: ADAPTERS[name].binary, installed: !!found, ...(found ? { version: found.version } : {}) };
+    }));
 }

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

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

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

@@ -0,0 +1,23 @@
+import { describe, expect, it } from 'vitest';
+import { ADAPTERS } from './adapters.js';
+/** A real `codex exec --json` run (codex-cli 0.160.1), the warning's path shortened: the shape the adapter must read. */
+const CODEX = [
+    '{"type":"thread.started","thread_id":"01a11477-f9fd-7472-8d31-5863de4cbbdb"}',
+    '{"type":"item.completed","item":{"id":"item_0","type":"error","message":"Codex is ignoring 1 unrecognized configuration setting. Check for typos or deprecated settings.\\n  user (~/.codex/config.toml)"}}',
+    '{"type":"turn.started"}',
+    '{"type":"item.completed","item":{"id":"item_2","type":"agent_message","text":"{\\"answers\\":[{\\"id\\":\\"a1\\",\\"call\\":\\"unsure\\",\\"evidence\\":\\"none\\"}]}"}}',
+    '{"type":"turn.completed","usage":{"input_tokens":26565,"cached_input_tokens":13184,"cache_write_input_tokens":0,"output_tokens":24,"reasoning_output_tokens":0}}',
+].join('\n');
+describe('reading an agent CLI\'s answer', () => {
+    it('takes Codex\'s last agent message, never a warning, and its tokens', () => {
+        expect(ADAPTERS.codex.answer(CODEX)).toEqual({ text: '{"answers":[{"id":"a1","call":"unsure","evidence":"none"}]}', tokens: { input: 26565, output: 24 } });
+    });
+    it('takes Claude Code\'s result, its cost and its tokens', () => {
+        const out = JSON.stringify({ result: '{"prior_points":[]}', total_cost_usd: 0.42, usage: { input_tokens: 10, cache_read_input_tokens: 900, cache_creation_input_tokens: 90, output_tokens: 300 } });
+        expect(ADAPTERS.claude.answer(out)).toEqual({ text: '{"prior_points":[]}', costUsd: 0.42, tokens: { input: 1000, output: 300 } });
+    });
+    it('falls back to the raw output when it is not what the CLI usually prints', () => {
+        expect(ADAPTERS.claude.answer('not json')).toEqual({ text: 'not json' });
+        expect(ADAPTERS.codex.answer('plain text')).toEqual({ text: 'plain text' });
+    });
+});

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

@@ -1,6 +1,7 @@
 import type { Config } from '../../types/index.js';
-import { type ReviewerResult } from '../reviewer.js';
+import { type ModeRecord, type ReviewerResult } from '../reviewer.js';
 import { type Exec } from './exec.js';
+import { type DaySpend, type ReviewAttempt } from './store.js';
 import { type OpenItem } from './verdict.js';
 export interface BackgroundJob {
     head: string;
@@ -21,12 +22,18 @@ export interface ReviewStatus {
         pid: number;
         head: string;
     };
+    /** What the reviewer spent today in this repository: the count the daily caps are checked against. */
+    today: DaySpend;
+    /** The last review that ended without a verdict, when it is newer than the last verdict. */
+    attempt?: ReviewAttempt;
     /** The last verdict recorded for the branch. */
     last?: {
         head: string;
         mode: 'full' | 'delta';
         at: string;
         open: OpenItem[];
+        ran?: ModeRecord;
+        disputed: OpenItem[];
     };
     log?: string;
 }

package/dist/review/reviewer/background.js

@@ -11,8 +11,9 @@ import { spawn, spawnSync } from 'child_process';
 import fs from 'fs';
 import path from 'path';
 import { reviewChange } from '../review.js';
-import { runReviewer } from '../reviewer.js';
+import { pushReviewSkip, runReviewer } from '../reviewer.js';
 import { defaultExec, GH_TIMEOUT_MS } from './exec.js';
+import { dismissedAs, readReviewDismissals, reviewerInputs } from './context.js';
 import { VerdictStore } from './store.js';
 import { itemLine } from './verdict.js';
 /**
@@ -38,6 +39,13 @@ export async function backgroundReview(cwd, job, config, exec = defaultExec, log
     const store = await VerdictStore.open(cwd, exec);
     if (!store)
         throw new Error(`${cwd} is not a repository`);
+    const skip = await pushReviewSkip(cwd, job.branch, job.head, config, exec);
+    if (skip) {
+        store.recordAttempt(job.branch, { head: job.head, outcome: 'skipped', reason: skip, at: new Date().toISOString() });
+        log(`review of ${job.head.slice(0, 9)}: skipped (${skip})`);
+        clearPid(store, job.branch);
+        return { outcome: 'skipped', items: [], unverified: [], resolved: [], answerInReply: [], notes: [], disputed: [], dropped: [], dismissed: [], reason: skip, reviewers: [], cached: false };
+    }
     const worktree = store.worktreeDir(job.head);
     const added = await exec('git', ['worktree', 'add', '--detach', worktree, job.head], { cwd, timeoutMs: 5 * GH_TIMEOUT_MS });
     if (added.exitCode !== 0 && !fs.existsSync(path.join(worktree, '.git')))
@@ -45,8 +53,9 @@ export async function backgroundReview(cwd, job, config, exec = defaultExec, log
     try {
         shareDependencies(cwd, worktree);
         // The typed checks' hints (a nested scan, a value that only leaves through serialisation) are the reviewer's candidates to confirm.
-        const hints = (await reviewChange({ cwd: worktree, config, source: { mode: 'base', base: job.base }, typed: true })).hints.join('\n');
-        const result = await runReviewer(worktree, job.base, config, exec, log, { trigger: 'push', branch: job.branch, hints });
+        const review = await reviewChange({ cwd: worktree, config, source: { mode: 'base', base: job.base }, typed: true });
+        // The worktree has the commit, not the team's untracked state: dismissals and reviewed functions come from the checkout.
+        const result = await runReviewer(worktree, job.base, config, exec, log, { trigger: 'push', branch: job.branch, stateRoot: cwd, ...reviewerInputs(review) });
         log(`review of ${job.head.slice(0, 9)}: ${result.outcome}${result.reason ? ` (${result.reason})` : ''}${result.items.length ? `, ${result.items.length} open item(s)` : ''}`);
         for (const item of result.items)
             log(`  ${itemLine(item)}`);
@@ -55,9 +64,7 @@ export async function backgroundReview(cwd, job, config, exec = defaultExec, log
     }
     finally {
         await exec('git', ['worktree', 'remove', '--force', worktree], { cwd, timeoutMs: 5 * GH_TIMEOUT_MS });
-        const pidFile = store.branchFile(job.branch, 'pid');
-        if (fs.existsSync(pidFile) && fs.readFileSync(pidFile, 'utf8').startsWith(`${process.pid} `))
-            fs.unlinkSync(pidFile);
+        clearPid(store, job.branch);
     }
 }
 /** What the background reviewer has done for a branch: running, the last verdict and its open items. */
@@ -65,13 +72,25 @@ export async function reviewStatus(cwd, branch, exec = defaultExec) {
     const store = await VerdictStore.open(cwd, exec);
     if (!store)
         return undefined;
-    const status = { branch };
+    const status = { branch, today: store.spend() };
     const running = runningJob(store, branch);
     if (running)
         status.running = running;
     const state = store.branchState(branch);
-    if (state)
-        status.last = { head: state.head, mode: state.mode, at: state.at, open: store.readJson(store.openPath(state.verdict)) ?? [] };
+    const attempt = store.attempt(branch);
+    if (attempt && (!state || attempt.at > state.at))
+        status.attempt = attempt;
+    if (state) {
+        const verdict = store.readJson(state.verdict);
+        const dismissals = readReviewDismissals(cwd);
+        status.last = {
+            head: state.head, mode: state.mode, at: state.at,
+            // A finding dismissed since this verdict is not work any more: it leaves the list now, not at the next review.
+            open: (store.readJson(store.openPath(state.verdict)) ?? []).filter(item => !dismissedAs(item, dismissals)),
+            ...(verdict?.inputs?.mode ? { ran: verdict.inputs.mode } : {}),
+            disputed: (verdict?.panel?.items ?? []).filter(d => d.status === 'disputed').map(d => ({ ...d.item, reviewer: d.judges.join('+') })),
+        };
+    }
     const log = store.branchFile(branch, 'log');
     if (fs.existsSync(log))
         status.log = log;
@@ -126,3 +145,9 @@ function notify(message) {
     else if (process.platform === 'linux')
         spawnSync('notify-send', ['Rigour', safe], { stdio: 'ignore', timeout: 5000 });
 }
+/** This process's pid record for the branch, removed when it ends (a newer job's record is left alone). */
+function clearPid(store, branch) {
+    const pidFile = store.branchFile(branch, 'pid');
+    if (fs.existsSync(pidFile) && fs.readFileSync(pidFile, 'utf8').startsWith(`${process.pid} `))
+        fs.unlinkSync(pidFile);
+}

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

@@ -11,8 +11,8 @@ let bin;
 const git = (...args) => execFileSync('git', ['-C', repo, ...args], { encoding: 'utf8' }).trim();
 const config = ConfigSchema.parse({ version: 1, review: { reviewer: { enabled: true } } });
 const originalPath = process.env.PATH;
-const PR = { number: 7, state: 'OPEN', isDraft: false, author: { login: 'author' }, body: 'desc' };
-const VERDICT = JSON.stringify({ prior_points: [], redundant: [], reads: [], scans: [], merge_impact: [], findings: [{ class: 'correctness', file: 'src/job.ts', line: 1, issue: 'never locks' }], carried: [], resolved_previous: [] });
+let PR = { number: 7, state: 'OPEN', isDraft: false, author: { login: 'author' }, body: 'desc' };
+const VERDICT = JSON.stringify({ prior_points: [], redundant: [], reads: [], scans: [], merge_impact: [], findings: [{ class: 'correctness', file: 'src/job.ts', line: 1, issue: 'never locks', consequence: 'a second run reads stale rows' }], carried: [], resolved_previous: [] });
 /** Real git; a pull request on the branch; a claude that answers one finding. */
 const exec = async (command, args, options) => {
     if (command === 'git') {
@@ -76,6 +76,20 @@ describe('the background review', () => {
         expect(status).toMatchObject({ branch: 'feature', last: { head, mode: 'full', open: [expect.objectContaining({ issue: 'never locks' })] } });
         expect(status?.running).toBeUndefined();
     });
+    it('asks whether a review is due before checking anything out, and the status says why it was skipped', async () => {
+        PR = { ...PR, isDraft: true };
+        try {
+            const head = git('rev-parse', 'HEAD');
+            const result = await backgroundReview(repo, { head, branch: 'feature', base: 'main' }, config, exec, () => undefined);
+            expect(result).toMatchObject({ outcome: 'skipped', reason: expect.stringContaining('is a draft') });
+            const store = (await VerdictStore.open(repo, exec));
+            expect(fs.existsSync(store.worktreeDir(head))).toBe(false); // never checked out
+            expect((await reviewStatus(repo, 'feature', exec))?.attempt).toMatchObject({ head, outcome: 'skipped', reason: expect.stringContaining('is a draft') });
+        }
+        finally {
+            PR = { ...PR, isDraft: false };
+        }
+    });
     it('starts detached with a pid the status reports, and a newer start for the branch ends the older one', async () => {
         const head = git('rev-parse', 'HEAD');
         const sleeper = [process.execPath, '-e', 'setTimeout(() => {}, 20000)'];