@rigour-labs/core 6.8.0 → 6.8.1

package/dist/review/backtest.test.js

@@ -1,183 +0,0 @@
-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 { ConfigSchema } from '../types/index.js';
-import { backtestPassed, formatBacktest, ledgerProblems, loadLedger, runBacktest, score, LEDGER_PATH } from './backtest.js';
-const item = (over = {}) => ({ gate: 'unused-export', file: 'src/lib/server/billing/invoices.ts', line: 40, text: 'Unused export `isRefund` is not imported anywhere', blocking: true, ...over });
-describe('a ledger point matches a finding', () => {
-    const caught = (row, finding) => score({ id: 'r', commit: 'abcdef0', base: 'main', points: [{ id: 'P', point: 'p', ...row }], must_not_flag: [] }, 'h', [finding], 0, undefined).points[0].caught;
-    it('by file, then by line window or text pattern, case-insensitively', () => {
-        expect(caught({ file: 'invoices', lines: [30, 50] }, item())).toBe(true);
-        expect(caught({ file: 'invoices', lines: [41, 50] }, item())).toBe(false);
-        expect(caught({ file: 'invoices', text: 'isrefund|twice' }, item())).toBe(true);
-        expect(caught({ file: 'invoices', lines: [41, 50], text: 'isRefund' }, item())).toBe(true); // either is enough
-        expect(caught({ file: 'receipts', text: 'isRefund' }, item())).toBe(false); // the file must match
-        expect(caught({ file: 'invoices', lines: [30, 50] }, item({ line: undefined }))).toBe(false); // a lineless finding cannot be placed in a window
-    });
-    it('rejects rows that can match nothing before any round runs', () => {
-        const ledger = { rounds: [{ id: 'r1', commit: 'abcdef0', base: 'main', points: [
-                        { id: 'A', point: 'p', file: 'x', lines: [1, 2] },
-                        { id: 'B', point: 'p', file: '', text: 'x' },
-                        { id: 'C', point: 'p', file: 'x' },
-                        { id: 'D', point: 'p', file: 'x', text: 'x', needs: 'a text pattern' },
-                        { id: 'E', point: 'p', file: '[', text: 'x' },
-                    ], must_not_flag: [{ file: 'x' }] }] };
-        expect(ledgerProblems(ledger)).toEqual([
-            'r1 B: no file pattern',
-            'r1 C: needs a line window or a text pattern',
-            'r1 D: needs a text pattern',
-            'r1 E: not a regular expression',
-            'r1 must_not_flag[0]: needs a line window or a text pattern',
-        ]);
-    });
-});
-describe('scoring a round', () => {
-    const round = {
-        id: 'r1', commit: 'abcdef0', base: 'main',
-        points: [
-            { id: 'P1', point: 'dead export', file: 'invoices', lines: [30, 50] },
-            { id: 'P2', point: 'copies the accumulator', file: 'totals', text: 'copied|quadratic' },
-            { id: 'P3', point: 'drops the currency', file: 'checkout', text: 'currency' },
-        ],
-        must_not_flag: [{ file: 'session', text: 'cookie' }],
-    };
-    it('counts a point as caught only by a blocking finding; an advisory match is noted and still missed', () => {
-        const items = [item(), item({ gate: 'quadratic-copy', file: 'src/totals.ts', line: 128, text: 'accumulator copied whole', blocking: false }), item({ gate: 'reviewer', file: 'src/hooks/session.ts', line: 53, text: 'the cookie is cleared' })];
-        const result = score(round, 'abcdef0123456', items, 1200, undefined);
-        expect(result.points).toEqual([
-            { id: 'P1', point: 'dead export', caught: true, noted: false, by: 'unused-export src/lib/server/billing/invoices.ts:40' },
-            { id: 'P2', point: 'copies the accumulator', caught: false, noted: true },
-            { id: 'P3', point: 'drops the currency', caught: false, noted: false },
-        ]);
-        expect(result.falseBlocks).toHaveLength(1);
-        expect(backtestPassed([result])).toBe(false);
-        expect(formatBacktest([result])).toContain('r1 at abcdef012: 1/3 caught, 1 false block(s), 3 finding(s), 1s; caught by unused-export 1');
-        expect(formatBacktest([result])).toContain('noted   P2 copies the accumulator (advisory only)');
-        expect(formatBacktest([result])).toContain('MISSED  P3');
-        expect(formatBacktest([result])).toContain('FALSE   reviewer src/hooks/session.ts:53');
-    });
-    it('passes only when every point is caught, nothing good is flagged and the reviewer answered', () => {
-        const all = [item(), item({ gate: 'quadratic-copy', file: 'src/totals.ts', text: 'copied whole' }), item({ gate: 'reviewer', file: 'src/checkout.ts', text: 'drops the currency' })];
-        expect(backtestPassed([score(round, 'h', all, 1, undefined)])).toBe(true);
-        expect(backtestPassed([score(round, 'h', all, 1, 'the reviewer did not answer')])).toBe(false);
-    });
-});
-describe('rigour backtest on a repository', () => {
-    let repo;
-    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);
-    };
-    beforeEach(() => {
-        repo = fs.mkdtempSync(path.join(os.tmpdir(), 'backtest-'));
-        git('init', '-q', '-b', 'main');
-        git('config', 'user.email', 't@example.com');
-        git('config', 'user.name', 't');
-        git('config', 'commit.gpgsign', 'false');
-        write('src/app.ts', 'export const app = 1;\n');
-        git('add', '-A');
-        git('commit', '-qm', 'base');
-        git('checkout', '-qb', 'feature');
-        write('src/lib/util.ts', 'export function helper(): number {\n    return 1;\n}\n');
-        git('add', '-A');
-        git('commit', '-qm', 'add a helper nothing uses');
-    });
-    afterEach(() => {
-        try {
-            git('worktree', 'prune');
-        }
-        catch { /* the repository may be gone */ }
-        fs.rmSync(repo, { recursive: true, force: true });
-    });
-    it('hides the review itself for a round, and shows the approval for an approved head', async () => {
-        const commit = git('rev-parse', 'HEAD');
-        const base = git('rev-parse', 'main');
-        const lines = [];
-        const ledger = { rounds: [
-                { id: 'r1', commit, base, reviewed_at: '2026-09-28T15:12:53Z', points: [], must_not_flag: [] },
-                { id: 'pr1-approved', commit, base, reviewed_at: '2026-09-28T15:12:53Z', approved: true, points: [], must_not_flag: [] },
-                { id: 'odd', commit, base, reviewed_at: 'not a date', approved: true, points: [], must_not_flag: [] },
-            ] };
-        await runBacktest(repo, ConfigSchema.parse({ version: 1 }), ledger, { progress: line => lines.push(line), collect: async () => ({ items: [] }) });
-        expect(lines.filter(l => l.includes('reviews hidden from')).map(l => l.replace(/^.*reviews hidden from /, ''))).toEqual(['2026-09-28T15:12:53Z', '2026-09-28T15:12:54.000Z', 'not a date']);
-    }, 60_000);
-    it('reviews the reviewed commit in a worktree with the review hidden, scores it, and leaves the checkout alone', async () => {
-        const reviewed = git('rev-parse', 'HEAD');
-        const base = git('rev-parse', 'main');
-        git('checkout', '-q', 'main'); // the person runs it from wherever they are
-        write(LEDGER_PATH, JSON.stringify({ rounds: [{
-                    id: 'r1', commit: reviewed, base,
-                    points: [
-                        { id: 'R1-1', point: 'helper is never imported', file: 'util\\.ts', lines: [1, 3] },
-                        { id: 'R1-2', point: 'something no gate knows', file: 'util', text: 'quadratic' },
-                    ],
-                    must_not_flag: [{ file: 'app\\.ts', lines: [1, 1] }],
-                }] }));
-        const config = ConfigSchema.parse({ version: 1, gates: { unused_exports: { block: true } } });
-        const results = await runBacktest(repo, config, loadLedger(repo), { progress: () => undefined });
-        expect(results).toHaveLength(1);
-        expect(results[0].points).toMatchObject([{ id: 'R1-1', caught: true, by: 'unused-export src/lib/util.ts:1' }, { id: 'R1-2', caught: false, noted: false }]);
-        expect(results[0].falseBlocks).toEqual([]);
-        expect(results[0].head).toBe(reviewed);
-        expect(backtestPassed(results)).toBe(false);
-        expect(git('branch', '--show-current')).toBe('main');
-        expect(fs.existsSync(path.join(repo, 'src/lib/util.ts'))).toBe(false); // the checkout did not move
-        expect(fs.existsSync(path.join(repo, '.git/rigour-backtest/checkout/src/lib/util.ts'))).toBe(true);
-        expect(fs.readdirSync(path.join(repo, '.rigour/backtest'))).toEqual([`r1-${reviewed.slice(0, 12)}.json`]);
-        // 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('warns when the base is older than the main the head already merged in', async () => {
-        const forked = git('rev-parse', 'main');
-        git('checkout', '-q', 'main');
-        write('src/main-only.ts', 'export const later = 1;\n');
-        git('add', '-A');
-        git('commit', '-qm', 'main moves on');
-        const merged = git('rev-parse', 'HEAD');
-        git('checkout', '-q', 'feature');
-        git('merge', '-q', '--no-edit', 'main');
-        const reviewed = git('rev-parse', 'HEAD');
-        const config = ConfigSchema.parse({ version: 1 });
-        const run = async (base) => {
-            const lines = [];
-            const ledger = { rounds: [{ id: 'r1', commit: reviewed, base, points: [], must_not_flag: [] }] };
-            await runBacktest(repo, config, ledger, { progress: line => lines.push(line), collect: async () => ({ items: [] }) });
-            return lines.filter(line => line.includes('warning'));
-        };
-        expect(await run(forked)).toEqual([expect.stringContaining(`set the base to ${merged.slice(0, 9)}`)]);
-        expect(await run(merged)).toEqual([]);
-        git('update-ref', 'refs/heads/main', forked); // a local main older than the round's base: the ref is stale, not the base
-        expect(await run(merged)).toEqual([]);
-        git('update-ref', 'refs/heads/main', merged);
-        git('checkout', '-q', 'main');
-        git('merge', '-q', '--no-edit', 'feature'); // the pull request is merged: its head is on main now
-        expect(await run(merged)).toEqual([]);
-    }, 60_000);
-    it('moves one worktree from round to round, leaving nothing of the last round behind', async () => {
-        const reviewed = git('rev-parse', 'HEAD');
-        const base = git('rev-parse', 'main');
-        const seen = [];
-        const ledger = { rounds: [
-                { id: 'after', commit: reviewed, base, points: [], must_not_flag: [] },
-                { id: 'before', commit: base, base, points: [], must_not_flag: [] },
-            ] };
-        await runBacktest(repo, ConfigSchema.parse({ version: 1 }), ledger, { progress: () => undefined, collect: async (tree) => {
-                seen.push({ tree, util: fs.existsSync(path.join(tree, 'src/lib/util.ts')), leftover: fs.existsSync(path.join(tree, 'scratch.txt')) });
-                fs.writeFileSync(path.join(tree, 'scratch.txt'), 'left by a round');
-                return { items: [] };
-            } });
-        expect(seen.map(s => s.tree)).toEqual([seen[0].tree, seen[0].tree]);
-        expect(seen.map(s => [s.util, s.leftover])).toEqual([[true, false], [false, false]]);
-    }, 60_000);
-    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.test.d.ts

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

package/dist/review/baseline.test.js

@@ -1,22 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { splitIntroduced } from './baseline.js';
-const finding = (file, title, details = 'd') => ({ id: 'AST_COMPLEXITY', title, details, files: [file] });
-describe('splitIntroduced', () => {
-    it("drops what the base already had, even when the change moved its numbers", () => {
-        const base = { failures: [finding('a.ts', "Function 'f' has complexity of 105 (max: 10)", 'L12: x')], added: new Set() };
-        const head = [finding('a.ts', "Function 'f' has complexity of 109 (max: 10)", 'L19: x'), finding('a.ts', "Function 'g' has complexity of 11 (max: 10)")];
-        const split = splitIntroduced(head, base);
-        expect(split.preexisting.map(f => f.title)).toEqual(["Function 'f' has complexity of 109 (max: 10)"]);
-        expect(split.introduced.map(f => f.title)).toEqual(["Function 'g' has complexity of 11 (max: 10)"]);
-    });
-    it('matches each base finding once, so a second copy of an old problem is new', () => {
-        const old = finding('a.ts', 'Unhandled promise', 'L3: then');
-        const split = splitIntroduced([old, finding('a.ts', 'Unhandled promise', 'L9: then')], { failures: [old], added: new Set() });
-        expect(split.preexisting).toHaveLength(1);
-        expect(split.introduced).toHaveLength(1);
-    });
-    it('never treats a finding in a file the change adds as old', () => {
-        const f = finding('new.ts', 'Naming drift');
-        expect(splitIntroduced([f], { failures: [f], added: new Set(['new.ts']) }).introduced).toEqual([f]);
-    });
-});

package/dist/review/branch-checks.test.d.ts

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

package/dist/review/branch-checks.test.js

@@ -1,48 +0,0 @@
-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 { ConfigSchema } from '../types/index.js';
-import { mergeConflicts, staleReferences } from './branch-checks.js';
-let repo;
-const git = (...args) => execFileSync('git', ['-C', repo, ...args], { encoding: 'utf8' });
-const write = (rel, body) => {
-    fs.mkdirSync(path.dirname(path.join(repo, rel)), { recursive: true });
-    fs.writeFileSync(path.join(repo, rel), body);
-};
-const config = ConfigSchema.parse({ version: 1 });
-beforeEach(() => {
-    repo = fs.mkdtempSync(path.join(os.tmpdir(), 'branch-checks-'));
-    git('init', '-q', '-b', 'main');
-    git('config', 'user.email', 't@example.com');
-    git('config', 'user.name', 't');
-    git('config', 'commit.gpgsign', 'false');
-    write('src/limits.ts', 'export const LIMIT = 1;\n');
-    write('scripts/seed.ts', 'console.log(1);\n');
-    write('scripts/seed.tsx', 'console.log(2);\n');
-    git('add', '-A');
-    git('commit', '-qm', 'init');
-});
-afterEach(() => { fs.rmSync(repo, { recursive: true, force: true }); });
-describe('branch checks', () => {
-    it('reports the files that conflict with main, and nothing when it merges cleanly', () => {
-        git('checkout', '-q', '-b', 'feature');
-        write('src/limits.ts', 'export const LIMIT = 2;\n');
-        git('commit', '-qam', 'feature');
-        expect(mergeConflicts(repo, 'main')).toEqual([]);
-        git('checkout', '-q', 'main');
-        write('src/limits.ts', 'export const LIMIT = 3;\n');
-        git('commit', '-qam', 'main moved');
-        git('checkout', '-q', 'feature');
-        expect(mergeConflicts(repo, 'main').map(f => [f.id, f.files?.[0]])).toEqual([['merge-conflict', 'src/limits.ts']]);
-    });
-    it('reports a mention of a file the branch deleted, but not of a longer path that starts with it', () => {
-        const base = git('rev-parse', 'HEAD').trim();
-        git('rm', '-q', 'scripts/seed.ts');
-        write('README.md', 'Run `scripts/seed.ts` first.\nThen scripts/seed.tsx.\n');
-        write('src/notes.ts', '// see scripts/seed.tsx\nexport const n = 1;\n');
-        const found = staleReferences(repo, base, config).map(f => [f.files?.[0], f.line]);
-        expect(found).toEqual([['README.md', 1]]);
-    });
-});

package/dist/review/check-outcomes.test.d.ts

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

package/dist/review/check-outcomes.test.js

@@ -1,56 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { checkId, checkPrecisions, isMuted, precisionOf, readOutcomes, recordOutcome, rememberReported } from './check-outcomes.js';
-import { dismissFinding, findingKey, quietSplit } from './quiet.js';
-import { recordReviewOutcome } from './agent-fixes.js';
-let cwd;
-beforeEach(() => { cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'outcomes-')); });
-afterEach(() => fs.rmSync(cwd, { recursive: true, force: true }));
-const finding = (id, title, file = 'src/a.ts', details = `${title} here`) => ({ id, title, details, severity: 'low', provenance: 'traditional', files: [file], line: 1 });
-describe('check precision', () => {
-    it('starts at an honest 0.5 and follows the evidence', () => {
-        expect(precisionOf({ fixed: 0, dismissed: 0 })).toBe(0.5);
-        expect(precisionOf({ fixed: 0, dismissed: 8 })).toBe(0.1);
-        expect(precisionOf({ fixed: 8, dismissed: 0 })).toBe(0.9);
-    });
-    it('mutes only on clear evidence: enough outcomes and a low posterior', () => {
-        expect(isMuted({ fixed: 0, dismissed: 3 })).toBe(false);
-        expect(isMuted({ fixed: 0, dismissed: 5 })).toBe(true);
-        expect(isMuted({ fixed: 2, dismissed: 4 })).toBe(false);
-    });
-    it('names a check by gate and rule, so one rule in a gate never mutes its neighbours', () => {
-        expect(checkId(finding('ast', 'Function too complex'))).toBe('ast: Function too complex');
-        expect(checkId({ rule: 'ast' })).toBe('ast');
-    });
-});
-describe('outcomes from real decisions', () => {
-    it('attributes a dismissal by key to the check review reported it from', () => {
-        const f = finding('ast', 'Too many parameters');
-        rememberReported(cwd, [{ key: findingKey(f), check: checkId(f) }]);
-        expect(dismissFinding(cwd, findingKey(f), 'builder needs these')).toBe(true);
-        expect(dismissFinding(cwd, findingKey(f), 'again')).toBe(true);
-        expect(readOutcomes(cwd)).toEqual({ 'ast: Too many parameters': { fixed: 0, dismissed: 1 } });
-    });
-    it('counts a fix an agent made against the check that reported it', () => {
-        fs.mkdirSync(path.join(cwd, 'src'));
-        fs.writeFileSync(path.join(cwd, 'src/a.ts'), 'before\n');
-        recordReviewOutcome(cwd, [finding('semantic-bugs', 'Unbounded read')], ['src/a.ts']);
-        fs.writeFileSync(path.join(cwd, 'src/a.ts'), 'after\n');
-        recordReviewOutcome(cwd, [], ['src/a.ts']);
-        expect(checkPrecisions(cwd)).toEqual([expect.objectContaining({ check: 'semantic-bugs: Unbounded read', fixed: 1, dismissed: 0 })]);
-    });
-});
-describe('quietSplit with precision', () => {
-    it('mutes an advisory check the team keeps dismissing, but never a proven one', () => {
-        for (let i = 0; i < 5; i++) {
-            recordOutcome(cwd, 'ast: Too many parameters', 'dismissed');
-            recordOutcome(cwd, 'security-patterns: Hard-coded secret', 'dismissed');
-        }
-        const split = quietSplit(cwd, [finding('ast', 'Too many parameters'), finding('ast', 'Function too complex'), finding('security-patterns', 'Hard-coded secret')]);
-        expect(split.muted).toBe(1);
-        expect(split.advisory.map(f => f.title)).toEqual(['Function too complex']);
-        expect(split.speaking.map(f => f.title)).toEqual(['Hard-coded secret']);
-    });
-});

package/dist/review/code-patterns.test.d.ts

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

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

@@ -1,142 +0,0 @@
-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 { ConfigSchema } from '../types/index.js';
-import { parseDiff } from '../utils/diff.js';
-import { diffFromGit } from './git-diff.js';
-import { duplicateFunctionFailures } from './duplicate-functions.js';
-import { loopCopyFailures } from './loop-copies.js';
-import { partialFixFailures } from './partial-fixes.js';
-import { partialWiringFailures } from './partial-wiring.js';
-import { optionalParamFailures } from './optional-params.js';
-import { queryPatternFailures } from './query-patterns.js';
-let repo;
-const git = (...args) => execFileSync('git', ['-C', repo, ...args], { encoding: 'utf8' });
-const write = (rel, body) => {
-    fs.mkdirSync(path.dirname(path.join(repo, rel)), { recursive: true });
-    fs.writeFileSync(path.join(repo, rel), body);
-};
-const config = ConfigSchema.parse({ version: 1 });
-const changed = () => parseDiff(diffFromGit(repo));
-beforeEach(() => {
-    repo = fs.mkdtempSync(path.join(os.tmpdir(), 'code-patterns-'));
-    git('init', '-q', '-b', 'main');
-    git('config', 'user.email', 't@example.com');
-    git('config', 'user.name', 't');
-    git('config', 'commit.gpgsign', 'false');
-    write('README.md', 'x\n');
-    git('add', '-A');
-    git('commit', '-qm', 'init');
-});
-afterEach(() => { fs.rmSync(repo, { recursive: true, force: true }); });
-describe('query patterns', () => {
-    it('reports offset paging in a loop and in a pager callback, not a single page a request asks for', () => {
-        write('src/sweep.ts', [
-            'export async function sweep(db: any) {',
-            '  for (let from = 0; ; from += 500) {',
-            "    const { data } = await db.from('rows').select('id').order('id').range(from, from + 499);",
-            '    if (!data?.length) return;',
-            '  }',
-            '}',
-            "export const all = (db: any) => readAllPages((from: number, to: number) => db.from('rows').select('id').order('id').range(from, to));",
-            "export function page(db: any, from: number, to: number) { return db.from('rows').select('id').range(from, to); }",
-            'declare function readAllPages(f: (from: number, to: number) => unknown): unknown;',
-        ].join('\n'));
-        expect(queryPatternFailures(repo, changed(), config).map(f => [f.id, f.line])).toEqual([['offset-paging', 3], ['offset-paging', 7]]);
-    });
-    it('reports a window read only from its start, not a bounded window or everything since an event', () => {
-        write('src/window.ts', [
-            "export const open = (db: any, window: { from: string; to: string }) => db.from('events').select('id').gte('created_at', window.from);",
-            "export const closed = (db: any, window: { from: string; to: string }) => db.from('events').select('id').gte('created_at', window.from).lte('created_at', window.to);",
-            "export const since = (db: any, since: string) => db.from('events').select('id').gt('started_at', since);",
-        ].join('\n'));
-        expect(queryPatternFailures(repo, changed(), config).map(f => [f.id, f.line])).toEqual([['unbounded-window', 1]]);
-    });
-});
-describe('optional for tests', () => {
-    it('reports an optional parameter or option that every production call passes and only a test omits', () => {
-        write('src/build.ts', 'export function build(items: string[], opts: { resumes?: string[] }, limit?: number) { return [items, opts, limit]; }\n');
-        write('src/run.ts', "import { build } from './build';\nbuild(['a'], { resumes: [] }, 5);\n");
-        write('src/build.test.ts', "import { build } from './build';\nbuild(['a'], {});\n");
-        const found = optionalParamFailures(repo, changed(), config).map(f => f.details.match(/`([^`]+)`/)[1]).sort();
-        expect(found).toEqual(['limit', 'resumes']);
-    });
-    it('stays quiet when production itself omits it, or when tests pass it too', () => {
-        write('src/build.ts', 'export function build(items: string[], limit?: number) { return [items, limit]; }\n');
-        write('src/run.ts', "import { build } from './build';\nbuild(['a']);\nbuild(['b'], 2);\n");
-        write('src/build.test.ts', "import { build } from './build';\nbuild(['a']);\n");
-        expect(optionalParamFailures(repo, changed(), config)).toEqual([]);
-    });
-});
-describe('duplicate functions', () => {
-    const body = (name) => `export function ${name}(x: number) {\n  const a = x + 1;\n  const b = a * 2;\n  if (b > 10) return b;\n  console.log(a, b);\n  return a;\n}\n`;
-    it('reports a changed function whose body copies another, in TypeScript and Svelte alike', () => {
-        write('src/a.ts', body('first'));
-        write('src/b.svelte', `<script lang="ts">\n${body('second').replace('export ', '')}</script>\n<p>hi</p>\n`);
-        const found = duplicateFunctionFailures(repo, changed(), config);
-        expect(found.map(f => [f.files?.[0], f.line])).toEqual([['src/b.svelte', 2]]);
-        expect(found[0].details).toContain('`first` in `src/a.ts:1`');
-    });
-    it('ignores small look-alike functions', () => {
-        write('src/a.ts', 'export const one = (x: number) => { return x + 1; };\n');
-        write('src/b.ts', 'export const two = (x: number) => { return x + 1; };\n');
-        expect(duplicateFunctionFailures(repo, changed(), config)).toEqual([]);
-    });
-});
-describe('quadratic copies', () => {
-    it('reports an accumulator spread into a new copy on every step, not a push', () => {
-        write('src/group.ts', [
-            'export function group(items: { day: string }[]) {',
-            '  const groups = new Map<string, { day: string }[]>();',
-            '  for (const item of items) groups.set(item.day, [...(groups.get(item.day) ?? []), item]);',
-            '  const ids = items.reduce((acc: string[], item) => [...acc, item.day], []);',
-            '  const fast = new Map<string, string[]>();',
-            '  for (const item of items) (fast.get(item.day) ?? fast.set(item.day, []).get(item.day)!).push(item.day);',
-            '  return { groups, ids, fast };',
-            '}',
-        ].join('\n'));
-        expect(loopCopyFailures(repo, changed(), config).map(f => f.line)).toEqual([3, 4]);
-    });
-});
-describe('partial fixes', () => {
-    it('names the places that still test the narrower condition a new predicate widened', () => {
-        write('src/routes/session/page.server.ts', 'export function load(snapshot: any) {\n  if (snapshot.answeredCount > 0) return 1;\n  return 0;\n}\n');
-        write('src/routes/session/page.svelte', '<script lang="ts">\n  const show = data.snapshot.answeredCount > 0;\n</script>\n');
-        git('add', '-A');
-        git('commit', '-qm', 'before');
-        write('src/routes/session/page.server.ts', 'export function load(snapshot: any) {\n  if (snapshot.answeredCount > 0) return 1;\n  return 0;\n}\nexport const resume = (snapshot: any) => {\n  const hasSaved = snapshot.answers.length > 0 || snapshot.answeredCount > 0;\n  return hasSaved;\n};\n');
-        const found = partialFixFailures(repo, changed(), config);
-        expect(found.map(f => [f.id, f.line])).toEqual([['partial-fix', 6]]);
-        expect(found[0].details).toContain('page.server.ts:2');
-        expect(found[0].details).toContain('page.svelte:2');
-    });
-});
-describe('partial wiring', () => {
-    const mount = (extra) => `<script lang="ts">\n  import Player from '$lib/Player.svelte';\n</script>\n<Player\n  mode="quiz"\n  {questions}${extra}\n/>\n`;
-    it('reports a callback added to most same-kind mounts of a local component but not one', () => {
-        write('src/lib/Player.svelte', '<script lang="ts">let { onResume } = $props();</script>\n');
-        for (const route of ['a', 'b', 'c'])
-            write(`src/routes/${route}/+page.svelte`, mount(''));
-        write('src/routes/d/+page.svelte', mount('').replace('mode="quiz"', 'mode="exam"'));
-        git('add', '-A');
-        git('commit', '-qm', 'mounts');
-        write('src/routes/a/+page.svelte', mount('\n  {onResume}'));
-        write('src/routes/b/+page.svelte', mount('\n  {onResume}'));
-        const found = partialWiringFailures(repo, changed(), config);
-        expect(found).toHaveLength(1);
-        expect(found[0].details).toContain('src/routes/c/+page.svelte');
-        expect(found[0].details).not.toContain('routes/d'); // another kind of mount
-    });
-    it('ignores styling props and components from packages', () => {
-        const icon = (extra) => `<script lang="ts">\n  import { Star } from 'lucide-svelte';\n</script>\n<Star class="h-4"${extra} />\n`;
-        for (const route of ['a', 'b', 'c'])
-            write(`src/routes/${route}/+page.svelte`, icon(''));
-        git('add', '-A');
-        git('commit', '-qm', 'icons');
-        write('src/routes/a/+page.svelte', icon(' onHover={go}'));
-        write('src/routes/b/+page.svelte', icon(' onHover={go}'));
-        expect(partialWiringFailures(repo, changed(), config)).toEqual([]);
-    });
-});

package/dist/review/dead-code.test.d.ts

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

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

@@ -1,154 +0,0 @@
-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 { ConfigSchema } from '../types/index.js';
-import { diffFromGit } from './git-diff.js';
-import { mustFix } from './quiet.js';
-import { orphanFileFailures } from './orphan-files.js';
-import { unusedExportFailures } from './unused-exports.js';
-let repo;
-const git = (...args) => execFileSync('git', ['-C', repo, ...args], { encoding: 'utf8' });
-const write = (rel, body) => {
-    fs.mkdirSync(path.dirname(path.join(repo, rel)), { recursive: true });
-    fs.writeFileSync(path.join(repo, rel), body);
-};
-const config = (gates = {}) => ConfigSchema.parse({ version: 1, gates });
-beforeEach(() => {
-    repo = fs.mkdtempSync(path.join(os.tmpdir(), 'dead-code-'));
-    git('init', '-q', '-b', 'main');
-    git('config', 'user.email', 't@example.com');
-    git('config', 'user.name', 't');
-    git('config', 'commit.gpgsign', 'false');
-    write('src/index.ts', "import { start } from './app';\nstart();\n");
-    write('src/app.ts', 'export function start() {}\n');
-    write('package.json', '{"scripts":{"seed":"node scripts/seed.mjs"}}\n');
-    git('add', '-A');
-    git('commit', '-qm', 'init');
-});
-afterEach(() => { fs.rmSync(repo, { recursive: true, force: true }); });
-describe('unused exports', () => {
-    it('reports an added export no other file names, on its own line', () => {
-        write('src/app.ts', 'export function start() {}\n\nexport const LIMIT = 5;\nexport function lonely() { return LIMIT; }\n');
-        write('src/use.ts', "import { LIMIT } from './app';\nconsole.log(LIMIT);\n");
-        const failures = unusedExportFailures(repo, diffFromGit(repo), config());
-        expect(failures.map(f => [f.files?.[0], f.line, f.id])).toEqual([['src/app.ts', 4, 'unused-export']]);
-        expect(failures[0].details).toContain('`lonely`');
-    });
-    it('does not count a test as a consumer: an export only its tests import is dead in production', () => {
-        write('src/app.ts', 'export function start() {}\n\nexport function onlyTested() { return 1; }\nexport function used() { return 2; }\n');
-        write('src/app.test.ts', "import { onlyTested, used } from './app';\nonlyTested();\nused();\n");
-        write('tests/helpers.ts', "import { onlyTested } from '../src/app';\nonlyTested();\n");
-        write('src/use.ts', "import { used } from './app';\nused();\n");
-        const names = unusedExportFailures(repo, diffFromGit(repo), config()).map(f => f.details.match(/`([^`]+)`/)[1]);
-        expect(names).toEqual(['onlyTested']);
-    });
-    it('reports a re-export nothing imports, without counting the module it comes from as a use', () => {
-        write('src/types.ts', 'export type Row = { id: string };\nexport type Used = { n: number };\n');
-        write('src/index.ts', "import { start } from './app';\nstart();\nexport type { Row, Used } from './types';\n");
-        write('src/consumer.ts', "import type { Used } from './index';\nexport const u: Used = { n: 1 };\nconsole.log(u);\n");
-        const names = unusedExportFailures(repo, diffFromGit(repo), config()).map(f => [f.files?.[0], f.details.match(/`([^`]+)`/)[1]]);
-        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');
-        const names = unusedExportFailures(repo, diffFromGit(repo), config({ unused_exports: { allow: ['register'] } }))
-            .map(f => f.details.match(/`([^`]+)`/)[1]);
-        expect(names).toEqual(['helper']);
-    });
-    it('does not count the same word in a file that never imports the module', () => {
-        write('src/payload.ts', 'export function eventId(kind: string) { return kind; }\nexport const used = eventId("x");\n');
-        write('src/main2.ts', "import { used } from './payload';\nconsole.log(used);\n");
-        write('src/routes/[eventId]/handler.ts', "const eventId = 'route-param';\nconsole.log(eventId);\n");
-        write('src/schedule.ts', 'const eventId = 7;\nconsole.log(eventId);\n');
-        const names = unusedExportFailures(repo, diffFromGit(repo), config()).map(f => f.details.match(/`([^`]+)`/)[1]);
-        expect(names).toContain('eventId');
-        expect(names).not.toContain('used');
-    });
-    it('reports a type imported then exported again that nothing imports from here', () => {
-        write('src/entry.ts', "export type Entry = 'a' | 'b';\n");
-        write('src/resume.ts', "import type { Entry } from './entry';\nexport type { Entry };\nexport const pick = (e: Entry) => e;\n");
-        write('src/main.ts', "import { pick } from './resume';\nconsole.log(pick('a'));\n");
-        const found = unusedExportFailures(repo, diffFromGit(repo), config()).map(f => [f.files?.[0], f.details.match(/`([^`]+)`/)[1]]);
-        expect(found).toContainEqual(['src/resume.ts', 'Entry']);
-        expect(found).not.toContainEqual(['src/entry.ts', 'Entry']);
-    });
-    it("never counts Rigour's own report as a use", () => {
-        write('src/app.ts', 'export function start() {}\nexport const orphanName = 1;\n');
-        write('rigour-report.json', '{"failures":[{"details":"orphanName"}]}\n');
-        expect(unusedExportFailures(repo, diffFromGit(repo), config())).toHaveLength(1);
-    });
-    it('reports dead code as a note unless the team blocks on it', () => {
-        write('src/app.ts', 'export function start() {}\nexport function lonely() { return 1; }\n');
-        write('src/new-tool.ts', 'export const tool = 1;\n');
-        const found = (gates = {}) => [
-            ...unusedExportFailures(repo, diffFromGit(repo), config(gates)),
-            ...orphanFileFailures(repo, diffFromGit(repo), config(gates)),
-        ];
-        expect(found().map(f => [f.id, mustFix(f)])).toEqual(expect.arrayContaining([['unused-export', false], ['orphan-file', false]]));
-        const strict = found({ unused_exports: { block: true }, orphan_files: { block: true } });
-        expect(strict.length).toBeGreaterThan(0);
-        expect(strict.every(mustFix)).toBe(true);
-    });
-    it('is off when disabled', () => {
-        write('src/app.ts', 'export function start() {}\nexport const x = 1;\n');
-        expect(unusedExportFailures(repo, diffFromGit(repo), config({ unused_exports: { enabled: false } }))).toEqual([]);
-    });
-});
-describe('package layout', () => {
-    it("never reports a package entry point's exports, which are its public API", () => {
-        write('packages/lib/package.json', '{"name":"lib","main":"dist/index.js","types":"dist/index.d.ts"}\n');
-        write('packages/lib/src/index.ts', "export { helper, type Shape } from './helper';\n");
-        write('packages/lib/src/helper.ts', 'export type Shape = { a: 1 };\nexport const helper = 1;\n');
-        write('packages/lib/src/tools/index.ts', "export { toolA } from './a';\n");
-        write('packages/lib/src/tools/a.ts', 'export const toolA = 1;\n');
-        write('packages/lib/src/index.ts', "export { helper, type Shape } from './helper';\nexport * from './tools/index.js';\n");
-        const reported = unusedExportFailures(repo, diffFromGit(repo), config()).map(f => f.files?.[0]);
-        expect(reported).not.toContain('packages/lib/src/index.ts');
-        expect(reported).not.toContain('packages/lib/src/tools/index.ts'); // re-exported whole by the entry
-    });
-    it('keeps an exported type in a signature when the project emits declarations, and only then', () => {
-        write('src/run.ts', 'export interface RunResult { ok: boolean }\nexport function run(): RunResult { return { ok: true }; }\n');
-        write('src/main.ts', "import { run } from './run';\nrun();\n");
-        const names = () => unusedExportFailures(repo, diffFromGit(repo), config()).map(f => f.details.match(/`([^`]+)`/)[1]);
-        expect(names()).toContain('RunResult'); // an application: drop the export
-        write('tsconfig.base.json', '{ "compilerOptions": { "declaration": true } }\n');
-        write('tsconfig.json', '{ "extends": "./tsconfig.base.json" }\n');
-        expect(names()).not.toContain('RunResult'); // a library: TypeScript needs it exported
-    });
-    it("counts a package.json bin or main path as running its source file", () => {
-        write('packages/tool/package.json', '{"name":"tool","bin":{"tool":"dist/bin.js"}}\n');
-        write('packages/tool/src/bin.ts', 'console.log("hi");\n');
-        expect(orphanFileFailures(repo, diffFromGit(repo), config())).toEqual([]);
-    });
-});
-describe('orphaned files', () => {
-    it('reports new files nothing outside the new files reaches, including a pair that only import each other', () => {
-        write('src/wired.ts', 'export const w = 1;\n');
-        write('src/index.ts', "import { start } from './app';\nimport { w } from './wired';\nstart(w);\n");
-        write('src/lonely.ts', 'export const l = 1;\n');
-        write('src/pair/a.ts', "import { b } from './b';\nexport const a = b;\n");
-        write('src/pair/b.ts', "import { a } from './a';\nexport const b = a;\n");
-        write('scripts/seed.mjs', 'console.log(1);\n');
-        write('src/tested.ts', 'export const t = 1;\n');
-        write('src/tested.test.ts', "import { t } from './tested';\n"); // a test runs it: reached
-        const files = orphanFileFailures(repo, diffFromGit(repo), config()).map(f => f.files?.[0]).sort();
-        expect(files).toEqual(['src/lonely.ts', 'src/pair/a.ts', 'src/pair/b.ts']);
-    });
-    it('lets a file through when a docs page is its only mention, and honours allow globs', () => {
-        write('src/tool.ts', 'export const t = 1;\n');
-        write('docs/tool.md', 'Run `src/tool.ts` by hand.\n');
-        expect(orphanFileFailures(repo, diffFromGit(repo), config()).map(f => f.files?.[0])).toEqual(['src/tool.ts']);
-        expect(orphanFileFailures(repo, diffFromGit(repo), config({ orphan_files: { allow: ['src/tool.ts'] } }))).toEqual([]);
-    });
-});