@rigour-labs/cli 6.13.0 → 6.14.0-rc.1

package/dist/cli.js

@@ -17,7 +17,7 @@ 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 { hooksPushCommand, pushHookOutput } from './commands/hooks-push.js';
 import { hooksReviewBackgroundCommand } from './commands/hooks-review-background.js';
 import { gitPushGateCommand, selfTestCommand, selfTestGitPushHook } from './commands/hooks-git.js';
 import { profileAddCommand, profileListCommand, profileWhichCommand } from './commands/profile.js';
@@ -617,8 +617,11 @@ hooksCmd
     .action(async (options) => {
     const stdin = await hookStdin();
     const result = options.git ? await gitPushGateCommand(stdin, process.cwd()) : await hooksPushCommand(stdin, process.cwd());
-    if (result.message)
-        process.stderr.write(result.message + '\n');
+    const out = pushHookOutput(result, !!options.git);
+    if (out.stdout)
+        process.stdout.write(out.stdout + '\n');
+    if (out.stderr)
+        process.stderr.write(out.stderr + '\n');
     process.exit(result.exitCode);
 });
 hooksCmd

package/dist/commands/brief.d.ts

@@ -1,5 +1,5 @@
 /** `rigour brief [goal]`: the briefing for the task in this checkout, as text or JSON. The goal, else the pull request's title and description, else the branch. */
-export declare function briefCommand(cwd: string, goal: string | undefined, options: {
+export declare function briefCommand(start: string, goal: string | undefined, options: {
     files?: string;
     json?: boolean;
 }): Promise<number>;

package/dist/commands/brief.js

@@ -9,6 +9,10 @@ import path from 'path';
 import chalk from 'chalk';
 import { briefFile, briefingText, briefTask, fileBriefingText, threadsDir } from '@rigour-labs/core';
 import { loadHookConfig } from './hooks-stop.js';
+/** The repository's top, where its rigour.yml, rules and briefing state live; the directory itself outside a repository. */
+function repositoryRoot(dir) {
+    return gitOut(dir, ['rev-parse', '--show-toplevel']) || dir;
+}
 /** Whether briefings are switched off here: the team's rigour.yml or the person's environment. */
 async function briefingOff(cwd) {
     if (/^(0|false|off|no)$/i.test(process.env.RIGOUR_BRIEF?.trim() ?? ''))
@@ -23,7 +27,8 @@ async function briefingOff(cwd) {
     }
 }
 /** `rigour brief [goal]`: the briefing for the task in this checkout, as text or JSON. The goal, else the pull request's title and description, else the branch. */
-export async function briefCommand(cwd, goal, options) {
+export async function briefCommand(start, goal, options) {
+    const cwd = repositoryRoot(start);
     const { off, max, lessons } = await briefingOff(cwd);
     if (off) {
         if (options.json)
@@ -52,7 +57,7 @@ export async function hooksBriefCommand(stdin, fallbackCwd) {
     catch {
         return '';
     }
-    const cwd = payload.cwd || fallbackCwd;
+    const cwd = repositoryRoot(payload.cwd || fallbackCwd);
     const session = payload.session_id;
     const { off, max, lessons } = await briefingOff(cwd);
     if (off || !session || briefedAlready(cwd, session))

package/dist/commands/check.js

@@ -312,7 +312,9 @@ function renderDeepOutput(report, config, options, resolvedDeepMode) {
         console.log(chalk.yellow(`  ☁️  Cloud provider execution. Code context may be sent to ${provider} API.`));
     }
     // Deep stats
-    if (stats.deep) {
+    if (stats.deep?.skipped)
+        console.log(chalk.yellow(`  Deep review skipped: ${stats.deep.skipped}`));
+    else if (stats.deep) {
         const tier = stats.deep.tier === 'cloud' ? provider : stats.deep.tier;
         const model = stats.deep.model || 'unknown';
         const inferenceSec = stats.deep.total_ms ? (stats.deep.total_ms / 1000).toFixed(1) + 's' : '';

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

@@ -1 +1,2 @@
-export declare function personOf(cwd: string): string;
+/** Who a person's decision is recorded as: their git email in the checkout, the one the team sync matches. Throws without one. */
+export declare function decider(cwd: string): string;

package/dist/commands/git-identity.js

@@ -1,10 +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
-    }
+import { personOf } from '@rigour-labs/core';
+/** Every decision path refuses with this: a decision recorded as nobody would never reach the team. */
+const NO_GIT_EMAIL = 'no git email is set in this checkout (git config user.email)';
+/** Who a person's decision is recorded as: their git email in the checkout, the one the team sync matches. Throws without one. */
+export function decider(cwd) {
+    const by = personOf(cwd);
+    if (by === 'unknown')
+        throw new Error(NO_GIT_EMAIL);
+    return by;
 }

package/dist/commands/hooks-push.d.ts

@@ -5,6 +5,18 @@ export interface PushGateResult {
     message: string;
 }
 export declare function hooksPushCommand(stdin: string, fallbackCwd: string): Promise<PushGateResult>;
+/**
+ * Where a push gate's message goes. Claude Code feeds a block's stderr (exit 2) back to the agent but shows no one the stderr
+ * of a hook that exits 0, so a note on a push that goes ahead (a review starting, or skipped by a cap) is PreToolUse context
+ * on stdout. git's pre-push hook speaks to the person at the terminal: stderr.
+ */
+export declare function pushHookOutput(result: {
+    exitCode: number;
+    message: string;
+}, git: boolean): {
+    stdout?: string;
+    stderr?: string;
+};
 /** The gate itself, on the repository's branch against main: shared by the agent hook and git's pre-push (hooks-git.ts). */
 export declare function pushGate(dir: string): Promise<PushGateResult>;
 /**

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, hookGoalDescription, itemLine, recordGoal, mergeBaseOf, resolveReviewer, reviewChange, reviewerInputs, reviewerBlocks, runReviewer, runToolchain, startBackgroundReview, } from '@rigour-labs/core';
+import { appendTaskEvent, branchBase, branchFailures, captureHumanEdits, diffFromGit, hookGoalDescription, itemLine, recordGoal, mergeBaseOf, resolveReviewer, reviewChange, reviewerCapReached, 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);
@@ -28,6 +28,18 @@ export async function hooksPushCommand(stdin, fallbackCwd) {
         return { exitCode: 0, message: '' };
     return pushGate(repo);
 }
+/**
+ * Where a push gate's message goes. Claude Code feeds a block's stderr (exit 2) back to the agent but shows no one the stderr
+ * of a hook that exits 0, so a note on a push that goes ahead (a review starting, or skipped by a cap) is PreToolUse context
+ * on stdout. git's pre-push hook speaks to the person at the terminal: stderr.
+ */
+export function pushHookOutput(result, git) {
+    if (!result.message)
+        return {};
+    if (git || result.exitCode !== 0)
+        return { stderr: result.message };
+    return { stdout: JSON.stringify({ hookSpecificOutput: { hookEventName: 'PreToolUse', additionalContext: result.message } }) };
+}
 /** The gate itself, on the repository's branch against main: shared by the agent hook and git's pre-push (hooks-git.ts). */
 export async function pushGate(dir) {
     const repo = repositoryOf(dir);
@@ -97,6 +109,10 @@ async function backgroundReviewNote(repo, mainRef, config) {
     if (!head || !branch || branch === 'HEAD')
         return '';
     const base = mainRef.replace(/^refs\/(remotes\/|heads\/)/, '');
+    // A reached cap is said, never hidden behind "it runs in the background": that run would only skip.
+    const capped = await reviewerCapReached(repo, config).catch(() => undefined);
+    if (capped)
+        return `Rigour: the model review of ${head.slice(0, 9)} was skipped: ${capped}.`;
     const log = await startBackgroundReview(repo, { head, branch, base }, [process.execPath, process.argv[1], 'hooks', 'review-background', '--commit', head, '--branch', branch, '--base', base]);
     return log ? `Rigour: the model review of ${head.slice(0, 9)} runs in the background (rigour review --status; log: ${log}). Run \`rigour review --reviewer --full\` before asking for a human review.` : '';
 }

package/dist/commands/hooks-stop.js

@@ -44,7 +44,7 @@ export async function hooksStopCommand(tool, stdin, fallbackCwd) {
     try {
         const decision = await stopReview(cwd, config ?? await loadHookConfig(cwd), attempt, sessionBaseline(cwd, session));
         const nothing = decision.reviewedFiles.length === 0;
-        appendAgentEvent(cwd, { type: 'stop_review', tool, session, blocked: decision.block, blocking: decision.blocking, against: decision.against, ...(nothing ? { nothing_to_review: true } : {}) });
+        appendAgentEvent(cwd, { type: 'stop_review', tool, session, blocked: decision.block, blocking: decision.blocking, against: decision.against, ...(decision.held.length ? { findings: decision.held.slice(0, 20) } : {}), ...(nothing ? { nothing_to_review: true } : {}) });
         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`);

package/dist/commands/hooks.js

@@ -20,6 +20,7 @@ import { installGitPushHook } from './hooks-git.js';
 import { isRigourScript, mergeHooksInto, recordCreated } from './install-record.js';
 import { agentHome, asUserLevel, installedAgents } from './personal.js';
 import { hookStdin } from './hook-input.js';
+import { loadHookConfig } from './hooks-stop.js';
 function getHookCliVersion() {
     const thisDir = path.dirname(fileURLToPath(import.meta.url));
     const packagePath = path.resolve(thisDir, '../../package.json');
@@ -612,6 +613,16 @@ function claudeToolDecision(detections) {
     const seen = detections.filter(d => d.decision !== 'allow');
     return seen.length ? { warning: `Rigour: possible credential${seen.length === 1 ? '' : 's'} in this tool call, not blocked:\n${seen.map(line).join('\n')}` } : {};
 }
+/** Every string a tool call carries (a Write's content, an Edit's new_string, a command), decoded, one per line. */
+function toolInputText(input) {
+    if (typeof input === 'string')
+        return input;
+    if (Array.isArray(input))
+        return input.map(toolInputText).filter(Boolean).join('\n');
+    if (input && typeof input === 'object')
+        return Object.values(input).map(toolInputText).filter(Boolean).join('\n');
+    return '';
+}
 /** Cursor's own hook event names. Claude Code sends hook_event_name too (PreToolUse, PostToolUse, Stop, ...). */
 const CURSOR_EVENTS = new Set([
     'beforeSubmitPrompt', 'beforeShellExecution', 'beforeMCPExecution', 'beforeReadFile', 'beforeTabFileRead',
@@ -668,6 +679,10 @@ export async function hooksCheckCommand(cwd, options = {}) {
                 cursorMode = true;
                 textToScan = extractCursorPromptText(payload);
             }
+            else if (payload && typeof payload.tool_input === 'object') {
+                // What the tool will receive, decoded: in the JSON envelope a quote is `\"`, so `password = "…"` never matched.
+                textToScan = toolInputText(payload.tool_input) || rawInput;
+            }
         }
         catch {
             // Not JSON — scan raw text as-is
@@ -676,11 +691,14 @@ export async function hooksCheckCommand(cwd, options = {}) {
             process.stdout.write(JSON.stringify(cursorMode ? { continue: true } : { status: 'clean', detections: [], duration_ms: 0, scanned_length: 0 }));
             return;
         }
+        // The team's switch for secrets in plain assignments (gates.security.secret_assignments), as the review reads it.
+        const secretAssignments = await loadHookConfig(cwd).then(c => c.gates.security?.secret_assignments, () => undefined);
         const result = scanInputForCredentials(textToScan, {
             enabled: true,
             block_on_detection: options.block ?? false,
             cwd,
             use_learned_feedback: true,
+            ...(secretAssignments === false ? { secret_assignments: false } : {}),
         });
         const messages = result.detections
             .map((d) => `[${d.type}] ${d.description} → ${d.recommendation}`)

package/dist/commands/learn-reviews.js

@@ -10,7 +10,7 @@
 import { execFileSync } from 'child_process';
 import chalk from 'chalk';
 import path from 'path';
-import { personOf } from './git-identity.js';
+import { decider } from './git-identity.js';
 import { acceptSuggestedText, scopeLesson, branchBase, decideCompiledCheck, decideLesson, defaultExec, proposeCompiledChecks, readCompiledChecks, suspension, githubReader, learnFromReviews, lessonsPath, pendingDecision, quietBotCandidate, readLessons, ruleWriterFor, ConfigSchema } from '@rigour-labs/core';
 import { loadConfig } from './review-config.js';
 export async function learnReviewsCommand(cwd, options) {
@@ -84,7 +84,7 @@ function printLesson(l) {
     const label = { verified: chalk.green('lesson   '), candidate: chalk.yellow('candidate'), rejected: chalk.red('rejected ') };
     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 || '(team standard)'}: ${l.text}${by} ${chalk.dim(`(${prs})`)}`);
+    console.log(`${label[l.state]} ${chalk.dim(l.id)} ${l.file || '(no file)'}: ${l.text}${by} ${chalk.dim(`(${prs})`)}`);
     const pending = pendingDecision(l);
     if (pending)
         console.log(chalk.yellow(`          ${pendingReason(pending)}`));
@@ -134,14 +134,22 @@ function decideCheck(cwd, id, state) {
         process.exitCode = 1;
     }
 }
+/** Who decides, or undefined after saying why not (exit code 1): a decision always carries who made it. */
+function deciderOrExit(cwd) {
+    try {
+        return decider(cwd);
+    }
+    catch (e) {
+        console.error(chalk.red(e.message));
+        process.exitCode = 1;
+        return undefined;
+    }
+}
 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;
+    const by = deciderOrExit(cwd);
+    if (!by)
         return;
-    }
     const check = decideCompiledCheck(cwd, id, state, by);
     if (!check) {
         console.error(chalk.red(`No compiled check ${id}.`));
@@ -157,9 +165,12 @@ function scope(cwd, id, to, why) {
         process.exitCode = 1;
         return;
     }
+    const by = deciderOrExit(cwd);
+    if (!by)
+        return;
     let lesson;
     try {
-        lesson = scopeLesson(cwd, id, to, personOf(cwd), why);
+        lesson = scopeLesson(cwd, id, to, by, why);
     }
     catch (e) {
         console.error(chalk.red(e.message));
@@ -176,7 +187,10 @@ function scope(cwd, id, to, why) {
 }
 /** A person takes the suggested wording of a lesson they decided; the old wording is kept as evidence. */
 function useWording(cwd, id) {
-    const lesson = acceptSuggestedText(cwd, id, personOf(cwd));
+    const by = deciderOrExit(cwd);
+    if (!by)
+        return;
+    const lesson = acceptSuggestedText(cwd, id, by);
     if (!lesson) {
         console.error(chalk.red(`No lesson ${id} with a suggested wording.`));
         process.exitCode = 1;
@@ -186,7 +200,10 @@ function useWording(cwd, id) {
 }
 /** 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);
+    const by = deciderOrExit(cwd);
+    if (!by)
+        return;
+    const lesson = decideLesson(cwd, id, decision, by, why);
     if (!lesson) {
         console.error(chalk.red(`No lesson ${id}.`));
         process.exitCode = 1;

package/dist/commands/review-human.js

@@ -92,6 +92,8 @@ function printQuietLines(result, notes) {
     const outside = result.excludedOutsideChangedLines;
     if (outside)
         groups.push({ line: `Not shown: ${outside} issue${outside === 1 ? '' : 's'} on lines this change did not touch${leftOutByCheck(result.outsideChangeByCheck)}.` });
+    if (result.report?.stats?.deep?.skipped)
+        groups.push({ line: `Deep review skipped: ${result.report.stats.deep.skipped}.` });
     if (result.baseUnknown)
         groups.push({ line: 'Compared with no base: HEAD already holds this diff, so findings on its lines were not checked against the code before it. Pass --base to compare.' });
     if (result.dismissed)

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

@@ -5,6 +5,8 @@ export interface ActivityItem {
     kind: ActivityKind;
     text: string;
     detail?: string;
+    /** The problems a stopped item is about (check and file, as the open-findings ledger keys them): one problem stopped at an edit and again at the stop counts once. */
+    problems?: string[];
 }
 export declare function buildActivity(input: {
     events: AgentEvent[];

package/dist/commands/studio-activity.js

@@ -7,6 +7,8 @@ import path from 'path';
 import { readLedger } from '@rigour-labs/core';
 import { checkoutRoots, eventsAcross, storiesAcross } from './studio-checkouts.js';
 const LIMIT = 200;
+/** A problem as the open-findings ledger keys it: its check and its file. */
+const problemKey = (check, file) => `${check ?? '?'}:${file ?? '?'}`;
 export function buildActivity(input) {
     const items = [
         ...input.events.flatMap(e => fromEvent(e)),
@@ -44,11 +46,18 @@ export function groupSessions(items) {
     }
     return sessions.map(list => {
         const counts = { stopped: 0, reported: 0, fixed: 0, checked: 0, reviewed: 0, taught: 0, pr: 0, reviewedFixed: 0 };
+        const stopped = new Set();
         for (const item of list) {
+            if (item.kind === 'stopped') {
+                for (const [i, problem] of (item.problems ?? [`${item.at}#0`]).entries())
+                    stopped.add(problem || `${item.at}#${i}`);
+                continue;
+            }
             counts[item.kind]++;
             if (item.kind === 'reviewed' && item.text.startsWith('Fixed '))
                 counts.reviewedFixed++;
         }
+        counts.stopped = stopped.size;
         const highlight = (i) => IMPORTANT.includes(i.kind) || (i.kind === 'reviewed' && i.text.startsWith('Fixed '));
         return { start: list[list.length - 1].at, end: list[0].at, counts, highlights: list.filter(highlight), rest: list.filter(i => !highlight(i)) };
     });
@@ -65,15 +74,30 @@ function fromEvent(event) {
             const found = findings.map(f => f.message).filter(Boolean).join('; ');
             // Stopped only when the hook ran with --block and said so; an event without the flag never claims a block.
             return [event.blocked
-                    ? { at, kind: 'stopped', text: `Stopped an edit to ${files}: ${found}` }
+                    ? { at, kind: 'stopped', text: `Stopped an edit to ${files}: ${found}`, problems: findings.map(f => problemKey(f.gate, f.file)) }
                     : { at, kind: 'reported', text: `Reported on an edit to ${files}: ${found}` }];
         }
-        case 'stop_review':
-            return [event.blocked
-                    ? { at, kind: 'stopped', text: `Kept the agent working: ${count(event.blocking ?? 0, 'problem')} left when it tried to finish` }
-                    : { at, kind: 'checked', text: 'The agent finished with nothing blocking' }];
-        case 'lessons_served':
-            return [{ at, kind: 'taught', text: `Told the agent ${count(event.lessons?.length ?? 0, 'lesson')} before it wrote`, detail: event.lessons?.join(' · ') }];
+        case 'stop_review': {
+            if (!event.blocked)
+                return [{ at, kind: 'checked', text: 'The agent finished with nothing blocking' }];
+            // What held it, as the edit line names what it stopped; an older record has only the count.
+            const held = event.findings ?? [];
+            const named = (f) => `${f.file ? `${f.file}: ` : ''}${f.title}${f.detail ? ` (${f.detail})` : ''}`;
+            if (held.length === 1 && (event.blocking ?? 1) === 1)
+                return [{ at, kind: 'stopped', text: `Kept the agent working: ${named(held[0])}`, problems: [problemKey(held[0].rule, held[0].file)] }]; // written at the block: the "Fixed" story says when it was fixed
+            // An older record names no problems: each counts as its own.
+            const problems = held.length ? held.map(f => problemKey(f.rule, f.file)) : Array.from({ length: event.blocking ?? 1 }, (_, i) => `${at}#${i}`);
+            return [{ at, kind: 'stopped', text: `Kept the agent working: ${count(event.blocking ?? held.length, 'problem')} left when it tried to finish`, problems, ...(held.length ? { detail: held.map(named).join(' · ') } : {}) }];
+        }
+        case 'lessons_served': {
+            const items = event.lessons?.length ?? 0;
+            if (event.via !== 'brief')
+                return [{ at, kind: 'taught', text: `Told the agent ${count(items, 'lesson')} before it wrote`, detail: event.lessons?.join(' · ') }];
+            // A briefing: the repository's rules and the team's lessons, for the files the task touches.
+            const rules = event.rules ?? 0;
+            const told = [rules ? count(rules, 'rule') : '', items - rules ? count(items - rules, 'lesson') : ''].filter(Boolean).join(' and ');
+            return [{ at, kind: 'taught', text: `Briefed the agent before it wrote: ${told}${event.files?.length ? ` for ${event.files.join(', ')}` : ''}`, detail: event.lessons?.join(' · ') }];
+        }
         case 'pr_catches':
             return [{ at, kind: 'pr', text: `A branch review found ${count(event.findings?.length ?? 0, 'problem')}`, detail: event.findings?.map(f => `${f.title} (${f.file})`).join(' · ') }];
         default:

package/dist/commands/studio-context.js

@@ -9,6 +9,10 @@ import { checkoutRoots, eventsAcross } from './studio-checkouts.js';
 const WEEK_MS = 7 * 24 * 60 * 60 * 1000;
 const WEEKS = 8;
 const SCOPE_TOOL = 'rigour_context_scope';
+/** The lessons these events gave agents: a briefing's items count only when they are lessons, not the repository's rules. */
+function lessonsIn(served) {
+    return served.reduce((n, e) => n + (e.lessons?.length ?? 0) - (e.rules ?? 0), 0);
+}
 export function buildAgentContext(input) {
     const at = (e) => e.createdAt ?? 0;
     const since = input.now.getTime() - WEEK_MS;
@@ -26,7 +30,7 @@ export function buildAgentContext(input) {
             tokensConsidered: sum(scopes, e => e.candidateTokens),
             tokensReturned: sum(scopes, e => e.returnedTokens),
             recalls: recentContext.filter(e => e.toolName === 'rigour_recall').length,
-            lessonsTold: served.filter(inWeek).reduce((n, e) => n + (e.lessons?.length ?? 0), 0),
+            lessonsTold: lessonsIn(served.filter(inWeek)),
             reuse: reuse.filter(inWeek).reverse().map(e => ({ at: e.timestamp ?? '', planned: e.planned ?? '', existing: e.existing ?? '', action: e.action ?? '' })),
         },
         weeks: Array.from({ length: WEEKS }, (_, i) => {
@@ -40,7 +44,7 @@ export function buildAgentContext(input) {
                 filesReturned: sum(weekScopes, e => e.returnedFiles),
                 filesConsidered: sum(weekScopes, e => e.candidateFiles),
                 recalls: input.context.filter(e => e.toolName === 'rigour_recall' && within(at(e))).length,
-                lessonsTold: served.filter(e => within(Date.parse(e.timestamp ?? ''))).reduce((n, e) => n + (e.lessons?.length ?? 0), 0),
+                lessonsTold: lessonsIn(served.filter(e => within(Date.parse(e.timestamp ?? '')))),
                 reuse: reuse.filter(e => within(Date.parse(e.timestamp ?? ''))).length,
             };
         }),

package/dist/commands/studio-learning.js

@@ -8,7 +8,7 @@
  * recorded on another machine (CI) never reach this one.
  */
 import { acceptSuggestedText, scopeLesson, decideCompiledCheck, decideLesson, fixLessonPrefix, proposeCompiledChecks, readCompiledChecks, suspension, localOutcomeMetrics, pendingDecision, quietBotCandidate, listKnowledgeLessons, readLessons } from '@rigour-labs/core';
-import { personOf } from './git-identity.js';
+import { decider } from './git-identity.js';
 import { checkoutRoots, eventsAcross, storiesAcross } from './studio-checkouts.js';
 const WEEK_MS = 7 * 24 * 60 * 60 * 1000;
 const WEEKS = 4;
@@ -105,7 +105,7 @@ export function decideReviewLesson(cwd, body) {
         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');
-    const lesson = decideLesson(cwd, id, decision, personOf(cwd), studioWhy(why));
+    const lesson = decideLesson(cwd, id, decision, decider(cwd), studioWhy(why));
     if (!lesson)
         throw new Error(`no review lesson ${id}`);
     return { id: lesson.id, state: lesson.state };
@@ -117,17 +117,14 @@ export function decideReviewLesson(cwd, body) {
 function scopeFromStudio(cwd, id, to, why) {
     if (to !== 'file' && to !== 'folder' && to !== 'repo')
         throw new Error('to is file, folder or repo');
-    const by = personOf(cwd);
-    if (by === 'unknown')
-        throw new Error('no git email is set in this checkout (git config user.email): who decides how far a lesson reaches is recorded with it');
-    const lesson = scopeLesson(cwd, id, to, by, studioWhy(why));
+    const lesson = scopeLesson(cwd, id, to, decider(cwd), studioWhy(why));
     if (!lesson)
         throw new Error(`no review lesson ${id}`);
     return { id: lesson.id, state: lesson.state };
 }
 /** A person takes a decided lesson's suggested wording from Studio, recorded as `--use-wording` records it. */
 function rewordFromStudio(cwd, id) {
-    const lesson = acceptSuggestedText(cwd, id, personOf(cwd));
+    const lesson = acceptSuggestedText(cwd, id, decider(cwd));
     if (!lesson)
         throw new Error(`no review lesson ${id} with a suggested wording`);
     return { id: lesson.id, state: lesson.state };
@@ -142,9 +139,7 @@ export function decideCompiledCheckFromStudio(cwd, body) {
         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 by = decider(cwd);
     const check = decideCompiledCheck(cwd, id, state, by);
     if (!check)
         throw new Error(`no compiled check ${id}`);

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

@@ -30,8 +30,13 @@ export interface StudioWeek {
         stage?: CatchStage;
     }>;
     stories: Story[];
+    /**
+     * Problems Rigour held an agent on this week during development, each counted once, at the stage that caught it first
+     * (an edit, then the stop on the same problem, is one problem caught at the edit); `fixed` of them were fixed since.
+     */
     stopped: {
         total: number;
+        fixed: number;
         byStage: Record<CatchStage, number>;
     };
     /** Times an agent tried to finish with a problem Rigour proved, and then fixed it. */

package/dist/commands/studio-week.js

@@ -13,9 +13,13 @@ export function buildWeek(input) {
     const from = new Date(input.now.getTime() - WEEK_MS);
     const inWeek = (at) => Date.parse(at) >= from.getTime() && Date.parse(at) <= input.now.getTime();
     const stories = input.stories.filter(s => DEVELOPMENT.includes(s.stage) && inWeek(s.at));
+    // Still open: caught this week and not fixed yet. A fixed one is a story; the ledger keys both by check and file.
+    const caught = input.open.filter(o => inWeek(o.openedAt) && DEVELOPMENT.includes(o.stage ?? 'edit'));
     const byStage = { edit: 0, review: 0, stop: 0, pr: 0 };
     for (const story of stories)
         byStage[story.stage]++;
+    for (const open of caught)
+        byStage[open.stage ?? 'edit']++;
     const overruled = input.dismissals.filter(d => inWeek(d.at)).length;
     const openedThisWeek = input.open.filter(o => inWeek(o.openedAt)).length;
     const prEvents = input.events.filter(e => e.type === 'pr_catches');
@@ -25,7 +29,7 @@ export function buildWeek(input) {
         to: input.now.toISOString(),
         needs: input.open.map(o => ({ ...o, title: o.title ?? o.rule })),
         stories: [...stories].reverse().slice(0, MAX_STORIES),
-        stopped: { total: stories.length, byStage },
+        stopped: { total: stories.length + caught.length, fixed: stories.length, byStage },
         agentSaidDone: byStage.stop,
         prCatches: prEvents.length === 0 ? null : prEvents.filter(e => e.timestamp && inWeek(e.timestamp)).reduce((n, e) => n + (e.findings?.length ?? 0), 0),
         raised: stories.length + overruled + openedThisWeek,

package/dist/commands/studio.js

@@ -507,7 +507,7 @@ export const studioCommand = new Command('studio')
     const syncTimer = setInterval(() => {
         void loadTeamConfiguration().then((config) => {
             if (config)
-                return syncTeamOutbox().catch(() => undefined);
+                return syncTeamOutbox({ cwd }).catch(() => undefined);
             return undefined;
         });
     }, 30_000);

package/dist/commands/team.js

@@ -95,10 +95,10 @@ teamCommand
 });
 teamCommand
     .command('sync')
-    .description("Send queued lessons from the team's repositories, and receive the team's")
+    .description("Send queued lessons from the team's repositories, and your decisions on this repository's review lessons; receive the team's")
     .option('--dry-run', 'Report pending records without sending them')
     .action(async (options) => {
-    const result = await syncTeamOutbox({ dryRun: Boolean(options.dryRun) });
+    const result = await syncTeamOutbox({ dryRun: Boolean(options.dryRun), cwd: process.cwd() });
     console.log(JSON.stringify(result, null, 2));
 });
 /** Initialize the schema, or print why it failed (with the fix) and set exit code 1. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rigour-labs/cli",
-  "version": "6.13.0",
+  "version": "6.14.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.13.0"
+    "@rigour-labs/core": "6.14.0-rc.1"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",
     "@types/inquirer": "9.0.7",
     "@types/node": "^25.0.3",
-    "@rigour-labs/studio": "6.13.0"
+    "@rigour-labs/studio": "6.14.0-rc.1"
   },
   "scripts": {
     "build": "tsc && pnpm bundle-studio",