viberails 0.6.9 → 0.6.11

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import chalk18 from "chalk";
+import chalk20 from "chalk";
 import { Command } from "commander";
 
 // src/commands/boundaries.ts
@@ -129,12 +129,12 @@ async function promptNamingMenu(state) {
       },
       {
         value: "componentNaming",
-        label: `${state.componentNaming ? ok : unset} Component naming`,
+        label: `${state.componentNaming ? ok : unset} Component exports`,
         hint: state.componentNaming ?? HINT_NOT_SET
       },
       {
         value: "hookNaming",
-        label: `${state.hookNaming ? ok : unset} Hook naming`,
+        label: `${state.hookNaming ? ok : unset} Hook exports`,
         hint: state.hookNaming ?? HINT_NOT_SET
       },
       {
@@ -171,7 +171,7 @@ async function promptNamingMenu(state) {
     }
     if (choice === "componentNaming") {
       const selected = await clack.select({
-        message: "Component naming convention",
+        message: "Component export naming (e.g. UserProfile)",
         options: [
           ...COMPONENT_NAMING_OPTIONS,
           { value: SENTINEL_CLEAR, label: "Clear (no convention)" }
@@ -183,7 +183,7 @@ async function promptNamingMenu(state) {
     }
     if (choice === "hookNaming") {
       const selected = await clack.select({
-        message: "Hook naming convention",
+        message: "Hook export naming (e.g. useAuth)",
         options: [
           ...HOOK_NAMING_OPTIONS,
           { value: SENTINEL_CLEAR, label: "Clear (no convention)" }
@@ -1419,9 +1419,9 @@ async function checkCommand(options, cwd) {
   }
   const violations = [];
   const severity = options.enforce ? "error" : "warn";
-  const log9 = options.format !== "json" && !options.hook && !options.quiet ? (msg) => process.stderr.write(chalk5.dim(msg)) : () => {
+  const log10 = options.format !== "json" && !options.hook && !options.quiet ? (msg) => process.stderr.write(chalk5.dim(msg)) : () => {
   };
-  log9("  Checking files...");
+  log10("  Checking files...");
   for (const file of filesToCheck) {
     const absPath = path7.isAbsolute(file) ? file : path7.join(projectRoot, file);
     const relPath = path7.relative(projectRoot, absPath);
@@ -1454,9 +1454,9 @@ async function checkCommand(options, cwd) {
       }
     }
   }
-  log9(" done\n");
+  log10(" done\n");
   if (!options.files) {
-    log9("  Checking missing tests...");
+    log10("  Checking missing tests...");
     const testViolations = checkMissingTests(projectRoot, config, severity);
     if (options.staged) {
       const stagedSet = new Set(filesToCheck);
@@ -1469,14 +1469,14 @@ async function checkCommand(options, cwd) {
     } else {
       violations.push(...testViolations);
     }
-    log9(" done\n");
+    log10(" done\n");
   }
   if (!options.files && !options.staged && !options.diffBase) {
-    log9("  Running test coverage...\n");
+    log10("  Running test coverage...\n");
     const coverageViolations = checkCoverage(projectRoot, config, filesToCheck, {
       staged: options.staged,
       enforce: options.enforce,
-      onProgress: (pkg) => log9(`    Coverage: ${pkg}...
+      onProgress: (pkg) => log10(`    Coverage: ${pkg}...
 `)
     });
     violations.push(...coverageViolations);
@@ -1501,7 +1501,7 @@ async function checkCommand(options, cwd) {
         severity
       });
     }
-    log9(`  Boundary check: ${graph.nodes.length} files in ${Date.now() - startTime}ms
+    log10(`  Boundary check: ${graph.nodes.length} files in ${Date.now() - startTime}ms
 `);
   }
   if (options.format === "json") {
@@ -2795,10 +2795,10 @@ ${chalk10.yellow("!")} No safe fixes to apply. Resolve aliased imports first.`);
 // src/commands/init.ts
 import * as fs21 from "fs";
 import * as path21 from "path";
-import * as clack13 from "@clack/prompts";
+import * as clack14 from "@clack/prompts";
 import { compactConfig as compactConfig4, generateConfig as generateConfig2 } from "@viberails/config";
 import { scan as scan3 } from "@viberails/scanner";
-import chalk16 from "chalk";
+import chalk18 from "chalk";
 
 // src/utils/check-prerequisites.ts
 import * as fs14 from "fs";
@@ -2905,15 +2905,7 @@ async function executeDeferredInstalls(projectRoot, installs) {
   return successCount;
 }
 
-// src/utils/prompt-main-menu.ts
-import * as clack11 from "@clack/prompts";
-
-// src/utils/prompt-main-menu-handlers.ts
-import * as clack10 from "@clack/prompts";
-
 // src/utils/prompt-integrations.ts
-import * as fs15 from "fs";
-import * as path15 from "path";
 import * as clack9 from "@clack/prompts";
 function buildLefthookInstallCommand(pm, isWorkspace) {
   if (pm === "yarn") return "yarn add -D lefthook";
@@ -2921,26 +2913,24 @@ function buildLefthookInstallCommand(pm, isWorkspace) {
   if (pm === "npm") return "npm install -D lefthook";
   return `${pm} add -D lefthook`;
 }
-async function promptIntegrationsDeferred(hookManager, tools, packageManager, isWorkspace, projectRoot) {
+async function promptIntegrationsDeferred(hookManager, tools) {
+  const hasHookManager = !!hookManager;
   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";
+  const hookLabel = hasHookManager ? `Pre-commit hook (${hookManager})` : "Pre-commit hook";
+  const hookHint = hasHookManager ? "runs viberails checks when you commit" : "local hook only \u2014 use lefthook or husky to commit hooks to repo";
   options.push({ value: "preCommit", label: hookLabel, hint: hookHint });
-  if (tools?.isTypeScript) {
+  if (tools?.typecheckLabel) {
     options.push({
       value: "typecheck",
-      label: "Typecheck (tsc --noEmit)",
+      label: `Typecheck (${tools.typecheckLabel})`,
       hint: "pre-commit hook + CI check"
     });
+  } else if (tools?.isTypeScript) {
+    options.push({
+      value: "typecheck",
+      label: "Typecheck",
+      hint: "needs root tsconfig.json, typecheck script, or turbo task"
+    });
   }
   if (tools?.linter) {
     const linterName = tools.linter === "biome" ? "Biome" : "ESLint";
@@ -2967,7 +2957,12 @@ async function promptIntegrationsDeferred(hookManager, tools, packageManager, is
       hint: "blocks PRs that fail viberails check"
     }
   );
-  const initialValues = options.map((o) => o.value);
+  const hasTypecheck = !!tools?.typecheckLabel;
+  const initialValues = options.filter((o) => {
+    if (o.value === "preCommit" && !hasHookManager) return false;
+    if (o.value === "typecheck" && !hasTypecheck) return false;
+    return true;
+  }).map((o) => o.value);
   const result = await clack9.multiselect({
     message: "Integrations",
     options,
@@ -2975,20 +2970,6 @@ async function promptIntegrationsDeferred(hookManager, tools, packageManager, is
     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"),
@@ -2997,39 +2978,16 @@ async function promptIntegrationsDeferred(hookManager, tools, packageManager, is
       githubAction: result.includes("githubAction"),
       typecheckHook: result.includes("typecheck"),
       lintHook: result.includes("lint")
-    },
-    lefthookInstall
+    }
   };
 }
 
+// src/utils/prompt-main-menu.ts
+import * as clack11 from "@clack/prompts";
+
 // src/utils/prompt-main-menu-handlers.ts
-async function handleAdvancedNaming(config) {
-  const rootPkg = getRootPackage(config.packages);
-  const state = {
-    maxFileLines: config.rules.maxFileLines,
-    maxTestFileLines: config.rules.maxTestFileLines,
-    testCoverage: config.rules.testCoverage,
-    enforceMissingTests: config.rules.enforceMissingTests,
-    enforceNaming: config.rules.enforceNaming,
-    fileNamingValue: rootPkg.conventions?.fileNaming,
-    componentNaming: rootPkg.conventions?.componentNaming,
-    hookNaming: rootPkg.conventions?.hookNaming,
-    importAlias: rootPkg.conventions?.importAlias,
-    coverageSummaryPath: rootPkg.coverage?.summaryPath ?? "coverage/coverage-summary.json",
-    coverageCommand: config.defaults?.coverage?.command
-  };
-  await promptNamingMenu(state);
-  rootPkg.conventions = rootPkg.conventions ?? {};
-  config.rules.enforceNaming = state.enforceNaming;
-  if (state.fileNamingValue) {
-    rootPkg.conventions.fileNaming = state.fileNamingValue;
-  } else {
-    delete rootPkg.conventions.fileNaming;
-  }
-  rootPkg.conventions.componentNaming = state.componentNaming || void 0;
-  rootPkg.conventions.hookNaming = state.hookNaming || void 0;
-  rootPkg.conventions.importAlias = state.importAlias || void 0;
-}
+import * as clack10 from "@clack/prompts";
+import chalk12 from "chalk";
 async function handleFileNaming(config, scanResult) {
   const isMonorepo = config.packages.length > 1;
   if (isMonorepo) {
@@ -3169,24 +3127,95 @@ async function handleBoundaries(config, state, opts) {
     clack10.log.warn(`Boundary inference failed: ${err instanceof Error ? err.message : err}`);
   }
 }
-async function handleIntegrations(state, opts) {
-  const result = await promptIntegrationsDeferred(
-    state.hookManager,
-    opts.tools,
-    opts.tools.packageManager,
-    opts.tools.isWorkspace,
-    opts.projectRoot
-  );
-  state.visited.integrations = true;
-  state.integrations = result.choice;
-  state.deferredInstalls = state.deferredInstalls.filter((d) => !d.command.includes("lefthook"));
-  if (result.lefthookInstall) {
-    state.deferredInstalls.push(result.lefthookInstall);
+async function handleAiContext(config) {
+  const rootPkg = getRootPackage(config.packages);
+  rootPkg.conventions = rootPkg.conventions ?? {};
+  while (true) {
+    const ok = chalk12.green("\u2713");
+    const unset = chalk12.dim("-");
+    const options = [
+      {
+        value: "componentNaming",
+        label: `${rootPkg.conventions.componentNaming ? ok : unset} Component exports`,
+        hint: rootPkg.conventions.componentNaming ?? "not set"
+      },
+      {
+        value: "hookNaming",
+        label: `${rootPkg.conventions.hookNaming ? ok : unset} Hook exports`,
+        hint: rootPkg.conventions.hookNaming ?? "not set"
+      },
+      {
+        value: "importAlias",
+        label: `${rootPkg.conventions.importAlias ? ok : unset} Import alias`,
+        hint: rootPkg.conventions.importAlias ?? "not set"
+      },
+      { value: "back", label: "  Back" }
+    ];
+    const choice = await clack10.select({
+      message: "AI context \u2014 conventions written to context.md for AI tools",
+      options
+    });
+    if (isCancelled(choice) || choice === "back") return;
+    if (choice === "componentNaming") {
+      const selected = await clack10.select({
+        message: "Component export naming (e.g. UserProfile)",
+        options: [
+          ...COMPONENT_NAMING_OPTIONS,
+          { value: SENTINEL_CLEAR, label: "Clear (no convention)" }
+        ],
+        initialValue: rootPkg.conventions.componentNaming ?? SENTINEL_CLEAR
+      });
+      if (isCancelled(selected)) continue;
+      rootPkg.conventions.componentNaming = selected === SENTINEL_CLEAR ? void 0 : selected;
+    }
+    if (choice === "hookNaming") {
+      const selected = await clack10.select({
+        message: "Hook export naming (e.g. useAuth)",
+        options: [
+          ...HOOK_NAMING_OPTIONS,
+          { value: SENTINEL_CLEAR, label: "Clear (no convention)" }
+        ],
+        initialValue: rootPkg.conventions.hookNaming ?? SENTINEL_CLEAR
+      });
+      if (isCancelled(selected)) continue;
+      rootPkg.conventions.hookNaming = selected === SENTINEL_CLEAR ? void 0 : selected;
+    }
+    if (choice === "importAlias") {
+      const selected = await clack10.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: rootPkg.conventions.importAlias ?? SENTINEL_CLEAR
+      });
+      if (isCancelled(selected)) continue;
+      if (selected === SENTINEL_CLEAR) {
+        rootPkg.conventions.importAlias = void 0;
+      } else if (selected === SENTINEL_CUSTOM) {
+        const result = await clack10.text({
+          message: "Custom import alias (e.g. #/*)?",
+          initialValue: rootPkg.conventions.importAlias ?? "",
+          placeholder: "e.g. #/*",
+          validate: (v) => {
+            if (typeof v !== "string" || !v.trim()) return "Alias cannot be empty";
+            if (!/^[a-zA-Z@~#$][a-zA-Z0-9@~#$_-]*\/\*$/.test(v.trim()))
+              return "Must match pattern like @/*, ~/*, or #src/*";
+          }
+        });
+        if (isCancelled(result)) continue;
+        rootPkg.conventions.importAlias = result.trim();
+      } else {
+        rootPkg.conventions.importAlias = selected;
+      }
+    }
   }
 }
 
 // src/utils/prompt-main-menu-hints.ts
-import chalk12 from "chalk";
+import chalk13 from "chalk";
 function fileLimitsHint(config) {
   const max = config.rules.maxFileLines;
   const test = config.rules.maxTestFileLines;
@@ -3202,7 +3231,7 @@ function fileNamingHint(config, scanResult) {
     );
     return detected ? `${naming} (detected)` : naming;
   }
-  return "mixed \u2014 will not enforce if skipped";
+  return "not set \u2014 select to configure";
 }
 function fileNamingStatus(config) {
   if (!config.rules.enforceNaming) return "unconfigured";
@@ -3229,30 +3258,27 @@ function coverageHint(config, hasTestRunner) {
   }
   return `${config.rules.testCoverage}%`;
 }
-function advancedNamingHint(config) {
+function aiContextHint(config) {
   const rootPkg = getRootPackage(config.packages);
-  if (!config.rules.enforceNaming) return "not enforced";
-  const ok = chalk12.green("\u2713");
-  const no = chalk12.dim("\u2717");
-  const parts = [
-    `${rootPkg.conventions?.fileNaming ? ok : no} file naming`,
-    `${rootPkg.conventions?.componentNaming ? ok : no} components`,
-    `${rootPkg.conventions?.hookNaming ? ok : no} hooks`,
-    `${rootPkg.conventions?.importAlias ? ok : no} alias`
-  ];
-  return parts.join(chalk12.dim(", "));
-}
-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(chalk12.green("pre-commit"));
-  if (state.integrations.typecheckHook) items.push(chalk12.green("typecheck"));
-  if (state.integrations.lintHook) items.push(chalk12.green("lint"));
-  if (state.integrations.claudeCodeHook) items.push(chalk12.green("Claude"));
-  if (state.integrations.claudeMdRef) items.push(chalk12.green("CLAUDE.md"));
-  if (state.integrations.githubAction) items.push(chalk12.green("CI"));
-  return items.length > 0 ? items.join(chalk12.dim(" \xB7 ")) : "none selected";
+  const count = [
+    rootPkg.conventions?.componentNaming,
+    rootPkg.conventions?.hookNaming,
+    rootPkg.conventions?.importAlias
+  ].filter(Boolean).length;
+  if (count === 3) return "all set";
+  if (count > 0) return `${count} of 3 conventions`;
+  return "none set \u2014 optional AI guidelines";
+}
+function aiContextStatus(config) {
+  const rootPkg = getRootPackage(config.packages);
+  const count = [
+    rootPkg.conventions?.componentNaming,
+    rootPkg.conventions?.hookNaming,
+    rootPkg.conventions?.importAlias
+  ].filter(Boolean).length;
+  if (count === 3) return "ok";
+  if (count > 0) return "partial";
+  return "unconfigured";
 }
 function packageOverridesHint(config) {
   const rootNaming = getRootPackage(config.packages).conventions?.fileNaming;
@@ -3270,17 +3296,6 @@ function boundariesHint(config, state) {
   const pkgCount = Object.keys(deny).length;
   return `${ruleCount} rules across ${pkgCount} packages`;
 }
-function advancedNamingStatus(config) {
-  if (!config.rules.enforceNaming) return "unconfigured";
-  const rootPkg = getRootPackage(config.packages);
-  const hasFile = !!rootPkg.conventions?.fileNaming;
-  const hasComp = !!rootPkg.conventions?.componentNaming;
-  const hasHook = !!rootPkg.conventions?.hookNaming;
-  const hasAlias = !!rootPkg.conventions?.importAlias;
-  if (hasFile && hasComp && hasHook && hasAlias) return "ok";
-  if (hasFile || hasComp || hasHook || hasAlias) return "partial";
-  return "unconfigured";
-}
 function packageOverridesStatus(config) {
   const rootNaming = getRootPackage(config.packages).conventions?.fileNaming;
   const editable = config.packages.filter((p) => p.path !== ".");
@@ -3290,10 +3305,10 @@ function packageOverridesStatus(config) {
   return customized ? "ok" : "unconfigured";
 }
 function statusIcon(status) {
-  if (status === "ok") return chalk12.green("\u2713");
-  if (status === "needs-input") return chalk12.yellow("?");
-  if (status === "unconfigured") return chalk12.dim("-");
-  return chalk12.yellow("~");
+  if (status === "ok") return chalk13.green("\u2713");
+  if (status === "needs-input") return chalk13.yellow("?");
+  if (status === "unconfigured") return chalk13.dim("-");
+  return chalk13.yellow("~");
 }
 function buildMainMenuOptions(config, scanResult, state) {
   const namingStatus = fileNamingStatus(config);
@@ -3307,7 +3322,7 @@ function buildMainMenuOptions(config, scanResult, state) {
     },
     {
       value: "fileNaming",
-      label: `${statusIcon(namingStatus)} Default file naming`,
+      label: `${statusIcon(namingStatus)} File naming`,
       hint: fileNamingHint(config, scanResult)
     },
     {
@@ -3321,9 +3336,9 @@ function buildMainMenuOptions(config, scanResult, state) {
       hint: coverageHint(config, state.hasTestRunner)
     },
     {
-      value: "advancedNaming",
-      label: `${statusIcon(advancedNamingStatus(config))} Advanced naming`,
-      hint: advancedNamingHint(config)
+      value: "aiContext",
+      label: `${statusIcon(aiContextStatus(config))} AI context`,
+      hint: aiContextHint(config)
     }
   ];
   if (config.packages.length > 1) {
@@ -3340,9 +3355,7 @@ function buildMainMenuOptions(config, scanResult, state) {
       { value: "boundaries", label: `${bIcon} Boundaries`, hint: boundariesHint(config, state) }
     );
   }
-  const iIcon = state.visited.integrations ? statusIcon("ok") : statusIcon("unconfigured");
   options.push(
-    { value: "integrations", label: `${iIcon} Integrations`, hint: integrationsHint(state) },
     { value: "reset", label: "  Reset all to defaults" },
     { value: "review", label: "  Review scan details", hint: "detected stack & conventions" },
     { value: "done", label: "  Done \u2014 write config" }
@@ -3354,7 +3367,7 @@ function buildMainMenuOptions(config, scanResult, state) {
 async function promptMainMenu(config, scanResult, opts) {
   const originalConfig = structuredClone(config);
   const state = {
-    visited: { integrations: false, boundaries: false },
+    visited: { boundaries: false },
     deferredInstalls: [],
     hasTestRunner: opts.hasTestRunner,
     hookManager: opts.hookManager
@@ -3381,10 +3394,9 @@ async function promptMainMenu(config, scanResult, opts) {
     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 === "aiContext") await handleAiContext(config);
     if (choice === "packageOverrides") await handlePackageOverrides(config);
     if (choice === "boundaries") await handleBoundaries(config, state, opts);
-    if (choice === "integrations") await handleIntegrations(state, opts);
     if (choice === "review") clack11.note(formatScanResultsText(scanResult), "Scan details");
     if (choice === "reset") {
       const confirmed = await clack11.confirm({
@@ -3395,8 +3407,7 @@ async function promptMainMenu(config, scanResult, opts) {
       if (confirmed) {
         Object.assign(config, structuredClone(originalConfig));
         state.deferredInstalls = [];
-        state.visited = { integrations: false, boundaries: false };
-        state.integrations = void 0;
+        state.visited = { boundaries: false };
         clack11.log.info("Reset all settings to scan-detected defaults.");
       }
     }
@@ -3404,37 +3415,26 @@ async function promptMainMenu(config, scanResult, opts) {
   return state;
 }
 
-// src/utils/update-gitignore.ts
-import * as fs16 from "fs";
-import * as path16 from "path";
-function updateGitignore(projectRoot) {
-  const gitignorePath = path16.join(projectRoot, ".gitignore");
-  let content = "";
-  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()}
-`;
-    fs16.writeFileSync(gitignorePath, `${prefix}${block}`);
-  }
-}
+// src/utils/prompt-prereqs.ts
+import * as fs17 from "fs";
+import * as path17 from "path";
+import * as clack12 from "@clack/prompts";
+import chalk15 from "chalk";
 
 // src/commands/init-hooks.ts
-import * as fs18 from "fs";
-import * as path18 from "path";
-import chalk13 from "chalk";
+import * as fs16 from "fs";
+import * as path16 from "path";
+import chalk14 from "chalk";
 import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
 
 // src/commands/resolve-typecheck.ts
-import * as fs17 from "fs";
-import * as path17 from "path";
+import * as fs15 from "fs";
+import * as path15 from "path";
 function hasTurboTask(projectRoot, taskName) {
-  const turboPath = path17.join(projectRoot, "turbo.json");
-  if (!fs17.existsSync(turboPath)) return false;
+  const turboPath = path15.join(projectRoot, "turbo.json");
+  if (!fs15.existsSync(turboPath)) return false;
   try {
-    const turbo = JSON.parse(fs17.readFileSync(turboPath, "utf-8"));
+    const turbo = JSON.parse(fs15.readFileSync(turboPath, "utf-8"));
     const tasks = turbo.tasks ?? turbo.pipeline ?? {};
     return taskName in tasks;
   } catch {
@@ -3445,10 +3445,10 @@ function resolveTypecheckCommand(projectRoot, packageManager) {
   if (hasTurboTask(projectRoot, "typecheck")) {
     return { command: "npx turbo typecheck", label: "turbo typecheck" };
   }
-  const pkgJsonPath = path17.join(projectRoot, "package.json");
-  if (fs17.existsSync(pkgJsonPath)) {
+  const pkgJsonPath = path15.join(projectRoot, "package.json");
+  if (fs15.existsSync(pkgJsonPath)) {
     try {
-      const pkg = JSON.parse(fs17.readFileSync(pkgJsonPath, "utf-8"));
+      const pkg = JSON.parse(fs15.readFileSync(pkgJsonPath, "utf-8"));
       if (pkg.scripts?.typecheck) {
         const pm = packageManager ?? "npm";
         return { command: `${pm} run typecheck`, label: `${pm} run typecheck` };
@@ -3456,7 +3456,7 @@ function resolveTypecheckCommand(projectRoot, packageManager) {
     } catch {
     }
   }
-  if (fs17.existsSync(path17.join(projectRoot, "tsconfig.json"))) {
+  if (fs15.existsSync(path15.join(projectRoot, "tsconfig.json"))) {
     return { command: "npx tsc --noEmit", label: "tsc --noEmit" };
   }
   return {
@@ -3466,36 +3466,36 @@ function resolveTypecheckCommand(projectRoot, packageManager) {
 
 // src/commands/init-hooks.ts
 function setupPreCommitHook(projectRoot) {
-  const lefthookPath = path18.join(projectRoot, "lefthook.yml");
-  if (fs18.existsSync(lefthookPath)) {
+  const lefthookPath = path16.join(projectRoot, "lefthook.yml");
+  if (fs16.existsSync(lefthookPath)) {
     addLefthookPreCommit(lefthookPath);
-    console.log(`  ${chalk13.green("\u2713")} lefthook.yml \u2014 added viberails pre-commit`);
+    console.log(`  ${chalk14.green("\u2713")} lefthook.yml \u2014 added viberails pre-commit`);
     return "lefthook.yml";
   }
-  const huskyDir = path18.join(projectRoot, ".husky");
-  if (fs18.existsSync(huskyDir)) {
+  const huskyDir = path16.join(projectRoot, ".husky");
+  if (fs16.existsSync(huskyDir)) {
     writeHuskyPreCommit(huskyDir);
-    console.log(`  ${chalk13.green("\u2713")} .husky/pre-commit \u2014 added viberails check`);
+    console.log(`  ${chalk14.green("\u2713")} .husky/pre-commit \u2014 added viberails check`);
     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 gitDir = path16.join(projectRoot, ".git");
+  if (fs16.existsSync(gitDir)) {
+    const hooksDir = path16.join(gitDir, "hooks");
+    if (!fs16.existsSync(hooksDir)) {
+      fs16.mkdirSync(hooksDir, { recursive: true });
     }
     writeGitHookPreCommit(hooksDir);
-    console.log(`  ${chalk13.green("\u2713")} .git/hooks/pre-commit`);
+    console.log(`  ${chalk14.green("\u2713")} .git/hooks/pre-commit`);
     return ".git/hooks/pre-commit";
   }
   return void 0;
 }
 function writeGitHookPreCommit(hooksDir) {
-  const hookPath = path18.join(hooksDir, "pre-commit");
-  if (fs18.existsSync(hookPath)) {
-    const existing = fs18.readFileSync(hookPath, "utf-8");
+  const hookPath = path16.join(hooksDir, "pre-commit");
+  if (fs16.existsSync(hookPath)) {
+    const existing = fs16.readFileSync(hookPath, "utf-8");
     if (existing.includes("viberails")) return;
-    fs18.writeFileSync(
+    fs16.writeFileSync(
       hookPath,
       `${existing.trimEnd()}
 
@@ -3512,10 +3512,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");
-  fs18.writeFileSync(hookPath, script, { mode: 493 });
+  fs16.writeFileSync(hookPath, script, { mode: 493 });
 }
 function addLefthookPreCommit(lefthookPath) {
-  const content = fs18.readFileSync(lefthookPath, "utf-8");
+  const content = fs16.readFileSync(lefthookPath, "utf-8");
   if (content.includes("viberails")) return;
   const doc = parseYaml(content) ?? {};
   if (!doc["pre-commit"]) {
@@ -3527,28 +3527,28 @@ 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"
   };
-  fs18.writeFileSync(lefthookPath, stringifyYaml(doc));
+  fs16.writeFileSync(lefthookPath, stringifyYaml(doc));
 }
 function detectHookManager(projectRoot) {
-  if (fs18.existsSync(path18.join(projectRoot, "lefthook.yml"))) return "Lefthook";
-  if (fs18.existsSync(path18.join(projectRoot, ".husky"))) return "Husky";
+  if (fs16.existsSync(path16.join(projectRoot, "lefthook.yml"))) return "Lefthook";
+  if (fs16.existsSync(path16.join(projectRoot, ".husky"))) return "Husky";
   return void 0;
 }
 function setupClaudeCodeHook(projectRoot) {
-  const claudeDir = path18.join(projectRoot, ".claude");
-  if (!fs18.existsSync(claudeDir)) {
-    fs18.mkdirSync(claudeDir, { recursive: true });
+  const claudeDir = path16.join(projectRoot, ".claude");
+  if (!fs16.existsSync(claudeDir)) {
+    fs16.mkdirSync(claudeDir, { recursive: true });
   }
-  const settingsPath = path18.join(claudeDir, "settings.json");
+  const settingsPath = path16.join(claudeDir, "settings.json");
   let settings = {};
-  if (fs18.existsSync(settingsPath)) {
+  if (fs16.existsSync(settingsPath)) {
     try {
-      settings = JSON.parse(fs18.readFileSync(settingsPath, "utf-8"));
+      settings = JSON.parse(fs16.readFileSync(settingsPath, "utf-8"));
     } catch {
       console.warn(
-        `  ${chalk13.yellow("!")} .claude/settings.json contains invalid JSON \u2014 skipping hook setup`
+        `  ${chalk14.yellow("!")} .claude/settings.json contains invalid JSON \u2014 skipping hook setup`
       );
-      console.warn(`  Fix the JSON manually, then re-run ${chalk13.cyan("viberails init --force")}`);
+      console.warn(`  Fix the JSON manually, then re-run ${chalk14.cyan("viberails init --force")}`);
       return;
     }
   }
@@ -3569,30 +3569,30 @@ function setupClaudeCodeHook(projectRoot) {
     }
   ];
   settings.hooks = hooks;
-  fs18.writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}
+  fs16.writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}
 `);
-  console.log(`  ${chalk13.green("\u2713")} .claude/settings.json \u2014 added viberails PostToolUse hook`);
+  console.log(`  ${chalk14.green("\u2713")} .claude/settings.json \u2014 added viberails PostToolUse hook`);
 }
 function setupClaudeMdReference(projectRoot) {
-  const claudeMdPath = path18.join(projectRoot, "CLAUDE.md");
+  const claudeMdPath = path16.join(projectRoot, "CLAUDE.md");
   let content = "";
-  if (fs18.existsSync(claudeMdPath)) {
-    content = fs18.readFileSync(claudeMdPath, "utf-8");
+  if (fs16.existsSync(claudeMdPath)) {
+    content = fs16.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();
-  fs18.writeFileSync(claudeMdPath, prefix + ref);
-  console.log(`  ${chalk13.green("\u2713")} CLAUDE.md \u2014 added @.viberails/context.md reference`);
+  fs16.writeFileSync(claudeMdPath, prefix + ref);
+  console.log(`  ${chalk14.green("\u2713")} CLAUDE.md \u2014 added @.viberails/context.md reference`);
 }
 function setupGithubAction(projectRoot, packageManager, options) {
-  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");
+  const workflowDir = path16.join(projectRoot, ".github", "workflows");
+  const workflowPath = path16.join(workflowDir, "viberails.yml");
+  if (fs16.existsSync(workflowPath)) {
+    const existing = fs16.readFileSync(workflowPath, "utf-8");
     if (existing.includes("viberails")) return void 0;
   }
-  fs18.mkdirSync(workflowDir, { recursive: true });
+  fs16.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`;
@@ -3646,30 +3646,212 @@ function setupGithubAction(projectRoot, packageManager, options) {
     ""
   );
   const content = lines.filter((l) => l !== void 0).join("\n");
-  fs18.writeFileSync(workflowPath, content);
+  fs16.writeFileSync(workflowPath, content);
   return ".github/workflows/viberails.yml";
 }
 function writeHuskyPreCommit(huskyDir) {
-  const hookPath = path18.join(huskyDir, "pre-commit");
+  const hookPath = path16.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 (fs18.existsSync(hookPath)) {
-    const existing = fs18.readFileSync(hookPath, "utf-8");
+  if (fs16.existsSync(hookPath)) {
+    const existing = fs16.readFileSync(hookPath, "utf-8");
     if (!existing.includes("viberails")) {
-      fs18.writeFileSync(hookPath, `${existing.trimEnd()}
+      fs16.writeFileSync(hookPath, `${existing.trimEnd()}
 ${cmd}
 `);
     }
     return;
   }
-  fs18.writeFileSync(hookPath, `#!/bin/sh
+  fs16.writeFileSync(hookPath, `#!/bin/sh
 ${cmd}
 `, { mode: 493 });
 }
 
+// src/utils/prompt-prereqs.ts
+function buildVitestInstallCommand(pm, isWorkspace) {
+  if (pm === "yarn") return "yarn add -D vitest";
+  if (pm === "npm") return "npm install -D vitest";
+  return isWorkspace ? "pnpm add -D -w vitest" : "pnpm add -D vitest";
+}
+function statusIcon2(status) {
+  if (status === "ok") return chalk15.green("\u2713");
+  if (status === "missing") return chalk15.yellow("!");
+  if (status === "skipped") return chalk15.dim("\u2717");
+  return chalk15.dim("-");
+}
+function buildReadinessNote(state) {
+  const lines = [];
+  const tr = state.testRunner;
+  lines.push(
+    `${statusIcon2(tr.status)} Test runner     ${tr.label ?? (tr.status === "skipped" ? "skipped" : "not detected")}`
+  );
+  const hm = state.hookManager;
+  lines.push(
+    `${statusIcon2(hm.status)} Hook manager    ${hm.label ?? (hm.status === "skipped" ? "skipped" : "not detected")}`
+  );
+  const li = state.linter;
+  lines.push(`${statusIcon2(li.status)} Linter          ${li.label ?? "none"}`);
+  const tc = state.typecheck;
+  if (tc.status === "ok") {
+    lines.push(`${statusIcon2("ok")} Typecheck       ${tc.label}`);
+  } else if (tc.status === "skipped") {
+    lines.push(`${statusIcon2("skipped")} Typecheck       skipped`);
+  } else {
+    lines.push(
+      `${statusIcon2("missing")} Typecheck       needs root tsconfig.json, typecheck script, or turbo task`
+    );
+  }
+  return lines.join("\n");
+}
+function hasMissing(state) {
+  return state.testRunner.status === "missing" || state.hookManager.status === "missing" || state.typecheck.status === "missing";
+}
+async function promptPrereqs(projectRoot, scanResult, hookManager, packageManager, isWorkspace) {
+  let hasTestRunner = !!scanResult.stack.testRunner;
+  let currentHookManager = hookManager;
+  let skipCoverage = false;
+  let skipHooks = false;
+  const linterName = scanResult.stack.linter?.name;
+  const linterLabel = linterName === "biome" ? "Biome" : linterName === "eslint" ? "ESLint" : linterName;
+  const typecheckResolved = resolveTypecheckCommand(projectRoot, packageManager);
+  const state = {
+    testRunner: hasTestRunner ? { status: "ok", label: scanResult.stack.testRunner?.name } : { status: "missing" },
+    hookManager: currentHookManager ? { status: "ok", label: currentHookManager } : { status: "missing" },
+    linter: linterName ? { status: "ok", label: linterLabel } : { status: "none" },
+    typecheck: typecheckResolved.label ? { status: "ok", label: typecheckResolved.label } : { status: "missing", reason: typecheckResolved.reason }
+  };
+  if (!hasMissing(state)) {
+    return {
+      hasTestRunner,
+      hookManager: currentHookManager,
+      skipCoverage,
+      skipHooks,
+      typecheckLabel: typecheckResolved.label
+    };
+  }
+  if (state.testRunner.status === "missing") {
+    clack12.note(buildReadinessNote(state), "Project readiness");
+    const cmd = buildVitestInstallCommand(packageManager, isWorkspace);
+    const choice = await clack12.select({
+      message: "No test runner detected. Coverage checks require one.",
+      options: [
+        { value: "install", label: "Install vitest", hint: cmd },
+        { value: "skip", label: "Skip \u2014 disable coverage checks" },
+        { value: "exit", label: "Exit" }
+      ]
+    });
+    assertNotCancelled(choice);
+    if (choice === "install") {
+      const s = clack12.spinner();
+      s.start("Installing vitest...");
+      const result = await spawnAsync(cmd, projectRoot);
+      if (result.status === 0) {
+        s.stop("Installed vitest");
+        hasTestRunner = true;
+        state.testRunner = { status: "ok", label: "vitest" };
+      } else {
+        s.stop("Failed to install vitest");
+        clack12.log.warn(`Install manually: ${cmd}`);
+        skipCoverage = true;
+        state.testRunner = { status: "skipped" };
+      }
+    } else if (choice === "skip") {
+      skipCoverage = true;
+      state.testRunner = { status: "skipped" };
+    } else {
+      clack12.outro("Aborted.");
+      process.exit(0);
+    }
+  }
+  if (state.hookManager.status === "missing") {
+    clack12.note(buildReadinessNote(state), "Project readiness");
+    const cmd = buildLefthookInstallCommand(packageManager, isWorkspace);
+    const choice = await clack12.select({
+      message: "No git hook manager detected. Pre-commit integration requires one.",
+      options: [
+        { value: "install", label: "Install lefthook", hint: cmd },
+        { value: "skip", label: "Skip \u2014 no pre-commit integration" },
+        { value: "exit", label: "Exit" }
+      ]
+    });
+    assertNotCancelled(choice);
+    if (choice === "install") {
+      const s = clack12.spinner();
+      s.start("Installing lefthook...");
+      const result = await spawnAsync(cmd, projectRoot);
+      if (result.status === 0) {
+        s.stop("Installed lefthook");
+        const ymlPath = path17.join(projectRoot, "lefthook.yml");
+        if (!fs17.existsSync(ymlPath)) {
+          fs17.writeFileSync(ymlPath, "# Managed by viberails\npre-commit:\n  commands: {}\n");
+        }
+        currentHookManager = detectHookManager(projectRoot);
+        state.hookManager = { status: "ok", label: currentHookManager ?? "lefthook" };
+      } else {
+        s.stop("Failed to install lefthook");
+        clack12.log.warn(`Install manually: ${cmd}`);
+        skipHooks = true;
+        state.hookManager = { status: "skipped" };
+      }
+    } else if (choice === "skip") {
+      skipHooks = true;
+      state.hookManager = { status: "skipped" };
+    } else {
+      clack12.outro("Aborted.");
+      process.exit(0);
+    }
+  }
+  if (state.typecheck.status === "missing") {
+    clack12.note(buildReadinessNote(state), "Project readiness");
+    const choice = await clack12.select({
+      message: "No typecheck command found. Without this, pre-commit and CI typecheck hooks will be unavailable.",
+      options: [
+        {
+          value: "continue",
+          label: "Continue without typecheck",
+          hint: "add a root tsconfig.json or typecheck script later, then re-run viberails"
+        },
+        { value: "exit", label: "Exit \u2014 fix this first" }
+      ]
+    });
+    assertNotCancelled(choice);
+    if (choice === "exit") {
+      clack12.outro(
+        "Add a root tsconfig.json, a typecheck script, or a turbo typecheck task, then re-run viberails."
+      );
+      process.exit(0);
+    }
+    state.typecheck = { status: "skipped" };
+  }
+  return {
+    hasTestRunner,
+    hookManager: currentHookManager,
+    skipCoverage,
+    skipHooks,
+    typecheckLabel: typecheckResolved.label
+  };
+}
+
+// src/utils/update-gitignore.ts
+import * as fs18 from "fs";
+import * as path18 from "path";
+function updateGitignore(projectRoot) {
+  const gitignorePath = path18.join(projectRoot, ".gitignore");
+  let content = "";
+  if (fs18.existsSync(gitignorePath)) {
+    content = fs18.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()}
+`;
+    fs18.writeFileSync(gitignorePath, `${prefix}${block}`);
+  }
+}
+
 // src/commands/init-hooks-extra.ts
 import * as fs19 from "fs";
 import * as path19 from "path";
-import chalk14 from "chalk";
+import chalk16 from "chalk";
 import { parse as parseYaml2, stringify as stringifyYaml2 } from "yaml";
 function addPreCommitStep(projectRoot, name, command, marker, lefthookExtra) {
   const lefthookPath = path19.join(projectRoot, "lefthook.yml");
@@ -3729,12 +3911,12 @@ ${command}
 function setupTypecheckHook(projectRoot, packageManager) {
   const resolved = resolveTypecheckCommand(projectRoot, packageManager);
   if (!resolved.command) {
-    console.log(`  ${chalk14.yellow("!")} Skipped typecheck hook: ${resolved.reason}`);
+    console.log(`  ${chalk16.yellow("!")} Skipped typecheck hook: ${resolved.reason}`);
     return void 0;
   }
   const target = addPreCommitStep(projectRoot, "typecheck", resolved.command, "typecheck");
   if (target) {
-    console.log(`  ${chalk14.green("\u2713")} ${target} \u2014 added typecheck (${resolved.label})`);
+    console.log(`  ${chalk16.green("\u2713")} ${target} \u2014 added typecheck (${resolved.label})`);
   }
   return target;
 }
@@ -3744,18 +3926,19 @@ function setupLintHook(projectRoot, linter) {
   let command;
   let lefthookExtra;
   if (isLefthook) {
-    command = linter === "biome" ? "npx biome check {staged_files}" : "npx eslint {staged_files}";
+    command = linter === "biome" ? "npx biome check --write {staged_files}" : "npx eslint --fix {staged_files}";
     lefthookExtra = {
-      glob: linter === "biome" ? "*.{js,ts,jsx,tsx,json,css}" : "*.{js,ts,jsx,tsx}"
+      glob: linter === "biome" ? "*.{js,ts,jsx,tsx,json,css}" : "*.{js,ts,jsx,tsx}",
+      stage_fixed: "true"
     };
   } else {
     const exts = linter === "biome" ? "'*.js' '*.ts' '*.jsx' '*.tsx' '*.json' '*.css'" : "'*.js' '*.ts' '*.jsx' '*.tsx'";
-    const lintCmd = linter === "biome" ? "biome check" : "eslint";
+    const lintCmd = linter === "biome" ? "biome check --write" : "eslint --fix";
     command = `git diff --cached --name-only --diff-filter=ACMR -- ${exts} | xargs npx ${lintCmd}`;
   }
   const target = addPreCommitStep(projectRoot, "lint", command, linter, lefthookExtra);
   if (target) {
-    console.log(`  ${chalk14.green("\u2713")} ${target} \u2014 added ${linterName} lint check`);
+    console.log(`  ${chalk16.green("\u2713")} ${target} \u2014 added ${linterName} lint check`);
   }
   return target;
 }
@@ -3764,7 +3947,7 @@ function setupSelectedIntegrations(projectRoot, integrations, opts) {
   if (integrations.preCommitHook) {
     const t = setupPreCommitHook(projectRoot);
     if (t && opts.lefthookExpected && !t.includes("lefthook")) {
-      console.log(`  ${chalk14.yellow("!")} Lefthook install failed \u2014 fell back to ${t}`);
+      console.log(`  ${chalk16.yellow("!")} Lefthook install failed \u2014 fell back to ${t}`);
     }
     created.push(t ? `${t} \u2014 added viberails pre-commit` : "pre-commit hook skipped");
   }
@@ -3797,10 +3980,10 @@ function setupSelectedIntegrations(projectRoot, integrations, opts) {
 // src/commands/init-non-interactive.ts
 import * as fs20 from "fs";
 import * as path20 from "path";
-import * as clack12 from "@clack/prompts";
+import * as clack13 from "@clack/prompts";
 import { compactConfig as compactConfig3, generateConfig } from "@viberails/config";
 import { scan as scan2 } from "@viberails/scanner";
-import chalk15 from "chalk";
+import chalk17 from "chalk";
 
 // src/utils/filter-confidence.ts
 function filterHighConfidence(conventions, meta) {
@@ -3821,7 +4004,7 @@ function getExemptedPackages(config) {
   return config.packages.filter((pkg) => pkg.rules?.testCoverage === 0 && pkg.path !== ".").map((pkg) => pkg.path);
 }
 async function initNonInteractive(projectRoot, configPath) {
-  const s = clack12.spinner();
+  const s = clack13.spinner();
   s.start("Scanning project...");
   const scanResult = await scan2(projectRoot);
   const config = generateConfig(scanResult);
@@ -3836,11 +4019,11 @@ async function initNonInteractive(projectRoot, configPath) {
   const exempted = getExemptedPackages(config);
   if (exempted.length > 0) {
     console.log(
-      `  ${chalk15.dim("Auto-exempted from coverage:")} ${exempted.join(", ")} ${chalk15.dim("(types-only)")}`
+      `  ${chalk17.dim("Auto-exempted from coverage:")} ${exempted.join(", ")} ${chalk17.dim("(types-only)")}`
     );
   }
   if (config.packages.length > 1) {
-    const bs = clack12.spinner();
+    const bs = clack13.spinner();
     bs.start("Building import graph...");
     const { buildImportGraph, inferBoundaries } = await import("@viberails/graph");
     const packages = resolveWorkspacePackages(projectRoot, config.packages);
@@ -3873,14 +4056,14 @@ async function initNonInteractive(projectRoot, configPath) {
   const hookManager = detectHookManager(projectRoot);
   const hasHookManager = hookManager === "Lefthook" || hookManager === "Husky";
   const preCommitTarget = hasHookManager ? setupPreCommitHook(projectRoot) : void 0;
-  const ok = chalk15.green("\u2713");
+  const ok = chalk17.green("\u2713");
   const created = [
     `${ok} ${path20.basename(configPath)}`,
     `${ok} .viberails/context.md`,
     `${ok} .viberails/scan-result.json`,
     `${ok} .claude/settings.json \u2014 added viberails hook`,
     `${ok} CLAUDE.md \u2014 added @.viberails/context.md reference`,
-    preCommitTarget ? `${ok} ${preCommitTarget}` : `${chalk15.yellow("!")} pre-commit hook skipped (install lefthook or husky)`,
+    preCommitTarget ? `${ok} ${preCommitTarget}` : `${chalk17.yellow("!")} pre-commit hook skipped (install lefthook or husky)`,
     actionTarget ? `${ok} ${actionTarget} \u2014 blocks PRs on violations` : ""
   ].filter(Boolean);
   if (hasHookManager && isTypeScript) setupTypecheckHook(projectRoot, rootPkgPm);
@@ -3905,8 +4088,8 @@ async function initCommand(options, cwd) {
       return initInteractive(projectRoot, configPath, options);
     }
     console.log(
-      `${chalk16.yellow("!")} viberails is already initialized.
-  Run ${chalk16.cyan("viberails")} to review or edit the existing setup, ${chalk16.cyan("viberails sync")} to update generated files, or ${chalk16.cyan("viberails init --force")} to replace it.`
+      `${chalk18.yellow("!")} viberails is already initialized.
+  Run ${chalk18.cyan("viberails")} to review or edit the existing setup, ${chalk18.cyan("viberails sync")} to update generated files, or ${chalk18.cyan("viberails init --force")} to replace it.`
     );
     return;
   }
@@ -3914,11 +4097,11 @@ async function initCommand(options, cwd) {
   await initInteractive(projectRoot, configPath, options);
 }
 async function initInteractive(projectRoot, configPath, options) {
-  clack13.intro("viberails");
+  clack14.intro("viberails");
   if (fs21.existsSync(configPath) && !options.force) {
     const action = await promptExistingConfigAction(path21.basename(configPath));
     if (action === "cancel") {
-      clack13.outro("Aborted. No files were written.");
+      clack14.outro("Aborted. No files were written.");
       return;
     }
     if (action === "edit") {
@@ -3932,45 +4115,60 @@ async function initInteractive(projectRoot, configPath, options) {
       `${path21.basename(configPath)} already exists and will be replaced. Continue?`
     );
     if (!replace) {
-      clack13.outro("Aborted. No files were written.");
+      clack14.outro("Aborted. No files were written.");
       return;
     }
   }
-  const s = clack13.spinner();
+  const s = clack14.spinner();
   s.start("Scanning project...");
   const scanResult = await scan3(projectRoot);
   const config = generateConfig2(scanResult);
   s.stop("Scan complete");
   if (scanResult.statistics.totalFiles === 0) {
-    clack13.log.warn(
+    clack14.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 hasTestRunner = !!scanResult.stack.testRunner;
-  const hookManager = detectHookManager(projectRoot);
-  const coveragePrereqs = checkCoveragePrereqs(projectRoot, scanResult);
   const rootPkgStack = (config.packages.find((p) => p.path === ".") ?? config.packages[0])?.stack;
+  const packageManager = rootPkgStack?.packageManager?.split("@")[0] ?? "npm";
+  const isWorkspace = config.packages.length > 1;
+  const prereqs = await promptPrereqs(
+    projectRoot,
+    scanResult,
+    detectHookManager(projectRoot),
+    packageManager,
+    isWorkspace
+  );
+  if (prereqs.skipCoverage) config.rules.testCoverage = 0;
+  const coveragePrereqs = prereqs.hasTestRunner ? checkCoveragePrereqs(projectRoot, scanResult) : [];
   const state = await promptMainMenu(config, scanResult, {
-    hasTestRunner,
-    hookManager,
+    hasTestRunner: prereqs.hasTestRunner,
+    hookManager: prereqs.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
+      packageManager,
+      isWorkspace
     }
   });
   const shouldWrite = await confirm3("Apply this setup?");
   if (!shouldWrite) {
-    clack13.outro("Aborted. No files were written.");
+    clack14.outro("Aborted. No files were written.");
     return;
   }
+  const integrations = await promptIntegrationsDeferred(prereqs.hookManager, {
+    isTypeScript: rootPkgStack?.language?.split("@")[0] === "typescript",
+    typecheckLabel: prereqs.typecheckLabel,
+    linter: rootPkgStack?.linter?.split("@")[0],
+    packageManager,
+    isWorkspace
+  });
   if (state.deferredInstalls.length > 0) {
     await executeDeferredInstalls(projectRoot, state.deferredInstalls);
   }
-  const ws = clack13.spinner();
+  const ws = clack14.spinner();
   ws.start("Writing configuration...");
   const compacted = compactConfig4(config);
   fs21.writeFileSync(configPath, `${JSON.stringify(compacted, null, 2)}
@@ -3978,31 +4176,28 @@ async function initInteractive(projectRoot, configPath, options) {
   writeGeneratedFiles(projectRoot, config, scanResult);
   updateGitignore(projectRoot);
   ws.stop("Configuration written");
-  const ok = chalk16.green("\u2713");
-  clack13.log.step(`${ok} ${path21.basename(configPath)}`);
-  clack13.log.step(`${ok} .viberails/context.md`);
-  clack13.log.step(`${ok} .viberails/scan-result.json`);
-  if (state.visited.integrations && state.integrations) {
-    const lefthookExpected = state.deferredInstalls.some((d) => d.command.includes("lefthook"));
-    setupSelectedIntegrations(projectRoot, state.integrations, {
-      linter: rootPkgStack?.linter?.split("@")[0],
-      packageManager: rootPkgStack?.packageManager?.split("@")[0],
-      lefthookExpected
-    });
-  }
-  clack13.outro(
+  const ok = chalk18.green("\u2713");
+  clack14.log.step(`${ok} ${path21.basename(configPath)}`);
+  clack14.log.step(`${ok} .viberails/context.md`);
+  clack14.log.step(`${ok} .viberails/scan-result.json`);
+  setupSelectedIntegrations(projectRoot, integrations.choice, {
+    linter: rootPkgStack?.linter?.split("@")[0],
+    packageManager,
+    lefthookExpected: prereqs.hookManager === "lefthook"
+  });
+  clack14.outro(
     `Done! Next: review viberails.config.json, then run viberails check
-  ${chalk16.dim("Tip: use")} ${chalk16.cyan("viberails check --enforce")} ${chalk16.dim("in CI to block PRs on violations.")}`
+  ${chalk18.dim("Tip: use")} ${chalk18.cyan("viberails check --enforce")} ${chalk18.dim("in CI to block PRs on violations.")}`
   );
 }
 
 // src/commands/sync.ts
 import * as fs22 from "fs";
 import * as path22 from "path";
-import * as clack14 from "@clack/prompts";
+import * as clack15 from "@clack/prompts";
 import { compactConfig as compactConfig5, loadConfig as loadConfig5, mergeConfig as mergeConfig2 } from "@viberails/config";
 import { scan as scan4 } from "@viberails/scanner";
-import chalk17 from "chalk";
+import chalk19 from "chalk";
 var CONFIG_FILE6 = "viberails.config.json";
 var SCAN_RESULT_FILE2 = ".viberails/scan-result.json";
 function loadPreviousStats(projectRoot) {
@@ -4028,7 +4223,7 @@ async function syncCommand(options, cwd) {
   const configPath = path22.join(projectRoot, CONFIG_FILE6);
   const existing = await loadConfig5(configPath);
   const previousStats = loadPreviousStats(projectRoot);
-  const s = clack14.spinner();
+  const s = clack15.spinner();
   s.start("Scanning project...");
   const scanResult = await scan4(projectRoot);
   s.stop("Scan complete");
@@ -4043,19 +4238,19 @@ async function syncCommand(options, cwd) {
   const statsDelta = previousStats ? formatStatsDelta(previousStats, scanResult.statistics) : void 0;
   if (changes.length > 0 || statsDelta) {
     console.log(`
-${chalk17.bold("Changes:")}`);
+${chalk19.bold("Changes:")}`);
     for (const change of changes) {
-      const icon = change.type === "removed" ? chalk17.red("-") : chalk17.green("+");
+      const icon = change.type === "removed" ? chalk19.red("-") : chalk19.green("+");
       console.log(`  ${icon} ${change.description}`);
     }
     if (statsDelta) {
-      console.log(`  ${chalk17.dim(statsDelta)}`);
+      console.log(`  ${chalk19.dim(statsDelta)}`);
     }
   }
   if (options?.interactive) {
-    clack14.intro("viberails sync (interactive)");
-    clack14.note(formatRulesText(merged).join("\n"), "Rules after sync");
-    const decision = await clack14.select({
+    clack15.intro("viberails sync (interactive)");
+    clack15.note(formatRulesText(merged).join("\n"), "Rules after sync");
+    const decision = await clack15.select({
       message: "How would you like to proceed?",
       options: [
         { value: "accept", label: "Accept changes" },
@@ -4065,7 +4260,7 @@ ${chalk17.bold("Changes:")}`);
     });
     assertNotCancelled(decision);
     if (decision === "cancel") {
-      clack14.outro("Sync cancelled. No files were written.");
+      clack15.outro("Sync cancelled. No files were written.");
       return;
     }
     if (decision === "customize") {
@@ -4089,8 +4284,8 @@ ${chalk17.bold("Changes:")}`);
       fs22.writeFileSync(configPath, `${JSON.stringify(recompacted, null, 2)}
 `);
       writeGeneratedFiles(projectRoot, merged, scanResult);
-      clack14.log.success("Updated config with your customizations.");
-      clack14.outro("Done! Run viberails check to verify.");
+      clack15.log.success("Updated config with your customizations.");
+      clack15.outro("Done! Run viberails check to verify.");
       return;
     }
   }
@@ -4098,18 +4293,18 @@ ${chalk17.bold("Changes:")}`);
 `);
   writeGeneratedFiles(projectRoot, merged, scanResult);
   console.log(`
-${chalk17.bold("Synced:")}`);
+${chalk19.bold("Synced:")}`);
   if (configChanged) {
-    console.log(`  ${chalk17.yellow("!")} ${CONFIG_FILE6} \u2014 updated (review changes)`);
+    console.log(`  ${chalk19.yellow("!")} ${CONFIG_FILE6} \u2014 updated (review changes)`);
   } else {
-    console.log(`  ${chalk17.green("\u2713")} ${CONFIG_FILE6} \u2014 unchanged`);
+    console.log(`  ${chalk19.green("\u2713")} ${CONFIG_FILE6} \u2014 unchanged`);
   }
-  console.log(`  ${chalk17.green("\u2713")} .viberails/context.md \u2014 regenerated`);
-  console.log(`  ${chalk17.green("\u2713")} .viberails/scan-result.json \u2014 updated`);
+  console.log(`  ${chalk19.green("\u2713")} .viberails/context.md \u2014 regenerated`);
+  console.log(`  ${chalk19.green("\u2713")} .viberails/scan-result.json \u2014 updated`);
 }
 
 // src/index.ts
-var VERSION = "0.6.9";
+var VERSION = "0.6.11";
 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) => {
@@ -4117,7 +4312,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(`${chalk18.red("Error:")} ${message}`);
+    console.error(`${chalk20.red("Error:")} ${message}`);
     process.exit(1);
   }
 });
@@ -4126,7 +4321,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(`${chalk18.red("Error:")} ${message}`);
+    console.error(`${chalk20.red("Error:")} ${message}`);
     process.exit(1);
   }
 });
@@ -4135,7 +4330,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(`${chalk18.red("Error:")} ${message}`);
+    console.error(`${chalk20.red("Error:")} ${message}`);
     process.exit(1);
   }
 });
@@ -4156,7 +4351,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(`${chalk18.red("Error:")} ${message}`);
+      console.error(`${chalk20.red("Error:")} ${message}`);
       process.exit(1);
     }
   }
@@ -4167,7 +4362,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(`${chalk18.red("Error:")} ${message}`);
+    console.error(`${chalk20.red("Error:")} ${message}`);
     process.exit(1);
   }
 });
@@ -4176,7 +4371,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(`${chalk18.red("Error:")} ${message}`);
+    console.error(`${chalk20.red("Error:")} ${message}`);
     process.exit(1);
   }
 });