@rigour-labs/cli 7.0.0-rc.5 → 7.0.0-rc.7

package/dist/cli.js

@@ -406,7 +406,9 @@ program
     .option('--include-bots', 'With --list: also list candidates only review bots raised (hidden by default)')
     .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('--not-a-rule <id>', 'Drop a candidate that is a one-off for its pull request, not a practice either way: never served, the judges are told nothing')
+    .option('--take-back <id>', 'Take back the last decision on a lesson (promote, reject or not a rule): a candidate again; the decision stays in its history')
+    .option('--why <text>', 'Why, recorded with --promote, --reject, --not-a-rule or --take-back')
     .option('--scope <id>', 'Set how far a lesson reaches, with --to: its file, its folder, or every change (a team standard); recorded as your decision')
     .option('--to <reach>', 'With --scope: file, folder or repo')
     .option('--use-wording <id>', 'Take the corrected wording a newer version suggests for a lesson you decided (the old wording is kept as evidence)')

package/dist/commands/hooks-git.js

@@ -13,6 +13,7 @@ import { execFileSync, spawnSync } from 'child_process';
 import fs from 'fs';
 import os from 'os';
 import path from 'path';
+import { pinnedHomeEnv } from '@rigour-labs/core/profile';
 import { pushGate } from './hooks-push.js';
 const MARK = 'rigour hooks push --git';
 /**
@@ -101,18 +102,19 @@ export async function selfTestGitPushHook(rigourCommand) {
         git(clone, ['commit', '-qm', 'base']);
         git(clone, ['push', '-q', '-u', 'origin', 'HEAD:main']);
         git(clone, ['checkout', '-qb', 'feature']);
+        // The clone is in the temp folder, where another profile may match: the pushes keep this repository's home.
         const installed = installGitPushHook(clone, rigourCommand);
         steps.push(`hook ${installed.action} at ${installed.path}`);
         fs.writeFileSync(path.join(clone, 'src/util.ts'), 'export const used = 1;\nexport const forgotten = 2;\n');
         git(clone, ['commit', '-qam', 'adds an export nothing uses']);
-        const refused = spawnSync('git', ['push', 'origin', 'feature'], { cwd: clone, encoding: 'utf8', env: { ...process.env, RIGOUR_TELEMETRY: '0' } });
+        const refused = spawnSync('git', ['push', 'origin', 'feature'], { cwd: clone, encoding: 'utf8', env: { ...pinnedHomeEnv(), RIGOUR_TELEMETRY: '0' } });
         const refusedRef = gitOutput(remote, ['rev-parse', '--verify', '-q', 'refs/heads/feature']);
         if (refused.status === 0 || refusedRef)
             return { ok: false, steps: [...steps, `FAIL: a push with an unused export went through (git exit ${refused.status}; remote has feature: ${!!refusedRef})\n${(refused.stderr || '').trim().slice(-600)}`] };
         steps.push(`a push with an unused export was refused (git exit ${refused.status}); the remote has no feature branch`);
         fs.writeFileSync(path.join(clone, 'src/util.ts'), 'export const used = 1;\n');
         git(clone, ['commit', '-qam', 'fix']);
-        const accepted = spawnSync('git', ['push', 'origin', 'feature'], { cwd: clone, encoding: 'utf8', env: { ...process.env, RIGOUR_TELEMETRY: '0' } });
+        const accepted = spawnSync('git', ['push', 'origin', 'feature'], { cwd: clone, encoding: 'utf8', env: { ...pinnedHomeEnv(), RIGOUR_TELEMETRY: '0' } });
         const acceptedRef = gitOutput(remote, ['rev-parse', '--verify', '-q', 'refs/heads/feature']);
         if (accepted.status !== 0 || acceptedRef !== gitOutput(clone, ['rev-parse', 'HEAD']))
             return { ok: false, steps: [...steps, `FAIL: the fixed push did not land (git exit ${accepted.status})\n${(accepted.stderr || '').trim().slice(-600)}`] };

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

@@ -4,6 +4,8 @@ export interface LearnReviewsOptions {
     limit?: string;
     promote?: string;
     reject?: string;
+    notARule?: string;
+    takeBack?: string;
     why?: string;
     list?: boolean;
     /** With --list: also list candidates only review bots raised (hidden by default, and counted). */

package/dist/commands/learn-reviews.js

@@ -18,6 +18,10 @@ export async function learnReviewsCommand(cwd, options) {
         return decide(cwd, options.promote, 'accepted', options.why);
     if (options.reject)
         return decide(cwd, options.reject, 'rejected', options.why);
+    if (options.notARule)
+        return decide(cwd, options.notARule, 'not-a-rule', options.why);
+    if (options.takeBack)
+        return decide(cwd, options.takeBack, 'took-back', options.why);
     if (options.list)
         return list(cwd, options.json, options.includeBots);
     if (options.useWording)
@@ -81,7 +85,7 @@ function list(cwd, json, includeBots) {
         console.log('No review lessons yet. Run `rigour learn-reviews`.');
 }
 function printLesson(l) {
-    const label = { verified: chalk.green('lesson   '), candidate: chalk.yellow('candidate'), rejected: chalk.red('rejected ') };
+    const label = { verified: chalk.green('lesson   '), candidate: chalk.yellow('candidate'), rejected: chalk.red('rejected '), dropped: chalk.dim('not a rule') };
     const prs = [...new Set(l.evidence.map(e => `#${e.pr}`))].join(', ');
     const by = chalk.dim(`${l.promotedBy ? ` [${l.promotedBy}]` : ''}${l.scope ? ` [${l.scope === 'repo' ? 'every change' : 'its folder'}]` : ''}`);
     console.log(`${label[l.state]} ${chalk.dim(l.id)} ${l.file || '(no file)'}: ${l.text}${by} ${chalk.dim(`(${prs})`)}`);
@@ -199,17 +203,32 @@ function useWording(cwd, id) {
     console.log(chalk.green(`✔ Now reads: ${lesson.text}`));
 }
 /** A person's decision, kept as evidence with who made it (their git email) and why. */
+/** What each decision tells the person it did. */
+const DECIDED = {
+    accepted: text => chalk.green(`✔ A lesson now: ${text}`),
+    rejected: text => chalk.yellow(`✔ Rejected: ${text}. The judges are told this team decided against it.`),
+    'not-a-rule': text => chalk.dim(`✔ Not a rule (a one-off for that pull request): ${text}. Never served, and the judges are told nothing.`),
+    'took-back': text => chalk.yellow(`✔ Taken back, a candidate again: ${text}. The earlier decision is kept in its history.`),
+};
 function decide(cwd, id, decision, why) {
     const by = deciderOrExit(cwd);
     if (!by)
         return;
-    const lesson = decideLesson(cwd, id, decision, by, why);
+    let lesson;
+    try {
+        lesson = decideLesson(cwd, id, decision, by, why);
+    }
+    catch (e) {
+        console.error(chalk.red(e.message));
+        process.exitCode = 1;
+        return;
+    }
     if (!lesson) {
         console.error(chalk.red(`No lesson ${id}.`));
         process.exitCode = 1;
         return;
     }
-    console.log(decision === 'accepted' ? chalk.green(`✔ A lesson now: ${lesson.text}`) : chalk.yellow(`✔ Rejected: ${lesson.text}. The judges are told this team decided against it.`));
+    console.log(DECIDED[decision](lesson.text));
 }
 /** The repository's rigour.yml, or the defaults when it cannot be read (no rigour.yml is the defaults already). */
 async function teamConfig(cwd) {

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

@@ -50,6 +50,8 @@ export interface LessonJourney {
     };
     /** A candidate only review bots raised, nothing waiting on a person (core quietBotCandidate): hidden until a person asks to see bot points. */
     fromBots?: true;
+    /** A person's last decision on a review lesson (promoted, rejected, not a rule) can be taken back to a candidate (core takeBackable). */
+    canTakeBack?: true;
     /**
      * Teammates' decisions on a review lesson, received from the team database (core team-decisions.ts): each with the
      * teammate's display name and when the team database got it; and, when a later team decision settled the lesson

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 { acceptSuggestedText, scopeLesson, decideCompiledCheck, decideLesson, fixLessonPrefix, proposeCompiledChecks, readCompiledChecks, suspension, localOutcomeMetrics, pendingDecision, quietBotCandidate, listKnowledgeLessons, readLessons, lastDecision, readTeamDecisionCache } from '@rigour-labs/core';
+import { acceptSuggestedText, scopeLesson, decideCompiledCheck, decideLesson, fixLessonPrefix, proposeCompiledChecks, readCompiledChecks, suspension, localOutcomeMetrics, pendingDecision, quietBotCandidate, listKnowledgeLessons, readLessons, lastDecision, takeBackable, readTeamDecisionCache } from '@rigour-labs/core';
 import { decider } from './git-identity.js';
 import { checkoutRoots, eventsAcross, storiesAcross } from './studio-checkouts.js';
 const WEEK_MS = 7 * 24 * 60 * 60 * 1000;
@@ -53,6 +53,7 @@ export function buildLearning(input) {
             ...(l.suggestedText ? { suggestedText: { text: l.suggestedText, why: l.suggestedWhy ?? 'reworded' } } : {}),
             reach: { scope: l.scope ?? 'file', hasFile: !!l.file },
             ...(quietBotCandidate(l) ? { fromBots: true } : {}),
+            ...(takeBackable(l) ? { canTakeBack: true } : {}),
         })),
         // 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))
@@ -107,6 +108,7 @@ function decisionFor(lesson) {
 function studioWhy(why) {
     return typeof why === 'string' && why.trim() ? why.trim() : 'decided in Studio';
 }
+const REVIEW_DECISIONS = new Set(['accepted', 'rejected', 'dismissed', 'not-a-rule', 'took-back']);
 /** 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 ?? {});
@@ -116,8 +118,8 @@ export function decideReviewLesson(cwd, body) {
         return rewordFromStudio(cwd, id);
     if (decision === 'scope')
         return scopeFromStudio(cwd, id, body.to, why);
-    if (decision !== 'accepted' && decision !== 'rejected' && decision !== 'dismissed')
-        throw new Error('decision is accepted, rejected, dismissed, reworded or scope');
+    if (!REVIEW_DECISIONS.has(decision))
+        throw new Error('decision is accepted, rejected, dismissed, not-a-rule, took-back, reworded or scope');
     const lesson = decideLesson(cwd, id, decision, decider(cwd), studioWhy(why));
     if (!lesson)
         throw new Error(`no review lesson ${id}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rigour-labs/cli",
-  "version": "7.0.0-rc.5",
+  "version": "7.0.0-rc.7",
   "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,12 +59,12 @@
     "globby": "^14.0.1",
     "ora": "^8.0.1",
     "yaml": "^2.8.2",
-    "@rigour-labs/core": "7.0.0-rc.5"
+    "@rigour-labs/core": "7.0.0-rc.7"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",
     "@types/node": "^25.0.3",
-    "@rigour-labs/studio": "7.0.0-rc.5"
+    "@rigour-labs/studio": "7.0.0-rc.7"
   },
   "scripts": {
     "build": "tsc && pnpm bundle-studio",