@ipation/specbridge 1.2.0 → 1.3.0

package/dist/index.d.ts

@@ -33,6 +33,22 @@ interface DecisionContent {
     context?: string;
     consequences?: string[];
 }
+/**
+ * Exception to a constraint
+ */
+interface ConstraintException {
+    pattern: string;
+    reason: string;
+    approvedBy?: string;
+    expiresAt?: string;
+}
+/**
+ * Structured verifier check specification
+ */
+interface ConstraintCheck {
+    verifier: string;
+    params?: Record<string, unknown>;
+}
 /**
  * A single constraint within a decision
  */
@@ -43,18 +59,10 @@ interface Constraint {
     severity: Severity;
     scope: string;
     verifier?: string;
+    check?: ConstraintCheck;
     autofix?: boolean;
     exceptions?: ConstraintException[];
 }
-/**
- * Exception to a constraint
- */
-interface ConstraintException {
-    pattern: string;
-    reason: string;
-    approvedBy?: string;
-    expiresAt?: string;
-}
 /**
  * Automated verification configuration
  */
@@ -167,6 +175,27 @@ interface LevelConfig {
     timeout?: number;
     severity?: Severity[];
 }
+/**
+ * Warning during verification (non-blocking)
+ */
+interface VerificationWarning {
+    type: 'missing_verifier' | 'invalid_pattern' | 'other';
+    message: string;
+    decisionId: string;
+    constraintId: string;
+    file?: string;
+}
+/**
+ * Error during verification (continued after error)
+ */
+interface VerificationIssue {
+    type: 'verifier_exception' | 'file_read_error' | 'other';
+    message: string;
+    decisionId?: string;
+    constraintId?: string;
+    file?: string;
+    stack?: string;
+}
 /**
  * Result of a verification run
  */
@@ -178,6 +207,8 @@ interface VerificationResult {
     failed: number;
     skipped: number;
     duration: number;
+    warnings?: VerificationWarning[];
+    errors?: VerificationIssue[];
 }
 /**
  * Result of an inference run
@@ -350,6 +381,16 @@ declare const ConstraintExceptionSchema: z.ZodObject<{
     approvedBy?: string | undefined;
     expiresAt?: string | undefined;
 }>;
+declare const ConstraintCheckSchema: z.ZodObject<{
+    verifier: z.ZodString;
+    params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    verifier: string;
+    params?: Record<string, unknown> | undefined;
+}, {
+    verifier: string;
+    params?: Record<string, unknown> | undefined;
+}>;
 declare const ConstraintSchema: z.ZodObject<{
     id: z.ZodString;
     type: z.ZodEnum<["invariant", "convention", "guideline"]>;
@@ -357,6 +398,16 @@ declare const ConstraintSchema: z.ZodObject<{
     severity: z.ZodEnum<["critical", "high", "medium", "low"]>;
     scope: z.ZodString;
     verifier: z.ZodOptional<z.ZodString>;
+    check: z.ZodOptional<z.ZodObject<{
+        verifier: z.ZodString;
+        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        verifier: string;
+        params?: Record<string, unknown> | undefined;
+    }, {
+        verifier: string;
+        params?: Record<string, unknown> | undefined;
+    }>>;
     autofix: z.ZodOptional<z.ZodBoolean>;
     exceptions: z.ZodOptional<z.ZodArray<z.ZodObject<{
         pattern: z.ZodString;
@@ -381,6 +432,10 @@ declare const ConstraintSchema: z.ZodObject<{
     severity: "critical" | "high" | "medium" | "low";
     scope: string;
     verifier?: string | undefined;
+    check?: {
+        verifier: string;
+        params?: Record<string, unknown> | undefined;
+    } | undefined;
     autofix?: boolean | undefined;
     exceptions?: {
         pattern: string;
@@ -395,6 +450,10 @@ declare const ConstraintSchema: z.ZodObject<{
     severity: "critical" | "high" | "medium" | "low";
     scope: string;
     verifier?: string | undefined;
+    check?: {
+        verifier: string;
+        params?: Record<string, unknown> | undefined;
+    } | undefined;
     autofix?: boolean | undefined;
     exceptions?: {
         pattern: string;
@@ -485,6 +544,16 @@ declare const DecisionSchema: z.ZodObject<{
         severity: z.ZodEnum<["critical", "high", "medium", "low"]>;
         scope: z.ZodString;
         verifier: z.ZodOptional<z.ZodString>;
+        check: z.ZodOptional<z.ZodObject<{
+            verifier: z.ZodString;
+            params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, "strip", z.ZodTypeAny, {
+            verifier: string;
+            params?: Record<string, unknown> | undefined;
+        }, {
+            verifier: string;
+            params?: Record<string, unknown> | undefined;
+        }>>;
         autofix: z.ZodOptional<z.ZodBoolean>;
         exceptions: z.ZodOptional<z.ZodArray<z.ZodObject<{
             pattern: z.ZodString;
@@ -509,6 +578,10 @@ declare const DecisionSchema: z.ZodObject<{
         severity: "critical" | "high" | "medium" | "low";
         scope: string;
         verifier?: string | undefined;
+        check?: {
+            verifier: string;
+            params?: Record<string, unknown> | undefined;
+        } | undefined;
         autofix?: boolean | undefined;
         exceptions?: {
             pattern: string;
@@ -523,6 +596,10 @@ declare const DecisionSchema: z.ZodObject<{
         severity: "critical" | "high" | "medium" | "low";
         scope: string;
         verifier?: string | undefined;
+        check?: {
+            verifier: string;
+            params?: Record<string, unknown> | undefined;
+        } | undefined;
         autofix?: boolean | undefined;
         exceptions?: {
             pattern: string;
@@ -601,6 +678,10 @@ declare const DecisionSchema: z.ZodObject<{
         severity: "critical" | "high" | "medium" | "low";
         scope: string;
         verifier?: string | undefined;
+        check?: {
+            verifier: string;
+            params?: Record<string, unknown> | undefined;
+        } | undefined;
         autofix?: boolean | undefined;
         exceptions?: {
             pattern: string;
@@ -647,6 +728,10 @@ declare const DecisionSchema: z.ZodObject<{
         severity: "critical" | "high" | "medium" | "low";
         scope: string;
         verifier?: string | undefined;
+        check?: {
+            verifier: string;
+            params?: Record<string, unknown> | undefined;
+        } | undefined;
         autofix?: boolean | undefined;
         exceptions?: {
             pattern: string;
@@ -676,6 +761,7 @@ type VerificationFrequencySchema_ = z.infer<typeof VerificationFrequencySchema>;
 type DecisionMetadataSchema_ = z.infer<typeof DecisionMetadataSchema>;
 type DecisionContentSchema_ = z.infer<typeof DecisionContentSchema>;
 type ConstraintExceptionSchema_ = z.infer<typeof ConstraintExceptionSchema>;
+type ConstraintCheckSchema_ = z.infer<typeof ConstraintCheckSchema>;
 type ConstraintSchema_ = z.infer<typeof ConstraintSchema>;
 type VerificationConfigSchema_ = z.infer<typeof VerificationConfigSchema>;
 type DecisionTypeSchema = z.infer<typeof DecisionSchema>;
@@ -1378,6 +1464,45 @@ declare function getAnalyzer(id: string): Analyzer | null;
  */
 declare function getAnalyzerIds(): string[];
 
+/**
+ * Entry in the explanation trace
+ */
+interface ExplanationEntry {
+    file: string;
+    decision: Decision;
+    constraint: Constraint;
+    applied: boolean;
+    reason: string;
+    selectedVerifier?: string;
+    verifierOutput?: {
+        violations: number;
+        duration: number;
+        error?: string;
+    };
+}
+/**
+ * Reporter for --explain mode
+ */
+declare class ExplainReporter {
+    private entries;
+    /**
+     * Add an entry to the explanation trace
+     */
+    add(entry: ExplanationEntry): void;
+    /**
+     * Print the explanation trace
+     */
+    print(): void;
+    /**
+     * Get all entries
+     */
+    getEntries(): ExplanationEntry[];
+    /**
+     * Clear all entries
+     */
+    clear(): void;
+}
+
 interface VerificationOptions {
     level?: VerificationLevel;
     files?: string[];
@@ -1385,6 +1510,7 @@ interface VerificationOptions {
     severity?: Severity[];
     timeout?: number;
     cwd?: string;
+    reporter?: ExplainReporter;
 }
 /**
  * Verification Engine class
@@ -1401,7 +1527,11 @@ declare class VerificationEngine {
     /**
      * Verify a single file
      */
-    verifyFile(filePath: string, decisions: Decision[], severityFilter?: Severity[], cwd?: string): Promise<Violation[]>;
+    verifyFile(filePath: string, decisions: Decision[], severityFilter?: Severity[], cwd?: string, reporter?: ExplainReporter): Promise<{
+        violations: Violation[];
+        warnings: VerificationWarning[];
+        errors: VerificationIssue[];
+    }>;
     /**
      * Verify multiple files
      */
@@ -1573,9 +1703,12 @@ declare function getVerifier(id: string): Verifier | null;
  */
 declare function getVerifierIds(): string[];
 /**
- * Select appropriate verifier based on constraint rule
+ * Select appropriate verifier based on constraint
  */
-declare function selectVerifierForConstraint(rule: string, specifiedVerifier?: string): Verifier | null;
+declare function selectVerifierForConstraint(rule: string, specifiedVerifier?: string, check?: {
+    verifier: string;
+    params?: Record<string, unknown>;
+}): Verifier | null;
 
 interface AutofixPatch {
     filePath: string;
@@ -2020,4 +2153,4 @@ declare function matchesAnyPattern(filePath: string, patterns: string[], options
     cwd?: string;
 }): boolean;
 
-export { type AffectedFile, type AgentContext, AgentContextGenerator, AlreadyInitializedError, type Analyzer, AnalyzerNotFoundError, ApiVerifier, type ApplicableConstraint, type ApplicableDecision, AstCache, AutofixEngine, type AutofixPatch, type AutofixResult, CodeScanner, ComplexityVerifier, type ComplianceReport, ConfigError, type Constraint, type ConstraintException, ConstraintExceptionSchema, type ConstraintExceptionSchema_, ConstraintSchema, type ConstraintSchema_, type ConstraintType, ConstraintTypeSchema, type ConstraintTypeSchema_, type ContextOptions, type Decision, type DecisionCompliance, type DecisionContent, DecisionContentSchema, type DecisionContentSchema_, type DecisionFilter, type DecisionMetadata, DecisionMetadataSchema, type DecisionMetadataSchema_, DecisionNotFoundError, DecisionSchema, type DecisionStatus, DecisionStatusSchema, type DecisionStatusSchema_, type DecisionTypeSchema, DecisionValidationError, type DependencyGraph, DependencyVerifier, type DriftAnalysis, ErrorsAnalyzer, ErrorsVerifier, FileSystemError, type GlobOptions, type GraphNode, HookError, type ImpactAnalysis, ImportsAnalyzer, ImportsVerifier, InferenceEngine, InferenceError, type InferenceOptions, type InferenceResult, type LevelConfig, LinksSchema, type LoadError, type LoadResult, type LoadedDecision, type McpServerOptions, type MigrationStep, NamingAnalyzer, NamingVerifier, NotInitializedError, type OverallDrift, type Pattern, type PatternExample, type PromptTemplate, PropagationEngine, type PropagationOptions, RegexVerifier, Registry, type RegistryConstraintMatch, RegistryError, type RegistryOptions, type ReportOptions, ReportStorage, Reporter, type ScanOptions, type ScanResult, type ScannedFile, SecurityVerifier, type Severity, SeveritySchema, type SeveritySchema_, type SpecBridgeConfig, SpecBridgeConfigSchema, type SpecBridgeConfigType, SpecBridgeError, SpecBridgeMcpServer, type StoredReport, StructureAnalyzer, type TextEdit, type TrendAnalysis, type TrendData, type TrendDirection, type VerificationConfig, VerificationConfigSchema, type VerificationConfigSchema_, type VerificationContext, VerificationEngine, VerificationError, type VerificationFrequency, VerificationFrequencySchema, type VerificationFrequencySchema_, type VerificationLevel, type VerificationOptions, type VerificationResult, type Verifier, VerifierNotFoundError, type Violation, type ViolationFix, analyzeTrend, buildDependencyGraph, builtinAnalyzers, builtinVerifiers, calculateConfidence, checkDegradation, createInferenceEngine, createPattern, createPropagationEngine, createRegistry, createScannerFromConfig, createVerificationEngine, createViolation, defaultConfig, detectDrift, ensureDir, extractSnippet, formatConsoleReport, formatContextAsJson, formatContextAsMarkdown, formatContextAsMcp, formatError, formatMarkdownReport, formatValidationErrors, generateContext, generateFormattedContext, generateReport, getAffectedFiles, getAffectingDecisions, getAnalyzer, getAnalyzerIds, getChangedFiles, getConfigPath, getDecisionsDir, getInferredDir, getReportsDir, getSpecBridgeDir, getTransitiveDependencies, getVerifier, getVerifierIds, getVerifiersDir, glob, isConstraintExcepted, isDirectory, loadConfig, loadDecisionFile, loadDecisionsFromDir, matchesAnyPattern, matchesPattern, mergeWithDefaults, normalizePath, parseYaml, parseYamlDocument, pathExists, readFilesInDir, readTextFile, runInference, selectVerifierForConstraint, shouldApplyConstraintToFile, stringifyYaml, templates, updateYamlDocument, validateConfig, validateDecision, validateDecisionFile, writeTextFile };
+export { type AffectedFile, type AgentContext, AgentContextGenerator, AlreadyInitializedError, type Analyzer, AnalyzerNotFoundError, ApiVerifier, type ApplicableConstraint, type ApplicableDecision, AstCache, AutofixEngine, type AutofixPatch, type AutofixResult, CodeScanner, ComplexityVerifier, type ComplianceReport, ConfigError, type Constraint, type ConstraintCheck, ConstraintCheckSchema, type ConstraintCheckSchema_, type ConstraintException, ConstraintExceptionSchema, type ConstraintExceptionSchema_, ConstraintSchema, type ConstraintSchema_, type ConstraintType, ConstraintTypeSchema, type ConstraintTypeSchema_, type ContextOptions, type Decision, type DecisionCompliance, type DecisionContent, DecisionContentSchema, type DecisionContentSchema_, type DecisionFilter, type DecisionMetadata, DecisionMetadataSchema, type DecisionMetadataSchema_, DecisionNotFoundError, DecisionSchema, type DecisionStatus, DecisionStatusSchema, type DecisionStatusSchema_, type DecisionTypeSchema, DecisionValidationError, type DependencyGraph, DependencyVerifier, type DriftAnalysis, ErrorsAnalyzer, ErrorsVerifier, FileSystemError, type GlobOptions, type GraphNode, HookError, type ImpactAnalysis, ImportsAnalyzer, ImportsVerifier, InferenceEngine, InferenceError, type InferenceOptions, type InferenceResult, type LevelConfig, LinksSchema, type LoadError, type LoadResult, type LoadedDecision, type McpServerOptions, type MigrationStep, NamingAnalyzer, NamingVerifier, NotInitializedError, type OverallDrift, type Pattern, type PatternExample, type PromptTemplate, PropagationEngine, type PropagationOptions, RegexVerifier, Registry, type RegistryConstraintMatch, RegistryError, type RegistryOptions, type ReportOptions, ReportStorage, Reporter, type ScanOptions, type ScanResult, type ScannedFile, SecurityVerifier, type Severity, SeveritySchema, type SeveritySchema_, type SpecBridgeConfig, SpecBridgeConfigSchema, type SpecBridgeConfigType, SpecBridgeError, SpecBridgeMcpServer, type StoredReport, StructureAnalyzer, type TextEdit, type TrendAnalysis, type TrendData, type TrendDirection, type VerificationConfig, VerificationConfigSchema, type VerificationConfigSchema_, type VerificationContext, VerificationEngine, VerificationError, type VerificationFrequency, VerificationFrequencySchema, type VerificationFrequencySchema_, type VerificationIssue, type VerificationLevel, type VerificationOptions, type VerificationResult, type VerificationWarning, type Verifier, VerifierNotFoundError, type Violation, type ViolationFix, analyzeTrend, buildDependencyGraph, builtinAnalyzers, builtinVerifiers, calculateConfidence, checkDegradation, createInferenceEngine, createPattern, createPropagationEngine, createRegistry, createScannerFromConfig, createVerificationEngine, createViolation, defaultConfig, detectDrift, ensureDir, extractSnippet, formatConsoleReport, formatContextAsJson, formatContextAsMarkdown, formatContextAsMcp, formatError, formatMarkdownReport, formatValidationErrors, generateContext, generateFormattedContext, generateReport, getAffectedFiles, getAffectingDecisions, getAnalyzer, getAnalyzerIds, getChangedFiles, getConfigPath, getDecisionsDir, getInferredDir, getReportsDir, getSpecBridgeDir, getTransitiveDependencies, getVerifier, getVerifierIds, getVerifiersDir, glob, isConstraintExcepted, isDirectory, loadConfig, loadDecisionFile, loadDecisionsFromDir, matchesAnyPattern, matchesPattern, mergeWithDefaults, normalizePath, parseYaml, parseYamlDocument, pathExists, readFilesInDir, readTextFile, runInference, selectVerifierForConstraint, shouldApplyConstraintToFile, stringifyYaml, templates, updateYamlDocument, validateConfig, validateDecision, validateDecisionFile, writeTextFile };

package/dist/index.js

@@ -26,6 +26,10 @@ var ConstraintExceptionSchema = z.object({
   approvedBy: z.string().optional(),
   expiresAt: z.string().datetime().optional()
 });
+var ConstraintCheckSchema = z.object({
+  verifier: z.string().min(1),
+  params: z.record(z.unknown()).optional()
+});
 var ConstraintSchema = z.object({
   id: z.string().min(1).regex(/^[a-z0-9-]+$/, "Constraint ID must be lowercase alphanumeric with hyphens"),
   type: ConstraintTypeSchema,
@@ -33,6 +37,7 @@ var ConstraintSchema = z.object({
   severity: SeveritySchema,
   scope: z.string().min(1),
   verifier: z.string().optional(),
+  check: ConstraintCheckSchema.optional(),
   autofix: z.boolean().optional(),
   exceptions: z.array(ConstraintExceptionSchema).optional()
 });
@@ -1577,6 +1582,7 @@ async function runInference(config, options) {
 
 // src/verification/engine.ts
 import { Project as Project2 } from "ts-morph";
+import chalk from "chalk";
 
 // src/verification/verifiers/base.ts
 function createViolation(params) {
@@ -2577,7 +2583,10 @@ function getVerifier(id) {
 function getVerifierIds() {
   return Object.keys(builtinVerifiers);
 }
-function selectVerifierForConstraint(rule, specifiedVerifier) {
+function selectVerifierForConstraint(rule, specifiedVerifier, check) {
+  if (check?.verifier) {
+    return getVerifier(check.verifier);
+  }
   if (specifiedVerifier) {
     return getVerifier(specifiedVerifier);
   }
@@ -2708,10 +2717,14 @@ var VerificationEngine = class {
         passed: 0,
         failed: 0,
         skipped: 0,
-        duration: Date.now() - startTime
+        duration: Date.now() - startTime,
+        warnings: [],
+        errors: []
       };
     }
     const allViolations = [];
+    const allWarnings = [];
+    const allErrors = [];
     let checked = 0;
     let passed = 0;
     let failed = 0;
@@ -2726,8 +2739,11 @@ var VerificationEngine = class {
       decisions,
       severityFilter,
       cwd,
-      (violations) => {
+      options.reporter,
+      (violations, warnings, errors) => {
         allViolations.push(...violations);
+        allWarnings.push(...warnings);
+        allErrors.push(...errors);
         checked++;
         if (violations.length > 0) {
           failed++;
@@ -2747,7 +2763,9 @@ var VerificationEngine = class {
           passed,
           failed,
           skipped: filesToVerify.length - checked,
-          duration: timeout
+          duration: timeout,
+          warnings: allWarnings,
+          errors: allErrors
         };
       }
     } finally {
@@ -2772,23 +2790,64 @@ var VerificationEngine = class {
       passed,
       failed,
       skipped,
-      duration: Date.now() - startTime
+      duration: Date.now() - startTime,
+      warnings: allWarnings,
+      errors: allErrors
     };
   }
   /**
    * Verify a single file
    */
-  async verifyFile(filePath, decisions, severityFilter, cwd = process.cwd()) {
+  async verifyFile(filePath, decisions, severityFilter, cwd = process.cwd(), reporter) {
     const violations = [];
+    const warnings = [];
+    const errors = [];
     const sourceFile = await this.astCache.get(filePath, this.project);
-    if (!sourceFile) return violations;
+    if (!sourceFile) return { violations, warnings, errors };
     for (const decision of decisions) {
       for (const constraint of decision.constraints) {
         if (!shouldApplyConstraintToFile({ filePath, constraint, cwd, severityFilter })) {
+          if (reporter) {
+            reporter.add({
+              file: filePath,
+              decision,
+              constraint,
+              applied: false,
+              reason: "File does not match scope pattern or severity filter"
+            });
+          }
           continue;
         }
-        const verifier = selectVerifierForConstraint(constraint.rule, constraint.verifier);
+        const verifier = selectVerifierForConstraint(
+          constraint.rule,
+          constraint.verifier,
+          constraint.check
+        );
         if (!verifier) {
+          const requestedVerifier = constraint.check?.verifier || constraint.verifier || "auto-detected";
+          console.warn(
+            chalk.yellow(
+              `Warning: No verifier found for ${decision.metadata.id}/${constraint.id}
+  Requested: ${requestedVerifier}
+  Available: ${getVerifierIds().join(", ")}`
+            )
+          );
+          warnings.push({
+            type: "missing_verifier",
+            message: `No verifier found for constraint (requested: ${requestedVerifier})`,
+            decisionId: decision.metadata.id,
+            constraintId: constraint.id,
+            file: filePath
+          });
+          if (reporter) {
+            reporter.add({
+              file: filePath,
+              decision,
+              constraint,
+              applied: false,
+              reason: `No verifier found (requested: ${requestedVerifier})`
+            });
+          }
           continue;
         }
         const ctx = {
@@ -2797,27 +2856,78 @@ var VerificationEngine = class {
           constraint,
           decisionId: decision.metadata.id
         };
+        const verificationStart = Date.now();
         try {
           const constraintViolations = await verifier.verify(ctx);
           violations.push(...constraintViolations);
-        } catch {
+          if (reporter) {
+            reporter.add({
+              file: filePath,
+              decision,
+              constraint,
+              applied: true,
+              reason: "Constraint matches file scope",
+              selectedVerifier: verifier.id,
+              verifierOutput: {
+                violations: constraintViolations.length,
+                duration: Date.now() - verificationStart
+              }
+            });
+          }
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          const errorStack = error instanceof Error ? error.stack : void 0;
+          console.error(
+            chalk.red(
+              `Error: Verifier '${verifier.id}' failed
+  File: ${filePath}
+  Decision: ${decision.metadata.id}/${constraint.id}
+  Error: ${errorMessage}`
+            )
+          );
+          if (errorStack) {
+            console.error(chalk.dim(errorStack));
+          }
+          errors.push({
+            type: "verifier_exception",
+            message: `Verifier '${verifier.id}' failed: ${errorMessage}`,
+            decisionId: decision.metadata.id,
+            constraintId: constraint.id,
+            file: filePath,
+            stack: errorStack
+          });
+          if (reporter) {
+            reporter.add({
+              file: filePath,
+              decision,
+              constraint,
+              applied: true,
+              reason: "Constraint matches file scope",
+              selectedVerifier: verifier.id,
+              verifierOutput: {
+                violations: 0,
+                duration: Date.now() - verificationStart,
+                error: errorMessage
+              }
+            });
+          }
         }
       }
     }
-    return violations;
+    return { violations, warnings, errors };
   }
   /**
    * Verify multiple files
    */
-  async verifyFiles(files, decisions, severityFilter, cwd, onFileVerified) {
+  async verifyFiles(files, decisions, severityFilter, cwd, reporter, onFileVerified) {
     const BATCH_SIZE = 10;
     for (let i = 0; i < files.length; i += BATCH_SIZE) {
       const batch = files.slice(i, i + BATCH_SIZE);
       const results = await Promise.all(
-        batch.map((file) => this.verifyFile(file, decisions, severityFilter, cwd))
+        batch.map((file) => this.verifyFile(file, decisions, severityFilter, cwd, reporter))
       );
-      for (const violations of results) {
-        onFileVerified(violations);
+      for (const result of results) {
+        onFileVerified(result.violations, result.warnings, result.errors);
       }
     }
   }
@@ -3375,54 +3485,54 @@ var Reporter = class {
 };
 
 // src/reporting/formats/console.ts
-import chalk from "chalk";
+import chalk2 from "chalk";
 import { table } from "table";
 function formatConsoleReport(report) {
   const lines = [];
   lines.push("");
-  lines.push(chalk.bold.blue("SpecBridge Compliance Report"));
-  lines.push(chalk.dim(`Generated: ${new Date(report.timestamp).toLocaleString()}`));
-  lines.push(chalk.dim(`Project: ${report.project}`));
+  lines.push(chalk2.bold.blue("SpecBridge Compliance Report"));
+  lines.push(chalk2.dim(`Generated: ${new Date(report.timestamp).toLocaleString()}`));
+  lines.push(chalk2.dim(`Project: ${report.project}`));
   lines.push("");
   const complianceColor = getComplianceColor(report.summary.compliance);
-  lines.push(chalk.bold("Overall Compliance"));
+  lines.push(chalk2.bold("Overall Compliance"));
   lines.push(`  ${complianceColor(formatComplianceBar(report.summary.compliance))} ${complianceColor(`${report.summary.compliance}%`)}`);
   lines.push("");
-  lines.push(chalk.bold("Summary"));
+  lines.push(chalk2.bold("Summary"));
   lines.push(`  Decisions: ${report.summary.activeDecisions} active / ${report.summary.totalDecisions} total`);
   lines.push(`  Constraints: ${report.summary.totalConstraints}`);
   lines.push("");
-  lines.push(chalk.bold("Violations"));
+  lines.push(chalk2.bold("Violations"));
   const { violations } = report.summary;
   const violationParts = [];
   if (violations.critical > 0) {
-    violationParts.push(chalk.red(`${violations.critical} critical`));
+    violationParts.push(chalk2.red(`${violations.critical} critical`));
   }
   if (violations.high > 0) {
-    violationParts.push(chalk.yellow(`${violations.high} high`));
+    violationParts.push(chalk2.yellow(`${violations.high} high`));
   }
   if (violations.medium > 0) {
-    violationParts.push(chalk.cyan(`${violations.medium} medium`));
+    violationParts.push(chalk2.cyan(`${violations.medium} medium`));
   }
   if (violations.low > 0) {
-    violationParts.push(chalk.dim(`${violations.low} low`));
+    violationParts.push(chalk2.dim(`${violations.low} low`));
   }
   if (violationParts.length > 0) {
     lines.push(`  ${violationParts.join(" | ")}`);
   } else {
-    lines.push(chalk.green("  No violations"));
+    lines.push(chalk2.green("  No violations"));
   }
   lines.push("");
   if (report.byDecision.length > 0) {
-    lines.push(chalk.bold("By Decision"));
+    lines.push(chalk2.bold("By Decision"));
     lines.push("");
     const tableData = [
       [
-        chalk.bold("Decision"),
-        chalk.bold("Status"),
-        chalk.bold("Constraints"),
-        chalk.bold("Violations"),
-        chalk.bold("Compliance")
+        chalk2.bold("Decision"),
+        chalk2.bold("Status"),
+        chalk2.bold("Constraints"),
+        chalk2.bold("Violations"),
+        chalk2.bold("Compliance")
       ]
     ];
     for (const dec of report.byDecision) {
@@ -3432,7 +3542,7 @@ function formatConsoleReport(report) {
         truncate(dec.title, 40),
         statusColor(dec.status),
         String(dec.constraints),
-        dec.violations > 0 ? chalk.red(String(dec.violations)) : chalk.green("0"),
+        dec.violations > 0 ? chalk2.red(String(dec.violations)) : chalk2.green("0"),
         compColor(`${dec.compliance}%`)
       ]);
     }
@@ -3466,23 +3576,23 @@ function formatComplianceBar(compliance) {
   return "\u2588".repeat(filled) + "\u2591".repeat(empty);
 }
 function getComplianceColor(compliance) {
-  if (compliance >= 90) return chalk.green;
-  if (compliance >= 70) return chalk.yellow;
-  if (compliance >= 50) return chalk.hex("#FFA500");
-  return chalk.red;
+  if (compliance >= 90) return chalk2.green;
+  if (compliance >= 70) return chalk2.yellow;
+  if (compliance >= 50) return chalk2.hex("#FFA500");
+  return chalk2.red;
 }
 function getStatusColor(status) {
   switch (status) {
     case "active":
-      return chalk.green;
+      return chalk2.green;
     case "draft":
-      return chalk.yellow;
+      return chalk2.yellow;
     case "deprecated":
-      return chalk.gray;
+      return chalk2.gray;
     case "superseded":
-      return chalk.blue;
+      return chalk2.blue;
     default:
-      return chalk.white;
+      return chalk2.white;
   }
 }
 function truncate(str, length) {
@@ -4269,6 +4379,7 @@ export {
   CodeScanner,
   ComplexityVerifier,
   ConfigError,
+  ConstraintCheckSchema,
   ConstraintExceptionSchema,
   ConstraintSchema,
   ConstraintTypeSchema,