viberails 0.6.3 → 0.6.5

package/dist/index.js

@@ -1,7 +1,18 @@
 #!/usr/bin/env node
+import {
+  assertNotCancelled,
+  confirm,
+  confirmDangerous,
+  getRootPackage,
+  promptExistingConfigAction,
+  promptInitDecision,
+  promptIntegrations,
+  promptRuleMenu,
+  spawnAsync
+} from "./chunk-XQKOK3FU.js";
 
 // src/index.ts
-import chalk14 from "chalk";
+import chalk16 from "chalk";
 import { Command } from "commander";
 
 // src/commands/boundaries.ts
@@ -27,530 +38,6 @@ function findProjectRoot(startDir) {
   }
 }
 
-// src/utils/prompt.ts
-import * as clack5 from "@clack/prompts";
-
-// src/utils/prompt-integrations.ts
-import { spawnSync } from "child_process";
-import * as clack from "@clack/prompts";
-async function promptHookManagerInstall(projectRoot, packageManager, isWorkspace) {
-  const choice = await clack.select({
-    message: "No git hook manager detected. Install Lefthook for shareable pre-commit hooks?",
-    options: [
-      {
-        value: "install",
-        label: "Yes, install Lefthook",
-        hint: "recommended \u2014 hooks are committed to the repo and shared with your team"
-      },
-      {
-        value: "skip",
-        label: "No, skip",
-        hint: "pre-commit hooks will be local-only (.git/hooks) and not shared"
-      }
-    ]
-  });
-  assertNotCancelled(choice);
-  if (choice !== "install") return void 0;
-  const pm = packageManager || "npm";
-  const installCmd = pm === "yarn" ? "yarn add -D lefthook" : pm === "pnpm" ? `pnpm add -D${isWorkspace ? " -w" : ""} lefthook` : "npm install -D lefthook";
-  const s = clack.spinner();
-  s.start("Installing Lefthook...");
-  const result = spawnSync(installCmd, {
-    cwd: projectRoot,
-    shell: true,
-    encoding: "utf-8",
-    stdio: "pipe"
-  });
-  if (result.status === 0) {
-    const fs21 = await import("fs");
-    const path21 = await import("path");
-    const lefthookPath = path21.join(projectRoot, "lefthook.yml");
-    if (!fs21.existsSync(lefthookPath)) {
-      fs21.writeFileSync(lefthookPath, "# Managed by viberails \u2014 https://viberails.sh\n");
-    }
-    s.stop("Installed Lefthook");
-    return "Lefthook";
-  }
-  s.stop("Failed to install Lefthook");
-  clack.log.warn(`Install manually: ${installCmd}`);
-  return void 0;
-}
-async function promptIntegrations(projectRoot, hookManager, tools) {
-  let resolvedHookManager = hookManager;
-  if (!resolvedHookManager) {
-    resolvedHookManager = await promptHookManagerInstall(
-      projectRoot,
-      tools?.packageManager ?? "npm",
-      tools?.isWorkspace
-    );
-  }
-  const isBareHook = !resolvedHookManager;
-  const hookLabel = resolvedHookManager ? `Pre-commit hook (${resolvedHookManager})` : "Pre-commit hook (git hook \u2014 local only)";
-  const hookHint = isBareHook ? "local only \u2014 will NOT be committed or shared with collaborators" : "runs viberails checks when you commit";
-  const options = [
-    {
-      value: "preCommit",
-      label: hookLabel,
-      hint: hookHint
-    }
-  ];
-  if (tools?.isTypeScript) {
-    options.push({
-      value: "typecheck",
-      label: "Typecheck (tsc --noEmit)",
-      hint: "pre-commit hook + CI check"
-    });
-  }
-  if (tools?.linter) {
-    const linterName = tools.linter === "biome" ? "Biome" : "ESLint";
-    options.push({
-      value: "lint",
-      label: `Lint check (${linterName})`,
-      hint: "pre-commit hook + CI check"
-    });
-  }
-  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 = isBareHook ? options.filter((o) => o.value !== "preCommit").map((o) => o.value) : options.map((o) => o.value);
-  const result = await clack.multiselect({
-    message: "Set up integrations?",
-    options,
-    initialValues,
-    required: false
-  });
-  assertNotCancelled(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")
-  };
-}
-
-// 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;
-}
-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);
-}
-
-// 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
-    });
-  }
-  const isMonorepo = packageCount > 0;
-  const coverageLabel = isMonorepo ? "Default coverage target" : "Test coverage target";
-  const coverageHint = state.testCoverage === 0 ? "0 (disabled)" : isMonorepo ? `${state.testCoverage}% (per-package default)` : `${state.testCoverage}%`;
-  options.push({ value: "testCoverage", label: coverageLabel, hint: coverageHint });
-  options.push({
-    value: "enforceMissingTests",
-    label: "Enforce missing tests",
-    hint: state.enforceMissingTests ? "yes" : "no"
-  });
-  if (state.testCoverage > 0) {
-    options.push(
-      {
-        value: "coverageSummaryPath",
-        label: isMonorepo ? "Default coverage summary path" : "Coverage summary path",
-        hint: state.coverageSummaryPath
-      },
-      {
-        value: "coverageCommand",
-        label: isMonorepo ? "Default coverage command" : "Coverage command",
-        hint: state.coverageCommand ?? "auto-detect from package.json test runner"
-      }
-    );
-    if (isMonorepo) {
-      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: state.maxFileLines,
-    testCoverage: state.testCoverage,
-    enforceMissingTests: state.enforceMissingTests,
-    enforceNaming: state.enforceNaming,
-    fileNamingValue: state.fileNamingValue,
-    coverageSummaryPath: state.coverageSummaryPath,
-    coverageCommand: state.coverageCommand,
-    packageOverrides: state.packageOverrides
-  };
-}
-
-// 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: "accept",
-        label: "Yes, looks good",
-        hint: "warns on violation; use --enforce in CI to block"
-      },
-      { value: "customize", label: "Let me customize rules" }
-    ]
-  });
-  assertNotCancelled(result);
-  return result;
-}
-
 // src/utils/resolve-workspace-packages.ts
 import * as fs2 from "fs";
 import * as path2 from "path";
@@ -655,7 +142,7 @@ ${chalk.bold("Inferred boundary rules:")}
   console.log(`
   ${totalRules} denied`);
   console.log("");
-  const shouldSave = await confirm3("Save to viberails.config.json?");
+  const shouldSave = await confirm("Save to viberails.config.json?");
   if (shouldSave) {
     config.boundaries = inferred;
     config.rules.enforceBoundaries = true;
@@ -742,7 +229,7 @@ function resolveIgnoreForFile(relPath, config) {
 }
 
 // src/commands/check-coverage.ts
-import { spawnSync as spawnSync2 } from "child_process";
+import { spawnSync } from "child_process";
 import * as fs4 from "fs";
 import * as path4 from "path";
 import { inferCoverageCommand } from "@viberails/config";
@@ -785,7 +272,7 @@ function readCoveragePercentage(summaryPath) {
   }
 }
 function runCoverageCommand(pkgRoot, command) {
-  const result = spawnSync2(command, {
+  const result = spawnSync(command, {
     cwd: pkgRoot,
     shell: true,
     encoding: "utf-8",
@@ -1167,13 +654,13 @@ function checkMissingTests(projectRoot, config, severity) {
     const testSuffix = testPattern.replace("*", "");
     const sourceFiles = collectSourceFiles(srcPath, projectRoot);
     for (const relFile of sourceFiles) {
-      const basename9 = path6.basename(relFile);
-      if (basename9.includes(".test.") || basename9.includes(".spec.") || basename9.startsWith("index.") || basename9.endsWith(".d.ts")) {
+      const basename10 = path6.basename(relFile);
+      if (basename10.includes(".test.") || basename10.includes(".spec.") || basename10.startsWith("index.") || basename10.endsWith(".d.ts")) {
         continue;
       }
-      const ext = path6.extname(basename9);
+      const ext = path6.extname(basename10);
       if (!SOURCE_EXTS2.has(ext)) continue;
-      const stem = basename9.slice(0, -ext.length);
+      const stem = basename10.slice(0, -ext.length);
       const expectedTestFile = `${stem}${testSuffix}`;
       const dir = path6.dirname(path6.join(projectRoot, relFile));
       const colocatedTest = path6.join(dir, expectedTestFile);
@@ -1254,9 +741,9 @@ async function checkCommand(options, cwd) {
   }
   const violations = [];
   const severity = options.enforce ? "error" : "warn";
-  const log7 = options.format !== "json" && !options.hook && !options.quiet ? (msg) => process.stderr.write(chalk3.dim(msg)) : () => {
+  const log5 = options.format !== "json" && !options.hook && !options.quiet ? (msg) => process.stderr.write(chalk3.dim(msg)) : () => {
   };
-  log7("  Checking files...");
+  log5("  Checking files...");
   for (const file of filesToCheck) {
     const absPath = path7.isAbsolute(file) ? file : path7.join(projectRoot, file);
     const relPath = path7.relative(projectRoot, absPath);
@@ -1289,9 +776,9 @@ async function checkCommand(options, cwd) {
       }
     }
   }
-  log7(" done\n");
+  log5(" done\n");
   if (!options.files) {
-    log7("  Checking missing tests...");
+    log5("  Checking missing tests...");
     const testViolations = checkMissingTests(projectRoot, config, severity);
     if (options.staged) {
       const stagedSet = new Set(filesToCheck);
@@ -1304,14 +791,14 @@ async function checkCommand(options, cwd) {
     } else {
       violations.push(...testViolations);
     }
-    log7(" done\n");
+    log5(" done\n");
   }
   if (!options.files && !options.staged && !options.diffBase) {
-    log7("  Running test coverage...\n");
+    log5("  Running test coverage...\n");
     const coverageViolations = checkCoverage(projectRoot, config, filesToCheck, {
       staged: options.staged,
       enforce: options.enforce,
-      onProgress: (pkg) => log7(`    Coverage: ${pkg}...
+      onProgress: (pkg) => log5(`    Coverage: ${pkg}...
 `)
     });
     violations.push(...coverageViolations);
@@ -1336,7 +823,7 @@ async function checkCommand(options, cwd) {
         severity
       });
     }
-    log7(`  Boundary check: ${graph.nodes.length} files in ${Date.now() - startTime}ms
+    log5(`  Boundary check: ${graph.nodes.length} files in ${Date.now() - startTime}ms
 `);
   }
   if (options.format === "json") {
@@ -1412,7 +899,7 @@ async function hookCheckCommand(cwd) {
 // src/commands/config.ts
 import * as fs10 from "fs";
 import * as path9 from "path";
-import * as clack6 from "@clack/prompts";
+import * as clack from "@clack/prompts";
 import { compactConfig as compactConfig2, loadConfig as loadConfig3, mergeConfig } from "@viberails/config";
 import { scan } from "@viberails/scanner";
 import chalk6 from "chalk";
@@ -1732,58 +1219,6 @@ function displayRulesPreview(config) {
   );
   console.log("");
 }
-function displayInitSummary(config, exemptedPackages) {
-  const root = config.packages.find((p) => p.path === ".") ?? config.packages[0];
-  const isMonorepo = config.packages.length > 1;
-  const ok = chalk5.green("\u2713");
-  const off = chalk5.dim("\u25CB");
-  console.log("");
-  console.log(`  ${chalk5.bold("Rules to apply:")}`);
-  console.log(`  ${ok} Max file size: ${chalk5.cyan(`${config.rules.maxFileLines} lines`)}`);
-  const fileNaming = root?.conventions?.fileNaming ?? config.packages.find((p) => p.conventions?.fileNaming)?.conventions?.fileNaming;
-  if (config.rules.enforceNaming && fileNaming) {
-    console.log(`  ${ok} File naming: ${chalk5.cyan(fileNaming)}`);
-  } else {
-    console.log(`  ${off} File naming: ${chalk5.dim("not enforced")}`);
-  }
-  const testPattern = root?.structure?.testPattern ?? config.packages.find((p) => p.structure?.testPattern)?.structure?.testPattern;
-  if (config.rules.enforceMissingTests && testPattern) {
-    console.log(`  ${ok} Missing tests: ${chalk5.cyan(`enforced (${testPattern})`)}`);
-  } else if (config.rules.enforceMissingTests) {
-    console.log(`  ${ok} Missing tests: ${chalk5.cyan("enforced")}`);
-  } else {
-    console.log(`  ${off} Missing tests: ${chalk5.dim("not enforced")}`);
-  }
-  if (config.rules.testCoverage > 0) {
-    if (isMonorepo) {
-      const withCoverage = config.packages.filter(
-        (p) => (p.rules?.testCoverage ?? config.rules.testCoverage) > 0
-      );
-      console.log(
-        `  ${ok} Coverage: ${chalk5.cyan(`${config.rules.testCoverage}%`)} default ${chalk5.dim(`(${withCoverage.length}/${config.packages.length} packages)`)}`
-      );
-    } else {
-      console.log(`  ${ok} Coverage: ${chalk5.cyan(`${config.rules.testCoverage}%`)}`);
-    }
-  } else {
-    console.log(`  ${off} Coverage: ${chalk5.dim("disabled")}`);
-  }
-  if (exemptedPackages.length > 0) {
-    console.log(
-      `  ${chalk5.dim("  exempted:")} ${chalk5.dim(exemptedPackages.join(", "))} ${chalk5.dim("(types-only)")}`
-    );
-  }
-  if (isMonorepo) {
-    console.log(
-      `
-  ${chalk5.dim(`${config.packages.length} packages scanned \xB7 warns on violation \xB7 use --enforce in CI`)}`
-    );
-  } else {
-    console.log(`
-  ${chalk5.dim("warns on violation \xB7 use --enforce in CI to block")}`);
-  }
-  console.log("");
-}
 
 // src/display-text.ts
 function plainConfidenceLabel(convention) {
@@ -1902,7 +1337,9 @@ function formatScanResultsText(scanResult) {
 // src/utils/apply-rule-overrides.ts
 function applyRuleOverrides(config, overrides) {
   if (overrides.packageOverrides) config.packages = overrides.packageOverrides;
+  const rootPkg = getRootPackage(config.packages);
   config.rules.maxFileLines = overrides.maxFileLines;
+  config.rules.maxTestFileLines = overrides.maxTestFileLines;
   config.rules.testCoverage = overrides.testCoverage;
   config.rules.enforceMissingTests = overrides.enforceMissingTests;
   config.rules.enforceNaming = overrides.enforceNaming;
@@ -1916,7 +1353,6 @@ function applyRuleOverrides(config, overrides) {
     }
   }
   if (overrides.fileNamingValue) {
-    const rootPkg = config.packages.find((p) => p.path === ".") ?? config.packages[0];
     const oldNaming = rootPkg.conventions?.fileNaming;
     rootPkg.conventions = rootPkg.conventions ?? {};
     rootPkg.conventions.fileNaming = overrides.fileNamingValue;
@@ -1928,6 +1364,18 @@ function applyRuleOverrides(config, overrides) {
       }
     }
   }
+  if (rootPkg) {
+    rootPkg.conventions = rootPkg.conventions ?? {};
+    if (overrides.componentNaming !== void 0) {
+      rootPkg.conventions.componentNaming = overrides.componentNaming || void 0;
+    }
+    if (overrides.hookNaming !== void 0) {
+      rootPkg.conventions.hookNaming = overrides.hookNaming || void 0;
+    }
+    if (overrides.importAlias !== void 0) {
+      rootPkg.conventions.importAlias = overrides.importAlias || void 0;
+    }
+  }
 }
 
 // src/utils/diff-configs.ts
@@ -2092,29 +1540,35 @@ async function configCommand(options, cwd) {
   }
   const configPath = path9.join(projectRoot, CONFIG_FILE3);
   if (!fs10.existsSync(configPath)) {
-    console.log(`${chalk6.yellow("!")} No config found. Run ${chalk6.cyan("viberails init")} first.`);
+    console.log(`${chalk6.yellow("!")} No config found. Run ${chalk6.cyan("viberails")} first.`);
     return;
   }
-  clack6.intro("viberails config");
+  if (!options.suppressIntro) {
+    clack.intro("viberails config");
+  }
   const config = await loadConfig3(configPath);
   let scanResult = options.rescan ? await rescanAndMerge(projectRoot, config) : void 0;
-  clack6.note(formatRulesText(config).join("\n"), "Current rules");
+  clack.note(formatRulesText(config).join("\n"), "Current rules");
   const rootPkg = config.packages.find((p) => p.path === ".") ?? config.packages[0];
   const overrides = await promptRuleMenu({
     maxFileLines: config.rules.maxFileLines,
+    maxTestFileLines: config.rules.maxTestFileLines,
     testCoverage: config.rules.testCoverage,
     enforceMissingTests: config.rules.enforceMissingTests,
     enforceNaming: config.rules.enforceNaming,
     fileNamingValue: rootPkg.conventions?.fileNaming,
+    componentNaming: rootPkg.conventions?.componentNaming,
+    hookNaming: rootPkg.conventions?.hookNaming,
+    importAlias: rootPkg.conventions?.importAlias,
     coverageSummaryPath: rootPkg.coverage?.summaryPath ?? "coverage/coverage-summary.json",
     coverageCommand: config.defaults?.coverage?.command,
     packageOverrides: config.packages
   });
   applyRuleOverrides(config, overrides);
   if (options.rescan && config.packages.length > 1) {
-    const shouldInfer = await confirm3("Re-infer boundary rules from import patterns?");
+    const shouldInfer = await confirm("Re-infer boundary rules from import patterns?");
     if (shouldInfer) {
-      const bs = clack6.spinner();
+      const bs = clack.spinner();
       bs.start("Building import graph...");
       const { buildImportGraph, inferBoundaries } = await import("@viberails/graph");
       const packages = resolveWorkspacePackages(projectRoot, config.packages);
@@ -2130,31 +1584,31 @@ async function configCommand(options, cwd) {
       }
     }
   }
-  const shouldWrite = await confirm3("Save updated configuration?");
+  const shouldWrite = await confirm("Save updated configuration?");
   if (!shouldWrite) {
-    clack6.outro("No changes written.");
+    clack.outro("No changes written.");
     return;
   }
   const compacted = compactConfig2(config);
   fs10.writeFileSync(configPath, `${JSON.stringify(compacted, null, 2)}
 `);
   if (!scanResult) {
-    const s = clack6.spinner();
+    const s = clack.spinner();
     s.start("Scanning for context generation...");
     scanResult = await scan(projectRoot);
     s.stop("Scan complete");
   }
   writeGeneratedFiles(projectRoot, config, scanResult);
-  clack6.log.success(
+  clack.log.success(
     `Updated:
   ${CONFIG_FILE3}
   .viberails/context.md
   .viberails/scan-result.json`
   );
-  clack6.outro("Done! Run viberails check to verify.");
+  clack.outro("Done! Run viberails check to verify.");
 }
 async function rescanAndMerge(projectRoot, config) {
-  const s = clack6.spinner();
+  const s = clack.spinner();
   s.start("Re-scanning project...");
   const scanResult = await scan(projectRoot);
   const merged = mergeConfig(config, scanResult);
@@ -2165,9 +1619,9 @@ async function rescanAndMerge(projectRoot, config) {
       const icon = c.type === "removed" ? "-" : "+";
       return `${icon} ${c.description}`;
     }).join("\n");
-    clack6.note(changeLines, "Changes detected");
+    clack.note(changeLines, "Changes detected");
   } else {
-    clack6.log.info("No new changes detected from scan.");
+    clack.log.info("No new changes detected from scan.");
   }
   Object.assign(config, merged);
   return scanResult;
@@ -2486,10 +1940,10 @@ function generateTestStub(sourceRelPath, config, projectRoot) {
   const pkg = resolvePackageForFile(sourceRelPath, config);
   const testPattern = pkg?.structure?.testPattern;
   if (!testPattern) return null;
-  const basename9 = path12.basename(sourceRelPath);
-  const ext = path12.extname(basename9);
+  const basename10 = path12.basename(sourceRelPath);
+  const ext = path12.extname(basename10);
   if (!ext) return null;
-  const stem = basename9.slice(0, -ext.length);
+  const stem = basename10.slice(0, -ext.length);
   const testSuffix = testPattern.replace("*", "");
   const testFilename = `${stem}${testSuffix}`;
   const dir = path12.dirname(path12.join(projectRoot, sourceRelPath));
@@ -2661,19 +2115,159 @@ ${chalk8.yellow("!")} No safe fixes to apply. Resolve aliased imports first.`);
 }
 
 // src/commands/init.ts
-import * as fs19 from "fs";
-import * as path19 from "path";
-import * as clack8 from "@clack/prompts";
-import { compactConfig as compactConfig3, generateConfig } from "@viberails/config";
-import { scan as scan2 } from "@viberails/scanner";
-import chalk12 from "chalk";
+import * as fs20 from "fs";
+import * as path20 from "path";
+import * as clack4 from "@clack/prompts";
+import { compactConfig as compactConfig4, generateConfig as generateConfig2 } from "@viberails/config";
+import { scan as scan3 } from "@viberails/scanner";
+import chalk14 from "chalk";
+
+// src/display-init.ts
+import { FRAMEWORK_NAMES as FRAMEWORK_NAMES5, STYLING_NAMES as STYLING_NAMES5 } from "@viberails/types";
+import chalk9 from "chalk";
+var INIT_OVERVIEW_NAMES = {
+  typescript: "TypeScript",
+  javascript: "JavaScript",
+  eslint: "ESLint",
+  prettier: "Prettier",
+  jest: "Jest",
+  vitest: "Vitest",
+  biome: "Biome"
+};
+function formatDetectedOverview(scanResult) {
+  const { stack } = scanResult;
+  const primaryParts = [];
+  const secondaryParts = [];
+  const formatOverviewItem = (item, nameMap) => formatItem(item, { ...INIT_OVERVIEW_NAMES, ...nameMap });
+  if (scanResult.packages.length > 1) {
+    primaryParts.push("monorepo");
+    primaryParts.push(`${scanResult.packages.length} packages`);
+  } else if (stack.framework) {
+    primaryParts.push(formatItem(stack.framework, FRAMEWORK_NAMES5));
+  } else {
+    primaryParts.push("single package");
+  }
+  primaryParts.push(formatOverviewItem(stack.language));
+  if (stack.styling) {
+    primaryParts.push(formatOverviewItem(stack.styling, STYLING_NAMES5));
+  }
+  if (stack.packageManager) secondaryParts.push(formatOverviewItem(stack.packageManager));
+  if (stack.linter) secondaryParts.push(formatOverviewItem(stack.linter));
+  if (stack.formatter) secondaryParts.push(formatOverviewItem(stack.formatter));
+  if (stack.testRunner) secondaryParts.push(formatOverviewItem(stack.testRunner));
+  const primary = primaryParts.map((part) => chalk9.cyan(part)).join(chalk9.dim(" \xB7 "));
+  const secondary = secondaryParts.join(chalk9.dim(" \xB7 "));
+  return secondary ? `${primary}
+  ${chalk9.dim(secondary)}` : primary;
+}
+function displayInitOverview(scanResult, config, exemptedPackages) {
+  const root = config.packages.find((p) => p.path === ".") ?? config.packages[0];
+  const isMonorepo = config.packages.length > 1;
+  const ok = chalk9.green("\u2713");
+  const info = chalk9.yellow("~");
+  console.log("");
+  console.log(`  ${chalk9.bold("Ready to initialize:")}`);
+  console.log(`  ${formatDetectedOverview(scanResult)}`);
+  console.log("");
+  console.log(`  ${chalk9.bold("Rules to apply:")}`);
+  console.log(`  ${ok} Max file size: ${chalk9.cyan(`${config.rules.maxFileLines} lines`)}`);
+  const fileNaming = root?.conventions?.fileNaming ?? config.packages.find((p) => p.conventions?.fileNaming)?.conventions?.fileNaming;
+  if (config.rules.enforceNaming && fileNaming) {
+    console.log(`  ${ok} File naming: ${chalk9.cyan(fileNaming)}`);
+  } else {
+    console.log(`  ${info} File naming: ${chalk9.dim("not enforced")}`);
+  }
+  const testPattern = root?.structure?.testPattern ?? config.packages.find((p) => p.structure?.testPattern)?.structure?.testPattern;
+  if (config.rules.enforceMissingTests && testPattern) {
+    console.log(`  ${ok} Missing tests: ${chalk9.cyan(`enforced (${testPattern})`)}`);
+  } else if (config.rules.enforceMissingTests) {
+    console.log(`  ${ok} Missing tests: ${chalk9.cyan("enforced")}`);
+  } else {
+    console.log(`  ${info} Missing tests: ${chalk9.dim("not enforced")}`);
+  }
+  if (config.rules.testCoverage > 0) {
+    if (isMonorepo) {
+      const withCoverage = config.packages.filter(
+        (p) => (p.rules?.testCoverage ?? config.rules.testCoverage) > 0
+      );
+      console.log(
+        `  ${ok} Coverage: ${chalk9.cyan(`${config.rules.testCoverage}%`)} default ${chalk9.dim(`(${withCoverage.length}/${config.packages.length} packages)`)}`
+      );
+    } else {
+      console.log(`  ${ok} Coverage: ${chalk9.cyan(`${config.rules.testCoverage}%`)}`);
+    }
+  } else {
+    console.log(`  ${info} Coverage: ${chalk9.dim("disabled")}`);
+  }
+  if (exemptedPackages.length > 0) {
+    console.log(
+      `  ${chalk9.dim("  exempted:")} ${chalk9.dim(exemptedPackages.join(", "))} ${chalk9.dim("(types-only)")}`
+    );
+  }
+  console.log("");
+  console.log(`  ${chalk9.bold("Also available:")}`);
+  if (isMonorepo) {
+    console.log(`  ${info} Infer boundaries from current imports`);
+  }
+  console.log(`  ${info} Set up hooks, Claude integration, and CI checks`);
+  console.log(
+    `
+  ${chalk9.dim("Defaults warn locally. Use --enforce in CI when you want failures to block.")}`
+  );
+  console.log("");
+}
+function summarizeSelectedIntegrations(integrations, opts) {
+  const lines = [];
+  if (opts.hasBoundaries) {
+    lines.push("\u2713 Boundary rules: inferred from current imports");
+  } else {
+    lines.push("~ Boundary rules: not enabled");
+  }
+  if (opts.hasCoverage) {
+    lines.push("\u2713 Coverage checks: enabled");
+  } else {
+    lines.push("~ Coverage checks: disabled");
+  }
+  const selectedIntegrations = [
+    integrations.preCommitHook ? "pre-commit hook" : void 0,
+    integrations.typecheckHook ? "typecheck" : void 0,
+    integrations.lintHook ? "lint check" : void 0,
+    integrations.claudeCodeHook ? "Claude Code hook" : void 0,
+    integrations.claudeMdRef ? "CLAUDE.md reference" : void 0,
+    integrations.githubAction ? "GitHub Actions workflow" : void 0
+  ].filter(Boolean);
+  if (selectedIntegrations.length > 0) {
+    lines.push(`\u2713 Integrations: ${selectedIntegrations.join(" \xB7 ")}`);
+  } else {
+    lines.push("~ Integrations: none selected");
+  }
+  return lines;
+}
+function displaySetupPlan(config, integrations, opts = {}) {
+  const configFile = opts.configFile ?? "viberails.config.json";
+  const lines = summarizeSelectedIntegrations(integrations, {
+    hasBoundaries: config.rules.enforceBoundaries,
+    hasCoverage: config.rules.testCoverage > 0
+  });
+  console.log("");
+  console.log(`  ${chalk9.bold("Ready to write:")}`);
+  console.log(
+    `  ${opts.replacingExistingConfig ? chalk9.yellow("!") : chalk9.green("\u2713")} ${configFile}${opts.replacingExistingConfig ? chalk9.dim(" (replacing existing config)") : ""}`
+  );
+  console.log(`  ${chalk9.green("\u2713")} .viberails/context.md`);
+  console.log(`  ${chalk9.green("\u2713")} .viberails/scan-result.json`);
+  for (const line of lines) {
+    const icon = line.startsWith("\u2713") ? chalk9.green("\u2713") : chalk9.yellow("~");
+    console.log(`  ${icon} ${line.slice(2)}`);
+  }
+  console.log("");
+}
 
 // src/utils/check-prerequisites.ts
-import { spawnSync as spawnSync3 } from "child_process";
 import * as fs14 from "fs";
 import * as path14 from "path";
-import * as clack7 from "@clack/prompts";
-import chalk9 from "chalk";
+import * as clack2 from "@clack/prompts";
+import chalk10 from "chalk";
 function checkCoveragePrereqs(projectRoot, scanResult) {
   const pm = scanResult.stack.packageManager.name;
   const vitestPackages = scanResult.packages.filter((pkg) => pkg.stack.testRunner?.name === "vitest").map((pkg) => pkg.relativePath);
@@ -2704,9 +2298,9 @@ function displayMissingPrereqs(prereqs) {
   const missing = prereqs.filter((p) => !p.installed);
   for (const m of missing) {
     const suffix = m.affectedPackages ? ` \u2014 needed for coverage in: ${m.affectedPackages.join(", ")}` : ` \u2014 ${m.reason}`;
-    console.log(`  ${chalk9.yellow("!")} ${m.label} not installed${suffix}`);
+    console.log(`  ${chalk10.yellow("!")} ${m.label} not installed${suffix}`);
     if (m.installCommand) {
-      console.log(`    Install: ${chalk9.cyan(m.installCommand)}`);
+      console.log(`    Install: ${chalk10.cyan(m.installCommand)}`);
     }
   }
 }
@@ -2718,24 +2312,24 @@ async function promptMissingPrereqs(projectRoot, prereqs) {
     const detail = p.affectedPackages ? `needed by: ${p.affectedPackages.join(", ")}` : p.reason;
     return `\u2717 ${p.label} \u2014 ${detail}`;
   }).join("\n");
-  clack7.note(prereqLines, "Coverage prerequisites");
+  clack2.note(prereqLines, "Coverage support");
   let disableCoverage = false;
   for (const m of missing) {
     if (!m.installCommand) continue;
     const pkgCount = m.affectedPackages?.length;
     const message = pkgCount ? `${m.label} is not installed. Required for coverage in ${pkgCount} packages using vitest.` : `${m.label} is not installed. It is required for coverage percentage checks.`;
-    const choice = await clack7.select({
+    const choice = await clack2.select({
       message,
       options: [
         {
           value: "install",
-          label: `Yes, install now`,
+          label: "Install now",
           hint: m.installCommand
         },
         {
           value: "disable",
-          label: "No, disable coverage percentage checks",
-          hint: "missing-test checks still active"
+          label: "Disable coverage checks",
+          hint: "missing-test checks still stay active"
         },
         {
           value: "skip",
@@ -2746,28 +2340,23 @@ async function promptMissingPrereqs(projectRoot, prereqs) {
     });
     assertNotCancelled(choice);
     if (choice === "install") {
-      const is = clack7.spinner();
+      const is = clack2.spinner();
       is.start(`Installing ${m.label}...`);
-      const result = spawnSync3(m.installCommand, {
-        cwd: projectRoot,
-        shell: true,
-        encoding: "utf-8",
-        stdio: "pipe"
-      });
+      const result = await spawnAsync(m.installCommand, projectRoot);
       if (result.status === 0) {
         is.stop(`Installed ${m.label}`);
       } else {
         is.stop(`Failed to install ${m.label}`);
-        clack7.log.warn(
+        clack2.log.warn(
           `Install manually: ${m.installCommand}
 Coverage percentage checks will not work until the dependency is installed.`
         );
       }
     } else if (choice === "disable") {
       disableCoverage = true;
-      clack7.log.info("Coverage percentage checks disabled. Missing-test checks remain active.");
+      clack2.log.info("Coverage percentage checks disabled. Missing-test checks remain active.");
     } else {
-      clack7.log.info(
+      clack2.log.info(
         `Coverage percentage checks will fail until ${m.label} is installed.
 Install later: ${m.installCommand}`
       );
@@ -2785,20 +2374,6 @@ function hasDependency(projectRoot, name) {
   }
 }
 
-// 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;
-    }
-  }
-  return filtered;
-}
-
 // src/utils/update-gitignore.ts
 import * as fs15 from "fs";
 import * as path15 from "path";
@@ -2819,7 +2394,7 @@ function updateGitignore(projectRoot) {
 // src/commands/init-hooks.ts
 import * as fs17 from "fs";
 import * as path17 from "path";
-import chalk10 from "chalk";
+import chalk11 from "chalk";
 import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
 
 // src/commands/resolve-typecheck.ts
@@ -2864,13 +2439,13 @@ function setupPreCommitHook(projectRoot) {
   const lefthookPath = path17.join(projectRoot, "lefthook.yml");
   if (fs17.existsSync(lefthookPath)) {
     addLefthookPreCommit(lefthookPath);
-    console.log(`  ${chalk10.green("\u2713")} lefthook.yml \u2014 added viberails pre-commit`);
+    console.log(`  ${chalk11.green("\u2713")} lefthook.yml \u2014 added viberails pre-commit`);
     return "lefthook.yml";
   }
   const huskyDir = path17.join(projectRoot, ".husky");
   if (fs17.existsSync(huskyDir)) {
     writeHuskyPreCommit(huskyDir);
-    console.log(`  ${chalk10.green("\u2713")} .husky/pre-commit \u2014 added viberails check`);
+    console.log(`  ${chalk11.green("\u2713")} .husky/pre-commit \u2014 added viberails check`);
     return ".husky/pre-commit";
   }
   const gitDir = path17.join(projectRoot, ".git");
@@ -2880,7 +2455,7 @@ function setupPreCommitHook(projectRoot) {
       fs17.mkdirSync(hooksDir, { recursive: true });
     }
     writeGitHookPreCommit(hooksDir);
-    console.log(`  ${chalk10.green("\u2713")} .git/hooks/pre-commit`);
+    console.log(`  ${chalk11.green("\u2713")} .git/hooks/pre-commit`);
     return ".git/hooks/pre-commit";
   }
   return void 0;
@@ -2941,9 +2516,9 @@ function setupClaudeCodeHook(projectRoot) {
       settings = JSON.parse(fs17.readFileSync(settingsPath, "utf-8"));
     } catch {
       console.warn(
-        `  ${chalk10.yellow("!")} .claude/settings.json contains invalid JSON \u2014 skipping hook setup`
+        `  ${chalk11.yellow("!")} .claude/settings.json contains invalid JSON \u2014 skipping hook setup`
       );
-      console.warn(`  Fix the JSON manually, then re-run ${chalk10.cyan("viberails init --force")}`);
+      console.warn(`  Fix the JSON manually, then re-run ${chalk11.cyan("viberails init --force")}`);
       return;
     }
   }
@@ -2966,7 +2541,7 @@ function setupClaudeCodeHook(projectRoot) {
   settings.hooks = hooks;
   fs17.writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}
 `);
-  console.log(`  ${chalk10.green("\u2713")} .claude/settings.json \u2014 added viberails PostToolUse hook`);
+  console.log(`  ${chalk11.green("\u2713")} .claude/settings.json \u2014 added viberails PostToolUse hook`);
 }
 function setupClaudeMdReference(projectRoot) {
   const claudeMdPath = path17.join(projectRoot, "CLAUDE.md");
@@ -2978,7 +2553,7 @@ function setupClaudeMdReference(projectRoot) {
   const ref = "\n@.viberails/context.md\n";
   const prefix = content.length === 0 ? "" : content.trimEnd();
   fs17.writeFileSync(claudeMdPath, prefix + ref);
-  console.log(`  ${chalk10.green("\u2713")} CLAUDE.md \u2014 added @.viberails/context.md reference`);
+  console.log(`  ${chalk11.green("\u2713")} CLAUDE.md \u2014 added @.viberails/context.md reference`);
 }
 function setupGithubAction(projectRoot, packageManager, options) {
   const workflowDir = path17.join(projectRoot, ".github", "workflows");
@@ -3064,7 +2639,7 @@ ${cmd}
 // src/commands/init-hooks-extra.ts
 import * as fs18 from "fs";
 import * as path18 from "path";
-import chalk11 from "chalk";
+import chalk12 from "chalk";
 import { parse as parseYaml2, stringify as stringifyYaml2 } from "yaml";
 function addPreCommitStep(projectRoot, name, command, marker, lefthookExtra) {
   const lefthookPath = path18.join(projectRoot, "lefthook.yml");
@@ -3124,12 +2699,12 @@ ${command}
 function setupTypecheckHook(projectRoot, packageManager) {
   const resolved = resolveTypecheckCommand(projectRoot, packageManager);
   if (!resolved.command) {
-    console.log(`  ${chalk11.yellow("!")} Skipped typecheck hook: ${resolved.reason}`);
+    console.log(`  ${chalk12.yellow("!")} Skipped typecheck hook: ${resolved.reason}`);
     return void 0;
   }
   const target = addPreCommitStep(projectRoot, "typecheck", resolved.command, "typecheck");
   if (target) {
-    console.log(`  ${chalk11.green("\u2713")} ${target} \u2014 added typecheck (${resolved.label})`);
+    console.log(`  ${chalk12.green("\u2713")} ${target} \u2014 added typecheck (${resolved.label})`);
   }
   return target;
 }
@@ -3150,7 +2725,7 @@ function setupLintHook(projectRoot, linter) {
   }
   const target = addPreCommitStep(projectRoot, "lint", command, linter, lefthookExtra);
   if (target) {
-    console.log(`  ${chalk11.green("\u2713")} ${target} \u2014 added ${linterName} lint check`);
+    console.log(`  ${chalk12.green("\u2713")} ${target} \u2014 added ${linterName} lint check`);
   }
   return target;
 }
@@ -3186,31 +2761,34 @@ function setupSelectedIntegrations(projectRoot, integrations, opts) {
   return created;
 }
 
-// src/commands/init.ts
-var CONFIG_FILE5 = "viberails.config.json";
+// src/commands/init-non-interactive.ts
+import * as fs19 from "fs";
+import * as path19 from "path";
+import * as clack3 from "@clack/prompts";
+import { compactConfig as compactConfig3, generateConfig } from "@viberails/config";
+import { scan as scan2 } from "@viberails/scanner";
+import chalk13 from "chalk";
+
+// 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;
+    }
+  }
+  return filtered;
+}
+
+// src/commands/init-non-interactive.ts
 function getExemptedPackages(config) {
   return config.packages.filter((pkg) => pkg.rules?.testCoverage === 0 && pkg.path !== ".").map((pkg) => pkg.path);
 }
-async function initCommand(options, cwd) {
-  const projectRoot = findProjectRoot(cwd ?? process.cwd());
-  if (!projectRoot) {
-    throw new Error(
-      "No package.json found. Make sure you are inside a JS/TS project, then run:\n  npx viberails"
-    );
-  }
-  const configPath = path19.join(projectRoot, CONFIG_FILE5);
-  if (fs19.existsSync(configPath) && !options.force) {
-    console.log(
-      `${chalk12.yellow("!")} viberails is already initialized.
-  Run ${chalk12.cyan("viberails config")} to edit rules, ${chalk12.cyan("viberails sync")} to update, or ${chalk12.cyan("viberails init --force")} to start fresh.`
-    );
-    return;
-  }
-  if (options.yes) return initNonInteractive(projectRoot, configPath);
-  await initInteractive(projectRoot, configPath, options);
-}
 async function initNonInteractive(projectRoot, configPath) {
-  const s = clack8.spinner();
+  const s = clack3.spinner();
   s.start("Scanning project...");
   const scanResult = await scan2(projectRoot);
   const config = generateConfig(scanResult);
@@ -3225,11 +2803,11 @@ async function initNonInteractive(projectRoot, configPath) {
   const exempted = getExemptedPackages(config);
   if (exempted.length > 0) {
     console.log(
-      `  ${chalk12.dim("Auto-exempted from coverage:")} ${exempted.join(", ")} ${chalk12.dim("(types-only)")}`
+      `  ${chalk13.dim("Auto-exempted from coverage:")} ${exempted.join(", ")} ${chalk13.dim("(types-only)")}`
     );
   }
   if (config.packages.length > 1) {
-    const bs = clack8.spinner();
+    const bs = clack3.spinner();
     bs.start("Building import graph...");
     const { buildImportGraph, inferBoundaries } = await import("@viberails/graph");
     const packages = resolveWorkspacePackages(projectRoot, config.packages);
@@ -3262,14 +2840,14 @@ async function initNonInteractive(projectRoot, configPath) {
   const hookManager = detectHookManager(projectRoot);
   const hasHookManager = hookManager === "Lefthook" || hookManager === "Husky";
   const preCommitTarget = hasHookManager ? setupPreCommitHook(projectRoot) : void 0;
-  const ok = chalk12.green("\u2713");
+  const ok = chalk13.green("\u2713");
   const created = [
     `${ok} ${path19.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}` : `${chalk12.yellow("!")} pre-commit hook skipped (install lefthook or husky)`,
+    preCommitTarget ? `${ok} ${preCommitTarget}` : `${chalk13.yellow("!")} pre-commit hook skipped (install lefthook or husky)`,
     actionTarget ? `${ok} ${actionTarget} \u2014 blocks PRs on violations` : ""
   ].filter(Boolean);
   if (hasHookManager && isTypeScript) setupTypecheckHook(projectRoot, rootPkgPm);
@@ -3278,39 +2856,93 @@ async function initNonInteractive(projectRoot, configPath) {
 Created:
 ${created.map((f) => `  ${f}`).join("\n")}`);
 }
+
+// src/commands/init.ts
+var CONFIG_FILE5 = "viberails.config.json";
+function getExemptedPackages2(config) {
+  return config.packages.filter((pkg) => pkg.rules?.testCoverage === 0 && pkg.path !== ".").map((pkg) => pkg.path);
+}
+async function initCommand(options, cwd) {
+  const projectRoot = findProjectRoot(cwd ?? process.cwd());
+  if (!projectRoot) {
+    throw new Error(
+      "No package.json found. Make sure you are inside a JS/TS project, then run:\n  npx viberails"
+    );
+  }
+  const configPath = path20.join(projectRoot, CONFIG_FILE5);
+  if (fs20.existsSync(configPath) && !options.force) {
+    if (!options.yes) {
+      return initInteractive(projectRoot, configPath, options);
+    }
+    console.log(
+      `${chalk14.yellow("!")} viberails is already initialized.
+  Run ${chalk14.cyan("viberails")} to review or edit the existing setup, ${chalk14.cyan("viberails sync")} to update generated files, or ${chalk14.cyan("viberails init --force")} to replace it.`
+    );
+    return;
+  }
+  if (options.yes) return initNonInteractive(projectRoot, configPath);
+  await initInteractive(projectRoot, configPath, options);
+}
 async function initInteractive(projectRoot, configPath, options) {
-  clack8.intro("viberails");
-  if (fs19.existsSync(configPath) && options.force) {
+  clack4.intro("viberails");
+  const replacingExistingConfig = fs20.existsSync(configPath);
+  if (fs20.existsSync(configPath) && !options.force) {
+    const action = await promptExistingConfigAction(path20.basename(configPath));
+    if (action === "cancel") {
+      clack4.outro("Aborted. No files were written.");
+      return;
+    }
+    if (action === "edit") {
+      await configCommand({ suppressIntro: true }, projectRoot);
+      return;
+    }
+    options.force = true;
+  }
+  if (fs20.existsSync(configPath) && options.force) {
     const replace = await confirmDangerous(
-      `${path19.basename(configPath)} already exists and will be replaced. Continue?`
+      `${path20.basename(configPath)} already exists and will be replaced. Continue?`
     );
     if (!replace) {
-      clack8.outro("Aborted. No files were written.");
+      clack4.outro("Aborted. No files were written.");
       return;
     }
   }
-  const s = clack8.spinner();
+  const s = clack4.spinner();
   s.start("Scanning project...");
-  const scanResult = await scan2(projectRoot);
-  const config = generateConfig(scanResult);
+  const scanResult = await scan3(projectRoot);
+  const config = generateConfig2(scanResult);
   s.stop("Scan complete");
   if (scanResult.statistics.totalFiles === 0) {
-    clack8.log.warn(
+    clack4.log.warn(
       "No source files detected. Try running from the project root,\nor check that source files exist. Run viberails sync after adding files."
     );
   }
-  clack8.note(formatScanResultsText(scanResult), "Scan results");
-  const exemptedPkgs = getExemptedPackages(config);
-  displayInitSummary(config, exemptedPkgs);
-  const decision = await promptInitDecision();
+  const exemptedPkgs = getExemptedPackages2(config);
+  let decision;
+  while (true) {
+    displayInitOverview(scanResult, config, exemptedPkgs);
+    const nextDecision = await promptInitDecision();
+    if (nextDecision === "review") {
+      clack4.note(formatScanResultsText(scanResult), "Detected details");
+      continue;
+    }
+    decision = nextDecision;
+    break;
+  }
   if (decision === "customize") {
+    const { resolveNamingDefault } = await import("./prompt-naming-default-AH54HEBC.js");
+    await resolveNamingDefault(config, scanResult);
     const rootPkg = config.packages.find((p) => p.path === ".") ?? config.packages[0];
     const overrides = await promptRuleMenu({
       maxFileLines: config.rules.maxFileLines,
+      maxTestFileLines: config.rules.maxTestFileLines,
       testCoverage: config.rules.testCoverage,
       enforceMissingTests: config.rules.enforceMissingTests,
       enforceNaming: config.rules.enforceNaming,
       fileNamingValue: rootPkg.conventions?.fileNaming,
+      componentNaming: rootPkg.conventions?.componentNaming,
+      hookNaming: rootPkg.conventions?.hookNaming,
+      importAlias: rootPkg.conventions?.importAlias,
       coverageSummaryPath: "coverage/coverage-summary.json",
       coverageCommand: config.defaults?.coverage?.command,
       packageOverrides: config.packages
@@ -3318,13 +2950,13 @@ async function initInteractive(projectRoot, configPath, options) {
     applyRuleOverrides(config, overrides);
   }
   if (config.packages.length > 1) {
-    clack8.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.",
+    clack4.note(
+      "Optional for monorepos. viberails can infer package boundaries\nfrom imports that already work today, so you start with rules\nthat match the current codebase.",
       "Boundaries"
     );
-    const shouldInfer = await confirm3("Infer boundary rules from import patterns?");
+    const shouldInfer = await confirm("Infer boundary rules from current import patterns?");
     if (shouldInfer) {
-      const bs = clack8.spinner();
+      const bs = clack4.spinner();
       bs.start("Building import graph...");
       const { buildImportGraph, inferBoundaries } = await import("@viberails/graph");
       const packages = resolveWorkspacePackages(projectRoot, config.packages);
@@ -3345,7 +2977,7 @@ async function initInteractive(projectRoot, configPath, options) {
   const coveragePrereqs = checkCoveragePrereqs(projectRoot, scanResult);
   const hasMissingPrereqs = coveragePrereqs.some((p) => !p.installed) || !hookManager;
   if (hasMissingPrereqs) {
-    clack8.log.info("Some dependencies are needed for full functionality.");
+    clack4.log.info("Some dependencies are needed for full functionality.");
   }
   const prereqResult = await promptMissingPrereqs(projectRoot, coveragePrereqs);
   if (prereqResult.disableCoverage) {
@@ -3358,46 +2990,50 @@ async function initInteractive(projectRoot, configPath, options) {
     packageManager: rootPkgStack?.packageManager?.split("@")[0],
     isWorkspace: config.packages.length > 1
   });
-  const shouldWrite = await confirm3("Write configuration and set up selected integrations?");
+  displaySetupPlan(config, integrations, {
+    replacingExistingConfig,
+    configFile: path20.basename(configPath)
+  });
+  const shouldWrite = await confirm("Apply this setup?");
   if (!shouldWrite) {
-    clack8.outro("Aborted. No files were written.");
+    clack4.outro("Aborted. No files were written.");
     return;
   }
-  const ws = clack8.spinner();
+  const ws = clack4.spinner();
   ws.start("Writing configuration...");
-  const compacted = compactConfig3(config);
-  fs19.writeFileSync(configPath, `${JSON.stringify(compacted, null, 2)}
+  const compacted = compactConfig4(config);
+  fs20.writeFileSync(configPath, `${JSON.stringify(compacted, null, 2)}
 `);
   writeGeneratedFiles(projectRoot, config, scanResult);
   updateGitignore(projectRoot);
   ws.stop("Configuration written");
-  const ok = chalk12.green("\u2713");
-  clack8.log.step(`${ok} ${path19.basename(configPath)}`);
-  clack8.log.step(`${ok} .viberails/context.md`);
-  clack8.log.step(`${ok} .viberails/scan-result.json`);
+  const ok = chalk14.green("\u2713");
+  clack4.log.step(`${ok} ${path20.basename(configPath)}`);
+  clack4.log.step(`${ok} .viberails/context.md`);
+  clack4.log.step(`${ok} .viberails/scan-result.json`);
   setupSelectedIntegrations(projectRoot, integrations, {
     linter: rootPkgStack?.linter?.split("@")[0],
     packageManager: rootPkgStack?.packageManager?.split("@")[0]
   });
-  clack8.outro(
+  clack4.outro(
     `Done! Next: review viberails.config.json, then run viberails check
-  ${chalk12.dim("Tip: use")} ${chalk12.cyan("viberails check --enforce")} ${chalk12.dim("in CI to block PRs on violations.")}`
+  ${chalk14.dim("Tip: use")} ${chalk14.cyan("viberails check --enforce")} ${chalk14.dim("in CI to block PRs on violations.")}`
   );
 }
 
 // src/commands/sync.ts
-import * as fs20 from "fs";
-import * as path20 from "path";
-import * as clack9 from "@clack/prompts";
-import { compactConfig as compactConfig4, loadConfig as loadConfig5, mergeConfig as mergeConfig2 } from "@viberails/config";
-import { scan as scan3 } from "@viberails/scanner";
-import chalk13 from "chalk";
+import * as fs21 from "fs";
+import * as path21 from "path";
+import * as clack5 from "@clack/prompts";
+import { compactConfig as compactConfig5, loadConfig as loadConfig5, mergeConfig as mergeConfig2 } from "@viberails/config";
+import { scan as scan4 } from "@viberails/scanner";
+import chalk15 from "chalk";
 var CONFIG_FILE6 = "viberails.config.json";
 var SCAN_RESULT_FILE2 = ".viberails/scan-result.json";
 function loadPreviousStats(projectRoot) {
-  const scanResultPath = path20.join(projectRoot, SCAN_RESULT_FILE2);
+  const scanResultPath = path21.join(projectRoot, SCAN_RESULT_FILE2);
   try {
-    const raw = fs20.readFileSync(scanResultPath, "utf-8");
+    const raw = fs21.readFileSync(scanResultPath, "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed?.statistics?.totalFiles !== void 0) {
       return parsed.statistics;
@@ -3414,17 +3050,17 @@ async function syncCommand(options, 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 = path20.join(projectRoot, CONFIG_FILE6);
+  const configPath = path21.join(projectRoot, CONFIG_FILE6);
   const existing = await loadConfig5(configPath);
   const previousStats = loadPreviousStats(projectRoot);
-  const s = clack9.spinner();
+  const s = clack5.spinner();
   s.start("Scanning project...");
-  const scanResult = await scan3(projectRoot);
+  const scanResult = await scan4(projectRoot);
   s.stop("Scan complete");
   const merged = mergeConfig2(existing, scanResult);
-  const compacted = compactConfig4(merged);
+  const compacted = compactConfig5(merged);
   const compactedJson = JSON.stringify(compacted, null, 2);
-  const rawDisk = fs20.readFileSync(configPath, "utf-8").trim();
+  const rawDisk = fs21.readFileSync(configPath, "utf-8").trim();
   const diskWithoutSync = rawDisk.replace(/"lastSync":\s*"[^"]*"/, '"lastSync": ""');
   const mergedWithoutSync = compactedJson.replace(/"lastSync":\s*"[^"]*"/, '"lastSync": ""');
   const configChanged = diskWithoutSync !== mergedWithoutSync;
@@ -3432,19 +3068,19 @@ async function syncCommand(options, cwd) {
   const statsDelta = previousStats ? formatStatsDelta(previousStats, scanResult.statistics) : void 0;
   if (changes.length > 0 || statsDelta) {
     console.log(`
-${chalk13.bold("Changes:")}`);
+${chalk15.bold("Changes:")}`);
     for (const change of changes) {
-      const icon = change.type === "removed" ? chalk13.red("-") : chalk13.green("+");
+      const icon = change.type === "removed" ? chalk15.red("-") : chalk15.green("+");
       console.log(`  ${icon} ${change.description}`);
     }
     if (statsDelta) {
-      console.log(`  ${chalk13.dim(statsDelta)}`);
+      console.log(`  ${chalk15.dim(statsDelta)}`);
     }
   }
   if (options?.interactive) {
-    clack9.intro("viberails sync (interactive)");
-    clack9.note(formatRulesText(merged).join("\n"), "Rules after sync");
-    const decision = await clack9.select({
+    clack5.intro("viberails sync (interactive)");
+    clack5.note(formatRulesText(merged).join("\n"), "Rules after sync");
+    const decision = await clack5.select({
       message: "How would you like to proceed?",
       options: [
         { value: "accept", label: "Accept changes" },
@@ -3454,47 +3090,51 @@ ${chalk13.bold("Changes:")}`);
     });
     assertNotCancelled(decision);
     if (decision === "cancel") {
-      clack9.outro("Sync cancelled. No files were written.");
+      clack5.outro("Sync cancelled. No files were written.");
       return;
     }
     if (decision === "customize") {
       const rootPkg = merged.packages.find((p) => p.path === ".") ?? merged.packages[0];
       const overrides = await promptRuleMenu({
         maxFileLines: merged.rules.maxFileLines,
+        maxTestFileLines: merged.rules.maxTestFileLines,
         testCoverage: merged.rules.testCoverage,
         enforceMissingTests: merged.rules.enforceMissingTests,
         enforceNaming: merged.rules.enforceNaming,
         fileNamingValue: rootPkg.conventions?.fileNaming,
+        componentNaming: rootPkg.conventions?.componentNaming,
+        hookNaming: rootPkg.conventions?.hookNaming,
+        importAlias: rootPkg.conventions?.importAlias,
         coverageSummaryPath: rootPkg.coverage?.summaryPath ?? "coverage/coverage-summary.json",
         coverageCommand: merged.defaults?.coverage?.command,
         packageOverrides: merged.packages
       });
       applyRuleOverrides(merged, overrides);
-      const recompacted = compactConfig4(merged);
-      fs20.writeFileSync(configPath, `${JSON.stringify(recompacted, null, 2)}
+      const recompacted = compactConfig5(merged);
+      fs21.writeFileSync(configPath, `${JSON.stringify(recompacted, null, 2)}
 `);
       writeGeneratedFiles(projectRoot, merged, scanResult);
-      clack9.log.success("Updated config with your customizations.");
-      clack9.outro("Done! Run viberails check to verify.");
+      clack5.log.success("Updated config with your customizations.");
+      clack5.outro("Done! Run viberails check to verify.");
       return;
     }
   }
-  fs20.writeFileSync(configPath, `${compactedJson}
+  fs21.writeFileSync(configPath, `${compactedJson}
 `);
   writeGeneratedFiles(projectRoot, merged, scanResult);
   console.log(`
-${chalk13.bold("Synced:")}`);
+${chalk15.bold("Synced:")}`);
   if (configChanged) {
-    console.log(`  ${chalk13.yellow("!")} ${CONFIG_FILE6} \u2014 updated (review changes)`);
+    console.log(`  ${chalk15.yellow("!")} ${CONFIG_FILE6} \u2014 updated (review changes)`);
   } else {
-    console.log(`  ${chalk13.green("\u2713")} ${CONFIG_FILE6} \u2014 unchanged`);
+    console.log(`  ${chalk15.green("\u2713")} ${CONFIG_FILE6} \u2014 unchanged`);
   }
-  console.log(`  ${chalk13.green("\u2713")} .viberails/context.md \u2014 regenerated`);
-  console.log(`  ${chalk13.green("\u2713")} .viberails/scan-result.json \u2014 updated`);
+  console.log(`  ${chalk15.green("\u2713")} .viberails/context.md \u2014 regenerated`);
+  console.log(`  ${chalk15.green("\u2713")} .viberails/scan-result.json \u2014 updated`);
 }
 
 // src/index.ts
-var VERSION = "0.6.3";
+var VERSION = "0.6.5";
 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) => {
@@ -3502,7 +3142,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(`${chalk14.red("Error:")} ${message}`);
+    console.error(`${chalk16.red("Error:")} ${message}`);
     process.exit(1);
   }
 });
@@ -3511,7 +3151,7 @@ program.command("sync").description("Re-scan and update generated files").option
     await syncCommand(options);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    console.error(`${chalk14.red("Error:")} ${message}`);
+    console.error(`${chalk16.red("Error:")} ${message}`);
     process.exit(1);
   }
 });
@@ -3520,7 +3160,7 @@ program.command("config").description("Interactively edit existing config rules"
     await configCommand(options);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    console.error(`${chalk14.red("Error:")} ${message}`);
+    console.error(`${chalk16.red("Error:")} ${message}`);
     process.exit(1);
   }
 });
@@ -3541,7 +3181,7 @@ program.command("check").description("Check files against enforced rules").optio
       process.exit(exitCode);
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
-      console.error(`${chalk14.red("Error:")} ${message}`);
+      console.error(`${chalk16.red("Error:")} ${message}`);
       process.exit(1);
     }
   }
@@ -3552,7 +3192,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(`${chalk14.red("Error:")} ${message}`);
+    console.error(`${chalk16.red("Error:")} ${message}`);
     process.exit(1);
   }
 });
@@ -3561,7 +3201,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(`${chalk14.red("Error:")} ${message}`);
+    console.error(`${chalk16.red("Error:")} ${message}`);
     process.exit(1);
   }
 });