@rigour-labs/core 6.9.0-rc.1 → 6.9.0-rc.3

package/dist/goal/goal.js

@@ -44,9 +44,9 @@ const FILE_EXTENSIONS = new Set(['ts', 'tsx', 'mts', 'cts', 'js', 'mjs', 'cjs',
     'ini', 'cfg', 'conf', 'c', 'h', 'cc', 'cpp', 'hpp', 'cs', 'php', 'scala', 'ex', 'exs', 'dart', 'lua', 'tf', 'hcl', 'snap']);
 /**
  * A token that names a file or path: has a folder separator or a glob, or ends in a known file extension. Member
- * access (`JSON.parse`, `session.leadId`, `res.status`) is a symbol, not a file. A bare `name.ext` is a file only when
+ * access (`JSON.parse`, `order.customerId`, `res.status`) is a symbol, not a file. A bare `name.ext` is a file only when
  * `exists` (the repository's file names) knows it, so `package.json` is a file and `res.json` is a member access. A URL
- * or an app route (`https://host/checkout?x=1`, `/learner/dashboard`) is never a file of the repository.
+ * or an app route (`https://host/checkout?x=1`, `/app/dashboard`) is never a file of the repository.
  */
 function isPath(token, exists) {
     if (/:\/\//.test(token) || token.startsWith('/') || !/^[\w.@/*?[\]{}!,+()$~-]+$/.test(token))

package/dist/outcomes/outcome.d.ts

@@ -1,5 +1,9 @@
 import { type Exec } from '../review/reviewer/exec.js';
-/** success and failure from the check runs; pending while one runs; none when there are none; unavailable when GitHub could not say. */
+/**
+ * failure: a check that passed on the commit before the merge failed on the merge commit (the merge broke it; a check
+ * already failing on main says nothing about this pull request); success: none did; pending while one runs; none when
+ * there are no runs; unavailable when GitHub could not say.
+ */
 export type CiResult = 'success' | 'failure' | 'pending' | 'none' | 'unavailable';
 export interface FollowUp {
     sha: string;
@@ -15,6 +19,8 @@ export interface PrOutcome {
     mergeSha: string;
     mergedAt: string;
     branch: string;
+    /** Who wrote the pull request: independence between pull requests is judged by it. */
+    author: string;
     /** What the merge changed on main: its first-parent diff. */
     files: string[];
     ci: CiResult;
@@ -35,28 +41,40 @@ export interface OutcomeOptions {
     windowDays: number;
     /** Only history before this time (a backtest); now when unset. */
     until?: string;
-    /** The CI result for a commit (gh); `unavailable` when it cannot be read. */
-    ci: (sha: string) => Promise<CiResult>;
+    /** The CI result for the merge commit against the commit before it on main (gh); `unavailable` when it cannot be read. */
+    ci: (sha: string, parent: string) => Promise<CiResult>;
+    /** How git is run (tests count the calls); `spawnSync` by default. */
+    git?: (args: string[]) => string;
 }
+type MergedRef = {
+    number: number;
+    mergeSha: string;
+    mergedAt: string;
+    branch: string;
+    author: string;
+};
 /**
- * The CI result for a commit from all its check runs, every page (a big matrix runs more than 100: a failure on page two
- * must not read as success); any error is `unavailable`, never a throw.
+ * The CI result for a merge commit from all its check runs, every page (a big matrix runs more than 100: a failure on
+ * page two must not read as success). A run that failed is counted only when the same check did not fail on the commit
+ * before the merge, read only then: on a main branch where a check is often red, "any run failed" says nothing about the
+ * pull request. Any error is `unavailable`, never a throw.
  */
-export declare function checkRunsCi(cwd: string, exec: Exec, env?: Record<string, string>): (sha: string) => Promise<CiResult>;
+export declare function checkRunsCi(cwd: string, exec: Exec, env?: Record<string, string>): (sha: string, parent: string) => Promise<CiResult>;
+interface OutcomeStore {
+    version: 1;
+    outcomes: Record<string, PrOutcome>;
+}
+export declare function readPrOutcomes(cwd: string): OutcomeStore;
 /**
  * Brings the store up to date for these merged pull requests: a settled record is kept as it is, anything else is read
  * again. The branch's thread (when this machine has one) gets a `merge` event the first time and an `outcome` event when
  * the record settles. Stops at `deadline` (ms since epoch) and says so: what was read is kept.
  */
-export declare function updatePrOutcomes(cwd: string, prs: Array<{
-    number: number;
-    mergeSha: string;
-    mergedAt: string;
-    branch: string;
-}>, options: OutcomeOptions & {
+export declare function updatePrOutcomes(cwd: string, prs: MergedRef[], options: OutcomeOptions & {
     deadline?: number;
 }): Promise<{
     outcomes: PrOutcome[];
     read: number;
     stopped?: string;
 }>;
+export {};

package/dist/outcomes/outcome.js

@@ -14,73 +14,95 @@ import { FIX, revertsPr } from '../review-learning/outcomes.js';
 import { GH_TIMEOUT_MS } from '../review/reviewer/exec.js';
 import { appendBranchEvent } from '../task/thread.js';
 const DAY_MS = 24 * 60 * 60 * 1000;
+/** An unsettled record read this recently is kept as it is: its window is open, and reading it again every run starves the older ones. */
+const RECHECK_MS = 12 * 60 * 60 * 1000;
 const OUTCOMES_FILE = path.join('.rigour', 'outcomes.json');
-/** The outcome of one merged pull request as of now (or `until`). */
-async function prOutcome(cwd, pr, options) {
+/** The outcome of one merged pull request as of now (or `until`), its follow-ups taken from main's log read once for the run. */
+async function prOutcome(pr, options, run, log) {
     const now = options.until ? Date.parse(options.until) : Date.now();
     const windowEnd = new Date(Math.min(Date.parse(pr.mergedAt) + options.windowDays * DAY_MS, now)).toISOString();
     const closed = Date.parse(pr.mergedAt) + options.windowDays * DAY_MS <= now;
-    const files = lines(git(cwd, ['diff', '--name-only', `${pr.mergeSha}^1`, pr.mergeSha]));
-    const followUps = files.length ? followUpsOf(cwd, pr.mergeSha, options.mainRef, files, pr.mergedAt, windowEnd) : [];
+    const files = lines(run(['diff', '--name-only', `${pr.mergeSha}^1`, pr.mergeSha]));
+    const followUps = followUpsOf(log, pr, files, windowEnd);
     const revert = followUps.find(f => revertsPr(f.subject, pr));
-    const ci = await options.ci(pr.mergeSha);
+    const ci = await options.ci(pr.mergeSha, `${pr.mergeSha}^1`);
     return {
-        pr: pr.number, mergeSha: pr.mergeSha, mergedAt: pr.mergedAt, branch: pr.branch, files, ci, followUps,
+        pr: pr.number, mergeSha: pr.mergeSha, mergedAt: pr.mergedAt, branch: pr.branch, author: pr.author, files, ci, followUps,
         ...(revert ? { reverted: { sha: revert.sha, subject: revert.subject } } : {}),
         windowEnd,
         settled: closed && (ci === 'success' || ci === 'failure' || ci === 'none'),
         checkedAt: new Date(now).toISOString(),
     };
 }
+/** The commits after the merge on main's first-parent history, up to the window's end, that touched any of the pull request's files. */
+function followUpsOf(log, pr, files, windowEnd) {
+    const wanted = new Set(files);
+    const merged = log.findIndex(c => c.sha === pr.mergeSha);
+    // The merge itself is in the log (it is read from a day before the earliest merge); without it, time decides.
+    const after = merged >= 0 ? log.slice(merged + 1) : log.filter(c => c.at > pr.mergedAt);
+    return after.filter(c => c.at <= windowEnd).flatMap(c => {
+        const touched = c.files.filter(file => wanted.has(file));
+        return touched.length ? [{ sha: c.sha, at: c.at, subject: c.subject, files: touched, fix: FIX.test(c.subject) }] : [];
+    });
+}
 /**
- * First-parent commits on main after the merge, inside the window, that touched any of the pull request's files. Both
- * ends bounded. The files are matched here, not passed to git: a large pull request's paths would pass the command-line
- * limit (about 32 KB on Windows), and the window already bounds what git lists.
+ * Main's first-parent history between two times, oldest first, with each commit's files: read once for every pull
+ * request a run brings up to date (their windows overlap). The files are matched in code, not passed to git: a large
+ * pull request's paths would pass the command-line limit (about 32 KB on Windows).
  */
-function followUpsOf(cwd, mergeSha, mainRef, files, from, to) {
-    const wanted = new Set(files);
-    const out = git(cwd, ['log', '--first-parent', '--name-only', '--format=%x00%H%x09%cI%x09%s', `--since=${from}`, `--until=${to}`, `${mergeSha}..${mainRef}`]);
+function mainLog(run, mainRef, since, until) {
+    const out = run(['log', '--first-parent', '--name-only', '--format=%x00%H%x09%cI%x09%s', `--since=${since}`, `--until=${until}`, mainRef]);
     return out.split('\0').filter(Boolean).flatMap(block => {
         const [header, ...rest] = block.split('\n');
         const [sha, at, ...subject] = header.split('\t');
-        if (!sha || !at)
-            return [];
-        const touched = rest.map(line => line.trim()).filter(file => wanted.has(file));
-        if (touched.length === 0)
-            return [];
-        const text = subject.join('\t');
-        return [{ sha, at, subject: text, files: touched, fix: FIX.test(text) }];
-    }).reverse(); // oldest first
+        return sha && at ? [{ sha, at, subject: subject.join('\t'), files: rest.map(line => line.trim()).filter(Boolean) }] : [];
+    }).reverse();
 }
 /**
- * The CI result for a commit from all its check runs, every page (a big matrix runs more than 100: a failure on page two
- * must not read as success); any error is `unavailable`, never a throw.
+ * The CI result for a merge commit from all its check runs, every page (a big matrix runs more than 100: a failure on
+ * page two must not read as success). A run that failed is counted only when the same check did not fail on the commit
+ * before the merge, read only then: on a main branch where a check is often red, "any run failed" says nothing about the
+ * pull request. Any error is `unavailable`, never a throw.
  */
 export function checkRunsCi(cwd, exec, env) {
-    return async (sha) => {
+    const runs = async (sha) => {
         try {
-            const read = await exec('gh', ['api', '--paginate', `repos/{owner}/{repo}/commits/${sha}/check-runs?per_page=100`, '--jq', '[.check_runs[] | {status, conclusion}]'], { cwd, timeoutMs: GH_TIMEOUT_MS, ...(env ? { env } : {}) });
+            const read = await exec('gh', ['api', '--paginate', `repos/{owner}/{repo}/commits/${sha}/check-runs?per_page=100`, '--jq', '[.check_runs[] | {name, status, conclusion}]'], { cwd, timeoutMs: GH_TIMEOUT_MS, ...(env ? { env } : {}) });
             if (read.exitCode !== 0)
-                return 'unavailable';
+                return undefined;
             // One array per page; unlike parseJsonArrays, output that does not parse is unavailable here, never an empty "none" that would settle.
-            return ciFrom(JSON.parse(`[${read.stdout.trim().replace(/\]\s*\[/g, '],[')}]`).flat());
+            return JSON.parse(`[${read.stdout.trim().replace(/\]\s*\[/g, '],[')}]`).flat();
         }
         catch {
-            return 'unavailable';
+            return undefined;
         }
     };
+    return async (sha, parent) => {
+        const merge = await runs(sha);
+        if (!merge)
+            return 'unavailable';
+        const failed = merge.filter(failedRun);
+        if (failed.length === 0)
+            return ciFrom(merge);
+        const before = await runs(parent);
+        if (!before)
+            return 'unavailable';
+        const redBefore = new Set(before.filter(failedRun).map(r => r.name));
+        return failed.some(r => !redBefore.has(r.name)) ? 'failure' : ciFrom(merge.filter(r => !failedRun(r)));
+    };
+}
+function failedRun(run) {
+    return run.conclusion === 'failure' || run.conclusion === 'timed_out';
 }
-/** A failure anywhere fails it; a run still going keeps it pending; cancelled and skipped runs say nothing. */
+/** With no new failure: a run still going keeps it pending; cancelled and skipped runs say nothing. */
 function ciFrom(runs) {
     if (!Array.isArray(runs) || runs.length === 0)
         return 'none';
-    if (runs.some(r => r.conclusion === 'failure' || r.conclusion === 'timed_out'))
-        return 'failure';
     if (runs.some(r => r.status !== 'completed'))
         return 'pending';
     return runs.some(r => r.conclusion === 'success') ? 'success' : 'none';
 }
-function readPrOutcomes(cwd) {
+export function readPrOutcomes(cwd) {
     try {
         const parsed = JSON.parse(fs.readFileSync(path.join(cwd, OUTCOMES_FILE), 'utf8'));
         return parsed?.version === 1 && parsed.outcomes && typeof parsed.outcomes === 'object' ? parsed : { version: 1, outcomes: {} };
@@ -97,29 +119,35 @@ function readPrOutcomes(cwd) {
 export async function updatePrOutcomes(cwd, prs, options) {
     const store = readPrOutcomes(cwd);
     const result = [];
+    const run = options.git ?? ((args) => git(cwd, args));
     let read = 0;
     let stopped;
-    for (const pr of prs) {
-        if (!pr.mergeSha)
-            continue;
-        const known = store.outcomes[pr.mergeSha];
-        if (known?.settled) {
-            result.push(known);
-            continue;
-        }
+    const now = options.until ? Date.parse(options.until) : Date.now();
+    const fresh = (outcome) => !!outcome && (outcome.settled || now - Date.parse(outcome.checkedAt) < RECHECK_MS);
+    // Oldest merge first: those are the ones whose windows close, so a run cut short by the deadline still moves records
+    // towards settled instead of reading the newest, still-open ones again and again.
+    const pending = prs.filter(pr => pr.mergeSha && !fresh(store.outcomes[pr.mergeSha])).sort((a, b) => (a.mergedAt < b.mergedAt ? -1 : 1));
+    // Main's log once, across every pull request to read: from a day before the earliest merge (so each merge commit is in
+    // it) to the latest window's end, bounded at both ends.
+    const log = pending.length ? mainLog(run, options.mainRef, new Date(Math.min(...pending.map(pr => Date.parse(pr.mergedAt))) - DAY_MS).toISOString(), new Date(Math.min(now, Math.max(...pending.map(pr => Date.parse(pr.mergedAt))) + options.windowDays * DAY_MS)).toISOString()) : [];
+    for (const pr of pending) {
         if (options.deadline !== undefined && Date.now() > options.deadline) {
             stopped = `read deadline reached after ${read} pull request(s); run again to read the rest`;
             break;
         }
-        const outcome = await prOutcome(cwd, pr, options);
+        const known = store.outcomes[pr.mergeSha];
+        const outcome = await prOutcome(pr, options, run, log);
         read++;
         if (!known)
             appendBranchEvent(cwd, pr.branch, { kind: 'merge', pr: pr.number, merge_sha: pr.mergeSha, merged_at: pr.mergedAt });
         if (outcome.settled)
             appendBranchEvent(cwd, pr.branch, { kind: 'outcome', pr: pr.number, ci: outcome.ci, follow_ups: outcome.followUps.length, fixes: outcome.followUps.filter(f => f.fix).length, reverted: !!outcome.reverted });
         store.outcomes[pr.mergeSha] = outcome;
-        result.push(outcome);
     }
+    // In the order asked for: every record known for these pull requests, read now or kept.
+    for (const pr of prs)
+        if (pr.mergeSha && store.outcomes[pr.mergeSha])
+            result.push(store.outcomes[pr.mergeSha]);
     fs.mkdirSync(path.join(cwd, '.rigour'), { recursive: true });
     fs.writeFileSync(path.join(cwd, OUTCOMES_FILE), JSON.stringify(store, null, 2) + '\n');
     return { outcomes: result, read, ...(stopped ? { stopped } : {}) };

package/dist/outcomes/run.d.ts

@@ -7,6 +7,7 @@ import type { Config } from '../types/index.js';
 import { type Exec } from '../review/reviewer/exec.js';
 import { type ResolvedSwitch } from '../switches.js';
 import { type PrOutcome } from './outcome.js';
+import { type OutcomeEvidenceResult } from '../review-learning/outcome-evidence.js';
 export interface OutcomesRun {
     switch: ResolvedSwitch;
     outcomes: PrOutcome[];
@@ -14,6 +15,8 @@ export interface OutcomesRun {
     read: number;
     /** Why the run read less than it was asked to, when it did. */
     stopped?: string;
+    /** What the records did to the team's review lessons (review-learning/outcome-evidence.ts). */
+    lessons?: OutcomeEvidenceResult;
 }
 export declare function runOutcomes(cwd: string, config: Config, options: {
     flag?: boolean;

package/dist/outcomes/run.js

@@ -2,9 +2,15 @@ import { branchBase } from '../gates/logic-drift-git-base.js';
 import { mergedPrs } from '../review/backtest-init.js';
 import { defaultExec, githubEnv, GH_TIMEOUT_MS } from '../review/reviewer/exec.js';
 import { resolveSwitch } from '../switches.js';
-import { checkRunsCi, updatePrOutcomes } from './outcome.js';
+import { checkRunsCi, readPrOutcomes, updatePrOutcomes } from './outcome.js';
+import { applyOutcomeEvidence } from '../review-learning/outcome-evidence.js';
+import { readLessons, writeLessons } from '../review-learning/lessons.js';
+import { gitIn } from '../review-learning/acted-on.js';
+import { eventsOfKind } from '../task/thread.js';
 /** How long one run may read before it stops and keeps what it has. */
 const READ_DEADLINE_MS = 2 * 60_000;
+/** How long one run may follow points' lines through history; the next run carries on. */
+const LESSON_DEADLINE_MS = 60_000;
 export async function runOutcomes(cwd, config, options) {
     const exec = options.exec ?? defaultExec;
     const resolved = resolveSwitch('outcomes', config, options.flag);
@@ -23,14 +29,35 @@ export async function runOutcomes(cwd, config, options) {
     });
     const incomplete = listed.incomplete ? 'the list of merged pull requests may be incomplete (gh listed too many updates to prove it)' : undefined;
     const stopped = [run.stopped, incomplete].filter(Boolean).join('; ');
-    return { switch: resolved, outcomes: run.outcomes, read: run.read, ...(stopped ? { stopped } : {}) };
+    const lessons = lessonEvidence(cwd, mainRef, config.learning?.outcomes?.demote_after ?? 2);
+    return { switch: resolved, outcomes: run.outcomes, read: run.read, ...(lessons ? { lessons } : {}), ...(stopped ? { stopped } : {}) };
+}
+/** Every record kept (not only this run's) against the team's lessons, and the reviews that found a lesson repeated; written only when something changed. */
+function lessonEvidence(cwd, mainRef, demoteAfter) {
+    const lessons = readLessons(cwd);
+    if (lessons.length === 0)
+        return undefined;
+    const applied = new Map();
+    for (const e of eventsOfKind(cwd, 'review')) {
+        if (typeof e.pr !== 'number' || !Array.isArray(e.lessons_applied))
+            continue;
+        const ids = applied.get(e.pr) ?? new Set();
+        for (const id of e.lessons_applied)
+            if (typeof id === 'string')
+                ids.add(id);
+        applied.set(e.pr, ids);
+    }
+    const result = applyOutcomeEvidence(lessons, Object.values(readPrOutcomes(cwd).outcomes), applied, { demoteAfter, git: gitIn(cwd), mainRef, deadline: Date.now() + LESSON_DEADLINE_MS });
+    if (result.added)
+        writeLessons(cwd, lessons);
+    return result;
 }
 async function onePr(cwd, pr, exec, env) {
-    const view = await exec('gh', ['pr', 'view', String(pr), '--json', 'number,mergedAt,mergeCommit,headRefName,state'], { cwd, timeoutMs: GH_TIMEOUT_MS, ...(env ? { env } : {}) });
+    const view = await exec('gh', ['pr', 'view', String(pr), '--json', 'number,mergedAt,mergeCommit,headRefName,author,state'], { cwd, timeoutMs: GH_TIMEOUT_MS, ...(env ? { env } : {}) });
     if (view.exitCode !== 0)
         throw new Error(`could not read pull request #${pr}: ${view.stderr.trim() || 'is gh signed in?'}`);
     const p = JSON.parse(view.stdout);
     if (p.state !== 'MERGED' || !p.mergeCommit?.oid)
         throw new Error(`pull request #${pr} is not merged`);
-    return { prs: [{ number: p.number, mergedAt: p.mergedAt, mergeSha: p.mergeCommit.oid, branch: p.headRefName ?? '' }], incomplete: false };
+    return { prs: [{ number: p.number, mergedAt: p.mergedAt, mergeSha: p.mergeCommit.oid, branch: p.headRefName ?? '', author: p.author?.login ?? '' }], incomplete: false };
 }

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

@@ -17,6 +17,7 @@ export interface MergedPr {
     mergedAt: string;
     mergeSha: string;
     branch: string;
+    author: string;
 }
 /** The last `n` merged pull requests, newest merge first; `incomplete` when the listing could not prove it has them all. */
 export declare function mergedPrs(cwd: string, n: number, config: Config, exec?: Exec): Promise<{

package/dist/review/backtest-init.js

@@ -58,7 +58,7 @@ export async function mergedPrs(cwd, n, config, exec = defaultExec) {
     // than its update, which is no later than that). Until then the listing doubles: bots that touch old pull requests after
     // merge (backports, labels, stale comments) can crowd a window.
     for (let limit = n * MERGED_OVERFETCH;; limit *= 2) {
-        const list = await exec('gh', ['pr', 'list', '--state', 'merged', '--limit', String(limit), '--search', 'sort:updated-desc', '--json', 'number,mergedAt,updatedAt,mergeCommit,headRefName'], { cwd, timeoutMs: GH_TIMEOUT_MS, env });
+        const list = await exec('gh', ['pr', 'list', '--state', 'merged', '--limit', String(limit), '--search', 'sort:updated-desc', '--json', 'number,mergedAt,updatedAt,mergeCommit,headRefName,author'], { cwd, timeoutMs: GH_TIMEOUT_MS, env });
         if (list.exitCode !== 0)
             throw new Error(`could not list merged pull requests: ${list.stderr.trim() || 'is gh signed in?'}`);
         let listed;
@@ -68,7 +68,7 @@ export async function mergedPrs(cwd, n, config, exec = defaultExec) {
         catch {
             throw new Error('could not read the list of merged pull requests');
         }
-        const prs = [...listed].sort((a, b) => (a.mergedAt < b.mergedAt ? 1 : -1)).slice(0, n).map(({ number, mergedAt, mergeCommit, headRefName }) => ({ number, mergedAt, mergeSha: mergeCommit?.oid ?? '', branch: headRefName ?? '' }));
+        const prs = [...listed].sort((a, b) => (a.mergedAt < b.mergedAt ? 1 : -1)).slice(0, n).map(({ number, mergedAt, mergeCommit, headRefName, author }) => ({ number, mergedAt, mergeSha: mergeCommit?.oid ?? '', branch: headRefName ?? '', author: author?.login ?? '' }));
         const oldestUpdate = listed.reduce((min, p) => (p.updatedAt < min ? p.updatedAt : min), listed[0]?.updatedAt ?? '');
         const complete = listed.length < limit || (prs.length === n && oldestUpdate <= prs[n - 1].mergedAt);
         if (complete)

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

@@ -56,6 +56,16 @@ export declare function reviewerInputs(review: {
     hints: string;
     checks: string[];
 };
+/** A lesson as the judge was shown it: its id, and the line it was listed as (the judge answers by that line). */
+export interface ServedLesson {
+    id: string;
+    listed: string;
+}
+/** The ids of the served lessons the judge said this change repeats; an answer that names no served lesson says nothing. */
+export declare function lessonsApplied(answers: Array<{
+    lesson: string;
+    applies: boolean;
+}>, served: ServedLesson[]): string[];
 /** The context pack as Markdown, its hash for the fingerprint, and the router's count of risky changed functions (undefined when it could not score). */
 export declare function buildContext(input: ContextInput): {
     text: string;
@@ -63,6 +73,7 @@ export declare function buildContext(input: ContextInput): {
     risky: number | undefined;
     rules: ServedRule[];
     lessons: number;
+    servedLessons: ServedLesson[];
 };
 /**
  * Tracked Markdown docs that name a changed file by path or by a distinctive file stem: one

package/dist/review/reviewer/context.js

@@ -70,6 +70,12 @@ export function dismissedAs(item, dismissals) {
 export function reviewerInputs(review) {
     return { hints: review.hints.join('\n'), checks: review.findings.map(f => `${f.files?.[0] ?? '?'}${f.line ? `:${f.line}` : ''} ${f.title}`) };
 }
+/** The ids of the served lessons the judge said this change repeats; an answer that names no served lesson says nothing. */
+export function lessonsApplied(answers, served) {
+    const norm = (text) => text.toLowerCase().replace(/\s+/g, ' ').trim();
+    const ids = answers.filter(a => a.applies === true && typeof a.lesson === 'string').map(a => served.find(s => norm(s.listed) === norm(a.lesson) || (norm(a.lesson).length >= 20 && norm(s.listed).startsWith(norm(a.lesson))))?.id);
+    return [...new Set(ids.filter((id) => !!id))];
+}
 /** The context pack as Markdown, its hash for the fingerprint, and the router's count of risky changed functions (undefined when it could not score). */
 export function buildContext(input) {
     const sections = [];
@@ -81,9 +87,9 @@ export function buildContext(input) {
         task = undefined;
     }
     // A judge reads the whole pull request: more of what the team taught fits than an agent's one question at the stop.
-    const lessons = input.lessons === 'off' ? [] : lessonsForDiff(input.cwd, input.diff, input.lessons, JUDGE_STANDARDS, JUDGE_FILE_LESSONS, JUDGE_LESSONS_PER_FILE, input.pr).map(lessonView);
-    if (lessons.length)
-        sections.push(`## Lessons this team taught on earlier reviews, for what this change touches (context: a lesson never blocks on its own; a finding still needs its quote)\n${lessons.map(l => `- ${describeLesson(l)}`).join('\n')}`);
+    const servedLessons = input.lessons === 'off' ? [] : lessonsForDiff(input.cwd, input.diff, input.lessons, JUDGE_STANDARDS, JUDGE_FILE_LESSONS, JUDGE_LESSONS_PER_FILE, input.pr).map(l => ({ id: l.id, listed: describeLesson(lessonView(l)) }));
+    if (servedLessons.length)
+        sections.push(`## Lessons this team taught on earlier reviews, for what this change touches (context: a lesson never blocks on its own; a finding still needs its quote)\n${servedLessons.map(l => `- ${l.listed}`).join('\n')}`);
     // The repository's own rules, always: the reviewer is the boundary, and what the team wrote is the standard it checks.
     const rules = rulesForDiff(input.cwd, input.diff, true, JUDGE_RULES).map((r) => ({ id: r.id, source: r.source, text: r.text, requirement: r.requirement }));
     if (rules.length)
@@ -103,7 +109,7 @@ export function buildContext(input) {
     if (docs.length)
         sections.push(`## Docs that describe the changed code (read one when its claim matters to a finding)\n${docs.map(d => `- ${d.doc} (names ${d.names.join(', ')})`).join('\n')}`);
     const text = sections.length ? `# What this team already knows\n\n${sections.join('\n\n')}\n` : 'none\n';
-    return { text, key: createHash('sha256').update(text).digest('hex').slice(0, 16), risky: task ? task.items.length + task.alreadyReviewed : undefined, rules, lessons: lessons.length };
+    return { text, key: createHash('sha256').update(text).digest('hex').slice(0, 16), risky: task ? task.items.length + task.alreadyReviewed : undefined, rules, lessons: servedLessons.length, servedLessons };
 }
 function where(x) {
     return x.file ? `${x.file}${x.line ? `:${x.line}` : ''}` : '(no file)';

package/dist/review/reviewer.d.ts

@@ -73,6 +73,8 @@ export interface ReviewerResult {
     };
     /** The record of this review (record.ts) and where it is kept, beside the verdict. */
     record?: ReviewRecord;
+    /** The team's lessons the judge said this change repeats, by id: what the outcome loop reads against a lesson (review-learning/outcome-evidence.ts). */
+    lessonsApplied?: string[];
     recordPath?: string;
     /** Tokens every run reported, summed: the only measure of a CLI that reports no dollars (Codex). */
     tokens?: Tokens;

package/dist/review/reviewer.js

@@ -34,7 +34,7 @@ import { resolveReviewer } from './reviewer/settings.js';
 import { VerdictStore } from './reviewer/store.js';
 import { trackUsage } from '../telemetry/telemetry.js';
 import { reviewerUsage } from './reviewer/usage.js';
-import { buildContext, dismissedAs, readReviewDismissals, relatedDocs } from './reviewer/context.js';
+import { buildContext, dismissedAs, lessonsApplied, readReviewDismissals, relatedDocs } from './reviewer/context.js';
 import { buildRecord } from './reviewer/record.js';
 import { account, attachServedRules, changedLinesOf, checkoutSearch, checkoutVerifier, carryResolved, evidenceTouched, mergeVerdicts, parseVerdict } from './reviewer/verdict.js';
 import { judgeUnset } from './reviewer/judge-env.js';
@@ -59,6 +59,7 @@ export async function runReviewer(cwd, base, config, exec = defaultExec, progres
             kind: 'review', trigger, outcome: result.outcome, blocking: result.items.length, should_fix: result.advisory.length,
             ...(result.pr ? { pr: result.pr } : {}),
             ...(result.prTitle ? { pr_title: result.prTitle } : {}),
+            ...(result.lessonsApplied ? { lessons_applied: result.lessonsApplied } : {}),
             ...(result.record ? { integrity: result.record.integrity, cost_usd: result.record.judges.reduce((sum, j) => sum + (j.cost_usd ?? 0), 0), judges: result.record.judges.map(j => j.reviewer) } : {}),
         });
     return result;
@@ -217,7 +218,8 @@ async function review(cwd, base, config, exec, progress, options) {
         const record = (cached && store.readJson(recordPath)) || buildRecord({ head, base: baseSha, scope, verdict, accounted, judges, lessonsServed: context.lessons, humanReviews: reviews.count });
         if (!cached || !fs.existsSync(recordPath))
             store.writeJson(recordPath, record);
-        return { ...res, record, recordPath };
+        const applied = lessonsApplied(verdict.lessons ?? [], context.servedLessons);
+        return { ...res, record, recordPath, ...(applied.length ? { lessonsApplied: applied } : {}) };
     };
     if (!options.force && fs.existsSync(verdictFile) && fs.existsSync(openFile)) {
         const verdict = store.readJson(verdictFile);

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

@@ -46,7 +46,7 @@ export async function learnFromReviews(cwd, options) {
         const byNumber = new Map(prs.filter(pr => pr.mergedAt).map(pr => [pr.number, pr]));
         const reverts = new Map([...byNumber.values()].map(pr => [pr.number, revertOf(git, pr, { mainRef: options.mainRef, until: options.until })]));
         for (const lesson of merged.lessons) {
-            if (lesson.state !== 'candidate' || lesson.evidence.some(e => e.kind === 'outcome' || e.kind === 'counter'))
+            if (lesson.state !== 'candidate' || lesson.evidence.some(e => e.kind === 'outcome' || e.kind === 'lines' || e.kind === 'counter'))
                 continue;
             for (const point of lesson.evidence.filter(e => (e.kind ?? 'point') === 'point')) {
                 const pr = byNumber.get(point.pr);
@@ -54,7 +54,8 @@ export async function learnFromReviews(cwd, options) {
                     continue;
                 const found = (point.actedOn === false ? reverts.get(pr.number) : undefined) ?? outcomeFor(git, lesson, pr, { mainRef: options.mainRef, until: options.until, windowDays: options.windowDays });
                 if (found) {
-                    lesson.evidence.push(found);
+                    // A fix on the point's lines, or a revert, is evidence for a person to promote in Studio, never a promotion (lessonState).
+                    lesson.evidence.push(found.kind === 'outcome' ? { ...found, kind: 'lines' } : found);
                     break;
                 }
             }

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

@@ -6,10 +6,19 @@ import type { Git, ReviewBody, ReviewComment } from './acted-on.js';
  *   counter   the lines shipped unchanged and nothing needed fixing within the window;
  *   correction  a person changed what an agent wrote (human-edits.ts): heavily weighted, it makes a lesson;
  *   accepted / rejected   a person decided (`rigour learn-reviews --promote / --reject`);
- *   norule    the rule writer found no rule in it (a report, a template, a one-off): never promoted again.
+ *   norule    the rule writer found no rule in it (a report, a template, a one-off): never promoted again;
+ *   followup  a later fix touched the point's file, with nothing else to show it was this point (outcome-evidence.ts):
+ *             recorded, never enough on its own;
+ *   lines     a later fix changed the point's own lines (outcome-evidence.ts): shown for a person to promote or dismiss,
+ *             never a promotion on its own (a fix on the same lines is often unrelated work);
+ *   dismissed a person looked at that evidence and set it aside: the lesson stays as it was;
+ *   reclassified  a lesson an outcome alone had promoted, back to a candidate when outcomes stopped promoting (once);
+ *   against   a later pull request a review found repeating the lesson merged anyway and settled clean;
+ *   demoted   enough independent `against` pull requests took back a lesson evidence had promoted: a candidate again,
+ *             until a person promotes it.
  * A record from before evidence kinds has none: it is a `point`.
  */
-export type EvidenceKind = 'point' | 'outcome' | 'counter' | 'correction' | 'accepted' | 'rejected' | 'norule';
+export type EvidenceKind = 'point' | 'outcome' | 'counter' | 'correction' | 'accepted' | 'rejected' | 'norule' | 'followup' | 'lines' | 'dismissed' | 'against' | 'demoted' | 'reclassified';
 export interface LessonEvidence {
     kind?: EvidenceKind;
     pr: number;
@@ -51,9 +60,9 @@ export interface ReviewLesson {
     updatedAt: string;
 }
 /**
- * A lesson's state from its evidence trail. A person's decision wins; then an outcome; counter-evidence
- * holds a candidate back; recurrence across pull requests and authors is enough only without it. A record
- * from before evidence kinds keeps the state it had.
+ * A lesson's state from its evidence trail. A person's decision wins; then a person's correction; counter-evidence
+ * holds a candidate back; recurrence across pull requests and authors is enough only without it. An outcome is
+ * evidence, never a promotion. A record from before evidence kinds keeps the state it had.
  */
 export declare function lessonState(lesson: ReviewLesson): Pick<ReviewLesson, 'state' | 'promotedBy'>;
 /** The point of a review comment: its bold title, else its first sentence, without tool output or markup. */
@@ -102,7 +111,7 @@ export declare function lessonsPath(cwd: string): string;
 export declare function readLessons(cwd: string): ReviewLesson[];
 export declare function writeLessons(cwd: string, lessons: ReviewLesson[]): void;
 /** A person's decision on a lesson, kept as evidence: accepted makes it a lesson, rejected an anti-lesson. Undefined for an unknown id. */
-export declare function decideLesson(cwd: string, id: string, decision: 'accepted' | 'rejected', by: string, why?: string): ReviewLesson | undefined;
+export declare function decideLesson(cwd: string, id: string, decision: 'accepted' | 'rejected' | 'dismissed', by: string, why?: string): ReviewLesson | undefined;
 /** An identifier specific enough to link two pieces of code: camelCase, snake_case, or long. */
 export declare function isSpecific(symbol: string): boolean;
 /** The meaningful words of a text or an identifier: `hasLaterAttempt` and "a later attempt" share later and attempt. */

package/dist/review-learning/lessons.js

@@ -35,9 +35,9 @@ const PLAIN_WORDS = new Set(['when', 'that', 'this', 'with', 'from', 'before', '
 const NOT_CODE = /(\.(md|mdx|txt|ya?ml|json|lock|snap)$)|(\.(test|spec)\.[cm]?[jt]sx?$)|(^|\/)(__tests__|docs?|migrations|\.github)\//i;
 const NOT_SYMBOLS = new Set(['this', 'that', 'with', 'from', 'return', 'const', 'await', 'async', 'function', 'true', 'false', 'null', 'undefined', 'string', 'number', 'boolean', 'export', 'import', 'type', 'interface', 'else', 'when', 'then', 'should', 'line', 'lines']);
 /**
- * A lesson's state from its evidence trail. A person's decision wins; then an outcome; counter-evidence
- * holds a candidate back; recurrence across pull requests and authors is enough only without it. A record
- * from before evidence kinds keeps the state it had.
+ * A lesson's state from its evidence trail. A person's decision wins; then a person's correction; counter-evidence
+ * holds a candidate back; recurrence across pull requests and authors is enough only without it. An outcome is
+ * evidence, never a promotion. A record from before evidence kinds keeps the state it had.
  */
 export function lessonState(lesson) {
     const kinds = new Set(lesson.evidence.map(e => e.kind));
@@ -51,10 +51,13 @@ export function lessonState(lesson) {
         return { state: 'verified', promotedBy: 'person' };
     if (kinds.has('norule'))
         return { state: 'candidate' };
+    // Taken back by evidence (outcome-evidence.ts): a person's decision above is the only way back.
+    if (kinds.has('demoted'))
+        return { state: 'candidate' };
     if (kinds.has('correction'))
         return { state: 'verified', promotedBy: 'correction' };
-    if (kinds.has('outcome'))
-        return { state: 'verified', promotedBy: 'outcome' };
+    // An outcome (a later fix on the point's lines, a revert) no longer promotes on its own: judged by a person against
+    // real history, it was most often unrelated work. It is shown in Studio for a person to promote.
     if (kinds.has('counter'))
         return { state: 'candidate' };
     const points = lesson.evidence.filter(e => (e.kind ?? 'point') === 'point');
@@ -224,12 +227,29 @@ export function lessonsPath(cwd) {
 export function readLessons(cwd) {
     try {
         const parsed = JSON.parse(fs.readFileSync(lessonsPath(cwd), 'utf8'));
-        return Array.isArray(parsed?.lessons) ? parsed.lessons : [];
+        return Array.isArray(parsed?.lessons) ? parsed.lessons.map(reclassified) : [];
     }
     catch {
         return [];
     }
 }
+/** Why a lesson an outcome alone had promoted is a candidate again. */
+const RECLASSIFIED = 'promoted by the exact-line rule, which no longer promotes on its own';
+/**
+ * A lesson stored as verified by an outcome (a later fix on its lines, or a revert), as every reader sees it now that
+ * outcomes no longer promote: its state worked out again from its evidence, and, when that leaves it a candidate, one
+ * `reclassified` record saying why. Never deleted, nothing else changed; the next write keeps it, and a lesson that
+ * already has the record is left as it is. Recurrence, a correction or a person's decision keeps a lesson verified.
+ */
+function reclassified(lesson) {
+    if (lesson.state !== 'verified' || lesson.promotedBy !== 'outcome' || lesson.evidence.some(e => e.kind === 'reclassified'))
+        return lesson;
+    const next = lessonState(lesson);
+    if (next.state === 'verified')
+        return { ...lesson, ...next };
+    const at = new Date().toISOString();
+    return { ...lesson, state: 'candidate', promotedBy: undefined, evidence: [...lesson.evidence, { kind: 'reclassified', pr: lesson.evidence[0]?.pr ?? 0, comment: `reclassified-${lesson.id}`, author: '', detail: RECLASSIFIED, at }] };
+}
 export function writeLessons(cwd, lessons) {
     const file = lessonsPath(cwd);
     fs.mkdirSync(path.dirname(file), { recursive: true });

package/dist/review-learning/outcome-evidence.d.ts

@@ -0,0 +1,41 @@
+/**
+ * What the outcome records (outcomes/outcome.ts) say about the team's review lessons. Deterministic, and a person's
+ * decision always wins (lessonState).
+ *
+ * For a lesson: a point its pull request did not act on, whose own lines (within three either side, followed through
+ * every later commit as code moves: outcomes.ts outcomeFor) a later commit inside the record's window changed, where
+ * that commit says it fixed something and touches at most fifteen files: `lines` evidence, with CI regressing on the
+ * merge commit or a revert recorded as context. It never promotes on its own: judged by a person on real history, a fix
+ * on the same lines was most often unrelated work. Studio shows it on the candidate for a person to promote or dismiss.
+ * A fix that touched only the point's file is `followup` evidence.
+ *
+ * Against a lesson: only when a review of a later pull request recorded the lesson as APPLYING (the change does what the
+ * lesson warns against; the reviewer's lessons step, review event `lessons_applied`) and the pull request merged anyway
+ * and settled clean: CI passed on the merge commit, no fix touched the lesson's file in the window, and no revert. A
+ * pull request that followed the lesson, or that no review checked against it, never counts. `demote_after` such pull
+ * requests, independent (more than one author, or merged at least a week apart), take back a lesson recurrence
+ * promoted: it is `demoted` to a candidate. A lesson a person promoted, or corrected into being,
+ * is not.
+ */
+import type { PrOutcome } from '../outcomes/outcome.js';
+import type { Git } from './acted-on.js';
+import { type ReviewLesson } from './lessons.js';
+export interface OutcomeEvidenceOptions {
+    demoteAfter: number;
+    /** git in the repository, and its main branch: without them, no lines can be followed. */
+    git?: Git;
+    mainRef?: string;
+    /** Stop following lines at this time (ms since epoch); what was found is kept. */
+    deadline?: number;
+}
+/** `suggested`: lessons that got new `lines` evidence, for a person to promote or dismiss; `demoted`: lessons taken back. */
+export interface OutcomeEvidenceResult {
+    added: number;
+    suggested: string[];
+    demoted: string[];
+}
+/**
+ * Adds the evidence the settled and unsettled records give, to `lessons` in place, once each (by its comment key), and
+ * recomputes their states. `applied` is, per pull request, the lessons a review of it recorded as applying.
+ */
+export declare function applyOutcomeEvidence(lessons: ReviewLesson[], records: PrOutcome[], applied: Map<number, Set<string>>, options: OutcomeEvidenceOptions): OutcomeEvidenceResult;

package/dist/review-learning/outcome-evidence.js

@@ -0,0 +1,72 @@
+import { lessonState } from './lessons.js';
+import { outcomeFor } from './outcomes.js';
+/** Lines either side of a point's own that count as its lines, and the most files a fixing commit may touch to say anything about one point. */
+const POINT_SLACK = 3;
+const MAX_FIX_FILES = 15;
+const WEEK_MS = 7 * 24 * 60 * 60 * 1000;
+/**
+ * Adds the evidence the settled and unsettled records give, to `lessons` in place, once each (by its comment key), and
+ * recomputes their states. `applied` is, per pull request, the lessons a review of it recorded as applying.
+ */
+export function applyOutcomeEvidence(lessons, records, applied, options) {
+    const byPr = new Map(records.map(r => [r.pr, r]));
+    const result = { added: 0, suggested: [], demoted: [] };
+    for (const lesson of lessons) {
+        const before = lesson.state;
+        const add = (evidence) => {
+            if (lesson.evidence.some(e => e.comment === evidence.comment))
+                return false;
+            lesson.evidence.push(evidence);
+            result.added++;
+            return true;
+        };
+        const own = new Set(lesson.evidence.filter(e => (e.kind ?? 'point') === 'point').map(e => e.pr));
+        // For it: a point its pull request left alone, whose own lines a later fix inside the window changed.
+        for (const point of lesson.evidence.filter(e => (e.kind ?? 'point') === 'point' && e.actedOn === false)) {
+            const record = byPr.get(point.pr);
+            // Only where the record shows a fix on the file at all: following lines costs a git walk, done only then.
+            const fileFix = lesson.file ? record?.followUps.find(f => f.fix && f.files.includes(lesson.file)) : undefined;
+            if (!record || !fileFix)
+                continue;
+            const context = [record.ci === 'failure' ? 'CI regressed on the merge commit' : '', record.reverted ? `the pull request was reverted by ${record.reverted.sha.slice(0, 9)}` : ''].filter(Boolean).join('; ');
+            const inTime = options.deadline === undefined || Date.now() <= options.deadline;
+            const lines = options.git && options.mainRef && lesson.at && inTime
+                ? outcomeFor(options.git, lesson, { number: record.pr, mergeSha: record.mergeSha, mergedAt: record.mergedAt }, { mainRef: options.mainRef, until: record.windowEnd, slack: POINT_SLACK, maxFiles: MAX_FIX_FILES })
+                : undefined;
+            // Evidence for a person, never a promotion: a fix on the same lines is often unrelated work.
+            if (lines?.kind === 'outcome') {
+                const evidence = { ...lines, kind: 'lines', comment: `lines-${record.pr}-${lines.comment.replace(/^outcome-/, '')}`, detail: `${lines.detail}${context ? `; ${context}` : ''}` };
+                if (add(evidence) && !result.suggested.includes(lesson.id))
+                    result.suggested.push(lesson.id);
+            }
+            else {
+                add({ kind: 'followup', pr: record.pr, comment: `followup-${record.pr}-${fileFix.sha.slice(0, 12)}`, author: '', detail: `${lesson.file} fixed later by ${fileFix.sha.slice(0, 9)} "${fileFix.subject}", not on the point's lines${context ? `; ${context}` : ''}`, at: fileFix.at });
+            }
+        }
+        // Against it: later pull requests a review found repeating it, merged anyway, settled clean.
+        if (lesson.state === 'verified' && lesson.promotedBy === 'recurrence') {
+            for (const [pr, ids] of applied) {
+                const record = byPr.get(pr);
+                if (own.has(pr) || !ids.has(lesson.id) || !record || !settledClean(record, lesson.file))
+                    continue;
+                add({ kind: 'against', pr, comment: `against-${pr}`, author: '', prAuthor: record.author, detail: `a review found #${pr} repeating it; merged ${record.mergedAt.slice(0, 10)}, CI passed, no fix on ${lesson.file || 'its files'} within the window, no revert`, at: record.mergedAt });
+            }
+            const against = lesson.evidence.filter(e => e.kind === 'against');
+            const authors = new Set(against.map(e => e.prAuthor).filter(Boolean)).size;
+            // Independent: more than one author, or merged at least a week apart (a span, never calendar buckets: two merges a day apart across a week boundary are not).
+            const times = against.map(e => Date.parse(e.at ?? '')).filter(Number.isFinite);
+            const apart = times.length > 1 && Math.max(...times) - Math.min(...times) >= WEEK_MS;
+            if (new Set(against.map(e => e.pr)).size >= options.demoteAfter && (authors > 1 || apart)) {
+                add({ kind: 'demoted', pr: against.at(-1).pr, comment: `demoted-${against.map(e => e.pr).sort((a, b) => a - b).join('-')}`, author: '', detail: `taken back: ${against.map(e => `#${e.pr}`).join(', ')} repeated it and settled clean`, at: new Date().toISOString() });
+            }
+        }
+        Object.assign(lesson, lessonState(lesson));
+        if (before === 'verified' && lesson.state === 'candidate')
+            result.demoted.push(lesson.id);
+    }
+    return result;
+}
+/** CI passed on the merge commit, no fix touched the file (any file, for a team standard) within the window, no revert. Settled only. */
+function settledClean(record, file) {
+    return record.settled && record.ci === 'success' && !record.reverted && !record.followUps.some(f => f.fix && (!file || f.files.includes(file)));
+}

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

@@ -16,6 +16,10 @@ export interface OutcomeOptions {
     until?: string;
     /** How long unchanged lines must ship before that counts against the point. */
     windowDays?: number;
+    /** Lines either side of the point's own that count as its lines (outcome-evidence.ts: 3). */
+    slack?: number;
+    /** A fixing commit that touches more files than this is a sweep, and says nothing about one point: no verdict. */
+    maxFiles?: number;
 }
 export interface MergedAt {
     number: number;

package/dist/review-learning/outcomes.js

@@ -7,7 +7,8 @@ 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]);
+    const slack = options.slack ?? 0;
+    let range = shift(changedHunks(git, lesson.at.commit, pr.mergeSha, lesson.file), [Math.max(1, lesson.at.start - slack), lesson.at.end + slack]);
     if (!range)
         return undefined; // the pull request changed them after all
     const before = options.until ? [`--before=${options.until}`] : [];
@@ -26,8 +27,9 @@ export function outcomeFor(git, lesson, pr, options) {
             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;
+        // Changed by a commit that says it fixed something, and is not a sweep across the codebase: the point was right. Changed otherwise: no verdict.
+        const sweep = options.maxFiles !== undefined && git(['show', '--name-only', '--format=', sha]).split('\n').filter(Boolean).length > options.maxFiles;
+        return FIX.test(subject) && !sweep ? { 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);

package/dist/switches.d.ts

@@ -275,6 +275,7 @@ export declare const SWITCHES: {
                 outcomes: {
                     mode: "off" | "on" | "required";
                     window_days: number;
+                    demote_after: number;
                 };
             };
             review: {
@@ -582,6 +583,7 @@ export declare const SWITCHES: {
                 outcomes: {
                     mode: "off" | "on" | "required";
                     window_days: number;
+                    demote_after: number;
                 };
             };
             review: {

package/dist/task/thread.d.ts

@@ -29,6 +29,8 @@ export declare function taskOf(cwd: string): {
 } | undefined;
 /** Appends one event to the checkout's task thread. Best effort: a thread never breaks the hook or command it runs in. */
 export declare function appendTaskEvent(cwd: string, event: TaskEvent): ThreadEvent | undefined;
+/** Every thread's events of one kind, oldest first: what the outcome loop reads across tasks (the reviews that found a lesson repeated). */
+export declare function eventsOfKind(cwd: string, kind: TaskEventKind): ThreadEvent[];
 /**
  * Appends one event to a named branch's thread, under the task its own events carry: what happened to a pull request
  * after it merged, recorded from wherever the outcome was read. Only a thread that already exists is written: a branch

package/dist/task/thread.js

@@ -99,6 +99,13 @@ export function appendTaskEvent(cwd, event) {
         return undefined;
     }
 }
+/** Every thread's events of one kind, oldest first: what the outcome loop reads across tasks (the reviews that found a lesson repeated). */
+export function eventsOfKind(cwd, kind) {
+    const dir = threadsDir(cwd);
+    if (!dir)
+        return [];
+    return listThreads(dir).flatMap(file => readEvents(path.join(dir, file))).filter(e => e.kind === kind).sort(byTime);
+}
 /**
  * Appends one event to a named branch's thread, under the task its own events carry: what happened to a pull request
  * after it merged, recorded from wherever the outcome was read. Only a thread that already exists is written: a branch

package/dist/templates/universal-config.js

@@ -280,7 +280,7 @@ export const UNIVERSAL_CONFIG = {
         max_items: 10,
     },
     learning: {
-        outcomes: { mode: 'off', window_days: 30 },
+        outcomes: { mode: 'off', window_days: 30, demote_after: 2 },
     },
     review: {
         include_heuristics: false,

package/dist/types/index.d.ts

@@ -2420,22 +2420,28 @@ export declare const ConfigSchema: z.ZodObject<{
             mode: z.ZodDefault<z.ZodOptional<z.ZodEnum<["off", "on", "required"]>>>;
             /** How long after a merge later commits count, in days. */
             window_days: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            /** How many later pull requests, independent and settled clean after a review found them repeating a lesson, demote it (review-learning/outcome-evidence.ts). */
+            demote_after: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
         }, "strip", z.ZodTypeAny, {
             mode: "off" | "on" | "required";
             window_days: number;
+            demote_after: number;
         }, {
             mode?: "off" | "on" | "required" | undefined;
             window_days?: number | undefined;
+            demote_after?: number | undefined;
         }>>>;
     }, "strip", z.ZodTypeAny, {
         outcomes: {
             mode: "off" | "on" | "required";
             window_days: number;
+            demote_after: number;
         };
     }, {
         outcomes?: {
             mode?: "off" | "on" | "required" | undefined;
             window_days?: number | undefined;
+            demote_after?: number | undefined;
         } | undefined;
     }>>>;
     /** rigour review / rigour_review / the PR bot / the stop hook. */
@@ -2928,6 +2934,7 @@ export declare const ConfigSchema: z.ZodObject<{
         outcomes: {
             mode: "off" | "on" | "required";
             window_days: number;
+            demote_after: number;
         };
     };
     review: {
@@ -3231,6 +3238,7 @@ export declare const ConfigSchema: z.ZodObject<{
         outcomes?: {
             mode?: "off" | "on" | "required" | undefined;
             window_days?: number | undefined;
+            demote_after?: number | undefined;
         } | undefined;
     } | undefined;
     review?: {

package/dist/types/index.js

@@ -380,6 +380,8 @@ export const ConfigSchema = z.object({
             mode: z.enum(['off', 'on', 'required']).optional().default('off'),
             /** How long after a merge later commits count, in days. */
             window_days: z.number().int().min(7).max(90).optional().default(30),
+            /** How many later pull requests, independent and settled clean after a review found them repeating a lesson, demote it (review-learning/outcome-evidence.ts). */
+            demote_after: z.number().int().min(2).optional().default(2),
         }).optional().default({}),
     }).optional().default({}),
     /** rigour review / rigour_review / the PR bot / the stop hook. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rigour-labs/core",
-  "version": "6.9.0-rc.1",
+  "version": "6.9.0-rc.3",
   "description": "Rigour's review engine: deterministic gates on changed lines, rules and lessons learned from your team's fixes, and per-check precision from what you fix versus dismiss, across TypeScript, JavaScript, Python, Go, Ruby and C#.",
   "engines": {
     "node": ">=22.13"
@@ -75,11 +75,11 @@
     "@anthropic-ai/sdk": "^0.132.1",
     "pg": "^8.16.3",
     "openai": "^5.23.2",
-    "@rigour-labs/brain-darwin-arm64": "6.9.0-rc.1",
-    "@rigour-labs/brain-darwin-x64": "6.9.0-rc.1",
-    "@rigour-labs/brain-linux-x64": "6.9.0-rc.1",
-    "@rigour-labs/brain-linux-arm64": "6.9.0-rc.1",
-    "@rigour-labs/brain-win-x64": "6.9.0-rc.1"
+    "@rigour-labs/brain-darwin-arm64": "6.9.0-rc.3",
+    "@rigour-labs/brain-darwin-x64": "6.9.0-rc.3",
+    "@rigour-labs/brain-linux-arm64": "6.9.0-rc.3",
+    "@rigour-labs/brain-win-x64": "6.9.0-rc.3",
+    "@rigour-labs/brain-linux-x64": "6.9.0-rc.3"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",