@getcoherent/cli 0.6.24 → 0.6.26

package/dist/index.js

@@ -2,21 +2,24 @@ import {
   createAIProvider
 } from "./chunk-SPQZBQYY.js";
 import {
-  autoFixCode,
-  checkDesignConsistency,
-  formatIssues,
-  validatePageQuality,
-  verifyIncrementalEdit
-} from "./chunk-2ZL4X4QD.js";
-import {
+  COHERENT_REQUIRED_PACKAGES,
+  ensureUseClientIfNeeded,
+  extractNpmPackagesFromCode,
+  findMissingPackages,
+  findMissingPackagesInCode,
+  fixEscapedClosingQuotes,
+  fixUnescapedLtInJsx,
   generateArchitecturePlan,
+  getInstalledPackages,
   getPageGroup,
   getPageType,
+  installPackages,
   loadPlan,
   routeToKey,
+  sanitizeMetadataStrings,
   savePlan,
   updateArchitecturePlan
-} from "./chunk-IYLHC4RC.js";
+} from "./chunk-CC3ARMGS.js";
 import {
   CORE_CONSTRAINTS,
   DESIGN_QUALITY,
@@ -28,6 +31,13 @@ import {
   inferPageTypeFromRoute,
   selectContextualRules
 } from "./chunk-5AHG4NNX.js";
+import {
+  autoFixCode,
+  checkDesignConsistency,
+  formatIssues,
+  validatePageQuality,
+  verifyIncrementalEdit
+} from "./chunk-H644LLXJ.js";
 import {
   __require
 } from "./chunk-3RG5ZIWI.js";
@@ -41,9 +51,9 @@ import { CLI_VERSION as CLI_VERSION6 } from "@getcoherent/core";
 import chalk4 from "chalk";
 import ora from "ora";
 import prompts2 from "prompts";
-import { existsSync as existsSync8, readFileSync as readFileSync5, mkdirSync as mkdirSync3, rmSync, writeFileSync as writeFileSync5 } from "fs";
-import { join as join6 } from "path";
-import { execSync as execSync2 } from "child_process";
+import { existsSync as existsSync7, readFileSync as readFileSync4, mkdirSync as mkdirSync3, rmSync, writeFileSync as writeFileSync5 } from "fs";
+import { join as join5 } from "path";
+import { execSync } from "child_process";
 
 // src/utils/find-config.ts
 import { existsSync } from "fs";
@@ -1803,222 +1813,6 @@ function formatTimeAgo(iso) {
   return date.toLocaleDateString();
 }
 
-// src/utils/self-heal.ts
-import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
-import { join as join3 } from "path";
-import { readdir, readFile as readFile2 } from "fs/promises";
-import { execSync } from "child_process";
-var COHERENT_REQUIRED_PACKAGES = [
-  "lucide-react",
-  "class-variance-authority",
-  "clsx",
-  "tailwind-merge",
-  "@radix-ui/react-slot"
-];
-var IMPORT_FROM_REGEX = /from\s+['"]([^'"]+)['"]/g;
-var NODE_BUILTINS = /* @__PURE__ */ new Set([
-  "assert",
-  "async_hooks",
-  "buffer",
-  "child_process",
-  "cluster",
-  "console",
-  "constants",
-  "crypto",
-  "dgram",
-  "diagnostics_channel",
-  "dns",
-  "domain",
-  "events",
-  "fs",
-  "http",
-  "http2",
-  "https",
-  "inspector",
-  "module",
-  "net",
-  "os",
-  "path",
-  "perf_hooks",
-  "process",
-  "punycode",
-  "querystring",
-  "readline",
-  "repl",
-  "stream",
-  "string_decoder",
-  "sys",
-  "test",
-  "timers",
-  "tls",
-  "trace_events",
-  "tty",
-  "url",
-  "util",
-  "v8",
-  "vm",
-  "wasi",
-  "worker_threads",
-  "zlib",
-  "fs/promises",
-  "path/posix",
-  "path/win32",
-  "stream/promises",
-  "stream/web",
-  "timers/promises",
-  "util/types"
-]);
-function extractNpmPackagesFromCode(code) {
-  if (typeof code !== "string") return /* @__PURE__ */ new Set();
-  const pkgs = /* @__PURE__ */ new Set();
-  let m;
-  IMPORT_FROM_REGEX.lastIndex = 0;
-  while ((m = IMPORT_FROM_REGEX.exec(code)) !== null) {
-    const spec = m[1];
-    if (spec.startsWith(".") || spec.startsWith("/") || spec.startsWith("@/") || spec === "next") continue;
-    if (spec.startsWith("node:") || NODE_BUILTINS.has(spec)) continue;
-    const pkg = spec.startsWith("@") ? spec.split("/").slice(0, 2).join("/") : spec.split("/")[0];
-    if (pkg && !NODE_BUILTINS.has(pkg)) pkgs.add(pkg);
-  }
-  return pkgs;
-}
-function getInstalledPackages(projectRoot) {
-  const pkgPath = join3(projectRoot, "package.json");
-  if (!existsSync4(pkgPath)) return /* @__PURE__ */ new Set();
-  try {
-    const json = JSON.parse(readFileSync3(pkgPath, "utf-8"));
-    const deps = { ...json.dependencies ?? {}, ...json.devDependencies ?? {} };
-    return new Set(Object.keys(deps));
-  } catch (e) {
-    if (process.env.COHERENT_DEBUG === "1") console.error("Failed to read package.json:", e);
-    return /* @__PURE__ */ new Set();
-  }
-}
-async function collectImportedPackages(dir, extensions) {
-  const packages = /* @__PURE__ */ new Set();
-  if (!existsSync4(dir)) return packages;
-  async function walk(d) {
-    let entries;
-    try {
-      entries = await readdir(d, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    for (const e of entries) {
-      const full = join3(d, e.name);
-      if (e.isDirectory() && !e.name.startsWith(".") && e.name !== "node_modules") {
-        await walk(full);
-        continue;
-      }
-      if (!e.isFile()) continue;
-      const ext = e.name.replace(/^.*\./, "");
-      if (!extensions.has(ext)) continue;
-      const content = await readFile2(full, "utf-8").catch(() => "");
-      extractNpmPackagesFromCode(content).forEach((p) => packages.add(p));
-    }
-  }
-  await walk(dir);
-  return packages;
-}
-async function findMissingPackages(projectRoot, dirs = ["app", "components"]) {
-  const installed = getInstalledPackages(projectRoot);
-  const required = new Set(COHERENT_REQUIRED_PACKAGES);
-  const imported = /* @__PURE__ */ new Set();
-  const extensions = /* @__PURE__ */ new Set(["ts", "tsx", "js", "jsx"]);
-  for (const d of dirs) {
-    const abs = join3(projectRoot, d);
-    const pkgs = await collectImportedPackages(abs, extensions);
-    pkgs.forEach((p) => imported.add(p));
-  }
-  const needed = /* @__PURE__ */ new Set([...required, ...imported]);
-  return [...needed].filter((p) => !installed.has(p)).sort();
-}
-function findMissingPackagesInCode(code, projectRoot) {
-  const installed = getInstalledPackages(projectRoot);
-  const required = new Set(COHERENT_REQUIRED_PACKAGES);
-  const fromCode = extractNpmPackagesFromCode(code);
-  const needed = /* @__PURE__ */ new Set([...required, ...fromCode]);
-  return [...needed].filter((p) => !installed.has(p)).sort();
-}
-var SAFE_PKG_NAME = /^(@[a-z0-9._-]+\/)?[a-z0-9._-]+$/;
-function installPackages(projectRoot, packages) {
-  if (packages.length === 0) return Promise.resolve(true);
-  const safe = packages.filter((p) => SAFE_PKG_NAME.test(p));
-  if (safe.length === 0) return Promise.resolve(true);
-  return new Promise((resolve17) => {
-    try {
-      const hasPnpm = existsSync4(join3(projectRoot, "pnpm-lock.yaml"));
-      if (hasPnpm) {
-        execSync(`pnpm add ${safe.join(" ")}`, { cwd: projectRoot, stdio: "pipe" });
-      } else {
-        execSync(`npm install --legacy-peer-deps ${safe.join(" ")}`, {
-          cwd: projectRoot,
-          stdio: "pipe"
-        });
-      }
-      resolve17(true);
-    } catch (e) {
-      if (process.env.COHERENT_DEBUG === "1") console.error("Failed to install packages:", e);
-      resolve17(false);
-    }
-  });
-}
-var CLIENT_HOOKS = /\b(useState|useEffect|useRef|useContext|useReducer|useCallback|useMemo|useId|useTransition|useDeferredValue)\s*\(/;
-var CLIENT_EVENTS = /\b(onClick|onChange|onSubmit|onBlur|onFocus|onKeyDown|onKeyUp|onMouseEnter|onMouseLeave|onScroll|onInput)\s*[={]/;
-function stripMetadataFromCode(code) {
-  const match = code.match(/\bexport\s+const\s+metadata\s*:\s*Metadata\s*=\s*\{/);
-  if (!match) return code;
-  const start = code.indexOf(match[0]);
-  const open = code.indexOf("{", start);
-  if (open === -1) return code;
-  let depth = 1;
-  let i = open + 1;
-  while (i < code.length && depth > 0) {
-    const c = code[i];
-    if (c === "{") depth++;
-    else if (c === "}") depth--;
-    i++;
-  }
-  const end = i;
-  const tail = code.slice(end);
-  const semicolon = tail.match(/^\s*;/);
-  const removeEnd = semicolon ? end + (semicolon.index + semicolon[0].length) : end;
-  return (code.slice(0, start) + code.slice(removeEnd)).replace(/\n{3,}/g, "\n\n").trim();
-}
-function ensureUseClientIfNeeded(code) {
-  const trimmed = code.trimStart();
-  const hasUseClient = trimmed.startsWith("'use client'") || trimmed.startsWith('"use client"');
-  const needsUseClient = CLIENT_HOOKS.test(code) || CLIENT_EVENTS.test(code);
-  let out = code;
-  if (hasUseClient || needsUseClient) {
-    out = stripMetadataFromCode(out);
-    if (needsUseClient && !hasUseClient) out = `'use client'
-
-${out}`;
-  }
-  return out;
-}
-function sanitizeMetadataStrings(code) {
-  let out = code.replace(/\\'(\s*[}\],])/g, "'$1");
-  out = out.replace(/(:\s*'.+)\\'(\s*)$/gm, "$1'$2");
-  for (const key of ["description", "title"]) {
-    const re = new RegExp(`\\b${key}:\\s*'((?:[^'\\\\]|'(?![,}]))*)'`, "gs");
-    out = out.replace(re, (_, inner) => `${key}: '${inner.replace(/'/g, "\\'")}'`);
-  }
-  return out;
-}
-function fixEscapedClosingQuotes(code) {
-  let out = code.replace(/\\'(\s*[}\],])/g, "'$1");
-  out = out.replace(/(:\s*'.+)\\'(\s*)$/gm, "$1'$2");
-  return out;
-}
-function fixUnescapedLtInJsx(code) {
-  let out = code;
-  out = out.replace(/>([^<\n]*)<(\d)/g, ">$1&lt;$2");
-  out = out.replace(/>([^<\n]*)<([^/a-zA-Z!{>\n])/g, ">$1&lt;$2");
-  return out;
-}
-
 // src/utils/welcome-content.ts
 import fs from "fs";
 import path2 from "path";
@@ -2453,14 +2247,14 @@ function hasApiKey() {
 }
 
 // src/utils/cursor-rules.ts
-import { writeFileSync as writeFileSync4, existsSync as existsSync6 } from "fs";
-import { join as join5 } from "path";
+import { writeFileSync as writeFileSync4, existsSync as existsSync5 } from "fs";
+import { join as join4 } from "path";
 import { loadManifest as loadManifest2 } from "@getcoherent/core";
 import { DesignSystemManager as DesignSystemManager2 } from "@getcoherent/core";
 
 // src/utils/claude-code.ts
-import { writeFileSync as writeFileSync3, existsSync as existsSync5, mkdirSync as mkdirSync2 } from "fs";
-import { join as join4 } from "path";
+import { writeFileSync as writeFileSync3, existsSync as existsSync4, mkdirSync as mkdirSync2 } from "fs";
+import { join as join3 } from "path";
 import { loadManifest } from "@getcoherent/core";
 import { DesignSystemManager } from "@getcoherent/core";
 function buildSharedComponentsListForClaude(manifest) {
@@ -2905,28 +2699,28 @@ var SETTINGS_JSON = `{
 `;
 function writeClaudeMd(projectRoot, manifest, config2) {
   const content = buildClaudeMdContent(manifest, config2);
-  const outPath = join4(projectRoot, "CLAUDE.md");
+  const outPath = join3(projectRoot, "CLAUDE.md");
   writeFileSync3(outPath, content, "utf-8");
 }
 function writeClaudeCommands(projectRoot) {
-  const dir = join4(projectRoot, ".claude", "commands");
+  const dir = join3(projectRoot, ".claude", "commands");
   ensureDir(dir);
   for (const [name, body] of Object.entries(COMMANDS)) {
-    writeFileSync3(join4(dir, name), body, "utf-8");
+    writeFileSync3(join3(dir, name), body, "utf-8");
   }
 }
 function writeClaudeSkills(projectRoot) {
-  const dirCoherent = join4(projectRoot, ".claude", "skills", "coherent-project");
-  const dirFrontend = join4(projectRoot, ".claude", "skills", "frontend-ux");
+  const dirCoherent = join3(projectRoot, ".claude", "skills", "coherent-project");
+  const dirFrontend = join3(projectRoot, ".claude", "skills", "frontend-ux");
   ensureDir(dirCoherent);
   ensureDir(dirFrontend);
-  writeFileSync3(join4(dirCoherent, "SKILL.md"), SKILL_COHERENT, "utf-8");
-  writeFileSync3(join4(dirFrontend, "SKILL.md"), SKILL_FRONTEND_UX, "utf-8");
+  writeFileSync3(join3(dirCoherent, "SKILL.md"), SKILL_COHERENT, "utf-8");
+  writeFileSync3(join3(dirFrontend, "SKILL.md"), SKILL_FRONTEND_UX, "utf-8");
 }
 function writeClaudeSettings(projectRoot) {
-  const dir = join4(projectRoot, ".claude");
+  const dir = join3(projectRoot, ".claude");
   ensureDir(dir);
-  writeFileSync3(join4(dir, "settings.json"), SETTINGS_JSON.trim(), "utf-8");
+  writeFileSync3(join3(dir, "settings.json"), SETTINGS_JSON.trim(), "utf-8");
 }
 async function loadManifestAndConfig(projectRoot) {
   let manifest;
@@ -2936,8 +2730,8 @@ async function loadManifestAndConfig(projectRoot) {
     manifest = { shared: [], nextId: 1 };
   }
   let config2 = null;
-  const configPath = join4(projectRoot, "design-system.config.ts");
-  if (existsSync5(configPath)) {
+  const configPath = join3(projectRoot, "design-system.config.ts");
+  if (existsSync4(configPath)) {
     try {
       const dsm = new DesignSystemManager(configPath);
       await dsm.load();
@@ -3316,8 +3110,8 @@ async function writeCursorRules(projectRoot) {
     manifest = { shared: [], nextId: 1 };
   }
   let config2 = null;
-  const configPath = join5(projectRoot, "design-system.config.ts");
-  if (existsSync6(configPath)) {
+  const configPath = join4(projectRoot, "design-system.config.ts");
+  if (existsSync5(configPath)) {
     try {
       const dsm = new DesignSystemManager2(configPath);
       await dsm.load();
@@ -3326,7 +3120,7 @@ async function writeCursorRules(projectRoot) {
     }
   }
   const content = buildCursorRules(manifest, config2);
-  const outPath = join5(projectRoot, ".cursorrules");
+  const outPath = join4(projectRoot, ".cursorrules");
   writeFileSync4(outPath, content, "utf-8");
   writeClaudeMd(projectRoot, manifest, config2);
   const tokenKeys = config2?.tokens ? [
@@ -3350,13 +3144,13 @@ async function regenerateCursorRules() {
 }
 
 // src/utils/tailwind-version.ts
-import { existsSync as existsSync7, readFileSync as readFileSync4 } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync3 } from "fs";
 import { resolve as resolve3 } from "path";
 function isTailwindV4(projectRoot) {
   const pkgPath = resolve3(projectRoot, "package.json");
-  if (existsSync7(pkgPath)) {
+  if (existsSync6(pkgPath)) {
     try {
-      const pkg = JSON.parse(readFileSync4(pkgPath, "utf-8"));
+      const pkg = JSON.parse(readFileSync3(pkgPath, "utf-8"));
       const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
       if (allDeps["@tailwindcss/postcss"]) return true;
       const twVersion = allDeps["tailwindcss"] || "";
@@ -3365,8 +3159,8 @@ function isTailwindV4(projectRoot) {
     }
   }
   const globalsPath = resolve3(projectRoot, "app", "globals.css");
-  if (existsSync7(globalsPath)) {
-    const content = readFileSync4(globalsPath, "utf-8");
+  if (existsSync6(globalsPath)) {
+    const content = readFileSync3(globalsPath, "utf-8");
     if (content.includes('@import "tailwindcss"') || content.includes("@import 'tailwindcss'")) return true;
   }
   return false;
@@ -3550,10 +3344,10 @@ function toKebabCase(str) {
 
 // src/commands/init.ts
 function hasNextInPackageJson(projectPath) {
-  const pkgPath = join6(projectPath, "package.json");
-  if (!existsSync8(pkgPath)) return false;
+  const pkgPath = join5(projectPath, "package.json");
+  if (!existsSync7(pkgPath)) return false;
   try {
-    const json = JSON.parse(readFileSync5(pkgPath, "utf-8"));
+    const json = JSON.parse(readFileSync4(pkgPath, "utf-8"));
     const deps = { ...json.dependencies, ...json.devDependencies };
     return typeof deps?.next === "string";
   } catch {
@@ -3563,30 +3357,30 @@ function hasNextInPackageJson(projectPath) {
 function cleanConflictingFiles(projectPath) {
   const conflicts = [".next", ".coherent", ".cursorrules", ".eslintrc.json", "CLAUDE.md", ".claude", ".vscode"];
   for (const name of conflicts) {
-    const fullPath = join6(projectPath, name);
-    if (existsSync8(fullPath)) {
+    const fullPath = join5(projectPath, name);
+    if (existsSync7(fullPath)) {
       rmSync(fullPath, { recursive: true, force: true });
     }
   }
 }
 function runCreateNextApp(projectPath) {
   cleanConflictingFiles(projectPath);
-  const envPath = join6(projectPath, ".env");
-  const envBackup = existsSync8(envPath) ? readFileSync5(envPath, "utf-8") : null;
+  const envPath = join5(projectPath, ".env");
+  const envBackup = existsSync7(envPath) ? readFileSync4(envPath, "utf-8") : null;
   if (envBackup !== null) rmSync(envPath, { force: true });
   const cmd = "npx --yes create-next-app@15.2.4 . --typescript --tailwind --eslint --app --no-src-dir --no-turbopack --yes";
-  execSync2(cmd, { cwd: projectPath, stdio: "inherit" });
+  execSync(cmd, { cwd: projectPath, stdio: "inherit" });
   if (envBackup !== null) {
-    const existing = existsSync8(envPath) ? readFileSync5(envPath, "utf-8") : "";
+    const existing = existsSync7(envPath) ? readFileSync4(envPath, "utf-8") : "";
     writeFileSync5(envPath, existing ? existing + "\n" + envBackup : envBackup, "utf-8");
   }
 }
 async function ensureCoherentPrerequisites(projectPath) {
-  const libPath = join6(projectPath, "lib");
-  const utilsPath = join6(projectPath, "lib", "utils.ts");
-  const componentsUiPath = join6(projectPath, "components", "ui");
-  if (!existsSync8(utilsPath)) {
-    if (!existsSync8(libPath)) mkdirSync3(libPath, { recursive: true });
+  const libPath = join5(projectPath, "lib");
+  const utilsPath = join5(projectPath, "lib", "utils.ts");
+  const componentsUiPath = join5(projectPath, "components", "ui");
+  if (!existsSync7(utilsPath)) {
+    if (!existsSync7(libPath)) mkdirSync3(libPath, { recursive: true });
     const cnContent = `import { type ClassValue, clsx } from 'clsx'
 import { twMerge } from 'tailwind-merge'
 
@@ -3596,20 +3390,20 @@ export function cn(...inputs: ClassValue[]) {
 `;
     await writeFile(utilsPath, cnContent);
   }
-  if (!existsSync8(componentsUiPath)) mkdirSync3(componentsUiPath, { recursive: true });
+  if (!existsSync7(componentsUiPath)) mkdirSync3(componentsUiPath, { recursive: true });
 }
 async function ensureRegistryComponents(config2, projectPath) {
   const provider = getComponentProvider();
   const baseComponents = ["button", "card", "input", "label", "switch"];
   await provider.installBatch(baseComponents, projectPath);
   const generator = new ComponentGenerator(config2);
-  const uiDir = join6(projectPath, "components", "ui");
-  if (!existsSync8(uiDir)) mkdirSync3(uiDir, { recursive: true });
+  const uiDir = join5(projectPath, "components", "ui");
+  if (!existsSync7(uiDir)) mkdirSync3(uiDir, { recursive: true });
   for (const comp of config2.components) {
     if (comp.source === "shadcn") continue;
     const fileName = toKebabCase(comp.name) + ".tsx";
-    const filePath = join6(uiDir, fileName);
-    if (existsSync8(filePath)) continue;
+    const filePath = join5(uiDir, fileName);
+    if (existsSync7(filePath)) continue;
     const code = await generator.generate(comp);
     await writeFile(filePath, code);
   }
@@ -3637,8 +3431,8 @@ async function initCommand(name) {
         );
         process.exit(1);
       }
-      const targetDir = join6(cwd2(), name);
-      if (!existsSync8(targetDir)) {
+      const targetDir = join5(cwd2(), name);
+      if (!existsSync7(targetDir)) {
         mkdirSync3(targetDir, { recursive: true });
       }
       process.chdir(targetDir);
@@ -3646,7 +3440,7 @@ async function initCommand(name) {
     let projectPath;
     try {
       projectPath = cwd2();
-      if (!existsSync8(projectPath)) {
+      if (!existsSync7(projectPath)) {
         throw new Error("ENOENT");
       }
     } catch (err) {
@@ -3717,7 +3511,7 @@ async function initCommand(name) {
       await ensureCoherentPrerequisites(projectPath);
       const depsSpinner = ora("Installing component dependencies...").start();
       try {
-        execSync2(`npm install --legacy-peer-deps ${COHERENT_REQUIRED_PACKAGES.join(" ")}`, {
+        execSync(`npm install --legacy-peer-deps ${COHERENT_REQUIRED_PACKAGES.join(" ")}`, {
           cwd: projectPath,
           stdio: "pipe"
         });
@@ -3730,7 +3524,7 @@ async function initCommand(name) {
       const usesV4 = isTailwindV4(projectPath);
       if (usesV4) {
         const v4Css = generateV4GlobalsCss(config2);
-        await writeFile(join6(projectPath, "app", "globals.css"), v4Css);
+        await writeFile(join5(projectPath, "app", "globals.css"), v4Css);
       } else {
         await scaffolder.generateGlobalsCss();
         await scaffolder.generateTailwindConfigTs();
@@ -3744,14 +3538,14 @@ const config = {
 
 export default config
 `;
-        await writeFile(join6(projectPath, "postcss.config.mjs"), postcssContent);
+        await writeFile(join5(projectPath, "postcss.config.mjs"), postcssContent);
       }
       await scaffolder.generateRootLayout();
       await configureNextImages(projectPath);
       await createAppRouteGroupLayout(projectPath);
       const welcomeMarkdown = getWelcomeMarkdown();
       const homePageContent = generateWelcomeComponent(welcomeMarkdown);
-      await writeFile(join6(projectPath, "app", "page.tsx"), homePageContent);
+      await writeFile(join5(projectPath, "app", "page.tsx"), homePageContent);
       const designSystemSpinner = ora("Creating design system pages...").start();
       await scaffolder.generateDesignSystemPages();
       designSystemSpinner.succeed("Design system pages created");
@@ -3766,7 +3560,7 @@ export default config
       scaffoldSpinner.succeed("Project structure created");
       const depsSpinner = ora("Installing component dependencies...").start();
       try {
-        execSync2(`npm install --legacy-peer-deps ${COHERENT_REQUIRED_PACKAGES.join(" ")}`, {
+        execSync(`npm install --legacy-peer-deps ${COHERENT_REQUIRED_PACKAGES.join(" ")}`, {
           cwd: projectPath,
           stdio: "pipe"
         });
@@ -3804,13 +3598,13 @@ export default config
   }
 }
 async function configureNextImages(projectPath) {
-  const tsPath = join6(projectPath, "next.config.ts");
-  const jsPath = join6(projectPath, "next.config.js");
-  const mjsPath = join6(projectPath, "next.config.mjs");
+  const tsPath = join5(projectPath, "next.config.ts");
+  const jsPath = join5(projectPath, "next.config.js");
+  const mjsPath = join5(projectPath, "next.config.mjs");
   let configPath = "";
-  if (existsSync8(tsPath)) configPath = tsPath;
-  else if (existsSync8(mjsPath)) configPath = mjsPath;
-  else if (existsSync8(jsPath)) configPath = jsPath;
+  if (existsSync7(tsPath)) configPath = tsPath;
+  else if (existsSync7(mjsPath)) configPath = mjsPath;
+  else if (existsSync7(jsPath)) configPath = jsPath;
   else return;
   const content = `import type { NextConfig } from "next";
 
@@ -3829,7 +3623,7 @@ export default nextConfig;
   await writeFile(configPath, content);
 }
 async function createAppRouteGroupLayout(projectPath) {
-  const dir = join6(projectPath, "app", "(app)");
+  const dir = join5(projectPath, "app", "(app)");
   mkdirSync3(dir, { recursive: true });
   const layoutCode = `export default function AppLayout({
   children,
@@ -3843,14 +3637,14 @@ async function createAppRouteGroupLayout(projectPath) {
   )
 }
 `;
-  await writeFile(join6(dir, "layout.tsx"), layoutCode);
+  await writeFile(join5(dir, "layout.tsx"), layoutCode);
 }
 
 // src/commands/chat.ts
 import chalk13 from "chalk";
 import ora2 from "ora";
-import { resolve as resolve10, relative as relative2, join as join11 } from "path";
-import { existsSync as existsSync17, readFileSync as readFileSync12, mkdirSync as mkdirSync6, readdirSync as readdirSync4 } from "fs";
+import { resolve as resolve10, relative as relative2, join as join10 } from "path";
+import { existsSync as existsSync16, readFileSync as readFileSync11, mkdirSync as mkdirSync6, readdirSync as readdirSync4 } from "fs";
 import {
   DesignSystemManager as DesignSystemManager7,
   ComponentManager as ComponentManager5,
@@ -4612,9 +4406,9 @@ function extractComponentSpec(changes) {
 }
 
 // src/utils/auth-route-group.ts
-import { join as join7 } from "path";
-import { readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
-import { existsSync as existsSync9 } from "fs";
+import { join as join6 } from "path";
+import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { existsSync as existsSync8 } from "fs";
 var AUTH_LAYOUT = `export default function AuthLayout({
   children,
 }: {
@@ -4646,20 +4440,20 @@ export default function ShowWhenNotAuthRoute({
 }
 `;
 async function ensureAuthRouteGroup(projectRoot) {
-  const authLayoutPath = join7(projectRoot, "app", "(auth)", "layout.tsx");
-  const guardPath2 = join7(projectRoot, "app", "ShowWhenNotAuthRoute.tsx");
-  const rootLayoutPath = join7(projectRoot, "app", "layout.tsx");
-  if (!existsSync9(authLayoutPath)) {
+  const authLayoutPath = join6(projectRoot, "app", "(auth)", "layout.tsx");
+  const guardPath2 = join6(projectRoot, "app", "ShowWhenNotAuthRoute.tsx");
+  const rootLayoutPath = join6(projectRoot, "app", "layout.tsx");
+  if (!existsSync8(authLayoutPath)) {
     const { mkdir: mkdir8 } = await import("fs/promises");
-    await mkdir8(join7(projectRoot, "app", "(auth)"), { recursive: true });
+    await mkdir8(join6(projectRoot, "app", "(auth)"), { recursive: true });
     await writeFile2(authLayoutPath, AUTH_LAYOUT, "utf-8");
   }
-  if (!existsSync9(guardPath2)) {
+  if (!existsSync8(guardPath2)) {
     await writeFile2(guardPath2, SHOW_WHEN_NOT_AUTH, "utf-8");
   }
   let layoutContent;
   try {
-    layoutContent = await readFile3(rootLayoutPath, "utf-8");
+    layoutContent = await readFile2(rootLayoutPath, "utf-8");
   } catch {
     return;
   }
@@ -4688,9 +4482,9 @@ async function ensureAuthRouteGroup(projectRoot) {
 }
 
 // src/utils/dark-mode.ts
-import { readFile as readFile4, writeFile as writeFile3 } from "fs/promises";
-import { join as join8 } from "path";
-import { existsSync as existsSync10 } from "fs";
+import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+import { join as join7 } from "path";
+import { existsSync as existsSync9 } from "fs";
 import { generateSharedComponent, loadManifest as loadManifest3, integrateSharedLayoutIntoRootLayout } from "@getcoherent/core";
 var THEME_TOGGLE_CODE = `'use client'
 
@@ -4716,9 +4510,9 @@ export function ThemeToggle() {
 }
 `;
 async function setDefaultDarkTheme(projectRoot) {
-  const layoutPath = join8(projectRoot, "app", "layout.tsx");
-  if (!existsSync10(layoutPath)) return false;
-  let content = await readFile4(layoutPath, "utf-8");
+  const layoutPath = join7(projectRoot, "app", "layout.tsx");
+  if (!existsSync9(layoutPath)) return false;
+  let content = await readFile3(layoutPath, "utf-8");
   if (content.includes('<html className="dark"') || content.includes("<html className='dark'")) return true;
   content = content.replace(/<html(\s|>)/, '<html className="dark"$1');
   await writeFile3(layoutPath, content, "utf-8");
@@ -4745,8 +4539,8 @@ async function ensureThemeToggle(projectRoot) {
 import { appendFile } from "fs/promises";
 
 // src/utils/backup.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync6, readdirSync, rmSync as rmSync2, statSync } from "fs";
-import { join as join9, relative, dirname as dirname4 } from "path";
+import { existsSync as existsSync10, mkdirSync as mkdirSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync6, readdirSync, rmSync as rmSync2, statSync } from "fs";
+import { join as join8, relative, dirname as dirname4 } from "path";
 import chalk6 from "chalk";
 var DEBUG = process.env.COHERENT_DEBUG === "1";
 var BACKUP_DIR = ".coherent/backups";
@@ -4761,28 +4555,28 @@ var CRITICAL_FILES = [
 var CRITICAL_DIRS = ["app", "components"];
 function createBackup(projectRoot) {
   try {
-    const backupBase = join9(projectRoot, BACKUP_DIR);
+    const backupBase = join8(projectRoot, BACKUP_DIR);
     const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
-    const backupPath = join9(backupBase, timestamp);
+    const backupPath = join8(backupBase, timestamp);
     mkdirSync4(backupPath, { recursive: true });
     let fileCount = 0;
     for (const file of CRITICAL_FILES) {
-      const src = join9(projectRoot, file);
-      if (existsSync11(src)) {
-        const dest = join9(backupPath, file);
+      const src = join8(projectRoot, file);
+      if (existsSync10(src)) {
+        const dest = join8(backupPath, file);
         mkdirSync4(dirname4(dest), { recursive: true });
-        writeFileSync6(dest, readFileSync6(src));
+        writeFileSync6(dest, readFileSync5(src));
         fileCount++;
       }
     }
     for (const dir of CRITICAL_DIRS) {
-      const srcDir = join9(projectRoot, dir);
-      if (!existsSync11(srcDir)) continue;
+      const srcDir = join8(projectRoot, dir);
+      if (!existsSync10(srcDir)) continue;
       backupDirectory(srcDir, projectRoot, backupPath);
       fileCount += countFiles(srcDir);
     }
     writeFileSync6(
-      join9(backupPath, ".backup-meta.json"),
+      join8(backupPath, ".backup-meta.json"),
       JSON.stringify(
         {
           timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -4803,15 +4597,15 @@ function backupDirectory(srcDir, projectRoot, backupPath) {
   const entries = readdirSync(srcDir, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.name === "node_modules" || entry.name === ".next" || entry.name === ".git") continue;
-    const fullPath = join9(srcDir, entry.name);
+    const fullPath = join8(srcDir, entry.name);
     const relPath = relative(projectRoot, fullPath);
-    const destPath = join9(backupPath, relPath);
+    const destPath = join8(backupPath, relPath);
     if (entry.isDirectory()) {
       mkdirSync4(destPath, { recursive: true });
       backupDirectory(fullPath, projectRoot, backupPath);
     } else if (entry.isFile()) {
       mkdirSync4(dirname4(destPath), { recursive: true });
-      writeFileSync6(destPath, readFileSync6(fullPath));
+      writeFileSync6(destPath, readFileSync5(fullPath));
     }
   }
 }
@@ -4821,7 +4615,7 @@ function countFiles(dir) {
     const entries = readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.name === "node_modules" || entry.name === ".next") continue;
-      const fullPath = join9(dir, entry.name);
+      const fullPath = join8(dir, entry.name);
       if (entry.isDirectory()) {
         count += countFiles(fullPath);
       } else if (entry.isFile()) {
@@ -4835,24 +4629,24 @@ function countFiles(dir) {
 }
 function pruneOldBackups(backupBase) {
   try {
-    const entries = readdirSync(backupBase).filter((e) => e !== ".gitkeep" && !e.startsWith(".")).map((name) => ({ name, time: statSync(join9(backupBase, name)).mtimeMs })).sort((a, b) => b.time - a.time);
+    const entries = readdirSync(backupBase).filter((e) => e !== ".gitkeep" && !e.startsWith(".")).map((name) => ({ name, time: statSync(join8(backupBase, name)).mtimeMs })).sort((a, b) => b.time - a.time);
     for (const old of entries.slice(MAX_BACKUPS)) {
-      rmSync2(join9(backupBase, old.name), { recursive: true, force: true });
+      rmSync2(join8(backupBase, old.name), { recursive: true, force: true });
     }
   } catch (e) {
     if (DEBUG) console.error("Failed to prune old backups:", e);
   }
 }
 function listBackups(projectRoot) {
-  const backupBase = join9(projectRoot, BACKUP_DIR);
-  if (!existsSync11(backupBase)) return [];
+  const backupBase = join8(projectRoot, BACKUP_DIR);
+  if (!existsSync10(backupBase)) return [];
   try {
     return readdirSync(backupBase).filter((e) => !e.startsWith(".")).map((name) => {
-      const metaPath = join9(backupBase, name, ".backup-meta.json");
+      const metaPath = join8(backupBase, name, ".backup-meta.json");
       let meta = { timestamp: name, files: 0 };
-      if (existsSync11(metaPath)) {
+      if (existsSync10(metaPath)) {
         try {
-          meta = JSON.parse(readFileSync6(metaPath, "utf-8"));
+          meta = JSON.parse(readFileSync5(metaPath, "utf-8"));
         } catch (e) {
           if (DEBUG) console.error("Bad backup meta:", metaPath, e);
         }
@@ -4865,8 +4659,8 @@ function listBackups(projectRoot) {
   }
 }
 function restoreBackup(projectRoot, backupName) {
-  const backupPath = join9(projectRoot, BACKUP_DIR, backupName);
-  if (!existsSync11(backupPath)) return false;
+  const backupPath = join8(projectRoot, BACKUP_DIR, backupName);
+  if (!existsSync10(backupPath)) return false;
   try {
     restoreDirectory(backupPath, backupPath, projectRoot);
     return true;
@@ -4879,15 +4673,15 @@ function restoreDirectory(currentDir, backupRoot, projectRoot) {
   const entries = readdirSync(currentDir, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.name === ".backup-meta.json") continue;
-    const fullPath = join9(currentDir, entry.name);
+    const fullPath = join8(currentDir, entry.name);
     const relPath = relative(backupRoot, fullPath);
-    const destPath = join9(projectRoot, relPath);
+    const destPath = join8(projectRoot, relPath);
     if (entry.isDirectory()) {
       mkdirSync4(destPath, { recursive: true });
       restoreDirectory(fullPath, backupRoot, projectRoot);
     } else if (entry.isFile()) {
       mkdirSync4(dirname4(destPath), { recursive: true });
-      writeFileSync6(destPath, readFileSync6(fullPath));
+      writeFileSync6(destPath, readFileSync5(fullPath));
     }
   }
 }
@@ -4899,15 +4693,15 @@ function logBackupCreated(backupPath) {
 }
 
 // src/utils/fix-globals-css.ts
-import { existsSync as existsSync12, readFileSync as readFileSync7, writeFileSync as writeFileSync7 } from "fs";
+import { existsSync as existsSync11, readFileSync as readFileSync6, writeFileSync as writeFileSync7 } from "fs";
 import { resolve as resolve4 } from "path";
 import { buildCssVariables as buildCssVariables2 } from "@getcoherent/core";
 function needsGlobalsFix(projectRoot) {
   const globalsPath = resolve4(projectRoot, "app", "globals.css");
-  if (!existsSync12(globalsPath)) {
+  if (!existsSync11(globalsPath)) {
     return false;
   }
-  const content = readFileSync7(globalsPath, "utf-8");
+  const content = readFileSync6(globalsPath, "utf-8");
   if (isTailwindV4(projectRoot)) {
     if (!content.includes("@theme inline")) return true;
     if (content.includes("@tailwind base")) return true;
@@ -4932,7 +4726,7 @@ function needsGlobalsFix(projectRoot) {
 function fixGlobalsCss(projectRoot, config2) {
   const globalsPath = resolve4(projectRoot, "app", "globals.css");
   const layoutPath = resolve4(projectRoot, "app", "layout.tsx");
-  if (!existsSync12(globalsPath)) {
+  if (!existsSync11(globalsPath)) {
     return;
   }
   if (isTailwindV4(projectRoot)) {
@@ -4955,10 +4749,10 @@ function fixGlobalsCss(projectRoot, config2) {
 }
 `;
   writeFileSync7(globalsPath, minimalCss, "utf-8");
-  if (!existsSync12(layoutPath)) {
+  if (!existsSync11(layoutPath)) {
     return;
   }
-  let layoutContent = readFileSync7(layoutPath, "utf-8");
+  let layoutContent = readFileSync6(layoutPath, "utf-8");
   if (layoutContent.includes("dangerouslySetInnerHTML")) {
     return;
   }
@@ -4972,7 +4766,7 @@ function fixGlobalsCss(projectRoot, config2) {
 
 // src/commands/chat/utils.ts
 import { resolve as resolve5 } from "path";
-import { existsSync as existsSync13, readFileSync as readFileSync8 } from "fs";
+import { existsSync as existsSync12, readFileSync as readFileSync7 } from "fs";
 import { DesignSystemManager as DesignSystemManager3, loadManifest as loadManifest4 } from "@getcoherent/core";
 import chalk7 from "chalk";
 var MARKETING_ROUTES = /* @__PURE__ */ new Set(["", "landing", "pricing", "about", "contact", "blog", "features"]);
@@ -4994,10 +4788,10 @@ function inferRouteUsesAuthSegment(route) {
 function readAnchorPageCodeFromDisk(projectRoot, route) {
   const useAuthSegment = inferRouteUsesAuthSegment(route);
   const abs = routeToFsPath(projectRoot, route, useAuthSegment);
-  if (!existsSync13(abs)) return null;
+  if (!existsSync12(abs)) return null;
   let code;
   try {
-    code = readFileSync8(abs, "utf-8");
+    code = readFileSync7(abs, "utf-8");
   } catch {
     return null;
   }
@@ -5013,11 +4807,11 @@ function routeToFsPath(projectRoot, route, isAuthOrPlan) {
   const isAuth = typeof isAuthOrPlan === "boolean" ? isAuthOrPlan : false;
   const slug = route.replace(/^\//, "");
   if (!slug) return resolve5(projectRoot, "app", "page.tsx");
+  if (isAuth || isAuthRoute(route)) return resolve5(projectRoot, "app", "(auth)", slug || "login", "page.tsx");
   if (plan) {
     const group = getPageGroup(route, plan);
     if (group) return resolve5(projectRoot, "app", `(${group.id})`, slug, "page.tsx");
   }
-  if (isAuth) return resolve5(projectRoot, "app", "(auth)", slug || "login", "page.tsx");
   if (isMarketingRoute(route)) return resolve5(projectRoot, "app", slug, "page.tsx");
   return resolve5(projectRoot, "app", "(app)", slug, "page.tsx");
 }
@@ -5026,11 +4820,11 @@ function routeToRelPath(route, isAuthOrPlan) {
   const isAuth = typeof isAuthOrPlan === "boolean" ? isAuthOrPlan : false;
   const slug = route.replace(/^\//, "");
   if (!slug) return "app/page.tsx";
+  if (isAuth || isAuthRoute(route)) return `app/(auth)/${slug || "login"}/page.tsx`;
   if (plan) {
     const group = getPageGroup(route, plan);
     if (group) return `app/(${group.id})/${slug}/page.tsx`;
   }
-  if (isAuth) return `app/(auth)/${slug || "login"}/page.tsx`;
   if (isMarketingRoute(route)) return `app/${slug}/page.tsx`;
   return `app/(app)/${slug}/page.tsx`;
 }
@@ -5115,7 +4909,7 @@ async function warnInlineDuplicates(projectRoot, pageName, route, pageCode, mani
   }
 }
 async function loadConfig(configPath) {
-  if (!existsSync13(configPath)) {
+  if (!existsSync12(configPath)) {
     throw new Error(
       `Design system config not found at ${configPath}
 Run "coherent init" first to create a project.`
@@ -5143,8 +4937,8 @@ async function resolveTargetFlags(message, options, config2, projectRoot) {
     if (entry) {
       const filePath = resolve5(projectRoot, entry.file);
       let currentCode = "";
-      if (existsSync13(filePath)) {
-        currentCode = readFileSync8(filePath, "utf-8");
+      if (existsSync12(filePath)) {
+        currentCode = readFileSync7(filePath, "utf-8");
       }
       const codeSnippet = currentCode ? `
 
@@ -5168,8 +4962,8 @@ ${currentCode}
       const relPath = page.route === "/" ? "app/page.tsx" : `app${page.route}/page.tsx`;
       const filePath = resolve5(projectRoot, relPath);
       let currentCode = "";
-      if (existsSync13(filePath)) {
-        currentCode = readFileSync8(filePath, "utf-8");
+      if (existsSync12(filePath)) {
+        currentCode = readFileSync7(filePath, "utf-8");
       }
       const codeSnippet = currentCode ? `
 
@@ -5624,7 +5418,7 @@ function applyDefaults(request) {
 }
 
 // src/commands/chat/split-generator.ts
-import { existsSync as existsSync14, readFileSync as readFileSync9, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+import { existsSync as existsSync13, readFileSync as readFileSync8, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
 import { resolve as resolve6 } from "path";
 import { z } from "zod";
 import {
@@ -6075,8 +5869,8 @@ function readExistingAppPageForReference(projectRoot, plan) {
       for (const group of ["(app)", "(admin)", "(dashboard)"]) {
         const filePath = resolve6(projectRoot, "app", group, key, "page.tsx");
         try {
-          if (existsSync14(filePath)) {
-            const code = readFileSync9(filePath, "utf-8");
+          if (existsSync13(filePath)) {
+            const code = readFileSync8(filePath, "utf-8");
             const lines = code.split("\n");
             return lines.slice(0, 60).join("\n");
           }
@@ -6087,7 +5881,7 @@ function readExistingAppPageForReference(projectRoot, plan) {
     }
   }
   const appDir = resolve6(projectRoot, "app");
-  if (!existsSync14(appDir)) return null;
+  if (!existsSync13(appDir)) return null;
   try {
     const entries = readdirSync2(appDir);
     for (const entry of entries) {
@@ -6097,8 +5891,8 @@ function readExistingAppPageForReference(projectRoot, plan) {
       const subDirs = readdirSync2(groupDir);
       for (const sub of subDirs) {
         const pagePath = resolve6(groupDir, sub, "page.tsx");
-        if (existsSync14(pagePath)) {
-          const code = readFileSync9(pagePath, "utf-8");
+        if (existsSync13(pagePath)) {
+          const code = readFileSync8(pagePath, "utf-8");
           const lines = code.split("\n");
           return lines.slice(0, 60).join("\n");
         }
@@ -6315,7 +6109,7 @@ async function splitGeneratePages(spinner, message, modCtx, provider, parseOpts)
     if (plan && plan.sharedComponents.length > 0) {
       spinner.start(`Phase 4.5/6 \u2014 Generating ${plan.sharedComponents.length} shared components from plan...`);
       try {
-        const { generateSharedComponentsFromPlan } = await import("./plan-generator-BHDEJGMY.js");
+        const { generateSharedComponentsFromPlan } = await import("./plan-generator-WPYWUA7U.js");
         const generated = await generateSharedComponentsFromPlan(
           plan,
           styleContext,
@@ -6372,13 +6166,13 @@ ${existingAppPageCode}
   const existingPageCode = {};
   if (projectRoot) {
     const appDir = resolve6(projectRoot, "app");
-    if (existsSync14(appDir)) {
+    if (existsSync13(appDir)) {
       const pageFiles = readdirSync2(appDir, { recursive: true }).filter(
         (f) => typeof f === "string" && f.endsWith("page.tsx")
       );
       for (const pf of pageFiles) {
         try {
-          const code = readFileSync9(resolve6(appDir, pf), "utf-8");
+          const code = readFileSync8(resolve6(appDir, pf), "utf-8");
           const route = "/" + pf.replace(/\/page\.tsx$/, "").replace(/\(.*?\)\//g, "");
           existingPageCode[route === "/" ? "/" : route] = code;
         } catch {
@@ -6673,7 +6467,7 @@ import {
 
 // src/commands/chat/code-generator.ts
 import { resolve as resolve7 } from "path";
-import { existsSync as existsSync15, readdirSync as readdirSync3, readFileSync as readFileSync10 } from "fs";
+import { existsSync as existsSync14, readdirSync as readdirSync3, readFileSync as readFileSync9 } from "fs";
 import { mkdir as mkdir3 } from "fs/promises";
 import { dirname as dirname5 } from "path";
 import {
@@ -6686,25 +6480,25 @@ import chalk9 from "chalk";
 
 // src/utils/file-hashes.ts
 import { createHash } from "crypto";
-import { readFile as readFile5, writeFile as writeFile4, mkdir as mkdir2 } from "fs/promises";
-import { join as join10 } from "path";
+import { readFile as readFile4, writeFile as writeFile4, mkdir as mkdir2 } from "fs/promises";
+import { join as join9 } from "path";
 var HASHES_FILE = ".coherent/file-hashes.json";
 async function computeFileHash(filePath) {
-  const content = await readFile5(filePath, "utf-8");
+  const content = await readFile4(filePath, "utf-8");
   return createHash("sha256").update(content).digest("hex");
 }
 async function loadHashes(projectRoot) {
   try {
-    const raw = await readFile5(join10(projectRoot, HASHES_FILE), "utf-8");
+    const raw = await readFile4(join9(projectRoot, HASHES_FILE), "utf-8");
     return JSON.parse(raw);
   } catch {
     return {};
   }
 }
 async function saveHashes(projectRoot, hashes) {
-  const dir = join10(projectRoot, ".coherent");
+  const dir = join9(projectRoot, ".coherent");
   await mkdir2(dir, { recursive: true });
-  await writeFile4(join10(projectRoot, HASHES_FILE), JSON.stringify(hashes, null, 2) + "\n");
+  await writeFile4(join9(projectRoot, HASHES_FILE), JSON.stringify(hashes, null, 2) + "\n");
 }
 async function isManuallyEdited(filePath, storedHash) {
   try {
@@ -6739,7 +6533,7 @@ async function ensureComponentsInstalled(componentIds, cm, dsm, pm, projectRoot)
     const isRegistered = !!cm.read(componentId);
     const fileName = toKebabCase(componentId) + ".tsx";
     const filePath = resolve7(projectRoot, "components", "ui", fileName);
-    const fileExists = existsSync15(filePath);
+    const fileExists = existsSync14(filePath);
     if (isRegistered && fileExists) continue;
     const result = await provider.installComponent(componentId, projectRoot);
     if (result.success && result.componentDef) {
@@ -6775,7 +6569,7 @@ async function regeneratePage(pageId, config2, projectRoot) {
   const code = await generator.generate(page, appType);
   const route = page.route || "/";
   const isAuth = isAuthRoute(route) || isAuthRoute(page.name || page.id || "");
-  const { loadPlan: loadPlanForPath } = await import("./plan-generator-BHDEJGMY.js");
+  const { loadPlan: loadPlanForPath } = await import("./plan-generator-WPYWUA7U.js");
   const planForPath = loadPlanForPath(projectRoot);
   const filePath = routeToFsPath(projectRoot, route, planForPath || isAuth);
   await mkdir3(dirname5(filePath), { recursive: true });
@@ -6783,7 +6577,7 @@ async function regeneratePage(pageId, config2, projectRoot) {
 }
 async function canOverwriteShared(projectRoot, componentFile, storedHashes) {
   const filePath = resolve7(projectRoot, componentFile);
-  if (!existsSync15(filePath)) return true;
+  if (!existsSync14(filePath)) return true;
   const storedHash = storedHashes[componentFile];
   if (!storedHash) return true;
   const edited = await isManuallyEdited(filePath, storedHash);
@@ -6859,16 +6653,16 @@ async function regenerateLayout(config2, projectRoot, options = {
 }
 async function scanAndInstallSharedDeps(projectRoot) {
   const sharedDir = resolve7(projectRoot, "components", "shared");
-  if (!existsSync15(sharedDir)) return [];
+  if (!existsSync14(sharedDir)) return [];
   const files = readdirSync3(sharedDir).filter((f) => f.endsWith(".tsx") || f.endsWith(".ts"));
   const installed = [];
   const provider = getComponentProvider();
   for (const file of files) {
-    const code = readFileSync10(resolve7(sharedDir, file), "utf-8");
+    const code = readFileSync9(resolve7(sharedDir, file), "utf-8");
     const importMatches = [...code.matchAll(/@\/components\/ui\/([a-z0-9-]+)/g)];
     for (const [, componentId] of importMatches) {
       const uiPath = resolve7(projectRoot, "components", "ui", `${componentId}.tsx`);
-      if (!existsSync15(uiPath) && provider.has(componentId)) {
+      if (!existsSync14(uiPath) && provider.has(componentId)) {
         try {
           await provider.installComponent(componentId, projectRoot);
           installed.push(componentId);
@@ -6882,7 +6676,7 @@ async function scanAndInstallSharedDeps(projectRoot) {
 async function ensureAppRouteGroupLayout(projectRoot, navType, forceUpdate = false, groupLayouts) {
   const effectiveNavType = groupLayouts?.["app"] || navType;
   const layoutPath = resolve7(projectRoot, "app", "(app)", "layout.tsx");
-  if (existsSync15(layoutPath) && !forceUpdate) return;
+  if (existsSync14(layoutPath) && !forceUpdate) return;
   const { mkdir: mkdirAsync } = await import("fs/promises");
   await mkdirAsync(resolve7(projectRoot, "app", "(app)"), { recursive: true });
   const code = buildAppLayoutCode(effectiveNavType);
@@ -6983,8 +6777,8 @@ async function ensurePlanGroupLayouts(projectRoot, plan, storedHashes = {}, conf
     await mkdirAsync(groupDir, { recursive: true });
     const layoutPath = resolve7(groupDir, "layout.tsx");
     const relPath = `app/(${group.id})/layout.tsx`;
-    if (existsSync15(layoutPath)) {
-      const currentContent = readFileSync10(layoutPath, "utf-8");
+    if (existsSync14(layoutPath)) {
+      const currentContent = readFileSync9(layoutPath, "utf-8");
       const currentHash = createHash2("md5").update(currentContent).digest("hex");
       const storedHash = storedHashes[relPath];
       if (storedHash && storedHash !== currentHash) {
@@ -7026,9 +6820,9 @@ async function regenerateFiles(modified, config2, projectRoot, options = { navCh
     const twGen = new TailwindConfigGenerator(config2);
     const twPath = resolve7(projectRoot, "tailwind.config.ts");
     const twCjsPath = resolve7(projectRoot, "tailwind.config.cjs");
-    if (existsSync15(twPath)) {
+    if (existsSync14(twPath)) {
       await writeFile(twPath, await twGen.generate());
-    } else if (existsSync15(twCjsPath)) {
+    } else if (existsSync14(twCjsPath)) {
       await writeFile(twCjsPath, await twGen.generateCjs());
     }
   }
@@ -8291,7 +8085,7 @@ function hasNavChanged(before, after) {
 // src/commands/chat/interactive.ts
 import chalk12 from "chalk";
 import { resolve as resolve9 } from "path";
-import { existsSync as existsSync16, readFileSync as readFileSync11, writeFileSync as writeFileSync8, mkdirSync as mkdirSync5 } from "fs";
+import { existsSync as existsSync15, readFileSync as readFileSync10, writeFileSync as writeFileSync8, mkdirSync as mkdirSync5 } from "fs";
 import { DesignSystemManager as DesignSystemManager6, ComponentManager as ComponentManager4, loadManifest as loadManifest7 } from "@getcoherent/core";
 var DEBUG3 = process.env.COHERENT_DEBUG === "1";
 async function interactiveChat(options, chatCommandFn) {
@@ -8316,8 +8110,8 @@ async function interactiveChat(options, chatCommandFn) {
   let history = [];
   try {
     mkdirSync5(historyDir, { recursive: true });
-    if (existsSync16(historyFile)) {
-      history = readFileSync11(historyFile, "utf-8").split("\n").filter(Boolean).slice(-200);
+    if (existsSync15(historyFile)) {
+      history = readFileSync10(historyFile, "utf-8").split("\n").filter(Boolean).slice(-200);
     }
   } catch (e) {
     if (DEBUG3) console.error("Failed to load REPL history:", e);
@@ -8495,8 +8289,8 @@ async function chatCommand(message, options) {
   const project = requireProject();
   const projectRoot = project.root;
   const configPath = project.configPath;
-  const migrationGuard = join11(projectRoot, ".coherent", "migration-in-progress");
-  if (existsSync17(migrationGuard)) {
+  const migrationGuard = join10(projectRoot, ".coherent", "migration-in-progress");
+  if (existsSync16(migrationGuard)) {
     spinner.fail("Migration in progress");
     console.error(chalk13.red("\n\u274C A migration is in progress. Run `coherent migrate --rollback` to undo first."));
     bail("Migration in progress");
@@ -8546,7 +8340,7 @@ async function chatCommand(message, options) {
       spinner.start(`Creating shared component: ${componentName}...`);
       const { createAIProvider: createAIProvider2 } = await import("./ai-provider-CGSIYFZT.js");
       const { generateSharedComponent: generateSharedComponent7 } = await import("@getcoherent/core");
-      const { autoFixCode: autoFixCode2 } = await import("./quality-validator-G5AE4337.js");
+      const { autoFixCode: autoFixCode2 } = await import("./quality-validator-VDQXXDAV.js");
       const { extractPropsInterface, extractDependencies } = await import("./component-extractor-VYJLT5NR.js");
       const aiProvider = await createAIProvider2(provider ?? "auto");
       const prompt = `Generate a React component called "${componentName}". Description: ${message}.
@@ -8654,7 +8448,7 @@ Return JSON: { "requests": [{ "type": "add-page", "changes": { "name": "${compon
     let manifest = await loadManifest8(project.root);
     const validShared = manifest.shared.filter((s) => {
       const fp = resolve10(project.root, s.file);
-      return existsSync17(fp);
+      return existsSync16(fp);
     });
     if (validShared.length !== manifest.shared.length) {
       const cleaned = manifest.shared.length - validShared.length;
@@ -8875,8 +8669,8 @@ Return JSON: { "requests": [{ "type": "add-page", "changes": { "name": "${compon
       for (const entry of manifest.shared) {
         try {
           const sharedPath = resolve10(projectRoot, entry.file);
-          if (existsSync17(sharedPath)) {
-            const sharedCode = readFileSync12(sharedPath, "utf-8");
+          if (existsSync16(sharedPath)) {
+            const sharedCode = readFileSync11(sharedPath, "utf-8");
             const sharedImports = sharedCode.matchAll(/@\/components\/ui\/([a-z0-9-]+)/g);
             for (const m of sharedImports) {
               if (m[1]) allNeededComponentIds.add(m[1]);
@@ -8896,8 +8690,8 @@ Return JSON: { "requests": [{ "type": "add-page", "changes": { "name": "${compon
     const missingComponents = [];
     for (const componentId of allNeededComponentIds) {
       const isRegistered = !!cm.read(componentId);
-      const filePath = join11(projectRoot, "components", "ui", `${componentId}.tsx`);
-      const fileExists = existsSync17(filePath);
+      const filePath = join10(projectRoot, "components", "ui", `${componentId}.tsx`);
+      const fileExists = existsSync16(filePath);
       if (DEBUG4) console.log(chalk13.gray(`    Checking ${componentId}: registered=${isRegistered} file=${fileExists}`));
       if (!isRegistered || !fileExists) {
         missingComponents.push(componentId);
@@ -9013,9 +8807,10 @@ Return JSON: { "requests": [{ "type": "add-page", "changes": { "name": "${compon
       }
     }
     try {
-      const { validateReuse } = await import("./reuse-validator-HC4LZEKF.js");
+      const { validateReuse } = await import("./reuse-validator-XR2ZEYC4.js");
       const { inferPageTypeFromRoute: inferPageTypeFromRoute2 } = await import("./design-constraints-EIP2XM7T.js");
       const manifest2 = await loadManifest8(projectRoot);
+      const reuseplan = projectRoot ? loadPlan(projectRoot) : null;
       if (manifest2.shared.length > 0) {
         for (const request of normalizedRequests) {
           if (request.type !== "add-page") continue;
@@ -9024,7 +8819,8 @@ Return JSON: { "requests": [{ "type": "add-page", "changes": { "name": "${compon
           if (!pageCode) continue;
           const route = changes.route || "";
           const pageType = inferPageTypeFromRoute2(route);
-          const warnings = validateReuse(manifest2, pageCode, pageType);
+          const planned = reuseplan ? new Set(reuseplan.sharedComponents.filter((c) => c.usedBy.includes(route)).map((c) => c.name)) : void 0;
+          const warnings = validateReuse(manifest2, pageCode, pageType, void 0, planned);
           for (const w of warnings) {
             console.log(chalk13.yellow(`  \u26A0 ${w.message}`));
           }
@@ -9043,9 +8839,9 @@ Return JSON: { "requests": [{ "type": "add-page", "changes": { "name": "${compon
         const route = page.route || `/${page.id || "page"}`;
         const pageFilePath = routeToFsPath(projectRoot, route, false);
         let pageCode = "";
-        if (existsSync17(pageFilePath)) {
+        if (existsSync16(pageFilePath)) {
           try {
-            pageCode = readFileSync12(pageFilePath, "utf-8");
+            pageCode = readFileSync11(pageFilePath, "utf-8");
           } catch {
           }
         }
@@ -9065,8 +8861,8 @@ Return JSON: { "requests": [{ "type": "add-page", "changes": { "name": "${compon
       }
       const missingRoutes = [...allLinkedRoutes].filter((route) => {
         if (expandedExisting.has(route)) return false;
-        if (existsSync17(routeToFsPath(projectRoot, route, false))) return false;
-        if (existsSync17(routeToFsPath(projectRoot, route, true))) return false;
+        if (existsSync16(routeToFsPath(projectRoot, route, false))) return false;
+        if (existsSync16(routeToFsPath(projectRoot, route, true))) return false;
         return true;
       });
       const SCAFFOLD_AI_LIMIT = 10;
@@ -9131,7 +8927,7 @@ Return JSON: { "requests": [{ "type": "add-page", "changes": { "name": "${compon
           const filePath = routeToFsPath(projectRoot, linkedRoute, isAuth);
           if (isAuth) await ensureAuthRouteGroup(projectRoot);
           const dir = resolve10(filePath, "..");
-          if (!existsSync17(dir)) {
+          if (!existsSync16(dir)) {
             mkdirSync6(dir, { recursive: true });
           }
           const placeholderCode = `export default function ${pageName.replace(/\s/g, "")}Page() {
@@ -9164,7 +8960,7 @@ Return JSON: { "requests": [{ "type": "add-page", "changes": { "name": "${compon
         for (const mod of result.modified) {
           if (mod.startsWith("app/") && mod.endsWith("/page.tsx")) {
             try {
-              const code = readFileSync12(resolve10(projectRoot, mod), "utf-8");
+              const code = readFileSync11(resolve10(projectRoot, mod), "utf-8");
               const issues = validatePageQuality(code, allRoutes).filter(
                 (i) => i.type === "BROKEN_INTERNAL_LINK"
               );
@@ -9247,13 +9043,13 @@ Return JSON: { "requests": [{ "type": "add-page", "changes": { "name": "${compon
       const sharedDir = resolve10(projectRoot, "components", "shared");
       const layoutFile = resolve10(projectRoot, "app", "layout.tsx");
       const filesToHash = [layoutFile];
-      if (existsSync17(sharedDir)) {
+      if (existsSync16(sharedDir)) {
         for (const f of readdirSync4(sharedDir)) {
           if (f.endsWith(".tsx")) filesToHash.push(resolve10(sharedDir, f));
         }
       }
       for (const filePath of filesToHash) {
-        if (existsSync17(filePath)) {
+        if (existsSync16(filePath)) {
           const rel = relative2(projectRoot, filePath);
           updatedHashes[rel] = await computeFileHash(filePath);
         }
@@ -9268,8 +9064,8 @@ Return JSON: { "requests": [{ "type": "add-page", "changes": { "name": "${compon
       let manifestChanged = false;
       for (const entry of currentManifest.shared) {
         const fullPath = resolve10(projectRoot, entry.file);
-        if (!existsSync17(fullPath)) continue;
-        const code = readFileSync12(fullPath, "utf-8");
+        if (!existsSync16(fullPath)) continue;
+        const code = readFileSync11(fullPath, "utf-8");
         const props = extractPropsInterface(code);
         const deps = extractDependencies(code);
         if (props && props !== entry.propsInterface || deps.length !== (entry.dependencies?.length ?? 0)) {
@@ -9283,8 +9079,8 @@ Return JSON: { "requests": [{ "type": "add-page", "changes": { "name": "${compon
       const pageFiles = Array.from(allModified).filter((f) => f.startsWith("app/") && f.endsWith("page.tsx"));
       for (const pageFile of pageFiles) {
         const fullPath = resolve10(projectRoot, pageFile);
-        if (!existsSync17(fullPath)) continue;
-        const pageCode = readFileSync12(fullPath, "utf-8");
+        if (!existsSync16(fullPath)) continue;
+        const pageCode = readFileSync11(fullPath, "utf-8");
         for (const entry of currentManifest.shared) {
           const isUsed = pageCode.includes(`from '@/components/shared/`) && (pageCode.includes(`{ ${entry.name} }`) || pageCode.includes(`{ ${entry.name},`));
           if (isUsed && !entry.usedIn.includes(pageFile)) {
@@ -9341,7 +9137,7 @@ Return JSON: { "requests": [{ "type": "add-page", "changes": { "name": "${compon
 ${uxRecommendations}
 `;
       try {
-        if (!existsSync17(recPath)) {
+        if (!existsSync16(recPath)) {
           await writeFile(
             recPath,
             "# UX/UI Recommendations\n\nRecommendations are added here when you use `coherent chat` and the AI suggests improvements.\n"
@@ -9415,9 +9211,9 @@ ${uxRecommendations}
 import chalk14 from "chalk";
 import ora3 from "ora";
 import { spawn } from "child_process";
-import { existsSync as existsSync20, rmSync as rmSync3, readFileSync as readFileSync15, writeFileSync as writeFileSync10, readdirSync as readdirSync6 } from "fs";
-import { resolve as resolve11, join as join14 } from "path";
-import { readdir as readdir2 } from "fs/promises";
+import { existsSync as existsSync19, rmSync as rmSync3, readFileSync as readFileSync14, writeFileSync as writeFileSync10, readdirSync as readdirSync6 } from "fs";
+import { resolve as resolve11, join as join13 } from "path";
+import { readdir } from "fs/promises";
 
 // src/utils/css-validator.ts
 var REQUIRED_THEME_TOKENS = [
@@ -9471,13 +9267,13 @@ function validateV4GlobalsCss(css) {
 import { DesignSystemManager as DesignSystemManager8, ComponentGenerator as ComponentGenerator3 } from "@getcoherent/core";
 
 // src/utils/file-watcher.ts
-import { readFileSync as readFileSync14, writeFileSync as writeFileSync9, existsSync as existsSync19 } from "fs";
-import { relative as relative4, join as join13 } from "path";
+import { readFileSync as readFileSync13, writeFileSync as writeFileSync9, existsSync as existsSync18 } from "fs";
+import { relative as relative4, join as join12 } from "path";
 import { loadManifest as loadManifest9, saveManifest as saveManifest4 } from "@getcoherent/core";
 
 // src/utils/component-integrity.ts
-import { existsSync as existsSync18, readFileSync as readFileSync13, readdirSync as readdirSync5 } from "fs";
-import { join as join12, relative as relative3 } from "path";
+import { existsSync as existsSync17, readFileSync as readFileSync12, readdirSync as readdirSync5 } from "fs";
+import { join as join11, relative as relative3 } from "path";
 function extractExportedComponentNames(code) {
   const names = [];
   let m;
@@ -9509,14 +9305,14 @@ function arraysEqual(a, b) {
 }
 function findPagesImporting(projectRoot, componentName, componentFile) {
   const results = [];
-  const appDir = join12(projectRoot, "app");
-  if (!existsSync18(appDir)) return results;
+  const appDir = join11(projectRoot, "app");
+  if (!existsSync17(appDir)) return results;
   const pageFiles = collectFiles(appDir, (name) => name === "page.tsx" || name === "page.jsx");
   const componentImportPath = componentFile.replace(/\.tsx$/, "").replace(/\.jsx$/, "");
   for (const absPath of pageFiles) {
     if (absPath.includes("design-system")) continue;
     try {
-      const code = readFileSync13(absPath, "utf-8");
+      const code = readFileSync12(absPath, "utf-8");
       const hasNamedImport = new RegExp(`import\\s+\\{[^}]*\\b${componentName}\\b[^}]*\\}\\s+from\\s+['"]`).test(code);
       const hasDefaultImport = new RegExp(`import\\s+${componentName}\\s+from\\s+['"]`).test(code);
       const hasPathImport = code.includes(`@/${componentImportPath}`);
@@ -9529,10 +9325,10 @@ function findPagesImporting(projectRoot, componentName, componentFile) {
   return results;
 }
 function isUsedInLayout(projectRoot, componentName) {
-  const layoutPath = join12(projectRoot, "app", "layout.tsx");
-  if (!existsSync18(layoutPath)) return false;
+  const layoutPath = join11(projectRoot, "app", "layout.tsx");
+  if (!existsSync17(layoutPath)) return false;
   try {
-    const code = readFileSync13(layoutPath, "utf-8");
+    const code = readFileSync12(layoutPath, "utf-8");
     return code.includes(componentName);
   } catch {
     return false;
@@ -9540,8 +9336,8 @@ function isUsedInLayout(projectRoot, componentName) {
 }
 function findUnregisteredComponents(projectRoot, manifest) {
   const results = [];
-  const componentsDir = join12(projectRoot, "components");
-  if (!existsSync18(componentsDir)) return results;
+  const componentsDir = join11(projectRoot, "components");
+  if (!existsSync17(componentsDir)) return results;
   const registeredFiles = new Set(manifest.shared.map((s) => s.file));
   const registeredNames = new Set(manifest.shared.map((s) => s.name));
   const files = collectFiles(
@@ -9553,7 +9349,7 @@ function findUnregisteredComponents(projectRoot, manifest) {
     const relFile = relative3(projectRoot, absPath);
     if (registeredFiles.has(relFile)) continue;
     try {
-      const code = readFileSync13(absPath, "utf-8");
+      const code = readFileSync12(absPath, "utf-8");
       const exports = extractExportedComponentNames(code);
       for (const name of exports) {
         if (registeredNames.has(name)) continue;
@@ -9568,14 +9364,14 @@ function findUnregisteredComponents(projectRoot, manifest) {
 }
 function findInlineDuplicates(projectRoot, manifest) {
   const results = [];
-  const appDir = join12(projectRoot, "app");
-  if (!existsSync18(appDir)) return results;
+  const appDir = join11(projectRoot, "app");
+  if (!existsSync17(appDir)) return results;
   const pageFiles = collectFiles(appDir, (name) => name === "page.tsx" || name === "page.jsx");
   for (const absPath of pageFiles) {
     if (absPath.includes("design-system")) continue;
     let code;
     try {
-      code = readFileSync13(absPath, "utf-8");
+      code = readFileSync12(absPath, "utf-8");
     } catch {
       continue;
     }
@@ -9598,8 +9394,8 @@ function findInlineDuplicates(projectRoot, manifest) {
   return results;
 }
 function findComponentFileByExportName(projectRoot, componentName) {
-  const componentsDir = join12(projectRoot, "components");
-  if (!existsSync18(componentsDir)) return null;
+  const componentsDir = join11(projectRoot, "components");
+  if (!existsSync17(componentsDir)) return null;
   const files = collectFiles(
     componentsDir,
     (name) => (name.endsWith(".tsx") || name.endsWith(".jsx")) && !name.startsWith("."),
@@ -9607,7 +9403,7 @@ function findComponentFileByExportName(projectRoot, componentName) {
   );
   for (const absPath of files) {
     try {
-      const code = readFileSync13(absPath, "utf-8");
+      const code = readFileSync12(absPath, "utf-8");
       const exports = extractExportedComponentNames(code);
       if (exports.includes(componentName)) {
         return relative3(projectRoot, absPath);
@@ -9620,8 +9416,8 @@ function findComponentFileByExportName(projectRoot, componentName) {
 function removeOrphanedEntries(projectRoot, manifest) {
   const removed = [];
   const valid = manifest.shared.filter((entry) => {
-    const filePath = join12(projectRoot, entry.file);
-    if (existsSync18(filePath)) return true;
+    const filePath = join11(projectRoot, entry.file);
+    if (existsSync17(filePath)) return true;
     removed.push({ id: entry.id, name: entry.name });
     return false;
   });
@@ -9639,8 +9435,8 @@ function reconcileComponents(projectRoot, manifest) {
   };
   const m = { ...manifest, shared: [...manifest.shared], nextId: manifest.nextId };
   m.shared = m.shared.filter((entry) => {
-    const filePath = join12(projectRoot, entry.file);
-    if (!existsSync18(filePath)) {
+    const filePath = join11(projectRoot, entry.file);
+    if (!existsSync17(filePath)) {
       const newPath = findComponentFileByExportName(projectRoot, entry.name);
       if (newPath) {
         result.updated.push({ id: entry.id, field: "file", from: entry.file, to: newPath });
@@ -9652,7 +9448,7 @@ function reconcileComponents(projectRoot, manifest) {
     }
     let code;
     try {
-      code = readFileSync13(join12(projectRoot, entry.file), "utf-8");
+      code = readFileSync12(join11(projectRoot, entry.file), "utf-8");
     } catch {
       return true;
     }
@@ -9736,7 +9532,7 @@ function collectFiles(dir, filter, skipDirs = []) {
       return;
     }
     for (const e of entries) {
-      const full = join12(d, e.name);
+      const full = join11(d, e.name);
       if (e.isDirectory()) {
         if (skipDirs.includes(e.name) || e.name.startsWith(".")) continue;
         walk(full);
@@ -9775,9 +9571,9 @@ function findInlineDuplicatesOfShared(content, manifest) {
 }
 function getWatcherConfig(projectRoot) {
   try {
-    const pkgPath = join13(projectRoot, "package.json");
-    if (!existsSync19(pkgPath)) return defaultWatcherConfig();
-    const pkg = JSON.parse(readFileSync14(pkgPath, "utf-8"));
+    const pkgPath = join12(projectRoot, "package.json");
+    if (!existsSync18(pkgPath)) return defaultWatcherConfig();
+    const pkg = JSON.parse(readFileSync13(pkgPath, "utf-8"));
     const c = pkg?.coherent?.watcher ?? {};
     return {
       enabled: c.enabled !== false,
@@ -9805,7 +9601,7 @@ async function handleFileChange(projectRoot, filePath) {
   if (relativePath.includes("node_modules") || relativePath.includes(".next")) return;
   let content;
   try {
-    content = readFileSync14(filePath, "utf-8");
+    content = readFileSync13(filePath, "utf-8");
   } catch {
     return;
   }
@@ -9878,7 +9674,7 @@ async function detectNewComponent(projectRoot, filePath) {
     const manifest = await loadManifest9(projectRoot);
     const alreadyRegistered = manifest.shared.some((s) => s.file === relativePath);
     if (alreadyRegistered) return;
-    const code = readFileSync14(filePath, "utf-8");
+    const code = readFileSync13(filePath, "utf-8");
     const exports = extractExportedComponentNames(code);
     if (exports.length > 0) {
       const alreadyByName = exports.every((n) => manifest.shared.some((s) => s.name === n));
@@ -9904,8 +9700,8 @@ function startFileWatcher(projectRoot) {
   let watcher = null;
   let manifestWatcher = null;
   import("chokidar").then((chokidar) => {
-    const appGlob = join13(projectRoot, "app", "**", "*.tsx");
-    const compGlob = join13(projectRoot, "components", "**", "*.tsx");
+    const appGlob = join12(projectRoot, "app", "**", "*.tsx");
+    const compGlob = join12(projectRoot, "components", "**", "*.tsx");
     watcher = chokidar.default.watch([appGlob, compGlob], {
       ignoreInitial: true,
       awaitWriteFinish: { stabilityThreshold: 500 }
@@ -9917,8 +9713,8 @@ function startFileWatcher(projectRoot) {
     });
     watcher.on("unlink", (fp) => handleFileDelete(projectRoot, fp));
   });
-  const manifestPath = join13(projectRoot, "coherent.components.json");
-  if (existsSync19(manifestPath)) {
+  const manifestPath = join12(projectRoot, "coherent.components.json");
+  if (existsSync18(manifestPath)) {
     import("chokidar").then((chokidar) => {
       manifestWatcher = chokidar.default.watch(manifestPath, { ignoreInitial: true });
       manifestWatcher.on("change", () => handleManifestChange(projectRoot));
@@ -9932,7 +9728,7 @@ function startFileWatcher(projectRoot) {
 
 // src/commands/preview.ts
 function getPackageManager(projectRoot) {
-  const hasPnpm = existsSync20(resolve11(projectRoot, "pnpm-lock.yaml"));
+  const hasPnpm = existsSync19(resolve11(projectRoot, "pnpm-lock.yaml"));
   return hasPnpm ? "pnpm" : "npm";
 }
 function runInstall(projectRoot) {
@@ -9956,21 +9752,21 @@ function runInstall(projectRoot) {
 function checkProjectInitialized(projectRoot) {
   const configPath = resolve11(projectRoot, "design-system.config.ts");
   const packageJsonPath = resolve11(projectRoot, "package.json");
-  if (!existsSync20(configPath)) {
+  if (!existsSync19(configPath)) {
     return false;
   }
-  if (!existsSync20(packageJsonPath)) {
+  if (!existsSync19(packageJsonPath)) {
     return false;
   }
   return true;
 }
 function checkDependenciesInstalled(projectRoot) {
   const nodeModulesPath = resolve11(projectRoot, "node_modules");
-  return existsSync20(nodeModulesPath);
+  return existsSync19(nodeModulesPath);
 }
 function clearStaleCache(projectRoot) {
-  const nextDir = join14(projectRoot, ".next");
-  if (existsSync20(nextDir)) {
+  const nextDir = join13(projectRoot, ".next");
+  if (existsSync19(nextDir)) {
     rmSync3(nextDir, { recursive: true, force: true });
     console.log(chalk14.dim("   \u2714 Cleared stale build cache"));
   }
@@ -9986,11 +9782,11 @@ async function preflightDependencyCheck(projectRoot) {
 }
 async function listPageFiles(appDir) {
   const out = [];
-  if (!existsSync20(appDir)) return out;
+  if (!existsSync19(appDir)) return out;
   async function walk(dir) {
-    const entries = await readdir2(dir, { withFileTypes: true });
+    const entries = await readdir(dir, { withFileTypes: true });
     for (const e of entries) {
-      const full = join14(dir, e.name);
+      const full = join13(dir, e.name);
       if (e.isDirectory() && !e.name.startsWith(".") && e.name !== "api" && e.name !== "design-system") await walk(full);
       else if (e.isFile() && e.name === "page.tsx") out.push(full);
     }
@@ -9999,10 +9795,10 @@ async function listPageFiles(appDir) {
   return out;
 }
 async function validateSyntax(projectRoot) {
-  const appDir = join14(projectRoot, "app");
+  const appDir = join13(projectRoot, "app");
   const pages = await listPageFiles(appDir);
   for (const file of pages) {
-    const content = readFileSync15(file, "utf-8");
+    const content = readFileSync14(file, "utf-8");
     const fixed = fixUnescapedLtInJsx(sanitizeMetadataStrings(ensureUseClientIfNeeded(content)));
     if (fixed !== content) {
       writeFileSync10(file, fixed, "utf-8");
@@ -10011,18 +9807,18 @@ async function validateSyntax(projectRoot) {
   }
 }
 async function fixMissingComponentExports(projectRoot) {
-  const appDir = join14(projectRoot, "app");
-  const uiDir = join14(projectRoot, "components", "ui");
-  if (!existsSync20(appDir) || !existsSync20(uiDir)) return;
+  const appDir = join13(projectRoot, "app");
+  const uiDir = join13(projectRoot, "components", "ui");
+  if (!existsSync19(appDir) || !existsSync19(uiDir)) return;
   const pages = await listPageFiles(appDir);
-  const sharedDir = join14(projectRoot, "components", "shared");
-  if (existsSync20(sharedDir)) {
-    const sharedFiles = readdirSync6(sharedDir).filter((f) => f.endsWith(".tsx") || f.endsWith(".ts")).map((f) => join14(sharedDir, f));
+  const sharedDir = join13(projectRoot, "components", "shared");
+  if (existsSync19(sharedDir)) {
+    const sharedFiles = readdirSync6(sharedDir).filter((f) => f.endsWith(".tsx") || f.endsWith(".ts")).map((f) => join13(sharedDir, f));
     pages.push(...sharedFiles);
   }
   const neededExports = /* @__PURE__ */ new Map();
   for (const file of pages) {
-    const content = readFileSync15(file, "utf-8");
+    const content = readFileSync14(file, "utf-8");
     const importRe = /import\s*\{([^}]+)\}\s*from\s*['"]@\/components\/ui\/([^'"]+)['"]/g;
     let m;
     while ((m = importRe.exec(content)) !== null) {
@@ -10032,7 +9828,7 @@ async function fixMissingComponentExports(projectRoot) {
       for (const name of names) neededExports.get(componentId).add(name);
     }
   }
-  const configPath = join14(projectRoot, "design-system.config.ts");
+  const configPath = join13(projectRoot, "design-system.config.ts");
   let config2 = null;
   try {
     const mgr = new DesignSystemManager8(configPath);
@@ -10042,8 +9838,8 @@ async function fixMissingComponentExports(projectRoot) {
   const generator = new ComponentGenerator3(config2 || { components: [], pages: [], tokens: {} });
   const provider = getComponentProvider();
   for (const [componentId, needed] of neededExports) {
-    const componentFile = join14(uiDir, `${componentId}.tsx`);
-    if (!existsSync20(componentFile)) {
+    const componentFile = join13(uiDir, `${componentId}.tsx`);
+    if (!existsSync19(componentFile)) {
       if (provider.has(componentId)) {
         try {
           const result = await provider.installComponent(componentId, projectRoot);
@@ -10066,7 +9862,7 @@ async function fixMissingComponentExports(projectRoot) {
       }
       continue;
     }
-    const content = readFileSync15(componentFile, "utf-8");
+    const content = readFileSync14(componentFile, "utf-8");
     const exportRe = /export\s+(?:const|function|class)\s+(\w+)|export\s*\{([^}]+)\}/g;
     const existingExports = /* @__PURE__ */ new Set();
     let em;
@@ -10100,7 +9896,7 @@ async function fixMissingComponentExports(projectRoot) {
   }
   const neededSharedExports = /* @__PURE__ */ new Map();
   for (const file of pages) {
-    const content = readFileSync15(file, "utf-8");
+    const content = readFileSync14(file, "utf-8");
     const sharedImportRe = /import\s*\{([^}]+)\}\s*from\s*['"]@\/components\/shared\/([^'"]+)['"]/g;
     let sm;
     while ((sm = sharedImportRe.exec(content)) !== null) {
@@ -10111,9 +9907,9 @@ async function fixMissingComponentExports(projectRoot) {
     }
   }
   for (const [componentId, needed] of neededSharedExports) {
-    const componentFile = join14(sharedDir, `${componentId}.tsx`);
-    if (!existsSync20(componentFile)) continue;
-    let content = readFileSync15(componentFile, "utf-8");
+    const componentFile = join13(sharedDir, `${componentId}.tsx`);
+    if (!existsSync19(componentFile)) continue;
+    let content = readFileSync14(componentFile, "utf-8");
     const exportRe = /export\s+(?:const|function|class)\s+(\w+)|export\s*\{([^}]+)\}/g;
     const existingExports = /* @__PURE__ */ new Set();
     let em;
@@ -10135,8 +9931,8 @@ async function fixMissingComponentExports(projectRoot) {
   }
 }
 async function backfillPageAnalysis(projectRoot) {
-  const configPath = join14(projectRoot, "design-system.config.ts");
-  if (!existsSync20(configPath)) return;
+  const configPath = join13(projectRoot, "design-system.config.ts");
+  if (!existsSync19(configPath)) return;
   try {
     const mgr = new DesignSystemManager8(configPath);
     const config2 = mgr.getConfig();
@@ -10147,14 +9943,14 @@ async function backfillPageAnalysis(projectRoot) {
       const isAuth = route.includes("login") || route.includes("register") || route.includes("signup") || route.includes("sign-up");
       let filePath;
       if (route === "/") {
-        filePath = join14(projectRoot, "app", "page.tsx");
+        filePath = join13(projectRoot, "app", "page.tsx");
       } else if (isAuth) {
-        filePath = join14(projectRoot, "app", "(auth)", route.slice(1), "page.tsx");
+        filePath = join13(projectRoot, "app", "(auth)", route.slice(1), "page.tsx");
       } else {
-        filePath = join14(projectRoot, "app", route.slice(1), "page.tsx");
+        filePath = join13(projectRoot, "app", route.slice(1), "page.tsx");
       }
-      if (!existsSync20(filePath)) continue;
-      const code = readFileSync15(filePath, "utf-8");
+      if (!existsSync19(filePath)) continue;
+      const code = readFileSync14(filePath, "utf-8");
       if (code.length < 50) continue;
       page.pageAnalysis = analyzePageCode(code);
       changed = true;
@@ -10305,11 +10101,11 @@ async function openBrowser(url) {
 }
 function startDevServer(projectRoot) {
   const packageJsonPath = resolve11(projectRoot, "package.json");
-  if (!existsSync20(packageJsonPath)) {
+  if (!existsSync19(packageJsonPath)) {
     throw new Error('package.json not found. Run "coherent init" first.');
   }
-  const hasPnpm = existsSync20(resolve11(projectRoot, "pnpm-lock.yaml"));
-  const hasNpm = existsSync20(resolve11(projectRoot, "package-lock.json"));
+  const hasPnpm = existsSync19(resolve11(projectRoot, "pnpm-lock.yaml"));
+  const hasNpm = existsSync19(resolve11(projectRoot, "package-lock.json"));
   const command = hasPnpm ? "pnpm" : hasNpm ? "npm" : "npx";
   const args = hasPnpm ? ["dev", "--turbo"] : hasNpm ? ["run", "dev", "--", "--turbo"] : ["next", "dev", "--turbo"];
   const child = spawn(command, args, {
@@ -10367,8 +10163,8 @@ async function previewCommand() {
     }
     if (isTailwindV4(projectRoot)) {
       const globalsPath = resolve11(projectRoot, "app", "globals.css");
-      if (existsSync20(globalsPath)) {
-        const globalsContent = readFileSync15(globalsPath, "utf-8");
+      if (existsSync19(globalsPath)) {
+        const globalsContent = readFileSync14(globalsPath, "utf-8");
         const cssIssues = validateV4GlobalsCss(globalsContent);
         if (cssIssues.length > 0) {
           console.log(chalk14.yellow("\n\u26A0\uFE0F  globals.css validation warnings:"));
@@ -10409,9 +10205,9 @@ async function previewCommand() {
 import chalk15 from "chalk";
 import ora4 from "ora";
 import { spawn as spawn2 } from "child_process";
-import { existsSync as existsSync21, rmSync as rmSync4, readdirSync as readdirSync7 } from "fs";
-import { resolve as resolve12, join as join15, dirname as dirname7 } from "path";
-import { readdir as readdir3, readFile as readFile6, writeFile as writeFile5, mkdir as mkdir5, copyFile as copyFile2 } from "fs/promises";
+import { existsSync as existsSync20, rmSync as rmSync4, readdirSync as readdirSync7 } from "fs";
+import { resolve as resolve12, join as join14, dirname as dirname7 } from "path";
+import { readdir as readdir2, readFile as readFile5, writeFile as writeFile5, mkdir as mkdir5, copyFile as copyFile2 } from "fs/promises";
 var COPY_EXCLUDE = /* @__PURE__ */ new Set([
   "node_modules",
   ".next",
@@ -10430,10 +10226,10 @@ var COPY_EXCLUDE = /* @__PURE__ */ new Set([
 ]);
 async function copyDir(src, dest) {
   await mkdir5(dest, { recursive: true });
-  const entries = await readdir3(src, { withFileTypes: true });
+  const entries = await readdir2(src, { withFileTypes: true });
   for (const e of entries) {
-    const srcPath = join15(src, e.name);
-    const destPath = join15(dest, e.name);
+    const srcPath = join14(src, e.name);
+    const destPath = join14(dest, e.name);
     if (COPY_EXCLUDE.has(e.name)) continue;
     if (e.isDirectory()) {
       await copyDir(srcPath, destPath);
@@ -10444,18 +10240,18 @@ async function copyDir(src, dest) {
   }
 }
 function checkProjectInitialized2(projectRoot) {
-  return existsSync21(resolve12(projectRoot, "design-system.config.ts")) && existsSync21(resolve12(projectRoot, "package.json"));
+  return existsSync20(resolve12(projectRoot, "design-system.config.ts")) && existsSync20(resolve12(projectRoot, "package.json"));
 }
 function getPackageManager2(projectRoot) {
-  if (existsSync21(resolve12(projectRoot, "pnpm-lock.yaml"))) return "pnpm";
-  if (existsSync21(resolve12(projectRoot, "package-lock.json"))) return "npm";
+  if (existsSync20(resolve12(projectRoot, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync20(resolve12(projectRoot, "package-lock.json"))) return "npm";
   return "npx";
 }
 async function patchNextConfigForExport(outRoot) {
   for (const name of ["next.config.ts", "next.config.mjs", "next.config.js"]) {
-    const p = join15(outRoot, name);
-    if (!existsSync21(p)) continue;
-    let content = await readFile6(p, "utf-8");
+    const p = join14(outRoot, name);
+    if (!existsSync20(p)) continue;
+    let content = await readFile5(p, "utf-8");
     if (content.includes("ignoreDuringBuilds")) return;
     content = content.replace(
       /(const\s+nextConfig\s*(?::\s*\w+)?\s*=\s*\{)/,
@@ -10495,10 +10291,10 @@ EXPOSE 3000
 \`\`\`
 `;
 async function ensureReadmeDeploySection(outRoot) {
-  const readmePath = join15(outRoot, "README.md");
-  if (!existsSync21(readmePath)) return;
+  const readmePath = join14(outRoot, "README.md");
+  if (!existsSync20(readmePath)) return;
   try {
-    let content = await readFile6(readmePath, "utf-8");
+    let content = await readFile5(readmePath, "utf-8");
     if (/##\s+Deploy\b/m.test(content)) return;
     content = content.trimEnd() + DEPLOY_SECTION + "\n";
     await writeFile5(readmePath, content);
@@ -10510,25 +10306,25 @@ async function countPages(outRoot) {
   async function walk(dir) {
     let entries;
     try {
-      entries = await readdir3(dir, { withFileTypes: true });
+      entries = await readdir2(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const e of entries) {
-      const full = join15(dir, e.name);
+      const full = join14(dir, e.name);
       if (e.isFile() && e.name === "page.tsx") n++;
       else if (e.isDirectory() && !e.name.startsWith(".") && e.name !== "api") await walk(full);
     }
   }
-  const appDir = join15(outRoot, "app");
-  if (existsSync21(appDir)) await walk(appDir);
+  const appDir = join14(outRoot, "app");
+  if (existsSync20(appDir)) await walk(appDir);
   return n;
 }
 function countComponents(outRoot) {
   let n = 0;
   for (const sub of ["ui", "shared"]) {
-    const dir = join15(outRoot, "components", sub);
-    if (!existsSync21(dir)) continue;
+    const dir = join14(outRoot, "components", sub);
+    if (!existsSync20(dir)) continue;
     try {
       n += readdirSync7(dir).filter((f) => f.endsWith(".tsx") || f.endsWith(".jsx")).length;
     } catch {
@@ -10536,14 +10332,14 @@ function countComponents(outRoot) {
   }
   return n;
 }
-var IMPORT_FROM_REGEX2 = /from\s+['"]([^'"]+)['"]/g;
-async function collectImportedPackages2(dir, extensions) {
+var IMPORT_FROM_REGEX = /from\s+['"]([^'"]+)['"]/g;
+async function collectImportedPackages(dir, extensions) {
   const packages = /* @__PURE__ */ new Set();
-  if (!existsSync21(dir)) return packages;
+  if (!existsSync20(dir)) return packages;
   async function walk(d) {
-    const entries = await readdir3(d, { withFileTypes: true });
+    const entries = await readdir2(d, { withFileTypes: true });
     for (const e of entries) {
-      const full = join15(d, e.name);
+      const full = join14(d, e.name);
       if (e.isDirectory() && !e.name.startsWith(".") && e.name !== "node_modules") {
         await walk(full);
         continue;
@@ -10551,10 +10347,10 @@ async function collectImportedPackages2(dir, extensions) {
       if (!e.isFile()) continue;
       const ext = e.name.replace(/^.*\./, "");
       if (!extensions.has(ext)) continue;
-      const content = await readFile6(full, "utf-8").catch(() => "");
+      const content = await readFile5(full, "utf-8").catch(() => "");
       let m;
-      IMPORT_FROM_REGEX2.lastIndex = 0;
-      while ((m = IMPORT_FROM_REGEX2.exec(content)) !== null) {
+      IMPORT_FROM_REGEX.lastIndex = 0;
+      while ((m = IMPORT_FROM_REGEX.exec(content)) !== null) {
         const spec = m[1];
         if (spec.startsWith(".") || spec.startsWith("/") || spec.startsWith("@/")) continue;
         const pkg = spec.startsWith("@") ? spec.split("/").slice(0, 2).join("/") : spec.split("/")[0];
@@ -10566,64 +10362,64 @@ async function collectImportedPackages2(dir, extensions) {
   return packages;
 }
 async function findMissingDepsInExport(outRoot) {
-  const pkgPath = join15(outRoot, "package.json");
-  if (!existsSync21(pkgPath)) return [];
+  const pkgPath = join14(outRoot, "package.json");
+  if (!existsSync20(pkgPath)) return [];
   let pkg;
   try {
-    pkg = JSON.parse(await readFile6(pkgPath, "utf-8"));
+    pkg = JSON.parse(await readFile5(pkgPath, "utf-8"));
   } catch {
     return [];
   }
   const inDeps = /* @__PURE__ */ new Set([...Object.keys(pkg.dependencies ?? {}), ...Object.keys(pkg.devDependencies ?? {})]);
-  const codeDirs = [join15(outRoot, "app"), join15(outRoot, "components")];
+  const codeDirs = [join14(outRoot, "app"), join14(outRoot, "components")];
   const extensions = /* @__PURE__ */ new Set(["ts", "tsx", "js", "jsx"]);
   const imported = /* @__PURE__ */ new Set();
   for (const dir of codeDirs) {
     ;
-    (await collectImportedPackages2(dir, extensions)).forEach((p) => imported.add(p));
+    (await collectImportedPackages(dir, extensions)).forEach((p) => imported.add(p));
   }
   return [...imported].filter((p) => !inDeps.has(p)).sort();
 }
 async function stripCoherentArtifacts(outputDir) {
   const removed = [];
   for (const p of ["app/design-system", "app/api/design-system"]) {
-    const full = join15(outputDir, p);
-    if (existsSync21(full)) {
+    const full = join14(outputDir, p);
+    if (existsSync20(full)) {
       rmSync4(full, { recursive: true, force: true });
       removed.push(p);
     }
   }
-  const appNavPath = join15(outputDir, "app", "AppNav.tsx");
-  if (existsSync21(appNavPath)) {
+  const appNavPath = join14(outputDir, "app", "AppNav.tsx");
+  if (existsSync20(appNavPath)) {
     rmSync4(appNavPath, { force: true });
     removed.push("app/AppNav.tsx");
   }
-  const layoutPath = join15(outputDir, "app", "layout.tsx");
-  if (existsSync21(layoutPath)) {
-    let layout = await readFile6(layoutPath, "utf-8");
+  const layoutPath = join14(outputDir, "app", "layout.tsx");
+  if (existsSync20(layoutPath)) {
+    let layout = await readFile5(layoutPath, "utf-8");
     layout = layout.replace(/import\s*\{?\s*AppNav\s*\}?\s*from\s*['"][^'"]+['"]\s*\n?/g, "");
     layout = layout.replace(/\s*<AppNav\s*\/?\s*>\s*/g, "\n");
     await writeFile5(layoutPath, layout, "utf-8");
   }
-  const sharedHeaderPath = join15(outputDir, "components", "shared", "header.tsx");
-  if (existsSync21(sharedHeaderPath)) {
-    let header = await readFile6(sharedHeaderPath, "utf-8");
+  const sharedHeaderPath = join14(outputDir, "components", "shared", "header.tsx");
+  if (existsSync20(sharedHeaderPath)) {
+    let header = await readFile5(sharedHeaderPath, "utf-8");
     header = header.replace(/<Link\s[^>]*href="\/design-system"[^>]*>[\s\S]*?<\/Link>/g, "");
     header = header.replace(/\n\s*<>\s*\n/, "\n");
     header = header.replace(/\n\s*<\/>\s*\n/, "\n");
     await writeFile5(sharedHeaderPath, header, "utf-8");
   }
-  const guardPath2 = join15(outputDir, "app", "ShowWhenNotAuthRoute.tsx");
-  if (existsSync21(guardPath2)) {
-    let guard = await readFile6(guardPath2, "utf-8");
+  const guardPath2 = join14(outputDir, "app", "ShowWhenNotAuthRoute.tsx");
+  if (existsSync20(guardPath2)) {
+    let guard = await readFile5(guardPath2, "utf-8");
     guard = guard.replace(/['"],?\s*'\/design-system['"],?\s*/g, "");
     const pathsMatch = guard.match(/HIDDEN_PATHS\s*=\s*\[([^\]]*)\]/);
     const remaining = pathsMatch ? pathsMatch[1].replace(/['"]/g, "").split(",").map((s) => s.trim()).filter(Boolean) : [];
     if (remaining.length === 0) {
       rmSync4(guardPath2, { force: true });
       removed.push("app/ShowWhenNotAuthRoute.tsx");
-      if (existsSync21(layoutPath)) {
-        let layout = await readFile6(layoutPath, "utf-8");
+      if (existsSync20(layoutPath)) {
+        let layout = await readFile5(layoutPath, "utf-8");
         layout = layout.replace(/import\s+\w+\s+from\s*['"]\.\/ShowWhenNotAuthRoute['"]\s*\n?/g, "");
         layout = layout.replace(/\s*<ShowWhenNotAuthRoute>\s*\n?/g, "\n");
         layout = layout.replace(/\s*<\/ShowWhenNotAuthRoute>\s*\n?/g, "\n");
@@ -10642,15 +10438,15 @@ async function stripCoherentArtifacts(outputDir) {
     ".env.local",
     "recommendations.md"
   ]) {
-    const full = join15(outputDir, name);
-    if (existsSync21(full)) {
+    const full = join14(outputDir, name);
+    if (existsSync20(full)) {
       rmSync4(full, { force: true });
       removed.push(name);
     }
   }
   for (const dir of [".claude", ".coherent"]) {
-    const full = join15(outputDir, dir);
-    if (existsSync21(full)) {
+    const full = join14(outputDir, dir);
+    if (existsSync20(full)) {
       rmSync4(full, { recursive: true, force: true });
       removed.push(dir + "/");
     }
@@ -10674,7 +10470,7 @@ async function exportCommand(options = {}) {
       process.exit(1);
     }
     spinner.text = "Copying project...";
-    if (existsSync21(outputDir)) rmSync4(outputDir, { recursive: true, force: true });
+    if (existsSync20(outputDir)) rmSync4(outputDir, { recursive: true, force: true });
     await copyDir(projectRoot, outputDir);
     spinner.succeed("Project copied");
     if (!keepDs) {
@@ -10849,8 +10645,8 @@ async function regenerateDocsCommand() {
 
 // src/commands/fix.ts
 import chalk18 from "chalk";
-import { readdirSync as readdirSync8, readFileSync as readFileSync16, existsSync as existsSync22, writeFileSync as writeFileSync11, rmSync as rmSync5, mkdirSync as mkdirSync7 } from "fs";
-import { resolve as resolve13, join as join16 } from "path";
+import { readdirSync as readdirSync8, readFileSync as readFileSync15, existsSync as existsSync21, writeFileSync as writeFileSync11, rmSync as rmSync5, mkdirSync as mkdirSync7 } from "fs";
+import { resolve as resolve13, join as join15 } from "path";
 import {
   DesignSystemManager as DesignSystemManager11,
   ComponentManager as ComponentManager6,
@@ -10876,7 +10672,7 @@ function listTsxFiles(dir) {
   try {
     const entries = readdirSync8(dir, { withFileTypes: true });
     for (const e of entries) {
-      const full = join16(dir, e.name);
+      const full = join15(dir, e.name);
       if (e.isDirectory() && e.name !== "node_modules" && !e.name.startsWith(".")) {
         files.push(...listTsxFiles(full));
       } else if (e.isFile() && e.name.endsWith(".tsx")) {
@@ -10905,8 +10701,8 @@ async function fixCommand(opts = {}) {
     console.log(chalk18.cyan("\ncoherent fix\n"));
   }
   if (!skipCache) {
-    const nextDir = join16(projectRoot, ".next");
-    if (existsSync22(nextDir)) {
+    const nextDir = join15(projectRoot, ".next");
+    if (existsSync21(nextDir)) {
       if (!dryRun) rmSync5(nextDir, { recursive: true, force: true });
       fixes.push("Cleared build cache");
       console.log(chalk18.green("  \u2714 Cleared build cache"));
@@ -10933,7 +10729,7 @@ async function fixCommand(opts = {}) {
   const componentsTsxFiles = listTsxFiles(resolve13(projectRoot, "components"));
   const allComponentIds = /* @__PURE__ */ new Set();
   for (const file of [...allTsxFiles, ...componentsTsxFiles]) {
-    const content = readFileSync16(file, "utf-8");
+    const content = readFileSync15(file, "utf-8");
     extractComponentIdsFromCode2(content).forEach((id) => allComponentIds.add(id));
   }
   let dsm = null;
@@ -10953,7 +10749,7 @@ async function fixCommand(opts = {}) {
       } else {
         const fileName = toKebabCase(id) + ".tsx";
         const filePath = resolve13(projectRoot, "components", "ui", fileName);
-        if (!existsSync22(filePath)) missingFiles.push(id);
+        if (!existsSync21(filePath)) missingFiles.push(id);
       }
     }
     const provider = getComponentProvider();
@@ -11005,7 +10801,7 @@ async function fixCommand(opts = {}) {
   const userTsxFiles = allTsxFiles.filter((f) => !f.includes("/design-system/"));
   let syntaxFixed = 0;
   for (const file of userTsxFiles) {
-    const content = readFileSync16(file, "utf-8");
+    const content = readFileSync15(file, "utf-8");
     const fixed = fixUnescapedLtInJsx(
       fixEscapedClosingQuotes(sanitizeMetadataStrings(ensureUseClientIfNeeded(content)))
     );
@@ -11023,7 +10819,7 @@ async function fixCommand(opts = {}) {
     let qualityFixCount = 0;
     const qualityFixDetails = [];
     for (const file of userTsxFiles) {
-      const content = readFileSync16(file, "utf-8");
+      const content = readFileSync15(file, "utf-8");
       const { code: autoFixed, fixes: fileFixes } = await autoFixCode(content);
       if (autoFixed !== content) {
         if (!dryRun) writeFileSync11(file, autoFixed, "utf-8");
@@ -11042,7 +10838,7 @@ async function fixCommand(opts = {}) {
   let totalWarnings = 0;
   const fileIssues = [];
   for (const file of allTsxFiles) {
-    const code = dryRun ? readFileSync16(file, "utf-8") : readFileSync16(file, "utf-8");
+    const code = dryRun ? readFileSync15(file, "utf-8") : readFileSync15(file, "utf-8");
     const relativePath = file.replace(projectRoot + "/", "");
     const baseName = file.split("/").pop() || "";
     const isAuthPage = relativePath.includes("(auth)");
@@ -11167,7 +10963,7 @@ async function fixCommand(opts = {}) {
 // src/commands/check.ts
 import chalk19 from "chalk";
 import { resolve as resolve14 } from "path";
-import { readdirSync as readdirSync9, readFileSync as readFileSync17, statSync as statSync3, existsSync as existsSync23 } from "fs";
+import { readdirSync as readdirSync9, readFileSync as readFileSync16, statSync as statSync3, existsSync as existsSync22 } from "fs";
 import { loadManifest as loadManifest11 } from "@getcoherent/core";
 var EXCLUDED_DIRS = /* @__PURE__ */ new Set(["node_modules", "design-system"]);
 function findTsxFiles(dir) {
@@ -11224,7 +11020,7 @@ async function checkCommand(opts = {}) {
       "NATIVE_TABLE"
     ]);
     for (const file of files) {
-      const code = readFileSync17(file, "utf-8");
+      const code = readFileSync16(file, "utf-8");
       const relativePath = file.replace(projectRoot + "/", "");
       const baseName = file.split("/").pop() || "";
       const isAuthPage = relativePath.includes("(auth)");
@@ -11266,7 +11062,7 @@ async function checkCommand(opts = {}) {
     routeSet.add("/");
     routeSet.add("#");
     for (const file of files) {
-      const code = readFileSync17(file, "utf-8");
+      const code = readFileSync16(file, "utf-8");
       const relativePath = file.replace(projectRoot + "/", "");
       const lines = code.split("\n");
       const linkHrefRe = /href\s*=\s*["'](\/[a-z0-9/-]*)["']/gi;
@@ -11299,7 +11095,7 @@ async function checkCommand(opts = {}) {
       if (manifest.shared.length > 0) {
         for (const entry of manifest.shared) {
           const fullPath = resolve14(project.root, entry.file);
-          if (!existsSync23(fullPath)) {
+          if (!existsSync22(fullPath)) {
             result.pages.withErrors++;
             if (!opts.json) console.log(chalk19.red(`
   \u2717 Missing shared component file: ${entry.id} (${entry.file})`));
@@ -11324,7 +11120,7 @@ async function checkCommand(opts = {}) {
       let _nameMismatch = 0;
       for (const entry of manifest.shared) {
         const filePath = resolve14(projectRoot, entry.file);
-        const fileExists = existsSync23(filePath);
+        const fileExists = existsSync22(filePath);
         if (!fileExists) {
           _orphaned++;
           if (!opts.json) {
@@ -11334,7 +11130,7 @@ async function checkCommand(opts = {}) {
           continue;
         }
         try {
-          const code = readFileSync17(filePath, "utf-8");
+          const code = readFileSync16(filePath, "utf-8");
           const actualExports = extractExportedComponentNames(code);
           if (actualExports.length > 0 && !actualExports.includes(entry.name)) {
             _nameMismatch++;
@@ -11402,7 +11198,7 @@ async function checkCommand(opts = {}) {
           id: e.id,
           name: e.name,
           type: e.type,
-          status: existsSync23(resolve14(projectRoot, e.file)) ? "ok" : "unused",
+          status: existsSync22(resolve14(projectRoot, e.file)) ? "ok" : "unused",
           message: "",
           suggestions: void 0
         }))
@@ -11412,15 +11208,15 @@ async function checkCommand(opts = {}) {
   }
   if (!skipShared) {
     try {
-      const { validateReuse } = await import("./reuse-validator-HC4LZEKF.js");
+      const { validateReuse } = await import("./reuse-validator-XR2ZEYC4.js");
       const { inferPageTypeFromRoute: inferPageTypeFromRoute2 } = await import("./design-constraints-EIP2XM7T.js");
       const manifest = await loadManifest11(projectRoot);
       const appDir = resolve14(projectRoot, "app");
-      const pageFiles = existsSync23(appDir) ? findTsxFiles(appDir) : [];
+      const pageFiles = existsSync22(appDir) ? findTsxFiles(appDir) : [];
       if (manifest.shared.length > 0 && pageFiles.length > 0) {
         const reuseWarnings = [];
         for (const file of pageFiles) {
-          const code = readFileSync17(file, "utf-8");
+          const code = readFileSync16(file, "utf-8");
           const relativePath = file.replace(projectRoot + "/", "");
           const route = "/" + relativePath.replace(/^app\//, "").replace(/\/page\.tsx$/, "").replace(/^\(.*?\)\//, "");
           const pageType = inferPageTypeFromRoute2(route);
@@ -11531,12 +11327,12 @@ import {
   generateSharedComponent as generateSharedComponent5,
   integrateSharedLayoutIntoRootLayout as integrateSharedLayoutIntoRootLayout3
 } from "@getcoherent/core";
-import { existsSync as existsSync24 } from "fs";
+import { existsSync as existsSync23 } from "fs";
 import { resolve as resolve15 } from "path";
 
 // src/utils/ds-files.ts
 import { mkdir as mkdir6, writeFile as writeFile6 } from "fs/promises";
-import { join as join17, dirname as dirname8 } from "path";
+import { join as join16, dirname as dirname8 } from "path";
 import { DesignSystemGenerator } from "@getcoherent/core";
 var SHARED_DS_KEYS = [
   "app/design-system/shared/page.tsx",
@@ -11550,7 +11346,7 @@ async function writeDesignSystemFiles(projectRoot, config2, options) {
   const toWrite = options?.sharedOnly ? new Map([...files].filter(([path4]) => SHARED_DS_KEYS.includes(path4))) : files;
   const written = [];
   for (const [relativePath, content] of toWrite) {
-    const fullPath = join17(projectRoot, relativePath);
+    const fullPath = join16(projectRoot, relativePath);
     await mkdir6(dirname8(fullPath), { recursive: true });
     await writeFile6(fullPath, content, "utf-8");
     written.push(relativePath);
@@ -11686,7 +11482,7 @@ function createComponentsCommand() {
       if (updated) console.log(chalk25.cyan("   Updated app/layout.tsx to use shared layout components.\n"));
     }
     const sharedPagePath = resolve15(project.root, "app/design-system/shared/page.tsx");
-    if (!existsSync24(sharedPagePath)) {
+    if (!existsSync23(sharedPagePath)) {
       try {
         const dsm = new DesignSystemManager12(project.configPath);
         await dsm.load();
@@ -11712,8 +11508,8 @@ function createComponentsCommand() {
 import chalk26 from "chalk";
 import ora6 from "ora";
 import { writeFile as writeFile7, mkdir as mkdir7 } from "fs/promises";
-import { resolve as resolve16, join as join18, dirname as dirname9 } from "path";
-import { existsSync as existsSync25 } from "fs";
+import { resolve as resolve16, join as join17, dirname as dirname9 } from "path";
+import { existsSync as existsSync24 } from "fs";
 import {
   FigmaClient,
   parseFigmaFileResponse,
@@ -11860,7 +11656,7 @@ async function importFigmaAction(urlOrKey, opts) {
       stats.filesWritten.push(filePath);
       return;
     }
-    const fullPath = join18(projectRoot, filePath);
+    const fullPath = join17(projectRoot, filePath);
     await mkdir7(dirname9(fullPath), { recursive: true });
     await writeFile7(fullPath, content, "utf-8");
     stats.filesWritten.push(filePath);
@@ -11962,7 +11758,7 @@ async function importFigmaAction(urlOrKey, opts) {
       spinner.start("Updating design-system.config.ts...");
       const configPath = resolve16(projectRoot, DESIGN_SYSTEM_CONFIG_PATH);
       const dsm = new DesignSystemManager13(configPath);
-      if (existsSync25(configPath)) {
+      if (existsSync24(configPath)) {
         await dsm.load();
         const existing = dsm.getConfig();
         dsm.updateConfig({
@@ -11991,8 +11787,8 @@ export const config = ${JSON.stringify(fullConfig, null, 2)} as const
       stats.configUpdated = true;
       spinner.succeed("design-system.config.ts updated");
       spinner.start("Ensuring root layout...");
-      const layoutPath = join18(projectRoot, "app/layout.tsx");
-      if (!existsSync25(layoutPath)) {
+      const layoutPath = join17(projectRoot, "app/layout.tsx");
+      if (!existsSync24(layoutPath)) {
         await mkdir7(dirname9(layoutPath), { recursive: true });
         await writeFile7(layoutPath, MINIMAL_ROOT_LAYOUT, "utf-8");
         stats.filesWritten.push("app/layout.tsx");
@@ -12082,8 +11878,8 @@ async function dsRegenerateCommand() {
 // src/commands/update.ts
 import chalk28 from "chalk";
 import ora8 from "ora";
-import { readFileSync as readFileSync18, existsSync as existsSync26 } from "fs";
-import { join as join19 } from "path";
+import { readFileSync as readFileSync17, existsSync as existsSync25 } from "fs";
+import { join as join18 } from "path";
 import { DesignSystemManager as DesignSystemManager15, CLI_VERSION as CLI_VERSION4 } from "@getcoherent/core";
 
 // src/utils/migrations.ts
@@ -12252,20 +12048,20 @@ var EXPECTED_CSS_VARS = [
   "--sidebar-ring"
 ];
 function checkMissingCssVars(projectRoot) {
-  const globalsPath = join19(projectRoot, "app", "globals.css");
-  if (!existsSync26(globalsPath)) return [];
+  const globalsPath = join18(projectRoot, "app", "globals.css");
+  if (!existsSync25(globalsPath)) return [];
   try {
-    const content = readFileSync18(globalsPath, "utf-8");
+    const content = readFileSync17(globalsPath, "utf-8");
     return EXPECTED_CSS_VARS.filter((v) => !content.includes(v));
   } catch {
     return [];
   }
 }
 function patchGlobalsCss(projectRoot, missingVars) {
-  const globalsPath = join19(projectRoot, "app", "globals.css");
-  if (!existsSync26(globalsPath) || missingVars.length === 0) return;
+  const globalsPath = join18(projectRoot, "app", "globals.css");
+  if (!existsSync25(globalsPath) || missingVars.length === 0) return;
   const { writeFileSync: writeFileSync14 } = __require("fs");
-  let content = readFileSync18(globalsPath, "utf-8");
+  let content = readFileSync17(globalsPath, "utf-8");
   const defaultValues = {
     "--chart-1": "220 70% 50%",
     "--chart-2": "160 60% 45%",
@@ -12343,26 +12139,26 @@ async function undoCommand(options) {
 // src/commands/sync.ts
 import chalk30 from "chalk";
 import ora9 from "ora";
-import { existsSync as existsSync27, readFileSync as readFileSync19 } from "fs";
-import { join as join20, relative as relative5, dirname as dirname10 } from "path";
-import { readdir as readdir4, readFile as readFile7 } from "fs/promises";
+import { existsSync as existsSync26, readFileSync as readFileSync18 } from "fs";
+import { join as join19, relative as relative5, dirname as dirname10 } from "path";
+import { readdir as readdir3, readFile as readFile6 } from "fs/promises";
 import { DesignSystemManager as DesignSystemManager16 } from "@getcoherent/core";
 import { loadManifest as loadManifest13, saveManifest as saveManifest6, findSharedComponent } from "@getcoherent/core";
 function extractTokensFromProject(projectRoot) {
   const lightColors = {};
   const darkColors = {};
-  const globalsPath = join20(projectRoot, "app", "globals.css");
-  if (existsSync27(globalsPath)) {
-    const css = readFileSync19(globalsPath, "utf-8");
+  const globalsPath = join19(projectRoot, "app", "globals.css");
+  if (existsSync26(globalsPath)) {
+    const css = readFileSync18(globalsPath, "utf-8");
     const rootMatch = css.match(/:root\s*\{([^}]+)\}/s);
     if (rootMatch) parseVarsInto(rootMatch[1], lightColors);
     const darkMatch = css.match(/\.dark\s*\{([^}]+)\}/s);
     if (darkMatch) parseVarsInto(darkMatch[1], darkColors);
   }
-  const layoutPath = join20(projectRoot, "app", "layout.tsx");
+  const layoutPath = join19(projectRoot, "app", "layout.tsx");
   let layoutCode = "";
-  if (existsSync27(layoutPath)) {
-    layoutCode = readFileSync19(layoutPath, "utf-8");
+  if (existsSync26(layoutPath)) {
+    layoutCode = readFileSync18(layoutPath, "utf-8");
     const rootInline = layoutCode.match(/:root\s*\{([^}]+)\}/s);
     if (rootInline && Object.keys(lightColors).length === 0) {
       parseVarsInto(rootInline[1], lightColors);
@@ -12380,7 +12176,7 @@ function extractTokensFromProject(projectRoot) {
     defaultMode = "dark";
   }
   let radius;
-  const allCss = [existsSync27(globalsPath) ? readFileSync19(globalsPath, "utf-8") : "", layoutCode].join("\n");
+  const allCss = [existsSync26(globalsPath) ? readFileSync18(globalsPath, "utf-8") : "", layoutCode].join("\n");
   const radiusMatch = allCss.match(/--radius:\s*([^;]+);/);
   if (radiusMatch) radius = radiusMatch[1].trim();
   return {
@@ -12403,13 +12199,13 @@ function parseVarsInto(block, target) {
 }
 async function detectCustomComponents(projectRoot, allPageCode) {
   const results = [];
-  const componentsDir = join20(projectRoot, "components");
-  if (!existsSync27(componentsDir)) return results;
+  const componentsDir = join19(projectRoot, "components");
+  if (!existsSync26(componentsDir)) return results;
   const files = [];
   await walkForTsx(componentsDir, files, ["ui"]);
   const fileResults = await Promise.all(
     files.map(async (filePath) => {
-      const code = await readFile7(filePath, "utf-8");
+      const code = await readFile6(filePath, "utf-8");
       const relFile = relative5(projectRoot, filePath);
       const exportedNames = extractExportedComponentNames2(code);
       return exportedNames.map((name) => ({
@@ -12426,12 +12222,12 @@ async function detectCustomComponents(projectRoot, allPageCode) {
 async function walkForTsx(dir, files, skipDirs) {
   let entries;
   try {
-    entries = await readdir4(dir, { withFileTypes: true });
+    entries = await readdir3(dir, { withFileTypes: true });
   } catch {
     return;
   }
   for (const e of entries) {
-    const full = join20(dir, e.name);
+    const full = join19(dir, e.name);
     if (e.isDirectory()) {
       if (skipDirs.includes(e.name) || e.name.startsWith(".")) continue;
       await walkForTsx(full, files, skipDirs);
@@ -12500,18 +12296,18 @@ async function discoverPages(appDir) {
   async function walk(dir) {
     let entries;
     try {
-      entries = await readdir4(dir, { withFileTypes: true });
+      entries = await readdir3(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const full = join20(dir, entry.name);
+      const full = join19(dir, entry.name);
       if (entry.isDirectory()) {
         if (["design-system", "api", "_not-found"].includes(entry.name)) continue;
         if (entry.name.startsWith(".")) continue;
         await walk(full);
       } else if (entry.name === "page.tsx" || entry.name === "page.jsx") {
-        const code = await readFile7(full, "utf-8");
+        const code = await readFile6(full, "utf-8");
         const routeDir = dirname10(relative5(appDir, full));
         let route = routeDir === "." ? "/" : "/" + routeDir;
         route = route.replace(/\/\([^)]+\)/g, "");
@@ -12594,8 +12390,8 @@ async function syncCommand(options = {}) {
   if (dryRun) console.log(chalk30.yellow("  [dry-run] No files will be written\n"));
   const spinner = ora9("Scanning project files...").start();
   try {
-    const appDir = join20(project.root, "app");
-    if (!existsSync27(appDir)) {
+    const appDir = join19(project.root, "app");
+    if (!existsSync26(appDir)) {
       spinner.fail("No app/ directory found");
       process.exit(1);
     }
@@ -12825,53 +12621,53 @@ async function syncCommand(options = {}) {
 // src/commands/migrate.ts
 import chalk31 from "chalk";
 import ora10 from "ora";
-import { existsSync as existsSync28, mkdirSync as mkdirSync8, cpSync, rmSync as rmSync6, writeFileSync as writeFileSync12, readFileSync as readFileSync20, readdirSync as readdirSync10 } from "fs";
-import { join as join21 } from "path";
+import { existsSync as existsSync27, mkdirSync as mkdirSync8, cpSync, rmSync as rmSync6, writeFileSync as writeFileSync12, readFileSync as readFileSync19, readdirSync as readdirSync10 } from "fs";
+import { join as join20 } from "path";
 function backupDir(projectRoot) {
   const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  return join21(projectRoot, ".coherent", "backups", `pre-migrate-${ts}`);
+  return join20(projectRoot, ".coherent", "backups", `pre-migrate-${ts}`);
 }
 function guardPath(projectRoot) {
-  return join21(projectRoot, ".coherent", "migration-in-progress");
+  return join20(projectRoot, ".coherent", "migration-in-progress");
 }
 function createBackup2(projectRoot) {
-  const uiDir = join21(projectRoot, "components", "ui");
+  const uiDir = join20(projectRoot, "components", "ui");
   const dest = backupDir(projectRoot);
   mkdirSync8(dest, { recursive: true });
-  if (existsSync28(uiDir)) {
-    cpSync(uiDir, join21(dest, "components-ui"), { recursive: true });
+  if (existsSync27(uiDir)) {
+    cpSync(uiDir, join20(dest, "components-ui"), { recursive: true });
   }
-  const configPath = join21(projectRoot, "design-system.config.ts");
-  if (existsSync28(configPath)) {
-    cpSync(configPath, join21(dest, "design-system.config.ts"));
+  const configPath = join20(projectRoot, "design-system.config.ts");
+  if (existsSync27(configPath)) {
+    cpSync(configPath, join20(dest, "design-system.config.ts"));
   }
   return dest;
 }
 function setGuard(projectRoot, backupPath) {
   const guard = guardPath(projectRoot);
-  mkdirSync8(join21(projectRoot, ".coherent"), { recursive: true });
+  mkdirSync8(join20(projectRoot, ".coherent"), { recursive: true });
   writeFileSync12(guard, JSON.stringify({ backup: backupPath, startedAt: (/* @__PURE__ */ new Date()).toISOString() }));
 }
 function clearGuard(projectRoot) {
   const guard = guardPath(projectRoot);
-  if (existsSync28(guard)) rmSync6(guard);
+  if (existsSync27(guard)) rmSync6(guard);
 }
 function rollback(projectRoot) {
   const guard = guardPath(projectRoot);
-  if (!existsSync28(guard)) return false;
+  if (!existsSync27(guard)) return false;
   try {
-    const data = JSON.parse(readFileSync20(guard, "utf-8"));
+    const data = JSON.parse(readFileSync19(guard, "utf-8"));
     const backup = data.backup;
-    if (!existsSync28(backup)) return false;
-    const uiBackup = join21(backup, "components-ui");
-    const uiDir = join21(projectRoot, "components", "ui");
-    if (existsSync28(uiBackup)) {
-      if (existsSync28(uiDir)) rmSync6(uiDir, { recursive: true });
+    if (!existsSync27(backup)) return false;
+    const uiBackup = join20(backup, "components-ui");
+    const uiDir = join20(projectRoot, "components", "ui");
+    if (existsSync27(uiBackup)) {
+      if (existsSync27(uiDir)) rmSync6(uiDir, { recursive: true });
       cpSync(uiBackup, uiDir, { recursive: true });
     }
-    const configBackup = join21(backup, "design-system.config.ts");
-    const configDest = join21(projectRoot, "design-system.config.ts");
-    if (existsSync28(configBackup)) {
+    const configBackup = join20(backup, "design-system.config.ts");
+    const configDest = join20(projectRoot, "design-system.config.ts");
+    if (existsSync27(configBackup)) {
       cpSync(configBackup, configDest);
     }
     clearGuard(projectRoot);
@@ -12899,13 +12695,13 @@ async function migrateAction(options) {
     return;
   }
   const guard = guardPath(projectRoot);
-  if (existsSync28(guard)) {
+  if (existsSync27(guard)) {
     console.log(chalk31.yellow("A migration is already in progress."));
     console.log(chalk31.dim("Run `coherent migrate --rollback` to undo, or delete .coherent/migration-in-progress"));
     return;
   }
-  const uiDir = join21(projectRoot, "components", "ui");
-  if (!existsSync28(uiDir)) {
+  const uiDir = join20(projectRoot, "components", "ui");
+  if (!existsSync27(uiDir)) {
     console.log(chalk31.yellow("No components/ui directory found. Nothing to migrate."));
     return;
   }
@@ -12931,8 +12727,8 @@ Found ${migratable.length} component(s) to migrate:`));
   setGuard(projectRoot, backup);
   try {
     for (const id of migratable) {
-      const filePath = join21(uiDir, `${id}.tsx`);
-      if (existsSync28(filePath)) rmSync6(filePath);
+      const filePath = join20(uiDir, `${id}.tsx`);
+      if (existsSync27(filePath)) rmSync6(filePath);
     }
     const results = await provider.installBatch(migratable, projectRoot, { force: true });
     let migrated = 0;
@@ -12954,20 +12750,20 @@ Found ${migratable.length} component(s) to migrate:`));
 }
 
 // src/utils/update-notifier.ts
-import { existsSync as existsSync29, mkdirSync as mkdirSync9, readFileSync as readFileSync21, writeFileSync as writeFileSync13 } from "fs";
-import { join as join22 } from "path";
+import { existsSync as existsSync28, mkdirSync as mkdirSync9, readFileSync as readFileSync20, writeFileSync as writeFileSync13 } from "fs";
+import { join as join21 } from "path";
 import { homedir } from "os";
 import chalk32 from "chalk";
 import { CLI_VERSION as CLI_VERSION5 } from "@getcoherent/core";
 var DEBUG5 = process.env.COHERENT_DEBUG === "1";
 var PACKAGE_NAME = "@getcoherent/cli";
-var CACHE_DIR = join22(homedir(), ".coherent");
-var CACHE_FILE = join22(CACHE_DIR, "update-check.json");
+var CACHE_DIR = join21(homedir(), ".coherent");
+var CACHE_FILE = join21(CACHE_DIR, "update-check.json");
 var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
 function readCache() {
   try {
-    if (!existsSync29(CACHE_FILE)) return null;
-    const raw = readFileSync21(CACHE_FILE, "utf-8");
+    if (!existsSync28(CACHE_FILE)) return null;
+    const raw = readFileSync20(CACHE_FILE, "utf-8");
     return JSON.parse(raw);
   } catch (e) {
     if (DEBUG5) console.error("Failed to read update cache:", e);
@@ -12976,7 +12772,7 @@ function readCache() {
 }
 function writeCache(data) {
   try {
-    if (!existsSync29(CACHE_DIR)) mkdirSync9(CACHE_DIR, { recursive: true });
+    if (!existsSync28(CACHE_DIR)) mkdirSync9(CACHE_DIR, { recursive: true });
     writeFileSync13(CACHE_FILE, JSON.stringify(data), "utf-8");
   } catch (e) {
     if (DEBUG5) console.error("Failed to write update cache:", e);