@rigour-labs/core 6.6.6 → 6.7.1

package/dist/inference/cloud-provider.js

@@ -1,8 +1,8 @@
 import { priceTokens } from './pricing.js';
 /** Default models per provider (user can override via model_name) */
 const DEFAULT_MODELS = {
-    claude: 'claude-opus-4-6',
-    anthropic: 'claude-sonnet-4-6',
+    claude: 'claude-sonnet-5-5',
+    anthropic: 'claude-sonnet-5-5',
     openai: 'gpt-5-mini',
     gemini: 'gemini-2.5-flash',
     groq: 'llama-3.3-70b-versatile',
@@ -24,6 +24,7 @@ const DEFAULT_BASE_URLS = {
     fireworks: 'https://api.fireworks.ai/inference/v1',
     deepseek: 'https://api.deepseek.com/v1',
     perplexity: 'https://api.perplexity.ai',
+    openrouter: 'https://openrouter.ai/api/v1',
     ollama: 'http://localhost:11434/v1',
     lmstudio: 'http://localhost:1234/v1',
 };
@@ -43,7 +44,11 @@ export class CloudProvider {
         this.providerName = providerName.toLowerCase();
         this.apiKey = apiKey.trim();
         this.baseUrl = options?.baseUrl;
-        this.modelName = options?.modelName || DEFAULT_MODELS[this.providerName] || 'gpt-4o-mini';
+        const model = options?.modelName || DEFAULT_MODELS[this.providerName];
+        // No guessed model: a default that does not exist on this provider fails every call, or bills the wrong one.
+        if (!model)
+            throw new Error(`No default model for provider "${this.providerName}": pass --model-name (for example rigour settings set deep.defaultModel <name>).`);
+        this.modelName = model;
         this.isClaude = this.providerName === 'claude' || this.providerName === 'anthropic';
         this.name = `cloud-${this.providerName}`;
     }
@@ -54,7 +59,8 @@ export class CloudProvider {
         if (this.isClaude) {
             try {
                 const { default: Anthropic } = await import('@anthropic-ai/sdk');
-                this.client = new Anthropic({ apiKey: this.apiKey });
+                // A base URL given for Claude (a proxy, a gateway) is honoured like any other provider's.
+                this.client = new Anthropic({ apiKey: this.apiKey, ...(this.baseUrl ? { baseURL: this.baseUrl } : {}) });
                 onProgress?.(`✓ ${this.providerName} API connected (model: ${this.modelName})`);
             }
             catch {
@@ -68,7 +74,7 @@ export class CloudProvider {
             // No limitations. User's key, user's choice.
             try {
                 const { default: OpenAI } = await import('openai');
-                const baseURL = this.baseUrl || DEFAULT_BASE_URLS[this.providerName] || undefined;
+                const baseURL = this.endpoint() || undefined;
                 this.client = new OpenAI({
                     apiKey: this.apiKey,
                     ...(baseURL ? { baseURL } : {}),
@@ -187,7 +193,11 @@ export class CloudProvider {
         return this.isOpenRouter() && /(^|\/)(anthropic\/|claude)/i.test(this.modelName);
     }
     isOpenRouter() {
-        return /(^|\.)openrouter\.ai(\/|$)/.test((this.baseUrl || '').replace(/^https?:\/\//, ''));
+        return /(^|\.)openrouter\.ai(\/|$)/.test(this.endpoint().replace(/^https?:\/\//, ''));
+    }
+    /** The API base URL: the one given, else the provider's own. */
+    endpoint() {
+        return this.baseUrl || DEFAULT_BASE_URLS[this.providerName] || '';
     }
     dispose() {
         this.client = null;

package/dist/inference/cloud-provider.test.js

@@ -8,6 +8,10 @@ vi.mock('openai', () => ({
 }));
 vi.mock('@anthropic-ai/sdk', () => ({
     default: class {
+        options;
+        constructor(options) {
+            this.options = options;
+        }
         messages = { create: anthropicCreate };
     },
 }));
@@ -18,6 +22,23 @@ beforeEach(() => {
     anthropicCreate.mockReset();
 });
 describe('CloudProvider', () => {
+    it('names no model it cannot know: a provider without a default needs one', () => {
+        expect(() => new CloudProvider('somecloud', 'k')).toThrow(/pass --model-name/);
+        expect(() => new CloudProvider('somecloud', 'k', { modelName: 'x' })).not.toThrow();
+    });
+    it('sends Claude calls to a base URL when one is given', async () => {
+        anthropicCreate.mockResolvedValue({ content: [{ type: 'text', text: 'ok' }], usage: { input_tokens: 1, output_tokens: 1 } });
+        const provider = new CloudProvider('claude', 'k', { modelName: 'claude-sonnet-5-5', baseUrl: 'https://gateway.example/anthropic' });
+        await provider.setup();
+        expect(provider.client.options).toMatchObject({ baseURL: 'https://gateway.example/anthropic' });
+    });
+    it('sends OpenRouter calls to OpenRouter, asking it to report their cost', async () => {
+        openaiCreate.mockResolvedValue({ choices: [{ message: { content: 'ok' } }], usage: { prompt_tokens: 1, completion_tokens: 1 } });
+        const provider = new CloudProvider('openrouter', 'k', { modelName: 'anthropic/claude-sonnet-5.5' });
+        await provider.setup();
+        await provider.analyze('prompt');
+        expect(openaiCreate.mock.calls[0][0]).toMatchObject({ usage: { include: true } });
+    });
     it('passes the per-call timeout to the SDK request', async () => {
         anthropicCreate.mockResolvedValue({ content: [{ type: 'text', text: 'ok' }], usage: { input_tokens: 10, output_tokens: 2 } });
         const provider = new CloudProvider('claude', 'k', { modelName: 'claude-sonnet-5-5' });

package/dist/pattern-index/embeddings.d.ts

@@ -1,8 +1,3 @@
-/**
- * Semantic Embedding Service
- *
- * Uses Transformers.js for local vector embeddings.
- */
 /**
  * Generate an embedding for a piece of text.
  */

package/dist/pattern-index/embeddings.js

@@ -1,8 +1,10 @@
 /**
  * Semantic Embedding Service
  *
- * Uses Transformers.js for local vector embeddings.
+ * Uses Transformers.js for local vector embeddings, loaded from wherever it is installed
+ * (semantic-runtime.ts). Without it, embeddings are empty and callers fall back to keywords.
  */
+import { loadTransformers } from './semantic-runtime.js';
 /**
  * Singleton for the embedding pipeline to avoid re-loading the model.
  */
@@ -26,10 +28,15 @@ async function getPipeline() {
         return null;
     if (!embeddingPipeline) {
         try {
-            // Dynamic import to isolate native dependency issues (like sharp)
-            const { pipeline } = await import('@xenova/transformers');
+            // Loaded where it is installed; never a dependency of the npm package (semantic-runtime.ts).
+            const transformers = await loadTransformers();
+            if (!transformers) {
+                // Not installed: keyword matching, said once by `rigour doctor`, not on every run.
+                embeddingUnavailable = true;
+                return null;
+            }
             // Using a compact but high-quality model for local embeddings
-            embeddingPipeline = await pipeline('feature-extraction', 'Xenova/all-MiniLM-L6-v2');
+            embeddingPipeline = await transformers.pipeline('feature-extraction', 'Xenova/all-MiniLM-L6-v2');
         }
         catch (error) {
             embeddingUnavailable = true;

package/dist/pattern-index/semantic-runtime.d.ts

@@ -0,0 +1,10 @@
+/** The version installed by `rigour setup`; the model it loads is fetched once on first use. */
+export declare const TRANSFORMERS_SPEC = "@xenova/transformers@2.17.2";
+/** Rigour's own copy, shared by every Rigour version on the machine (per profile home). */
+export declare function semanticRuntimeDir(): string;
+/** Where the library resolves from, or undefined when it is not installed anywhere Rigour looks. */
+export declare function locateTransformers(cwd?: string): string | undefined;
+/** The library's module, loaded from wherever it is installed. */
+export declare function loadTransformers(cwd?: string): Promise<any | undefined>;
+/** Whether Rigour's home has its own copy (what `rigour setup` installs). */
+export declare function semanticRuntimeInstalled(): boolean;

package/dist/pattern-index/semantic-runtime.js

@@ -0,0 +1,46 @@
+/**
+ * Where the local embedding library (`@xenova/transformers`, with its ONNX runtime about 230 MB)
+ * comes from. It is not a dependency of the npm package: npm installed it again for every
+ * version a hook pinned, so a machine kept one copy per Rigour version. `rigour setup` installs it
+ * once into Rigour's home, where every version finds it.
+ *
+ * Search order: next to Rigour itself (a checkout, or a project that installs Rigour and the
+ * library as devDependencies), the project being worked on, then Rigour's home. Without it,
+ * recall and pattern matching fall back to keywords, which find far less (on the committed eval
+ * sets, 6% of memories and 20% of existing helpers, against 81% and 93% by meaning).
+ */
+import { createRequire } from 'module';
+import fs from 'fs';
+import path from 'path';
+import { pathToFileURL } from 'url';
+import { rigourUserDir } from '../utils/user-state.js';
+/** The version installed by `rigour setup`; the model it loads is fetched once on first use. */
+export const TRANSFORMERS_SPEC = '@xenova/transformers@2.17.2';
+const PACKAGE = '@xenova/transformers';
+/** Rigour's own copy, shared by every Rigour version on the machine (per profile home). */
+export function semanticRuntimeDir() {
+    return path.join(rigourUserDir(), 'runtime', 'semantic');
+}
+/** Where the library resolves from, or undefined when it is not installed anywhere Rigour looks. */
+export function locateTransformers(cwd = process.cwd()) {
+    for (const base of [import.meta.url, path.join(cwd, 'package.json'), path.join(semanticRuntimeDir(), 'package.json')]) {
+        try {
+            return createRequire(base).resolve(PACKAGE);
+        }
+        catch {
+            // not there
+        }
+    }
+    return undefined;
+}
+/** The library's module, loaded from wherever it is installed. */
+export async function loadTransformers(cwd = process.cwd()) {
+    const entry = locateTransformers(cwd);
+    if (!entry)
+        return undefined;
+    return import(pathToFileURL(entry).href);
+}
+/** Whether Rigour's home has its own copy (what `rigour setup` installs). */
+export function semanticRuntimeInstalled() {
+    return fs.existsSync(path.join(semanticRuntimeDir(), 'node_modules', ...PACKAGE.split('/'), 'package.json'));
+}

package/dist/pattern-index/semantic-runtime.test.d.ts

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

package/dist/pattern-index/semantic-runtime.test.js

@@ -0,0 +1,31 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { locateTransformers, semanticRuntimeDir, semanticRuntimeInstalled } from './semantic-runtime.js';
+let home;
+const original = process.env.RIGOUR_HOME;
+beforeEach(() => {
+    home = fs.mkdtempSync(path.join(os.tmpdir(), 'semantic-home-'));
+    process.env.RIGOUR_HOME = home;
+});
+afterEach(() => {
+    process.env.RIGOUR_HOME = original;
+    fs.rmSync(home, { recursive: true, force: true });
+});
+describe('the semantic runtime', () => {
+    it('lives in Rigour\'s home, shared by every Rigour version, and is seen there once installed', () => {
+        expect(semanticRuntimeDir()).toBe(path.join(home, '.rigour', 'runtime', 'semantic'));
+        expect(semanticRuntimeInstalled()).toBe(false);
+        const pkg = path.join(semanticRuntimeDir(), 'node_modules', '@xenova', 'transformers');
+        fs.mkdirSync(pkg, { recursive: true });
+        fs.writeFileSync(path.join(pkg, 'package.json'), JSON.stringify({ name: '@xenova/transformers', main: 'index.js' }));
+        fs.writeFileSync(path.join(pkg, 'index.js'), 'module.exports = {};');
+        expect(semanticRuntimeInstalled()).toBe(true);
+        expect(locateTransformers(home)).toBeDefined();
+    });
+    it('is not a dependency of the published package: the 240 MB is installed once, never per version', () => {
+        const manifest = JSON.parse(fs.readFileSync(path.join(__dirname, '../../package.json'), 'utf8'));
+        expect({ ...manifest.dependencies, ...manifest.optionalDependencies }).not.toHaveProperty('@xenova/transformers');
+    });
+});

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

@@ -0,0 +1,38 @@
+/**
+ * The panel measured against the ledger, per judge: which human points each judge raised on its
+ * own, how often two judges agree (Cohen's kappa over the ledger's points, where the set of items
+ * is fixed, so agreeing on "not raised" is meaningful), and what a caught point cost. A high kappa
+ * means the judges share blind spots and a second one adds little; a judge whose catches the others
+ * always make too is not earning its runs. This decides one, two or three judges with data.
+ */
+import type { ReviewerResult } from './reviewer.js';
+/** What each judge raised unprompted in one round, with what the round cost. */
+export interface JudgeRun {
+    judges: string[];
+    raised: Array<{
+        judge: string;
+        file: string;
+        line: number | undefined;
+        text: string;
+    }>;
+    costUsd?: number;
+    runs: number;
+}
+export interface JudgeCatches {
+    judges: string[];
+    /** Ledger point ids each judge raised. */
+    caught: Record<string, string[]>;
+    points: string[];
+    costUsd?: number;
+    runs: number;
+}
+/** Each judge's own raises: the panel's record when there was one, else the items tagged with the judge who found them. */
+export declare function judgedFrom(result: ReviewerResult): JudgeRun | undefined;
+/** Across rounds: each judge's catches, every pair's kappa, and the cost of a caught point. */
+export declare function formatJudges(rounds: Array<{
+    judges?: JudgeCatches;
+    points: Array<{
+        id: string;
+        caught: boolean;
+    }>;
+}>): string;

package/dist/review/backtest-judges.js

@@ -0,0 +1,63 @@
+/** Each judge's own raises: the panel's record when there was one, else the items tagged with the judge who found them. */
+export function judgedFrom(result) {
+    if (result.reviewers.length < 2)
+        return undefined;
+    const raised = [];
+    if (result.panel) {
+        for (const d of result.panel) {
+            for (const judge of d.judges) {
+                const own = d.members?.find(m => m.judge === judge)?.item ?? d.item;
+                raised.push({ judge, file: own.file ?? '', line: own.line, text: [own.issue, own.consequence, own.evidence].filter(Boolean).join(' ') });
+            }
+        }
+    }
+    else {
+        for (const item of [...result.items, ...result.unverified, ...result.notes]) {
+            if (item.kind === 'prior' || !item.reviewer)
+                continue;
+            for (const judge of item.reviewer.split('+'))
+                raised.push({ judge, file: item.file ?? '', line: item.line, text: [item.issue, item.consequence, item.evidence].filter(Boolean).join(' ') });
+        }
+    }
+    return { judges: result.reviewers, raised, ...(result.costUsd !== undefined ? { costUsd: result.costUsd } : {}), runs: result.runs ?? result.reviewers.length };
+}
+/** Cohen's kappa for two raters' yes/no calls on the same items; 1 when they agree on everything, 0 at chance. */
+function cohensKappa(a, b) {
+    const n = a.length;
+    if (n === 0 || n !== b.length)
+        return Number.NaN;
+    const agree = a.filter((x, i) => x === b[i]).length / n;
+    const pa = a.filter(Boolean).length / n;
+    const pb = b.filter(Boolean).length / n;
+    const chance = pa * pb + (1 - pa) * (1 - pb);
+    return chance === 1 ? (agree === 1 ? 1 : 0) : (agree - chance) / (1 - chance);
+}
+/** Across rounds: each judge's catches, every pair's kappa, and the cost of a caught point. */
+export function formatJudges(rounds) {
+    const judged = rounds.map(r => r.judges).filter((j) => !!j);
+    if (!judged.length)
+        return '';
+    const names = [...new Set(judged.flatMap(j => j.judges))];
+    const total = judged.reduce((sum, j) => sum + j.points.length, 0);
+    const lines = ['', `Judges (${judged.length} round(s), ${total} human point(s))`];
+    for (const name of names) {
+        const caught = judged.reduce((sum, j) => sum + (j.caught[name]?.length ?? 0), 0);
+        const only = judged.reduce((sum, j) => sum + (j.caught[name] ?? []).filter(id => j.judges.filter(o => o !== name).every(o => !(j.caught[o] ?? []).includes(id))).length, 0);
+        lines.push(`  ${name}: raised ${caught}/${total}; ${only} that no other judge raised`);
+    }
+    for (let i = 0; i < names.length; i++) {
+        for (let k = i + 1; k < names.length; k++) {
+            const both = judged.filter(j => j.judges.includes(names[i]) && j.judges.includes(names[k]));
+            const a = both.flatMap(j => j.points.map(p => (j.caught[names[i]] ?? []).includes(p)));
+            const b = both.flatMap(j => j.points.map(p => (j.caught[names[k]] ?? []).includes(p)));
+            const kappa = cohensKappa(a, b);
+            if (a.length)
+                lines.push(`  ${names[i]} and ${names[k]}: kappa ${Number.isNaN(kappa) ? 'n/a' : kappa.toFixed(2)} over ${a.length} point(s)${kappa > 0.8 ? ' (they share blind spots: a second judge adds little)' : ''}`);
+        }
+    }
+    const cost = judged.reduce((sum, j) => sum + (j.costUsd ?? 0), 0);
+    const runs = judged.reduce((sum, j) => sum + j.runs, 0);
+    const caughtPoints = rounds.filter(r => r.judges).reduce((sum, r) => sum + r.points.filter(p => p.caught).length, 0);
+    lines.push(`  ${runs} agent run(s)${cost ? `, $${cost.toFixed(2)} recorded` : ''}${cost && caughtPoints ? `, $${(cost / caughtPoints).toFixed(2)} per caught point` : ''}`);
+    return lines.join('\n');
+}

package/dist/review/backtest-judges.test.d.ts

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

package/dist/review/backtest-judges.test.js

@@ -0,0 +1,32 @@
+import { describe, expect, it } from 'vitest';
+import { formatJudges, judgedFrom } from './backtest-judges.js';
+const base = { outcome: 'findings', items: [], unverified: [], resolved: [], answerInReply: [], notes: [], disputed: [], dropped: [], dismissed: [], reviewers: ['claude', 'codex'], cached: false };
+describe('measuring each judge', () => {
+    it('computes Cohen\'s kappa between two judges: 1 in full agreement, 0 at chance, and says when they share blind spots', () => {
+        const round = (claude, codex) => ({ judges: { judges: ['claude', 'codex'], caught: { claude, codex }, points: ['p1', 'p2', 'p3', 'p4'], runs: 2 }, points: [] });
+        expect(formatJudges([round(['p1', 'p3'], ['p1', 'p3'])])).toContain('kappa 1.00 over 4 point(s) (they share blind spots: a second judge adds little)');
+        expect(formatJudges([round(['p1', 'p2'], ['p1', 'p3'])])).toContain('kappa 0.00 over 4 point(s)');
+        expect(formatJudges([round(['p1'], ['p2'])])).toMatch(/kappa -0\.\d\d over 4/);
+    });
+    it('takes each judge\'s own item from the panel, including what it raised in its own words', () => {
+        const lock = { id: 'a', kind: 'finding', class: 'correctness', file: 'src/job.ts', line: 2, issue: 'returns before the lock' };
+        const judged = judgedFrom({ ...base, costUsd: 2, runs: 3, panel: [
+                { item: lock, judges: ['claude', 'codex'], calls: { claude: 'raised', codex: 'raised' }, status: 'confirmed', members: [{ judge: 'claude', item: lock }, { judge: 'codex', item: { ...lock, id: 'b', line: 3, issue: 'lock taken late' } }] },
+            ] });
+        expect(judged).toEqual({ judges: ['claude', 'codex'], costUsd: 2, runs: 3, raised: [
+                { judge: 'claude', file: 'src/job.ts', line: 2, text: 'returns before the lock' },
+                { judge: 'codex', file: 'src/job.ts', line: 3, text: 'lock taken late' },
+            ] });
+        expect(judgedFrom({ ...base, reviewers: ['claude'] })).toBeUndefined();
+    });
+    it('reports each judge, what only it found, each pair\'s agreement and the cost of a caught point', () => {
+        const round = (caught) => ({ judges: { judges: ['claude', 'codex'], caught, points: ['p1', 'p2', 'p3', 'p4'], runs: 3, costUsd: 3 }, points: ['p1', 'p2', 'p3', 'p4'].map(id => ({ id, caught: Object.values(caught).some(ids => ids.includes(id)) })) });
+        const report = formatJudges([round({ claude: ['p1', 'p2'], codex: ['p1', 'p3'] }), round({ claude: ['p1'], codex: ['p1'] })]);
+        expect(report).toContain('Judges (2 round(s), 8 human point(s))');
+        expect(report).toContain('claude: raised 3/8; 1 that no other judge raised');
+        expect(report).toContain('codex: raised 3/8; 1 that no other judge raised');
+        expect(report).toMatch(/claude and codex: kappa 0\.\d\d over 8 point\(s\)/);
+        expect(report).toContain('6 agent run(s), $6.00 recorded, $1.50 per caught point');
+        expect(formatJudges([{ points: [] }])).toBe('');
+    });
+});

package/dist/review/backtest.d.ts

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import type { Config } from '../types/index.js';
 import { type Exec, type Progress } from './reviewer.js';
+import { type JudgeCatches, type JudgeRun } from './backtest-judges.js';
 declare const Point: z.ZodObject<{
     /** A regular expression over the finding's file path. */
     file: z.ZodString;
@@ -292,6 +293,8 @@ export interface RoundResult {
     durationMs: number;
     /** Why the reviewer gave no verdict, when it ran. */
     reviewerError?: string;
+    /** With two or more judges: the ledger points each raised on its own, and the round's runs and cost. */
+    judges?: JudgeCatches;
 }
 export interface BacktestOptions {
     round?: string;
@@ -299,10 +302,7 @@ export interface BacktestOptions {
     exec?: Exec;
     progress?: Progress;
     /** Produces the findings for a worktree; tests replace it. */
-    collect?: (worktree: string, round: LedgerRound, config: Config) => Promise<{
-        items: BacktestItem[];
-        reviewerError?: string;
-    }>;
+    collect?: (worktree: string, round: LedgerRound, config: Config) => Promise<Collected>;
 }
 export declare function loadLedger(cwd: string): Ledger;
 /** Rows that cannot match anything: no file pattern, neither a line window nor a text pattern, or a scaffold mark. */
@@ -311,5 +311,10 @@ export declare function runBacktest(cwd: string, config: Config, ledger: Ledger,
 /** Every point caught, nothing the reviewer called good flagged, and a verdict when the reviewer ran. */
 export declare function backtestPassed(results: RoundResult[]): boolean;
 export declare function score(round: LedgerRound, head: string, items: BacktestItem[], durationMs: number, reviewerError: string | undefined): RoundResult;
+interface Collected {
+    items: BacktestItem[];
+    reviewerError?: string;
+    judged?: JudgeRun;
+}
 export declare function formatBacktest(results: RoundResult[]): string;
 export {};

package/dist/review/backtest.js

@@ -15,6 +15,8 @@ import path from 'path';
 import { z } from 'zod';
 import { reviewChange } from './review.js';
 import { defaultExec, runReviewer } from './reviewer.js';
+import { reviewerInputs } from './reviewer/context.js';
+import { formatJudges, judgedFrom } from './backtest-judges.js';
 const Match = z.object({
     /** A regular expression over the finding's file path. */
     file: z.string(),
@@ -90,8 +92,8 @@ export async function runBacktest(cwd, config, ledger, options = {}) {
         const head = (await exec('git', ['rev-parse', 'HEAD'], { cwd: worktree, timeoutMs: GIT_TIMEOUT_MS })).stdout.trim();
         progress(`backtest ${round.id}: ${head.slice(0, 9)} against ${round.base}${round.reviewed_at ? `, reviews hidden from ${round.reviewed_at}` : ''}`);
         const collect = options.collect ?? ((tree, r, c) => collectItems(tree, r, c, !!options.reviewer, exec, progress));
-        const { items, reviewerError } = await collect(worktree, round, config);
-        const result = score(round, head, items, Date.now() - started, reviewerError);
+        const { items, reviewerError, judged } = await collect(worktree, round, config);
+        const result = { ...score(round, head, items, Date.now() - started, reviewerError), ...(judged ? { judges: judgeCatches(round, judged) } : {}) };
         record(cwd, result);
         results.push(result);
     }
@@ -125,8 +127,10 @@ async function worktreeFor(cwd, commit, exec) {
     if (!common)
         throw new Error(`${cwd} is not a git repository`);
     const resolved = await exec('git', ['rev-parse', '--verify', `${commit}^{commit}`], { cwd, timeoutMs: GIT_TIMEOUT_MS });
-    if (resolved.exitCode !== 0)
-        throw new Error(`commit ${commit} is not in this repository (fetch the branch it was reviewed on)`);
+    if (resolved.exitCode !== 0) {
+        const reason = resolved.stderr.trim().split('\n').at(-1);
+        throw new Error(`commit ${commit} is not in this repository (fetch the branch it was reviewed on)${reason ? `: git said "${reason}"` : ''}`);
+    }
     const dir = path.join(common, 'rigour-backtest', resolved.stdout.trim().slice(0, 12));
     if (!fs.existsSync(path.join(dir, '.git'))) {
         fs.mkdirSync(path.dirname(dir), { recursive: true });
@@ -143,6 +147,11 @@ function shareDependencies(cwd, worktree) {
     if (fs.existsSync(root) && !fs.existsSync(path.join(worktree, 'node_modules')))
         fs.symlinkSync(root, path.join(worktree, 'node_modules'), 'junction');
 }
+/** Which ledger points each judge raised itself, matched the way the score matches any finding. */
+function judgeCatches(round, judged) {
+    const caught = Object.fromEntries(judged.judges.map(judge => [judge, round.points.filter(point => judged.raised.some(r => r.judge === judge && matches(point, { gate: `judge:${judge}`, file: r.file, line: r.line, text: r.text, blocking: true }))).map(p => p.id)]));
+    return { judges: judged.judges, caught, points: round.points.map(p => p.id), runs: judged.runs, ...(judged.costUsd !== undefined ? { costUsd: judged.costUsd } : {}) };
+}
 async function collectItems(worktree, round, config, reviewer, exec, progress) {
     const review = await reviewChange({ cwd: worktree, config, source: { mode: 'base', base: round.base }, typed: true });
     const items = [
@@ -151,13 +160,14 @@ async function collectItems(worktree, round, config, reviewer, exec, progress) {
     ];
     if (!reviewer)
         return { items };
-    const result = await runReviewer(worktree, round.base, config, exec, progress, { pr: round.pr, reviewsBefore: round.reviewed_at, trigger: 'backtest', force: true, hints: review.hints.join('\n') });
+    const result = await runReviewer(worktree, round.base, config, exec, progress, { pr: round.pr, reviewsBefore: round.reviewed_at, trigger: 'backtest', force: true, ...reviewerInputs(review) });
     if (result.outcome === 'unavailable' || result.outcome === 'skipped')
         return { items, reviewerError: result.reason ?? result.outcome };
     // The reviewer behind each catch is part of the score, so the gate is `reviewer:<name>`.
-    const asReviewerItem = (item, blocking) => ({ gate: `reviewer:${item.reviewer ?? result.reviewers[0]}`, file: item.file ?? '', line: item.line, text: [item.issue, item.evidence].filter(Boolean).join(' '), blocking });
-    items.push(...result.items.map(i => asReviewerItem(i, true)), ...result.unverified.map(i => asReviewerItem(i, false)));
-    return { items };
+    const asReviewerItem = (item, blocking) => ({ gate: `reviewer:${item.reviewer ?? result.reviewers[0]}`, file: item.file ?? '', line: item.line, text: [item.issue, item.consequence, item.evidence].filter(Boolean).join(' '), blocking });
+    items.push(...result.items.map(i => asReviewerItem(i, true)), ...[...result.unverified, ...result.notes, ...result.disputed].map(i => asReviewerItem(i, false)));
+    const judged = judgedFrom(result);
+    return { items, ...(judged ? { judged } : {}) };
 }
 function asItem(failure, blocking) {
     return { gate: failure.id, file: failure.files?.[0] ?? '', line: failure.line, text: [failure.title, failure.details, failure.hint].filter(Boolean).join(' '), blocking };
@@ -185,7 +195,7 @@ export function formatBacktest(results) {
         if (r.reviewerError)
             lines.push(`  NO VERDICT ${r.reviewerError}`);
     }
-    return lines.join('\n');
+    return lines.join('\n') + formatJudges(results);
 }
 /** Which gate (or the reviewer) caught what: `; caught by unused-export 2, reviewer 1`, so a rule is judged on its own rows. */
 function byGate(result) {

package/dist/review/backtest.test.js

@@ -118,12 +118,12 @@ describe('rigour backtest on a repository', () => {
         // The worktree is reused on the next run.
         const again = await runBacktest(repo, config, loadLedger(repo), { round: 'r1', progress: () => undefined });
         expect(again[0].points[0].caught).toBe(true);
-    });
+    }, 60_000); // a real worktree and a typed review: over 10s on a Windows runner
     it('names a round or a commit it cannot find', async () => {
         const config = ConfigSchema.parse({ version: 1 });
         const ledger = { rounds: [{ id: 'r1', commit: '0000000000000000000000000000000000000000', base: 'main', points: [{ id: 'P', point: 'p', file: 'x', text: 'x' }], must_not_flag: [] }] };
         await expect(runBacktest(repo, config, ledger, { round: 'r9' })).rejects.toThrow('no round "r9"');
         await expect(runBacktest(repo, config, ledger, { progress: () => undefined })).rejects.toThrow('is not in this repository');
         expect(() => loadLedger(repo)).toThrow('no ledger');
-    });
+    }, 60_000); // a real worktree and a typed review: over 10s on a Windows runner
 });

package/dist/review/baseline.js

@@ -39,7 +39,8 @@ export async function baseFindings(cwd, config, commit, files) {
         const modules = path.join(cwd, 'node_modules');
         if (fs.existsSync(modules))
             fs.symlinkSync(modules, path.join(dir, 'node_modules'), 'junction');
-        const report = await new GateRunner(config).run(dir, await normalizeScopePatterns(dir, files), undefined, { record: false });
+        // The team's commands find nothing to compare per finding (they report no file), so the base copy never runs them.
+        const report = await new GateRunner({ ...config, commands: {} }).run(dir, await normalizeScopePatterns(dir, files), undefined, { record: false });
         return { failures: report.failures, added };
     }
     finally {

package/dist/review/dead-code.test.js

@@ -51,6 +51,13 @@ describe('unused exports', () => {
         expect(names).toContainEqual(['src/index.ts', 'Row']);
         expect(names).not.toContainEqual(['src/index.ts', 'Used']);
     });
+    it('never reports a type-test file as orphaned: tsd runs test-d/ and *.test-d.ts by itself', () => {
+        write('test-d/types.ts', "import { start } from '../src/app';\nstart();\n");
+        write('src/app.test-d.ts', "import { start } from './app';\nstart();\n");
+        const orphans = orphanFileFailures(repo, diffFromGit(repo), config()).map(f => f.files?.[0]);
+        expect(orphans).not.toContain('test-d/types.ts');
+        expect(orphans).not.toContain('src/app.test-d.ts');
+    });
     it('skips what a framework calls by name, and names the team allows', () => {
         write('src/routes/+page.server.ts', 'export const load = () => ({});\nexport const helper = 1;\n');
         write('src/plugin.ts', 'export const register = () => {};\n');

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

@@ -0,0 +1,21 @@
+import { type Exec } from './reviewer/exec.js';
+export interface FixScope {
+    pr: number;
+    review: {
+        id: number;
+        login: string;
+        submittedAt: string;
+        commit: string;
+    };
+    cited: string[];
+    changed: string[];
+    extra: string[];
+}
+export declare function fixScope(cwd: string, options: {
+    pr: number | undefined;
+    review: number | undefined;
+    githubAccount: string | undefined;
+}, exec?: Exec): Promise<{
+    scope?: FixScope;
+    error?: string;
+}>;