@rigour-labs/core 6.8.0 → 6.8.1

package/dist/pattern-index/staleness.test.js

@@ -1,211 +0,0 @@
-/**
- * Staleness Detector Tests
- *
- * Tests for the staleness detection system.
- */
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import * as os from 'os';
-import { StalenessDetector, checkCodeStaleness } from './staleness.js';
-describe('StalenessDetector', () => {
-    let testDir;
-    beforeEach(async () => {
-        testDir = await fs.mkdtemp(path.join(os.tmpdir(), 'rigour-staleness-'));
-    });
-    afterEach(async () => {
-        await fs.rm(testDir, { recursive: true, force: true });
-    });
-    describe('React deprecations', () => {
-        it('should detect componentWillMount', async () => {
-            await fs.writeFile(path.join(testDir, 'package.json'), JSON.stringify({ dependencies: { react: '^18.0.0' } }));
-            const detector = new StalenessDetector(testDir);
-            const result = await detector.checkStaleness(`
-                class MyComponent extends React.Component {
-                    componentWillMount() {
-                        console.log('mounting');
-                    }
-                }
-            `);
-            expect(result.status).toBe('DEPRECATED');
-            expect(result.issues.some(i => i.pattern.includes('componentWillMount'))).toBe(true);
-            expect(result.issues[0].replacement).toContain('useEffect');
-        });
-        it('should detect ReactDOM.render', async () => {
-            await fs.writeFile(path.join(testDir, 'package.json'), JSON.stringify({ dependencies: { react: '^18.0.0', 'react-dom': '^18.0.0' } }));
-            const detector = new StalenessDetector(testDir);
-            const result = await detector.checkStaleness(`
-                ReactDOM.render(<App />, document.getElementById('root'));
-            `);
-            expect(result.status).toBe('DEPRECATED');
-            expect(result.issues.some(i => i.pattern.includes('ReactDOM.render'))).toBe(true);
-            expect(result.issues[0].replacement).toContain('createRoot');
-        });
-        it('should not flag React deprecations if React is not installed', async () => {
-            await fs.writeFile(path.join(testDir, 'package.json'), JSON.stringify({ dependencies: { express: '^4.0.0' } }));
-            const detector = new StalenessDetector(testDir);
-            const result = await detector.checkStaleness(`
-                componentWillMount() {}
-            `);
-            // Should not flag React-specific patterns if React isn't a dependency
-            expect(result.issues.filter(i => i.pattern.includes('componentWillMount'))).toHaveLength(0);
-        });
-    });
-    describe('Package deprecations', () => {
-        it('should detect moment.js usage', async () => {
-            await fs.writeFile(path.join(testDir, 'package.json'), JSON.stringify({ dependencies: {} }));
-            const detector = new StalenessDetector(testDir);
-            const result = await detector.checkStaleness(`
-                import moment from 'moment';
-                const date = moment().format('YYYY-MM-DD');
-            `);
-            expect(result.status).toBe('STALE');
-            expect(result.issues.some(i => i.replacement.includes('date-fns'))).toBe(true);
-        });
-        it('should detect request library usage', async () => {
-            await fs.writeFile(path.join(testDir, 'package.json'), JSON.stringify({ dependencies: {} }));
-            const detector = new StalenessDetector(testDir);
-            const result = await detector.checkStaleness(`
-                const request = require('request');
-                request.get('https://example.com');
-            `);
-            expect(result.status).toBe('DEPRECATED');
-            expect(result.issues.some(i => i.replacement.includes('fetch'))).toBe(true);
-        });
-    });
-    describe('JavaScript deprecations', () => {
-        it('should detect var keyword usage', async () => {
-            await fs.writeFile(path.join(testDir, 'package.json'), JSON.stringify({ dependencies: {} }));
-            const detector = new StalenessDetector(testDir);
-            const result = await detector.checkStaleness(`
-                var name = 'test';
-                var count = 0;
-            `);
-            expect(result.issues.some(i => i.replacement.includes('const') || i.replacement.includes('let'))).toBe(true);
-        });
-    });
-    describe('Redux deprecations', () => {
-        it('should detect createStore usage in modern Redux projects', async () => {
-            await fs.writeFile(path.join(testDir, 'package.json'), JSON.stringify({ dependencies: { redux: '^4.2.0' } }));
-            const detector = new StalenessDetector(testDir);
-            const result = await detector.checkStaleness(`
-                import { createStore } from 'redux';
-                const store = createStore(reducer);
-            `);
-            expect(result.status).toBe('STALE');
-            expect(result.issues.some(i => i.replacement.includes('configureStore'))).toBe(true);
-        });
-    });
-    describe('Node.js deprecations', () => {
-        it('should detect Buffer constructor', async () => {
-            await fs.writeFile(path.join(testDir, 'package.json'), JSON.stringify({ dependencies: {} }));
-            const detector = new StalenessDetector(testDir);
-            const result = await detector.checkStaleness(`
-                const buf = new Buffer('hello');
-            `);
-            expect(result.status).toBe('DEPRECATED');
-            expect(result.issues.some(i => i.replacement.includes('Buffer.from'))).toBe(true);
-        });
-    });
-    describe('Next.js deprecations', () => {
-        it('should detect getInitialProps in Next 13+ projects', async () => {
-            await fs.writeFile(path.join(testDir, 'package.json'), JSON.stringify({ dependencies: { next: '^13.0.0' } }));
-            const detector = new StalenessDetector(testDir);
-            const result = await detector.checkStaleness(`
-                MyPage.getInitialProps = async (ctx) => {
-                    return { data: {} };
-                };
-            `);
-            expect(result.issues.some(i => i.pattern.includes('getInitialProps'))).toBe(true);
-        });
-    });
-    describe('TypeScript best practices', () => {
-        it('should warn about enum usage', async () => {
-            await fs.writeFile(path.join(testDir, 'package.json'), JSON.stringify({ dependencies: {} }));
-            const detector = new StalenessDetector(testDir);
-            const result = await detector.checkStaleness(`
-                enum Status {
-                    Active = 'active',
-                    Inactive = 'inactive'
-                }
-            `);
-            expect(result.issues.some(i => i.severity === 'info' && i.pattern.includes('enum'))).toBe(true);
-        });
-    });
-    describe('Project context', () => {
-        it('should return project versions in context', async () => {
-            await fs.writeFile(path.join(testDir, 'package.json'), JSON.stringify({
-                dependencies: {
-                    react: '^18.2.0',
-                    next: '^14.0.0'
-                },
-                devDependencies: {
-                    typescript: '^5.0.0'
-                }
-            }));
-            const detector = new StalenessDetector(testDir);
-            const result = await detector.checkStaleness('const x = 1;');
-            expect(result.projectContext.react).toBeDefined();
-            expect(result.projectContext.next).toBeDefined();
-            expect(result.projectContext.typescript).toBeDefined();
-        });
-    });
-    describe('Custom deprecations', () => {
-        it('should allow adding custom deprecation rules', async () => {
-            await fs.writeFile(path.join(testDir, 'package.json'), JSON.stringify({ dependencies: {} }));
-            const detector = new StalenessDetector(testDir);
-            detector.addDeprecation({
-                pattern: 'legacyFunction',
-                deprecatedIn: '1.0.0',
-                replacement: 'newFunction()',
-                severity: 'error',
-                reason: 'Custom deprecation'
-            });
-            const result = await detector.checkStaleness(`
-                legacyFunction();
-            `);
-            expect(result.issues.some(i => i.replacement === 'newFunction()')).toBe(true);
-        });
-    });
-    describe('Overall status', () => {
-        it('should return FRESH when no issues found', async () => {
-            await fs.writeFile(path.join(testDir, 'package.json'), JSON.stringify({ dependencies: {} }));
-            const detector = new StalenessDetector(testDir);
-            const result = await detector.checkStaleness(`
-                const name = 'test';
-                const greet = () => console.log('Hello');
-            `);
-            expect(result.status).toBe('FRESH');
-        });
-        it('should return STALE for warnings', async () => {
-            await fs.writeFile(path.join(testDir, 'package.json'), JSON.stringify({ dependencies: { redux: '^4.2.0' } }));
-            const detector = new StalenessDetector(testDir);
-            const result = await detector.checkStaleness(`
-                createStore(reducer);
-            `);
-            expect(result.status).toBe('STALE');
-        });
-        it('should return DEPRECATED for errors', async () => {
-            await fs.writeFile(path.join(testDir, 'package.json'), JSON.stringify({ dependencies: {} }));
-            const detector = new StalenessDetector(testDir);
-            const result = await detector.checkStaleness(`
-                new Buffer('hello');
-            `);
-            expect(result.status).toBe('DEPRECATED');
-        });
-    });
-});
-describe('checkCodeStaleness', () => {
-    let testDir;
-    beforeEach(async () => {
-        testDir = await fs.mkdtemp(path.join(os.tmpdir(), 'rigour-staleness-'));
-        await fs.writeFile(path.join(testDir, 'package.json'), JSON.stringify({ dependencies: {} }));
-    });
-    afterEach(async () => {
-        await fs.rm(testDir, { recursive: true, force: true });
-    });
-    it('should be a quick helper for staleness checking', async () => {
-        const result = await checkCodeStaleness(testDir, 'const x = 1;');
-        expect(result.status).toBe('FRESH');
-    });
-});

package/dist/review/agent-fixes.test.d.ts

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

package/dist/review/agent-fixes.test.js

@@ -1,32 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { listResolvedFixes, openFindingCount, recordReviewOutcome } from './agent-fixes.js';
-const finding = (file) => ({ id: 'semantic-bugs', title: 't', details: 'd', files: [file], line: 2 });
-describe('recordReviewOutcome', () => {
-    let cwd;
-    beforeEach(() => {
-        cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-fixes-'));
-        fs.writeFileSync(path.join(cwd, 'a.ts'), 'before\n');
-    });
-    afterEach(() => { fs.rmSync(cwd, { recursive: true, force: true }); });
-    it('stores the before and after once a reviewed file no longer has the finding', () => {
-        expect(recordReviewOutcome(cwd, [finding('a.ts')], ['a.ts'])).toMatchObject({ opened: 1, resolved: 0 });
-        fs.writeFileSync(path.join(cwd, 'a.ts'), 'after\n');
-        expect(recordReviewOutcome(cwd, [], ['a.ts'])).toMatchObject({ opened: 0, resolved: 1 });
-        const [fix] = listResolvedFixes(cwd);
-        expect(fix).toMatchObject({ file: 'a.ts', rule: 'semantic-bugs', before: 'before\n', after: 'after\n' });
-        expect(openFindingCount(cwd)).toBe(0);
-    });
-    it('keeps a finding open when its file was not part of the review (committed, not fixed)', () => {
-        recordReviewOutcome(cwd, [finding('a.ts')], ['a.ts']);
-        expect(recordReviewOutcome(cwd, [], ['other.ts'])).toMatchObject({ opened: 0, resolved: 0 });
-        expect(openFindingCount(cwd)).toBe(1);
-    });
-    it('does not count a finding that vanished without an edit as a fix', () => {
-        recordReviewOutcome(cwd, [finding('a.ts')], ['a.ts']);
-        expect(recordReviewOutcome(cwd, [], ['a.ts'])).toMatchObject({ opened: 0, resolved: 0 });
-        expect(listResolvedFixes(cwd)).toEqual([]);
-    });
-});

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

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

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

@@ -1,136 +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 { ledgerProblems, loadLedger, LEDGER_PATH, LedgerSchema } from './backtest.js';
-import { mergedPrs, scaffoldLedger } from './backtest-init.js';
-let repo;
-const git = (...args) => execFileSync('git', ['-C', repo, ...args], { encoding: 'utf8' }).trim();
-const config = ConfigSchema.parse({ version: 1 });
-const REVIEWS = [
-    { id: 1, user: { login: 'ci-bot', type: 'Bot' }, body: 'automated', state: 'COMMENTED', submitted_at: '2026-04-12T10:00:00Z', commit_id: 'c1c1c1c1c1' },
-    { id: 2, user: { login: 'senior', type: 'User' }, body: '## Review\n\n- A retry posts the invoice twice.\n- **Quadratic** scan in `latestPayment`.\nlooks good otherwise', state: 'CHANGES_REQUESTED', submitted_at: '2026-04-12T12:00:00Z', commit_id: 'c2c2c2c2c2' },
-];
-const INLINE = [
-    { path: 'src/lib/server/invoices.ts', line: 40, body: 'The export reads every line item for ids.\n\nNarrow it.', created_at: '2026-04-12T12:00:00Z' },
-    { path: 'src/checkout/total.ts', line: null, original_line: null, body: 'Drops the currency', created_at: '2026-04-12T12:00:00Z' },
-];
-function fakeExec(calls) {
-    return async (command, args, options) => {
-        calls.push([command, ...args]);
-        if (command === 'git') {
-            try {
-                return { exitCode: 0, stdout: execFileSync('git', args, { cwd: options.cwd, encoding: 'utf8', stdio: 'pipe' }), stderr: '' };
-            }
-            catch (error) {
-                return { exitCode: error.status ?? 1, stdout: '', stderr: String(error.stderr ?? '') };
-            }
-        }
-        if (args[0] === 'auth')
-            return { exitCode: 0, stdout: 'token\n', stderr: '' };
-        if (args[0] === 'pr')
-            return { exitCode: 0, stdout: 'author\n', stderr: '' };
-        if (args[1].endsWith('/reviews'))
-            return { exitCode: 0, stdout: JSON.stringify(REVIEWS), stderr: '' };
-        return { exitCode: 0, stdout: JSON.stringify(INLINE), stderr: '' };
-    };
-}
-beforeEach(() => {
-    repo = fs.mkdtempSync(path.join(os.tmpdir(), 'backtest-init-'));
-    git('init', '-q', '-b', 'main');
-    git('config', 'user.email', 't@example.com');
-    git('config', 'user.name', 't');
-    git('config', 'commit.gpgsign', 'false');
-    fs.writeFileSync(path.join(repo, 'a.ts'), 'export const a = 1;\n');
-    git('add', '-A');
-    execFileSync('git', ['-C', repo, 'commit', '-qm', 'main as of the review'], { env: { ...process.env, GIT_COMMITTER_DATE: '2026-04-12T09:00:00Z', GIT_AUTHOR_DATE: '2026-04-12T09:00:00Z' } });
-});
-afterEach(() => { fs.rmSync(repo, { recursive: true, force: true }); });
-describe('rigour backtest init', () => {
-    it('takes the base from where the reviewed commit left main, not from main as of the review', async () => {
-        const forked = git('rev-parse', 'HEAD');
-        git('checkout', '-q', '-b', 'feature');
-        fs.writeFileSync(path.join(repo, 'b.ts'), 'export const b = 1;\n');
-        git('add', '-A');
-        execFileSync('git', ['-C', repo, 'commit', '-qm', 'the branch'], { env: { ...process.env, GIT_COMMITTER_DATE: '2026-04-12T09:30:00Z', GIT_AUTHOR_DATE: '2026-04-12T09:30:00Z' } });
-        const reviewed = git('rev-parse', 'HEAD');
-        git('checkout', '-q', 'main');
-        fs.writeFileSync(path.join(repo, 'c.ts'), 'export const c = 1;\n');
-        git('add', '-A');
-        execFileSync('git', ['-C', repo, 'commit', '-qm', 'main moves on before the review'], { env: { ...process.env, GIT_COMMITTER_DATE: '2026-04-12T11:00:00Z', GIT_AUTHOR_DATE: '2026-04-12T11:00:00Z' } });
-        const realCommit = (calls) => async (command, args, options) => {
-            const answer = await fakeExec(calls)(command, args, options);
-            return command === 'gh' && args[1]?.endsWith('/reviews') ? { ...answer, stdout: JSON.stringify(REVIEWS.map(r => ({ ...r, commit_id: reviewed }))) } : answer;
-        };
-        const { rounds } = await scaffoldLedger(repo, 212, config, realCommit([]));
-        expect(rounds[0].base).toBe(forked);
-    });
-    it('writes one round per human review: inline comments become file-and-window points, body bullets need a pattern', async () => {
-        const calls = [];
-        const mainAtReview = git('rev-parse', 'HEAD');
-        const { rounds, incomplete } = await scaffoldLedger(repo, 212, config, fakeExec(calls));
-        expect(rounds).toHaveLength(1);
-        expect(rounds[0]).toMatchObject({ id: 'pr212-r1', commit: 'c2c2c2c2c2', base: mainAtReview, reviewed_at: '2026-04-12T12:00:00Z', pr: 212 });
-        expect(rounds[0].points).toEqual([
-            { id: 'R1-1', point: 'The export reads every line item for ids.', file: 'src/lib/server/invoices\\.ts', lines: [30, 50] },
-            { id: 'R1-2', point: 'Drops the currency', file: 'src/checkout/total\\.ts', needs: 'a line window or a text pattern (the comment has no line)' },
-            { id: 'R1-B1', point: 'A retry posts the invoice twice.', file: '', needs: 'a file pattern and a text pattern (this point was made in the review body, not on a line)' },
-            { id: 'R1-B2', point: 'Quadratic scan in latestPayment.', file: '', needs: 'a file pattern and a text pattern (this point was made in the review body, not on a line)' },
-        ]);
-        expect(incomplete).toBe(3);
-        expect(calls.find(c => c[0] === 'gh' && c[1] === 'pr')).toContain('212');
-        const written = LedgerSchema.parse(JSON.parse(fs.readFileSync(path.join(repo, LEDGER_PATH), 'utf8')));
-        expect(ledgerProblems(written)).toHaveLength(3);
-        expect(() => loadLedger(repo)).toThrow('rows a person still has to complete');
-    });
-    it('keeps rounds already in the ledger and replaces its own', async () => {
-        fs.mkdirSync(path.join(repo, '.rigour'));
-        fs.writeFileSync(path.join(repo, LEDGER_PATH), JSON.stringify({ rounds: [
-                { id: 'pr212-r1', commit: 'old0000', base: 'main', points: [], must_not_flag: [] },
-                { id: 'pr7-r1', commit: 'other00', base: 'main', points: [{ id: 'P', point: 'p', file: 'x', text: 'x' }], must_not_flag: [] },
-            ] }));
-        await scaffoldLedger(repo, 212, config, fakeExec([]));
-        const written = LedgerSchema.parse(JSON.parse(fs.readFileSync(path.join(repo, LEDGER_PATH), 'utf8')));
-        expect(written.rounds.map(r => [r.id, r.commit])).toEqual([['pr7-r1', 'other00'], ['pr212-r1', 'c2c2c2c2c2']]);
-    });
-});
-describe('the last N merged pull requests', () => {
-    const run = async (pages) => {
-        const limits = [];
-        const exec = async (command, args, options) => {
-            if (command === 'gh' && args[0] === 'auth')
-                return { exitCode: 0, stdout: 'token\n', stderr: '' };
-            if (command === 'gh' && args[0] === 'pr') {
-                expect(args).toEqual(expect.arrayContaining(['--search', 'sort:updated-desc', '--json', 'number,mergedAt,updatedAt']));
-                const limit = Number(args[args.indexOf('--limit') + 1]);
-                limits.push(limit);
-                return { exitCode: 0, stdout: JSON.stringify(pages(limit).slice(0, limit)), stderr: '' };
-            }
-            return fakeExec([])(command, args, options);
-        };
-        return { ...(await mergedPrs(repo, 2, config, exec)), limits };
-    };
-    const pr = (number, mergedAt, updatedAt = mergedAt) => ({ number, mergedAt: `2026-04-${mergedAt}T00:00:00Z`, updatedAt: `2026-04-${updatedAt}T00:00:00Z` });
-    it('keeps the N most recently merged: a long-lived pull request merged last is in, one merged first is out', async () => {
-        const { prs, incomplete, limits } = await run(() => [pr(3, '12'), pr(6, '10'), pr(5, '05'), pr(7, '01')]);
-        expect(prs.map(p => p.number)).toEqual([3, 6]);
-        expect(incomplete).toBe(false);
-        expect(limits).toEqual([8]); // fewer listed than asked for: that is everything
-    });
-    it('lists more when old pull requests touched after merge crowd the window, until the result is provably complete', async () => {
-        // Eight old pull requests a bot touched on the 20th, then the two real latest merges.
-        const all = [...Array.from({ length: 8 }, (_, i) => pr(100 + i, '02', '20')), pr(3, '12'), pr(6, '10'), pr(5, '05')];
-        const { prs, incomplete, limits } = await run(() => all);
-        expect(limits).toEqual([8, 16]); // the first page held only crowding bots' touches: its oldest update (the 20th) is after the merges kept
-        expect(prs.map(p => p.number)).toEqual([3, 6]);
-        expect(incomplete).toBe(false);
-    });
-    it('stops at the cap and says the result may be incomplete', async () => {
-        const crowd = Array.from({ length: 200 }, (_, i) => pr(1000 + i, '01', '28'));
-        const { incomplete, limits } = await run(() => crowd);
-        expect(limits).toEqual([8, 16, 32, 64]);
-        expect(incomplete).toBe(true);
-    });
-});

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

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

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

@@ -1,32 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { formatJudges, judgedFrom } from './backtest-judges.js';
-const base = { outcome: 'findings', items: [], unverified: [], resolved: [], answerInReply: [], notes: [], advisory: [], 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-last.test.d.ts

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

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

@@ -1,109 +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 { backtestLast, formatLast, scoreLast, LAST_LEDGER_PATH } from './backtest-last.js';
-import { roundsForPr } from './backtest-init.js';
-const config = ConfigSchema.parse({ version: 1 });
-const item = (file, line, blocking = true, gate = 'reviewer:claude') => ({ gate, file, line, text: `${file} scan has no upper bound`, blocking });
-const result = (round, items, caught = 0, costUsd) => ({ round, head: 'h', base: 'b', points: Array.from({ length: caught }, (_, i) => ({ id: `p${i}`, point: 'p', caught: true, noted: false })), falseBlocks: [], items, durationMs: 1000, ...(costUsd !== undefined ? { costUsd } : {}) });
-describe('the front door report', () => {
-    const ledger = { rounds: [
-            { id: 'pr7-r1', commit: 'c', base: 'b', reviewed_at: '2026-04-12T12:00:00Z', pr: 7, points: [{ id: 'R1-1', point: 'drops the currency', file: 'src/b\\.ts', lines: [1, 11] }], must_not_flag: [] },
-            { id: 'pr7-r2', commit: 'c', base: 'b', reviewed_at: '2026-04-12T13:00:00Z', pr: 7, points: [{ id: 'R2-1', point: 'the export reads every line item', file: 'src/a\\.ts', lines: [1, 11] }], must_not_flag: [] },
-            { id: 'pr7-r3', commit: 'c', base: 'b', reviewed_at: '2026-04-12T14:00:00Z', pr: 7, points: [{ id: 'R3-1', point: 'still unbounded', file: 'src/a\\.ts', lines: [1, 11] }], must_not_flag: [] },
-            { id: 'pr7-approved', commit: 'c', base: 'b', reviewed_at: '2026-04-12T15:00:00Z', pr: 7, points: [], must_not_flag: [] },
-            { id: 'pr8-approved', commit: 'c', base: 'b', reviewed_at: '2026-04-13T15:00:00Z', pr: 8, points: [], must_not_flag: [] },
-        ] };
-    it('counts points raised later that an earlier round blocked, with how many rounds earlier, and every block on an approved head', () => {
-        const results = [result('pr7-r1', [item('src/a.ts', 3)]), result('pr7-r2', [item('src/a.ts', 3)], 1, 1.5), result('pr7-r3', [], 0, 0.5), result('pr7-approved', [item('src/a.ts', 3)]), result('pr8-approved', [item('src/z.ts', 9, false)])];
-        const r = scoreLast(ledger, results);
-        expect(r).toMatchObject({ prs: 2, rounds: 5, approvedHeads: 2, pointsLater: 2, sameRound: 1, costUsd: 2 });
-        expect(r.early).toEqual([
-            { pr: 7, round: 'pr7-r1', point: 'the export reads every line item', by: 'reviewer:claude src/a.ts:3', roundsEarlier: 1 },
-            { pr: 7, round: 'pr7-r1', point: 'still unbounded', by: 'reviewer:claude src/a.ts:3', roundsEarlier: 2 }, // the earliest round that blocked it counts
-        ]);
-        expect(r.blocksOnApproved).toEqual([{ pr: 7, round: 'pr7-approved', item: item('src/a.ts', 3) }]); // an advisory item on pr8 is not a block
-        const text = formatLast({ ...r, skipped: ['pr9-r1: commit abcdef012 is not reachable (force-pushed away)'] });
-        expect(text.split('\n')[0]).toBe('1 blocking item(s) on 2 approved head(s): every one is a block the team would have overridden.'); // the worse number first
-        expect(text).toContain('2 of 2 point(s) people raised in a later round were already blocked, 1.5 round(s) earlier on average.');
-        expect(text).toContain('skipped pr9-r1: commit abcdef012');
-        const clean = formatLast({ ...scoreLast(ledger, results.map(x => (x.round.endsWith('-approved') ? { ...x, items: [] } : x))), skipped: [] });
-        expect(clean.split('\n')[0]).toContain('point(s) people raised in a later round were already blocked'); // nothing on approved heads: the catches lead
-        expect(clean).toContain('0 blocking items on 2 approved head(s).');
-    });
-});
-describe('rigour backtest --last', () => {
-    let repo;
-    const git = (...args) => execFileSync('git', ['-C', repo, ...args], { encoding: 'utf8' }).trim();
-    const commit = (message, date) => { git('add', '-A'); execFileSync('git', ['-C', repo, 'commit', '-qm', message], { env: { ...process.env, GIT_COMMITTER_DATE: date, GIT_AUTHOR_DATE: date } }); return git('rev-parse', 'HEAD'); };
-    let reviewed;
-    const fake = (calls) => async (command, args, options) => {
-        calls.push([command, ...args]);
-        if (command === 'git') {
-            if (args[0] === 'fetch')
-                return { exitCode: 0, stdout: '', stderr: '' }; // the head is already here
-            try {
-                return { exitCode: 0, stdout: execFileSync('git', args, { cwd: options.cwd, encoding: 'utf8', stdio: 'pipe' }), stderr: '' };
-            }
-            catch (error) {
-                return { exitCode: error.status ?? 1, stdout: '', stderr: String(error.stderr ?? '') };
-            }
-        }
-        if (args[0] === 'auth')
-            return { exitCode: 0, stdout: 'token\n', stderr: '' };
-        if (args[0] === 'pr' && args[1] === 'list')
-            return { exitCode: 0, stdout: JSON.stringify([{ number: 7, mergedAt: '2026-04-12T16:00:00Z' }, { number: 6, mergedAt: '2026-04-11T16:00:00Z' }]), stderr: '' };
-        if (args[0] === 'pr')
-            return { exitCode: 0, stdout: 'author\n', stderr: '' };
-        const pr = /pulls\/(\d+)\//.exec(args[1])?.[1];
-        if (args[1].endsWith('/reviews')) {
-            if (pr === '6')
-                return { exitCode: 0, stdout: JSON.stringify([{ id: 60, user: { login: 'author', type: 'User' }, body: 'self note', state: 'COMMENTED', submitted_at: '2026-04-11T12:00:00Z', commit_id: reviewed }]), stderr: '' };
-            return { exitCode: 0, stdout: JSON.stringify([
-                    { id: 1, user: { login: 'senior', type: 'User' }, body: 'first pass', state: 'CHANGES_REQUESTED', submitted_at: '2026-04-12T12:00:00Z', commit_id: reviewed },
-                    { id: 2, user: { login: 'senior', type: 'User' }, body: 'second pass', state: 'CHANGES_REQUESTED', submitted_at: '2026-04-12T13:00:00Z', commit_id: reviewed },
-                    { id: 3, user: { login: 'senior', type: 'User' }, body: '', state: 'APPROVED', submitted_at: '2026-04-12T14:00:00Z', commit_id: reviewed },
-                ]), stderr: '' };
-        }
-        if (args[1].includes('/reviews/1/'))
-            return { exitCode: 0, stdout: JSON.stringify([{ path: 'b.ts', line: 1, body: 'Drops the currency', created_at: '2026-04-12T12:00:00Z' }]), stderr: '' };
-        if (args[1].includes('/reviews/2/'))
-            return { exitCode: 0, stdout: JSON.stringify([{ path: 'a.ts', line: 1, body: 'The export reads every line item.', created_at: '2026-04-12T13:00:00Z' }]), stderr: '' };
-        return { exitCode: 0, stdout: '[]', stderr: '' };
-    };
-    beforeEach(() => {
-        repo = fs.mkdtempSync(path.join(os.tmpdir(), 'backtest-last-'));
-        git('init', '-q', '-b', 'main');
-        git('config', 'user.email', 't@example.com');
-        git('config', 'user.name', 't');
-        git('config', 'commit.gpgsign', 'false');
-        fs.writeFileSync(path.join(repo, 'a.ts'), 'export const a = 1;\n');
-        commit('main', '2026-04-12T09:00:00Z');
-        git('checkout', '-q', '-b', 'feature');
-        fs.writeFileSync(path.join(repo, 'b.ts'), 'export const b = 1;\n');
-        reviewed = commit('the branch', '2026-04-12T09:30:00Z');
-    });
-    afterEach(() => { fs.rmSync(repo, { recursive: true, force: true }); });
-    it('builds the ledger from the last merged pull requests, the approved head included, runs it and leads with the two numbers', async () => {
-        const calls = [];
-        const report = await backtestLast(repo, config, { last: 2, exec: fake(calls), collect: async () => ({ items: [item('a.ts', 1)], costUsd: 0.25 }) });
-        expect(report).toMatchObject({ prs: 1, rounds: 3, approvedHeads: 1, pointsLater: 1, sameRound: 1, costUsd: 0.75 });
-        expect(report.early).toEqual([{ pr: 7, round: 'pr7-r1', point: 'The export reads every line item.', by: 'reviewer:claude a.ts:1', roundsEarlier: 1 }]);
-        expect(report.blocksOnApproved.map(b => b.round)).toEqual(['pr7-approved']);
-        expect(report.skipped).toEqual(['pull request 6: pull request 6 has no review by a person yet']); // the author's own note is not a review
-        expect(calls.filter(c => c[0] === 'git' && c[1] === 'fetch').map(c => c.at(-1))).toEqual(['pull/7/head', 'pull/6/head']);
-        const written = JSON.parse(fs.readFileSync(path.join(repo, LAST_LEDGER_PATH), 'utf8'));
-        expect(written.rounds.map(r => [r.id, r.points.length])).toEqual([['pr7-r1', 1], ['pr7-r2', 1], ['pr7-approved', 0]]);
-        expect(formatLast(report).split('\n')[0]).toContain('1 blocking item(s) on 1 approved head(s)');
-    });
-    it('gives the scaffolder the approved head only when asked, with no points', async () => {
-        const calls = [];
-        const without = await roundsForPr(repo, 7, config, fake(calls));
-        expect(without.approved).toBeUndefined();
-        const withHead = await roundsForPr(repo, 7, config, fake(calls), { approvedHead: true });
-        expect(withHead.approved).toMatchObject({ id: 'pr7-approved', commit: reviewed, reviewed_at: '2026-04-12T14:00:00Z', points: [] });
-    });
-});

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

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