viberails 0.5.4 → 0.6.0

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import chalk13 from "chalk";
+import chalk14 from "chalk";
 import { Command } from "commander";
 
 // src/commands/boundaries.ts
@@ -62,11 +62,11 @@ async function promptHookManagerInstall(projectRoot, packageManager, isWorkspace
     stdio: "pipe"
   });
   if (result.status === 0) {
-    const fs20 = await import("fs");
-    const path20 = await import("path");
-    const lefthookPath = path20.join(projectRoot, "lefthook.yml");
-    if (!fs20.existsSync(lefthookPath)) {
-      fs20.writeFileSync(lefthookPath, "# Managed by viberails \u2014 https://viberails.sh\n");
+    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";
@@ -98,7 +98,7 @@ async function promptIntegrations(projectRoot, hookManager, tools) {
     options.push({
       value: "typecheck",
       label: "Typecheck (tsc --noEmit)",
-      hint: "catches type errors before commit"
+      hint: "pre-commit hook + CI check"
     });
   }
   if (tools?.linter) {
@@ -106,7 +106,7 @@ async function promptIntegrations(projectRoot, hookManager, tools) {
     options.push({
       value: "lint",
       label: `Lint check (${linterName})`,
-      hint: "runs linter on staged files before commit"
+      hint: "pre-commit hook + CI check"
     });
   }
   options.push(
@@ -698,7 +698,7 @@ ${chalk.yellow("Cycles detected:")}`);
 import * as fs7 from "fs";
 import * as path7 from "path";
 import { loadConfig as loadConfig2 } from "@viberails/config";
-import chalk2 from "chalk";
+import chalk3 from "chalk";
 
 // src/commands/check-config.ts
 import { BUILTIN_IGNORE } from "@viberails/config";
@@ -789,7 +789,8 @@ function runCoverageCommand(pkgRoot, command) {
     cwd: pkgRoot,
     shell: true,
     encoding: "utf-8",
-    stdio: "pipe"
+    stdio: "pipe",
+    timeout: 3e5
   });
   if (result.status === 0) return { ok: true };
   const stderr = result.stderr?.trim() ?? "";
@@ -952,7 +953,7 @@ function checkNaming(relPath, conventions) {
 }
 function getStagedFiles(projectRoot) {
   try {
-    const output = execSync("git diff --cached --name-only --diff-filter=ACM", {
+    const output = execSync("git diff --cached --name-only --diff-filter=ACMR", {
       cwd: projectRoot,
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "ignore"]
@@ -979,7 +980,62 @@ function getDiffFiles(projectRoot, base) {
       added: addedOutput.trim().split("\n").filter(Boolean)
     };
   } catch {
-    return { all: [], added: [] };
+    const msg = `git diff failed for base '${base}' \u2014 no files will be checked`;
+    process.stderr.write(`Warning: ${msg}
+`);
+    return { all: [], added: [], error: msg };
+  }
+}
+function testFileToSourceFile(testFile) {
+  const match = testFile.match(/^(.+)\.(test|spec)(\.[^.]+)$/);
+  if (!match) return null;
+  return `${match[1]}${match[3]}`;
+}
+function deletedTestFileToSourceFile(deletedTestFile, config) {
+  const normalized = deletedTestFile.replaceAll("\\", "/");
+  const sortedPackages = [...config.packages].sort((a, b) => b.path.length - a.path.length);
+  for (const pkg of sortedPackages) {
+    const relInPkg = pkg.path === "." ? normalized : normalized.startsWith(`${pkg.path}/`) ? normalized.slice(pkg.path.length + 1) : null;
+    if (relInPkg === null) continue;
+    const srcDir = pkg.structure?.srcDir;
+    if (!srcDir) continue;
+    const testsDir = pkg.structure?.tests;
+    if (testsDir && relInPkg.startsWith(`${testsDir}/`)) {
+      const relWithinTests = relInPkg.slice(testsDir.length + 1);
+      const relWithinSrc = testFileToSourceFile(relWithinTests);
+      if (relWithinSrc) {
+        return pkg.path === "." ? path5.posix.join(srcDir, relWithinSrc) : path5.posix.join(pkg.path, srcDir, relWithinSrc);
+      }
+    }
+    const colocated = testFileToSourceFile(relInPkg);
+    if (colocated) {
+      return pkg.path === "." ? colocated : path5.posix.join(pkg.path, colocated);
+    }
+  }
+  return null;
+}
+function getStagedDeletedTestSourceFiles(projectRoot, config) {
+  try {
+    const output = execSync("git diff --cached --name-only --diff-filter=D", {
+      cwd: projectRoot,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    return output.trim().split("\n").filter(Boolean).map((file) => deletedTestFileToSourceFile(file, config)).filter((f) => f !== null);
+  } catch {
+    return [];
+  }
+}
+function getDiffDeletedTestSourceFiles(projectRoot, base, config) {
+  try {
+    const output = execSync(`git diff --name-only --diff-filter=D ${base}...HEAD`, {
+      cwd: projectRoot,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    return output.trim().split("\n").filter(Boolean).map((file) => deletedTestFileToSourceFile(file, config)).filter((f) => f !== null);
+  } catch {
+    return [];
   }
 }
 function getAllSourceFiles(projectRoot, config) {
@@ -1022,7 +1078,7 @@ function collectSourceFiles(dir, projectRoot) {
     }
     for (const entry of entries) {
       if (entry.isDirectory()) {
-        if (entry.name === "node_modules") continue;
+        if (ALWAYS_SKIP_DIRS.has(entry.name)) continue;
         walk(path5.join(d, entry.name));
       } else if (entry.isFile()) {
         files.push(path5.relative(projectRoot, path5.join(d, entry.name)));
@@ -1033,6 +1089,55 @@ function collectSourceFiles(dir, projectRoot) {
   return files;
 }
 
+// src/commands/check-print.ts
+import chalk2 from "chalk";
+function printGroupedViolations(violations, limit) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const v of violations) {
+    const existing = groups.get(v.rule) ?? [];
+    existing.push(v);
+    groups.set(v.rule, existing);
+  }
+  const ruleOrder = [
+    "file-size",
+    "file-naming",
+    "missing-test",
+    "test-coverage",
+    "boundary-violation"
+  ];
+  const sortedKeys = [...groups.keys()].sort(
+    (a, b) => (ruleOrder.indexOf(a) === -1 ? 99 : ruleOrder.indexOf(a)) - (ruleOrder.indexOf(b) === -1 ? 99 : ruleOrder.indexOf(b))
+  );
+  let totalShown = 0;
+  const totalLimit = limit ?? Number.POSITIVE_INFINITY;
+  for (const rule of sortedKeys) {
+    const group = groups.get(rule);
+    if (!group) continue;
+    const remaining = totalLimit - totalShown;
+    if (remaining <= 0) break;
+    const toShow = group.slice(0, remaining);
+    const hidden = group.length - toShow.length;
+    for (const v of toShow) {
+      const icon = v.severity === "error" ? chalk2.red("\u2717") : chalk2.yellow("!");
+      console.log(`${icon} ${chalk2.dim(v.rule)} ${v.file}: ${v.message}`);
+    }
+    totalShown += toShow.length;
+    if (hidden > 0) {
+      console.log(chalk2.dim(`  ... and ${hidden} more ${rule} violations`));
+    }
+  }
+}
+function printSummary(violations) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const v of violations) {
+    counts.set(v.rule, (counts.get(v.rule) ?? 0) + 1);
+  }
+  const word = violations.length === 1 ? "violation" : "violations";
+  const parts = [...counts.entries()].map(([rule, count]) => `${count} ${rule}`);
+  console.log(`
+${violations.length} ${word} found (${parts.join(", ")}).`);
+}
+
 // src/commands/check-tests.ts
 import * as fs6 from "fs";
 import * as path6 from "path";
@@ -1062,18 +1167,19 @@ function checkMissingTests(projectRoot, config, severity) {
     const testSuffix = testPattern.replace("*", "");
     const sourceFiles = collectSourceFiles(srcPath, projectRoot);
     for (const relFile of sourceFiles) {
-      const basename8 = path6.basename(relFile);
-      if (basename8.includes(".test.") || basename8.includes(".spec.") || basename8.startsWith("index.") || basename8.endsWith(".d.ts")) {
+      const basename9 = path6.basename(relFile);
+      if (basename9.includes(".test.") || basename9.includes(".spec.") || basename9.startsWith("index.") || basename9.endsWith(".d.ts")) {
         continue;
       }
-      const ext = path6.extname(basename8);
+      const ext = path6.extname(basename9);
       if (!SOURCE_EXTS2.has(ext)) continue;
-      const stem = basename8.slice(0, -ext.length);
+      const stem = basename9.slice(0, -ext.length);
       const expectedTestFile = `${stem}${testSuffix}`;
       const dir = path6.dirname(path6.join(projectRoot, relFile));
       const colocatedTest = path6.join(dir, expectedTestFile);
       const testsDir = pkg.structure?.tests;
-      const dedicatedTest = testsDir ? path6.join(packageRoot2, testsDir, expectedTestFile) : null;
+      const relToSrc = path6.relative(srcPath, path6.join(projectRoot, path6.dirname(relFile)));
+      const dedicatedTest = testsDir ? path6.join(packageRoot2, testsDir, relToSrc, expectedTestFile) : null;
       const hasTest = fs6.existsSync(colocatedTest) || dedicatedTest !== null && fs6.existsSync(dedicatedTest);
       if (!hasTest) {
         violations.push({
@@ -1103,91 +1209,52 @@ function isTestFile(relPath) {
   const filename = path7.basename(relPath);
   return filename.includes(".test.") || filename.includes(".spec.") || filename.startsWith("test.") || filename.startsWith("spec.") || relPath.includes("__tests__/") || relPath.includes("__test__/");
 }
-function printGroupedViolations(violations, limit) {
-  const groups = /* @__PURE__ */ new Map();
-  for (const v of violations) {
-    const existing = groups.get(v.rule) ?? [];
-    existing.push(v);
-    groups.set(v.rule, existing);
-  }
-  const ruleOrder = [
-    "file-size",
-    "file-naming",
-    "missing-test",
-    "test-coverage",
-    "boundary-violation"
-  ];
-  const sortedKeys = [...groups.keys()].sort(
-    (a, b) => (ruleOrder.indexOf(a) === -1 ? 99 : ruleOrder.indexOf(a)) - (ruleOrder.indexOf(b) === -1 ? 99 : ruleOrder.indexOf(b))
-  );
-  let totalShown = 0;
-  const totalLimit = limit ?? Number.POSITIVE_INFINITY;
-  for (const rule of sortedKeys) {
-    const group = groups.get(rule);
-    if (!group) continue;
-    const remaining = totalLimit - totalShown;
-    if (remaining <= 0) break;
-    const toShow = group.slice(0, remaining);
-    const hidden = group.length - toShow.length;
-    for (const v of toShow) {
-      const icon = v.severity === "error" ? chalk2.red("\u2717") : chalk2.yellow("!");
-      console.log(`${icon} ${chalk2.dim(v.rule)} ${v.file}: ${v.message}`);
-    }
-    totalShown += toShow.length;
-    if (hidden > 0) {
-      console.log(chalk2.dim(`  ... and ${hidden} more ${rule} violations`));
-    }
-  }
-}
-function printSummary(violations) {
-  const counts = /* @__PURE__ */ new Map();
-  for (const v of violations) {
-    counts.set(v.rule, (counts.get(v.rule) ?? 0) + 1);
-  }
-  const word = violations.length === 1 ? "violation" : "violations";
-  const parts = [...counts.entries()].map(([rule, count]) => `${count} ${rule}`);
-  console.log(`
-${violations.length} ${word} found (${parts.join(", ")}).`);
-}
 async function checkCommand(options, cwd) {
   const startDir = cwd ?? process.cwd();
   const projectRoot = findProjectRoot(startDir);
   if (!projectRoot) {
-    console.error(`${chalk2.red("Error:")} No package.json found. Are you in a JS/TS project?`);
+    console.error(`${chalk3.red("Error:")} No package.json found. Are you in a JS/TS project?`);
     return 1;
   }
   const configPath = path7.join(projectRoot, CONFIG_FILE2);
   if (!fs7.existsSync(configPath)) {
     console.error(
-      `${chalk2.red("Error:")} No viberails.config.json found. Run \`viberails init\` first.`
+      `${chalk3.red("Error:")} No viberails.config.json found. Run \`viberails init\` first.`
     );
     return 1;
   }
   const config = await loadConfig2(configPath);
   let filesToCheck;
   let diffAddedFiles = null;
+  let deletedTestSourceFiles = [];
   if (options.staged) {
-    filesToCheck = getStagedFiles(projectRoot);
+    filesToCheck = getStagedFiles(projectRoot).filter((f) => SOURCE_EXTS.has(path7.extname(f)));
+    deletedTestSourceFiles = getStagedDeletedTestSourceFiles(projectRoot, config);
   } else if (options.diffBase) {
     const diff = getDiffFiles(projectRoot, options.diffBase);
+    if (diff.error && options.enforce) {
+      console.error(`${chalk3.red("Error:")} ${diff.error}`);
+      return 1;
+    }
     filesToCheck = diff.all.filter((f) => SOURCE_EXTS.has(path7.extname(f)));
     diffAddedFiles = new Set(diff.added);
+    deletedTestSourceFiles = getDiffDeletedTestSourceFiles(projectRoot, options.diffBase, config);
   } else if (options.files && options.files.length > 0) {
     filesToCheck = options.files;
   } else {
     filesToCheck = getAllSourceFiles(projectRoot, config);
   }
-  if (filesToCheck.length === 0) {
+  if (filesToCheck.length === 0 && deletedTestSourceFiles.length === 0) {
     if (options.format === "json") {
       console.log(JSON.stringify({ violations: [], checkedFiles: 0 }));
     } else {
-      console.log(`${chalk2.green("\u2713")} No files to check.`);
+      console.log(`${chalk3.green("\u2713")} No files to check.`);
     }
     return 0;
   }
   const violations = [];
   const severity = options.enforce ? "error" : "warn";
-  const log7 = options.format !== "json" && !options.hook ? (msg) => process.stderr.write(chalk2.dim(msg)) : () => {
+  const log7 = options.format !== "json" && !options.hook && !options.quiet ? (msg) => process.stderr.write(chalk3.dim(msg)) : () => {
   };
   log7("  Checking files...");
   for (const file of filesToCheck) {
@@ -1223,12 +1290,20 @@ async function checkCommand(options, cwd) {
     }
   }
   log7(" done\n");
-  if (!options.staged && !options.files) {
+  if (!options.files) {
     log7("  Checking missing tests...");
     const testViolations = checkMissingTests(projectRoot, config, severity);
-    violations.push(
-      ...diffAddedFiles ? testViolations.filter((v) => diffAddedFiles.has(v.file)) : testViolations
-    );
+    if (options.staged) {
+      const stagedSet = new Set(filesToCheck);
+      for (const f of deletedTestSourceFiles) stagedSet.add(f);
+      violations.push(...testViolations.filter((v) => stagedSet.has(v.file)));
+    } else if (diffAddedFiles) {
+      const checkSet = new Set(diffAddedFiles);
+      for (const f of deletedTestSourceFiles) checkSet.add(f);
+      violations.push(...testViolations.filter((v) => checkSet.has(v.file)));
+    } else {
+      violations.push(...testViolations);
+    }
     log7(" done\n");
   }
   if (!options.files && !options.staged && !options.diffBase) {
@@ -1274,7 +1349,7 @@ async function checkCommand(options, cwd) {
     return options.enforce && violations.length > 0 ? 1 : 0;
   }
   if (violations.length === 0) {
-    console.log(`${chalk2.green("\u2713")} ${filesToCheck.length} files checked \u2014 no violations`);
+    console.log(`${chalk3.green("\u2713")} ${filesToCheck.length} files checked \u2014 no violations`);
     return 0;
   }
   if (!options.quiet) {
@@ -1282,7 +1357,7 @@ async function checkCommand(options, cwd) {
   }
   printSummary(violations);
   if (options.enforce) {
-    console.log(chalk2.red("Fix violations before committing."));
+    console.log(chalk3.red("Fix violations before committing."));
     return 1;
   }
   return 0;
@@ -1340,7 +1415,7 @@ import * as path9 from "path";
 import * as clack6 from "@clack/prompts";
 import { compactConfig as compactConfig2, loadConfig as loadConfig3, mergeConfig } from "@viberails/config";
 import { scan } from "@viberails/scanner";
-import chalk5 from "chalk";
+import chalk6 from "chalk";
 
 // src/display-text.ts
 import {
@@ -1359,7 +1434,7 @@ import {
   ORM_NAMES,
   STYLING_NAMES as STYLING_NAMES2
 } from "@viberails/types";
-import chalk4 from "chalk";
+import chalk5 from "chalk";
 
 // src/display-helpers.ts
 import { ROLE_DESCRIPTIONS } from "@viberails/types";
@@ -1412,7 +1487,7 @@ function formatRoleGroup(group) {
 
 // src/display-monorepo.ts
 import { FRAMEWORK_NAMES, STYLING_NAMES } from "@viberails/types";
-import chalk3 from "chalk";
+import chalk4 from "chalk";
 function formatPackageSummary(pkg) {
   const parts = [];
   if (pkg.stack.framework) {
@@ -1421,30 +1496,31 @@ function formatPackageSummary(pkg) {
   if (pkg.stack.styling) {
     parts.push(formatItem(pkg.stack.styling, STYLING_NAMES));
   }
-  const files = `${pkg.statistics.totalFiles} files`;
+  const n = pkg.statistics.totalFiles;
+  const files = `${n} ${n === 1 ? "file" : "files"}`;
   const detail = parts.length > 0 ? `${parts.join(", ")} (${files})` : `(${files})`;
   return `  ${pkg.relativePath} \u2014 ${detail}`;
 }
 function displayMonorepoResults(scanResult) {
   const { stack, packages } = scanResult;
   console.log(`
-${chalk3.bold(`Detected: (monorepo, ${packages.length} packages)`)}`);
-  console.log(`  ${chalk3.green("\u2713")} ${formatItem(stack.language)}`);
+${chalk4.bold(`Detected: (monorepo, ${packages.length} packages)`)}`);
+  console.log(`  ${chalk4.green("\u2713")} ${formatItem(stack.language)}`);
   if (stack.packageManager) {
-    console.log(`  ${chalk3.green("\u2713")} ${formatItem(stack.packageManager)}`);
+    console.log(`  ${chalk4.green("\u2713")} ${formatItem(stack.packageManager)}`);
   }
   if (stack.linter && stack.formatter && stack.linter.name === stack.formatter.name) {
-    console.log(`  ${chalk3.green("\u2713")} ${formatItem(stack.linter)} (lint + format)`);
+    console.log(`  ${chalk4.green("\u2713")} ${formatItem(stack.linter)} (lint + format)`);
   } else {
     if (stack.linter) {
-      console.log(`  ${chalk3.green("\u2713")} ${formatItem(stack.linter)}`);
+      console.log(`  ${chalk4.green("\u2713")} ${formatItem(stack.linter)}`);
     }
     if (stack.formatter) {
-      console.log(`  ${chalk3.green("\u2713")} ${formatItem(stack.formatter)}`);
+      console.log(`  ${chalk4.green("\u2713")} ${formatItem(stack.formatter)}`);
     }
   }
   if (stack.testRunner) {
-    console.log(`  ${chalk3.green("\u2713")} ${formatItem(stack.testRunner)}`);
+    console.log(`  ${chalk4.green("\u2713")} ${formatItem(stack.testRunner)}`);
   }
   console.log("");
   for (const pkg of packages) {
@@ -1455,13 +1531,13 @@ ${chalk3.bold(`Detected: (monorepo, ${packages.length} packages)`)}`);
   );
   if (packagesWithDirs.length > 0) {
     console.log(`
-${chalk3.bold("Structure:")}`);
+${chalk4.bold("Structure:")}`);
     for (const pkg of packagesWithDirs) {
       const groups = groupByRole(pkg.structure.directories);
       if (groups.length === 0) continue;
       console.log(`  ${pkg.relativePath}:`);
       for (const group of groups) {
-        console.log(`    ${chalk3.green("\u2713")} ${formatRoleGroup(group)}`);
+        console.log(`    ${chalk4.green("\u2713")} ${formatRoleGroup(group)}`);
       }
     }
   }
@@ -1477,7 +1553,8 @@ function formatPackageSummaryPlain(pkg) {
   if (pkg.stack.styling) {
     parts.push(formatItem(pkg.stack.styling, STYLING_NAMES));
   }
-  const files = `${pkg.statistics.totalFiles} files`;
+  const n = pkg.statistics.totalFiles;
+  const files = `${n} ${n === 1 ? "file" : "files"}`;
   const detail = parts.length > 0 ? `${parts.join(", ")} (${files})` : `(${files})`;
   return `  ${pkg.relativePath} \u2014 ${detail}`;
 }
@@ -1541,7 +1618,7 @@ function displayConventions(scanResult) {
   const conventionEntries = Object.entries(scanResult.conventions);
   if (conventionEntries.length === 0) return;
   console.log(`
-${chalk4.bold("Conventions:")}`);
+${chalk5.bold("Conventions:")}`);
   for (const [key, convention] of conventionEntries) {
     if (convention.confidence === "low") continue;
     const label = CONVENTION_LABELS[key] ?? key;
@@ -1549,19 +1626,19 @@ ${chalk4.bold("Conventions:")}`);
       const pkgValues = scanResult.packages.filter((pkg) => pkg.conventions[key] && pkg.conventions[key].confidence !== "low").map((pkg) => ({ relativePath: pkg.relativePath, convention: pkg.conventions[key] }));
       const allSame = pkgValues.every((pv) => pv.convention.value === convention.value);
       if (allSame || pkgValues.length <= 1) {
-        const ind = convention.confidence === "high" ? chalk4.green("\u2713") : chalk4.yellow("~");
-        const detail = chalk4.dim(`(${confidenceLabel(convention)})`);
+        const ind = convention.confidence === "high" ? chalk5.green("\u2713") : chalk5.yellow("~");
+        const detail = chalk5.dim(`(${confidenceLabel(convention)})`);
         console.log(`  ${ind} ${label}: ${convention.value} ${detail}`);
       } else {
-        console.log(`  ${chalk4.yellow("~")} ${label}: varies by package`);
+        console.log(`  ${chalk5.yellow("~")} ${label}: varies by package`);
         for (const pv of pkgValues) {
           const pct = Math.round(pv.convention.consistency);
           console.log(`    ${pv.relativePath}: ${pv.convention.value} (${pct}%)`);
         }
       }
     } else {
-      const ind = convention.confidence === "high" ? chalk4.green("\u2713") : chalk4.yellow("~");
-      const detail = chalk4.dim(`(${confidenceLabel(convention)})`);
+      const ind = convention.confidence === "high" ? chalk5.green("\u2713") : chalk5.yellow("~");
+      const detail = chalk5.dim(`(${confidenceLabel(convention)})`);
       console.log(`  ${ind} ${label}: ${convention.value} ${detail}`);
     }
   }
@@ -1569,7 +1646,7 @@ ${chalk4.bold("Conventions:")}`);
 function displaySummarySection(scanResult) {
   const pkgCount = scanResult.packages.length > 1 ? scanResult.packages.length : void 0;
   console.log(`
-${chalk4.bold("Summary:")}`);
+${chalk5.bold("Summary:")}`);
   console.log(`  ${formatSummary(scanResult.statistics, pkgCount)}`);
   const ext = formatExtensions(scanResult.statistics.filesByExtension);
   if (ext) {
@@ -1583,47 +1660,47 @@ function displayScanResults(scanResult) {
   }
   const { stack } = scanResult;
   console.log(`
-${chalk4.bold("Detected:")}`);
+${chalk5.bold("Detected:")}`);
   if (stack.framework) {
-    console.log(`  ${chalk4.green("\u2713")} ${formatItem(stack.framework, FRAMEWORK_NAMES2)}`);
+    console.log(`  ${chalk5.green("\u2713")} ${formatItem(stack.framework, FRAMEWORK_NAMES2)}`);
   }
-  console.log(`  ${chalk4.green("\u2713")} ${formatItem(stack.language)}`);
+  console.log(`  ${chalk5.green("\u2713")} ${formatItem(stack.language)}`);
   if (stack.styling) {
-    console.log(`  ${chalk4.green("\u2713")} ${formatItem(stack.styling, STYLING_NAMES2)}`);
+    console.log(`  ${chalk5.green("\u2713")} ${formatItem(stack.styling, STYLING_NAMES2)}`);
   }
   if (stack.backend) {
-    console.log(`  ${chalk4.green("\u2713")} ${formatItem(stack.backend, FRAMEWORK_NAMES2)}`);
+    console.log(`  ${chalk5.green("\u2713")} ${formatItem(stack.backend, FRAMEWORK_NAMES2)}`);
   }
   if (stack.orm) {
-    console.log(`  ${chalk4.green("\u2713")} ${formatItem(stack.orm, ORM_NAMES)}`);
+    console.log(`  ${chalk5.green("\u2713")} ${formatItem(stack.orm, ORM_NAMES)}`);
   }
   if (stack.linter && stack.formatter && stack.linter.name === stack.formatter.name) {
-    console.log(`  ${chalk4.green("\u2713")} ${formatItem(stack.linter)} (lint + format)`);
+    console.log(`  ${chalk5.green("\u2713")} ${formatItem(stack.linter)} (lint + format)`);
   } else {
     if (stack.linter) {
-      console.log(`  ${chalk4.green("\u2713")} ${formatItem(stack.linter)}`);
+      console.log(`  ${chalk5.green("\u2713")} ${formatItem(stack.linter)}`);
     }
     if (stack.formatter) {
-      console.log(`  ${chalk4.green("\u2713")} ${formatItem(stack.formatter)}`);
+      console.log(`  ${chalk5.green("\u2713")} ${formatItem(stack.formatter)}`);
     }
   }
   if (stack.testRunner) {
-    console.log(`  ${chalk4.green("\u2713")} ${formatItem(stack.testRunner)}`);
+    console.log(`  ${chalk5.green("\u2713")} ${formatItem(stack.testRunner)}`);
   }
   if (stack.packageManager) {
-    console.log(`  ${chalk4.green("\u2713")} ${formatItem(stack.packageManager)}`);
+    console.log(`  ${chalk5.green("\u2713")} ${formatItem(stack.packageManager)}`);
   }
   if (stack.libraries.length > 0) {
     for (const lib of stack.libraries) {
-      console.log(`  ${chalk4.green("\u2713")} ${formatItem(lib, LIBRARY_NAMES)}`);
+      console.log(`  ${chalk5.green("\u2713")} ${formatItem(lib, LIBRARY_NAMES)}`);
     }
   }
   const groups = groupByRole(scanResult.structure.directories);
   if (groups.length > 0) {
     console.log(`
-${chalk4.bold("Structure:")}`);
+${chalk5.bold("Structure:")}`);
     for (const group of groups) {
-      console.log(`  ${chalk4.green("\u2713")} ${formatRoleGroup(group)}`);
+      console.log(`  ${chalk5.green("\u2713")} ${formatRoleGroup(group)}`);
     }
   }
   displayConventions(scanResult);
@@ -1633,49 +1710,49 @@ ${chalk4.bold("Structure:")}`);
 function displayRulesPreview(config) {
   const root = config.packages.find((p) => p.path === ".") ?? config.packages[0];
   console.log(
-    `${chalk4.bold("Rules:")} ${chalk4.dim("(warns on violation; use --enforce in CI to block)")}`
+    `${chalk5.bold("Rules:")} ${chalk5.dim("(warns on violation; use --enforce in CI to block)")}`
   );
-  console.log(`  ${chalk4.dim("\u2022")} Max file size: ${config.rules.maxFileLines} lines`);
+  console.log(`  ${chalk5.dim("\u2022")} Max file size: ${config.rules.maxFileLines} lines`);
   if (config.rules.testCoverage > 0 && root?.structure?.testPattern) {
     console.log(
-      `  ${chalk4.dim("\u2022")} Test coverage target: ${config.rules.testCoverage}% (${root.structure.testPattern})`
+      `  ${chalk5.dim("\u2022")} Test coverage target: ${config.rules.testCoverage}% (${root.structure.testPattern})`
     );
   } else if (config.rules.testCoverage > 0) {
-    console.log(`  ${chalk4.dim("\u2022")} Test coverage target: ${config.rules.testCoverage}%`);
+    console.log(`  ${chalk5.dim("\u2022")} Test coverage target: ${config.rules.testCoverage}%`);
   } else {
-    console.log(`  ${chalk4.dim("\u2022")} Test coverage target: disabled`);
+    console.log(`  ${chalk5.dim("\u2022")} Test coverage target: disabled`);
   }
   if (config.rules.enforceNaming && root?.conventions?.fileNaming) {
-    console.log(`  ${chalk4.dim("\u2022")} Enforce file naming: ${root.conventions.fileNaming}`);
+    console.log(`  ${chalk5.dim("\u2022")} Enforce file naming: ${root.conventions.fileNaming}`);
   } else {
-    console.log(`  ${chalk4.dim("\u2022")} Enforce file naming: no`);
+    console.log(`  ${chalk5.dim("\u2022")} Enforce file naming: no`);
   }
   console.log(
-    `  ${chalk4.dim("\u2022")} Enforce boundaries: ${config.rules.enforceBoundaries ? "yes" : "no"}`
+    `  ${chalk5.dim("\u2022")} Enforce boundaries: ${config.rules.enforceBoundaries ? "yes" : "no"}`
   );
   console.log("");
 }
 function displayInitSummary(config, exemptedPackages) {
   const root = config.packages.find((p) => p.path === ".") ?? config.packages[0];
   const isMonorepo = config.packages.length > 1;
-  const ok = chalk4.green("\u2713");
-  const off = chalk4.dim("\u25CB");
+  const ok = chalk5.green("\u2713");
+  const off = chalk5.dim("\u25CB");
   console.log("");
-  console.log(`  ${chalk4.bold("Rules to apply:")}`);
-  console.log(`  ${ok} Max file size: ${chalk4.cyan(`${config.rules.maxFileLines} lines`)}`);
+  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: ${chalk4.cyan(fileNaming)}`);
+    console.log(`  ${ok} File naming: ${chalk5.cyan(fileNaming)}`);
   } else {
-    console.log(`  ${off} File naming: ${chalk4.dim("not enforced")}`);
+    console.log(`  ${off} File naming: ${chalk5.dim("not enforced")}`);
   }
   const testPattern = root?.structure?.testPattern ?? config.packages.find((p) => p.structure?.testPattern)?.structure?.testPattern;
   if (config.rules.enforceMissingTests && testPattern) {
-    console.log(`  ${ok} Missing tests: ${chalk4.cyan(`enforced (${testPattern})`)}`);
+    console.log(`  ${ok} Missing tests: ${chalk5.cyan(`enforced (${testPattern})`)}`);
   } else if (config.rules.enforceMissingTests) {
-    console.log(`  ${ok} Missing tests: ${chalk4.cyan("enforced")}`);
+    console.log(`  ${ok} Missing tests: ${chalk5.cyan("enforced")}`);
   } else {
-    console.log(`  ${off} Missing tests: ${chalk4.dim("not enforced")}`);
+    console.log(`  ${off} Missing tests: ${chalk5.dim("not enforced")}`);
   }
   if (config.rules.testCoverage > 0) {
     if (isMonorepo) {
@@ -1683,27 +1760,27 @@ function displayInitSummary(config, exemptedPackages) {
         (p) => (p.rules?.testCoverage ?? config.rules.testCoverage) > 0
       );
       console.log(
-        `  ${ok} Coverage: ${chalk4.cyan(`${config.rules.testCoverage}%`)} default ${chalk4.dim(`(${withCoverage.length}/${config.packages.length} packages)`)}`
+        `  ${ok} Coverage: ${chalk5.cyan(`${config.rules.testCoverage}%`)} default ${chalk5.dim(`(${withCoverage.length}/${config.packages.length} packages)`)}`
       );
     } else {
-      console.log(`  ${ok} Coverage: ${chalk4.cyan(`${config.rules.testCoverage}%`)}`);
+      console.log(`  ${ok} Coverage: ${chalk5.cyan(`${config.rules.testCoverage}%`)}`);
     }
   } else {
-    console.log(`  ${off} Coverage: ${chalk4.dim("disabled")}`);
+    console.log(`  ${off} Coverage: ${chalk5.dim("disabled")}`);
   }
   if (exemptedPackages.length > 0) {
     console.log(
-      `  ${chalk4.dim("  exempted:")} ${chalk4.dim(exemptedPackages.join(", "))} ${chalk4.dim("(types-only)")}`
+      `  ${chalk5.dim("  exempted:")} ${chalk5.dim(exemptedPackages.join(", "))} ${chalk5.dim("(types-only)")}`
     );
   }
   if (isMonorepo) {
     console.log(
       `
-  ${chalk4.dim(`${config.packages.length} packages scanned \xB7 warns on violation \xB7 use --enforce in CI`)}`
+  ${chalk5.dim(`${config.packages.length} packages scanned \xB7 warns on violation \xB7 use --enforce in CI`)}`
     );
   } else {
     console.log(`
-  ${chalk4.dim("warns on violation \xB7 use --enforce in CI to block")}`);
+  ${chalk5.dim("warns on violation \xB7 use --enforce in CI to block")}`);
   }
   console.log("");
 }
@@ -2015,7 +2092,7 @@ async function configCommand(options, cwd) {
   }
   const configPath = path9.join(projectRoot, CONFIG_FILE3);
   if (!fs10.existsSync(configPath)) {
-    console.log(`${chalk5.yellow("!")} No config found. Run ${chalk5.cyan("viberails init")} first.`);
+    console.log(`${chalk6.yellow("!")} No config found. Run ${chalk6.cyan("viberails init")} first.`);
     return;
   }
   clack6.intro("viberails config");
@@ -2100,22 +2177,22 @@ async function rescanAndMerge(projectRoot, config) {
 import * as fs13 from "fs";
 import * as path13 from "path";
 import { loadConfig as loadConfig4 } from "@viberails/config";
-import chalk7 from "chalk";
+import chalk8 from "chalk";
 
 // src/commands/fix-helpers.ts
 import { execSync as execSync2 } from "child_process";
-import chalk6 from "chalk";
+import chalk7 from "chalk";
 function printPlan(renames, stubs) {
   if (renames.length > 0) {
-    console.log(chalk6.bold("\nFile renames:"));
+    console.log(chalk7.bold("\nFile renames:"));
     for (const r of renames) {
-      console.log(`  ${chalk6.red(r.oldPath)} \u2192 ${chalk6.green(r.newPath)}`);
+      console.log(`  ${chalk7.red(r.oldPath)} \u2192 ${chalk7.green(r.newPath)}`);
     }
   }
   if (stubs.length > 0) {
-    console.log(chalk6.bold("\nTest stubs to create:"));
+    console.log(chalk7.bold("\nTest stubs to create:"));
     for (const s of stubs) {
-      console.log(`  ${chalk6.green("+")} ${s.path}`);
+      console.log(`  ${chalk7.green("+")} ${s.path}`);
     }
   }
 }
@@ -2149,8 +2226,62 @@ function computeNewSpecifier(oldSpecifier, newBare) {
   const newSpec = prefix + newBare;
   return hasJsExt ? `${newSpec}.js` : newSpec;
 }
-async function updateImportsAfterRenames(renames, projectRoot) {
+async function scanForAliasImports(renames, projectRoot) {
   if (renames.length === 0) return [];
+  const { readFile, readdir } = await import("fs/promises");
+  const oldBareNames = /* @__PURE__ */ new Set();
+  for (const r of renames) {
+    const oldFilename = path10.basename(r.oldPath);
+    oldBareNames.add(oldFilename.slice(0, oldFilename.indexOf(".")));
+  }
+  const importPattern = /(?:import|export)\s+.*?from\s+['"]([^'"]+)['"]|import\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+  const skipDirs = /* @__PURE__ */ new Set([
+    "node_modules",
+    "dist",
+    "build",
+    ".next",
+    ".expo",
+    ".turbo",
+    "coverage"
+  ]);
+  const sourceExts = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
+  const allEntries = await readdir(projectRoot, { recursive: true, withFileTypes: true });
+  const files = allEntries.filter((e) => {
+    if (!e.isFile()) return false;
+    const ext = path10.extname(e.name);
+    if (!sourceExts.has(ext)) return false;
+    const rel = path10.join(e.parentPath, e.name);
+    const segments = path10.relative(projectRoot, rel).split(path10.sep);
+    return !segments.some((s) => skipDirs.has(s));
+  }).map((e) => path10.join(e.parentPath, e.name));
+  const aliases = [];
+  for (const file of files) {
+    let content;
+    try {
+      content = await readFile(file, "utf-8");
+    } catch {
+      continue;
+    }
+    const lines = content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      importPattern.lastIndex = 0;
+      for (let match = importPattern.exec(line); match !== null; match = importPattern.exec(line)) {
+        const specifier = match[1] ?? match[2];
+        if (!specifier || specifier.startsWith(".")) continue;
+        if (!specifier.includes("/")) continue;
+        const lastSegment = specifier.split("/").pop() ?? "";
+        const bare = lastSegment.replace(/\.(tsx?|jsx?|mjs|cjs)$/, "");
+        if (oldBareNames.has(bare)) {
+          aliases.push({ file, specifier, line: i + 1 });
+        }
+      }
+    }
+  }
+  return aliases;
+}
+async function updateImportsAfterRenames(renames, projectRoot) {
+  if (renames.length === 0) return { updates: [], skippedAliases: [] };
   const { Project, SyntaxKind } = await import("ts-morph");
   const renameMap = /* @__PURE__ */ new Map();
   for (const r of renames) {
@@ -2165,15 +2296,44 @@ async function updateImportsAfterRenames(renames, projectRoot) {
   });
   project.addSourceFilesAtPaths(path10.join(projectRoot, "**/*.{ts,tsx,js,jsx,mjs,cjs}"));
   const updates = [];
+  const skippedAliases = [];
   const extensions = ["", ".ts", ".tsx", ".js", ".jsx", "/index.ts", "/index.tsx", "/index.js"];
+  const oldBareNames = /* @__PURE__ */ new Set();
+  for (const r of renames) {
+    const oldFilename = path10.basename(r.oldPath);
+    oldBareNames.add(oldFilename.slice(0, oldFilename.indexOf(".")));
+  }
   for (const sourceFile of project.getSourceFiles()) {
     const filePath = sourceFile.getFilePath();
     const segments = filePath.split(path10.sep);
-    if (segments.includes("node_modules") || segments.includes("dist")) continue;
+    const skipDirs = /* @__PURE__ */ new Set([
+      "node_modules",
+      "dist",
+      "build",
+      ".next",
+      ".expo",
+      ".svelte-kit",
+      ".turbo",
+      "coverage"
+    ]);
+    if (segments.some((s) => skipDirs.has(s))) continue;
     const fileDir = path10.dirname(filePath);
     for (const decl of sourceFile.getImportDeclarations()) {
       const specifier = decl.getModuleSpecifierValue();
-      if (!specifier.startsWith(".")) continue;
+      if (!specifier.startsWith(".")) {
+        if (specifier.includes("/")) {
+          const lastSegment = specifier.split("/").pop() ?? "";
+          const bare = lastSegment.replace(/\.(tsx?|jsx?|mjs|cjs)$/, "");
+          if (oldBareNames.has(bare)) {
+            skippedAliases.push({
+              file: filePath,
+              specifier,
+              line: decl.getStartLineNumber()
+            });
+          }
+        }
+        continue;
+      }
       const match = resolveToRenamedFile(specifier, fileDir, renameMap, extensions);
       if (!match) continue;
       const newSpec = computeNewSpecifier(specifier, match.newBare);
@@ -2223,7 +2383,7 @@ async function updateImportsAfterRenames(renames, projectRoot) {
   if (updates.length > 0) {
     await project.save();
   }
-  return updates;
+  return { updates, skippedAliases };
 }
 function resolveToRenamedFile(specifier, fromDir, renameMap, extensions) {
   const cleanSpec = specifier.endsWith(".js") ? specifier.slice(0, -3) : specifier;
@@ -2326,10 +2486,10 @@ function generateTestStub(sourceRelPath, config, projectRoot) {
   const pkg = resolvePackageForFile(sourceRelPath, config);
   const testPattern = pkg?.structure?.testPattern;
   if (!testPattern) return null;
-  const basename8 = path12.basename(sourceRelPath);
-  const ext = path12.extname(basename8);
+  const basename9 = path12.basename(sourceRelPath);
+  const ext = path12.extname(basename9);
   if (!ext) return null;
-  const stem = basename8.slice(0, -ext.length);
+  const stem = basename9.slice(0, -ext.length);
   const testSuffix = testPattern.replace("*", "");
   const testFilename = `${stem}${testSuffix}`;
   const dir = path12.dirname(path12.join(projectRoot, sourceRelPath));
@@ -2360,13 +2520,13 @@ async function fixCommand(options, cwd) {
   const startDir = cwd ?? process.cwd();
   const projectRoot = findProjectRoot(startDir);
   if (!projectRoot) {
-    console.error(`${chalk7.red("Error:")} No package.json found. Are you in a JS/TS project?`);
+    console.error(`${chalk8.red("Error:")} No package.json found. Are you in a JS/TS project?`);
     return 1;
   }
   const configPath = path13.join(projectRoot, CONFIG_FILE4);
   if (!fs13.existsSync(configPath)) {
     console.error(
-      `${chalk7.red("Error:")} No viberails.config.json found. Run \`viberails init\` first.`
+      `${chalk8.red("Error:")} No viberails.config.json found. Run \`viberails init\` first.`
     );
     return 1;
   }
@@ -2375,7 +2535,7 @@ async function fixCommand(options, cwd) {
     const isDirty = checkGitDirty(projectRoot);
     if (isDirty) {
       console.log(
-        chalk7.yellow("Warning: You have uncommitted changes. Consider committing first.")
+        chalk8.yellow("Warning: You have uncommitted changes. Consider committing first.")
       );
     }
   }
@@ -2404,13 +2564,59 @@ async function fixCommand(options, cwd) {
       if (stub) testStubs.push(stub);
     }
   }
-  if (dedupedRenames.length === 0 && testStubs.length === 0) {
-    console.log(`${chalk7.green("\u2713")} No fixable violations found.`);
+  const aliasImports = await scanForAliasImports(dedupedRenames, projectRoot);
+  const blockedOldBareNames = /* @__PURE__ */ new Set();
+  for (const alias of aliasImports) {
+    const lastSegment = alias.specifier.split("/").pop() ?? "";
+    const bare = lastSegment.replace(/\.(tsx?|jsx?|mjs|cjs)$/, "");
+    blockedOldBareNames.add(bare);
+  }
+  const safeRenames = dedupedRenames.filter((r) => {
+    const oldFilename = path13.basename(r.oldPath);
+    const bare = oldFilename.slice(0, oldFilename.indexOf("."));
+    return !blockedOldBareNames.has(bare);
+  });
+  const skippedRenames = dedupedRenames.filter((r) => {
+    const oldFilename = path13.basename(r.oldPath);
+    const bare = oldFilename.slice(0, oldFilename.indexOf("."));
+    return blockedOldBareNames.has(bare);
+  });
+  if (safeRenames.length === 0 && testStubs.length === 0 && skippedRenames.length === 0) {
+    console.log(`${chalk8.green("\u2713")} No fixable violations found.`);
+    return 0;
+  }
+  printPlan(safeRenames, testStubs);
+  if (skippedRenames.length > 0) {
+    console.log("");
+    console.log(
+      chalk8.yellow(
+        `Skipping ${skippedRenames.length} rename${skippedRenames.length > 1 ? "s" : ""} \u2014 aliased imports would break:`
+      )
+    );
+    for (const r of skippedRenames.slice(0, 5)) {
+      console.log(chalk8.dim(`  ${r.oldPath} \u2192 ${r.newPath}`));
+    }
+    if (skippedRenames.length > 5) {
+      console.log(chalk8.dim(`  ... and ${skippedRenames.length - 5} more`));
+    }
+    console.log("");
+    console.log(chalk8.yellow("Affected aliased imports:"));
+    for (const alias of aliasImports.slice(0, 5)) {
+      const relFile = path13.relative(projectRoot, alias.file);
+      console.log(chalk8.dim(`  ${relFile}:${alias.line} \u2014 ${alias.specifier}`));
+    }
+    if (aliasImports.length > 5) {
+      console.log(chalk8.dim(`  ... and ${aliasImports.length - 5} more`));
+    }
+    console.log(chalk8.dim("  Update these imports to relative paths first, then re-run fix."));
+  }
+  if (safeRenames.length === 0 && testStubs.length === 0) {
+    console.log(`
+${chalk8.yellow("!")} No safe fixes to apply. Resolve aliased imports first.`);
     return 0;
   }
-  printPlan(dedupedRenames, testStubs);
   if (options.dryRun) {
-    console.log(chalk7.dim("\nDry run \u2014 no changes applied."));
+    console.log(chalk8.dim("\nDry run \u2014 no changes applied."));
     return 0;
   }
   if (!options.yes) {
@@ -2421,15 +2627,15 @@ async function fixCommand(options, cwd) {
     }
   }
   let renameCount = 0;
-  for (const rename of dedupedRenames) {
+  for (const rename of safeRenames) {
     if (executeRename(rename)) {
       renameCount++;
     }
   }
   let importUpdateCount = 0;
   if (renameCount > 0) {
-    const appliedRenames = dedupedRenames.filter((r) => fs13.existsSync(r.newAbsPath));
-    const updates = await updateImportsAfterRenames(appliedRenames, projectRoot);
+    const appliedRenames = safeRenames.filter((r) => fs13.existsSync(r.newAbsPath));
+    const { updates } = await updateImportsAfterRenames(appliedRenames, projectRoot);
     importUpdateCount = updates.length;
   }
   let stubCount = 0;
@@ -2441,33 +2647,33 @@ async function fixCommand(options, cwd) {
   }
   console.log("");
   if (renameCount > 0) {
-    console.log(`${chalk7.green("\u2713")} Renamed ${renameCount} file${renameCount > 1 ? "s" : ""}`);
+    console.log(`${chalk8.green("\u2713")} Renamed ${renameCount} file${renameCount > 1 ? "s" : ""}`);
   }
   if (importUpdateCount > 0) {
     console.log(
-      `${chalk7.green("\u2713")} Updated ${importUpdateCount} import${importUpdateCount > 1 ? "s" : ""}`
+      `${chalk8.green("\u2713")} Updated ${importUpdateCount} import${importUpdateCount > 1 ? "s" : ""}`
     );
   }
   if (stubCount > 0) {
-    console.log(`${chalk7.green("\u2713")} Generated ${stubCount} test stub${stubCount > 1 ? "s" : ""}`);
+    console.log(`${chalk8.green("\u2713")} Generated ${stubCount} test stub${stubCount > 1 ? "s" : ""}`);
   }
   return 0;
 }
 
 // src/commands/init.ts
-import * as fs18 from "fs";
-import * as path18 from "path";
+import * as fs19 from "fs";
+import * as path19 from "path";
 import * as clack8 from "@clack/prompts";
 import { compactConfig as compactConfig3, generateConfig } from "@viberails/config";
 import { scan as scan2 } from "@viberails/scanner";
-import chalk11 from "chalk";
+import chalk12 from "chalk";
 
 // src/utils/check-prerequisites.ts
 import { spawnSync as spawnSync3 } from "child_process";
 import * as fs14 from "fs";
 import * as path14 from "path";
 import * as clack7 from "@clack/prompts";
-import chalk8 from "chalk";
+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);
@@ -2498,9 +2704,9 @@ function displayMissingPrereqs(prereqs) {
   const missing = prereqs.filter((p) => !p.installed);
   for (const m of missing) {
     const suffix = m.affectedPackages ? ` \u2014 needed for coverage in: ${m.affectedPackages.join(", ")}` : ` \u2014 ${m.reason}`;
-    console.log(`  ${chalk8.yellow("!")} ${m.label} not installed${suffix}`);
+    console.log(`  ${chalk9.yellow("!")} ${m.label} not installed${suffix}`);
     if (m.installCommand) {
-      console.log(`    Install: ${chalk8.cyan(m.installCommand)}`);
+      console.log(`    Install: ${chalk9.cyan(m.installCommand)}`);
     }
   }
 }
@@ -2611,46 +2817,85 @@ function updateGitignore(projectRoot) {
 }
 
 // src/commands/init-hooks.ts
+import * as fs17 from "fs";
+import * as path17 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 chalk9 from "chalk";
-import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+function hasTurboTask(projectRoot, taskName) {
+  const turboPath = path16.join(projectRoot, "turbo.json");
+  if (!fs16.existsSync(turboPath)) return false;
+  try {
+    const turbo = JSON.parse(fs16.readFileSync(turboPath, "utf-8"));
+    const tasks = turbo.tasks ?? turbo.pipeline ?? {};
+    return taskName in tasks;
+  } catch {
+    return false;
+  }
+}
+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)) {
+    try {
+      const pkg = JSON.parse(fs16.readFileSync(pkgJsonPath, "utf-8"));
+      if (pkg.scripts?.typecheck) {
+        const pm = packageManager ?? "npm";
+        return { command: `${pm} run typecheck`, label: `${pm} run typecheck` };
+      }
+    } catch {
+    }
+  }
+  if (fs16.existsSync(path16.join(projectRoot, "tsconfig.json"))) {
+    return { command: "npx tsc --noEmit", label: "tsc --noEmit" };
+  }
+  return {
+    reason: "no root tsconfig.json, no typecheck script, and no turbo typecheck task found"
+  };
+}
+
+// src/commands/init-hooks.ts
 function setupPreCommitHook(projectRoot) {
-  const lefthookPath = path16.join(projectRoot, "lefthook.yml");
-  if (fs16.existsSync(lefthookPath)) {
+  const lefthookPath = path17.join(projectRoot, "lefthook.yml");
+  if (fs17.existsSync(lefthookPath)) {
     addLefthookPreCommit(lefthookPath);
-    console.log(`  ${chalk9.green("\u2713")} lefthook.yml \u2014 added viberails pre-commit`);
+    console.log(`  ${chalk10.green("\u2713")} lefthook.yml \u2014 added viberails pre-commit`);
     return "lefthook.yml";
   }
-  const huskyDir = path16.join(projectRoot, ".husky");
-  if (fs16.existsSync(huskyDir)) {
+  const huskyDir = path17.join(projectRoot, ".husky");
+  if (fs17.existsSync(huskyDir)) {
     writeHuskyPreCommit(huskyDir);
-    console.log(`  ${chalk9.green("\u2713")} .husky/pre-commit \u2014 added viberails check`);
+    console.log(`  ${chalk10.green("\u2713")} .husky/pre-commit \u2014 added viberails check`);
     return ".husky/pre-commit";
   }
-  const gitDir = path16.join(projectRoot, ".git");
-  if (fs16.existsSync(gitDir)) {
-    const hooksDir = path16.join(gitDir, "hooks");
-    if (!fs16.existsSync(hooksDir)) {
-      fs16.mkdirSync(hooksDir, { recursive: true });
+  const gitDir = path17.join(projectRoot, ".git");
+  if (fs17.existsSync(gitDir)) {
+    const hooksDir = path17.join(gitDir, "hooks");
+    if (!fs17.existsSync(hooksDir)) {
+      fs17.mkdirSync(hooksDir, { recursive: true });
     }
     writeGitHookPreCommit(hooksDir);
-    console.log(`  ${chalk9.green("\u2713")} .git/hooks/pre-commit`);
+    console.log(`  ${chalk10.green("\u2713")} .git/hooks/pre-commit`);
     return ".git/hooks/pre-commit";
   }
   return void 0;
 }
 function writeGitHookPreCommit(hooksDir) {
-  const hookPath = path16.join(hooksDir, "pre-commit");
-  if (fs16.existsSync(hookPath)) {
-    const existing = fs16.readFileSync(hookPath, "utf-8");
+  const hookPath = path17.join(hooksDir, "pre-commit");
+  if (fs17.existsSync(hookPath)) {
+    const existing = fs17.readFileSync(hookPath, "utf-8");
     if (existing.includes("viberails")) return;
-    fs16.writeFileSync(
+    fs17.writeFileSync(
       hookPath,
       `${existing.trimEnd()}
 
 # viberails check
-npx viberails check --staged
+if [ -x ./node_modules/.bin/viberails ]; then ./node_modules/.bin/viberails check --staged; else npx viberails check --staged; fi
 `
     );
     return;
@@ -2659,13 +2904,13 @@ npx viberails check --staged
     "#!/bin/sh",
     "# Generated by viberails \u2014 https://viberails.sh",
     "",
-    "npx viberails check --staged",
+    "if [ -x ./node_modules/.bin/viberails ]; then ./node_modules/.bin/viberails check --staged; else npx viberails check --staged; fi",
     ""
   ].join("\n");
-  fs16.writeFileSync(hookPath, script, { mode: 493 });
+  fs17.writeFileSync(hookPath, script, { mode: 493 });
 }
 function addLefthookPreCommit(lefthookPath) {
-  const content = fs16.readFileSync(lefthookPath, "utf-8");
+  const content = fs17.readFileSync(lefthookPath, "utf-8");
   if (content.includes("viberails")) return;
   const doc = parseYaml(content) ?? {};
   if (!doc["pre-commit"]) {
@@ -2675,30 +2920,30 @@ function addLefthookPreCommit(lefthookPath) {
     doc["pre-commit"].commands = {};
   }
   doc["pre-commit"].commands.viberails = {
-    run: "npx viberails check --staged"
+    run: "if [ -x ./node_modules/.bin/viberails ]; then ./node_modules/.bin/viberails check --staged; else npx viberails check --staged; fi"
   };
-  fs16.writeFileSync(lefthookPath, stringifyYaml(doc));
+  fs17.writeFileSync(lefthookPath, stringifyYaml(doc));
 }
 function detectHookManager(projectRoot) {
-  if (fs16.existsSync(path16.join(projectRoot, "lefthook.yml"))) return "Lefthook";
-  if (fs16.existsSync(path16.join(projectRoot, ".husky"))) return "Husky";
+  if (fs17.existsSync(path17.join(projectRoot, "lefthook.yml"))) return "Lefthook";
+  if (fs17.existsSync(path17.join(projectRoot, ".husky"))) return "Husky";
   return void 0;
 }
 function setupClaudeCodeHook(projectRoot) {
-  const claudeDir = path16.join(projectRoot, ".claude");
-  if (!fs16.existsSync(claudeDir)) {
-    fs16.mkdirSync(claudeDir, { recursive: true });
+  const claudeDir = path17.join(projectRoot, ".claude");
+  if (!fs17.existsSync(claudeDir)) {
+    fs17.mkdirSync(claudeDir, { recursive: true });
   }
-  const settingsPath = path16.join(claudeDir, "settings.json");
+  const settingsPath = path17.join(claudeDir, "settings.json");
   let settings = {};
-  if (fs16.existsSync(settingsPath)) {
+  if (fs17.existsSync(settingsPath)) {
     try {
-      settings = JSON.parse(fs16.readFileSync(settingsPath, "utf-8"));
+      settings = JSON.parse(fs17.readFileSync(settingsPath, "utf-8"));
     } catch {
       console.warn(
-        `  ${chalk9.yellow("!")} .claude/settings.json contains invalid JSON \u2014 skipping hook setup`
+        `  ${chalk10.yellow("!")} .claude/settings.json contains invalid JSON \u2014 skipping hook setup`
       );
-      console.warn(`  Fix the JSON manually, then re-run ${chalk9.cyan("viberails init --force")}`);
+      console.warn(`  Fix the JSON manually, then re-run ${chalk10.cyan("viberails init --force")}`);
       return;
     }
   }
@@ -2719,30 +2964,30 @@ function setupClaudeCodeHook(projectRoot) {
     }
   ];
   settings.hooks = hooks;
-  fs16.writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}
+  fs17.writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}
 `);
-  console.log(`  ${chalk9.green("\u2713")} .claude/settings.json \u2014 added viberails PostToolUse hook`);
+  console.log(`  ${chalk10.green("\u2713")} .claude/settings.json \u2014 added viberails PostToolUse hook`);
 }
 function setupClaudeMdReference(projectRoot) {
-  const claudeMdPath = path16.join(projectRoot, "CLAUDE.md");
+  const claudeMdPath = path17.join(projectRoot, "CLAUDE.md");
   let content = "";
-  if (fs16.existsSync(claudeMdPath)) {
-    content = fs16.readFileSync(claudeMdPath, "utf-8");
+  if (fs17.existsSync(claudeMdPath)) {
+    content = fs17.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();
-  fs16.writeFileSync(claudeMdPath, prefix + ref);
-  console.log(`  ${chalk9.green("\u2713")} CLAUDE.md \u2014 added @.viberails/context.md reference`);
+  fs17.writeFileSync(claudeMdPath, prefix + ref);
+  console.log(`  ${chalk10.green("\u2713")} CLAUDE.md \u2014 added @.viberails/context.md reference`);
 }
 function setupGithubAction(projectRoot, packageManager, options) {
-  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");
+  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");
     if (existing.includes("viberails")) return void 0;
   }
-  fs16.mkdirSync(workflowDir, { recursive: true });
+  fs17.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`;
@@ -2751,7 +2996,7 @@ function setupGithubAction(projectRoot, packageManager, options) {
     "",
     "on:",
     "  pull_request:",
-    "    branches: [main]",
+    "    branches: [main, master]",
     "",
     "jobs:",
     "  check:",
@@ -2769,87 +3014,94 @@ function setupGithubAction(projectRoot, packageManager, options) {
     "      - uses: actions/setup-node@v4",
     "        with:",
     "          node-version: 22",
-    pm !== "npm" ? `          cache: ${pm}` : "",
+    `          cache: ${pm}`,
     "",
     `      - run: ${installCmd}`
   );
   if (options?.typecheck) {
-    lines.push(`      - run: ${runPrefix} tsc --noEmit`);
+    const resolved = resolveTypecheckCommand(projectRoot, pm);
+    if (resolved.command) {
+      const ciCmd = resolved.command.startsWith("npx ") ? `${runPrefix} ${resolved.command.slice(4)}` : resolved.command;
+      lines.push(`      - run: ${ciCmd}`);
+    }
   }
   if (options?.linter) {
     const lintCmd = options.linter === "biome" ? "biome check ." : "eslint .";
     lines.push(`      - run: ${runPrefix} ${lintCmd}`);
   }
   lines.push(
-    `      - run: ${runPrefix} viberails check --enforce --diff-base origin/\${{ github.event.pull_request.base.ref }}`,
+    `      - run: npx viberails check --enforce --diff-base origin/\${{ github.event.pull_request.base.ref }}`,
     ""
   );
   const content = lines.filter((l) => l !== void 0).join("\n");
-  fs16.writeFileSync(workflowPath, content);
+  fs17.writeFileSync(workflowPath, content);
   return ".github/workflows/viberails.yml";
 }
 function writeHuskyPreCommit(huskyDir) {
-  const hookPath = path16.join(huskyDir, "pre-commit");
-  if (fs16.existsSync(hookPath)) {
-    const existing = fs16.readFileSync(hookPath, "utf-8");
+  const hookPath = path17.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 (!existing.includes("viberails")) {
-      fs16.writeFileSync(hookPath, `${existing.trimEnd()}
-npx viberails check --staged
+      fs17.writeFileSync(hookPath, `${existing.trimEnd()}
+${cmd}
 `);
     }
     return;
   }
-  fs16.writeFileSync(hookPath, "#!/bin/sh\nnpx viberails check --staged\n", { mode: 493 });
+  fs17.writeFileSync(hookPath, `#!/bin/sh
+${cmd}
+`, { mode: 493 });
 }
 
 // src/commands/init-hooks-extra.ts
-import * as fs17 from "fs";
-import * as path17 from "path";
-import chalk10 from "chalk";
+import * as fs18 from "fs";
+import * as path18 from "path";
+import chalk11 from "chalk";
 import { parse as parseYaml2, stringify as stringifyYaml2 } from "yaml";
 function addPreCommitStep(projectRoot, name, command, marker) {
-  const lefthookPath = path17.join(projectRoot, "lefthook.yml");
-  if (fs17.existsSync(lefthookPath)) {
-    const content = fs17.readFileSync(lefthookPath, "utf-8");
+  const lefthookPath = path18.join(projectRoot, "lefthook.yml");
+  if (fs18.existsSync(lefthookPath)) {
+    const content = fs18.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 };
-    fs17.writeFileSync(lefthookPath, stringifyYaml2(doc));
+    fs18.writeFileSync(lefthookPath, stringifyYaml2(doc));
     return "lefthook.yml";
   }
-  const huskyDir = path17.join(projectRoot, ".husky");
-  if (fs17.existsSync(huskyDir)) {
-    const hookPath = path17.join(huskyDir, "pre-commit");
-    if (fs17.existsSync(hookPath)) {
-      const existing = fs17.readFileSync(hookPath, "utf-8");
+  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");
       if (existing.includes(marker)) return void 0;
-      fs17.writeFileSync(hookPath, `${existing.trimEnd()}
+      fs18.writeFileSync(hookPath, `${existing.trimEnd()}
 ${command}
 `);
     } else {
-      fs17.writeFileSync(hookPath, `#!/bin/sh
+      fs18.writeFileSync(hookPath, `#!/bin/sh
 ${command}
 `, { mode: 493 });
     }
     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 hookPath = path17.join(hooksDir, "pre-commit");
-    if (fs17.existsSync(hookPath)) {
-      const existing = fs17.readFileSync(hookPath, "utf-8");
+  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");
       if (existing.includes(marker)) return void 0;
-      fs17.writeFileSync(hookPath, `${existing.trimEnd()}
+      fs18.writeFileSync(hookPath, `${existing.trimEnd()}
 
 # ${name}
 ${command}
 `);
     } else {
-      fs17.writeFileSync(hookPath, `#!/bin/sh
+      fs18.writeFileSync(hookPath, `#!/bin/sh
 # Generated by viberails
 
 # ${name}
@@ -2862,10 +3114,15 @@ ${command}
   }
   return void 0;
 }
-function setupTypecheckHook(projectRoot) {
-  const target = addPreCommitStep(projectRoot, "typecheck", "npx tsc --noEmit", "tsc");
+function setupTypecheckHook(projectRoot, packageManager) {
+  const resolved = resolveTypecheckCommand(projectRoot, packageManager);
+  if (!resolved.command) {
+    console.log(`  ${chalk11.yellow("!")} Skipped typecheck hook: ${resolved.reason}`);
+    return void 0;
+  }
+  const target = addPreCommitStep(projectRoot, "typecheck", resolved.command, "typecheck");
   if (target) {
-    console.log(`  ${chalk10.green("\u2713")} ${target} \u2014 added typecheck (tsc --noEmit)`);
+    console.log(`  ${chalk11.green("\u2713")} ${target} \u2014 added typecheck (${resolved.label})`);
   }
   return target;
 }
@@ -2874,7 +3131,7 @@ function setupLintHook(projectRoot, linter) {
   const linterName = linter === "biome" ? "Biome" : "ESLint";
   const target = addPreCommitStep(projectRoot, "lint", command, linter);
   if (target) {
-    console.log(`  ${chalk10.green("\u2713")} ${target} \u2014 added ${linterName} lint check`);
+    console.log(`  ${chalk11.green("\u2713")} ${target} \u2014 added ${linterName} lint check`);
   }
   return target;
 }
@@ -2885,7 +3142,7 @@ function setupSelectedIntegrations(projectRoot, integrations, opts) {
     created.push(t ? `${t} \u2014 added viberails pre-commit` : "pre-commit hook skipped");
   }
   if (integrations.typecheckHook) {
-    const t = setupTypecheckHook(projectRoot);
+    const t = setupTypecheckHook(projectRoot, opts.packageManager);
     if (t) created.push(`${t} \u2014 added typecheck`);
   }
   if (integrations.lintHook && opts.linter) {
@@ -2922,11 +3179,11 @@ async function initCommand(options, cwd) {
       "No package.json found. Make sure you are inside a JS/TS project, then run:\n  npx viberails"
     );
   }
-  const configPath = path18.join(projectRoot, CONFIG_FILE5);
-  if (fs18.existsSync(configPath) && !options.force) {
+  const configPath = path19.join(projectRoot, CONFIG_FILE5);
+  if (fs19.existsSync(configPath) && !options.force) {
     console.log(
-      `${chalk11.yellow("!")} viberails is already initialized.
-  Run ${chalk11.cyan("viberails config")} to edit rules, ${chalk11.cyan("viberails sync")} to update, or ${chalk11.cyan("viberails init --force")} to start fresh.`
+      `${chalk12.yellow("!")} viberails is already initialized.
+  Run ${chalk12.cyan("viberails config")} to edit rules, ${chalk12.cyan("viberails sync")} to update, or ${chalk12.cyan("viberails init --force")} to start fresh.`
     );
     return;
   }
@@ -2934,7 +3191,7 @@ async function initCommand(options, cwd) {
   await initInteractive(projectRoot, configPath, options);
 }
 async function initNonInteractive(projectRoot, configPath) {
-  console.log(chalk11.dim("Scanning project..."));
+  console.log(chalk12.dim("Scanning project..."));
   const scanResult = await scan2(projectRoot);
   const config = generateConfig(scanResult);
   for (const pkg of config.packages) {
@@ -2947,11 +3204,11 @@ async function initNonInteractive(projectRoot, configPath) {
   const exempted = getExemptedPackages(config);
   if (exempted.length > 0) {
     console.log(
-      `  ${chalk11.dim("Auto-exempted from coverage:")} ${exempted.join(", ")} ${chalk11.dim("(types-only)")}`
+      `  ${chalk12.dim("Auto-exempted from coverage:")} ${exempted.join(", ")} ${chalk12.dim("(types-only)")}`
     );
   }
   if (config.packages.length > 1) {
-    console.log(chalk11.dim("Building import graph..."));
+    console.log(chalk12.dim("Building import graph..."));
     const { buildImportGraph, inferBoundaries } = await import("@viberails/graph");
     const packages = resolveWorkspacePackages(projectRoot, config.packages);
     const graph = await buildImportGraph(projectRoot, { packages, ignore: config.ignore });
@@ -2964,16 +3221,16 @@ async function initNonInteractive(projectRoot, configPath) {
     }
   }
   const compacted = compactConfig3(config);
-  fs18.writeFileSync(configPath, `${JSON.stringify(compacted, null, 2)}
+  fs19.writeFileSync(configPath, `${JSON.stringify(compacted, null, 2)}
 `);
   writeGeneratedFiles(projectRoot, config, scanResult);
   updateGitignore(projectRoot);
   setupClaudeCodeHook(projectRoot);
   setupClaudeMdReference(projectRoot);
   const rootPkg = config.packages[0];
-  const rootPkgPm = rootPkg?.stack?.packageManager ?? "npm";
+  const rootPkgPm = rootPkg?.stack?.packageManager?.split("@")[0] ?? "npm";
   const linter = rootPkg?.stack?.linter?.split("@")[0];
-  const isTypeScript = rootPkg?.stack?.language === "typescript";
+  const isTypeScript = rootPkg?.stack?.language?.split("@")[0] === "typescript";
   const actionTarget = setupGithubAction(projectRoot, rootPkgPm, {
     linter,
     typecheck: isTypeScript
@@ -2981,17 +3238,17 @@ async function initNonInteractive(projectRoot, configPath) {
   const hookManager = detectHookManager(projectRoot);
   const hasHookManager = hookManager === "Lefthook" || hookManager === "Husky";
   const preCommitTarget = hasHookManager ? setupPreCommitHook(projectRoot) : void 0;
-  const ok = chalk11.green("\u2713");
+  const ok = chalk12.green("\u2713");
   const created = [
-    `${ok} ${path18.basename(configPath)}`,
+    `${ok} ${path19.basename(configPath)}`,
     `${ok} .viberails/context.md`,
     `${ok} .viberails/scan-result.json`,
     `${ok} .claude/settings.json \u2014 added viberails hook`,
     `${ok} CLAUDE.md \u2014 added @.viberails/context.md reference`,
-    preCommitTarget ? `${ok} ${preCommitTarget}` : `${chalk11.yellow("!")} pre-commit hook skipped (install lefthook or husky)`,
+    preCommitTarget ? `${ok} ${preCommitTarget}` : `${chalk12.yellow("!")} pre-commit hook skipped (install lefthook or husky)`,
     actionTarget ? `${ok} ${actionTarget} \u2014 blocks PRs on violations` : ""
   ].filter(Boolean);
-  if (hasHookManager && rootPkg?.stack?.language === "typescript") setupTypecheckHook(projectRoot);
+  if (hasHookManager && isTypeScript) setupTypecheckHook(projectRoot, rootPkgPm);
   if (hasHookManager && linter) setupLintHook(projectRoot, linter);
   console.log(`
 Created:
@@ -2999,9 +3256,9 @@ ${created.map((f) => `  ${f}`).join("\n")}`);
 }
 async function initInteractive(projectRoot, configPath, options) {
   clack8.intro("viberails");
-  if (fs18.existsSync(configPath) && options.force) {
+  if (fs19.existsSync(configPath) && options.force) {
     const replace = await confirmDangerous(
-      `${path18.basename(configPath)} already exists and will be replaced. Continue?`
+      `${path19.basename(configPath)} already exists and will be replaced. Continue?`
     );
     if (!replace) {
       clack8.outro("Aborted. No files were written.");
@@ -3013,13 +3270,6 @@ async function initInteractive(projectRoot, configPath, options) {
   const scanResult = await scan2(projectRoot);
   const config = generateConfig(scanResult);
   s.stop("Scan complete");
-  const prereqResult = await promptMissingPrereqs(
-    projectRoot,
-    checkCoveragePrereqs(projectRoot, scanResult)
-  );
-  if (prereqResult.disableCoverage) {
-    config.rules.testCoverage = 0;
-  }
   if (scanResult.statistics.totalFiles === 0) {
     clack8.log.warn(
       "No source files detected. Try running from the project root,\nor check that source files exist. Run viberails sync after adding files."
@@ -3060,20 +3310,28 @@ async function initInteractive(projectRoot, configPath, options) {
       if (denyCount > 0) {
         config.boundaries = inferred;
         config.rules.enforceBoundaries = true;
-        bs.stop(`Inferred ${denyCount} boundary rules`);
-        const boundaryLines = Object.entries(inferred.deny).map(([pkg, denied]) => `${pkg} must NOT import from: ${denied.join(", ")}`).join("\n");
-        clack8.note(boundaryLines, "Boundary rules");
+        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 === "typescript",
+    isTypeScript: rootPkgStack?.language?.split("@")[0] === "typescript",
     linter: rootPkgStack?.linter?.split("@")[0],
-    packageManager: rootPkgStack?.packageManager,
+    packageManager: rootPkgStack?.packageManager?.split("@")[0],
     isWorkspace: config.packages.length > 1
   });
   const shouldWrite = await confirm3("Write configuration and set up selected integrations?");
@@ -3082,40 +3340,37 @@ async function initInteractive(projectRoot, configPath, options) {
     return;
   }
   const compacted = compactConfig3(config);
-  fs18.writeFileSync(configPath, `${JSON.stringify(compacted, null, 2)}
+  fs19.writeFileSync(configPath, `${JSON.stringify(compacted, null, 2)}
 `);
   writeGeneratedFiles(projectRoot, config, scanResult);
   updateGitignore(projectRoot);
-  const createdFiles = [
-    path18.basename(configPath),
-    ".viberails/context.md",
-    ".viberails/scan-result.json",
-    ...setupSelectedIntegrations(projectRoot, integrations, {
-      linter: rootPkgStack?.linter?.split("@")[0],
-      packageManager: rootPkgStack?.packageManager
-    })
-  ];
-  clack8.log.success(`Created:
-${createdFiles.map((f) => `  ${f}`).join("\n")}`);
+  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(
     `Done! Next: review viberails.config.json, then run viberails check
-  ${chalk11.dim("Tip: use")} ${chalk11.cyan("viberails check --enforce")} ${chalk11.dim("in CI to block PRs on violations.")}`
+  ${chalk12.dim("Tip: use")} ${chalk12.cyan("viberails check --enforce")} ${chalk12.dim("in CI to block PRs on violations.")}`
   );
 }
 
 // src/commands/sync.ts
-import * as fs19 from "fs";
-import * as path19 from "path";
+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 chalk12 from "chalk";
+import chalk13 from "chalk";
 var CONFIG_FILE6 = "viberails.config.json";
 var SCAN_RESULT_FILE2 = ".viberails/scan-result.json";
 function loadPreviousStats(projectRoot) {
-  const scanResultPath = path19.join(projectRoot, SCAN_RESULT_FILE2);
+  const scanResultPath = path20.join(projectRoot, SCAN_RESULT_FILE2);
   try {
-    const raw = fs19.readFileSync(scanResultPath, "utf-8");
+    const raw = fs20.readFileSync(scanResultPath, "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed?.statistics?.totalFiles !== void 0) {
       return parsed.statistics;
@@ -3132,15 +3387,15 @@ 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 = path19.join(projectRoot, CONFIG_FILE6);
+  const configPath = path20.join(projectRoot, CONFIG_FILE6);
   const existing = await loadConfig5(configPath);
   const previousStats = loadPreviousStats(projectRoot);
-  console.log(chalk12.dim("Scanning project..."));
+  console.log(chalk13.dim("Scanning project..."));
   const scanResult = await scan3(projectRoot);
   const merged = mergeConfig2(existing, scanResult);
   const compacted = compactConfig4(merged);
   const compactedJson = JSON.stringify(compacted, null, 2);
-  const rawDisk = fs19.readFileSync(configPath, "utf-8").trim();
+  const rawDisk = fs20.readFileSync(configPath, "utf-8").trim();
   const diskWithoutSync = rawDisk.replace(/"lastSync":\s*"[^"]*"/, '"lastSync": ""');
   const mergedWithoutSync = compactedJson.replace(/"lastSync":\s*"[^"]*"/, '"lastSync": ""');
   const configChanged = diskWithoutSync !== mergedWithoutSync;
@@ -3148,13 +3403,13 @@ async function syncCommand(options, cwd) {
   const statsDelta = previousStats ? formatStatsDelta(previousStats, scanResult.statistics) : void 0;
   if (changes.length > 0 || statsDelta) {
     console.log(`
-${chalk12.bold("Changes:")}`);
+${chalk13.bold("Changes:")}`);
     for (const change of changes) {
-      const icon = change.type === "removed" ? chalk12.red("-") : chalk12.green("+");
+      const icon = change.type === "removed" ? chalk13.red("-") : chalk13.green("+");
       console.log(`  ${icon} ${change.description}`);
     }
     if (statsDelta) {
-      console.log(`  ${chalk12.dim(statsDelta)}`);
+      console.log(`  ${chalk13.dim(statsDelta)}`);
     }
   }
   if (options?.interactive) {
@@ -3187,7 +3442,7 @@ ${chalk12.bold("Changes:")}`);
       });
       applyRuleOverrides(merged, overrides);
       const recompacted = compactConfig4(merged);
-      fs19.writeFileSync(configPath, `${JSON.stringify(recompacted, null, 2)}
+      fs20.writeFileSync(configPath, `${JSON.stringify(recompacted, null, 2)}
 `);
       writeGeneratedFiles(projectRoot, merged, scanResult);
       clack9.log.success("Updated config with your customizations.");
@@ -3195,22 +3450,22 @@ ${chalk12.bold("Changes:")}`);
       return;
     }
   }
-  fs19.writeFileSync(configPath, `${compactedJson}
+  fs20.writeFileSync(configPath, `${compactedJson}
 `);
   writeGeneratedFiles(projectRoot, merged, scanResult);
   console.log(`
-${chalk12.bold("Synced:")}`);
+${chalk13.bold("Synced:")}`);
   if (configChanged) {
-    console.log(`  ${chalk12.yellow("!")} ${CONFIG_FILE6} \u2014 updated (review changes)`);
+    console.log(`  ${chalk13.yellow("!")} ${CONFIG_FILE6} \u2014 updated (review changes)`);
   } else {
-    console.log(`  ${chalk12.green("\u2713")} ${CONFIG_FILE6} \u2014 unchanged`);
+    console.log(`  ${chalk13.green("\u2713")} ${CONFIG_FILE6} \u2014 unchanged`);
   }
-  console.log(`  ${chalk12.green("\u2713")} .viberails/context.md \u2014 regenerated`);
-  console.log(`  ${chalk12.green("\u2713")} .viberails/scan-result.json \u2014 updated`);
+  console.log(`  ${chalk13.green("\u2713")} .viberails/context.md \u2014 regenerated`);
+  console.log(`  ${chalk13.green("\u2713")} .viberails/scan-result.json \u2014 updated`);
 }
 
 // src/index.ts
-var VERSION = "0.5.4";
+var VERSION = "0.6.0";
 var program = new Command();
 program.name("viberails").description("Guardrails for vibe coding").version(VERSION);
 program.command("init", { isDefault: true }).description("Scan your project and set up enforcement guardrails").option("-y, --yes", "Non-interactive mode (use defaults, high-confidence only)").option("-f, --force", "Re-initialize, replacing existing config").action(async (options) => {
@@ -3218,7 +3473,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(`${chalk13.red("Error:")} ${message}`);
+    console.error(`${chalk14.red("Error:")} ${message}`);
     process.exit(1);
   }
 });
@@ -3227,7 +3482,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(`${chalk13.red("Error:")} ${message}`);
+    console.error(`${chalk14.red("Error:")} ${message}`);
     process.exit(1);
   }
 });
@@ -3236,7 +3491,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(`${chalk13.red("Error:")} ${message}`);
+    console.error(`${chalk14.red("Error:")} ${message}`);
     process.exit(1);
   }
 });
@@ -3257,7 +3512,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(`${chalk13.red("Error:")} ${message}`);
+      console.error(`${chalk14.red("Error:")} ${message}`);
       process.exit(1);
     }
   }
@@ -3268,7 +3523,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(`${chalk13.red("Error:")} ${message}`);
+    console.error(`${chalk14.red("Error:")} ${message}`);
     process.exit(1);
   }
 });
@@ -3277,7 +3532,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(`${chalk13.red("Error:")} ${message}`);
+    console.error(`${chalk14.red("Error:")} ${message}`);
     process.exit(1);
   }
 });