@rigour-labs/cli 6.8.1 → 6.9.0-rc.2

package/dist/cli.js

@@ -15,6 +15,7 @@ import { hooksInitCommand, hooksCheckCommand } from './commands/hooks.js';
 import { hooksStopCommand } from './commands/hooks-stop.js';
 import { backtestCommand, backtestInitCommand } from './commands/backtest.js';
 import { threadCommand } from './commands/thread.js';
+import { outcomesCommand } from './commands/outcomes.js';
 import { briefCommand, hooksBriefCommand, hooksBriefFileCommand } from './commands/brief.js';
 import { hooksPushCommand } from './commands/hooks-push.js';
 import { hooksReviewBackgroundCommand } from './commands/hooks-review-background.js';
@@ -259,6 +260,8 @@ program
     .option('--max', 'Use the strongest local model (Qwen2.5-Coder-7B, 4.7GB; 16GB RAM)')
     .option('--model-path <gguf>', 'Run a local GGUF instead of the published model (to evaluate a fine-tune)')
     .option('--pr-body <path>', 'File with the PR description, read by --max and cloud review (default: the GitHub Actions pull request)')
+    .option('--goal', 'Check the change against the goal its PR description declares (Scope, Out of scope, Done when), whatever your settings say')
+    .option('--no-goal', 'Do not check the change against its PR description for this run (a team that requires it refuses this)')
     .option('--independent', 'Trust nothing the change wrote, for an enforcing check: review every risky function whatever agents recorded as reviewed, and with --base read dismissals, check outcomes and rigour.yml from the base')
     .option('--diff-tests', 'Run changed exported functions before and after the change and report behaviour changes (vitest/jest packages; needs --max or -k)')
     .option('-k, --api-key <key>', 'Cloud API key for deep analysis')
@@ -520,6 +523,17 @@ program
     .action(async (goal, options) => {
     process.exit(await briefCommand(process.cwd(), goal, options));
 });
+program
+    .command('outcomes')
+    .description('What happened after recent pull requests merged: CI on the merge commit, later commits and fixes on their files, reverts. Needs the outcome loop on (learning.outcomes.mode, RIGOUR_OUTCOMES, or --outcomes)')
+    .option('--pr <number>', 'Only this merged pull request')
+    .option('--last <n>', 'The last n merged pull requests (default 20)')
+    .option('--outcomes', 'Read outcomes for this run, whatever your settings say')
+    .option('--no-outcomes', 'Do not read outcomes for this run (a team that requires them refuses this)')
+    .option('--json', 'Output the records in JSON format')
+    .action(async (options) => {
+    process.exit(await outcomesCommand(process.cwd(), options));
+});
 program
     .command('thread [key]')
     .description('The thread of an engineering task: what agents, checks, pushes and reviews did to it, in order. Key: a ticket (PROJ-123), a branch, or a pull request (#42); the checkout\'s own task by default')

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/hooks-push.js

@@ -16,7 +16,7 @@ import { spawnSync } from 'child_process';
 import fs from 'fs';
 import os from 'os';
 import path from 'path';
-import { appendTaskEvent, branchBase, branchFailures, captureHumanEdits, diffFromGit, itemLine, mergeBaseOf, resolveReviewer, reviewChange, reviewerInputs, reviewerBlocks, runReviewer, runToolchain, startBackgroundReview, } from '@rigour-labs/core';
+import { appendTaskEvent, branchBase, branchFailures, captureHumanEdits, diffFromGit, hookGoalDescription, itemLine, recordGoal, mergeBaseOf, resolveReviewer, reviewChange, reviewerInputs, reviewerBlocks, runReviewer, runToolchain, startBackgroundReview, } from '@rigour-labs/core';
 import { loadHookConfig } from './hooks-stop.js';
 export async function hooksPushCommand(stdin, fallbackCwd) {
     const payload = parse(stdin);
@@ -61,7 +61,9 @@ async function gates(repo, base, mainRef, config) {
     const log = [];
     const source = { mode: 'since', commit: base };
     const diff = diffFromGit(repo, source);
-    const review = await reviewChange({ cwd: repo, config, diff, source, typed: true });
+    const goalDescription = await hookGoalDescription(repo, config);
+    const review = await reviewChange({ cwd: repo, config, diff, source, typed: true, ...(goalDescription !== undefined ? { goalDescription } : {}) });
+    recordGoal(repo, 'push', goalDescription, review);
     // What the review reports is what must be fixed (quiet.ts `mustFix`); the stop hook uses the same set.
     const mustFix = [...review.findings, ...branchFailures(repo, base, mainRef, config)];
     for (const f of mustFix)

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.d.ts

@@ -0,0 +1,6 @@
+export declare function outcomesCommand(cwd: string, options: {
+    pr?: string;
+    last?: string;
+    outcomes?: boolean;
+    json?: boolean;
+}): Promise<number>;

package/dist/commands/outcomes.js

@@ -0,0 +1,39 @@
+/**
+ * `rigour outcomes`: what happened after the repository's recent pull requests merged (core outcomes/): CI on each merge
+ * commit, the later commits on its files and the fixes among them, and a revert. Read when the outcome loop is on
+ * (learning.outcomes.mode, RIGOUR_OUTCOMES, your settings, or --outcomes for this run); kept in .rigour/outcomes.json.
+ */
+import chalk from 'chalk';
+import { runOutcomes } from '@rigour-labs/core';
+import { loadConfig } from './review-config.js';
+export async function outcomesCommand(cwd, options) {
+    const config = await loadConfig(cwd, {});
+    const run = await runOutcomes(cwd, config, {
+        ...(options.outcomes !== undefined ? { flag: options.outcomes } : {}),
+        ...(options.pr ? { pr: Number(options.pr.replace(/^#/, '')) } : {}),
+        ...(options.last ? { last: Number(options.last) } : {}),
+    });
+    // Off is a choice, not a failure: a CI step that runs this for every team stays green where outcomes are off.
+    if (options.json) {
+        console.log(JSON.stringify(run, null, 2));
+        return 0;
+    }
+    for (const line of run.switch.refused)
+        console.error(chalk.yellow(`Not applied: ${line}`));
+    if (!run.switch.enabled) {
+        console.log(chalk.dim(`Nothing read (${run.switch.source}): ${run.stopped}.`));
+        return 0;
+    }
+    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) {
+    const fixes = o.followUps.filter(f => f.fix).length;
+    const ci = o.ci === 'failure' ? chalk.red('CI failed') : o.ci === 'success' ? chalk.green('CI passed') : chalk.dim(`CI ${o.ci}`);
+    const after = `${o.followUps.length} later commit(s) on its files${fixes ? `, ${chalk.yellow(`${fixes} fix(es)`)}` : ''}`;
+    return `#${o.pr} ${o.mergeSha.slice(0, 9)} merged ${o.mergedAt.slice(0, 10)}: ${ci}, ${after}${o.reverted ? `, ${chalk.red(`reverted by ${o.reverted.sha.slice(0, 9)}`)}` : ''}${o.settled ? '' : chalk.dim(' (window open)')}`;
+}

package/dist/commands/review-goal.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The goal check's record for `rigour review --json`: whether it ran, which layer decided, what the description
+ * declared, and why a check that was on checked nothing (docs/GOAL.md).
+ */
+import type { ResolvedSwitch, ReviewResult } from '@rigour-labs/core';
+/** What the goal check did on this run, and why: for the JSON record and a line in the human verdict. */
+export interface GoalReport {
+    enabled: boolean;
+    source: ResolvedSwitch['source'];
+    required: boolean;
+    refused: string[];
+    /** Whether the description declared anything to check (Scope, Out of scope, or a Done when item naming a file or symbol). */
+    declared: boolean;
+    scope?: string[];
+    out_of_scope?: string[];
+    done_when?: number;
+    /** Why a check that is on checked nothing. */
+    reason?: string;
+}
+export declare function goalReport(goal: ResolvedSwitch, description: string | undefined, result: Pick<ReviewResult, 'goal'>): GoalReport;

package/dist/commands/review-goal.js

@@ -0,0 +1,8 @@
+export function goalReport(goal, description, result) {
+    return {
+        enabled: goal.enabled, source: goal.source, required: goal.required, refused: goal.refused, declared: !!result.goal,
+        ...(result.goal ? { scope: result.goal.scope, out_of_scope: result.goal.outOfScope, done_when: result.goal.doneWhen.length } : {}),
+        ...(goal.enabled && description === undefined ? { reason: 'no pull request description: pass --pr-body, or run in a pull request\'s GitHub Actions job' } : {}),
+        ...(goal.enabled && description !== undefined && !result.goal ? { reason: 'the description declares no Scope, Out of scope, or Done when item naming a file or symbol' } : {}),
+    };
+}

package/dist/commands/review-reviewer.d.ts

@@ -1,7 +1,7 @@
 import { type Config, type ReviewerResult, type ReviewResult, type RunChoice } from '@rigour-labs/core';
 /** The base a branch review runs against: the one named, else where the branch left main. */
 export declare function reviewerBase(cwd: string, named: string | undefined): string | undefined;
-export declare function reviewerFor(cwd: string, base: string | undefined, config: Config, full: boolean, choice: RunChoice, review: ReviewResult): Promise<ReviewerResult>;
+export declare function reviewerFor(cwd: string, base: string | undefined, config: Config, full: boolean, choice: RunChoice, review: ReviewResult, goal?: boolean): Promise<ReviewerResult>;
 export declare function printReviewer(result: ReviewerResult, options?: {
     notes?: boolean;
 }): void;

package/dist/commands/review-reviewer.js

@@ -12,10 +12,10 @@ import { branchBase, itemLine, reviewerInputs, reviewStatus, runReviewer } from
 export function reviewerBase(cwd, named) {
     return named ?? branchBase(cwd)?.mainRef.replace(/^refs\/(remotes\/|heads\/)/, '');
 }
-export async function reviewerFor(cwd, base, config, full, choice, review) {
+export async function reviewerFor(cwd, base, config, full, choice, review, goal) {
     if (!base)
         return { outcome: 'unavailable', items: [], unverified: [], resolved: [], answerInReply: [], notes: [], advisory: [], disputed: [], dropped: [], dismissed: [], reason: 'no base to review against: pass --base, or fetch the main branch', reviewers: [], cached: false };
-    return runReviewer(cwd, base, config, undefined, undefined, { trigger: 'review', full, choice, ...reviewerInputs(review) });
+    return runReviewer(cwd, base, config, undefined, undefined, { trigger: 'review', full, choice, ...(goal !== undefined ? { goal } : {}), ...reviewerInputs(review) });
 }
 /** Verified should-fixes shown in full before the rest fold into a count. */
 const ADVISORY_SHOWN = 5;

package/dist/commands/review.d.ts

@@ -12,6 +12,7 @@ export interface ReviewOptions {
     max?: boolean;
     modelPath?: string;
     prBody?: string;
+    goal?: boolean;
     diffTests?: boolean;
     independent?: boolean;
     apiKey?: string;

package/dist/commands/review.js

@@ -16,7 +16,8 @@ import { execFileSync } from 'child_process';
 import fs from 'fs-extra';
 import path from 'path';
 import chalk from 'chalk';
-import { buildReviewTask, costBucket, diffFromGit, durationBucket, flushDailyUsage, Logger, LogLevel, resolveDeepOptions, trackUsage, reviewChange, toReviewFinding, GitDiffError, mergeBaseOf, receiptReport, recordPrCatches, reviewerBlocks } from '@rigour-labs/core';
+import { buildReviewTask, costBucket, diffFromGit, durationBucket, flushDailyUsage, Logger, LogLevel, resolveDeepOptions, trackUsage, resolveSwitch, reviewChange, toReviewFinding, GitDiffError, mergeBaseOf, receiptReport, recordPrCatches, reviewerBlocks } from '@rigour-labs/core';
+import { goalReport } from './review-goal.js';
 import { receiptFor } from './review-receipt.js';
 import { whatWasChecked } from './review-checked.js';
 import { printReviewer, printStatus, reviewerBase, reviewerFor, reviewerJson } from './review-reviewer.js';
@@ -47,6 +48,8 @@ export async function reviewCommand(cwd, options = {}) {
         if (!options.ci && !options.json && !options.githubSummary && isDeep)
             console.log(chalk.blue.bold('Deep analysis enabled.\n'));
         const source = options.base ? { mode: 'base', base: options.base } : { mode: 'working' };
+        const goal = resolveSwitch('goal', config, options.goal);
+        const goalDescription = goal.enabled ? readPrBody(cwd, options) : undefined;
         const result = await reviewChange({
             cwd, config, diff, source,
             files: options.files ? options.files.split(',').map(f => f.trim()).filter(Boolean) : undefined,
@@ -54,13 +57,14 @@ export async function reviewCommand(cwd, options = {}) {
             deep: isDeep ? deepOptions(cwd, options) : undefined,
             trustedRef,
             typed: true,
+            ...(goalDescription !== undefined ? { goalDescription } : {}),
         });
         if (options.base)
             recordPrCatches(cwd, result.findings);
         const receipt = receiptFor(cwd, diff ?? changeDiff(cwd, source), config, !!options.independent);
-        const reviewer = options.reviewer ? await reviewerFor(cwd, reviewerBase(cwd, options.base), config, !!options.full, { ...(options.single ? { mode: 'single' } : {}), ...(options.panel !== undefined ? { panel: options.panel } : {}) }, result) : undefined;
+        const reviewer = options.reviewer ? await reviewerFor(cwd, reviewerBase(cwd, options.base), config, !!options.full, { ...(options.single ? { mode: 'single' } : {}), ...(options.panel !== undefined ? { panel: options.panel } : {}) }, result, options.goal) : undefined;
         const checked = options.json ? whatWasChecked(cwd, options, trustedRef, result) : undefined;
-        await print(result, options, receipt, reviewer, { cwd, scope: scopeOf(options), commits: commitsOf(cwd, options.base), ms: Date.now() - started }, checked);
+        await print(result, options, receipt, reviewer, { cwd, scope: scopeOf(options), commits: commitsOf(cwd, options.base), ms: Date.now() - started }, checked, goalReport(goal, goalDescription, result));
         if (!isDeep && !receipt && !options.ci && !options.json && !options.githubSummary) {
             hintReviewTask(cwd, diff ?? diffFromGit(cwd, source), config.gates.deep?.router);
         }
@@ -147,10 +151,12 @@ function deepOptions(cwd, options) {
         independent: !!options.independent,
     };
 }
-async function print(result, options, receipt, reviewer, context, checked) {
+async function print(result, options, receipt, reviewer, context, checked, goal) {
     const summary = buildCiReviewSummary(result.findings, result.report?.failures.length ?? 0, result.changedLines, result.unlocated + result.fileFindings.length);
     if (options.json)
-        return writeJson(result, summary, receipt, reviewer, checked);
+        return writeJson(result, summary, receipt, reviewer, checked, goal);
+    if (goal?.refused.length && !options.githubSummary)
+        console.error(chalk.yellow(`Goal check: ${goal.refused.join('; ')}`));
     if (options.githubSummary || options.ci) {
         // The machine-read outputs say why a review is not a pass on stderr; the human one says it in its verdict.
         if (result.deepError)
@@ -190,11 +196,12 @@ function changeDiff(cwd, source) {
         return undefined;
     }
 }
-function writeJson(result, summary, receipt, reviewer, checked) {
+function writeJson(result, summary, receipt, reviewer, checked, goal) {
     const stats = result.report?.stats;
     const json = JSON.stringify({
         status: result.status,
         ...(checked ? { checked } : {}),
+        ...(goal ? { goal } : {}),
         score: stats?.score ?? 100,
         ai_health_score: stats?.ai_health_score,
         structural_score: stats?.structural_score,

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

@@ -21,6 +21,18 @@ 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;
+    };
 }
 export interface StudioLearning {
     lessons: LessonJourney[];
@@ -39,6 +51,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,14 +41,15 @@ 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))
         // The same lesson learned in several places (this repo and personal lessons from others) shows once.
@@ -65,6 +67,36 @@ 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), 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 === 'accepted' || e.kind === 'rejected' || e.kind === 'dismissed').at(-1);
+    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-reviewer.js

@@ -10,9 +10,9 @@
 import { execFileSync } from 'child_process';
 import fs from 'fs';
 import path from 'path';
-import YAML from 'yaml';
-import { ConfigSchema, dismissReviewerFinding, loadSettings, resolveReviewer, reviewerAvailability, reviewStatus, saveUserReviewer, } from '@rigour-labs/core';
+import { dismissReviewerFinding, loadSettings, resolveReviewer, reviewerAvailability, reviewStatus, saveUserReviewer, } from '@rigour-labs/core';
 import { loadConfig } from './review-config.js';
+import { writeTeamSettings } from './studio-team-settings.js';
 const TEAM_KEYS = ['enabled', 'mode', 'panel', 'mode_required', 'judges', 'escalate', 'reviewers', 'on_push', 'panel_max_items', 'dismissals'];
 export async function loadStudioReviewer(cwd) {
     const config = await loadConfig(cwd, {});
@@ -76,36 +76,6 @@ export async function saveTeamReviewer(cwd, body) {
     const unknown = Object.keys(patch).find(key => !TEAM_WRITABLE.has(key));
     if (unknown)
         throw new Error(`not a team reviewer setting: ${unknown}`);
-    const file = path.join(cwd, 'rigour.yml');
-    const exists = fs.existsSync(file);
-    if (exists && fs.lstatSync(file).isSymbolicLink())
-        throw new Error('rigour.yml is a link: edit the file it points to directly');
-    if (!exists && create !== true)
-        throw new Error('there is no rigour.yml: creating one makes this the team\'s setup, so confirm it (create: true)');
-    const doc = exists ? YAML.parseDocument(fs.readFileSync(file, 'utf8')) : new YAML.Document({});
-    if (doc.errors.length)
-        throw new Error(`rigour.yml does not parse: ${doc.errors[0].message}`);
-    for (const [key, value] of Object.entries(patch)) {
-        if (value === null)
-            doc.deleteIn(['review', 'reviewer', key]);
-        else
-            doc.setIn(['review', 'reviewer', key], value);
-    }
-    const parsed = ConfigSchema.safeParse(doc.toJS());
-    if (!parsed.success)
-        throw new Error(`that would not be a valid rigour.yml: ${parsed.error.issues.map(i => `${i.path.join('.')}: ${i.message}`).join('; ')}`);
-    fs.writeFileSync(file, String(doc));
-    return { ...(await loadStudioReviewer(cwd)), diff: diffOf(cwd, exists) };
-}
-/** What the person will commit: git's diff of rigour.yml, or the whole new file. */
-function diffOf(cwd, existed) {
-    if (!existed)
-        return fs.readFileSync(path.join(cwd, 'rigour.yml'), 'utf8').split('\n').filter(Boolean).map(line => `+${line}`).join('\n');
-    try {
-        return execFileSync('git', ['diff', '--no-color', '--unified=1', '--', 'rigour.yml'], { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] })
-            .split('\n').filter(line => /^[+-](?![+-])/.test(line) || line.startsWith('@@')).join('\n');
-    }
-    catch {
-        return '';
-    }
+    const diff = writeTeamSettings(cwd, Object.entries(patch).map(([key, value]) => [['review', 'reviewer', key], value]), create === true);
+    return { ...(await loadStudioReviewer(cwd)), diff };
 }

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

@@ -0,0 +1,16 @@
+import { type ResolvedSwitch, type SwitchName, type TeamSwitch } from '@rigour-labs/core';
+export interface StudioSwitch {
+    effective: ResolvedSwitch;
+    team: TeamSwitch;
+    /** Whether the team's setting comes from a rigour.yml, or is Rigour's default. */
+    teamFile: boolean;
+    /** The person's own choice; null when they left it to the team. */
+    user: boolean | null;
+}
+/** A switch's name from a request path, or undefined when it names none. */
+export declare function switchNamed(name: string): SwitchName | undefined;
+export declare function loadStudioSwitch(cwd: string, name: SwitchName): Promise<StudioSwitch>;
+/** `{ user: true | false | null }` changes the person's own; `{ team: 'off' | 'on' | 'required' | null, create? }` the team's. */
+export declare function saveStudioSwitch(cwd: string, name: SwitchName, body: unknown): Promise<StudioSwitch & {
+    diff?: string;
+}>;

package/dist/commands/studio-switches.js

@@ -0,0 +1,39 @@
+/**
+ * Studio's switches (core's switches.ts: the goal check, ...): whether each runs, where that choice comes from, and the
+ * person's and the team's settings. The person's goes to their settings.json; the team's to rigour.yml in the working
+ * tree, never committed (studio-team-settings.ts).
+ */
+import fs from 'fs';
+import path from 'path';
+import { loadSettings, resolveSwitch, saveUserSwitch, SWITCHES } from '@rigour-labs/core';
+import { loadConfig } from './review-config.js';
+import { writeTeamSettings } from './studio-team-settings.js';
+/** A switch's name from a request path, or undefined when it names none. */
+export function switchNamed(name) {
+    return Object.hasOwn(SWITCHES, name) ? name : undefined;
+}
+export async function loadStudioSwitch(cwd, name) {
+    const config = await loadConfig(cwd, {});
+    const user = loadSettings()[name];
+    return {
+        // Studio shows what a run here would do without a flag; the environment is the terminal's, not the person's choice.
+        effective: resolveSwitch(name, config, undefined, user, {}),
+        team: SWITCHES[name].team(config) ?? 'off',
+        teamFile: fs.existsSync(path.join(cwd, 'rigour.yml')),
+        user: user ?? null,
+    };
+}
+/** `{ user: true | false | null }` changes the person's own; `{ team: 'off' | 'on' | 'required' | null, create? }` the team's. */
+export async function saveStudioSwitch(cwd, name, body) {
+    const payload = (body ?? {});
+    if ('user' in payload === 'team' in payload)
+        throw new Error('send either user (true, false or null) or team (off, on, required or null)');
+    if ('user' in payload) {
+        saveUserSwitch(name, payload.user);
+        return loadStudioSwitch(cwd, name);
+    }
+    if (payload.team !== null && payload.team !== 'off' && payload.team !== 'on' && payload.team !== 'required')
+        throw new Error('team is off, on, required, or null for Rigour\'s default');
+    const diff = writeTeamSettings(cwd, [[SWITCHES[name].teamPath, payload.team]], payload.create === true);
+    return { ...(await loadStudioSwitch(cwd, name)), diff };
+}

package/dist/commands/studio-team-settings.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Sets each key path to its value (`null` removes it: Rigour's default again) and returns the diff to commit. The whole
+ * file must still be a valid rigour.yml before it is written. A missing file is created only when asked (`create`),
+ * since that turns a personal install into the team's.
+ */
+export declare function writeTeamSettings(cwd: string, edits: Array<[string[], unknown]>, create: boolean): string;

package/dist/commands/studio-team-settings.js

@@ -0,0 +1,48 @@
+/**
+ * A team setting written from Studio: rigour.yml in the working tree, comments and layout kept, never committed. Team
+ * policy still reaches everyone through a reviewed commit, so the caller shows the diff to commit.
+ */
+import { execFileSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import YAML from 'yaml';
+import { ConfigSchema } from '@rigour-labs/core';
+/**
+ * Sets each key path to its value (`null` removes it: Rigour's default again) and returns the diff to commit. The whole
+ * file must still be a valid rigour.yml before it is written. A missing file is created only when asked (`create`),
+ * since that turns a personal install into the team's.
+ */
+export function writeTeamSettings(cwd, edits, create) {
+    const file = path.join(cwd, 'rigour.yml');
+    const exists = fs.existsSync(file);
+    if (exists && fs.lstatSync(file).isSymbolicLink())
+        throw new Error('rigour.yml is a link: edit the file it points to directly');
+    if (!exists && !create)
+        throw new Error('there is no rigour.yml: creating one makes this the team\'s setup, so confirm it (create: true)');
+    const doc = exists ? YAML.parseDocument(fs.readFileSync(file, 'utf8')) : new YAML.Document({});
+    if (doc.errors.length)
+        throw new Error(`rigour.yml does not parse: ${doc.errors[0].message}`);
+    for (const [key, value] of edits) {
+        if (value === null)
+            doc.deleteIn(key);
+        else
+            doc.setIn(key, value);
+    }
+    const parsed = ConfigSchema.safeParse(doc.toJS());
+    if (!parsed.success)
+        throw new Error(`that would not be a valid rigour.yml: ${parsed.error.issues.map(i => `${i.path.join('.')}: ${i.message}`).join('; ')}`);
+    fs.writeFileSync(file, String(doc));
+    return diffOf(cwd, exists);
+}
+/** What the person will commit: git's diff of rigour.yml, or the whole new file. */
+function diffOf(cwd, existed) {
+    if (!existed)
+        return fs.readFileSync(path.join(cwd, 'rigour.yml'), 'utf8').split('\n').filter(Boolean).map(line => `+${line}`).join('\n');
+    try {
+        return execFileSync('git', ['diff', '--no-color', '--unified=1', '--', 'rigour.yml'], { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] })
+            .split('\n').filter(line => /^[+-](?![+-])/.test(line) || line.startsWith('@@')).join('\n');
+    }
+    catch {
+        return '';
+    }
+}

package/dist/commands/studio.js

@@ -291,6 +291,31 @@ async function handleApiRequest(req, res, url, ctx) {
         }
         return true;
     }
+    const switchPath = /^\/api\/switches\/([a-z]+)$/.exec(url.pathname);
+    if (switchPath && (req.method === 'GET' || req.method === 'POST')) {
+        try {
+            const { loadStudioSwitch, saveStudioSwitch, switchNamed } = await import('./studio-switches.js');
+            const name = switchNamed(switchPath[1]);
+            if (!name)
+                sendJson(res, 404, { error: `no switch named ${switchPath[1]}` });
+            else
+                sendJson(res, 200, req.method === 'GET' ? await loadStudioSwitch(cwd, name) : await saveStudioSwitch(cwd, name, JSON.parse((await readBody(req)) || '{}')));
+        }
+        catch (e) {
+            sendJson(res, req.method === 'GET' ? 500 : 400, { error: e.message });
+        }
+        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.8.1",
+  "version": "6.9.0-rc.2",
   "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.8.1"
+    "@rigour-labs/core": "6.9.0-rc.2"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",
     "@types/inquirer": "9.0.7",
     "@types/node": "^25.0.3",
-    "@rigour-labs/studio": "6.8.1"
+    "@rigour-labs/studio": "6.9.0-rc.2"
   },
   "scripts": {
     "build": "tsc && pnpm bundle-studio",