@rigour-labs/core 6.7.2 → 6.7.4

package/dist/review-learning/outcomes.js

@@ -0,0 +1,73 @@
+import { changedHunks } from './acted-on.js';
+/** Commit subjects that say the commit fixed something. */
+const FIX = /\b(fix(e[sd])?|bug|hotfix|regression|revert|broke|broken)\b/i;
+const DAY_MS = 24 * 60 * 60 * 1000;
+/** The outcome or counter evidence for an inline point the pull request did not act on, or undefined when there is none yet. */
+export function outcomeFor(git, lesson, pr, options) {
+    const point = lesson.evidence.find(e => (e.kind ?? 'point') === 'point' && e.pr === pr.number);
+    if (!point || point.actedOn || !lesson.at || !lesson.file || !pr.mergedAt)
+        return undefined;
+    let range = shift(changedHunks(git, lesson.at.commit, pr.mergeSha, lesson.file), [lesson.at.start, lesson.at.end]);
+    if (!range)
+        return undefined; // the pull request changed them after all
+    const before = options.until ? [`--before=${options.until}`] : [];
+    let commits = [];
+    try {
+        commits = git(['rev-list', '--reverse', '--first-parent', ...before, `${pr.mergeSha}..${options.mainRef}`, '--', lesson.file]).split('\n').filter(Boolean);
+    }
+    catch {
+        return undefined;
+    }
+    for (const sha of commits) {
+        const hunks = changedHunks(git, `${sha}^`, sha, lesson.file);
+        const next = shift(hunks, range);
+        if (next) {
+            range = next;
+            continue;
+        }
+        const [subject, date] = git(['log', '-1', '--format=%s%x09%cI', sha]).trim().split('\t');
+        // Changed by a commit that says it fixed something: the point was right. Changed otherwise: no verdict.
+        return FIX.test(subject) ? { kind: 'outcome', pr: pr.number, comment: `outcome-${sha.slice(0, 12)}`, author: '', detail: `fixed later by ${sha.slice(0, 9)} "${subject}"`, at: date } : undefined;
+    }
+    const now = options.until ? Date.parse(options.until) : Date.now();
+    const days = Math.floor((now - Date.parse(pr.mergedAt)) / DAY_MS);
+    if (days < (options.windowDays ?? 30))
+        return undefined;
+    return { kind: 'counter', pr: pr.number, comment: `counter-${pr.number}-${lesson.at.start}`, author: '', detail: `the lines shipped unchanged for ${days} days after the merge`, at: options.until ?? new Date().toISOString() };
+}
+/** A revert of the pull request on main, before `until`: an outcome for every point it left unaddressed. */
+export function revertOf(git, pr, options) {
+    let log = '';
+    try {
+        log = git(['log', '--first-parent', '--format=%H%x09%cI%x09%s', ...(options.until ? [`--before=${options.until}`] : []), `${pr.mergeSha}..${options.mainRef}`]);
+    }
+    catch {
+        return undefined;
+    }
+    for (const line of log.split('\n')) {
+        const [sha, date, subject] = line.split('\t');
+        if (sha && /^revert\b/i.test(subject ?? '') && (subject.includes(`#${pr.number}`) || subject.includes(pr.mergeSha.slice(0, 7)))) {
+            return { kind: 'outcome', pr: pr.number, comment: `revert-${sha.slice(0, 12)}`, author: '', detail: `the pull request was reverted by ${sha.slice(0, 9)} "${subject}"`, at: date };
+        }
+    }
+    return undefined;
+}
+/** The range after a commit's hunks, or undefined when a hunk touched it. */
+function shift(hunks, [start, end]) {
+    let offset = 0;
+    for (const [s, e, removed, added] of hunks) {
+        if (removed === 0) {
+            // An insertion after line s: inside the range touches it, before it moves it down.
+            if (s >= start && s < end)
+                return undefined;
+            if (s < start)
+                offset += added;
+            continue;
+        }
+        if (s <= end && start <= e)
+            return undefined;
+        if (e < start)
+            offset += added - removed;
+    }
+    return [start + offset, end + offset];
+}

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

@@ -3,9 +3,12 @@ import fs from 'fs';
 import os from 'os';
 import path from 'path';
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { actedOn, gitIn } from './acted-on.js';
+import { gitIn, withActedOn } from './acted-on.js';
 import { learnFromReviews } from './learn-from-reviews.js';
-import { isSpecific, lessonText, matchLessons, mergeLessons, readLessons } from './lessons.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, 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();
@@ -23,17 +26,17 @@ beforeEach(() => {
 });
 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('actedOn', () => {
-    it('keeps a comment whose lines changed before merge, and drops one nobody acted on', () => {
+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 acted = actedOn(gitIn(repo), { number: 7, mergeSha: merged, mergedAt: '', comments: [
+        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?'),
-            ] });
-        expect(acted.map(c => c.id)).toEqual(['a']);
+            ], reviews: [] });
+        expect(marked.map(c => [c.id, c.actedOn])).toEqual([['a', true], ['b', false]]);
     });
 });
 describe('lessons', () => {
@@ -43,16 +46,32 @@ describe('lessons', () => {
         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('verifies a lesson only when it was acted on in two PRs', () => {
-        const lesson = (pr, comment) => ({
-            id: 'x', text: 'Use upsert', file: 'src/orders.ts', symbols: ['save', 'insert'], state: 'candidate',
-            evidence: [{ pr, comment, author: 'r' }], createdAt: '', updatedAt: '',
-        });
-        const once = mergeLessons([], [lesson(1, 'c1'), lesson(1, 'c2')]);
-        expect(once.lessons[0].state).toBe('candidate');
-        const twice = mergeLessons(once.lessons, [lesson(2, 'c3')]);
-        expect(twice).toMatchObject({ added: 0, verified: 1 });
-        expect(twice.lessons[0].evidence).toHaveLength(3);
+    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]'), '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: '' };
@@ -69,6 +88,93 @@ describe('lessons', () => {
         expect(matchLessons(lessons, change, { includeCandidates: true }).map(l => l.id)).toEqual(['2', '1', '3']);
     });
 });
+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]);
@@ -84,21 +190,42 @@ describe('learnFromReviews', () => {
         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 },
+                { 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 });
-        expect(result).toMatchObject({ prs: 1, comments: 1, actedOn: 1, added: 1, total: 1 });
-        expect(readLessons(repo)[0]).toMatchObject({ file: 'src/orders.ts', text: 'Use an upsert keyed on `id` so retries do not duplicate orders.', evidence: [{ pr: 7, author: 'priya' }] });
+        // 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([]); // one PR is not enough to verify
-        expect(lessonsSection(lessonsForDiff(repo, diff, 'all'))).toContain('src/orders.ts: Use an upsert keyed on `id` so retries do not duplicate orders. (acted on in PR #7)');
+        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/review-learning/review-points.d.ts

@@ -0,0 +1,4 @@
+/** The bullet and numbered lines of a review body: the points a reviewer makes outside any one line. */
+export declare function bodyPoints(body: string): string[];
+/** A comment's first non-empty line, markup removed, at most 140 characters. */
+export declare function firstLine(text: string): string;

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

@@ -0,0 +1,14 @@
+/**
+ * The points a person makes in a review body: its bullet and numbered lines, each cut to its first
+ * line. One reader for the backtest's ledger and the learner, so both see the same points.
+ */
+const BULLET = /^\s*(?:[-*]|\d+[.)])\s+(.{8,})$/;
+/** The bullet and numbered lines of a review body: the points a reviewer makes outside any one line. */
+export function bodyPoints(body) {
+    return body.split('\n').map(l => BULLET.exec(l)?.[1]).filter((l) => !!l).map(firstLine);
+}
+/** A comment's first non-empty line, markup removed, at most 140 characters. */
+export function firstLine(text) {
+    const line = text.split('\n').find(l => l.trim())?.replace(/[*_`#]/g, '').trim() ?? '';
+    return line.length > 140 ? `${line.slice(0, 137)}...` : line;
+}

package/dist/review-learning/rules-from-reviews.d.ts

@@ -0,0 +1,14 @@
+import type { ReviewLesson } from './lessons.js';
+/** One model call: the prompt in, the answer text out, or undefined when it could not run (learning never fails on it). */
+export type RuleWriter = (prompt: string) => Promise<string | undefined>;
+/**
+ * The points as the rules the model wrote: a point it called no rule is kept and marked so (never
+ * promoted again), a point it did not answer is kept as it was (a failed call never loses evidence), and
+ * the person's words stay in the evidence. A rule about a file keeps that file only when the point was already about it.
+ */
+export declare function rulesFromReviews(lessons: ReviewLesson[], write: RuleWriter): Promise<{
+    lessons: ReviewLesson[];
+    rules: number;
+    dropped: number;
+    unanswered: number;
+}>;

package/dist/review-learning/rules-from-reviews.js

@@ -0,0 +1,86 @@
+/**
+ * Turning reviews into rules: a frontier model rewrites each point a person made, which the pull
+ * request then acted on, as the plain-language rule behind it, or says it is not a rule (a test
+ * report, a status note, a one-off fix). Memory, never training: the rule is text the next judge and
+ * agent read, it keeps the person's own words as evidence, and it stays a candidate until the same
+ * rule recurs in two or more pull requests or a person promotes it.
+ */
+import crypto from 'crypto';
+/** Points per call: enough to share the context, few enough that every one gets an answer. */
+const BATCH = 20;
+const MAX_RULE = 200;
+function rulesPrompt(lessons) {
+    const points = lessons.map(l => ({ id: l.id, pr: l.evidence[0]?.pr, file: l.file || null, said: l.text }));
+    return `A team's senior reviewers teach through code review. Below are points people made in reviews of
+this repository, each of which the pull request then acted on. For each point, decide whether it
+teaches a rule the team would want applied to future changes, beyond this one pull request.
+
+- If it does, write that rule as one plain imperative sentence of at most ${MAX_RULE} characters
+  ("Apply every filter known before a read in the query itself."). Keep a name only when the rule is
+  about that code. Give "file" when the rule is about one file, else null.
+- If it is a test or check report, a status note, praise, a question, or a fix of one specific bug that
+  teaches nothing general, give "rule": null.
+
+Do not read or change any file; answer from the points alone. Your final message must be ONLY this
+JSON: {"rules":[{"id":"<the point's id>","rule":"..." | null,"file":"<path>" | null}]}
+
+Points:
+${JSON.stringify(points, null, 1)}`;
+}
+/**
+ * The points as the rules the model wrote: a point it called no rule is kept and marked so (never
+ * promoted again), a point it did not answer is kept as it was (a failed call never loses evidence), and
+ * the person's words stay in the evidence. A rule about a file keeps that file only when the point was already about it.
+ */
+export async function rulesFromReviews(lessons, write) {
+    const out = [];
+    let rules = 0, dropped = 0, unanswered = 0;
+    for (let i = 0; i < lessons.length; i += BATCH) {
+        const batch = lessons.slice(i, i + BATCH);
+        const answers = parseRules(await write(rulesPrompt(batch)));
+        for (const lesson of batch) {
+            const answer = answers.get(lesson.id);
+            if (!answer) {
+                unanswered++;
+                out.push(lesson);
+            }
+            else if (!answer.rule) {
+                // Kept, marked: a point the writer found no rule in is never promoted, or paid for, again.
+                dropped++;
+                out.push({ ...lesson, evidence: [...lesson.evidence, { kind: 'norule', pr: lesson.evidence[0]?.pr ?? 0, comment: `norule-${lesson.id}`, author: '', detail: 'the rule writer found no rule in it' }] });
+            }
+            else {
+                rules++;
+                const file = answer.file && answer.file === lesson.file ? lesson.file : '';
+                out.push({
+                    ...lesson, text: answer.rule, file,
+                    id: crypto.createHash('sha256').update(`${file}\u0000${answer.rule.toLowerCase().replace(/[^a-z0-9]+/g, ' ').trim()}`).digest('hex').slice(0, 12),
+                    evidence: lesson.evidence.map(e => ({ ...e, said: e.said ?? lesson.text })),
+                });
+            }
+        }
+    }
+    return { lessons: out, rules, dropped, unanswered };
+}
+function parseRules(text) {
+    const found = new Map();
+    if (!text)
+        return found;
+    const start = text.indexOf('{"rules"') >= 0 ? text.indexOf('{"rules"') : text.indexOf('{');
+    for (let end = text.lastIndexOf('}'); start >= 0 && end > start; end = text.lastIndexOf('}', end - 1)) {
+        try {
+            const parsed = JSON.parse(text.slice(start, end + 1));
+            for (const r of Array.isArray(parsed?.rules) ? parsed.rules : []) {
+                if (typeof r?.id !== 'string')
+                    continue;
+                const rule = typeof r.rule === 'string' && r.rule.trim().length >= 12 ? r.rule.trim().slice(0, MAX_RULE) : null;
+                found.set(r.id, { rule, file: typeof r.file === 'string' ? r.file : null });
+            }
+            return found;
+        }
+        catch {
+            // not a whole object yet: try a shorter one
+        }
+    }
+    return found;
+}

package/dist/review-learning/team-lessons.d.ts

@@ -4,5 +4,21 @@ export type LessonMode = 'verified' | 'all' | 'off';
 export declare const DEFAULT_LESSON_MODE: LessonMode;
 /** The team's review lessons in play for this mode: none when off, verified ones by default. */
 export declare function activeLessons(cwd: string, mode?: LessonMode): ReviewLesson[];
-export declare function lessonsForDiff(cwd: string, diff: string, mode?: LessonMode): ReviewLesson[];
+/** `standards`: how many team standards may come with the file lessons (a judge reading a whole pull request takes more than an agent's one question). */
+export declare function lessonsForDiff(cwd: string, diff: string, mode?: LessonMode, standards?: number): ReviewLesson[];
+/** The points this team rejected that a change touches: what the judges are told is settled. */
+export declare function rejectedForDiff(cwd: string, diff: string): ReviewLesson[];
+/** A lesson as a judge or agent sees it, in one place. */
+export interface LessonView {
+    file: string;
+    text: string;
+    prs: number[];
+    said?: string;
+}
+export declare function lessonView(l: ReviewLesson): LessonView;
+/**
+ * One line per lesson: where it applies, the rule, and, when a model wrote the rule from a person's
+ * point, their own words, so anyone can see when the rule went beyond what was said.
+ */
+export declare function describeLesson(l: LessonView): string;
 export declare function lessonsSection(lessons: ReviewLesson[]): string;

package/dist/review-learning/team-lessons.js

@@ -13,20 +13,44 @@ export function activeLessons(cwd, mode = DEFAULT_LESSON_MODE) {
         return [];
     return readLessons(cwd).filter(l => mode === 'all' || l.state === 'verified');
 }
-export function lessonsForDiff(cwd, diff, mode = DEFAULT_LESSON_MODE) {
+/** `standards`: how many team standards may come with the file lessons (a judge reading a whole pull request takes more than an agent's one question). */
+export function lessonsForDiff(cwd, diff, mode = DEFAULT_LESSON_MODE, standards) {
     if (mode === 'off')
         return [];
     const lessons = readLessons(cwd);
     if (lessons.length === 0)
         return [];
-    const files = Object.keys(parseDiff(diff));
+    return matchLessons(lessons, changeShape(diff), { includeCandidates: mode === 'all', ...(standards !== undefined ? { standards } : {}) });
+}
+/** The points this team rejected that a change touches: what the judges are told is settled. */
+export function rejectedForDiff(cwd, diff) {
+    const rejected = readLessons(cwd).filter(l => l.state === 'rejected');
+    if (rejected.length === 0)
+        return [];
+    const matched = new Set(matchLessons(rejected.map(l => ({ ...l, state: 'verified' })), changeShape(diff), { standards: 5 }).map(l => l.id));
+    return rejected.filter(l => matched.has(l.id));
+}
+function changeShape(diff) {
     const added = diff.split('\n').filter(line => line.startsWith('+') && !line.startsWith('+++')).join('\n');
-    const symbols = new Set(added.match(/[A-Za-z_$][\w$]{3,}/g) ?? []);
-    return matchLessons(lessons, { files, symbols }, { includeCandidates: mode === 'all' });
+    return { files: Object.keys(parseDiff(diff)), symbols: new Set(added.match(/[A-Za-z_$][\w$]{3,}/g) ?? []) };
+}
+export function lessonView(l) {
+    const said = l.evidence.find(e => e.said && e.said !== l.text)?.said;
+    return { file: l.file, text: l.text, prs: [...new Set(l.evidence.map(e => e.pr))], ...(said ? { said } : {}) };
+}
+/**
+ * One line per lesson: where it applies, the rule, and, when a model wrote the rule from a person's
+ * point, their own words, so anyone can see when the rule went beyond what was said.
+ */
+export function describeLesson(l) {
+    const where = l.file ? `${l.file}: ` : 'team standard: ';
+    const said = l.said ? ` (in their words: "${l.said}")` : '';
+    const prs = l.prs.length ? ` (acted on in PR ${l.prs.map(p => `#${p}`).join(', ')})` : '';
+    return `${where}${l.text}${said}${prs}`;
 }
 export function lessonsSection(lessons) {
     if (lessons.length === 0)
         return '';
-    const lines = lessons.map(l => `- ${l.file}: ${l.text} (acted on in PR ${[...new Set(l.evidence.map(e => `#${e.pr}`))].join(', ')})`);
+    const lines = lessons.map(l => `- ${describeLesson(lessonView(l))}`);
     return `TEAM LESSONS (this team asked for these in past reviews; check whether the change repeats any):\n${lines.join('\n')}`;
 }

package/dist/templates/universal-config.js

@@ -211,10 +211,12 @@ export const UNIVERSAL_CONFIG = {
         unused_exports: {
             enabled: true,
             allow: [],
+            block: false,
         },
         orphan_files: {
             enabled: true,
             allow: [],
+            block: false,
         },
         query_patterns: {
             enabled: true,
@@ -290,6 +292,7 @@ export const UNIVERSAL_CONFIG = {
             judges: 2,
             escalate: 'always',
             cross_models: {},
+            judge_env: {},
         },
     },
     ignore: [],