viberails 0.3.3 → 0.5.0

package/dist/index.js

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import chalk10 from "chalk";
+import chalk12 from "chalk";
 import { Command } from "commander";
 
 // src/commands/boundaries.ts
 import * as fs3 from "fs";
 import * as path3 from "path";
-import { loadConfig } from "@viberails/config";
+import { compactConfig, loadConfig } from "@viberails/config";
 import chalk from "chalk";
 
 // src/utils/find-project-root.ts
@@ -28,118 +28,485 @@ function findProjectRoot(startDir) {
 }
 
 // src/utils/prompt.ts
+import * as clack5 from "@clack/prompts";
+
+// src/utils/prompt-integrations.ts
 import * as clack from "@clack/prompts";
-function assertNotCancelled(value) {
-  if (clack.isCancel(value)) {
-    clack.cancel("Setup cancelled.");
-    process.exit(0);
+async function promptIntegrations(hookManager, tools) {
+  const hookLabel = hookManager ? `Pre-commit hook (${hookManager})` : "Pre-commit hook (git hook)";
+  const options = [
+    {
+      value: "preCommit",
+      label: hookLabel,
+      hint: "runs viberails checks when you commit"
+    }
+  ];
+  if (tools?.isTypeScript) {
+    options.push({
+      value: "typecheck",
+      label: "Typecheck (tsc --noEmit)",
+      hint: "catches type errors before commit"
+    });
   }
-}
-async function confirm2(message) {
-  const result = await clack.confirm({ message, initialValue: true });
+  if (tools?.linter) {
+    const linterName = tools.linter === "biome" ? "Biome" : "ESLint";
+    options.push({
+      value: "lint",
+      label: `Lint check (${linterName})`,
+      hint: "runs linter on staged files before commit"
+    });
+  }
+  options.push(
+    {
+      value: "claude",
+      label: "Claude Code hook",
+      hint: "checks files when Claude edits them"
+    },
+    {
+      value: "claudeMd",
+      label: "CLAUDE.md reference",
+      hint: "appends @.viberails/context.md so Claude loads rules automatically"
+    },
+    {
+      value: "githubAction",
+      label: "GitHub Actions workflow",
+      hint: "blocks PRs that fail viberails check"
+    }
+  );
+  const initialValues = options.map((o) => o.value);
+  const result = await clack.multiselect({
+    message: "Set up integrations?",
+    options,
+    initialValues,
+    required: false
+  });
   assertNotCancelled(result);
-  return result;
+  return {
+    preCommitHook: result.includes("preCommit"),
+    claudeCodeHook: result.includes("claude"),
+    claudeMdRef: result.includes("claudeMd"),
+    githubAction: result.includes("githubAction"),
+    typecheckHook: result.includes("typecheck"),
+    lintHook: result.includes("lint")
+  };
 }
-async function confirmDangerous(message) {
-  const result = await clack.confirm({ message, initialValue: false });
-  assertNotCancelled(result);
-  return result;
+
+// src/utils/prompt-rules.ts
+import * as clack4 from "@clack/prompts";
+
+// src/utils/prompt-menu-handlers.ts
+import * as clack3 from "@clack/prompts";
+
+// src/utils/prompt-package-overrides.ts
+import * as clack2 from "@clack/prompts";
+function normalizePackageOverrides(packages) {
+  for (const pkg of packages) {
+    if (pkg.rules && Object.keys(pkg.rules).length === 0) {
+      delete pkg.rules;
+    }
+    if (pkg.coverage && Object.keys(pkg.coverage).length === 0) {
+      delete pkg.coverage;
+    }
+  }
+  return packages;
 }
-async function promptInitDecision() {
-  const result = await clack.select({
-    message: "Accept these settings?",
-    options: [
-      { value: "accept", label: "Yes, looks good", hint: "recommended" },
-      { value: "customize", label: "Let me customize" }
-    ]
-  });
-  assertNotCancelled(result);
-  return result;
+function packageCoverageHint(pkg, defaults) {
+  const coverage = pkg.rules?.testCoverage ?? defaults.testCoverage;
+  const isExempt = coverage === 0;
+  const hasSummaryOverride = pkg.coverage?.summaryPath !== void 0 && pkg.coverage.summaryPath !== defaults.coverageSummaryPath;
+  const defaultCommand = defaults.coverageCommand ?? "";
+  const hasCommandOverride = pkg.coverage?.command !== void 0 && pkg.coverage.command !== defaultCommand;
+  const tags = [];
+  const nameSegments = pkg.name.replace(/^@[^/]+\//, "").split(/[-/]/);
+  const isTypesOnly = isExempt && nameSegments.some((s) => s === "types");
+  tags.push(isExempt ? isTypesOnly ? "exempt (types-only)" : "exempt" : `${coverage}%`);
+  if (hasSummaryOverride) tags.push("summary override");
+  if (hasCommandOverride) tags.push("command override");
+  return tags.join(", ");
+}
+async function promptPackageCoverageOverrides(packages, defaults) {
+  const editablePackages = packages.filter((pkg) => pkg.path !== ".");
+  if (editablePackages.length === 0) return packages;
+  while (true) {
+    const selectedPath = await clack2.select({
+      message: "Select package to edit coverage overrides",
+      options: [
+        ...editablePackages.map((pkg) => ({
+          value: pkg.path,
+          label: `${pkg.path} (${pkg.name})`,
+          hint: packageCoverageHint(pkg, defaults)
+        })),
+        { value: "__done__", label: "Done" }
+      ]
+    });
+    assertNotCancelled(selectedPath);
+    if (selectedPath === "__done__") break;
+    const target = editablePackages.find((pkg) => pkg.path === selectedPath);
+    if (!target) continue;
+    while (true) {
+      const effectiveCoverage = target.rules?.testCoverage ?? defaults.testCoverage;
+      const effectiveSummary = target.coverage?.summaryPath ?? defaults.coverageSummaryPath;
+      const effectiveCommand = target.coverage?.command ?? defaults.coverageCommand ?? "(auto-detect)";
+      const choice = await clack2.select({
+        message: `Edit coverage overrides for ${target.path}`,
+        options: [
+          { value: "testCoverage", label: "testCoverage", hint: String(effectiveCoverage) },
+          { value: "summaryPath", label: "coverage.summaryPath", hint: effectiveSummary },
+          { value: "command", label: "coverage.command", hint: effectiveCommand },
+          { value: "reset", label: "Reset this package to inherit defaults" },
+          { value: "back", label: "Back to package list" }
+        ]
+      });
+      assertNotCancelled(choice);
+      if (choice === "back") break;
+      if (choice === "testCoverage") {
+        const result = await clack2.text({
+          message: "Package testCoverage (0 to exempt package)?",
+          initialValue: String(effectiveCoverage),
+          validate: (v) => {
+            if (typeof v !== "string") return "Enter a number between 0 and 100";
+            const n = Number.parseInt(v, 10);
+            if (Number.isNaN(n) || n < 0 || n > 100) return "Enter a number between 0 and 100";
+          }
+        });
+        assertNotCancelled(result);
+        const nextCoverage = Number.parseInt(result, 10);
+        if (nextCoverage === defaults.testCoverage) {
+          if (target.rules) {
+            delete target.rules.testCoverage;
+          }
+        } else {
+          target.rules = { ...target.rules ?? {}, testCoverage: nextCoverage };
+        }
+      }
+      if (choice === "summaryPath") {
+        const result = await clack2.text({
+          message: "Package coverage.summaryPath (blank to inherit default)?",
+          initialValue: target.coverage?.summaryPath !== void 0 ? target.coverage.summaryPath : "",
+          placeholder: defaults.coverageSummaryPath
+        });
+        assertNotCancelled(result);
+        const value = result.trim();
+        if (value.length === 0 || value === defaults.coverageSummaryPath) {
+          if (target.coverage) {
+            delete target.coverage.summaryPath;
+          }
+        } else {
+          target.coverage = { ...target.coverage ?? {}, summaryPath: value };
+        }
+      }
+      if (choice === "command") {
+        const result = await clack2.text({
+          message: "Package coverage.command (blank to inherit default/auto)?",
+          initialValue: target.coverage?.command !== void 0 ? target.coverage.command : "",
+          placeholder: defaults.coverageCommand ?? "(auto-detect from package.json test runner)"
+        });
+        assertNotCancelled(result);
+        const value = result.trim();
+        const defaultCommand = defaults.coverageCommand ?? "";
+        if (value.length === 0 || value === defaultCommand) {
+          if (target.coverage) {
+            delete target.coverage.command;
+          }
+        } else {
+          target.coverage = { ...target.coverage ?? {}, command: value };
+        }
+      }
+      if (choice === "reset") {
+        if (target.rules) {
+          delete target.rules.testCoverage;
+        }
+        delete target.coverage;
+      }
+      normalizePackageOverrides(editablePackages);
+    }
+  }
+  return normalizePackageOverrides(packages);
 }
-async function promptRuleCustomization(defaults) {
-  const maxFileLinesResult = await clack.text({
-    message: "Maximum lines per source file?",
-    placeholder: String(defaults.maxFileLines),
-    initialValue: String(defaults.maxFileLines),
-    validate: (v) => {
-      const n = Number.parseInt(v, 10);
-      if (Number.isNaN(n) || n < 1) return "Enter a positive number";
+
+// src/utils/prompt-menu-handlers.ts
+function getPackageDiffs(pkg, root) {
+  const diffs = [];
+  const convKeys = ["fileNaming", "componentNaming", "hookNaming", "importAlias"];
+  for (const key of convKeys) {
+    if (pkg.conventions?.[key] && pkg.conventions[key] !== root.conventions?.[key]) {
+      diffs.push(`${key}: ${pkg.conventions[key]}`);
     }
+  }
+  const stackKeys = [
+    "framework",
+    "language",
+    "styling",
+    "backend",
+    "orm",
+    "linter",
+    "formatter",
+    "testRunner",
+    "packageManager"
+  ];
+  for (const key of stackKeys) {
+    if (pkg.stack?.[key] && pkg.stack[key] !== root.stack?.[key]) {
+      diffs.push(`${key}: ${pkg.stack[key]}`);
+    }
+  }
+  if (pkg.rules?.maxFileLines !== void 0 && pkg.rules.maxFileLines !== root.rules?.maxFileLines && pkg.rules.maxFileLines > 0) {
+    diffs.push(`maxFileLines: ${pkg.rules.maxFileLines}`);
+  }
+  if (pkg.rules?.testCoverage !== void 0 && pkg.rules.testCoverage !== root.rules?.testCoverage && pkg.rules.testCoverage >= 0) {
+    diffs.push(`testCoverage: ${pkg.rules.testCoverage}`);
+  }
+  if (pkg.coverage?.summaryPath && pkg.coverage.summaryPath !== root.coverage?.summaryPath) {
+    diffs.push(`coverage.summaryPath: ${pkg.coverage.summaryPath}`);
+  }
+  if (pkg.coverage?.command && pkg.coverage.command !== root.coverage?.command) {
+    diffs.push("coverage.command: (override)");
+  }
+  return diffs;
+}
+function buildMenuOptions(state, packageCount) {
+  const namingHint = state.enforceNaming ? `yes${state.fileNamingValue ? ` (${state.fileNamingValue})` : ""}` : "no";
+  const options = [
+    { value: "maxFileLines", label: "Max file lines", hint: String(state.maxFileLines) },
+    { value: "enforceNaming", label: "Enforce file naming", hint: namingHint }
+  ];
+  if (state.fileNamingValue) {
+    options.push({
+      value: "fileNaming",
+      label: "File naming convention",
+      hint: state.fileNamingValue
+    });
+  }
+  options.push({
+    value: "testCoverage",
+    label: "Test coverage target",
+    hint: state.testCoverage === 0 ? "0 (disabled)" : `${state.testCoverage}%`
   });
-  assertNotCancelled(maxFileLinesResult);
-  const requireTestsResult = await clack.confirm({
-    message: "Require matching test files for source files?",
-    initialValue: defaults.requireTests
-  });
-  assertNotCancelled(requireTestsResult);
-  const namingLabel = defaults.fileNamingValue ? `Enforce file naming? (detected: ${defaults.fileNamingValue})` : "Enforce file naming?";
-  const enforceNamingResult = await clack.confirm({
-    message: namingLabel,
-    initialValue: defaults.enforceNaming
+  options.push({
+    value: "enforceMissingTests",
+    label: "Enforce missing tests",
+    hint: state.enforceMissingTests ? "yes" : "no"
   });
-  assertNotCancelled(enforceNamingResult);
-  const enforcementResult = await clack.select({
-    message: "Enforcement mode",
-    options: [
+  if (state.testCoverage > 0) {
+    options.push(
       {
-        value: "warn",
-        label: "warn",
-        hint: "show violations but don't block commits (recommended)"
+        value: "coverageSummaryPath",
+        label: "Coverage summary path",
+        hint: state.coverageSummaryPath
       },
       {
-        value: "enforce",
-        label: "enforce",
-        hint: "block commits with violations"
+        value: "coverageCommand",
+        label: "Coverage command",
+        hint: state.coverageCommand ?? "auto-detect from package.json test runner"
       }
-    ],
-    initialValue: defaults.enforcement
-  });
-  assertNotCancelled(enforcementResult);
+    );
+    if (packageCount > 0) {
+      options.push({
+        value: "packageOverrides",
+        label: "Per-package coverage overrides",
+        hint: `${packageCount} package${packageCount > 1 ? "s" : ""} configurable`
+      });
+    }
+  }
+  options.push(
+    { value: "reset", label: "Reset all to detected defaults" },
+    { value: "done", label: "Done" }
+  );
+  return options;
+}
+function clonePackages(packages) {
+  return packages?.map((pkg) => ({
+    ...pkg,
+    stack: pkg.stack ? { ...pkg.stack } : void 0,
+    structure: pkg.structure ? { ...pkg.structure } : void 0,
+    conventions: pkg.conventions ? { ...pkg.conventions } : void 0,
+    rules: pkg.rules ? { ...pkg.rules } : void 0,
+    coverage: pkg.coverage ? { ...pkg.coverage } : void 0,
+    ignore: pkg.ignore ? [...pkg.ignore] : void 0,
+    boundaries: pkg.boundaries ? {
+      deny: [...pkg.boundaries.deny],
+      ignore: pkg.boundaries.ignore ? [...pkg.boundaries.ignore] : void 0
+    } : void 0
+  }));
+}
+async function handleMenuChoice(choice, state, defaults, root) {
+  if (choice === "reset") {
+    state.maxFileLines = defaults.maxFileLines;
+    state.testCoverage = defaults.testCoverage;
+    state.enforceMissingTests = defaults.enforceMissingTests;
+    state.enforceNaming = defaults.enforceNaming;
+    state.fileNamingValue = defaults.fileNamingValue;
+    state.coverageSummaryPath = defaults.coverageSummaryPath;
+    state.coverageCommand = defaults.coverageCommand;
+    state.packageOverrides = clonePackages(defaults.packageOverrides);
+    clack3.log.info("Reset all rules to detected defaults.");
+    return;
+  }
+  if (choice === "packageOverrides") {
+    if (state.packageOverrides) {
+      const packageDiffs = root ? state.packageOverrides.filter((pkg) => pkg.path !== root.path).map((pkg) => ({ pkg, diffs: getPackageDiffs(pkg, root) })).filter((entry) => entry.diffs.length > 0) : [];
+      state.packageOverrides = await promptPackageCoverageOverrides(state.packageOverrides, {
+        testCoverage: state.testCoverage,
+        coverageSummaryPath: state.coverageSummaryPath,
+        coverageCommand: state.coverageCommand
+      });
+      const lines = packageDiffs.map((entry) => `${entry.pkg.path}
+  ${entry.diffs.join(", ")}`);
+      if (lines.length > 0) {
+        clack3.note(lines.join("\n\n"), "Existing package differences");
+      }
+    }
+    return;
+  }
+  if (choice === "maxFileLines") {
+    const result = await clack3.text({
+      message: "Maximum lines per source file?",
+      initialValue: String(state.maxFileLines),
+      validate: (v) => {
+        if (typeof v !== "string") return "Enter a positive number";
+        const n = Number.parseInt(v, 10);
+        if (Number.isNaN(n) || n < 1) return "Enter a positive number";
+      }
+    });
+    assertNotCancelled(result);
+    state.maxFileLines = Number.parseInt(result, 10);
+  }
+  if (choice === "enforceMissingTests") {
+    const result = await clack3.confirm({
+      message: "Require every source file to have a corresponding test file?",
+      initialValue: state.enforceMissingTests
+    });
+    assertNotCancelled(result);
+    state.enforceMissingTests = result;
+  }
+  if (choice === "testCoverage") {
+    const result = await clack3.text({
+      message: "Test coverage target (0 disables coverage checks)?",
+      initialValue: String(state.testCoverage),
+      validate: (v) => {
+        if (typeof v !== "string") return "Enter a number between 0 and 100";
+        const n = Number.parseInt(v, 10);
+        if (Number.isNaN(n) || n < 0 || n > 100) return "Enter a number between 0 and 100";
+      }
+    });
+    assertNotCancelled(result);
+    state.testCoverage = Number.parseInt(result, 10);
+  }
+  if (choice === "coverageSummaryPath") {
+    const result = await clack3.text({
+      message: "Coverage summary path (relative to package root)?",
+      initialValue: state.coverageSummaryPath,
+      validate: (v) => {
+        if (typeof v !== "string" || v.trim().length === 0) return "Path cannot be empty";
+      }
+    });
+    assertNotCancelled(result);
+    state.coverageSummaryPath = result.trim();
+  }
+  if (choice === "coverageCommand") {
+    const result = await clack3.text({
+      message: "Coverage command (blank to auto-detect from package.json)?",
+      initialValue: state.coverageCommand ?? "",
+      placeholder: "(auto-detect from package.json test runner)"
+    });
+    assertNotCancelled(result);
+    const trimmed = result.trim();
+    state.coverageCommand = trimmed.length > 0 ? trimmed : void 0;
+  }
+  if (choice === "enforceNaming") {
+    const result = await clack3.confirm({
+      message: state.fileNamingValue ? `Enforce file naming? (detected: ${state.fileNamingValue})` : "Enforce file naming?",
+      initialValue: state.enforceNaming
+    });
+    assertNotCancelled(result);
+    state.enforceNaming = result;
+  }
+  if (choice === "fileNaming") {
+    const selected = await clack3.select({
+      message: "Which file naming convention should be enforced?",
+      options: [
+        { value: "kebab-case", label: "kebab-case" },
+        { value: "camelCase", label: "camelCase" },
+        { value: "PascalCase", label: "PascalCase" },
+        { value: "snake_case", label: "snake_case" }
+      ],
+      initialValue: state.fileNamingValue
+    });
+    assertNotCancelled(selected);
+    state.fileNamingValue = selected;
+  }
+}
+
+// src/utils/prompt-rules.ts
+function getRootPackage(packages) {
+  return packages.find((pkg) => pkg.path === ".") ?? packages[0];
+}
+async function promptRuleMenu(defaults) {
+  const state = {
+    ...defaults,
+    packageOverrides: clonePackages(defaults.packageOverrides)
+  };
+  const root = state.packageOverrides && state.packageOverrides.length > 0 ? getRootPackage(state.packageOverrides) : void 0;
+  const packageCount = state.packageOverrides?.filter((pkg) => pkg.path !== ".").length ?? 0;
+  while (true) {
+    const options = buildMenuOptions(state, packageCount);
+    const choice = await clack4.select({ message: "Customize rules", options });
+    assertNotCancelled(choice);
+    if (choice === "done") break;
+    await handleMenuChoice(choice, state, defaults, root);
+  }
   return {
-    maxFileLines: Number.parseInt(maxFileLinesResult, 10),
-    requireTests: requireTestsResult,
-    enforceNaming: enforceNamingResult,
-    enforcement: enforcementResult
+    maxFileLines: state.maxFileLines,
+    testCoverage: state.testCoverage,
+    enforceMissingTests: state.enforceMissingTests,
+    enforceNaming: state.enforceNaming,
+    fileNamingValue: state.fileNamingValue,
+    coverageSummaryPath: state.coverageSummaryPath,
+    coverageCommand: state.coverageCommand,
+    packageOverrides: state.packageOverrides
   };
 }
-async function promptIntegrations(hookManager) {
-  const hookLabel = hookManager ? `Pre-commit hook (${hookManager})` : "Pre-commit hook (git hook)";
-  const result = await clack.multiselect({
-    message: "Set up integrations?",
+
+// src/utils/prompt.ts
+function assertNotCancelled(value) {
+  if (clack5.isCancel(value)) {
+    clack5.cancel("Setup cancelled.");
+    process.exit(0);
+  }
+}
+async function confirm3(message) {
+  const result = await clack5.confirm({ message, initialValue: true });
+  assertNotCancelled(result);
+  return result;
+}
+async function confirmDangerous(message) {
+  const result = await clack5.confirm({ message, initialValue: false });
+  assertNotCancelled(result);
+  return result;
+}
+async function promptInitDecision() {
+  const result = await clack5.select({
+    message: "Accept these rules?",
     options: [
       {
-        value: "preCommit",
-        label: hookLabel,
-        hint: "runs checks when you commit"
-      },
-      {
-        value: "claude",
-        label: "Claude Code hook",
-        hint: "checks files when Claude edits them"
+        value: "accept",
+        label: "Yes, looks good",
+        hint: "warns on violation; use --enforce in CI to block"
       },
-      {
-        value: "claudeMd",
-        label: "CLAUDE.md reference",
-        hint: "appends @.viberails/context.md so Claude loads rules automatically"
-      }
-    ],
-    initialValues: ["preCommit", "claude", "claudeMd"],
-    required: false
+      { value: "customize", label: "Let me customize rules" }
+    ]
   });
   assertNotCancelled(result);
-  return {
-    preCommitHook: result.includes("preCommit"),
-    claudeCodeHook: result.includes("claude"),
-    claudeMdRef: result.includes("claudeMd")
-  };
+  return result;
 }
 
 // src/utils/resolve-workspace-packages.ts
 import * as fs2 from "fs";
 import * as path2 from "path";
-function resolveWorkspacePackages(projectRoot, workspace) {
-  const packages = [];
-  for (const relativePath of workspace.packages) {
+function resolveWorkspacePackages(projectRoot, packages) {
+  const resolved = [];
+  for (const pkgConfig of packages) {
+    if (pkgConfig.path === ".") continue;
+    const relativePath = pkgConfig.path;
     const absPath = path2.join(projectRoot, relativePath);
     const pkgJsonPath = path2.join(absPath, "package.json");
     if (!fs2.existsSync(pkgJsonPath)) continue;
@@ -155,13 +522,13 @@ function resolveWorkspacePackages(projectRoot, workspace) {
       ...Object.keys(pkg.dependencies ?? {}),
       ...Object.keys(pkg.devDependencies ?? {})
     ];
-    packages.push({ name, path: absPath, relativePath, internalDeps: allDeps });
+    resolved.push({ name, path: absPath, relativePath, internalDeps: allDeps });
   }
-  const packageNames = new Set(packages.map((p) => p.name));
-  for (const pkg of packages) {
+  const packageNames = new Set(resolved.map((p) => p.name));
+  for (const pkg of resolved) {
     pkg.internalDeps = pkg.internalDeps.filter((dep) => packageNames.has(dep));
   }
-  return packages;
+  return resolved;
 }
 
 // src/commands/boundaries.ts
@@ -212,7 +579,7 @@ Enforcement: ${config.rules.enforceBoundaries ? chalk.green("on") : chalk.yellow
 async function inferAndDisplay(projectRoot, config, configPath) {
   console.log(chalk.dim("Analyzing imports..."));
   const { buildImportGraph, inferBoundaries } = await import("@viberails/graph");
-  const packages = config.workspace ? resolveWorkspacePackages(projectRoot, config.workspace) : void 0;
+  const packages = config.packages.length > 1 ? resolveWorkspacePackages(projectRoot, config.packages) : void 0;
   const graph = await buildImportGraph(projectRoot, {
     packages,
     ignore: config.ignore
@@ -236,11 +603,11 @@ ${chalk.bold("Inferred boundary rules:")}
   console.log(`
   ${totalRules} denied`);
   console.log("");
-  const shouldSave = await confirm2("Save to viberails.config.json?");
+  const shouldSave = await confirm3("Save to viberails.config.json?");
   if (shouldSave) {
     config.boundaries = inferred;
     config.rules.enforceBoundaries = true;
-    fs3.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}
+    fs3.writeFileSync(configPath, `${JSON.stringify(compactConfig(config), null, 2)}
 `);
     console.log(`${chalk.green("\u2713")} Saved ${totalRules} rules`);
   }
@@ -248,7 +615,7 @@ ${chalk.bold("Inferred boundary rules:")}
 async function showGraph(projectRoot, config) {
   console.log(chalk.dim("Building import graph..."));
   const { buildImportGraph } = await import("@viberails/graph");
-  const packages = config.workspace ? resolveWorkspacePackages(projectRoot, config.workspace) : void 0;
+  const packages = config.packages.length > 1 ? resolveWorkspacePackages(projectRoot, config.packages) : void 0;
   const graph = await buildImportGraph(projectRoot, {
     packages,
     ignore: config.ignore
@@ -276,42 +643,191 @@ ${chalk.yellow("Cycles detected:")}`);
 }
 
 // src/commands/check.ts
-import * as fs6 from "fs";
-import * as path6 from "path";
+import * as fs7 from "fs";
+import * as path7 from "path";
 import { loadConfig as loadConfig2 } from "@viberails/config";
 import chalk2 from "chalk";
 
 // src/commands/check-config.ts
+import { BUILTIN_IGNORE } from "@viberails/config";
 function resolveConfigForFile(relPath, config) {
-  if (!config.packages || config.packages.length === 0) {
-    return { rules: config.rules, conventions: config.conventions };
-  }
   const sortedPackages = [...config.packages].sort((a, b) => b.path.length - a.path.length);
   for (const pkg of sortedPackages) {
+    if (pkg.path === ".") continue;
     if (relPath.startsWith(`${pkg.path}/`) || relPath === pkg.path) {
       return {
         rules: { ...config.rules, ...pkg.rules },
-        conventions: { ...config.conventions, ...pkg.conventions }
+        conventions: pkg.conventions ?? {},
+        coverage: {
+          ...config.defaults?.coverage ?? {},
+          ...pkg.coverage ?? {}
+        }
       };
     }
   }
-  return { rules: config.rules, conventions: config.conventions };
+  const root = config.packages.find((p) => p.path === ".") ?? config.packages[0];
+  return {
+    rules: { ...config.rules, ...root.rules },
+    conventions: root.conventions ?? {},
+    coverage: {
+      ...config.defaults?.coverage ?? {},
+      ...root.coverage ?? {}
+    }
+  };
+}
+function getEffectiveIgnore(config) {
+  return [...BUILTIN_IGNORE, ...config.ignore ?? []];
 }
 function resolveIgnoreForFile(relPath, config) {
-  const globalIgnore = config.ignore;
-  if (!config.packages) return globalIgnore;
-  for (const pkg of config.packages) {
-    if (pkg.ignore && relPath.startsWith(`${pkg.path}/`)) {
-      return [...globalIgnore, ...pkg.ignore];
+  const base = getEffectiveIgnore(config);
+  const root = config.packages.find((p) => p.path === ".");
+  const withRoot = root?.ignore ? [...base, ...root.ignore] : base;
+  const matched = [...config.packages].filter((p) => p.path !== ".").sort((a, b) => b.path.length - a.path.length).find((p) => relPath.startsWith(`${p.path}/`) || relPath === p.path);
+  if (matched?.ignore) {
+    return [...withRoot, ...matched.ignore];
+  }
+  return withRoot;
+}
+
+// src/commands/check-coverage.ts
+import { spawnSync } from "child_process";
+import * as fs4 from "fs";
+import * as path4 from "path";
+var DEFAULT_SUMMARY_PATH = "coverage/coverage-summary.json";
+function packageRoot(projectRoot, pkg) {
+  return pkg.path === "." ? projectRoot : path4.join(projectRoot, pkg.path);
+}
+function resolveForPackage(config, pkg) {
+  return {
+    pkg,
+    rules: { ...config.rules, ...pkg.rules },
+    coverage: {
+      ...config.defaults?.coverage ?? {},
+      ...pkg.coverage ?? {}
+    }
+  };
+}
+function resolveCoveragePackages(projectRoot, config, filesToCheck, staged) {
+  if (!staged) {
+    return config.packages.map((pkg) => resolveForPackage(config, pkg));
+  }
+  const matched = /* @__PURE__ */ new Map();
+  for (const raw of filesToCheck) {
+    const relPath = path4.isAbsolute(raw) ? path4.relative(projectRoot, raw) : raw;
+    const sorted = [...config.packages].filter((pkg2) => pkg2.path !== ".").sort((a, b) => b.path.length - a.path.length);
+    const pkg = sorted.find(
+      (candidate) => relPath.startsWith(`${candidate.path}/`) || relPath === candidate.path
+    ) ?? config.packages.find((candidate) => candidate.path === ".") ?? config.packages[0];
+    matched.set(pkg.path, resolveForPackage(config, pkg));
+  }
+  return [...matched.values()];
+}
+function readCoveragePercentage(summaryPath) {
+  try {
+    const parsed = JSON.parse(fs4.readFileSync(summaryPath, "utf-8"));
+    const pct = parsed.total?.lines?.pct;
+    return typeof pct === "number" ? pct : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function runCoverageCommand(pkgRoot, command) {
+  const result = spawnSync(command, {
+    cwd: pkgRoot,
+    shell: true,
+    encoding: "utf-8",
+    stdio: "pipe"
+  });
+  if (result.status === 0) return { ok: true };
+  const stderr = result.stderr?.trim() ?? "";
+  const stdout = result.stdout?.trim() ?? "";
+  const raw = stderr || stdout || `exit code ${result.status ?? 1}`;
+  if (raw.includes("coverage-v8") || raw.includes("coverage-istanbul") || raw.includes("MISSING DEP")) {
+    return {
+      ok: false,
+      detail: "Missing coverage provider. Install with: npm install -D @vitest/coverage-v8"
+    };
+  }
+  const detail = raw.replace(/\x1B\[[0-9;]*m/g, "");
+  return { ok: false, detail };
+}
+function violationFilePath(projectRoot, pkgRoot, summaryPath) {
+  return path4.relative(projectRoot, path4.join(pkgRoot, summaryPath));
+}
+function pushViolation(violations, file, message, severity) {
+  violations.push({
+    file,
+    rule: "test-coverage",
+    message,
+    severity
+  });
+}
+function checkCoverage(projectRoot, config, filesToCheck, options) {
+  const severity = options.enforce ? "error" : "warn";
+  const targets = resolveCoveragePackages(
+    projectRoot,
+    config,
+    filesToCheck,
+    options.staged === true
+  );
+  const violations = [];
+  for (const target of targets) {
+    if (target.rules.testCoverage <= 0) continue;
+    const pkgRoot = packageRoot(projectRoot, target.pkg);
+    const summaryPath = target.coverage.summaryPath ?? DEFAULT_SUMMARY_PATH;
+    const summaryAbs = path4.join(pkgRoot, summaryPath);
+    const summaryRel = violationFilePath(projectRoot, pkgRoot, summaryPath);
+    let pct = readCoveragePercentage(summaryAbs);
+    if (pct === void 0 && !options.staged) {
+      const command = target.coverage.command;
+      if (!command) {
+        const pkgLabel = target.pkg.path === "." ? "root package" : target.pkg.path;
+        pushViolation(
+          violations,
+          summaryRel,
+          `No coverage summary found for "${pkgLabel}". Run your test suite with coverage enabled, or set defaults.coverage.command in viberails.config.json.`,
+          severity
+        );
+        continue;
+      }
+      const run = runCoverageCommand(pkgRoot, command);
+      if (!run.ok) {
+        pushViolation(
+          violations,
+          summaryRel,
+          `Failed to run coverage command: ${run.detail}.`,
+          severity
+        );
+        continue;
+      }
+      pct = readCoveragePercentage(summaryAbs);
+    }
+    if (pct === void 0) {
+      pushViolation(
+        violations,
+        summaryRel,
+        `Coverage summary not found or invalid at \`${summaryPath}\`.`,
+        severity
+      );
+      continue;
+    }
+    if (pct < target.rules.testCoverage) {
+      pushViolation(
+        violations,
+        summaryRel,
+        `Line coverage ${pct.toFixed(1)}% is below required ${target.rules.testCoverage}%.`,
+        severity
+      );
     }
   }
-  return globalIgnore;
+  return violations;
 }
 
 // src/commands/check-files.ts
 import { execSync } from "child_process";
-import * as fs4 from "fs";
-import * as path4 from "path";
+import * as fs5 from "fs";
+import * as path5 from "path";
+import { BUILTIN_IGNORE as BUILTIN_IGNORE2 } from "@viberails/config";
 import picomatch from "picomatch";
 var ALWAYS_SKIP_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
@@ -354,7 +870,7 @@ function isIgnored(relPath, ignorePatterns) {
 }
 function countFileLines(filePath) {
   try {
-    const content = fs4.readFileSync(filePath, "utf-8");
+    const content = fs5.readFileSync(filePath, "utf-8");
     if (content.length === 0) return 0;
     let count = 1;
     for (let i = 0; i < content.length; i++) {
@@ -366,14 +882,14 @@ function countFileLines(filePath) {
   }
 }
 function checkNaming(relPath, conventions) {
-  const filename = path4.basename(relPath);
-  const ext = path4.extname(filename);
+  const filename = path5.basename(relPath);
+  const ext = path5.extname(filename);
   if (!SOURCE_EXTS.has(ext)) return void 0;
   if (filename.startsWith("index.") || filename.includes(".config.") || filename.includes(".test.") || filename.includes(".spec.") || filename.startsWith(".") || filename.startsWith("_") || filename.startsWith("+") || filename.startsWith("$") || filename.startsWith("[")) {
     return void 0;
   }
   const bare = filename.slice(0, filename.indexOf("."));
-  const convention = typeof conventions.fileNaming === "string" ? conventions.fileNaming : conventions.fileNaming?.value;
+  const convention = conventions.fileNaming;
   if (!convention) return void 0;
   const pattern = NAMING_PATTERNS[convention];
   if (!pattern || pattern.test(bare)) return void 0;
@@ -383,33 +899,55 @@ function getStagedFiles(projectRoot) {
   try {
     const output = execSync("git diff --cached --name-only --diff-filter=ACM", {
       cwd: projectRoot,
-      encoding: "utf-8"
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
     });
     return output.trim().split("\n").filter(Boolean);
   } catch {
     return [];
   }
 }
+function getDiffFiles(projectRoot, base) {
+  try {
+    const allOutput = execSync(`git diff --name-only --diff-filter=ACMR ${base}...HEAD`, {
+      cwd: projectRoot,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    const addedOutput = execSync(`git diff --name-only --diff-filter=A ${base}...HEAD`, {
+      cwd: projectRoot,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    return {
+      all: allOutput.trim().split("\n").filter(Boolean),
+      added: addedOutput.trim().split("\n").filter(Boolean)
+    };
+  } catch {
+    return { all: [], added: [] };
+  }
+}
 function getAllSourceFiles(projectRoot, config) {
+  const effectiveIgnore = [...BUILTIN_IGNORE2, ...config.ignore ?? []];
   const files = [];
   const walk = (dir) => {
     let entries;
     try {
-      entries = fs4.readdirSync(dir, { withFileTypes: true });
+      entries = fs5.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const rel = path4.relative(projectRoot, path4.join(dir, entry.name));
+      const rel = path5.relative(projectRoot, path5.join(dir, entry.name));
       if (entry.isDirectory()) {
         if (ALWAYS_SKIP_DIRS.has(entry.name)) {
           continue;
         }
-        if (isIgnored(rel, config.ignore)) continue;
-        walk(path4.join(dir, entry.name));
+        if (isIgnored(rel, effectiveIgnore)) continue;
+        walk(path5.join(dir, entry.name));
       } else if (entry.isFile()) {
-        const ext = path4.extname(entry.name);
-        if (SOURCE_EXTS.has(ext) && !isIgnored(rel, config.ignore)) {
+        const ext = path5.extname(entry.name);
+        if (SOURCE_EXTS.has(ext) && !isIgnored(rel, effectiveIgnore)) {
           files.push(rel);
         }
       }
@@ -423,16 +961,16 @@ function collectSourceFiles(dir, projectRoot) {
   const walk = (d) => {
     let entries;
     try {
-      entries = fs4.readdirSync(d, { withFileTypes: true });
+      entries = fs5.readdirSync(d, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
       if (entry.isDirectory()) {
         if (entry.name === "node_modules") continue;
-        walk(path4.join(d, entry.name));
+        walk(path5.join(d, entry.name));
       } else if (entry.isFile()) {
-        files.push(path4.relative(projectRoot, path4.join(d, entry.name)));
+        files.push(path5.relative(projectRoot, path5.join(d, entry.name)));
       }
     }
   };
@@ -441,8 +979,8 @@ function collectSourceFiles(dir, projectRoot) {
 }
 
 // src/commands/check-tests.ts
-import * as fs5 from "fs";
-import * as path5 from "path";
+import * as fs6 from "fs";
+import * as path6 from "path";
 var SOURCE_EXTS2 = /* @__PURE__ */ new Set([
   ".ts",
   ".tsx",
@@ -456,44 +994,58 @@ var SOURCE_EXTS2 = /* @__PURE__ */ new Set([
 ]);
 function checkMissingTests(projectRoot, config, severity) {
   const violations = [];
-  const { testPattern } = config.structure;
-  if (!testPattern) return violations;
-  const srcDir = config.structure.srcDir;
-  if (!srcDir) return violations;
-  const srcPath = path5.join(projectRoot, srcDir);
-  if (!fs5.existsSync(srcPath)) return violations;
-  const testSuffix = testPattern.replace("*", "");
-  const sourceFiles = collectSourceFiles(srcPath, projectRoot);
-  for (const relFile of sourceFiles) {
-    const basename7 = path5.basename(relFile);
-    if (basename7.includes(".test.") || basename7.includes(".spec.") || basename7.startsWith("index.") || basename7.endsWith(".d.ts")) {
-      continue;
-    }
-    const ext = path5.extname(basename7);
-    if (!SOURCE_EXTS2.has(ext)) continue;
-    const stem = basename7.slice(0, basename7.indexOf("."));
-    const expectedTestFile = `${stem}${testSuffix}`;
-    const dir = path5.dirname(path5.join(projectRoot, relFile));
-    const colocatedTest = path5.join(dir, expectedTestFile);
-    const testsDir = config.structure.tests;
-    const dedicatedTest = testsDir ? path5.join(projectRoot, testsDir, expectedTestFile) : null;
-    const hasTest = fs5.existsSync(colocatedTest) || dedicatedTest !== null && fs5.existsSync(dedicatedTest);
-    if (!hasTest) {
-      violations.push({
-        file: relFile,
-        rule: "missing-test",
-        message: `No test file found. Expected \`${expectedTestFile}\`.`,
-        severity
-      });
+  for (const pkg of config.packages) {
+    const effectiveRules = { ...config.rules, ...pkg.rules };
+    const enforceMissing = effectiveRules.enforceMissingTests ?? effectiveRules.testCoverage > 0;
+    if (!enforceMissing) continue;
+    const testPattern = pkg.structure?.testPattern;
+    const srcDir = pkg.structure?.srcDir;
+    if (!testPattern || !srcDir) continue;
+    const packageRoot2 = pkg.path === "." ? projectRoot : path6.join(projectRoot, pkg.path);
+    const srcPath = path6.join(packageRoot2, srcDir);
+    if (!fs6.existsSync(srcPath)) continue;
+    const testSuffix = testPattern.replace("*", "");
+    const sourceFiles = collectSourceFiles(srcPath, projectRoot);
+    for (const relFile of sourceFiles) {
+      const basename8 = path6.basename(relFile);
+      if (basename8.includes(".test.") || basename8.includes(".spec.") || basename8.startsWith("index.") || basename8.endsWith(".d.ts")) {
+        continue;
+      }
+      const ext = path6.extname(basename8);
+      if (!SOURCE_EXTS2.has(ext)) continue;
+      const stem = basename8.slice(0, -ext.length);
+      const expectedTestFile = `${stem}${testSuffix}`;
+      const dir = path6.dirname(path6.join(projectRoot, relFile));
+      const colocatedTest = path6.join(dir, expectedTestFile);
+      const testsDir = pkg.structure?.tests;
+      const dedicatedTest = testsDir ? path6.join(packageRoot2, testsDir, expectedTestFile) : null;
+      const hasTest = fs6.existsSync(colocatedTest) || dedicatedTest !== null && fs6.existsSync(dedicatedTest);
+      if (!hasTest) {
+        violations.push({
+          file: relFile,
+          rule: "missing-test",
+          message: `No test file found. Expected \`${expectedTestFile}\`.`,
+          severity
+        });
+      }
     }
   }
   return violations;
 }
+function resolvePackageForFile(sourceRelPath, config) {
+  const sorted = [...config.packages].filter((p) => p.path !== ".").sort((a, b) => b.path.length - a.path.length);
+  for (const pkg of sorted) {
+    if (sourceRelPath.startsWith(`${pkg.path}/`) || sourceRelPath === pkg.path) {
+      return pkg;
+    }
+  }
+  return config.packages.find((p) => p.path === ".") ?? config.packages[0];
+}
 
 // src/commands/check.ts
 var CONFIG_FILE2 = "viberails.config.json";
 function isTestFile(relPath) {
-  const filename = path6.basename(relPath);
+  const filename = path7.basename(relPath);
   return filename.includes(".test.") || filename.includes(".spec.") || filename.startsWith("test.") || filename.startsWith("spec.") || relPath.includes("__tests__/") || relPath.includes("__test__/");
 }
 function printGroupedViolations(violations, limit) {
@@ -503,7 +1055,13 @@ function printGroupedViolations(violations, limit) {
     existing.push(v);
     groups.set(v.rule, existing);
   }
-  const ruleOrder = ["file-size", "file-naming", "missing-test", "boundary-violation"];
+  const ruleOrder = [
+    "file-size",
+    "file-naming",
+    "missing-test",
+    "test-coverage",
+    "boundary-violation"
+  ];
   const sortedKeys = [...groups.keys()].sort(
     (a, b) => (ruleOrder.indexOf(a) === -1 ? 99 : ruleOrder.indexOf(a)) - (ruleOrder.indexOf(b) === -1 ? 99 : ruleOrder.indexOf(b))
   );
@@ -543,8 +1101,8 @@ async function checkCommand(options, cwd) {
     console.error(`${chalk2.red("Error:")} No package.json found. Are you in a JS/TS project?`);
     return 1;
   }
-  const configPath = path6.join(projectRoot, CONFIG_FILE2);
-  if (!fs6.existsSync(configPath)) {
+  const configPath = path7.join(projectRoot, CONFIG_FILE2);
+  if (!fs7.existsSync(configPath)) {
     console.error(
       `${chalk2.red("Error:")} No viberails.config.json found. Run \`viberails init\` first.`
     );
@@ -552,25 +1110,34 @@ async function checkCommand(options, cwd) {
   }
   const config = await loadConfig2(configPath);
   let filesToCheck;
+  let diffAddedFiles = null;
   if (options.staged) {
     filesToCheck = getStagedFiles(projectRoot);
+  } else if (options.diffBase) {
+    const diff = getDiffFiles(projectRoot, options.diffBase);
+    filesToCheck = diff.all.filter((f) => SOURCE_EXTS.has(path7.extname(f)));
+    diffAddedFiles = new Set(diff.added);
   } else if (options.files && options.files.length > 0) {
     filesToCheck = options.files;
   } else {
     filesToCheck = getAllSourceFiles(projectRoot, config);
   }
   if (filesToCheck.length === 0) {
-    console.log(`${chalk2.green("\u2713")} No files to check.`);
+    if (options.format === "json") {
+      console.log(JSON.stringify({ violations: [], checkedFiles: 0 }));
+    } else {
+      console.log(`${chalk2.green("\u2713")} No files to check.`);
+    }
     return 0;
   }
   const violations = [];
-  const severity = config.enforcement === "enforce" ? "error" : "warn";
+  const severity = options.enforce ? "error" : "warn";
   for (const file of filesToCheck) {
-    const absPath = path6.isAbsolute(file) ? file : path6.join(projectRoot, file);
-    const relPath = path6.relative(projectRoot, absPath);
+    const absPath = path7.isAbsolute(file) ? file : path7.join(projectRoot, file);
+    const relPath = path7.relative(projectRoot, absPath);
     const effectiveIgnore = resolveIgnoreForFile(relPath, config);
     if (isIgnored(relPath, effectiveIgnore)) continue;
-    if (!fs6.existsSync(absPath)) continue;
+    if (!fs7.existsSync(absPath)) continue;
     const resolved = resolveConfigForFile(relPath, config);
     const testFile = isTestFile(relPath);
     const maxLines = testFile ? resolved.rules.maxTestFileLines : resolved.rules.maxFileLines;
@@ -597,23 +1164,34 @@ async function checkCommand(options, cwd) {
       }
     }
   }
-  if (config.rules.requireTests && !options.staged && !options.files) {
+  if (!options.staged && !options.files) {
     const testViolations = checkMissingTests(projectRoot, config, severity);
-    violations.push(...testViolations);
+    if (diffAddedFiles) {
+      violations.push(...testViolations.filter((v) => diffAddedFiles.has(v.file)));
+    } else {
+      violations.push(...testViolations);
+    }
+  }
+  if (!options.files && !options.staged && !options.diffBase) {
+    const coverageViolations = checkCoverage(projectRoot, config, filesToCheck, {
+      staged: options.staged,
+      enforce: options.enforce
+    });
+    violations.push(...coverageViolations);
   }
   if (config.rules.enforceBoundaries && config.boundaries && Object.keys(config.boundaries.deny).length > 0 && !options.noBoundaries) {
     const startTime = Date.now();
     const { buildImportGraph, checkBoundaries } = await import("@viberails/graph");
-    const packages = config.workspace ? resolveWorkspacePackages(projectRoot, config.workspace) : void 0;
+    const packages = config.packages.length > 1 ? resolveWorkspacePackages(projectRoot, config.packages) : void 0;
     const graph = await buildImportGraph(projectRoot, {
       packages,
       ignore: config.ignore
     });
     const boundaryViolations = checkBoundaries(graph, config.boundaries);
-    const filterSet = options.staged || options.files ? new Set(filesToCheck.map((f) => path6.resolve(projectRoot, f))) : null;
+    const filterSet = options.staged || options.files || options.diffBase ? new Set(filesToCheck.map((f) => path7.resolve(projectRoot, f))) : null;
     for (const bv of boundaryViolations) {
       if (filterSet && !filterSet.has(bv.file)) continue;
-      const relFile = path6.relative(projectRoot, bv.file);
+      const relFile = path7.relative(projectRoot, bv.file);
       violations.push({
         file: relFile,
         rule: "boundary-violation",
@@ -622,17 +1200,18 @@ async function checkCommand(options, cwd) {
       });
     }
     const elapsed = Date.now() - startTime;
-    console.log(chalk2.dim(`  Boundary check: ${graph.nodes.length} files in ${elapsed}ms`));
+    if (options.format !== "json") {
+      console.log(chalk2.dim(`  Boundary check: ${graph.nodes.length} files in ${elapsed}ms`));
+    }
   }
   if (options.format === "json") {
     console.log(
       JSON.stringify({
         violations,
-        checkedFiles: filesToCheck.length,
-        enforcement: config.enforcement
+        checkedFiles: filesToCheck.length
       })
     );
-    return config.enforcement === "enforce" && violations.length > 0 ? 1 : 0;
+    return options.enforce && violations.length > 0 ? 1 : 0;
   }
   if (violations.length === 0) {
     console.log(`${chalk2.green("\u2713")} ${filesToCheck.length} files checked \u2014 no violations`);
@@ -642,16 +1221,62 @@ async function checkCommand(options, cwd) {
     printGroupedViolations(violations, options.limit);
   }
   printSummary(violations);
-  if (config.enforcement === "enforce") {
+  if (options.enforce) {
     console.log(chalk2.red("Fix violations before committing."));
     return 1;
   }
   return 0;
 }
 
+// src/commands/check-hook.ts
+import * as fs8 from "fs";
+function parseHookFilePath(input) {
+  try {
+    if (!input.trim()) return void 0;
+    const parsed = JSON.parse(input);
+    return parsed?.tool_input?.file_path ?? void 0;
+  } catch {
+    return void 0;
+  }
+}
+function readStdin() {
+  try {
+    return fs8.readFileSync(0, "utf-8");
+  } catch {
+    return "";
+  }
+}
+async function hookCheckCommand(cwd) {
+  try {
+    const filePath = parseHookFilePath(readStdin());
+    if (!filePath) return 0;
+    const originalWrite = process.stdout.write.bind(process.stdout);
+    let captured = "";
+    process.stdout.write = (chunk) => {
+      captured += typeof chunk === "string" ? chunk : chunk.toString();
+      return true;
+    };
+    try {
+      await checkCommand({ files: [filePath], format: "json" }, cwd);
+    } finally {
+      process.stdout.write = originalWrite;
+    }
+    if (!captured.trim()) return 0;
+    const result = JSON.parse(captured);
+    if (result.violations?.length > 0) {
+      process.stderr.write(`${captured.trim()}
+`);
+      return 2;
+    }
+    return 0;
+  } catch {
+    return 0;
+  }
+}
+
 // src/commands/fix.ts
-import * as fs9 from "fs";
-import * as path10 from "path";
+import * as fs11 from "fs";
+import * as path11 from "path";
 import { loadConfig as loadConfig3 } from "@viberails/config";
 import chalk4 from "chalk";
 
@@ -676,7 +1301,8 @@ function checkGitDirty(projectRoot) {
   try {
     const output = execSync2("git status --porcelain", {
       cwd: projectRoot,
-      encoding: "utf-8"
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
     });
     return output.trim().length > 0;
   } catch {
@@ -685,14 +1311,11 @@ function checkGitDirty(projectRoot) {
 }
 function getConventionValue(convention) {
   if (typeof convention === "string") return convention;
-  if (convention && typeof convention === "object" && "value" in convention) {
-    return convention.value;
-  }
   return void 0;
 }
 
 // src/commands/fix-imports.ts
-import * as path7 from "path";
+import * as path8 from "path";
 function stripExtension(filePath) {
   return filePath.replace(/\.(tsx?|jsx?|mjs|cjs)$/, "");
 }
@@ -710,7 +1333,7 @@ async function updateImportsAfterRenames(renames, projectRoot) {
   const renameMap = /* @__PURE__ */ new Map();
   for (const r of renames) {
     const oldStripped = stripExtension(r.oldAbsPath);
-    const newFilename = path7.basename(r.newPath);
+    const newFilename = path8.basename(r.newPath);
     const newName = newFilename.slice(0, newFilename.indexOf("."));
     renameMap.set(oldStripped, { newBare: newName });
   }
@@ -718,14 +1341,14 @@ async function updateImportsAfterRenames(renames, projectRoot) {
     tsConfigFilePath: void 0,
     skipAddingFilesFromTsConfig: true
   });
-  project.addSourceFilesAtPaths(path7.join(projectRoot, "**/*.{ts,tsx,js,jsx,mjs,cjs}"));
+  project.addSourceFilesAtPaths(path8.join(projectRoot, "**/*.{ts,tsx,js,jsx,mjs,cjs}"));
   const updates = [];
   const extensions = ["", ".ts", ".tsx", ".js", ".jsx", "/index.ts", "/index.tsx", "/index.js"];
   for (const sourceFile of project.getSourceFiles()) {
     const filePath = sourceFile.getFilePath();
-    const segments = filePath.split(path7.sep);
+    const segments = filePath.split(path8.sep);
     if (segments.includes("node_modules") || segments.includes("dist")) continue;
-    const fileDir = path7.dirname(filePath);
+    const fileDir = path8.dirname(filePath);
     for (const decl of sourceFile.getImportDeclarations()) {
       const specifier = decl.getModuleSpecifierValue();
       if (!specifier.startsWith(".")) continue;
@@ -782,7 +1405,7 @@ async function updateImportsAfterRenames(renames, projectRoot) {
 }
 function resolveToRenamedFile(specifier, fromDir, renameMap, extensions) {
   const cleanSpec = specifier.endsWith(".js") ? specifier.slice(0, -3) : specifier;
-  const resolved = path7.resolve(fromDir, cleanSpec);
+  const resolved = path8.resolve(fromDir, cleanSpec);
   for (const ext of extensions) {
     const candidate = resolved + ext;
     const stripped = stripExtension(candidate);
@@ -793,8 +1416,8 @@ function resolveToRenamedFile(specifier, fromDir, renameMap, extensions) {
 }
 
 // src/commands/fix-naming.ts
-import * as fs7 from "fs";
-import * as path8 from "path";
+import * as fs9 from "fs";
+import * as path9 from "path";
 
 // src/commands/convert-name.ts
 function splitIntoWords(name) {
@@ -843,8 +1466,8 @@ function capitalize(word) {
 
 // src/commands/fix-naming.ts
 function computeRename(relPath, targetConvention, projectRoot) {
-  const filename = path8.basename(relPath);
-  const dir = path8.dirname(relPath);
+  const filename = path9.basename(relPath);
+  const dir = path9.dirname(relPath);
   const dotIndex = filename.indexOf(".");
   if (dotIndex === -1) return null;
   const bare = filename.slice(0, dotIndex);
@@ -852,15 +1475,15 @@ function computeRename(relPath, targetConvention, projectRoot) {
   const newBare = convertName(bare, targetConvention);
   if (newBare === bare) return null;
   const newFilename = newBare + suffix;
-  const newRelPath = path8.join(dir, newFilename);
-  const oldAbsPath = path8.join(projectRoot, relPath);
-  const newAbsPath = path8.join(projectRoot, newRelPath);
-  if (fs7.existsSync(newAbsPath)) return null;
+  const newRelPath = path9.join(dir, newFilename);
+  const oldAbsPath = path9.join(projectRoot, relPath);
+  const newAbsPath = path9.join(projectRoot, newRelPath);
+  if (fs9.existsSync(newAbsPath)) return null;
   return { oldPath: relPath, newPath: newRelPath, oldAbsPath, newAbsPath };
 }
 function executeRename(rename) {
-  if (fs7.existsSync(rename.newAbsPath)) return false;
-  fs7.renameSync(rename.oldAbsPath, rename.newAbsPath);
+  if (fs9.existsSync(rename.newAbsPath)) return false;
+  fs9.renameSync(rename.oldAbsPath, rename.newAbsPath);
   return true;
 }
 function deduplicateRenames(renames) {
@@ -875,33 +1498,38 @@ function deduplicateRenames(renames) {
 }
 
 // src/commands/fix-tests.ts
-import * as fs8 from "fs";
-import * as path9 from "path";
+import * as fs10 from "fs";
+import * as path10 from "path";
 function generateTestStub(sourceRelPath, config, projectRoot) {
-  const { testPattern } = config.structure;
+  const pkg = resolvePackageForFile(sourceRelPath, config);
+  const testPattern = pkg?.structure?.testPattern;
   if (!testPattern) return null;
-  const basename7 = path9.basename(sourceRelPath);
-  const stem = basename7.slice(0, basename7.indexOf("."));
+  const basename8 = path10.basename(sourceRelPath);
+  const ext = path10.extname(basename8);
+  if (!ext) return null;
+  const stem = basename8.slice(0, -ext.length);
   const testSuffix = testPattern.replace("*", "");
   const testFilename = `${stem}${testSuffix}`;
-  const dir = path9.dirname(path9.join(projectRoot, sourceRelPath));
-  const testAbsPath = path9.join(dir, testFilename);
-  if (fs8.existsSync(testAbsPath)) return null;
+  const dir = path10.dirname(path10.join(projectRoot, sourceRelPath));
+  const testAbsPath = path10.join(dir, testFilename);
+  if (fs10.existsSync(testAbsPath)) return null;
   return {
-    path: path9.relative(projectRoot, testAbsPath),
+    path: path10.relative(projectRoot, testAbsPath),
     absPath: testAbsPath,
     moduleName: stem
   };
 }
 function writeTestStub(stub, config) {
-  const runner = config.stack.testRunner === "jest" ? "jest" : "vitest";
+  const pkg = resolvePackageForFile(stub.path, config);
+  const testRunner = pkg?.stack?.testRunner ?? "";
+  const runner = testRunner.startsWith("jest") ? "jest" : "vitest";
   const importLine = runner === "jest" ? "" : "import { describe, it, expect } from 'vitest';\n\n";
   const content = `${importLine}describe('${stub.moduleName}', () => {
   it.todo('add tests');
 });
 `;
-  fs8.mkdirSync(path9.dirname(stub.absPath), { recursive: true });
-  fs8.writeFileSync(stub.absPath, content);
+  fs10.mkdirSync(path10.dirname(stub.absPath), { recursive: true });
+  fs10.writeFileSync(stub.absPath, content);
 }
 
 // src/commands/fix.ts
@@ -913,8 +1541,8 @@ async function fixCommand(options, cwd) {
     console.error(`${chalk4.red("Error:")} No package.json found. Are you in a JS/TS project?`);
     return 1;
   }
-  const configPath = path10.join(projectRoot, CONFIG_FILE3);
-  if (!fs9.existsSync(configPath)) {
+  const configPath = path11.join(projectRoot, CONFIG_FILE3);
+  if (!fs11.existsSync(configPath)) {
     console.error(
       `${chalk4.red("Error:")} No viberails.config.json found. Run \`viberails init\` first.`
     );
@@ -947,7 +1575,7 @@ async function fixCommand(options, cwd) {
   }
   const dedupedRenames = deduplicateRenames(renames);
   const testStubs = [];
-  if (shouldFixTests && config.rules.requireTests) {
+  if (shouldFixTests) {
     const testViolations = checkMissingTests(projectRoot, config, "warn");
     for (const v of testViolations) {
       const stub = generateTestStub(v.file, config, projectRoot);
@@ -978,13 +1606,13 @@ async function fixCommand(options, cwd) {
   }
   let importUpdateCount = 0;
   if (renameCount > 0) {
-    const appliedRenames = dedupedRenames.filter((r) => fs9.existsSync(r.newAbsPath));
+    const appliedRenames = dedupedRenames.filter((r) => fs11.existsSync(r.newAbsPath));
     const updates = await updateImportsAfterRenames(appliedRenames, projectRoot);
     importUpdateCount = updates.length;
   }
   let stubCount = 0;
   for (const stub of testStubs) {
-    if (!fs9.existsSync(stub.absPath)) {
+    if (!fs11.existsSync(stub.absPath)) {
       writeTestStub(stub, config);
       stubCount++;
     }
@@ -1005,14 +1633,14 @@ async function fixCommand(options, cwd) {
 }
 
 // src/commands/init.ts
-import * as fs12 from "fs";
-import * as path13 from "path";
-import * as clack2 from "@clack/prompts";
-import { generateConfig } from "@viberails/config";
+import * as fs17 from "fs";
+import * as path17 from "path";
+import * as clack7 from "@clack/prompts";
+import { compactConfig as compactConfig2, generateConfig } from "@viberails/config";
 import { scan } from "@viberails/scanner";
-import chalk8 from "chalk";
+import chalk10 from "chalk";
 
-// src/display-text.ts
+// src/display.ts
 import {
   CONVENTION_LABELS as CONVENTION_LABELS2,
   FRAMEWORK_NAMES as FRAMEWORK_NAMES3,
@@ -1020,6 +1648,7 @@ import {
   ORM_NAMES as ORM_NAMES2,
   STYLING_NAMES as STYLING_NAMES3
 } from "@viberails/types";
+import chalk6 from "chalk";
 
 // src/display-helpers.ts
 import { ROLE_DESCRIPTIONS } from "@viberails/types";
@@ -1070,26 +1699,136 @@ function formatRoleGroup(group) {
   return `${group.label} \u2014 ${dirs} (${files})`;
 }
 
-// src/display.ts
+// src/display-monorepo.ts
+import { FRAMEWORK_NAMES as FRAMEWORK_NAMES2, STYLING_NAMES as STYLING_NAMES2 } from "@viberails/types";
+import chalk5 from "chalk";
+
+// src/display-text.ts
 import {
   CONVENTION_LABELS,
-  FRAMEWORK_NAMES as FRAMEWORK_NAMES2,
+  FRAMEWORK_NAMES,
   LIBRARY_NAMES,
   ORM_NAMES,
-  STYLING_NAMES as STYLING_NAMES2
+  STYLING_NAMES
 } from "@viberails/types";
-import chalk6 from "chalk";
+function plainConfidenceLabel(convention) {
+  const pct = Math.round(convention.consistency);
+  if (convention.confidence === "high") {
+    return `${pct}%`;
+  }
+  return `${pct}%, suggested only`;
+}
+function formatConventionsText(scanResult) {
+  const lines = [];
+  const conventionEntries = Object.entries(scanResult.conventions);
+  if (conventionEntries.length === 0) return lines;
+  lines.push("");
+  lines.push("Conventions:");
+  for (const [key, convention] of conventionEntries) {
+    if (convention.confidence === "low") continue;
+    const label = CONVENTION_LABELS[key] ?? key;
+    if (scanResult.packages.length > 1) {
+      const pkgValues = scanResult.packages.filter((pkg) => pkg.conventions[key] && pkg.conventions[key].confidence !== "low").map((pkg) => ({ relativePath: pkg.relativePath, convention: pkg.conventions[key] }));
+      const allSame = pkgValues.every((pv) => pv.convention.value === convention.value);
+      if (allSame || pkgValues.length <= 1) {
+        const ind = convention.confidence === "high" ? "\u2713" : "~";
+        lines.push(`  ${ind} ${label}: ${convention.value} (${plainConfidenceLabel(convention)})`);
+      } else {
+        lines.push(`  ~ ${label}: varies by package`);
+        for (const pv of pkgValues) {
+          const pct = Math.round(pv.convention.consistency);
+          lines.push(`    ${pv.relativePath}: ${pv.convention.value} (${pct}%)`);
+        }
+      }
+    } else {
+      const ind = convention.confidence === "high" ? "\u2713" : "~";
+      lines.push(`  ${ind} ${label}: ${convention.value} (${plainConfidenceLabel(convention)})`);
+    }
+  }
+  return lines;
+}
+function formatRulesText(config) {
+  const root = config.packages.find((p) => p.path === ".") ?? config.packages[0];
+  const lines = [];
+  lines.push(`Max file size: ${config.rules.maxFileLines} lines`);
+  if (config.rules.testCoverage > 0) {
+    lines.push(`Test coverage target: ${config.rules.testCoverage}%`);
+  } else {
+    lines.push("Test coverage target: disabled");
+  }
+  const enforceMissing = config.rules.enforceMissingTests ?? config.rules.testCoverage > 0;
+  if (enforceMissing && root?.structure?.testPattern) {
+    lines.push(`Enforce missing tests: yes (${root.structure.testPattern})`);
+  } else {
+    lines.push("Enforce missing tests: no");
+  }
+  if (config.rules.enforceNaming && root?.conventions?.fileNaming) {
+    lines.push(`Enforce file naming: ${root.conventions.fileNaming}`);
+  } else {
+    lines.push("Enforce file naming: no");
+  }
+  return lines;
+}
+function formatScanResultsText(scanResult) {
+  if (scanResult.packages.length > 1) {
+    return formatMonorepoResultsText(scanResult);
+  }
+  const lines = [];
+  const { stack } = scanResult;
+  lines.push("Detected:");
+  if (stack.framework) {
+    lines.push(`  \u2713 ${formatItem(stack.framework, FRAMEWORK_NAMES)}`);
+  }
+  lines.push(`  \u2713 ${formatItem(stack.language)}`);
+  if (stack.styling) {
+    lines.push(`  \u2713 ${formatItem(stack.styling, STYLING_NAMES)}`);
+  }
+  if (stack.backend) {
+    lines.push(`  \u2713 ${formatItem(stack.backend, FRAMEWORK_NAMES)}`);
+  }
+  if (stack.orm) {
+    lines.push(`  \u2713 ${formatItem(stack.orm, ORM_NAMES)}`);
+  }
+  const secondaryParts = [];
+  if (stack.packageManager) secondaryParts.push(formatItem(stack.packageManager));
+  if (stack.linter) secondaryParts.push(formatItem(stack.linter));
+  if (stack.formatter) secondaryParts.push(formatItem(stack.formatter));
+  if (stack.testRunner) secondaryParts.push(formatItem(stack.testRunner));
+  if (secondaryParts.length > 0) {
+    lines.push(`  \u2713 ${secondaryParts.join(" \xB7 ")}`);
+  }
+  if (stack.libraries.length > 0) {
+    for (const lib of stack.libraries) {
+      lines.push(`  \u2713 ${formatItem(lib, LIBRARY_NAMES)}`);
+    }
+  }
+  const groups = groupByRole(scanResult.structure.directories);
+  if (groups.length > 0) {
+    lines.push("");
+    lines.push("Structure:");
+    for (const group of groups) {
+      lines.push(`  \u2713 ${formatRoleGroup(group)}`);
+    }
+  }
+  lines.push(...formatConventionsText(scanResult));
+  const pkgCount = scanResult.packages.length > 1 ? scanResult.packages.length : void 0;
+  lines.push("");
+  lines.push(formatSummary(scanResult.statistics, pkgCount));
+  const ext = formatExtensions(scanResult.statistics.filesByExtension);
+  if (ext) {
+    lines.push(ext);
+  }
+  return lines.join("\n");
+}
 
 // src/display-monorepo.ts
-import { FRAMEWORK_NAMES, STYLING_NAMES } from "@viberails/types";
-import chalk5 from "chalk";
 function formatPackageSummary(pkg) {
   const parts = [];
   if (pkg.stack.framework) {
-    parts.push(formatItem(pkg.stack.framework, FRAMEWORK_NAMES));
+    parts.push(formatItem(pkg.stack.framework, FRAMEWORK_NAMES2));
   }
   if (pkg.stack.styling) {
-    parts.push(formatItem(pkg.stack.styling, STYLING_NAMES));
+    parts.push(formatItem(pkg.stack.styling, STYLING_NAMES2));
   }
   const files = `${pkg.statistics.totalFiles} files`;
   const detail = parts.length > 0 ? `${parts.join(", ")} (${files})` : `(${files})`;
@@ -1103,11 +1842,15 @@ ${chalk5.bold(`Detected: (monorepo, ${packages.length} packages)`)}`);
   if (stack.packageManager) {
     console.log(`  ${chalk5.green("\u2713")} ${formatItem(stack.packageManager)}`);
   }
-  if (stack.linter) {
-    console.log(`  ${chalk5.green("\u2713")} ${formatItem(stack.linter)}`);
-  }
-  if (stack.formatter) {
-    console.log(`  ${chalk5.green("\u2713")} ${formatItem(stack.formatter)}`);
+  if (stack.linter && stack.formatter && stack.linter.name === stack.formatter.name) {
+    console.log(`  ${chalk5.green("\u2713")} ${formatItem(stack.linter)} (lint + format)`);
+  } else {
+    if (stack.linter) {
+      console.log(`  ${chalk5.green("\u2713")} ${formatItem(stack.linter)}`);
+    }
+    if (stack.formatter) {
+      console.log(`  ${chalk5.green("\u2713")} ${formatItem(stack.formatter)}`);
+    }
   }
   if (stack.testRunner) {
     console.log(`  ${chalk5.green("\u2713")} ${formatItem(stack.testRunner)}`);
@@ -1138,23 +1881,27 @@ ${chalk5.bold("Structure:")}`);
 function formatPackageSummaryPlain(pkg) {
   const parts = [];
   if (pkg.stack.framework) {
-    parts.push(formatItem(pkg.stack.framework, FRAMEWORK_NAMES));
+    parts.push(formatItem(pkg.stack.framework, FRAMEWORK_NAMES2));
   }
   if (pkg.stack.styling) {
-    parts.push(formatItem(pkg.stack.styling, STYLING_NAMES));
+    parts.push(formatItem(pkg.stack.styling, STYLING_NAMES2));
   }
   const files = `${pkg.statistics.totalFiles} files`;
   const detail = parts.length > 0 ? `${parts.join(", ")} (${files})` : `(${files})`;
   return `  ${pkg.relativePath} \u2014 ${detail}`;
 }
-function formatMonorepoResultsText(scanResult, config) {
+function formatMonorepoResultsText(scanResult) {
   const lines = [];
   const { stack, packages } = scanResult;
   lines.push(`Detected: (monorepo, ${packages.length} packages)`);
   const sharedParts = [formatItem(stack.language)];
   if (stack.packageManager) sharedParts.push(formatItem(stack.packageManager));
-  if (stack.linter) sharedParts.push(formatItem(stack.linter));
-  if (stack.formatter) sharedParts.push(formatItem(stack.formatter));
+  if (stack.linter && stack.formatter && stack.linter.name === stack.formatter.name) {
+    sharedParts.push(`${formatItem(stack.linter)} (lint + format)`);
+  } else {
+    if (stack.linter) sharedParts.push(formatItem(stack.linter));
+    if (stack.formatter) sharedParts.push(formatItem(stack.formatter));
+  }
   if (stack.testRunner) sharedParts.push(formatItem(stack.testRunner));
   lines.push(`  \u2713 ${sharedParts.join(" \xB7 ")}`);
   lines.push("");
@@ -1184,7 +1931,6 @@ function formatMonorepoResultsText(scanResult, config) {
   if (ext) {
     lines.push(ext);
   }
-  lines.push(...formatRulesText(config));
   return lines.join("\n");
 }
 
@@ -1207,7 +1953,7 @@ function displayConventions(scanResult) {
 ${chalk6.bold("Conventions:")}`);
   for (const [key, convention] of conventionEntries) {
     if (convention.confidence === "low") continue;
-    const label = CONVENTION_LABELS[key] ?? key;
+    const label = CONVENTION_LABELS2[key] ?? key;
     if (scanResult.packages.length > 1) {
       const pkgValues = scanResult.packages.filter((pkg) => pkg.conventions[key] && pkg.conventions[key].confidence !== "low").map((pkg) => ({ relativePath: pkg.relativePath, convention: pkg.conventions[key] }));
       const allSame = pkgValues.every((pv) => pv.convention.value === convention.value);
@@ -1248,23 +1994,27 @@ function displayScanResults(scanResult) {
   console.log(`
 ${chalk6.bold("Detected:")}`);
   if (stack.framework) {
-    console.log(`  ${chalk6.green("\u2713")} ${formatItem(stack.framework, FRAMEWORK_NAMES2)}`);
+    console.log(`  ${chalk6.green("\u2713")} ${formatItem(stack.framework, FRAMEWORK_NAMES3)}`);
   }
   console.log(`  ${chalk6.green("\u2713")} ${formatItem(stack.language)}`);
   if (stack.styling) {
-    console.log(`  ${chalk6.green("\u2713")} ${formatItem(stack.styling, STYLING_NAMES2)}`);
+    console.log(`  ${chalk6.green("\u2713")} ${formatItem(stack.styling, STYLING_NAMES3)}`);
   }
   if (stack.backend) {
-    console.log(`  ${chalk6.green("\u2713")} ${formatItem(stack.backend, FRAMEWORK_NAMES2)}`);
+    console.log(`  ${chalk6.green("\u2713")} ${formatItem(stack.backend, FRAMEWORK_NAMES3)}`);
   }
   if (stack.orm) {
-    console.log(`  ${chalk6.green("\u2713")} ${formatItem(stack.orm, ORM_NAMES)}`);
+    console.log(`  ${chalk6.green("\u2713")} ${formatItem(stack.orm, ORM_NAMES2)}`);
   }
-  if (stack.linter) {
-    console.log(`  ${chalk6.green("\u2713")} ${formatItem(stack.linter)}`);
-  }
-  if (stack.formatter) {
-    console.log(`  ${chalk6.green("\u2713")} ${formatItem(stack.formatter)}`);
+  if (stack.linter && stack.formatter && stack.linter.name === stack.formatter.name) {
+    console.log(`  ${chalk6.green("\u2713")} ${formatItem(stack.linter)} (lint + format)`);
+  } else {
+    if (stack.linter) {
+      console.log(`  ${chalk6.green("\u2713")} ${formatItem(stack.linter)}`);
+    }
+    if (stack.formatter) {
+      console.log(`  ${chalk6.green("\u2713")} ${formatItem(stack.formatter)}`);
+    }
   }
   if (stack.testRunner) {
     console.log(`  ${chalk6.green("\u2713")} ${formatItem(stack.testRunner)}`);
@@ -1274,7 +2024,7 @@ ${chalk6.bold("Detected:")}`);
   }
   if (stack.libraries.length > 0) {
     for (const lib of stack.libraries) {
-      console.log(`  ${chalk6.green("\u2713")} ${formatItem(lib, LIBRARY_NAMES)}`);
+      console.log(`  ${chalk6.green("\u2713")} ${formatItem(lib, LIBRARY_NAMES2)}`);
     }
   }
   const groups = groupByRole(scanResult.structure.directories);
@@ -1289,25 +2039,23 @@ ${chalk6.bold("Structure:")}`);
   displaySummarySection(scanResult);
   console.log("");
 }
-function getConventionStr(cv) {
-  return typeof cv === "string" ? cv : cv.value;
-}
 function displayRulesPreview(config) {
-  console.log(`${chalk6.bold("Rules:")}`);
+  const root = config.packages.find((p) => p.path === ".") ?? config.packages[0];
+  console.log(
+    `${chalk6.bold("Rules:")} ${chalk6.dim("(warns on violation; use --enforce in CI to block)")}`
+  );
   console.log(`  ${chalk6.dim("\u2022")} Max file size: ${config.rules.maxFileLines} lines`);
-  if (config.rules.requireTests && config.structure.testPattern) {
+  if (config.rules.testCoverage > 0 && root?.structure?.testPattern) {
     console.log(
-      `  ${chalk6.dim("\u2022")} Require test files: yes (${config.structure.testPattern})`
+      `  ${chalk6.dim("\u2022")} Test coverage target: ${config.rules.testCoverage}% (${root.structure.testPattern})`
     );
-  } else if (config.rules.requireTests) {
-    console.log(`  ${chalk6.dim("\u2022")} Require test files: yes`);
+  } else if (config.rules.testCoverage > 0) {
+    console.log(`  ${chalk6.dim("\u2022")} Test coverage target: ${config.rules.testCoverage}%`);
   } else {
-    console.log(`  ${chalk6.dim("\u2022")} Require test files: no`);
+    console.log(`  ${chalk6.dim("\u2022")} Test coverage target: disabled`);
   }
-  if (config.rules.enforceNaming && config.conventions.fileNaming) {
-    console.log(
-      `  ${chalk6.dim("\u2022")} Enforce file naming: ${getConventionStr(config.conventions.fileNaming)}`
-    );
+  if (config.rules.enforceNaming && root?.conventions?.fileNaming) {
+    console.log(`  ${chalk6.dim("\u2022")} Enforce file naming: ${root.conventions.fileNaming}`);
   } else {
     console.log(`  ${chalk6.dim("\u2022")} Enforce file naming: no`);
   }
@@ -1315,146 +2063,163 @@ function displayRulesPreview(config) {
     `  ${chalk6.dim("\u2022")} Enforce boundaries: ${config.rules.enforceBoundaries ? "yes" : "no"}`
   );
   console.log("");
-  if (config.enforcement === "enforce") {
-    console.log(`${chalk6.bold("Enforcement mode:")} enforce (violations will block commits)`);
-  } else {
-    console.log(
-      `${chalk6.bold("Enforcement mode:")} warn (violations shown but won't block commits)`
-    );
-  }
-  console.log("");
 }
 
-// src/display-text.ts
-function getConventionStr2(cv) {
-  return typeof cv === "string" ? cv : cv.value;
+// src/utils/check-prerequisites.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import * as fs12 from "fs";
+import * as path12 from "path";
+import * as clack6 from "@clack/prompts";
+import chalk7 from "chalk";
+function checkCoveragePrereqs(projectRoot, scanResult) {
+  const testRunner = scanResult.stack.testRunner;
+  if (!testRunner) return [];
+  const runner = testRunner.name;
+  const pm = scanResult.stack.packageManager.name;
+  if (runner === "vitest") {
+    const hasV8 = hasDependency(projectRoot, "@vitest/coverage-v8");
+    const hasIstanbul = hasDependency(projectRoot, "@vitest/coverage-istanbul");
+    const installed = hasV8 || hasIstanbul;
+    const addCmd = pm === "yarn" ? "yarn add -D" : pm === "npm" ? "npm install -D" : `${pm} add -D`;
+    return [
+      {
+        label: "@vitest/coverage-v8",
+        installed,
+        installCommand: installed ? void 0 : `${addCmd} @vitest/coverage-v8`,
+        reason: "Required for coverage percentage checks with vitest"
+      }
+    ];
+  }
+  return [];
 }
-function plainConfidenceLabel(convention) {
-  const pct = Math.round(convention.consistency);
-  if (convention.confidence === "high") {
-    return `${pct}%`;
+function displayMissingPrereqs(prereqs) {
+  const missing = prereqs.filter((p) => !p.installed);
+  for (const m of missing) {
+    console.log(`  ${chalk7.yellow("!")} ${m.label} not installed \u2014 ${m.reason}`);
+    if (m.installCommand) {
+      console.log(`    Install: ${chalk7.cyan(m.installCommand)}`);
+    }
   }
-  return `${pct}%, suggested only`;
 }
-function formatConventionsText(scanResult) {
-  const lines = [];
-  const conventionEntries = Object.entries(scanResult.conventions);
-  if (conventionEntries.length === 0) return lines;
-  lines.push("");
-  lines.push("Conventions:");
-  for (const [key, convention] of conventionEntries) {
-    if (convention.confidence === "low") continue;
-    const label = CONVENTION_LABELS2[key] ?? key;
-    if (scanResult.packages.length > 1) {
-      const pkgValues = scanResult.packages.filter((pkg) => pkg.conventions[key] && pkg.conventions[key].confidence !== "low").map((pkg) => ({ relativePath: pkg.relativePath, convention: pkg.conventions[key] }));
-      const allSame = pkgValues.every((pv) => pv.convention.value === convention.value);
-      if (allSame || pkgValues.length <= 1) {
-        const ind = convention.confidence === "high" ? "\u2713" : "~";
-        lines.push(`  ${ind} ${label}: ${convention.value} (${plainConfidenceLabel(convention)})`);
-      } else {
-        lines.push(`  ~ ${label}: varies by package`);
-        for (const pv of pkgValues) {
-          const pct = Math.round(pv.convention.consistency);
-          lines.push(`    ${pv.relativePath}: ${pv.convention.value} (${pct}%)`);
+async function promptMissingPrereqs(projectRoot, prereqs) {
+  const missing = prereqs.filter((p) => !p.installed);
+  if (missing.length === 0) return { disableCoverage: false };
+  const prereqLines = prereqs.map(
+    (p) => `${p.installed ? "\u2713" : "\u2717"} ${p.label}${p.installed ? "" : ` \u2014 ${p.reason}`}`
+  ).join("\n");
+  clack6.note(prereqLines, "Coverage prerequisites");
+  let disableCoverage = false;
+  for (const m of missing) {
+    if (!m.installCommand) continue;
+    const choice = await clack6.select({
+      message: `${m.label} is not installed. It is required for coverage percentage checks.`,
+      options: [
+        {
+          value: "install",
+          label: `Yes, install now`,
+          hint: m.installCommand
+        },
+        {
+          value: "disable",
+          label: "No, disable coverage percentage checks",
+          hint: "missing-test checks still active"
+        },
+        {
+          value: "skip",
+          label: "Skip for now",
+          hint: `install later: ${m.installCommand}`
         }
+      ]
+    });
+    assertNotCancelled(choice);
+    if (choice === "install") {
+      const is = clack6.spinner();
+      is.start(`Installing ${m.label}...`);
+      const result = spawnSync2(m.installCommand, {
+        cwd: projectRoot,
+        shell: true,
+        encoding: "utf-8",
+        stdio: "pipe"
+      });
+      if (result.status === 0) {
+        is.stop(`Installed ${m.label}`);
+      } else {
+        is.stop(`Failed to install ${m.label}`);
+        clack6.log.warn(
+          `Install manually: ${m.installCommand}
+Coverage percentage checks will not work until the dependency is installed.`
+        );
       }
+    } else if (choice === "disable") {
+      disableCoverage = true;
+      clack6.log.info("Coverage percentage checks disabled. Missing-test checks remain active.");
     } else {
-      const ind = convention.confidence === "high" ? "\u2713" : "~";
-      lines.push(`  ${ind} ${label}: ${convention.value} (${plainConfidenceLabel(convention)})`);
+      clack6.log.info(
+        `Coverage percentage checks will fail until ${m.label} is installed.
+Install later: ${m.installCommand}`
+      );
     }
   }
-  return lines;
+  return { disableCoverage };
 }
-function formatRulesText(config) {
-  const lines = [];
-  lines.push("");
-  lines.push("Rules:");
-  lines.push(`  \u2022 Max file size: ${config.rules.maxFileLines} lines`);
-  if (config.rules.requireTests && config.structure.testPattern) {
-    lines.push(`  \u2022 Require test files: yes (${config.structure.testPattern})`);
-  } else if (config.rules.requireTests) {
-    lines.push("  \u2022 Require test files: yes");
-  } else {
-    lines.push("  \u2022 Require test files: no");
-  }
-  if (config.rules.enforceNaming && config.conventions.fileNaming) {
-    lines.push(`  \u2022 Enforce file naming: ${getConventionStr2(config.conventions.fileNaming)}`);
-  } else {
-    lines.push("  \u2022 Enforce file naming: no");
+function hasDependency(projectRoot, name) {
+  try {
+    const pkgPath = path12.join(projectRoot, "package.json");
+    const pkg = JSON.parse(fs12.readFileSync(pkgPath, "utf-8"));
+    return !!(pkg.devDependencies?.[name] || pkg.dependencies?.[name]);
+  } catch {
+    return false;
   }
-  lines.push(`  \u2022 Enforcement mode: ${config.enforcement}`);
-  return lines;
 }
-function formatScanResultsText(scanResult, config) {
-  if (scanResult.packages.length > 1) {
-    return formatMonorepoResultsText(scanResult, config);
-  }
-  const lines = [];
-  const { stack } = scanResult;
-  lines.push("Detected:");
-  if (stack.framework) {
-    lines.push(`  \u2713 ${formatItem(stack.framework, FRAMEWORK_NAMES3)}`);
-  }
-  lines.push(`  \u2713 ${formatItem(stack.language)}`);
-  if (stack.styling) {
-    lines.push(`  \u2713 ${formatItem(stack.styling, STYLING_NAMES3)}`);
-  }
-  if (stack.backend) {
-    lines.push(`  \u2713 ${formatItem(stack.backend, FRAMEWORK_NAMES3)}`);
-  }
-  if (stack.orm) {
-    lines.push(`  \u2713 ${formatItem(stack.orm, ORM_NAMES2)}`);
-  }
-  const secondaryParts = [];
-  if (stack.packageManager) secondaryParts.push(formatItem(stack.packageManager));
-  if (stack.linter) secondaryParts.push(formatItem(stack.linter));
-  if (stack.formatter) secondaryParts.push(formatItem(stack.formatter));
-  if (stack.testRunner) secondaryParts.push(formatItem(stack.testRunner));
-  if (secondaryParts.length > 0) {
-    lines.push(`  \u2713 ${secondaryParts.join(" \xB7 ")}`);
-  }
-  if (stack.libraries.length > 0) {
-    for (const lib of stack.libraries) {
-      lines.push(`  \u2713 ${formatItem(lib, LIBRARY_NAMES2)}`);
+
+// src/utils/filter-confidence.ts
+function filterHighConfidence(conventions, meta) {
+  if (!meta) return conventions;
+  const filtered = {};
+  for (const [key, value] of Object.entries(conventions)) {
+    if (value === void 0) continue;
+    const convMeta = meta[key];
+    if (!convMeta || convMeta.confidence === "high") {
+      filtered[key] = value;
     }
   }
-  const groups = groupByRole(scanResult.structure.directories);
-  if (groups.length > 0) {
-    lines.push("");
-    lines.push("Structure:");
-    for (const group of groups) {
-      lines.push(`  \u2713 ${formatRoleGroup(group)}`);
-    }
+  return filtered;
+}
+
+// src/utils/update-gitignore.ts
+import * as fs13 from "fs";
+import * as path13 from "path";
+function updateGitignore(projectRoot) {
+  const gitignorePath = path13.join(projectRoot, ".gitignore");
+  let content = "";
+  if (fs13.existsSync(gitignorePath)) {
+    content = fs13.readFileSync(gitignorePath, "utf-8");
   }
-  lines.push(...formatConventionsText(scanResult));
-  const pkgCount = scanResult.packages.length > 1 ? scanResult.packages.length : void 0;
-  lines.push("");
-  lines.push(formatSummary(scanResult.statistics, pkgCount));
-  const ext = formatExtensions(scanResult.statistics.filesByExtension);
-  if (ext) {
-    lines.push(ext);
+  if (!content.includes(".viberails/scan-result.json")) {
+    const block = "\n# viberails\n.viberails/scan-result.json\n";
+    const prefix = content.length === 0 ? "" : `${content.trimEnd()}
+`;
+    fs13.writeFileSync(gitignorePath, `${prefix}${block}`);
   }
-  lines.push(...formatRulesText(config));
-  return lines.join("\n");
 }
 
 // src/utils/write-generated-files.ts
-import * as fs10 from "fs";
-import * as path11 from "path";
+import * as fs14 from "fs";
+import * as path14 from "path";
 import { generateContext } from "@viberails/context";
 var CONTEXT_DIR = ".viberails";
 var CONTEXT_FILE = "context.md";
 var SCAN_RESULT_FILE = "scan-result.json";
 function writeGeneratedFiles(projectRoot, config, scanResult) {
-  const contextDir = path11.join(projectRoot, CONTEXT_DIR);
+  const contextDir = path14.join(projectRoot, CONTEXT_DIR);
   try {
-    if (!fs10.existsSync(contextDir)) {
-      fs10.mkdirSync(contextDir, { recursive: true });
+    if (!fs14.existsSync(contextDir)) {
+      fs14.mkdirSync(contextDir, { recursive: true });
     }
     const context = generateContext(config);
-    fs10.writeFileSync(path11.join(contextDir, CONTEXT_FILE), context);
-    fs10.writeFileSync(
-      path11.join(contextDir, SCAN_RESULT_FILE),
+    fs14.writeFileSync(path14.join(contextDir, CONTEXT_FILE), context);
+    fs14.writeFileSync(
+      path14.join(contextDir, SCAN_RESULT_FILE),
       `${JSON.stringify(scanResult, null, 2)}
 `
     );
@@ -1465,38 +2230,41 @@ function writeGeneratedFiles(projectRoot, config, scanResult) {
 }
 
 // src/commands/init-hooks.ts
-import * as fs11 from "fs";
-import * as path12 from "path";
-import chalk7 from "chalk";
+import * as fs15 from "fs";
+import * as path15 from "path";
+import chalk8 from "chalk";
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
 function setupPreCommitHook(projectRoot) {
-  const lefthookPath = path12.join(projectRoot, "lefthook.yml");
-  if (fs11.existsSync(lefthookPath)) {
+  const lefthookPath = path15.join(projectRoot, "lefthook.yml");
+  if (fs15.existsSync(lefthookPath)) {
     addLefthookPreCommit(lefthookPath);
-    console.log(`  ${chalk7.green("\u2713")} lefthook.yml \u2014 added viberails pre-commit`);
-    return;
+    console.log(`  ${chalk8.green("\u2713")} lefthook.yml \u2014 added viberails pre-commit`);
+    return "lefthook.yml";
   }
-  const huskyDir = path12.join(projectRoot, ".husky");
-  if (fs11.existsSync(huskyDir)) {
+  const huskyDir = path15.join(projectRoot, ".husky");
+  if (fs15.existsSync(huskyDir)) {
     writeHuskyPreCommit(huskyDir);
-    console.log(`  ${chalk7.green("\u2713")} .husky/pre-commit \u2014 added viberails check`);
-    return;
-  }
-  const gitDir = path12.join(projectRoot, ".git");
-  if (fs11.existsSync(gitDir)) {
-    const hooksDir = path12.join(gitDir, "hooks");
-    if (!fs11.existsSync(hooksDir)) {
-      fs11.mkdirSync(hooksDir, { recursive: true });
+    console.log(`  ${chalk8.green("\u2713")} .husky/pre-commit \u2014 added viberails check`);
+    return ".husky/pre-commit";
+  }
+  const gitDir = path15.join(projectRoot, ".git");
+  if (fs15.existsSync(gitDir)) {
+    const hooksDir = path15.join(gitDir, "hooks");
+    if (!fs15.existsSync(hooksDir)) {
+      fs15.mkdirSync(hooksDir, { recursive: true });
     }
     writeGitHookPreCommit(hooksDir);
-    console.log(`  ${chalk7.green("\u2713")} .git/hooks/pre-commit`);
+    console.log(`  ${chalk8.green("\u2713")} .git/hooks/pre-commit`);
+    return ".git/hooks/pre-commit";
   }
+  return void 0;
 }
 function writeGitHookPreCommit(hooksDir) {
-  const hookPath = path12.join(hooksDir, "pre-commit");
-  if (fs11.existsSync(hookPath)) {
-    const existing = fs11.readFileSync(hookPath, "utf-8");
+  const hookPath = path15.join(hooksDir, "pre-commit");
+  if (fs15.existsSync(hookPath)) {
+    const existing = fs15.readFileSync(hookPath, "utf-8");
     if (existing.includes("viberails")) return;
-    fs11.writeFileSync(
+    fs15.writeFileSync(
       hookPath,
       `${existing.trimEnd()}
 
@@ -1513,71 +2281,51 @@ npx viberails check --staged
     "npx viberails check --staged",
     ""
   ].join("\n");
-  fs11.writeFileSync(hookPath, script, { mode: 493 });
+  fs15.writeFileSync(hookPath, script, { mode: 493 });
 }
 function addLefthookPreCommit(lefthookPath) {
-  const content = fs11.readFileSync(lefthookPath, "utf-8");
+  const content = fs15.readFileSync(lefthookPath, "utf-8");
   if (content.includes("viberails")) return;
-  const hasPreCommit = /^pre-commit:/m.test(content);
-  if (hasPreCommit) {
-    const commandBlock = ["", "    viberails:", "      run: npx viberails check --staged"].join(
-      "\n"
-    );
-    const updated = `${content.trimEnd()}
-${commandBlock}
-`;
-    fs11.writeFileSync(lefthookPath, updated);
-  } else {
-    const section = [
-      "",
-      "pre-commit:",
-      "  commands:",
-      "    viberails:",
-      "      run: npx viberails check --staged"
-    ].join("\n");
-    fs11.writeFileSync(lefthookPath, `${content.trimEnd()}
-${section}
-`);
+  const doc = parseYaml(content) ?? {};
+  if (!doc["pre-commit"]) {
+    doc["pre-commit"] = { commands: {} };
   }
+  if (!doc["pre-commit"].commands) {
+    doc["pre-commit"].commands = {};
+  }
+  doc["pre-commit"].commands.viberails = {
+    run: "npx viberails check --staged"
+  };
+  fs15.writeFileSync(lefthookPath, stringifyYaml(doc));
 }
 function detectHookManager(projectRoot) {
-  if (fs11.existsSync(path12.join(projectRoot, "lefthook.yml"))) return "Lefthook";
-  if (fs11.existsSync(path12.join(projectRoot, ".husky"))) return "Husky";
-  if (fs11.existsSync(path12.join(projectRoot, ".git"))) return "git hook";
+  if (fs15.existsSync(path15.join(projectRoot, "lefthook.yml"))) return "Lefthook";
+  if (fs15.existsSync(path15.join(projectRoot, ".husky"))) return "Husky";
+  if (fs15.existsSync(path15.join(projectRoot, ".git"))) return "git hook";
   return void 0;
 }
 function setupClaudeCodeHook(projectRoot) {
-  const claudeDir = path12.join(projectRoot, ".claude");
-  if (!fs11.existsSync(claudeDir)) {
-    fs11.mkdirSync(claudeDir, { recursive: true });
+  const claudeDir = path15.join(projectRoot, ".claude");
+  if (!fs15.existsSync(claudeDir)) {
+    fs15.mkdirSync(claudeDir, { recursive: true });
   }
-  const settingsPath = path12.join(claudeDir, "settings.json");
+  const settingsPath = path15.join(claudeDir, "settings.json");
   let settings = {};
-  if (fs11.existsSync(settingsPath)) {
+  if (fs15.existsSync(settingsPath)) {
     try {
-      settings = JSON.parse(fs11.readFileSync(settingsPath, "utf-8"));
+      settings = JSON.parse(fs15.readFileSync(settingsPath, "utf-8"));
     } catch {
       console.warn(
-        `  ${chalk7.yellow("!")} .claude/settings.json contains invalid JSON \u2014 resetting to add hook`
+        `  ${chalk8.yellow("!")} .claude/settings.json contains invalid JSON \u2014 skipping hook setup`
       );
-      settings = {};
+      console.warn(`  Fix the JSON manually, then re-run ${chalk8.cyan("viberails init --force")}`);
+      return;
     }
   }
   const hooks = settings.hooks ?? {};
   const existing = hooks.PostToolUse ?? [];
   if (existing.some((h) => JSON.stringify(h).includes("viberails"))) return;
-  const extractFile = `node -e "try{process.stdout.write(JSON.parse(require('fs').readFileSync(0,'utf8')).tool_input?.file_path??'')}catch{}"`;
-  const checkAndReport = [
-    `FILE=$(${extractFile})`,
-    'if [ -z "$FILE" ]; then exit 0; fi',
-    'OUTPUT=$(npx viberails check --files "$FILE" --format json 2>&1)',
-    `if echo "$OUTPUT" | node -e "process.exit(JSON.parse(require('fs').readFileSync(0,'utf8')).violations?.length?0:1)" 2>/dev/null; then`,
-    '  echo "$OUTPUT" >&2',
-    "  exit 2",
-    "fi",
-    "exit 0"
-  ].join("\n");
-  const hookCommand = checkAndReport;
+  const hookCommand = "if [ -x ./node_modules/.bin/viberails ]; then ./node_modules/.bin/viberails check --hook; else npx viberails check --hook; fi";
   hooks.PostToolUse = [
     ...existing,
     {
@@ -1591,228 +2339,406 @@ function setupClaudeCodeHook(projectRoot) {
     }
   ];
   settings.hooks = hooks;
-  fs11.writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}
+  fs15.writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}
 `);
-  console.log(`  ${chalk7.green("\u2713")} .claude/settings.json \u2014 added viberails PostToolUse hook`);
+  console.log(`  ${chalk8.green("\u2713")} .claude/settings.json \u2014 added viberails PostToolUse hook`);
 }
 function setupClaudeMdReference(projectRoot) {
-  const claudeMdPath = path12.join(projectRoot, "CLAUDE.md");
+  const claudeMdPath = path15.join(projectRoot, "CLAUDE.md");
   let content = "";
-  if (fs11.existsSync(claudeMdPath)) {
-    content = fs11.readFileSync(claudeMdPath, "utf-8");
+  if (fs15.existsSync(claudeMdPath)) {
+    content = fs15.readFileSync(claudeMdPath, "utf-8");
   }
   if (content.includes("@.viberails/context.md")) return;
   const ref = "\n@.viberails/context.md\n";
   const prefix = content.length === 0 ? "" : content.trimEnd();
-  fs11.writeFileSync(claudeMdPath, prefix + ref);
-  console.log(`  ${chalk7.green("\u2713")} CLAUDE.md \u2014 added @.viberails/context.md reference`);
+  fs15.writeFileSync(claudeMdPath, prefix + ref);
+  console.log(`  ${chalk8.green("\u2713")} CLAUDE.md \u2014 added @.viberails/context.md reference`);
+}
+function setupGithubAction(projectRoot, packageManager) {
+  const workflowDir = path15.join(projectRoot, ".github", "workflows");
+  const workflowPath = path15.join(workflowDir, "viberails.yml");
+  if (fs15.existsSync(workflowPath)) {
+    const existing = fs15.readFileSync(workflowPath, "utf-8");
+    if (existing.includes("viberails")) return void 0;
+  }
+  fs15.mkdirSync(workflowDir, { recursive: true });
+  const pm = packageManager || "npm";
+  const installCmd = pm === "yarn" ? "yarn install --frozen-lockfile" : pm === "pnpm" ? "pnpm install --frozen-lockfile" : "npm ci";
+  const runPrefix = pm === "npm" ? "npx" : `${pm} exec`;
+  const lines = [
+    "name: viberails",
+    "",
+    "on:",
+    "  pull_request:",
+    "    branches: [main]",
+    "",
+    "jobs:",
+    "  check:",
+    "    runs-on: ubuntu-latest",
+    "    steps:",
+    "      - uses: actions/checkout@v4",
+    "        with:",
+    "          fetch-depth: 0",
+    ""
+  ];
+  if (pm === "pnpm") {
+    lines.push("      - uses: pnpm/action-setup@v4", "");
+  }
+  lines.push(
+    "      - uses: actions/setup-node@v4",
+    "        with:",
+    "          node-version: 22",
+    pm !== "npm" ? `          cache: ${pm}` : "",
+    "",
+    `      - run: ${installCmd}`,
+    `      - run: ${runPrefix} viberails check --enforce --diff-base origin/\${{ github.event.pull_request.base.ref }}`,
+    ""
+  );
+  const content = lines.filter((l) => l !== void 0).join("\n");
+  fs15.writeFileSync(workflowPath, content);
+  return ".github/workflows/viberails.yml";
 }
 function writeHuskyPreCommit(huskyDir) {
-  const hookPath = path12.join(huskyDir, "pre-commit");
-  if (fs11.existsSync(hookPath)) {
-    const existing = fs11.readFileSync(hookPath, "utf-8");
+  const hookPath = path15.join(huskyDir, "pre-commit");
+  if (fs15.existsSync(hookPath)) {
+    const existing = fs15.readFileSync(hookPath, "utf-8");
     if (!existing.includes("viberails")) {
-      fs11.writeFileSync(hookPath, `${existing.trimEnd()}
+      fs15.writeFileSync(hookPath, `${existing.trimEnd()}
 npx viberails check --staged
 `);
     }
     return;
   }
-  fs11.writeFileSync(hookPath, "#!/bin/sh\nnpx viberails check --staged\n", { mode: 493 });
+  fs15.writeFileSync(hookPath, "#!/bin/sh\nnpx viberails check --staged\n", { mode: 493 });
 }
 
-// src/commands/init.ts
-var CONFIG_FILE4 = "viberails.config.json";
-function filterHighConfidence(conventions) {
-  const filtered = {};
-  for (const [key, value] of Object.entries(conventions)) {
-    if (value === void 0) continue;
-    if (typeof value === "string") {
-      filtered[key] = value;
-    } else if (value._confidence === "high") {
-      filtered[key] = value;
+// src/commands/init-hooks-extra.ts
+import * as fs16 from "fs";
+import * as path16 from "path";
+import chalk9 from "chalk";
+import { parse as parseYaml2, stringify as stringifyYaml2 } from "yaml";
+function addPreCommitStep(projectRoot, name, command, marker) {
+  const lefthookPath = path16.join(projectRoot, "lefthook.yml");
+  if (fs16.existsSync(lefthookPath)) {
+    const content = fs16.readFileSync(lefthookPath, "utf-8");
+    if (content.includes(marker)) return void 0;
+    const doc = parseYaml2(content) ?? {};
+    if (!doc["pre-commit"]) doc["pre-commit"] = { commands: {} };
+    if (!doc["pre-commit"].commands) doc["pre-commit"].commands = {};
+    doc["pre-commit"].commands[name] = { run: command };
+    fs16.writeFileSync(lefthookPath, stringifyYaml2(doc));
+    return "lefthook.yml";
+  }
+  const huskyDir = path16.join(projectRoot, ".husky");
+  if (fs16.existsSync(huskyDir)) {
+    const hookPath = path16.join(huskyDir, "pre-commit");
+    if (fs16.existsSync(hookPath)) {
+      const existing = fs16.readFileSync(hookPath, "utf-8");
+      if (existing.includes(marker)) return void 0;
+      fs16.writeFileSync(hookPath, `${existing.trimEnd()}
+${command}
+`);
+    } else {
+      fs16.writeFileSync(hookPath, `#!/bin/sh
+${command}
+`, { mode: 493 });
+    }
+    return ".husky/pre-commit";
+  }
+  const gitDir = path16.join(projectRoot, ".git");
+  if (fs16.existsSync(gitDir)) {
+    const hooksDir = path16.join(gitDir, "hooks");
+    if (!fs16.existsSync(hooksDir)) fs16.mkdirSync(hooksDir, { recursive: true });
+    const hookPath = path16.join(hooksDir, "pre-commit");
+    if (fs16.existsSync(hookPath)) {
+      const existing = fs16.readFileSync(hookPath, "utf-8");
+      if (existing.includes(marker)) return void 0;
+      fs16.writeFileSync(hookPath, `${existing.trimEnd()}
+
+# ${name}
+${command}
+`);
+    } else {
+      fs16.writeFileSync(hookPath, `#!/bin/sh
+# Generated by viberails
+
+# ${name}
+${command}
+`, {
+        mode: 493
+      });
     }
+    return ".git/hooks/pre-commit";
   }
-  return filtered;
+  return void 0;
 }
-function getConventionStr3(cv) {
-  if (!cv) return void 0;
-  return typeof cv === "string" ? cv : cv.value;
+function setupTypecheckHook(projectRoot) {
+  const target = addPreCommitStep(projectRoot, "typecheck", "npx tsc --noEmit", "tsc");
+  if (target) {
+    console.log(`  ${chalk9.green("\u2713")} ${target} \u2014 added typecheck (tsc --noEmit)`);
+  }
+  return target;
 }
-function hasConventionOverrides(config) {
-  if (!config.packages || config.packages.length === 0) return false;
-  return config.packages.some((pkg) => pkg.conventions && Object.keys(pkg.conventions).length > 0);
+function setupLintHook(projectRoot, linter) {
+  const command = linter === "biome" ? "npx biome check ." : "npx eslint .";
+  const linterName = linter === "biome" ? "Biome" : "ESLint";
+  const target = addPreCommitStep(projectRoot, "lint", command, linter);
+  if (target) {
+    console.log(`  ${chalk9.green("\u2713")} ${target} \u2014 added ${linterName} lint check`);
+  }
+  return target;
+}
+function setupSelectedIntegrations(projectRoot, integrations, opts) {
+  const created = [];
+  if (integrations.preCommitHook) {
+    const t = setupPreCommitHook(projectRoot);
+    created.push(t ? `${t} \u2014 added viberails pre-commit` : "pre-commit hook skipped");
+  }
+  if (integrations.typecheckHook) {
+    const t = setupTypecheckHook(projectRoot);
+    if (t) created.push(`${t} \u2014 added typecheck`);
+  }
+  if (integrations.lintHook && opts.linter) {
+    const t = setupLintHook(projectRoot, opts.linter);
+    if (t) created.push(`${t} \u2014 added lint check`);
+  }
+  if (integrations.claudeCodeHook) {
+    setupClaudeCodeHook(projectRoot);
+    created.push(".claude/settings.json \u2014 added viberails hook");
+  }
+  if (integrations.claudeMdRef) {
+    setupClaudeMdReference(projectRoot);
+    created.push("CLAUDE.md \u2014 added @.viberails/context.md reference");
+  }
+  if (integrations.githubAction) {
+    const t = setupGithubAction(projectRoot, opts.packageManager ?? "npm");
+    if (t) created.push(`${t} \u2014 blocks PRs on violations`);
+  }
+  return created;
+}
+
+// src/commands/init.ts
+var CONFIG_FILE4 = "viberails.config.json";
+function getExemptedPackages(config) {
+  return config.packages.filter((pkg) => pkg.rules?.testCoverage === 0 && pkg.path !== ".").map((pkg) => pkg.path);
 }
 async function initCommand(options, cwd) {
-  const startDir = cwd ?? process.cwd();
-  const projectRoot = findProjectRoot(startDir);
+  const projectRoot = findProjectRoot(cwd ?? process.cwd());
   if (!projectRoot) {
     throw new Error(
-      "No package.json found in this directory or any parent.\n\nMake sure you are inside a JavaScript or TypeScript project, then run:\n  npx viberails"
+      "No package.json found. Make sure you are inside a JS/TS project, then run:\n  npx viberails"
     );
   }
-  const configPath = path13.join(projectRoot, CONFIG_FILE4);
-  if (fs12.existsSync(configPath) && !options.force) {
+  const configPath = path17.join(projectRoot, CONFIG_FILE4);
+  if (fs17.existsSync(configPath) && !options.force) {
     console.log(
-      `${chalk8.yellow("!")} viberails is already initialized.
-  Run ${chalk8.cyan("viberails sync")} to update, or ${chalk8.cyan("viberails init --force")} to start fresh.`
+      `${chalk10.yellow("!")} viberails is already initialized.
+  Run ${chalk10.cyan("viberails sync")} to update, or ${chalk10.cyan("viberails init --force")} to start fresh.`
     );
     return;
   }
-  if (options.yes) {
-    console.log(chalk8.dim("Scanning project..."));
-    const scanResult2 = await scan(projectRoot);
-    const config2 = generateConfig(scanResult2);
-    config2.conventions = filterHighConfidence(config2.conventions);
-    displayScanResults(scanResult2);
-    displayRulesPreview(config2);
-    if (config2.workspace?.packages && config2.workspace.packages.length > 0) {
-      console.log(chalk8.dim("Building import graph..."));
-      const { buildImportGraph, inferBoundaries } = await import("@viberails/graph");
-      const packages = resolveWorkspacePackages(projectRoot, config2.workspace);
-      const graph = await buildImportGraph(projectRoot, {
-        packages,
-        ignore: config2.ignore
-      });
-      const inferred = inferBoundaries(graph);
-      const denyCount = Object.values(inferred.deny).reduce((sum, arr) => sum + arr.length, 0);
-      if (denyCount > 0) {
-        config2.boundaries = inferred;
-        config2.rules.enforceBoundaries = true;
-        console.log(`  Inferred ${denyCount} boundary rules`);
-      }
+  if (options.yes) return initNonInteractive(projectRoot, configPath);
+  await initInteractive(projectRoot, configPath, options);
+}
+async function initNonInteractive(projectRoot, configPath) {
+  console.log(chalk10.dim("Scanning project..."));
+  const scanResult = await scan(projectRoot);
+  const config = generateConfig(scanResult);
+  for (const pkg of config.packages) {
+    const pkgMeta = config._meta?.packages?.[pkg.path]?.conventions;
+    pkg.conventions = filterHighConfidence(pkg.conventions ?? {}, pkgMeta);
+  }
+  displayMissingPrereqs(checkCoveragePrereqs(projectRoot, scanResult));
+  displayScanResults(scanResult);
+  displayRulesPreview(config);
+  const exempted = getExemptedPackages(config);
+  if (exempted.length > 0) {
+    console.log(
+      `  ${chalk10.dim("Auto-exempted from coverage:")} ${exempted.join(", ")} ${chalk10.dim("(types-only)")}`
+    );
+  }
+  if (config.packages.length > 1) {
+    console.log(chalk10.dim("Building import graph..."));
+    const { buildImportGraph, inferBoundaries } = await import("@viberails/graph");
+    const packages = resolveWorkspacePackages(projectRoot, config.packages);
+    const graph = await buildImportGraph(projectRoot, { packages, ignore: config.ignore });
+    const inferred = inferBoundaries(graph);
+    const denyCount = Object.values(inferred.deny).reduce((sum, arr) => sum + arr.length, 0);
+    if (denyCount > 0) {
+      config.boundaries = inferred;
+      config.rules.enforceBoundaries = true;
+      console.log(`  Inferred ${denyCount} boundary rules`);
     }
-    fs12.writeFileSync(configPath, `${JSON.stringify(config2, null, 2)}
+  }
+  const compacted = compactConfig2(config);
+  fs17.writeFileSync(configPath, `${JSON.stringify(compacted, null, 2)}
 `);
-    writeGeneratedFiles(projectRoot, config2, scanResult2);
-    updateGitignore(projectRoot);
-    setupClaudeMdReference(projectRoot);
-    console.log(`
-Created:`);
-    console.log(`  ${chalk8.green("\u2713")} ${CONFIG_FILE4}`);
-    console.log(`  ${chalk8.green("\u2713")} .viberails/context.md`);
-    console.log(`  ${chalk8.green("\u2713")} .viberails/scan-result.json`);
-    return;
+  writeGeneratedFiles(projectRoot, config, scanResult);
+  updateGitignore(projectRoot);
+  setupClaudeCodeHook(projectRoot);
+  setupClaudeMdReference(projectRoot);
+  const preCommitTarget = setupPreCommitHook(projectRoot);
+  const rootPkg = config.packages[0];
+  const rootPkgPm = rootPkg?.stack?.packageManager ?? "npm";
+  const actionTarget = setupGithubAction(projectRoot, rootPkgPm);
+  const typecheckTarget = rootPkg?.stack?.language === "typescript" ? setupTypecheckHook(projectRoot) : void 0;
+  const linter = rootPkg?.stack?.linter?.split("@")[0];
+  const lintTarget = linter ? setupLintHook(projectRoot, linter) : void 0;
+  const ok = chalk10.green("\u2713");
+  const created = [
+    `${ok} ${path17.basename(configPath)}`,
+    `${ok} .viberails/context.md`,
+    `${ok} .viberails/scan-result.json`,
+    `${ok} .claude/settings.json \u2014 added viberails hook`,
+    `${ok} CLAUDE.md \u2014 added @.viberails/context.md reference`,
+    preCommitTarget ? `${ok} ${preCommitTarget}` : `${chalk10.yellow("!")} pre-commit hook skipped`,
+    typecheckTarget ? `${ok} ${typecheckTarget} \u2014 added typecheck` : "",
+    lintTarget ? `${ok} ${lintTarget} \u2014 added lint check` : "",
+    actionTarget ? `${ok} ${actionTarget} \u2014 blocks PRs on violations` : ""
+  ].filter(Boolean);
+  console.log(`
+Created:
+${created.map((f) => `  ${f}`).join("\n")}`);
+}
+async function initInteractive(projectRoot, configPath, options) {
+  clack7.intro("viberails");
+  if (fs17.existsSync(configPath) && options.force) {
+    const replace = await confirmDangerous(
+      `${path17.basename(configPath)} already exists and will be replaced. Continue?`
+    );
+    if (!replace) {
+      clack7.outro("Aborted. No files were written.");
+      return;
+    }
   }
-  clack2.intro("viberails");
-  const s = clack2.spinner();
+  const s = clack7.spinner();
   s.start("Scanning project...");
   const scanResult = await scan(projectRoot);
   const config = generateConfig(scanResult);
   s.stop("Scan complete");
+  const prereqResult = await promptMissingPrereqs(
+    projectRoot,
+    checkCoveragePrereqs(projectRoot, scanResult)
+  );
+  if (prereqResult.disableCoverage) {
+    config.rules.testCoverage = 0;
+  }
   if (scanResult.statistics.totalFiles === 0) {
-    clack2.log.warn(
-      "No source files detected. viberails will generate context\nwith minimal content. Run viberails sync after adding files."
+    clack7.log.warn(
+      "No source files detected. Try running from the project root,\nor check that source files exist. Run viberails sync after adding files."
     );
   }
-  const resultsText = formatScanResultsText(scanResult, config);
-  clack2.note(resultsText, "Scan results");
+  clack7.note(formatScanResultsText(scanResult), "Scan results");
+  const rulesLines = formatRulesText(config);
+  const exemptedPkgs = getExemptedPackages(config);
+  if (exemptedPkgs.length > 0)
+    rulesLines.push(`Auto-exempted from coverage: ${exemptedPkgs.join(", ")} (types-only)`);
+  clack7.note(rulesLines.join("\n"), "Rules");
   const decision = await promptInitDecision();
   if (decision === "customize") {
-    clack2.note(
-      "Rules control what viberails checks for.\nYou can change these later in viberails.config.json.",
-      "Rules"
-    );
-    const overrides = await promptRuleCustomization({
+    const rootPkg = config.packages.find((p) => p.path === ".") ?? config.packages[0];
+    const overrides = await promptRuleMenu({
       maxFileLines: config.rules.maxFileLines,
-      requireTests: config.rules.requireTests,
+      testCoverage: config.rules.testCoverage,
+      enforceMissingTests: config.rules.enforceMissingTests,
       enforceNaming: config.rules.enforceNaming,
-      enforcement: config.enforcement,
-      fileNamingValue: getConventionStr3(config.conventions.fileNaming)
+      fileNamingValue: rootPkg.conventions?.fileNaming,
+      coverageSummaryPath: "coverage/coverage-summary.json",
+      coverageCommand: config.defaults?.coverage?.command,
+      packageOverrides: config.packages
     });
+    if (overrides.packageOverrides) config.packages = overrides.packageOverrides;
     config.rules.maxFileLines = overrides.maxFileLines;
-    config.rules.requireTests = overrides.requireTests;
+    config.rules.testCoverage = overrides.testCoverage;
+    config.rules.enforceMissingTests = overrides.enforceMissingTests;
     config.rules.enforceNaming = overrides.enforceNaming;
-    config.enforcement = overrides.enforcement;
-    if (config.workspace?.packages && config.workspace.packages.length > 0) {
-      clack2.note(
-        'These rules apply globally. To customize per package,\nedit the "packages" section in viberails.config.json.',
-        "Per-package overrides"
-      );
+    for (const pkg of config.packages) {
+      pkg.coverage = pkg.coverage ?? {};
+      if (pkg.coverage.summaryPath === void 0) {
+        pkg.coverage.summaryPath = overrides.coverageSummaryPath;
+      }
+      if (pkg.coverage.command === void 0 && overrides.coverageCommand) {
+        pkg.coverage.command = overrides.coverageCommand;
+      }
+    }
+    if (overrides.fileNamingValue) {
+      const oldNaming = rootPkg.conventions?.fileNaming;
+      rootPkg.conventions = rootPkg.conventions ?? {};
+      rootPkg.conventions.fileNaming = overrides.fileNamingValue;
+      if (oldNaming && oldNaming !== overrides.fileNamingValue) {
+        for (const pkg of config.packages) {
+          if (pkg.conventions?.fileNaming === oldNaming) {
+            pkg.conventions.fileNaming = overrides.fileNamingValue;
+          }
+        }
+      }
     }
   }
-  if (config.workspace?.packages && config.workspace.packages.length > 0) {
-    clack2.note(
+  if (config.packages.length > 1) {
+    clack7.note(
       "Boundary rules prevent packages from importing where they\nshouldn't. viberails scans your existing imports and creates\nrules based on what's already working.",
       "Boundaries"
     );
-    const shouldInfer = await confirm2("Infer boundary rules from import patterns?");
+    const shouldInfer = await confirm3("Infer boundary rules from import patterns?");
     if (shouldInfer) {
-      const bs = clack2.spinner();
+      const bs = clack7.spinner();
       bs.start("Building import graph...");
       const { buildImportGraph, inferBoundaries } = await import("@viberails/graph");
-      const packages = resolveWorkspacePackages(projectRoot, config.workspace);
-      const graph = await buildImportGraph(projectRoot, {
-        packages,
-        ignore: config.ignore
-      });
+      const packages = resolveWorkspacePackages(projectRoot, config.packages);
+      const graph = await buildImportGraph(projectRoot, { packages, ignore: config.ignore });
       const inferred = inferBoundaries(graph);
       const denyCount = Object.values(inferred.deny).reduce((sum, arr) => sum + arr.length, 0);
       if (denyCount > 0) {
         config.boundaries = inferred;
         config.rules.enforceBoundaries = true;
         bs.stop(`Inferred ${denyCount} boundary rules`);
+        const boundaryLines = Object.entries(inferred.deny).map(([pkg, denied]) => `${pkg} must NOT import from: ${denied.join(", ")}`).join("\n");
+        clack7.note(boundaryLines, "Boundary rules");
       } else {
         bs.stop("No boundary rules inferred");
       }
     }
   }
   const hookManager = detectHookManager(projectRoot);
-  const integrations = await promptIntegrations(hookManager);
-  if (hasConventionOverrides(config)) {
-    clack2.note(
-      "Some packages use different conventions. Per-package\noverrides have been saved in viberails.config.json \u2014\nreview and adjust as needed.",
-      "Per-package conventions"
-    );
+  const rootPkgStack = (config.packages.find((p) => p.path === ".") ?? config.packages[0])?.stack;
+  const integrations = await promptIntegrations(hookManager, {
+    isTypeScript: rootPkgStack?.language === "typescript",
+    linter: rootPkgStack?.linter?.split("@")[0]
+  });
+  const shouldWrite = await confirm3("Write configuration and set up selected integrations?");
+  if (!shouldWrite) {
+    clack7.outro("Aborted. No files were written.");
+    return;
   }
-  fs12.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}
+  const compacted = compactConfig2(config);
+  fs17.writeFileSync(configPath, `${JSON.stringify(compacted, null, 2)}
 `);
   writeGeneratedFiles(projectRoot, config, scanResult);
   updateGitignore(projectRoot);
   const createdFiles = [
-    CONFIG_FILE4,
+    path17.basename(configPath),
     ".viberails/context.md",
-    ".viberails/scan-result.json"
+    ".viberails/scan-result.json",
+    ...setupSelectedIntegrations(projectRoot, integrations, {
+      linter: rootPkgStack?.linter?.split("@")[0],
+      packageManager: rootPkgStack?.packageManager
+    })
   ];
-  if (integrations.preCommitHook) {
-    setupPreCommitHook(projectRoot);
-    const hookMgr = detectHookManager(projectRoot);
-    if (hookMgr) {
-      createdFiles.push(`lefthook.yml \u2014 added viberails pre-commit`);
-    }
-  }
-  if (integrations.claudeCodeHook) {
-    setupClaudeCodeHook(projectRoot);
-    createdFiles.push(".claude/settings.json \u2014 added viberails hook");
-  }
-  if (integrations.claudeMdRef) {
-    setupClaudeMdReference(projectRoot);
-    createdFiles.push("CLAUDE.md \u2014 added @.viberails/context.md reference");
-  }
-  clack2.log.success(`Created:
+  clack7.log.success(`Created:
 ${createdFiles.map((f) => `  ${f}`).join("\n")}`);
-  clack2.outro("Done! Next: review viberails.config.json, then run viberails check");
-}
-function updateGitignore(projectRoot) {
-  const gitignorePath = path13.join(projectRoot, ".gitignore");
-  let content = "";
-  if (fs12.existsSync(gitignorePath)) {
-    content = fs12.readFileSync(gitignorePath, "utf-8");
-  }
-  if (!content.includes(".viberails/scan-result.json")) {
-    const block = "\n# viberails\n.viberails/scan-result.json\n";
-    const prefix = content.length === 0 ? "" : `${content.trimEnd()}
-`;
-    fs12.writeFileSync(gitignorePath, `${prefix}${block}`);
-  }
+  clack7.outro(
+    `Done! Next: review viberails.config.json, then run viberails check
+  ${chalk10.dim("Tip: use")} ${chalk10.cyan("viberails check --enforce")} ${chalk10.dim("in CI to block PRs on violations.")}`
+  );
 }
 
 // src/commands/sync.ts
-import * as fs13 from "fs";
-import * as path14 from "path";
-import { loadConfig as loadConfig4, mergeConfig } from "@viberails/config";
+import * as fs18 from "fs";
+import * as path18 from "path";
+import { compactConfig as compactConfig3, loadConfig as loadConfig4, mergeConfig } from "@viberails/config";
 import { scan as scan2 } from "@viberails/scanner";
-import chalk9 from "chalk";
+import chalk11 from "chalk";
 
 // src/utils/diff-configs.ts
 import { CONVENTION_LABELS as CONVENTION_LABELS3, FRAMEWORK_NAMES as FRAMEWORK_NAMES4, ORM_NAMES as ORM_NAMES3, STYLING_NAMES as STYLING_NAMES4 } from "@viberails/types";
@@ -1833,11 +2759,8 @@ function displayStackName(s) {
   const display = allMaps[name] ?? name;
   return version ? `${display} ${version}` : display;
 }
-function conventionStr(cv) {
-  return typeof cv === "string" ? cv : cv.value;
-}
-function isDetected(cv) {
-  return typeof cv !== "string" && cv._detected === true;
+function isNewlyDetected(config, pkgPath, key) {
+  return config._meta?.packages?.[pkgPath]?.conventions?.[key]?.detected === true;
 }
 var STACK_FIELDS = [
   "framework",
@@ -1864,59 +2787,66 @@ var STRUCTURE_FIELDS = [
   { key: "tests", label: "tests directory" },
   { key: "testPattern", label: "test pattern" }
 ];
-function diffConfigs(existing, merged) {
+function diffPackage(existing, merged, mergedConfig) {
   const changes = [];
+  const pkgPrefix = existing.path === "." ? "" : `${existing.path}: `;
   for (const field of STACK_FIELDS) {
-    const oldVal = existing.stack[field];
-    const newVal = merged.stack[field];
+    const oldVal = existing.stack?.[field];
+    const newVal = merged.stack?.[field];
     if (!oldVal && newVal) {
-      changes.push({ type: "added", description: `Stack: added ${displayStackName(newVal)}` });
+      changes.push({
+        type: "added",
+        description: `${pkgPrefix}Stack: added ${displayStackName(newVal)}`
+      });
     } else if (oldVal && newVal && oldVal !== newVal) {
       changes.push({
         type: "changed",
-        description: `Stack: ${displayStackName(oldVal)} \u2192 ${displayStackName(newVal)}`
+        description: `${pkgPrefix}Stack: ${displayStackName(oldVal)} \u2192 ${displayStackName(newVal)}`
       });
     }
   }
   for (const key of CONVENTION_KEYS) {
-    const oldVal = existing.conventions[key];
-    const newVal = merged.conventions[key];
+    const oldVal = existing.conventions?.[key];
+    const newVal = merged.conventions?.[key];
     const label = CONVENTION_LABELS3[key] ?? key;
     if (!oldVal && newVal) {
       changes.push({
         type: "added",
-        description: `New convention: ${label} (${conventionStr(newVal)})`
+        description: `${pkgPrefix}New convention: ${label} (${newVal})`
       });
-    } else if (oldVal && newVal && isDetected(newVal)) {
+    } else if (oldVal && newVal && oldVal !== newVal) {
+      const suffix = isNewlyDetected(mergedConfig, merged.path, key) ? " (newly detected)" : "";
       changes.push({
         type: "changed",
-        description: `Convention updated: ${label} (${conventionStr(newVal)})`
+        description: `${pkgPrefix}Convention updated: ${label} (${newVal})${suffix}`
       });
     }
   }
   for (const { key, label } of STRUCTURE_FIELDS) {
-    const oldVal = existing.structure[key];
-    const newVal = merged.structure[key];
+    const oldVal = existing.structure?.[key];
+    const newVal = merged.structure?.[key];
     if (!oldVal && newVal) {
-      changes.push({ type: "added", description: `Structure: detected ${label} (${newVal})` });
-    }
-  }
-  const existingPaths = new Set((existing.packages ?? []).map((p) => p.path));
-  for (const pkg of merged.packages ?? []) {
-    if (!existingPaths.has(pkg.path)) {
-      changes.push({ type: "added", description: `New package: ${pkg.path}` });
+      changes.push({
+        type: "added",
+        description: `${pkgPrefix}Structure: detected ${label} (${newVal})`
+      });
     }
   }
-  const existingWsPkgs = new Set(existing.workspace?.packages ?? []);
-  const mergedWsPkgs = new Set(merged.workspace?.packages ?? []);
-  for (const pkg of mergedWsPkgs) {
-    if (!existingWsPkgs.has(pkg)) {
-      changes.push({ type: "added", description: `Workspace: added ${pkg}` });
+  return changes;
+}
+function diffConfigs(existing, merged) {
+  const changes = [];
+  const existingByPath = new Map(existing.packages.map((p) => [p.path, p]));
+  const mergedByPath = new Map(merged.packages.map((p) => [p.path, p]));
+  for (const existingPkg of existing.packages) {
+    const mergedPkg = mergedByPath.get(existingPkg.path);
+    if (mergedPkg) {
+      changes.push(...diffPackage(existingPkg, mergedPkg, merged));
     }
   }
-  for (const pkg of existingWsPkgs) {
-    if (!mergedWsPkgs.has(pkg)) {
-      changes.push({ type: "removed", description: `Workspace: removed ${pkg}` });
+  for (const mergedPkg of merged.packages) {
+    if (!existingByPath.has(mergedPkg.path)) {
+      changes.push({ type: "added", description: `New package: ${mergedPkg.path}` });
     }
   }
   return changes;
@@ -1941,9 +2871,9 @@ function formatStatsDelta(oldStats, newStats) {
 var CONFIG_FILE5 = "viberails.config.json";
 var SCAN_RESULT_FILE2 = ".viberails/scan-result.json";
 function loadPreviousStats(projectRoot) {
-  const scanResultPath = path14.join(projectRoot, SCAN_RESULT_FILE2);
+  const scanResultPath = path18.join(projectRoot, SCAN_RESULT_FILE2);
   try {
-    const raw = fs13.readFileSync(scanResultPath, "utf-8");
+    const raw = fs18.readFileSync(scanResultPath, "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed?.statistics?.totalFiles !== void 0) {
       return parsed.statistics;
@@ -1960,44 +2890,47 @@ async function syncCommand(cwd) {
       "No package.json found in this directory or any parent.\n\nMake sure you are inside a JavaScript or TypeScript project, then run:\n  npx viberails"
     );
   }
-  const configPath = path14.join(projectRoot, CONFIG_FILE5);
+  const configPath = path18.join(projectRoot, CONFIG_FILE5);
   const existing = await loadConfig4(configPath);
   const previousStats = loadPreviousStats(projectRoot);
-  console.log(chalk9.dim("Scanning project..."));
+  console.log(chalk11.dim("Scanning project..."));
   const scanResult = await scan2(projectRoot);
   const merged = mergeConfig(existing, scanResult);
-  const existingJson = JSON.stringify(existing, null, 2);
-  const mergedJson = JSON.stringify(merged, null, 2);
-  const configChanged = existingJson !== mergedJson;
+  const compacted = compactConfig3(merged);
+  const compactedJson = JSON.stringify(compacted, null, 2);
+  const rawDisk = fs18.readFileSync(configPath, "utf-8").trim();
+  const diskWithoutSync = rawDisk.replace(/"lastSync":\s*"[^"]*"/, '"lastSync": ""');
+  const mergedWithoutSync = compactedJson.replace(/"lastSync":\s*"[^"]*"/, '"lastSync": ""');
+  const configChanged = diskWithoutSync !== mergedWithoutSync;
   const changes = configChanged ? diffConfigs(existing, merged) : [];
   const statsDelta = previousStats ? formatStatsDelta(previousStats, scanResult.statistics) : void 0;
   if (changes.length > 0 || statsDelta) {
     console.log(`
-${chalk9.bold("Changes:")}`);
+${chalk11.bold("Changes:")}`);
     for (const change of changes) {
-      const icon = change.type === "removed" ? chalk9.red("-") : chalk9.green("+");
+      const icon = change.type === "removed" ? chalk11.red("-") : chalk11.green("+");
       console.log(`  ${icon} ${change.description}`);
     }
     if (statsDelta) {
-      console.log(`  ${chalk9.dim(statsDelta)}`);
+      console.log(`  ${chalk11.dim(statsDelta)}`);
     }
   }
-  fs13.writeFileSync(configPath, `${mergedJson}
+  fs18.writeFileSync(configPath, `${compactedJson}
 `);
   writeGeneratedFiles(projectRoot, merged, scanResult);
   console.log(`
-${chalk9.bold("Synced:")}`);
+${chalk11.bold("Synced:")}`);
   if (configChanged) {
-    console.log(`  ${chalk9.yellow("!")} ${CONFIG_FILE5} \u2014 updated (review changes)`);
+    console.log(`  ${chalk11.yellow("!")} ${CONFIG_FILE5} \u2014 updated (review changes)`);
   } else {
-    console.log(`  ${chalk9.green("\u2713")} ${CONFIG_FILE5} \u2014 unchanged`);
+    console.log(`  ${chalk11.green("\u2713")} ${CONFIG_FILE5} \u2014 unchanged`);
   }
-  console.log(`  ${chalk9.green("\u2713")} .viberails/context.md \u2014 regenerated`);
-  console.log(`  ${chalk9.green("\u2713")} .viberails/scan-result.json \u2014 updated`);
+  console.log(`  ${chalk11.green("\u2713")} .viberails/context.md \u2014 regenerated`);
+  console.log(`  ${chalk11.green("\u2713")} .viberails/scan-result.json \u2014 updated`);
 }
 
 // src/index.ts
-var VERSION = "0.3.3";
+var VERSION = "0.5.0";
 var program = new Command();
 program.name("viberails").description("Guardrails for vibe coding").version(VERSION);
 program.command("init", { isDefault: true }).description("Scan your project and set up enforcement guardrails").option("-y, --yes", "Non-interactive mode (use defaults, high-confidence only)").option("-f, --force", "Re-initialize, replacing existing config").action(async (options) => {
@@ -2005,7 +2938,7 @@ program.command("init", { isDefault: true }).description("Scan your project and
     await initCommand(options);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    console.error(`${chalk10.red("Error:")} ${message}`);
+    console.error(`${chalk12.red("Error:")} ${message}`);
     process.exit(1);
   }
 });
@@ -2014,22 +2947,28 @@ program.command("sync").description("Re-scan and update generated files").action
     await syncCommand();
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    console.error(`${chalk10.red("Error:")} ${message}`);
+    console.error(`${chalk12.red("Error:")} ${message}`);
     process.exit(1);
   }
 });
-program.command("check").description("Check files against enforced rules").option("--staged", "Check only staged files (for pre-commit hooks)").option("--files <files...>", "Check specific files").option("--no-boundaries", "Skip boundary checking").option("--quiet", "Show only summary counts, not individual violations").option("--limit <n>", "Maximum number of violations to display", Number.parseInt).option("--format <format>", "Output format: text (default) or json").action(
+program.command("check").description("Check files against enforced rules").option("--staged", "Check only staged files (for pre-commit hooks)").option("--files <files...>", "Check specific files").option("--diff-base <ref>", "Only check files changed since <ref> (for CI on PRs)").option("--no-boundaries", "Skip boundary checking").option("--quiet", "Show only summary counts, not individual violations").option("--limit <n>", "Maximum number of violations to display", Number.parseInt).option("--format <format>", "Output format: text (default) or json").option("--enforce", "Exit with error on violations (for CI)").option("--hook", "Claude Code hook mode: read file from stdin, output to stderr").action(
   async (options) => {
     try {
+      if (options.hook) {
+        const exitCode2 = await hookCheckCommand();
+        process.exit(exitCode2);
+      }
       const exitCode = await checkCommand({
         ...options,
+        diffBase: options.diffBase,
+        enforce: options.enforce,
         noBoundaries: options.boundaries === false,
         format: options.format === "json" ? "json" : "text"
       });
       process.exit(exitCode);
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
-      console.error(`${chalk10.red("Error:")} ${message}`);
+      console.error(`${chalk12.red("Error:")} ${message}`);
       process.exit(1);
     }
   }
@@ -2040,7 +2979,7 @@ program.command("fix").description("Auto-fix file naming violations and generate
     process.exit(exitCode);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    console.error(`${chalk10.red("Error:")} ${message}`);
+    console.error(`${chalk12.red("Error:")} ${message}`);
     process.exit(1);
   }
 });
@@ -2049,7 +2988,7 @@ program.command("boundaries").description("Display, infer, or inspect import bou
     await boundariesCommand(options);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    console.error(`${chalk10.red("Error:")} ${message}`);
+    console.error(`${chalk12.red("Error:")} ${message}`);
     process.exit(1);
   }
 });