@ipation/specbridge 0.2.1

package/dist/cli.js

@@ -0,0 +1,3315 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import { Command as Command12 } from "commander";
+import chalk12 from "chalk";
+
+// src/core/errors/index.ts
+var SpecBridgeError = class extends Error {
+  constructor(message, code, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "SpecBridgeError";
+    Error.captureStackTrace(this, this.constructor);
+  }
+};
+var ConfigError = class extends SpecBridgeError {
+  constructor(message, details) {
+    super(message, "CONFIG_ERROR", details);
+    this.name = "ConfigError";
+  }
+};
+var DecisionValidationError = class extends SpecBridgeError {
+  constructor(message, decisionId, validationErrors) {
+    super(message, "DECISION_VALIDATION_ERROR", { decisionId, validationErrors });
+    this.decisionId = decisionId;
+    this.validationErrors = validationErrors;
+    this.name = "DecisionValidationError";
+  }
+};
+var DecisionNotFoundError = class extends SpecBridgeError {
+  constructor(decisionId) {
+    super(`Decision not found: ${decisionId}`, "DECISION_NOT_FOUND", { decisionId });
+    this.name = "DecisionNotFoundError";
+  }
+};
+var FileSystemError = class extends SpecBridgeError {
+  constructor(message, path) {
+    super(message, "FILE_SYSTEM_ERROR", { path });
+    this.path = path;
+    this.name = "FileSystemError";
+  }
+};
+var AlreadyInitializedError = class extends SpecBridgeError {
+  constructor(path) {
+    super(`SpecBridge is already initialized at ${path}`, "ALREADY_INITIALIZED", { path });
+    this.name = "AlreadyInitializedError";
+  }
+};
+var NotInitializedError = class extends SpecBridgeError {
+  constructor() {
+    super(
+      'SpecBridge is not initialized. Run "specbridge init" first.',
+      "NOT_INITIALIZED"
+    );
+    this.name = "NotInitializedError";
+  }
+};
+var AnalyzerNotFoundError = class extends SpecBridgeError {
+  constructor(analyzerId) {
+    super(`Analyzer not found: ${analyzerId}`, "ANALYZER_NOT_FOUND", { analyzerId });
+    this.name = "AnalyzerNotFoundError";
+  }
+};
+function formatError(error) {
+  if (error instanceof SpecBridgeError) {
+    let message = `Error [${error.code}]: ${error.message}`;
+    if (error.details) {
+      const detailsStr = Object.entries(error.details).filter(([key]) => key !== "validationErrors").map(([key, value]) => `  ${key}: ${value}`).join("\n");
+      if (detailsStr) {
+        message += `
+${detailsStr}`;
+      }
+    }
+    if (error instanceof DecisionValidationError && error.validationErrors.length > 0) {
+      message += "\nValidation errors:\n" + error.validationErrors.map((e) => `  - ${e}`).join("\n");
+    }
+    return message;
+  }
+  return `Error: ${error.message}`;
+}
+
+// src/cli/commands/init.ts
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import { join as join2 } from "path";
+
+// src/utils/fs.ts
+import { readFile, writeFile, mkdir, access, readdir, stat } from "fs/promises";
+import { join, dirname } from "path";
+import { constants } from "fs";
+async function pathExists(path) {
+  try {
+    await access(path, constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function ensureDir(path) {
+  await mkdir(path, { recursive: true });
+}
+async function readTextFile(path) {
+  return readFile(path, "utf-8");
+}
+async function writeTextFile(path, content) {
+  await ensureDir(dirname(path));
+  await writeFile(path, content, "utf-8");
+}
+async function readFilesInDir(dirPath, filter) {
+  try {
+    const entries = await readdir(dirPath, { withFileTypes: true });
+    const files = entries.filter((entry) => entry.isFile()).map((entry) => entry.name);
+    if (filter) {
+      return files.filter(filter);
+    }
+    return files;
+  } catch {
+    return [];
+  }
+}
+function getSpecBridgeDir(basePath = process.cwd()) {
+  return join(basePath, ".specbridge");
+}
+function getDecisionsDir(basePath = process.cwd()) {
+  return join(getSpecBridgeDir(basePath), "decisions");
+}
+function getVerifiersDir(basePath = process.cwd()) {
+  return join(getSpecBridgeDir(basePath), "verifiers");
+}
+function getInferredDir(basePath = process.cwd()) {
+  return join(getSpecBridgeDir(basePath), "inferred");
+}
+function getReportsDir(basePath = process.cwd()) {
+  return join(getSpecBridgeDir(basePath), "reports");
+}
+function getConfigPath(basePath = process.cwd()) {
+  return join(getSpecBridgeDir(basePath), "config.yaml");
+}
+
+// src/utils/yaml.ts
+import { parse, stringify, parseDocument } from "yaml";
+function parseYaml(content) {
+  return parse(content);
+}
+function stringifyYaml(data, options) {
+  return stringify(data, {
+    indent: options?.indent ?? 2,
+    lineWidth: 100,
+    minContentWidth: 20
+  });
+}
+
+// src/core/schemas/config.schema.ts
+import { z } from "zod";
+var SeveritySchema = z.enum(["critical", "high", "medium", "low"]);
+var LevelConfigSchema = z.object({
+  timeout: z.number().positive().optional(),
+  severity: z.array(SeveritySchema).optional()
+});
+var ProjectConfigSchema = z.object({
+  name: z.string().min(1),
+  sourceRoots: z.array(z.string().min(1)).min(1),
+  exclude: z.array(z.string()).optional()
+});
+var InferenceConfigSchema = z.object({
+  minConfidence: z.number().min(0).max(100).optional(),
+  analyzers: z.array(z.string()).optional()
+});
+var VerificationConfigSchema = z.object({
+  levels: z.object({
+    commit: LevelConfigSchema.optional(),
+    pr: LevelConfigSchema.optional(),
+    full: LevelConfigSchema.optional()
+  }).optional()
+});
+var AgentConfigSchema = z.object({
+  format: z.enum(["markdown", "json", "mcp"]).optional(),
+  includeRationale: z.boolean().optional()
+});
+var SpecBridgeConfigSchema = z.object({
+  version: z.string().regex(/^\d+\.\d+$/, "Version must be in format X.Y"),
+  project: ProjectConfigSchema,
+  inference: InferenceConfigSchema.optional(),
+  verification: VerificationConfigSchema.optional(),
+  agent: AgentConfigSchema.optional()
+});
+function validateConfig(data) {
+  const result = SpecBridgeConfigSchema.safeParse(data);
+  if (result.success) {
+    return { success: true, data: result.data };
+  }
+  return { success: false, errors: result.error };
+}
+var defaultConfig = {
+  version: "1.0",
+  project: {
+    name: "my-project",
+    sourceRoots: ["src/**/*.ts", "src/**/*.tsx"],
+    exclude: ["**/*.test.ts", "**/*.spec.ts", "**/node_modules/**", "**/dist/**"]
+  },
+  inference: {
+    minConfidence: 70,
+    analyzers: ["naming", "structure", "imports", "errors"]
+  },
+  verification: {
+    levels: {
+      commit: {
+        timeout: 5e3,
+        severity: ["critical"]
+      },
+      pr: {
+        timeout: 6e4,
+        severity: ["critical", "high"]
+      },
+      full: {
+        timeout: 3e5,
+        severity: ["critical", "high", "medium", "low"]
+      }
+    }
+  },
+  agent: {
+    format: "markdown",
+    includeRationale: true
+  }
+};
+
+// src/cli/commands/init.ts
+var initCommand = new Command("init").description("Initialize SpecBridge in the current project").option("-f, --force", "Overwrite existing configuration").option("-n, --name <name>", "Project name").action(async (options) => {
+  const cwd = process.cwd();
+  const specbridgeDir = getSpecBridgeDir(cwd);
+  if (!options.force && await pathExists(specbridgeDir)) {
+    throw new AlreadyInitializedError(specbridgeDir);
+  }
+  const spinner = ora("Initializing SpecBridge...").start();
+  try {
+    await ensureDir(specbridgeDir);
+    await ensureDir(getDecisionsDir(cwd));
+    await ensureDir(getVerifiersDir(cwd));
+    await ensureDir(getInferredDir(cwd));
+    await ensureDir(getReportsDir(cwd));
+    const projectName = options.name || getProjectNameFromPath(cwd);
+    const config = {
+      ...defaultConfig,
+      project: {
+        ...defaultConfig.project,
+        name: projectName
+      }
+    };
+    const configContent = stringifyYaml(config);
+    await writeTextFile(getConfigPath(cwd), configContent);
+    const exampleDecision = createExampleDecision(projectName);
+    await writeTextFile(
+      join2(getDecisionsDir(cwd), "example.decision.yaml"),
+      stringifyYaml(exampleDecision)
+    );
+    await writeTextFile(join2(getVerifiersDir(cwd), ".gitkeep"), "");
+    await writeTextFile(join2(getInferredDir(cwd), ".gitkeep"), "");
+    await writeTextFile(join2(getReportsDir(cwd), ".gitkeep"), "");
+    spinner.succeed("SpecBridge initialized successfully!");
+    console.log("");
+    console.log(chalk.green("Created:"));
+    console.log(`  ${chalk.dim(".specbridge/")}`);
+    console.log(`  ${chalk.dim("\u251C\u2500\u2500")} config.yaml`);
+    console.log(`  ${chalk.dim("\u251C\u2500\u2500")} decisions/`);
+    console.log(`  ${chalk.dim("\u2502   \u2514\u2500\u2500")} example.decision.yaml`);
+    console.log(`  ${chalk.dim("\u251C\u2500\u2500")} verifiers/`);
+    console.log(`  ${chalk.dim("\u251C\u2500\u2500")} inferred/`);
+    console.log(`  ${chalk.dim("\u2514\u2500\u2500")} reports/`);
+    console.log("");
+    console.log(chalk.cyan("Next steps:"));
+    console.log(`  1. Edit ${chalk.bold(".specbridge/config.yaml")} to configure source paths`);
+    console.log(`  2. Run ${chalk.bold("specbridge infer")} to detect patterns in your codebase`);
+    console.log(`  3. Create decisions in ${chalk.bold(".specbridge/decisions/")}`);
+    console.log(`  4. Run ${chalk.bold("specbridge verify")} to check compliance`);
+  } catch (error) {
+    spinner.fail("Failed to initialize SpecBridge");
+    throw error;
+  }
+});
+function getProjectNameFromPath(dirPath) {
+  const parts = dirPath.split(/[/\\]/);
+  return parts[parts.length - 1] || "my-project";
+}
+function createExampleDecision(projectName) {
+  return {
+    kind: "Decision",
+    metadata: {
+      id: "example-001",
+      title: "Example Decision - Error Handling Convention",
+      status: "draft",
+      owners: ["team"],
+      tags: ["example", "error-handling"]
+    },
+    decision: {
+      summary: "All errors should be handled using a consistent error class hierarchy.",
+      rationale: `Consistent error handling improves debugging and makes the codebase more maintainable.
+This is an example decision to demonstrate SpecBridge functionality.`,
+      context: `This decision was auto-generated when initializing SpecBridge for ${projectName}.
+Replace or delete this file and create your own architectural decisions.`
+    },
+    constraints: [
+      {
+        id: "custom-errors",
+        type: "convention",
+        rule: "Custom error classes should extend a base AppError class",
+        severity: "medium",
+        scope: "src/**/*.ts"
+      },
+      {
+        id: "error-logging",
+        type: "guideline",
+        rule: "Errors should be logged with appropriate context before being thrown or handled",
+        severity: "low",
+        scope: "src/**/*.ts"
+      }
+    ]
+  };
+}
+
+// src/cli/commands/infer.ts
+import { Command as Command2 } from "commander";
+import chalk2 from "chalk";
+import ora2 from "ora";
+import { join as join3 } from "path";
+
+// src/inference/scanner.ts
+import { Project, Node, SyntaxKind } from "ts-morph";
+
+// src/utils/glob.ts
+import fg from "fast-glob";
+import { minimatch } from "minimatch";
+async function glob(patterns, options = {}) {
+  const {
+    cwd = process.cwd(),
+    ignore = [],
+    absolute = false,
+    onlyFiles = true
+  } = options;
+  return fg(patterns, {
+    cwd,
+    ignore,
+    absolute,
+    onlyFiles,
+    dot: false
+  });
+}
+function matchesPattern(filePath, pattern) {
+  return minimatch(filePath, pattern, { matchBase: true });
+}
+
+// src/inference/scanner.ts
+var CodeScanner = class {
+  project;
+  scannedFiles = /* @__PURE__ */ new Map();
+  constructor() {
+    this.project = new Project({
+      compilerOptions: {
+        allowJs: true,
+        checkJs: false,
+        noEmit: true,
+        skipLibCheck: true
+      },
+      skipAddingFilesFromTsConfig: true
+    });
+  }
+  /**
+   * Scan files matching the given patterns
+   */
+  async scan(options) {
+    const { sourceRoots, exclude = [], cwd = process.cwd() } = options;
+    const files = await glob(sourceRoots, {
+      cwd,
+      ignore: exclude,
+      absolute: true
+    });
+    for (const filePath of files) {
+      try {
+        const sourceFile = this.project.addSourceFileAtPath(filePath);
+        const lines = sourceFile.getEndLineNumber();
+        this.scannedFiles.set(filePath, {
+          path: filePath,
+          sourceFile,
+          lines
+        });
+      } catch {
+      }
+    }
+    const scannedArray = Array.from(this.scannedFiles.values());
+    const totalLines = scannedArray.reduce((sum, f) => sum + f.lines, 0);
+    return {
+      files: scannedArray,
+      totalFiles: scannedArray.length,
+      totalLines
+    };
+  }
+  /**
+   * Get all scanned files
+   */
+  getFiles() {
+    return Array.from(this.scannedFiles.values());
+  }
+  /**
+   * Get a specific file
+   */
+  getFile(path) {
+    return this.scannedFiles.get(path);
+  }
+  /**
+   * Get project instance for advanced analysis
+   */
+  getProject() {
+    return this.project;
+  }
+  /**
+   * Find all classes in scanned files
+   */
+  findClasses() {
+    const classes = [];
+    for (const { path, sourceFile } of this.scannedFiles.values()) {
+      for (const classDecl of sourceFile.getClasses()) {
+        const name = classDecl.getName();
+        if (name) {
+          classes.push({
+            file: path,
+            name,
+            line: classDecl.getStartLineNumber()
+          });
+        }
+      }
+    }
+    return classes;
+  }
+  /**
+   * Find all functions in scanned files
+   */
+  findFunctions() {
+    const functions = [];
+    for (const { path, sourceFile } of this.scannedFiles.values()) {
+      for (const funcDecl of sourceFile.getFunctions()) {
+        const name = funcDecl.getName();
+        if (name) {
+          functions.push({
+            file: path,
+            name,
+            line: funcDecl.getStartLineNumber(),
+            isExported: funcDecl.isExported()
+          });
+        }
+      }
+      for (const varDecl of sourceFile.getVariableDeclarations()) {
+        const init = varDecl.getInitializer();
+        if (init && Node.isArrowFunction(init)) {
+          functions.push({
+            file: path,
+            name: varDecl.getName(),
+            line: varDecl.getStartLineNumber(),
+            isExported: varDecl.isExported()
+          });
+        }
+      }
+    }
+    return functions;
+  }
+  /**
+   * Find all imports in scanned files
+   */
+  findImports() {
+    const imports = [];
+    for (const { path, sourceFile } of this.scannedFiles.values()) {
+      for (const importDecl of sourceFile.getImportDeclarations()) {
+        const module = importDecl.getModuleSpecifierValue();
+        const namedImports = importDecl.getNamedImports().map((n) => n.getName());
+        imports.push({
+          file: path,
+          module,
+          named: namedImports,
+          line: importDecl.getStartLineNumber()
+        });
+      }
+    }
+    return imports;
+  }
+  /**
+   * Find all interfaces in scanned files
+   */
+  findInterfaces() {
+    const interfaces = [];
+    for (const { path, sourceFile } of this.scannedFiles.values()) {
+      for (const interfaceDecl of sourceFile.getInterfaces()) {
+        interfaces.push({
+          file: path,
+          name: interfaceDecl.getName(),
+          line: interfaceDecl.getStartLineNumber()
+        });
+      }
+    }
+    return interfaces;
+  }
+  /**
+   * Find all type aliases in scanned files
+   */
+  findTypeAliases() {
+    const types = [];
+    for (const { path, sourceFile } of this.scannedFiles.values()) {
+      for (const typeAlias of sourceFile.getTypeAliases()) {
+        types.push({
+          file: path,
+          name: typeAlias.getName(),
+          line: typeAlias.getStartLineNumber()
+        });
+      }
+    }
+    return types;
+  }
+  /**
+   * Find try-catch blocks in scanned files
+   */
+  findTryCatchBlocks() {
+    const blocks = [];
+    for (const { path, sourceFile } of this.scannedFiles.values()) {
+      sourceFile.forEachDescendant((node) => {
+        if (Node.isTryStatement(node)) {
+          const catchClause = node.getCatchClause();
+          const hasThrow = catchClause ? catchClause.getDescendantsOfKind(SyntaxKind.ThrowStatement).length > 0 : false;
+          blocks.push({
+            file: path,
+            line: node.getStartLineNumber(),
+            hasThrow
+          });
+        }
+      });
+    }
+    return blocks;
+  }
+};
+
+// src/inference/analyzers/base.ts
+function createPattern(analyzer, params) {
+  return {
+    analyzer,
+    ...params
+  };
+}
+function calculateConfidence(occurrences, total, minOccurrences = 3) {
+  if (occurrences < minOccurrences) {
+    return 0;
+  }
+  const ratio = occurrences / total;
+  return Math.min(100, Math.round(50 + ratio * 50));
+}
+
+// src/inference/analyzers/naming.ts
+var CLASS_PATTERNS = [
+  { convention: "PascalCase", regex: /^[A-Z][a-zA-Z0-9]*$/, description: "Classes use PascalCase" }
+];
+var FUNCTION_PATTERNS = [
+  { convention: "camelCase", regex: /^[a-z][a-zA-Z0-9]*$/, description: "Functions use camelCase" },
+  { 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" }
+];
+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" }
+];
+var NamingAnalyzer = class {
+  id = "naming";
+  name = "Naming Convention Analyzer";
+  description = "Detects naming conventions for classes, functions, interfaces, and types";
+  async analyze(scanner) {
+    const patterns = [];
+    const classPattern = this.analyzeClassNaming(scanner);
+    if (classPattern) patterns.push(classPattern);
+    const functionPattern = this.analyzeFunctionNaming(scanner);
+    if (functionPattern) patterns.push(functionPattern);
+    const interfacePattern = this.analyzeInterfaceNaming(scanner);
+    if (interfacePattern) patterns.push(interfacePattern);
+    const typePattern = this.analyzeTypeNaming(scanner);
+    if (typePattern) patterns.push(typePattern);
+    return patterns;
+  }
+  analyzeClassNaming(scanner) {
+    const classes = scanner.findClasses();
+    if (classes.length < 3) return null;
+    const matches = this.findBestMatch(classes.map((c) => c.name), CLASS_PATTERNS);
+    if (!matches) return null;
+    return createPattern(this.id, {
+      id: "naming-classes",
+      name: "Class Naming Convention",
+      description: `Classes follow ${matches.convention} naming convention`,
+      confidence: matches.confidence,
+      occurrences: matches.matchCount,
+      examples: classes.slice(0, 3).map((c) => ({
+        file: c.file,
+        line: c.line,
+        snippet: `class ${c.name}`
+      })),
+      suggestedConstraint: {
+        type: "convention",
+        rule: `Classes should use ${matches.convention} naming convention`,
+        severity: "medium",
+        scope: "src/**/*.ts"
+      }
+    });
+  }
+  analyzeFunctionNaming(scanner) {
+    const functions = scanner.findFunctions();
+    if (functions.length < 3) return null;
+    const matches = this.findBestMatch(functions.map((f) => f.name), FUNCTION_PATTERNS);
+    if (!matches) return null;
+    return createPattern(this.id, {
+      id: "naming-functions",
+      name: "Function Naming Convention",
+      description: `Functions follow ${matches.convention} naming convention`,
+      confidence: matches.confidence,
+      occurrences: matches.matchCount,
+      examples: functions.slice(0, 3).map((f) => ({
+        file: f.file,
+        line: f.line,
+        snippet: `function ${f.name}`
+      })),
+      suggestedConstraint: {
+        type: "convention",
+        rule: `Functions should use ${matches.convention} naming convention`,
+        severity: "low",
+        scope: "src/**/*.ts"
+      }
+    });
+  }
+  analyzeInterfaceNaming(scanner) {
+    const interfaces = scanner.findInterfaces();
+    if (interfaces.length < 3) return null;
+    const matches = this.findBestMatch(interfaces.map((i) => i.name), INTERFACE_PATTERNS);
+    if (!matches) return null;
+    return createPattern(this.id, {
+      id: "naming-interfaces",
+      name: "Interface Naming Convention",
+      description: `Interfaces follow ${matches.convention} naming convention`,
+      confidence: matches.confidence,
+      occurrences: matches.matchCount,
+      examples: interfaces.slice(0, 3).map((i) => ({
+        file: i.file,
+        line: i.line,
+        snippet: `interface ${i.name}`
+      })),
+      suggestedConstraint: {
+        type: "convention",
+        rule: `Interfaces should use ${matches.convention} naming convention`,
+        severity: "low",
+        scope: "src/**/*.ts"
+      }
+    });
+  }
+  analyzeTypeNaming(scanner) {
+    const types = scanner.findTypeAliases();
+    if (types.length < 3) return null;
+    const matches = this.findBestMatch(types.map((t) => t.name), TYPE_PATTERNS);
+    if (!matches) return null;
+    return createPattern(this.id, {
+      id: "naming-types",
+      name: "Type Alias Naming Convention",
+      description: `Type aliases follow ${matches.convention} naming convention`,
+      confidence: matches.confidence,
+      occurrences: matches.matchCount,
+      examples: types.slice(0, 3).map((t) => ({
+        file: t.file,
+        line: t.line,
+        snippet: `type ${t.name}`
+      })),
+      suggestedConstraint: {
+        type: "guideline",
+        rule: `Type aliases should use ${matches.convention} naming convention`,
+        severity: "low",
+        scope: "src/**/*.ts"
+      }
+    });
+  }
+  findBestMatch(names, patterns) {
+    let bestMatch = null;
+    for (const pattern of patterns) {
+      const matchCount = names.filter((name) => pattern.regex.test(name)).length;
+      if (!bestMatch || matchCount > bestMatch.matchCount) {
+        bestMatch = { convention: pattern.convention, matchCount };
+      }
+    }
+    if (!bestMatch || bestMatch.matchCount < 3) return null;
+    const confidence = calculateConfidence(bestMatch.matchCount, names.length);
+    if (confidence < 50) return null;
+    return {
+      convention: bestMatch.convention,
+      confidence,
+      matchCount: bestMatch.matchCount
+    };
+  }
+};
+
+// src/inference/analyzers/imports.ts
+var ImportsAnalyzer = class {
+  id = "imports";
+  name = "Import Pattern Analyzer";
+  description = "Detects import organization patterns and module usage conventions";
+  async analyze(scanner) {
+    const patterns = [];
+    const barrelPattern = this.analyzeBarrelImports(scanner);
+    if (barrelPattern) patterns.push(barrelPattern);
+    const relativePattern = this.analyzeRelativeImports(scanner);
+    if (relativePattern) patterns.push(relativePattern);
+    const modulePatterns = this.analyzeCommonModules(scanner);
+    patterns.push(...modulePatterns);
+    return patterns;
+  }
+  analyzeBarrelImports(scanner) {
+    const imports = scanner.findImports();
+    const barrelImports = imports.filter((i) => {
+      const modulePath = i.module;
+      return modulePath.startsWith(".") && !modulePath.includes(".js") && !modulePath.includes(".ts");
+    });
+    const indexImports = barrelImports.filter((i) => {
+      return i.module.endsWith("/index") || !i.module.includes("/");
+    });
+    if (indexImports.length < 3) return null;
+    const confidence = calculateConfidence(indexImports.length, barrelImports.length);
+    if (confidence < 50) return null;
+    return createPattern(this.id, {
+      id: "imports-barrel",
+      name: "Barrel Import Pattern",
+      description: "Modules are imported through barrel (index) files",
+      confidence,
+      occurrences: indexImports.length,
+      examples: indexImports.slice(0, 3).map((i) => ({
+        file: i.file,
+        line: i.line,
+        snippet: `import { ${i.named.slice(0, 3).join(", ")} } from '${i.module}'`
+      })),
+      suggestedConstraint: {
+        type: "convention",
+        rule: "Import from barrel (index) files rather than individual modules",
+        severity: "low",
+        scope: "src/**/*.ts"
+      }
+    });
+  }
+  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 total = relativeImports.length + absoluteImports.length + aliasImports.length;
+    if (total < 10) return null;
+    if (aliasImports.length > relativeImports.length && aliasImports.length >= 5) {
+      const confidence = calculateConfidence(aliasImports.length, total);
+      if (confidence < 50) return null;
+      return createPattern(this.id, {
+        id: "imports-alias",
+        name: "Path Alias Import Pattern",
+        description: "Imports use path aliases (@ or ~) instead of relative paths",
+        confidence,
+        occurrences: aliasImports.length,
+        examples: aliasImports.slice(0, 3).map((i) => ({
+          file: i.file,
+          line: i.line,
+          snippet: `import { ${i.named.slice(0, 2).join(", ")} } from '${i.module}'`
+        })),
+        suggestedConstraint: {
+          type: "convention",
+          rule: "Use path aliases instead of relative imports",
+          severity: "low",
+          scope: "src/**/*.ts"
+        }
+      });
+    }
+    if (relativeImports.length > aliasImports.length * 2 && relativeImports.length >= 5) {
+      const confidence = calculateConfidence(relativeImports.length, total);
+      if (confidence < 50) return null;
+      return createPattern(this.id, {
+        id: "imports-relative",
+        name: "Relative Import Pattern",
+        description: "Imports use relative paths",
+        confidence,
+        occurrences: relativeImports.length,
+        examples: relativeImports.slice(0, 3).map((i) => ({
+          file: i.file,
+          line: i.line,
+          snippet: `import { ${i.named.slice(0, 2).join(", ")} } from '${i.module}'`
+        })),
+        suggestedConstraint: {
+          type: "guideline",
+          rule: "Use relative imports for local modules",
+          severity: "low",
+          scope: "src/**/*.ts"
+        }
+      });
+    }
+    return null;
+  }
+  analyzeCommonModules(scanner) {
+    const patterns = [];
+    const imports = scanner.findImports();
+    const moduleCounts = /* @__PURE__ */ new Map();
+    for (const imp of imports) {
+      if (imp.module.startsWith(".")) continue;
+      const parts = imp.module.split("/");
+      const packageName = imp.module.startsWith("@") && parts.length > 1 ? `${parts[0]}/${parts[1]}` : parts[0];
+      if (packageName) {
+        const existing = moduleCounts.get(packageName) || { count: 0, examples: [] };
+        existing.count++;
+        existing.examples.push(imp);
+        moduleCounts.set(packageName, existing);
+      }
+    }
+    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}'`
+          }))
+        }));
+      }
+    }
+    return patterns;
+  }
+};
+
+// src/inference/analyzers/structure.ts
+import { basename, dirname as dirname2 } from "path";
+var StructureAnalyzer = class {
+  id = "structure";
+  name = "Code Structure Analyzer";
+  description = "Detects file organization and directory structure patterns";
+  async analyze(scanner) {
+    const patterns = [];
+    const files = scanner.getFiles();
+    const dirPatterns = this.analyzeDirectoryConventions(files);
+    patterns.push(...dirPatterns);
+    const filePatterns = this.analyzeFileNaming(files);
+    patterns.push(...filePatterns);
+    const colocationPattern = this.analyzeColocation(files);
+    if (colocationPattern) patterns.push(colocationPattern);
+    return patterns;
+  }
+  analyzeDirectoryConventions(files) {
+    const patterns = [];
+    const dirCounts = /* @__PURE__ */ new Map();
+    for (const file of files) {
+      const dir = basename(dirname2(file.path));
+      dirCounts.set(dir, (dirCounts.get(dir) || 0) + 1);
+    }
+    const commonDirs = [
+      { name: "components", description: "UI components are organized in a components directory" },
+      { name: "hooks", description: "Custom hooks are organized in a hooks directory" },
+      { name: "utils", description: "Utility functions are organized in a utils directory" },
+      { name: "services", description: "Service modules are organized in a services directory" },
+      { name: "types", description: "Type definitions are organized in a types directory" },
+      { name: "api", description: "API modules are organized in an api directory" },
+      { name: "lib", description: "Library code is organized in a lib directory" },
+      { name: "core", description: "Core modules are organized in a core directory" }
+    ];
+    for (const { name, description } of commonDirs) {
+      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`
+          }
+        }));
+      }
+    }
+    return patterns;
+  }
+  analyzeFileNaming(files) {
+    const patterns = [];
+    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" }
+    ];
+    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)
+          }))
+        }));
+      }
+    }
+    return patterns;
+  }
+  analyzeColocation(files) {
+    const testFiles = files.filter((f) => /\.(test|spec)\.tsx?$/.test(f.path));
+    const sourceFiles = files.filter((f) => !/\.(test|spec)\.tsx?$/.test(f.path));
+    if (testFiles.length < 3) return null;
+    let colocatedCount = 0;
+    const colocatedExamples = [];
+    for (const testFile of testFiles) {
+      const testDir = dirname2(testFile.path);
+      const testName = basename(testFile.path).replace(/\.(test|spec)\.tsx?$/, "");
+      const hasColocatedSource = sourceFiles.some(
+        (s) => dirname2(s.path) === testDir && basename(s.path).startsWith(testName)
+      );
+      if (hasColocatedSource) {
+        colocatedCount++;
+        if (colocatedExamples.length < 3) {
+          colocatedExamples.push({
+            file: testFile.path,
+            line: 1,
+            snippet: basename(testFile.path)
+          });
+        }
+      }
+    }
+    const confidence = calculateConfidence(colocatedCount, testFiles.length);
+    if (confidence < 60) return null;
+    return createPattern(this.id, {
+      id: "structure-colocation",
+      name: "Test Colocation Pattern",
+      description: "Test files are colocated with their source files",
+      confidence,
+      occurrences: colocatedCount,
+      examples: colocatedExamples,
+      suggestedConstraint: {
+        type: "guideline",
+        rule: "Test files should be colocated with their source files",
+        severity: "low",
+        scope: "src/**/*.test.ts"
+      }
+    });
+  }
+};
+
+// src/inference/analyzers/errors.ts
+import { Node as Node2 } from "ts-morph";
+var ErrorsAnalyzer = class {
+  id = "errors";
+  name = "Error Handling Analyzer";
+  description = "Detects error handling patterns and custom error class usage";
+  async analyze(scanner) {
+    const patterns = [];
+    const errorClassPattern = this.analyzeCustomErrorClasses(scanner);
+    if (errorClassPattern) patterns.push(errorClassPattern);
+    const tryCatchPattern = this.analyzeTryCatchPatterns(scanner);
+    if (tryCatchPattern) patterns.push(tryCatchPattern);
+    const throwPattern = this.analyzeThrowPatterns(scanner);
+    if (throwPattern) patterns.push(throwPattern);
+    return patterns;
+  }
+  analyzeCustomErrorClasses(scanner) {
+    const classes = scanner.findClasses();
+    const errorClasses = classes.filter(
+      (c) => c.name.endsWith("Error") || c.name.endsWith("Exception")
+    );
+    if (errorClasses.length < 2) return null;
+    const files = scanner.getFiles();
+    let extendsError = 0;
+    let extendsCustomBase = 0;
+    let customBaseName = null;
+    for (const errorClass of errorClasses) {
+      const file = files.find((f) => f.path === errorClass.file);
+      if (!file) continue;
+      const classDecl = file.sourceFile.getClass(errorClass.name);
+      if (!classDecl) continue;
+      const extendClause = classDecl.getExtends();
+      if (extendClause) {
+        const baseName = extendClause.getText();
+        if (baseName === "Error") {
+          extendsError++;
+        } else if (baseName.endsWith("Error")) {
+          extendsCustomBase++;
+          customBaseName = customBaseName || baseName;
+        }
+      }
+    }
+    if (extendsCustomBase >= 2 && customBaseName) {
+      const confidence = calculateConfidence(extendsCustomBase, errorClasses.length);
+      return createPattern(this.id, {
+        id: "errors-custom-base",
+        name: "Custom Error Base Class",
+        description: `Custom errors extend a common base class (${customBaseName})`,
+        confidence,
+        occurrences: extendsCustomBase,
+        examples: errorClasses.slice(0, 3).map((c) => ({
+          file: c.file,
+          line: c.line,
+          snippet: `class ${c.name} extends ${customBaseName}`
+        })),
+        suggestedConstraint: {
+          type: "convention",
+          rule: `Custom error classes should extend ${customBaseName}`,
+          severity: "medium",
+          scope: "src/**/*.ts",
+          verifier: "error-hierarchy"
+        }
+      });
+    }
+    if (errorClasses.length >= 3) {
+      const confidence = Math.min(100, 50 + errorClasses.length * 5);
+      return createPattern(this.id, {
+        id: "errors-custom-classes",
+        name: "Custom Error Classes",
+        description: "Custom error classes are used for domain-specific errors",
+        confidence,
+        occurrences: errorClasses.length,
+        examples: errorClasses.slice(0, 3).map((c) => ({
+          file: c.file,
+          line: c.line,
+          snippet: `class ${c.name}`
+        })),
+        suggestedConstraint: {
+          type: "guideline",
+          rule: "Use custom error classes for domain-specific errors",
+          severity: "low",
+          scope: "src/**/*.ts"
+        }
+      });
+    }
+    return null;
+  }
+  analyzeTryCatchPatterns(scanner) {
+    const tryCatchBlocks = scanner.findTryCatchBlocks();
+    if (tryCatchBlocks.length < 3) return null;
+    const rethrowCount = tryCatchBlocks.filter((b) => b.hasThrow).length;
+    const swallowCount = tryCatchBlocks.length - rethrowCount;
+    if (rethrowCount >= 3 && rethrowCount > swallowCount) {
+      const confidence = calculateConfidence(rethrowCount, tryCatchBlocks.length);
+      return createPattern(this.id, {
+        id: "errors-rethrow",
+        name: "Error Rethrow Pattern",
+        description: "Caught errors are typically rethrown after handling",
+        confidence,
+        occurrences: rethrowCount,
+        examples: tryCatchBlocks.filter((b) => b.hasThrow).slice(0, 3).map((b) => ({
+          file: b.file,
+          line: b.line,
+          snippet: "try { ... } catch (e) { ... throw ... }"
+        })),
+        suggestedConstraint: {
+          type: "guideline",
+          rule: "Caught errors should be rethrown or wrapped after handling",
+          severity: "low",
+          scope: "src/**/*.ts"
+        }
+      });
+    }
+    return null;
+  }
+  analyzeThrowPatterns(scanner) {
+    const files = scanner.getFiles();
+    let throwNewError = 0;
+    let throwCustom = 0;
+    const examples = [];
+    for (const { path, sourceFile } of files) {
+      sourceFile.forEachDescendant((node) => {
+        if (Node2.isThrowStatement(node)) {
+          const expression = node.getExpression();
+          if (expression) {
+            const text = expression.getText();
+            if (text.startsWith("new Error(")) {
+              throwNewError++;
+            } else if (text.startsWith("new ") && text.includes("Error")) {
+              throwCustom++;
+              if (examples.length < 3) {
+                examples.push({
+                  file: path,
+                  line: node.getStartLineNumber(),
+                  snippet: `throw ${text.slice(0, 50)}${text.length > 50 ? "..." : ""}`
+                });
+              }
+            }
+          }
+        }
+      });
+    }
+    if (throwCustom >= 3 && throwCustom > throwNewError) {
+      const confidence = calculateConfidence(throwCustom, throwCustom + throwNewError);
+      return createPattern(this.id, {
+        id: "errors-throw-custom",
+        name: "Custom Error Throwing",
+        description: "Custom error classes are thrown instead of generic Error",
+        confidence,
+        occurrences: throwCustom,
+        examples,
+        suggestedConstraint: {
+          type: "convention",
+          rule: "Throw custom error classes instead of generic Error",
+          severity: "medium",
+          scope: "src/**/*.ts",
+          verifier: "custom-errors-only"
+        }
+      });
+    }
+    return null;
+  }
+};
+
+// src/inference/analyzers/index.ts
+var builtinAnalyzers = {
+  naming: () => new NamingAnalyzer(),
+  imports: () => new ImportsAnalyzer(),
+  structure: () => new StructureAnalyzer(),
+  errors: () => new ErrorsAnalyzer()
+};
+function getAnalyzer(id) {
+  const factory = builtinAnalyzers[id];
+  return factory ? factory() : null;
+}
+function getAnalyzerIds() {
+  return Object.keys(builtinAnalyzers);
+}
+
+// src/inference/engine.ts
+var InferenceEngine = class {
+  scanner;
+  analyzers = [];
+  constructor() {
+    this.scanner = new CodeScanner();
+  }
+  /**
+   * Configure analyzers to use
+   */
+  configureAnalyzers(analyzerIds) {
+    this.analyzers = [];
+    for (const id of analyzerIds) {
+      const analyzer = getAnalyzer(id);
+      if (!analyzer) {
+        throw new AnalyzerNotFoundError(id);
+      }
+      this.analyzers.push(analyzer);
+    }
+  }
+  /**
+   * Run inference on the codebase
+   */
+  async infer(options) {
+    const startTime = Date.now();
+    const {
+      analyzers: analyzerIds = getAnalyzerIds(),
+      minConfidence = 50,
+      sourceRoots = ["src/**/*.ts", "src/**/*.tsx"],
+      exclude = ["**/*.test.ts", "**/*.spec.ts", "**/node_modules/**", "**/dist/**"],
+      cwd = process.cwd()
+    } = options;
+    this.configureAnalyzers(analyzerIds);
+    const scanResult = await this.scanner.scan({
+      sourceRoots,
+      exclude,
+      cwd
+    });
+    if (scanResult.totalFiles === 0) {
+      return {
+        patterns: [],
+        analyzersRun: analyzerIds,
+        filesScanned: 0,
+        duration: Date.now() - startTime
+      };
+    }
+    const allPatterns = [];
+    for (const analyzer of this.analyzers) {
+      try {
+        const patterns = await analyzer.analyze(this.scanner);
+        allPatterns.push(...patterns);
+      } catch (error) {
+        console.warn(`Analyzer ${analyzer.id} failed:`, error);
+      }
+    }
+    const filteredPatterns = allPatterns.filter((p) => p.confidence >= minConfidence);
+    filteredPatterns.sort((a, b) => b.confidence - a.confidence);
+    return {
+      patterns: filteredPatterns,
+      analyzersRun: analyzerIds,
+      filesScanned: scanResult.totalFiles,
+      duration: Date.now() - startTime
+    };
+  }
+  /**
+   * Get scanner for direct access
+   */
+  getScanner() {
+    return this.scanner;
+  }
+};
+function createInferenceEngine() {
+  return new InferenceEngine();
+}
+
+// src/config/loader.ts
+async function loadConfig(basePath = process.cwd()) {
+  const specbridgeDir = getSpecBridgeDir(basePath);
+  const configPath = getConfigPath(basePath);
+  if (!await pathExists(specbridgeDir)) {
+    throw new NotInitializedError();
+  }
+  if (!await pathExists(configPath)) {
+    return defaultConfig;
+  }
+  const content = await readTextFile(configPath);
+  const parsed = parseYaml(content);
+  const result = validateConfig(parsed);
+  if (!result.success) {
+    const errors = result.errors.errors.map((e) => `${e.path.join(".")}: ${e.message}`);
+    throw new ConfigError(`Invalid configuration in ${configPath}`, { errors });
+  }
+  return result.data;
+}
+
+// src/cli/commands/infer.ts
+var inferCommand = new Command2("infer").description("Analyze codebase and detect patterns").option("-o, --output <file>", "Output file path").option("-c, --min-confidence <number>", "Minimum confidence threshold (0-100)", "50").option("-a, --analyzers <list>", "Comma-separated list of analyzers to run").option("--json", "Output as JSON").option("--save", "Save results to .specbridge/inferred/").action(async (options) => {
+  const cwd = process.cwd();
+  if (!await pathExists(getSpecBridgeDir(cwd))) {
+    throw new NotInitializedError();
+  }
+  const spinner = ora2("Loading configuration...").start();
+  try {
+    const config = await loadConfig(cwd);
+    const minConfidence = parseInt(options.minConfidence || "50", 10);
+    const analyzerList = options.analyzers ? options.analyzers.split(",").map((a) => a.trim()) : config.inference?.analyzers || getAnalyzerIds();
+    spinner.text = `Scanning codebase (analyzers: ${analyzerList.join(", ")})...`;
+    const engine = createInferenceEngine();
+    const result = await engine.infer({
+      analyzers: analyzerList,
+      minConfidence,
+      sourceRoots: config.project.sourceRoots,
+      exclude: config.project.exclude,
+      cwd
+    });
+    spinner.succeed(`Scanned ${result.filesScanned} files in ${result.duration}ms`);
+    if (result.patterns.length === 0) {
+      console.log(chalk2.yellow("\nNo patterns detected above confidence threshold."));
+      console.log(chalk2.dim(`Try lowering --min-confidence (current: ${minConfidence})`));
+      return;
+    }
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      printPatterns(result.patterns);
+    }
+    if (options.save || options.output) {
+      const outputPath = options.output || join3(getInferredDir(cwd), "patterns.json");
+      await writeTextFile(outputPath, JSON.stringify(result, null, 2));
+      console.log(chalk2.green(`
+Results saved to: ${outputPath}`));
+    }
+    if (!options.json) {
+      console.log("");
+      console.log(chalk2.cyan("Next steps:"));
+      console.log("  Review detected patterns and create decisions for important ones.");
+      console.log(`  Use ${chalk2.bold("specbridge decision create <id>")} to create a new decision.`);
+    }
+  } catch (error) {
+    spinner.fail("Inference failed");
+    throw error;
+  }
+});
+function printPatterns(patterns) {
+  console.log(chalk2.bold(`
+Detected ${patterns.length} pattern(s):
+`));
+  for (const pattern of patterns) {
+    const confidenceColor = pattern.confidence >= 80 ? chalk2.green : pattern.confidence >= 60 ? chalk2.yellow : chalk2.dim;
+    console.log(chalk2.bold(`${pattern.name}`));
+    console.log(chalk2.dim(`  ID: ${pattern.id}`));
+    console.log(`  ${pattern.description}`);
+    console.log(`  Confidence: ${confidenceColor(`${pattern.confidence}%`)} (${pattern.occurrences} occurrences)`);
+    console.log(chalk2.dim(`  Analyzer: ${pattern.analyzer}`));
+    if (pattern.examples.length > 0) {
+      console.log(chalk2.dim("  Examples:"));
+      for (const example of pattern.examples.slice(0, 2)) {
+        console.log(chalk2.dim(`    - ${example.file}:${example.line}`));
+        console.log(chalk2.dim(`      ${example.snippet}`));
+      }
+    }
+    if (pattern.suggestedConstraint) {
+      const typeColor = pattern.suggestedConstraint.type === "invariant" ? chalk2.red : pattern.suggestedConstraint.type === "convention" ? chalk2.yellow : chalk2.green;
+      console.log(chalk2.cyan("  Suggested constraint:"));
+      console.log(`    Type: ${typeColor(pattern.suggestedConstraint.type || "convention")}`);
+      console.log(`    Rule: ${pattern.suggestedConstraint.rule}`);
+    }
+    console.log("");
+  }
+}
+
+// src/cli/commands/verify.ts
+import { Command as Command3 } from "commander";
+import chalk3 from "chalk";
+import ora3 from "ora";
+
+// src/verification/engine.ts
+import { Project as Project2 } from "ts-morph";
+
+// src/registry/loader.ts
+import { join as join4 } from "path";
+
+// src/core/schemas/decision.schema.ts
+import { z as z2 } from "zod";
+var DecisionStatusSchema = z2.enum(["draft", "active", "deprecated", "superseded"]);
+var ConstraintTypeSchema = z2.enum(["invariant", "convention", "guideline"]);
+var SeveritySchema2 = z2.enum(["critical", "high", "medium", "low"]);
+var VerificationFrequencySchema = z2.enum(["commit", "pr", "daily", "weekly"]);
+var DecisionMetadataSchema = z2.object({
+  id: z2.string().min(1).regex(/^[a-z0-9-]+$/, "ID must be lowercase alphanumeric with hyphens"),
+  title: z2.string().min(1).max(200),
+  status: DecisionStatusSchema,
+  owners: z2.array(z2.string().min(1)).min(1),
+  createdAt: z2.string().datetime().optional(),
+  updatedAt: z2.string().datetime().optional(),
+  supersededBy: z2.string().optional(),
+  tags: z2.array(z2.string()).optional()
+});
+var DecisionContentSchema = z2.object({
+  summary: z2.string().min(1).max(500),
+  rationale: z2.string().min(1),
+  context: z2.string().optional(),
+  consequences: z2.array(z2.string()).optional()
+});
+var ConstraintExceptionSchema = z2.object({
+  pattern: z2.string().min(1),
+  reason: z2.string().min(1),
+  approvedBy: z2.string().optional(),
+  expiresAt: z2.string().datetime().optional()
+});
+var ConstraintSchema = z2.object({
+  id: z2.string().min(1).regex(/^[a-z0-9-]+$/, "Constraint ID must be lowercase alphanumeric with hyphens"),
+  type: ConstraintTypeSchema,
+  rule: z2.string().min(1),
+  severity: SeveritySchema2,
+  scope: z2.string().min(1),
+  verifier: z2.string().optional(),
+  autofix: z2.boolean().optional(),
+  exceptions: z2.array(ConstraintExceptionSchema).optional()
+});
+var VerificationConfigSchema2 = z2.object({
+  check: z2.string().min(1),
+  target: z2.string().min(1),
+  frequency: VerificationFrequencySchema,
+  timeout: z2.number().positive().optional()
+});
+var LinksSchema = z2.object({
+  related: z2.array(z2.string()).optional(),
+  supersedes: z2.array(z2.string()).optional(),
+  references: z2.array(z2.string().url()).optional()
+});
+var DecisionSchema = z2.object({
+  kind: z2.literal("Decision"),
+  metadata: DecisionMetadataSchema,
+  decision: DecisionContentSchema,
+  constraints: z2.array(ConstraintSchema).min(1),
+  verification: z2.object({
+    automated: z2.array(VerificationConfigSchema2).optional()
+  }).optional(),
+  links: LinksSchema.optional()
+});
+function validateDecision(data) {
+  const result = DecisionSchema.safeParse(data);
+  if (result.success) {
+    return { success: true, data: result.data };
+  }
+  return { success: false, errors: result.error };
+}
+function formatValidationErrors(errors) {
+  return errors.errors.map((err) => {
+    const path = err.path.join(".");
+    return `${path}: ${err.message}`;
+  });
+}
+
+// src/registry/loader.ts
+async function loadDecisionFile(filePath) {
+  if (!await pathExists(filePath)) {
+    throw new FileSystemError(`Decision file not found: ${filePath}`, filePath);
+  }
+  const content = await readTextFile(filePath);
+  const parsed = parseYaml(content);
+  const result = validateDecision(parsed);
+  if (!result.success) {
+    const errors = formatValidationErrors(result.errors);
+    throw new DecisionValidationError(
+      `Invalid decision file: ${filePath}`,
+      typeof parsed === "object" && parsed !== null && "metadata" in parsed ? parsed.metadata?.id || "unknown" : "unknown",
+      errors
+    );
+  }
+  return result.data;
+}
+async function loadDecisionsFromDir(dirPath) {
+  const decisions = [];
+  const errors = [];
+  if (!await pathExists(dirPath)) {
+    return { decisions, errors };
+  }
+  const files = await readFilesInDir(dirPath, (f) => f.endsWith(".decision.yaml"));
+  for (const file of files) {
+    const filePath = join4(dirPath, file);
+    try {
+      const decision = await loadDecisionFile(filePath);
+      decisions.push({ decision, filePath });
+    } catch (error) {
+      errors.push({
+        filePath,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  return { decisions, errors };
+}
+async function validateDecisionFile(filePath) {
+  try {
+    if (!await pathExists(filePath)) {
+      return { valid: false, errors: [`File not found: ${filePath}`] };
+    }
+    const content = await readTextFile(filePath);
+    const parsed = parseYaml(content);
+    const result = validateDecision(parsed);
+    if (!result.success) {
+      return { valid: false, errors: formatValidationErrors(result.errors) };
+    }
+    return { valid: true, errors: [] };
+  } catch (error) {
+    return {
+      valid: false,
+      errors: [error instanceof Error ? error.message : String(error)]
+    };
+  }
+}
+
+// src/registry/registry.ts
+var Registry = class {
+  decisions = /* @__PURE__ */ new Map();
+  basePath;
+  loaded = false;
+  constructor(options = {}) {
+    this.basePath = options.basePath || process.cwd();
+  }
+  /**
+   * Load all decisions from the decisions directory
+   */
+  async load() {
+    if (!await pathExists(getSpecBridgeDir(this.basePath))) {
+      throw new NotInitializedError();
+    }
+    const decisionsDir = getDecisionsDir(this.basePath);
+    const result = await loadDecisionsFromDir(decisionsDir);
+    this.decisions.clear();
+    for (const loaded of result.decisions) {
+      this.decisions.set(loaded.decision.metadata.id, loaded);
+    }
+    this.loaded = true;
+    return result;
+  }
+  /**
+   * Ensure registry is loaded
+   */
+  ensureLoaded() {
+    if (!this.loaded) {
+      throw new Error("Registry not loaded. Call load() first.");
+    }
+  }
+  /**
+   * Get all decisions
+   */
+  getAll(filter) {
+    this.ensureLoaded();
+    let decisions = Array.from(this.decisions.values()).map((d) => d.decision);
+    if (filter) {
+      decisions = this.applyFilter(decisions, filter);
+    }
+    return decisions;
+  }
+  /**
+   * Get active decisions only
+   */
+  getActive() {
+    return this.getAll({ status: ["active"] });
+  }
+  /**
+   * Get a decision by ID
+   */
+  get(id) {
+    this.ensureLoaded();
+    const loaded = this.decisions.get(id);
+    if (!loaded) {
+      throw new DecisionNotFoundError(id);
+    }
+    return loaded.decision;
+  }
+  /**
+   * Get a decision with its file path
+   */
+  getWithPath(id) {
+    this.ensureLoaded();
+    const loaded = this.decisions.get(id);
+    if (!loaded) {
+      throw new DecisionNotFoundError(id);
+    }
+    return loaded;
+  }
+  /**
+   * Check if a decision exists
+   */
+  has(id) {
+    this.ensureLoaded();
+    return this.decisions.has(id);
+  }
+  /**
+   * Get all decision IDs
+   */
+  getIds() {
+    this.ensureLoaded();
+    return Array.from(this.decisions.keys());
+  }
+  /**
+   * Get constraints applicable to a specific file
+   */
+  getConstraintsForFile(filePath, filter) {
+    this.ensureLoaded();
+    const applicable = [];
+    let decisions = this.getActive();
+    if (filter) {
+      decisions = this.applyFilter(decisions, filter);
+    }
+    for (const decision of decisions) {
+      for (const constraint of decision.constraints) {
+        if (matchesPattern(filePath, constraint.scope)) {
+          applicable.push({
+            decisionId: decision.metadata.id,
+            decisionTitle: decision.metadata.title,
+            constraintId: constraint.id,
+            type: constraint.type,
+            rule: constraint.rule,
+            severity: constraint.severity,
+            scope: constraint.scope
+          });
+        }
+      }
+    }
+    return applicable;
+  }
+  /**
+   * Get decisions by tag
+   */
+  getByTag(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)
+    );
+  }
+  /**
+   * Apply filter to decisions
+   */
+  applyFilter(decisions, filter) {
+    return decisions.filter((decision) => {
+      if (filter.status && !filter.status.includes(decision.metadata.status)) {
+        return false;
+      }
+      if (filter.tags) {
+        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)
+        );
+        if (!hasType) return false;
+      }
+      if (filter.severity) {
+        const hasSeverity = decision.constraints.some(
+          (c) => filter.severity?.includes(c.severity)
+        );
+        if (!hasSeverity) return false;
+      }
+      return true;
+    });
+  }
+  /**
+   * Get count of decisions by status
+   */
+  getStatusCounts() {
+    this.ensureLoaded();
+    const counts = {
+      draft: 0,
+      active: 0,
+      deprecated: 0,
+      superseded: 0
+    };
+    for (const loaded of this.decisions.values()) {
+      counts[loaded.decision.metadata.status]++;
+    }
+    return counts;
+  }
+  /**
+   * Get total constraint count
+   */
+  getConstraintCount() {
+    this.ensureLoaded();
+    let count = 0;
+    for (const loaded of this.decisions.values()) {
+      count += loaded.decision.constraints.length;
+    }
+    return count;
+  }
+};
+function createRegistry(options) {
+  return new Registry(options);
+}
+
+// src/verification/verifiers/base.ts
+function createViolation(params) {
+  return params;
+}
+
+// src/verification/verifiers/naming.ts
+var NAMING_PATTERNS = {
+  PascalCase: {
+    regex: /^[A-Z][a-zA-Z0-9]*$/,
+    description: "PascalCase (e.g., MyClass)"
+  },
+  camelCase: {
+    regex: /^[a-z][a-zA-Z0-9]*$/,
+    description: "camelCase (e.g., myFunction)"
+  },
+  UPPER_SNAKE_CASE: {
+    regex: /^[A-Z][A-Z0-9_]*$/,
+    description: "UPPER_SNAKE_CASE (e.g., MAX_VALUE)"
+  },
+  snake_case: {
+    regex: /^[a-z][a-z0-9_]*$/,
+    description: "snake_case (e.g., my_variable)"
+  },
+  "kebab-case": {
+    regex: /^[a-z][a-z0-9-]*$/,
+    description: "kebab-case (e.g., my-component)"
+  }
+};
+var NamingVerifier = class {
+  id = "naming";
+  name = "Naming Convention Verifier";
+  description = "Verifies naming conventions for classes, functions, and variables";
+  async verify(ctx) {
+    const violations = [];
+    const { sourceFile, constraint, decisionId, filePath } = ctx;
+    const rule = constraint.rule.toLowerCase();
+    let convention = null;
+    let targetType = null;
+    for (const [name] of Object.entries(NAMING_PATTERNS)) {
+      if (rule.includes(name.toLowerCase())) {
+        convention = name;
+        break;
+      }
+    }
+    if (rule.includes("class")) targetType = "class";
+    else if (rule.includes("function")) targetType = "function";
+    else if (rule.includes("interface")) targetType = "interface";
+    else if (rule.includes("type")) targetType = "type";
+    if (!convention || !targetType) {
+      return violations;
+    }
+    const pattern = NAMING_PATTERNS[convention];
+    if (!pattern) return violations;
+    if (targetType === "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}`
+          }));
+        }
+      }
+    }
+    if (targetType === "function") {
+      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}`
+          }));
+        }
+      }
+    }
+    if (targetType === "interface") {
+      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}`
+          }));
+        }
+      }
+    }
+    if (targetType === "type") {
+      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}`
+          }));
+        }
+      }
+    }
+    return violations;
+  }
+};
+
+// src/verification/verifiers/imports.ts
+var ImportsVerifier = class {
+  id = "imports";
+  name = "Import Pattern Verifier";
+  description = "Verifies import patterns like barrel imports, path aliases, etc.";
+  async verify(ctx) {
+    const violations = [];
+    const { sourceFile, constraint, decisionId, filePath } = ctx;
+    const rule = constraint.rule.toLowerCase();
+    if (rule.includes("barrel") || rule.includes("index")) {
+      for (const importDecl of sourceFile.getImportDeclarations()) {
+        const moduleSpec = importDecl.getModuleSpecifierValue();
+        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"
+            }));
+          }
+        }
+      }
+    }
+    if (rule.includes("alias") || rule.includes("@/") || rule.includes("path alias")) {
+      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"
+          }));
+        }
+      }
+    }
+    if (rule.includes("circular") || rule.includes("cycle")) {
+      const currentFilename = filePath.replace(/\.[jt]sx?$/, "");
+      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"
+          }));
+        }
+      }
+    }
+    if (rule.includes("wildcard") || rule.includes("* as") || rule.includes("no namespace")) {
+      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"
+          }));
+        }
+      }
+    }
+    return violations;
+  }
+};
+
+// src/verification/verifiers/errors.ts
+import { Node as Node3 } from "ts-morph";
+var ErrorsVerifier = class {
+  id = "errors";
+  name = "Error Handling Verifier";
+  description = "Verifies error handling patterns";
+  async verify(ctx) {
+    const violations = [];
+    const { sourceFile, constraint, decisionId, filePath } = ctx;
+    const rule = constraint.rule.toLowerCase();
+    if (rule.includes("extend") || rule.includes("base") || rule.includes("hierarchy")) {
+      const baseClassMatch = rule.match(/extend\s+(\w+)/i) || rule.match(/(\w+Error)\s+class/i);
+      const requiredBase = baseClassMatch ? baseClassMatch[1] : null;
+      for (const classDecl of sourceFile.getClasses()) {
+        const className = classDecl.getName();
+        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"
+          }));
+        } else if (requiredBase) {
+          const baseName = extendsClause.getText();
+          if (baseName !== requiredBase && baseName !== "Error") {
+          }
+        }
+      }
+    }
+    if (rule.includes("custom error") || rule.includes("throw custom")) {
+      sourceFile.forEachDescendant((node) => {
+        if (Node3.isThrowStatement(node)) {
+          const expression = node.getExpression();
+          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"
+              }));
+            }
+          }
+        }
+      });
+    }
+    if (rule.includes("empty catch") || rule.includes("swallow") || rule.includes("handle")) {
+      sourceFile.forEachDescendant((node) => {
+        if (Node3.isTryStatement(node)) {
+          const catchClause = node.getCatchClause();
+          if (catchClause) {
+            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"
+              }));
+            }
+          }
+        }
+      });
+    }
+    if (rule.includes("logging") || rule.includes("logger") || rule.includes("no console")) {
+      sourceFile.forEachDescendant((node) => {
+        if (Node3.isCallExpression(node)) {
+          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"
+            }));
+          }
+        }
+      });
+    }
+    return violations;
+  }
+};
+
+// src/verification/verifiers/regex.ts
+var RegexVerifier = class {
+  id = "regex";
+  name = "Regex Pattern Verifier";
+  description = "Verifies code against regex patterns specified in constraints";
+  async verify(ctx) {
+    const violations = [];
+    const { sourceFile, constraint, decisionId, filePath } = ctx;
+    const rule = constraint.rule;
+    const mustNotMatch = rule.match(/must\s+not\s+(?:contain|match|use)\s+\/(.+?)\//i);
+    const shouldMatch = rule.match(/(?:should|must)\s+(?:contain|match|use)\s+\/(.+?)\//i);
+    const forbiddenPattern = rule.match(/forbidden:\s*\/(.+?)\//i);
+    const requiredPattern = rule.match(/required:\s*\/(.+?)\//i);
+    const fileText = sourceFile.getFullText();
+    const patternToForbid = mustNotMatch?.[1] || forbiddenPattern?.[1];
+    if (patternToForbid) {
+      try {
+        const regex = new RegExp(patternToForbid, "g");
+        let match;
+        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}/`
+          }));
+        }
+      } catch {
+      }
+    }
+    const patternToRequire = shouldMatch?.[1] || requiredPattern?.[1];
+    if (patternToRequire && !mustNotMatch) {
+      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}/`
+          }));
+        }
+      } catch {
+      }
+    }
+    return violations;
+  }
+};
+
+// src/verification/verifiers/index.ts
+var builtinVerifiers = {
+  naming: () => new NamingVerifier(),
+  imports: () => new ImportsVerifier(),
+  errors: () => new ErrorsVerifier(),
+  regex: () => new RegexVerifier()
+};
+function getVerifier(id) {
+  const factory = builtinVerifiers[id];
+  return factory ? factory() : null;
+}
+function selectVerifierForConstraint(rule, specifiedVerifier) {
+  if (specifiedVerifier) {
+    return getVerifier(specifiedVerifier);
+  }
+  const lowerRule = rule.toLowerCase();
+  if (lowerRule.includes("naming") || lowerRule.includes("case")) {
+    return getVerifier("naming");
+  }
+  if (lowerRule.includes("import") || lowerRule.includes("barrel") || lowerRule.includes("alias")) {
+    return getVerifier("imports");
+  }
+  if (lowerRule.includes("error") || lowerRule.includes("throw") || lowerRule.includes("catch")) {
+    return getVerifier("errors");
+  }
+  if (lowerRule.includes("/") || lowerRule.includes("pattern") || lowerRule.includes("regex")) {
+    return getVerifier("regex");
+  }
+  return getVerifier("regex");
+}
+
+// src/verification/engine.ts
+var VerificationEngine = class {
+  registry;
+  project;
+  constructor(registry) {
+    this.registry = registry || createRegistry();
+    this.project = new Project2({
+      compilerOptions: {
+        allowJs: true,
+        checkJs: false,
+        noEmit: true,
+        skipLibCheck: true
+      },
+      skipAddingFilesFromTsConfig: true
+    });
+  }
+  /**
+   * Run verification
+   */
+  async verify(config, options = {}) {
+    const startTime = Date.now();
+    const {
+      level = "full",
+      files: specificFiles,
+      decisions: decisionIds,
+      cwd = process.cwd()
+    } = options;
+    const levelConfig = config.verification?.levels?.[level];
+    const severityFilter = options.severity || levelConfig?.severity;
+    const timeout = options.timeout || levelConfig?.timeout || 6e4;
+    await this.registry.load();
+    let decisions = this.registry.getActive();
+    if (decisionIds && decisionIds.length > 0) {
+      decisions = decisions.filter((d) => decisionIds.includes(d.metadata.id));
+    }
+    const filesToVerify = specificFiles ? specificFiles : await glob(config.project.sourceRoots, {
+      cwd,
+      ignore: config.project.exclude,
+      absolute: true
+    });
+    if (filesToVerify.length === 0) {
+      return {
+        success: true,
+        violations: [],
+        checked: 0,
+        passed: 0,
+        failed: 0,
+        skipped: 0,
+        duration: Date.now() - startTime
+      };
+    }
+    const allViolations = [];
+    let checked = 0;
+    let passed = 0;
+    let failed = 0;
+    let skipped = 0;
+    const timeoutPromise = new Promise(
+      (resolve) => setTimeout(() => resolve("timeout"), timeout)
+    );
+    const verificationPromise = this.verifyFiles(
+      filesToVerify,
+      decisions,
+      severityFilter,
+      (violations) => {
+        allViolations.push(...violations);
+        checked++;
+        if (violations.length > 0) {
+          failed++;
+        } else {
+          passed++;
+        }
+      }
+    );
+    const result = await Promise.race([verificationPromise, timeoutPromise]);
+    if (result === "timeout") {
+      return {
+        success: false,
+        violations: allViolations,
+        checked,
+        passed,
+        failed,
+        skipped: filesToVerify.length - checked,
+        duration: timeout
+      };
+    }
+    const hasBlockingViolations = allViolations.some((v) => {
+      if (level === "commit") {
+        return v.type === "invariant" || v.severity === "critical";
+      }
+      if (level === "pr") {
+        return v.type === "invariant" || v.severity === "critical" || v.severity === "high";
+      }
+      return v.type === "invariant";
+    });
+    return {
+      success: !hasBlockingViolations,
+      violations: allViolations,
+      checked,
+      passed,
+      failed,
+      skipped,
+      duration: Date.now() - startTime
+    };
+  }
+  /**
+   * Verify a single file
+   */
+  async verifyFile(filePath, decisions, severityFilter) {
+    const violations = [];
+    let sourceFile = this.project.getSourceFile(filePath);
+    if (!sourceFile) {
+      try {
+        sourceFile = this.project.addSourceFileAtPath(filePath);
+      } catch {
+        return violations;
+      }
+    }
+    for (const decision of decisions) {
+      for (const constraint of decision.constraints) {
+        if (!matchesPattern(filePath, constraint.scope)) {
+          continue;
+        }
+        if (severityFilter && !severityFilter.includes(constraint.severity)) {
+          continue;
+        }
+        if (this.isExcepted(filePath, constraint)) {
+          continue;
+        }
+        const verifier = selectVerifierForConstraint(constraint.rule, constraint.verifier);
+        if (!verifier) {
+          continue;
+        }
+        const ctx = {
+          filePath,
+          sourceFile,
+          constraint,
+          decisionId: decision.metadata.id
+        };
+        try {
+          const constraintViolations = await verifier.verify(ctx);
+          violations.push(...constraintViolations);
+        } catch {
+        }
+      }
+    }
+    return violations;
+  }
+  /**
+   * Verify multiple files
+   */
+  async verifyFiles(files, decisions, severityFilter, onFileVerified) {
+    for (const file of files) {
+      const violations = await this.verifyFile(file, decisions, severityFilter);
+      onFileVerified(violations);
+    }
+  }
+  /**
+   * Check if file is excepted from constraint
+   */
+  isExcepted(filePath, constraint) {
+    if (!constraint.exceptions) return false;
+    return constraint.exceptions.some((exception) => {
+      if (exception.expiresAt) {
+        const expiryDate = new Date(exception.expiresAt);
+        if (expiryDate < /* @__PURE__ */ new Date()) {
+          return false;
+        }
+      }
+      return matchesPattern(filePath, exception.pattern);
+    });
+  }
+  /**
+   * Get registry
+   */
+  getRegistry() {
+    return this.registry;
+  }
+};
+function createVerificationEngine(registry) {
+  return new VerificationEngine(registry);
+}
+
+// src/cli/commands/verify.ts
+var verifyCommand = new Command3("verify").description("Verify code compliance against decisions").option("-l, --level <level>", "Verification level (commit, pr, full)", "full").option("-f, --files <patterns>", "Comma-separated file patterns to check").option("-d, --decisions <ids>", "Comma-separated decision IDs to check").option("-s, --severity <levels>", "Comma-separated severity levels (critical, high, medium, low)").option("--json", "Output as JSON").option("--fix", "Attempt to auto-fix violations (not yet implemented)").action(async (options) => {
+  const cwd = process.cwd();
+  if (!await pathExists(getSpecBridgeDir(cwd))) {
+    throw new NotInitializedError();
+  }
+  const spinner = ora3("Loading configuration...").start();
+  try {
+    const config = await loadConfig(cwd);
+    const level = options.level || "full";
+    const files = options.files?.split(",").map((f) => f.trim());
+    const decisions = options.decisions?.split(",").map((d) => d.trim());
+    const severity = options.severity?.split(",").map((s) => s.trim());
+    spinner.text = `Running ${level}-level verification...`;
+    const engine = createVerificationEngine();
+    const result = await engine.verify(config, {
+      level,
+      files,
+      decisions,
+      severity,
+      cwd
+    });
+    spinner.stop();
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      printResult(result, level);
+    }
+    if (!result.success) {
+      process.exit(1);
+    }
+  } catch (error) {
+    spinner.fail("Verification failed");
+    throw error;
+  }
+});
+function printResult(result, level) {
+  console.log("");
+  if (result.violations.length === 0) {
+    console.log(chalk3.green("\u2713 All checks passed!"));
+    console.log(chalk3.dim(`  ${result.checked} files checked in ${result.duration}ms`));
+    return;
+  }
+  const byFile = /* @__PURE__ */ new Map();
+  for (const violation of result.violations) {
+    const existing = byFile.get(violation.file) || [];
+    existing.push(violation);
+    byFile.set(violation.file, existing);
+  }
+  for (const [file, violations] of byFile) {
+    console.log(chalk3.underline(file));
+    for (const v of violations) {
+      const typeIcon = getTypeIcon(v.type);
+      const severityColor = getSeverityColor(v.severity);
+      const location = v.line ? `:${v.line}${v.column ? `:${v.column}` : ""}` : "";
+      console.log(
+        `  ${typeIcon} ${severityColor(`[${v.severity}]`)} ${v.message}`
+      );
+      console.log(chalk3.dim(`    ${v.decisionId}/${v.constraintId}${location}`));
+      if (v.suggestion) {
+        console.log(chalk3.cyan(`    Suggestion: ${v.suggestion}`));
+      }
+    }
+    console.log("");
+  }
+  const criticalCount = result.violations.filter((v) => v.severity === "critical").length;
+  const highCount = result.violations.filter((v) => v.severity === "high").length;
+  const mediumCount = result.violations.filter((v) => v.severity === "medium").length;
+  const lowCount = result.violations.filter((v) => v.severity === "low").length;
+  console.log(chalk3.bold("Summary:"));
+  console.log(`  Files: ${result.checked} checked, ${result.passed} passed, ${result.failed} failed`);
+  const violationParts = [];
+  if (criticalCount > 0) violationParts.push(chalk3.red(`${criticalCount} critical`));
+  if (highCount > 0) violationParts.push(chalk3.yellow(`${highCount} high`));
+  if (mediumCount > 0) violationParts.push(chalk3.cyan(`${mediumCount} medium`));
+  if (lowCount > 0) violationParts.push(chalk3.dim(`${lowCount} low`));
+  console.log(`  Violations: ${violationParts.join(", ")}`);
+  console.log(`  Duration: ${result.duration}ms`);
+  if (!result.success) {
+    console.log("");
+    const blockingTypes = level === "commit" ? "invariant or critical" : level === "pr" ? "invariant, critical, or high" : "invariant";
+    console.log(chalk3.red(`\u2717 Verification failed. ${blockingTypes} violations must be resolved.`));
+  }
+}
+function getTypeIcon(type) {
+  switch (type) {
+    case "invariant":
+      return chalk3.red("\u25CF");
+    case "convention":
+      return chalk3.yellow("\u25CF");
+    case "guideline":
+      return chalk3.green("\u25CF");
+    default:
+      return "\u25CB";
+  }
+}
+function getSeverityColor(severity) {
+  switch (severity) {
+    case "critical":
+      return chalk3.red;
+    case "high":
+      return chalk3.yellow;
+    case "medium":
+      return chalk3.cyan;
+    case "low":
+      return chalk3.dim;
+    default:
+      return chalk3.white;
+  }
+}
+
+// src/cli/commands/decision/index.ts
+import { Command as Command8 } from "commander";
+
+// src/cli/commands/decision/list.ts
+import { Command as Command4 } from "commander";
+import chalk4 from "chalk";
+import { table } from "table";
+var listDecisions = new Command4("list").description("List all architectural decisions").option("-s, --status <status>", "Filter by status (draft, active, deprecated, superseded)").option("-t, --tag <tag>", "Filter by tag").option("--json", "Output as JSON").action(async (options) => {
+  const registry = createRegistry();
+  const result = await registry.load();
+  if (result.errors.length > 0) {
+    console.warn(chalk4.yellow("\nWarnings:"));
+    for (const err of result.errors) {
+      console.warn(chalk4.yellow(`  - ${err.filePath}: ${err.error}`));
+    }
+    console.log("");
+  }
+  const filter = {};
+  if (options.status) {
+    filter.status = [options.status];
+  }
+  if (options.tag) {
+    filter.tags = [options.tag];
+  }
+  const decisions = registry.getAll(filter);
+  if (decisions.length === 0) {
+    console.log(chalk4.yellow("No decisions found."));
+    return;
+  }
+  if (options.json) {
+    console.log(JSON.stringify(decisions, null, 2));
+    return;
+  }
+  const data = [
+    [
+      chalk4.bold("ID"),
+      chalk4.bold("Title"),
+      chalk4.bold("Status"),
+      chalk4.bold("Constraints"),
+      chalk4.bold("Tags")
+    ]
+  ];
+  for (const decision of decisions) {
+    const statusColor = getStatusColor(decision.metadata.status);
+    const constraintTypes = getConstraintTypeSummary(decision.constraints.map((c) => c.type));
+    data.push([
+      decision.metadata.id,
+      truncate(decision.metadata.title, 40),
+      statusColor(decision.metadata.status),
+      constraintTypes,
+      (decision.metadata.tags || []).join(", ") || "-"
+    ]);
+  }
+  console.log(table(data, {
+    border: {
+      topBody: "",
+      topJoin: "",
+      topLeft: "",
+      topRight: "",
+      bottomBody: "",
+      bottomJoin: "",
+      bottomLeft: "",
+      bottomRight: "",
+      bodyLeft: "",
+      bodyRight: "",
+      bodyJoin: "  ",
+      joinBody: "",
+      joinLeft: "",
+      joinRight: "",
+      joinJoin: ""
+    },
+    drawHorizontalLine: (index) => index === 1
+  }));
+  console.log(chalk4.dim(`Total: ${decisions.length} decision(s)`));
+});
+function getStatusColor(status) {
+  switch (status) {
+    case "active":
+      return chalk4.green;
+    case "draft":
+      return chalk4.yellow;
+    case "deprecated":
+      return chalk4.gray;
+    case "superseded":
+      return chalk4.blue;
+    default:
+      return chalk4.white;
+  }
+}
+function getConstraintTypeSummary(types) {
+  const counts = {
+    invariant: 0,
+    convention: 0,
+    guideline: 0
+  };
+  for (const type of types) {
+    counts[type]++;
+  }
+  const parts = [];
+  if (counts.invariant > 0) parts.push(chalk4.red(`${counts.invariant}I`));
+  if (counts.convention > 0) parts.push(chalk4.yellow(`${counts.convention}C`));
+  if (counts.guideline > 0) parts.push(chalk4.green(`${counts.guideline}G`));
+  return parts.join(" ") || "-";
+}
+function truncate(str, length) {
+  if (str.length <= length) return str;
+  return str.slice(0, length - 3) + "...";
+}
+
+// src/cli/commands/decision/show.ts
+import { Command as Command5 } from "commander";
+import chalk5 from "chalk";
+var showDecision = new Command5("show").description("Show details of a specific decision").argument("<id>", "Decision ID").option("--json", "Output as JSON").action(async (id, options) => {
+  const registry = createRegistry();
+  await registry.load();
+  const decision = registry.get(id);
+  if (options.json) {
+    console.log(JSON.stringify(decision, null, 2));
+    return;
+  }
+  printDecision(decision);
+});
+function printDecision(decision) {
+  const { metadata, decision: content, constraints } = decision;
+  console.log(chalk5.bold.blue(`
+${metadata.title}`));
+  console.log(chalk5.dim(`ID: ${metadata.id}`));
+  console.log("");
+  console.log(chalk5.bold("Status:"), getStatusBadge(metadata.status));
+  console.log(chalk5.bold("Owners:"), metadata.owners.join(", "));
+  if (metadata.tags && metadata.tags.length > 0) {
+    console.log(chalk5.bold("Tags:"), metadata.tags.map((t) => chalk5.cyan(t)).join(", "));
+  }
+  if (metadata.createdAt) {
+    console.log(chalk5.bold("Created:"), metadata.createdAt);
+  }
+  if (metadata.supersededBy) {
+    console.log(chalk5.bold("Superseded by:"), chalk5.yellow(metadata.supersededBy));
+  }
+  console.log("");
+  console.log(chalk5.bold.underline("Summary"));
+  console.log(content.summary);
+  console.log("");
+  console.log(chalk5.bold.underline("Rationale"));
+  console.log(content.rationale);
+  console.log("");
+  if (content.context) {
+    console.log(chalk5.bold.underline("Context"));
+    console.log(content.context);
+    console.log("");
+  }
+  if (content.consequences && content.consequences.length > 0) {
+    console.log(chalk5.bold.underline("Consequences"));
+    for (const consequence of content.consequences) {
+      console.log(`  \u2022 ${consequence}`);
+    }
+    console.log("");
+  }
+  console.log(chalk5.bold.underline(`Constraints (${constraints.length})`));
+  for (const constraint of constraints) {
+    const typeIcon = getTypeIcon2(constraint.type);
+    const severityBadge = getSeverityBadge(constraint.severity);
+    console.log(`
+  ${typeIcon} ${chalk5.bold(constraint.id)} ${severityBadge}`);
+    console.log(`     ${constraint.rule}`);
+    console.log(chalk5.dim(`     Scope: ${constraint.scope}`));
+    if (constraint.verifier) {
+      console.log(chalk5.dim(`     Verifier: ${constraint.verifier}`));
+    }
+    if (constraint.exceptions && constraint.exceptions.length > 0) {
+      console.log(chalk5.dim(`     Exceptions: ${constraint.exceptions.length}`));
+    }
+  }
+  console.log("");
+  if (decision.verification?.automated && decision.verification.automated.length > 0) {
+    console.log(chalk5.bold.underline("Automated Verification"));
+    for (const check of decision.verification.automated) {
+      console.log(`  \u2022 ${check.check} (${check.frequency})`);
+      console.log(chalk5.dim(`    Target: ${check.target}`));
+    }
+    console.log("");
+  }
+  if (decision.links) {
+    const { related, supersedes, references } = decision.links;
+    if (related && related.length > 0) {
+      console.log(chalk5.bold("Related:"), related.join(", "));
+    }
+    if (supersedes && supersedes.length > 0) {
+      console.log(chalk5.bold("Supersedes:"), supersedes.join(", "));
+    }
+    if (references && references.length > 0) {
+      console.log(chalk5.bold("References:"));
+      for (const ref of references) {
+        console.log(`  \u2022 ${ref}`);
+      }
+    }
+  }
+}
+function getStatusBadge(status) {
+  switch (status) {
+    case "active":
+      return chalk5.bgGreen.black(" ACTIVE ");
+    case "draft":
+      return chalk5.bgYellow.black(" DRAFT ");
+    case "deprecated":
+      return chalk5.bgGray.white(" DEPRECATED ");
+    case "superseded":
+      return chalk5.bgBlue.white(" SUPERSEDED ");
+    default:
+      return status;
+  }
+}
+function getTypeIcon2(type) {
+  switch (type) {
+    case "invariant":
+      return chalk5.red("\u25CF");
+    case "convention":
+      return chalk5.yellow("\u25CF");
+    case "guideline":
+      return chalk5.green("\u25CF");
+    default:
+      return "\u25CB";
+  }
+}
+function getSeverityBadge(severity) {
+  switch (severity) {
+    case "critical":
+      return chalk5.bgRed.white(" CRITICAL ");
+    case "high":
+      return chalk5.bgYellow.black(" HIGH ");
+    case "medium":
+      return chalk5.bgCyan.black(" MEDIUM ");
+    case "low":
+      return chalk5.bgGray.white(" LOW ");
+    default:
+      return severity;
+  }
+}
+
+// src/cli/commands/decision/validate.ts
+import { Command as Command6 } from "commander";
+import chalk6 from "chalk";
+import ora4 from "ora";
+import { join as join5 } from "path";
+var validateDecisions = new Command6("validate").description("Validate decision files").option("-f, --file <path>", "Validate a specific file").action(async (options) => {
+  const cwd = process.cwd();
+  if (!await pathExists(getSpecBridgeDir(cwd))) {
+    throw new NotInitializedError();
+  }
+  const spinner = ora4("Validating decisions...").start();
+  try {
+    let files = [];
+    if (options.file) {
+      files = [options.file];
+    } else {
+      const decisionsDir = getDecisionsDir(cwd);
+      const decisionFiles = await readFilesInDir(
+        decisionsDir,
+        (f) => f.endsWith(".decision.yaml")
+      );
+      files = decisionFiles.map((f) => join5(decisionsDir, f));
+    }
+    if (files.length === 0) {
+      spinner.info("No decision files found.");
+      return;
+    }
+    let valid = 0;
+    let invalid = 0;
+    const errors = [];
+    for (const file of files) {
+      const result = await validateDecisionFile(file);
+      if (result.valid) {
+        valid++;
+      } else {
+        invalid++;
+        errors.push({ file, errors: result.errors });
+      }
+    }
+    spinner.stop();
+    if (invalid === 0) {
+      console.log(chalk6.green(`\u2713 All ${valid} decision file(s) are valid.`));
+    } else {
+      console.log(chalk6.red(`\u2717 ${invalid} of ${files.length} decision file(s) have errors.
+`));
+      for (const { file, errors: fileErrors } of errors) {
+        console.log(chalk6.red(`File: ${file}`));
+        for (const err of fileErrors) {
+          console.log(chalk6.dim(`  - ${err}`));
+        }
+        console.log("");
+      }
+      process.exit(1);
+    }
+  } catch (error) {
+    spinner.fail("Validation failed");
+    throw error;
+  }
+});
+
+// src/cli/commands/decision/create.ts
+import { Command as Command7 } from "commander";
+import chalk7 from "chalk";
+import { join as join6 } from "path";
+var createDecision = new Command7("create").description("Create a new decision file").argument("<id>", "Decision ID (e.g., auth-001)").requiredOption("-t, --title <title>", "Decision title").requiredOption("-s, --summary <summary>", "One-sentence summary").option("--type <type>", "Default constraint type (invariant, convention, guideline)", "convention").option("--severity <severity>", "Default constraint severity (critical, high, medium, low)", "medium").option("--scope <scope>", "Default constraint scope (glob pattern)", "src/**/*.ts").option("-o, --owner <owner>", "Owner name", "team").action(async (id, options) => {
+  const cwd = process.cwd();
+  if (!await pathExists(getSpecBridgeDir(cwd))) {
+    throw new NotInitializedError();
+  }
+  if (!/^[a-z0-9-]+$/.test(id)) {
+    console.error(chalk7.red("Error: Decision ID must be lowercase alphanumeric with hyphens only."));
+    process.exit(1);
+  }
+  const decisionsDir = getDecisionsDir(cwd);
+  const filePath = join6(decisionsDir, `${id}.decision.yaml`);
+  if (await pathExists(filePath)) {
+    console.error(chalk7.red(`Error: Decision file already exists: ${filePath}`));
+    process.exit(1);
+  }
+  const decision = {
+    kind: "Decision",
+    metadata: {
+      id,
+      title: options.title,
+      status: "draft",
+      owners: [options.owner || "team"],
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      tags: []
+    },
+    decision: {
+      summary: options.summary,
+      rationale: "TODO: Explain why this decision was made.",
+      context: "TODO: Describe the context and background.",
+      consequences: [
+        "TODO: List positive consequences",
+        "TODO: List negative consequences or trade-offs"
+      ]
+    },
+    constraints: [
+      {
+        id: `${id}-c1`,
+        type: options.type || "convention",
+        rule: "TODO: Describe the constraint rule",
+        severity: options.severity || "medium",
+        scope: options.scope || "src/**/*.ts"
+      }
+    ],
+    verification: {
+      automated: []
+    }
+  };
+  await writeTextFile(filePath, stringifyYaml(decision));
+  console.log(chalk7.green(`\u2713 Created decision: ${filePath}`));
+  console.log("");
+  console.log(chalk7.cyan("Next steps:"));
+  console.log(`  1. Edit the file to add rationale, context, and consequences`);
+  console.log(`  2. Define constraints with appropriate scopes`);
+  console.log(`  3. Run ${chalk7.bold("specbridge decision validate")} to check syntax`);
+  console.log(`  4. Change status from ${chalk7.yellow("draft")} to ${chalk7.green("active")} when ready`);
+});
+
+// src/cli/commands/decision/index.ts
+var decisionCommand = new Command8("decision").description("Manage architectural decisions").addCommand(listDecisions).addCommand(showDecision).addCommand(validateDecisions).addCommand(createDecision);
+
+// src/cli/commands/hook.ts
+import { Command as Command9 } from "commander";
+import chalk8 from "chalk";
+import ora5 from "ora";
+import { join as join7 } from "path";
+var HOOK_SCRIPT = `#!/bin/sh
+# SpecBridge pre-commit hook
+# Runs verification on staged files
+
+# Get list of staged TypeScript files
+STAGED_FILES=$(git diff --cached --name-only --diff-filter=ACM | grep -E '\\.(ts|tsx)$')
+
+if [ -z "$STAGED_FILES" ]; then
+  exit 0
+fi
+
+echo "Running SpecBridge verification..."
+
+# Run specbridge verify on staged files
+npx specbridge hook run --level commit --files "$STAGED_FILES"
+
+exit $?
+`;
+var hookCommand = new Command9("hook").description("Manage Git hooks for verification");
+hookCommand.command("install").description("Install Git pre-commit hook").option("-f, --force", "Overwrite existing hook").option("--husky", "Install for husky").option("--lefthook", "Install for lefthook").action(async (options) => {
+  const cwd = process.cwd();
+  if (!await pathExists(getSpecBridgeDir(cwd))) {
+    throw new NotInitializedError();
+  }
+  const spinner = ora5("Detecting hook system...").start();
+  try {
+    let hookPath;
+    let hookContent;
+    if (options.husky) {
+      hookPath = join7(cwd, ".husky", "pre-commit");
+      hookContent = HOOK_SCRIPT;
+      spinner.text = "Installing husky pre-commit hook...";
+    } else if (options.lefthook) {
+      spinner.succeed("Lefthook detected");
+      console.log("");
+      console.log(chalk8.cyan("Add this to your lefthook.yml:"));
+      console.log("");
+      console.log(chalk8.dim(`pre-commit:
+  commands:
+    specbridge:
+      glob: "*.{ts,tsx}"
+      run: npx specbridge hook run --level commit --files {staged_files}
+`));
+      return;
+    } else {
+      if (await pathExists(join7(cwd, ".husky"))) {
+        hookPath = join7(cwd, ".husky", "pre-commit");
+        hookContent = HOOK_SCRIPT;
+        spinner.text = "Installing husky pre-commit hook...";
+      } else if (await pathExists(join7(cwd, "lefthook.yml"))) {
+        spinner.succeed("Lefthook detected");
+        console.log("");
+        console.log(chalk8.cyan("Add this to your lefthook.yml:"));
+        console.log("");
+        console.log(chalk8.dim(`pre-commit:
+  commands:
+    specbridge:
+      glob: "*.{ts,tsx}"
+      run: npx specbridge hook run --level commit --files {staged_files}
+`));
+        return;
+      } else {
+        hookPath = join7(cwd, ".git", "hooks", "pre-commit");
+        hookContent = HOOK_SCRIPT;
+        spinner.text = "Installing Git pre-commit hook...";
+      }
+    }
+    if (await pathExists(hookPath) && !options.force) {
+      spinner.fail("Hook already exists");
+      console.log(chalk8.yellow(`Use --force to overwrite: ${hookPath}`));
+      return;
+    }
+    await writeTextFile(hookPath, hookContent);
+    const { execSync } = await import("child_process");
+    try {
+      execSync(`chmod +x "${hookPath}"`, { stdio: "ignore" });
+    } catch {
+    }
+    spinner.succeed("Pre-commit hook installed");
+    console.log(chalk8.dim(`  Path: ${hookPath}`));
+    console.log("");
+    console.log(chalk8.cyan("The hook will run on each commit and verify staged files."));
+  } catch (error) {
+    spinner.fail("Failed to install hook");
+    throw error;
+  }
+});
+hookCommand.command("run").description("Run verification (called by hook)").option("-l, --level <level>", "Verification level", "commit").option("-f, --files <files>", "Space or comma-separated file list").action(async (options) => {
+  const cwd = process.cwd();
+  if (!await pathExists(getSpecBridgeDir(cwd))) {
+    throw new NotInitializedError();
+  }
+  try {
+    const config = await loadConfig(cwd);
+    const level = options.level || "commit";
+    const files = options.files ? options.files.split(/[\s,]+/).filter((f) => f.length > 0) : void 0;
+    if (!files || files.length === 0) {
+      process.exit(0);
+    }
+    const engine = createVerificationEngine();
+    const result = await engine.verify(config, {
+      level,
+      files,
+      cwd
+    });
+    if (result.violations.length === 0) {
+      console.log(chalk8.green("\u2713 SpecBridge: All checks passed"));
+      process.exit(0);
+    }
+    console.log(chalk8.red(`\u2717 SpecBridge: ${result.violations.length} violation(s) found`));
+    console.log("");
+    for (const v of result.violations) {
+      const location = v.line ? `:${v.line}` : "";
+      console.log(`  ${v.file}${location}: ${v.message}`);
+      console.log(chalk8.dim(`    [${v.severity}] ${v.decisionId}/${v.constraintId}`));
+    }
+    console.log("");
+    console.log(chalk8.yellow("Run `specbridge verify` for full details."));
+    process.exit(result.success ? 0 : 1);
+  } catch (error) {
+    console.error(chalk8.red("SpecBridge verification failed"));
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+hookCommand.command("uninstall").description("Remove Git pre-commit hook").action(async () => {
+  const cwd = process.cwd();
+  const spinner = ora5("Removing hook...").start();
+  try {
+    const hookPaths = [
+      join7(cwd, ".husky", "pre-commit"),
+      join7(cwd, ".git", "hooks", "pre-commit")
+    ];
+    let removed = false;
+    for (const hookPath of hookPaths) {
+      if (await pathExists(hookPath)) {
+        const content = await readTextFile(hookPath);
+        if (content.includes("SpecBridge")) {
+          const { unlink } = await import("fs/promises");
+          await unlink(hookPath);
+          spinner.succeed(`Removed hook: ${hookPath}`);
+          removed = true;
+        }
+      }
+    }
+    if (!removed) {
+      spinner.info("No SpecBridge hooks found");
+    }
+  } catch (error) {
+    spinner.fail("Failed to remove hook");
+    throw error;
+  }
+});
+
+// src/cli/commands/report.ts
+import { Command as Command10 } from "commander";
+import chalk10 from "chalk";
+import ora6 from "ora";
+import { join as join8 } from "path";
+
+// src/reporting/reporter.ts
+async function generateReport(config, options = {}) {
+  const { includeAll = false, cwd = process.cwd() } = options;
+  const registry = createRegistry({ basePath: cwd });
+  await registry.load();
+  const engine = createVerificationEngine(registry);
+  const result = await engine.verify(config, { level: "full", cwd });
+  const decisions = includeAll ? registry.getAll() : registry.getActive();
+  const byDecision = [];
+  for (const decision of decisions) {
+    const decisionViolations = result.violations.filter(
+      (v) => v.decisionId === decision.metadata.id
+    );
+    const constraintCount = decision.constraints.length;
+    const violationCount = decisionViolations.length;
+    const compliance = violationCount === 0 ? 100 : Math.max(0, 100 - Math.min(violationCount * 10, 100));
+    byDecision.push({
+      decisionId: decision.metadata.id,
+      title: decision.metadata.title,
+      status: decision.metadata.status,
+      constraints: constraintCount,
+      violations: violationCount,
+      compliance
+    });
+  }
+  byDecision.sort((a, b) => a.compliance - b.compliance);
+  const totalDecisions = decisions.length;
+  const activeDecisions = decisions.filter((d) => d.metadata.status === "active").length;
+  const totalConstraints = decisions.reduce((sum, d) => sum + d.constraints.length, 0);
+  const violationsBySeverity = {
+    critical: result.violations.filter((v) => v.severity === "critical").length,
+    high: result.violations.filter((v) => v.severity === "high").length,
+    medium: result.violations.filter((v) => v.severity === "medium").length,
+    low: result.violations.filter((v) => v.severity === "low").length
+  };
+  const overallCompliance = byDecision.length > 0 ? Math.round(byDecision.reduce((sum, d) => sum + d.compliance, 0) / byDecision.length) : 100;
+  return {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    project: config.project.name,
+    summary: {
+      totalDecisions,
+      activeDecisions,
+      totalConstraints,
+      violations: violationsBySeverity,
+      compliance: overallCompliance
+    },
+    byDecision
+  };
+}
+
+// src/reporting/formats/console.ts
+import chalk9 from "chalk";
+import { table as table2 } from "table";
+function formatConsoleReport(report) {
+  const lines = [];
+  lines.push("");
+  lines.push(chalk9.bold.blue("SpecBridge Compliance Report"));
+  lines.push(chalk9.dim(`Generated: ${new Date(report.timestamp).toLocaleString()}`));
+  lines.push(chalk9.dim(`Project: ${report.project}`));
+  lines.push("");
+  const complianceColor = getComplianceColor(report.summary.compliance);
+  lines.push(chalk9.bold("Overall Compliance"));
+  lines.push(`  ${complianceColor(formatComplianceBar(report.summary.compliance))} ${complianceColor(`${report.summary.compliance}%`)}`);
+  lines.push("");
+  lines.push(chalk9.bold("Summary"));
+  lines.push(`  Decisions: ${report.summary.activeDecisions} active / ${report.summary.totalDecisions} total`);
+  lines.push(`  Constraints: ${report.summary.totalConstraints}`);
+  lines.push("");
+  lines.push(chalk9.bold("Violations"));
+  const { violations } = report.summary;
+  const violationParts = [];
+  if (violations.critical > 0) {
+    violationParts.push(chalk9.red(`${violations.critical} critical`));
+  }
+  if (violations.high > 0) {
+    violationParts.push(chalk9.yellow(`${violations.high} high`));
+  }
+  if (violations.medium > 0) {
+    violationParts.push(chalk9.cyan(`${violations.medium} medium`));
+  }
+  if (violations.low > 0) {
+    violationParts.push(chalk9.dim(`${violations.low} low`));
+  }
+  if (violationParts.length > 0) {
+    lines.push(`  ${violationParts.join(" | ")}`);
+  } else {
+    lines.push(chalk9.green("  No violations"));
+  }
+  lines.push("");
+  if (report.byDecision.length > 0) {
+    lines.push(chalk9.bold("By Decision"));
+    lines.push("");
+    const tableData = [
+      [
+        chalk9.bold("Decision"),
+        chalk9.bold("Status"),
+        chalk9.bold("Constraints"),
+        chalk9.bold("Violations"),
+        chalk9.bold("Compliance")
+      ]
+    ];
+    for (const dec of report.byDecision) {
+      const compColor = getComplianceColor(dec.compliance);
+      const statusColor = getStatusColor2(dec.status);
+      tableData.push([
+        truncate2(dec.title, 40),
+        statusColor(dec.status),
+        String(dec.constraints),
+        dec.violations > 0 ? chalk9.red(String(dec.violations)) : chalk9.green("0"),
+        compColor(`${dec.compliance}%`)
+      ]);
+    }
+    const tableOutput = table2(tableData, {
+      border: {
+        topBody: "",
+        topJoin: "",
+        topLeft: "",
+        topRight: "",
+        bottomBody: "",
+        bottomJoin: "",
+        bottomLeft: "",
+        bottomRight: "",
+        bodyLeft: "  ",
+        bodyRight: "",
+        bodyJoin: "  ",
+        joinBody: "",
+        joinLeft: "",
+        joinRight: "",
+        joinJoin: ""
+      },
+      drawHorizontalLine: (index) => index === 1
+    });
+    lines.push(tableOutput);
+  }
+  return lines.join("\n");
+}
+function formatComplianceBar(compliance) {
+  const filled = Math.round(compliance / 10);
+  const empty = 10 - filled;
+  return "\u2588".repeat(filled) + "\u2591".repeat(empty);
+}
+function getComplianceColor(compliance) {
+  if (compliance >= 90) return chalk9.green;
+  if (compliance >= 70) return chalk9.yellow;
+  if (compliance >= 50) return chalk9.hex("#FFA500");
+  return chalk9.red;
+}
+function getStatusColor2(status) {
+  switch (status) {
+    case "active":
+      return chalk9.green;
+    case "draft":
+      return chalk9.yellow;
+    case "deprecated":
+      return chalk9.gray;
+    case "superseded":
+      return chalk9.blue;
+    default:
+      return chalk9.white;
+  }
+}
+function truncate2(str, length) {
+  if (str.length <= length) return str;
+  return str.slice(0, length - 3) + "...";
+}
+
+// src/reporting/formats/markdown.ts
+function formatMarkdownReport(report) {
+  const lines = [];
+  lines.push("# SpecBridge Compliance Report");
+  lines.push("");
+  lines.push(`**Project:** ${report.project}`);
+  lines.push(`**Generated:** ${new Date(report.timestamp).toLocaleString()}`);
+  lines.push("");
+  lines.push("## Overall Compliance");
+  lines.push("");
+  lines.push(`**Score:** ${report.summary.compliance}%`);
+  lines.push("");
+  lines.push(formatProgressBar(report.summary.compliance));
+  lines.push("");
+  lines.push("## Summary");
+  lines.push("");
+  lines.push(`- **Active Decisions:** ${report.summary.activeDecisions} / ${report.summary.totalDecisions}`);
+  lines.push(`- **Total Constraints:** ${report.summary.totalConstraints}`);
+  lines.push("");
+  lines.push("### Violations");
+  lines.push("");
+  const { violations } = report.summary;
+  const totalViolations = violations.critical + violations.high + violations.medium + violations.low;
+  if (totalViolations === 0) {
+    lines.push("No violations found.");
+  } else {
+    lines.push(`| Severity | Count |`);
+    lines.push(`|----------|-------|`);
+    lines.push(`| Critical | ${violations.critical} |`);
+    lines.push(`| High | ${violations.high} |`);
+    lines.push(`| Medium | ${violations.medium} |`);
+    lines.push(`| Low | ${violations.low} |`);
+    lines.push(`| **Total** | **${totalViolations}** |`);
+  }
+  lines.push("");
+  if (report.byDecision.length > 0) {
+    lines.push("## By Decision");
+    lines.push("");
+    lines.push("| Decision | Status | Constraints | Violations | Compliance |");
+    lines.push("|----------|--------|-------------|------------|------------|");
+    for (const dec of report.byDecision) {
+      const complianceEmoji = dec.compliance >= 90 ? "" : dec.compliance >= 70 ? "" : "";
+      lines.push(
+        `| ${dec.title} | ${dec.status} | ${dec.constraints} | ${dec.violations} | ${complianceEmoji} ${dec.compliance}% |`
+      );
+    }
+    lines.push("");
+  }
+  lines.push("---");
+  lines.push("");
+  lines.push("*Generated by [SpecBridge](https://github.com/specbridge/specbridge)*");
+  return lines.join("\n");
+}
+function formatProgressBar(percentage) {
+  const width = 20;
+  const filled = Math.round(percentage / 100 * width);
+  const empty = width - filled;
+  const filledChar = "";
+  const emptyChar = "";
+  return `\`${filledChar.repeat(filled)}${emptyChar.repeat(empty)}\` ${percentage}%`;
+}
+
+// src/cli/commands/report.ts
+var reportCommand = new Command10("report").description("Generate compliance report").option("-f, --format <format>", "Output format (console, json, markdown)", "console").option("-o, --output <file>", "Output file path").option("--save", "Save to .specbridge/reports/").option("-a, --all", "Include all decisions (not just active)").action(async (options) => {
+  const cwd = process.cwd();
+  if (!await pathExists(getSpecBridgeDir(cwd))) {
+    throw new NotInitializedError();
+  }
+  const spinner = ora6("Generating compliance report...").start();
+  try {
+    const config = await loadConfig(cwd);
+    const report = await generateReport(config, {
+      includeAll: options.all,
+      cwd
+    });
+    spinner.succeed("Report generated");
+    let output;
+    let extension;
+    switch (options.format) {
+      case "json":
+        output = JSON.stringify(report, null, 2);
+        extension = "json";
+        break;
+      case "markdown":
+      case "md":
+        output = formatMarkdownReport(report);
+        extension = "md";
+        break;
+      case "console":
+      default:
+        output = formatConsoleReport(report);
+        extension = "txt";
+        break;
+    }
+    if (options.format !== "json" || !options.output) {
+      console.log(output);
+    }
+    if (options.output || options.save) {
+      const outputPath = options.output || join8(
+        getReportsDir(cwd),
+        `health-${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}.${extension}`
+      );
+      await writeTextFile(outputPath, output);
+      console.log(chalk10.green(`
+Report saved to: ${outputPath}`));
+      if (options.save && !options.output) {
+        const latestPath = join8(getReportsDir(cwd), `health-latest.${extension}`);
+        await writeTextFile(latestPath, output);
+      }
+    }
+  } catch (error) {
+    spinner.fail("Failed to generate report");
+    throw error;
+  }
+});
+
+// src/cli/commands/context.ts
+import { Command as Command11 } from "commander";
+import chalk11 from "chalk";
+
+// src/agent/context.generator.ts
+async function generateContext(filePath, config, options = {}) {
+  const { includeRationale = config.agent?.includeRationale ?? true, cwd = process.cwd() } = options;
+  const registry = createRegistry({ basePath: cwd });
+  await registry.load();
+  const decisions = registry.getActive();
+  const applicableDecisions = [];
+  for (const decision of decisions) {
+    const applicableConstraints = [];
+    for (const constraint of decision.constraints) {
+      if (matchesPattern(filePath, constraint.scope)) {
+        applicableConstraints.push({
+          id: constraint.id,
+          type: constraint.type,
+          rule: constraint.rule,
+          severity: constraint.severity
+        });
+      }
+    }
+    if (applicableConstraints.length > 0) {
+      applicableDecisions.push({
+        id: decision.metadata.id,
+        title: decision.metadata.title,
+        summary: includeRationale ? decision.decision.summary : "",
+        constraints: applicableConstraints
+      });
+    }
+  }
+  return {
+    file: filePath,
+    applicableDecisions,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function formatContextAsMarkdown(context) {
+  const lines = [];
+  lines.push("# Architectural Constraints");
+  lines.push("");
+  lines.push(`File: \`${context.file}\``);
+  lines.push("");
+  if (context.applicableDecisions.length === 0) {
+    lines.push("No specific architectural constraints apply to this file.");
+    return lines.join("\n");
+  }
+  lines.push("The following architectural decisions apply to this file:");
+  lines.push("");
+  for (const decision of context.applicableDecisions) {
+    lines.push(`## ${decision.title}`);
+    lines.push("");
+    if (decision.summary) {
+      lines.push(decision.summary);
+      lines.push("");
+    }
+    lines.push("### Constraints");
+    lines.push("");
+    for (const constraint of decision.constraints) {
+      const typeEmoji = constraint.type === "invariant" ? "" : constraint.type === "convention" ? "" : "";
+      const severityBadge = `[${constraint.severity.toUpperCase()}]`;
+      lines.push(`- ${typeEmoji} **${severityBadge}** ${constraint.rule}`);
+    }
+    lines.push("");
+  }
+  lines.push("---");
+  lines.push("");
+  lines.push("Please ensure your code complies with these constraints.");
+  return lines.join("\n");
+}
+function formatContextAsJson(context) {
+  return JSON.stringify(context, null, 2);
+}
+function formatContextAsMcp(context) {
+  return {
+    type: "architectural_context",
+    version: "1.0",
+    file: context.file,
+    timestamp: context.generatedAt,
+    decisions: context.applicableDecisions.map((d) => ({
+      id: d.id,
+      title: d.title,
+      summary: d.summary,
+      constraints: d.constraints.map((c) => ({
+        id: c.id,
+        type: c.type,
+        severity: c.severity,
+        rule: c.rule
+      }))
+    }))
+  };
+}
+async function generateFormattedContext(filePath, config, options = {}) {
+  const context = await generateContext(filePath, config, options);
+  const format = options.format || config.agent?.format || "markdown";
+  switch (format) {
+    case "json":
+      return formatContextAsJson(context);
+    case "mcp":
+      return JSON.stringify(formatContextAsMcp(context), null, 2);
+    case "markdown":
+    default:
+      return formatContextAsMarkdown(context);
+  }
+}
+
+// src/cli/commands/context.ts
+var contextCommand = new Command11("context").description("Generate architectural context for a file (for AI agents)").argument("<file>", "File path to generate context for").option("-f, --format <format>", "Output format (markdown, json, mcp)", "markdown").option("-o, --output <file>", "Output file path").option("--no-rationale", "Exclude rationale/summary from output").action(async (file, options) => {
+  const cwd = process.cwd();
+  if (!await pathExists(getSpecBridgeDir(cwd))) {
+    throw new NotInitializedError();
+  }
+  try {
+    const config = await loadConfig(cwd);
+    const output = await generateFormattedContext(file, config, {
+      format: options.format,
+      includeRationale: options.noRationale !== true,
+      cwd
+    });
+    if (options.output) {
+      await writeTextFile(options.output, output);
+      console.log(chalk11.green(`Context saved to: ${options.output}`));
+    } else {
+      console.log(output);
+    }
+  } catch (error) {
+    console.error(chalk11.red("Failed to generate context"));
+    throw error;
+  }
+});
+
+// src/cli/index.ts
+var program = new Command12();
+program.name("specbridge").description("Architecture Decision Runtime - Transform architectural decisions into executable, verifiable constraints").version("0.1.0");
+program.addCommand(initCommand);
+program.addCommand(inferCommand);
+program.addCommand(verifyCommand);
+program.addCommand(decisionCommand);
+program.addCommand(hookCommand);
+program.addCommand(reportCommand);
+program.addCommand(contextCommand);
+program.exitOverride((err) => {
+  if (err.code === "commander.help" || err.code === "commander.helpDisplayed") {
+    process.exit(0);
+  }
+  if (err.code === "commander.version") {
+    process.exit(0);
+  }
+  console.error(chalk12.red(formatError(err)));
+  process.exit(1);
+});
+program.parseAsync(process.argv).catch((error) => {
+  console.error(chalk12.red(formatError(error)));
+  process.exit(1);
+});
+//# sourceMappingURL=cli.js.map