@rigour-labs/core 1.7.0 → 2.1.0

package/dist/gates/safety.js

@@ -1,9 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SafetyGate = void 0;
-const base_js_1 = require("./base.js");
-const execa_1 = require("execa");
-class SafetyGate extends base_js_1.Gate {
+import { Gate } from './base.js';
+import { execa } from 'execa';
+export class SafetyGate extends Gate {
     config;
     constructor(config) {
         super('safety-rail', 'Safety & Protection Rails');
@@ -18,7 +15,7 @@ class SafetyGate extends base_js_1.Gate {
         try {
             // Check for modified files in protected paths using git
             // This is a "Safety Rail" - if an agent touched these, we fail.
-            const { stdout } = await (0, execa_1.execa)('git', ['status', '--porcelain'], { cwd: context.cwd });
+            const { stdout } = await execa('git', ['status', '--porcelain'], { cwd: context.cwd });
             const modifiedFiles = stdout.split('\n')
                 .filter(line => line.trim().length > 0)
                 .map(line => line.slice(3));
@@ -44,4 +41,3 @@ class SafetyGate extends base_js_1.Gate {
         });
     }
 }
-exports.SafetyGate = SafetyGate;

package/dist/gates/structure.js

@@ -1,13 +1,7 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StructureGate = void 0;
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const path_1 = __importDefault(require("path"));
-const base_js_1 = require("./base.js");
-class StructureGate extends base_js_1.Gate {
+import fs from 'fs-extra';
+import path from 'path';
+import { Gate } from './base.js';
+export class StructureGate extends Gate {
     config;
     constructor(config) {
         super('structure-check', 'Project Structure');
@@ -16,8 +10,8 @@ class StructureGate extends base_js_1.Gate {
     async run(context) {
         const missing = [];
         for (const file of this.config.requiredFiles) {
-            const filePath = path_1.default.join(context.cwd, file);
-            if (!(await fs_extra_1.default.pathExists(filePath))) {
+            const filePath = path.join(context.cwd, file);
+            if (!(await fs.pathExists(filePath))) {
                 missing.push(file);
             }
         }
@@ -29,4 +23,3 @@ class StructureGate extends base_js_1.Gate {
         return [];
     }
 }
-exports.StructureGate = StructureGate;

package/dist/index.js

@@ -1,26 +1,8 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Gate = void 0;
-__exportStar(require("./types/index.js"), exports);
-__exportStar(require("./gates/runner.js"), exports);
-__exportStar(require("./discovery.js"), exports);
-__exportStar(require("./services/fix-packet-service.js"), exports);
-__exportStar(require("./templates/index.js"), exports);
-__exportStar(require("./types/fix-packet.js"), exports);
-var base_js_1 = require("./gates/base.js");
-Object.defineProperty(exports, "Gate", { enumerable: true, get: function () { return base_js_1.Gate; } });
-__exportStar(require("./utils/logger.js"), exports);
+export * from './types/index.js';
+export * from './gates/runner.js';
+export * from './discovery.js';
+export * from './services/fix-packet-service.js';
+export * from './templates/index.js';
+export * from './types/fix-packet.js';
+export { Gate } from './gates/base.js';
+export * from './utils/logger.js';

package/dist/services/context-engine.d.ts

@@ -0,0 +1,22 @@
+import { Config } from '../types/index.js';
+export interface ProjectAnchor {
+    id: string;
+    type: 'env' | 'naming' | 'import';
+    pattern: string;
+    confidence: number;
+    occurrences: number;
+}
+export interface GoldenRecord {
+    anchors: ProjectAnchor[];
+    metadata: {
+        scannedFiles: number;
+        detectedCasing: 'camelCase' | 'snake_case' | 'PascalCase' | 'unknown';
+    };
+}
+export declare class ContextEngine {
+    private config;
+    constructor(config: Config);
+    discover(cwd: string): Promise<GoldenRecord>;
+    private mineEnvVars;
+    private incrementRegistry;
+}

package/dist/services/context-engine.js

@@ -0,0 +1,78 @@
+import { FileScanner } from '../utils/scanner.js';
+import path from 'path';
+import fs from 'fs-extra';
+export class ContextEngine {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    async discover(cwd) {
+        const anchors = [];
+        const files = await FileScanner.findFiles({
+            cwd,
+            patterns: [
+                '**/*.{ts,js,py,yaml,yml,json}',
+                '.env*',
+                '**/.env*',
+                '**/package.json',
+                '**/Dockerfile',
+                '**/*.tf'
+            ]
+        });
+        const limit = this.config.gates.context?.mining_depth || 100;
+        const samples = files.slice(0, limit);
+        const envVars = new Map();
+        let scannedFiles = 0;
+        for (const file of samples) {
+            try {
+                const content = await fs.readFile(path.join(cwd, file), 'utf-8');
+                scannedFiles++;
+                this.mineEnvVars(content, file, envVars);
+            }
+            catch (e) { }
+        }
+        console.log(`[ContextEngine] Discovered ${envVars.size} env anchors`);
+        // Convert envVars to anchors
+        for (const [name, count] of envVars.entries()) {
+            const confidence = count >= 2 ? 1 : 0.5;
+            anchors.push({
+                id: name,
+                type: 'env',
+                pattern: name,
+                occurrences: count,
+                confidence
+            });
+        }
+        return {
+            anchors,
+            metadata: {
+                scannedFiles,
+                detectedCasing: 'unknown', // TODO: Implement casing discovery
+            }
+        };
+    }
+    mineEnvVars(content, file, registry) {
+        const isAnchorSource = file.includes('.env') || file.includes('yml') || file.includes('yaml');
+        if (isAnchorSource) {
+            const matches = content.matchAll(/^\s*([A-Z0-9_]+)\s*=/gm);
+            for (const match of matches) {
+                // Anchors from .env count for more initially
+                registry.set(match[1], (registry.get(match[1]) || 0) + 2);
+            }
+        }
+        // Source code matches (process.env.VAR or process.env['VAR'])
+        const tsJsMatches = content.matchAll(/process\.env(?:\.([A-Z0-9_]+)|\[['"]([A-Z0-9_]+)['"]\])/g);
+        for (const match of tsJsMatches) {
+            const name = match[1] || match[2];
+            this.incrementRegistry(registry, name);
+        }
+        // Python matches (os.environ.get('VAR') or os.environ['VAR'])
+        const pyMatches = content.matchAll(/os\.environ(?:\.get\(|\[)['"]([A-Z0-9_]+)['"]/g);
+        for (const match of pyMatches) {
+            this.incrementRegistry(registry, match[1]);
+        }
+    }
+    incrementRegistry(registry, key) {
+        registry.set(key, (registry.get(key) || 0) + 1);
+    }
+}

package/dist/services/fix-packet-service.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FixPacketService = void 0;
-const fix_packet_js_1 = require("../types/fix-packet.js");
-class FixPacketService {
+import { FixPacketV2Schema } from '../types/fix-packet.js';
+export class FixPacketService {
     generate(report, config) {
         const violations = report.failures.map(f => ({
             id: f.id,
@@ -27,7 +24,7 @@ class FixPacketService {
                 no_new_deps: true,
             },
         };
-        return fix_packet_js_1.FixPacketV2Schema.parse(packet);
+        return FixPacketV2Schema.parse(packet);
     }
     inferSeverity(f) {
         // High complexity or God objects are usually High severity
@@ -40,4 +37,3 @@ class FixPacketService {
         return 'medium';
     }
 }
-exports.FixPacketService = FixPacketService;

package/dist/services/state-service.js

@@ -1,25 +1,19 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StateService = void 0;
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const path_1 = __importDefault(require("path"));
+import fs from 'fs-extra';
+import path from 'path';
 const STATE_DIR = '.rigour';
 const STATE_FILE = 'state.json';
 const CURRENT_VERSION = 1;
-class StateService {
+export class StateService {
     statePath;
     state;
     constructor(cwd) {
-        this.statePath = path_1.default.join(cwd, STATE_DIR, STATE_FILE);
+        this.statePath = path.join(cwd, STATE_DIR, STATE_FILE);
         this.state = this.load();
     }
     load() {
         try {
-            if (fs_extra_1.default.existsSync(this.statePath)) {
-                const content = fs_extra_1.default.readFileSync(this.statePath, 'utf-8');
+            if (fs.existsSync(this.statePath)) {
+                const content = fs.readFileSync(this.statePath, 'utf-8');
                 return JSON.parse(content);
             }
         }
@@ -89,8 +83,8 @@ class StateService {
     }
     save() {
         try {
-            fs_extra_1.default.ensureDirSync(path_1.default.dirname(this.statePath));
-            fs_extra_1.default.writeFileSync(this.statePath, JSON.stringify(this.state, null, 2));
+            fs.ensureDirSync(path.dirname(this.statePath));
+            fs.writeFileSync(this.statePath, JSON.stringify(this.state, null, 2));
         }
         catch {
             // Silent fail - state is optional
@@ -102,11 +96,10 @@ class StateService {
     clear() {
         this.state = this.createEmpty();
         try {
-            fs_extra_1.default.removeSync(this.statePath);
+            fs.removeSync(this.statePath);
         }
         catch {
             // Silent fail
         }
     }
 }
-exports.StateService = StateService;

package/dist/smoke.test.js

@@ -1,9 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const vitest_1 = require("vitest");
-const runner_js_1 = require("../src/gates/runner.js");
-(0, vitest_1.describe)('GateRunner Smoke Test', () => {
-    (0, vitest_1.it)('should initialize with empty config', async () => {
+import { describe, it, expect } from 'vitest';
+import { GateRunner } from '../src/gates/runner.js';
+describe('GateRunner Smoke Test', () => {
+    it('should initialize with empty config', async () => {
         const config = {
             version: 1,
             commands: {},
@@ -13,7 +11,7 @@ const runner_js_1 = require("../src/gates/runner.js");
                 forbid_fixme: true,
             },
         };
-        const runner = new runner_js_1.GateRunner(config);
-        (0, vitest_1.expect)(runner).toBeDefined();
+        const runner = new GateRunner(config);
+        expect(runner).toBeDefined();
     });
 });

package/dist/templates/index.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UNIVERSAL_CONFIG = exports.PARADIGM_TEMPLATES = exports.TEMPLATES = void 0;
-exports.TEMPLATES = [
+export const TEMPLATES = [
     {
         name: 'ui',
         markers: [
@@ -92,7 +89,7 @@ exports.TEMPLATES = [
         },
     },
 ];
-exports.PARADIGM_TEMPLATES = [
+export const PARADIGM_TEMPLATES = [
     {
         name: 'oop',
         markers: [
@@ -149,7 +146,7 @@ exports.PARADIGM_TEMPLATES = [
         },
     },
 ];
-exports.UNIVERSAL_CONFIG = {
+export const UNIVERSAL_CONFIG = {
     version: 1,
     commands: {},
     gates: {
@@ -177,9 +174,22 @@ exports.UNIVERSAL_CONFIG = {
             max_files_changed_per_cycle: 10,
             protected_paths: ['.github/**', 'docs/**', 'rigour.yml'],
         },
+        context: {
+            enabled: true,
+            sensitivity: 0.8,
+            mining_depth: 100,
+            ignored_patterns: [],
+        },
+        environment: {
+            enabled: true,
+            enforce_contracts: true,
+            tools: {},
+            required_env: [],
+        },
     },
     output: {
         report_path: 'rigour-report.json',
     },
     planned: [],
+    ignore: [],
 };

package/dist/types/fix-packet.js

@@ -1,32 +1,29 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FixPacketV2Schema = void 0;
-const zod_1 = require("zod");
+import { z } from 'zod';
 /**
  * Fix Packet v2 Schema
  * Designed for high-fidelity communication with AI agents during the refinement loop.
  */
-exports.FixPacketV2Schema = zod_1.z.object({
-    version: zod_1.z.literal(2),
-    goal: zod_1.z.string().default('Achieve PASS state for all quality gates'),
-    violations: zod_1.z.array(zod_1.z.object({
-        id: zod_1.z.string(),
-        gate: zod_1.z.string(),
-        severity: zod_1.z.enum(['low', 'medium', 'high', 'critical']).default('medium'),
-        category: zod_1.z.string().optional(),
-        title: zod_1.z.string(),
-        details: zod_1.z.string(),
-        files: zod_1.z.array(zod_1.z.string()).optional(),
-        hint: zod_1.z.string().optional(),
-        instructions: zod_1.z.array(zod_1.z.string()).optional(), // Step-by-step fix instructions
-        metrics: zod_1.z.record(zod_1.z.any()).optional(), // e.g., { complexity: 15, max: 10 }
+export const FixPacketV2Schema = z.object({
+    version: z.literal(2),
+    goal: z.string().default('Achieve PASS state for all quality gates'),
+    violations: z.array(z.object({
+        id: z.string(),
+        gate: z.string(),
+        severity: z.enum(['low', 'medium', 'high', 'critical']).default('medium'),
+        category: z.string().optional(),
+        title: z.string(),
+        details: z.string(),
+        files: z.array(z.string()).optional(),
+        hint: z.string().optional(),
+        instructions: z.array(z.string()).optional(), // Step-by-step fix instructions
+        metrics: z.record(z.any()).optional(), // e.g., { complexity: 15, max: 10 }
     })),
-    constraints: zod_1.z.object({
-        protected_paths: zod_1.z.array(zod_1.z.string()).optional(),
-        do_not_touch: zod_1.z.array(zod_1.z.string()).optional(), // Alias for protected_paths
-        max_files_changed: zod_1.z.number().optional(),
-        no_new_deps: zod_1.z.boolean().optional().default(true),
-        allowed_dependencies: zod_1.z.array(zod_1.z.string()).optional(),
-        paradigm: zod_1.z.string().optional(), // 'oop', 'functional'
+    constraints: z.object({
+        protected_paths: z.array(z.string()).optional(),
+        do_not_touch: z.array(z.string()).optional(), // Alias for protected_paths
+        max_files_changed: z.number().optional(),
+        no_new_deps: z.boolean().optional().default(true),
+        allowed_dependencies: z.array(z.string()).optional(),
+        paradigm: z.string().optional(), // 'oop', 'functional'
     }).optional().default({}),
 });

package/dist/types/index.d.ts

@@ -77,6 +77,38 @@ export declare const GatesSchema: z.ZodObject<{
         max_files_changed_per_cycle?: number | undefined;
         protected_paths?: string[] | undefined;
     }>>>;
+    context: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        sensitivity: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        mining_depth: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        ignored_patterns: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        sensitivity: number;
+        mining_depth: number;
+        ignored_patterns: string[];
+    }, {
+        enabled?: boolean | undefined;
+        sensitivity?: number | undefined;
+        mining_depth?: number | undefined;
+        ignored_patterns?: string[] | undefined;
+    }>>>;
+    environment: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        enforce_contracts: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        tools: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
+        required_env: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        enforce_contracts: boolean;
+        tools: Record<string, string>;
+        required_env: string[];
+    }, {
+        enabled?: boolean | undefined;
+        enforce_contracts?: boolean | undefined;
+        tools?: Record<string, string> | undefined;
+        required_env?: string[] | undefined;
+    }>>>;
 }, "strip", z.ZodTypeAny, {
     max_file_lines: number;
     forbid_todos: boolean;
@@ -107,6 +139,18 @@ export declare const GatesSchema: z.ZodObject<{
         max_files_changed_per_cycle: number;
         protected_paths: string[];
     };
+    context: {
+        enabled: boolean;
+        sensitivity: number;
+        mining_depth: number;
+        ignored_patterns: string[];
+    };
+    environment: {
+        enabled: boolean;
+        enforce_contracts: boolean;
+        tools: Record<string, string>;
+        required_env: string[];
+    };
 }, {
     max_file_lines?: number | undefined;
     forbid_todos?: boolean | undefined;
@@ -137,6 +181,18 @@ export declare const GatesSchema: z.ZodObject<{
         max_files_changed_per_cycle?: number | undefined;
         protected_paths?: string[] | undefined;
     } | undefined;
+    context?: {
+        enabled?: boolean | undefined;
+        sensitivity?: number | undefined;
+        mining_depth?: number | undefined;
+        ignored_patterns?: string[] | undefined;
+    } | undefined;
+    environment?: {
+        enabled?: boolean | undefined;
+        enforce_contracts?: boolean | undefined;
+        tools?: Record<string, string> | undefined;
+        required_env?: string[] | undefined;
+    } | undefined;
 }>;
 export declare const CommandsSchema: z.ZodObject<{
     format: z.ZodOptional<z.ZodString>;
@@ -252,6 +308,38 @@ export declare const ConfigSchema: z.ZodObject<{
             max_files_changed_per_cycle?: number | undefined;
             protected_paths?: string[] | undefined;
         }>>>;
+        context: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            sensitivity: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            mining_depth: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            ignored_patterns: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            sensitivity: number;
+            mining_depth: number;
+            ignored_patterns: string[];
+        }, {
+            enabled?: boolean | undefined;
+            sensitivity?: number | undefined;
+            mining_depth?: number | undefined;
+            ignored_patterns?: string[] | undefined;
+        }>>>;
+        environment: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            enforce_contracts: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            tools: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
+            required_env: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            enforce_contracts: boolean;
+            tools: Record<string, string>;
+            required_env: string[];
+        }, {
+            enabled?: boolean | undefined;
+            enforce_contracts?: boolean | undefined;
+            tools?: Record<string, string> | undefined;
+            required_env?: string[] | undefined;
+        }>>>;
     }, "strip", z.ZodTypeAny, {
         max_file_lines: number;
         forbid_todos: boolean;
@@ -282,6 +370,18 @@ export declare const ConfigSchema: z.ZodObject<{
             max_files_changed_per_cycle: number;
             protected_paths: string[];
         };
+        context: {
+            enabled: boolean;
+            sensitivity: number;
+            mining_depth: number;
+            ignored_patterns: string[];
+        };
+        environment: {
+            enabled: boolean;
+            enforce_contracts: boolean;
+            tools: Record<string, string>;
+            required_env: string[];
+        };
     }, {
         max_file_lines?: number | undefined;
         forbid_todos?: boolean | undefined;
@@ -312,6 +412,18 @@ export declare const ConfigSchema: z.ZodObject<{
             max_files_changed_per_cycle?: number | undefined;
             protected_paths?: string[] | undefined;
         } | undefined;
+        context?: {
+            enabled?: boolean | undefined;
+            sensitivity?: number | undefined;
+            mining_depth?: number | undefined;
+            ignored_patterns?: string[] | undefined;
+        } | undefined;
+        environment?: {
+            enabled?: boolean | undefined;
+            enforce_contracts?: boolean | undefined;
+            tools?: Record<string, string> | undefined;
+            required_env?: string[] | undefined;
+        } | undefined;
     }>>>;
     output: z.ZodDefault<z.ZodOptional<z.ZodObject<{
         report_path: z.ZodDefault<z.ZodString>;
@@ -321,7 +433,9 @@ export declare const ConfigSchema: z.ZodObject<{
         report_path?: string | undefined;
     }>>>;
     planned: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+    ignore: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
 }, "strip", z.ZodTypeAny, {
+    ignore: string[];
     version: number;
     commands: {
         format?: string | undefined;
@@ -359,6 +473,18 @@ export declare const ConfigSchema: z.ZodObject<{
             max_files_changed_per_cycle: number;
             protected_paths: string[];
         };
+        context: {
+            enabled: boolean;
+            sensitivity: number;
+            mining_depth: number;
+            ignored_patterns: string[];
+        };
+        environment: {
+            enabled: boolean;
+            enforce_contracts: boolean;
+            tools: Record<string, string>;
+            required_env: string[];
+        };
     };
     output: {
         report_path: string;
@@ -367,6 +493,7 @@ export declare const ConfigSchema: z.ZodObject<{
     preset?: string | undefined;
     paradigm?: string | undefined;
 }, {
+    ignore?: string[] | undefined;
     version?: number | undefined;
     preset?: string | undefined;
     paradigm?: string | undefined;
@@ -406,6 +533,18 @@ export declare const ConfigSchema: z.ZodObject<{
             max_files_changed_per_cycle?: number | undefined;
             protected_paths?: string[] | undefined;
         } | undefined;
+        context?: {
+            enabled?: boolean | undefined;
+            sensitivity?: number | undefined;
+            mining_depth?: number | undefined;
+            ignored_patterns?: string[] | undefined;
+        } | undefined;
+        environment?: {
+            enabled?: boolean | undefined;
+            enforce_contracts?: boolean | undefined;
+            tools?: Record<string, string> | undefined;
+            required_env?: string[] | undefined;
+        } | undefined;
     } | undefined;
     output?: {
         report_path?: string | undefined;
@@ -415,6 +554,9 @@ export declare const ConfigSchema: z.ZodObject<{
 export type Gates = z.infer<typeof GatesSchema>;
 export type Commands = z.infer<typeof CommandsSchema>;
 export type Config = z.infer<typeof ConfigSchema>;
+export type RawGates = z.input<typeof GatesSchema>;
+export type RawCommands = z.input<typeof CommandsSchema>;
+export type RawConfig = z.input<typeof ConfigSchema>;
 export declare const StatusSchema: z.ZodEnum<["PASS", "FAIL", "SKIP", "ERROR"]>;
 export type Status = z.infer<typeof StatusSchema>;
 export declare const FailureSchema: z.ZodObject<{
@@ -461,12 +603,19 @@ export declare const ReportSchema: z.ZodObject<{
     }>, "many">;
     stats: z.ZodObject<{
         duration_ms: z.ZodNumber;
+        score: z.ZodOptional<z.ZodNumber>;
     }, "strip", z.ZodTypeAny, {
         duration_ms: number;
+        score?: number | undefined;
     }, {
         duration_ms: number;
+        score?: number | undefined;
     }>;
 }, "strip", z.ZodTypeAny, {
+    stats: {
+        duration_ms: number;
+        score?: number | undefined;
+    };
     status: "PASS" | "FAIL" | "SKIP" | "ERROR";
     summary: Record<string, "PASS" | "FAIL" | "SKIP" | "ERROR">;
     failures: {
@@ -476,10 +625,11 @@ export declare const ReportSchema: z.ZodObject<{
         files?: string[] | undefined;
         hint?: string | undefined;
     }[];
+}, {
     stats: {
         duration_ms: number;
+        score?: number | undefined;
     };
-}, {
     status: "PASS" | "FAIL" | "SKIP" | "ERROR";
     summary: Record<string, "PASS" | "FAIL" | "SKIP" | "ERROR">;
     failures: {
@@ -489,8 +639,5 @@ export declare const ReportSchema: z.ZodObject<{
         files?: string[] | undefined;
         hint?: string | undefined;
     }[];
-    stats: {
-        duration_ms: number;
-    };
 }>;
 export type Report = z.infer<typeof ReportSchema>;