@rigour-labs/core 6.9.0-rc.2 → 6.9.0-rc.4

package/dist/index.d.ts

@@ -20,7 +20,8 @@ export { dismissFinding, dismissedKeys, findingKey, isProven, mustFix, quietSpli
 export { loadLedger, ledgerProblems, runBacktest, backtestPassed, formatBacktest, LEDGER_PATH, type Ledger, type RoundResult } from './review/backtest.js';
 export { scaffoldLedger } from './review/backtest-init.js';
 export type { CiResult, FollowUp, PrOutcome } from './outcomes/outcome.js';
-export { runOutcomes, type OutcomesRun } from './outcomes/run.js';
+export { localOutcomeMetrics, runOutcomes, type OutcomesRun } from './outcomes/run.js';
+export type { OutcomeMetrics, Share } from './outcomes/metrics.js';
 export { fixScope, type FixScope } from './review/fix-scope.js';
 export { isGeneratedFile } from './review/generated-files.js';
 export { costBucket, countUsage, doNotTrack, durationBucket, flushDailyUsage, isTelemetryEnabled, readTelemetryState, setTelemetryEnabled, shouldAskTelemetry, telemetryToken, trackUsage } from './telemetry/telemetry.js';
@@ -46,7 +47,7 @@ export { learnFromReviews, type LearnFromReviewsOptions, type LearnFromReviewsRe
 export { ruleWriterFor } from './review/reviewer/rule-writer.js';
 export { backtestLast, formatLast, scoreLast, LAST_LEDGER_PATH, type LastReport } from './review/backtest-last.js';
 export { buildRecord, recordLines, recordIntact, type ReviewRecord } from './review/reviewer/record.js';
-export { readLessons, writeLessons, decideLesson, lessonState, matchLessons, lessonText, lessonsPath, type ReviewLesson, type LessonEvidence } from './review-learning/lessons.js';
+export { readLessons, writeLessons, decideLesson, lessonState, pendingDecision, matchLessons, lessonText, lessonsPath, type ReviewLesson, type LessonEvidence } from './review-learning/lessons.js';
 export { lessonsForDiff, lessonsSection, type LessonMode } from './review-learning/team-lessons.js';
 export { recordAgentWrites, captureHumanEdits } from './review-learning/human-edits.js';
 export { readRepoRules, rulesForDiff, rulesSection, splitRules, type RepoRule } from './review-learning/repo-rules.js';

package/dist/index.js

@@ -19,7 +19,7 @@ export { isControlFile, mergeBaseOf, readStateFile } from './review/trusted-stat
 export { dismissFinding, dismissedKeys, findingKey, isProven, mustFix, quietSplit, DISMISSED_FILE } from './review/quiet.js';
 export { loadLedger, ledgerProblems, runBacktest, backtestPassed, formatBacktest, LEDGER_PATH } from './review/backtest.js';
 export { scaffoldLedger } from './review/backtest-init.js';
-export { runOutcomes } from './outcomes/run.js';
+export { localOutcomeMetrics, runOutcomes } from './outcomes/run.js';
 export { fixScope } from './review/fix-scope.js';
 export { isGeneratedFile } from './review/generated-files.js';
 export { costBucket, countUsage, doNotTrack, durationBucket, flushDailyUsage, isTelemetryEnabled, readTelemetryState, setTelemetryEnabled, shouldAskTelemetry, telemetryToken, trackUsage } from './telemetry/telemetry.js';
@@ -45,7 +45,7 @@ export { learnFromReviews } from './review-learning/learn-from-reviews.js';
 export { ruleWriterFor } from './review/reviewer/rule-writer.js';
 export { backtestLast, formatLast, scoreLast, LAST_LEDGER_PATH } from './review/backtest-last.js';
 export { buildRecord, recordLines, recordIntact } from './review/reviewer/record.js';
-export { readLessons, writeLessons, decideLesson, lessonState, matchLessons, lessonText, lessonsPath } from './review-learning/lessons.js';
+export { readLessons, writeLessons, decideLesson, lessonState, pendingDecision, matchLessons, lessonText, lessonsPath } from './review-learning/lessons.js';
 export { lessonsForDiff, lessonsSection } from './review-learning/team-lessons.js';
 export { recordAgentWrites, captureHumanEdits } from './review-learning/human-edits.js';
 export { readRepoRules, rulesForDiff, rulesSection, splitRules } from './review-learning/repo-rules.js';

package/dist/outcomes/metrics.d.ts

@@ -0,0 +1,56 @@
+/**
+ * The outcome loop's numbers: the one place they are counted (Studio, `rigour outcomes --json` and telemetry read this,
+ * never their own count). The shape is versioned and documented in docs/OUTCOMES.md, "Numbers".
+ *
+ * Counts only, over what this machine read. A rate is given only when at least MIN_FOR_RATE records are behind it;
+ * below that it is null with the reason. Pull requests a review by Rigour saw and pull requests it did not are counted
+ * side by side and never compared: teams choose which pull requests get reviewed, so the two groups differ, and a gap
+ * between them is not Rigour's effect.
+ */
+import type { ReviewLesson } from '../review-learning/lessons.js';
+import type { PrOutcome } from './outcome.js';
+export interface Share {
+    count: number;
+    of: number;
+    /** count / of, two decimals; null when `of` is under MIN_FOR_RATE. */
+    rate: number | null;
+    reason?: string;
+}
+export interface OutcomeMetrics {
+    version: 1;
+    records: {
+        merged: number;
+        settled: number;
+        unsettled: number;
+    };
+    /** Over settled records only: an open window can still change. */
+    settled: {
+        /** Over settled records whose CI result is known (passed or failed): one with no CI to read never dilutes it. */
+        ciRegressed: Share;
+        /** Settled records with no CI result to read. */
+        ciUnknown: number;
+        reverted: Share;
+        /** A later commit on its files, inside the window, that says it fixes something. */
+        fixedLater: Share;
+        /** Side by side, never compared (see above). */
+        reviewed: {
+            prs: number;
+            fixedLater: Share;
+        };
+        notReviewed: {
+            prs: number;
+            fixedLater: Share;
+        };
+    };
+    lessons: {
+        /** Candidates waiting on a person: a later fix on their lines, back to candidate, or taken back. */
+        awaitingDecision: number;
+        /** Promoted by a person after such evidence. */
+        promotedFromEvidence: number;
+        dismissed: number;
+        /** Taken back by evidence and not promoted again since. */
+        takenBack: number;
+    };
+}
+/** `reviewed`: the pull requests a review by Rigour ran on (the threads' review events). */
+export declare function outcomeMetrics(records: PrOutcome[], lessons: ReviewLesson[], reviewed: Set<number>): OutcomeMetrics;

package/dist/outcomes/metrics.js

@@ -0,0 +1,38 @@
+import { pendingDecision } from '../review-learning/lessons.js';
+/** Fewer records than this give a count, never a percentage. */
+const MIN_FOR_RATE = 10;
+/** `reviewed`: the pull requests a review by Rigour ran on (the threads' review events). */
+export function outcomeMetrics(records, lessons, reviewed) {
+    const settled = records.filter(r => r.settled);
+    const fixed = (r) => r.followUps.some(f => f.fix);
+    const inReview = settled.filter(r => reviewed.has(r.pr));
+    const notInReview = settled.filter(r => !reviewed.has(r.pr));
+    return {
+        version: 1,
+        records: { merged: records.length, settled: settled.length, unsettled: records.length - settled.length },
+        settled: {
+            ciRegressed: share(settled.filter(r => r.ci === 'failure').length, settled.filter(r => r.ci === 'success' || r.ci === 'failure').length),
+            ciUnknown: settled.filter(r => r.ci !== 'success' && r.ci !== 'failure').length,
+            reverted: share(settled.filter(r => !!r.reverted).length, settled.length),
+            fixedLater: share(settled.filter(fixed).length, settled.length),
+            reviewed: { prs: inReview.length, fixedLater: share(inReview.filter(fixed).length, inReview.length) },
+            notReviewed: { prs: notInReview.length, fixedLater: share(notInReview.filter(fixed).length, notInReview.length) },
+        },
+        lessons: {
+            awaitingDecision: lessons.filter(l => pendingDecision(l)).length,
+            promotedFromEvidence: lessons.filter(promotedAfterEvidence).length,
+            dismissed: lessons.filter(l => l.evidence.some(e => e.kind === 'dismissed')).length,
+            takenBack: lessons.filter(l => pendingDecision(l)?.kind === 'demoted').length,
+        },
+    };
+}
+function share(count, of) {
+    return of >= MIN_FOR_RATE
+        ? { count, of, rate: Math.round((count / of) * 100) / 100 }
+        : { count, of, rate: null, reason: `fewer than ${MIN_FOR_RATE} records: a count, not a rate` };
+}
+/** A person's promotion that came after a later fix on its lines, a reclassification or a take-back. */
+function promotedAfterEvidence(lesson) {
+    const evidenceAt = lesson.evidence.findIndex(e => e.kind === 'lines' || e.kind === 'reclassified' || e.kind === 'demoted');
+    return evidenceAt >= 0 && lesson.evidence.slice(evidenceAt + 1).some(e => e.kind === 'accepted') && lesson.state === 'verified';
+}

package/dist/outcomes/run.d.ts

@@ -8,6 +8,7 @@ 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';
+import { type OutcomeMetrics } from './metrics.js';
 export interface OutcomesRun {
     switch: ResolvedSwitch;
     outcomes: PrOutcome[];
@@ -17,6 +18,8 @@ export interface OutcomesRun {
     stopped?: string;
     /** What the records did to the team's review lessons (review-learning/outcome-evidence.ts). */
     lessons?: OutcomeEvidenceResult;
+    /** The outcome numbers over every record kept (metrics.ts). */
+    metrics?: OutcomeMetrics;
 }
 export declare function runOutcomes(cwd: string, config: Config, options: {
     flag?: boolean;
@@ -24,3 +27,5 @@ export declare function runOutcomes(cwd: string, config: Config, options: {
     last?: number;
     exec?: Exec;
 }): Promise<OutcomesRun>;
+/** The outcome numbers for this checkout (metrics.ts), over every record it keeps; undefined when it keeps none. Read-only. */
+export declare function localOutcomeMetrics(cwd: string): OutcomeMetrics | undefined;

package/dist/outcomes/run.js

@@ -7,6 +7,7 @@ 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';
+import { outcomeMetrics } from './metrics.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. */
@@ -30,16 +31,28 @@ 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('; ');
     const lessons = lessonEvidence(cwd, mainRef, config.learning?.outcomes?.demote_after ?? 2);
-    return { switch: resolved, outcomes: run.outcomes, read: run.read, ...(lessons ? { lessons } : {}), ...(stopped ? { stopped } : {}) };
+    const metrics = localOutcomeMetrics(cwd);
+    return { switch: resolved, outcomes: run.outcomes, read: run.read, ...(lessons ? { lessons } : {}), ...(metrics ? { metrics } : {}), ...(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 result = applyOutcomeEvidence(lessons, Object.values(readPrOutcomes(cwd).outcomes), reviews(cwd).applied, { demoteAfter, git: gitIn(cwd), mainRef, deadline: Date.now() + LESSON_DEADLINE_MS });
+    if (result.added)
+        writeLessons(cwd, lessons);
+    return result;
+}
+/** Per pull request, the lessons a review of it recorded as applying, and every pull request a review by Rigour ran on: from the threads. */
+function reviews(cwd) {
     const applied = new Map();
+    const reviewed = new Set();
     for (const e of eventsOfKind(cwd, 'review')) {
-        if (typeof e.pr !== 'number' || !Array.isArray(e.lessons_applied))
+        if (typeof e.pr !== 'number')
+            continue;
+        reviewed.add(e.pr);
+        if (!Array.isArray(e.lessons_applied))
             continue;
         const ids = applied.get(e.pr) ?? new Set();
         for (const id of e.lessons_applied)
@@ -47,10 +60,12 @@ function lessonEvidence(cwd, mainRef, demoteAfter) {
                 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;
+    return { applied, reviewed };
+}
+/** The outcome numbers for this checkout (metrics.ts), over every record it keeps; undefined when it keeps none. Read-only. */
+export function localOutcomeMetrics(cwd) {
+    const records = Object.values(readPrOutcomes(cwd).outcomes);
+    return records.length ? outcomeMetrics(records, readLessons(cwd), reviews(cwd).reviewed) : undefined;
 }
 async function onePr(cwd, pr, exec, env) {
     const view = await exec('gh', ['pr', 'view', String(pr), '--json', 'number,mergedAt,mergeCommit,headRefName,author,state'], { cwd, timeoutMs: GH_TIMEOUT_MS, ...(env ? { env } : {}) });

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

@@ -12,12 +12,13 @@ import type { Git, ReviewBody, ReviewComment } from './acted-on.js';
  *   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' | 'followup' | 'lines' | 'dismissed' | 'against' | 'demoted';
+export type EvidenceKind = 'point' | 'outcome' | 'counter' | 'correction' | 'accepted' | 'rejected' | 'norule' | 'followup' | 'lines' | 'dismissed' | 'against' | 'demoted' | 'reclassified';
 export interface LessonEvidence {
     kind?: EvidenceKind;
     pr: number;
@@ -59,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. */
@@ -108,6 +109,12 @@ export declare function matchLessons(lessons: ReviewLesson[], change: ChangeShap
 /** RIGOUR_REVIEW_LESSONS points at a lessons file outside the clone (CI, or a team's shared copy). */
 export declare function lessonsPath(cwd: string): string;
 export declare function readLessons(cwd: string): ReviewLesson[];
+/**
+ * What a person is asked to decide on a candidate, from the last of its evidence and decisions: taken back by evidence
+ * (`demoted`), back to a candidate when outcomes stopped promoting (`reclassified`), or a later fix on its lines
+ * (`lines`); undefined when nothing waits on a person. Studio and the outcome numbers read it, so they never disagree.
+ */
+export declare function pendingDecision(lesson: ReviewLesson): LessonEvidence | undefined;
 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' | 'dismissed', by: string, why?: string): ReviewLesson | undefined;

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));
@@ -56,8 +56,8 @@ export function lessonState(lesson) {
         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');
@@ -227,12 +227,40 @@ 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 [];
     }
 }
+/**
+ * What a person is asked to decide on a candidate, from the last of its evidence and decisions: taken back by evidence
+ * (`demoted`), back to a candidate when outcomes stopped promoting (`reclassified`), or a later fix on its lines
+ * (`lines`); undefined when nothing waits on a person. Studio and the outcome numbers read it, so they never disagree.
+ */
+export function pendingDecision(lesson) {
+    if (lesson.state !== 'candidate')
+        return undefined;
+    const last = lesson.evidence.filter(e => e.kind === 'demoted' || e.kind === 'lines' || e.kind === 'reclassified' || e.kind === 'accepted' || e.kind === 'rejected' || e.kind === 'dismissed').at(-1);
+    return last?.kind === 'demoted' || last?.kind === 'lines' || last?.kind === 'reclassified' ? last : undefined;
+}
+/** 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

@@ -13,8 +13,8 @@
  * 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 evidence promoted
- * (by an outcome or by recurrence): it is `demoted` to a candidate. A lesson a person promoted, or corrected into being,
+ * 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';

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

@@ -44,7 +44,7 @@ export function applyOutcomeEvidence(lessons, records, applied, options) {
             }
         }
         // Against it: later pull requests a review found repeating it, merged anyway, settled clean.
-        if (lesson.state === 'verified' && (lesson.promotedBy === 'outcome' || lesson.promotedBy === 'recurrence')) {
+        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))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rigour-labs/core",
-  "version": "6.9.0-rc.2",
+  "version": "6.9.0-rc.4",
   "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.2",
-    "@rigour-labs/brain-darwin-x64": "6.9.0-rc.2",
-    "@rigour-labs/brain-linux-arm64": "6.9.0-rc.2",
-    "@rigour-labs/brain-linux-x64": "6.9.0-rc.2",
-    "@rigour-labs/brain-win-x64": "6.9.0-rc.2"
+    "@rigour-labs/brain-darwin-arm64": "6.9.0-rc.4",
+    "@rigour-labs/brain-darwin-x64": "6.9.0-rc.4",
+    "@rigour-labs/brain-win-x64": "6.9.0-rc.4",
+    "@rigour-labs/brain-linux-arm64": "6.9.0-rc.4",
+    "@rigour-labs/brain-linux-x64": "6.9.0-rc.4"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",