@nuvio/cli 0.5.5 → 1.1.0

package/dist/cli-entry.js

@@ -1,10 +1,25 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { resolve } from "path";
+import { resolve as resolve4 } from "path";
 
-// src/init.ts
-import { createInterface } from "readline";
+// src/brand-apply.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { join as join2, resolve } from "path";
+import { applyPatchToSource } from "@nuvio/ast-engine";
+import {
+  buildBrandPatchOps,
+  brandFragmentHostHint,
+  DEFAULT_BRAND_CONFIG,
+  isHostPatchable,
+  isPccBrandableCategory,
+  normalizeBrandConfig
+} from "@nuvio/shared";
+import {
+  listPccManifestFiles,
+  loadPccManifestFromFile,
+  resolvePccManifestPath
+} from "@nuvio/shared/load-pcc-manifest";
 
 // src/detect-project.ts
 import { existsSync, readFileSync } from "fs";
@@ -104,283 +119,957 @@ function detectProject(root) {
   };
 }
 
-// src/detect-pm.ts
-import { existsSync as existsSync2 } from "fs";
-import { join as join2 } from "path";
-function detectPackageManager(root, override) {
-  if (override) return override;
-  if (existsSync2(join2(root, "pnpm-lock.yaml"))) return "pnpm";
-  if (existsSync2(join2(root, "package-lock.json"))) return "npm";
-  if (existsSync2(join2(root, "yarn.lock"))) return "yarn";
-  if (existsSync2(join2(root, "bun.lockb")) || existsSync2(join2(root, "bun.lock")))
-    return "bun";
-  return "npm";
-}
-function installCommand(pm, version) {
-  const pkgs = `@nuvio/vite-plugin@${version} @nuvio/overlay@${version}`;
-  switch (pm) {
-    case "pnpm":
-      return `pnpm add -D ${pkgs}`;
-    case "yarn":
-      return `yarn add -D ${pkgs}`;
-    case "bun":
-      return `bun add -d ${pkgs}`;
-    default:
-      return `npm install -D ${pkgs}`;
+// src/project-scan.ts
+import { relative } from "path";
+import {
+  buildSourceIndex,
+  detectProjectLibraries,
+  NUVIO_DEFAULT_SCAN_GLOBS
+} from "@nuvio/vite-plugin/scan";
+var SCAN_GLOBS = [...NUVIO_DEFAULT_SCAN_GLOBS, "app/**/*.{tsx,jsx}"];
+function scanProject(root) {
+  const ctx = detectProject(root);
+  const detectedLibraries = detectProjectLibraries(root, ctx.packageJson);
+  const index = buildSourceIndex(root, SCAN_GLOBS, { detectedLibraries });
+  return { ctx, detectedLibraries, index };
+}
+function relPath(root, fileAbs) {
+  return relative(root, fileAbs).replace(/\\/g, "/");
+}
+function isTableHost(entry) {
+  return entry.hierarchyRole === "table" || entry.id.endsWith(".table") || entry.id.includes(".header.") || /\.row\./.test(entry.id);
+}
+function aggregateClassNameModes(entries) {
+  const counts = {};
+  for (const entry of entries) {
+    const mode = entry.classNameMode ?? "literal-only";
+    counts[mode] = (counts[mode] ?? 0) + 1;
   }
+  return counts;
 }
 
-// src/install-packages.ts
-import { spawnSync } from "child_process";
-import { readFileSync as readFileSync2 } from "fs";
-function parseInstalledVersion(pkg, name) {
-  const dev = pkg.devDependencies;
-  const deps = pkg.dependencies;
-  const raw = dev?.[name] ?? deps?.[name];
-  if (!raw) return null;
-  return raw.replace(/^[\^~]/, "");
-}
-function packagesNeedInstall(packageJsonPath, targetVersion) {
-  const pkg = JSON.parse(readFileSync2(packageJsonPath, "utf8"));
-  for (const name of ["@nuvio/vite-plugin", "@nuvio/overlay"]) {
-    const v = parseInstalledVersion(pkg, name);
-    if (v !== targetVersion) return true;
+// src/brand-apply.ts
+var BRAND_RELATIVE = "nuvio/brand.json";
+function readProjectBrandConfig(cwd) {
+  const filePath = join2(resolve(cwd), BRAND_RELATIVE);
+  if (!existsSync2(filePath)) {
+    return { ...DEFAULT_BRAND_CONFIG };
   }
-  return false;
-}
-function runInstall(root, pm, version) {
-  const cmd = installCommand(pm, version);
-  const result = spawnSync(cmd, {
-    cwd: root,
-    shell: true,
-    stdio: "inherit",
-    env: process.env
-  });
-  if (result.status !== 0) {
-    return {
-      ok: false,
-      message: `Install failed. Try manually:
-  ${cmd}`
-    };
+  try {
+    const raw = readFileSync2(filePath, "utf8");
+    return normalizeBrandConfig(JSON.parse(raw));
+  } catch {
+    return { ...DEFAULT_BRAND_CONFIG };
   }
-  return { ok: true };
-}
-
-// src/babel-traverse.ts
-import traverseImport from "@babel/traverse";
-var traverse = typeof traverseImport === "function" ? traverseImport : traverseImport.default;
-var babel_traverse_default = traverse;
-
-// src/patch-vite-config.ts
-import * as t from "@babel/types";
-import { readFileSync as readFileSync3, writeFileSync } from "fs";
-
-// src/babel-generator.ts
-import generateImport from "@babel/generator";
-var generate = typeof generateImport === "function" ? generateImport : generateImport.default;
-var babel_generator_default = generate;
-
-// src/parse-ts.ts
-import { parse } from "@babel/parser";
-var PARSE_OPTS = {
-  sourceType: "module",
-  plugins: ["typescript", "jsx"]
-};
-function parseTs(source, filename = "file.tsx") {
-  return parse(source, {
-    ...PARSE_OPTS,
-    sourceFilename: filename
-  });
 }
-function printTs(ast, source) {
-  const out = babel_generator_default(ast, { retainLines: true }, source);
-  return out.code.endsWith("\n") ? out.code : `${out.code}
-`;
+function duplicateIdSet(errors) {
+  return new Set(errors.map((error) => error.id));
 }
-
-// src/patch-vite-config.ts
-function hasNuvioImport(ast) {
-  let found = false;
-  babel_traverse_default(ast, {
-    ImportDeclaration(path) {
-      if (path.node.source.value === "@nuvio/vite-plugin") found = true;
+function collectApplyTargets(manifest, entries, duplicateIds) {
+  const byId = new Map(entries.map((entry) => [entry.id, entry]));
+  const targets = [];
+  let skipped = 0;
+  for (const category of Object.keys(manifest.categories)) {
+    if (!isPccBrandableCategory(category)) {
+      continue;
     }
-  });
-  return found;
-}
-function hasNuvioPluginCall(ast) {
-  let found = false;
-  babel_traverse_default(ast, {
-    CallExpression(path) {
-      if (t.isIdentifier(path.node.callee, { name: "nuvio" })) found = true;
+    const config = manifest.categories[category];
+    if (!config) {
+      continue;
     }
-  });
-  return found;
-}
-var OVERLAY_DEP = "@nuvio/overlay";
-function excludeListsOverlay(expr) {
-  if (!expr || !t.isArrayExpression(expr)) return false;
-  return expr.elements.some(
-    (el) => t.isStringLiteral(el) && el.value === OVERLAY_DEP
-  );
-}
-function ensureOptimizeDepsExclude(ast) {
-  let patched = false;
-  babel_traverse_default(ast, {
-    CallExpression(path) {
-      const callee = path.node.callee;
-      if (!t.isIdentifier(callee, { name: "defineConfig" })) return;
-      const arg = path.node.arguments[0];
-      if (!t.isObjectExpression(arg)) return;
-      let optimizeDeps;
-      for (const prop of arg.properties) {
-        if (t.isObjectProperty(prop) && t.isIdentifier(prop.key, { name: "optimizeDeps" })) {
-          optimizeDeps = prop;
-          break;
-        }
-      }
-      if (!optimizeDeps) {
-        arg.properties.push(
-          t.objectProperty(
-            t.identifier("optimizeDeps"),
-            t.objectExpression([
-              t.objectProperty(
-                t.identifier("exclude"),
-                t.arrayExpression([t.stringLiteral(OVERLAY_DEP)])
-              )
-            ])
-          )
-        );
-        patched = true;
-        return;
+    for (const hostId of config.hosts) {
+      const entry = byId.get(hostId);
+      if (!entry) {
+        skipped += 1;
+        continue;
       }
-      if (!t.isObjectExpression(optimizeDeps.value)) return;
-      let excludeProp;
-      for (const p of optimizeDeps.value.properties) {
-        if (t.isObjectProperty(p) && t.isIdentifier(p.key, { name: "exclude" })) {
-          excludeProp = p;
-          break;
-        }
+      const patch = isHostPatchable(entry, duplicateIds);
+      if (!patch.patchable) {
+        skipped += 1;
+        continue;
       }
-      if (!excludeProp) {
-        optimizeDeps.value.properties.push(
-          t.objectProperty(
-            t.identifier("exclude"),
-            t.arrayExpression([t.stringLiteral(OVERLAY_DEP)])
-          )
-        );
-        patched = true;
-        return;
+      targets.push({
+        hostId,
+        category,
+        action: category,
+        entry
+      });
+    }
+  }
+  return { targets, skipped };
+}
+async function applyTargetsToProject(projectRoot, targets, brand, dryRun) {
+  const root = resolve(projectRoot);
+  const byFile = /* @__PURE__ */ new Map();
+  for (const target of targets) {
+    const filePath = resolve(root, target.entry.file);
+    const list = byFile.get(filePath) ?? [];
+    list.push(target);
+    byFile.set(filePath, list);
+  }
+  let applied = 0;
+  const failed = [];
+  for (const [filePath, fileTargets] of byFile) {
+    if (!existsSync2(filePath)) {
+      for (const target of fileTargets) {
+        failed.push({ hostId: target.hostId, reason: "file_missing" });
       }
-      if (t.isArrayExpression(excludeProp.value) && !excludeListsOverlay(excludeProp.value)) {
-        excludeProp.value.elements.push(t.stringLiteral(OVERLAY_DEP));
-        patched = true;
+      continue;
+    }
+    if (dryRun) {
+      applied += fileTargets.length;
+      continue;
+    }
+    let source = readFileSync2(filePath, "utf8");
+    for (const target of fileTargets) {
+      const ops = buildBrandPatchOps(
+        target.action,
+        brand,
+        brandFragmentHostHint(target.entry)
+      );
+      const result = await applyPatchToSource(source, filePath, target.hostId, ops, {
+        classNameMode: target.entry.classNameMode
+      });
+      if (!result.ok) {
+        failed.push({ hostId: target.hostId, reason: result.message ?? result.code });
+        continue;
       }
+      source = result.source;
+      applied += 1;
     }
-  });
-  return patched;
-}
-function viteConfigHasOverlayOptimizeExclude(filePath) {
-  const source = readFileSync3(filePath, "utf8");
-  return /optimizeDeps\s*:\s*\{[^}]*exclude\s*:\s*\[[^\]]*@nuvio\/overlay/.test(
-    source
-  ) || /exclude\s*:\s*\[[^\]]*["']@nuvio\/overlay["']/.test(source);
-}
-function appendNuvioPlugin(ast) {
-  let patched = false;
-  babel_traverse_default(ast, {
-    ObjectProperty(path) {
-      if (!t.isIdentifier(path.node.key, { name: "plugins" })) return;
-      if (!t.isArrayExpression(path.node.value)) return;
-      path.node.value.elements.push(t.callExpression(t.identifier("nuvio"), []));
-      patched = true;
+    writeFileSync(filePath, source, "utf8");
+  }
+  return { applied, failed };
+}
+function printHumanReport(result) {
+  console.log(`Page: ${result.page}`);
+  console.log(`Route: ${result.route}`);
+  console.log(`Manifest: ${result.manifestPath}`);
+  console.log(`Applied: ${result.applied}`);
+  console.log(`Skipped: ${result.skipped}`);
+  if (result.failed.length > 0) {
+    console.log("Failed:");
+    for (const failure of result.failed) {
+      console.log(`- ${failure.hostId}: ${failure.reason}`);
     }
-  });
-  return patched;
+  }
 }
-function patchViteConfigFile(filePath) {
-  const source = readFileSync3(filePath, "utf8");
-  let ast;
-  try {
-    ast = parseTs(source, filePath);
-  } catch {
-    return { ok: false, error: "parse failed" };
+async function applyLoadedManifest(manifestPath, manifest, entries, duplicateIds, brand, projectRoot, opts) {
+  const { targets, skipped } = collectApplyTargets(manifest, entries, duplicateIds);
+  const { applied, failed } = await applyTargetsToProject(
+    projectRoot,
+    targets,
+    brand,
+    opts.dryRun === true
+  );
+  return {
+    page: manifest.page,
+    route: manifest.route,
+    manifestPath,
+    applied,
+    skipped,
+    failed
+  };
+}
+async function runBrandApplyAll(opts) {
+  const manifestPaths = listPccManifestFiles(opts.cwd);
+  if (manifestPaths.length === 0) {
+    console.error(`No PCC manifests found under ${resolve(opts.cwd)}/nuvio/pages`);
+    return 2;
   }
-  const depsPatched = ensureOptimizeDepsExclude(ast);
-  const alreadyPlugin = hasNuvioImport(ast) && hasNuvioPluginCall(ast);
-  if (alreadyPlugin && !depsPatched) {
-    return { ok: true, skipped: true };
+  const brand = readProjectBrandConfig(opts.cwd);
+  let scan;
+  try {
+    scan = scanProject(opts.cwd);
+  } catch (e) {
+    if (e instanceof PreflightError) {
+      console.error(e.message);
+      return 3;
+    }
+    throw e;
   }
-  if (!hasNuvioImport(ast)) {
-    ast.program.body.unshift(
-      t.importDeclaration(
-        [t.importSpecifier(t.identifier("nuvio"), t.identifier("nuvio"))],
-        t.stringLiteral("@nuvio/vite-plugin")
+  const duplicateIds = duplicateIdSet(scan.index.duplicateErrors);
+  const pages = [];
+  for (const manifestPath of manifestPaths) {
+    const loaded = loadPccManifestFromFile(manifestPath);
+    if (!loaded.ok) {
+      console.error(`Invalid PCC manifest (${manifestPath}): ${loaded.error.message}`);
+      return 2;
+    }
+    pages.push(
+      await applyLoadedManifest(
+        manifestPath,
+        loaded.manifest,
+        scan.index.entries,
+        duplicateIds,
+        brand,
+        scan.ctx.root,
+        opts
       )
     );
   }
-  if (!hasNuvioPluginCall(ast)) {
-    if (!appendNuvioPlugin(ast)) {
-      return { ok: false, error: "no static plugins array" };
-    }
+  const pass = pages.every((page) => page.failed.length === 0);
+  if (opts.json) {
+    console.log(JSON.stringify({ pass, dryRun: opts.dryRun === true, pages }, null, 2));
+    return pass ? 0 : 1;
   }
-  writeFileSync(filePath, printTs(ast, source), "utf8");
-  return { ok: true, skipped: alreadyPlugin && depsPatched };
+  console.log(`Nuvio Brand Apply${opts.dryRun ? " (dry run)" : ""}
+`);
+  for (const page of pages) {
+    printHumanReport(page);
+    console.log("");
+  }
+  console.log(`Result: ${pass ? "PASS" : "FAIL"}`);
+  return pass ? 0 : 1;
 }
-function viteConfigHasNuvio(filePath) {
-  const source = readFileSync3(filePath, "utf8");
+async function runBrandApply(opts) {
+  if (opts.all) {
+    return runBrandApplyAll(opts);
+  }
+  let manifestPath;
   try {
-    const ast = parseTs(source, filePath);
-    return hasNuvioImport(ast) && hasNuvioPluginCall(ast);
-  } catch {
-    return /nuvio\s*\(/.test(source);
+    manifestPath = resolve(
+      resolvePccManifestPath(opts.cwd, { page: opts.page, manifest: opts.manifest })
+    );
+  } catch (e) {
+    console.error(e instanceof Error ? e.message : String(e));
+    return 2;
   }
+  const loaded = loadPccManifestFromFile(manifestPath);
+  if (!loaded.ok) {
+    console.error(`Invalid PCC manifest (${manifestPath}): ${loaded.error.message}`);
+    return 2;
+  }
+  const brand = readProjectBrandConfig(opts.cwd);
+  let scan;
+  try {
+    scan = scanProject(opts.cwd);
+  } catch (e) {
+    if (e instanceof PreflightError) {
+      console.error(e.message);
+      return 3;
+    }
+    throw e;
+  }
+  const duplicateIds = duplicateIdSet(scan.index.duplicateErrors);
+  const result = await applyLoadedManifest(
+    manifestPath,
+    loaded.manifest,
+    scan.index.entries,
+    duplicateIds,
+    brand,
+    scan.ctx.root,
+    opts
+  );
+  const pass = result.failed.length === 0;
+  if (opts.json) {
+    console.log(JSON.stringify({ pass, dryRun: opts.dryRun === true, ...result }, null, 2));
+    return pass ? 0 : 1;
+  }
+  console.log(`Nuvio Brand Apply${opts.dryRun ? " (dry run)" : ""}
+`);
+  printHumanReport(result);
+  console.log(`
+Result: ${pass ? "PASS" : "FAIL"}`);
+  return pass ? 0 : 1;
 }
 
-// src/patch-app-root.ts
-import * as t2 from "@babel/types";
-import { existsSync as existsSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "fs";
-import { join as join3 } from "path";
-var APP_CANDIDATES = [
-  "src/App.tsx",
-  "src/App.jsx",
-  "src/main.tsx",
-  "src/main.jsx"
-];
-function resolveAppFile(root) {
-  for (const rel of APP_CANDIDATES) {
-    const p = join3(root, rel);
-    if (existsSync3(p)) return p;
+// src/brand-scan.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { join as join3, resolve as resolve2 } from "path";
+import {
+  DEFAULT_BRAND_CONFIG as DEFAULT_BRAND_CONFIG2,
+  evaluateBrandPageScan,
+  getBrandColorLabel,
+  getBrandDensityLabel,
+  getBrandRadiusLabel,
+  getBrandTypographyLabel,
+  normalizeBrandConfig as normalizeBrandConfig2,
+  pccCategoryLabel
+} from "@nuvio/shared";
+import {
+  listPccManifestFiles as listPccManifestFiles2,
+  loadPccManifestFromFile as loadPccManifestFromFile2,
+  resolvePccManifestPath as resolvePccManifestPath2
+} from "@nuvio/shared/load-pcc-manifest";
+var BRAND_RELATIVE2 = "nuvio/brand.json";
+function readProjectBrandConfig2(cwd) {
+  const filePath = join3(resolve2(cwd), BRAND_RELATIVE2);
+  if (!existsSync3(filePath)) {
+    return { ...DEFAULT_BRAND_CONFIG2 };
+  }
+  try {
+    const raw = readFileSync3(filePath, "utf8");
+    return normalizeBrandConfig2(JSON.parse(raw));
+  } catch {
+    return { ...DEFAULT_BRAND_CONFIG2 };
   }
-  return null;
 }
-function hasOverlayImport(ast) {
-  let found = false;
-  babel_traverse_default(ast, {
-    ImportDeclaration(path) {
-      if (path.node.source.value === "@nuvio/overlay") found = true;
+function formatBrandSummary(brand) {
+  return [
+    getBrandColorLabel(brand.color),
+    getBrandRadiusLabel(brand.radius),
+    getBrandDensityLabel(brand.density),
+    getBrandTypographyLabel(brand.typography)
+  ].join(" \xB7 ");
+}
+function printHumanReport2(result, manifestPath) {
+  console.log("Nuvio Brand Scan\n");
+  console.log(`Page: ${result.page}`);
+  console.log(`Route: ${result.route}`);
+  console.log(`Manifest: ${manifestPath}`);
+  console.log(`Saved brand: ${formatBrandSummary(result.brand)}
+`);
+  console.log("Category summary:");
+  for (const category of result.categories) {
+    const label = pccCategoryLabel(category.category).padEnd(10);
+    const status = category.pass ? "PASS" : "FAIL";
+    console.log(
+      `${label} ${status} on-brand ${category.onBrand}/${category.expected} \xB7 off-brand ${category.offBrand} \xB7 no-traits ${category.noTraits}`
+    );
+  }
+  console.log("\nTotals:");
+  console.log(`On-brand    ${result.onBrandCount}`);
+  console.log(`Off-brand   ${result.offBrandCount}`);
+  console.log(`No traits   ${result.noTraitsCount}`);
+  console.log(`Missing     ${result.missingCount}`);
+  const offBrandHosts = result.hosts.filter((host) => host.status === "off_brand");
+  if (offBrandHosts.length > 0) {
+    console.log("\nOff-brand hosts:");
+    for (const host of offBrandHosts.slice(0, 12)) {
+      const headline = host.inspect?.headline ?? "Off-brand";
+      console.log(`- ${host.hostId} (${host.category}) \u2014 ${headline}`);
     }
-  });
-  return found;
-}
-function hasDevShell(ast) {
-  let found = false;
-  babel_traverse_default(ast, {
-    JSXElement(path) {
-      const name = path.node.openingElement.name;
-      if (t2.isJSXIdentifier(name) && name.name === "NuvioDevShell") found = true;
+    if (offBrandHosts.length > 12) {
+      console.log(`\u2026and ${offBrandHosts.length - 12} more`);
     }
-  });
-  return found;
-}
-function unwrapJsx(node) {
-  if (!node) return null;
-  if (t2.isJSXElement(node) || t2.isJSXFragment(node)) return node;
-  if (t2.isParenthesizedExpression(node)) return unwrapJsx(node.expression);
+  }
+  console.log(`
+Result: ${result.pass ? "PASS" : "FAIL"}`);
+}
+function printAllHumanReport(pages) {
+  console.log("Nuvio Brand Scan (all pages)\n");
+  for (const page of pages) {
+    const status = page.result.pass ? "PASS" : "FAIL";
+    const summary = `${page.result.onBrandCount} on-brand \xB7 ${page.result.offBrandCount} off-brand`;
+    console.log(`${page.result.page.padEnd(16)} ${status}  ${summary}`);
+  }
+  const pass = pages.every((page) => page.result.pass);
+  console.log(`
+Result: ${pass ? "PASS" : "FAIL"}`);
+}
+function scanLoadedManifest(manifestPath, entries, brand) {
+  const loaded = loadPccManifestFromFile2(manifestPath);
+  if (!loaded.ok) {
+    return {
+      ok: false,
+      code: 2,
+      message: `Invalid PCC manifest (${manifestPath}): ${loaded.error.message}`
+    };
+  }
+  return {
+    ok: true,
+    result: evaluateBrandPageScan(loaded.manifest, entries, brand)
+  };
+}
+function runBrandScanAll(opts) {
+  const manifestPaths = listPccManifestFiles2(opts.cwd);
+  if (manifestPaths.length === 0) {
+    console.error(`No PCC manifests found under ${resolve2(opts.cwd)}/nuvio/pages`);
+    return 2;
+  }
+  const brand = readProjectBrandConfig2(opts.cwd);
+  let scan;
+  try {
+    scan = scanProject(opts.cwd);
+  } catch (e) {
+    if (e instanceof PreflightError) {
+      console.error(e.message);
+      return 3;
+    }
+    throw e;
+  }
+  const pages = [];
+  for (const manifestPath of manifestPaths) {
+    const scanned = scanLoadedManifest(manifestPath, scan.index.entries, brand);
+    if (!scanned.ok) {
+      console.error(scanned.message);
+      return scanned.code;
+    }
+    pages.push({ manifestPath, result: scanned.result });
+  }
+  const pass = pages.every((page) => page.result.pass);
+  if (opts.json) {
+    console.log(JSON.stringify({ pass, brand, pages }, null, 2));
+    return pass ? 0 : 1;
+  }
+  printAllHumanReport(pages);
+  return pass ? 0 : 1;
+}
+function runBrandScan(opts) {
+  if (opts.all) {
+    return runBrandScanAll(opts);
+  }
+  let manifestPath;
+  try {
+    manifestPath = resolve2(
+      resolvePccManifestPath2(opts.cwd, { page: opts.page, manifest: opts.manifest })
+    );
+  } catch (e) {
+    console.error(e instanceof Error ? e.message : String(e));
+    return 2;
+  }
+  const brand = readProjectBrandConfig2(opts.cwd);
+  let scan;
+  try {
+    scan = scanProject(opts.cwd);
+  } catch (e) {
+    if (e instanceof PreflightError) {
+      console.error(e.message);
+      return 3;
+    }
+    throw e;
+  }
+  const scanned = scanLoadedManifest(manifestPath, scan.index.entries, brand);
+  if (!scanned.ok) {
+    console.error(scanned.message);
+    return scanned.code;
+  }
+  if (opts.json) {
+    console.log(
+      JSON.stringify(
+        {
+          manifestPath,
+          ...scanned.result
+        },
+        null,
+        2
+      )
+    );
+    return scanned.result.pass ? 0 : 1;
+  }
+  printHumanReport2(scanned.result, manifestPath);
+  return scanned.result.pass ? 0 : 1;
+}
+
+// src/coverage-verify.ts
+import { resolve as resolve3 } from "path";
+import {
+  evaluatePageCoverage,
+  pccCategoryLabel as pccCategoryLabel2
+} from "@nuvio/shared";
+import {
+  listPccManifestFiles as listPccManifestFiles3,
+  loadPccManifestFromFile as loadPccManifestFromFile3,
+  resolvePccManifestPath as resolvePccManifestPath3
+} from "@nuvio/shared/load-pcc-manifest";
+function formatCategoryLine(summary) {
+  const label = pccCategoryLabel2(summary.category).padEnd(10);
+  const status = summary.pass ? "PASS" : "FAIL";
+  return `${label} ${status} ${summary.indexed}/${summary.expected}`;
+}
+function printHumanReport3(result, manifestPath) {
+  console.log("Nuvio Coverage Report\n");
+  console.log(`Page: ${result.page}`);
+  console.log(`Route: ${result.route}`);
+  console.log(`Manifest: ${manifestPath}
+`);
+  console.log("Category summary:");
+  for (const category of result.categories) {
+    console.log(formatCategoryLine(category));
+  }
+  console.log("\nCoverage gates:");
+  const g = result.gates;
+  console.log(`Indexed      ${g.indexed}/${g.expected}`);
+  console.log(`Patchable    ${g.patchable}/${g.expected}`);
+  console.log(`Categorized  ${g.categorized}/${g.expected}`);
+  console.log(`Editable     ${g.editable}/${g.expected}`);
+  console.log(`Brandable    ${g.brandable}/${g.expected}`);
+  console.log("\nBrandability:");
+  console.log(`Brandable      ${result.brandableCount}`);
+  console.log(`Editable-only  ${result.editableOnlyCount}`);
+  const missing = result.issues.filter((i) => i.kind === "missing");
+  const unpatchable = result.issues.filter((i) => i.kind === "unpatchable");
+  const duplicates = result.issues.filter((i) => i.kind === "duplicate_id");
+  if (missing.length > 0) {
+    console.log("\nMissing hosts:");
+    for (const issue of missing) {
+      console.log(`- ${issue.hostId} (${issue.category})`);
+    }
+  }
+  if (unpatchable.length > 0) {
+    console.log("\nUnpatchable hosts:");
+    for (const issue of unpatchable) {
+      console.log(`- ${issue.hostId}`);
+      if (issue.reason) {
+        console.log(`  reason: ${issue.reason}`);
+      }
+    }
+  }
+  if (duplicates.length > 0) {
+    console.log("\nDuplicate id hosts:");
+    for (const issue of duplicates) {
+      console.log(`- ${issue.hostId}`);
+    }
+  }
+  console.log(`
+Result: ${result.pass ? "PASS" : "FAIL"}`);
+}
+function printAllHumanReport2(summary) {
+  console.log("Nuvio Coverage Report (all pages)\n");
+  for (const entry of summary.pages) {
+    const status = entry.result.pass ? "PASS" : "FAIL";
+    console.log(`${entry.result.page.padEnd(16)} ${status}  ${entry.manifestPath}`);
+  }
+  console.log(`
+Result: ${summary.pass ? "PASS" : "FAIL"}`);
+}
+function verifyLoadedManifest(manifestPath, entries, duplicateErrors) {
+  const loaded = loadPccManifestFromFile3(manifestPath);
+  if (!loaded.ok) {
+    return {
+      ok: false,
+      code: 2,
+      message: `Invalid PCC manifest (${manifestPath}): ${loaded.error.message}`
+    };
+  }
+  const result = evaluatePageCoverage(loaded.manifest, entries, duplicateErrors);
+  return { ok: true, result };
+}
+function runCoverageVerifyAll(opts) {
+  const manifestPaths = listPccManifestFiles3(opts.cwd);
+  if (manifestPaths.length === 0) {
+    console.error(`No PCC manifests found under ${resolve3(opts.cwd)}/nuvio/pages`);
+    return 2;
+  }
+  let scan;
+  try {
+    scan = scanProject(opts.cwd);
+  } catch (e) {
+    if (e instanceof PreflightError) {
+      console.error(e.message);
+      return 3;
+    }
+    throw e;
+  }
+  const pages = [];
+  for (const manifestPath of manifestPaths) {
+    const verified = verifyLoadedManifest(
+      manifestPath,
+      scan.index.entries,
+      scan.index.duplicateErrors
+    );
+    if (!verified.ok) {
+      console.error(verified.message);
+      return verified.code;
+    }
+    pages.push({ manifestPath, result: verified.result });
+  }
+  const summary = {
+    pass: pages.every((page) => page.result.pass),
+    pages
+  };
+  if (opts.json) {
+    console.log(JSON.stringify(summary, null, 2));
+    return summary.pass ? 0 : 1;
+  }
+  printAllHumanReport2(summary);
+  return summary.pass ? 0 : 1;
+}
+function runCoverageVerify(opts) {
+  if (opts.all) {
+    return runCoverageVerifyAll(opts);
+  }
+  let manifestPath;
+  try {
+    manifestPath = resolve3(
+      resolvePccManifestPath3(opts.cwd, { page: opts.page, manifest: opts.manifest })
+    );
+  } catch (e) {
+    console.error(e instanceof Error ? e.message : String(e));
+    return 2;
+  }
+  let scan;
+  try {
+    scan = scanProject(opts.cwd);
+  } catch (e) {
+    if (e instanceof PreflightError) {
+      console.error(e.message);
+      return 3;
+    }
+    throw e;
+  }
+  const verified = verifyLoadedManifest(
+    manifestPath,
+    scan.index.entries,
+    scan.index.duplicateErrors
+  );
+  if (!verified.ok) {
+    console.error(verified.message);
+    return verified.code;
+  }
+  if (opts.json) {
+    console.log(
+      JSON.stringify(
+        {
+          manifestPath,
+          ...verified.result
+        },
+        null,
+        2
+      )
+    );
+    return verified.result.pass ? 0 : 1;
+  }
+  printHumanReport3(verified.result, manifestPath);
+  return verified.result.pass ? 0 : 1;
+}
+
+// src/detect-pm.ts
+import { existsSync as existsSync4 } from "fs";
+import { join as join4 } from "path";
+function detectPackageManager(root, override) {
+  if (override) return override;
+  if (existsSync4(join4(root, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync4(join4(root, "package-lock.json"))) return "npm";
+  if (existsSync4(join4(root, "yarn.lock"))) return "yarn";
+  if (existsSync4(join4(root, "bun.lockb")) || existsSync4(join4(root, "bun.lock")))
+    return "bun";
+  return "npm";
+}
+function installCommand(pm, version) {
+  const pkgs = `@nuvio/vite-plugin@${version} @nuvio/overlay@${version}`;
+  switch (pm) {
+    case "pnpm":
+      return `pnpm add -D ${pkgs}`;
+    case "yarn":
+      return `yarn add -D ${pkgs}`;
+    case "bun":
+      return `bun add -d ${pkgs}`;
+    default:
+      return `npm install -D ${pkgs}`;
+  }
+}
+
+// src/nuvio-deps.ts
+import { readFileSync as readFileSync4 } from "fs";
+function readPackageJson(packageJsonPath) {
+  return JSON.parse(readFileSync4(packageJsonPath, "utf8"));
+}
+function getDependencyVersion(pkg, name) {
+  const deps = pkg.dependencies;
+  const devDeps = pkg.devDependencies;
+  return deps?.[name] ?? devDeps?.[name];
+}
+function hasNuvioDependency(pkg, name) {
+  return Boolean(getDependencyVersion(pkg, name));
+}
+function hasNuvioPackages(pkg) {
+  return hasNuvioDependency(pkg, "@nuvio/vite-plugin") && hasNuvioDependency(pkg, "@nuvio/overlay");
+}
+function isWorkspaceLinkedVersion(version) {
+  if (!version) return false;
+  return version.startsWith("workspace:") || version.startsWith("link:") || version.startsWith("file:");
+}
+function nuvioOverlayLinkKind(pkg) {
+  const raw = getDependencyVersion(pkg, "@nuvio/overlay");
+  if (!raw) return "missing";
+  return isWorkspaceLinkedVersion(raw) ? "workspace" : "npm";
+}
+
+// src/telemetry.ts
+import { mkdirSync, readFileSync as readFileSync5, writeFileSync as writeFileSync2 } from "fs";
+import { homedir } from "os";
+import { join as join5 } from "path";
+import { randomUUID } from "crypto";
+import os from "os";
+import { PostHog } from "posthog-node";
+
+// src/nuvio-posthog-token.ts
+var NUVIO_POSTHOG_TOKEN = "phc_CJnWrLU4hB4aA88DJrPnma2WBMQqVHxUMVvrsye3R6x2";
+
+// src/version.ts
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+var NUVIO_VERSION = require2("../package.json").version;
+
+// src/telemetry.ts
+var POSTHOG_HOST = "https://us.i.posthog.com";
+function telemetryFilePath() {
+  return join5(homedir(), ".nuvio", "telemetry.json");
+}
+var FORBIDDEN_PROP_KEYS = /* @__PURE__ */ new Set([
+  "cwd",
+  "root",
+  "file",
+  "path",
+  "name",
+  "message",
+  "stack"
+]);
+var SHUTDOWN_TIMEOUT_MS = 3e3;
+var client = null;
+var sessionAnonymousId = null;
+var shutdownDone = false;
+var signalHandlersRegistered = false;
+function telemetryDebug(message, detail) {
+  if (process.env.NUVIO_TELEMETRY_DEBUG !== "1") return;
+  if (detail !== void 0) {
+    console.error(`[nuvio telemetry] ${message}`, detail);
+    return;
+  }
+  console.error(`[nuvio telemetry] ${message}`);
+}
+function isTelemetryEnabled() {
+  const flag = process.env.NUVIO_TELEMETRY;
+  if (flag === "0") return false;
+  if (flag?.toLowerCase() === "false") return false;
+  return true;
+}
+function posthogToken() {
+  return process.env.NUVIO_POSTHOG_TOKEN ?? NUVIO_POSTHOG_TOKEN;
+}
+function tokenIsConfigured(token) {
+  return Boolean(token && token.startsWith("phc_"));
+}
+function readOrCreateAnonymousId() {
+  if (sessionAnonymousId) return sessionAnonymousId;
+  try {
+    const raw = readFileSync5(telemetryFilePath(), "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed.anonymousId) {
+      sessionAnonymousId = parsed.anonymousId;
+      return parsed.anonymousId;
+    }
+  } catch {
+  }
+  const id = randomUUID();
+  sessionAnonymousId = id;
+  try {
+    mkdirSync(join5(homedir(), ".nuvio"), { recursive: true, mode: 448 });
+    writeFileSync2(
+      telemetryFilePath(),
+      JSON.stringify({ anonymousId: id }, null, 2),
+      { mode: 384 }
+    );
+  } catch {
+  }
+  return id;
+}
+function getClient() {
+  if (!isTelemetryEnabled()) return null;
+  const token = posthogToken();
+  if (!tokenIsConfigured(token)) return null;
+  if (!client) {
+    client = new PostHog(token, {
+      host: POSTHOG_HOST,
+      flushAt: 1,
+      flushInterval: 0
+    });
+    telemetryDebug("PostHog client initialized", {
+      host: POSTHOG_HOST,
+      tokenPrefix: `${token.slice(0, 8)}\u2026`
+    });
+  }
+  return client;
+}
+function sanitizeProps(props) {
+  if (!props) return void 0;
+  const out = {};
+  for (const [key, value] of Object.entries(props)) {
+    if (FORBIDDEN_PROP_KEYS.has(key)) continue;
+    if (value === void 0) continue;
+    if (typeof value === "string" && /[/\\]/.test(value)) continue;
+    out[key] = value;
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+function resolveCliInvokedCommand(help, command) {
+  if (help) return "help";
+  if (!command) return "none";
+  if (command === "init") return "init";
+  if (command === "doctor") return "doctor";
+  if (command === "scan") return "scan";
+  if (command === "stats") return "stats";
+  return "unknown";
+}
+function buildCliInvokedProps(command, pmOverride) {
+  const props = {
+    nuvio_version: NUVIO_VERSION,
+    os: process.platform,
+    arch: os.arch(),
+    node: process.version,
+    command
+  };
+  if (pmOverride) props.package_manager = pmOverride;
+  return props;
+}
+function buildCliTelemetryProps(pm, project) {
+  const props = {
+    nuvio_version: NUVIO_VERSION,
+    os: process.platform,
+    arch: os.arch(),
+    node: process.version
+  };
+  if (pm) props.package_manager = pm;
+  if (project) {
+    props.has_react = true;
+    props.has_vite = true;
+    props.has_tailwind = project.tailwindOk;
+  }
+  return props;
+}
+function preflightErrorCode(message) {
+  if (message === MSG.noPackageJson) return "preflight_no_package_json";
+  if (message === MSG.noVite) return "preflight_no_vite";
+  if (message === MSG.noReact) return "preflight_no_react";
+  if (message === MSG.noViteDep) return "preflight_no_vite_dep";
+  if (message === MSG.monorepoRoot || message === MSG.cliPackage) {
+    return "preflight_monorepo";
+  }
+  return "preflight_unknown";
+}
+function captureCliInvoked(command, pmOverride) {
+  captureCliEvent("nuvio_cli_invoked", buildCliInvokedProps(command, pmOverride));
+}
+function captureCliEvent(event, props) {
+  try {
+    if (!isTelemetryEnabled()) {
+      telemetryDebug(`skipped ${event} (telemetry disabled)`);
+      return;
+    }
+    const ph = getClient();
+    if (!ph) {
+      telemetryDebug(`skipped ${event} (no PostHog client \u2014 check token)`);
+      return;
+    }
+    const distinctId = readOrCreateAnonymousId();
+    ph.capture({
+      distinctId,
+      event,
+      properties: sanitizeProps(props)
+    });
+    telemetryDebug(`captured ${event}`, { distinctId });
+  } catch (error) {
+    telemetryDebug(`capture failed for ${event}`, error);
+  }
+}
+async function flushAndShutdownClient() {
+  if (!client) return;
+  const active = client;
+  client = null;
+  await Promise.race([
+    (async () => {
+      await active.flush();
+      await active.shutdown();
+    })(),
+    new Promise((_, reject) => {
+      setTimeout(
+        () => reject(new Error("telemetry shutdown timed out")),
+        SHUTDOWN_TIMEOUT_MS
+      );
+    })
+  ]);
+}
+async function shutdownTelemetry() {
+  if (shutdownDone) return;
+  shutdownDone = true;
+  try {
+    await flushAndShutdownClient();
+    telemetryDebug("flush + shutdown complete");
+  } catch (error) {
+    telemetryDebug("shutdown failed", error);
+  }
+}
+function registerTelemetrySignalHandlers() {
+  if (signalHandlersRegistered) return;
+  signalHandlersRegistered = true;
+  const onSignal = (signal) => {
+    void (async () => {
+      await shutdownTelemetry();
+      const code2 = signal === "SIGINT" ? 130 : 143;
+      process.exit(code2);
+    })();
+  };
+  process.once("SIGINT", onSignal);
+  process.once("SIGTERM", onSignal);
+}
+
+// src/babel-traverse.ts
+import traverseImport from "@babel/traverse";
+var traverse = typeof traverseImport === "function" ? traverseImport : traverseImport.default;
+var babel_traverse_default = traverse;
+
+// src/patch-app-root.ts
+import * as t from "@babel/types";
+import fg from "fast-glob";
+import { existsSync as existsSync5, readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "fs";
+import { join as join6 } from "path";
+
+// src/babel-generator.ts
+import generateImport from "@babel/generator";
+var generate = typeof generateImport === "function" ? generateImport : generateImport.default;
+var babel_generator_default = generate;
+
+// src/parse-ts.ts
+import { parse } from "@babel/parser";
+var PARSE_OPTS = {
+  sourceType: "module",
+  plugins: ["typescript", "jsx"]
+};
+function parseTs(source, filename = "file.tsx") {
+  return parse(source, {
+    ...PARSE_OPTS,
+    sourceFilename: filename
+  });
+}
+function printTs(ast, source) {
+  const out = babel_generator_default(ast, { retainLines: true }, source);
+  return out.code.endsWith("\n") ? out.code : `${out.code}
+`;
+}
+
+// src/patch-app-root.ts
+var APP_CANDIDATES = [
+  "src/App.tsx",
+  "src/App.jsx",
+  "src/main.tsx",
+  "src/main.jsx"
+];
+function resolveAppFile(root) {
+  for (const rel of APP_CANDIDATES) {
+    const p = join6(root, rel);
+    if (existsSync5(p)) return p;
+  }
+  return null;
+}
+function hasOverlayImport(ast) {
+  let found = false;
+  babel_traverse_default(ast, {
+    ImportDeclaration(path) {
+      if (path.node.source.value === "@nuvio/overlay") found = true;
+    }
+  });
+  return found;
+}
+function hasDevShell(ast) {
+  let found = false;
+  babel_traverse_default(ast, {
+    JSXElement(path) {
+      const name = path.node.openingElement.name;
+      if (t.isJSXIdentifier(name) && name.name === "NuvioDevShell") found = true;
+    }
+  });
+  return found;
+}
+function unwrapJsx(node) {
+  if (!node) return null;
+  if (t.isJSXElement(node) || t.isJSXFragment(node)) return node;
+  if (t.isParenthesizedExpression(node)) return unwrapJsx(node.expression);
   return null;
 }
-var devShellElement = t2.jsxElement(
-  t2.jsxOpeningElement(t2.jsxIdentifier("NuvioDevShell"), [], true),
+var devShellElement = t.jsxElement(
+  t.jsxOpeningElement(t.jsxIdentifier("NuvioDevShell"), [], true),
   null,
   [],
   true
@@ -391,15 +1080,15 @@ function appendDevShell(ast) {
     ReturnStatement(path) {
       const jsx = unwrapJsx(path.node.argument);
       if (!jsx) return;
-      if (t2.isJSXFragment(jsx)) {
-        jsx.children.push(t2.jsxText("\n      "));
+      if (t.isJSXFragment(jsx)) {
+        jsx.children.push(t.jsxText("\n      "));
         jsx.children.push(devShellElement);
         patched = true;
       } else {
-        path.node.argument = t2.jsxFragment(
-          t2.jsxOpeningFragment(),
-          t2.jsxClosingFragment(),
-          [jsx, t2.jsxText("\n      "), devShellElement]
+        path.node.argument = t.jsxFragment(
+          t.jsxOpeningFragment(),
+          t.jsxClosingFragment(),
+          [jsx, t.jsxText("\n      "), devShellElement]
         );
         patched = true;
       }
@@ -408,7 +1097,7 @@ function appendDevShell(ast) {
   return patched;
 }
 function patchAppRootFile(filePath) {
-  const source = readFileSync4(filePath, "utf8");
+  const source = readFileSync6(filePath, "utf8");
   let ast;
   try {
     ast = parseTs(source, filePath);
@@ -420,26 +1109,26 @@ function patchAppRootFile(filePath) {
   }
   if (!hasOverlayImport(ast)) {
     ast.program.body.unshift(
-      t2.importDeclaration(
+      t.importDeclaration(
         [
-          t2.importSpecifier(
-            t2.identifier("NuvioDevShell"),
-            t2.identifier("NuvioDevShell")
+          t.importSpecifier(
+            t.identifier("NuvioDevShell"),
+            t.identifier("NuvioDevShell")
           )
         ],
-        t2.stringLiteral("@nuvio/overlay")
+        t.stringLiteral("@nuvio/overlay")
       )
     );
   }
   if (!hasDevShell(ast) && !appendDevShell(ast)) {
     return { ok: false, error: "no JSX return to patch" };
   }
-  writeFileSync2(filePath, printTs(ast, source), "utf8");
+  writeFileSync3(filePath, printTs(ast, source), "utf8");
   return { ok: true };
 }
 function appHasDevShell(filePath) {
-  if (!existsSync3(filePath)) return false;
-  const source = readFileSync4(filePath, "utf8");
+  if (!existsSync5(filePath)) return false;
+  const source = readFileSync6(filePath, "utf8");
   try {
     const ast = parseTs(source, filePath);
     return hasOverlayImport(ast) && hasDevShell(ast);
@@ -447,32 +1136,42 @@ function appHasDevShell(filePath) {
     return /NuvioDevShell/.test(source);
   }
 }
+function projectHasDevShell(root) {
+  const appFile = resolveAppFile(root);
+  if (appFile && appHasDevShell(appFile)) return true;
+  const files = fg.sync(["src/**/*.{tsx,jsx}"], {
+    cwd: root,
+    absolute: true,
+    onlyFiles: true
+  });
+  for (const file of files) {
+    if (appHasDevShell(file)) return true;
+  }
+  return false;
+}
 
 // src/patch-main-styles.ts
-import { existsSync as existsSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "fs";
-import { join as join4 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "fs";
+import { join as join7 } from "path";
 var MAIN_CANDIDATES = ["src/main.tsx", "src/main.jsx", "main.tsx", "main.jsx"];
 var STYLE_IMPORT = 'import "@nuvio/overlay/style.css";';
 function overlayInstalledFromNpm(packageJsonPath) {
-  const pkg = JSON.parse(readFileSync5(packageJsonPath, "utf8"));
-  const dev = pkg.devDependencies;
-  const raw = dev?.["@nuvio/overlay"];
-  if (!raw) return false;
-  return !raw.startsWith("workspace:") && !raw.startsWith("link:") && !raw.startsWith("file:");
+  const pkg = readPackageJson(packageJsonPath);
+  return nuvioOverlayLinkKind(pkg) === "npm";
 }
 function resolveMainEntry(root) {
   for (const rel of MAIN_CANDIDATES) {
-    const p = join4(root, rel);
-    if (existsSync4(p)) return p;
+    const p = join7(root, rel);
+    if (existsSync6(p)) return p;
   }
   return null;
 }
 function mainHasOverlayStyles(mainPath) {
-  const text = readFileSync5(mainPath, "utf8");
+  const text = readFileSync7(mainPath, "utf8");
   return text.includes("@nuvio/overlay/style.css") || text.includes("@nuvio/overlay/dist/style.css");
 }
 function patchMainOverlayStyles(mainPath) {
-  const text = readFileSync5(mainPath, "utf8");
+  const text = readFileSync7(mainPath, "utf8");
   if (text.includes("@nuvio/overlay/style.css") || text.includes("@nuvio/overlay/dist/style.css")) {
     return { ok: true, skipped: true };
   }
@@ -486,209 +1185,212 @@ function patchMainOverlayStyles(mainPath) {
   } else {
     lines.unshift(STYLE_IMPORT, "");
   }
-  writeFileSync3(mainPath, lines.join("\n"));
+  writeFileSync4(mainPath, lines.join("\n"));
   return { ok: true };
 }
 
-// src/patch-starter-id.ts
-import * as t3 from "@babel/types";
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "fs";
-
-// src/scan-ids.ts
-import { readFileSync as readFileSync6 } from "fs";
-import { join as join5 } from "path";
-import fg from "fast-glob";
-var ID_GLOB = ["src/**/*.{tsx,jsx}"];
-function projectHasPageTitleId(root) {
-  const files = fg.sync(ID_GLOB, { cwd: root, absolute: true });
-  for (const file of files) {
-    const text = readFileSync6(file, "utf8");
-    if (/data-nuvio-id=["']page\.title["']/.test(text)) {
-      return true;
+// src/patch-vite-config.ts
+import * as t2 from "@babel/types";
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync5 } from "fs";
+function hasNuvioImport(ast) {
+  let found = false;
+  babel_traverse_default(ast, {
+    ImportDeclaration(path) {
+      if (path.node.source.value === "@nuvio/vite-plugin") found = true;
     }
-  }
-  return false;
+  });
+  return found;
 }
-function findHeadingFiles(root) {
-  const files = fg.sync(ID_GLOB, { cwd: root, absolute: true });
-  const ordered = [
-    join5(root, "src/App.tsx"),
-    join5(root, "src/App.jsx"),
-    ...files.filter(
-      (f) => !f.endsWith("App.tsx") && !f.endsWith("App.jsx")
-    )
-  ];
-  const seen = /* @__PURE__ */ new Set();
-  const out = [];
-  for (const f of ordered) {
-    if (!seen.has(f) && files.includes(f)) {
-      seen.add(f);
-      out.push(f);
+function hasNuvioPluginCall(ast) {
+  let found = false;
+  babel_traverse_default(ast, {
+    CallExpression(path) {
+      if (t2.isIdentifier(path.node.callee, { name: "nuvio" })) found = true;
     }
-  }
-  for (const f of files) {
-    if (!seen.has(f)) out.push(f);
-  }
-  return out;
+  });
+  return found;
 }
-
-// src/patch-starter-id.ts
-function patchFirstHeading(filePath) {
-  const source = readFileSync7(filePath, "utf8");
-  let ast;
-  try {
-    ast = parseTs(source, filePath);
-  } catch {
-    return { ok: false, error: "parse failed" };
-  }
+var OVERLAY_DEP = "@nuvio/overlay";
+function excludeListsOverlay(expr) {
+  if (!expr || !t2.isArrayExpression(expr)) return false;
+  return expr.elements.some(
+    (el) => t2.isStringLiteral(el) && el.value === OVERLAY_DEP
+  );
+}
+function ensureOptimizeDepsExclude(ast) {
   let patched = false;
   babel_traverse_default(ast, {
-    JSXOpeningElement(path) {
-      if (patched) return;
-      const name = path.node.name;
-      if (!t3.isJSXIdentifier(name)) return;
-      if (name.name !== "h1" && name.name !== "h2") return;
-      for (const attr of path.node.attributes) {
-        if (t3.isJSXAttribute(attr) && t3.isJSXIdentifier(attr.name, { name: "data-nuvio-id" })) {
-          return;
+    CallExpression(path) {
+      const callee = path.node.callee;
+      if (!t2.isIdentifier(callee, { name: "defineConfig" })) return;
+      const arg = path.node.arguments[0];
+      if (!t2.isObjectExpression(arg)) return;
+      let optimizeDeps;
+      for (const prop of arg.properties) {
+        if (t2.isObjectProperty(prop) && t2.isIdentifier(prop.key, { name: "optimizeDeps" })) {
+          optimizeDeps = prop;
+          break;
         }
       }
-      path.node.attributes.push(
-        t3.jsxAttribute(
-          t3.jsxIdentifier("data-nuvio-id"),
-          t3.stringLiteral("page.title")
-        )
-      );
+      if (!optimizeDeps) {
+        arg.properties.push(
+          t2.objectProperty(
+            t2.identifier("optimizeDeps"),
+            t2.objectExpression([
+              t2.objectProperty(
+                t2.identifier("exclude"),
+                t2.arrayExpression([t2.stringLiteral(OVERLAY_DEP)])
+              )
+            ])
+          )
+        );
+        patched = true;
+        return;
+      }
+      if (!t2.isObjectExpression(optimizeDeps.value)) return;
+      let excludeProp;
+      for (const p of optimizeDeps.value.properties) {
+        if (t2.isObjectProperty(p) && t2.isIdentifier(p.key, { name: "exclude" })) {
+          excludeProp = p;
+          break;
+        }
+      }
+      if (!excludeProp) {
+        optimizeDeps.value.properties.push(
+          t2.objectProperty(
+            t2.identifier("exclude"),
+            t2.arrayExpression([t2.stringLiteral(OVERLAY_DEP)])
+          )
+        );
+        patched = true;
+        return;
+      }
+      if (t2.isArrayExpression(excludeProp.value) && !excludeListsOverlay(excludeProp.value)) {
+        excludeProp.value.elements.push(t2.stringLiteral(OVERLAY_DEP));
+        patched = true;
+      }
+    }
+  });
+  return patched;
+}
+function viteConfigHasOverlayOptimizeExclude(filePath) {
+  const source = readFileSync8(filePath, "utf8");
+  return /optimizeDeps\s*:\s*\{[^}]*exclude\s*:\s*\[[^\]]*@nuvio\/overlay/.test(
+    source
+  ) || /exclude\s*:\s*\[[^\]]*["']@nuvio\/overlay["']/.test(source);
+}
+function appendNuvioPlugin(ast) {
+  let patched = false;
+  babel_traverse_default(ast, {
+    ObjectProperty(path) {
+      if (!t2.isIdentifier(path.node.key, { name: "plugins" })) return;
+      if (!t2.isArrayExpression(path.node.value)) return;
+      path.node.value.elements.push(t2.callExpression(t2.identifier("nuvio"), []));
       patched = true;
     }
   });
-  if (!patched) return { ok: false, error: "no h1/h2" };
-  writeFileSync4(filePath, printTs(ast, source), "utf8");
-  return { ok: true };
+  return patched;
 }
-function patchStarterId(root) {
-  const files = findHeadingFiles(root);
-  for (const file of files) {
-    const source = readFileSync7(file, "utf8");
-    if (!/<h[12][\s>]/.test(source) && !/<>[\s\S]*<h[12]/.test(source)) {
-      try {
-        const ast = parseTs(source, file);
-        let has = false;
-        babel_traverse_default(ast, {
-          JSXOpeningElement(path) {
-            const name = path.node.name;
-            if (t3.isJSXIdentifier(name) && (name.name === "h1" || name.name === "h2"))
-              has = true;
-          }
-        });
-        if (!has) continue;
-      } catch {
-        continue;
-      }
+function patchViteConfigFile(filePath) {
+  const source = readFileSync8(filePath, "utf8");
+  let ast;
+  try {
+    ast = parseTs(source, filePath);
+  } catch {
+    return { ok: false, error: "parse failed" };
+  }
+  const depsPatched = ensureOptimizeDepsExclude(ast);
+  const alreadyPlugin = hasNuvioImport(ast) && hasNuvioPluginCall(ast);
+  if (alreadyPlugin && !depsPatched) {
+    return { ok: true, skipped: true };
+  }
+  if (!hasNuvioImport(ast)) {
+    ast.program.body.unshift(
+      t2.importDeclaration(
+        [t2.importSpecifier(t2.identifier("nuvio"), t2.identifier("nuvio"))],
+        t2.stringLiteral("@nuvio/vite-plugin")
+      )
+    );
+  }
+  if (!hasNuvioPluginCall(ast)) {
+    if (!appendNuvioPlugin(ast)) {
+      return { ok: false, error: "no static plugins array" };
     }
-    const outcome = patchFirstHeading(file);
-    if (outcome.ok) return { outcome, file };
   }
-  return { outcome: { ok: false, error: "no heading" } };
-}
-
-// src/plan.ts
-function createPlan(root, pm) {
-  const pmRun = pm === "pnpm" ? "pnpm dev" : pm === "yarn" ? "yarn dev" : pm === "bun" ? "bun run dev" : "npm run dev";
-  return {
-    root,
-    pm,
-    pmRun,
-    installCommand: "",
-    modify: [],
-    create: [],
-    warnings: [],
-    tier: "full",
-    failedSteps: []
-  };
+  writeFileSync5(filePath, printTs(ast, source), "utf8");
+  return { ok: true, skipped: alreadyPlugin && depsPatched };
 }
-
-// src/version.ts
-import { createRequire } from "module";
-var require2 = createRequire(import.meta.url);
-var NUVIO_VERSION = require2("../package.json").version;
-
-// src/write-nuvio-folder.ts
-import { existsSync as existsSync5, mkdirSync, readFileSync as readFileSync8, writeFileSync as writeFileSync5 } from "fs";
-import { dirname, join as join6 } from "path";
-import { fileURLToPath } from "url";
-var CLI_ROOT = join6(dirname(fileURLToPath(import.meta.url)), "..");
-function loadTemplate(name) {
-  return readFileSync8(join6(CLI_ROOT, "templates", name), "utf8");
+function viteConfigHasNuvio(filePath) {
+  const source = readFileSync8(filePath, "utf8");
+  try {
+    const ast = parseTs(source, filePath);
+    return hasNuvioImport(ast) && hasNuvioPluginCall(ast);
+  } catch {
+    return /nuvio\s*\(/.test(source);
+  }
 }
-function render(tpl, vars) {
-  let out = tpl;
-  for (const [key, value] of Object.entries(vars)) {
-    out = out.replaceAll(`{{${key}}}`, value);
+
+// src/scan-ids.ts
+import { readFileSync as readFileSync9 } from "fs";
+import { join as join8 } from "path";
+import fg2 from "fast-glob";
+var ID_GLOB = ["src/**/*.{tsx,jsx}"];
+function projectHasPageTitleId(root) {
+  const files = fg2.sync(ID_GLOB, { cwd: root, absolute: true });
+  for (const file of files) {
+    const text = readFileSync9(file, "utf8");
+    if (/data-nuvio-id=["']page\.title["']/.test(text)) {
+      return true;
+    }
   }
-  return out;
+  return false;
 }
-function writeNuvioFolder(opts) {
-  const dir = join6(opts.root, "nuvio");
-  const created = [];
-  mkdirSync(dir, { recursive: true });
-  const vars = {
-    NUVIO_VERSION: opts.version,
-    PM_RUN: opts.pmRun,
-    FAILED_STEPS: opts.failedSteps.join(", ") || "(none)"
-  };
-  const startHere = join6(dir, "START_HERE.md");
-  writeFileSync5(
-    startHere,
-    render(loadTemplate("START_HERE.md.tpl"), vars),
-    "utf8"
-  );
-  created.push("nuvio/START_HERE.md");
-  const readme = join6(dir, "README.md");
-  writeFileSync5(
-    readme,
-    render(loadTemplate("README.pointer.md.tpl"), vars),
-    "utf8"
-  );
-  created.push("nuvio/README.md");
-  const agent = join6(dir, "AGENT.md");
-  if (!existsSync5(agent) || opts.forceAgent) {
-    writeFileSync5(agent, render(loadTemplate("AGENT.md.tpl"), vars), "utf8");
-    created.push("nuvio/AGENT.md");
+function findHeadingFiles(root) {
+  const files = fg2.sync(ID_GLOB, { cwd: root, absolute: true });
+  const ordered = [
+    join8(root, "src/App.tsx"),
+    join8(root, "src/App.jsx"),
+    ...files.filter(
+      (f) => !f.endsWith("App.tsx") && !f.endsWith("App.jsx")
+    )
+  ];
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const f of ordered) {
+    if (!seen.has(f) && files.includes(f)) {
+      seen.add(f);
+      out.push(f);
+    }
   }
-  if (opts.failedSteps.length > 0) {
-    const todo = join6(dir, "SETUP_TODO.md");
-    writeFileSync5(
-      todo,
-      render(loadTemplate("SETUP_TODO.md.tpl"), vars),
-      "utf8"
-    );
-    created.push("nuvio/SETUP_TODO.md");
+  for (const f of files) {
+    if (!seen.has(f)) out.push(f);
   }
-  return created;
+  return out;
 }
 
 // src/verify.ts
-import { readFileSync as readFileSync9 } from "fs";
+function optimizeDepsSatisfied(viteConfigPath, packageJsonPath) {
+  if (viteConfigHasOverlayOptimizeExclude(viteConfigPath)) return true;
+  const pkg = readPackageJson(packageJsonPath);
+  return nuvioOverlayLinkKind(pkg) === "workspace";
+}
 function verifyProject(root, packageJsonPath, viteConfigPath) {
-  const pkg = JSON.parse(readFileSync9(packageJsonPath, "utf8"));
-  const dev = pkg.devDependencies;
-  const depsOk = Boolean(dev?.["@nuvio/vite-plugin"]) && Boolean(dev?.["@nuvio/overlay"]);
-  const appFile = resolveAppFile(root);
+  const pkg = readPackageJson(packageJsonPath);
+  const depsOk = hasNuvioPackages(pkg);
   const mainEntry = resolveMainEntry(root);
   return {
     deps: depsOk ? "OK" : "MISSING",
     vite: viteConfigHasNuvio(viteConfigPath) ? "OK" : "TODO",
     overlayCss: mainEntry && (mainHasOverlayStyles(mainEntry) || !overlayInstalledFromNpm(packageJsonPath)) ? "OK" : "TODO",
-    optimizeDeps: viteConfigHasOverlayOptimizeExclude(viteConfigPath) ? "OK" : "TODO",
-    shell: appFile && appHasDevShell(appFile) ? "OK" : "TODO",
+    optimizeDeps: optimizeDepsSatisfied(viteConfigPath, packageJsonPath) ? "OK" : "TODO",
+    shell: projectHasDevShell(root) ? "OK" : "TODO",
     starterId: projectHasPageTitleId(root) ? "OK" : "MISSING"
   };
 }
 function printVerification(v) {
   console.log("Verification:");
   console.log(
-    `  devDependencies: @nuvio/vite-plugin, @nuvio/overlay \u2014 ${v.deps}`
+    `  dependencies: @nuvio/vite-plugin, @nuvio/overlay \u2014 ${v.deps}`
   );
   console.log(`  vite.config: nuvio() \u2014 ${v.vite}`);
   console.log(`  main.tsx: @nuvio/overlay/style.css \u2014 ${v.overlayCss}`);
@@ -697,214 +1399,341 @@ function printVerification(v) {
   console.log(`  Starter id page.title \u2014 ${v.starterId}`);
 }
 
-// src/telemetry.ts
-import { mkdirSync as mkdirSync2, readFileSync as readFileSync10, writeFileSync as writeFileSync6 } from "fs";
-import { homedir } from "os";
-import { join as join7 } from "path";
-import { randomUUID } from "crypto";
-import os from "os";
-import { PostHog } from "posthog-node";
-
-// src/nuvio-posthog-token.ts
-var NUVIO_POSTHOG_TOKEN = "phc_CJnWrLU4hB4aA88DJrPnma2WBMQqVHxUMVvrsye3R6x2";
-
-// src/telemetry.ts
-var POSTHOG_HOST = "https://us.i.posthog.com";
-function telemetryFilePath() {
-  return join7(homedir(), ".nuvio", "telemetry.json");
-}
-var FORBIDDEN_PROP_KEYS = /* @__PURE__ */ new Set([
-  "cwd",
-  "root",
-  "file",
-  "path",
-  "name",
-  "message",
-  "stack"
-]);
-var SHUTDOWN_TIMEOUT_MS = 3e3;
-var client = null;
-var sessionAnonymousId = null;
-var shutdownDone = false;
-var signalHandlersRegistered = false;
-function telemetryDebug(message, detail) {
-  if (process.env.NUVIO_TELEMETRY_DEBUG !== "1") return;
-  if (detail !== void 0) {
-    console.error(`[nuvio telemetry] ${message}`, detail);
-    return;
+// src/doctor.ts
+async function checkDevServerReachable(port) {
+  const url = `http://127.0.0.1:${port}/`;
+  try {
+    const res = await fetch(url, { signal: AbortSignal.timeout(1500) });
+    if (res.ok) {
+      return {
+        id: "dev_server",
+        label: `Dev server reachable (${url})`,
+        status: "pass"
+      };
+    }
+    return {
+      id: "dev_server",
+      label: "Dev server reachable",
+      status: "warn",
+      detail: `HTTP ${res.status} from ${url}`
+    };
+  } catch {
+    return {
+      id: "dev_server",
+      label: "Dev server reachable",
+      status: "warn",
+      detail: `Start pnpm dev \u2014 could not reach ${url}`
+    };
   }
-  console.error(`[nuvio telemetry] ${message}`);
-}
-function isTelemetryEnabled() {
-  const flag = process.env.NUVIO_TELEMETRY;
-  if (flag === "0") return false;
-  if (flag?.toLowerCase() === "false") return false;
-  return true;
-}
-function posthogToken() {
-  return process.env.NUVIO_POSTHOG_TOKEN ?? NUVIO_POSTHOG_TOKEN;
 }
-function tokenIsConfigured(token) {
-  return Boolean(token && token.startsWith("phc_"));
+function summarize(result) {
+  const total = result.checks.length;
+  const passed = result.passCount;
+  const label = result.failCount > 0 ? "nuvio not ready" : result.warnCount > 0 ? "nuvio partially ready" : "nuvio ready";
+  console.log(`
+Result: ${passed}/${total} passed \u2014 ${label}`);
 }
-function readOrCreateAnonymousId() {
-  if (sessionAnonymousId) return sessionAnonymousId;
+async function runDoctor(opts) {
+  let scan;
   try {
-    const raw = readFileSync10(telemetryFilePath(), "utf8");
-    const parsed = JSON.parse(raw);
-    if (parsed.anonymousId) {
-      sessionAnonymousId = parsed.anonymousId;
-      return parsed.anonymousId;
+    scan = scanProject(opts.cwd);
+  } catch (e) {
+    if (e instanceof PreflightError) {
+      console.error(e.message);
+      return 1;
     }
-  } catch {
+    throw e;
   }
-  const id = randomUUID();
-  sessionAnonymousId = id;
-  try {
-    mkdirSync2(join7(homedir(), ".nuvio"), { recursive: true, mode: 448 });
-    writeFileSync6(
-      telemetryFilePath(),
-      JSON.stringify({ anonymousId: id }, null, 2),
-      { mode: 384 }
-    );
-  } catch {
+  const { ctx, detectedLibraries, index } = scan;
+  const pkg = ctx.packageJson;
+  const projectName = String(pkg.name ?? "project");
+  const verification = verifyProject(
+    ctx.root,
+    ctx.packageJsonPath,
+    ctx.viteConfigPath
+  );
+  const checks = [
+    {
+      id: "deps_plugin",
+      label: "@nuvio/vite-plugin installed",
+      status: verification.deps === "OK" ? "pass" : "fail"
+    },
+    {
+      id: "deps_overlay",
+      label: "@nuvio/overlay installed",
+      status: verification.deps === "OK" ? "pass" : "fail"
+    },
+    {
+      id: "vite_plugin",
+      label: "vite.config contains nuvio()",
+      status: verification.vite === "OK" ? "pass" : "fail"
+    },
+    {
+      id: "optimize_deps",
+      label: "optimizeDeps.exclude includes @nuvio/overlay",
+      status: verification.optimizeDeps === "OK" ? "pass" : "fail",
+      detail: verification.optimizeDeps === "OK" && nuvioOverlayLinkKind(pkg) === "workspace" ? "workspace install \u2014 optional" : void 0
+    },
+    {
+      id: "overlay_css",
+      label: "main entry imports @nuvio/overlay/style.css",
+      status: verification.overlayCss === "OK" ? "pass" : "fail",
+      detail: verification.overlayCss === "OK" && nuvioOverlayLinkKind(pkg) === "workspace" ? "workspace install \u2014 optional" : void 0
+    },
+    {
+      id: "dev_shell",
+      label: "NuvioDevShell mounted in app",
+      status: verification.shell === "OK" ? "pass" : "fail"
+    },
+    {
+      id: "tailwind",
+      label: "Tailwind detected",
+      status: ctx.tailwindOk ? "pass" : "warn",
+      detail: ctx.tailwindOk ? void 0 : "Style edits may not apply visually without Tailwind"
+    },
+    {
+      id: "editable_hosts",
+      label: "At least one data-nuvio-id indexed",
+      status: index.entries.length > 0 ? "pass" : "fail",
+      detail: index.entries.length > 0 ? `${index.entries.length} host(s)` : "Run dev \u2192 Make Editable, or add ids manually"
+    }
+  ];
+  if (detectedLibraries.length > 0) {
+    checks.push({
+      id: "libraries",
+      label: "Component libraries detected",
+      status: "pass",
+      detail: detectedLibraries.join(", ")
+    });
   }
-  return id;
-}
-function getClient() {
-  if (!isTelemetryEnabled()) return null;
-  const token = posthogToken();
-  if (!tokenIsConfigured(token)) return null;
-  if (!client) {
-    client = new PostHog(token, {
-      host: POSTHOG_HOST,
-      flushAt: 1,
-      flushInterval: 0
+  if (index.duplicateErrors.length > 0) {
+    checks.push({
+      id: "duplicate_ids",
+      label: "No duplicate data-nuvio-id values",
+      status: "fail",
+      detail: `${index.duplicateErrors.length} duplicate id(s) \u2014 run nuvio scan`
     });
-    telemetryDebug("PostHog client initialized", {
-      host: POSTHOG_HOST,
-      tokenPrefix: `${token.slice(0, 8)}\u2026`
+  } else {
+    checks.push({
+      id: "duplicate_ids",
+      label: "No duplicate data-nuvio-id values",
+      status: "pass"
     });
   }
-  return client;
-}
-function sanitizeProps(props) {
-  if (!props) return void 0;
-  const out = {};
-  for (const [key, value] of Object.entries(props)) {
-    if (FORBIDDEN_PROP_KEYS.has(key)) continue;
-    if (value === void 0) continue;
-    if (typeof value === "string" && /[/\\]/.test(value)) continue;
-    out[key] = value;
+  if (opts.checkDevServer !== false) {
+    checks.push(await checkDevServerReachable(opts.devServerPort ?? 5173));
   }
-  return Object.keys(out).length > 0 ? out : void 0;
-}
-function resolveCliInvokedCommand(help, command) {
-  if (help) return "help";
-  if (!command) return "none";
-  if (command === "init") return "init";
-  return "unknown";
-}
-function buildCliInvokedProps(command, pmOverride) {
-  const props = {
-    nuvio_version: NUVIO_VERSION,
-    os: process.platform,
-    arch: os.arch(),
-    node: process.version,
-    command
+  const passCount = checks.filter((c) => c.status === "pass").length;
+  const warnCount = checks.filter((c) => c.status === "warn").length;
+  const failCount = checks.filter((c) => c.status === "fail").length;
+  const result = {
+    projectName,
+    checks,
+    passCount,
+    warnCount,
+    failCount
   };
-  if (pmOverride) props.package_manager = pmOverride;
-  return props;
-}
-function buildCliTelemetryProps(pm, project) {
-  const props = {
-    nuvio_version: NUVIO_VERSION,
-    os: process.platform,
-    arch: os.arch(),
-    node: process.version
+  const pm = detectPackageManager(ctx.root);
+  const telemetry = {
+    ...buildCliTelemetryProps(pm, ctx),
+    pass_count: passCount,
+    warn_count: warnCount,
+    fail_count: failCount,
+    ready: failCount === 0
   };
-  if (pm) props.package_manager = pm;
-  if (project) {
-    props.has_react = true;
-    props.has_vite = true;
-    props.has_tailwind = project.tailwindOk;
+  captureCliEvent("doctor_run", telemetry);
+  if (opts.json) {
+    console.log(JSON.stringify(result, null, 2));
+    return failCount > 0 ? 1 : 0;
   }
-  return props;
+  console.log(`nuvio doctor \u2014 ${projectName}
+`);
+  for (const check of checks) {
+    const icon = check.status === "pass" ? "\u2705" : check.status === "warn" ? "\u26A0" : "\u274C";
+    const suffix = check.detail ? ` \u2014 ${check.detail}` : "";
+    console.log(`  ${icon} ${check.label}${suffix}`);
+  }
+  summarize(result);
+  return failCount > 0 ? 1 : 0;
 }
-function preflightErrorCode(message) {
-  if (message === MSG.noPackageJson) return "preflight_no_package_json";
-  if (message === MSG.noVite) return "preflight_no_vite";
-  if (message === MSG.noReact) return "preflight_no_react";
-  if (message === MSG.noViteDep) return "preflight_no_vite_dep";
-  if (message === MSG.monorepoRoot || message === MSG.cliPackage) {
-    return "preflight_monorepo";
+
+// src/init.ts
+import { createInterface } from "readline";
+
+// src/install-packages.ts
+import { spawnSync } from "child_process";
+import { readFileSync as readFileSync10 } from "fs";
+function parseInstalledVersion(pkg, name) {
+  const dev = pkg.devDependencies;
+  const deps = pkg.dependencies;
+  const raw = dev?.[name] ?? deps?.[name];
+  if (!raw) return null;
+  return raw.replace(/^[\^~]/, "");
+}
+function packagesNeedInstall(packageJsonPath, targetVersion) {
+  const pkg = JSON.parse(readFileSync10(packageJsonPath, "utf8"));
+  for (const name of ["@nuvio/vite-plugin", "@nuvio/overlay"]) {
+    const v = parseInstalledVersion(pkg, name);
+    if (v !== targetVersion) return true;
   }
-  return "preflight_unknown";
+  return false;
 }
-function captureCliInvoked(command, pmOverride) {
-  captureCliEvent("nuvio_cli_invoked", buildCliInvokedProps(command, pmOverride));
+function runInstall(root, pm, version) {
+  const cmd = installCommand(pm, version);
+  const result = spawnSync(cmd, {
+    cwd: root,
+    shell: true,
+    stdio: "inherit",
+    env: process.env
+  });
+  if (result.status !== 0) {
+    return {
+      ok: false,
+      message: `Install failed. Try manually:
+  ${cmd}`
+    };
+  }
+  return { ok: true };
 }
-function captureCliEvent(event, props) {
+
+// src/patch-starter-id.ts
+import * as t3 from "@babel/types";
+import { readFileSync as readFileSync11, writeFileSync as writeFileSync6 } from "fs";
+function patchFirstHeading(filePath) {
+  const source = readFileSync11(filePath, "utf8");
+  let ast;
   try {
-    if (!isTelemetryEnabled()) {
-      telemetryDebug(`skipped ${event} (telemetry disabled)`);
-      return;
+    ast = parseTs(source, filePath);
+  } catch {
+    return { ok: false, error: "parse failed" };
+  }
+  let patched = false;
+  babel_traverse_default(ast, {
+    JSXOpeningElement(path) {
+      if (patched) return;
+      const name = path.node.name;
+      if (!t3.isJSXIdentifier(name)) return;
+      if (name.name !== "h1" && name.name !== "h2") return;
+      for (const attr of path.node.attributes) {
+        if (t3.isJSXAttribute(attr) && t3.isJSXIdentifier(attr.name, { name: "data-nuvio-id" })) {
+          return;
+        }
+      }
+      path.node.attributes.push(
+        t3.jsxAttribute(
+          t3.jsxIdentifier("data-nuvio-id"),
+          t3.stringLiteral("page.title")
+        )
+      );
+      patched = true;
     }
-    const ph = getClient();
-    if (!ph) {
-      telemetryDebug(`skipped ${event} (no PostHog client \u2014 check token)`);
-      return;
+  });
+  if (!patched) return { ok: false, error: "no h1/h2" };
+  writeFileSync6(filePath, printTs(ast, source), "utf8");
+  return { ok: true };
+}
+function patchStarterId(root) {
+  const files = findHeadingFiles(root);
+  for (const file of files) {
+    const source = readFileSync11(file, "utf8");
+    if (!/<h[12][\s>]/.test(source) && !/<>[\s\S]*<h[12]/.test(source)) {
+      try {
+        const ast = parseTs(source, file);
+        let has = false;
+        babel_traverse_default(ast, {
+          JSXOpeningElement(path) {
+            const name = path.node.name;
+            if (t3.isJSXIdentifier(name) && (name.name === "h1" || name.name === "h2"))
+              has = true;
+          }
+        });
+        if (!has) continue;
+      } catch {
+        continue;
+      }
     }
-    const distinctId = readOrCreateAnonymousId();
-    ph.capture({
-      distinctId,
-      event,
-      properties: sanitizeProps(props)
-    });
-    telemetryDebug(`captured ${event}`, { distinctId });
-  } catch (error) {
-    telemetryDebug(`capture failed for ${event}`, error);
+    const outcome = patchFirstHeading(file);
+    if (outcome.ok) return { outcome, file };
   }
+  return { outcome: { ok: false, error: "no heading" } };
 }
-async function flushAndShutdownClient() {
-  if (!client) return;
-  const active = client;
-  client = null;
-  await Promise.race([
-    (async () => {
-      await active.flush();
-      await active.shutdown();
-    })(),
-    new Promise((_, reject) => {
-      setTimeout(
-        () => reject(new Error("telemetry shutdown timed out")),
-        SHUTDOWN_TIMEOUT_MS
-      );
-    })
-  ]);
+
+// src/plan.ts
+function createPlan(root, pm) {
+  const pmRun = pm === "pnpm" ? "pnpm dev" : pm === "yarn" ? "yarn dev" : pm === "bun" ? "bun run dev" : "npm run dev";
+  return {
+    root,
+    pm,
+    pmRun,
+    installCommand: "",
+    modify: [],
+    create: [],
+    warnings: [],
+    tier: "full",
+    failedSteps: []
+  };
 }
-async function shutdownTelemetry() {
-  if (shutdownDone) return;
-  shutdownDone = true;
-  try {
-    await flushAndShutdownClient();
-    telemetryDebug("flush + shutdown complete");
-  } catch (error) {
-    telemetryDebug("shutdown failed", error);
+
+// src/write-nuvio-folder.ts
+import { existsSync as existsSync7, mkdirSync as mkdirSync2, readFileSync as readFileSync12, writeFileSync as writeFileSync7 } from "fs";
+import { dirname, join as join9 } from "path";
+import { fileURLToPath } from "url";
+import { DEFAULT_BRAND_CONFIG as DEFAULT_BRAND_CONFIG3, serializeBrandConfig } from "@nuvio/shared";
+var CLI_ROOT = join9(dirname(fileURLToPath(import.meta.url)), "..");
+function loadTemplate(name) {
+  return readFileSync12(join9(CLI_ROOT, "templates", name), "utf8");
+}
+function render(tpl, vars) {
+  let out = tpl;
+  for (const [key, value] of Object.entries(vars)) {
+    out = out.replaceAll(`{{${key}}}`, value);
   }
+  return out;
 }
-function registerTelemetrySignalHandlers() {
-  if (signalHandlersRegistered) return;
-  signalHandlersRegistered = true;
-  const onSignal = (signal) => {
-    void (async () => {
-      await shutdownTelemetry();
-      const code2 = signal === "SIGINT" ? 130 : 143;
-      process.exit(code2);
-    })();
+function writeNuvioFolder(opts) {
+  const dir = join9(opts.root, "nuvio");
+  const created = [];
+  mkdirSync2(dir, { recursive: true });
+  const vars = {
+    NUVIO_VERSION: opts.version,
+    PM_RUN: opts.pmRun,
+    FAILED_STEPS: opts.failedSteps.join(", ") || "(none)"
   };
-  process.once("SIGINT", onSignal);
-  process.once("SIGTERM", onSignal);
+  const startHere = join9(dir, "START_HERE.md");
+  writeFileSync7(
+    startHere,
+    render(loadTemplate("START_HERE.md.tpl"), vars),
+    "utf8"
+  );
+  created.push("nuvio/START_HERE.md");
+  const readme = join9(dir, "README.md");
+  writeFileSync7(
+    readme,
+    render(loadTemplate("README.pointer.md.tpl"), vars),
+    "utf8"
+  );
+  created.push("nuvio/README.md");
+  const agent = join9(dir, "AGENT.md");
+  if (!existsSync7(agent) || opts.forceAgent) {
+    writeFileSync7(agent, render(loadTemplate("AGENT.md.tpl"), vars), "utf8");
+    created.push("nuvio/AGENT.md");
+  }
+  if (opts.failedSteps.length > 0) {
+    const todo = join9(dir, "SETUP_TODO.md");
+    writeFileSync7(
+      todo,
+      render(loadTemplate("SETUP_TODO.md.tpl"), vars),
+      "utf8"
+    );
+    created.push("nuvio/SETUP_TODO.md");
+  }
+  const brand = join9(dir, "brand.json");
+  if (!existsSync7(brand)) {
+    writeFileSync7(brand, `${JSON.stringify(serializeBrandConfig(DEFAULT_BRAND_CONFIG3), null, 2)}
+`, "utf8");
+    created.push("nuvio/brand.json");
+  }
+  return created;
 }
 
 // src/init.ts
@@ -924,10 +1753,10 @@ async function confirm(plan) {
   console.log(`
 Install: ${plan.installCommand || "(skip)"}`);
   const rl = createInterface({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve2) => {
+  return new Promise((resolve5) => {
     rl.question("\nProceed? [y/N] ", (answer) => {
       rl.close();
-      resolve2(/^y(es)?$/i.test(answer.trim()));
+      resolve5(/^y(es)?$/i.test(answer.trim()));
     });
   });
 }
@@ -1152,14 +1981,165 @@ async function runInit(opts) {
   return plan.tier === "partial" || plan.tier === "full" ? 0 : 1;
 }
 
+// src/scan-cmd.ts
+function runScan(opts) {
+  let scan;
+  try {
+    scan = scanProject(opts.cwd);
+  } catch (e) {
+    if (e instanceof PreflightError) {
+      console.error(e.message);
+      return 1;
+    }
+    throw e;
+  }
+  const { ctx, detectedLibraries, index } = scan;
+  const projectName = String(ctx.packageJson.name ?? "project");
+  const hosts = index.entries.map((entry) => ({
+    id: entry.id,
+    file: relPath(ctx.root, entry.file),
+    line: entry.line,
+    column: entry.column,
+    libraryHint: entry.libraryHint,
+    classNameMode: entry.classNameMode
+  }));
+  const result = {
+    projectName,
+    hosts,
+    hostCount: hosts.length,
+    duplicateErrors: index.duplicateErrors.map((dup) => ({
+      id: dup.id,
+      occurrences: dup.occurrences.map((o) => ({
+        file: relPath(ctx.root, o.file),
+        line: o.line
+      }))
+    })),
+    detectedLibraries,
+    scannedFileCount: index.scannedFileCount
+  };
+  const pm = detectPackageManager(ctx.root);
+  const telemetry = {
+    ...buildCliTelemetryProps(pm, ctx),
+    host_count: result.hostCount,
+    duplicate_count: result.duplicateErrors.length,
+    library_count: detectedLibraries.length
+  };
+  captureCliEvent("scan_run", telemetry);
+  if (opts.json) {
+    console.log(JSON.stringify(result, null, 2));
+    return result.duplicateErrors.length > 0 ? 1 : 0;
+  }
+  console.log(`nuvio scan \u2014 ${result.hostCount} editable host(s)
+`);
+  for (const host of hosts) {
+    console.log(
+      `  ${host.id.padEnd(28)} ${host.file}:${host.line}`
+    );
+  }
+  if (result.duplicateErrors.length > 0) {
+    console.log("");
+    for (const dup of result.duplicateErrors) {
+      const places = dup.occurrences.map((o) => `${o.file}:${o.line}`).join(", ");
+      console.log(`  \u274C duplicate id: ${dup.id} (${places}) \u2014 fix before apply`);
+    }
+  }
+  if (detectedLibraries.length > 0) {
+    console.log(`
+  Libraries: ${detectedLibraries.join(", ")}`);
+  }
+  if (result.hostCount === 0) {
+    console.log(
+      "\n  No hosts found \u2014 use Make Editable in the browser or add data-nuvio-id manually."
+    );
+  }
+  return result.duplicateErrors.length > 0 ? 1 : 0;
+}
+
+// src/stats.ts
+import { readRuntimeVersions } from "@nuvio/vite-plugin/scan";
+function runStats(opts) {
+  let scan;
+  try {
+    scan = scanProject(opts.cwd);
+  } catch (e) {
+    if (e instanceof PreflightError) {
+      console.error(e.message);
+      return 1;
+    }
+    throw e;
+  }
+  const { ctx, detectedLibraries, index } = scan;
+  const projectName = String(ctx.packageJson.name ?? "project");
+  const taggedFiles = new Set(
+    index.entries.map((e) => relPath(ctx.root, e.file))
+  ).size;
+  const classNameModes = aggregateClassNameModes(index.entries);
+  const tableHosts = index.entries.filter(isTableHost).length;
+  const versions = readRuntimeVersions(ctx.root);
+  const result = {
+    projectName,
+    editableHosts: index.entries.length,
+    taggedFiles,
+    scannedFiles: index.scannedFileCount,
+    duplicateIds: index.duplicateErrors.length,
+    tableHosts,
+    detectedLibraries,
+    tailwindVersion: versions.tailwindVersion,
+    classNameModes
+  };
+  const pm = detectPackageManager(ctx.root);
+  const telemetry = {
+    ...buildCliTelemetryProps(pm, ctx),
+    editable_hosts: result.editableHosts,
+    tagged_files: result.taggedFiles,
+    duplicate_ids: result.duplicateIds,
+    table_hosts: result.tableHosts,
+    library_count: detectedLibraries.length
+  };
+  captureCliEvent("stats_run", telemetry);
+  if (opts.json) {
+    console.log(JSON.stringify(result, null, 2));
+    return 0;
+  }
+  console.log("nuvio stats\n");
+  console.log(`  Editable hosts:     ${result.editableHosts}`);
+  console.log(`  Tagged files:       ${result.taggedFiles}`);
+  console.log(`  Files scanned:      ${result.scannedFiles}`);
+  console.log(
+    `  Libraries detected: ${result.detectedLibraries.length > 0 ? result.detectedLibraries.join(", ") : "none"}`
+  );
+  console.log(`  Table hosts:        ${result.tableHosts}`);
+  console.log(`  Duplicate ids:      ${result.duplicateIds}`);
+  if (result.tailwindVersion) {
+    console.log(`  Tailwind version:   ${result.tailwindVersion}`);
+  }
+  const modeParts = Object.entries(result.classNameModes).sort(([a], [b]) => a.localeCompare(b)).map(([mode, count]) => `${mode} ${count}`);
+  if (modeParts.length > 0) {
+    console.log(`  Class modes:        ${modeParts.join(", ")}`);
+  }
+  return 0;
+}
+
 // src/cli.ts
 function printHelp() {
   console.log(`nuvio \u2014 CLI for React + Vite
 
 Usage:
   nuvio init [options]
+  nuvio doctor [options]
+  nuvio scan [options]
+  nuvio stats [options]
+  nuvio coverage verify [options]
+  nuvio brand scan [options]
+  nuvio brand apply [options]
+
+Common options:
+  --cwd <path>          Project root (default: current directory)
+  --json                Machine-readable output (doctor, scan, stats)
+  --verbose             Show error stacks
+  -h, --help            Show help
 
-Options:
+Init options:
   --yes                 Skip confirmation
   --no-install          Patch files only; do not run package manager install
   --dry-run             Show plan only (still prompts unless --yes / CI)
@@ -1167,16 +2147,39 @@ Options:
   --strict              Fail if Tailwind is not detected
   --skip-tailwind-check Do not warn when Tailwind is missing
   --force-agent         Overwrite nuvio/AGENT.md
-  --cwd <path>          Project root (default: current directory)
-  --verbose             Show error stacks
-  -h, --help            Show help
 
-Example:
-  pnpm dlx @nuvio/cli init
+Doctor options:
+  --skip-dev-server     Skip localhost dev-server health check
+
+Coverage verify options:
+  --page <slug>         Page slug (loads nuvio/pages/<slug>.pcc.yaml)
+  --manifest <path>     Explicit PCC manifest path (overrides --page)
+  --all                 Verify every manifest in nuvio/pages/
+
+Brand scan options:
+  --page <slug>         Page slug (loads nuvio/pages/<slug>.pcc.yaml)
+  --manifest <path>     Explicit PCC manifest path (overrides --page)
+  --all                 Scan every manifest in nuvio/pages/
+
+Brand apply options:
+  --page <slug>         Page slug (loads nuvio/pages/<slug>.pcc.yaml)
+  --manifest <path>     Explicit PCC manifest path (overrides --page)
+  --all                 Apply to every manifest in nuvio/pages/
+  --dry-run             Report targets without writing source files
+
+Examples:
   pnpm dlx @nuvio/cli init --yes
+  pnpm dlx @nuvio/cli doctor
+  pnpm dlx @nuvio/cli scan --json
+  pnpm dlx @nuvio/cli stats
+  pnpm dlx @nuvio/cli coverage verify --page dashboard --cwd apps/tailadmin-dogfood
+  pnpm dlx @nuvio/cli coverage verify --all --cwd apps/tailadmin-dogfood
+  pnpm dlx @nuvio/cli brand scan --page dashboard --cwd apps/tailadmin-dogfood
+  pnpm dlx @nuvio/cli brand scan --all --cwd apps/tailadmin-dogfood
+  pnpm dlx @nuvio/cli brand apply --all --cwd apps/tailadmin-dogfood
 `);
 }
-function parseArgs(argv) {
+function parseInitArgs(argv) {
   const args = argv.slice(2);
   let command = null;
   const opts = { cwd: process.cwd() };
@@ -1201,7 +2204,7 @@ function parseArgs(argv) {
     else if (arg === "--pm") {
       opts.pm = args[++i];
     } else if (arg === "--cwd") {
-      opts.cwd = resolve(args[++i] ?? ".");
+      opts.cwd = resolve4(args[++i] ?? ".");
     } else if (arg.startsWith("-")) {
       console.error(`Unknown option: ${arg}`);
       help = true;
@@ -1209,10 +2212,161 @@ function parseArgs(argv) {
   }
   return { command, opts, help };
 }
+function parseProjectCommandArgs(argv, command) {
+  const args = argv.slice(2);
+  const common = { cwd: process.cwd() };
+  const doctor = { ...common };
+  let help = false;
+  let i = args[0] === command ? 1 : 0;
+  for (; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "-h" || arg === "--help") {
+      help = true;
+      continue;
+    }
+    if (arg === "--json") {
+      common.json = true;
+      doctor.json = true;
+    } else if (arg === "--verbose") {
+      common.verbose = true;
+      doctor.verbose = true;
+    } else if (arg === "--cwd") {
+      const cwd = resolve4(args[++i] ?? ".");
+      common.cwd = cwd;
+      doctor.cwd = cwd;
+    } else if (arg === "--skip-dev-server") {
+      doctor.skipDevServer = true;
+    } else if (arg.startsWith("-")) {
+      console.error(`Unknown option: ${arg}`);
+      help = true;
+    }
+  }
+  return { command, common, doctor, help };
+}
+function parseCoverageVerifyArgs(argv) {
+  const args = argv.slice(2);
+  const common = { cwd: process.cwd() };
+  let help = false;
+  let page;
+  let manifest;
+  let all = false;
+  let i = 0;
+  if (args[0] === "coverage") {
+    i = 1;
+  }
+  const subcommand = args[i] === "verify" ? "verify" : "";
+  if (subcommand) {
+    i += 1;
+  }
+  for (; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "-h" || arg === "--help") {
+      help = true;
+      continue;
+    }
+    if (arg === "--json") {
+      common.json = true;
+    } else if (arg === "--verbose") {
+      common.verbose = true;
+    } else if (arg === "--cwd") {
+      common.cwd = resolve4(args[++i] ?? ".");
+    } else if (arg === "--page") {
+      page = args[++i];
+    } else if (arg === "--manifest") {
+      manifest = resolve4(args[++i] ?? "");
+    } else if (arg === "--all") {
+      all = true;
+    } else if (arg.startsWith("-")) {
+      console.error(`Unknown option: ${arg}`);
+      help = true;
+    }
+  }
+  return { command: "coverage", subcommand, common, page, manifest, all, help };
+}
+function parseBrandArgs(argv) {
+  const args = argv.slice(2);
+  const common = { cwd: process.cwd() };
+  let help = false;
+  let page;
+  let manifest;
+  let all = false;
+  let dryRun = false;
+  let i = 0;
+  if (args[0] === "brand") {
+    i = 1;
+  }
+  const subArg = args[i];
+  const subcommand = subArg === "scan" || subArg === "apply" ? subArg : "";
+  if (subcommand) {
+    i += 1;
+  }
+  for (; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "-h" || arg === "--help") {
+      help = true;
+      continue;
+    }
+    if (arg === "--json") {
+      common.json = true;
+    } else if (arg === "--verbose") {
+      common.verbose = true;
+    } else if (arg === "--cwd") {
+      common.cwd = resolve4(args[++i] ?? ".");
+    } else if (arg === "--page") {
+      page = args[++i];
+    } else if (arg === "--manifest") {
+      manifest = resolve4(args[++i] ?? "");
+    } else if (arg === "--all") {
+      all = true;
+    } else if (arg === "--dry-run") {
+      dryRun = true;
+    } else if (arg.startsWith("-")) {
+      console.error(`Unknown option: ${arg}`);
+      help = true;
+    }
+  }
+  return { command: "brand", subcommand, common, page, manifest, all, dryRun, help };
+}
 async function runCli(argv) {
   registerTelemetrySignalHandlers();
-  const { command, opts, help } = parseArgs(argv);
-  captureCliInvoked(resolveCliInvokedCommand(help, command), opts.pm);
+  const rawCommand = argv[2] ?? null;
+  const isCoverageCmd = rawCommand === "coverage";
+  const isBrandCmd = rawCommand === "brand";
+  const isProjectCmd = rawCommand === "doctor" || rawCommand === "scan" || rawCommand === "stats" || isCoverageCmd || isBrandCmd;
+  let help = false;
+  let command = rawCommand;
+  let initOpts = { cwd: process.cwd() };
+  let commonOpts = { cwd: process.cwd() };
+  let doctorOpts = { cwd: process.cwd() };
+  let coverageOpts = null;
+  let brandOpts = null;
+  if (isBrandCmd) {
+    brandOpts = parseBrandArgs(argv);
+    help = brandOpts.help;
+    command = brandOpts.command;
+    commonOpts = brandOpts.common;
+  } else if (isCoverageCmd) {
+    coverageOpts = parseCoverageVerifyArgs(argv);
+    help = coverageOpts.help;
+    command = coverageOpts.command;
+    commonOpts = coverageOpts.common;
+  } else if (isProjectCmd) {
+    const parsed = parseProjectCommandArgs(argv, rawCommand);
+    help = parsed.help;
+    command = parsed.command;
+    commonOpts = parsed.common;
+    doctorOpts = parsed.doctor;
+  } else {
+    const parsed = parseInitArgs(argv);
+    help = parsed.help;
+    command = parsed.command;
+    initOpts = parsed.opts;
+  }
+  const cwd = isProjectCmd ? commonOpts.cwd : initOpts.cwd;
+  captureCliInvoked(
+    resolveCliInvokedCommand(help, command),
+    isProjectCmd ? void 0 : initOpts.pm
+  );
   try {
     if (help) {
       printHelp();
@@ -1222,19 +2376,78 @@ async function runCli(argv) {
       printHelp();
       return 1;
     }
-    if (command !== "init") {
-      console.error(`Unknown command: ${command}`);
-      printHelp();
-      return 1;
+    switch (command) {
+      case "init":
+        return await runInit(initOpts);
+      case "doctor":
+        return await runDoctor({
+          cwd: doctorOpts.cwd,
+          json: doctorOpts.json,
+          checkDevServer: !doctorOpts.skipDevServer
+        });
+      case "scan":
+        return runScan({ cwd: commonOpts.cwd, json: commonOpts.json });
+      case "stats":
+        return runStats({ cwd: commonOpts.cwd, json: commonOpts.json });
+      case "coverage": {
+        if (!coverageOpts || coverageOpts.subcommand !== "verify") {
+          console.error("Usage: nuvio coverage verify --page <slug>");
+          printHelp();
+          return 1;
+        }
+        if (!coverageOpts.page && !coverageOpts.manifest && !coverageOpts.all) {
+          console.error("Either --page, --manifest, or --all is required");
+          return 2;
+        }
+        return runCoverageVerify({
+          cwd: coverageOpts.common.cwd,
+          page: coverageOpts.page,
+          manifest: coverageOpts.manifest,
+          all: coverageOpts.all,
+          json: coverageOpts.common.json
+        });
+      }
+      case "brand": {
+        if (!brandOpts || brandOpts.subcommand !== "scan" && brandOpts.subcommand !== "apply") {
+          console.error("Usage: nuvio brand scan|apply --page <slug>");
+          printHelp();
+          return 1;
+        }
+        if (!brandOpts.page && !brandOpts.manifest && !brandOpts.all) {
+          console.error("Either --page, --manifest, or --all is required");
+          return 2;
+        }
+        if (brandOpts.subcommand === "scan") {
+          return runBrandScan({
+            cwd: brandOpts.common.cwd,
+            page: brandOpts.page,
+            manifest: brandOpts.manifest,
+            all: brandOpts.all,
+            json: brandOpts.common.json
+          });
+        }
+        return runBrandApply({
+          cwd: brandOpts.common.cwd,
+          page: brandOpts.page,
+          manifest: brandOpts.manifest,
+          all: brandOpts.all,
+          dryRun: brandOpts.dryRun,
+          json: brandOpts.common.json
+        });
+      }
+      default:
+        console.error(`Unknown command: ${command}`);
+        printHelp();
+        return 1;
     }
-    return await runInit(opts);
   } catch (e) {
-    const pm = detectPackageManager(opts.cwd, opts.pm);
+    const pm = detectPackageManager(cwd, initOpts.pm);
     captureCliEvent("nuvio_init_failed", {
       ...buildCliTelemetryProps(pm),
       error_code: "unexpected_error"
     });
-    if (opts.verbose) console.error(e);
+    const verbose = isProjectCmd ? commonOpts.verbose : initOpts.verbose;
+    if (verbose) console.error(e);
     else console.error("Something went wrong. Run with --verbose for details.");
     return 2;
   } finally {