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

package/dist/review-learning/repo-rules.test.js

@@ -1,55 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { rulesForDiff, rulesSection, splitRules } from './repo-rules.js';
-const AGENTS = `# Conventions
-
-@SHARED.md
-
-- **Migrations are append-only.** Add new files under \`migrations/\`; never edit applied ones.
-- Every outbound send goes through \`deliverOrder()\` in \`src/lib/delivery.ts\`, which checks the permit.
-- Keep components small.
-
-Prefer \`fetchWithTimeout\` over a bare call when talking to partner APIs; a hung request blocks the queue.
-`;
-let repo;
-beforeEach(() => {
-    repo = fs.mkdtempSync(path.join(os.tmpdir(), 'repo-rules-'));
-    fs.writeFileSync(path.join(repo, 'AGENTS.md'), AGENTS);
-    fs.mkdirSync(path.join(repo, '.cursor/rules'), { recursive: true });
-    fs.writeFileSync(path.join(repo, '.cursor/rules/ui.mdc'), 'Never set `fullWidth` on `<Button>`; use `maxWidth` caps instead of stretching.\n');
-});
-afterEach(() => { fs.rmSync(repo, { recursive: true, force: true }); });
-const diff = (file, added) => `+++ b/${file}\n@@ -1,0 +1,1 @@\n+${added}\n`;
-describe('repository rules', () => {
-    it('splits a rules file into rules with the paths and specific identifiers they name', () => {
-        const rules = splitRules('AGENTS.md', AGENTS);
-        expect(rules.map(r => r.text.slice(0, 30))).toEqual(['**Migrations are append-only.*', 'Every outbound send goes throu', 'Prefer `fetchWithTimeout` over']);
-        expect(rules[1]).toMatchObject({ paths: ['src/lib/delivery.ts'], symbols: ['deliverOrder'] });
-        expect(rules[0].paths).toEqual(['migrations/']);
-        expect(rules.map(r => r.requirement)).toEqual([true, true, false]); // "never", "every"; "prefer" is guidance
-        // A section that only describes an exception, with no imperative, is guidance; one that ends in an imperative is a requirement.
-        const [exceptionOnly, withImperative] = splitRules('AGENTS.md', '- **One narrow exception:** the queue table is still literally named `study_jobs`, not renamed with the feature.\n\n- **One narrow exception:** the queue table is still literally named `study_jobs`. Import the `JOBS_TABLE` constant; do not inline the raw table name again.\n');
-        expect([exceptionOnly.requirement, withImperative.requirement]).toEqual([false, true]);
-        expect(rules[0].id).toMatch(/^[0-9a-f]{10}$/);
-        expect(splitRules('AGENTS.md', AGENTS)[0].id).toBe(rules[0].id); // stable across runs
-    });
-    it('keeps a rule\'s "Why" and "How to apply" paragraphs with it, and ranks a rule naming the change above one that only shares its words', () => {
-        const text = '- **Use the design system.** Every control comes from `src/lib/ui`.\n\n**Why:** one source of styling.\n\n**How to apply:** import from `$lib/ui`, never a raw `<button>`.\n\n- Bound both ends of every time window a scheduled job reads.\n\n- Name the index a new query relies on in the migrations.\n';
-        const rules = splitRules('AGENTS.md', text);
-        expect(rules.map(r => r.text.slice(0, 24))).toEqual(['**Use the design system.', 'Bound both ends of every', 'Name the index a new que']);
-        expect(rules[0].text).toContain('**How to apply:**');
-        fs.writeFileSync(path.join(repo, 'AGENTS.md'), text);
-        const change = diff('src/lib/ui/Button.svelte', 'const timeWindow = scheduledJob.readsRows();');
-        expect(rulesForDiff(repo, change, true, 10).map(r => r.text.slice(0, 12))).toEqual(['**Use the de', 'Bound both e']); // the path hit first, then shared words; the index rule shares nothing
-        expect(rulesForDiff(repo, change, true, 1)).toHaveLength(1);
-    });
-    it('shows only the rules that name what the change touches, and nothing when disabled', () => {
-        expect(rulesForDiff(repo, diff('migrations/2026_add.sql', 'alter table x;'), true).map(r => r.text.slice(0, 20))).toEqual(['**Migrations are app']);
-        expect(rulesForDiff(repo, diff('src/jobs/send.ts', 'await deliverOrder(order);'), true).map(r => r.text.slice(0, 20))).toEqual(['Every outbound send ']);
-        expect(rulesForDiff(repo, diff('src/ui/List.tsx', 'const x = 1;'), true)).toEqual([]);
-        expect(rulesForDiff(repo, diff('migrations/2026_add.sql', 'x'), false)).toEqual([]);
-        expect(rulesSection(rulesForDiff(repo, diff('src/a.ts', 'await fetchWithTimeout(url);'), true))).toContain('[AGENTS.md] Prefer `fetchWithTimeout`');
-    });
-});

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

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

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

@@ -1,249 +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 { gitIn, withActedOn } from './acted-on.js';
-import { learnFromReviews } from './learn-from-reviews.js';
-import { outcomeFor } from './outcomes.js';
-import { rulesFromReviews } from './rules-from-reviews.js';
-import { describeLesson, lessonView } from './team-lessons.js';
-import { decideLesson, isSpecific, lessonState, lessonText, lessonsFromReview, matchLessons, mergeLessons, readLessons, writeLessons } from './lessons.js';
-import { lessonsForDiff, lessonsSection } from './team-lessons.js';
-let repo;
-const git = (...args) => execFileSync('git', ['-C', repo, ...args], { encoding: 'utf8' }).trim();
-const write = (body) => fs.writeFileSync(path.join(repo, 'src/orders.ts'), body);
-const commit = (message) => { git('add', '-A'); git('commit', '-qm', message); return git('rev-parse', 'HEAD'); };
-const V1 = 'export async function save(db, order) {\n  await db.insert(order);\n  return order.id;\n}\n';
-const V2 = 'export async function save(db, order) {\n  await db.upsert(order, { onConflict: "id" });\n  return order.id;\n}\n';
-beforeEach(() => {
-    repo = fs.mkdtempSync(path.join(os.tmpdir(), 'review-learning-'));
-    git('init', '-q', '-b', 'main');
-    git('config', 'user.email', 't@example.com');
-    git('config', 'user.name', 't');
-    git('config', 'commit.gpgsign', 'false');
-    fs.mkdirSync(path.join(repo, 'src'));
-});
-afterEach(() => { fs.rmSync(repo, { recursive: true, force: true }); });
-const comment = (id, sha, start, body, prNumber = 7) => ({ id, prNumber, path: 'src/orders.ts', start, end: start, commit: sha, body, author: 'reviewer' });
-describe('acted on', () => {
-    it('marks a comment whose lines changed before merge, and one nobody acted on, keeping both', () => {
-        write(V1);
-        const reviewed = commit('pr head');
-        write(V2);
-        const merged = commit('address review');
-        const marked = withActedOn(gitIn(repo), { number: 7, mergeSha: merged, mergedAt: '', comments: [
-                comment('a', reviewed, 2, '**Use an upsert keyed on `id` so a retry does not duplicate the order.**'),
-                comment('b', reviewed, 3, 'Nit: return the whole order?'),
-            ], reviews: [] });
-        expect(marked.map(c => [c.id, c.actedOn])).toEqual([['a', true], ['b', false]]);
-    });
-});
-describe('lessons', () => {
-    it('never makes a lesson of a bare path or a review bot\'s line-range scaffolding', () => {
-        expect(lessonText('src/routes/learner/+layout.ts')).toBe('');
-        expect(lessonText('`src/routes/learner/api/[planId]/+server.ts`')).toBe('');
-        expect(lessonText('In src/a.ts around lines 10-12: Check the lock before the first read.')).toBe('Check the lock before the first read.');
-        expect(lessonText('Around line 124-141: Add a test for the failed save.')).toBe('Add a test for the failed save.');
-        expect(lessonsFromReview({ id: '1', prNumber: 3, commit: 'c', author: 'rabbit[bot]', source: 'bot', body: '- `src/a/b.ts`\n- Bound both ends of the time window.' }, ['src/a/b.ts']).map(l => l.text))
-            .toEqual(['Bound both ends of the time window.']);
-    });
-    it('keeps the point of a review comment and drops tool output and markup', () => {
-        const body = '_⚠️ Potential issue_ | _🟠 Major_\n\n**Use an upsert keyed on `id`.**\n\n<details>\n<summary>🏁 Script executed</summary>\nrg -n insert\n</details>';
-        expect(lessonText(body)).toBe('Use an upsert keyed on `id`.');
-        expect(lessonText('Callers retry on timeout, so this insert duplicates orders. Please use upsert.')).toBe('Callers retry on timeout, so this insert duplicates orders.');
-        expect(lessonText('### Medium Severity\n\nThe retry loop never resets `attempt`, so a second failure gives up at once.')).toBe('The retry loop never resets `attempt`, so a second failure gives up at once.');
-    });
-    it('makes a candidate a lesson only on evidence, and keeps every piece of it', () => {
-        const point = (pr, prAuthor, source = 'person', reviewer = `reviewer-of-${pr}`) => ({ kind: 'point', pr, comment: `c${pr}${prAuthor}`, author: reviewer, source, prAuthor });
-        const lesson = (...evidence) => ({ id: 'x', text: 'Use upsert', file: 'src/orders.ts', symbols: [], state: 'candidate', evidence, createdAt: '', updatedAt: '' });
-        expect(lessonState(lesson(point(1, 'ann')))).toEqual({ state: 'candidate' });
-        expect(lessonState(lesson(point(1, 'ann'), point(2, 'ann')))).toEqual({ state: 'candidate' }); // two PRs, one author: weak, not enough
-        expect(lessonState(lesson(point(1, 'ann'), point(2, 'bob', 'bot')))).toEqual({ state: 'verified', promotedBy: 'recurrence' }); // a bot's point counts the same
-        const said = (e, text) => ({ ...e, text });
-        expect(lessonState(lesson(said(point(1, 'ann', 'bot', 'helper[bot]'), 'Around line 60-103: update the callers.'), said(point(2, 'bob', 'bot', 'helper[bot]'), 'Around line 12-14: update the loader.')))).toEqual({ state: 'candidate' }); // a bot rewording its own point is one source
-        expect(lessonState(lesson(said(point(1, 'ann', 'bot', 'helper[bot]'), 'Consider more tests.'), said(point(2, 'bob', 'bot', 'helper[bot]'), 'Consider more tests.')))).toEqual({ state: 'candidate' }); // one bot's template on every PR is one source
-        expect(lessonState(lesson(said(point(1, 'ann', 'person', 'lead'), 'Regenerate the API client after changing the schema.'), said(point(2, 'bob', 'person', 'lead'), 'The generated client is stale again.')))).toEqual({ state: 'verified', promotedBy: 'recurrence' }); // a senior re-raising it in their own words
-        expect(lessonState(lesson(point(1, 'ann'), point(2, 'bob'), { kind: 'norule', pr: 1, comment: 'n', author: '' }))).toEqual({ state: 'candidate' }); // no rule in it: never promoted again
-        const outcome = { kind: 'outcome', pr: 1, comment: 'o', author: '', detail: 'fixed later by abc' };
-        const counter = { kind: 'counter', pr: 1, comment: 'k', author: '', detail: 'unchanged 40 days' };
-        expect(lessonState(lesson(point(1, 'ann', 'bot'), outcome))).toEqual({ state: 'verified', promotedBy: 'outcome' });
-        expect(lessonState(lesson(point(1, 'ann'), point(2, 'bob'), counter))).toEqual({ state: 'candidate' }); // counter-evidence holds recurrence back
-        const accepted = { kind: 'accepted', pr: 1, comment: 'y', author: 'lead@x' };
-        const rejected = { kind: 'rejected', pr: 1, comment: 'n', author: 'lead@x' };
-        expect(lessonState(lesson(point(1, 'ann'), outcome, rejected))).toEqual({ state: 'rejected' }); // a person's decision wins
-        expect(lessonState(lesson(point(1, 'ann'), rejected, accepted))).toEqual({ state: 'verified', promotedBy: 'person' }); // the latest decision
-        expect(lessonState({ ...lesson({ pr: 1, comment: 'old', author: 'r' }), state: 'verified' })).toEqual({ state: 'verified', promotedBy: 'legacy' }); // a record from before evidence keeps its state
-    });
-    it('records a person accepting or rejecting a lesson as evidence, with who and why', () => {
-        writeLessons(repo, [{ id: 'x', text: 'Use upsert', file: 'src/orders.ts', symbols: [], state: 'candidate', evidence: [{ kind: 'point', pr: 1, comment: 'c', author: 'r' }], createdAt: '', updatedAt: '' }]);
-        expect(decideLesson(repo, 'x', 'rejected', 'lead@x', 'we accept duplicates here')).toMatchObject({ state: 'rejected' });
-        expect(readLessons(repo)[0].evidence.at(-1)).toMatchObject({ kind: 'rejected', author: 'lead@x', detail: 'we accept duplicates here' });
-        expect(matchLessons(readLessons(repo), { files: ['src/orders.ts'], symbols: new Set() }, { includeCandidates: true })).toEqual([]); // never served as a lesson
-        expect(decideLesson(repo, 'nope', 'accepted', 'lead@x')).toBeUndefined();
-    });
-    it('matches lessons by file, symbols and directory, verified only unless asked', () => {
-        const base = { symbols: ['insert'], evidence: [{ pr: 1, comment: 'c', author: 'r' }], createdAt: '', updatedAt: '' };
-        const lessons = [
-            { ...base, id: '1', text: 'same file', file: 'src/orders.ts', state: 'verified' },
-            { ...base, id: '2', text: 'other dir, two shared symbols', file: 'lib/x.ts', state: 'verified', symbols: ['insertOrder', 'orderId'] },
-            { ...base, id: '6', text: 'a lesson about a runbook', file: 'docs/runbook.md', state: 'verified', symbols: ['insertOrder', 'orderId'] },
-            { ...base, id: '5', text: 'other dir, one generic shared symbol', file: 'lib/z.ts', state: 'verified' },
-            { ...base, id: '3', text: 'candidate', file: 'src/orders.ts', state: 'candidate' },
-            { ...base, id: '4', text: 'unrelated', file: 'lib/y.ts', state: 'verified', symbols: ['other'] },
-        ];
-        const change = { files: ['src/orders.ts'], symbols: new Set(['insert', 'insertOrder', 'orderId']) };
-        expect(matchLessons(lessons, change).map(l => l.id)).toEqual(['2', '1']); // two specific shared names outrank a same-file lesson with only generic ones
-        expect(matchLessons(lessons, change, { includeCandidates: true }).map(l => l.id)).toEqual(['2', '1', '3']);
-        // A lesson learned only from the pull request under review is its own reviews, already in front of the judge.
-        const own = { ...base, id: '7', text: 'from this very pull request', file: 'src/orders.ts', state: 'verified', evidence: [{ pr: 42, comment: 'c', author: 'r' }] };
-        const also = { ...own, id: '8', text: 'from this and another', evidence: [{ pr: 42, comment: 'c', author: 'r' }, { pr: 3, comment: 'd', author: 'r' }] };
-        expect(matchLessons([...lessons, own, also], change, { excludePr: 42 }).map(l => l.id).sort()).toEqual(['1', '2', '8']); // '7' is left out; '8' has evidence elsewhere too
-        // One file's many lessons never crowd out another file's only one.
-        const many = Array.from({ length: 6 }, (_, i) => ({ ...base, id: `m${i}`, text: `orders lesson ${i}`, file: 'src/orders.ts', state: 'verified', symbols: ['insertOrder', 'orderId'] }));
-        const lone = { ...base, id: 'lone', text: 'the only lesson about the manifest', file: 'src/manifest.sha', state: 'verified' };
-        const served = matchLessons([...many, lone], { files: ['src/orders.ts', 'src/manifest.sha'], symbols: new Set(['insertOrder', 'orderId']) }, { limit: 4, perFile: 3 });
-        expect(served.map(l => l.id)).toEqual(['m0', 'm1', 'm2', 'lone']);
-    });
-});
-describe('learning from one pull request as it goes', () => {
-    it('reads its reviews up to a time, and counts a point acted on by the head as of then', async () => {
-        write(V1);
-        const reviewed = commit('pr head');
-        write(V2);
-        const fixed = commit('address review');
-        const api = 'https://api.github.com/repos/acme/app';
-        const pages = {
-            [`${api}/pulls/42`]: { number: 42, user: { login: 'dev' }, head: { sha: fixed } },
-            [`${api}/pulls/42/commits?per_page=100&page=1`]: [
-                { sha: reviewed, commit: { committer: { date: '2026-09-01T00:00:00Z' } } },
-                { sha: fixed, commit: { committer: { date: '2026-09-02T00:00:00Z' } } },
-            ],
-            [`${api}/pulls/42/comments?per_page=100&page=1`]: [],
-            [`${api}/pulls/42/reviews?per_page=100&page=1`]: [
-                { id: 1, commit_id: reviewed, submitted_at: '2026-09-01T12:00:00Z', user: { login: 'priya' }, body: '- In src/orders.ts make the insert idempotent on retry.' },
-                { id: 2, commit_id: fixed, submitted_at: '2026-09-06T00:00:00Z', user: { login: 'priya' }, body: '- A later point the learner must not see yet.' },
-            ],
-        };
-        const fetchImpl = async (url) => ({ ok: url in pages, status: url in pages ? 200 : 404, json: async () => pages[url] });
-        const early = await learnFromReviews(repo, { token: 't', repo: 'acme/app', fetch: fetchImpl, pr: 42, until: '2026-09-01T18:00:00Z' });
-        expect(early).toMatchObject({ prs: 1, reviewBodies: 1, total: 1 }); // the later review is not seen yet
-        expect(readLessons(repo)[0]).toMatchObject({ file: 'src/orders.ts', text: 'In src/orders.ts make the insert idempotent on retry.', evidence: [{ pr: 42, author: 'priya', actedOn: false }] });
-        fs.rmSync(path.join(repo, '.rigour', 'review-lessons.json'));
-        await learnFromReviews(repo, { token: 't', repo: 'acme/app', fetch: fetchImpl, pr: 42, until: '2026-09-03T00:00:00Z' });
-        expect(readLessons(repo)[0].evidence[0]).toMatchObject({ actedOn: true }); // the fix landed before this cut
-    });
-});
-describe('outcome evidence from git', () => {
-    it('finds a later fix to the lines a point named, counts lines left alone against it, and never looks past the cut', () => {
-        write('export function total(order) {\n  return order.items.length;\n}\n');
-        commit('base');
-        git('checkout', '-qb', 'feature');
-        write('export function total(order) {\n  const n = order.items.length;\n  return n;\n}\n');
-        const reviewed = commit('pr head');
-        git('checkout', '-q', 'main');
-        git('merge', '-q', '--no-ff', '--no-edit', 'feature');
-        const merge = git('rev-parse', 'HEAD');
-        write('// header\nexport function total(order) {\n  const n = order.items?.length ?? 0;\n  return n;\n}\n');
-        execFileSync('git', ['-C', repo, 'commit', '-qam', 'fix: total crashes on an order with no items'], { env: { ...process.env, GIT_COMMITTER_DATE: '2026-09-20T00:00:00Z' } });
-        const point = (start, actedOn = false) => ({ id: `p${start}`, text: 'Guard a missing items list.', file: 'src/orders.ts', symbols: [], state: 'candidate', at: { commit: reviewed, start, end: start }, evidence: [{ kind: 'point', pr: 7, comment: `c${start}`, author: 'bot', source: 'bot', actedOn }], createdAt: '', updatedAt: '' });
-        const pr = { number: 7, mergeSha: merge, mergedAt: '2026-09-01T00:00:00Z' };
-        const later = outcomeFor(gitIn(repo), point(2), pr, { mainRef: 'main' });
-        expect(later).toMatchObject({ kind: 'outcome', detail: expect.stringContaining('fix: total crashes on an order with no items') });
-        expect(outcomeFor(gitIn(repo), point(2), pr, { mainRef: 'main', until: '2026-09-10T00:00:00Z' })).toBeUndefined(); // before the fix, within the window: no verdict yet
-        expect(outcomeFor(gitIn(repo), point(3), pr, { mainRef: 'main' })).toMatchObject({ kind: 'counter' }); // `return n;` shipped and stayed, past the window
-        expect(outcomeFor(gitIn(repo), point(2, true), pr, { mainRef: 'main' })).toBeUndefined(); // acted on in the PR: no outcome to read
-    });
-});
-describe('team standards', () => {
-    it('verifies a standard when the same point recurs in another author\'s PR, and serves it only to a change it is about', () => {
-        const standard = (pr, text) => ({ id: `s${pr}`, text, file: '', symbols: [], state: 'candidate', evidence: [{ kind: 'point', pr, comment: `r${pr}`, author: `reviewer${pr}`, prAuthor: `dev${pr}` }], createdAt: '', updatedAt: '' });
-        const merged = mergeLessons([], [standard(1, 'Bound both ends of every time window a job reads.'), standard(2, 'Bound both ends of the time window this job reads.')]);
-        expect(merged.lessons).toHaveLength(1);
-        expect(merged.lessons[0].state).toBe('verified');
-        const unrelated = mergeLessons(merged.lessons, [standard(3, 'Log the request id on every error.')]);
-        expect(unrelated.lessons).toHaveLength(2);
-        expect(matchLessons(unrelated.lessons, { files: ['src/jobs/scan.ts'], symbols: new Set(['timeWindowStart', 'readRows']) }).map(l => l.text)).toEqual(['Bound both ends of every time window a job reads.']);
-        expect(matchLessons(unrelated.lessons, { files: ['src/ui/Dialog.svelte'], symbols: new Set(['onKeydown']) })).toEqual([]); // nothing in common: not served
-    });
-});
-describe('turning reviews into rules', () => {
-    const point = (id, text, file = '') => ({ id, text, file, symbols: [], state: 'candidate', evidence: [{ pr: 7, comment: `c-${id}`, author: 'priya' }], createdAt: '', updatedAt: '' });
-    it('keeps the rule behind a point, drops a status note, keeps an unanswered point as said, and keeps the words beside the rule', async () => {
-        const prompts = [];
-        const write = async (prompt) => {
-            prompts.push(prompt);
-            return 'Here you go:\n{"rules":[{"id":"a","rule":"Apply discounts before computing an invoice total.","file":null},{"id":"b","rule":null,"file":null}]}';
-        };
-        const points = [point('a', 'The invoice total is computed before the discount is applied.'), point('b', 'npm run check: 0 errors, lint clean.'), point('c', 'A retry posts the payment twice.')];
-        const out = await rulesFromReviews(points, write);
-        expect(out).toMatchObject({ rules: 1, dropped: 1, unanswered: 1 });
-        expect(out.lessons.map(l => [l.text, l.evidence.at(-1)?.kind])).toEqual([
-            ['Apply discounts before computing an invoice total.', undefined], ['npm run check: 0 errors, lint clean.', 'norule'], ['A retry posts the payment twice.', undefined],
-        ]); // the no-rule point is kept and marked, never sent again
-        expect(out.lessons[0].evidence[0].said).toBe('The invoice total is computed before the discount is applied.');
-        expect(prompts[0]).toContain('"said": "npm run check: 0 errors, lint clean."');
-        expect(describeLesson(lessonView({ ...out.lessons[0], evidence: [...out.lessons[0].evidence, { pr: 9, comment: 'x', author: 'sam' }] })))
-            .toBe('team standard: Apply discounts before computing an invoice total. (in their words: "The invoice total is computed before the discount is applied.") (acted on in PR #7, #9)');
-    });
-    it('never loses a point when the model cannot run, and keeps a file only when the point was about it', async () => {
-        const out = await rulesFromReviews([point('a', 'In src/run.ts the flag is read last.', 'src/run.ts')], async () => undefined);
-        expect(out.lessons.map(l => [l.text, l.file])).toEqual([['In src/run.ts the flag is read last.', 'src/run.ts']]);
-        const moved = await rulesFromReviews([point('a', 'A point about one place.', 'src/a.ts')], async () => '{"rules":[{"id":"a","rule":"A rule the model placed in another file.","file":"src/b.ts"}]}');
-        expect(moved.lessons[0].file).toBe('');
-    });
-});
-describe('isSpecific', () => {
-    it('counts identifiers that name something, not common words', () => {
-        expect(['orderId', 'max_rows', 'renderTransactionalMessage'].map(isSpecific)).toEqual([true, true, true]);
-        expect(['data', 'error', 'route', 'insert'].map(isSpecific)).toEqual([false, false, false, false]);
-    });
-});
-describe('learnFromReviews', () => {
-    it('reads merged PRs from GitHub, learns from acted-on comments, and shows them for the next change', async () => {
-        write(V1);
-        const reviewed = commit('pr head');
-        write(V2);
-        const merged = commit('address review');
-        const api = 'https://api.github.com/repos/acme/app';
-        const pages = {
-            [`${api}/pulls?state=closed&sort=updated&direction=desc&per_page=100&page=1`]: [
-                { number: 7, merged_at: '2026-09-01T00:00:00Z', merge_commit_sha: merged, user: { login: 'dev' } },
-                { number: 8, merged_at: null, merge_commit_sha: null },
-            ],
-            [`${api}/pulls?state=closed&sort=updated&direction=desc&per_page=100&page=2`]: [],
-            [`${api}/pulls/7/comments?per_page=100`]: [
-                { id: 11, path: 'src/orders.ts', original_line: 2, original_commit_id: reviewed, body: '**Use an upsert keyed on `id` so retries do not duplicate orders.**', user: { login: 'priya' } },
-                { id: 12, path: 'src/orders.ts', original_line: 2, original_commit_id: reviewed, body: 'agreed', in_reply_to_id: 11, user: { login: 'sam' } },
-                { id: 13, path: 'src/orders.ts', original_line: 2, original_commit_id: reviewed, body: '**Rename the variable to orderRow for clarity.**', user: { login: 'review-helper[bot]', type: 'Bot' } },
-                { id: 14, path: 'src/orders.ts', original_line: 2, original_commit_id: reviewed, body: '**Self note: tidy this later.**', user: { login: 'dev' } },
-            ],
-            [`${api}/pulls/7/reviews?per_page=100`]: [
-                { id: 21, commit_id: reviewed, user: { login: 'priya' }, body: '## Review\n\n- Bound both ends of every time window a scheduled job reads.\n- In src/orders.ts the insert needs the idempotency key.\nThanks!' },
-                { id: 22, commit_id: reviewed, user: { login: 'review-helper[bot]', type: 'Bot' }, body: '- Consider adding more unit tests for orders.' },
-                { id: 23, commit_id: reviewed, user: { login: 'dev' }, body: '- Addressed every point in the next commit.' },
-            ],
-        };
-        const fetchImpl = async (url) => ({ ok: url in pages, status: url in pages ? 200 : 404, json: async () => pages[url] });
-        const result = await learnFromReviews(repo, { token: 't', repo: 'acme/app', fetch: fetchImpl });
-        // Every point is a candidate, the bot's too; the author's own comments are not review points.
-        expect(result).toMatchObject({ prs: 1, comments: 2, actedOn: 2, reviewBodies: 2, candidates: { person: 3, bot: 2 }, verified: 0 });
-        const lessons = readLessons(repo);
-        expect(lessons.every(l => l.state === 'candidate')).toBe(true); // nothing is a lesson without evidence
-        const sources = new Set(lessons.flatMap(l => l.evidence.map(e => `${e.author}/${e.source}/${e.prAuthor}`)));
-        expect([...sources].sort()).toEqual(['priya/person/dev', 'review-helper[bot]/bot/dev']);
-        expect(lessons.map(l => l.text)).toEqual(expect.arrayContaining(['Bound both ends of every time window a scheduled job reads.', 'Consider adding more unit tests for orders.']));
-        const diff = '+++ b/src/orders.ts\n@@ -1,0 +1,1 @@\n+  await db.insert(other);\n';
-        expect(lessonsForDiff(repo, diff, 'verified')).toEqual([]); // candidates are not served by default
-        expect(lessonsSection(lessonsForDiff(repo, diff, 'all'))).toContain('src/orders.ts: Use an upsert keyed on `id` so retries do not duplicate orders.');
-        const again = await learnFromReviews(repo, { token: 't', repo: 'acme/app', fetch: fetchImpl, writeRules: async () => { throw new Error('nothing promoted: no rule is written'); } });
-        expect(again).toMatchObject({ added: 0, total: lessons.length });
-        const upsert = lessons.find(l => l.text.startsWith('Use an upsert'));
-        decideLesson(repo, upsert.id, 'accepted', 'lead@acme');
-        const ruled = await learnFromReviews(repo, { token: 't', repo: 'acme/app', fetch: fetchImpl, writeRules: async (prompt) => JSON.stringify({ rules: [...prompt.matchAll(/"id": "(\w+)"/g)].map(m => ({ id: m[1], rule: 'Make every write idempotent on retry.', file: 'src/orders.ts' })) }) });
-        expect(ruled).toMatchObject({ rules: 1, notRules: 0, promoted: { person: 1 } }); // written only for the promoted lesson
-        expect(readLessons(repo).find(l => l.state === 'verified')).toMatchObject({ text: 'Make every write idempotent on retry.', promotedBy: 'person' });
-        const audit = fs.readFileSync(path.join(repo, '.rigour', 'review-rules-log.jsonl'), 'utf8').trim().split('\n').map(l => JSON.parse(l));
-        expect(audit.map(a => [a.said, a.rule])).toEqual([[upsert.text, 'Make every write idempotent on retry.']]);
-    });
-});

package/dist/safety.test.d.ts

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

package/dist/safety.test.js

@@ -1,42 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { FileGuardGate } from './gates/safety.js';
-import { execa } from 'execa';
-vi.mock('execa');
-describe('FileGuardGate', () => {
-    const config = {
-        safety: {
-            protected_paths: ['docs/'],
-            max_files_changed_per_cycle: 10
-        }
-    };
-    it('should flag modified (M) protected files', async () => {
-        const gate = new FileGuardGate(config);
-        vi.mocked(execa).mockResolvedValueOnce({ stdout: ' M docs/SPEC.md\n' });
-        const failures = await gate.run({ cwd: '/test', record: {} });
-        expect(failures).toHaveLength(1);
-        expect(failures[0].title).toContain("Protected file 'docs/SPEC.md' was modified.");
-    });
-    it('should flag added (A) protected files', async () => {
-        const gate = new FileGuardGate(config);
-        vi.mocked(execa).mockResolvedValueOnce({ stdout: 'A  docs/NEW.md\n' });
-        const failures = await gate.run({ cwd: '/test', record: {} });
-        expect(failures).toHaveLength(1);
-        expect(failures[0].title).toContain("Protected file 'docs/NEW.md' was modified.");
-    });
-    it('should NOT flag untracked (??) protected files', async () => {
-        const gate = new FileGuardGate(config);
-        vi.mocked(execa).mockResolvedValueOnce({ stdout: '?? docs/UNTRAKED.md\n' });
-        const failures = await gate.run({ cwd: '/test', record: {} });
-        expect(failures).toHaveLength(0);
-    });
-    it('should correctly handle multiple mixed statuses', async () => {
-        const gate = new FileGuardGate(config);
-        vi.mocked(execa).mockResolvedValueOnce({
-            stdout: ' M docs/MODIFIED.md\n?? docs/NEW_UNTRACKED.md\n D docs/DELETED.md\n'
-        });
-        const failures = await gate.run({ cwd: '/test', record: {} });
-        expect(failures).toHaveLength(2);
-        expect(failures.map(f => f.title)).toContain("Protected file 'docs/MODIFIED.md' was modified.");
-        expect(failures.map(f => f.title)).toContain("Protected file 'docs/DELETED.md' was modified.");
-    });
-});

package/dist/semantic/benchmark.test.d.ts

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

package/dist/semantic/benchmark.test.js

@@ -1,22 +0,0 @@
-import path from 'path';
-import { describe, expect, it } from 'vitest';
-import { CANDIDATE_RULES, ECOSYSTEM_RULES } from './rules/ecosystem/index.js';
-import { loadCases, runCase } from './benchmark.js';
-const ROOT = path.resolve(__dirname, '../../../../benchmarks/semantic');
-describe('semantic benchmark', () => {
-    const cases = loadCases(ROOT);
-    it('has cases for every built-in rule, including negatives', () => {
-        const rules = new Set(cases.map(c => c.rule));
-        expect(rules).toEqual(new Set([
-            'in-memory-aggregation', 'credential-redirect', 'degraded-response-cached',
-            ...[...ECOSYSTEM_RULES, ...CANDIDATE_RULES].map(rule => rule.id), null,
-        ]));
-    });
-    for (const bench of cases) {
-        it(`${bench.name}: ${bench.note}`, () => {
-            const result = runCase(ROOT, bench);
-            expect(result.falsePositives).toEqual([]);
-            expect(result.caught).toBe(true);
-        });
-    }
-});

package/dist/semantic/intent/intent.test.d.ts

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

package/dist/semantic/intent/intent.test.js

@@ -1,46 +0,0 @@
-import path from 'path';
-import { describe, expect, it } from 'vitest';
-import { loadIntentCases, runIntentCase, scoreIntent } from './benchmark.js';
-import { verdictOf } from './intent-check.js';
-const ROOT = path.resolve(__dirname, '../../../../../benchmarks/intent');
-/** Answers from the labels: an oracle, optionally contradicting itself on one read. */
-function labelledModel(labels, contradict) {
-    return {
-        async ask(prompt) {
-            const label = Object.keys(labels).find(name => prompt.includes(`Question: If \`${name}\``) || prompt.includes(`result of \`${name}\``));
-            if (!label)
-                return null;
-            const optional = labels[label] === 'optional';
-            const firstQuestion = prompt.includes('Question: If');
-            if (label === contradict)
-                return 'yes';
-            return firstQuestion === optional ? 'yes' : 'no';
-        },
-    };
-}
-describe('verdictOf', () => {
-    it('counts only consistent flipped answers', () => {
-        expect(verdictOf(['yes', 'no'])).toBe('optional');
-        expect(verdictOf(['no', 'yes'])).toBe('required');
-        expect(verdictOf(['yes', 'yes'])).toBe('unknown');
-        expect(verdictOf(['no', 'no'])).toBe('unknown');
-        expect(verdictOf([null, 'no'])).toBe('unknown');
-    });
-});
-describe('intent benchmark with a labelled oracle', () => {
-    const cases = loadIntentCases(ROOT);
-    it('finds every labelled site, skips the fixed one, and scores the oracle perfectly', async () => {
-        const results = await Promise.all(cases.map(bench => runIntentCase(ROOT, bench, labelledModel(bench.labels))));
-        const score = scoreIntent(results);
-        expect(score.finderErrors).toEqual([]);
-        expect(score.falsePositives).toBe(0);
-        expect(score.falseNegatives).toBe(0);
-        expect(score.rawCorrect).toBe(score.rawTotal);
-    });
-    it('drops a read whose answers contradict each other instead of guessing', async () => {
-        const bench = cases.find(c => c.name === 'dashboard');
-        const result = await runIntentCase(ROOT, bench, labelledModel(bench.labels, 'getRecommendedCourses'));
-        expect(result.verdicts.find(v => v.read.label === 'getRecommendedCourses')?.verdict).toBe('unknown');
-        expect(result.findings).toBe(0);
-    });
-});

package/dist/semantic/learn/learn.test.d.ts

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

package/dist/semantic/learn/learn.test.js

@@ -1,67 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import ts from 'typescript';
-import { afterEach, describe, expect, it } from 'vitest';
-import { fileURLToPath } from 'url';
-import { forEachNode } from '../ast.js';
-import { loadLearnCases, runLearnCase } from './benchmark.js';
-import { guardsOf, namesIn, propertiesNamed } from './conditions.js';
-import { functionKeyOf, isInvocation } from './identity.js';
-import { loadLearnedRules, saveLearnedRule } from './store.js';
-const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../../../../benchmarks/learn');
-describe('learn benchmark', () => {
-    for (const bench of loadLearnCases(ROOT)) {
-        it(`${bench.name}: ${bench.note}`, async () => {
-            const result = await runLearnCase(ROOT, bench);
-            expect(result.problems).toEqual([]);
-        });
-    }
-});
-function parse(text) {
-    return ts.createSourceFile('x.ts', text, ts.ScriptTarget.Latest, true);
-}
-function firstCall(sf) {
-    let call;
-    forEachNode(sf, (n) => { if (!call && isInvocation(n))
-        call = n; });
-    return call;
-}
-describe('guardsOf', () => {
-    it('collects the spread condition and the value condition', () => {
-        const sf = parse("h({ ...(ok ? { 'cache-control': fresh ? 'max-age=1' : 'no-store' } : {}) });");
-        const [prop] = propertiesNamed(sf, 'cache-control');
-        expect(namesIn(guardsOf(prop, firstCall(sf)))).toEqual(['fresh', 'ok']);
-    });
-    it('lists property names before receivers', () => {
-        const sf = parse("h({ c: status === 200 && body.stepsAvailable !== false ? 'a' : 'b' });");
-        const [prop] = propertiesNamed(sf, 'c');
-        expect(namesIn(guardsOf(prop, firstCall(sf)))[0]).toBe('stepsAvailable');
-    });
-});
-describe('functionKeyOf', () => {
-    it('names nested arrows, methods and the module level', () => {
-        const sf = parse('class A { run() { const inner = () => f(); } }\ng();\n');
-        const keys = [];
-        forEachNode(sf, (n) => { if (isInvocation(n))
-            keys.push(functionKeyOf(n)); });
-        expect(keys).toEqual(['A.run>inner', '<module>']);
-    });
-});
-describe('learned rule store', () => {
-    let dir;
-    afterEach(() => { if (dir)
-        fs.rmSync(dir, { recursive: true, force: true }); dir = undefined; });
-    it('round-trips a rule and skips files that are not rules', () => {
-        dir = fs.mkdtempSync(path.join(os.tmpdir(), 'learned-'));
-        const rule = {
-            id: 'require-option-redirect-abcd1234', version: 1,
-            pattern: { template: 'require-option', callee: { level: 'name', key: 'fetch' }, argIndex: 1, property: 'redirect' },
-            message: 'm', severity: 'medium', source: { file: 'http.ts', function: 'post' },
-            validation: { firesBefore: 1, firesAfter: 0, maxHits: 3, repoHits: [] },
-        };
-        saveLearnedRule(dir, rule);
-        fs.writeFileSync(path.join(dir, '.rigour', 'rules', 'broken.json'), '{"id": 1}');
-        expect(loadLearnedRules(dir)).toEqual([rule]);
-    });
-});

package/dist/semantic/origins.test.d.ts

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

package/dist/semantic/origins.test.js

@@ -1,77 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import ts from 'typescript';
-import { afterEach, describe, expect, it } from 'vitest';
-import { forEachNode, symbolOf } from './ast.js';
-import { originsOf } from './origins.js';
-import { programBatches } from './program.js';
-let dir;
-afterEach(() => { if (dir)
-    fs.rmSync(dir, { recursive: true, force: true }); dir = undefined; });
-/** Program over `files`; returns the checker and a finder for `probe(<expr>)` arguments in main.ts. */
-function setup(files) {
-    dir = fs.mkdtempSync(path.join(os.tmpdir(), 'origins-'));
-    for (const [name, body] of Object.entries(files))
-        fs.writeFileSync(path.join(dir, name), body);
-    const [program] = [...programBatches([path.join(dir, 'main.ts')], { strict: true, noEmit: true })];
-    const checker = program.getTypeChecker();
-    const main = program.getSourceFile(path.join(dir, 'main.ts'));
-    const probe = () => {
-        let found;
-        forEachNode(main, (n) => {
-            if (ts.isCallExpression(n) && ts.isIdentifier(n.expression) && n.expression.text === 'probe')
-                found = n.arguments[0];
-        });
-        return found;
-    };
-    const kinds = () => originsOf(checker, probe()).map(o => o.kind === 'call' ? `call:${o.node.expression.getText()}` : o.kind === 'param' ? `param:${o.index}` : o.kind);
-    return { kinds };
-}
-const PRELUDE = 'declare function probe(v: unknown): void;\ndeclare function a(): number;\ndeclare function b(): number;\n';
-describe('originsOf', () => {
-    it('follows const initializers and let reassignments', () => {
-        const { kinds } = setup({ 'main.ts': `${PRELUDE}let x = a();\nif (Math.random()) x = b();\nconst y = x;\nprobe(y);\n` });
-        expect(kinds().sort()).toEqual(['call:a', 'call:b']);
-    });
-    it('maps an element of Promise.all([...]) to the matching call', async () => {
-        const { kinds } = setup({ 'main.ts': `${PRELUDE}async function f() {\n  const [first, second] = await Promise.all([a(), b()]);\n  probe(second);\n  return first;\n}\n` });
-        expect(kinds()).toEqual(['call:b']);
-    });
-    it('reads a destructured property from an object literal', () => {
-        const { kinds } = setup({ 'main.ts': `${PRELUDE}const obj = { left: a(), right: b() };\nconst { right } = obj;\nprobe(right);\n` });
-        expect(kinds()).toEqual(['call:b']);
-    });
-    it('keeps both sides of ?? and of a conditional', () => {
-        const { kinds } = setup({ 'main.ts': `${PRELUDE}const v = Math.random() > 0.5 ? a() : (b() ?? a());\nprobe(v);\n` });
-        expect(kinds().sort()).toEqual(['call:a', 'call:a', 'call:b']);
-    });
-    it('reports a parameter with its index', () => {
-        const { kinds } = setup({ 'main.ts': `${PRELUDE}function f(first: number, second: number) {\n  probe(second);\n  return first;\n}\n` });
-        expect(kinds()).toEqual(['param:1']);
-    });
-    it('follows imports across files to the declaration', () => {
-        const { kinds } = setup({
-            'lib.ts': 'export const shared = Math.max(1, 2);\n',
-            'main.ts': `${PRELUDE}import { shared } from './lib';\nprobe(shared);\n`,
-        });
-        expect(kinds()).toEqual(['call:Math.max']);
-    });
-    it('stays unknown for an import that does not resolve', () => {
-        const { kinds } = setup({ 'main.ts': `${PRELUDE}import { missing } from './nowhere';\nprobe(missing);\n` });
-        expect(kinds()).toEqual(['unknown']);
-    });
-});
-describe('symbolOf', () => {
-    it('resolves the name in a shorthand property to the variable it reads', () => {
-        dir = fs.mkdtempSync(path.join(os.tmpdir(), 'origins-'));
-        fs.writeFileSync(path.join(dir, 'main.ts'), "const headers = { 'x-token': 't' };\nexport const init = { headers };\n");
-        const [program] = [...programBatches([path.join(dir, 'main.ts')], { strict: true, noEmit: true })];
-        const main = program.getSourceFile(path.join(dir, 'main.ts'));
-        let shorthand;
-        forEachNode(main, (n) => { if (ts.isShorthandPropertyAssignment(n))
-            shorthand = n; });
-        const decl = symbolOf(program.getTypeChecker(), shorthand.name)?.valueDeclaration;
-        expect(decl && ts.isVariableDeclaration(decl) && decl.name.getText()).toBe('headers');
-    });
-});

package/dist/semantic/project-facts.test.d.ts

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