@rigour-labs/core 4.3.2 → 4.3.4

package/dist/gates/context-window-artifacts.js

@@ -36,9 +36,10 @@ export class ContextWindowArtifactsGate extends Gate {
         if (!this.config.enabled)
             return [];
         const failures = [];
+        const scanPatterns = context.patterns || ['**/*.{ts,js,tsx,jsx,py}'];
         const files = await FileScanner.findFiles({
             cwd: context.cwd,
-            patterns: ['**/*.{ts,js,tsx,jsx,py}'],
+            patterns: scanPatterns,
             ignore: [...(context.ignore || []), '**/node_modules/**', '**/dist/**', '**/*.test.*', '**/*.spec.*', '**/*.min.*'],
         });
         Logger.info(`Context Window Artifacts: Scanning ${files.length} files`);

package/dist/gates/deprecated-apis.js

@@ -48,9 +48,11 @@ export class DeprecatedApisGate extends Gate {
             return [];
         const failures = [];
         const deprecated = [];
+        const defaultPatterns = ['**/*.{ts,js,tsx,jsx,py,go,cs,java,kt}'];
+        const scanPatterns = context.patterns || defaultPatterns;
         const files = await FileScanner.findFiles({
             cwd: context.cwd,
-            patterns: ['**/*.{ts,js,tsx,jsx,py,go,cs,java,kt}'],
+            patterns: scanPatterns,
             ignore: [...(context.ignore || []), '**/node_modules/**', '**/dist/**', '**/build/**',
                 '**/*.test.*', '**/*.spec.*', '**/__tests__/**',
                 '**/.venv/**', '**/venv/**', '**/vendor/**', '**/__pycache__/**',

package/dist/gates/duplication-drift.js

@@ -33,9 +33,10 @@ export class DuplicationDriftGate extends Gate {
             return [];
         const failures = [];
         const functions = [];
+        const scanPatterns = context.patterns || ['**/*.{ts,js,tsx,jsx,py}'];
         const files = await FileScanner.findFiles({
             cwd: context.cwd,
-            patterns: ['**/*.{ts,js,tsx,jsx,py}'],
+            patterns: scanPatterns,
             ignore: [...(context.ignore || []), '**/node_modules/**', '**/dist/**', '**/*.test.*', '**/*.spec.*'],
         });
         Logger.info(`Duplication Drift: Scanning ${files.length} files`);

package/dist/gates/frontend-secret-exposure.d.ts

@@ -1,3 +1,22 @@
+/**
+ * Frontend Secret Exposure Gate
+ *
+ * Detects server-side secret keys (Stripe, OpenAI, AWS, etc.) referenced
+ * in frontend-accessible files where they would be bundled into client JS.
+ *
+ * The "vibe-coded startup" attack pattern:
+ *   process.env.STRIPE_SECRET_KEY inside a React component
+ *   → bundled by webpack/Vite → visible in DevTools → $2,500 in fraudulent charges
+ *
+ * Two detection modes:
+ *   1. Env-var name detection: process.env.VARNAME / import.meta.env.VARNAME
+ *      where VARNAME matches secret_env_name_patterns and lacks a safe public prefix.
+ *   2. Literal key detection: actual live API key values embedded in source
+ *      (sk_live_..., sk-proj-..., AKIA..., ghp_..., etc.)
+ *
+ * @since v4.4.0
+ * @see CWE-312 Cleartext Storage of Sensitive Information
+ */
 import { Gate, GateContext } from './base.js';
 import { Failure, Provenance } from '../types/index.js';
 export interface FrontendSecretExposureConfig {
@@ -12,16 +31,29 @@ export interface FrontendSecretExposureConfig {
     allowlist_env_names?: string[];
 }
 export declare class FrontendSecretExposureGate extends Gate {
-    private config;
-    private severityOrder;
+    private cfg;
+    private secretNamePatterns;
+    private safePrefixPatterns;
+    private frontendPathPatterns;
+    private serverPathPatterns;
     constructor(config?: FrontendSecretExposureConfig);
     protected get provenance(): Provenance;
     run(context: GateContext): Promise<Failure[]>;
-    private shouldSkipFile;
-    private isClientBundled;
-    private isServerOnlyContent;
-    private findEnvExposures;
-    private collectMatches;
-    private isSecretLikeEnvName;
-    private matchesAnyPattern;
+    /** Classify a file path as frontend, server, or ambiguous based on config patterns. */
+    private classifyFile;
+    /** Test/fixture files are excluded — they legitimately contain dummy keys. */
+    private isTestFile;
+    /**
+     * Check whether a var name looks like a server-side secret:
+     * - Matches at least one secret_env_name_pattern
+     * - Does NOT start with a safe public prefix
+     * - Is NOT in the user allowlist
+     */
+    private isSecretVar;
+    /** Scan one file for env-var references and literal key values. */
+    private scanFile;
+    private makeEnvRefExposure;
+    /** Filters out trivial dummy/placeholder text to reduce false positives. */
+    private isDummyValue;
+    private toFailures;
 }

package/dist/gates/frontend-secret-exposure.js

@@ -1,174 +1,354 @@
+/**
+ * Frontend Secret Exposure Gate
+ *
+ * Detects server-side secret keys (Stripe, OpenAI, AWS, etc.) referenced
+ * in frontend-accessible files where they would be bundled into client JS.
+ *
+ * The "vibe-coded startup" attack pattern:
+ *   process.env.STRIPE_SECRET_KEY inside a React component
+ *   → bundled by webpack/Vite → visible in DevTools → $2,500 in fraudulent charges
+ *
+ * Two detection modes:
+ *   1. Env-var name detection: process.env.VARNAME / import.meta.env.VARNAME
+ *      where VARNAME matches secret_env_name_patterns and lacks a safe public prefix.
+ *   2. Literal key detection: actual live API key values embedded in source
+ *      (sk_live_..., sk-proj-..., AKIA..., ghp_..., etc.)
+ *
+ * @since v4.4.0
+ * @see CWE-312 Cleartext Storage of Sensitive Information
+ */
 import { Gate } from './base.js';
 import { FileScanner } from '../utils/scanner.js';
 import { Logger } from '../utils/logger.js';
 import fs from 'fs-extra';
 import path from 'path';
-const DEFAULT_SECRET_ENV_NAME_PATTERNS = [
-    '(?:^|_)(?:secret|private)(?:_|$)',
-    '(?:^|_)(?:token|api[_-]?key|access[_-]?key|client[_-]?secret|signing|webhook)(?:_|$)',
-    '(?:^|_)(?:db[_-]?url|database[_-]?url|connection[_-]?string)(?:_|$)',
-];
-const DEFAULT_SAFE_PUBLIC_PREFIXES = [
-    'NEXT_PUBLIC_',
-    'VITE_',
-    'PUBLIC_',
-    'NUXT_PUBLIC_',
-    'REACT_APP_',
-];
-const DEFAULT_FRONTEND_PATH_PATTERNS = [
-    '(^|/)pages/(?!api/)',
-    '(^|/)components/',
-    '(^|/)src/components/',
-    '(^|/)src/views/',
-    '(^|/)src/app/',
-    '(^|/)app/(?!api/)',
-    '(^|/)views/',
-    '(^|/)public/',
-];
-const DEFAULT_SERVER_PATH_PATTERNS = [
-    '(^|/)pages/api/',
-    '(^|/)src/pages/api/',
-    '(^|/)app/api/',
-    '(^|/)src/app/api/',
-    '\\.server\\.(?:ts|tsx|js|jsx|mjs|cjs)$',
+/**
+ * Literal API key patterns — actual values that are always dangerous in frontend code.
+ * These bypass the env-name heuristic and fire regardless of variable naming.
+ */
+const LITERAL_KEY_PATTERNS = [
+    {
+        label: 'Stripe Live Secret Key',
+        regex: /\bsk_live_[a-zA-Z0-9]{24,}\b/g,
+        severity: 'critical',
+        hint: 'Live Stripe secret key (sk_live_...) exposed in client bundle. ' +
+            'Attackers can charge cards without a frontend. Move to server-side only.',
+        cwe: 'CWE-312',
+    },
+    {
+        label: 'Stripe Live Restricted Key',
+        regex: /\brk_live_[a-zA-Z0-9]{24,}\b/g,
+        severity: 'critical',
+        hint: 'Live Stripe restricted key (rk_live_...) must never appear in frontend code.',
+        cwe: 'CWE-312',
+    },
+    {
+        label: 'OpenAI API Key',
+        regex: /\bsk-proj-[a-zA-Z0-9_-]{40,}\b/g,
+        severity: 'critical',
+        hint: 'OpenAI project API key (sk-proj-...) exposed in client bundle. ' +
+            'Attackers can make unlimited API calls at your expense.',
+        cwe: 'CWE-312',
+    },
+    {
+        label: 'OpenAI Legacy API Key',
+        regex: /\bsk-[a-zA-Z0-9]{48,}\b/g,
+        severity: 'critical',
+        hint: 'OpenAI API key (sk-...) exposed in client bundle. Move to server-side proxy.',
+        cwe: 'CWE-312',
+    },
+    {
+        label: 'AWS Access Key ID',
+        regex: /\bAKIA[A-Z2-7]{16}\b/g,
+        severity: 'critical',
+        hint: 'AWS Access Key ID exposed in client bundle. This grants AWS API access.',
+        cwe: 'CWE-312',
+    },
+    {
+        label: 'GitHub Personal Access Token',
+        regex: /\bghp_[a-zA-Z0-9]{36,}\b/g,
+        severity: 'critical',
+        hint: 'GitHub PAT (ghp_...) in frontend code. Grants repo access to anyone who views bundle.',
+        cwe: 'CWE-312',
+    },
+    {
+        label: 'GitHub Fine-Grained PAT',
+        regex: /\bgithub_pat_[a-zA-Z0-9_]{55,}\b/g,
+        severity: 'critical',
+        hint: 'GitHub fine-grained PAT (github_pat_...) must never appear in frontend code.',
+        cwe: 'CWE-312',
+    },
+    {
+        label: 'Anthropic API Key',
+        regex: /\bsk-ant-api\d{2}-[a-zA-Z0-9_-]{90,}\b/g,
+        severity: 'critical',
+        hint: 'Anthropic API key exposed in client bundle. Move to a server-side proxy.',
+        cwe: 'CWE-312',
+    },
+    {
+        label: 'SendGrid API Key',
+        regex: /\bSG\.[a-zA-Z0-9_-]{22,}\.[a-zA-Z0-9_-]{43,}\b/g,
+        severity: 'critical',
+        hint: 'SendGrid API key exposed in client bundle. Attackers can send spam as you.',
+        cwe: 'CWE-312',
+    },
 ];
+/** Severity ordering for threshold comparison */
+const SEVERITY_ORDER = { critical: 0, high: 1, medium: 2, low: 3 };
+/**
+ * Extracts the env var name from a single-reference line.
+ *   process.env.VARNAME          → "VARNAME"
+ *   process.env["VARNAME"]       → "VARNAME"
+ *   import.meta.env.VARNAME      → "VARNAME"
+ * Returns null if no match.
+ */
+function extractEnvVarName(line, checkProcessEnv, checkImportMetaEnv) {
+    if (checkProcessEnv) {
+        const dot = line.match(/process\.env\.([A-Z][A-Z0-9_]*)/);
+        if (dot)
+            return dot[1];
+        const bracket = line.match(/process\.env\[['"]([A-Z][A-Z0-9_]*)['"]\]/);
+        if (bracket)
+            return bracket[1];
+    }
+    if (checkImportMetaEnv) {
+        const vite = line.match(/import\.meta\.env\.([A-Z_][A-Z0-9_]*)/);
+        if (vite)
+            return vite[1];
+    }
+    return null;
+}
+/**
+ * Finds all var names from destructuring:
+ *   const { STRIPE_SECRET_KEY, OPENAI_KEY } = process.env
+ */
+function extractDestructuredEnvVars(line) {
+    if (!/=\s*process\.env\b/.test(line))
+        return [];
+    const brace = line.match(/\{\s*([^}]+)\s*\}/);
+    if (!brace)
+        return [];
+    return brace[1]
+        .split(',')
+        .map(s => s.split(':')[0].trim()) // handle "SECRET_KEY: renamed"
+        .filter(s => /^[A-Z_][A-Z0-9_]*$/.test(s));
+}
 export class FrontendSecretExposureGate extends Gate {
-    config;
-    severityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
+    cfg;
+    secretNamePatterns;
+    safePrefixPatterns;
+    frontendPathPatterns;
+    serverPathPatterns;
     constructor(config = {}) {
-        super('frontend-secret-exposure', 'Frontend Secret Exposure Detection');
-        this.config = {
+        super('frontend-secret-exposure', 'Frontend Secret Exposure');
+        this.cfg = {
             enabled: config.enabled ?? true,
             block_on_severity: config.block_on_severity ?? 'high',
             check_process_env: config.check_process_env ?? true,
             check_import_meta_env: config.check_import_meta_env ?? true,
-            secret_env_name_patterns: config.secret_env_name_patterns ?? DEFAULT_SECRET_ENV_NAME_PATTERNS,
-            safe_public_prefixes: config.safe_public_prefixes ?? DEFAULT_SAFE_PUBLIC_PREFIXES,
-            frontend_path_patterns: config.frontend_path_patterns ?? DEFAULT_FRONTEND_PATH_PATTERNS,
-            server_path_patterns: config.server_path_patterns ?? DEFAULT_SERVER_PATH_PATTERNS,
+            secret_env_name_patterns: config.secret_env_name_patterns ?? [
+                '(?:^|_)(?:secret|private)(?:_|$)',
+                '(?:^|_)(?:token|api[_-]?key|access[_-]?key|client[_-]?secret|signing|webhook)(?:_|$)',
+                '(?:^|_)(?:db[_-]?url|database[_-]?url|connection[_-]?string)(?:_|$)',
+            ],
+            safe_public_prefixes: config.safe_public_prefixes ?? [
+                'NEXT_PUBLIC_', 'VITE_', 'PUBLIC_', 'NUXT_PUBLIC_', 'REACT_APP_',
+            ],
+            frontend_path_patterns: config.frontend_path_patterns ?? [
+                '(^|/)pages/(?!api/)',
+                '(^|/)components/',
+                '(^|/)src/components/',
+                '(^|/)src/views/',
+                '(^|/)src/app/',
+                '(^|/)app/(?!api/)',
+                '(^|/)views/',
+                '(^|/)public/',
+            ],
+            server_path_patterns: config.server_path_patterns ?? [
+                '(^|/)pages/api/',
+                '(^|/)src/pages/api/',
+                '(^|/)app/api/',
+                '(^|/)src/app/api/',
+                '\\.server\\.(?:ts|tsx|js|jsx|mjs|cjs)$',
+            ],
             allowlist_env_names: config.allowlist_env_names ?? [],
         };
+        this.secretNamePatterns = this.cfg.secret_env_name_patterns.map(p => new RegExp(p, 'i'));
+        // Escape prefix strings to safe regex literals
+        this.safePrefixPatterns = this.cfg.safe_public_prefixes.map(prefix => new RegExp(`^${prefix.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`));
+        this.frontendPathPatterns = this.cfg.frontend_path_patterns.map(p => new RegExp(p));
+        this.serverPathPatterns = this.cfg.server_path_patterns.map(p => new RegExp(p));
     }
     get provenance() { return 'security'; }
     async run(context) {
-        if (!this.config.enabled)
+        if (!this.cfg.enabled)
             return [];
+        const scanPatterns = context.patterns || ['**/*.{ts,tsx,js,jsx,mjs,cjs,vue,svelte}'];
         const files = await FileScanner.findFiles({
             cwd: context.cwd,
-            patterns: ['**/*.{ts,tsx,js,jsx,mjs,cjs}'],
-            ignore: [...(context.ignore || []), '**/node_modules/**', '**/dist/**', '**/build/**', '**/.next/**', '**/coverage/**'],
+            patterns: scanPatterns,
+            ignore: [
+                ...(context.ignore || []),
+                '**/node_modules/**', '**/dist/**', '**/build/**',
+                '**/.next/**', '**/coverage/**', '**/out/**',
+            ],
         });
-        const scanFiles = files.filter(file => !this.shouldSkipFile(file));
-        const findings = [];
-        Logger.info(`Frontend Secret Exposure Gate: Scanning ${scanFiles.length} files`);
-        for (const file of scanFiles) {
-            const fullPath = path.join(context.cwd, file);
-            let content = '';
+        // Skip test/fixture files — they routinely use dummy keys
+        const sourceFiles = files.filter(f => !this.isTestFile(f));
+        Logger.info(`Frontend Secret Exposure Gate: scanning ${sourceFiles.length} files`);
+        const exposures = [];
+        for (const file of sourceFiles) {
+            const fileContext = this.classifyFile(file);
+            if (fileContext === 'server')
+                continue;
             try {
-                content = await fs.readFile(fullPath, 'utf-8');
+                const fullPath = path.join(context.cwd, file);
+                const content = await fs.readFile(fullPath, 'utf-8');
+                // Skip files guarded by Next.js server-only import
+                if (/import\s+['"]server-only['"]/.test(content))
+                    continue;
+                this.scanFile(content, file, fileContext, exposures);
             }
             catch {
-                continue;
+                // Unreadable — skip silently
             }
-            if (!this.isClientBundled(file, content))
-                continue;
-            findings.push(...this.findEnvExposures(file, content));
         }
-        findings.sort((a, b) => this.severityOrder[a.severity] - this.severityOrder[b.severity]);
-        const threshold = this.severityOrder[this.config.block_on_severity];
-        return findings
-            .filter(f => this.severityOrder[f.severity] <= threshold)
-            .map(f => this.createFailure(`Potential frontend secret exposure: ${f.source}.${f.envVar} is referenced in client-bundled code.`, [f.file], 'Move secret usage to server-only code (API route/server action) and expose only public-safe values.', 'Security: Frontend Secret Exposure', f.line, f.line, f.severity));
+        return this.toFailures(exposures);
     }
-    shouldSkipFile(file) {
-        const normalized = file.replace(/\\/g, '/');
-        if (/\.(test|spec)\.(?:ts|tsx|js|jsx|mjs|cjs)$/i.test(normalized))
-            return true;
-        if (/\/(?:__tests__|tests|test|__test__|e2e|fixtures|mocks)\//.test(`/${normalized}`))
-            return true;
-        if (/\/(?:examples|studio-dist)\//.test(`/${normalized}`))
-            return true;
-        return false;
+    /** Classify a file path as frontend, server, or ambiguous based on config patterns. */
+    classifyFile(file) {
+        const n = file.replace(/\\/g, '/');
+        // Server paths take priority over frontend paths
+        if (this.serverPathPatterns.some(p => p.test(n)))
+            return 'server';
+        if (this.frontendPathPatterns.some(p => p.test(n)))
+            return 'frontend';
+        return 'ambiguous';
+    }
+    /** Test/fixture files are excluded — they legitimately contain dummy keys. */
+    isTestFile(file) {
+        const n = file.replace(/\\/g, '/');
+        return /\.(test|spec)\.(ts|tsx|js|jsx)$/.test(n)
+            || /\/__tests__\//.test(n)
+            || /\/(?:fixtures|mocks|stubs)\//.test(n);
     }
-    isClientBundled(file, content) {
-        const normalized = file.replace(/\\/g, '/');
-        if (this.matchesAnyPattern(normalized, this.config.server_path_patterns))
+    /**
+     * Check whether a var name looks like a server-side secret:
+     * - Matches at least one secret_env_name_pattern
+     * - Does NOT start with a safe public prefix
+     * - Is NOT in the user allowlist
+     */
+    isSecretVar(varName) {
+        if (this.cfg.allowlist_env_names.includes(varName))
             return false;
-        if (this.isServerOnlyContent(content))
+        if (this.safePrefixPatterns.some(p => p.test(varName)))
             return false;
-        if (/^\s*['"]use client['"]\s*;?/m.test(content))
-            return true;
-        if (this.matchesAnyPattern(normalized, this.config.frontend_path_patterns))
-            return true;
-        return false;
-    }
-    isServerOnlyContent(content) {
-        if (/from\s+['"]server-only['"]/.test(content))
-            return true;
-        if (/import\s+['"]server-only['"]/.test(content))
-            return true;
-        if (/export\s+async\s+function\s+getServerSideProps\s*\(/.test(content))
-            return true;
-        if (/export\s+async\s+function\s+getStaticProps\s*\(/.test(content))
-            return true;
-        if (/['"]use server['"]/.test(content))
-            return true;
-        return false;
-    }
-    findEnvExposures(file, content) {
-        const findings = [];
-        if (this.config.check_process_env) {
-            const processEnvRegex = /process\.env\.([A-Za-z_][A-Za-z0-9_]*)/g;
-            findings.push(...this.collectMatches(file, content, processEnvRegex, 'process.env'));
-        }
-        if (this.config.check_import_meta_env) {
-            const importMetaRegex = /import\.meta\.env\.([A-Za-z_][A-Za-z0-9_]*)/g;
-            findings.push(...this.collectMatches(file, content, importMetaRegex, 'import.meta.env'));
-        }
-        return findings;
+        return this.secretNamePatterns.some(p => p.test(varName));
     }
-    collectMatches(file, content, regex, source) {
-        const matches = [];
-        const scanRegex = new RegExp(regex.source, 'g');
-        for (const match of content.matchAll(scanRegex)) {
-            const envVar = match[1];
-            if (!this.isSecretLikeEnvName(envVar))
+    /** Scan one file for env-var references and literal key values. */
+    scanFile(content, file, fileContext, out) {
+        const lines = content.split('\n');
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            const lineNum = i + 1;
+            // Skip comment lines to avoid flagging docs/examples
+            const trimmed = line.trimStart();
+            if (trimmed.startsWith('//') ||
+                trimmed.startsWith('*') ||
+                trimmed.startsWith('#') ||
+                trimmed.startsWith('<!--'))
                 continue;
-            const startIndex = match.index ?? 0;
-            const beforeMatch = content.slice(0, startIndex);
-            const line = beforeMatch.split('\n').length;
-            matches.push({
-                file,
-                line,
-                envVar,
-                source,
-                severity: 'high',
-            });
-        }
-        return matches;
-    }
-    isSecretLikeEnvName(envVar) {
-        if (this.config.allowlist_env_names.includes(envVar))
-            return false;
-        if (this.config.safe_public_prefixes.some(prefix => envVar.startsWith(prefix)))
-            return false;
-        return this.config.secret_env_name_patterns.some(pattern => {
-            try {
-                return new RegExp(pattern, 'i').test(envVar);
+            // 1. Env-var name detection (process.env / import.meta.env)
+            if (this.cfg.check_process_env || this.cfg.check_import_meta_env) {
+                const single = extractEnvVarName(line, this.cfg.check_process_env, this.cfg.check_import_meta_env);
+                if (single && this.isSecretVar(single)) {
+                    out.push(this.makeEnvRefExposure(file, lineNum, line, single, fileContext));
+                }
+                // Destructuring: const { STRIPE_SECRET_KEY } = process.env
+                if (this.cfg.check_process_env) {
+                    for (const varName of extractDestructuredEnvVars(line)) {
+                        if (this.isSecretVar(varName)) {
+                            out.push(this.makeEnvRefExposure(file, lineNum, line, varName, fileContext));
+                        }
+                    }
+                }
             }
-            catch {
-                return false;
+            // 2. Literal API key detection
+            for (const pattern of LITERAL_KEY_PATTERNS) {
+                pattern.regex.lastIndex = 0;
+                let m;
+                while ((m = pattern.regex.exec(line)) !== null) {
+                    // Skip dummy/placeholder values and test-mode keys
+                    if (this.isDummyValue(m[0]))
+                        continue;
+                    if (/(?:sk_test_|pk_test_|_test_|_sandbox_)/i.test(m[0]))
+                        continue;
+                    out.push({
+                        file,
+                        line: lineNum,
+                        lineText: line.trim().slice(0, 80),
+                        varName: m[0].slice(0, 24) + (m[0].length > 24 ? '...' : ''),
+                        kind: 'literal',
+                        serviceLabel: pattern.label,
+                        hint: pattern.hint,
+                        cwe: pattern.cwe,
+                        severity: pattern.severity,
+                        fileContext,
+                    });
+                }
             }
-        });
+        }
     }
-    matchesAnyPattern(value, patterns) {
-        return patterns.some(pattern => {
-            try {
-                return new RegExp(pattern, 'i').test(value);
-            }
-            catch {
+    makeEnvRefExposure(file, line, lineText, varName, fileContext) {
+        // Definite frontend → critical; ambiguous → high (may be a shared util)
+        const severity = fileContext === 'frontend' ? 'critical' : 'high';
+        return {
+            file,
+            line,
+            lineText: lineText.trim().slice(0, 80),
+            varName,
+            kind: 'env-ref',
+            serviceLabel: 'Secret Env Var',
+            hint: `\`${varName}\` looks like a server-side secret but is referenced in a ` +
+                `client-bundled file. Use an API route (Next.js /api, Remix action, ` +
+                `Nuxt server route) to proxy calls instead of exposing the secret to the browser.`,
+            cwe: 'CWE-312',
+            severity,
+            fileContext,
+        };
+    }
+    /** Filters out trivial dummy/placeholder text to reduce false positives. */
+    isDummyValue(text) {
+        return /(?:example|placeholder|your[_-]|xxx+|dummy|fake|changeme)/i.test(text);
+    }
+    toFailures(exposures) {
+        if (exposures.length === 0)
+            return [];
+        const blockThreshold = SEVERITY_ORDER[this.cfg.block_on_severity];
+        // Deduplicate: same file + line + varName from parallel patterns
+        const seen = new Set();
+        const unique = exposures.filter(e => {
+            const key = `${e.file}:${e.line}:${e.varName}`;
+            if (seen.has(key))
                 return false;
-            }
+            seen.add(key);
+            return true;
         });
+        // Sort critical first
+        unique.sort((a, b) => SEVERITY_ORDER[a.severity] - SEVERITY_ORDER[b.severity]);
+        const failures = [];
+        for (const exp of unique) {
+            if (SEVERITY_ORDER[exp.severity] > blockThreshold)
+                continue;
+            const ctx = exp.fileContext === 'frontend' ? '[definite frontend]' : '[possible frontend]';
+            const kind = exp.kind === 'literal' ? 'literal key' : 'env var ref';
+            failures.push(this.createFailure(`[${exp.cwe}] ${exp.serviceLabel} (${kind}) in ${ctx} file — ` +
+                `\`${exp.varName}\` at line ${exp.line}`, [exp.file], exp.hint, `Security: Frontend Secret Exposure — ${exp.serviceLabel}`, exp.line, exp.line, exp.severity));
+        }
+        if (unique.length > 0 && failures.length === 0) {
+            Logger.info(`Frontend Secret Exposure: ${unique.length} issue(s) below ` +
+                `${this.cfg.block_on_severity} threshold`);
+        }
+        return failures;
     }
 }

package/dist/gates/hallucinated-imports.js

@@ -47,9 +47,11 @@ export class HallucinatedImportsGate extends Gate {
             return [];
         const failures = [];
         const hallucinated = [];
+        const defaultPatterns = ['**/*.{ts,js,tsx,jsx,py,go,rb,cs,rs,java,kt}'];
+        const scanPatterns = context.patterns || defaultPatterns;
         const files = await FileScanner.findFiles({
             cwd: context.cwd,
-            patterns: ['**/*.{ts,js,tsx,jsx,py,go,rb,cs,rs,java,kt}'],
+            patterns: scanPatterns,
             ignore: [...(context.ignore || []), '**/node_modules/**', '**/dist/**', '**/build/**',
                 '**/examples/**',
                 '**/studio-dist/**', '**/.next/**', '**/coverage/**',

package/dist/gates/inconsistent-error-handling.js

@@ -41,9 +41,10 @@ export class InconsistentErrorHandlingGate extends Gate {
             return [];
         const failures = [];
         const handlers = [];
+        const scanPatterns = context.patterns || ['**/*.{ts,js,tsx,jsx}'];
         const files = await FileScanner.findFiles({
             cwd: context.cwd,
-            patterns: ['**/*.{ts,js,tsx,jsx}'],
+            patterns: scanPatterns,
             ignore: [...(context.ignore || []), '**/node_modules/**', '**/dist/**', '**/*.test.*', '**/*.spec.*'],
         });
         Logger.info(`Inconsistent Error Handling: Scanning ${files.length} files`);

package/dist/gates/phantom-apis.js

@@ -45,9 +45,11 @@ export class PhantomApisGate extends Gate {
             return [];
         const failures = [];
         const phantoms = [];
+        const defaultPatterns = ['**/*.{ts,js,tsx,jsx,py,go,cs,java,kt}'];
+        const scanPatterns = context.patterns || defaultPatterns;
         const files = await FileScanner.findFiles({
             cwd: context.cwd,
-            patterns: ['**/*.{ts,js,tsx,jsx,py,go,cs,java,kt}'],
+            patterns: scanPatterns,
             ignore: [...(context.ignore || []), '**/node_modules/**', '**/dist/**', '**/build/**',
                 '**/*.test.*', '**/*.spec.*', '**/__tests__/**',
                 '**/.venv/**', '**/venv/**', '**/vendor/**', '**/__pycache__/**',

package/dist/gates/promise-safety-helpers.js

@@ -39,7 +39,7 @@ export function extractIndentedBody(content, startIdx) {
 }
 export function isInsideTryBlock(lines, lineIdx) {
     let braceDepth = 0;
-    for (let j = lineIdx - 1; j >= Math.max(0, lineIdx - 30); j--) {
+    for (let j = lineIdx - 1; j >= Math.max(0, lineIdx - 100); j--) {
         const prevLine = stripStrings(lines[j]);
         for (const ch of prevLine) {
             if (ch === '}')
@@ -56,7 +56,7 @@ export function isInsideTryBlock(lines, lineIdx) {
 }
 export function isInsidePythonTry(lines, lineIdx) {
     const lineIndent = lines[lineIdx].length - lines[lineIdx].trimStart().length;
-    for (let j = lineIdx - 1; j >= Math.max(0, lineIdx - 30); j--) {
+    for (let j = lineIdx - 1; j >= Math.max(0, lineIdx - 100); j--) {
         const trimmed = lines[j].trim();
         if (trimmed === '')
             continue;
@@ -71,7 +71,7 @@ export function isInsidePythonTry(lines, lineIdx) {
     return false;
 }
 export function isInsideRubyRescue(lines, lineIdx) {
-    for (let j = lineIdx - 1; j >= Math.max(0, lineIdx - 30); j--) {
+    for (let j = lineIdx - 1; j >= Math.max(0, lineIdx - 100); j--) {
         const trimmed = lines[j].trim();
         if (trimmed === 'begin')
             return true;
@@ -83,14 +83,14 @@ export function isInsideRubyRescue(lines, lineIdx) {
     return false;
 }
 export function hasCatchAhead(lines, idx) {
-    for (let j = idx; j < Math.min(idx + 10, lines.length); j++) {
+    for (let j = idx; j < Math.min(idx + 50, lines.length); j++) {
         if (/\.catch\s*\(/.test(lines[j]))
             return true;
     }
     return false;
 }
 export function hasStatusCheckAhead(lines, idx) {
-    for (let j = idx; j < Math.min(idx + 10, lines.length); j++) {
+    for (let j = idx; j < Math.min(idx + 50, lines.length); j++) {
         if (/\.\s*ok\b/.test(lines[j]) || /\.status(?:Text)?\b/.test(lines[j]))
             return true;
     }

package/dist/gates/promise-safety.js

@@ -36,9 +36,10 @@ export class PromiseSafetyGate extends Gate {
             return [];
         const violations = [];
         const allPatterns = Object.values(LANG_GLOBS).flat();
+        const scanPatterns = context.patterns || allPatterns;
         const files = await FileScanner.findFiles({
             cwd: context.cwd,
-            patterns: allPatterns,
+            patterns: scanPatterns,
             ignore: [...(context.ignore || []), '**/node_modules/**', '**/dist/**', '**/build/**',
                 '**/*.test.*', '**/*.spec.*', '**/vendor/**', '**/__pycache__/**',
                 '**/bin/Debug/**', '**/bin/Release/**', '**/obj/**', '**/venv/**', '**/.venv/**'],
@@ -87,7 +88,7 @@ export class PromiseSafetyGate extends Gate {
             if (!/\.then\s*\(/.test(line))
                 continue;
             let hasCatch = false;
-            for (let j = i; j < Math.min(i + 10, lines.length); j++) {
+            for (let j = i; j < Math.min(i + 50, lines.length); j++) {
                 const lookahead = this.sanitizeLine(lines[j]);
                 if (/\.catch\s*\(/.test(lookahead)) {
                     hasCatch = true;
@@ -209,7 +210,7 @@ export class PromiseSafetyGate extends Gate {
             if (!httpPatterns.test(lines[i]) || isInsidePythonTry(lines, i))
                 continue;
             let hasCheck = false;
-            for (let j = i; j < Math.min(i + 10, lines.length); j++) {
+            for (let j = i; j < Math.min(i + 50, lines.length); j++) {
                 if (/raise_for_status|status_code/.test(lines[j])) {
                     hasCheck = true;
                     break;
@@ -317,7 +318,7 @@ export class PromiseSafetyGate extends Gate {
         for (let i = 0; i < lines.length; i++) {
             if (/\.(?:GetAsync|PostAsync|SendAsync)\s*\(/.test(lines[i]) && !isInsideTryBlock(lines, i)) {
                 let hasCheck = false;
-                for (let j = i; j < Math.min(i + 10, lines.length); j++) {
+                for (let j = i; j < Math.min(i + 50, lines.length); j++) {
                     if (/EnsureSuccess|IsSuccessStatusCode|StatusCode/.test(lines[j])) {
                         hasCheck = true;
                         break;

package/dist/gates/runner.js

@@ -199,13 +199,13 @@ export class GateRunner {
                 }
                 const isLocalDeepExecution = !deepOptions.apiKey || (deepOptions.provider || '').toLowerCase() === 'local';
                 const deepTier = isLocalDeepExecution
-                    ? (deepOptions.pro ? 'pro' : 'deep')
+                    ? (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.pro ? 'Qwen2.5-Coder-1.5B' : 'Qwen3.5-0.8B')
                         : (deepOptions.modelName || deepOptions.provider || 'cloud'),
                     total_ms: Date.now() - deepSetupStart,
                     findings_count: deepFailures.length,

package/dist/gates/runner.test.js

@@ -25,7 +25,7 @@ describe('GateRunner deep stats execution mode', () => {
             },
         });
     }
-    it('reports local deep tier when provider=local even with apiKey', async () => {
+    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, {
@@ -34,10 +34,10 @@ describe('GateRunner deep stats execution mode', () => {
             provider: 'local',
             pro: false,
         });
-        expect(report.stats.deep?.tier).toBe('deep');
-        expect(report.stats.deep?.model).toBe('Qwen2.5-Coder-0.5B');
+        expect(report.stats.deep?.tier).toBe('lite');
+        expect(report.stats.deep?.model).toBe('Qwen3.5-0.8B');
     });
-    it('reports local pro tier when provider=local and pro=true', async () => {
+    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, {
@@ -46,7 +46,7 @@ describe('GateRunner deep stats execution mode', () => {
             provider: 'local',
             pro: true,
         });
-        expect(report.stats.deep?.tier).toBe('pro');
+        expect(report.stats.deep?.tier).toBe('deep');
         expect(report.stats.deep?.model).toBe('Qwen2.5-Coder-1.5B');
     });
     it('reports cloud tier/model for cloud providers', async () => {

package/dist/gates/security-patterns.js

@@ -251,9 +251,10 @@ export class SecurityPatternsGate extends Gate {
         }
         const failures = [];
         const vulnerabilities = [];
+        const scanPatterns = context.patterns || ['**/*.{ts,js,tsx,jsx,py,java,go}'];
         const files = await FileScanner.findFiles({
             cwd: context.cwd,
-            patterns: ['**/*.{ts,js,tsx,jsx,py,java,go}'],
+            patterns: scanPatterns,
             ignore: [...(context.ignore || []), '**/node_modules/**', '**/dist/**', '**/build/**', '**/.next/**', '**/coverage/**'],
         });
         const scanFiles = files.filter(file => !this.shouldSkipSecurityFile(file));

package/dist/gates/side-effect-analysis.js

@@ -73,9 +73,10 @@ export class SideEffectAnalysisGate extends Gate {
         if (!this.cfg.enabled)
             return [];
         const violations = [];
+        const scanPatterns = context.patterns || FILE_GLOBS;
         const files = await FileScanner.findFiles({
             cwd: context.cwd,
-            patterns: FILE_GLOBS,
+            patterns: scanPatterns,
             ignore: [
                 ...(context.ignore || []),
                 '**/node_modules/**', '**/dist/**', '**/build/**',

package/dist/gates/test-quality.js

@@ -50,16 +50,18 @@ export class TestQualityGate extends Gate {
             return [];
         const failures = [];
         const issues = [];
+        const defaultPatterns = [
+            '**/*.test.{ts,js,tsx,jsx}', '**/*.spec.{ts,js,tsx,jsx}',
+            '**/__tests__/**/*.{ts,js,tsx,jsx}',
+            '**/test_*.py', '**/*_test.py', '**/tests/**/*.py',
+            '**/*_test.go',
+            '**/*Test.java', '**/*Tests.java', '**/src/test/**/*.java',
+            '**/*Test.kt', '**/*Tests.kt', '**/src/test/**/*.kt',
+        ];
+        const scanPatterns = context.patterns || defaultPatterns;
         const files = await FileScanner.findFiles({
             cwd: context.cwd,
-            patterns: [
-                '**/*.test.{ts,js,tsx,jsx}', '**/*.spec.{ts,js,tsx,jsx}',
-                '**/__tests__/**/*.{ts,js,tsx,jsx}',
-                '**/test_*.py', '**/*_test.py', '**/tests/**/*.py',
-                '**/*_test.go',
-                '**/*Test.java', '**/*Tests.java', '**/src/test/**/*.java',
-                '**/*Test.kt', '**/*Tests.kt', '**/src/test/**/*.kt',
-            ],
+            patterns: scanPatterns,
             ignore: [...(context.ignore || []), '**/node_modules/**', '**/dist/**', '**/build/**',
                 '**/.venv/**', '**/venv/**', '**/vendor/**',
                 '**/target/**', '**/.gradle/**', '**/out/**'],

package/dist/inference/cloud-provider.js

@@ -2,13 +2,13 @@
 const DEFAULT_MODELS = {
     claude: 'claude-opus-4-6',
     anthropic: 'claude-sonnet-4-6',
-    openai: 'gpt-4o-mini',
-    gemini: 'gemini-3-flash',
-    groq: 'llama-3.1-70b-versatile',
+    openai: 'gpt-5-mini',
+    gemini: 'gemini-2.5-flash',
+    groq: 'llama-3.3-70b-versatile',
     mistral: 'mistral-large-latest',
-    together: 'meta-llama/Llama-3.1-70B-Instruct-Turbo',
-    fireworks: 'accounts/fireworks/models/llama-v3p1-70b-instruct',
-    deepseek: 'deepseek-coder',
+    together: 'meta-llama/Llama-4-Maverick-17B-128E-Instruct-FP8',
+    fireworks: 'accounts/fireworks/models/llama-v3p3-70b-instruct',
+    deepseek: 'deepseek-v4',
     perplexity: 'llama-3.1-sonar-large-128k-online',
     ollama: 'qwen2.5-coder:7b',
     lmstudio: 'qwen2.5-coder-7b-instruct',

package/dist/inference/index.js

@@ -18,6 +18,8 @@ export function createProvider(options) {
         });
     }
     // Default: local sidecar
-    const tier = options.pro ? 'pro' : 'deep';
+    // deep = Qwen2.5-Coder-1.5B (full power, company-hosted)
+    // lite = Qwen3.5-0.8B (lightweight, default CLI sidecar)
+    const tier = options.pro ? 'deep' : 'lite';
     return new SidecarProvider(tier);
 }

package/dist/inference/model-manager.d.ts

@@ -13,9 +13,17 @@ export declare function getModelPath(tier: ModelTier): string;
  * Get model info for a tier.
  */
 export declare function getModelInfo(tier: ModelTier): ModelInfo;
+/**
+ * Check HuggingFace for a newer model version (like antivirus signature updates).
+ * Reads latest_version.json from the RLAIF dataset repo. Non-blocking — if the
+ * check fails (offline, HF down), we silently use the cached/bundled version.
+ *
+ * Results are cached locally for 24 hours to avoid hammering HF on every run.
+ */
+export declare function checkForUpdates(onProgress?: (message: string, percent?: number) => void): Promise<string>;
 /**
  * Download a model from HuggingFace CDN.
- * Tries fine-tuned model first, falls back to stock Qwen if unavailable.
+ * Checks for updates first, then tries fine-tuned model, falls back to stock Qwen.
  */
 export declare function downloadModel(tier: ModelTier, onProgress?: (message: string, percent?: number) => void): Promise<string>;
 /**

package/dist/inference/model-manager.js

@@ -6,8 +6,11 @@ import path from 'path';
 import fs from 'fs-extra';
 import { createHash } from 'crypto';
 import { RIGOUR_DIR } from '../storage/db.js';
-import { MODELS, FALLBACK_MODELS } from './types.js';
+import { MODELS, FALLBACK_MODELS, VERSION_CHECK_URL, BUNDLED_MODEL_VERSION, updateModelVersion } from './types.js';
 const MODELS_DIR = path.join(RIGOUR_DIR, 'models');
+const VERSION_CACHE_PATH = path.join(MODELS_DIR, '.latest_version.json');
+const VERSION_CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000; // Check once per day
+const VERSION_CHECK_TIMEOUT_MS = 5000; // 5s timeout — don't block startup
 const SHA256_RE = /^[a-f0-9]{64}$/i;
 function getModelMetadataPath(filename) {
     return path.join(MODELS_DIR, filename + '.meta.json');
@@ -173,12 +176,66 @@ async function downloadFromUrl(tier, model, onProgress) {
         throw error;
     }
 }
+/**
+ * Check HuggingFace for a newer model version (like antivirus signature updates).
+ * Reads latest_version.json from the RLAIF dataset repo. Non-blocking — if the
+ * check fails (offline, HF down), we silently use the cached/bundled version.
+ *
+ * Results are cached locally for 24 hours to avoid hammering HF on every run.
+ */
+export async function checkForUpdates(onProgress) {
+    fs.ensureDirSync(MODELS_DIR);
+    // Check local version cache first — avoid network on every run
+    try {
+        if (await fs.pathExists(VERSION_CACHE_PATH)) {
+            const cached = await fs.readJson(VERSION_CACHE_PATH);
+            const age = Date.now() - new Date(cached.checkedAt).getTime();
+            if (age < VERSION_CHECK_INTERVAL_MS && cached.version) {
+                const v = String(cached.version);
+                updateModelVersion(v);
+                return v;
+            }
+        }
+    }
+    catch {
+        // Corrupted cache — proceed to network check
+    }
+    // Fetch latest version from HuggingFace (with timeout)
+    try {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), VERSION_CHECK_TIMEOUT_MS);
+        const response = await fetch(VERSION_CHECK_URL, { signal: controller.signal });
+        clearTimeout(timeout);
+        if (response.ok) {
+            const data = await response.json();
+            const latestVersion = String(data.version || BUNDLED_MODEL_VERSION);
+            // Cache the result locally
+            await fs.writeJson(VERSION_CACHE_PATH, {
+                version: latestVersion,
+                checkedAt: new Date().toISOString(),
+                source: 'huggingface',
+            }, { spaces: 2 }).catch(() => { });
+            // Update in-memory model definitions
+            updateModelVersion(latestVersion);
+            if (latestVersion !== BUNDLED_MODEL_VERSION) {
+                onProgress?.(`Model update available: v${latestVersion}`, 0);
+            }
+            return latestVersion;
+        }
+    }
+    catch {
+        // Offline / HF down / timeout — use bundled version silently
+    }
+    return BUNDLED_MODEL_VERSION;
+}
 /**
  * Download a model from HuggingFace CDN.
- * Tries fine-tuned model first, falls back to stock Qwen if unavailable.
+ * Checks for updates first, then tries fine-tuned model, falls back to stock Qwen.
  */
 export async function downloadModel(tier, onProgress) {
     fs.ensureDirSync(MODELS_DIR);
+    // Check for newer model version (non-blocking, cached 24h)
+    await checkForUpdates(onProgress);
     if (await isModelCached(tier)) {
         onProgress?.(`Model ${MODELS[tier].name} already cached`, 100);
         return getModelPath(tier);

package/dist/inference/sidecar-provider.js

@@ -27,7 +27,7 @@ export class SidecarProvider {
     modelPath = null;
     tier;
     threads;
-    constructor(tier = 'deep', threads = 4) {
+    constructor(tier = 'lite', threads = 4) {
         this.tier = tier;
         this.threads = threads;
     }

package/dist/inference/types.d.ts

@@ -60,8 +60,12 @@ export interface DeepAnalysisResult {
 }
 /**
  * Available model tiers.
+ *
+ * - deep: Qwen2.5-Coder-1.5B fine-tuned — full power, company-hosted
+ * - lite: Qwen2.5-Coder-0.5B fine-tuned — lightweight, ships as default CLI sidecar
+ * - legacy: Qwen2.5-Coder-0.5B fine-tuned — previous default, reproducibility
  */
-export type ModelTier = 'deep' | 'pro';
+export type ModelTier = 'deep' | 'lite' | 'legacy';
 /**
  * Model info for download/caching.
  */
@@ -74,13 +78,24 @@ export interface ModelInfo {
     sizeHuman: string;
 }
 /**
- * Model version — bump when new fine-tuned GGUF is published.
- * The RLAIF pipeline uploads new models to HuggingFace, and
- * model-manager checks this version to auto-update.
+ * Minimum bundled model version — used as fallback when the auto-update
+ * check fails (offline, HF down, first run). The RLAIF training pipeline
+ * publishes new versions to HuggingFace and updates latest_version.json.
+ * At startup, model-manager checks HF for the latest version and downloads
+ * it automatically (like antivirus signature updates).
  */
-export declare const MODEL_VERSION = "1";
-/** All supported model definitions */
+export declare const BUNDLED_MODEL_VERSION = "1";
+/** HuggingFace dataset repo where latest_version.json lives */
+export declare const VERSION_CHECK_URL = "https://huggingface.co/datasets/rigour-labs/rigour-rlaif-data/resolve/main/latest_version.json";
+/** Build model info for a given tier and version */
+export declare function buildModelInfo(tier: ModelTier, version: string): ModelInfo;
+/** Current model definitions — initialized with bundled version, updated at runtime */
 export declare const MODELS: Record<ModelTier, ModelInfo>;
+/**
+ * Update MODELS in-place to point to a newer version.
+ * Called by model-manager after checking latest_version.json.
+ */
+export declare function updateModelVersion(version: string): void;
 /**
  * Fallback stock models — used when fine-tuned model is not yet
  * available on HuggingFace (initial setup / first-time users).

package/dist/inference/types.js

@@ -1,28 +1,46 @@
 /**
- * Model version — bump when new fine-tuned GGUF is published.
- * The RLAIF pipeline uploads new models to HuggingFace, and
- * model-manager checks this version to auto-update.
+ * Minimum bundled model version — used as fallback when the auto-update
+ * check fails (offline, HF down, first run). The RLAIF training pipeline
+ * publishes new versions to HuggingFace and updates latest_version.json.
+ * At startup, model-manager checks HF for the latest version and downloads
+ * it automatically (like antivirus signature updates).
  */
-export const MODEL_VERSION = '1';
-/** All supported model definitions */
+export const BUNDLED_MODEL_VERSION = '1';
+/** HuggingFace dataset repo where latest_version.json lives */
+export const VERSION_CHECK_URL = 'https://huggingface.co/datasets/rigour-labs/rigour-rlaif-data/resolve/main/latest_version.json';
+/** Build model info for a given tier and version */
+export function buildModelInfo(tier, version) {
+    const meta = {
+        deep: { base: 'Qwen2.5-Coder-1.5B', size: 900_000_000, sizeH: '900MB' },
+        lite: { base: 'Qwen2.5-Coder-0.5B', size: 500_000_000, sizeH: '500MB' },
+        legacy: { base: 'Qwen2.5-Coder-0.5B', size: 350_000_000, sizeH: '350MB' },
+    };
+    const m = meta[tier];
+    return {
+        tier,
+        name: `Rigour-${tier[0].toUpperCase() + tier.slice(1)}-v${version} (${m.base} fine-tuned)`,
+        filename: `rigour-${tier}-v${version}-q4_k_m.gguf`,
+        url: `https://huggingface.co/rigour-labs/rigour-${tier}-v${version}-gguf/resolve/main/rigour-${tier}-v${version}-q4_k_m.gguf`,
+        sizeBytes: m.size,
+        sizeHuman: m.sizeH,
+    };
+}
+/** Current model definitions — initialized with bundled version, updated at runtime */
 export const MODELS = {
-    deep: {
-        tier: 'deep',
-        name: 'Rigour-Deep-v1 (Qwen2.5-Coder-0.5B fine-tuned)',
-        filename: `rigour-deep-v${MODEL_VERSION}-q4_k_m.gguf`,
-        url: `https://huggingface.co/rigour-labs/rigour-deep-v1-gguf/resolve/main/rigour-deep-v${MODEL_VERSION}-q4_k_m.gguf`,
-        sizeBytes: 350_000_000,
-        sizeHuman: '350MB',
-    },
-    pro: {
-        tier: 'pro',
-        name: 'Rigour-Pro-v1 (Qwen2.5-Coder-1.5B fine-tuned)',
-        filename: `rigour-pro-v${MODEL_VERSION}-q4_k_m.gguf`,
-        url: `https://huggingface.co/rigour-labs/rigour-pro-v1-gguf/resolve/main/rigour-pro-v${MODEL_VERSION}-q4_k_m.gguf`,
-        sizeBytes: 900_000_000,
-        sizeHuman: '900MB',
-    },
+    deep: buildModelInfo('deep', BUNDLED_MODEL_VERSION),
+    lite: buildModelInfo('lite', BUNDLED_MODEL_VERSION),
+    legacy: buildModelInfo('legacy', BUNDLED_MODEL_VERSION),
 };
+/**
+ * Update MODELS in-place to point to a newer version.
+ * Called by model-manager after checking latest_version.json.
+ */
+export function updateModelVersion(version) {
+    for (const tier of ['deep', 'lite', 'legacy']) {
+        const updated = buildModelInfo(tier, version);
+        MODELS[tier] = updated;
+    }
+}
 /**
  * Fallback stock models — used when fine-tuned model is not yet
  * available on HuggingFace (initial setup / first-time users).
@@ -30,18 +48,26 @@ export const MODELS = {
 export const FALLBACK_MODELS = {
     deep: {
         tier: 'deep',
-        name: 'Qwen2.5-Coder-0.5B-Instruct (stock)',
-        filename: 'qwen2.5-coder-0.5b-instruct-q4_k_m.gguf',
-        url: 'https://huggingface.co/Qwen/Qwen2.5-Coder-0.5B-Instruct-GGUF/resolve/main/qwen2.5-coder-0.5b-instruct-q4_k_m.gguf',
-        sizeBytes: 350_000_000,
-        sizeHuman: '350MB',
-    },
-    pro: {
-        tier: 'pro',
         name: 'Qwen2.5-Coder-1.5B-Instruct (stock)',
         filename: 'qwen2.5-coder-1.5b-instruct-q4_k_m.gguf',
         url: 'https://huggingface.co/Qwen/Qwen2.5-Coder-1.5B-Instruct-GGUF/resolve/main/qwen2.5-coder-1.5b-instruct-q4_k_m.gguf',
         sizeBytes: 900_000_000,
         sizeHuman: '900MB',
     },
+    lite: {
+        tier: 'lite',
+        name: 'Qwen2.5-Coder-0.5B-Instruct (stock)',
+        filename: 'qwen2.5-coder-0.5b-instruct-q4_k_m.gguf',
+        url: 'https://huggingface.co/Qwen/Qwen2.5-Coder-0.5B-Instruct-GGUF/resolve/main/qwen2.5-coder-0.5b-instruct-q4_k_m.gguf',
+        sizeBytes: 500_000_000,
+        sizeHuman: '500MB',
+    },
+    legacy: {
+        tier: 'legacy',
+        name: 'Qwen2.5-Coder-0.5B-Instruct (stock)',
+        filename: 'qwen2.5-coder-0.5b-instruct-q4_k_m.gguf',
+        url: 'https://huggingface.co/Qwen/Qwen2.5-Coder-0.5B-Instruct-GGUF/resolve/main/qwen2.5-coder-0.5b-instruct-q4_k_m.gguf',
+        sizeBytes: 350_000_000,
+        sizeHuman: '350MB',
+    },
 };

package/dist/types/index.d.ts

@@ -2748,7 +2748,7 @@ export declare const ReportSchema: z.ZodObject<{
         }>>;
         deep: z.ZodOptional<z.ZodObject<{
             enabled: z.ZodBoolean;
-            tier: z.ZodOptional<z.ZodEnum<["deep", "pro", "cloud"]>>;
+            tier: z.ZodOptional<z.ZodEnum<["deep", "lite", "legacy", "cloud"]>>;
             model: z.ZodOptional<z.ZodString>;
             total_ms: z.ZodOptional<z.ZodNumber>;
             files_analyzed: z.ZodOptional<z.ZodNumber>;
@@ -2756,7 +2756,7 @@ export declare const ReportSchema: z.ZodObject<{
             findings_verified: z.ZodOptional<z.ZodNumber>;
         }, "strip", z.ZodTypeAny, {
             enabled: boolean;
-            tier?: "deep" | "pro" | "cloud" | undefined;
+            tier?: "deep" | "lite" | "legacy" | "cloud" | undefined;
             model?: string | undefined;
             total_ms?: number | undefined;
             files_analyzed?: number | undefined;
@@ -2764,7 +2764,7 @@ export declare const ReportSchema: z.ZodObject<{
             findings_verified?: number | undefined;
         }, {
             enabled: boolean;
-            tier?: "deep" | "pro" | "cloud" | undefined;
+            tier?: "deep" | "lite" | "legacy" | "cloud" | undefined;
             model?: string | undefined;
             total_ms?: number | undefined;
             files_analyzed?: number | undefined;
@@ -2775,7 +2775,7 @@ export declare const ReportSchema: z.ZodObject<{
         duration_ms: number;
         deep?: {
             enabled: boolean;
-            tier?: "deep" | "pro" | "cloud" | undefined;
+            tier?: "deep" | "lite" | "legacy" | "cloud" | undefined;
             model?: string | undefined;
             total_ms?: number | undefined;
             files_analyzed?: number | undefined;
@@ -2798,7 +2798,7 @@ export declare const ReportSchema: z.ZodObject<{
         duration_ms: number;
         deep?: {
             enabled: boolean;
-            tier?: "deep" | "pro" | "cloud" | undefined;
+            tier?: "deep" | "lite" | "legacy" | "cloud" | undefined;
             model?: string | undefined;
             total_ms?: number | undefined;
             files_analyzed?: number | undefined;
@@ -2823,7 +2823,7 @@ export declare const ReportSchema: z.ZodObject<{
         duration_ms: number;
         deep?: {
             enabled: boolean;
-            tier?: "deep" | "pro" | "cloud" | undefined;
+            tier?: "deep" | "lite" | "legacy" | "cloud" | undefined;
             model?: string | undefined;
             total_ms?: number | undefined;
             files_analyzed?: number | undefined;
@@ -2865,7 +2865,7 @@ export declare const ReportSchema: z.ZodObject<{
         duration_ms: number;
         deep?: {
             enabled: boolean;
-            tier?: "deep" | "pro" | "cloud" | undefined;
+            tier?: "deep" | "lite" | "legacy" | "cloud" | undefined;
             model?: string | undefined;
             total_ms?: number | undefined;
             files_analyzed?: number | undefined;

package/dist/types/index.js

@@ -383,7 +383,7 @@ export const ReportSchema = z.object({
         }).optional(),
         deep: z.object({
             enabled: z.boolean(),
-            tier: z.enum(['deep', 'pro', 'cloud']).optional(),
+            tier: z.enum(['deep', 'lite', 'legacy', 'cloud']).optional(),
             model: z.string().optional(),
             total_ms: z.number().optional(),
             files_analyzed: z.number().optional(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rigour-labs/core",
-  "version": "4.3.2",
+  "version": "4.3.4",
   "description": "Deterministic quality gate engine for AI-generated code. AST analysis, drift detection, and Fix Packet generation across TypeScript, JavaScript, Python, Go, Ruby, and C#.",
   "license": "MIT",
   "homepage": "https://rigour.run",
@@ -59,11 +59,11 @@
     "@xenova/transformers": "^2.17.2",
     "better-sqlite3": "^11.0.0",
     "openai": "^4.104.0",
-    "@rigour-labs/brain-darwin-arm64": "4.3.2",
-    "@rigour-labs/brain-linux-arm64": "4.3.2",
-    "@rigour-labs/brain-darwin-x64": "4.3.2",
-    "@rigour-labs/brain-win-x64": "4.3.2",
-    "@rigour-labs/brain-linux-x64": "4.3.2"
+    "@rigour-labs/brain-darwin-arm64": "4.3.4",
+    "@rigour-labs/brain-darwin-x64": "4.3.4",
+    "@rigour-labs/brain-linux-x64": "4.3.4",
+    "@rigour-labs/brain-linux-arm64": "4.3.4",
+    "@rigour-labs/brain-win-x64": "4.3.4"
   },
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.12",