@rigour-labs/core 6.2.4 → 6.3.0

package/dist/types/index.d.ts

@@ -495,6 +495,16 @@ export declare const GatesSchema: z.ZodObject<{
         custom_patterns?: string[] | undefined;
         audit_log?: boolean | undefined;
     }>>>;
+    semantic_bugs: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        rules: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        rules?: string[] | undefined;
+    }, {
+        enabled?: boolean | undefined;
+        rules?: string[] | undefined;
+    }>>>;
     side_effect_analysis: z.ZodDefault<z.ZodOptional<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
         check_unbounded_timers: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
@@ -573,9 +583,10 @@ 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>;
+        intent_checks: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
         checks: z.ZodDefault<z.ZodOptional<z.ZodObject<{
             solid: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
             dry: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
@@ -609,9 +620,8 @@ export declare const GatesSchema: z.ZodObject<{
         pro: boolean;
         provider: string;
         threads: number;
-        max_tokens: number;
         temperature: number;
-        timeout_ms: number;
+        intent_checks: boolean;
         checks: {
             architecture: boolean;
             test_quality: boolean;
@@ -626,6 +636,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;
@@ -638,6 +650,7 @@ export declare const GatesSchema: z.ZodObject<{
         max_tokens?: number | undefined;
         temperature?: number | undefined;
         timeout_ms?: number | undefined;
+        intent_checks?: boolean | undefined;
         checks?: {
             architecture?: boolean | undefined;
             test_quality?: boolean | undefined;
@@ -655,9 +668,8 @@ export declare const GatesSchema: z.ZodObject<{
         pro: boolean;
         provider: string;
         threads: number;
-        max_tokens: number;
         temperature: number;
-        timeout_ms: number;
+        intent_checks: boolean;
         checks: {
             architecture: boolean;
             test_quality: boolean;
@@ -672,6 +684,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;
@@ -852,6 +866,10 @@ export declare const GatesSchema: z.ZodObject<{
         custom_patterns: string[];
         audit_log: boolean;
     };
+    semantic_bugs: {
+        enabled: boolean;
+        rules?: string[] | undefined;
+    };
     side_effect_analysis: {
         enabled: boolean;
         ignore_patterns: string[];
@@ -890,6 +908,7 @@ export declare const GatesSchema: z.ZodObject<{
         max_tokens?: number | undefined;
         temperature?: number | undefined;
         timeout_ms?: number | undefined;
+        intent_checks?: boolean | undefined;
         checks?: {
             architecture?: boolean | undefined;
             test_quality?: boolean | undefined;
@@ -1080,6 +1099,10 @@ export declare const GatesSchema: z.ZodObject<{
         custom_patterns?: string[] | undefined;
         audit_log?: boolean | undefined;
     } | undefined;
+    semantic_bugs?: {
+        enabled?: boolean | undefined;
+        rules?: string[] | undefined;
+    } | undefined;
     side_effect_analysis?: {
         enabled?: boolean | undefined;
         ignore_patterns?: string[] | undefined;
@@ -1661,6 +1684,16 @@ export declare const ConfigSchema: z.ZodObject<{
             custom_patterns?: string[] | undefined;
             audit_log?: boolean | undefined;
         }>>>;
+        semantic_bugs: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            rules: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            rules?: string[] | undefined;
+        }, {
+            enabled?: boolean | undefined;
+            rules?: string[] | undefined;
+        }>>>;
         side_effect_analysis: z.ZodDefault<z.ZodOptional<z.ZodObject<{
             enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
             check_unbounded_timers: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
@@ -1739,9 +1772,10 @@ 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>;
+            intent_checks: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
             checks: z.ZodDefault<z.ZodOptional<z.ZodObject<{
                 solid: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
                 dry: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
@@ -1775,9 +1809,8 @@ export declare const ConfigSchema: z.ZodObject<{
             pro: boolean;
             provider: string;
             threads: number;
-            max_tokens: number;
             temperature: number;
-            timeout_ms: number;
+            intent_checks: boolean;
             checks: {
                 architecture: boolean;
                 test_quality: boolean;
@@ -1792,6 +1825,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;
@@ -1804,6 +1839,7 @@ export declare const ConfigSchema: z.ZodObject<{
             max_tokens?: number | undefined;
             temperature?: number | undefined;
             timeout_ms?: number | undefined;
+            intent_checks?: boolean | undefined;
             checks?: {
                 architecture?: boolean | undefined;
                 test_quality?: boolean | undefined;
@@ -1821,9 +1857,8 @@ export declare const ConfigSchema: z.ZodObject<{
             pro: boolean;
             provider: string;
             threads: number;
-            max_tokens: number;
             temperature: number;
-            timeout_ms: number;
+            intent_checks: boolean;
             checks: {
                 architecture: boolean;
                 test_quality: boolean;
@@ -1838,6 +1873,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;
@@ -2018,6 +2055,10 @@ export declare const ConfigSchema: z.ZodObject<{
             custom_patterns: string[];
             audit_log: boolean;
         };
+        semantic_bugs: {
+            enabled: boolean;
+            rules?: string[] | undefined;
+        };
         side_effect_analysis: {
             enabled: boolean;
             ignore_patterns: string[];
@@ -2056,6 +2097,7 @@ export declare const ConfigSchema: z.ZodObject<{
             max_tokens?: number | undefined;
             temperature?: number | undefined;
             timeout_ms?: number | undefined;
+            intent_checks?: boolean | undefined;
             checks?: {
                 architecture?: boolean | undefined;
                 test_quality?: boolean | undefined;
@@ -2246,6 +2288,10 @@ export declare const ConfigSchema: z.ZodObject<{
             custom_patterns?: string[] | undefined;
             audit_log?: boolean | undefined;
         } | undefined;
+        semantic_bugs?: {
+            enabled?: boolean | undefined;
+            rules?: string[] | undefined;
+        } | undefined;
         side_effect_analysis?: {
             enabled?: boolean | undefined;
             ignore_patterns?: string[] | undefined;
@@ -2319,9 +2365,8 @@ export declare const ConfigSchema: z.ZodObject<{
             pro: boolean;
             provider: string;
             threads: number;
-            max_tokens: number;
             temperature: number;
-            timeout_ms: number;
+            intent_checks: boolean;
             checks: {
                 architecture: boolean;
                 test_quality: boolean;
@@ -2336,6 +2381,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;
@@ -2516,6 +2563,10 @@ export declare const ConfigSchema: z.ZodObject<{
             custom_patterns: string[];
             audit_log: boolean;
         };
+        semantic_bugs: {
+            enabled: boolean;
+            rules?: string[] | undefined;
+        };
         side_effect_analysis: {
             enabled: boolean;
             ignore_patterns: string[];
@@ -2580,6 +2631,7 @@ export declare const ConfigSchema: z.ZodObject<{
             max_tokens?: number | undefined;
             temperature?: number | undefined;
             timeout_ms?: number | undefined;
+            intent_checks?: boolean | undefined;
             checks?: {
                 architecture?: boolean | undefined;
                 test_quality?: boolean | undefined;
@@ -2770,6 +2822,10 @@ export declare const ConfigSchema: z.ZodObject<{
             custom_patterns?: string[] | undefined;
             audit_log?: boolean | undefined;
         } | undefined;
+        semantic_bugs?: {
+            enabled?: boolean | undefined;
+            rules?: string[] | undefined;
+        } | undefined;
         side_effect_analysis?: {
             enabled?: boolean | undefined;
             ignore_patterns?: string[] | undefined;
@@ -2944,26 +3000,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 +3046,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 +3075,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 +3106,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 +3154,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 +3209,5 @@ export interface DeepOptions {
     modelName?: string;
     agents?: number;
     maxFiles?: number;
+    focusLines?: Record<string, number[]>;
 }

package/dist/types/index.js

@@ -266,6 +266,10 @@ export const GatesSchema = z.object({
         audit_log: z.boolean().optional().default(true),
     }).optional().default({}),
     // v4.3+ Side-Effect Safety Analysis
+    semantic_bugs: z.object({
+        enabled: z.boolean().optional().default(false),
+        rules: z.array(z.string()).optional(),
+    }).optional().default({}),
     side_effect_analysis: z.object({
         enabled: z.boolean().optional().default(true),
         check_unbounded_timers: z.boolean().optional().default(true),
@@ -303,9 +307,12 @@ 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
+        // Intent questions at engine-proven sites (optional-read-no-fallback) in scoped reviews.
+        // Off: the stock local models failed the zero-false-finding bar (docs/DEEP_ANALYSIS.md).
+        intent_checks: z.boolean().optional().default(false),
         checks: z.object({
             solid: z.boolean().optional().default(true),
             dry: z.boolean().optional().default(true),
@@ -402,10 +409,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;