@rigour-labs/cli 6.10.1 → 6.11.0-rc.1

package/dist/cli.js

@@ -403,6 +403,9 @@ program
     .option('--promote <id>', 'Accept a candidate as a lesson (recorded as your decision)')
     .option('--reject <id>', 'Reject a candidate or lesson: the judges are told this team decided against it')
     .option('--why <text>', 'Why, recorded with --promote or --reject')
+    .option('--compile', 'Propose a deterministic check for each verified lesson a template fits, and list the compiled checks')
+    .option('--approve-check <id>', 'Approve a compiled check: it runs on every review (a note unless gates.compiled_lessons.block)')
+    .option('--withdraw-check <id>', 'Take a compiled check back: it stops running')
     .option('--json', 'Output as JSON')
     .action(async (options) => {
     await learnReviewsCommand(process.cwd(), options);

package/dist/commands/hooks-stop.js

@@ -48,9 +48,9 @@ export async function hooksStopCommand(tool, stdin, fallbackCwd) {
         appendTaskEvent(cwd, { kind: 'stop-review', agent: tool, session, blocked: decision.block, blocking: decision.blocking, files: decision.reviewedFiles });
         if (nothing)
             process.stderr.write(`Rigour stop review: nothing to review against ${decision.against}.\n`);
-        countUsage('stop_review');
+        countUsage('stop_review', 1, { agent: tool });
         if (decision.block)
-            countUsage(attempt > 1 ? 'stop_block_repeat' : 'stop_block');
+            countUsage(attempt > 1 ? 'stop_block_repeat' : 'stop_block', 1, { agent: tool });
         recordReviewed(cwd, session, fingerprint);
         const capture = recordReviewOutcome(cwd, decision.findings, decision.reviewedFiles, 'stop');
         await recordFixLessons(cwd, capture.fixes).catch(() => undefined); // learning never blocks the agent

package/dist/commands/hooks.js

@@ -760,9 +760,10 @@ export async function hooksCheckCommand(cwd, options = {}) {
         result: await runHookChecker({ cwd: group.root, files: group.files, timeout_ms: Number.isFinite(timeout) ? timeout : 5000, agentId }),
     })));
     const result = mergeHookResults(runs.map(r => r.result));
-    countUsage('hook_check');
+    const counted = { agent: cursorMode ? 'cursor' : agentId };
+    countUsage('hook_check', 1, counted);
     for (const failure of result.failures)
-        countUsage(`hook_finding:${failure.gate}`);
+        countUsage(`hook_finding:${failure.gate}`, 1, counted);
     await Promise.allSettled(runs.flatMap(({ root, files: repoFiles, result: repoResult }) => {
         const requestId = randomUUID();
         const outcome = repoResult.status === 'pass' ? 'success' : repoResult.status === 'fail' ? 'rejected' : 'error';

package/dist/commands/learn-reviews.d.ts

@@ -10,6 +10,11 @@ export interface LearnReviewsOptions {
     /** Rewrite each new point as the rule behind it with the team's reviewer CLI (memory, never training). */
     rules?: boolean;
     pr?: string;
+    /** Propose a deterministic check for every verified lesson a template fits, and list the compiled checks. */
+    compile?: boolean;
+    /** A person's decision on a compiled check: it runs (approve) or stops (withdraw). */
+    approveCheck?: string;
+    withdrawCheck?: string;
 }
 export declare function learnReviewsCommand(cwd: string, options: LearnReviewsOptions): Promise<void>;
 /** owner/name from the origin remote (https or ssh, any host alias). */

package/dist/commands/learn-reviews.js

@@ -11,7 +11,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 { branchBase, decideCompiledCheck, decideLesson, defaultExec, proposeCompiledChecks, readCompiledChecks, suspension, githubToken, learnFromReviews, lessonsPath, readLessons, ruleWriterFor, ConfigSchema } from '@rigour-labs/core';
 import { loadConfig } from './review-config.js';
 export async function learnReviewsCommand(cwd, options) {
     if (options.promote)
@@ -20,6 +20,12 @@ export async function learnReviewsCommand(cwd, options) {
         return decide(cwd, options.reject, 'rejected', options.why);
     if (options.list)
         return list(cwd, options.json);
+    if (options.compile)
+        return compile(cwd, options.json);
+    if (options.approveCheck)
+        return decideCheck(cwd, options.approveCheck, 'active');
+    if (options.withdrawCheck)
+        return decideCheck(cwd, options.withdrawCheck, 'withdrawn');
     try {
         const config = await teamConfig(cwd);
         const writeRules = options.rules ? await ruleWriterFor(cwd, config, defaultExec, line => console.error(chalk.yellow(line))) : undefined;
@@ -56,6 +62,57 @@ function list(cwd, json) {
     if (lessons.length === 0)
         console.log('No review lessons yet. Run `rigour learn-reviews`.');
 }
+/** Proposes checks for the verified lessons a template fits, then lists every compiled check and its state. */
+function compile(cwd, json) {
+    const proposed = proposeCompiledChecks(cwd);
+    const checks = readCompiledChecks(cwd);
+    if (json)
+        return void console.log(JSON.stringify({ proposed: proposed.map(c => c.id), checks }, null, 2));
+    const label = { proposed: chalk.yellow('proposed '), active: chalk.green('active   '), withdrawn: chalk.dim('withdrawn') };
+    const lessons = new Map(readLessons(cwd).map(l => [l.id, l]));
+    for (const c of checks) {
+        const suspended = suspension(c, lessons);
+        console.log(`${suspended ? chalk.red('suspended') : label[c.state]} ${chalk.dim(c.id)} ${c.files}: ${c.kind === 'forbid' ? `no \`${c.symbol}\`` : `\`${c.symbol}\` needs \`${c.with}\``} (${c.message})`);
+        if (suspended)
+            console.log(chalk.dim(`          ${suspended}`));
+        if (c.state === 'proposed' && c.backtest)
+            console.log(chalk.dim(`          ${backtestLine(c.backtest)}`));
+    }
+    if (checks.length === 0)
+        console.log('No verified lesson fits a check yet: a lesson compiles when it names its file and its symbols in backticks and says never, avoid, instead of, always or must.');
+    else if (proposed.length)
+        console.log(`\n${proposed.length} new proposal(s). A proposed check runs only once a person approves it: rigour learn-reviews --approve-check <id>`);
+}
+/** What the history says about a proposed check: counts, and a rate only from RATE_MIN. */
+function backtestLine(b) {
+    const share = (s) => `${s.fired} of ${s.n}${s.rate === null ? '' : ` (${Math.round(s.rate * 100)}%)`}`;
+    return `fires on ${share(b.repeating)} merged pull request(s) a review found the lesson repeating in; on ${share(b.other)} other merged change(s) to its files`;
+}
+function decideCheck(cwd, id, state) {
+    try {
+        decideCheckOrThrow(cwd, id, state);
+    }
+    catch (error) {
+        console.error(chalk.red(error.message));
+        process.exitCode = 1;
+    }
+}
+function decideCheckOrThrow(cwd, id, state) {
+    // Who decided is committed with the check: a decision with no one to name is refused, never recorded empty.
+    const by = personOf(cwd);
+    if (by === 'unknown') {
+        console.error(chalk.red('No git email is set in this checkout (git config user.email): who approves or takes back a compiled check is committed with it.'));
+        process.exitCode = 1;
+        return;
+    }
+    const check = decideCompiledCheck(cwd, id, state, by);
+    if (!check) {
+        console.error(chalk.red(`No compiled check ${id}.`));
+        process.exitCode = 1;
+        return;
+    }
+    console.log(state === 'active' ? chalk.green(`✔ Runs from now on (a note unless gates.compiled_lessons.block): ${check.message}`) : chalk.yellow(`✔ Taken back: ${check.message}`));
+}
 /** A person's decision, kept as evidence with who made it (their git email) and why. */
 function decide(cwd, id, decision, why) {
     const lesson = decideLesson(cwd, id, decision, personOf(cwd), why);

package/dist/commands/review.js

@@ -16,7 +16,7 @@ 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, resolveSwitch, reviewChange, toReviewFinding, GitDiffError, mergeBaseOf, receiptReport, recordPrCatches, reviewerBlocks } from '@rigour-labs/core';
+import { learningUsage, 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';
@@ -68,7 +68,7 @@ export async function reviewCommand(cwd, options = {}) {
         if (!isDeep && !receipt && !options.ci && !options.json && !options.githubSummary) {
             hintReviewTask(cwd, diff ?? diffFromGit(cwd, source), config.gates.deep?.router);
         }
-        await reportUsage(result, isDeep, options, Date.now() - started);
+        await reportUsage(result, isDeep, options, Date.now() - started, cwd, config);
         process.exit(reviewer && reviewerBlocks(reviewer) ? Math.max(exitCodeFor(result), EXIT_FAIL) : exitCodeFor(result));
     }
     catch (error) {
@@ -250,7 +250,7 @@ function hintReviewTask(cwd, diff, router) {
     }
 }
 /** Anonymous usage (opt-in; TELEMETRY.md): counts and gate names only, never files or messages. */
-async function reportUsage(result, isDeep, options, ms) {
+async function reportUsage(result, isDeep, options, ms, cwd, config) {
     const byGate = (findings) => findings.reduce((acc, f) => ({ ...acc, [f.id]: (acc[f.id] ?? 0) + 1 }), {});
     const deep = result.report?.stats.deep;
     await trackUsage('review_completed', {
@@ -267,7 +267,8 @@ async function reportUsage(result, isDeep, options, ms) {
         deep_cost_bucket: costBucket(deep?.cost_usd),
         duration: durationBucket(ms),
     }, { version: process.env.RIGOUR_CLI_VERSION });
-    await flushDailyUsage();
+    // Once a day, what this repository's learning loop did goes with the day's counts (TELEMETRY.md).
+    await flushDailyUsage({ daily: () => learningUsage(cwd, config) });
 }
 /** A deep run that did not happen overrides the changed-line verdict. */
 function exitCodeFor(result) {

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

@@ -7,7 +7,7 @@
  * 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 { type OutcomeMetrics, type AgentEvent, type LessonRecord, type ReviewLesson, type Story } from '@rigour-labs/core';
+import { type CompiledCheck, type OutcomeMetrics, type AgentEvent, type LessonRecord, type ReviewLesson, type Story } from '@rigour-labs/core';
 export interface LessonJourney {
     id: string;
     text: string;
@@ -49,6 +49,10 @@ export interface StudioLearning {
     prRecorded: boolean;
     /** What happened after merges this checkout read (core outcomes/metrics.ts); absent before `rigour outcomes` has run. */
     outcomes?: OutcomeMetrics;
+    /** Lessons compiled into checks (core review-learning/compiled-lessons.ts), for a person to approve or take back; `suspended` says why one approved no longer runs. */
+    compiled?: Array<CompiledCheck & {
+        suspended?: string;
+    }>;
 }
 export declare function buildLearning(input: {
     now: Date;
@@ -63,6 +67,15 @@ export declare function decideReviewLesson(cwd: string, body: unknown): {
     id: string;
     state: string;
 };
+/**
+ * A person's decision on a compiled check from Studio, as `rigour learn-reviews --approve-check / --withdraw-check`
+ * records it: with their git email, committed with the check. With no git email set, it is refused.
+ */
+export declare function decideCompiledCheckFromStudio(cwd: string, body: unknown): CompiledCheck;
+/** Proposes checks for the verified lessons a template fits, each backtested on the main branch's history. */
+export declare function proposeChecksFromStudio(cwd: string): {
+    proposed: number;
+};
 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,7 @@
  * 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 { decideLesson, fixLessonPrefix, localOutcomeMetrics, pendingDecision, listKnowledgeLessons, readLessons } from '@rigour-labs/core';
+import { decideCompiledCheck, decideLesson, fixLessonPrefix, proposeCompiledChecks, readCompiledChecks, suspension, localOutcomeMetrics, pendingDecision, 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;
@@ -99,11 +99,35 @@ export function decideReviewLesson(cwd, body) {
         throw new Error(`no review lesson ${id}`);
     return { id: lesson.id, state: lesson.state };
 }
+/**
+ * A person's decision on a compiled check from Studio, as `rigour learn-reviews --approve-check / --withdraw-check`
+ * records it: with their git email, committed with the check. With no git email set, it is refused.
+ */
+export function decideCompiledCheckFromStudio(cwd, body) {
+    const { id, state } = (body ?? {});
+    if (typeof id !== 'string' || !/^c-[\w-]+$/.test(id))
+        throw new Error('a compiled check id is required');
+    if (state !== 'active' && state !== 'withdrawn')
+        throw new Error('state is active or withdrawn');
+    const by = personOf(cwd);
+    if (by === 'unknown')
+        throw new Error('no git email is set in this checkout (git config user.email): who decides a compiled check is committed with it');
+    const check = decideCompiledCheck(cwd, id, state, by);
+    if (!check)
+        throw new Error(`no compiled check ${id}`);
+    return check;
+}
+/** Proposes checks for the verified lessons a template fits, each backtested on the main branch's history. */
+export function proposeChecksFromStudio(cwd) {
+    return { proposed: proposeCompiledChecks(cwd).length };
+}
 export async function loadLearning(cwd, now = new Date(), weeks = WEEKS) {
     const roots = checkoutRoots(cwd);
     const learning = buildLearning({ now, lessons: await listKnowledgeLessons(cwd), reviewLessons: readLessons(cwd), stories: storiesAcross(roots), events: eventsAcross(roots), weeks });
     const outcomes = localOutcomeMetrics(cwd);
-    return outcomes ? { ...learning, outcomes } : learning;
+    const lessons = new Map(readLessons(cwd).map(l => [l.id, l]));
+    const withChecks = { ...learning, compiled: readCompiledChecks(cwd).map(c => ({ ...c, ...(suspension(c, lessons) ? { suspended: suspension(c, lessons) } : {}) })) };
+    return outcomes ? { ...withChecks, outcomes } : withChecks;
 }
 /**
  * "Fixed before: Credential header follows redirects (semantic-bugs). The header…" → the defect,

package/dist/commands/studio.js

@@ -323,6 +323,17 @@ async function handleApiRequest(req, res, url, ctx) {
         }
         return true;
     }
+    if (url.pathname === '/api/compiled-checks' && req.method === 'POST') {
+        try {
+            const { decideCompiledCheckFromStudio, proposeChecksFromStudio } = await import('./studio-learning.js');
+            const body = JSON.parse((await readBody(req)) || '{}');
+            sendJson(res, 200, body?.propose === true ? proposeChecksFromStudio(cwd) : decideCompiledCheckFromStudio(cwd, body));
+        }
+        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.10.1",
+  "version": "6.11.0-rc.1",
   "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.10.1"
+    "@rigour-labs/core": "6.11.0-rc.1"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",
     "@types/inquirer": "9.0.7",
     "@types/node": "^25.0.3",
-    "@rigour-labs/studio": "6.10.1"
+    "@rigour-labs/studio": "6.11.0-rc.1"
   },
   "scripts": {
     "build": "tsc && pnpm bundle-studio",