@rigour-labs/core 6.11.1-rc.1 → 6.11.1-rc.3

package/dist/gates/base.d.ts

@@ -8,6 +8,8 @@ export interface GateContext {
     patterns?: string[];
     /** Shared file cache across gates — reduces memory ~80% on large repos */
     fileCache?: FileSystemCache;
+    /** A gate that could not check (nothing to compare with) says why: the run shows SKIP, never PASS. */
+    skip?: (reason: string) => void;
 }
 export declare abstract class Gate {
     readonly id: string;

package/dist/gates/language-adapters/python-adapter.js

@@ -104,7 +104,8 @@ class PythonAdapter {
             if (match && !line.includes('def') && !line.includes('class')) {
                 const name = match[1];
                 // Distinguish constants from regular variables
-                const kind = /^[A-Z][A-Z0-9_]*$/.test(name) ? 'constant' : 'variable';
+                // A private constant (`_RETRY_DELAYS`) is a constant too: the same reading classifyCasing gives it.
+                const kind = classifyCasing(name) === 'SCREAMING_SNAKE' ? 'constant' : 'variable';
                 patterns.push({
                     name, kind,
                     convention: classifyCasing(name),

package/dist/gates/language-adapters/types.d.ts

@@ -53,8 +53,11 @@ export interface NamingPattern {
     kind: 'function' | 'class' | 'variable' | 'constant' | 'method';
     convention: NamingConvention;
 }
-export type NamingConvention = 'camelCase' | 'PascalCase' | 'snake_case' | 'SCREAMING_SNAKE' | 'kebab-case' | 'other';
+export type NamingConvention = 'camelCase' | 'PascalCase' | 'snake_case' | 'SCREAMING_SNAKE' | 'kebab-case' | 'other'
+/** One lowercase word (`run`, `data`): camelCase and snake_case alike, so evidence of neither. */
+ | 'ambiguous';
 /**
- * Classify a name into its casing convention.
+ * Classify a name into its casing convention. Leading underscores mark privacy, not casing (`_load_rows` is
+ * snake_case, `_Private` PascalCase), and a dunder (`__init__`) is the language's own name, so it is ambiguous.
  */
-export declare function classifyCasing(name: string): NamingConvention;
+export declare function classifyCasing(raw: string): NamingConvention;

package/dist/gates/language-adapters/types.js

@@ -5,13 +5,21 @@
  * Gates use these adapters instead of inline `if ext === '.py'` chains.
  */
 /**
- * Classify a name into its casing convention.
+ * Classify a name into its casing convention. Leading underscores mark privacy, not casing (`_load_rows` is
+ * snake_case, `_Private` PascalCase), and a dunder (`__init__`) is the language's own name, so it is ambiguous.
  */
-export function classifyCasing(name) {
+export function classifyCasing(raw) {
+    if (/^__\w+__$/.test(raw))
+        return 'ambiguous';
+    const name = raw.replace(/^_+/, '');
+    if (!name)
+        return 'other';
     if (/^[A-Z][A-Z0-9_]*$/.test(name))
         return 'SCREAMING_SNAKE';
     if (/^[A-Z][a-zA-Z0-9]*$/.test(name))
         return 'PascalCase';
+    if (/^[a-z][a-z0-9]*$/.test(name))
+        return 'ambiguous';
     if (/^[a-z][a-zA-Z0-9]*$/.test(name))
         return 'camelCase';
     if (/^[a-z][a-z0-9_]*$/.test(name))

package/dist/gates/logic-drift-git-base.d.ts

@@ -1,7 +1,12 @@
 export interface GitLogicBase {
+    /** The commit compared against. */
+    base: string;
+    /** Tracked files that differ from the base (added, copied, modified, renamed). Untracked files are not in it. */
     changedFiles: Set<string>;
     readAtBase: (file: string) => string | null;
 }
+/** Why a check that compares with the main branch could not run in a git checkout (resolveGitLogicBase gave null). */
+export declare const NO_GIT_BASE = "nothing to compare with: no main branch (GITHUB_BASE_REF, origin/main, main, origin/master or master), or run from below the repository root";
 export declare function isGitWorktree(cwd: string): boolean;
 export interface BranchBase {
     /** The main branch as found: GITHUB_BASE_REF, else origin/main, main, origin/master, master. */
@@ -14,3 +19,9 @@ export interface BranchBase {
 export declare function branchBase(cwd: string): BranchBase | null;
 /** Use a fixed commit for the entire scan; never move the baseline on read. */
 export declare function resolveGitLogicBase(cwd: string): GitLogicBase | null;
+/** Files git does not track and does not ignore: what an agent just created. */
+export declare function untrackedFiles(cwd: string): string[];
+/** Every file committed at `commit`, repository-relative with `/`. */
+export declare function filesAtCommit(cwd: string, commit: string): string[];
+/** The contents of `files` at `commit`, read by one git process; a file missing there is left out. */
+export declare function readManyAtCommit(cwd: string, commit: string, files: string[]): Map<string, string>;

package/dist/gates/logic-drift-git-base.js

@@ -1,4 +1,6 @@
 import { execFileSync } from 'node:child_process';
+/** Why a check that compares with the main branch could not run in a git checkout (resolveGitLogicBase gave null). */
+export const NO_GIT_BASE = 'nothing to compare with: no main branch (GITHUB_BASE_REF, origin/main, main, origin/master or master), or run from below the repository root';
 export function isGitWorktree(cwd) {
     return git(cwd, ['rev-parse', '--is-inside-work-tree'])?.trim() === 'true';
 }
@@ -40,7 +42,43 @@ export function resolveGitLogicBase(cwd) {
     if (diff === null)
         return null;
     return {
+        base,
         changedFiles: new Set(diff.split('\0').filter(Boolean)),
         readAtBase: file => git(cwd, ['show', `${base}:${file}`]),
     };
 }
+/** Files git does not track and does not ignore: what an agent just created. */
+export function untrackedFiles(cwd) {
+    return (git(cwd, ['ls-files', '--others', '--exclude-standard', '-z']) ?? '').split('\0').filter(Boolean);
+}
+/** Every file committed at `commit`, repository-relative with `/`. */
+export function filesAtCommit(cwd, commit) {
+    return (git(cwd, ['ls-tree', '-r', '--name-only', '-z', commit]) ?? '').split('\0').filter(Boolean);
+}
+/** The contents of `files` at `commit`, read by one git process; a file missing there is left out. */
+export function readManyAtCommit(cwd, commit, files) {
+    const contents = new Map();
+    if (files.length === 0)
+        return contents;
+    let out;
+    try {
+        out = execFileSync('git', ['cat-file', '--batch'], { cwd, input: files.map(file => `${commit}:${file}`).join('\n') + '\n', stdio: ['pipe', 'pipe', 'ignore'], maxBuffer: 256 * 1024 * 1024 });
+    }
+    catch {
+        return contents;
+    }
+    let at = 0;
+    for (const file of files) {
+        const end = out.indexOf(0x0a, at);
+        if (end < 0)
+            break;
+        const header = out.subarray(at, end).toString('utf8').split(' ');
+        at = end + 1;
+        if (header[1] !== 'blob')
+            continue; // "<name> missing", or not a file
+        const size = Number(header[2]);
+        contents.set(file, out.subarray(at, at + size).toString('utf8'));
+        at += size + 1;
+    }
+    return contents;
+}

package/dist/gates/logic-drift.js

@@ -26,7 +26,7 @@ import { FileScanner } from '../utils/scanner.js';
 import { Logger } from '../utils/logger.js';
 import { languageAdapters } from './language-adapters/index.js';
 import { extractCallSequence, isDangerousMutation } from './logic-drift-extractors.js';
-import { isGitWorktree, resolveGitLogicBase } from './logic-drift-git-base.js';
+import { NO_GIT_BASE, isGitWorktree, resolveGitLogicBase } from './logic-drift-git-base.js';
 import { isScoped } from '../utils/scope.js';
 import fs from 'fs-extra';
 import path from 'path';
@@ -60,7 +60,7 @@ export class LogicDriftGate extends Gate {
         // In Git worktrees, compare only files changed from an immutable base.
         const gitBase = resolveGitLogicBase(context.cwd);
         if (!gitBase && isGitWorktree(context.cwd)) {
-            Logger.info('Logic Drift: no main reference available; comparison unavailable');
+            context.skip?.(NO_GIT_BASE);
             return [];
         }
         const scanFiles = gitBase ? files.filter(file => gitBase.changedFiles.has(file)) : files;

package/dist/gates/runner.js

@@ -145,6 +145,7 @@ export class GateRunner {
         const start = Date.now();
         const failures = [];
         const summary = {};
+        const skips = {};
         const ignore = this.config.ignore;
         // 0. Run Context Discovery
         let record;
@@ -162,11 +163,16 @@ export class GateRunner {
             gateIndex++;
             try {
                 onProgress?.(`  [${gateIndex}/${totalGates}] Running ${gate.id}...`);
-                const gateFailures = await gate.run({ cwd, record, ignore, patterns, fileCache });
+                let skipped;
+                const gateFailures = await gate.run({ cwd, record, ignore, patterns, fileCache, skip: reason => { skipped = reason; } });
                 if (gateFailures.length > 0) {
                     failures.push(...gateFailures);
                     summary[gate.id] = 'FAIL';
                 }
+                else if (skipped !== undefined) {
+                    summary[gate.id] = 'SKIP';
+                    skips[gate.id] = skipped;
+                }
                 else {
                     summary[gate.id] = 'PASS';
                 }
@@ -299,6 +305,7 @@ export class GateRunner {
         const report = {
             status,
             summary,
+            ...(Object.keys(skips).length ? { skips } : {}),
             failures,
             stats: {
                 duration_ms: Date.now() - start,

package/dist/gates/style-drift-rules.d.ts

@@ -3,10 +3,6 @@
  *
  * Contains per-language naming convention rules and naming pattern regexes.
  */
-/**
- * Casing classification rules
- */
-export declare function classifyCasing(name: string): 'camelCase' | 'snake_case' | 'PascalCase' | 'SCREAMING_SNAKE' | null;
 /**
  * Function name pattern for JavaScript
  */

package/dist/gates/style-drift-rules.js

@@ -3,25 +3,6 @@
  *
  * Contains per-language naming convention rules and naming pattern regexes.
  */
-/**
- * Casing classification rules
- */
-export function classifyCasing(name) {
-    if (name.startsWith('_') || name.length <= 1)
-        return null;
-    if (/^[A-Z][A-Z0-9_]+$/.test(name)) {
-        return 'SCREAMING_SNAKE';
-    }
-    else if (/^[A-Z]/.test(name)) {
-        return 'PascalCase';
-    }
-    else if (name.includes('_')) {
-        return 'snake_case';
-    }
-    else {
-        return 'camelCase';
-    }
-}
 /**
  * Function name pattern for JavaScript
  */

package/dist/gates/style-drift.d.ts

@@ -32,8 +32,16 @@ export declare class StyleDriftGate extends Gate {
     constructor(config?: StyleDriftConfig);
     protected get provenance(): Provenance;
     run(context: GateContext): Promise<Failure[]>;
+    /**
+     * The changed and untracked files, each against a fingerprint of its language's files committed at the base.
+     * On the base branch with a clean tree nothing differs, so nothing is compared.
+     */
+    private againstGitBase;
+    /** Each file against its own language's fingerprint. */
+    private compare;
     private computePerLanguageBaseline;
     private computeFingerprint;
+    private fingerprintOf;
     private emptyFingerprint;
     private analyzeFile;
     private mergeIntoFingerprint;

package/dist/gates/style-drift.js

@@ -25,6 +25,7 @@ import { Logger } from '../utils/logger.js';
 import { languageAdapters } from './language-adapters/index.js';
 import { extractComparableJsNames } from './js-style-context.js';
 import { isScoped } from '../utils/scope.js';
+import { filesAtCommit, isGitWorktree, NO_GIT_BASE, readManyAtCommit, resolveGitLogicBase, untrackedFiles } from './logic-drift-git-base.js';
 import { TRY_CATCH_PATTERN, CATCH_PATTERN, RESULT_TYPE_PATTERN, NAMED_IMPORT_PATTERN, WILDCARD_IMPORT_PATTERN, SIDE_EFFECT_IMPORT_PATTERN, DEFAULT_IMPORT_PATTERN, countQuotes, } from './style-drift-rules.js';
 import fs from 'fs-extra';
 import path from 'path';
@@ -43,16 +44,26 @@ export class StyleDriftGate extends Gate {
     async run(context) {
         if (!this.config.enabled)
             return [];
-        const failures = [];
         const baselinePath = path.join(context.cwd, this.config.baseline_path);
         // Find source files
+        const ignore = [...(context.ignore || []), '**/node_modules/**', '**/dist/**', '**/*.test.*', '**/*.spec.*', '**/*.d.ts'];
         const files = await FileScanner.findFiles({
             cwd: context.cwd,
             patterns: context.patterns || languageAdapters.getScanPatterns(),
-            ignore: [...(context.ignore || []), '**/node_modules/**', '**/dist/**', '**/*.test.*', '**/*.spec.*', '**/*.d.ts'],
+            ignore,
         });
         if (files.length === 0)
             return [];
+        // In a git checkout the project's style is the code committed at the base, read fresh on every run, and
+        // only the files that differ from it are compared. Nothing is cached, so no earlier run on a dirty tree
+        // can change a verdict, and a .rigour/style-baseline.json left by an older version is never read.
+        const gitBase = resolveGitLogicBase(context.cwd);
+        if (!gitBase && isGitWorktree(context.cwd)) {
+            context.skip?.(NO_GIT_BASE);
+            return [];
+        }
+        if (gitBase)
+            return this.againstGitBase(context, files, ignore, gitBase);
         // Group files by language
         const filesByLang = new Map();
         for (const file of files) {
@@ -94,6 +105,38 @@ export class StyleDriftGate extends Gate {
             return []; // No failures on first scan
         }
         // Subsequent scan: compare each file against its own language's baseline
+        return this.compare(context, files, baseline);
+    }
+    /**
+     * The changed and untracked files, each against a fingerprint of its language's files committed at the base.
+     * On the base branch with a clean tree nothing differs, so nothing is compared.
+     */
+    async againstGitBase(context, files, ignore, gitBase) {
+        const changed = new Set([...gitBase.changedFiles, ...untrackedFiles(context.cwd)]);
+        const compared = files.filter(file => changed.has(file));
+        if (compared.length === 0)
+            return [];
+        const languages = new Set(compared.map(file => languageAdapters.getAdapter(file)?.id));
+        const sampled = new Map();
+        for (const file of FileScanner.filterPaths(filesAtCommit(context.cwd, gitBase.base), { patterns: languageAdapters.getScanPatterns(), ignore })) {
+            const id = languageAdapters.getAdapter(file)?.id;
+            if (!id || !languages.has(id))
+                continue;
+            const list = sampled.get(id) ?? [];
+            if (list.length < this.config.sample_size)
+                list.push(file);
+            sampled.set(id, list);
+        }
+        const atBase = readManyAtCommit(context.cwd, gitBase.base, [...sampled.values()].flat());
+        const baseline = { languages: {}, createdAt: '', version: 3 };
+        for (const [id, list] of sampled) {
+            baseline.languages[id] = this.fingerprintOf(new Map(list.flatMap(file => atBase.has(file) ? [[file, atBase.get(file)]] : [])));
+        }
+        return this.compare(context, compared, baseline);
+    }
+    /** Each file against its own language's fingerprint. */
+    async compare(context, files, baseline) {
+        const failures = [];
         const contents = await FileScanner.readFiles(context.cwd, files, context.fileCache);
         for (const [file, content] of contents) {
             const adapter = languageAdapters.getAdapter(file);
@@ -132,8 +175,10 @@ export class StyleDriftGate extends Gate {
         return baseline;
     }
     async computeFingerprint(context, files) {
+        return this.fingerprintOf(await FileScanner.readFiles(context.cwd, files, context.fileCache));
+    }
+    fingerprintOf(contents) {
         const fingerprint = this.emptyFingerprint();
-        const contents = await FileScanner.readFiles(context.cwd, files, context.fileCache);
         for (const [file, content] of contents) {
             const fileAnalysis = this.analyzeFile(content, file);
             this.mergeIntoFingerprint(fingerprint, fileAnalysis);
@@ -165,10 +210,13 @@ export class StyleDriftGate extends Gate {
                 ? extractComparableJsNames(content, filePath)
                 : adapter.extractNamingPatterns(content);
             for (const pattern of namingPatterns) {
+                if (pattern.convention === 'ambiguous')
+                    continue; // a one-word name says nothing about the casing
                 if (pattern.kind === 'function' || pattern.kind === 'method') {
                     fp.naming.functions[pattern.convention]++;
                 }
-                else if (pattern.kind === 'variable' || pattern.kind === 'constant') {
+                else if (pattern.kind === 'variable') {
+                    // A constant follows the constant convention (`MAX_ROWS`), never the variables': it is not compared.
                     fp.naming.variables[pattern.convention]++;
                 }
             }

package/dist/index.d.ts

@@ -11,7 +11,7 @@ export { FrontendSecretExposureGate } from './gates/frontend-secret-exposure.js'
 export * from './utils/logger.js';
 export { normalizeScopePatterns, isScoped } from './utils/scope.js';
 export { deepAnalysisError } from './utils/deep-status.js';
-export { rigourUserDir, repoStateDir } from './utils/user-state.js';
+export { rigourUserDir, repoStateDir, legacyStateNote } from './utils/user-state.js';
 export { locateTransformers, semanticRuntimeDir, semanticRuntimeInstalled, TRANSFORMERS_SPEC } from './pattern-index/semantic-runtime.js';
 export { reviewChange, toReviewFinding, type ReviewInput, type ReviewResult, type ReviewFinding } from './review/review.js';
 export { splitByChangedLines, type ChangedLineSplit } from './review/changed-lines.js';

package/dist/index.js

@@ -11,7 +11,7 @@ export { FrontendSecretExposureGate } from './gates/frontend-secret-exposure.js'
 export * from './utils/logger.js';
 export { normalizeScopePatterns, isScoped } from './utils/scope.js';
 export { deepAnalysisError } from './utils/deep-status.js';
-export { rigourUserDir, repoStateDir } from './utils/user-state.js';
+export { rigourUserDir, repoStateDir, legacyStateNote } from './utils/user-state.js';
 export { locateTransformers, semanticRuntimeDir, semanticRuntimeInstalled, TRANSFORMERS_SPEC } from './pattern-index/semantic-runtime.js';
 export { reviewChange, toReviewFinding } from './review/review.js';
 export { splitByChangedLines } from './review/changed-lines.js';

package/dist/services/terminal-renderer.d.ts

@@ -16,6 +16,8 @@ export interface RenderOptions {
 export interface GateResult {
     id: string;
     status: Status;
+    /** Why a SKIP: the check could not check. */
+    reason?: string;
 }
 export declare function renderScoreGauge(score: number, label: string): string;
 export declare function renderSeveritySection(failures: Failure[], severity: Severity, maxItems?: number): string;

package/dist/services/terminal-renderer.js

@@ -65,6 +65,9 @@ export function renderGateGrid(gates) {
         const row = entries.slice(i, i + 3).map(e => e.padEnd(22)).join('');
         lines.push(`  ${row}`);
     }
+    for (const g of gates)
+        if (g.status === 'SKIP' && g.reason)
+            lines.push(chalk.dim(`  \u{23ED} ${g.id} skipped: ${g.reason}`));
     return lines.join('\n');
 }
 // ── Brain Status ───────────────────────────────────────────────────
@@ -155,7 +158,7 @@ export function renderFullReport(report, options = {}) {
     }
     // Gate grid from report summary
     if (report.summary) {
-        const gates = Object.entries(report.summary).map(([id, status]) => ({ id, status }));
+        const gates = Object.entries(report.summary).map(([id, status]) => ({ id, status, reason: report.skips?.[id] }));
         if (gates.length > 0) {
             boxContent.push(renderGateGrid(gates));
             boxContent.push('');

package/dist/types/index.d.ts

@@ -3435,6 +3435,8 @@ export type Failure = z.infer<typeof FailureSchema>;
 export declare const ReportSchema: z.ZodObject<{
     status: z.ZodEnum<["PASS", "FAIL", "SKIP", "ERROR"]>;
     summary: z.ZodRecord<z.ZodString, z.ZodEnum<["PASS", "FAIL", "SKIP", "ERROR"]>>;
+    /** Why a check reported SKIP: it could not check (for example, no main branch to compare with). */
+    skips: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     failures: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         title: z.ZodString;
@@ -3764,6 +3766,7 @@ export declare const ReportSchema: z.ZodObject<{
         category?: string | undefined;
         advisory?: boolean | undefined;
     }[];
+    skips?: Record<string, string> | undefined;
 }, {
     stats: {
         duration_ms: number;
@@ -3828,6 +3831,7 @@ export declare const ReportSchema: z.ZodObject<{
         category?: string | undefined;
         advisory?: boolean | undefined;
     }[];
+    skips?: Record<string, string> | undefined;
 }>;
 export type Report = z.infer<typeof ReportSchema>;
 /** Options passed from CLI --deep / --pro / --max / -k flags */

package/dist/types/index.js

@@ -521,6 +521,8 @@ export const FailureSchema = z.object({
 export const ReportSchema = z.object({
     status: StatusSchema,
     summary: z.record(StatusSchema),
+    /** Why a check reported SKIP: it could not check (for example, no main branch to compare with). */
+    skips: z.record(z.string()).optional(),
     failures: z.array(FailureSchema),
     stats: z.object({
         duration_ms: z.number(),

package/dist/utils/scanner.d.ts

@@ -8,6 +8,8 @@ export declare class FileScanner {
     private static DEFAULT_PATTERNS;
     private static DEFAULT_IGNORE;
     static findFiles(options: ScannerOptions): Promise<string[]>;
+    /** The selection findFiles makes, over paths listed elsewhere (a commit's files) instead of the disk. */
+    static filterPaths(paths: string[], options: Omit<ScannerOptions, 'cwd'>): string[];
     /**
      * Read file contents. When a FileSystemCache is provided, uses it for
      * shared caching across gates (avoids re-loading per gate).

package/dist/utils/scanner.js

@@ -1,4 +1,5 @@
 import { globby } from 'globby';
+import micromatch from 'micromatch';
 import fs from 'fs-extra';
 import path from 'path';
 import { directoriesAsGlobs, withDirectoryForms } from './glob-paths.js';
@@ -42,6 +43,12 @@ export class FileScanner {
         });
         return files.sort();
     }
+    /** The selection findFiles makes, over paths listed elsewhere (a commit's files) instead of the disk. */
+    static filterPaths(paths, options) {
+        const patterns = (options.patterns || this.DEFAULT_PATTERNS).map(toGlobSeparators);
+        const ignore = withDirectoryForms([...new Set([...this.DEFAULT_IGNORE, ...(options.ignore || [])])].map(toGlobSeparators));
+        return paths.filter(file => micromatch.isMatch(file, patterns, { ignore })).sort();
+    }
     /**
      * Read file contents. When a FileSystemCache is provided, uses it for
      * shared caching across gates (avoids re-loading per gate).

package/dist/utils/user-state.d.ts

@@ -1,5 +1,15 @@
-/** The home Rigour keeps its state under: RIGOUR_HOME when set (a profile, a sandbox, tests), else the OS home. */
+/**
+ * The home Rigour keeps its state under (`<home>/.rigour`): RIGOUR_HOME when set (a profile, a sandbox, tests),
+ * else the OS home. A RIGOUR_HOME ending in `.rigour` names the state directory itself, so its parent is the home.
+ * Earlier versions kept state one level deeper (`<RIGOUR_HOME>/.rigour`): where that holds state, it stays in use
+ * and nothing is moved (legacyStateNote says how).
+ */
 export declare function rigourHome(): string;
+/**
+ * For `rigour doctor`: state an earlier version wrote under `<RIGOUR_HOME>/.rigour`, still in use, and how to move
+ * it; or, when the named directory holds state of its own too, both places. Nothing is moved for anyone.
+ */
+export declare function legacyStateNote(): string | undefined;
 /** The user's Rigour directory: `<rigourHome()>/.rigour`. Every piece of Rigour's own state lives under it. */
 export declare function rigourUserDir(): string;
 /**

package/dist/utils/user-state.js

@@ -2,9 +2,49 @@ import crypto from 'crypto';
 import fs from 'fs';
 import os from 'os';
 import path from 'path';
-/** The home Rigour keeps its state under: RIGOUR_HOME when set (a profile, a sandbox, tests), else the OS home. */
+/**
+ * The home Rigour keeps its state under (`<home>/.rigour`): RIGOUR_HOME when set (a profile, a sandbox, tests),
+ * else the OS home. A RIGOUR_HOME ending in `.rigour` names the state directory itself, so its parent is the home.
+ * Earlier versions kept state one level deeper (`<RIGOUR_HOME>/.rigour`): where that holds state, it stays in use
+ * and nothing is moved (legacyStateNote says how).
+ */
 export function rigourHome() {
-    return process.env.RIGOUR_HOME || os.homedir();
+    const set = process.env.RIGOUR_HOME;
+    if (!set)
+        return os.homedir();
+    if (path.basename(path.resolve(set)) !== '.rigour')
+        return set;
+    return hasState(path.join(set, '.rigour')) ? set : path.dirname(path.resolve(set));
+}
+function hasState(dir) {
+    try {
+        return fs.readdirSync(dir).length > 0;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * For `rigour doctor`: state an earlier version wrote under `<RIGOUR_HOME>/.rigour`, still in use, and how to move
+ * it; or, when the named directory holds state of its own too, both places. Nothing is moved for anyone.
+ */
+export function legacyStateNote() {
+    const set = process.env.RIGOUR_HOME;
+    if (!set || path.basename(path.resolve(set)) !== '.rigour')
+        return undefined;
+    const named = path.resolve(set);
+    const doubled = path.join(named, '.rigour');
+    if (!hasState(doubled))
+        return undefined;
+    const own = (() => { try {
+        return fs.readdirSync(named).filter(entry => entry !== '.rigour').length > 0;
+    }
+    catch {
+        return false;
+    } })();
+    return own
+        ? `Rigour state is in both ${named} and ${doubled}. This run uses ${doubled}, where your tools have been writing; merge the two by hand if you need both.`
+        : `Rigour state is in ${doubled}, written by an earlier version. RIGOUR_HOME=${set} now names the state directory itself: to use ${named}, move the contents of ${doubled} up one level.`;
 }
 /** The user's Rigour directory: `<rigourHome()>/.rigour`. Every piece of Rigour's own state lives under it. */
 export function rigourUserDir() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rigour-labs/core",
-  "version": "6.11.1-rc.1",
+  "version": "6.11.1-rc.3",
   "description": "Rigour's review engine: deterministic gates on changed lines, rules and lessons learned from your team's fixes, and per-check precision from what you fix versus dismiss, across TypeScript, JavaScript, Python, Go, Ruby and C#.",
   "engines": {
     "node": ">=22.13"
@@ -75,11 +75,11 @@
     "@anthropic-ai/sdk": "^0.132.1",
     "pg": "^8.16.3",
     "openai": "^5.23.2",
-    "@rigour-labs/brain-darwin-arm64": "6.11.1-rc.1",
-    "@rigour-labs/brain-darwin-x64": "6.11.1-rc.1",
-    "@rigour-labs/brain-linux-x64": "6.11.1-rc.1",
-    "@rigour-labs/brain-linux-arm64": "6.11.1-rc.1",
-    "@rigour-labs/brain-win-x64": "6.11.1-rc.1"
+    "@rigour-labs/brain-darwin-arm64": "6.11.1-rc.3",
+    "@rigour-labs/brain-linux-arm64": "6.11.1-rc.3",
+    "@rigour-labs/brain-linux-x64": "6.11.1-rc.3",
+    "@rigour-labs/brain-darwin-x64": "6.11.1-rc.3",
+    "@rigour-labs/brain-win-x64": "6.11.1-rc.3"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",