@rigour-labs/core 2.22.0 → 3.0.1

package/dist/templates/index.js

@@ -135,6 +135,167 @@ export const TEMPLATES = [
             ],
         },
     },
+    // --- Regulated Industry Presets ---
+    {
+        name: 'healthcare',
+        markers: [
+            'hl7', 'fhir', 'hipaa', 'medical', 'patient', 'health',
+            'ehr', 'phi', 'dicom', 'icd-10', 'snomed',
+        ],
+        config: {
+            preset: 'healthcare',
+            ignore: [
+                '.git/**', 'node_modules/**', 'dist/**', 'build/**',
+                'venv/**', '.venv/**', '__pycache__/**',
+            ],
+            gates: {
+                max_file_lines: 300,
+                required_files: ['docs/COMPLIANCE.md', 'docs/SPEC.md', 'docs/ARCH.md', 'README.md'],
+                security: {
+                    enabled: true,
+                    sql_injection: true,
+                    xss: true,
+                    path_traversal: true,
+                    hardcoded_secrets: true,
+                    insecure_randomness: true,
+                    command_injection: true,
+                    block_on_severity: 'critical',
+                },
+            },
+        },
+    },
+    {
+        name: 'fintech',
+        markers: [
+            'trading', 'payment', 'kyc', 'aml', 'pci', 'transaction',
+            'ledger', 'banking', 'stripe', 'plaid', 'sox',
+        ],
+        config: {
+            preset: 'fintech',
+            ignore: [
+                '.git/**', 'node_modules/**', 'dist/**', 'build/**',
+                'venv/**', '.venv/**', '__pycache__/**', 'vendor/**',
+            ],
+            gates: {
+                max_file_lines: 350,
+                required_files: ['docs/AUDIT_LOG.md', 'docs/SPEC.md', 'docs/ARCH.md', 'README.md'],
+                security: {
+                    enabled: true,
+                    sql_injection: true,
+                    xss: true,
+                    path_traversal: true,
+                    hardcoded_secrets: true,
+                    insecure_randomness: true,
+                    command_injection: true,
+                    block_on_severity: 'high',
+                },
+                agent_team: {
+                    enabled: true,
+                    max_concurrent_agents: 3,
+                    cross_agent_pattern_check: true,
+                    handoff_verification: true,
+                    task_ownership: 'strict',
+                },
+            },
+        },
+    },
+    {
+        name: 'government',
+        markers: [
+            'fedramp', 'nist', 'cmmc', 'federal', 'govcloud',
+            'il4', 'il5', 'fisma', 'itar', 'cui',
+        ],
+        config: {
+            preset: 'government',
+            ignore: [
+                '.git/**', 'node_modules/**', 'dist/**', 'build/**',
+                'venv/**', '.venv/**', '__pycache__/**', 'vendor/**',
+            ],
+            gates: {
+                max_file_lines: 250,
+                required_files: ['docs/SECURITY.md', 'docs/SPEC.md', 'docs/ARCH.md', 'README.md'],
+                ast: {
+                    complexity: 8,
+                    max_methods: 10,
+                    max_params: 4,
+                    max_nesting: 3,
+                    max_inheritance_depth: 3,
+                    max_class_dependencies: 5,
+                    max_function_lines: 40,
+                },
+                security: {
+                    enabled: true,
+                    sql_injection: true,
+                    xss: true,
+                    path_traversal: true,
+                    hardcoded_secrets: true,
+                    insecure_randomness: true,
+                    command_injection: true,
+                    block_on_severity: 'medium',
+                },
+                agent_team: {
+                    enabled: true,
+                    max_concurrent_agents: 3,
+                    cross_agent_pattern_check: true,
+                    handoff_verification: true,
+                    task_ownership: 'strict',
+                },
+                checkpoint: {
+                    enabled: true,
+                    interval_minutes: 10,
+                    quality_threshold: 85,
+                    drift_detection: true,
+                    auto_save_on_failure: true,
+                },
+            },
+        },
+    },
+    // DevSecOps / Security SRE preset
+    {
+        name: 'devsecops',
+        markers: [
+            'trivy', 'snyk', 'semgrep', 'sonarqube', 'owasp',
+            'sast', 'dast', 'pentest', 'vulnerability', 'cve',
+            'security-scan', 'falco', 'wazuh', 'ossec',
+        ],
+        config: {
+            preset: 'devsecops',
+            ignore: [
+                '.git/**', 'node_modules/**', 'dist/**', 'build/**',
+                'venv/**', '.venv/**', '__pycache__/**', 'vendor/**',
+            ],
+            gates: {
+                max_file_lines: 300,
+                required_files: ['docs/SECURITY.md', 'docs/RUNBOOK.md', 'README.md'],
+                ast: {
+                    complexity: 10,
+                    max_methods: 10,
+                    max_params: 5,
+                    max_nesting: 3,
+                    max_inheritance_depth: 3,
+                    max_class_dependencies: 5,
+                    max_function_lines: 50,
+                },
+                security: {
+                    enabled: true,
+                    sql_injection: true,
+                    xss: true,
+                    path_traversal: true,
+                    hardcoded_secrets: true,
+                    insecure_randomness: true,
+                    command_injection: true,
+                    block_on_severity: 'high',
+                },
+                agent_team: {
+                    enabled: true,
+                    max_concurrent_agents: 3,
+                    cross_agent_pattern_check: true,
+                    handoff_verification: true,
+                    task_ownership: 'strict',
+                },
+            },
+        },
+    },
 ];
 export const PARADIGM_TEMPLATES = [
     {
@@ -312,6 +473,21 @@ export const UNIVERSAL_CONFIG = {
             degradation_threshold: 0.4,
             signals_required: 2,
         },
+        promise_safety: {
+            enabled: true,
+            check_unhandled_then: true,
+            check_unsafe_parse: true,
+            check_async_without_await: true,
+            check_unsafe_fetch: true,
+            ignore_patterns: [],
+        },
+    },
+    hooks: {
+        enabled: false,
+        tools: [],
+        fast_gates: ['hallucinated-imports', 'promise-safety', 'security-patterns', 'file-size'],
+        timeout_ms: 5000,
+        block_on_failure: false,
     },
     output: {
         report_path: 'rigour-report.json',

package/dist/types/fix-packet.d.ts

@@ -9,7 +9,7 @@ export declare const FixPacketV2Schema: z.ZodObject<{
     violations: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         gate: z.ZodString;
-        severity: z.ZodDefault<z.ZodEnum<["low", "medium", "high", "critical"]>>;
+        severity: z.ZodDefault<z.ZodEnum<["info", "low", "medium", "high", "critical"]>>;
         category: z.ZodOptional<z.ZodString>;
         title: z.ZodString;
         details: z.ZodString;
@@ -21,7 +21,7 @@ export declare const FixPacketV2Schema: z.ZodObject<{
         id: string;
         title: string;
         details: string;
-        severity: "critical" | "high" | "medium" | "low";
+        severity: "critical" | "high" | "medium" | "low" | "info";
         gate: string;
         files?: string[] | undefined;
         hint?: string | undefined;
@@ -33,7 +33,7 @@ export declare const FixPacketV2Schema: z.ZodObject<{
         title: string;
         details: string;
         gate: string;
-        severity?: "critical" | "high" | "medium" | "low" | undefined;
+        severity?: "critical" | "high" | "medium" | "low" | "info" | undefined;
         files?: string[] | undefined;
         hint?: string | undefined;
         category?: string | undefined;
@@ -69,7 +69,7 @@ export declare const FixPacketV2Schema: z.ZodObject<{
         id: string;
         title: string;
         details: string;
-        severity: "critical" | "high" | "medium" | "low";
+        severity: "critical" | "high" | "medium" | "low" | "info";
         gate: string;
         files?: string[] | undefined;
         hint?: string | undefined;
@@ -92,7 +92,7 @@ export declare const FixPacketV2Schema: z.ZodObject<{
         title: string;
         details: string;
         gate: string;
-        severity?: "critical" | "high" | "medium" | "low" | undefined;
+        severity?: "critical" | "high" | "medium" | "low" | "info" | undefined;
         files?: string[] | undefined;
         hint?: string | undefined;
         category?: string | undefined;

package/dist/types/fix-packet.js

@@ -9,7 +9,7 @@ export const FixPacketV2Schema = z.object({
     violations: z.array(z.object({
         id: z.string(),
         gate: z.string(),
-        severity: z.enum(['low', 'medium', 'high', 'critical']).default('medium'),
+        severity: z.enum(['info', 'low', 'medium', 'high', 'critical']).default('medium'),
         category: z.string().optional(),
         title: z.string(),
         details: z.string(),

package/dist/types/index.d.ts

@@ -293,6 +293,28 @@ export declare const GatesSchema: z.ZodObject<{
         degradation_threshold?: number | undefined;
         signals_required?: number | undefined;
     }>>>;
+    promise_safety: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        check_unhandled_then: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        check_unsafe_parse: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        check_async_without_await: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        check_unsafe_fetch: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        ignore_patterns: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        ignore_patterns: string[];
+        check_unhandled_then: boolean;
+        check_unsafe_parse: boolean;
+        check_async_without_await: boolean;
+        check_unsafe_fetch: boolean;
+    }, {
+        enabled?: boolean | undefined;
+        ignore_patterns?: string[] | undefined;
+        check_unhandled_then?: boolean | undefined;
+        check_unsafe_parse?: boolean | undefined;
+        check_async_without_await?: boolean | undefined;
+        check_unsafe_fetch?: boolean | undefined;
+    }>>>;
 }, "strip", z.ZodTypeAny, {
     max_file_lines: number;
     forbid_todos: boolean;
@@ -403,6 +425,14 @@ export declare const GatesSchema: z.ZodObject<{
         degradation_threshold: number;
         signals_required: number;
     };
+    promise_safety: {
+        enabled: boolean;
+        ignore_patterns: string[];
+        check_unhandled_then: boolean;
+        check_unsafe_parse: boolean;
+        check_async_without_await: boolean;
+        check_unsafe_fetch: boolean;
+    };
 }, {
     max_file_lines?: number | undefined;
     forbid_todos?: boolean | undefined;
@@ -513,6 +543,14 @@ export declare const GatesSchema: z.ZodObject<{
         degradation_threshold?: number | undefined;
         signals_required?: number | undefined;
     } | undefined;
+    promise_safety?: {
+        enabled?: boolean | undefined;
+        ignore_patterns?: string[] | undefined;
+        check_unhandled_then?: boolean | undefined;
+        check_unsafe_parse?: boolean | undefined;
+        check_async_without_await?: boolean | undefined;
+        check_unsafe_fetch?: boolean | undefined;
+    } | undefined;
 }>;
 export declare const CommandsSchema: z.ZodObject<{
     format: z.ZodOptional<z.ZodString>;
@@ -530,6 +568,25 @@ export declare const CommandsSchema: z.ZodObject<{
     typecheck?: string | undefined;
     test?: string | undefined;
 }>;
+export declare const HooksSchema: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    tools: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodEnum<["claude", "cursor", "cline", "windsurf"]>, "many">>>;
+    fast_gates: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+    timeout_ms: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    block_on_failure: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    enabled: boolean;
+    tools: ("claude" | "cursor" | "cline" | "windsurf")[];
+    fast_gates: string[];
+    timeout_ms: number;
+    block_on_failure: boolean;
+}, {
+    enabled?: boolean | undefined;
+    tools?: ("claude" | "cursor" | "cline" | "windsurf")[] | undefined;
+    fast_gates?: string[] | undefined;
+    timeout_ms?: number | undefined;
+    block_on_failure?: boolean | undefined;
+}>>>;
 export declare const ConfigSchema: z.ZodObject<{
     version: z.ZodDefault<z.ZodNumber>;
     preset: z.ZodOptional<z.ZodString>;
@@ -844,6 +901,28 @@ export declare const ConfigSchema: z.ZodObject<{
             degradation_threshold?: number | undefined;
             signals_required?: number | undefined;
         }>>>;
+        promise_safety: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            check_unhandled_then: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            check_unsafe_parse: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            check_async_without_await: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            check_unsafe_fetch: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            ignore_patterns: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            ignore_patterns: string[];
+            check_unhandled_then: boolean;
+            check_unsafe_parse: boolean;
+            check_async_without_await: boolean;
+            check_unsafe_fetch: boolean;
+        }, {
+            enabled?: boolean | undefined;
+            ignore_patterns?: string[] | undefined;
+            check_unhandled_then?: boolean | undefined;
+            check_unsafe_parse?: boolean | undefined;
+            check_async_without_await?: boolean | undefined;
+            check_unsafe_fetch?: boolean | undefined;
+        }>>>;
     }, "strip", z.ZodTypeAny, {
         max_file_lines: number;
         forbid_todos: boolean;
@@ -954,6 +1033,14 @@ export declare const ConfigSchema: z.ZodObject<{
             degradation_threshold: number;
             signals_required: number;
         };
+        promise_safety: {
+            enabled: boolean;
+            ignore_patterns: string[];
+            check_unhandled_then: boolean;
+            check_unsafe_parse: boolean;
+            check_async_without_await: boolean;
+            check_unsafe_fetch: boolean;
+        };
     }, {
         max_file_lines?: number | undefined;
         forbid_todos?: boolean | undefined;
@@ -1064,6 +1151,33 @@ export declare const ConfigSchema: z.ZodObject<{
             degradation_threshold?: number | undefined;
             signals_required?: number | undefined;
         } | undefined;
+        promise_safety?: {
+            enabled?: boolean | undefined;
+            ignore_patterns?: string[] | undefined;
+            check_unhandled_then?: boolean | undefined;
+            check_unsafe_parse?: boolean | undefined;
+            check_async_without_await?: boolean | undefined;
+            check_unsafe_fetch?: boolean | undefined;
+        } | undefined;
+    }>>>;
+    hooks: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        tools: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodEnum<["claude", "cursor", "cline", "windsurf"]>, "many">>>;
+        fast_gates: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+        timeout_ms: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        block_on_failure: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        tools: ("claude" | "cursor" | "cline" | "windsurf")[];
+        fast_gates: string[];
+        timeout_ms: number;
+        block_on_failure: boolean;
+    }, {
+        enabled?: boolean | undefined;
+        tools?: ("claude" | "cursor" | "cline" | "windsurf")[] | undefined;
+        fast_gates?: string[] | undefined;
+        timeout_ms?: number | undefined;
+        block_on_failure?: boolean | undefined;
     }>>>;
     output: z.ZodDefault<z.ZodOptional<z.ZodObject<{
         report_path: z.ZodDefault<z.ZodString>;
@@ -1193,6 +1307,21 @@ export declare const ConfigSchema: z.ZodObject<{
             degradation_threshold: number;
             signals_required: number;
         };
+        promise_safety: {
+            enabled: boolean;
+            ignore_patterns: string[];
+            check_unhandled_then: boolean;
+            check_unsafe_parse: boolean;
+            check_async_without_await: boolean;
+            check_unsafe_fetch: boolean;
+        };
+    };
+    hooks: {
+        enabled: boolean;
+        tools: ("claude" | "cursor" | "cline" | "windsurf")[];
+        fast_gates: string[];
+        timeout_ms: number;
+        block_on_failure: boolean;
     };
     output: {
         report_path: string;
@@ -1321,6 +1450,21 @@ export declare const ConfigSchema: z.ZodObject<{
             degradation_threshold?: number | undefined;
             signals_required?: number | undefined;
         } | undefined;
+        promise_safety?: {
+            enabled?: boolean | undefined;
+            ignore_patterns?: string[] | undefined;
+            check_unhandled_then?: boolean | undefined;
+            check_unsafe_parse?: boolean | undefined;
+            check_async_without_await?: boolean | undefined;
+            check_unsafe_fetch?: boolean | undefined;
+        } | undefined;
+    } | undefined;
+    hooks?: {
+        enabled?: boolean | undefined;
+        tools?: ("claude" | "cursor" | "cline" | "windsurf")[] | undefined;
+        fast_gates?: string[] | undefined;
+        timeout_ms?: number | undefined;
+        block_on_failure?: boolean | undefined;
     } | undefined;
     output?: {
         report_path?: string | undefined;
@@ -1329,14 +1473,19 @@ export declare const ConfigSchema: z.ZodObject<{
 }>;
 export type Gates = z.infer<typeof GatesSchema>;
 export type Commands = z.infer<typeof CommandsSchema>;
+export type Hooks = z.infer<typeof HooksSchema>;
 export type Config = z.infer<typeof ConfigSchema>;
 export type RawGates = z.input<typeof GatesSchema>;
 export type RawCommands = z.input<typeof CommandsSchema>;
+export type RawHooks = z.input<typeof HooksSchema>;
 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 SeveritySchema: z.ZodEnum<["critical", "high", "medium", "low", "info"]>;
 export type Severity = z.infer<typeof SeveritySchema>;
+/** Provenance tags — lets dashboards/agents filter by what matters */
+export declare const ProvenanceSchema: z.ZodEnum<["ai-drift", "traditional", "security", "governance"]>;
+export type Provenance = z.infer<typeof ProvenanceSchema>;
 /** Severity weights for score calculation */
 export declare const SEVERITY_WEIGHTS: Record<Severity, number>;
 export declare const FailureSchema: z.ZodObject<{
@@ -1344,6 +1493,7 @@ export declare const FailureSchema: z.ZodObject<{
     title: z.ZodString;
     details: z.ZodString;
     severity: z.ZodOptional<z.ZodEnum<["critical", "high", "medium", "low", "info"]>>;
+    provenance: z.ZodOptional<z.ZodEnum<["ai-drift", "traditional", "security", "governance"]>>;
     files: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     line: z.ZodOptional<z.ZodNumber>;
     endLine: z.ZodOptional<z.ZodNumber>;
@@ -1353,6 +1503,7 @@ export declare const FailureSchema: z.ZodObject<{
     title: string;
     details: string;
     severity?: "critical" | "high" | "medium" | "low" | "info" | undefined;
+    provenance?: "security" | "ai-drift" | "traditional" | "governance" | undefined;
     files?: string[] | undefined;
     line?: number | undefined;
     endLine?: number | undefined;
@@ -1362,6 +1513,7 @@ export declare const FailureSchema: z.ZodObject<{
     title: string;
     details: string;
     severity?: "critical" | "high" | "medium" | "low" | "info" | undefined;
+    provenance?: "security" | "ai-drift" | "traditional" | "governance" | undefined;
     files?: string[] | undefined;
     line?: number | undefined;
     endLine?: number | undefined;
@@ -1376,6 +1528,7 @@ export declare const ReportSchema: z.ZodObject<{
         title: z.ZodString;
         details: z.ZodString;
         severity: z.ZodOptional<z.ZodEnum<["critical", "high", "medium", "low", "info"]>>;
+        provenance: z.ZodOptional<z.ZodEnum<["ai-drift", "traditional", "security", "governance"]>>;
         files: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
         line: z.ZodOptional<z.ZodNumber>;
         endLine: z.ZodOptional<z.ZodNumber>;
@@ -1385,6 +1538,7 @@ export declare const ReportSchema: z.ZodObject<{
         title: string;
         details: string;
         severity?: "critical" | "high" | "medium" | "low" | "info" | undefined;
+        provenance?: "security" | "ai-drift" | "traditional" | "governance" | undefined;
         files?: string[] | undefined;
         line?: number | undefined;
         endLine?: number | undefined;
@@ -1394,6 +1548,7 @@ export declare const ReportSchema: z.ZodObject<{
         title: string;
         details: string;
         severity?: "critical" | "high" | "medium" | "low" | "info" | undefined;
+        provenance?: "security" | "ai-drift" | "traditional" | "governance" | undefined;
         files?: string[] | undefined;
         line?: number | undefined;
         endLine?: number | undefined;
@@ -1402,21 +1557,63 @@ export declare const ReportSchema: z.ZodObject<{
     stats: z.ZodObject<{
         duration_ms: z.ZodNumber;
         score: z.ZodOptional<z.ZodNumber>;
+        ai_health_score: z.ZodOptional<z.ZodNumber>;
+        structural_score: z.ZodOptional<z.ZodNumber>;
         severity_breakdown: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+        provenance_breakdown: z.ZodOptional<z.ZodObject<{
+            'ai-drift': z.ZodNumber;
+            traditional: z.ZodNumber;
+            security: z.ZodNumber;
+            governance: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            security: number;
+            'ai-drift': number;
+            traditional: number;
+            governance: number;
+        }, {
+            security: number;
+            'ai-drift': number;
+            traditional: number;
+            governance: number;
+        }>>;
     }, "strip", z.ZodTypeAny, {
         duration_ms: number;
         score?: number | undefined;
+        ai_health_score?: number | undefined;
+        structural_score?: number | undefined;
         severity_breakdown?: Record<string, number> | undefined;
+        provenance_breakdown?: {
+            security: number;
+            'ai-drift': number;
+            traditional: number;
+            governance: number;
+        } | undefined;
     }, {
         duration_ms: number;
         score?: number | undefined;
+        ai_health_score?: number | undefined;
+        structural_score?: number | undefined;
         severity_breakdown?: Record<string, number> | undefined;
+        provenance_breakdown?: {
+            security: number;
+            'ai-drift': number;
+            traditional: number;
+            governance: number;
+        } | undefined;
     }>;
 }, "strip", z.ZodTypeAny, {
     stats: {
         duration_ms: number;
         score?: number | undefined;
+        ai_health_score?: number | undefined;
+        structural_score?: number | undefined;
         severity_breakdown?: Record<string, number> | undefined;
+        provenance_breakdown?: {
+            security: number;
+            'ai-drift': number;
+            traditional: number;
+            governance: number;
+        } | undefined;
     };
     status: "PASS" | "FAIL" | "SKIP" | "ERROR";
     summary: Record<string, "PASS" | "FAIL" | "SKIP" | "ERROR">;
@@ -1425,6 +1622,7 @@ export declare const ReportSchema: z.ZodObject<{
         title: string;
         details: string;
         severity?: "critical" | "high" | "medium" | "low" | "info" | undefined;
+        provenance?: "security" | "ai-drift" | "traditional" | "governance" | undefined;
         files?: string[] | undefined;
         line?: number | undefined;
         endLine?: number | undefined;
@@ -1434,7 +1632,15 @@ export declare const ReportSchema: z.ZodObject<{
     stats: {
         duration_ms: number;
         score?: number | undefined;
+        ai_health_score?: number | undefined;
+        structural_score?: number | undefined;
         severity_breakdown?: Record<string, number> | undefined;
+        provenance_breakdown?: {
+            security: number;
+            'ai-drift': number;
+            traditional: number;
+            governance: number;
+        } | undefined;
     };
     status: "PASS" | "FAIL" | "SKIP" | "ERROR";
     summary: Record<string, "PASS" | "FAIL" | "SKIP" | "ERROR">;
@@ -1443,6 +1649,7 @@ export declare const ReportSchema: z.ZodObject<{
         title: string;
         details: string;
         severity?: "critical" | "high" | "medium" | "low" | "info" | undefined;
+        provenance?: "security" | "ai-drift" | "traditional" | "governance" | undefined;
         files?: string[] | undefined;
         line?: number | undefined;
         endLine?: number | undefined;

package/dist/types/index.js

@@ -129,6 +129,14 @@ export const GatesSchema = z.object({
         degradation_threshold: z.number().min(0).max(1).optional().default(0.4),
         signals_required: z.number().optional().default(2),
     }).optional().default({}),
+    promise_safety: z.object({
+        enabled: z.boolean().optional().default(true),
+        check_unhandled_then: z.boolean().optional().default(true),
+        check_unsafe_parse: z.boolean().optional().default(true),
+        check_async_without_await: z.boolean().optional().default(true),
+        check_unsafe_fetch: z.boolean().optional().default(true),
+        ignore_patterns: z.array(z.string()).optional().default([]),
+    }).optional().default({}),
 });
 export const CommandsSchema = z.object({
     format: z.string().optional(),
@@ -136,12 +144,25 @@ export const CommandsSchema = z.object({
     typecheck: z.string().optional(),
     test: z.string().optional(),
 });
+export const HooksSchema = z.object({
+    enabled: z.boolean().optional().default(false),
+    tools: z.array(z.enum(['claude', 'cursor', 'cline', 'windsurf'])).optional().default([]),
+    fast_gates: z.array(z.string()).optional().default([
+        'hallucinated-imports',
+        'promise-safety',
+        'security-patterns',
+        'file-size',
+    ]),
+    timeout_ms: z.number().optional().default(5000),
+    block_on_failure: z.boolean().optional().default(false),
+}).optional().default({});
 export const ConfigSchema = z.object({
     version: z.number().default(1),
     preset: z.string().optional(),
     paradigm: z.string().optional(),
     commands: CommandsSchema.optional().default({}),
     gates: GatesSchema.optional().default({}),
+    hooks: HooksSchema,
     output: z.object({
         report_path: z.string().default('rigour-report.json'),
     }).optional().default({}),
@@ -150,6 +171,8 @@ export const ConfigSchema = z.object({
 });
 export const StatusSchema = z.enum(['PASS', 'FAIL', 'SKIP', 'ERROR']);
 export const SeveritySchema = z.enum(['critical', 'high', 'medium', 'low', 'info']);
+/** Provenance tags — lets dashboards/agents filter by what matters */
+export const ProvenanceSchema = z.enum(['ai-drift', 'traditional', 'security', 'governance']);
 /** Severity weights for score calculation */
 export const SEVERITY_WEIGHTS = {
     critical: 20,
@@ -163,6 +186,7 @@ export const FailureSchema = z.object({
     title: z.string(),
     details: z.string(),
     severity: SeveritySchema.optional(),
+    provenance: ProvenanceSchema.optional(),
     files: z.array(z.string()).optional(),
     line: z.number().optional(),
     endLine: z.number().optional(),
@@ -175,6 +199,14 @@ export const ReportSchema = z.object({
     stats: z.object({
         duration_ms: z.number(),
         score: z.number().optional(),
+        ai_health_score: z.number().optional(),
+        structural_score: z.number().optional(),
         severity_breakdown: z.record(z.number()).optional(),
+        provenance_breakdown: z.object({
+            'ai-drift': z.number(),
+            traditional: z.number(),
+            security: z.number(),
+            governance: z.number(),
+        }).optional(),
     }),
 });