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

package/dist/commands/git-identity.d.ts

@@ -0,0 +1 @@
+export declare function personOf(cwd: string): string;

package/dist/commands/git-identity.js

@@ -0,0 +1,10 @@
+/** Who a person's decision is recorded as: their git email in the checkout, or `unknown` without one. */
+import { execFileSync } from 'child_process';
+export function personOf(cwd) {
+    try {
+        return execFileSync('git', ['config', 'user.email'], { cwd, encoding: 'utf8' }).trim() || 'unknown';
+    }
+    catch {
+        return 'unknown'; // no git identity: recorded as unknown
+    }
+}

package/dist/commands/learn-reviews.js

@@ -10,6 +10,7 @@
 import { execFileSync } from 'child_process';
 import chalk from 'chalk';
 import path from 'path';
+import { personOf } from './git-identity.js';
 import { branchBase, decideLesson, defaultExec, githubToken, learnFromReviews, lessonsPath, readLessons, ruleWriterFor, ConfigSchema } from '@rigour-labs/core';
 import { loadConfig } from './review-config.js';
 export async function learnReviewsCommand(cwd, options) {
@@ -57,14 +58,7 @@ function list(cwd, json) {
 }
 /** A person's decision, kept as evidence with who made it (their git email) and why. */
 function decide(cwd, id, decision, why) {
-    let by = 'unknown';
-    try {
-        by = execFileSync('git', ['config', 'user.email'], { cwd, encoding: 'utf8' }).trim() || by;
-    }
-    catch {
-        // no git identity: recorded as unknown
-    }
-    const lesson = decideLesson(cwd, id, decision, by, why);
+    const lesson = decideLesson(cwd, id, decision, personOf(cwd), why);
     if (!lesson) {
         console.error(chalk.red(`No lesson ${id}.`));
         process.exitCode = 1;

package/dist/commands/outcomes.js

@@ -27,6 +27,8 @@ export async function outcomesCommand(cwd, options) {
     for (const o of run.outcomes)
         console.log(outcomeLine(o));
     console.log(chalk.dim(`${run.outcomes.length} pull request(s), ${run.read} read now, the rest settled.${run.stopped ? ` Stopped early: ${run.stopped}.` : ''}`));
+    if (run.lessons?.added)
+        console.log(`Lessons: ${run.lessons.added} new piece(s) of evidence, ${run.lessons.suggested.length} to look at in Studio (a later fix changed their lines), ${run.lessons.demoted.length} taken back.`);
     return 0;
 }
 function outcomeLine(o) {

package/dist/commands/studio-learning.d.ts

@@ -21,6 +21,23 @@ export interface LessonJourney {
     stoppedInDevelopment: number | null;
     reachedPr: number | null;
     canDecide: boolean;
+    /** A review lesson evidence took back (review-learning/outcome-evidence.ts): why, and the pull requests that did. A person may promote it again. */
+    takenBack?: {
+        detail: string;
+        prs: number[];
+        at: string;
+    };
+    /** A later fix changed the point's own lines (review-learning/outcome-evidence.ts): evidence for a person to promote or dismiss, never a promotion on its own. */
+    suggested?: {
+        detail: string;
+        pr: number;
+        at: string;
+    };
+    /** Back to a candidate when outcomes stopped promoting: why, and the evidence that had promoted it, for a person to promote again or dismiss. */
+    reclassified?: {
+        detail: string;
+        evidence: string[];
+    };
 }
 export interface StudioLearning {
     lessons: LessonJourney[];
@@ -39,6 +56,11 @@ export declare function buildLearning(input: {
     events: AgentEvent[];
     weeks?: number;
 }): StudioLearning;
+/** A person's decision on a review lesson from Studio, recorded as `rigour learn-reviews --promote / --reject` records it: with their git email, and final. */
+export declare function decideReviewLesson(cwd: string, body: unknown): {
+    id: string;
+    state: string;
+};
 export declare function loadLearning(cwd: string, now?: Date, weeks?: number): Promise<StudioLearning>;
 /**
  * "Fixed before: Credential header follows redirects (semantic-bugs). The header…" → the defect,

package/dist/commands/studio-learning.js

@@ -7,7 +7,8 @@
  * lesson's subject prefix). Counts that Rigour cannot know here are null, never 0: PR catches
  * recorded on another machine (CI) never reach this one.
  */
-import { fixLessonPrefix, listKnowledgeLessons, readLessons } from '@rigour-labs/core';
+import { decideLesson, fixLessonPrefix, listKnowledgeLessons, readLessons } from '@rigour-labs/core';
+import { personOf } from './git-identity.js';
 import { checkoutRoots, eventsAcross, storiesAcross } from './studio-checkouts.js';
 const WEEK_MS = 7 * 24 * 60 * 60 * 1000;
 const WEEKS = 4;
@@ -40,16 +41,18 @@ export function buildLearning(input) {
             id: l.id,
             text: l.text,
             origin: 'pr',
-            learnedFrom: `At PR ${[...new Set(l.evidence.map(e => `#${e.pr}`))].join(', ')}, from ${[...new Set(l.evidence.map(e => e.author))].join(', ')}`,
+            // Where it was learned: the review points, not the outcome or decision evidence added since.
+            learnedFrom: learnedFromPoints(l.evidence.filter(e => (e.kind ?? 'point') === 'point')),
             learnedAt: l.createdAt,
             state: l.state,
             scope: 'this repo',
             told: told(l.text),
             stoppedInDevelopment: null,
             reachedPr: null,
-            canDecide: false,
+            ...decisionFor(l),
         })),
-    ].sort((a, b) => b.learnedAt.localeCompare(a.learnedAt))
+        // Lessons back to a candidate when outcomes stopped promoting come first: a person decides each once.
+    ].sort((a, b) => Number(!!b.reclassified) - Number(!!a.reclassified) || b.learnedAt.localeCompare(a.learnedAt))
         // The same lesson learned in several places (this repo and personal lessons from others) shows once.
         .filter((lesson, i, all) => all.findIndex(other => other.text === lesson.text) === i);
     const count = input.weeks ?? WEEKS;
@@ -65,6 +68,39 @@ export function buildLearning(input) {
     });
     return { lessons, weeks, prRecorded };
 }
+function learnedFromPoints(points) {
+    const authors = [...new Set(points.map(e => e.author).filter(Boolean))];
+    return `At PR ${[...new Set(points.map(e => `#${e.pr}`))].join(', ')}${authors.length ? `, from ${authors.join(', ')}` : ''}`;
+}
+/**
+ * What a person can decide on a review lesson, from the last of its evidence and decisions: taken back by evidence
+ * (promote it again, or drop it), back to a candidate when outcomes stopped promoting (promote it again, or dismiss),
+ * or a candidate with a later fix on its lines (promote it, or dismiss the evidence).
+ */
+function decisionFor(lesson) {
+    if (lesson.state !== 'candidate')
+        return { canDecide: false };
+    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);
+    if (last?.kind === 'reclassified')
+        return { canDecide: true, reclassified: { detail: last.detail ?? '', evidence: lesson.evidence.filter(e => e.kind === 'outcome' || e.kind === 'lines').map(e => e.detail ?? '').filter(Boolean) } };
+    if (last?.kind === 'demoted')
+        return { canDecide: true, takenBack: { detail: last.detail ?? '', prs: lesson.evidence.filter(e => e.kind === 'against').map(e => e.pr), at: last.at ?? '' } };
+    if (last?.kind === 'lines')
+        return { canDecide: true, suggested: { detail: last.detail ?? '', pr: last.pr, at: last.at ?? '' } };
+    return { canDecide: false };
+}
+/** A person's decision on a review lesson from Studio, recorded as `rigour learn-reviews --promote / --reject` records it: with their git email, and final. */
+export function decideReviewLesson(cwd, body) {
+    const { id, decision, why } = (body ?? {});
+    if (typeof id !== 'string' || !/^[0-9a-f]{12}$/.test(id))
+        throw new Error('a review lesson id (12 hex characters) is required');
+    if (decision !== 'accepted' && decision !== 'rejected' && decision !== 'dismissed')
+        throw new Error('decision is accepted, rejected or dismissed');
+    const lesson = decideLesson(cwd, id, decision, personOf(cwd), typeof why === 'string' && why.trim() ? why.trim() : 'decided in Studio');
+    if (!lesson)
+        throw new Error(`no review lesson ${id}`);
+    return { id: lesson.id, state: lesson.state };
+}
 export async function loadLearning(cwd, now = new Date(), weeks = WEEKS) {
     const roots = checkoutRoots(cwd);
     return buildLearning({ now, lessons: await listKnowledgeLessons(cwd), reviewLessons: readLessons(cwd), stories: storiesAcross(roots), events: eventsAcross(roots), weeks });

package/dist/commands/studio.js

@@ -306,6 +306,16 @@ async function handleApiRequest(req, res, url, ctx) {
         }
         return true;
     }
+    if (url.pathname === '/api/review-lessons' && req.method === 'POST') {
+        try {
+            const { decideReviewLesson } = await import('./studio-learning.js');
+            sendJson(res, 200, decideReviewLesson(cwd, JSON.parse((await readBody(req)) || '{}')));
+        }
+        catch (e) {
+            sendJson(res, 400, { error: e.message });
+        }
+        return true;
+    }
     if (url.pathname === '/api/learning') {
         try {
             const { loadLearning } = await import('./studio-learning.js');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rigour-labs/cli",
-  "version": "6.9.0-rc.1",
+  "version": "6.9.0-rc.3",
   "description": "Code review that happens while your agent writes: deterministic checks on the lines it changed, quiet unless it can prove a defect, and learning from your team's fixes and dismissals. Works with Claude Code, Cursor, Codex, Cline and Windsurf.",
   "engines": {
     "node": ">=22.13"
@@ -59,13 +59,13 @@
     "inquirer": "9.2.16",
     "ora": "^8.0.1",
     "yaml": "^2.8.2",
-    "@rigour-labs/core": "6.9.0-rc.1"
+    "@rigour-labs/core": "6.9.0-rc.3"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",
     "@types/inquirer": "9.0.7",
     "@types/node": "^25.0.3",
-    "@rigour-labs/studio": "6.9.0-rc.1"
+    "@rigour-labs/studio": "6.9.0-rc.3"
   },
   "scripts": {
     "build": "tsc && pnpm bundle-studio",