@rigour-labs/core 6.2.3 → 6.2.5

package/dist/gates/deep-runner.js

@@ -0,0 +1,65 @@
+/**
+ * Deep analysis as the gate runner reports it: summary status, report stats
+ * and failures, derived from the deep gate's outcome.
+ */
+import { DeepAnalysisGate } from './deep-analysis.js';
+import { Logger } from '../utils/logger.js';
+/**
+ * Run the deep gate and turn its outcome into summary, stats and failures.
+ * A deep run that could not analyze anything is ERROR with a visible
+ * failure, never a clean PASS.
+ */
+export async function runDeepAnalysis(config, context, deepOptions) {
+    const start = Date.now();
+    const deepGate = new DeepAnalysisGate({
+        options: deepOptions,
+        checks: config.gates.deep?.checks,
+        threads: config.gates.deep?.threads,
+        maxTokens: config.gates.deep?.max_tokens,
+        temperature: config.gates.deep?.temperature,
+        timeoutMs: config.gates.deep?.timeout_ms,
+        onProgress: deepOptions.onProgress,
+    });
+    let findings = [];
+    let thrown;
+    try {
+        findings = await deepGate.run(context);
+    }
+    catch (error) {
+        thrown = error?.message ?? String(error);
+        Logger.error(`Deep analysis failed: ${thrown}`);
+    }
+    // A gate that threw produced nothing: never report its last outcome as ok.
+    const outcome = thrown ? { ...deepGate.getOutcome(), status: 'error', error: thrown } : deepGate.getOutcome();
+    const isLocal = !deepOptions.apiKey || (deepOptions.provider || '').toLowerCase() === 'local';
+    const stats = {
+        enabled: true,
+        status: outcome.status,
+        mode: outcome.mode,
+        tier: isLocal ? (deepOptions.pro ? 'deep' : 'lite') : 'cloud',
+        model: outcome.model,
+        model_fallback: outcome.modelFallback,
+        total_ms: Date.now() - start,
+        files_analyzed: outcome.filesAnalyzed,
+        chunks_total: outcome.chunksTotal,
+        chunks_failed: outcome.chunksFailed,
+        error: outcome.error,
+        findings_count: findings.length,
+        findings_verified: findings.filter(f => f.verified).length,
+    };
+    if (outcome.status === 'error') {
+        return {
+            failures: [{
+                    id: 'deep-analysis',
+                    title: 'Deep analysis did not run',
+                    details: outcome.error || 'Deep analysis failed before producing results.',
+                    severity: 'medium',
+                    provenance: 'traditional',
+                    hint: 'Run `rigour doctor`. For local mode, `rigour deep pull` installs the engine and model.',
+                }],
+            summary: 'ERROR',
+            stats,
+        };
+    }
+    return { failures: findings, summary: findings.length > 0 ? 'FAIL' : 'PASS', stats };
+}

package/dist/gates/dependency.js

@@ -18,6 +18,7 @@ import path from 'path';
 import { Gate } from './base.js';
 import { FileScanner } from '../utils/scanner.js';
 import { Logger } from '../utils/logger.js';
+import { scopeExcludes } from '../utils/scope.js';
 /**
  * Known heavy packages with lighter alternatives.
  * Format: package → "alternative (size comparison)"
@@ -84,6 +85,9 @@ export class DependencyGate extends Gate {
         const depConfig = this.config.gates.dependencies || {};
         const forbidden = depConfig.forbid || [];
         const { cwd } = context;
+        // Dependency health belongs to the manifest: a scoped run checks it only with package.json in scope.
+        if (await scopeExcludes(context, 'package.json'))
+            return [];
         // 1. Scan Node.js (package.json) — forbidden + new checks
         const pkgPath = path.join(cwd, 'package.json');
         if (await fs.pathExists(pkgPath)) {

package/dist/gates/hallucinated-imports/index.js

@@ -48,21 +48,25 @@ export class HallucinatedImportsGate extends Gate {
         const hallucinated = [];
         const defaultPatterns = ['**/*.{ts,js,tsx,jsx,py,go,rb,cs,rs,java,kt}'];
         const scanPatterns = context.patterns || defaultPatterns;
+        const ignore = [...(context.ignore || []), '**/node_modules/**', '**/dist/**', '**/build/**',
+            '**/examples/**', '**/studio-dist/**', '**/.next/**', '**/coverage/**',
+            '**/*.test.*', '**/*.spec.*', '**/__tests__/**',
+            '**/.venv/**', '**/venv/**', '**/vendor/**', '**/bin/Debug/**', '**/bin/Release/**', '**/obj/**',
+            '**/target/debug/**', '**/target/release/**', '**/out/**', '**/.gradle/**', '**/gradle/**'];
         const files = await FileScanner.findFiles({
             cwd: context.cwd,
             patterns: scanPatterns,
-            ignore: [...(context.ignore || []), '**/node_modules/**', '**/dist/**', '**/build/**',
-                '**/examples/**',
-                '**/studio-dist/**', '**/.next/**', '**/coverage/**',
-                '**/*.test.*', '**/*.spec.*', '**/__tests__/**',
-                '**/.venv/**', '**/venv/**', '**/vendor/**', '**/bin/Debug/**', '**/bin/Release/**', '**/obj/**',
-                '**/target/debug/**', '**/target/release/**',
-                '**/out/**', '**/.gradle/**', '**/gradle/**'],
+            ignore,
         });
         const analyzableFiles = files.filter(file => !this.shouldSkipFile(file));
         Logger.info(`Hallucinated Imports: Scanning ${analyzableFiles.length} files`);
-        const projectFiles = new Set(analyzableFiles.map(f => f.replace(/\\/g, '/')));
-        const allProjectFiles = new Set(files.map(f => f.replace(/\\/g, '/')));
+        // A scoped review scans changed files, but relative imports may point
+        // to unchanged files. Resolve against the project, not the edit set.
+        const resolutionFiles = context.patterns
+            ? await FileScanner.findFiles({ cwd: context.cwd, patterns: defaultPatterns, ignore })
+            : files;
+        const projectFiles = new Set(resolutionFiles.map(f => f.replace(/\\/g, '/')));
+        const allProjectFiles = projectFiles;
         const packageJson = await loadPackageJson(context.cwd);
         const rootDeps = new Set([
             ...Object.keys(packageJson?.dependencies || {}),

package/dist/gates/hallucinated-imports.test.js

@@ -264,6 +264,16 @@ describe('HallucinatedImportsGate — JS/TS Node builtins', () => {
         mockReaddirSync.mockReturnValue([]);
         gate = new HallucinatedImportsGate({ enabled: true });
     });
+    it('resolves changed-file imports against unchanged project files', async () => {
+        FileScanner.findFiles
+            .mockResolvedValueOnce(['src/feature.ts'])
+            .mockResolvedValueOnce(['src/feature.ts', 'src/types.ts']);
+        mockReadFile.mockResolvedValue("import type { Value } from './types.js';\n");
+        mockPathExists.mockResolvedValue(false);
+        const failures = await gate.run({ ...context, patterns: ['src/feature.ts'] });
+        expect(failures).toEqual([]);
+        expect(FileScanner.findFiles).toHaveBeenCalledTimes(2);
+    });
     it('should NOT flag Node.js built-in modules', async () => {
         const jsContent = `
 import fs from 'fs';

package/dist/gates/js-style-context.d.ts

@@ -0,0 +1,3 @@
+import { type NamingPattern } from './language-adapters/types.js';
+/** Extract comparable JS/TS names, excluding framework-defined identifiers. */
+export declare function extractComparableJsNames(content: string, file: string): NamingPattern[];

package/dist/gates/js-style-context.js

@@ -0,0 +1,65 @@
+import ts from 'typescript';
+import { classifyCasing } from './language-adapters/types.js';
+const HTTP_METHODS = new Set(['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD', 'OPTIONS']);
+function isNextRoute(file) {
+    return /(?:^|\/)app(?:\/[^/]+)*\/route\.[cm]?[jt]sx?$/.test(file.replace(/\\/g, '/'));
+}
+function exported(node) {
+    return ts.canHaveModifiers(node)
+        && Boolean(ts.getModifiers(node)?.some(modifier => modifier.kind === ts.SyntaxKind.ExportKeyword));
+}
+function containsJsx(node) {
+    let found = false;
+    const visit = (child) => {
+        if (ts.isJsxElement(child) || ts.isJsxSelfClosingElement(child) || ts.isJsxFragment(child)) {
+            found = true;
+            return;
+        }
+        if (!found)
+            ts.forEachChild(child, visit);
+    };
+    ts.forEachChild(node, visit);
+    return found;
+}
+function isComponent(name, node, file) {
+    return /\.[jt]sx$/.test(file) && /^[A-Z]/.test(name) && containsJsx(node);
+}
+function isModuleConstant(declaration) {
+    const list = declaration.parent;
+    return ts.isVariableDeclarationList(list)
+        && (list.flags & ts.NodeFlags.Const) !== 0
+        && ts.isVariableStatement(list.parent)
+        && ts.isSourceFile(list.parent.parent);
+}
+function isFunctionValue(initializer) {
+    return Boolean(initializer && (ts.isArrowFunction(initializer) || ts.isFunctionExpression(initializer)));
+}
+/** Extract comparable JS/TS names, excluding framework-defined identifiers. */
+export function extractComparableJsNames(content, file) {
+    const kind = /\.[jt]sx$/.test(file) ? ts.ScriptKind.TSX : /\.[cm]?ts$/.test(file) ? ts.ScriptKind.TS : ts.ScriptKind.JS;
+    const source = ts.createSourceFile(file, content, ts.ScriptTarget.Latest, true, kind);
+    const patterns = [];
+    const route = isNextRoute(file);
+    const visit = (node) => {
+        if (ts.isFunctionDeclaration(node) && node.name) {
+            const name = node.name.text;
+            if (!(route && exported(node) && HTTP_METHODS.has(name)) && !isComponent(name, node, file)) {
+                patterns.push({ name, kind: 'function', convention: classifyCasing(name) });
+            }
+        }
+        if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name)) {
+            const name = node.name.text;
+            const fn = isFunctionValue(node.initializer);
+            const statement = node.parent.parent;
+            const routeExport = route && HTTP_METHODS.has(name) && ts.isVariableStatement(statement) && exported(statement);
+            const component = fn && isComponent(name, node.initializer, file);
+            const conventionalConstant = !fn && isModuleConstant(node) && classifyCasing(name) === 'SCREAMING_SNAKE';
+            if (!routeExport && !component && !conventionalConstant) {
+                patterns.push({ name, kind: fn ? 'function' : 'variable', convention: classifyCasing(name) });
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(source);
+    return patterns;
+}

package/dist/gates/js-style-context.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/gates/js-style-context.test.js

@@ -0,0 +1,35 @@
+import { describe, expect, it } from 'vitest';
+import { extractComparableJsNames } from './js-style-context.js';
+describe('context-aware JS naming', () => {
+    it('excludes exported Next route methods only inside app route files', () => {
+        const code = `
+            export async function GET() { return Response.json({}); }
+            export const POST = async () => Response.json({});
+            function GET_HELPER() { return 1; }
+        `;
+        expect(extractComparableJsNames(code, 'src/app/api/items/route.ts').map(item => item.name))
+            .toEqual(['GET_HELPER']);
+        expect(extractComparableJsNames(code, 'src/lib/route.ts').map(item => item.name))
+            .toEqual(['GET', 'POST', 'GET_HELPER']);
+    });
+    it('excludes JSX-returning components but keeps ordinary PascalCase functions', () => {
+        const code = `
+            export function StepReview() { return <section />; }
+            const WizardField = () => <input />;
+            function ParseValue() { return 1; }
+        `;
+        expect(extractComparableJsNames(code, 'src/components/WizardField.tsx').map(item => item.name))
+            .toEqual(['ParseValue']);
+    });
+    it('excludes module constants but keeps unconventional local variables', () => {
+        const code = `
+            const EMAIL_TEMPLATE = 'hello';
+            function sendMessage() {
+                const LOCAL_VALUE = 1;
+                return LOCAL_VALUE;
+            }
+        `;
+        expect(extractComparableJsNames(code, 'src/lib/template.ts').map(item => item.name))
+            .toEqual(['sendMessage', 'LOCAL_VALUE']);
+    });
+});

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

@@ -0,0 +1,7 @@
+export interface GitLogicBase {
+    changedFiles: Set<string>;
+    readAtBase: (file: string) => string | null;
+}
+export declare function isGitWorktree(cwd: string): boolean;
+/** Use a fixed commit for the entire scan; never move the baseline on read. */
+export declare function resolveGitLogicBase(cwd: string): GitLogicBase | null;

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

@@ -0,0 +1,41 @@
+import { execFileSync } from 'node:child_process';
+export function isGitWorktree(cwd) {
+    return git(cwd, ['rev-parse', '--is-inside-work-tree'])?.trim() === 'true';
+}
+function git(cwd, args) {
+    try {
+        return execFileSync('git', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], maxBuffer: 16 * 1024 * 1024 });
+    }
+    catch {
+        return null;
+    }
+}
+/** Use a fixed commit for the entire scan; never move the baseline on read. */
+export function resolveGitLogicBase(cwd) {
+    // Git reports the path relative to the worktree root without relying on
+    // platform-specific path casing or Windows short-name expansion.
+    const prefix = git(cwd, ['rev-parse', '--show-prefix']);
+    if (prefix === null || prefix.trim())
+        return null;
+    const currentBranch = git(cwd, ['symbolic-ref', '--quiet', '--short', 'HEAD'])?.trim();
+    const candidates = [
+        process.env.GITHUB_BASE_REF ? `refs/remotes/origin/${process.env.GITHUB_BASE_REF}` : '',
+        'refs/remotes/origin/main', 'refs/heads/main',
+        'refs/remotes/origin/master', 'refs/heads/master',
+    ].filter(Boolean);
+    const mainRef = candidates.find(ref => git(cwd, ['rev-parse', '--verify', '--quiet', ref])?.trim());
+    if (!mainRef)
+        return null;
+    const base = currentBranch === 'main' || currentBranch === 'master'
+        ? git(cwd, ['rev-parse', 'HEAD'])?.trim()
+        : git(cwd, ['merge-base', 'HEAD', mainRef])?.trim();
+    if (!base)
+        return null;
+    const diff = git(cwd, ['diff', '--name-only', '-z', '--diff-filter=ACMR', base, '--']);
+    if (diff === null)
+        return null;
+    return {
+        changedFiles: new Set(diff.split('\0').filter(Boolean)),
+        readAtBase: file => git(cwd, ['show', `${base}:${file}`]),
+    };
+}

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

@@ -12,9 +12,9 @@
  * - Tests might still pass (if they don't cover edge cases)
  * - The change looks intentional ("AI refactored the function")
  *
- * Strategy: Collect baselines for critical functions, then detect
- * mutations between scans. This foundation enables future LLM-powered
- * deeper analysis (feeding baselines into DriftBench training).
+ * Strategy: Compare changed functions against the Git main merge base.
+ * Repeated scans of the same change must report the same review signals.
+ * Non-Git projects retain the legacy local baseline behavior.
  */
 import { Gate, GateContext } from './base.js';
 import { Failure, Provenance } from '../types/index.js';

package/dist/gates/logic-drift.js

@@ -12,15 +12,17 @@
  * - Tests might still pass (if they don't cover edge cases)
  * - The change looks intentional ("AI refactored the function")
  *
- * Strategy: Collect baselines for critical functions, then detect
- * mutations between scans. This foundation enables future LLM-powered
- * deeper analysis (feeding baselines into DriftBench training).
+ * Strategy: Compare changed functions against the Git main merge base.
+ * Repeated scans of the same change must report the same review signals.
+ * Non-Git projects retain the legacy local baseline behavior.
  */
 import { Gate } from './base.js';
 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 { isScoped } from '../utils/scope.js';
 import fs from 'fs-extra';
 import path from 'path';
 import crypto from 'crypto';
@@ -50,16 +52,35 @@ export class LogicDriftGate extends Gate {
         });
         if (files.length === 0)
             return [];
+        // 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');
+            return [];
+        }
+        const scanFiles = gitBase ? files.filter(file => gitBase.changedFiles.has(file)) : files;
+        if (gitBase && scanFiles.length === 0)
+            return [];
         // Extract current function baselines
         const currentFunctions = [];
-        const contents = await FileScanner.readFiles(context.cwd, files, context.fileCache);
+        const contents = await FileScanner.readFiles(context.cwd, scanFiles, context.fileCache);
         for (const [file, content] of contents) {
             const extracted = this.extractFunctionBaselines(content, file);
             currentFunctions.push(...extracted);
         }
-        // Load previous baseline
+        // Git is authoritative when present; old local snapshots are fallback
+        // only for projects without an available Git main reference.
         let previousBaseline = null;
-        if (await fs.pathExists(baselinePath)) {
+        if (gitBase) {
+            const functions = [];
+            for (const file of scanFiles) {
+                const content = gitBase.readAtBase(file);
+                if (content !== null)
+                    functions.push(...this.extractFunctionBaselines(content, file));
+            }
+            previousBaseline = { functions, createdAt: '', lastUpdated: '', scanCount: 0 };
+        }
+        else if (await fs.pathExists(baselinePath)) {
             try {
                 const raw = await fs.readJson(baselinePath);
                 // Validate baseline has required structure
@@ -74,6 +95,11 @@ export class LogicDriftGate extends Gate {
                 Logger.debug('Failed to load logic baseline');
             }
         }
+        // A scoped run sees only some files: compare against the baseline but
+        // never create or overwrite it, or the rest of the repo drops out of it.
+        const scoped = isScoped(context.patterns);
+        if (!previousBaseline && scoped)
+            return [];
         if (!previousBaseline) {
             // First scan: save baseline, no comparisons yet
             const baseline = {
@@ -131,7 +157,8 @@ export class LogicDriftGate extends Gate {
             lastUpdated: new Date().toISOString(),
             scanCount: previousBaseline.scanCount + 1,
         };
-        await fs.writeJson(baselinePath, updatedBaseline, { spaces: 2 });
+        if (!gitBase && !scoped)
+            await fs.writeJson(baselinePath, updatedBaseline, { spaces: 2 });
         if (failures.length > 0) {
             Logger.info(`Logic Drift: Found ${failures.length} logic mutations`);
         }
@@ -146,7 +173,12 @@ export class LogicDriftGate extends Gate {
         }
         const skipKeywords = new Set(['if', 'for', 'while', 'switch', 'catch', 'constructor', 'else', 'elif', 'elsif', 'rescue']);
         const functions = adapter.extractFunctions(content, file);
+        const seen = new Set();
         for (const fn of functions) {
+            const identity = `${fn.name}:${fn.startLine}`;
+            if (seen.has(identity))
+                continue;
+            seen.add(identity);
             // Skip control flow keywords
             if (skipKeywords.has(fn.name))
                 continue;

package/dist/gates/logic-drift.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/gates/logic-drift.test.js

@@ -0,0 +1,45 @@
+import { execFileSync } from 'node:child_process';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { LogicDriftGate } from './logic-drift.js';
+describe('LogicDriftGate Git baseline', () => {
+    let cwd;
+    const git = (...args) => execFileSync('git', args, { cwd, stdio: 'pipe' });
+    beforeEach(() => {
+        cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'logic-drift-'));
+        git('init', '-q', '-b', 'main');
+        git('config', 'user.name', 'Rigour Test');
+        git('config', 'user.email', 'test@example.invalid');
+        fs.mkdirSync(path.join(cwd, 'src'));
+        fs.writeFileSync(path.join(cwd, 'src/rules.ts'), 'export function eligible(score: number) { return score >= 10; }\n');
+        git('add', '.');
+        git('commit', '-qm', 'base');
+    });
+    afterEach(() => { fs.rmSync(cwd, { recursive: true, force: true }); });
+    it('reports a branch mutation consistently and clears it after merge', async () => {
+        const gate = new LogicDriftGate();
+        expect(await gate.run({ cwd })).toEqual([]);
+        git('switch', '-q', '-c', 'feature');
+        fs.writeFileSync(path.join(cwd, 'src/rules.ts'), 'export function eligible(score: number) { return score > 10; }\n');
+        const first = await gate.run({ cwd });
+        const second = await gate.run({ cwd });
+        expect(first).toEqual(second);
+        expect(first).toHaveLength(1);
+        expect(first.some(finding => finding.details.includes("'>=' to '>'"))).toBe(true);
+        expect(fs.existsSync(path.join(cwd, '.rigour/logic-baseline.json'))).toBe(false);
+        git('add', '.');
+        git('commit', '-qm', 'change boundary');
+        git('switch', '-q', 'main');
+        git('merge', '-q', '--ff-only', 'feature');
+        expect(await gate.run({ cwd })).toEqual([]);
+    }, 30_000);
+    it('does not use a moving local snapshot when Git has no main reference', async () => {
+        git('switch', '-q', '-c', 'feature');
+        git('branch', '-D', 'main');
+        const gate = new LogicDriftGate();
+        expect(await gate.run({ cwd })).toEqual([]);
+        expect(fs.existsSync(path.join(cwd, '.rigour/logic-baseline.json'))).toBe(false);
+    });
+});

package/dist/gates/runner.js

@@ -1,5 +1,5 @@
 import { SEVERITY_WEIGHTS } from '../types/index.js';
-import { DeepAnalysisGate } from './deep-analysis.js';
+import { runDeepAnalysis } from './deep-runner.js';
 import { persistAndReinforce } from '../storage/local-memory.js';
 import { recordGateRun } from '../services/adaptive-thresholds.js';
 import { FileGate } from './file.js';
@@ -200,45 +200,10 @@ export class GateRunner {
         // 3. Run Deep Analysis (if enabled)
         let deepStats = undefined;
         if (deepOptions?.enabled) {
-            const deepSetupStart = Date.now();
-            const deepGate = new DeepAnalysisGate({
-                options: deepOptions,
-                checks: this.config.gates.deep?.checks,
-                threads: this.config.gates.deep?.threads,
-                maxTokens: this.config.gates.deep?.max_tokens,
-                temperature: this.config.gates.deep?.temperature,
-                timeoutMs: this.config.gates.deep?.timeout_ms,
-                onProgress: deepOptions.onProgress,
-            });
-            try {
-                const deepFailures = await deepGate.run({ cwd, ignore, patterns });
-                if (deepFailures.length > 0) {
-                    failures.push(...deepFailures);
-                    summary['deep-analysis'] = 'FAIL';
-                }
-                else {
-                    summary['deep-analysis'] = 'PASS';
-                }
-                const isLocalDeepExecution = !deepOptions.apiKey || (deepOptions.provider || '').toLowerCase() === 'local';
-                const deepTier = isLocalDeepExecution
-                    ? (deepOptions.pro ? 'deep' : 'lite')
-                    : 'cloud';
-                deepStats = {
-                    enabled: true,
-                    tier: deepTier,
-                    model: isLocalDeepExecution
-                        ? (deepOptions.pro ? 'Qwen2.5-Coder-1.5B' : 'Qwen2.5-Coder-0.5B')
-                        : (deepOptions.modelName || deepOptions.provider || 'cloud'),
-                    total_ms: Date.now() - deepSetupStart,
-                    findings_count: deepFailures.length,
-                    findings_verified: deepFailures.filter((f) => f.verified).length,
-                };
-            }
-            catch (error) {
-                Logger.error(`Deep analysis failed: ${error.message}`);
-                summary['deep-analysis'] = 'ERROR';
-                deepStats = { enabled: true };
-            }
+            const deep = await runDeepAnalysis(this.config, { cwd, ignore, patterns }, deepOptions);
+            failures.push(...deep.failures);
+            summary['deep-analysis'] = deep.summary;
+            deepStats = deep.stats;
         }
         const status = failures.length > 0 ? 'FAIL' : 'PASS';
         // Severity-weighted scoring with per-gate cap and deduplication

package/dist/gates/runner.test.js

@@ -4,6 +4,12 @@ import path from 'path';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { GateRunner } from './runner.js';
 import { DeepAnalysisGate } from './deep-analysis.js';
+function mockDeep(outcome, failures = []) {
+    vi.spyOn(DeepAnalysisGate.prototype, 'run').mockResolvedValue(failures);
+    vi.spyOn(DeepAnalysisGate.prototype, 'getOutcome').mockReturnValue({
+        status: 'ok', mode: 'facts', filesAnalyzed: 1, chunksTotal: 1, chunksFailed: 0, ...outcome,
+    });
+}
 describe('GateRunner deep stats execution mode', () => {
     let testDir;
     beforeEach(async () => {
@@ -25,41 +31,47 @@ describe('GateRunner deep stats execution mode', () => {
             },
         });
     }
-    it('reports local lite tier when provider=local even with apiKey', async () => {
-        vi.spyOn(DeepAnalysisGate.prototype, 'run').mockResolvedValue([]);
-        const runner = createRunner();
-        const report = await runner.run(testDir, undefined, {
-            enabled: true,
-            apiKey: 'sk-test',
-            provider: 'local',
-            pro: false,
+    it('reports local lite tier and the model the provider actually loaded', async () => {
+        mockDeep({ model: 'Qwen2.5-Coder-0.5B-Instruct (stock)', modelFallback: true });
+        const report = await createRunner().run(testDir, undefined, {
+            enabled: true, apiKey: 'sk-test', provider: 'local', pro: false,
         });
         expect(report.stats.deep?.tier).toBe('lite');
-        expect(report.stats.deep?.model).toBe('Qwen2.5-Coder-0.5B');
+        expect(report.stats.deep?.model).toBe('Qwen2.5-Coder-0.5B-Instruct (stock)');
+        expect(report.stats.deep?.model_fallback).toBe(true);
+        expect(report.stats.deep?.status).toBe('ok');
+        expect(report.summary['deep-analysis']).toBe('PASS');
     });
     it('reports local deep tier when provider=local and pro=true', async () => {
-        vi.spyOn(DeepAnalysisGate.prototype, 'run').mockResolvedValue([]);
-        const runner = createRunner();
-        const report = await runner.run(testDir, undefined, {
-            enabled: true,
-            apiKey: 'sk-test',
-            provider: 'local',
-            pro: true,
+        mockDeep({ model: 'Rigour-Deep-v5.0.0 (Qwen2.5-Coder-1.5B fine-tuned)', modelFallback: false });
+        const report = await createRunner().run(testDir, undefined, {
+            enabled: true, apiKey: 'sk-test', provider: 'local', pro: true,
         });
         expect(report.stats.deep?.tier).toBe('deep');
-        expect(report.stats.deep?.model).toBe('Qwen2.5-Coder-1.5B');
+        expect(report.stats.deep?.model).toBe('Rigour-Deep-v5.0.0 (Qwen2.5-Coder-1.5B fine-tuned)');
     });
     it('reports cloud tier/model for cloud providers', async () => {
-        vi.spyOn(DeepAnalysisGate.prototype, 'run').mockResolvedValue([]);
-        const runner = createRunner();
-        const report = await runner.run(testDir, undefined, {
-            enabled: true,
-            apiKey: 'sk-test',
-            provider: 'openai',
-            modelName: 'gpt-4.1-mini',
-            pro: false,
+        mockDeep({ model: 'gpt-4.1-mini' });
+        const report = await createRunner().run(testDir, undefined, {
+            enabled: true, apiKey: 'sk-test', provider: 'openai', modelName: 'gpt-4.1-mini', pro: false,
         });
         expect(report.stats.deep?.tier).toBe('cloud');
         expect(report.stats.deep?.model).toBe('gpt-4.1-mini');
     });
+    it('reports a deep run that could not analyze anything as ERROR with a visible failure', async () => {
+        mockDeep({ status: 'error', chunksTotal: 3, chunksFailed: 3, error: 'All 3 inference call(s) failed.' });
+        const report = await createRunner().run(testDir, undefined, { enabled: true, pro: false });
+        expect(report.summary['deep-analysis']).toBe('ERROR');
+        expect(report.status).toBe('FAIL');
+        expect(report.stats.deep).toMatchObject({ status: 'error', chunks_total: 3, chunks_failed: 3, error: 'All 3 inference call(s) failed.' });
+        const failure = report.failures.find(f => f.id === 'deep-analysis');
+        expect(failure?.title).toBe('Deep analysis did not run');
+        expect(failure?.details).toContain('All 3 inference call(s) failed.');
+    });
+    it('keeps a partial run as PASS/FAIL by findings and records failed chunks', async () => {
+        mockDeep({ status: 'partial', chunksTotal: 4, chunksFailed: 1 });
+        const report = await createRunner().run(testDir, undefined, { enabled: true, pro: false });
+        expect(report.summary['deep-analysis']).toBe('PASS');
+        expect(report.stats.deep).toMatchObject({ status: 'partial', chunks_total: 4, chunks_failed: 1 });
+    });
 });

package/dist/gates/scoped-gates.test.d.ts

@@ -0,0 +1 @@
+export {};