@rigour-labs/core 6.11.1-rc.2 → 6.11.1

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

@@ -5,6 +5,8 @@ export interface GitLogicBase {
     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. */

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';
 }

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.js

@@ -25,7 +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, readManyAtCommit, resolveGitLogicBase, untrackedFiles } from './logic-drift-git-base.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';
@@ -59,7 +59,7 @@ export class StyleDriftGate extends Gate {
         // 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)) {
-            Logger.info('Style Drift: no main reference available; comparison unavailable');
+            context.skip?.(NO_GIT_BASE);
             return [];
         }
         if (gitBase)
@@ -210,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/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.2",
+  "version": "6.11.1",
   "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-linux-arm64": "6.11.1-rc.2",
-    "@rigour-labs/brain-darwin-x64": "6.11.1-rc.2",
-    "@rigour-labs/brain-linux-x64": "6.11.1-rc.2",
-    "@rigour-labs/brain-darwin-arm64": "6.11.1-rc.2",
-    "@rigour-labs/brain-win-x64": "6.11.1-rc.2"
+    "@rigour-labs/brain-darwin-x64": "6.11.1",
+    "@rigour-labs/brain-linux-x64": "6.11.1",
+    "@rigour-labs/brain-linux-arm64": "6.11.1",
+    "@rigour-labs/brain-win-x64": "6.11.1",
+    "@rigour-labs/brain-darwin-arm64": "6.11.1"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",