viberails 0.6.5 → 0.6.7

package/dist/index.js

@@ -1,15 +1,4 @@
 #!/usr/bin/env node
-import {
-  assertNotCancelled,
-  confirm,
-  confirmDangerous,
-  getRootPackage,
-  promptExistingConfigAction,
-  promptInitDecision,
-  promptIntegrations,
-  promptRuleMenu,
-  spawnAsync
-} from "./chunk-XQKOK3FU.js";
 
 // src/index.ts
 import chalk16 from "chalk";
@@ -38,6 +27,656 @@ function findProjectRoot(startDir) {
   }
 }
 
+// src/utils/prompt.ts
+import * as clack5 from "@clack/prompts";
+
+// src/utils/prompt-rules.ts
+import * as clack4 from "@clack/prompts";
+
+// src/utils/get-root-package.ts
+function getRootPackage(packages) {
+  return packages.find((pkg) => pkg.path === ".") ?? packages[0];
+}
+
+// src/utils/prompt-menu-handlers.ts
+import * as clack3 from "@clack/prompts";
+
+// src/utils/prompt-package-overrides.ts
+import * as clack2 from "@clack/prompts";
+
+// src/utils/prompt-constants.ts
+var SENTINEL_DONE = "__done__";
+var SENTINEL_CLEAR = "__clear__";
+var SENTINEL_CUSTOM = "__custom__";
+var SENTINEL_NONE = "__none__";
+var SENTINEL_INHERIT = "__inherit__";
+var SENTINEL_SKIP = "__skip__";
+var HINT_NOT_SET = "not set";
+var HINT_NO_OVERRIDES = "no overrides";
+var HINT_AUTO_DETECT = "auto-detect";
+
+// src/utils/prompt-submenus.ts
+import * as clack from "@clack/prompts";
+var FILE_NAMING_OPTIONS = [
+  { value: "kebab-case", label: "kebab-case" },
+  { value: "camelCase", label: "camelCase" },
+  { value: "PascalCase", label: "PascalCase" },
+  { value: "snake_case", label: "snake_case" }
+];
+var COMPONENT_NAMING_OPTIONS = [
+  { value: "PascalCase", label: "PascalCase", hint: "MyComponent.tsx" },
+  { value: "camelCase", label: "camelCase", hint: "myComponent.tsx" }
+];
+var HOOK_NAMING_OPTIONS = [
+  { value: "useXxx", label: "useXxx", hint: "useAuth, useFormData" },
+  { value: "use-*", label: "use-*", hint: "use-auth, use-form-data" }
+];
+async function promptFileLimitsMenu(state) {
+  while (true) {
+    const choice = await clack.select({
+      message: "File limits",
+      options: [
+        { value: "maxFileLines", label: "Max file lines", hint: String(state.maxFileLines) },
+        {
+          value: "maxTestFileLines",
+          label: "Max test file lines",
+          hint: state.maxTestFileLines > 0 ? String(state.maxTestFileLines) : "0 (unlimited)"
+        },
+        { value: "back", label: "Back" }
+      ]
+    });
+    if (isCancelled(choice) || choice === "back") return;
+    if (choice === "maxFileLines") {
+      const result = await clack.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";
+        }
+      });
+      if (isCancelled(result)) continue;
+      state.maxFileLines = Number.parseInt(result, 10);
+    }
+    if (choice === "maxTestFileLines") {
+      const result = await clack.text({
+        message: "Maximum lines per test file (0 to disable)?",
+        initialValue: String(state.maxTestFileLines),
+        validate: (v) => {
+          if (typeof v !== "string") return "Enter a number (0 or positive)";
+          const n = Number.parseInt(v, 10);
+          if (Number.isNaN(n) || n < 0) return "Enter a number (0 or positive)";
+        }
+      });
+      if (isCancelled(result)) continue;
+      state.maxTestFileLines = Number.parseInt(result, 10);
+    }
+  }
+}
+async function promptNamingMenu(state) {
+  while (true) {
+    const options = [
+      {
+        value: "enforceNaming",
+        label: "Enforce file naming",
+        hint: state.enforceNaming ? "yes" : "no"
+      }
+    ];
+    if (state.enforceNaming) {
+      options.push({
+        value: "fileNaming",
+        label: "File naming convention",
+        hint: state.fileNamingValue ?? HINT_NOT_SET
+      });
+    }
+    options.push(
+      {
+        value: "componentNaming",
+        label: "Component naming",
+        hint: state.componentNaming ?? HINT_NOT_SET
+      },
+      {
+        value: "hookNaming",
+        label: "Hook naming",
+        hint: state.hookNaming ?? HINT_NOT_SET
+      },
+      {
+        value: "importAlias",
+        label: "Import alias",
+        hint: state.importAlias ?? HINT_NOT_SET
+      },
+      { value: "back", label: "Back" }
+    );
+    const choice = await clack.select({ message: "Naming & conventions", options });
+    if (isCancelled(choice) || choice === "back") return;
+    if (choice === "enforceNaming") {
+      const result = await clack.confirm({
+        message: state.fileNamingValue ? `Enforce file naming? (detected: ${state.fileNamingValue})` : "Enforce file naming?",
+        initialValue: state.enforceNaming
+      });
+      if (isCancelled(result)) continue;
+      if (result && !state.fileNamingValue) {
+        const selected = await clack.select({
+          message: "Which file naming convention should be enforced?",
+          options: [...FILE_NAMING_OPTIONS]
+        });
+        if (isCancelled(selected)) continue;
+        state.fileNamingValue = selected;
+      }
+      state.enforceNaming = result;
+    }
+    if (choice === "fileNaming") {
+      const selected = await clack.select({
+        message: "Which file naming convention should be enforced?",
+        options: [...FILE_NAMING_OPTIONS],
+        initialValue: state.fileNamingValue
+      });
+      if (isCancelled(selected)) continue;
+      state.fileNamingValue = selected;
+    }
+    if (choice === "componentNaming") {
+      const selected = await clack.select({
+        message: "Component naming convention",
+        options: [
+          ...COMPONENT_NAMING_OPTIONS,
+          { value: SENTINEL_CLEAR, label: "Clear (no convention)" }
+        ],
+        initialValue: state.componentNaming ?? SENTINEL_CLEAR
+      });
+      if (isCancelled(selected)) continue;
+      state.componentNaming = selected === SENTINEL_CLEAR ? void 0 : selected;
+    }
+    if (choice === "hookNaming") {
+      const selected = await clack.select({
+        message: "Hook naming convention",
+        options: [
+          ...HOOK_NAMING_OPTIONS,
+          { value: SENTINEL_CLEAR, label: "Clear (no convention)" }
+        ],
+        initialValue: state.hookNaming ?? SENTINEL_CLEAR
+      });
+      if (isCancelled(selected)) continue;
+      state.hookNaming = selected === SENTINEL_CLEAR ? void 0 : selected;
+    }
+    if (choice === "importAlias") {
+      const selected = await clack.select({
+        message: "Import alias pattern",
+        options: [
+          { value: "@/*", label: "@/*", hint: "import { x } from '@/utils'" },
+          { value: "~/*", label: "~/*", hint: "import { x } from '~/utils'" },
+          { value: SENTINEL_CUSTOM, label: "Custom..." },
+          { value: SENTINEL_CLEAR, label: "Clear (no alias)" }
+        ],
+        initialValue: state.importAlias ?? SENTINEL_CLEAR
+      });
+      if (isCancelled(selected)) continue;
+      if (selected === SENTINEL_CLEAR) {
+        state.importAlias = void 0;
+      } else if (selected === SENTINEL_CUSTOM) {
+        const result = await clack.text({
+          message: "Custom import alias (e.g. #/*)?",
+          initialValue: state.importAlias ?? "",
+          placeholder: "e.g. #/*",
+          validate: (v) => {
+            if (typeof v !== "string" || !v.trim()) return "Alias cannot be empty";
+            if (!/^[a-zA-Z@~#$][a-zA-Z0-9@~#$_-]*\/\*$/.test(v.trim()))
+              return "Must match pattern like @/*, ~/*, or #src/*";
+          }
+        });
+        if (isCancelled(result)) continue;
+        state.importAlias = result.trim();
+      } else {
+        state.importAlias = selected;
+      }
+    }
+  }
+}
+async function promptTestingMenu(state) {
+  while (true) {
+    const options = [
+      {
+        value: "enforceMissingTests",
+        label: "Enforce missing tests",
+        hint: state.enforceMissingTests ? "yes" : "no"
+      },
+      {
+        value: "testCoverage",
+        label: "Test coverage target",
+        hint: state.testCoverage === 0 ? "0 (disabled)" : `${state.testCoverage}%`
+      }
+    ];
+    if (state.testCoverage > 0) {
+      options.push(
+        {
+          value: "coverageSummaryPath",
+          label: "Coverage summary path",
+          hint: state.coverageSummaryPath
+        },
+        {
+          value: "coverageCommand",
+          label: "Coverage command",
+          hint: state.coverageCommand ?? "auto-detect from package.json test runner"
+        }
+      );
+    }
+    options.push({ value: "back", label: "Back" });
+    const choice = await clack.select({ message: "Testing & coverage", options });
+    if (isCancelled(choice) || choice === "back") return;
+    if (choice === "enforceMissingTests") {
+      const result = await clack.confirm({
+        message: "Require every source file to have a corresponding test file?",
+        initialValue: state.enforceMissingTests
+      });
+      if (isCancelled(result)) continue;
+      state.enforceMissingTests = result;
+    }
+    if (choice === "testCoverage") {
+      const result = await clack.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";
+        }
+      });
+      if (isCancelled(result)) continue;
+      state.testCoverage = Number.parseInt(result, 10);
+    }
+    if (choice === "coverageSummaryPath") {
+      const result = await clack.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";
+        }
+      });
+      if (isCancelled(result)) continue;
+      state.coverageSummaryPath = result.trim();
+    }
+    if (choice === "coverageCommand") {
+      const result = await clack.text({
+        message: "Coverage command (blank to auto-detect from package.json)?",
+        initialValue: state.coverageCommand ?? "",
+        placeholder: "(auto-detect from package.json test runner)"
+      });
+      if (isCancelled(result)) continue;
+      const trimmed = result.trim();
+      state.coverageCommand = trimmed.length > 0 ? trimmed : void 0;
+    }
+  }
+}
+
+// src/utils/prompt-package-overrides.ts
+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;
+    }
+    if (pkg.conventions && Object.keys(pkg.conventions).length === 0) {
+      delete pkg.conventions;
+    }
+  }
+  return packages;
+}
+function packageOverrideHint(pkg, defaults) {
+  const tags = [];
+  if (pkg.conventions?.fileNaming && pkg.conventions.fileNaming !== defaults.fileNamingValue) {
+    tags.push(pkg.conventions.fileNaming);
+  }
+  if (pkg.rules?.maxFileLines !== void 0 && pkg.rules.maxFileLines !== defaults.maxFileLines && pkg.rules.maxFileLines > 0) {
+    tags.push(`${pkg.rules.maxFileLines} lines`);
+  }
+  const coverage = pkg.rules?.testCoverage ?? defaults.testCoverage;
+  const isExempt = coverage === 0;
+  const nameSegments = pkg.name.replace(/^@[^/]+\//, "").split(/[-/]/);
+  const isTypesOnly = isExempt && nameSegments.some((s) => s === "types");
+  if (isExempt) {
+    tags.push(isTypesOnly ? "exempt (types-only)" : "exempt");
+  } else if (pkg.rules?.testCoverage !== void 0 && pkg.rules.testCoverage !== defaults.testCoverage) {
+    tags.push(`${coverage}%`);
+  }
+  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;
+  if (hasSummaryOverride) tags.push("summary override");
+  if (hasCommandOverride) tags.push("command override");
+  return tags.length > 0 ? tags.join(", ") : HINT_NO_OVERRIDES;
+}
+async function promptPackageOverrides(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 overrides",
+      options: [
+        ...editablePackages.map((pkg) => ({
+          value: pkg.path,
+          label: `${pkg.path} (${pkg.name})`,
+          hint: packageOverrideHint(pkg, defaults)
+        })),
+        { value: SENTINEL_DONE, label: "Done" }
+      ]
+    });
+    if (isCancelled(selectedPath) || selectedPath === SENTINEL_DONE) break;
+    const target = editablePackages.find((pkg) => pkg.path === selectedPath);
+    if (!target) continue;
+    await promptSinglePackageOverrides(target, defaults);
+    normalizePackageOverrides(editablePackages);
+  }
+  return normalizePackageOverrides(packages);
+}
+async function promptSinglePackageOverrides(target, defaults) {
+  while (true) {
+    const effectiveNaming = target.conventions?.fileNaming ?? defaults.fileNamingValue;
+    const effectiveMaxLines = target.rules?.maxFileLines ?? defaults.maxFileLines;
+    const effectiveCoverage = target.rules?.testCoverage ?? defaults.testCoverage;
+    const effectiveSummary = target.coverage?.summaryPath ?? defaults.coverageSummaryPath;
+    const effectiveCommand = target.coverage?.command ?? defaults.coverageCommand ?? HINT_AUTO_DETECT;
+    const hasNamingOverride = target.conventions?.fileNaming !== void 0 && target.conventions.fileNaming !== defaults.fileNamingValue;
+    const hasMaxLinesOverride = target.rules?.maxFileLines !== void 0 && target.rules.maxFileLines !== defaults.maxFileLines;
+    const namingHint = hasNamingOverride ? String(effectiveNaming) : `inherits: ${effectiveNaming ?? "not set"}`;
+    const maxLinesHint = hasMaxLinesOverride ? String(effectiveMaxLines) : `inherits: ${effectiveMaxLines}`;
+    const choice = await clack2.select({
+      message: `Edit overrides for ${target.path}`,
+      options: [
+        { value: "fileNaming", label: "File naming", hint: namingHint },
+        { value: "maxFileLines", label: "Max file lines", hint: maxLinesHint },
+        { value: "testCoverage", label: "Test coverage", hint: String(effectiveCoverage) },
+        { value: "summaryPath", label: "Coverage summary path", hint: effectiveSummary },
+        { value: "command", label: "Coverage command", hint: effectiveCommand },
+        { value: "reset", label: "Reset all overrides for this package" },
+        { value: "back", label: "Back to package list" }
+      ]
+    });
+    if (isCancelled(choice) || choice === "back") break;
+    if (choice === "fileNaming") {
+      const selected = await clack2.select({
+        message: `File naming for ${target.path}`,
+        options: [
+          ...FILE_NAMING_OPTIONS,
+          { value: SENTINEL_NONE, label: "(none \u2014 exempt from checks)" },
+          {
+            value: SENTINEL_INHERIT,
+            label: `Inherit default${defaults.fileNamingValue ? ` (${defaults.fileNamingValue})` : ""}`
+          }
+        ],
+        initialValue: target.conventions?.fileNaming ?? SENTINEL_INHERIT
+      });
+      if (isCancelled(selected)) continue;
+      if (selected === SENTINEL_INHERIT) {
+        if (target.conventions) delete target.conventions.fileNaming;
+      } else if (selected === SENTINEL_NONE) {
+        target.conventions = { ...target.conventions ?? {}, fileNaming: "" };
+      } else {
+        target.conventions = { ...target.conventions ?? {}, fileNaming: selected };
+      }
+    }
+    if (choice === "maxFileLines") {
+      const result = await clack2.text({
+        message: `Max file lines for ${target.path} (blank to inherit default)?`,
+        initialValue: target.rules?.maxFileLines !== void 0 ? String(target.rules.maxFileLines) : "",
+        placeholder: String(defaults.maxFileLines)
+      });
+      if (isCancelled(result)) continue;
+      const value = result.trim();
+      if (value.length === 0 || Number.parseInt(value, 10) === defaults.maxFileLines) {
+        if (target.rules) delete target.rules.maxFileLines;
+      } else {
+        target.rules = { ...target.rules ?? {}, maxFileLines: Number.parseInt(value, 10) };
+      }
+    }
+    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";
+        }
+      });
+      if (isCancelled(result)) continue;
+      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: "Path to coverage summary file (blank to inherit default)?",
+        initialValue: target.coverage?.summaryPath !== void 0 ? target.coverage.summaryPath : "",
+        placeholder: defaults.coverageSummaryPath
+      });
+      if (isCancelled(result)) continue;
+      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: "Coverage command (blank to auto-detect)?",
+        initialValue: target.coverage?.command !== void 0 ? target.coverage.command : "",
+        placeholder: defaults.coverageCommand ?? "(auto-detect from package.json test runner)"
+      });
+      if (isCancelled(result)) continue;
+      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.rules.maxFileLines;
+      }
+      delete target.coverage;
+      delete target.conventions;
+    }
+  }
+}
+
+// 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 fileLimitsHint2 = state.maxTestFileLines > 0 ? `max ${state.maxFileLines} lines, tests ${state.maxTestFileLines}` : `max ${state.maxFileLines} lines, test files unlimited`;
+  const namingHint = state.enforceNaming ? `${state.fileNamingValue ?? "not set"} (enforced)` : "not enforced";
+  const testingHint = state.testCoverage > 0 ? `${state.testCoverage}% coverage, missing tests ${state.enforceMissingTests ? "enforced" : "not enforced"}` : `coverage disabled, missing tests ${state.enforceMissingTests ? "enforced" : "not enforced"}`;
+  const options = [
+    { value: "fileLimits", label: "File limits", hint: fileLimitsHint2 },
+    { value: "naming", label: "Naming & conventions", hint: namingHint },
+    { value: "testing", label: "Testing & coverage", hint: testingHint }
+  ];
+  if (packageCount > 0) {
+    options.push({
+      value: "packageOverrides",
+      label: "Per-package 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 ? structuredClone(packages) : void 0;
+}
+async function handleMenuChoice(choice, state, defaults, root) {
+  if (choice === "reset") {
+    state.maxFileLines = defaults.maxFileLines;
+    state.maxTestFileLines = defaults.maxTestFileLines;
+    state.testCoverage = defaults.testCoverage;
+    state.enforceMissingTests = defaults.enforceMissingTests;
+    state.enforceNaming = defaults.enforceNaming;
+    state.fileNamingValue = defaults.fileNamingValue;
+    state.componentNaming = defaults.componentNaming;
+    state.hookNaming = defaults.hookNaming;
+    state.importAlias = defaults.importAlias;
+    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 === "fileLimits") {
+    await promptFileLimitsMenu(state);
+    return;
+  }
+  if (choice === "naming") {
+    await promptNamingMenu(state);
+    return;
+  }
+  if (choice === "testing") {
+    await promptTestingMenu(state);
+    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 promptPackageOverrides(state.packageOverrides, {
+        fileNamingValue: state.fileNamingValue,
+        maxFileLines: state.maxFileLines,
+        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;
+  }
+}
+
+// src/utils/prompt-rules.ts
+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,
+    maxTestFileLines: state.maxTestFileLines,
+    testCoverage: state.testCoverage,
+    enforceMissingTests: state.enforceMissingTests,
+    enforceNaming: state.enforceNaming,
+    fileNamingValue: state.fileNamingValue,
+    componentNaming: state.componentNaming,
+    hookNaming: state.hookNaming,
+    importAlias: state.importAlias,
+    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);
+  }
+}
+function isCancelled(value) {
+  return clack5.isCancel(value);
+}
+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 promptExistingConfigAction(configFile) {
+  const result = await clack5.select({
+    message: `${configFile} already exists. What do you want to do?`,
+    options: [
+      {
+        value: "edit",
+        label: "Edit existing config",
+        hint: "open the current rules and save updates in place"
+      },
+      {
+        value: "replace",
+        label: "Replace with a fresh scan",
+        hint: "re-scan the project and overwrite the current config"
+      },
+      {
+        value: "cancel",
+        label: "Cancel",
+        hint: "leave the current setup unchanged"
+      }
+    ]
+  });
+  assertNotCancelled(result);
+  return result;
+}
+
 // src/utils/resolve-workspace-packages.ts
 import * as fs2 from "fs";
 import * as path2 from "path";
@@ -142,7 +781,7 @@ ${chalk.bold("Inferred boundary rules:")}
   console.log(`
   ${totalRules} denied`);
   console.log("");
-  const shouldSave = await confirm("Save to viberails.config.json?");
+  const shouldSave = await confirm3("Save to viberails.config.json?");
   if (shouldSave) {
     config.boundaries = inferred;
     config.rules.enforceBoundaries = true;
@@ -741,9 +1380,9 @@ async function checkCommand(options, cwd) {
   }
   const violations = [];
   const severity = options.enforce ? "error" : "warn";
-  const log5 = options.format !== "json" && !options.hook && !options.quiet ? (msg) => process.stderr.write(chalk3.dim(msg)) : () => {
+  const log9 = options.format !== "json" && !options.hook && !options.quiet ? (msg) => process.stderr.write(chalk3.dim(msg)) : () => {
   };
-  log5("  Checking files...");
+  log9("  Checking files...");
   for (const file of filesToCheck) {
     const absPath = path7.isAbsolute(file) ? file : path7.join(projectRoot, file);
     const relPath = path7.relative(projectRoot, absPath);
@@ -776,9 +1415,9 @@ async function checkCommand(options, cwd) {
       }
     }
   }
-  log5(" done\n");
+  log9(" done\n");
   if (!options.files) {
-    log5("  Checking missing tests...");
+    log9("  Checking missing tests...");
     const testViolations = checkMissingTests(projectRoot, config, severity);
     if (options.staged) {
       const stagedSet = new Set(filesToCheck);
@@ -791,14 +1430,14 @@ async function checkCommand(options, cwd) {
     } else {
       violations.push(...testViolations);
     }
-    log5(" done\n");
+    log9(" done\n");
   }
   if (!options.files && !options.staged && !options.diffBase) {
-    log5("  Running test coverage...\n");
+    log9("  Running test coverage...\n");
     const coverageViolations = checkCoverage(projectRoot, config, filesToCheck, {
       staged: options.staged,
       enforce: options.enforce,
-      onProgress: (pkg) => log5(`    Coverage: ${pkg}...
+      onProgress: (pkg) => log9(`    Coverage: ${pkg}...
 `)
     });
     violations.push(...coverageViolations);
@@ -823,7 +1462,7 @@ async function checkCommand(options, cwd) {
         severity
       });
     }
-    log5(`  Boundary check: ${graph.nodes.length} files in ${Date.now() - startTime}ms
+    log9(`  Boundary check: ${graph.nodes.length} files in ${Date.now() - startTime}ms
 `);
   }
   if (options.format === "json") {
@@ -899,7 +1538,7 @@ async function hookCheckCommand(cwd) {
 // src/commands/config.ts
 import * as fs10 from "fs";
 import * as path9 from "path";
-import * as clack from "@clack/prompts";
+import * as clack6 from "@clack/prompts";
 import { compactConfig as compactConfig2, loadConfig as loadConfig3, mergeConfig } from "@viberails/config";
 import { scan } from "@viberails/scanner";
 import chalk6 from "chalk";
@@ -1544,11 +2183,11 @@ async function configCommand(options, cwd) {
     return;
   }
   if (!options.suppressIntro) {
-    clack.intro("viberails config");
+    clack6.intro("viberails config");
   }
   const config = await loadConfig3(configPath);
   let scanResult = options.rescan ? await rescanAndMerge(projectRoot, config) : void 0;
-  clack.note(formatRulesText(config).join("\n"), "Current rules");
+  clack6.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,
@@ -1566,9 +2205,9 @@ async function configCommand(options, cwd) {
   });
   applyRuleOverrides(config, overrides);
   if (options.rescan && config.packages.length > 1) {
-    const shouldInfer = await confirm("Re-infer boundary rules from import patterns?");
+    const shouldInfer = await confirm3("Re-infer boundary rules from import patterns?");
     if (shouldInfer) {
-      const bs = clack.spinner();
+      const bs = clack6.spinner();
       bs.start("Building import graph...");
       const { buildImportGraph, inferBoundaries } = await import("@viberails/graph");
       const packages = resolveWorkspacePackages(projectRoot, config.packages);
@@ -1584,31 +2223,31 @@ async function configCommand(options, cwd) {
       }
     }
   }
-  const shouldWrite = await confirm("Save updated configuration?");
+  const shouldWrite = await confirm3("Save updated configuration?");
   if (!shouldWrite) {
-    clack.outro("No changes written.");
+    clack6.outro("No changes written.");
     return;
   }
   const compacted = compactConfig2(config);
   fs10.writeFileSync(configPath, `${JSON.stringify(compacted, null, 2)}
 `);
   if (!scanResult) {
-    const s = clack.spinner();
+    const s = clack6.spinner();
     s.start("Scanning for context generation...");
     scanResult = await scan(projectRoot);
     s.stop("Scan complete");
   }
   writeGeneratedFiles(projectRoot, config, scanResult);
-  clack.log.success(
+  clack6.log.success(
     `Updated:
   ${CONFIG_FILE3}
   .viberails/context.md
   .viberails/scan-result.json`
   );
-  clack.outro("Done! Run viberails check to verify.");
+  clack6.outro("Done! Run viberails check to verify.");
 }
 async function rescanAndMerge(projectRoot, config) {
-  const s = clack.spinner();
+  const s = clack6.spinner();
   s.start("Re-scanning project...");
   const scanResult = await scan(projectRoot);
   const merged = mergeConfig(config, scanResult);
@@ -1619,9 +2258,9 @@ async function rescanAndMerge(projectRoot, config) {
       const icon = c.type === "removed" ? "-" : "+";
       return `${icon} ${c.description}`;
     }).join("\n");
-    clack.note(changeLines, "Changes detected");
+    clack6.note(changeLines, "Changes detected");
   } else {
-    clack.log.info("No new changes detected from scan.");
+    clack6.log.info("No new changes detected from scan.");
   }
   Object.assign(config, merged);
   return scanResult;
@@ -2115,159 +2754,42 @@ ${chalk8.yellow("!")} No safe fixes to apply. Resolve aliased imports first.`);
 }
 
 // src/commands/init.ts
-import * as fs20 from "fs";
-import * as path20 from "path";
-import * as clack4 from "@clack/prompts";
+import * as fs21 from "fs";
+import * as path21 from "path";
+import * as clack13 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";
+// src/utils/check-prerequisites.ts
+import * as fs14 from "fs";
+import * as path14 from "path";
+import * as clack7 from "@clack/prompts";
 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
+
+// src/utils/spawn-async.ts
+import { spawn } from "child_process";
+function spawnAsync(command, cwd) {
+  return new Promise((resolve4) => {
+    const child = spawn(command, { cwd, shell: true, stdio: "pipe" });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (d) => {
+      stdout += d.toString();
+    });
+    child.stderr.on("data", (d) => {
+      stderr += d.toString();
+    });
+    child.on("close", (status) => {
+      resolve4({ status, stdout, stderr });
+    });
+    child.on("error", () => {
+      resolve4({ status: 1, stdout, stderr });
+    });
   });
-  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 * as fs14 from "fs";
-import * as path14 from "path";
-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);
@@ -2298,113 +2820,572 @@ 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(`  ${chalk10.yellow("!")} ${m.label} not installed${suffix}`);
+    console.log(`  ${chalk9.yellow("!")} ${m.label} not installed${suffix}`);
     if (m.installCommand) {
-      console.log(`    Install: ${chalk10.cyan(m.installCommand)}`);
+      console.log(`    Install: ${chalk9.cyan(m.installCommand)}`);
     }
   }
 }
-async function promptMissingPrereqs(projectRoot, prereqs) {
-  const missing = prereqs.filter((p) => !p.installed);
-  if (missing.length === 0) return { disableCoverage: false };
-  const prereqLines = prereqs.map((p) => {
-    if (p.installed) return `\u2713 ${p.label}`;
-    const detail = p.affectedPackages ? `needed by: ${p.affectedPackages.join(", ")}` : p.reason;
-    return `\u2717 ${p.label} \u2014 ${detail}`;
-  }).join("\n");
-  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 clack2.select({
-      message,
+function planCoverageInstall(prereqs) {
+  const missing = prereqs.find((p) => !p.installed && p.installCommand);
+  if (!missing?.installCommand) return void 0;
+  return {
+    label: missing.label,
+    command: missing.installCommand
+  };
+}
+function hasDependency(projectRoot, name) {
+  try {
+    const pkgPath = path14.join(projectRoot, "package.json");
+    const pkg = JSON.parse(fs14.readFileSync(pkgPath, "utf-8"));
+    return !!(pkg.devDependencies?.[name] || pkg.dependencies?.[name]);
+  } catch {
+    return false;
+  }
+}
+
+// src/utils/deferred-install.ts
+import * as clack8 from "@clack/prompts";
+async function executeDeferredInstalls(projectRoot, installs) {
+  if (installs.length === 0) return 0;
+  let successCount = 0;
+  for (const install of installs) {
+    const s = clack8.spinner();
+    s.start(`Installing ${install.label}...`);
+    const result = await spawnAsync(install.command, projectRoot);
+    if (result.status === 0) {
+      s.stop(`Installed ${install.label}`);
+      install.onSuccess?.();
+      successCount++;
+    } else {
+      s.stop(`Failed to install ${install.label}`);
+      clack8.log.warn(`Install manually: ${install.command}`);
+      install.onFailure?.();
+    }
+  }
+  return successCount;
+}
+
+// src/utils/prompt-main-menu.ts
+import * as clack11 from "@clack/prompts";
+
+// src/utils/prompt-main-menu-handlers.ts
+import * as clack10 from "@clack/prompts";
+
+// src/utils/prompt-integrations.ts
+import * as fs15 from "fs";
+import * as path15 from "path";
+import * as clack9 from "@clack/prompts";
+function buildLefthookInstallCommand(pm, isWorkspace) {
+  if (pm === "yarn") return "yarn add -D lefthook";
+  if (pm === "pnpm") return `pnpm add -D${isWorkspace ? " -w" : ""} lefthook`;
+  if (pm === "npm") return "npm install -D lefthook";
+  return `${pm} add -D lefthook`;
+}
+async function promptIntegrationsDeferred(hookManager, tools, packageManager, isWorkspace, projectRoot) {
+  const options = [];
+  const needsLefthook = !hookManager;
+  if (needsLefthook) {
+    const pm = packageManager ?? "npm";
+    options.push({
+      value: "installLefthook",
+      label: "Install Lefthook",
+      hint: `after final confirmation \u2014 ${buildLefthookInstallCommand(pm, isWorkspace)}`
+    });
+  }
+  const hookLabel = hookManager ? `Pre-commit hook (${hookManager})` : "Pre-commit hook";
+  const hookHint = needsLefthook ? "uses Lefthook if installed above, otherwise local git hook" : "runs viberails checks when you commit";
+  options.push({ 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 = options.map((o) => o.value);
+  const result = await clack9.multiselect({
+    message: "Integrations",
+    options,
+    initialValues,
+    required: false
+  });
+  assertNotCancelled(result);
+  let lefthookInstall;
+  if (needsLefthook && result.includes("installLefthook")) {
+    const pm = packageManager ?? "npm";
+    lefthookInstall = {
+      label: "Lefthook",
+      command: buildLefthookInstallCommand(pm, isWorkspace),
+      onSuccess: projectRoot ? () => {
+        const ymlPath = path15.join(projectRoot, "lefthook.yml");
+        if (!fs15.existsSync(ymlPath)) {
+          fs15.writeFileSync(ymlPath, "# Generated by viberails\n");
+        }
+      } : void 0
+    };
+  }
+  return {
+    choice: {
+      preCommitHook: result.includes("preCommit"),
+      claudeCodeHook: result.includes("claude"),
+      claudeMdRef: result.includes("claudeMd"),
+      githubAction: result.includes("githubAction"),
+      typecheckHook: result.includes("typecheck"),
+      lintHook: result.includes("lint")
+    },
+    lefthookInstall
+  };
+}
+
+// src/utils/prompt-main-menu-handlers.ts
+async function handleAdvancedNaming(config) {
+  const rootPkg = getRootPackage(config.packages);
+  const state = {
+    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
+  };
+  await promptNamingMenu(state);
+  rootPkg.conventions = rootPkg.conventions ?? {};
+  config.rules.enforceNaming = state.enforceNaming;
+  if (state.fileNamingValue) {
+    rootPkg.conventions.fileNaming = state.fileNamingValue;
+  } else {
+    delete rootPkg.conventions.fileNaming;
+  }
+  rootPkg.conventions.componentNaming = state.componentNaming || void 0;
+  rootPkg.conventions.hookNaming = state.hookNaming || void 0;
+  rootPkg.conventions.importAlias = state.importAlias || void 0;
+}
+async function handleFileNaming(config, scanResult) {
+  const isMonorepo = config.packages.length > 1;
+  if (isMonorepo) {
+    const pkgData = scanResult.packages.filter((p) => p.conventions.fileNaming && p.conventions.fileNaming.confidence !== "low").map((p) => ({
+      path: p.relativePath,
+      naming: p.conventions.fileNaming
+    }));
+    if (pkgData.length > 0) {
+      const lines = pkgData.map(
+        (p) => `${p.path}: ${p.naming.value} (${Math.round(p.naming.consistency)}%)`
+      );
+      clack10.note(lines.join("\n"), "Per-package file naming detected");
+    }
+  }
+  const namingOptions = FILE_NAMING_OPTIONS.map((opt) => {
+    if (isMonorepo) {
+      const pkgs = scanResult.packages.filter((p) => p.conventions.fileNaming?.value === opt.value);
+      const hint = pkgs.length > 0 ? `${pkgs.length} package${pkgs.length > 1 ? "s" : ""}` : void 0;
+      return { value: opt.value, label: opt.label, hint };
+    }
+    return { value: opt.value, label: opt.label };
+  });
+  const rootPkg = getRootPackage(config.packages);
+  const selected = await clack10.select({
+    message: isMonorepo ? "Default file naming convention" : "File naming convention",
+    options: [...namingOptions, { value: SENTINEL_SKIP, label: "Don't enforce" }],
+    initialValue: rootPkg.conventions?.fileNaming ?? SENTINEL_SKIP
+  });
+  if (isCancelled(selected)) return;
+  if (selected === SENTINEL_SKIP) {
+    config.rules.enforceNaming = false;
+    if (rootPkg.conventions) delete rootPkg.conventions.fileNaming;
+  } else {
+    config.rules.enforceNaming = true;
+    rootPkg.conventions = rootPkg.conventions ?? {};
+    rootPkg.conventions.fileNaming = selected;
+  }
+}
+async function handleMissingTests(config) {
+  const result = await clack10.confirm({
+    message: "Require every source file to have a test file?",
+    initialValue: config.rules.enforceMissingTests
+  });
+  if (isCancelled(result)) return;
+  config.rules.enforceMissingTests = result;
+}
+async function handleCoverage(config, state, opts) {
+  if (!opts.hasTestRunner) {
+    clack10.note(
+      "No test runner (vitest, jest, etc.) was detected.\nInstall one, then re-run viberails init to configure coverage.",
+      "Coverage inactive"
+    );
+    return;
+  }
+  const planned = planCoverageInstall(opts.coveragePrereqs);
+  if (planned) {
+    const choice = await clack10.select({
+      message: `${planned.label} is not installed. Needed for coverage checks.`,
       options: [
         {
           value: "install",
-          label: "Install now",
-          hint: m.installCommand
-        },
-        {
-          value: "disable",
-          label: "Disable coverage checks",
-          hint: "missing-test checks still stay active"
+          label: "Install (after final confirmation)",
+          hint: planned.command
         },
+        { value: "disable", label: "Disable coverage checks" },
         {
           value: "skip",
           label: "Skip for now",
-          hint: `install later: ${m.installCommand}`
+          hint: `install later: ${planned.command}`
         }
       ]
     });
-    assertNotCancelled(choice);
+    if (isCancelled(choice)) return;
+    state.deferredInstalls = state.deferredInstalls.filter((d) => d.command !== planned.command);
     if (choice === "install") {
-      const is = clack2.spinner();
-      is.start(`Installing ${m.label}...`);
-      const result = await spawnAsync(m.installCommand, projectRoot);
-      if (result.status === 0) {
-        is.stop(`Installed ${m.label}`);
-      } else {
-        is.stop(`Failed to install ${m.label}`);
-        clack2.log.warn(
-          `Install manually: ${m.installCommand}
-Coverage percentage checks will not work until the dependency is installed.`
-        );
-      }
+      planned.onFailure = () => {
+        config.rules.testCoverage = 0;
+      };
+      state.deferredInstalls.push(planned);
     } else if (choice === "disable") {
-      disableCoverage = true;
-      clack2.log.info("Coverage percentage checks disabled. Missing-test checks remain active.");
-    } else {
-      clack2.log.info(
-        `Coverage percentage checks will fail until ${m.label} is installed.
-Install later: ${m.installCommand}`
-      );
+      config.rules.testCoverage = 0;
+      return;
     }
   }
-  return { disableCoverage };
+  const result = await clack10.text({
+    message: "Test coverage target (0 = disable)?",
+    initialValue: String(config.rules.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";
+    }
+  });
+  if (isCancelled(result)) return;
+  config.rules.testCoverage = Number.parseInt(result, 10);
 }
-function hasDependency(projectRoot, name) {
+async function handlePackageOverrides(config) {
+  const rootPkg = getRootPackage(config.packages);
+  config.packages = await promptPackageOverrides(config.packages, {
+    fileNamingValue: rootPkg.conventions?.fileNaming,
+    maxFileLines: config.rules.maxFileLines,
+    testCoverage: config.rules.testCoverage,
+    coverageSummaryPath: rootPkg.coverage?.summaryPath ?? "coverage/coverage-summary.json",
+    coverageCommand: config.defaults?.coverage?.command
+  });
+  normalizePackageOverrides(config.packages);
+}
+async function handleBoundaries(config, state, opts) {
+  const shouldInfer = await clack10.confirm({
+    message: "Infer boundary rules from current import patterns?",
+    initialValue: false
+  });
+  if (isCancelled(shouldInfer)) return;
+  state.visited.boundaries = true;
+  if (!shouldInfer) {
+    config.rules.enforceBoundaries = false;
+    return;
+  }
+  const bs = clack10.spinner();
+  bs.start("Building import graph...");
   try {
-    const pkgPath = path14.join(projectRoot, "package.json");
-    const pkg = JSON.parse(fs14.readFileSync(pkgPath, "utf-8"));
-    return !!(pkg.devDependencies?.[name] || pkg.dependencies?.[name]);
-  } catch {
-    return false;
+    const { buildImportGraph, inferBoundaries } = await import("@viberails/graph");
+    const packages = resolveWorkspacePackages(opts.projectRoot, config.packages);
+    const graph = await buildImportGraph(opts.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;
+      const pkgCount = Object.keys(inferred.deny).length;
+      bs.stop(`Inferred ${denyCount} boundary rules across ${pkgCount} packages`);
+    } else {
+      bs.stop("No boundary rules inferred");
+    }
+  } catch (err) {
+    bs.stop("Failed to build import graph");
+    clack10.log.warn(`Boundary inference failed: ${err instanceof Error ? err.message : err}`);
+  }
+}
+async function handleIntegrations(state, opts) {
+  const result = await promptIntegrationsDeferred(
+    state.hookManager,
+    opts.tools,
+    opts.tools.packageManager,
+    opts.tools.isWorkspace,
+    opts.projectRoot
+  );
+  state.visited.integrations = true;
+  state.integrations = result.choice;
+  state.deferredInstalls = state.deferredInstalls.filter((d) => !d.command.includes("lefthook"));
+  if (result.lefthookInstall) {
+    state.deferredInstalls.push(result.lefthookInstall);
   }
 }
 
+// src/utils/prompt-main-menu-hints.ts
+import chalk10 from "chalk";
+function fileLimitsHint(config) {
+  const max = config.rules.maxFileLines;
+  const test = config.rules.maxTestFileLines;
+  return test > 0 ? `${max} lines, tests ${test}` : `${max} lines`;
+}
+function fileNamingHint(config, scanResult) {
+  const rootPkg = getRootPackage(config.packages);
+  const naming = rootPkg.conventions?.fileNaming;
+  if (!config.rules.enforceNaming) return "not enforced";
+  if (naming) {
+    const detected = scanResult.packages.some(
+      (p) => p.conventions.fileNaming?.value === naming && p.conventions.fileNaming.confidence === "high"
+    );
+    return detected ? `${naming} (detected)` : naming;
+  }
+  return "mixed \u2014 will not enforce if skipped";
+}
+function fileNamingStatus(config) {
+  if (!config.rules.enforceNaming) return "disabled";
+  const rootPkg = getRootPackage(config.packages);
+  return rootPkg.conventions?.fileNaming ? "ok" : "needs-input";
+}
+function missingTestsHint(config) {
+  if (!config.rules.enforceMissingTests) return "not enforced";
+  const rootPkg = getRootPackage(config.packages);
+  const pattern = rootPkg.structure?.testPattern;
+  return pattern ? `enforced (${pattern})` : "enforced";
+}
+function coverageHint(config, hasTestRunner) {
+  if (config.rules.testCoverage === 0) return "disabled";
+  if (!hasTestRunner)
+    return `${config.rules.testCoverage}% target (inactive \u2014 no test runner)`;
+  const isMonorepo = config.packages.length > 1;
+  if (isMonorepo) {
+    const withCov = config.packages.filter(
+      (p) => (p.rules?.testCoverage ?? config.rules.testCoverage) > 0
+    );
+    const exempt = config.packages.length - withCov.length;
+    return exempt > 0 ? `${config.rules.testCoverage}% (${withCov.length}/${config.packages.length} packages, ${exempt} exempt)` : `${config.rules.testCoverage}%`;
+  }
+  return `${config.rules.testCoverage}%`;
+}
+function advancedNamingHint(config) {
+  const rootPkg = getRootPackage(config.packages);
+  const parts = [];
+  if (rootPkg.conventions?.componentNaming)
+    parts.push(`${rootPkg.conventions.componentNaming} components`);
+  if (rootPkg.conventions?.hookNaming) parts.push(`${rootPkg.conventions.hookNaming} hooks`);
+  if (rootPkg.conventions?.importAlias) parts.push(rootPkg.conventions.importAlias);
+  return parts.length > 0 ? parts.join(", ") : "component, hook, and alias conventions";
+}
+function integrationsHint(state) {
+  if (!state.visited.integrations || !state.integrations)
+    return "not configured \u2014 select to set up";
+  const items = [];
+  if (state.integrations.preCommitHook) items.push("pre-commit");
+  if (state.integrations.typecheckHook) items.push("typecheck");
+  if (state.integrations.lintHook) items.push("lint");
+  if (state.integrations.claudeCodeHook) items.push("Claude");
+  if (state.integrations.claudeMdRef) items.push("CLAUDE.md");
+  if (state.integrations.githubAction) items.push("CI");
+  return items.length > 0 ? items.join(" \xB7 ") : "none selected";
+}
+function packageOverridesHint(config) {
+  const rootNaming = getRootPackage(config.packages).conventions?.fileNaming;
+  const editable = config.packages.filter((p) => p.path !== ".");
+  const customized = editable.filter(
+    (p) => p.rules || p.coverage || p.conventions?.fileNaming !== void 0 && p.conventions.fileNaming !== rootNaming
+  ).length;
+  return customized > 0 ? `${editable.length} packages (${customized} customized)` : `${editable.length} packages`;
+}
+function boundariesHint(config, state) {
+  if (!state.visited.boundaries || !config.rules.enforceBoundaries) return "not enabled";
+  const deny = config.boundaries?.deny;
+  if (!deny) return "enabled";
+  const ruleCount = Object.values(deny).reduce((s, a) => s + a.length, 0);
+  const pkgCount = Object.keys(deny).length;
+  return `${ruleCount} rules across ${pkgCount} packages`;
+}
+function advancedNamingStatus(config) {
+  const rootPkg = getRootPackage(config.packages);
+  const hasAny = !!rootPkg.conventions?.componentNaming || !!rootPkg.conventions?.hookNaming || !!rootPkg.conventions?.importAlias;
+  return hasAny ? "ok" : "unconfigured";
+}
+function packageOverridesStatus(config) {
+  const rootNaming = getRootPackage(config.packages).conventions?.fileNaming;
+  const editable = config.packages.filter((p) => p.path !== ".");
+  const customized = editable.some(
+    (p) => p.rules || p.coverage || p.conventions?.fileNaming !== void 0 && p.conventions.fileNaming !== rootNaming
+  );
+  return customized ? "ok" : "unconfigured";
+}
+function statusIcon(status) {
+  if (status === "ok") return chalk10.green("\u2713");
+  if (status === "needs-input") return chalk10.yellow("?");
+  if (status === "unconfigured") return chalk10.dim("-");
+  return chalk10.yellow("~");
+}
+function buildMainMenuOptions(config, scanResult, state) {
+  const namingStatus = fileNamingStatus(config);
+  const coverageStatus = config.rules.testCoverage === 0 ? "disabled" : !state.hasTestRunner ? "disabled" : "ok";
+  const missingTestsStatus = config.rules.enforceMissingTests ? "ok" : "disabled";
+  const options = [
+    {
+      value: "fileLimits",
+      label: `${statusIcon("ok")} Max file size`,
+      hint: fileLimitsHint(config)
+    },
+    {
+      value: "fileNaming",
+      label: `${statusIcon(namingStatus)} Default file naming`,
+      hint: fileNamingHint(config, scanResult)
+    },
+    {
+      value: "missingTests",
+      label: `${statusIcon(missingTestsStatus)} Missing tests`,
+      hint: missingTestsHint(config)
+    },
+    {
+      value: "coverage",
+      label: `${statusIcon(coverageStatus)} Coverage`,
+      hint: coverageHint(config, state.hasTestRunner)
+    },
+    {
+      value: "advancedNaming",
+      label: `${statusIcon(advancedNamingStatus(config))} Advanced naming`,
+      hint: advancedNamingHint(config)
+    }
+  ];
+  if (config.packages.length > 1) {
+    const bIcon = statusIcon(
+      state.visited.boundaries && config.rules.enforceBoundaries ? "ok" : "unconfigured"
+    );
+    const poIcon = statusIcon(packageOverridesStatus(config));
+    options.push(
+      {
+        value: "packageOverrides",
+        label: `${poIcon} Per-package overrides`,
+        hint: packageOverridesHint(config)
+      },
+      { value: "boundaries", label: `${bIcon} Boundaries`, hint: boundariesHint(config, state) }
+    );
+  }
+  const iIcon = state.visited.integrations ? statusIcon("ok") : statusIcon("unconfigured");
+  options.push(
+    { value: "integrations", label: `${iIcon} Integrations`, hint: integrationsHint(state) },
+    { value: "reset", label: "  Reset all to defaults" },
+    { value: "review", label: "  Review scan details" },
+    { value: "done", label: "  Done \u2014 write config" }
+  );
+  return options;
+}
+
+// src/utils/prompt-main-menu.ts
+async function promptMainMenu(config, scanResult, opts) {
+  const originalConfig = structuredClone(config);
+  const state = {
+    visited: { integrations: false, boundaries: false },
+    deferredInstalls: [],
+    hasTestRunner: opts.hasTestRunner,
+    hookManager: opts.hookManager
+  };
+  while (true) {
+    const options = buildMainMenuOptions(config, scanResult, state);
+    const choice = await clack11.select({ message: "Configure viberails", options });
+    assertNotCancelled(choice);
+    if (choice === "done") {
+      if (config.rules.enforceNaming && !getRootPackage(config.packages).conventions?.fileNaming) {
+        config.rules.enforceNaming = false;
+      }
+      break;
+    }
+    if (choice === "fileLimits") {
+      const s = {
+        maxFileLines: config.rules.maxFileLines,
+        maxTestFileLines: config.rules.maxTestFileLines
+      };
+      await promptFileLimitsMenu(s);
+      config.rules.maxFileLines = s.maxFileLines;
+      config.rules.maxTestFileLines = s.maxTestFileLines;
+    }
+    if (choice === "fileNaming") await handleFileNaming(config, scanResult);
+    if (choice === "missingTests") await handleMissingTests(config);
+    if (choice === "coverage") await handleCoverage(config, state, opts);
+    if (choice === "advancedNaming") await handleAdvancedNaming(config);
+    if (choice === "packageOverrides") await handlePackageOverrides(config);
+    if (choice === "boundaries") await handleBoundaries(config, state, opts);
+    if (choice === "integrations") await handleIntegrations(state, opts);
+    if (choice === "review") clack11.note(formatScanResultsText(scanResult), "Scan details");
+    if (choice === "reset") {
+      const confirmed = await clack11.confirm({
+        message: "Reset all settings to scan-detected defaults?",
+        initialValue: false
+      });
+      assertNotCancelled(confirmed);
+      if (confirmed) {
+        Object.assign(config, structuredClone(originalConfig));
+        state.deferredInstalls = [];
+        state.visited = { integrations: false, boundaries: false };
+        state.integrations = void 0;
+        clack11.log.info("Reset all settings to scan-detected defaults.");
+      }
+    }
+  }
+  return state;
+}
+
 // src/utils/update-gitignore.ts
-import * as fs15 from "fs";
-import * as path15 from "path";
+import * as fs16 from "fs";
+import * as path16 from "path";
 function updateGitignore(projectRoot) {
-  const gitignorePath = path15.join(projectRoot, ".gitignore");
+  const gitignorePath = path16.join(projectRoot, ".gitignore");
   let content = "";
-  if (fs15.existsSync(gitignorePath)) {
-    content = fs15.readFileSync(gitignorePath, "utf-8");
+  if (fs16.existsSync(gitignorePath)) {
+    content = fs16.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()}
 `;
-    fs15.writeFileSync(gitignorePath, `${prefix}${block}`);
+    fs16.writeFileSync(gitignorePath, `${prefix}${block}`);
   }
 }
 
 // src/commands/init-hooks.ts
-import * as fs17 from "fs";
-import * as path17 from "path";
+import * as fs18 from "fs";
+import * as path18 from "path";
 import chalk11 from "chalk";
 import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
 
 // src/commands/resolve-typecheck.ts
-import * as fs16 from "fs";
-import * as path16 from "path";
+import * as fs17 from "fs";
+import * as path17 from "path";
 function hasTurboTask(projectRoot, taskName) {
-  const turboPath = path16.join(projectRoot, "turbo.json");
-  if (!fs16.existsSync(turboPath)) return false;
+  const turboPath = path17.join(projectRoot, "turbo.json");
+  if (!fs17.existsSync(turboPath)) return false;
   try {
-    const turbo = JSON.parse(fs16.readFileSync(turboPath, "utf-8"));
+    const turbo = JSON.parse(fs17.readFileSync(turboPath, "utf-8"));
     const tasks = turbo.tasks ?? turbo.pipeline ?? {};
     return taskName in tasks;
   } catch {
@@ -2415,10 +3396,10 @@ function resolveTypecheckCommand(projectRoot, packageManager) {
   if (hasTurboTask(projectRoot, "typecheck")) {
     return { command: "npx turbo typecheck", label: "turbo typecheck" };
   }
-  const pkgJsonPath = path16.join(projectRoot, "package.json");
-  if (fs16.existsSync(pkgJsonPath)) {
+  const pkgJsonPath = path17.join(projectRoot, "package.json");
+  if (fs17.existsSync(pkgJsonPath)) {
     try {
-      const pkg = JSON.parse(fs16.readFileSync(pkgJsonPath, "utf-8"));
+      const pkg = JSON.parse(fs17.readFileSync(pkgJsonPath, "utf-8"));
       if (pkg.scripts?.typecheck) {
         const pm = packageManager ?? "npm";
         return { command: `${pm} run typecheck`, label: `${pm} run typecheck` };
@@ -2426,7 +3407,7 @@ function resolveTypecheckCommand(projectRoot, packageManager) {
     } catch {
     }
   }
-  if (fs16.existsSync(path16.join(projectRoot, "tsconfig.json"))) {
+  if (fs17.existsSync(path17.join(projectRoot, "tsconfig.json"))) {
     return { command: "npx tsc --noEmit", label: "tsc --noEmit" };
   }
   return {
@@ -2436,23 +3417,23 @@ function resolveTypecheckCommand(projectRoot, packageManager) {
 
 // src/commands/init-hooks.ts
 function setupPreCommitHook(projectRoot) {
-  const lefthookPath = path17.join(projectRoot, "lefthook.yml");
-  if (fs17.existsSync(lefthookPath)) {
+  const lefthookPath = path18.join(projectRoot, "lefthook.yml");
+  if (fs18.existsSync(lefthookPath)) {
     addLefthookPreCommit(lefthookPath);
     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)) {
+  const huskyDir = path18.join(projectRoot, ".husky");
+  if (fs18.existsSync(huskyDir)) {
     writeHuskyPreCommit(huskyDir);
     console.log(`  ${chalk11.green("\u2713")} .husky/pre-commit \u2014 added viberails check`);
     return ".husky/pre-commit";
   }
-  const gitDir = path17.join(projectRoot, ".git");
-  if (fs17.existsSync(gitDir)) {
-    const hooksDir = path17.join(gitDir, "hooks");
-    if (!fs17.existsSync(hooksDir)) {
-      fs17.mkdirSync(hooksDir, { recursive: true });
+  const gitDir = path18.join(projectRoot, ".git");
+  if (fs18.existsSync(gitDir)) {
+    const hooksDir = path18.join(gitDir, "hooks");
+    if (!fs18.existsSync(hooksDir)) {
+      fs18.mkdirSync(hooksDir, { recursive: true });
     }
     writeGitHookPreCommit(hooksDir);
     console.log(`  ${chalk11.green("\u2713")} .git/hooks/pre-commit`);
@@ -2461,11 +3442,11 @@ function setupPreCommitHook(projectRoot) {
   return void 0;
 }
 function writeGitHookPreCommit(hooksDir) {
-  const hookPath = path17.join(hooksDir, "pre-commit");
-  if (fs17.existsSync(hookPath)) {
-    const existing = fs17.readFileSync(hookPath, "utf-8");
+  const hookPath = path18.join(hooksDir, "pre-commit");
+  if (fs18.existsSync(hookPath)) {
+    const existing = fs18.readFileSync(hookPath, "utf-8");
     if (existing.includes("viberails")) return;
-    fs17.writeFileSync(
+    fs18.writeFileSync(
       hookPath,
       `${existing.trimEnd()}
 
@@ -2482,10 +3463,10 @@ if [ -x ./node_modules/.bin/viberails ]; then ./node_modules/.bin/viberails chec
     "if [ -x ./node_modules/.bin/viberails ]; then ./node_modules/.bin/viberails check --staged; else npx viberails check --staged; fi",
     ""
   ].join("\n");
-  fs17.writeFileSync(hookPath, script, { mode: 493 });
+  fs18.writeFileSync(hookPath, script, { mode: 493 });
 }
 function addLefthookPreCommit(lefthookPath) {
-  const content = fs17.readFileSync(lefthookPath, "utf-8");
+  const content = fs18.readFileSync(lefthookPath, "utf-8");
   if (content.includes("viberails")) return;
   const doc = parseYaml(content) ?? {};
   if (!doc["pre-commit"]) {
@@ -2497,23 +3478,23 @@ function addLefthookPreCommit(lefthookPath) {
   doc["pre-commit"].commands.viberails = {
     run: "if [ -x ./node_modules/.bin/viberails ]; then ./node_modules/.bin/viberails check --staged; else npx viberails check --staged; fi"
   };
-  fs17.writeFileSync(lefthookPath, stringifyYaml(doc));
+  fs18.writeFileSync(lefthookPath, stringifyYaml(doc));
 }
 function detectHookManager(projectRoot) {
-  if (fs17.existsSync(path17.join(projectRoot, "lefthook.yml"))) return "Lefthook";
-  if (fs17.existsSync(path17.join(projectRoot, ".husky"))) return "Husky";
+  if (fs18.existsSync(path18.join(projectRoot, "lefthook.yml"))) return "Lefthook";
+  if (fs18.existsSync(path18.join(projectRoot, ".husky"))) return "Husky";
   return void 0;
 }
 function setupClaudeCodeHook(projectRoot) {
-  const claudeDir = path17.join(projectRoot, ".claude");
-  if (!fs17.existsSync(claudeDir)) {
-    fs17.mkdirSync(claudeDir, { recursive: true });
+  const claudeDir = path18.join(projectRoot, ".claude");
+  if (!fs18.existsSync(claudeDir)) {
+    fs18.mkdirSync(claudeDir, { recursive: true });
   }
-  const settingsPath = path17.join(claudeDir, "settings.json");
+  const settingsPath = path18.join(claudeDir, "settings.json");
   let settings = {};
-  if (fs17.existsSync(settingsPath)) {
+  if (fs18.existsSync(settingsPath)) {
     try {
-      settings = JSON.parse(fs17.readFileSync(settingsPath, "utf-8"));
+      settings = JSON.parse(fs18.readFileSync(settingsPath, "utf-8"));
     } catch {
       console.warn(
         `  ${chalk11.yellow("!")} .claude/settings.json contains invalid JSON \u2014 skipping hook setup`
@@ -2539,30 +3520,30 @@ function setupClaudeCodeHook(projectRoot) {
     }
   ];
   settings.hooks = hooks;
-  fs17.writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}
+  fs18.writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}
 `);
   console.log(`  ${chalk11.green("\u2713")} .claude/settings.json \u2014 added viberails PostToolUse hook`);
 }
 function setupClaudeMdReference(projectRoot) {
-  const claudeMdPath = path17.join(projectRoot, "CLAUDE.md");
+  const claudeMdPath = path18.join(projectRoot, "CLAUDE.md");
   let content = "";
-  if (fs17.existsSync(claudeMdPath)) {
-    content = fs17.readFileSync(claudeMdPath, "utf-8");
+  if (fs18.existsSync(claudeMdPath)) {
+    content = fs18.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();
-  fs17.writeFileSync(claudeMdPath, prefix + ref);
+  fs18.writeFileSync(claudeMdPath, prefix + ref);
   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");
-  const workflowPath = path17.join(workflowDir, "viberails.yml");
-  if (fs17.existsSync(workflowPath)) {
-    const existing = fs17.readFileSync(workflowPath, "utf-8");
+  const workflowDir = path18.join(projectRoot, ".github", "workflows");
+  const workflowPath = path18.join(workflowDir, "viberails.yml");
+  if (fs18.existsSync(workflowPath)) {
+    const existing = fs18.readFileSync(workflowPath, "utf-8");
     if (existing.includes("viberails")) return void 0;
   }
-  fs17.mkdirSync(workflowDir, { recursive: true });
+  fs18.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`;
@@ -2616,74 +3597,74 @@ function setupGithubAction(projectRoot, packageManager, options) {
     ""
   );
   const content = lines.filter((l) => l !== void 0).join("\n");
-  fs17.writeFileSync(workflowPath, content);
+  fs18.writeFileSync(workflowPath, content);
   return ".github/workflows/viberails.yml";
 }
 function writeHuskyPreCommit(huskyDir) {
-  const hookPath = path17.join(huskyDir, "pre-commit");
+  const hookPath = path18.join(huskyDir, "pre-commit");
   const cmd = "if [ -x ./node_modules/.bin/viberails ]; then ./node_modules/.bin/viberails check --staged; else npx viberails check --staged; fi";
-  if (fs17.existsSync(hookPath)) {
-    const existing = fs17.readFileSync(hookPath, "utf-8");
+  if (fs18.existsSync(hookPath)) {
+    const existing = fs18.readFileSync(hookPath, "utf-8");
     if (!existing.includes("viberails")) {
-      fs17.writeFileSync(hookPath, `${existing.trimEnd()}
+      fs18.writeFileSync(hookPath, `${existing.trimEnd()}
 ${cmd}
 `);
     }
     return;
   }
-  fs17.writeFileSync(hookPath, `#!/bin/sh
+  fs18.writeFileSync(hookPath, `#!/bin/sh
 ${cmd}
 `, { mode: 493 });
 }
 
 // src/commands/init-hooks-extra.ts
-import * as fs18 from "fs";
-import * as path18 from "path";
+import * as fs19 from "fs";
+import * as path19 from "path";
 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");
-  if (fs18.existsSync(lefthookPath)) {
-    const content = fs18.readFileSync(lefthookPath, "utf-8");
+  const lefthookPath = path19.join(projectRoot, "lefthook.yml");
+  if (fs19.existsSync(lefthookPath)) {
+    const content = fs19.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, ...lefthookExtra };
-    fs18.writeFileSync(lefthookPath, stringifyYaml2(doc));
+    fs19.writeFileSync(lefthookPath, stringifyYaml2(doc));
     return "lefthook.yml";
   }
-  const huskyDir = path18.join(projectRoot, ".husky");
-  if (fs18.existsSync(huskyDir)) {
-    const hookPath = path18.join(huskyDir, "pre-commit");
-    if (fs18.existsSync(hookPath)) {
-      const existing = fs18.readFileSync(hookPath, "utf-8");
+  const huskyDir = path19.join(projectRoot, ".husky");
+  if (fs19.existsSync(huskyDir)) {
+    const hookPath = path19.join(huskyDir, "pre-commit");
+    if (fs19.existsSync(hookPath)) {
+      const existing = fs19.readFileSync(hookPath, "utf-8");
       if (existing.includes(marker)) return void 0;
-      fs18.writeFileSync(hookPath, `${existing.trimEnd()}
+      fs19.writeFileSync(hookPath, `${existing.trimEnd()}
 ${command}
 `);
     } else {
-      fs18.writeFileSync(hookPath, `#!/bin/sh
+      fs19.writeFileSync(hookPath, `#!/bin/sh
 ${command}
 `, { mode: 493 });
     }
     return ".husky/pre-commit";
   }
-  const gitDir = path18.join(projectRoot, ".git");
-  if (fs18.existsSync(gitDir)) {
-    const hooksDir = path18.join(gitDir, "hooks");
-    if (!fs18.existsSync(hooksDir)) fs18.mkdirSync(hooksDir, { recursive: true });
-    const hookPath = path18.join(hooksDir, "pre-commit");
-    if (fs18.existsSync(hookPath)) {
-      const existing = fs18.readFileSync(hookPath, "utf-8");
+  const gitDir = path19.join(projectRoot, ".git");
+  if (fs19.existsSync(gitDir)) {
+    const hooksDir = path19.join(gitDir, "hooks");
+    if (!fs19.existsSync(hooksDir)) fs19.mkdirSync(hooksDir, { recursive: true });
+    const hookPath = path19.join(hooksDir, "pre-commit");
+    if (fs19.existsSync(hookPath)) {
+      const existing = fs19.readFileSync(hookPath, "utf-8");
       if (existing.includes(marker)) return void 0;
-      fs18.writeFileSync(hookPath, `${existing.trimEnd()}
+      fs19.writeFileSync(hookPath, `${existing.trimEnd()}
 
 # ${name}
 ${command}
 `);
     } else {
-      fs18.writeFileSync(hookPath, `#!/bin/sh
+      fs19.writeFileSync(hookPath, `#!/bin/sh
 # Generated by viberails
 
 # ${name}
@@ -2709,7 +3690,7 @@ function setupTypecheckHook(projectRoot, packageManager) {
   return target;
 }
 function setupLintHook(projectRoot, linter) {
-  const isLefthook = fs18.existsSync(path18.join(projectRoot, "lefthook.yml"));
+  const isLefthook = fs19.existsSync(path19.join(projectRoot, "lefthook.yml"));
   const linterName = linter === "biome" ? "Biome" : "ESLint";
   let command;
   let lefthookExtra;
@@ -2733,6 +3714,9 @@ function setupSelectedIntegrations(projectRoot, integrations, opts) {
   const created = [];
   if (integrations.preCommitHook) {
     const t = setupPreCommitHook(projectRoot);
+    if (t && opts.lefthookExpected && !t.includes("lefthook")) {
+      console.log(`  ${chalk12.yellow("!")} Lefthook install failed \u2014 fell back to ${t}`);
+    }
     created.push(t ? `${t} \u2014 added viberails pre-commit` : "pre-commit hook skipped");
   }
   if (integrations.typecheckHook) {
@@ -2762,9 +3746,9 @@ function setupSelectedIntegrations(projectRoot, integrations, opts) {
 }
 
 // src/commands/init-non-interactive.ts
-import * as fs19 from "fs";
-import * as path19 from "path";
-import * as clack3 from "@clack/prompts";
+import * as fs20 from "fs";
+import * as path20 from "path";
+import * as clack12 from "@clack/prompts";
 import { compactConfig as compactConfig3, generateConfig } from "@viberails/config";
 import { scan as scan2 } from "@viberails/scanner";
 import chalk13 from "chalk";
@@ -2788,7 +3772,7 @@ function getExemptedPackages(config) {
   return config.packages.filter((pkg) => pkg.rules?.testCoverage === 0 && pkg.path !== ".").map((pkg) => pkg.path);
 }
 async function initNonInteractive(projectRoot, configPath) {
-  const s = clack3.spinner();
+  const s = clack12.spinner();
   s.start("Scanning project...");
   const scanResult = await scan2(projectRoot);
   const config = generateConfig(scanResult);
@@ -2807,7 +3791,7 @@ async function initNonInteractive(projectRoot, configPath) {
     );
   }
   if (config.packages.length > 1) {
-    const bs = clack3.spinner();
+    const bs = clack12.spinner();
     bs.start("Building import graph...");
     const { buildImportGraph, inferBoundaries } = await import("@viberails/graph");
     const packages = resolveWorkspacePackages(projectRoot, config.packages);
@@ -2823,7 +3807,7 @@ async function initNonInteractive(projectRoot, configPath) {
     }
   }
   const compacted = compactConfig3(config);
-  fs19.writeFileSync(configPath, `${JSON.stringify(compacted, null, 2)}
+  fs20.writeFileSync(configPath, `${JSON.stringify(compacted, null, 2)}
 `);
   writeGeneratedFiles(projectRoot, config, scanResult);
   updateGitignore(projectRoot);
@@ -2842,7 +3826,7 @@ async function initNonInteractive(projectRoot, configPath) {
   const preCommitTarget = hasHookManager ? setupPreCommitHook(projectRoot) : void 0;
   const ok = chalk13.green("\u2713");
   const created = [
-    `${ok} ${path19.basename(configPath)}`,
+    `${ok} ${path20.basename(configPath)}`,
     `${ok} .viberails/context.md`,
     `${ok} .viberails/scan-result.json`,
     `${ok} .claude/settings.json \u2014 added viberails hook`,
@@ -2859,9 +3843,6 @@ ${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) {
@@ -2869,8 +3850,8 @@ async function initCommand(options, cwd) {
       "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) {
+  const configPath = path21.join(projectRoot, CONFIG_FILE5);
+  if (fs21.existsSync(configPath) && !options.force) {
     if (!options.yes) {
       return initInteractive(projectRoot, configPath, options);
     }
@@ -2884,12 +3865,11 @@ async function initCommand(options, cwd) {
   await initInteractive(projectRoot, configPath, options);
 }
 async function initInteractive(projectRoot, configPath, options) {
-  clack4.intro("viberails");
-  const replacingExistingConfig = fs20.existsSync(configPath);
-  if (fs20.existsSync(configPath) && !options.force) {
-    const action = await promptExistingConfigAction(path20.basename(configPath));
+  clack13.intro("viberails");
+  if (fs21.existsSync(configPath) && !options.force) {
+    const action = await promptExistingConfigAction(path21.basename(configPath));
     if (action === "cancel") {
-      clack4.outro("Aborted. No files were written.");
+      clack13.outro("Aborted. No files were written.");
       return;
     }
     if (action === "edit") {
@@ -2898,142 +3878,93 @@ async function initInteractive(projectRoot, configPath, options) {
     }
     options.force = true;
   }
-  if (fs20.existsSync(configPath) && options.force) {
+  if (fs21.existsSync(configPath) && options.force) {
     const replace = await confirmDangerous(
-      `${path20.basename(configPath)} already exists and will be replaced. Continue?`
+      `${path21.basename(configPath)} already exists and will be replaced. Continue?`
     );
     if (!replace) {
-      clack4.outro("Aborted. No files were written.");
+      clack13.outro("Aborted. No files were written.");
       return;
     }
   }
-  const s = clack4.spinner();
+  const s = clack13.spinner();
   s.start("Scanning project...");
   const scanResult = await scan3(projectRoot);
   const config = generateConfig2(scanResult);
   s.stop("Scan complete");
   if (scanResult.statistics.totalFiles === 0) {
-    clack4.log.warn(
+    clack13.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 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
-    });
-    applyRuleOverrides(config, overrides);
-  }
-  if (config.packages.length > 1) {
-    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 hasTestRunner = !!scanResult.stack.testRunner;
+  if (!hasTestRunner) {
+    clack13.log.info(
+      "No test runner detected. Coverage checks are inactive until a test runner is installed.\nInstall a test runner (e.g. vitest) and re-run viberails init."
     );
-    const shouldInfer = await confirm("Infer boundary rules from current import patterns?");
-    if (shouldInfer) {
-      const bs = clack4.spinner();
-      bs.start("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;
-        const pkgCount = Object.keys(inferred.deny).length;
-        bs.stop(`Inferred ${denyCount} boundary rules across ${pkgCount} packages`);
-      } else {
-        bs.stop("No boundary rules inferred");
-      }
-    }
   }
   const hookManager = detectHookManager(projectRoot);
   const coveragePrereqs = checkCoveragePrereqs(projectRoot, scanResult);
-  const hasMissingPrereqs = coveragePrereqs.some((p) => !p.installed) || !hookManager;
-  if (hasMissingPrereqs) {
-    clack4.log.info("Some dependencies are needed for full functionality.");
-  }
-  const prereqResult = await promptMissingPrereqs(projectRoot, coveragePrereqs);
-  if (prereqResult.disableCoverage) {
-    config.rules.testCoverage = 0;
-  }
   const rootPkgStack = (config.packages.find((p) => p.path === ".") ?? config.packages[0])?.stack;
-  const integrations = await promptIntegrations(projectRoot, hookManager, {
-    isTypeScript: rootPkgStack?.language?.split("@")[0] === "typescript",
-    linter: rootPkgStack?.linter?.split("@")[0],
-    packageManager: rootPkgStack?.packageManager?.split("@")[0],
-    isWorkspace: config.packages.length > 1
-  });
-  displaySetupPlan(config, integrations, {
-    replacingExistingConfig,
-    configFile: path20.basename(configPath)
+  const state = await promptMainMenu(config, scanResult, {
+    hasTestRunner,
+    hookManager,
+    coveragePrereqs,
+    projectRoot,
+    tools: {
+      isTypeScript: rootPkgStack?.language?.split("@")[0] === "typescript",
+      linter: rootPkgStack?.linter?.split("@")[0],
+      packageManager: rootPkgStack?.packageManager?.split("@")[0],
+      isWorkspace: config.packages.length > 1
+    }
   });
-  const shouldWrite = await confirm("Apply this setup?");
+  const shouldWrite = await confirm3("Apply this setup?");
   if (!shouldWrite) {
-    clack4.outro("Aborted. No files were written.");
+    clack13.outro("Aborted. No files were written.");
     return;
   }
-  const ws = clack4.spinner();
+  if (state.deferredInstalls.length > 0) {
+    await executeDeferredInstalls(projectRoot, state.deferredInstalls);
+  }
+  const ws = clack13.spinner();
   ws.start("Writing configuration...");
   const compacted = compactConfig4(config);
-  fs20.writeFileSync(configPath, `${JSON.stringify(compacted, null, 2)}
+  fs21.writeFileSync(configPath, `${JSON.stringify(compacted, null, 2)}
 `);
   writeGeneratedFiles(projectRoot, config, scanResult);
   updateGitignore(projectRoot);
   ws.stop("Configuration written");
   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]
-  });
-  clack4.outro(
+  clack13.log.step(`${ok} ${path21.basename(configPath)}`);
+  clack13.log.step(`${ok} .viberails/context.md`);
+  clack13.log.step(`${ok} .viberails/scan-result.json`);
+  if (state.visited.integrations && state.integrations) {
+    const lefthookExpected = state.deferredInstalls.some((d) => d.command.includes("lefthook"));
+    setupSelectedIntegrations(projectRoot, state.integrations, {
+      linter: rootPkgStack?.linter?.split("@")[0],
+      packageManager: rootPkgStack?.packageManager?.split("@")[0],
+      lefthookExpected
+    });
+  }
+  clack13.outro(
     `Done! Next: review viberails.config.json, then run viberails check
   ${chalk14.dim("Tip: use")} ${chalk14.cyan("viberails check --enforce")} ${chalk14.dim("in CI to block PRs on violations.")}`
   );
 }
 
 // src/commands/sync.ts
-import * as fs21 from "fs";
-import * as path21 from "path";
-import * as clack5 from "@clack/prompts";
+import * as fs22 from "fs";
+import * as path22 from "path";
+import * as clack14 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 = path21.join(projectRoot, SCAN_RESULT_FILE2);
+  const scanResultPath = path22.join(projectRoot, SCAN_RESULT_FILE2);
   try {
-    const raw = fs21.readFileSync(scanResultPath, "utf-8");
+    const raw = fs22.readFileSync(scanResultPath, "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed?.statistics?.totalFiles !== void 0) {
       return parsed.statistics;
@@ -3050,17 +3981,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 = path21.join(projectRoot, CONFIG_FILE6);
+  const configPath = path22.join(projectRoot, CONFIG_FILE6);
   const existing = await loadConfig5(configPath);
   const previousStats = loadPreviousStats(projectRoot);
-  const s = clack5.spinner();
+  const s = clack14.spinner();
   s.start("Scanning project...");
   const scanResult = await scan4(projectRoot);
   s.stop("Scan complete");
   const merged = mergeConfig2(existing, scanResult);
   const compacted = compactConfig5(merged);
   const compactedJson = JSON.stringify(compacted, null, 2);
-  const rawDisk = fs21.readFileSync(configPath, "utf-8").trim();
+  const rawDisk = fs22.readFileSync(configPath, "utf-8").trim();
   const diskWithoutSync = rawDisk.replace(/"lastSync":\s*"[^"]*"/, '"lastSync": ""');
   const mergedWithoutSync = compactedJson.replace(/"lastSync":\s*"[^"]*"/, '"lastSync": ""');
   const configChanged = diskWithoutSync !== mergedWithoutSync;
@@ -3078,9 +4009,9 @@ ${chalk15.bold("Changes:")}`);
     }
   }
   if (options?.interactive) {
-    clack5.intro("viberails sync (interactive)");
-    clack5.note(formatRulesText(merged).join("\n"), "Rules after sync");
-    const decision = await clack5.select({
+    clack14.intro("viberails sync (interactive)");
+    clack14.note(formatRulesText(merged).join("\n"), "Rules after sync");
+    const decision = await clack14.select({
       message: "How would you like to proceed?",
       options: [
         { value: "accept", label: "Accept changes" },
@@ -3090,7 +4021,7 @@ ${chalk15.bold("Changes:")}`);
     });
     assertNotCancelled(decision);
     if (decision === "cancel") {
-      clack5.outro("Sync cancelled. No files were written.");
+      clack14.outro("Sync cancelled. No files were written.");
       return;
     }
     if (decision === "customize") {
@@ -3111,15 +4042,15 @@ ${chalk15.bold("Changes:")}`);
       });
       applyRuleOverrides(merged, overrides);
       const recompacted = compactConfig5(merged);
-      fs21.writeFileSync(configPath, `${JSON.stringify(recompacted, null, 2)}
+      fs22.writeFileSync(configPath, `${JSON.stringify(recompacted, null, 2)}
 `);
       writeGeneratedFiles(projectRoot, merged, scanResult);
-      clack5.log.success("Updated config with your customizations.");
-      clack5.outro("Done! Run viberails check to verify.");
+      clack14.log.success("Updated config with your customizations.");
+      clack14.outro("Done! Run viberails check to verify.");
       return;
     }
   }
-  fs21.writeFileSync(configPath, `${compactedJson}
+  fs22.writeFileSync(configPath, `${compactedJson}
 `);
   writeGeneratedFiles(projectRoot, merged, scanResult);
   console.log(`
@@ -3134,7 +4065,7 @@ ${chalk15.bold("Synced:")}`);
 }
 
 // src/index.ts
-var VERSION = "0.6.5";
+var VERSION = "0.6.7";
 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) => {