@rigour-labs/core 6.2.4 → 6.2.5

package/dist/types/index.d.ts

@@ -573,9 +573,9 @@ export declare const GatesSchema: z.ZodObject<{
         model_name: z.ZodOptional<z.ZodString>;
         model_path: z.ZodOptional<z.ZodString>;
         threads: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-        max_tokens: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        max_tokens: z.ZodOptional<z.ZodNumber>;
         temperature: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-        timeout_ms: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        timeout_ms: z.ZodOptional<z.ZodNumber>;
         checks: z.ZodDefault<z.ZodOptional<z.ZodObject<{
             solid: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
             dry: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
@@ -609,9 +609,7 @@ export declare const GatesSchema: z.ZodObject<{
         pro: boolean;
         provider: string;
         threads: number;
-        max_tokens: number;
         temperature: number;
-        timeout_ms: number;
         checks: {
             architecture: boolean;
             test_quality: boolean;
@@ -626,6 +624,8 @@ export declare const GatesSchema: z.ZodObject<{
         api_base_url?: string | undefined;
         model_name?: string | undefined;
         model_path?: string | undefined;
+        max_tokens?: number | undefined;
+        timeout_ms?: number | undefined;
     }, {
         enabled?: boolean | undefined;
         pro?: boolean | undefined;
@@ -655,9 +655,7 @@ export declare const GatesSchema: z.ZodObject<{
         pro: boolean;
         provider: string;
         threads: number;
-        max_tokens: number;
         temperature: number;
-        timeout_ms: number;
         checks: {
             architecture: boolean;
             test_quality: boolean;
@@ -672,6 +670,8 @@ export declare const GatesSchema: z.ZodObject<{
         api_base_url?: string | undefined;
         model_name?: string | undefined;
         model_path?: string | undefined;
+        max_tokens?: number | undefined;
+        timeout_ms?: number | undefined;
     };
     max_file_lines: number;
     forbid_todos: boolean;
@@ -1739,9 +1739,9 @@ export declare const ConfigSchema: z.ZodObject<{
             model_name: z.ZodOptional<z.ZodString>;
             model_path: z.ZodOptional<z.ZodString>;
             threads: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-            max_tokens: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            max_tokens: z.ZodOptional<z.ZodNumber>;
             temperature: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-            timeout_ms: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            timeout_ms: z.ZodOptional<z.ZodNumber>;
             checks: z.ZodDefault<z.ZodOptional<z.ZodObject<{
                 solid: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
                 dry: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
@@ -1775,9 +1775,7 @@ export declare const ConfigSchema: z.ZodObject<{
             pro: boolean;
             provider: string;
             threads: number;
-            max_tokens: number;
             temperature: number;
-            timeout_ms: number;
             checks: {
                 architecture: boolean;
                 test_quality: boolean;
@@ -1792,6 +1790,8 @@ export declare const ConfigSchema: z.ZodObject<{
             api_base_url?: string | undefined;
             model_name?: string | undefined;
             model_path?: string | undefined;
+            max_tokens?: number | undefined;
+            timeout_ms?: number | undefined;
         }, {
             enabled?: boolean | undefined;
             pro?: boolean | undefined;
@@ -1821,9 +1821,7 @@ export declare const ConfigSchema: z.ZodObject<{
             pro: boolean;
             provider: string;
             threads: number;
-            max_tokens: number;
             temperature: number;
-            timeout_ms: number;
             checks: {
                 architecture: boolean;
                 test_quality: boolean;
@@ -1838,6 +1836,8 @@ export declare const ConfigSchema: z.ZodObject<{
             api_base_url?: string | undefined;
             model_name?: string | undefined;
             model_path?: string | undefined;
+            max_tokens?: number | undefined;
+            timeout_ms?: number | undefined;
         };
         max_file_lines: number;
         forbid_todos: boolean;
@@ -2319,9 +2319,7 @@ export declare const ConfigSchema: z.ZodObject<{
             pro: boolean;
             provider: string;
             threads: number;
-            max_tokens: number;
             temperature: number;
-            timeout_ms: number;
             checks: {
                 architecture: boolean;
                 test_quality: boolean;
@@ -2336,6 +2334,8 @@ export declare const ConfigSchema: z.ZodObject<{
             api_base_url?: string | undefined;
             model_name?: string | undefined;
             model_path?: string | undefined;
+            max_tokens?: number | undefined;
+            timeout_ms?: number | undefined;
         };
         max_file_lines: number;
         forbid_todos: boolean;
@@ -2944,26 +2944,45 @@ export declare const ReportSchema: z.ZodObject<{
         }>>;
         deep: z.ZodOptional<z.ZodObject<{
             enabled: z.ZodBoolean;
+            /** ok: every inference ran; partial: some failed; error: deep did not run. */
+            status: z.ZodOptional<z.ZodEnum<["ok", "partial", "error"]>>;
+            mode: z.ZodOptional<z.ZodEnum<["facts", "code"]>>;
             tier: z.ZodOptional<z.ZodEnum<["deep", "lite", "legacy", "cloud"]>>;
             model: z.ZodOptional<z.ZodString>;
+            model_fallback: z.ZodOptional<z.ZodBoolean>;
             total_ms: z.ZodOptional<z.ZodNumber>;
             files_analyzed: z.ZodOptional<z.ZodNumber>;
+            chunks_total: z.ZodOptional<z.ZodNumber>;
+            chunks_failed: z.ZodOptional<z.ZodNumber>;
+            error: z.ZodOptional<z.ZodString>;
             findings_count: z.ZodOptional<z.ZodNumber>;
             findings_verified: z.ZodOptional<z.ZodNumber>;
         }, "strip", z.ZodTypeAny, {
             enabled: boolean;
+            status?: "ok" | "partial" | "error" | undefined;
+            mode?: "code" | "facts" | undefined;
+            error?: string | undefined;
             tier?: "deep" | "lite" | "legacy" | "cloud" | undefined;
             model?: string | undefined;
+            model_fallback?: boolean | undefined;
             total_ms?: number | undefined;
             files_analyzed?: number | undefined;
+            chunks_total?: number | undefined;
+            chunks_failed?: number | undefined;
             findings_count?: number | undefined;
             findings_verified?: number | undefined;
         }, {
             enabled: boolean;
+            status?: "ok" | "partial" | "error" | undefined;
+            mode?: "code" | "facts" | undefined;
+            error?: string | undefined;
             tier?: "deep" | "lite" | "legacy" | "cloud" | undefined;
             model?: string | undefined;
+            model_fallback?: boolean | undefined;
             total_ms?: number | undefined;
             files_analyzed?: number | undefined;
+            chunks_total?: number | undefined;
+            chunks_failed?: number | undefined;
             findings_count?: number | undefined;
             findings_verified?: number | undefined;
         }>>;
@@ -2971,10 +2990,16 @@ export declare const ReportSchema: z.ZodObject<{
         duration_ms: number;
         deep?: {
             enabled: boolean;
+            status?: "ok" | "partial" | "error" | undefined;
+            mode?: "code" | "facts" | undefined;
+            error?: string | undefined;
             tier?: "deep" | "lite" | "legacy" | "cloud" | undefined;
             model?: string | undefined;
+            model_fallback?: boolean | undefined;
             total_ms?: number | undefined;
             files_analyzed?: number | undefined;
+            chunks_total?: number | undefined;
+            chunks_failed?: number | undefined;
             findings_count?: number | undefined;
             findings_verified?: number | undefined;
         } | undefined;
@@ -2994,10 +3019,16 @@ export declare const ReportSchema: z.ZodObject<{
         duration_ms: number;
         deep?: {
             enabled: boolean;
+            status?: "ok" | "partial" | "error" | undefined;
+            mode?: "code" | "facts" | undefined;
+            error?: string | undefined;
             tier?: "deep" | "lite" | "legacy" | "cloud" | undefined;
             model?: string | undefined;
+            model_fallback?: boolean | undefined;
             total_ms?: number | undefined;
             files_analyzed?: number | undefined;
+            chunks_total?: number | undefined;
+            chunks_failed?: number | undefined;
             findings_count?: number | undefined;
             findings_verified?: number | undefined;
         } | undefined;
@@ -3019,10 +3050,16 @@ export declare const ReportSchema: z.ZodObject<{
         duration_ms: number;
         deep?: {
             enabled: boolean;
+            status?: "ok" | "partial" | "error" | undefined;
+            mode?: "code" | "facts" | undefined;
+            error?: string | undefined;
             tier?: "deep" | "lite" | "legacy" | "cloud" | undefined;
             model?: string | undefined;
+            model_fallback?: boolean | undefined;
             total_ms?: number | undefined;
             files_analyzed?: number | undefined;
+            chunks_total?: number | undefined;
+            chunks_failed?: number | undefined;
             findings_count?: number | undefined;
             findings_verified?: number | undefined;
         } | undefined;
@@ -3061,10 +3098,16 @@ export declare const ReportSchema: z.ZodObject<{
         duration_ms: number;
         deep?: {
             enabled: boolean;
+            status?: "ok" | "partial" | "error" | undefined;
+            mode?: "code" | "facts" | undefined;
+            error?: string | undefined;
             tier?: "deep" | "lite" | "legacy" | "cloud" | undefined;
             model?: string | undefined;
+            model_fallback?: boolean | undefined;
             total_ms?: number | undefined;
             files_analyzed?: number | undefined;
+            chunks_total?: number | undefined;
+            chunks_failed?: number | undefined;
             findings_count?: number | undefined;
             findings_verified?: number | undefined;
         } | undefined;
@@ -3110,4 +3153,5 @@ export interface DeepOptions {
     modelName?: string;
     agents?: number;
     maxFiles?: number;
+    focusLines?: Record<string, number[]>;
 }

package/dist/types/index.js

@@ -303,9 +303,9 @@ export const GatesSchema = z.object({
         model_name: z.string().optional(), // cloud model name override (e.g. 'gpt-4o', 'claude-sonnet-4-5-20250929', 'gemini-pro')
         model_path: z.string().optional(), // custom local GGUF model path override
         threads: z.number().optional().default(4),
-        max_tokens: z.number().optional().default(512),
+        max_tokens: z.number().optional(), // default per provider: local 1024, cloud 4096
         temperature: z.number().optional().default(0.1),
-        timeout_ms: z.number().optional().default(60000),
+        timeout_ms: z.number().optional(), // per inference call; default per provider: local 60s, cloud 120s
         checks: z.object({
             solid: z.boolean().optional().default(true),
             dry: z.boolean().optional().default(true),
@@ -402,10 +402,17 @@ export const ReportSchema = z.object({
         }).optional(),
         deep: z.object({
             enabled: z.boolean(),
+            /** ok: every inference ran; partial: some failed; error: deep did not run. */
+            status: z.enum(['ok', 'partial', 'error']).optional(),
+            mode: z.enum(['facts', 'code']).optional(),
             tier: z.enum(['deep', 'lite', 'legacy', 'cloud']).optional(),
             model: z.string().optional(),
+            model_fallback: z.boolean().optional(),
             total_ms: z.number().optional(),
             files_analyzed: z.number().optional(),
+            chunks_total: z.number().optional(),
+            chunks_failed: z.number().optional(),
+            error: z.string().optional(),
             findings_count: z.number().optional(),
             findings_verified: z.number().optional(),
         }).optional(),

package/dist/utils/deep-status.d.ts

@@ -0,0 +1,7 @@
+import type { Report } from '../types/index.js';
+/**
+ * Why deep analysis did not run, or undefined when it ran (fully or
+ * partially) or was not requested. Callers use this to fail loudly instead
+ * of presenting an empty deep result as a clean pass.
+ */
+export declare function deepAnalysisError(report: Pick<Report, 'stats'>): string | undefined;

package/dist/utils/deep-status.js

@@ -0,0 +1,11 @@
+/**
+ * Why deep analysis did not run, or undefined when it ran (fully or
+ * partially) or was not requested. Callers use this to fail loudly instead
+ * of presenting an empty deep result as a clean pass.
+ */
+export function deepAnalysisError(report) {
+    const deep = report.stats.deep;
+    if (deep?.status !== 'error')
+        return undefined;
+    return deep.error || 'unknown error';
+}

package/dist/utils/diff.d.ts

@@ -0,0 +1,3 @@
+export declare function parseDiff(diff: string): Record<string, Set<number>>;
+/** Changed lines as sorted arrays, the shape DeepOptions.focusLines takes. */
+export declare function changedLinesByFile(mapping: Record<string, Set<number>>): Record<string, number[]>;

package/dist/utils/diff.js

@@ -0,0 +1,52 @@
+export function parseDiff(diff) {
+    const state = { mapping: {}, file: '', newLine: 0, oldLeft: 0, newLeft: 0 };
+    for (const line of diff.split('\n')) {
+        if (state.oldLeft > 0 || state.newLeft > 0)
+            readHunkLine(state, line);
+        else
+            readHeaderLine(state, line);
+    }
+    return state.mapping;
+}
+function readHunkLine(state, line) {
+    if (line.startsWith('\\'))
+        return; // ""
+    if (line.startsWith('-')) {
+        state.oldLeft--;
+        return;
+    }
+    if (line.startsWith('+')) {
+        if (state.file)
+            state.mapping[state.file].add(state.newLine);
+    }
+    else {
+        state.oldLeft--;
+    }
+    state.newLine++;
+    state.newLeft--;
+}
+function readHeaderLine(state, line) {
+    if (line.startsWith('diff --git ')) {
+        state.file = '';
+    }
+    else if (line.startsWith('+++ ')) {
+        state.file = line.startsWith('+++ b/') ? line.slice(6).trim() : '';
+        if (state.file)
+            state.mapping[state.file] ??= new Set();
+    }
+    else if (line.startsWith('@@')) {
+        readHunkHeader(state, line);
+    }
+}
+function readHunkHeader(state, line) {
+    const hunk = line.match(/^@@ -\d+(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/);
+    if (!hunk)
+        return;
+    state.oldLeft = hunk[1] === undefined ? 1 : parseInt(hunk[1], 10);
+    state.newLine = parseInt(hunk[2], 10);
+    state.newLeft = hunk[3] === undefined ? 1 : parseInt(hunk[3], 10);
+}
+/** Changed lines as sorted arrays, the shape DeepOptions.focusLines takes. */
+export function changedLinesByFile(mapping) {
+    return Object.fromEntries(Object.entries(mapping).map(([file, lines]) => [file, [...lines].sort((a, b) => a - b)]));
+}

package/dist/utils/diff.test.d.ts

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

package/dist/utils/diff.test.js

@@ -0,0 +1,38 @@
+import { describe, expect, it } from 'vitest';
+import { changedLinesByFile, parseDiff } from './diff.js';
+const lines = (m) => changedLinesByFile(m);
+describe('parseDiff', () => {
+    it('maps added lines to new-side line numbers', () => {
+        const diff = [
+            'diff --git a/src/a.ts b/src/a.ts',
+            '--- a/src/a.ts',
+            '+++ b/src/a.ts',
+            '@@ -1,3 +1,4 @@',
+            ' const a = 1;',
+            '-const b = 2;',
+            '+const b = 3;',
+            '+const c = 4;',
+            ' export { a };',
+        ].join('\n');
+        expect(lines(parseDiff(diff))).toEqual({ 'src/a.ts': [2, 3] });
+    });
+    it('handles several files and hunks', () => {
+        const diff = [
+            '+++ b/a.ts', '@@ -10,2 +10,3 @@', ' x', '+y', ' z',
+            '+++ b/b.ts', '@@ -1 +1 @@', '-old', '+new',
+        ].join('\n');
+        expect(lines(parseDiff(diff))).toEqual({ 'a.ts': [11], 'b.ts': [1] });
+    });
+    it('does not mistake content lines starting with +++ or --- for headers', () => {
+        const diff = ['+++ b/a.ts', '@@ -1,2 +1,3 @@', ' let i = 0;', '+++i;', '---j;', ' done();'].join('\n');
+        expect(lines(parseDiff(diff))).toEqual({ 'a.ts': [2] });
+    });
+    it('does not count "No newline at end of file" as a line', () => {
+        const diff = ['+++ b/a.ts', '@@ -1,1 +1,2 @@', ' a', '\', '+b'].join('\n');
+        expect(lines(parseDiff(diff))).toEqual({ 'a.ts': [2] });
+    });
+    it('ignores deleted files', () => {
+        const diff = ['diff --git a/gone.ts b/gone.ts', '--- a/gone.ts', '+++ /dev/null', '@@ -1,2 +0,0 @@', '-a', '-b'].join('\n');
+        expect(parseDiff(diff)).toEqual({});
+    });
+});

package/dist/utils/scanner.js

@@ -1,6 +1,17 @@
 import { globby } from 'globby';
 import fs from 'fs-extra';
 import path from 'path';
+/**
+ * Glob patterns use `/` as the separator and `\` as the escape character.
+ * Only on Windows can a backslash be a path separator, and even there one
+ * that escapes a glob character (`\[` in `app/\[key\]/route.ts`) must stay.
+ * Same rule as fast-glob's convertPathToPattern for Windows paths.
+ */
+function toGlobSeparators(pattern) {
+    if (process.platform !== 'win32')
+        return pattern;
+    return pattern.replace(/\\(?![!()+@[\]{}])/g, '/');
+}
 export class FileScanner {
     static DEFAULT_PATTERNS = ['**/*.{ts,tsx,js,jsx,mjs,cjs,py,go,rs,rb,cs,java,kt,css,html,md,yaml,yml,toml,json}'];
     static DEFAULT_IGNORE = [
@@ -18,9 +29,9 @@ export class FileScanner {
         'rigour-report.json'
     ];
     static async findFiles(options) {
-        const patterns = (options.patterns || this.DEFAULT_PATTERNS).map(p => p.replace(/\\/g, '/'));
+        const patterns = (options.patterns || this.DEFAULT_PATTERNS).map(toGlobSeparators);
         const userIgnore = options.ignore || [];
-        const ignore = [...new Set([...this.DEFAULT_IGNORE, ...userIgnore])].map(p => p.replace(/\\/g, '/'));
+        const ignore = [...new Set([...this.DEFAULT_IGNORE, ...userIgnore])].map(toGlobSeparators);
         const normalizedCwd = options.cwd.replace(/\\/g, '/');
         return globby(patterns, {
             cwd: normalizedCwd,

package/dist/utils/scanner.test.js

@@ -16,14 +16,28 @@ describe('FileScanner', () => {
         expect(ignore).toContain('**/node_modules/**');
         expect(ignore).toContain('custom-ignore');
     });
-    it('should normalize paths to forward slashes', async () => {
-        const options = {
-            cwd: 'C:\\test\\path',
-            patterns: ['**\\*.ts']
-        };
-        await FileScanner.findFiles(options);
-        const call = vi.mocked(globby).mock.calls[1];
-        expect(call[0][0]).toBe('**/*.ts');
+    it('should normalize Windows paths to forward slashes', async () => {
+        const platform = Object.getOwnPropertyDescriptor(process, 'platform');
+        Object.defineProperty(process, 'platform', { value: 'win32' });
+        try {
+            await FileScanner.findFiles({ cwd: 'C:\\test\\path', patterns: ['**\\*.ts', 'app\\\\[key\\]\\route.ts'] });
+        }
+        finally {
+            Object.defineProperty(process, 'platform', platform);
+        }
+        const call = vi.mocked(globby).mock.calls.at(-1);
+        expect(call[0]).toEqual(['**/*.ts', 'app/\\[key\\]/route.ts']);
         expect(call[1]?.cwd).toBe('C:/test/path');
     });
+    it('should keep glob escapes on POSIX', async () => {
+        const platform = Object.getOwnPropertyDescriptor(process, 'platform');
+        Object.defineProperty(process, 'platform', { value: 'linux' });
+        try {
+            await FileScanner.findFiles({ cwd: '/repo', patterns: ['src/app/\\[key\\]/route.ts'] });
+        }
+        finally {
+            Object.defineProperty(process, 'platform', platform);
+        }
+        expect(vi.mocked(globby).mock.calls.at(-1)[0]).toEqual(['src/app/\\[key\\]/route.ts']);
+    });
 });

package/dist/utils/scope.d.ts

@@ -0,0 +1,15 @@
+/** Convert CLI path arguments into cwd-relative, escaped glob patterns. */
+export declare function normalizeScopePatterns(cwd: string, inputs: string[]): Promise<string[]>;
+/** True when a gate context carries an explicit file scope. */
+export declare function isScoped(patterns: string[] | undefined): patterns is string[];
+/** True when any of `files` is in the scoped file set (paths compared cwd-relative). */
+export declare function touchesScope(files: string[] | undefined, scopedFiles: Set<string>): boolean;
+/** The concrete cwd-relative files matched by a scoped run's patterns. */
+export declare function resolveScopedFiles(cwd: string, patterns: string[], ignore?: string[]): Promise<Set<string>>;
+/** True when a scoped run does not include `file` (a manifest such as package.json). */
+export declare function scopeExcludes(context: {
+    cwd: string;
+    patterns?: string[];
+    ignore?: string[];
+}, file: string): Promise<boolean>;
+export declare function toPosix(p: string): string;

package/dist/utils/scope.js

@@ -0,0 +1,51 @@
+/**
+ * File scope for `rigour check <paths...>` and `rigour review`.
+ *
+ * CLI inputs may be absolute, relative or directories. Gates glob with
+ * globby, so each input becomes a cwd-relative glob with glob-special
+ * characters escaped (Next.js routes such as `app/[key]/route.ts` would
+ * otherwise be read as a character class).
+ */
+import path from 'path';
+import fs from 'fs-extra';
+import { convertPathToPattern } from 'globby';
+import { FileScanner } from './scanner.js';
+/** Convert CLI path arguments into cwd-relative, escaped glob patterns. */
+export async function normalizeScopePatterns(cwd, inputs) {
+    const patterns = [];
+    for (const input of inputs) {
+        const absolute = path.resolve(cwd, input);
+        const relative = toPosix(path.relative(cwd, absolute)) || '.';
+        const isDirectory = await fs.stat(absolute).then(s => s.isDirectory()).catch(() => false);
+        if (!isDirectory && !(await fs.pathExists(absolute))) {
+            // Not a path on disk: keep it as the glob the user wrote.
+            patterns.push(toPosix(input));
+            continue;
+        }
+        const escaped = relative === '.' ? '' : convertPathToPattern(relative);
+        patterns.push(isDirectory ? (escaped ? `${escaped}/**/*` : '**/*') : escaped);
+    }
+    return patterns;
+}
+/** True when a gate context carries an explicit file scope. */
+export function isScoped(patterns) {
+    return Array.isArray(patterns) && patterns.length > 0;
+}
+/** True when any of `files` is in the scoped file set (paths compared cwd-relative). */
+export function touchesScope(files, scopedFiles) {
+    return (files ?? []).some(f => scopedFiles.has(toPosix(f).replace(/^\.\//, '')));
+}
+/** The concrete cwd-relative files matched by a scoped run's patterns. */
+export async function resolveScopedFiles(cwd, patterns, ignore) {
+    const files = await FileScanner.findFiles({ cwd, patterns, ignore });
+    return new Set(files.map(toPosix));
+}
+/** True when a scoped run does not include `file` (a manifest such as package.json). */
+export async function scopeExcludes(context, file) {
+    if (!isScoped(context.patterns))
+        return false;
+    return !(await resolveScopedFiles(context.cwd, context.patterns, context.ignore)).has(file);
+}
+export function toPosix(p) {
+    return p.replace(/\\/g, '/');
+}

package/dist/utils/scope.test.d.ts

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

package/dist/utils/scope.test.js

@@ -0,0 +1,38 @@
+import fs from 'fs-extra';
+import os from 'os';
+import path from 'path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { isScoped, normalizeScopePatterns, resolveScopedFiles, touchesScope } from './scope.js';
+describe('scope', () => {
+    let cwd;
+    beforeEach(async () => {
+        cwd = await fs.mkdtemp(path.join(os.tmpdir(), 'rigour-scope-'));
+        await fs.outputFile(path.join(cwd, 'src/app/[key]/route.ts'), 'export {}');
+        await fs.outputFile(path.join(cwd, 'src/app/k/route.ts'), 'export {}');
+        await fs.outputFile(path.join(cwd, 'src/lib/a.ts'), 'export {}');
+    });
+    afterEach(async () => { await fs.remove(cwd); });
+    it('turns absolute, relative and directory inputs into cwd-relative patterns', async () => {
+        const patterns = await normalizeScopePatterns(cwd, [path.join(cwd, 'src/lib/a.ts'), './src/lib', 'src/lib/a.ts']);
+        expect(patterns).toEqual(['src/lib/a.ts', 'src/lib/**/*', 'src/lib/a.ts']);
+    });
+    it('escapes glob characters so a Next.js [key] route matches only itself', async () => {
+        const patterns = await normalizeScopePatterns(cwd, ['src/app/[key]/route.ts']);
+        expect([...await resolveScopedFiles(cwd, patterns)]).toEqual(['src/app/[key]/route.ts']);
+    });
+    it('keeps a non-existent input as the glob the user wrote', async () => {
+        expect(await normalizeScopePatterns(cwd, ['src/**/*.ts'])).toEqual(['src/**/*.ts']);
+    });
+    it('treats the repo root as everything', async () => {
+        expect(await normalizeScopePatterns(cwd, ['.'])).toEqual(['**/*']);
+    });
+    it('detects scoped runs and scope membership', () => {
+        expect(isScoped(undefined)).toBe(false);
+        expect(isScoped([])).toBe(false);
+        expect(isScoped(['a.ts'])).toBe(true);
+        const scoped = new Set(['src/lib/a.ts']);
+        expect(touchesScope(['./src/lib/a.ts', 'b.ts'], scoped)).toBe(true);
+        expect(touchesScope(['b.ts'], scoped)).toBe(false);
+        expect(touchesScope(undefined, scoped)).toBe(false);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rigour-labs/core",
-  "version": "6.2.4",
+  "version": "6.2.5",
   "description": "AI-native quality gate engine with local Bayesian learning. AST analysis, drift detection, Fix Packet generation, and agent self-healing across TypeScript, JavaScript, Python, Go, Ruby, and C#.",
   "license": "MIT",
   "homepage": "https://rigour.run",
@@ -67,11 +67,11 @@
     "pg": "^8.16.3",
     "sqlite3": "^5.1.7",
     "openai": "^4.104.0",
-    "@rigour-labs/brain-darwin-arm64": "6.2.4",
-    "@rigour-labs/brain-darwin-x64": "6.2.4",
-    "@rigour-labs/brain-linux-x64": "6.2.4",
-    "@rigour-labs/brain-win-x64": "6.2.4",
-    "@rigour-labs/brain-linux-arm64": "6.2.4"
+    "@rigour-labs/brain-darwin-arm64": "6.2.5",
+    "@rigour-labs/brain-darwin-x64": "6.2.5",
+    "@rigour-labs/brain-linux-arm64": "6.2.5",
+    "@rigour-labs/brain-win-x64": "6.2.5",
+    "@rigour-labs/brain-linux-x64": "6.2.5"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",