viberails 0.6.4 → 0.6.6

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import chalk14 from "chalk";
+import chalk15 from "chalk";
 import { Command } from "commander";
 
 // src/commands/boundaries.ts
@@ -30,146 +30,285 @@ function findProjectRoot(startDir) {
 // src/utils/prompt.ts
 import * as clack5 from "@clack/prompts";
 
-// src/utils/prompt-integrations.ts
-import * as clack from "@clack/prompts";
+// src/utils/prompt-rules.ts
+import * as clack4 from "@clack/prompts";
 
-// 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 });
-    });
-  });
+// src/utils/get-root-package.ts
+function getRootPackage(packages) {
+  return packages.find((pkg) => pkg.path === ".") ?? packages[0];
 }
 
-// src/utils/prompt-integrations.ts
-async function promptHookManagerInstall(projectRoot, packageManager, isWorkspace) {
-  const choice = await clack.select({
-    message: "No shared git hook manager detected. Install Lefthook?",
-    options: [
+// 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__";
+
+// 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" }
+      ]
+    });
+    assertNotCancelled(choice);
+    if (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";
+        }
+      });
+      assertNotCancelled(result);
+      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)";
+        }
+      });
+      assertNotCancelled(result);
+      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 ?? "(not set)"
+      });
+    }
+    options.push(
       {
-        value: "install",
-        label: "Yes, install Lefthook",
-        hint: "recommended \u2014 hooks are committed to the repo and shared with your team"
+        value: "componentNaming",
+        label: "Component naming",
+        hint: state.componentNaming ?? "(not set)"
       },
       {
-        value: "skip",
-        label: "No, skip",
-        hint: "pre-commit hooks will be local-only (.git/hooks) and not shared"
-      }
-    ]
-  });
-  assertNotCancelled(choice);
-  if (choice !== "install") return void 0;
-  const pm = packageManager || "npm";
-  const installCmd = pm === "yarn" ? "yarn add -D lefthook" : pm === "pnpm" ? `pnpm add -D${isWorkspace ? " -w" : ""} lefthook` : "npm install -D lefthook";
-  const s = clack.spinner();
-  s.start("Installing Lefthook...");
-  const result = await spawnAsync(installCmd, projectRoot);
-  if (result.status === 0) {
-    const fs21 = await import("fs");
-    const path21 = await import("path");
-    const lefthookPath = path21.join(projectRoot, "lefthook.yml");
-    if (!fs21.existsSync(lefthookPath)) {
-      fs21.writeFileSync(lefthookPath, "# Managed by viberails \u2014 https://viberails.sh\n");
-    }
-    s.stop("Installed Lefthook");
-    return "Lefthook";
-  }
-  s.stop("Failed to install Lefthook");
-  clack.log.warn(`Install manually: ${installCmd}`);
-  return void 0;
-}
-async function promptIntegrations(projectRoot, hookManager, tools) {
-  let resolvedHookManager = hookManager;
-  if (!resolvedHookManager) {
-    resolvedHookManager = await promptHookManagerInstall(
-      projectRoot,
-      tools?.packageManager ?? "npm",
-      tools?.isWorkspace
+        value: "hookNaming",
+        label: "Hook naming",
+        hint: state.hookNaming ?? "(not set)"
+      },
+      {
+        value: "importAlias",
+        label: "Import alias",
+        hint: state.importAlias ?? "(not set)"
+      },
+      { value: "back", label: "Back" }
     );
-  }
-  const isBareHook = !resolvedHookManager;
-  const hookLabel = resolvedHookManager ? `Pre-commit hook (${resolvedHookManager})` : "Pre-commit hook (git hook \u2014 local only)";
-  const hookHint = isBareHook ? "local only \u2014 will NOT be committed or shared with collaborators" : "runs viberails checks when you commit";
-  const options = [
-    {
-      value: "preCommit",
-      label: hookLabel,
-      hint: hookHint
+    const choice = await clack.select({ message: "Naming & conventions", options });
+    assertNotCancelled(choice);
+    if (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
+      });
+      assertNotCancelled(result);
+      if (result && !state.fileNamingValue) {
+        const selected = await clack.select({
+          message: "Which file naming convention should be enforced?",
+          options: [...FILE_NAMING_OPTIONS]
+        });
+        assertNotCancelled(selected);
+        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
+      });
+      assertNotCancelled(selected);
+      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
+      });
+      assertNotCancelled(selected);
+      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
+      });
+      assertNotCancelled(selected);
+      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
+      });
+      assertNotCancelled(selected);
+      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/*";
+          }
+        });
+        assertNotCancelled(result);
+        state.importAlias = result.trim();
+      } else {
+        state.importAlias = selected;
+      }
     }
-  ];
-  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"
+}
+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"
+        }
+      );
     }
-  );
-  const initialValues = isBareHook ? options.filter((o) => o.value !== "preCommit").map((o) => o.value) : options.map((o) => o.value);
-  const result = await clack.multiselect({
-    message: "Optional integrations",
-    options,
-    initialValues,
-    required: false
-  });
-  assertNotCancelled(result);
-  return {
-    preCommitHook: result.includes("preCommit"),
-    claudeCodeHook: result.includes("claude"),
-    claudeMdRef: result.includes("claudeMd"),
-    githubAction: result.includes("githubAction"),
-    typecheckHook: result.includes("typecheck"),
-    lintHook: result.includes("lint")
-  };
+    options.push({ value: "back", label: "Back" });
+    const choice = await clack.select({ message: "Testing & coverage", options });
+    assertNotCancelled(choice);
+    if (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
+      });
+      assertNotCancelled(result);
+      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";
+        }
+      });
+      assertNotCancelled(result);
+      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";
+        }
+      });
+      assertNotCancelled(result);
+      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)"
+      });
+      assertNotCancelled(result);
+      const trimmed = result.trim();
+      state.coverageCommand = trimmed.length > 0 ? trimmed : void 0;
+    }
+  }
 }
 
-// src/utils/prompt-rules.ts
-import * as clack4 from "@clack/prompts";
-
-// src/utils/prompt-menu-handlers.ts
-import * as clack3 from "@clack/prompts";
-
 // src/utils/prompt-package-overrides.ts
-import * as clack2 from "@clack/prompts";
 function normalizePackageOverrides(packages) {
   for (const pkg of packages) {
     if (pkg.rules && Object.keys(pkg.rules).length === 0) {
@@ -178,121 +317,177 @@ function normalizePackageOverrides(packages) {
     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 packageCoverageHint(pkg, defaults) {
+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;
-  const tags = [];
-  const nameSegments = pkg.name.replace(/^@[^/]+\//, "").split(/[-/]/);
-  const isTypesOnly = isExempt && nameSegments.some((s) => s === "types");
-  tags.push(isExempt ? isTypesOnly ? "exempt (types-only)" : "exempt" : `${coverage}%`);
   if (hasSummaryOverride) tags.push("summary override");
   if (hasCommandOverride) tags.push("command override");
-  return tags.join(", ");
+  return tags.length > 0 ? tags.join(", ") : "(no overrides)";
 }
-async function promptPackageCoverageOverrides(packages, defaults) {
+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 coverage overrides",
+      message: "Select package to edit overrides",
       options: [
         ...editablePackages.map((pkg) => ({
           value: pkg.path,
           label: `${pkg.path} (${pkg.name})`,
-          hint: packageCoverageHint(pkg, defaults)
+          hint: packageOverrideHint(pkg, defaults)
         })),
-        { value: "__done__", label: "Done" }
+        { value: SENTINEL_DONE, label: "Done" }
       ]
     });
     assertNotCancelled(selectedPath);
-    if (selectedPath === "__done__") break;
+    if (selectedPath === SENTINEL_DONE) break;
     const target = editablePackages.find((pkg) => pkg.path === selectedPath);
     if (!target) continue;
-    while (true) {
-      const effectiveCoverage = target.rules?.testCoverage ?? defaults.testCoverage;
-      const effectiveSummary = target.coverage?.summaryPath ?? defaults.coverageSummaryPath;
-      const effectiveCommand = target.coverage?.command ?? defaults.coverageCommand ?? "(auto-detect)";
-      const choice = await clack2.select({
-        message: `Edit coverage overrides for ${target.path}`,
+    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 ?? "(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" }
+      ]
+    });
+    assertNotCancelled(choice);
+    if (choice === "back") break;
+    if (choice === "fileNaming") {
+      const selected = await clack2.select({
+        message: `File naming for ${target.path}`,
         options: [
-          { value: "testCoverage", label: "testCoverage", hint: String(effectiveCoverage) },
-          { value: "summaryPath", label: "coverage.summaryPath", hint: effectiveSummary },
-          { value: "command", label: "coverage.command", hint: effectiveCommand },
-          { value: "reset", label: "Reset this package to inherit defaults" },
-          { value: "back", label: "Back to package list" }
-        ]
-      });
-      assertNotCancelled(choice);
-      if (choice === "back") break;
-      if (choice === "testCoverage") {
-        const result = await clack2.text({
-          message: "Package testCoverage (0 to exempt package)?",
-          initialValue: String(effectiveCoverage),
-          validate: (v) => {
-            if (typeof v !== "string") return "Enter a number between 0 and 100";
-            const n = Number.parseInt(v, 10);
-            if (Number.isNaN(n) || n < 0 || n > 100) return "Enter a number between 0 and 100";
-          }
-        });
-        assertNotCancelled(result);
-        const nextCoverage = Number.parseInt(result, 10);
-        if (nextCoverage === defaults.testCoverage) {
-          if (target.rules) {
-            delete target.rules.testCoverage;
+          ...FILE_NAMING_OPTIONS,
+          { value: SENTINEL_NONE, label: "(none \u2014 exempt from checks)" },
+          {
+            value: SENTINEL_INHERIT,
+            label: `Inherit default${defaults.fileNamingValue ? ` (${defaults.fileNamingValue})` : ""}`
           }
-        } else {
-          target.rules = { ...target.rules ?? {}, testCoverage: nextCoverage };
-        }
+        ],
+        initialValue: target.conventions?.fileNaming ?? SENTINEL_INHERIT
+      });
+      assertNotCancelled(selected);
+      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 === "summaryPath") {
-        const result = await clack2.text({
-          message: "Package coverage.summaryPath (blank to inherit default)?",
-          initialValue: target.coverage?.summaryPath !== void 0 ? target.coverage.summaryPath : "",
-          placeholder: defaults.coverageSummaryPath
-        });
-        assertNotCancelled(result);
-        const value = result.trim();
-        if (value.length === 0 || value === defaults.coverageSummaryPath) {
-          if (target.coverage) {
-            delete target.coverage.summaryPath;
-          }
-        } else {
-          target.coverage = { ...target.coverage ?? {}, summaryPath: value };
-        }
+    }
+    if (choice === "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)
+      });
+      assertNotCancelled(result);
+      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 === "command") {
-        const result = await clack2.text({
-          message: "Package coverage.command (blank to inherit default/auto)?",
-          initialValue: target.coverage?.command !== void 0 ? target.coverage.command : "",
-          placeholder: defaults.coverageCommand ?? "(auto-detect from package.json test runner)"
-        });
-        assertNotCancelled(result);
-        const value = result.trim();
-        const defaultCommand = defaults.coverageCommand ?? "";
-        if (value.length === 0 || value === defaultCommand) {
-          if (target.coverage) {
-            delete target.coverage.command;
-          }
-        } else {
-          target.coverage = { ...target.coverage ?? {}, command: value };
+    }
+    if (choice === "testCoverage") {
+      const result = await clack2.text({
+        message: "Package testCoverage (0 to exempt package)?",
+        initialValue: String(effectiveCoverage),
+        validate: (v) => {
+          if (typeof v !== "string") return "Enter a number between 0 and 100";
+          const n = Number.parseInt(v, 10);
+          if (Number.isNaN(n) || n < 0 || n > 100) return "Enter a number between 0 and 100";
         }
+      });
+      assertNotCancelled(result);
+      const nextCoverage = Number.parseInt(result, 10);
+      if (nextCoverage === defaults.testCoverage) {
+        if (target.rules) delete target.rules.testCoverage;
+      } else {
+        target.rules = { ...target.rules ?? {}, testCoverage: nextCoverage };
       }
-      if (choice === "reset") {
-        if (target.rules) {
-          delete target.rules.testCoverage;
-        }
-        delete target.coverage;
+    }
+    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
+      });
+      assertNotCancelled(result);
+      const value = result.trim();
+      if (value.length === 0 || value === defaults.coverageSummaryPath) {
+        if (target.coverage) delete target.coverage.summaryPath;
+      } else {
+        target.coverage = { ...target.coverage ?? {}, summaryPath: value };
+      }
+    }
+    if (choice === "command") {
+      const result = await clack2.text({
+        message: "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)"
+      });
+      assertNotCancelled(result);
+      const value = result.trim();
+      const defaultCommand = defaults.coverageCommand ?? "";
+      if (value.length === 0 || value === defaultCommand) {
+        if (target.coverage) delete target.coverage.command;
+      } else {
+        target.coverage = { ...target.coverage ?? {}, command: value };
       }
-      normalizePackageOverrides(editablePackages);
+    }
+    if (choice === "reset") {
+      if (target.rules) {
+        delete target.rules.testCoverage;
+        delete target.rules.maxFileLines;
+      }
+      delete target.coverage;
+      delete target.conventions;
     }
   }
-  return normalizePackageOverrides(packages);
 }
 
 // src/utils/prompt-menu-handlers.ts
@@ -335,48 +530,21 @@ function getPackageDiffs(pkg, root) {
   return diffs;
 }
 function buildMenuOptions(state, packageCount) {
-  const namingHint = state.enforceNaming ? `yes${state.fileNamingValue ? ` (${state.fileNamingValue})` : ""}` : "no";
+  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: "maxFileLines", label: "Max file lines", hint: String(state.maxFileLines) },
-    { value: "enforceNaming", label: "Enforce file naming", hint: namingHint }
+    { value: "fileLimits", label: "File limits", hint: fileLimitsHint2 },
+    { value: "naming", label: "Naming & conventions", hint: namingHint },
+    { value: "testing", label: "Testing & coverage", hint: testingHint }
   ];
-  if (state.fileNamingValue) {
+  if (packageCount > 0) {
     options.push({
-      value: "fileNaming",
-      label: "File naming convention",
-      hint: state.fileNamingValue
+      value: "packageOverrides",
+      label: "Per-package overrides",
+      hint: `${packageCount} package${packageCount > 1 ? "s" : ""} configurable`
     });
   }
-  const isMonorepo = packageCount > 0;
-  const coverageLabel = isMonorepo ? "Default coverage target" : "Test coverage target";
-  const coverageHint = state.testCoverage === 0 ? "0 (disabled)" : isMonorepo ? `${state.testCoverage}% (per-package default)` : `${state.testCoverage}%`;
-  options.push({ value: "testCoverage", label: coverageLabel, hint: coverageHint });
-  options.push({
-    value: "enforceMissingTests",
-    label: "Enforce missing tests",
-    hint: state.enforceMissingTests ? "yes" : "no"
-  });
-  if (state.testCoverage > 0) {
-    options.push(
-      {
-        value: "coverageSummaryPath",
-        label: isMonorepo ? "Default coverage summary path" : "Coverage summary path",
-        hint: state.coverageSummaryPath
-      },
-      {
-        value: "coverageCommand",
-        label: isMonorepo ? "Default coverage command" : "Coverage command",
-        hint: state.coverageCommand ?? "auto-detect from package.json test runner"
-      }
-    );
-    if (isMonorepo) {
-      options.push({
-        value: "packageOverrides",
-        label: "Per-package coverage overrides",
-        hint: `${packageCount} package${packageCount > 1 ? "s" : ""} configurable`
-      });
-    }
-  }
   options.push(
     { value: "reset", label: "Reset all to detected defaults" },
     { value: "done", label: "Done" }
@@ -384,37 +552,43 @@ function buildMenuOptions(state, packageCount) {
   return options;
 }
 function clonePackages(packages) {
-  return packages?.map((pkg) => ({
-    ...pkg,
-    stack: pkg.stack ? { ...pkg.stack } : void 0,
-    structure: pkg.structure ? { ...pkg.structure } : void 0,
-    conventions: pkg.conventions ? { ...pkg.conventions } : void 0,
-    rules: pkg.rules ? { ...pkg.rules } : void 0,
-    coverage: pkg.coverage ? { ...pkg.coverage } : void 0,
-    ignore: pkg.ignore ? [...pkg.ignore] : void 0,
-    boundaries: pkg.boundaries ? {
-      deny: [...pkg.boundaries.deny],
-      ignore: pkg.boundaries.ignore ? [...pkg.boundaries.ignore] : void 0
-    } : void 0
-  }));
+  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 promptPackageCoverageOverrides(state.packageOverrides, {
+      state.packageOverrides = await promptPackageOverrides(state.packageOverrides, {
+        fileNamingValue: state.fileNamingValue,
+        maxFileLines: state.maxFileLines,
         testCoverage: state.testCoverage,
         coverageSummaryPath: state.coverageSummaryPath,
         coverageCommand: state.coverageCommand
@@ -427,89 +601,9 @@ async function handleMenuChoice(choice, state, defaults, root) {
     }
     return;
   }
-  if (choice === "maxFileLines") {
-    const result = await clack3.text({
-      message: "Maximum lines per source file?",
-      initialValue: String(state.maxFileLines),
-      validate: (v) => {
-        if (typeof v !== "string") return "Enter a positive number";
-        const n = Number.parseInt(v, 10);
-        if (Number.isNaN(n) || n < 1) return "Enter a positive number";
-      }
-    });
-    assertNotCancelled(result);
-    state.maxFileLines = Number.parseInt(result, 10);
-  }
-  if (choice === "enforceMissingTests") {
-    const result = await clack3.confirm({
-      message: "Require every source file to have a corresponding test file?",
-      initialValue: state.enforceMissingTests
-    });
-    assertNotCancelled(result);
-    state.enforceMissingTests = result;
-  }
-  if (choice === "testCoverage") {
-    const result = await clack3.text({
-      message: "Test coverage target (0 disables coverage checks)?",
-      initialValue: String(state.testCoverage),
-      validate: (v) => {
-        if (typeof v !== "string") return "Enter a number between 0 and 100";
-        const n = Number.parseInt(v, 10);
-        if (Number.isNaN(n) || n < 0 || n > 100) return "Enter a number between 0 and 100";
-      }
-    });
-    assertNotCancelled(result);
-    state.testCoverage = Number.parseInt(result, 10);
-  }
-  if (choice === "coverageSummaryPath") {
-    const result = await clack3.text({
-      message: "Coverage summary path (relative to package root)?",
-      initialValue: state.coverageSummaryPath,
-      validate: (v) => {
-        if (typeof v !== "string" || v.trim().length === 0) return "Path cannot be empty";
-      }
-    });
-    assertNotCancelled(result);
-    state.coverageSummaryPath = result.trim();
-  }
-  if (choice === "coverageCommand") {
-    const result = await clack3.text({
-      message: "Coverage command (blank to auto-detect from package.json)?",
-      initialValue: state.coverageCommand ?? "",
-      placeholder: "(auto-detect from package.json test runner)"
-    });
-    assertNotCancelled(result);
-    const trimmed = result.trim();
-    state.coverageCommand = trimmed.length > 0 ? trimmed : void 0;
-  }
-  if (choice === "enforceNaming") {
-    const result = await clack3.confirm({
-      message: state.fileNamingValue ? `Enforce file naming? (detected: ${state.fileNamingValue})` : "Enforce file naming?",
-      initialValue: state.enforceNaming
-    });
-    assertNotCancelled(result);
-    state.enforceNaming = result;
-  }
-  if (choice === "fileNaming") {
-    const selected = await clack3.select({
-      message: "Which file naming convention should be enforced?",
-      options: [
-        { value: "kebab-case", label: "kebab-case" },
-        { value: "camelCase", label: "camelCase" },
-        { value: "PascalCase", label: "PascalCase" },
-        { value: "snake_case", label: "snake_case" }
-      ],
-      initialValue: state.fileNamingValue
-    });
-    assertNotCancelled(selected);
-    state.fileNamingValue = selected;
-  }
 }
 
 // src/utils/prompt-rules.ts
-function getRootPackage(packages) {
-  return packages.find((pkg) => pkg.path === ".") ?? packages[0];
-}
 async function promptRuleMenu(defaults) {
   const state = {
     ...defaults,
@@ -526,10 +620,14 @@ async function promptRuleMenu(defaults) {
   }
   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
@@ -577,30 +675,6 @@ async function promptExistingConfigAction(configFile) {
   assertNotCancelled(result);
   return result;
 }
-async function promptInitDecision() {
-  const result = await clack5.select({
-    message: "How do you want to proceed?",
-    options: [
-      {
-        value: "accept",
-        label: "Accept defaults",
-        hint: "writes the config with these defaults; use --enforce in CI to block"
-      },
-      {
-        value: "customize",
-        label: "Customize rules",
-        hint: "edit limits, naming, test coverage, and package overrides"
-      },
-      {
-        value: "review",
-        label: "Review detected details",
-        hint: "show the full scan report with package and structure details"
-      }
-    ]
-  });
-  assertNotCancelled(result);
-  return result;
-}
 
 // src/utils/resolve-workspace-packages.ts
 import * as fs2 from "fs";
@@ -1218,13 +1292,13 @@ function checkMissingTests(projectRoot, config, severity) {
     const testSuffix = testPattern.replace("*", "");
     const sourceFiles = collectSourceFiles(srcPath, projectRoot);
     for (const relFile of sourceFiles) {
-      const basename9 = path6.basename(relFile);
-      if (basename9.includes(".test.") || basename9.includes(".spec.") || basename9.startsWith("index.") || basename9.endsWith(".d.ts")) {
+      const basename10 = path6.basename(relFile);
+      if (basename10.includes(".test.") || basename10.includes(".spec.") || basename10.startsWith("index.") || basename10.endsWith(".d.ts")) {
         continue;
       }
-      const ext = path6.extname(basename9);
+      const ext = path6.extname(basename10);
       if (!SOURCE_EXTS2.has(ext)) continue;
-      const stem = basename9.slice(0, -ext.length);
+      const stem = basename10.slice(0, -ext.length);
       const expectedTestFile = `${stem}${testSuffix}`;
       const dir = path6.dirname(path6.join(projectRoot, relFile));
       const colocatedTest = path6.join(dir, expectedTestFile);
@@ -1305,9 +1379,9 @@ async function checkCommand(options, cwd) {
   }
   const violations = [];
   const severity = options.enforce ? "error" : "warn";
-  const log7 = options.format !== "json" && !options.hook && !options.quiet ? (msg) => process.stderr.write(chalk3.dim(msg)) : () => {
+  const log8 = options.format !== "json" && !options.hook && !options.quiet ? (msg) => process.stderr.write(chalk3.dim(msg)) : () => {
   };
-  log7("  Checking files...");
+  log8("  Checking files...");
   for (const file of filesToCheck) {
     const absPath = path7.isAbsolute(file) ? file : path7.join(projectRoot, file);
     const relPath = path7.relative(projectRoot, absPath);
@@ -1340,9 +1414,9 @@ async function checkCommand(options, cwd) {
       }
     }
   }
-  log7(" done\n");
+  log8(" done\n");
   if (!options.files) {
-    log7("  Checking missing tests...");
+    log8("  Checking missing tests...");
     const testViolations = checkMissingTests(projectRoot, config, severity);
     if (options.staged) {
       const stagedSet = new Set(filesToCheck);
@@ -1355,14 +1429,14 @@ async function checkCommand(options, cwd) {
     } else {
       violations.push(...testViolations);
     }
-    log7(" done\n");
+    log8(" done\n");
   }
   if (!options.files && !options.staged && !options.diffBase) {
-    log7("  Running test coverage...\n");
+    log8("  Running test coverage...\n");
     const coverageViolations = checkCoverage(projectRoot, config, filesToCheck, {
       staged: options.staged,
       enforce: options.enforce,
-      onProgress: (pkg) => log7(`    Coverage: ${pkg}...
+      onProgress: (pkg) => log8(`    Coverage: ${pkg}...
 `)
     });
     violations.push(...coverageViolations);
@@ -1387,7 +1461,7 @@ async function checkCommand(options, cwd) {
         severity
       });
     }
-    log7(`  Boundary check: ${graph.nodes.length} files in ${Date.now() - startTime}ms
+    log8(`  Boundary check: ${graph.nodes.length} files in ${Date.now() - startTime}ms
 `);
   }
   if (options.format === "json") {
@@ -1654,15 +1728,6 @@ function formatMonorepoResultsText(scanResult) {
 }
 
 // src/display.ts
-var INIT_OVERVIEW_NAMES = {
-  typescript: "TypeScript",
-  javascript: "JavaScript",
-  eslint: "ESLint",
-  prettier: "Prettier",
-  jest: "Jest",
-  vitest: "Vitest",
-  biome: "Biome"
-};
 function formatItem(item, nameMap) {
   const name = nameMap?.[item.name] ?? item.name;
   return item.version ? `${name} ${item.version}` : name;
@@ -1792,134 +1857,6 @@ function displayRulesPreview(config) {
   );
   console.log("");
 }
-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_NAMES2));
-  } else {
-    primaryParts.push("single package");
-  }
-  primaryParts.push(formatOverviewItem(stack.language));
-  if (stack.styling) {
-    primaryParts.push(formatOverviewItem(stack.styling, STYLING_NAMES2));
-  }
-  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) => chalk5.cyan(part)).join(chalk5.dim(" \xB7 "));
-  const secondary = secondaryParts.join(chalk5.dim(" \xB7 "));
-  return secondary ? `${primary}
-  ${chalk5.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 = chalk5.green("\u2713");
-  const info = chalk5.yellow("~");
-  console.log("");
-  console.log(`  ${chalk5.bold("Ready to initialize:")}`);
-  console.log(`  ${formatDetectedOverview(scanResult)}`);
-  console.log("");
-  console.log(`  ${chalk5.bold("Rules to apply:")}`);
-  console.log(`  ${ok} Max file size: ${chalk5.cyan(`${config.rules.maxFileLines} lines`)}`);
-  const fileNaming = root?.conventions?.fileNaming ?? config.packages.find((p) => p.conventions?.fileNaming)?.conventions?.fileNaming;
-  if (config.rules.enforceNaming && fileNaming) {
-    console.log(`  ${ok} File naming: ${chalk5.cyan(fileNaming)}`);
-  } else {
-    console.log(`  ${info} File naming: ${chalk5.dim("not enforced")}`);
-  }
-  const testPattern = root?.structure?.testPattern ?? config.packages.find((p) => p.structure?.testPattern)?.structure?.testPattern;
-  if (config.rules.enforceMissingTests && testPattern) {
-    console.log(`  ${ok} Missing tests: ${chalk5.cyan(`enforced (${testPattern})`)}`);
-  } else if (config.rules.enforceMissingTests) {
-    console.log(`  ${ok} Missing tests: ${chalk5.cyan("enforced")}`);
-  } else {
-    console.log(`  ${info} Missing tests: ${chalk5.dim("not enforced")}`);
-  }
-  if (config.rules.testCoverage > 0) {
-    if (isMonorepo) {
-      const withCoverage = config.packages.filter(
-        (p) => (p.rules?.testCoverage ?? config.rules.testCoverage) > 0
-      );
-      console.log(
-        `  ${ok} Coverage: ${chalk5.cyan(`${config.rules.testCoverage}%`)} default ${chalk5.dim(`(${withCoverage.length}/${config.packages.length} packages)`)}`
-      );
-    } else {
-      console.log(`  ${ok} Coverage: ${chalk5.cyan(`${config.rules.testCoverage}%`)}`);
-    }
-  } else {
-    console.log(`  ${info} Coverage: ${chalk5.dim("disabled")}`);
-  }
-  if (exemptedPackages.length > 0) {
-    console.log(
-      `  ${chalk5.dim("  exempted:")} ${chalk5.dim(exemptedPackages.join(", "))} ${chalk5.dim("(types-only)")}`
-    );
-  }
-  console.log("");
-  console.log(`  ${chalk5.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(
-    `
-  ${chalk5.dim("Defaults warn locally. Use --enforce in CI when you want failures to block.")}`
-  );
-  console.log("");
-}
-function summarizeSelectedIntegrations(integrations, opts) {
-  const lines = [];
-  if (opts.hasBoundaries) {
-    lines.push("\u2713 Boundary rules: inferred from current imports");
-  } else {
-    lines.push("~ Boundary rules: not enabled");
-  }
-  if (opts.hasCoverage) {
-    lines.push("\u2713 Coverage checks: enabled");
-  } else {
-    lines.push("~ Coverage checks: disabled");
-  }
-  const selectedIntegrations = [
-    integrations.preCommitHook ? "pre-commit hook" : void 0,
-    integrations.typecheckHook ? "typecheck" : void 0,
-    integrations.lintHook ? "lint check" : void 0,
-    integrations.claudeCodeHook ? "Claude Code hook" : void 0,
-    integrations.claudeMdRef ? "CLAUDE.md reference" : void 0,
-    integrations.githubAction ? "GitHub Actions workflow" : void 0
-  ].filter(Boolean);
-  if (selectedIntegrations.length > 0) {
-    lines.push(`\u2713 Integrations: ${selectedIntegrations.join(" \xB7 ")}`);
-  } else {
-    lines.push("~ Integrations: none selected");
-  }
-  return lines;
-}
-function displaySetupPlan(config, integrations, opts = {}) {
-  const configFile = opts.configFile ?? "viberails.config.json";
-  const lines = summarizeSelectedIntegrations(integrations, {
-    hasBoundaries: config.rules.enforceBoundaries,
-    hasCoverage: config.rules.testCoverage > 0
-  });
-  console.log("");
-  console.log(`  ${chalk5.bold("Ready to write:")}`);
-  console.log(
-    `  ${opts.replacingExistingConfig ? chalk5.yellow("!") : chalk5.green("\u2713")} ${configFile}${opts.replacingExistingConfig ? chalk5.dim(" (replacing existing config)") : ""}`
-  );
-  console.log(`  ${chalk5.green("\u2713")} .viberails/context.md`);
-  console.log(`  ${chalk5.green("\u2713")} .viberails/scan-result.json`);
-  for (const line of lines) {
-    const icon = line.startsWith("\u2713") ? chalk5.green("\u2713") : chalk5.yellow("~");
-    console.log(`  ${icon} ${line.slice(2)}`);
-  }
-  console.log("");
-}
 
 // src/display-text.ts
 function plainConfidenceLabel(convention) {
@@ -2038,7 +1975,9 @@ function formatScanResultsText(scanResult) {
 // src/utils/apply-rule-overrides.ts
 function applyRuleOverrides(config, overrides) {
   if (overrides.packageOverrides) config.packages = overrides.packageOverrides;
+  const rootPkg = getRootPackage(config.packages);
   config.rules.maxFileLines = overrides.maxFileLines;
+  config.rules.maxTestFileLines = overrides.maxTestFileLines;
   config.rules.testCoverage = overrides.testCoverage;
   config.rules.enforceMissingTests = overrides.enforceMissingTests;
   config.rules.enforceNaming = overrides.enforceNaming;
@@ -2052,7 +1991,6 @@ function applyRuleOverrides(config, overrides) {
     }
   }
   if (overrides.fileNamingValue) {
-    const rootPkg = config.packages.find((p) => p.path === ".") ?? config.packages[0];
     const oldNaming = rootPkg.conventions?.fileNaming;
     rootPkg.conventions = rootPkg.conventions ?? {};
     rootPkg.conventions.fileNaming = overrides.fileNamingValue;
@@ -2064,6 +2002,18 @@ function applyRuleOverrides(config, overrides) {
       }
     }
   }
+  if (rootPkg) {
+    rootPkg.conventions = rootPkg.conventions ?? {};
+    if (overrides.componentNaming !== void 0) {
+      rootPkg.conventions.componentNaming = overrides.componentNaming || void 0;
+    }
+    if (overrides.hookNaming !== void 0) {
+      rootPkg.conventions.hookNaming = overrides.hookNaming || void 0;
+    }
+    if (overrides.importAlias !== void 0) {
+      rootPkg.conventions.importAlias = overrides.importAlias || void 0;
+    }
+  }
 }
 
 // src/utils/diff-configs.ts
@@ -2240,10 +2190,14 @@ async function configCommand(options, cwd) {
   const rootPkg = config.packages.find((p) => p.path === ".") ?? config.packages[0];
   const overrides = await promptRuleMenu({
     maxFileLines: config.rules.maxFileLines,
+    maxTestFileLines: config.rules.maxTestFileLines,
     testCoverage: config.rules.testCoverage,
     enforceMissingTests: config.rules.enforceMissingTests,
     enforceNaming: config.rules.enforceNaming,
     fileNamingValue: rootPkg.conventions?.fileNaming,
+    componentNaming: rootPkg.conventions?.componentNaming,
+    hookNaming: rootPkg.conventions?.hookNaming,
+    importAlias: rootPkg.conventions?.importAlias,
     coverageSummaryPath: rootPkg.coverage?.summaryPath ?? "coverage/coverage-summary.json",
     coverageCommand: config.defaults?.coverage?.command,
     packageOverrides: config.packages
@@ -2624,10 +2578,10 @@ function generateTestStub(sourceRelPath, config, projectRoot) {
   const pkg = resolvePackageForFile(sourceRelPath, config);
   const testPattern = pkg?.structure?.testPattern;
   if (!testPattern) return null;
-  const basename9 = path12.basename(sourceRelPath);
-  const ext = path12.extname(basename9);
+  const basename10 = path12.basename(sourceRelPath);
+  const ext = path12.extname(basename10);
   if (!ext) return null;
-  const stem = basename9.slice(0, -ext.length);
+  const stem = basename10.slice(0, -ext.length);
   const testSuffix = testPattern.replace("*", "");
   const testFilename = `${stem}${testSuffix}`;
   const dir = path12.dirname(path12.join(projectRoot, sourceRelPath));
@@ -2799,169 +2753,601 @@ ${chalk8.yellow("!")} No safe fixes to apply. Resolve aliased imports first.`);
 }
 
 // src/commands/init.ts
-import * as fs19 from "fs";
-import * as path19 from "path";
+import * as fs21 from "fs";
+import * as path21 from "path";
+import * as clack12 from "@clack/prompts";
+import { compactConfig as compactConfig4, generateConfig as generateConfig2 } from "@viberails/config";
+import { scan as scan3 } from "@viberails/scanner";
+import chalk13 from "chalk";
+
+// 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";
+
+// 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 });
+    });
+  });
+}
+
+// src/utils/check-prerequisites.ts
+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);
+  const hasVitest = vitestPackages.length > 0 || scanResult.stack.testRunner?.name === "vitest";
+  if (!hasVitest) return [];
+  let installed = hasDependency(projectRoot, "@vitest/coverage-v8") || hasDependency(projectRoot, "@vitest/coverage-istanbul");
+  if (!installed && vitestPackages.length > 0) {
+    installed = vitestPackages.every((rel) => {
+      const pkgDir = path14.join(projectRoot, rel);
+      return hasDependency(pkgDir, "@vitest/coverage-v8") || hasDependency(pkgDir, "@vitest/coverage-istanbul");
+    });
+  }
+  const isWorkspace = scanResult.packages.length > 1;
+  const addCmd = pm === "yarn" ? "yarn add -D" : pm === "pnpm" && isWorkspace ? "pnpm add -D -w" : pm === "npm" ? "npm install -D" : `${pm} add -D`;
+  const affectedPackages = vitestPackages.length > 1 ? vitestPackages : void 0;
+  const reason = affectedPackages ? `Required for coverage in: ${affectedPackages.join(", ")}` : "Required for coverage percentage checks with vitest";
+  return [
+    {
+      label: "@vitest/coverage-v8",
+      installed,
+      installCommand: installed ? void 0 : `${addCmd} @vitest/coverage-v8`,
+      reason,
+      affectedPackages
+    }
+  ];
+}
+function displayMissingPrereqs(prereqs) {
+  const missing = prereqs.filter((p) => !p.installed);
+  for (const m of missing) {
+    const suffix = m.affectedPackages ? ` \u2014 needed for coverage in: ${m.affectedPackages.join(", ")}` : ` \u2014 ${m.reason}`;
+    console.log(`  ${chalk9.yellow("!")} ${m.label} not installed${suffix}`);
+    if (m.installCommand) {
+      console.log(`    Install: ${chalk9.cyan(m.installCommand)}`);
+    }
+  }
+}
+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";
-import { compactConfig as compactConfig3, generateConfig } from "@viberails/config";
-import { scan as scan2 } from "@viberails/scanner";
-import chalk12 from "chalk";
+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 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-hints.ts
+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 statusIcon(status) {
+  if (status === "ok") return "\u2713";
+  if (status === "needs-input") return "?";
+  return "~";
+}
+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)} 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: "  Advanced naming", hint: advancedNamingHint(config) }
+  ];
+  if (config.packages.length > 1) {
+    const bIcon = state.visited.boundaries && config.rules.enforceBoundaries ? statusIcon("ok") : "  ";
+    options.push(
+      {
+        value: "packageOverrides",
+        label: "  Per-package overrides",
+        hint: packageOverridesHint(config)
+      },
+      { value: "boundaries", label: `${bIcon} Boundaries`, hint: boundariesHint(config, state) }
+    );
+  }
+  const iIcon = state.visited.integrations ? statusIcon("ok") : "  ";
+  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/check-prerequisites.ts
-import * as fs14 from "fs";
-import * as path14 from "path";
-import * as clack7 from "@clack/prompts";
-import chalk9 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);
-  const hasVitest = vitestPackages.length > 0 || scanResult.stack.testRunner?.name === "vitest";
-  if (!hasVitest) return [];
-  let installed = hasDependency(projectRoot, "@vitest/coverage-v8") || hasDependency(projectRoot, "@vitest/coverage-istanbul");
-  if (!installed && vitestPackages.length > 0) {
-    installed = vitestPackages.every((rel) => {
-      const pkgDir = path14.join(projectRoot, rel);
-      return hasDependency(pkgDir, "@vitest/coverage-v8") || hasDependency(pkgDir, "@vitest/coverage-istanbul");
-    });
+// src/utils/prompt-main-menu.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;
   }
-  const isWorkspace = scanResult.packages.length > 1;
-  const addCmd = pm === "yarn" ? "yarn add -D" : pm === "pnpm" && isWorkspace ? "pnpm add -D -w" : pm === "npm" ? "npm install -D" : `${pm} add -D`;
-  const affectedPackages = vitestPackages.length > 1 ? vitestPackages : void 0;
-  const reason = affectedPackages ? `Required for coverage in: ${affectedPackages.join(", ")}` : "Required for coverage percentage checks with vitest";
-  return [
-    {
-      label: "@vitest/coverage-v8",
-      installed,
-      installCommand: installed ? void 0 : `${addCmd} @vitest/coverage-v8`,
-      reason,
-      affectedPackages
+  rootPkg.conventions.componentNaming = state.componentNaming || void 0;
+  rootPkg.conventions.hookNaming = state.hookNaming || void 0;
+  rootPkg.conventions.importAlias = state.importAlias || void 0;
+}
+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 clack10.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") clack10.note(formatScanResultsText(scanResult), "Scan details");
+    if (choice === "reset") {
+      Object.assign(config, structuredClone(originalConfig));
+      state.deferredInstalls = [];
+      state.visited = { integrations: false, boundaries: false };
+      state.integrations = void 0;
+      clack10.log.info("Reset all settings to scan-detected defaults.");
+    }
+  }
+  return state;
 }
-function displayMissingPrereqs(prereqs) {
-  const missing = prereqs.filter((p) => !p.installed);
-  for (const m of missing) {
-    const suffix = m.affectedPackages ? ` \u2014 needed for coverage in: ${m.affectedPackages.join(", ")}` : ` \u2014 ${m.reason}`;
-    console.log(`  ${chalk9.yellow("!")} ${m.label} not installed${suffix}`);
-    if (m.installCommand) {
-      console.log(`    Install: ${chalk9.cyan(m.installCommand)}`);
+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
+  });
+  assertNotCancelled(selected);
+  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 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");
-  clack7.note(prereqLines, "Coverage support");
-  let disableCoverage = false;
-  for (const m of missing) {
-    if (!m.installCommand) continue;
-    const pkgCount = m.affectedPackages?.length;
-    const message = pkgCount ? `${m.label} is not installed. Required for coverage in ${pkgCount} packages using vitest.` : `${m.label} is not installed. It is required for coverage percentage checks.`;
-    const choice = await clack7.select({
-      message,
+async function handleMissingTests(config) {
+  const result = await clack10.confirm({
+    message: "Require every source file to have a test file?",
+    initialValue: config.rules.enforceMissingTests
+  });
+  assertNotCancelled(result);
+  config.rules.enforceMissingTests = result;
+}
+async function handleCoverage(config, state, opts) {
+  if (!opts.hasTestRunner) {
+    clack10.log.info("Coverage checks are inactive \u2014 no test runner detected.");
+    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);
+    state.deferredInstalls = state.deferredInstalls.filter((d) => d.command !== planned.command);
     if (choice === "install") {
-      const is = clack7.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}`);
-        clack7.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;
-      clack7.log.info("Coverage percentage checks disabled. Missing-test checks remain active.");
-    } else {
-      clack7.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";
+    }
+  });
+  assertNotCancelled(result);
+  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
+  });
+  assertNotCancelled(shouldInfer);
+  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}`);
   }
 }
-
-// src/utils/filter-confidence.ts
-function filterHighConfidence(conventions, meta) {
-  if (!meta) return conventions;
-  const filtered = {};
-  for (const [key, value] of Object.entries(conventions)) {
-    if (value === void 0) continue;
-    const convMeta = meta[key];
-    if (!convMeta || convMeta.confidence === "high") {
-      filtered[key] = value;
-    }
+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);
   }
-  return filtered;
 }
 
 // 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 chalk10 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 {
@@ -2972,10 +3358,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` };
@@ -2983,7 +3369,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 {
@@ -2993,23 +3379,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(`  ${chalk10.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(`  ${chalk10.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(`  ${chalk10.green("\u2713")} .git/hooks/pre-commit`);
@@ -3018,11 +3404,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()}
 
@@ -3039,10 +3425,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"]) {
@@ -3054,23 +3440,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(
         `  ${chalk10.yellow("!")} .claude/settings.json contains invalid JSON \u2014 skipping hook setup`
@@ -3096,30 +3482,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(`  ${chalk10.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(`  ${chalk10.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`;
@@ -3173,74 +3559,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 chalk11 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}
@@ -3266,7 +3652,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;
@@ -3290,6 +3676,9 @@ function setupSelectedIntegrations(projectRoot, integrations, opts) {
   const created = [];
   if (integrations.preCommitHook) {
     const t = setupPreCommitHook(projectRoot);
+    if (t && opts.lefthookExpected && !t.includes("lefthook")) {
+      console.log(`  ${chalk11.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) {
@@ -3318,34 +3707,34 @@ function setupSelectedIntegrations(projectRoot, integrations, opts) {
   return created;
 }
 
-// src/commands/init.ts
-var CONFIG_FILE5 = "viberails.config.json";
-function getExemptedPackages(config) {
-  return config.packages.filter((pkg) => pkg.rules?.testCoverage === 0 && pkg.path !== ".").map((pkg) => pkg.path);
-}
-async function initCommand(options, cwd) {
-  const projectRoot = findProjectRoot(cwd ?? process.cwd());
-  if (!projectRoot) {
-    throw new Error(
-      "No package.json found. Make sure you are inside a JS/TS project, then run:\n  npx viberails"
-    );
-  }
-  const configPath = path19.join(projectRoot, CONFIG_FILE5);
-  if (fs19.existsSync(configPath) && !options.force) {
-    if (!options.yes) {
-      return initInteractive(projectRoot, configPath, options);
+// src/commands/init-non-interactive.ts
+import * as fs20 from "fs";
+import * as path20 from "path";
+import * as clack11 from "@clack/prompts";
+import { compactConfig as compactConfig3, generateConfig } from "@viberails/config";
+import { scan as scan2 } from "@viberails/scanner";
+import chalk12 from "chalk";
+
+// src/utils/filter-confidence.ts
+function filterHighConfidence(conventions, meta) {
+  if (!meta) return conventions;
+  const filtered = {};
+  for (const [key, value] of Object.entries(conventions)) {
+    if (value === void 0) continue;
+    const convMeta = meta[key];
+    if (!convMeta || convMeta.confidence === "high") {
+      filtered[key] = value;
     }
-    console.log(
-      `${chalk12.yellow("!")} viberails is already initialized.
-  Run ${chalk12.cyan("viberails")} to review or edit the existing setup, ${chalk12.cyan("viberails sync")} to update generated files, or ${chalk12.cyan("viberails init --force")} to replace it.`
-    );
-    return;
   }
-  if (options.yes) return initNonInteractive(projectRoot, configPath);
-  await initInteractive(projectRoot, configPath, options);
+  return filtered;
+}
+
+// src/commands/init-non-interactive.ts
+function getExemptedPackages(config) {
+  return config.packages.filter((pkg) => pkg.rules?.testCoverage === 0 && pkg.path !== ".").map((pkg) => pkg.path);
 }
 async function initNonInteractive(projectRoot, configPath) {
-  const s = clack8.spinner();
+  const s = clack11.spinner();
   s.start("Scanning project...");
   const scanResult = await scan2(projectRoot);
   const config = generateConfig(scanResult);
@@ -3364,7 +3753,7 @@ async function initNonInteractive(projectRoot, configPath) {
     );
   }
   if (config.packages.length > 1) {
-    const bs = clack8.spinner();
+    const bs = clack11.spinner();
     bs.start("Building import graph...");
     const { buildImportGraph, inferBoundaries } = await import("@viberails/graph");
     const packages = resolveWorkspacePackages(projectRoot, config.packages);
@@ -3380,7 +3769,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);
@@ -3399,7 +3788,7 @@ async function initNonInteractive(projectRoot, configPath) {
   const preCommitTarget = hasHookManager ? setupPreCommitHook(projectRoot) : void 0;
   const ok = chalk12.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`,
@@ -3413,13 +3802,36 @@ async function initNonInteractive(projectRoot, configPath) {
 Created:
 ${created.map((f) => `  ${f}`).join("\n")}`);
 }
+
+// src/commands/init.ts
+var CONFIG_FILE5 = "viberails.config.json";
+async function initCommand(options, cwd) {
+  const projectRoot = findProjectRoot(cwd ?? process.cwd());
+  if (!projectRoot) {
+    throw new Error(
+      "No package.json found. Make sure you are inside a JS/TS project, then run:\n  npx viberails"
+    );
+  }
+  const configPath = path21.join(projectRoot, CONFIG_FILE5);
+  if (fs21.existsSync(configPath) && !options.force) {
+    if (!options.yes) {
+      return initInteractive(projectRoot, configPath, options);
+    }
+    console.log(
+      `${chalk13.yellow("!")} viberails is already initialized.
+  Run ${chalk13.cyan("viberails")} to review or edit the existing setup, ${chalk13.cyan("viberails sync")} to update generated files, or ${chalk13.cyan("viberails init --force")} to replace it.`
+    );
+    return;
+  }
+  if (options.yes) return initNonInteractive(projectRoot, configPath);
+  await initInteractive(projectRoot, configPath, options);
+}
 async function initInteractive(projectRoot, configPath, options) {
-  clack8.intro("viberails");
-  const replacingExistingConfig = fs19.existsSync(configPath);
-  if (fs19.existsSync(configPath) && !options.force) {
-    const action = await promptExistingConfigAction(path19.basename(configPath));
+  clack12.intro("viberails");
+  if (fs21.existsSync(configPath) && !options.force) {
+    const action = await promptExistingConfigAction(path21.basename(configPath));
     if (action === "cancel") {
-      clack8.outro("Aborted. No files were written.");
+      clack12.outro("Aborted. No files were written.");
       return;
     }
     if (action === "edit") {
@@ -3428,136 +3840,93 @@ async function initInteractive(projectRoot, configPath, options) {
     }
     options.force = true;
   }
-  if (fs19.existsSync(configPath) && options.force) {
+  if (fs21.existsSync(configPath) && options.force) {
     const replace = await confirmDangerous(
-      `${path19.basename(configPath)} already exists and will be replaced. Continue?`
+      `${path21.basename(configPath)} already exists and will be replaced. Continue?`
     );
     if (!replace) {
-      clack8.outro("Aborted. No files were written.");
+      clack12.outro("Aborted. No files were written.");
       return;
     }
   }
-  const s = clack8.spinner();
+  const s = clack12.spinner();
   s.start("Scanning project...");
-  const scanResult = await scan2(projectRoot);
-  const config = generateConfig(scanResult);
+  const scanResult = await scan3(projectRoot);
+  const config = generateConfig2(scanResult);
   s.stop("Scan complete");
   if (scanResult.statistics.totalFiles === 0) {
-    clack8.log.warn(
+    clack12.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 = getExemptedPackages(config);
-  let decision;
-  while (true) {
-    displayInitOverview(scanResult, config, exemptedPkgs);
-    const nextDecision = await promptInitDecision();
-    if (nextDecision === "review") {
-      clack8.note(formatScanResultsText(scanResult), "Detected details");
-      continue;
-    }
-    decision = nextDecision;
-    break;
-  }
-  if (decision === "customize") {
-    const rootPkg = config.packages.find((p) => p.path === ".") ?? config.packages[0];
-    const overrides = await promptRuleMenu({
-      maxFileLines: config.rules.maxFileLines,
-      testCoverage: config.rules.testCoverage,
-      enforceMissingTests: config.rules.enforceMissingTests,
-      enforceNaming: config.rules.enforceNaming,
-      fileNamingValue: rootPkg.conventions?.fileNaming,
-      coverageSummaryPath: "coverage/coverage-summary.json",
-      coverageCommand: config.defaults?.coverage?.command,
-      packageOverrides: config.packages
-    });
-    applyRuleOverrides(config, overrides);
-  }
-  if (config.packages.length > 1) {
-    clack8.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) {
+    clack12.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 confirm3("Infer boundary rules from current import patterns?");
-    if (shouldInfer) {
-      const bs = clack8.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) {
-    clack8.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: path19.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 confirm3("Apply this setup?");
   if (!shouldWrite) {
-    clack8.outro("Aborted. No files were written.");
+    clack12.outro("Aborted. No files were written.");
     return;
   }
-  const ws = clack8.spinner();
+  if (state.deferredInstalls.length > 0) {
+    await executeDeferredInstalls(projectRoot, state.deferredInstalls);
+  }
+  const ws = clack12.spinner();
   ws.start("Writing configuration...");
-  const compacted = compactConfig3(config);
-  fs19.writeFileSync(configPath, `${JSON.stringify(compacted, null, 2)}
+  const compacted = compactConfig4(config);
+  fs21.writeFileSync(configPath, `${JSON.stringify(compacted, null, 2)}
 `);
   writeGeneratedFiles(projectRoot, config, scanResult);
   updateGitignore(projectRoot);
   ws.stop("Configuration written");
-  const ok = chalk12.green("\u2713");
-  clack8.log.step(`${ok} ${path19.basename(configPath)}`);
-  clack8.log.step(`${ok} .viberails/context.md`);
-  clack8.log.step(`${ok} .viberails/scan-result.json`);
-  setupSelectedIntegrations(projectRoot, integrations, {
-    linter: rootPkgStack?.linter?.split("@")[0],
-    packageManager: rootPkgStack?.packageManager?.split("@")[0]
-  });
-  clack8.outro(
+  const ok = chalk13.green("\u2713");
+  clack12.log.step(`${ok} ${path21.basename(configPath)}`);
+  clack12.log.step(`${ok} .viberails/context.md`);
+  clack12.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
+    });
+  }
+  clack12.outro(
     `Done! Next: review viberails.config.json, then run viberails check
-  ${chalk12.dim("Tip: use")} ${chalk12.cyan("viberails check --enforce")} ${chalk12.dim("in CI to block PRs on violations.")}`
+  ${chalk13.dim("Tip: use")} ${chalk13.cyan("viberails check --enforce")} ${chalk13.dim("in CI to block PRs on violations.")}`
   );
 }
 
 // src/commands/sync.ts
-import * as fs20 from "fs";
-import * as path20 from "path";
-import * as clack9 from "@clack/prompts";
-import { compactConfig as compactConfig4, loadConfig as loadConfig5, mergeConfig as mergeConfig2 } from "@viberails/config";
-import { scan as scan3 } from "@viberails/scanner";
-import chalk13 from "chalk";
+import * as fs22 from "fs";
+import * as path22 from "path";
+import * as clack13 from "@clack/prompts";
+import { compactConfig as compactConfig5, loadConfig as loadConfig5, mergeConfig as mergeConfig2 } from "@viberails/config";
+import { scan as scan4 } from "@viberails/scanner";
+import chalk14 from "chalk";
 var CONFIG_FILE6 = "viberails.config.json";
 var SCAN_RESULT_FILE2 = ".viberails/scan-result.json";
 function loadPreviousStats(projectRoot) {
-  const scanResultPath = path20.join(projectRoot, SCAN_RESULT_FILE2);
+  const scanResultPath = path22.join(projectRoot, SCAN_RESULT_FILE2);
   try {
-    const raw = fs20.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;
@@ -3574,17 +3943,17 @@ async function syncCommand(options, cwd) {
       "No package.json found in this directory or any parent.\n\nMake sure you are inside a JavaScript or TypeScript project, then run:\n  npx viberails"
     );
   }
-  const configPath = path20.join(projectRoot, CONFIG_FILE6);
+  const configPath = path22.join(projectRoot, CONFIG_FILE6);
   const existing = await loadConfig5(configPath);
   const previousStats = loadPreviousStats(projectRoot);
-  const s = clack9.spinner();
+  const s = clack13.spinner();
   s.start("Scanning project...");
-  const scanResult = await scan3(projectRoot);
+  const scanResult = await scan4(projectRoot);
   s.stop("Scan complete");
   const merged = mergeConfig2(existing, scanResult);
-  const compacted = compactConfig4(merged);
+  const compacted = compactConfig5(merged);
   const compactedJson = JSON.stringify(compacted, null, 2);
-  const rawDisk = fs20.readFileSync(configPath, "utf-8").trim();
+  const rawDisk = fs22.readFileSync(configPath, "utf-8").trim();
   const diskWithoutSync = rawDisk.replace(/"lastSync":\s*"[^"]*"/, '"lastSync": ""');
   const mergedWithoutSync = compactedJson.replace(/"lastSync":\s*"[^"]*"/, '"lastSync": ""');
   const configChanged = diskWithoutSync !== mergedWithoutSync;
@@ -3592,19 +3961,19 @@ async function syncCommand(options, cwd) {
   const statsDelta = previousStats ? formatStatsDelta(previousStats, scanResult.statistics) : void 0;
   if (changes.length > 0 || statsDelta) {
     console.log(`
-${chalk13.bold("Changes:")}`);
+${chalk14.bold("Changes:")}`);
     for (const change of changes) {
-      const icon = change.type === "removed" ? chalk13.red("-") : chalk13.green("+");
+      const icon = change.type === "removed" ? chalk14.red("-") : chalk14.green("+");
       console.log(`  ${icon} ${change.description}`);
     }
     if (statsDelta) {
-      console.log(`  ${chalk13.dim(statsDelta)}`);
+      console.log(`  ${chalk14.dim(statsDelta)}`);
     }
   }
   if (options?.interactive) {
-    clack9.intro("viberails sync (interactive)");
-    clack9.note(formatRulesText(merged).join("\n"), "Rules after sync");
-    const decision = await clack9.select({
+    clack13.intro("viberails sync (interactive)");
+    clack13.note(formatRulesText(merged).join("\n"), "Rules after sync");
+    const decision = await clack13.select({
       message: "How would you like to proceed?",
       options: [
         { value: "accept", label: "Accept changes" },
@@ -3614,47 +3983,51 @@ ${chalk13.bold("Changes:")}`);
     });
     assertNotCancelled(decision);
     if (decision === "cancel") {
-      clack9.outro("Sync cancelled. No files were written.");
+      clack13.outro("Sync cancelled. No files were written.");
       return;
     }
     if (decision === "customize") {
       const rootPkg = merged.packages.find((p) => p.path === ".") ?? merged.packages[0];
       const overrides = await promptRuleMenu({
         maxFileLines: merged.rules.maxFileLines,
+        maxTestFileLines: merged.rules.maxTestFileLines,
         testCoverage: merged.rules.testCoverage,
         enforceMissingTests: merged.rules.enforceMissingTests,
         enforceNaming: merged.rules.enforceNaming,
         fileNamingValue: rootPkg.conventions?.fileNaming,
+        componentNaming: rootPkg.conventions?.componentNaming,
+        hookNaming: rootPkg.conventions?.hookNaming,
+        importAlias: rootPkg.conventions?.importAlias,
         coverageSummaryPath: rootPkg.coverage?.summaryPath ?? "coverage/coverage-summary.json",
         coverageCommand: merged.defaults?.coverage?.command,
         packageOverrides: merged.packages
       });
       applyRuleOverrides(merged, overrides);
-      const recompacted = compactConfig4(merged);
-      fs20.writeFileSync(configPath, `${JSON.stringify(recompacted, null, 2)}
+      const recompacted = compactConfig5(merged);
+      fs22.writeFileSync(configPath, `${JSON.stringify(recompacted, null, 2)}
 `);
       writeGeneratedFiles(projectRoot, merged, scanResult);
-      clack9.log.success("Updated config with your customizations.");
-      clack9.outro("Done! Run viberails check to verify.");
+      clack13.log.success("Updated config with your customizations.");
+      clack13.outro("Done! Run viberails check to verify.");
       return;
     }
   }
-  fs20.writeFileSync(configPath, `${compactedJson}
+  fs22.writeFileSync(configPath, `${compactedJson}
 `);
   writeGeneratedFiles(projectRoot, merged, scanResult);
   console.log(`
-${chalk13.bold("Synced:")}`);
+${chalk14.bold("Synced:")}`);
   if (configChanged) {
-    console.log(`  ${chalk13.yellow("!")} ${CONFIG_FILE6} \u2014 updated (review changes)`);
+    console.log(`  ${chalk14.yellow("!")} ${CONFIG_FILE6} \u2014 updated (review changes)`);
   } else {
-    console.log(`  ${chalk13.green("\u2713")} ${CONFIG_FILE6} \u2014 unchanged`);
+    console.log(`  ${chalk14.green("\u2713")} ${CONFIG_FILE6} \u2014 unchanged`);
   }
-  console.log(`  ${chalk13.green("\u2713")} .viberails/context.md \u2014 regenerated`);
-  console.log(`  ${chalk13.green("\u2713")} .viberails/scan-result.json \u2014 updated`);
+  console.log(`  ${chalk14.green("\u2713")} .viberails/context.md \u2014 regenerated`);
+  console.log(`  ${chalk14.green("\u2713")} .viberails/scan-result.json \u2014 updated`);
 }
 
 // src/index.ts
-var VERSION = "0.6.4";
+var VERSION = "0.6.6";
 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) => {
@@ -3662,7 +4035,7 @@ program.command("init", { isDefault: true }).description("Scan your project and
     await initCommand(options);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    console.error(`${chalk14.red("Error:")} ${message}`);
+    console.error(`${chalk15.red("Error:")} ${message}`);
     process.exit(1);
   }
 });
@@ -3671,7 +4044,7 @@ program.command("sync").description("Re-scan and update generated files").option
     await syncCommand(options);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    console.error(`${chalk14.red("Error:")} ${message}`);
+    console.error(`${chalk15.red("Error:")} ${message}`);
     process.exit(1);
   }
 });
@@ -3680,7 +4053,7 @@ program.command("config").description("Interactively edit existing config rules"
     await configCommand(options);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    console.error(`${chalk14.red("Error:")} ${message}`);
+    console.error(`${chalk15.red("Error:")} ${message}`);
     process.exit(1);
   }
 });
@@ -3701,7 +4074,7 @@ program.command("check").description("Check files against enforced rules").optio
       process.exit(exitCode);
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
-      console.error(`${chalk14.red("Error:")} ${message}`);
+      console.error(`${chalk15.red("Error:")} ${message}`);
       process.exit(1);
     }
   }
@@ -3712,7 +4085,7 @@ program.command("fix").description("Auto-fix file naming violations and generate
     process.exit(exitCode);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    console.error(`${chalk14.red("Error:")} ${message}`);
+    console.error(`${chalk15.red("Error:")} ${message}`);
     process.exit(1);
   }
 });
@@ -3721,7 +4094,7 @@ program.command("boundaries").description("Display, infer, or inspect import bou
     await boundariesCommand(options);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    console.error(`${chalk14.red("Error:")} ${message}`);
+    console.error(`${chalk15.red("Error:")} ${message}`);
     process.exit(1);
   }
 });