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

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

@@ -1,26 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { humanReviews } from './inputs.js';
-const pr = { number: 7, state: 'open', draft: false, author: 'author', body: '' };
-const reviews = [
-    { id: 1, user: { login: 'senior', type: 'User' }, body: 'Keep a separate case for a visitor with no account.', state: 'CHANGES_REQUESTED', submitted_at: '2026-09-25T18:09:11Z', commit_id: 'a0a0a0a0a0aa' },
-    { id: 2, user: { login: 'senior', type: 'User' }, body: '', state: 'APPROVED', submitted_at: '2026-09-28T15:12:53Z', commit_id: 'b1b1b1b1b1bb' },
-    { id: 3, user: { login: 'author', type: 'User' }, body: '', state: 'APPROVED', submitted_at: '2026-09-28T16:00:00Z', commit_id: 'b1b1b1b1b1bb' },
-];
-const gh = async (args) => ({ exitCode: 0, stdout: JSON.stringify(args[1].endsWith('/reviews') ? reviews : []), stderr: '' });
-describe('the human reviews a judge reads', () => {
-    it('keeps an approval without words: it settles the points its author raised before it', async () => {
-        const { reviews: read } = await humanReviews(gh, pr, undefined);
-        expect(read.markdown).toContain('## Review by senior, 2026-09-25T18:09:11Z, CHANGES_REQUESTED (on a0a0a0a0a)');
-        expect(read.markdown).toContain('## Review by senior, 2026-09-28T15:12:53Z, APPROVED (on b1b1b1b1b)\n\n(approved without comment: every point senior raised before this is settled)');
-        expect(read.approvals).toEqual([{ login: 'senior', at: '2026-09-28T15:12:53Z', commit: 'b1b1b1b1b1bb' }]); // the author's own approval is not a review
-        expect(read.count).toBe(1); // reviews with points: the judge must answer those, and an approval has none
-        expect(read.label).toBe('senior, 2026-09-28T15:12:53Z (1 review)');
-    });
-    it('hides the approval like any review from the reviewed moment on', async () => {
-        const { reviews: read } = await humanReviews(gh, pr, '2026-09-28T15:12:53Z');
-        expect(read.approvals).toEqual([]);
-        expect(read.markdown).not.toContain('APPROVED');
-        const later = await humanReviews(gh, pr, '2026-09-28T15:12:54.000Z');
-        expect(later.reviews.approvals).toHaveLength(1);
-    });
-});

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

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

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

@@ -1,110 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { clusterItems, similarity, statusOf } from './consensus.js';
-import { applyPanel, parseAnswers, runPanel } from './panel.js';
-let n = 0;
-const item = (file, line, cls, issue, consequence = 'wrong rows') => ({ id: `i${++n}`, kind: 'finding', class: cls, file, line, issue, consequence });
-/** Evidence counts only as a real file:line: here, any src/q.ts line. */
-const evidenced = (text) => /src\/q\.ts:\d+/.test(text);
-const members = (judges, items) => clusterItems(judges, items).map(c => c.members.map(m => `${m.judge}:${m.item.issue}`));
-describe('matching findings across judges', () => {
-    it('needs the same file, and shared wording unless it is the same line and class', () => {
-        const a = item('src/a.ts', 10, 'correctness', 'window not bounded at both ends', 'scans every past event');
-        expect(similarity(a, { ...a, file: 'src/b.ts' })).toBe(0);
-        expect(similarity(a, item('src/a.ts', 11, 'correctness', 'dedupe key changes when the user edits', 'duplicate emails go out'))).toBe(0);
-        expect(similarity(a, item('src/a.ts', 10, 'correctness', 'something else entirely', 'duplicate emails go out'))).toBeGreaterThanOrEqual(0.5);
-    });
-    it('keeps two different findings on adjacent lines apart, even listed in a misleading order (first-fit by line would cross them)', () => {
-        const judgeA = [item('src/q.ts', 10, 'production-cost', 'time window not bounded at both ends'), item('src/q.ts', 11, 'correctness', 'dedupe key changes when the user edits')];
-        const judgeB = [item('src/q.ts', 10, 'correctness', 'dedupe key built from updated_at changes when the user edits'), item('src/q.ts', 11, 'production-cost', 'read window has no upper bound at either end')];
-        expect(members(['a', 'b'], [judgeA, judgeB])).toEqual([
-            ['a:time window not bounded at both ends', 'b:read window has no upper bound at either end'],
-            ['a:dedupe key changes when the user edits', 'b:dedupe key built from updated_at changes when the user edits'],
-        ]);
-    });
-    it('matches one bug two judges cite at different lines', () => {
-        const judgeA = [item('src/q.ts', 10, 'correctness', 'lock is checked after the first read of rows')];
-        const judgeB = [item('src/q.ts', 40, 'correctness', 'the first read of rows happens before the lock is checked')];
-        expect(members(['a', 'b'], [judgeA, judgeB])).toHaveLength(1);
-    });
-    it('puts what one judge split under the one item another judge wrote', () => {
-        const judgeA = [item('src/q.ts', 10, 'production-cost', 'both reads, rows and cards, are unbounded')];
-        const judgeB = [item('src/q.ts', 10, 'production-cost', 'rows read is unbounded'), item('src/q.ts', 14, 'production-cost', 'cards read is unbounded')];
-        expect(members(['a', 'b'], [judgeA, judgeB])).toEqual([['a:both reads, rows and cards, are unbounded', 'b:rows read is unbounded', 'b:cards read is unbounded']]);
-    });
-    it('never merges one judge\'s own two findings, however close', () => {
-        const judgeA = [item('src/x.ts', 10, 'correctness', 'session.user may be null when the token expired'), item('src/x.ts', 12, 'correctness', 'session.expires compared as a string, not a date')];
-        expect(members(['a', 'b'], [judgeA, []])).toEqual([['a:session.user may be null when the token expired'], ['a:session.expires compared as a string, not a date']]);
-    });
-    it('groups three judges, and is the same every run', () => {
-        const items = [
-            [item('src/q.ts', 10, 'correctness', 'lock checked after the read')],
-            [item('src/q.ts', 11, 'correctness', 'the read happens before the lock is checked'), item('src/r.ts', 3, 'dead-code', 'export unused')],
-            [item('src/q.ts', 10, 'correctness', 'lock checked only after the read')],
-        ];
-        const once = members(['a', 'b', 'c'], items);
-        expect(once).toEqual(members(['a', 'b', 'c'], items));
-        expect(once.map(c => c.length)).toEqual([3, 1]);
-    });
-});
-describe('deciding a finding', () => {
-    it('confirms on a strict majority, drops on evidence against with nobody unsure, else disputes', () => {
-        expect(statusOf({ a: 'raised', b: 'raised' }, 2)).toBe('confirmed');
-        expect(statusOf({ a: 'raised', b: 'confirm' }, 2)).toBe('confirmed');
-        expect(statusOf({ a: 'raised', b: 'refute' }, 2)).toBe('dropped');
-        expect(statusOf({ a: 'raised', b: 'unsure' }, 2)).toBe('disputed');
-        expect(statusOf({ a: 'raised', b: 'raised' }, 3)).toBe('confirmed');
-        expect(statusOf({ a: 'raised', b: 'confirm', c: 'refute' }, 3)).toBe('confirmed');
-        expect(statusOf({ a: 'raised', b: 'refute', c: 'refute' }, 3)).toBe('dropped');
-        expect(statusOf({ a: 'raised', b: 'refute', c: 'unsure' }, 3)).toBe('disputed');
-    });
-    it('asks each judge once about what it did not raise, needs file:line evidence, and caps what it asks', async () => {
-        const asked = {};
-        const lone = item('src/q.ts', 10, 'correctness', 'lock checked after the read');
-        const refuted = item('src/q.ts', 30, 'correctness', 'the cursor skips the last page');
-        const bare = item('src/q.ts', 50, 'correctness', 'an index is missing on created_at');
-        const overCap = item('src/z.ts', 1, 'correctness', 'retries forever on 429');
-        const answers = { b: [{ id: lone.id, call: 'confirm', evidence: 'src/q.ts:12 reads before lock()' }, { id: refuted.id, call: 'refute', evidence: 'src/q.ts:33 the loop runs once more' }, { id: bare.id, call: 'confirm' }] };
-        const decided = await runPanel({
-            judges: ['a', 'b'], items: [[lone, refuted, bare, overCap], []], previousDisputed: [], touched: new Set(), maxItems: 3, evidenced,
-            ask: async (judge, items) => { asked[judge] = items.map(i => i.issue); return answers[judge] ?? []; },
-        });
-        expect(asked).toEqual({ b: ['lock checked after the read', 'the cursor skips the last page', 'an index is missing on created_at'] });
-        const status = Object.fromEntries(decided.map(d => [d.item.issue, d.status]));
-        expect(status).toEqual({ 'lock checked after the read': 'confirmed', 'the cursor skips the last page': 'dropped', 'an index is missing on created_at': 'disputed', 'retries forever on 429': 'disputed' });
-        expect(decided.find(d => d.item.id === overCap.id)?.note).toContain('panel_max_items');
-        expect(decided.find(d => d.item.id === lone.id)).toMatchObject({ judges: ['a'], calls: { a: 'raised', b: 'confirm' }, cross: [{ by: 'b', call: 'confirm', evidence: 'src/q.ts:12 reads before lock()' }] });
-    });
-    it('does not ask again about a finding disputed before on a file nothing has touched since', async () => {
-        const again = item('src/q.ts', 10, 'correctness', 'lock checked after the read');
-        const asked = [];
-        const ask = async (_judge, items) => { asked.push(...items.map(i => i.id)); return []; };
-        const untouched = await runPanel({ judges: ['a', 'b'], items: [[again], []], previousDisputed: [{ ...again, id: 'old' }], touched: new Set(), maxItems: 20, evidenced, ask });
-        expect(untouched[0]).toMatchObject({ status: 'disputed', note: 'disputed before; its file is unchanged since' });
-        expect(asked).toEqual([]);
-        await runPanel({ judges: ['a', 'b'], items: [[again], []], previousDisputed: [{ ...again, id: 'old' }], touched: new Set(['src/q.ts']), maxItems: 20, evidenced, ask });
-        expect(asked).toEqual([again.id]);
-    });
-    it('a judge that fails to answer leaves the findings disputed, never confirmed', async () => {
-        const lone = item('src/q.ts', 10, 'correctness', 'lock checked after the read');
-        const decided = await runPanel({ judges: ['a', 'b'], items: [[lone], []], previousDisputed: [], touched: new Set(), maxItems: 20, evidenced, ask: async () => { throw new Error('timed out'); } });
-        expect(decided[0]).toMatchObject({ status: 'disputed', calls: { a: 'raised', b: 'unsure' } });
-    });
-});
-describe('the panel in the accounting', () => {
-    it('blocks only on what it confirmed, and lists the rest', () => {
-        const confirmed = item('src/q.ts', 10, 'correctness', 'lock checked after the read');
-        const disputed = item('src/q.ts', 30, 'correctness', 'cursor skips a page');
-        const human = { ...item('', 0, 'prior point', 'a human point'), kind: 'prior' };
-        const result = applyPanel({ open: [confirmed, disputed, human] }, new Set([confirmed.id, disputed.id]), [
-            { item: confirmed, judges: ['a', 'b'], calls: { a: 'raised', b: 'raised' }, status: 'confirmed' },
-            { item: disputed, judges: ['a'], calls: { a: 'raised', b: 'unsure' }, status: 'disputed' },
-        ]);
-        expect(result.open.map(i => i.issue)).toEqual(['a human point', 'lock checked after the read']);
-        expect(result.open[1].reviewer).toBe('a+b');
-        expect(result.disputed.map(i => i.issue)).toEqual(['cursor skips a page']);
-    });
-    it('reads the answers out of a reply with prose around them, and nothing from a reply without them', () => {
-        expect(parseAnswers('Checked.\n```json\n{"answers":[{"id":"x","call":"refute","evidence":"a.ts:3"},{"id":"y","call":"maybe"}]}\n```')).toEqual([{ id: 'x', call: 'refute', evidence: 'a.ts:3' }]);
-        expect(parseAnswers('I could not decide.')).toEqual([]);
-    });
-});

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

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

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

@@ -1,32 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { buildRecord, recordIntact, recordLines } from './record.js';
-const item = (over) => ({ id: 'i1', kind: 'finding', class: 'correctness', file: 'src/job.ts', line: 2, issue: 'returns before the lock', quote: 'return 1;', ...over });
-const input = () => ({
-    head: 'abcdef0123456789', base: '0123456789abcdef', scope: 'full',
-    verdict: { prior_points: [], redundant: [], reads: [], scans: [], merge_impact: [], findings: [], carried: [], resolved_previous: [],
-        rules: [{ id: 'r1', status: 'followed' }, { id: 'r2', status: 'broken' }, { id: 'r3', status: 'not-applicable' }], lessons: [{ lesson: 'bound the window', applies: true }, { lesson: 'keyset', applies: false }] },
-    accounted: { open: [item({}), item({ id: 'p1', kind: 'prior', class: 'prior point', issue: 'take the lock' })], advisory: [item({ id: 's1', issue: 'could log the id' })], unverified: [item({ id: 'u1' })], notes: [item({ id: 'n1' }), item({ id: 'n2' })], resolved: [{ item: item({ id: 'old' }), evidence: 'fixed' }], answerInReply: [], disputed: [], dismissed: [item({ id: 'd1' })] },
-    judges: [{ reviewer: 'claude', version: '2.1.0', model: 'opus', cost_usd: 1.25, turns: 19 }],
-    lessonsServed: 4, humanReviews: 2, at: '2026-10-08T00:00:00Z',
-});
-describe('the review record', () => {
-    it('counts what was verified, what was reported and what people decided, and hashes it', () => {
-        const record = buildRecord(input());
-        expect(record.verified).toMatchObject({ rules: { served: 3, followed: 1, broken: 1, not_applicable: 1 }, lessons: { served: 4, applied: 1 }, prior_points: { open: 1, resolved: 1, answer_in_reply: 0 }, unverified: 1, notes: 2, disputed: 0 });
-        expect(record.verified.blocking).toHaveLength(2);
-        expect(record.verified.should_fix).toHaveLength(1);
-        expect(record).toMatchObject({ reported: { human_reviews: 2 }, people: { dismissed: 1 }, judges: [{ reviewer: 'claude', turns: 19 }] });
-        expect(record.integrity).toMatch(/^[0-9a-f]{64}$/);
-        expect(buildRecord(input()).integrity).toBe(record.integrity); // the same review hashes the same
-        expect(recordIntact(record)).toBe(true);
-        expect(recordIntact({ ...record, verified: { ...record.verified, blocking: [] } })).toBe(false); // a block removed after the fact shows
-    });
-    it('renders for a pull request: blocks in full, a few should-fixes, the counts, the judges and the hash', () => {
-        const lines = recordLines(buildRecord(input()), 1);
-        expect(lines[0]).toBe('**Review record** · 2 blocking · 1 should-fix · rules 1 followed, 1 broken, 1 not applicable of 3 · lessons 1 of 4 apply · prior points 1 open, 1 resolved');
-        expect(lines).toContain('- **Blocking** `src/job.ts:2` returns before the lock');
-        expect(lines).toContain('- Should fix: `src/job.ts:2` could log the id');
-        expect(lines.at(-2)).toBe('Also seen, never blocking: 2 working notes, 1 unverified, 1 dismissed.');
-        expect(lines.at(-1)).toMatch(/^Judged by claude 2\.1\.0 \(opus\) \$1\.25 on `abcdef012` against `012345678` \(full\); 2 human review\(s\) seen\. Integrity `[0-9a-f]{16}`\.$/);
-    });
-});

package/dist/review/reviewer/rule-writer.test.d.ts

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

package/dist/review/reviewer/rule-writer.test.js

@@ -1,52 +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 { ruleWriterFor } from './rule-writer.js';
-let repo;
-let bin;
-const originalPath = process.env.PATH;
-beforeEach(() => {
-    repo = fs.mkdtempSync(path.join(os.tmpdir(), 'rule-writer-'));
-    execFileSync('git', ['-C', repo, 'init', '-q', '-b', 'main']);
-    bin = fs.mkdtempSync(path.join(os.tmpdir(), 'rule-writer-bin-'));
-    fs.writeFileSync(path.join(bin, process.platform === 'win32' ? 'claude.cmd' : 'claude'), '#!/bin/sh\nexit 0\n', { mode: 0o755 });
-    process.env.PATH = [bin, originalPath ?? ''].join(path.delimiter);
-});
-afterEach(() => {
-    process.env.PATH = originalPath;
-    for (const dir of [repo, bin])
-        fs.rmSync(dir, { recursive: true, force: true });
-});
-/** Answers git for real, the fake claude with a priced reply, and any other copy of claude as not installed. */
-function fake(calls) {
-    return async (command, args, options) => {
-        if (command === 'git')
-            return { exitCode: 0, stdout: execFileSync('git', args, { cwd: options.cwd, encoding: 'utf8' }), stderr: '' };
-        if (!command.startsWith(bin))
-            return { exitCode: 127, stdout: '', stderr: 'not found' };
-        if (args[0] === '--version')
-            return { exitCode: 0, stdout: '2.1.0 (Claude Code)\n', stderr: '' };
-        calls.push({ args, unset: options.unset });
-        return { exitCode: 0, stdout: JSON.stringify({ result: '{"rules":[]}', total_cost_usd: 0.6 }), stderr: '' };
-    };
-}
-describe('the rule writer', () => {
-    it('runs the team reviewer CLI isolated like a judge, counts its cost, and stops at the daily cap', async () => {
-        const calls = [];
-        const config = ConfigSchema.parse({ version: 1, review: { reviewer: { reviewers: ['claude'], max_usd_per_day: 1 } } });
-        const write = (await ruleWriterFor(repo, config, fake(calls)));
-        expect(await write('first')).toBe('{"rules":[]}');
-        expect(await write('second')).toBe('{"rules":[]}'); // $0.60 spent: under the $1 cap
-        expect(await write('third')).toBeUndefined(); // $1.20: the cap is reached, no call made
-        expect(calls).toHaveLength(2);
-        expect(calls[0].args).toEqual(expect.arrayContaining(['--strict-mcp-config', '--disallowedTools', 'Edit', 'Write']));
-        expect(calls[0].unset).toContain('RIGOUR_API_KEY');
-    });
-    it('is not available when no reviewer CLI is installed', async () => {
-        const config = ConfigSchema.parse({ version: 1, review: { reviewer: { reviewers: ['codex'] } } });
-        expect(await ruleWriterFor(repo, config, fake([]))).toBeUndefined();
-    });
-});

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

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

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

@@ -1,57 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { ConfigSchema } from '../../types/index.js';
-import { resolveReviewer } from './settings.js';
-const team = (reviewer = {}) => ConfigSchema.parse({ version: 1, review: { reviewer } });
-describe('the reviewer settings a run uses', () => {
-    it('is one judge, no panel, until someone asks', () => {
-        expect(resolveReviewer(team(), {}, undefined, {})).toMatchObject({ enabled: false, mode: 'single', panel: false, judges: 2, escalate: 'always', source: { mode: 'team', panel: 'team' }, refused: [] });
-    });
-    it('takes the nearest layer: a flag, then the environment, then the person, then the team', () => {
-        const user = { enabled: true, mode: 'full', panel: true, judges: 3 };
-        expect(resolveReviewer(team({ mode: 'single' }), {}, user, {})).toMatchObject({ enabled: true, mode: 'full', panel: true, judges: 3, source: { mode: 'user', panel: 'user' } });
-        expect(resolveReviewer(team(), {}, user, { RIGOUR_REVIEWER_PANEL: 'off', RIGOUR_REVIEWER_MODE: 'cross' })).toMatchObject({ mode: 'cross', panel: false, source: { mode: 'env', panel: 'env' } });
-        expect(resolveReviewer(team(), { mode: 'single', panel: false }, user, { RIGOUR_REVIEWER_MODE: 'full' })).toMatchObject({ mode: 'single', source: { mode: 'flag' } });
-    });
-    it('turns a panel into a full review, since it needs two vendors', () => {
-        expect(resolveReviewer(team({ mode: 'single' }), { panel: true }, undefined, {})).toMatchObject({ mode: 'full', panel: true, source: { mode: 'flag', panel: 'flag' } });
-    });
-    it('keeps the team floor, and says what it refused', () => {
-        const floor = team({ mode: 'full', panel: 'required', mode_required: true });
-        const resolved = resolveReviewer(floor, { mode: 'single', panel: false }, { escalate: 'risk' }, {});
-        expect(resolved).toMatchObject({ mode: 'full', panel: true, escalate: 'always', required: { mode: true, panel: true } });
-        expect(resolved.refused).toEqual([
-            'panel off (flag) refused: rigour.yml sets review.reviewer.panel: required',
-            'mode single (flag) refused: rigour.yml sets review.reviewer.mode_required with mode full',
-            'escalate risk (user) refused: rigour.yml requires every review to be full',
-        ]);
-    });
-    it('reports an environment value it does not understand instead of ignoring it quietly', () => {
-        expect(resolveReviewer(team(), {}, undefined, { RIGOUR_REVIEWER_MODE: 'triple', RIGOUR_REVIEWER_PANEL: 'maybe' }).refused).toEqual([
-            'RIGOUR_REVIEWER_MODE=triple ignored: use single, cross or full',
-            'RIGOUR_REVIEWER_PANEL=maybe ignored: use on or off',
-        ]);
-    });
-    it('lets a nearer choice of one judge turn a panel off, unless the team requires it, and says when it refuses', () => {
-        expect(resolveReviewer(team({ mode: 'full', panel: 'on' }), { mode: 'single' }, undefined, {})).toMatchObject({ mode: 'single', panel: false, refused: [] });
-        expect(resolveReviewer(team(), { mode: 'single' }, { panel: true }, {})).toMatchObject({ mode: 'single', panel: false }); // the flag is nearer than your setting
-        const user = resolveReviewer(team(), {}, { mode: 'single', panel: true }, {});
-        expect(user).toMatchObject({ mode: 'full', panel: true });
-        expect(user.refused).toEqual(['mode single (user) refused: the panel (user) needs judges from two vendors']);
-        expect(resolveReviewer(team({ mode: 'full', panel: 'required' }), { mode: 'single' }, undefined, {}).refused).toEqual(['mode single (flag) refused: rigour.yml sets review.reviewer.panel: required']);
-    });
-    it('under a team floor a person cannot turn reviews off or lower the judges', () => {
-        const floor = team({ enabled: true, mode: 'full', judges: 3, mode_required: true });
-        const resolved = resolveReviewer(floor, {}, { enabled: false, judges: 2 }, {});
-        expect(resolved).toMatchObject({ enabled: true, judges: 3 });
-        expect(resolved.refused).toEqual(['reviews off (user) refused: rigour.yml requires the reviewer', 'judges 2 (user) refused: rigour.yml requires 3']);
-        expect(resolveReviewer(team({ enabled: true }), {}, { enabled: false, judges: 3 }, {})).toMatchObject({ enabled: false, judges: 3 }); // no floor: your choice
-    });
-    it('takes the lower daily cap: a person can spend less than the team allows, never more', () => {
-        expect(resolveReviewer(team({ max_runs_per_day: 20, max_usd_per_day: 5 }), {}, { max_runs_per_day: 6 }, {})).toMatchObject({ max_runs_per_day: 6, max_usd_per_day: 5, refused: [] });
-        const higher = resolveReviewer(team({ max_runs_per_day: 20 }), {}, { max_runs_per_day: 50 }, {});
-        expect(higher.max_runs_per_day).toBe(20);
-        expect(higher.refused).toEqual(['max_runs_per_day 50 (user) refused: rigour.yml caps it at 20']);
-        expect(resolveReviewer(team(), {}, { max_usd_per_day: 2 }, {})).toMatchObject({ max_usd_per_day: 2 }); // no team cap: yours
-        expect(resolveReviewer(team(), {}, undefined, {}).max_runs_per_day).toBeUndefined(); // unset by default
-    });
-});

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

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

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

@@ -1,14 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { reviewerUsage } from './usage.js';
-const item = { id: 'abcdef0123', kind: 'finding', class: 'correctness', file: 'src/secret-path.ts', line: 2, issue: 'private text' };
-describe('reviewer usage telemetry', () => {
-    it('reports counts and buckets only: never file names, finding text or ids', () => {
-        const result = { outcome: 'findings', items: [item], unverified: [], resolved: [], answerInReply: [], notes: [], advisory: [], disputed: [item, item], dropped: [], dismissed: [], reviewers: ['claude', 'codex', 'cursor'], scope: 'delta', cached: false, costUsd: 0.7, runs: 5,
-            mode: { asked: 'panel', ran: 'panel', source: 'team', escalation: '2 risky changed function(s)' } };
-        const usage = reviewerUsage(result, 'push');
-        expect(usage).toEqual({ outcome: 'findings', trigger: 'push', scope: 'delta', asked: 'panel', ran: 'panel', source: 'team', degraded: false, escalation: 'all-judges', refused: 0, judges: 3, cached: false, confirmed: 1, disputed: 2, dropped: 0, notes: 0, dismissed: 0, runs: 5, cost_bucket: '$0.50-2' });
-        const text = JSON.stringify(usage);
-        for (const leak of ['secret-path', 'private text', 'abcdef0123'])
-            expect(text).not.toContain(leak);
-    });
-});

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

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