@rigour-labs/core 6.8.0 → 6.8.1

package/dist/review/deep-runs.test.d.ts

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

package/dist/review/deep-runs.test.js

@@ -1,23 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { appendDeepRun, readDeepRuns, summarizeDeepRuns } from './deep-runs.js';
-let dir;
-beforeEach(() => { dir = fs.mkdtempSync(path.join(os.tmpdir(), 'deep-runs-')); });
-afterEach(() => { fs.rmSync(dir, { recursive: true, force: true }); });
-describe('deep runs', () => {
-    it('records what each run spent and sums only what was reported', () => {
-        appendDeepRun(dir, { enabled: true, status: 'ok', tier: 'cloud', cost_usd: 0.25, input_tokens: 1000, output_tokens: 100,
-            router: { functions: 10, routed: 3, files_skipped: 2, already_reviewed: 1 }, tool_calls: 7, findings_count: 2 });
-        appendDeepRun(dir, { enabled: true, status: 'partial', tier: 'cloud', input_tokens: 500, output_tokens: 50 });
-        appendDeepRun(dir, { enabled: true, status: 'ok', tier: 'lite' });
-        appendDeepRun(dir, { enabled: true, status: 'error', tier: 'cloud', cost_usd: 9 }); // nothing ran: not a run
-        const runs = readDeepRuns(dir);
-        expect(runs).toHaveLength(3);
-        expect(summarizeDeepRuns(runs)).toEqual({
-            runs: 3, costUsd: 0.25, unpricedRuns: 1, inputTokens: 1500, outputTokens: 150,
-            functionsRanked: 10, functionsRouted: 3, alreadyReviewed: 1, toolCalls: 7, findingsKept: 2,
-        });
-    });
-});

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

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

package/dist/review/effectiveness.test.js

@@ -1,42 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { describe, expect, it } from 'vitest';
-import { appendAgentEvent, computeEffectiveness, readAgentEvents } from './effectiveness.js';
-const review = (failures) => [
-    { type: 'tool_call', tool: 'rigour_review' },
-    { type: 'tool_response', tool: 'rigour_review', content: [{ type: 'text', text: JSON.stringify({ status: failures.length ? 'FAIL' : 'PASS', failures }) }] },
-];
-describe('computeEffectiveness', () => {
-    it('counts reviews, findings resolved by later reviews, and tool calls', () => {
-        const events = [
-            { type: 'tool_call', tool: 'rigour_recall' },
-            ...review([{ id: 'semantic-bugs', file: 'a.ts' }, { id: 'promise-safety', file: 'b.ts' }]),
-            ...review([{ id: 'promise-safety', file: 'b.ts' }]),
-            ...review([]),
-        ];
-        expect(computeEffectiveness(events)).toMatchObject({
-            reviews: 3, failedReviews: 2, findingsReported: 2, findingsResolved: 2,
-            toolCalls: { rigour_recall: 1, rigour_review: 3 },
-        });
-    });
-    it('follows a blocked stop through to a clean stop in the same session, and counts self-reviews', () => {
-        const events = [
-            { type: 'stop_review', session: 's1', blocked: true },
-            ...review([]),
-            { type: 'stop_review', session: 's1', blocked: false },
-            { type: 'stop_review', session: 's2', blocked: false },
-        ];
-        expect(computeEffectiveness(events)).toMatchObject({
-            stopChecks: 3, stopBlocks: 1, blockedStopsFollowedThrough: 1, stopsWithSelfReview: 1,
-        });
-    });
-    it('reads the log it writes and skips malformed lines', () => {
-        const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'effectiveness-'));
-        appendAgentEvent(dir, { type: 'stop_review', blocked: true });
-        fs.appendFileSync(path.join(dir, '.rigour', 'events.jsonl'), 'not json\n');
-        expect(readAgentEvents(dir).map(e => e.type)).toEqual(['stop_review']);
-        expect(readAgentEvents(path.join(dir, 'missing'))).toEqual([]);
-        fs.rmSync(dir, { recursive: true, force: true });
-    });
-});

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

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

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

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

package/dist/review/generated-files.test.d.ts

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

package/dist/review/generated-files.test.js

@@ -1,25 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { isGeneratedFile, withoutGenerated } from './generated-files.js';
-let dir;
-beforeEach(() => { dir = fs.mkdtempSync(path.join(os.tmpdir(), 'generated-')); });
-afterEach(() => { fs.rmSync(dir, { recursive: true, force: true }); });
-describe('generated files', () => {
-    it('recognises generated files by name and by the marker at their top', () => {
-        fs.writeFileSync(path.join(dir, 'client.ts'), '// This file is auto-generated by @hey-api/openapi-ts\nexport const x = 1;\n');
-        fs.writeFileSync(path.join(dir, 'schema.ts'), '/* eslint-disable */\n// @generated by protoc\n');
-        fs.writeFileSync(path.join(dir, 'handwritten.ts'), "// Generates the client; edit freely.\nexport const generate = () => 'x';\n");
-        expect(isGeneratedFile(dir, 'client.ts')).toBe(true);
-        expect(isGeneratedFile(dir, 'schema.ts')).toBe(true);
-        expect(isGeneratedFile(dir, 'src/api/client.gen.ts')).toBe(true);
-        expect(isGeneratedFile(dir, 'src/__generated__/types.ts')).toBe(true);
-        expect(isGeneratedFile(dir, 'handwritten.ts')).toBe(false);
-        expect(isGeneratedFile(dir, 'src/missing.ts')).toBe(false);
-    });
-    it('drops generated files from the change under review', () => {
-        const changed = { 'src/a.ts': new Set([1]), 'src/b.gen.ts': new Set([2]) };
-        expect(Object.keys(withoutGenerated(dir, changed))).toEqual(['src/a.ts']);
-    });
-});

package/dist/review/migration-order.test.d.ts

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

package/dist/review/migration-order.test.js

@@ -1,62 +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 { addedFiles, migrationOrderFailures } from './migration-order.js';
-let repo;
-const git = (...args) => execFileSync('git', ['-C', repo, ...args], { encoding: 'utf8' });
-const write = (rel, body = 'select 1;\n') => {
-    fs.mkdirSync(path.dirname(path.join(repo, rel)), { recursive: true });
-    fs.writeFileSync(path.join(repo, rel), body);
-};
-const commit = (message) => { git('add', '-A'); git('commit', '-qm', message); };
-const config = (enabled = true) => ConfigSchema.parse({ version: 1, gates: { migration_order: { enabled } } });
-const DIR = 'supabase/migrations';
-beforeEach(() => {
-    repo = fs.mkdtempSync(path.join(os.tmpdir(), 'migration-order-'));
-    git('init', '-q', '-b', 'main');
-    git('config', 'user.email', 't@example.com');
-    git('config', 'user.name', 't');
-    git('config', 'commit.gpgsign', 'false');
-    write(`${DIR}/20260101000000_init.sql`);
-    commit('init');
-});
-afterEach(() => fs.rmSync(repo, { recursive: true, force: true }));
-describe('migrationOrderFailures', () => {
-    it('flags a branch migration dated before one main merged since', () => {
-        git('checkout', '-q', '-b', 'feature');
-        write(`${DIR}/20260107000000_feature.sql`);
-        commit('feature');
-        git('checkout', '-q', 'main');
-        write(`${DIR}/20260110000000_main.sql`);
-        commit('main moved');
-        git('checkout', '-q', 'feature');
-        const source = { mode: 'base', base: 'main' };
-        const failures = migrationOrderFailures(repo, diffFromGit(repo, source), source, config());
-        expect(failures).toEqual([expect.objectContaining({
-                id: 'migration-order', files: [`${DIR}/20260107000000_feature.sql`], line: 1,
-            })]);
-        expect(failures[0].details).toContain('20260110000000_main.sql');
-    });
-    it('passes a migration dated after the newest on the base, and uncommitted work against HEAD', () => {
-        write(`${DIR}/20260201000000_next.sql`);
-        expect(migrationOrderFailures(repo, diffFromGit(repo), { mode: 'working' }, config())).toEqual([]);
-        write(`${DIR}/20251231000000_old.sql`);
-        expect(migrationOrderFailures(repo, diffFromGit(repo), { mode: 'working' }, config()).map(f => f.files)).toEqual([[`${DIR}/20251231000000_old.sql`]]);
-    });
-    it('checks only the configured directories, and only when enabled', () => {
-        write('db/migrations/0001_old.sql');
-        write(`${DIR}/20251231000000_old.sql`);
-        expect(migrationOrderFailures(repo, diffFromGit(repo), { mode: 'working' }, config(false))).toEqual([]);
-        expect(migrationOrderFailures(repo, diffFromGit(repo), { mode: 'working' }, config()).map(f => f.files[0])).toEqual([`${DIR}/20251231000000_old.sql`]);
-    });
-});
-describe('addedFiles', () => {
-    it('lists only files the diff creates', () => {
-        const diff = ['--- /dev/null', '+++ b/new.sql', '@@ -0,0 +1 @@', '+x', '--- a/old.sql', '+++ b/old.sql'].join('\n');
-        expect(addedFiles(diff)).toEqual(['new.sql']);
-    });
-});

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

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

package/dist/review/quiet.test.js

@@ -1,38 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { dismissFinding, findingKey, quietSplit } from './quiet.js';
-let dir;
-beforeEach(() => { dir = fs.mkdtempSync(path.join(os.tmpdir(), 'quiet-')); });
-afterEach(() => { fs.rmSync(dir, { recursive: true, force: true }); });
-const finding = (id, details = 'd', line = 3) => ({ id, title: id, details, files: ['src/a.ts'], line });
-describe('quiet by default', () => {
-    it('lets only findings that prove a defect speak; heuristics are advisory unless the team asks for them', () => {
-        const all = [finding('semantic-bugs'), finding('security-patterns'), finding('promise-safety'), finding('file-size'), finding('deep-analysis')];
-        const quiet = quietSplit(dir, all);
-        expect(quiet.speaking.map(f => f.id)).toEqual(['semantic-bugs', 'security-patterns', 'deep-analysis']);
-        expect(quiet.advisory.map(f => f.id)).toEqual(['promise-safety', 'file-size']);
-        expect(quietSplit(dir, all, true).speaking).toHaveLength(5);
-    });
-    it('speaks on what must be fixed, the one rule the stop hook and the push gate share: critical, or high and verified or from a security gate', () => {
-        const all = [
-            { ...finding('frontend-secret-exposure'), severity: 'high', provenance: 'security' },
-            { ...finding('promise-safety'), severity: 'high' },
-            { ...finding('promise-safety', 'verified'), severity: 'high', verified: true },
-            { ...finding('file-size'), severity: 'critical' },
-            finding('migration-order'),
-        ];
-        expect(quietSplit(dir, all).speaking.map(f => f.id)).toEqual(['frontend-secret-exposure', 'promise-safety', 'file-size', 'migration-order']);
-        expect(quietSplit(dir, all).advisory.map(f => f.details)).toEqual(['d']);
-    });
-    it('never reports a dismissed finding again, even after its line moves', () => {
-        const leak = finding('security-patterns', 'Hardcoded token in `client`');
-        expect(dismissFinding(dir, findingKey(leak), 'test fixture token, never deployed')).toBe(true);
-        expect(dismissFinding(dir, findingKey(leak), 'again')).toBe(true); // idempotent
-        const moved = { ...leak, line: 40 };
-        expect(quietSplit(dir, [moved, finding('semantic-bugs')])).toMatchObject({ dismissed: 1, dismissedByGate: { 'security-patterns': 1 }, speaking: [expect.objectContaining({ id: 'semantic-bugs' })] });
-        expect(JSON.parse(fs.readFileSync(path.join(dir, '.rigour/dismissed.json'), 'utf8')).entries).toHaveLength(1);
-        expect(dismissFinding(dir, 'not-a-key', 'x')).toBe(false);
-    });
-});

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

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

package/dist/review/receipt.test.js

@@ -1,60 +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 { findFunction } from '../deep/risk.js';
-import { diffFromGit } from './git-diff.js';
-import { recordReview } from './ledger.js';
-import { buildQualityReceipt } from './receipt.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 review = (file, fn, reviewer = 'agent') => {
-    const found = findFunction(repo, file, fn);
-    recordReview(repo, { file, function: fn, hash: found.hash, reviewer, verdict: 'no_issue', note: 'checked' });
-};
-beforeEach(() => {
-    repo = fs.mkdtempSync(path.join(os.tmpdir(), 'receipt-'));
-    git('init', '-q', '-b', 'main');
-    git('config', 'user.email', 't@example.com');
-    git('config', 'user.name', 't');
-    git('config', 'commit.gpgsign', 'false');
-    write('.gitignore', '.rigour/\n');
-    write('src/pay.ts', 'export const x = 1;\n');
-    git('add', '-A');
-    git('commit', '-qm', 'init');
-});
-afterEach(() => fs.rmSync(repo, { recursive: true, force: true }));
-// Risky: a data write. Low risk: a formatter. Each in its own function.
-const RISKY = (n) => `export async function saveRefund${n}(db: any, cents: number) {\n  return db.insert({ cents: cents + ${n} });\n}\n`;
-const PLAIN = 'export function label(name: string) {\n  return name.trim();\n}\n';
-describe('buildQualityReceipt', () => {
-    it('says what was reviewed at its current code, what changed after review, what is low risk, and what is not covered', () => {
-        write('src/pay.ts', RISKY(1) + RISKY(2) + RISKY(3) + PLAIN);
-        write('config/app.yml', 'a: 1\n');
-        review('src/pay.ts', 'saveRefund1');
-        review('src/pay.ts', 'saveRefund2');
-        write('src/pay.ts', RISKY(1) + RISKY(2).replace('cents + 2', 'cents + 20') + RISKY(3) + PLAIN); // edited after its review
-        const receipt = buildQualityReceipt(repo, diffFromGit(repo));
-        expect(receipt).toMatchObject({ functions: 4, reviewed: 1, changedSinceReview: 1, lowRisk: 1, otherFiles: 1, setAside: 0, reviewers: { agent: 1 } });
-        expect(receipt.notCovered.map(g => [g.function, g.changedSinceReview])).toEqual([['saveRefund2', true], ['saveRefund3', false]]);
-    });
-    it('counts no self-reported review when independent, and says how many it set aside', () => {
-        write('src/pay.ts', RISKY(1) + RISKY(2));
-        review('src/pay.ts', 'saveRefund1');
-        const receipt = buildQualityReceipt(repo, diffFromGit(repo), { independent: true });
-        expect(receipt).toMatchObject({ reviewed: 0, setAside: 1 });
-        expect(receipt.notCovered).toHaveLength(2);
-    });
-    it('treats a function matching a verified team lesson as risky, and says which lesson', () => {
-        write('src/pay.ts', 'export function formatTotal(totalCents: number) {\n  return (totalCents / 100).toFixed(2);\n}\n');
-        write('.rigour/review-lessons.json', JSON.stringify({ version: 1, lessons: [{
-                    id: 'l1', text: 'Format money from integer cents, never floats.', file: 'src/pay.ts', symbols: ['totalCents'],
-                    state: 'verified', evidence: [{ pr: 12, comment: 'c', author: 'reviewer' }], createdAt: '', updatedAt: '',
-                }] }));
-        const withLesson = buildQualityReceipt(repo, diffFromGit(repo));
-        expect(withLesson.notCovered).toEqual([expect.objectContaining({ function: 'formatTotal', lesson: 'Format money from integer cents, never floats.' })]);
-        expect(buildQualityReceipt(repo, diffFromGit(repo), { lessonMode: 'off' }).notCovered).toEqual([]);
-    });
-});

package/dist/review/review-task.test.d.ts

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

package/dist/review/review-task.test.js

@@ -1,89 +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 { diffFromGit } from './git-diff.js';
-import { acknowledgeReview } from './review-ack.js';
-import { buildReviewTask } from './review-task.js';
-import { exportReviewed, readLedger, REVIEWED_FILE } from './ledger.js';
-import { reviewAckMessage } from '../hooks/stop-review.js';
-import { writeLessons } from '../review-learning/lessons.js';
-let repo;
-const git = (...args) => execFileSync('git', ['-C', repo, ...args], { encoding: 'utf8' });
-const write = (body) => fs.writeFileSync(path.join(repo, 'sync.ts'), body);
-const BEFORE = [
-    'export async function syncOrders(db, cursor) {',
-    '  const rows = await page(cursor);',
-    '  return rows;',
-    '}',
-    'function label(name) {',
-    '  return name;',
-    '}',
-    '',
-].join('\n');
-const AFTER = [
-    'export async function syncOrders(db, cursor) {',
-    '  const rows = await page(cursor);',
-    "  await db.from('orders').upsert(rows);",
-    '  return rows;',
-    '}',
-    'function label(name) {',
-    '  return name.trim();',
-    '}',
-    '',
-].join('\n');
-beforeEach(() => {
-    repo = fs.mkdtempSync(path.join(os.tmpdir(), 'review-task-'));
-    git('init', '-q', '-b', 'main');
-    git('config', 'user.email', 't@example.com');
-    git('config', 'user.name', 't');
-    git('config', 'commit.gpgsign', 'false');
-    write(BEFORE);
-    git('add', '-A');
-    git('commit', '-q', '-m', 'base');
-    write(AFTER);
-});
-afterEach(() => { fs.rmSync(repo, { recursive: true, force: true }); });
-describe('review task and acknowledgements', () => {
-    it('asks about the risky changed function only, with questions from its signals', () => {
-        const task = buildReviewTask(repo, diffFromGit(repo));
-        expect(task.items.map(i => i.function)).toEqual(['syncOrders']);
-        expect(task.items[0].questions[0]).toMatch(/concurrent calls/);
-        expect(task.items[0].questions.at(-1)).toContain('`syncOrders`');
-    });
-    it('sends a function a verified team lesson names to review, and asks whether the change repeats it', () => {
-        write(AFTER.replace('name.trim()', 'name.toLocaleUpperCase()'));
-        writeLessons(repo, [{ id: 'l1', text: 'Locale casing breaks Turkish names.', file: 'sync.ts', symbols: ['toLocaleUpperCase'], state: 'verified', evidence: [{ pr: 7, comment: 'c1', author: 'r' }], createdAt: '', updatedAt: '' }]);
-        const task = buildReviewTask(repo, diffFromGit(repo));
-        const label = task.items.find(i => i.function === 'label');
-        expect(label?.questions[0]).toContain('Locale casing breaks Turkish names.');
-        expect(buildReviewTask(repo, diffFromGit(repo), {}, 'off').items.map(i => i.function)).toEqual(['syncOrders']);
-    });
-    it('drops an acknowledged function from the task until its code changes again', () => {
-        const ack = acknowledgeReview(repo, { file: 'sync.ts', function: 'syncOrders', verdict: 'no_issue', note: 'upsert key is the unique order id; callers retry safely' });
-        expect(ack.ok).toBe(true);
-        expect(buildReviewTask(repo, diffFromGit(repo))).toMatchObject({ items: [], alreadyReviewed: 1 });
-        write(AFTER.replace('return rows;', 'return rows.slice(1);'));
-        expect(buildReviewTask(repo, diffFromGit(repo)).items.map(i => i.function)).toEqual(['syncOrders']);
-    });
-    it('refuses an acknowledgement without a real note, a known verdict, or a real function', () => {
-        expect(acknowledgeReview(repo, { file: 'sync.ts', function: 'syncOrders', verdict: 'no_issue', note: 'ok' })).toMatchObject({ ok: false });
-        expect(acknowledgeReview(repo, { file: 'sync.ts', function: 'syncOrders', verdict: 'lgtm', note: 'looked at it carefully' })).toMatchObject({ ok: false });
-        expect(acknowledgeReview(repo, { file: 'sync.ts', function: 'nope', verdict: 'fixed', note: 'looked at it carefully' })).toMatchObject({ ok: false });
-        expect(readLedger(repo)).toEqual([]);
-    });
-    it('exports hashes and verdicts only, and a committed export clears the task too', () => {
-        acknowledgeReview(repo, { file: 'sync.ts', function: 'syncOrders', verdict: 'fixed', note: 'made the upsert key explicit' });
-        exportReviewed(repo);
-        const exported = JSON.parse(fs.readFileSync(path.join(repo, REVIEWED_FILE), 'utf8'));
-        expect(Object.keys(exported.entries[0]).sort()).toEqual(['file', 'function', 'hash', 'reviewer', 'verdict']);
-        fs.rmSync(path.join(repo, '.rigour', 'review-ledger.jsonl'));
-        expect(buildReviewTask(repo, diffFromGit(repo)).items).toEqual([]);
-    });
-    it('tells a stopping agent which functions still need review, and how', () => {
-        const message = reviewAckMessage(buildReviewTask(repo, diffFromGit(repo)).items, 1);
-        expect(message).toContain('sync.ts:1 `syncOrders`');
-        expect(message).toContain('rigour_review_ack');
-    });
-});

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

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