@ipation/specbridge 2.3.0 → 2.4.2

package/dist/index.js

@@ -464,12 +464,7 @@ import fg from "fast-glob";
 import { minimatch } from "minimatch";
 import { relative, isAbsolute } from "path";
 async function glob(patterns, options = {}) {
-  const {
-    cwd = process.cwd(),
-    ignore = [],
-    absolute = false,
-    onlyFiles = true
-  } = options;
+  const { cwd = process.cwd(), ignore = [], absolute = false, onlyFiles = true } = options;
   return fg(patterns, {
     cwd,
     ignore,
@@ -612,17 +607,13 @@ var Registry = class {
    * Get decisions by tag
    */
   getByTag(tag) {
-    return this.getAll().filter(
-      (d) => d.metadata.tags?.includes(tag)
-    );
+    return this.getAll().filter((d) => d.metadata.tags?.includes(tag));
   }
   /**
    * Get decisions by owner
    */
   getByOwner(owner) {
-    return this.getAll().filter(
-      (d) => d.metadata.owners.includes(owner)
-    );
+    return this.getAll().filter((d) => d.metadata.owners.includes(owner));
   }
   /**
    * Apply filter to decisions
@@ -633,21 +624,15 @@ var Registry = class {
         return false;
       }
       if (filter.tags) {
-        const hasTags = filter.tags.some(
-          (tag) => decision.metadata.tags?.includes(tag)
-        );
+        const hasTags = filter.tags.some((tag) => decision.metadata.tags?.includes(tag));
         if (!hasTags) return false;
       }
       if (filter.constraintType) {
-        const hasType = decision.constraints.some(
-          (c) => filter.constraintType?.includes(c.type)
-        );
+        const hasType = decision.constraints.some((c) => filter.constraintType?.includes(c.type));
         if (!hasType) return false;
       }
       if (filter.severity) {
-        const hasSeverity = decision.constraints.some(
-          (c) => filter.severity?.includes(c.severity)
-        );
+        const hasSeverity = decision.constraints.some((c) => filter.severity?.includes(c.severity));
         if (!hasSeverity) return false;
       }
       return true;
@@ -905,12 +890,24 @@ var FUNCTION_PATTERNS = [
   { convention: "snake_case", regex: /^[a-z][a-z0-9_]*$/, description: "Functions use snake_case" }
 ];
 var INTERFACE_PATTERNS = [
-  { convention: "PascalCase", regex: /^[A-Z][a-zA-Z0-9]*$/, description: "Interfaces use PascalCase" },
-  { convention: "IPrefixed", regex: /^I[A-Z][a-zA-Z0-9]*$/, description: "Interfaces are prefixed with I" }
+  {
+    convention: "PascalCase",
+    regex: /^[A-Z][a-zA-Z0-9]*$/,
+    description: "Interfaces use PascalCase"
+  },
+  {
+    convention: "IPrefixed",
+    regex: /^I[A-Z][a-zA-Z0-9]*$/,
+    description: "Interfaces are prefixed with I"
+  }
 ];
 var TYPE_PATTERNS = [
   { convention: "PascalCase", regex: /^[A-Z][a-zA-Z0-9]*$/, description: "Types use PascalCase" },
-  { convention: "TSuffixed", regex: /^[A-Z][a-zA-Z0-9]*Type$/, description: "Types are suffixed with Type" }
+  {
+    convention: "TSuffixed",
+    regex: /^[A-Z][a-zA-Z0-9]*Type$/,
+    description: "Types are suffixed with Type"
+  }
 ];
 var NamingAnalyzer = class {
   id = "naming";
@@ -931,7 +928,10 @@ var NamingAnalyzer = class {
   analyzeClassNaming(scanner) {
     const classes = scanner.findClasses();
     if (classes.length < 3) return null;
-    const matches = this.findBestMatch(classes.map((c) => c.name), CLASS_PATTERNS);
+    const matches = this.findBestMatch(
+      classes.map((c) => c.name),
+      CLASS_PATTERNS
+    );
     if (!matches) return null;
     return createPattern(this.id, {
       id: "naming-classes",
@@ -955,7 +955,10 @@ var NamingAnalyzer = class {
   analyzeFunctionNaming(scanner) {
     const functions = scanner.findFunctions();
     if (functions.length < 3) return null;
-    const matches = this.findBestMatch(functions.map((f) => f.name), FUNCTION_PATTERNS);
+    const matches = this.findBestMatch(
+      functions.map((f) => f.name),
+      FUNCTION_PATTERNS
+    );
     if (!matches) return null;
     return createPattern(this.id, {
       id: "naming-functions",
@@ -979,7 +982,10 @@ var NamingAnalyzer = class {
   analyzeInterfaceNaming(scanner) {
     const interfaces = scanner.findInterfaces();
     if (interfaces.length < 3) return null;
-    const matches = this.findBestMatch(interfaces.map((i) => i.name), INTERFACE_PATTERNS);
+    const matches = this.findBestMatch(
+      interfaces.map((i) => i.name),
+      INTERFACE_PATTERNS
+    );
     if (!matches) return null;
     return createPattern(this.id, {
       id: "naming-interfaces",
@@ -1003,7 +1009,10 @@ var NamingAnalyzer = class {
   analyzeTypeNaming(scanner) {
     const types = scanner.findTypeAliases();
     if (types.length < 3) return null;
-    const matches = this.findBestMatch(types.map((t) => t.name), TYPE_PATTERNS);
+    const matches = this.findBestMatch(
+      types.map((t) => t.name),
+      TYPE_PATTERNS
+    );
     if (!matches) return null;
     return createPattern(this.id, {
       id: "naming-types",
@@ -1092,8 +1101,12 @@ var ImportsAnalyzer = class {
   analyzeRelativeImports(scanner) {
     const imports = scanner.findImports();
     const relativeImports = imports.filter((i) => i.module.startsWith("."));
-    const absoluteImports = imports.filter((i) => !i.module.startsWith(".") && !i.module.startsWith("@"));
-    const aliasImports = imports.filter((i) => i.module.startsWith("@/") || i.module.startsWith("~"));
+    const absoluteImports = imports.filter(
+      (i) => !i.module.startsWith(".") && !i.module.startsWith("@")
+    );
+    const aliasImports = imports.filter(
+      (i) => i.module.startsWith("@/") || i.module.startsWith("~")
+    );
     const total = relativeImports.length + absoluteImports.length + aliasImports.length;
     if (total < 10) return null;
     if (aliasImports.length > relativeImports.length && aliasImports.length >= 5) {
@@ -1160,18 +1173,20 @@ var ImportsAnalyzer = class {
     for (const [packageName, data] of moduleCounts) {
       if (data.count >= 5) {
         const confidence = Math.min(100, 50 + data.count * 2);
-        patterns.push(createPattern(this.id, {
-          id: `imports-module-${packageName.replace(/[/@]/g, "-")}`,
-          name: `${packageName} Usage`,
-          description: `${packageName} is used across ${data.count} files`,
-          confidence,
-          occurrences: data.count,
-          examples: data.examples.slice(0, 3).map((i) => ({
-            file: i.file,
-            line: i.line,
-            snippet: `import { ${i.named.slice(0, 2).join(", ") || "..."} } from '${i.module}'`
-          }))
-        }));
+        patterns.push(
+          createPattern(this.id, {
+            id: `imports-module-${packageName.replace(/[/@]/g, "-")}`,
+            name: `${packageName} Usage`,
+            description: `${packageName} is used across ${data.count} files`,
+            confidence,
+            occurrences: data.count,
+            examples: data.examples.slice(0, 3).map((i) => ({
+              file: i.file,
+              line: i.line,
+              snippet: `import { ${i.named.slice(0, 2).join(", ") || "..."} } from '${i.module}'`
+            }))
+          })
+        );
       }
     }
     return patterns;
@@ -1216,24 +1231,26 @@ var StructureAnalyzer = class {
       const count = dirCounts.get(name);
       if (count && count >= 3) {
         const exampleFiles = files.filter((f) => basename(dirname2(f.path)) === name).slice(0, 3);
-        patterns.push(createPattern(this.id, {
-          id: `structure-dir-${name}`,
-          name: `${name}/ Directory Convention`,
-          description,
-          confidence: Math.min(100, 60 + count * 5),
-          occurrences: count,
-          examples: exampleFiles.map((f) => ({
-            file: f.path,
-            line: 1,
-            snippet: basename(f.path)
-          })),
-          suggestedConstraint: {
-            type: "convention",
-            rule: `${name.charAt(0).toUpperCase() + name.slice(1)} should be placed in the ${name}/ directory`,
-            severity: "low",
-            scope: `src/**/${name}/**/*.ts`
-          }
-        }));
+        patterns.push(
+          createPattern(this.id, {
+            id: `structure-dir-${name}`,
+            name: `${name}/ Directory Convention`,
+            description,
+            confidence: Math.min(100, 60 + count * 5),
+            occurrences: count,
+            examples: exampleFiles.map((f) => ({
+              file: f.path,
+              line: 1,
+              snippet: basename(f.path)
+            })),
+            suggestedConstraint: {
+              type: "convention",
+              rule: `${name.charAt(0).toUpperCase() + name.slice(1)} should be placed in the ${name}/ directory`,
+              severity: "low",
+              scope: `src/**/${name}/**/*.ts`
+            }
+          })
+        );
       }
     }
     return patterns;
@@ -1243,29 +1260,55 @@ var StructureAnalyzer = class {
     const suffixPatterns = [
       { suffix: ".test.ts", pattern: /\.test\.ts$/, description: "Test files use .test.ts suffix" },
       { suffix: ".spec.ts", pattern: /\.spec\.ts$/, description: "Test files use .spec.ts suffix" },
-      { suffix: ".types.ts", pattern: /\.types\.ts$/, description: "Type definition files use .types.ts suffix" },
-      { suffix: ".utils.ts", pattern: /\.utils\.ts$/, description: "Utility files use .utils.ts suffix" },
-      { suffix: ".service.ts", pattern: /\.service\.ts$/, description: "Service files use .service.ts suffix" },
-      { suffix: ".controller.ts", pattern: /\.controller\.ts$/, description: "Controller files use .controller.ts suffix" },
-      { suffix: ".model.ts", pattern: /\.model\.ts$/, description: "Model files use .model.ts suffix" },
-      { suffix: ".schema.ts", pattern: /\.schema\.ts$/, description: "Schema files use .schema.ts suffix" }
+      {
+        suffix: ".types.ts",
+        pattern: /\.types\.ts$/,
+        description: "Type definition files use .types.ts suffix"
+      },
+      {
+        suffix: ".utils.ts",
+        pattern: /\.utils\.ts$/,
+        description: "Utility files use .utils.ts suffix"
+      },
+      {
+        suffix: ".service.ts",
+        pattern: /\.service\.ts$/,
+        description: "Service files use .service.ts suffix"
+      },
+      {
+        suffix: ".controller.ts",
+        pattern: /\.controller\.ts$/,
+        description: "Controller files use .controller.ts suffix"
+      },
+      {
+        suffix: ".model.ts",
+        pattern: /\.model\.ts$/,
+        description: "Model files use .model.ts suffix"
+      },
+      {
+        suffix: ".schema.ts",
+        pattern: /\.schema\.ts$/,
+        description: "Schema files use .schema.ts suffix"
+      }
     ];
     for (const { suffix, pattern, description } of suffixPatterns) {
       const matchingFiles = files.filter((f) => pattern.test(f.path));
       if (matchingFiles.length >= 3) {
         const confidence = Math.min(100, 60 + matchingFiles.length * 3);
-        patterns.push(createPattern(this.id, {
-          id: `structure-suffix-${suffix.replace(/\./g, "-")}`,
-          name: `${suffix} File Naming`,
-          description,
-          confidence,
-          occurrences: matchingFiles.length,
-          examples: matchingFiles.slice(0, 3).map((f) => ({
-            file: f.path,
-            line: 1,
-            snippet: basename(f.path)
-          }))
-        }));
+        patterns.push(
+          createPattern(this.id, {
+            id: `structure-suffix-${suffix.replace(/\./g, "-")}`,
+            name: `${suffix} File Naming`,
+            description,
+            confidence,
+            occurrences: matchingFiles.length,
+            examples: matchingFiles.slice(0, 3).map((f) => ({
+              file: f.path,
+              line: 1,
+              snippet: basename(f.path)
+            }))
+          })
+        );
       }
     }
     return patterns;
@@ -1582,7 +1625,6 @@ 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 defineVerifierPlugin(plugin) {
@@ -1644,17 +1686,19 @@ var NamingVerifier = class {
       for (const classDecl of sourceFile.getClasses()) {
         const name = classDecl.getName();
         if (name && !pattern.regex.test(name)) {
-          violations.push(createViolation({
-            decisionId,
-            constraintId: constraint.id,
-            type: constraint.type,
-            severity: constraint.severity,
-            message: `Class "${name}" does not follow ${pattern.description} naming convention`,
-            file: filePath,
-            line: classDecl.getStartLineNumber(),
-            column: classDecl.getStart() - classDecl.getStartLinePos(),
-            suggestion: `Rename to follow ${pattern.description}`
-          }));
+          violations.push(
+            createViolation({
+              decisionId,
+              constraintId: constraint.id,
+              type: constraint.type,
+              severity: constraint.severity,
+              message: `Class "${name}" does not follow ${pattern.description} naming convention`,
+              file: filePath,
+              line: classDecl.getStartLineNumber(),
+              column: classDecl.getStart() - classDecl.getStartLinePos(),
+              suggestion: `Rename to follow ${pattern.description}`
+            })
+          );
         }
       }
     }
@@ -1662,16 +1706,18 @@ var NamingVerifier = class {
       for (const funcDecl of sourceFile.getFunctions()) {
         const name = funcDecl.getName();
         if (name && !pattern.regex.test(name)) {
-          violations.push(createViolation({
-            decisionId,
-            constraintId: constraint.id,
-            type: constraint.type,
-            severity: constraint.severity,
-            message: `Function "${name}" does not follow ${pattern.description} naming convention`,
-            file: filePath,
-            line: funcDecl.getStartLineNumber(),
-            suggestion: `Rename to follow ${pattern.description}`
-          }));
+          violations.push(
+            createViolation({
+              decisionId,
+              constraintId: constraint.id,
+              type: constraint.type,
+              severity: constraint.severity,
+              message: `Function "${name}" does not follow ${pattern.description} naming convention`,
+              file: filePath,
+              line: funcDecl.getStartLineNumber(),
+              suggestion: `Rename to follow ${pattern.description}`
+            })
+          );
         }
       }
     }
@@ -1679,16 +1725,18 @@ var NamingVerifier = class {
       for (const interfaceDecl of sourceFile.getInterfaces()) {
         const name = interfaceDecl.getName();
         if (!pattern.regex.test(name)) {
-          violations.push(createViolation({
-            decisionId,
-            constraintId: constraint.id,
-            type: constraint.type,
-            severity: constraint.severity,
-            message: `Interface "${name}" does not follow ${pattern.description} naming convention`,
-            file: filePath,
-            line: interfaceDecl.getStartLineNumber(),
-            suggestion: `Rename to follow ${pattern.description}`
-          }));
+          violations.push(
+            createViolation({
+              decisionId,
+              constraintId: constraint.id,
+              type: constraint.type,
+              severity: constraint.severity,
+              message: `Interface "${name}" does not follow ${pattern.description} naming convention`,
+              file: filePath,
+              line: interfaceDecl.getStartLineNumber(),
+              suggestion: `Rename to follow ${pattern.description}`
+            })
+          );
         }
       }
     }
@@ -1696,16 +1744,18 @@ var NamingVerifier = class {
       for (const typeAlias of sourceFile.getTypeAliases()) {
         const name = typeAlias.getName();
         if (!pattern.regex.test(name)) {
-          violations.push(createViolation({
-            decisionId,
-            constraintId: constraint.id,
-            type: constraint.type,
-            severity: constraint.severity,
-            message: `Type "${name}" does not follow ${pattern.description} naming convention`,
-            file: filePath,
-            line: typeAlias.getStartLineNumber(),
-            suggestion: `Rename to follow ${pattern.description}`
-          }));
+          violations.push(
+            createViolation({
+              decisionId,
+              constraintId: constraint.id,
+              type: constraint.type,
+              severity: constraint.severity,
+              message: `Type "${name}" does not follow ${pattern.description} naming convention`,
+              file: filePath,
+              line: typeAlias.getStartLineNumber(),
+              suggestion: `Rename to follow ${pattern.description}`
+            })
+          );
         }
       }
     }
@@ -1740,20 +1790,22 @@ var ImportsVerifier = class {
         const ms = importDecl.getModuleSpecifier();
         const start = ms.getStart() + 1;
         const end = ms.getEnd() - 1;
-        violations.push(createViolation({
-          decisionId,
-          constraintId: constraint.id,
-          type: constraint.type,
-          severity: constraint.severity,
-          message: `Relative import "${moduleSpec}" should include a .js extension`,
-          file: filePath,
-          line: importDecl.getStartLineNumber(),
-          suggestion: `Update to "${suggested}"`,
-          autofix: {
-            description: "Add/normalize .js extension in import specifier",
-            edits: [{ start, end, text: suggested }]
-          }
-        }));
+        violations.push(
+          createViolation({
+            decisionId,
+            constraintId: constraint.id,
+            type: constraint.type,
+            severity: constraint.severity,
+            message: `Relative import "${moduleSpec}" should include a .js extension`,
+            file: filePath,
+            line: importDecl.getStartLineNumber(),
+            suggestion: `Update to "${suggested}"`,
+            autofix: {
+              description: "Add/normalize .js extension in import specifier",
+              edits: [{ start, end, text: suggested }]
+            }
+          })
+        );
       }
     }
     if (rule.includes("barrel") || rule.includes("index")) {
@@ -1762,16 +1814,18 @@ var ImportsVerifier = class {
         if (!moduleSpec.startsWith(".")) continue;
         if (moduleSpec.match(/\.(ts|js|tsx|jsx)$/) || moduleSpec.match(/\/[^/]+$/)) {
           if (!moduleSpec.endsWith("/index") && !moduleSpec.endsWith("index")) {
-            violations.push(createViolation({
-              decisionId,
-              constraintId: constraint.id,
-              type: constraint.type,
-              severity: constraint.severity,
-              message: `Import from "${moduleSpec}" should use barrel (index) import`,
-              file: filePath,
-              line: importDecl.getStartLineNumber(),
-              suggestion: "Import from the parent directory index file instead"
-            }));
+            violations.push(
+              createViolation({
+                decisionId,
+                constraintId: constraint.id,
+                type: constraint.type,
+                severity: constraint.severity,
+                message: `Import from "${moduleSpec}" should use barrel (index) import`,
+                file: filePath,
+                line: importDecl.getStartLineNumber(),
+                suggestion: "Import from the parent directory index file instead"
+              })
+            );
           }
         }
       }
@@ -1780,16 +1834,18 @@ var ImportsVerifier = class {
       for (const importDecl of sourceFile.getImportDeclarations()) {
         const moduleSpec = importDecl.getModuleSpecifierValue();
         if (moduleSpec.match(/^\.\.\/\.\.\/\.\.\//)) {
-          violations.push(createViolation({
-            decisionId,
-            constraintId: constraint.id,
-            type: constraint.type,
-            severity: constraint.severity,
-            message: `Deep relative import "${moduleSpec}" should use path alias`,
-            file: filePath,
-            line: importDecl.getStartLineNumber(),
-            suggestion: "Use path alias (e.g., @/module) for deep imports"
-          }));
+          violations.push(
+            createViolation({
+              decisionId,
+              constraintId: constraint.id,
+              type: constraint.type,
+              severity: constraint.severity,
+              message: `Deep relative import "${moduleSpec}" should use path alias`,
+              file: filePath,
+              line: importDecl.getStartLineNumber(),
+              suggestion: "Use path alias (e.g., @/module) for deep imports"
+            })
+          );
         }
       }
     }
@@ -1798,16 +1854,18 @@ var ImportsVerifier = class {
       for (const importDecl of sourceFile.getImportDeclarations()) {
         const moduleSpec = importDecl.getModuleSpecifierValue();
         if (moduleSpec.includes(currentFilename.split("/").pop() || "")) {
-          violations.push(createViolation({
-            decisionId,
-            constraintId: constraint.id,
-            type: constraint.type,
-            severity: constraint.severity,
-            message: `Possible circular import detected: "${moduleSpec}"`,
-            file: filePath,
-            line: importDecl.getStartLineNumber(),
-            suggestion: "Review import structure for circular dependencies"
-          }));
+          violations.push(
+            createViolation({
+              decisionId,
+              constraintId: constraint.id,
+              type: constraint.type,
+              severity: constraint.severity,
+              message: `Possible circular import detected: "${moduleSpec}"`,
+              file: filePath,
+              line: importDecl.getStartLineNumber(),
+              suggestion: "Review import structure for circular dependencies"
+            })
+          );
         }
       }
     }
@@ -1815,16 +1873,18 @@ var ImportsVerifier = class {
       for (const importDecl of sourceFile.getImportDeclarations()) {
         const namespaceImport = importDecl.getNamespaceImport();
         if (namespaceImport) {
-          violations.push(createViolation({
-            decisionId,
-            constraintId: constraint.id,
-            type: constraint.type,
-            severity: constraint.severity,
-            message: `Namespace import "* as ${namespaceImport.getText()}" should use named imports`,
-            file: filePath,
-            line: importDecl.getStartLineNumber(),
-            suggestion: "Use specific named imports instead of namespace import"
-          }));
+          violations.push(
+            createViolation({
+              decisionId,
+              constraintId: constraint.id,
+              type: constraint.type,
+              severity: constraint.severity,
+              message: `Namespace import "* as ${namespaceImport.getText()}" should use named imports`,
+              file: filePath,
+              line: importDecl.getStartLineNumber(),
+              suggestion: "Use specific named imports instead of namespace import"
+            })
+          );
         }
       }
     }
@@ -1850,16 +1910,18 @@ var ErrorsVerifier = class {
         if (!className?.endsWith("Error") && !className?.endsWith("Exception")) continue;
         const extendsClause = classDecl.getExtends();
         if (!extendsClause) {
-          violations.push(createViolation({
-            decisionId,
-            constraintId: constraint.id,
-            type: constraint.type,
-            severity: constraint.severity,
-            message: `Error class "${className}" does not extend any base class`,
-            file: filePath,
-            line: classDecl.getStartLineNumber(),
-            suggestion: requiredBase ? `Extend ${requiredBase}` : "Extend a base error class for consistent error handling"
-          }));
+          violations.push(
+            createViolation({
+              decisionId,
+              constraintId: constraint.id,
+              type: constraint.type,
+              severity: constraint.severity,
+              message: `Error class "${className}" does not extend any base class`,
+              file: filePath,
+              line: classDecl.getStartLineNumber(),
+              suggestion: requiredBase ? `Extend ${requiredBase}` : "Extend a base error class for consistent error handling"
+            })
+          );
         } else if (requiredBase) {
           const baseName = extendsClause.getText();
           if (baseName !== requiredBase && baseName !== "Error") {
@@ -1874,16 +1936,18 @@ var ErrorsVerifier = class {
           if (expression) {
             const text = expression.getText();
             if (text.startsWith("new Error(")) {
-              violations.push(createViolation({
-                decisionId,
-                constraintId: constraint.id,
-                type: constraint.type,
-                severity: constraint.severity,
-                message: "Throwing generic Error instead of custom error class",
-                file: filePath,
-                line: node.getStartLineNumber(),
-                suggestion: "Use a custom error class for better error handling"
-              }));
+              violations.push(
+                createViolation({
+                  decisionId,
+                  constraintId: constraint.id,
+                  type: constraint.type,
+                  severity: constraint.severity,
+                  message: "Throwing generic Error instead of custom error class",
+                  file: filePath,
+                  line: node.getStartLineNumber(),
+                  suggestion: "Use a custom error class for better error handling"
+                })
+              );
             }
           }
         }
@@ -1897,16 +1961,18 @@ var ErrorsVerifier = class {
             const block = catchClause.getBlock();
             const statements = block.getStatements();
             if (statements.length === 0) {
-              violations.push(createViolation({
-                decisionId,
-                constraintId: constraint.id,
-                type: constraint.type,
-                severity: constraint.severity,
-                message: "Empty catch block swallows error without handling",
-                file: filePath,
-                line: catchClause.getStartLineNumber(),
-                suggestion: "Add error handling, logging, or rethrow the error"
-              }));
+              violations.push(
+                createViolation({
+                  decisionId,
+                  constraintId: constraint.id,
+                  type: constraint.type,
+                  severity: constraint.severity,
+                  message: "Empty catch block swallows error without handling",
+                  file: filePath,
+                  line: catchClause.getStartLineNumber(),
+                  suggestion: "Add error handling, logging, or rethrow the error"
+                })
+              );
             }
           }
         }
@@ -1918,16 +1984,18 @@ var ErrorsVerifier = class {
           const expression = node.getExpression();
           const text = expression.getText();
           if (text === "console.error" || text === "console.log") {
-            violations.push(createViolation({
-              decisionId,
-              constraintId: constraint.id,
-              type: constraint.type,
-              severity: constraint.severity,
-              message: `Using ${text} instead of proper logging`,
-              file: filePath,
-              line: node.getStartLineNumber(),
-              suggestion: "Use a proper logging library"
-            }));
+            violations.push(
+              createViolation({
+                decisionId,
+                constraintId: constraint.id,
+                type: constraint.type,
+                severity: constraint.severity,
+                message: `Using ${text} instead of proper logging`,
+                file: filePath,
+                line: node.getStartLineNumber(),
+                suggestion: "Use a proper logging library"
+              })
+            );
           }
         }
       });
@@ -1958,16 +2026,18 @@ var RegexVerifier = class {
         while ((match = regex.exec(fileText)) !== null) {
           const beforeMatch = fileText.substring(0, match.index);
           const lineNumber = beforeMatch.split("\n").length;
-          violations.push(createViolation({
-            decisionId,
-            constraintId: constraint.id,
-            type: constraint.type,
-            severity: constraint.severity,
-            message: `Found forbidden pattern: "${match[0]}"`,
-            file: filePath,
-            line: lineNumber,
-            suggestion: `Remove or replace the pattern matching /${patternToForbid}/`
-          }));
+          violations.push(
+            createViolation({
+              decisionId,
+              constraintId: constraint.id,
+              type: constraint.type,
+              severity: constraint.severity,
+              message: `Found forbidden pattern: "${match[0]}"`,
+              file: filePath,
+              line: lineNumber,
+              suggestion: `Remove or replace the pattern matching /${patternToForbid}/`
+            })
+          );
         }
       } catch {
       }
@@ -1977,15 +2047,17 @@ var RegexVerifier = class {
       try {
         const regex = new RegExp(patternToRequire);
         if (!regex.test(fileText)) {
-          violations.push(createViolation({
-            decisionId,
-            constraintId: constraint.id,
-            type: constraint.type,
-            severity: constraint.severity,
-            message: `File does not contain required pattern: /${patternToRequire}/`,
-            file: filePath,
-            suggestion: `Add code matching /${patternToRequire}/`
-          }));
+          violations.push(
+            createViolation({
+              decisionId,
+              constraintId: constraint.id,
+              type: constraint.type,
+              severity: constraint.severity,
+              message: `File does not contain required pattern: /${patternToRequire}/`,
+              file: filePath,
+              suggestion: `Add code matching /${patternToRequire}/`
+            })
+          );
         }
       } catch {
       }
@@ -2124,7 +2196,9 @@ function parseBannedDependency(rule) {
   return value.length > 0 ? value : null;
 }
 function parseLayerRule(rule) {
-  const m = rule.match(/(\w+)\s{1,5}layer\s{1,5}cannot\s{1,5}depend\s{1,5}on\s{1,5}(\w+)\s{1,5}layer/i);
+  const m = rule.match(
+    /(\w+)\s{1,5}layer\s{1,5}cannot\s{1,5}depend\s{1,5}on\s{1,5}(\w+)\s{1,5}layer/i
+  );
   const fromLayer = m?.[1]?.toLowerCase();
   const toLayer = m?.[2]?.toLowerCase();
   if (!fromLayer || !toLayer) return null;
@@ -2150,22 +2224,25 @@ var DependencyVerifier = class {
       const sccs = tarjanScc(graph);
       const current = projectFilePath;
       for (const scc of sccs) {
-        const hasSelfLoop = scc.length === 1 && (graph.get(scc[0])?.has(scc[0]) ?? false);
+        const first = scc[0];
+        const hasSelfLoop = first !== void 0 && scc.length === 1 && (graph.get(first)?.has(first) ?? false);
         const isCycle = scc.length > 1 || hasSelfLoop;
         if (!isCycle) continue;
         if (!scc.includes(current)) continue;
         const sorted = [...scc].sort();
         if (sorted[0] !== current) continue;
-        violations.push(createViolation({
-          decisionId,
-          constraintId: constraint.id,
-          type: constraint.type,
-          severity: constraint.severity,
-          message: `Circular dependency detected across: ${sorted.join(" -> ")}`,
-          file: filePath,
-          line: 1,
-          suggestion: "Break the cycle by extracting shared abstractions or reversing the dependency"
-        }));
+        violations.push(
+          createViolation({
+            decisionId,
+            constraintId: constraint.id,
+            type: constraint.type,
+            severity: constraint.severity,
+            message: `Circular dependency detected across: ${sorted.join(" -> ")}`,
+            file: filePath,
+            line: 1,
+            suggestion: "Break the cycle by extracting shared abstractions or reversing the dependency"
+          })
+        );
       }
     }
     const layerRule = parseLayerRule(rule);
@@ -2175,16 +2252,18 @@ var DependencyVerifier = class {
         const resolved = resolveToSourceFilePath(project, projectFilePath, moduleSpec);
         if (!resolved) continue;
         if (fileInLayer(resolved, layerRule.toLayer)) {
-          violations.push(createViolation({
-            decisionId,
-            constraintId: constraint.id,
-            type: constraint.type,
-            severity: constraint.severity,
-            message: `Layer violation: ${layerRule.fromLayer} depends on ${layerRule.toLayer} via import "${moduleSpec}"`,
-            file: filePath,
-            line: importDecl.getStartLineNumber(),
-            suggestion: `Refactor to remove dependency from ${layerRule.fromLayer} to ${layerRule.toLayer}`
-          }));
+          violations.push(
+            createViolation({
+              decisionId,
+              constraintId: constraint.id,
+              type: constraint.type,
+              severity: constraint.severity,
+              message: `Layer violation: ${layerRule.fromLayer} depends on ${layerRule.toLayer} via import "${moduleSpec}"`,
+              file: filePath,
+              line: importDecl.getStartLineNumber(),
+              suggestion: `Refactor to remove dependency from ${layerRule.fromLayer} to ${layerRule.toLayer}`
+            })
+          );
         }
       }
     }
@@ -2194,16 +2273,18 @@ var DependencyVerifier = class {
       for (const importDecl of sourceFile.getImportDeclarations()) {
         const moduleSpec = importDecl.getModuleSpecifierValue();
         if (moduleSpec.toLowerCase().includes(bannedLower)) {
-          violations.push(createViolation({
-            decisionId,
-            constraintId: constraint.id,
-            type: constraint.type,
-            severity: constraint.severity,
-            message: `Banned dependency import detected: "${moduleSpec}"`,
-            file: filePath,
-            line: importDecl.getStartLineNumber(),
-            suggestion: `Remove or replace dependency "${banned}"`
-          }));
+          violations.push(
+            createViolation({
+              decisionId,
+              constraintId: constraint.id,
+              type: constraint.type,
+              severity: constraint.severity,
+              message: `Banned dependency import detected: "${moduleSpec}"`,
+              file: filePath,
+              line: importDecl.getStartLineNumber(),
+              suggestion: `Remove or replace dependency "${banned}"`
+            })
+          );
         }
       }
     }
@@ -2214,16 +2295,18 @@ var DependencyVerifier = class {
         if (!moduleSpec.startsWith(".")) continue;
         const depth = (moduleSpec.match(/\.\.\//g) || []).length;
         if (depth > maxDepth) {
-          violations.push(createViolation({
-            decisionId,
-            constraintId: constraint.id,
-            type: constraint.type,
-            severity: constraint.severity,
-            message: `Import depth ${depth} exceeds maximum ${maxDepth}: "${moduleSpec}"`,
-            file: filePath,
-            line: importDecl.getStartLineNumber(),
-            suggestion: "Use a shallower module boundary (or introduce a public entrypoint for this dependency)"
-          }));
+          violations.push(
+            createViolation({
+              decisionId,
+              constraintId: constraint.id,
+              type: constraint.type,
+              severity: constraint.severity,
+              message: `Import depth ${depth} exceeds maximum ${maxDepth}: "${moduleSpec}"`,
+              file: filePath,
+              line: importDecl.getStartLineNumber(),
+              suggestion: "Use a shallower module boundary (or introduce a public entrypoint for this dependency)"
+            })
+          );
         }
       }
     }
@@ -2232,7 +2315,9 @@ var DependencyVerifier = class {
 };
 
 // src/verification/verifiers/complexity.ts
-import { Node as Node4 } from "ts-morph";
+import {
+  Node as Node4
+} from "ts-morph";
 import { SyntaxKind as SyntaxKind2 } from "ts-morph";
 function parseLimit(rule, pattern) {
   const m = rule.match(pattern);
@@ -2316,16 +2401,18 @@ var ComplexityVerifier = class {
     if (maxLines !== null) {
       const lineCount = getFileLineCount(sourceFile.getFullText());
       if (lineCount > maxLines) {
-        violations.push(createViolation({
-          decisionId,
-          constraintId: constraint.id,
-          type: constraint.type,
-          severity: constraint.severity,
-          message: `File has ${lineCount} lines which exceeds maximum ${maxLines}`,
-          file: filePath,
-          line: 1,
-          suggestion: "Split the file into smaller modules"
-        }));
+        violations.push(
+          createViolation({
+            decisionId,
+            constraintId: constraint.id,
+            type: constraint.type,
+            severity: constraint.severity,
+            message: `File has ${lineCount} lines which exceeds maximum ${maxLines}`,
+            file: filePath,
+            line: 1,
+            suggestion: "Split the file into smaller modules"
+          })
+        );
       }
     }
     const functionLikes = [
@@ -2339,46 +2426,52 @@ var ComplexityVerifier = class {
       if (maxComplexity !== null) {
         const complexity = calculateCyclomaticComplexity(fn);
         if (complexity > maxComplexity) {
-          violations.push(createViolation({
-            decisionId,
-            constraintId: constraint.id,
-            type: constraint.type,
-            severity: constraint.severity,
-            message: `Function ${fnName} has cyclomatic complexity ${complexity} which exceeds maximum ${maxComplexity}`,
-            file: filePath,
-            line: fn.getStartLineNumber(),
-            suggestion: "Refactor to reduce branching or extract smaller functions"
-          }));
+          violations.push(
+            createViolation({
+              decisionId,
+              constraintId: constraint.id,
+              type: constraint.type,
+              severity: constraint.severity,
+              message: `Function ${fnName} has cyclomatic complexity ${complexity} which exceeds maximum ${maxComplexity}`,
+              file: filePath,
+              line: fn.getStartLineNumber(),
+              suggestion: "Refactor to reduce branching or extract smaller functions"
+            })
+          );
         }
       }
       if (maxParams !== null) {
         const paramCount = fn.getParameters().length;
         if (paramCount > maxParams) {
-          violations.push(createViolation({
-            decisionId,
-            constraintId: constraint.id,
-            type: constraint.type,
-            severity: constraint.severity,
-            message: `Function ${fnName} has ${paramCount} parameters which exceeds maximum ${maxParams}`,
-            file: filePath,
-            line: fn.getStartLineNumber(),
-            suggestion: "Consider grouping parameters into an options object"
-          }));
+          violations.push(
+            createViolation({
+              decisionId,
+              constraintId: constraint.id,
+              type: constraint.type,
+              severity: constraint.severity,
+              message: `Function ${fnName} has ${paramCount} parameters which exceeds maximum ${maxParams}`,
+              file: filePath,
+              line: fn.getStartLineNumber(),
+              suggestion: "Consider grouping parameters into an options object"
+            })
+          );
         }
       }
       if (maxNesting !== null) {
         const depth = maxNestingDepth(fn);
         if (depth > maxNesting) {
-          violations.push(createViolation({
-            decisionId,
-            constraintId: constraint.id,
-            type: constraint.type,
-            severity: constraint.severity,
-            message: `Function ${fnName} has nesting depth ${depth} which exceeds maximum ${maxNesting}`,
-            file: filePath,
-            line: fn.getStartLineNumber(),
-            suggestion: "Reduce nesting by using early returns or extracting functions"
-          }));
+          violations.push(
+            createViolation({
+              decisionId,
+              constraintId: constraint.id,
+              type: constraint.type,
+              severity: constraint.severity,
+              message: `Function ${fnName} has nesting depth ${depth} which exceeds maximum ${maxNesting}`,
+              file: filePath,
+              line: fn.getStartLineNumber(),
+              suggestion: "Reduce nesting by using early returns or extracting functions"
+            })
+          );
         }
       }
     }
@@ -2414,48 +2507,54 @@ var SecurityVerifier = class {
         if (!init || !isStringLiteralLike(init)) continue;
         const value = init.getText().slice(1, -1);
         if (value.length === 0) continue;
-        violations.push(createViolation({
-          decisionId,
-          constraintId: constraint.id,
-          type: constraint.type,
-          severity: constraint.severity,
-          message: `Possible hardcoded secret in variable "${name}"`,
-          file: filePath,
-          line: vd.getStartLineNumber(),
-          suggestion: "Move secrets to environment variables or a secret manager"
-        }));
+        violations.push(
+          createViolation({
+            decisionId,
+            constraintId: constraint.id,
+            type: constraint.type,
+            severity: constraint.severity,
+            message: `Possible hardcoded secret in variable "${name}"`,
+            file: filePath,
+            line: vd.getStartLineNumber(),
+            suggestion: "Move secrets to environment variables or a secret manager"
+          })
+        );
       }
       for (const pa of sourceFile.getDescendantsOfKind(SyntaxKind3.PropertyAssignment)) {
         const propName = pa.getNameNode().getText();
         if (!SECRET_NAME_RE.test(propName)) continue;
         const init = pa.getInitializer();
         if (!init || !isStringLiteralLike(init)) continue;
-        violations.push(createViolation({
-          decisionId,
-          constraintId: constraint.id,
-          type: constraint.type,
-          severity: constraint.severity,
-          message: `Possible hardcoded secret in object property ${propName}`,
-          file: filePath,
-          line: pa.getStartLineNumber(),
-          suggestion: "Move secrets to environment variables or a secret manager"
-        }));
+        violations.push(
+          createViolation({
+            decisionId,
+            constraintId: constraint.id,
+            type: constraint.type,
+            severity: constraint.severity,
+            message: `Possible hardcoded secret in object property ${propName}`,
+            file: filePath,
+            line: pa.getStartLineNumber(),
+            suggestion: "Move secrets to environment variables or a secret manager"
+          })
+        );
       }
     }
     if (checkEval) {
       for (const call of sourceFile.getDescendantsOfKind(SyntaxKind3.CallExpression)) {
         const exprText = call.getExpression().getText();
         if (exprText === "eval" || exprText === "Function") {
-          violations.push(createViolation({
-            decisionId,
-            constraintId: constraint.id,
-            type: constraint.type,
-            severity: constraint.severity,
-            message: `Unsafe dynamic code execution via ${exprText}()`,
-            file: filePath,
-            line: call.getStartLineNumber(),
-            suggestion: "Avoid eval/Function; use safer alternatives"
-          }));
+          violations.push(
+            createViolation({
+              decisionId,
+              constraintId: constraint.id,
+              type: constraint.type,
+              severity: constraint.severity,
+              message: `Unsafe dynamic code execution via ${exprText}()`,
+              file: filePath,
+              line: call.getStartLineNumber(),
+              suggestion: "Avoid eval/Function; use safer alternatives"
+            })
+          );
         }
       }
     }
@@ -2465,29 +2564,33 @@ var SecurityVerifier = class {
         const propertyAccess = left.asKind(SyntaxKind3.PropertyAccessExpression);
         if (!propertyAccess) continue;
         if (propertyAccess.getName() === "innerHTML") {
-          violations.push(createViolation({
+          violations.push(
+            createViolation({
+              decisionId,
+              constraintId: constraint.id,
+              type: constraint.type,
+              severity: constraint.severity,
+              message: "Potential XSS: assignment to innerHTML",
+              file: filePath,
+              line: bin.getStartLineNumber(),
+              suggestion: "Prefer textContent or a safe templating/escaping strategy"
+            })
+          );
+        }
+      }
+      if (sourceFile.getFullText().includes("dangerouslySetInnerHTML")) {
+        violations.push(
+          createViolation({
             decisionId,
             constraintId: constraint.id,
             type: constraint.type,
             severity: constraint.severity,
-            message: "Potential XSS: assignment to innerHTML",
+            message: "Potential XSS: usage of dangerouslySetInnerHTML",
             file: filePath,
-            line: bin.getStartLineNumber(),
-            suggestion: "Prefer textContent or a safe templating/escaping strategy"
-          }));
-        }
-      }
-      if (sourceFile.getFullText().includes("dangerouslySetInnerHTML")) {
-        violations.push(createViolation({
-          decisionId,
-          constraintId: constraint.id,
-          type: constraint.type,
-          severity: constraint.severity,
-          message: "Potential XSS: usage of dangerouslySetInnerHTML",
-          file: filePath,
-          line: 1,
-          suggestion: "Avoid dangerouslySetInnerHTML or ensure content is sanitized"
-        }));
+            line: 1,
+            suggestion: "Avoid dangerouslySetInnerHTML or ensure content is sanitized"
+          })
+        );
       }
     }
     if (checkSql) {
@@ -2506,31 +2609,35 @@ var SecurityVerifier = class {
         if (!text.includes("select") && !text.includes("insert") && !text.includes("update") && !text.includes("delete")) {
           continue;
         }
-        violations.push(createViolation({
-          decisionId,
-          constraintId: constraint.id,
-          type: constraint.type,
-          severity: constraint.severity,
-          message: "Potential SQL injection: dynamically constructed SQL query",
-          file: filePath,
-          line: call.getStartLineNumber(),
-          suggestion: "Use parameterized queries / prepared statements"
-        }));
+        violations.push(
+          createViolation({
+            decisionId,
+            constraintId: constraint.id,
+            type: constraint.type,
+            severity: constraint.severity,
+            message: "Potential SQL injection: dynamically constructed SQL query",
+            file: filePath,
+            line: call.getStartLineNumber(),
+            suggestion: "Use parameterized queries / prepared statements"
+          })
+        );
       }
     }
     if (checkProto) {
       const text = sourceFile.getFullText();
       if (text.includes("__proto__") || text.includes("constructor.prototype")) {
-        violations.push(createViolation({
-          decisionId,
-          constraintId: constraint.id,
-          type: constraint.type,
-          severity: constraint.severity,
-          message: "Potential prototype pollution pattern detected",
-          file: filePath,
-          line: 1,
-          suggestion: "Avoid writing to __proto__/prototype; validate object keys"
-        }));
+        violations.push(
+          createViolation({
+            decisionId,
+            constraintId: constraint.id,
+            type: constraint.type,
+            severity: constraint.severity,
+            message: "Potential prototype pollution pattern detected",
+            file: filePath,
+            line: 1,
+            suggestion: "Avoid writing to __proto__/prototype; validate object keys"
+          })
+        );
       }
     }
     return violations;
@@ -2570,16 +2677,18 @@ var ApiVerifier = class {
       const pathValue = stringLiteral.getLiteralValue();
       if (typeof pathValue !== "string") continue;
       if (!isKebabPath(pathValue)) {
-        violations.push(createViolation({
-          decisionId,
-          constraintId: constraint.id,
-          type: constraint.type,
-          severity: constraint.severity,
-          message: `Endpoint path "${pathValue}" is not kebab-case`,
-          file: filePath,
-          line: call.getStartLineNumber(),
-          suggestion: "Use lowercase and hyphens in static path segments (e.g., /user-settings)"
-        }));
+        violations.push(
+          createViolation({
+            decisionId,
+            constraintId: constraint.id,
+            type: constraint.type,
+            severity: constraint.severity,
+            message: `Endpoint path "${pathValue}" is not kebab-case`,
+            file: filePath,
+            line: call.getStartLineNumber(),
+            suggestion: "Use lowercase and hyphens in static path segments (e.g., /user-settings)"
+          })
+        );
       }
     }
     return violations;
@@ -2591,10 +2700,36 @@ import { existsSync } from "fs";
 import { join as join3 } from "path";
 import { pathToFileURL } from "url";
 import fg2 from "fast-glob";
+
+// src/utils/logger.ts
+import pino from "pino";
+var defaultOptions = {
+  level: process.env.SPECBRIDGE_LOG_LEVEL || "info",
+  timestamp: pino.stdTimeFunctions.isoTime,
+  base: {
+    service: "specbridge"
+  }
+};
+var destination = pino.destination({
+  fd: 2,
+  // stderr
+  sync: false
+});
+var rootLogger = pino(defaultOptions, destination);
+function getLogger(bindings) {
+  if (!bindings) {
+    return rootLogger;
+  }
+  return rootLogger.child(bindings);
+}
+var logger = getLogger();
+
+// src/verification/plugins/loader.ts
 var PluginLoader = class {
   plugins = /* @__PURE__ */ new Map();
   loaded = false;
   loadErrors = [];
+  logger = getLogger({ module: "verification.plugins.loader" });
   /**
    * Load all plugins from the specified base path
    *
@@ -2617,15 +2752,15 @@ var PluginLoader = class {
       } catch (error) {
         const message = error instanceof Error ? error.message : String(error);
         this.loadErrors.push({ file, error: message });
-        console.warn(`Failed to load plugin from ${file}: ${message}`);
+        this.logger.warn({ file, error: message }, "Failed to load plugin");
       }
     }
     this.loaded = true;
     if (this.plugins.size > 0) {
-      console.error(`Loaded ${this.plugins.size} custom verifier(s)`);
+      this.logger.info({ count: this.plugins.size }, "Loaded custom verifier plugins");
     }
     if (this.loadErrors.length > 0) {
-      console.warn(`Failed to load ${this.loadErrors.length} plugin(s)`);
+      this.logger.warn({ count: this.loadErrors.length }, "Plugin load failures");
     }
   }
   /**
@@ -2734,7 +2869,10 @@ var PluginLoader = class {
       return { success: false, error: `Plugin ${id} requires params but none were provided` };
     }
     if (typeof plugin.paramsSchema !== "object" || !plugin.paramsSchema || !("parse" in plugin.paramsSchema)) {
-      return { success: false, error: `Plugin ${id} has invalid paramsSchema (must be a Zod schema)` };
+      return {
+        success: false,
+        error: `Plugin ${id} has invalid paramsSchema (must be a Zod schema)`
+      };
     }
     const schema = plugin.paramsSchema;
     if (schema.safeParse) {
@@ -2801,8 +2939,9 @@ var builtinVerifiers = {
 };
 var verifierInstances = /* @__PURE__ */ new Map();
 function getVerifier(id) {
-  if (verifierInstances.has(id)) {
-    return verifierInstances.get(id);
+  const pooled = verifierInstances.get(id);
+  if (pooled) {
+    return pooled;
   }
   const pluginLoader2 = getPluginLoader();
   const customVerifier = pluginLoader2.getVerifier(id);
@@ -3007,6 +3146,7 @@ var VerificationEngine = class {
   astCache;
   resultsCache;
   pluginsLoaded = false;
+  logger = getLogger({ module: "verification.engine" });
   constructor(registry) {
     this.registry = registry || createRegistry();
     this.project = new Project2({
@@ -3180,12 +3320,14 @@ var VerificationEngine = class {
         );
         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(", ")}`
-            )
+          this.logger.warn(
+            {
+              decisionId: decision.metadata.id,
+              constraintId: constraint.id,
+              requestedVerifier,
+              availableVerifiers: getVerifierIds()
+            },
+            "No verifier found for constraint"
           );
           warnings.push({
             type: "missing_verifier",
@@ -3232,7 +3374,10 @@ var VerificationEngine = class {
         }
         if (constraint.check?.verifier && constraint.check?.params) {
           const pluginLoader2 = getPluginLoader();
-          const validationResult = pluginLoader2.validateParams(constraint.check.verifier, constraint.check.params);
+          const validationResult = pluginLoader2.validateParams(
+            constraint.check.verifier,
+            constraint.check.params
+          );
           if (!validationResult.success) {
             warnings.push({
               type: "invalid_params",
@@ -3292,17 +3437,17 @@ var VerificationEngine = class {
         } 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}`
-            )
+          this.logger.error(
+            {
+              verifierId: verifier.id,
+              filePath,
+              decisionId: decision.metadata.id,
+              constraintId: constraint.id,
+              error: errorMessage,
+              stack: errorStack
+            },
+            "Verifier execution failed"
           );
-          if (errorStack) {
-            console.error(chalk.dim(errorStack));
-          }
           errors.push({
             type: "verifier_exception",
             message: `Verifier '${verifier.id}' failed: ${errorMessage}`,
@@ -3367,7 +3512,11 @@ import { resolve } from "path";
 var execFileAsync = promisify(execFile);
 async function getChangedFiles(cwd) {
   try {
-    const { stdout: stdout2 } = await execFileAsync("git", ["diff", "--name-only", "--diff-filter=AM", "HEAD"], { cwd });
+    const { stdout: stdout2 } = await execFileAsync(
+      "git",
+      ["diff", "--name-only", "--diff-filter=AM", "HEAD"],
+      { cwd }
+    );
     const rel = stdout2.trim().split("\n").map((s) => s.trim()).filter(Boolean);
     const abs = [];
     for (const file of rel) {
@@ -3438,8 +3587,14 @@ var AutofixEngine = class {
       const edits = [];
       for (const violation of fileViolations) {
         const fix = violation.autofix;
+        if (!fix) {
+          skippedViolations++;
+          continue;
+        }
         if (options.interactive) {
-          const ok = await confirmFix(`Apply fix: ${fix.description} (${filePath}:${violation.line ?? 1})?`);
+          const ok = await confirmFix(
+            `Apply fix: ${fix.description} (${filePath}:${violation.line ?? 1})?`
+          );
           if (!ok) {
             skippedViolations++;
             continue;
@@ -3566,7 +3721,24 @@ var PropagationEngine = class {
     if (!this.graph) {
       await this.initialize(config, options);
     }
-    const affectedFilePaths = getAffectedFiles(this.graph, decisionId);
+    const graph = this.graph;
+    if (!graph) {
+      return {
+        decision: decisionId,
+        change,
+        affectedFiles: [],
+        estimatedEffort: "low",
+        migrationSteps: [
+          {
+            order: 1,
+            description: "Run verification to confirm all violations resolved",
+            files: [],
+            automated: true
+          }
+        ]
+      };
+    }
+    const affectedFilePaths = getAffectedFiles(graph, decisionId);
     const verificationEngine = createVerificationEngine(this.registry);
     const result = await verificationEngine.verify(config, {
       files: affectedFilePaths,
@@ -3599,10 +3771,7 @@ var PropagationEngine = class {
     } else {
       estimatedEffort = "high";
     }
-    const migrationSteps = this.generateMigrationSteps(
-      affectedFiles,
-      totalAutoFixable > 0
-    );
+    const migrationSteps = this.generateMigrationSteps(affectedFiles, totalAutoFixable > 0);
     return {
       decision: decisionId,
       change,
@@ -3625,9 +3794,7 @@ var PropagationEngine = class {
         automated: true
       });
     }
-    const filesWithManualFixes = affectedFiles.filter(
-      (f) => f.violations > f.autoFixable
-    );
+    const filesWithManualFixes = affectedFiles.filter((f) => f.violations > f.autoFixable);
     if (filesWithManualFixes.length > 0) {
       const highPriority = filesWithManualFixes.filter((f) => f.violations > 5);
       const mediumPriority = filesWithManualFixes.filter(
@@ -3707,10 +3874,7 @@ async function generateReport(config, options = {}) {
         medium: decisionViolations.filter((v) => v.severity === "medium").length,
         low: decisionViolations.filter((v) => v.severity === "low").length
       };
-      weightedScore = decisionViolations.reduce(
-        (score, v) => score + weights[v.severity],
-        0
-      );
+      weightedScore = decisionViolations.reduce((score, v) => score + weights[v.severity], 0);
       compliance = Math.max(0, 100 - weightedScore);
       if (decisionViolations.length > 0 && constraintCount > 0) {
         const violationRate = decisionViolations.length / constraintCount;
@@ -3830,7 +3994,9 @@ var Reporter = class {
       lines.push("Summary:");
       lines.push(`  Decisions Checked: ${result.summary.decisionsChecked || 0}`);
       lines.push(`  Files Checked: ${result.summary.filesChecked || 0}`);
-      lines.push(`  Total Violations: ${result.summary.totalViolations || result.violations?.length || 0}`);
+      lines.push(
+        `  Total Violations: ${result.summary.totalViolations || result.violations?.length || 0}`
+      );
       lines.push(`  Critical: ${result.summary.critical || 0}`);
       lines.push(`  High: ${result.summary.high || 0}`);
       lines.push(`  Medium: ${result.summary.medium || 0}`);
@@ -3844,7 +4010,9 @@ var Reporter = class {
       lines.push("-".repeat(50));
       result.violations.forEach((v) => {
         const severity = v.severity.toLowerCase();
-        lines.push(`  [${v.severity.toUpperCase()}] ${v.decisionId} - ${v.constraintId} (${severity})`);
+        lines.push(
+          `  [${v.severity.toUpperCase()}] ${v.decisionId} - ${v.constraintId} (${severity})`
+        );
         lines.push(`    ${v.message}`);
         const file = v.location?.file || v.file;
         const line = v.location?.line || v.line || 0;
@@ -3865,7 +4033,9 @@ var Reporter = class {
     lines.push("");
     if (result.summary) {
       lines.push("Summary:");
-      lines.push(`  Total Violations: ${result.summary.totalViolations || result.violations?.length || 0}`);
+      lines.push(
+        `  Total Violations: ${result.summary.totalViolations || result.violations?.length || 0}`
+      );
       lines.push("");
     }
     if (result.violations && result.violations.length > 0) {
@@ -3919,7 +4089,9 @@ var Reporter = class {
       lines.push("### Summary\n");
       lines.push(`- **Decisions Checked:** ${result.summary.decisionsChecked || 0}`);
       lines.push(`- **Files Checked:** ${result.summary.filesChecked || 0}`);
-      lines.push(`- **Total Violations:** ${result.summary.totalViolations || result.violations?.length || 0}`);
+      lines.push(
+        `- **Total Violations:** ${result.summary.totalViolations || result.violations?.length || 0}`
+      );
       lines.push(`- **Critical:** ${result.summary.critical || 0}`);
       lines.push(`- **High:** ${result.summary.high || 0}`);
       lines.push(`- **Medium:** ${result.summary.medium || 0}`);
@@ -3944,54 +4116,58 @@ var Reporter = class {
 };
 
 // src/reporting/formats/console.ts
-import chalk2 from "chalk";
+import chalk from "chalk";
 import { table } from "table";
 function formatConsoleReport(report) {
   const lines = [];
   lines.push("");
-  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(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("");
   const complianceColor = getComplianceColor(report.summary.compliance);
-  lines.push(chalk2.bold("Overall Compliance"));
-  lines.push(`  ${complianceColor(formatComplianceBar(report.summary.compliance))} ${complianceColor(`${report.summary.compliance}%`)}`);
+  lines.push(chalk.bold("Overall Compliance"));
+  lines.push(
+    `  ${complianceColor(formatComplianceBar(report.summary.compliance))} ${complianceColor(`${report.summary.compliance}%`)}`
+  );
   lines.push("");
-  lines.push(chalk2.bold("Summary"));
-  lines.push(`  Decisions: ${report.summary.activeDecisions} active / ${report.summary.totalDecisions} total`);
+  lines.push(chalk.bold("Summary"));
+  lines.push(
+    `  Decisions: ${report.summary.activeDecisions} active / ${report.summary.totalDecisions} total`
+  );
   lines.push(`  Constraints: ${report.summary.totalConstraints}`);
   lines.push("");
-  lines.push(chalk2.bold("Violations"));
+  lines.push(chalk.bold("Violations"));
   const { violations } = report.summary;
   const violationParts = [];
   if (violations.critical > 0) {
-    violationParts.push(chalk2.red(`${violations.critical} critical`));
+    violationParts.push(chalk.red(`${violations.critical} critical`));
   }
   if (violations.high > 0) {
-    violationParts.push(chalk2.yellow(`${violations.high} high`));
+    violationParts.push(chalk.yellow(`${violations.high} high`));
   }
   if (violations.medium > 0) {
-    violationParts.push(chalk2.cyan(`${violations.medium} medium`));
+    violationParts.push(chalk.cyan(`${violations.medium} medium`));
   }
   if (violations.low > 0) {
-    violationParts.push(chalk2.dim(`${violations.low} low`));
+    violationParts.push(chalk.dim(`${violations.low} low`));
   }
   if (violationParts.length > 0) {
     lines.push(`  ${violationParts.join(" | ")}`);
   } else {
-    lines.push(chalk2.green("  No violations"));
+    lines.push(chalk.green("  No violations"));
   }
   lines.push("");
   if (report.byDecision.length > 0) {
-    lines.push(chalk2.bold("By Decision"));
+    lines.push(chalk.bold("By Decision"));
     lines.push("");
     const tableData = [
       [
-        chalk2.bold("Decision"),
-        chalk2.bold("Status"),
-        chalk2.bold("Constraints"),
-        chalk2.bold("Violations"),
-        chalk2.bold("Compliance")
+        chalk.bold("Decision"),
+        chalk.bold("Status"),
+        chalk.bold("Constraints"),
+        chalk.bold("Violations"),
+        chalk.bold("Compliance")
       ]
     ];
     for (const dec of report.byDecision) {
@@ -4001,7 +4177,7 @@ function formatConsoleReport(report) {
         truncate(dec.title, 40),
         statusColor(dec.status),
         String(dec.constraints),
-        dec.violations > 0 ? chalk2.red(String(dec.violations)) : chalk2.green("0"),
+        dec.violations > 0 ? chalk.red(String(dec.violations)) : chalk.green("0"),
         compColor(`${dec.compliance}%`)
       ]);
     }
@@ -4035,23 +4211,23 @@ function formatComplianceBar(compliance) {
   return "\u2588".repeat(filled) + "\u2591".repeat(empty);
 }
 function getComplianceColor(compliance) {
-  if (compliance >= 90) return chalk2.green;
-  if (compliance >= 70) return chalk2.yellow;
-  if (compliance >= 50) return chalk2.hex("#FFA500");
-  return chalk2.red;
+  if (compliance >= 90) return chalk.green;
+  if (compliance >= 70) return chalk.yellow;
+  if (compliance >= 50) return chalk.hex("#FFA500");
+  return chalk.red;
 }
 function getStatusColor(status) {
   switch (status) {
     case "active":
-      return chalk2.green;
+      return chalk.green;
     case "draft":
-      return chalk2.yellow;
+      return chalk.yellow;
     case "deprecated":
-      return chalk2.gray;
+      return chalk.gray;
     case "superseded":
-      return chalk2.blue;
+      return chalk.blue;
     default:
-      return chalk2.white;
+      return chalk.white;
   }
 }
 function truncate(str, length) {
@@ -4075,7 +4251,9 @@ function formatMarkdownReport(report) {
   lines.push("");
   lines.push("## Summary");
   lines.push("");
-  lines.push(`- **Active Decisions:** ${report.summary.activeDecisions} / ${report.summary.totalDecisions}`);
+  lines.push(
+    `- **Active Decisions:** ${report.summary.activeDecisions} / ${report.summary.totalDecisions}`
+  );
   lines.push(`- **Total Constraints:** ${report.summary.totalConstraints}`);
   lines.push("");
   lines.push("### Violations");
@@ -4125,6 +4303,7 @@ function formatProgressBar(percentage) {
 import { join as join4 } from "path";
 var ReportStorage = class {
   storageDir;
+  logger = getLogger({ module: "reporting.storage" });
   constructor(basePath) {
     this.storageDir = join4(getSpecBridgeDir(basePath), "reports", "history");
   }
@@ -4183,7 +4362,7 @@ var ReportStorage = class {
         const timestamp = file.replace("report-", "").replace(".json", "");
         return { timestamp, report };
       } catch (error) {
-        console.warn(`Warning: Failed to load report ${file}:`, error);
+        this.logger.warn({ file, error }, "Failed to load report file");
         return null;
       }
     });
@@ -4227,7 +4406,7 @@ var ReportStorage = class {
         const fs = await import("fs/promises");
         await fs.unlink(filepath);
       } catch (error) {
-        console.warn(`Warning: Failed to delete old report ${file}:`, error);
+        this.logger.warn({ file, error }, "Failed to delete old report file");
       }
     }
     return filesToDelete.length;
@@ -4238,9 +4417,7 @@ var ReportStorage = class {
 async function detectDrift(current, previous) {
   const byDecision = [];
   for (const currDecision of current.byDecision) {
-    const prevDecision = previous.byDecision.find(
-      (d) => d.decisionId === currDecision.decisionId
-    );
+    const prevDecision = previous.byDecision.find((d) => d.decisionId === currDecision.decisionId);
     if (!prevDecision) {
       byDecision.push({
         decisionId: currDecision.decisionId,
@@ -5021,9 +5198,7 @@ var AnalyticsEngine = class {
         overallTrend = "down";
       }
     }
-    const sortedByCompliance = [...latest.byDecision].sort(
-      (a, b) => b.compliance - a.compliance
-    );
+    const sortedByCompliance = [...latest.byDecision].sort((a, b) => b.compliance - a.compliance);
     const topDecisions = sortedByCompliance.slice(0, 5).map((d) => ({
       decisionId: d.decisionId,
       title: d.title,
@@ -5064,6 +5239,7 @@ var DashboardServer = class {
   CACHE_TTL = 6e4;
   // 1 minute
   refreshInterval = null;
+  logger = getLogger({ module: "dashboard.server" });
   constructor(options) {
     this.cwd = options.cwd;
     this.config = options.config;
@@ -5079,10 +5255,11 @@ var DashboardServer = class {
   async start() {
     await this.registry.load();
     await this.refreshCache();
-    this.refreshInterval = setInterval(
-      () => this.refreshCache().catch(console.error),
-      this.CACHE_TTL
-    );
+    this.refreshInterval = setInterval(() => {
+      void this.refreshCache().catch((error) => {
+        this.logger.error({ error }, "Background cache refresh failed");
+      });
+    }, this.CACHE_TTL);
   }
   /**
    * Stop the server and clear intervals
@@ -5103,7 +5280,7 @@ var DashboardServer = class {
       this.cacheTimestamp = Date.now();
       await this.reportStorage.save(report);
     } catch (error) {
-      console.error("Cache refresh failed:", error);
+      this.logger.error({ error }, "Cache refresh failed");
       if (!this.cachedReport) {
         try {
           const stored = await this.reportStorage.loadLatest();
@@ -5111,7 +5288,7 @@ var DashboardServer = class {
             this.cachedReport = stored.report;
           }
         } catch (fallbackError) {
-          console.error("Failed to load fallback report:", fallbackError);
+          this.logger.error({ error: fallbackError }, "Failed to load fallback report");
         }
       }
     }
@@ -5354,11 +5531,13 @@ var DashboardServer = class {
    */
   setupStaticFiles() {
     const publicDir = join5(__dirname, "public");
-    this.app.use(express.static(publicDir, {
-      maxAge: "1h",
-      // Cache static assets
-      etag: true
-    }));
+    this.app.use(
+      express.static(publicDir, {
+        maxAge: "1h",
+        // Cache static assets
+        etag: true
+      })
+    );
     this.app.get("/{*path}", (_req, res) => {
       res.sendFile(join5(publicDir, "index.html"));
     });
@@ -5369,12 +5548,19 @@ function createDashboardServer(options) {
 }
 
 // src/lsp/server.ts
-import { createConnection, ProposedFeatures, TextDocuments, TextDocumentSyncKind, DiagnosticSeverity, CodeActionKind } from "vscode-languageserver/node.js";
+import {
+  createConnection,
+  ProposedFeatures,
+  TextDocuments,
+  TextDocumentSyncKind,
+  DiagnosticSeverity,
+  CodeActionKind
+} from "vscode-languageserver/node.js";
 import { TextDocument } from "vscode-languageserver-textdocument";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import path3 from "path";
 import { Project as Project3 } from "ts-morph";
-import chalk3 from "chalk";
+import chalk2 from "chalk";
 function severityToDiagnostic(severity) {
   switch (severity) {
     case "critical":
@@ -5485,7 +5671,7 @@ var SpecBridgeLspServer = class {
     if (!await pathExists(getSpecBridgeDir(this.cwd))) {
       const err = new NotInitializedError();
       this.initError = err.message;
-      if (this.options.verbose) this.connection.console.error(chalk3.red(this.initError));
+      if (this.options.verbose) this.connection.console.error(chalk2.red(this.initError));
       return;
     }
     try {
@@ -5494,7 +5680,8 @@ var SpecBridgeLspServer = class {
         await getPluginLoader().loadPlugins(this.cwd);
       } catch (error) {
         const msg = error instanceof Error ? error.message : String(error);
-        if (this.options.verbose) this.connection.console.error(chalk3.red(`Plugin load failed: ${msg}`));
+        if (this.options.verbose)
+          this.connection.console.error(chalk2.red(`Plugin load failed: ${msg}`));
       }
       this.registry = createRegistry({ basePath: this.cwd });
       await this.registry.load();
@@ -5507,11 +5694,13 @@ var SpecBridgeLspServer = class {
         }
       }
       if (this.options.verbose) {
-        this.connection.console.log(chalk3.dim(`Loaded ${this.decisions.length} active decision(s)`));
+        this.connection.console.log(
+          chalk2.dim(`Loaded ${this.decisions.length} active decision(s)`)
+        );
       }
     } catch (error) {
       this.initError = error instanceof Error ? error.message : String(error);
-      if (this.options.verbose) this.connection.console.error(chalk3.red(this.initError));
+      if (this.options.verbose) this.connection.console.error(chalk2.red(this.initError));
     }
   }
   async verifyTextDocument(doc) {
@@ -5525,7 +5714,11 @@ var SpecBridgeLspServer = class {
     for (const decision of this.decisions) {
       for (const constraint of decision.constraints) {
         if (!shouldApplyConstraintToFile({ filePath, constraint, cwd: this.cwd })) continue;
-        const verifier = selectVerifierForConstraint(constraint.rule, constraint.verifier, constraint.check);
+        const verifier = selectVerifierForConstraint(
+          constraint.rule,
+          constraint.verifier,
+          constraint.check
+        );
         if (!verifier) continue;
         const ctx = {
           filePath,
@@ -5579,6 +5772,9 @@ async function startLspServer(options) {
 // src/integrations/github.ts
 function toMdTable(rows) {
   const header = rows[0];
+  if (!header) {
+    return "";
+  }
   const body = rows.slice(1);
   const sep = header.map(() => "---");
   const lines = [
@@ -5592,9 +5788,7 @@ function formatViolationsForGitHub(violations, limit = 50) {
   if (violations.length === 0) {
     return "## SpecBridge\n\n\u2705 No violations found.";
   }
-  const rows = [
-    ["Severity", "Type", "File", "Decision/Constraint", "Message"]
-  ];
+  const rows = [["Severity", "Type", "File", "Decision/Constraint", "Message"]];
   for (const v of violations.slice(0, limit)) {
     const loc = v.line ? `:${v.line}${v.column ? `:${v.column}` : ""}` : "";
     rows.push([
@@ -5616,19 +5810,24 @@ ${toMdTable(rows)}${extra}`;
 }
 async function postPrComment(violations, options) {
   const body = formatViolationsForGitHub(violations);
-  const res = await fetch(`https://api.github.com/repos/${options.repo}/issues/${options.pr}/comments`, {
-    method: "POST",
-    headers: {
-      Authorization: `Bearer ${options.token}`,
-      Accept: "application/vnd.github+json",
-      "Content-Type": "application/json",
-      "User-Agent": "specbridge"
-    },
-    body: JSON.stringify({ body })
-  });
+  const res = await fetch(
+    `https://api.github.com/repos/${options.repo}/issues/${options.pr}/comments`,
+    {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${options.token}`,
+        Accept: "application/vnd.github+json",
+        "Content-Type": "application/json",
+        "User-Agent": "specbridge"
+      },
+      body: JSON.stringify({ body })
+    }
+  );
   if (!res.ok) {
     const text = await res.text().catch(() => "");
-    throw new Error(`GitHub comment failed: ${res.status} ${res.statusText}${text ? ` - ${text}` : ""}`);
+    throw new Error(
+      `GitHub comment failed: ${res.status} ${res.statusText}${text ? ` - ${text}` : ""}`
+    );
   }
 }
 export {
@@ -5722,6 +5921,7 @@ export {
   getConfigPath,
   getDecisionsDir,
   getInferredDir,
+  getLogger,
   getReportsDir,
   getSpecBridgeDir,
   getTransitiveDependencies,
@@ -5734,6 +5934,7 @@ export {
   loadConfig,
   loadDecisionFile,
   loadDecisionsFromDir,
+  logger,
   matchesAnyPattern,
   matchesPattern,
   mergeWithDefaults,