@mikulgohil/ai-kit 1.10.0 → 2.0.0

package/dist/index.js

@@ -15,8 +15,10 @@ var GUIDES_DIR = path.join(PACKAGE_ROOT, "guides");
 var DOCS_SCAFFOLDS_DIR = path.join(PACKAGE_ROOT, "docs-scaffolds");
 var AGENTS_DIR = path.join(PACKAGE_ROOT, "agents");
 var CONTEXTS_DIR = path.join(PACKAGE_ROOT, "contexts");
-var VERSION = "1.10.0";
+var VERSION = "2.0.0";
+var SKILL_PREFIX = "kit-";
 var AI_KIT_CONFIG_FILE = "ai-kit.config.json";
+var BACKUP_DIR = ".ai-kit/backups";
 var GENERATED_FILES = {
   claudeMd: "CLAUDE.md",
   cursorRules: ".cursorrules",
@@ -43,16 +45,17 @@ var TEMPLATE_FRAGMENTS = [
 ];
 
 // src/commands/init.ts
-import path20 from "path";
+import path21 from "path";
 import fs9 from "fs-extra";
 import { select } from "@inquirer/prompts";
 import ora from "ora";
 
 // src/scanner/index.ts
-import path13 from "path";
+import path14 from "path";
 
 // src/utils.ts
 import fs from "fs-extra";
+import path2 from "path";
 import chalk from "chalk";
 function readJsonSafe(filePath) {
   try {
@@ -105,9 +108,91 @@ function mergeWithMarkers(existingContent, newGenerated) {
   const after = existingContent.substring(endIdx + AI_KIT_END.length);
   return `${before}${newGenerated}${after}`;
 }
+async function backupFiles(projectDir, files) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
+  const backupDir = path2.join(projectDir, BACKUP_DIR, timestamp);
+  await fs.ensureDir(backupDir);
+  let backedUp = 0;
+  for (const file of files) {
+    const fullPath = path2.join(projectDir, file);
+    if (await fs.pathExists(fullPath)) {
+      const dest = path2.join(backupDir, file);
+      await fs.ensureDir(path2.dirname(dest));
+      await fs.copy(fullPath, dest);
+      backedUp++;
+    }
+  }
+  if (backedUp === 0) {
+    await fs.remove(backupDir);
+    return "";
+  }
+  return backupDir;
+}
+async function listBackups(projectDir) {
+  const backupsRoot = path2.join(projectDir, BACKUP_DIR);
+  if (!await fs.pathExists(backupsRoot)) return [];
+  const entries = await fs.readdir(backupsRoot);
+  return entries.filter((e) => /^\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}$/.test(e)).sort().reverse();
+}
+async function restoreBackup(projectDir, backupName) {
+  const backupDir = path2.join(projectDir, BACKUP_DIR, backupName);
+  if (!await fs.pathExists(backupDir)) {
+    throw new Error(`Backup not found: ${backupName}`);
+  }
+  const restored = [];
+  async function walk(dir, rel) {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const entryRel = rel ? `${rel}/${entry.name}` : entry.name;
+      const srcPath = path2.join(dir, entry.name);
+      const destPath = path2.join(projectDir, entryRel);
+      if (entry.isDirectory()) {
+        await walk(srcPath, entryRel);
+      } else {
+        await fs.ensureDir(path2.dirname(destPath));
+        await fs.copy(srcPath, destPath, { overwrite: true });
+        restored.push(entryRel);
+      }
+    }
+  }
+  await walk(backupDir, "");
+  return restored;
+}
+function parseSections(markdown) {
+  const lines = markdown.split("\n");
+  const sections = [];
+  let current = null;
+  const contentLines = [];
+  function flush() {
+    if (current) {
+      current.content = contentLines.join("\n").trim();
+      current.raw = `${"#".repeat(current.level)} ${current.heading}
+
+${current.content}`.trim();
+      sections.push(current);
+      contentLines.length = 0;
+    }
+  }
+  for (const line of lines) {
+    const match = line.match(/^(#{1,6})\s+(.+)$/);
+    if (match) {
+      flush();
+      current = {
+        heading: match[2].trim(),
+        level: match[1].length,
+        content: "",
+        raw: ""
+      };
+    } else if (current) {
+      contentLines.push(line);
+    }
+  }
+  flush();
+  return sections;
+}
 
 // src/scanner/nextjs.ts
-import path2 from "path";
+import path3 from "path";
 function detectNextjs(projectPath, pkg) {
   const deps = {
     ...pkg.dependencies,
@@ -119,8 +204,8 @@ function detectNextjs(projectPath, pkg) {
   }
   const nextjsVersion = deps.next.replace(/[\^~>=<]/g, "");
   const nextjsMajorVersion = parseInt(nextjsVersion.split(".")[0], 10) || void 0;
-  const hasAppDir = dirExists(path2.join(projectPath, "app")) || dirExists(path2.join(projectPath, "src", "app"));
-  const hasPagesDir = dirExists(path2.join(projectPath, "pages")) || dirExists(path2.join(projectPath, "src", "pages"));
+  const hasAppDir = dirExists(path3.join(projectPath, "app")) || dirExists(path3.join(projectPath, "src", "app"));
+  const hasPagesDir = dirExists(path3.join(projectPath, "pages")) || dirExists(path3.join(projectPath, "src", "pages"));
   let routerType;
   if (hasAppDir && hasPagesDir) routerType = "hybrid";
   else if (hasAppDir) routerType = "app";
@@ -206,7 +291,7 @@ function detectOptimizely(pkg) {
 }
 
 // src/scanner/styling.ts
-import path3 from "path";
+import path4 from "path";
 function detectStyling(projectPath, pkg) {
   const deps = {
     ...pkg.dependencies,
@@ -218,7 +303,7 @@ function detectStyling(projectPath, pkg) {
     styling.push("tailwind");
     tailwindVersion = (deps.tailwindcss || deps["@tailwindcss/postcss"] || "").replace(/[\^~>=<]/g, "");
   }
-  const hasTailwindConfig = fileExists(path3.join(projectPath, "tailwind.config.js")) || fileExists(path3.join(projectPath, "tailwind.config.ts")) || fileExists(path3.join(projectPath, "tailwind.config.mjs"));
+  const hasTailwindConfig = fileExists(path4.join(projectPath, "tailwind.config.js")) || fileExists(path4.join(projectPath, "tailwind.config.ts")) || fileExists(path4.join(projectPath, "tailwind.config.mjs"));
   if (hasTailwindConfig && !styling.includes("tailwind")) {
     styling.push("tailwind");
   }
@@ -231,9 +316,9 @@ function detectStyling(projectPath, pkg) {
 }
 
 // src/scanner/typescript.ts
-import path4 from "path";
+import path5 from "path";
 function detectTypescript(projectPath) {
-  const tsconfigPath = path4.join(projectPath, "tsconfig.json");
+  const tsconfigPath = path5.join(projectPath, "tsconfig.json");
   if (!fileExists(tsconfigPath)) {
     return { typescript: false };
   }
@@ -245,18 +330,18 @@ function detectTypescript(projectPath) {
 }
 
 // src/scanner/monorepo.ts
-import path5 from "path";
+import path6 from "path";
 function detectMonorepo(projectPath, pkg) {
-  if (fileExists(path5.join(projectPath, "turbo.json"))) {
+  if (fileExists(path6.join(projectPath, "turbo.json"))) {
     return { monorepo: true, monorepoTool: "turborepo" };
   }
-  if (fileExists(path5.join(projectPath, "nx.json"))) {
+  if (fileExists(path6.join(projectPath, "nx.json"))) {
     return { monorepo: true, monorepoTool: "nx" };
   }
-  if (fileExists(path5.join(projectPath, "lerna.json"))) {
+  if (fileExists(path6.join(projectPath, "lerna.json"))) {
     return { monorepo: true, monorepoTool: "lerna" };
   }
-  if (fileExists(path5.join(projectPath, "pnpm-workspace.yaml"))) {
+  if (fileExists(path6.join(projectPath, "pnpm-workspace.yaml"))) {
     return { monorepo: true, monorepoTool: "pnpm-workspaces" };
   }
   if (pkg.workspaces) {
@@ -266,10 +351,10 @@ function detectMonorepo(projectPath, pkg) {
 }
 
 // src/scanner/package-manager.ts
-import path6 from "path";
+import path7 from "path";
 function detectPackageManager(projectPath) {
   const pkg = readJsonSafe(
-    path6.join(projectPath, "package.json")
+    path7.join(projectPath, "package.json")
   );
   if (pkg?.packageManager) {
     if (pkg.packageManager.startsWith("pnpm")) return "pnpm";
@@ -277,15 +362,15 @@ function detectPackageManager(projectPath) {
     if (pkg.packageManager.startsWith("bun")) return "bun";
     return "npm";
   }
-  if (fileExists(path6.join(projectPath, "pnpm-lock.yaml"))) return "pnpm";
-  if (fileExists(path6.join(projectPath, "yarn.lock"))) return "yarn";
-  if (fileExists(path6.join(projectPath, "bun.lockb"))) return "bun";
-  if (fileExists(path6.join(projectPath, "bun.lock"))) return "bun";
+  if (fileExists(path7.join(projectPath, "pnpm-lock.yaml"))) return "pnpm";
+  if (fileExists(path7.join(projectPath, "yarn.lock"))) return "yarn";
+  if (fileExists(path7.join(projectPath, "bun.lockb"))) return "bun";
+  if (fileExists(path7.join(projectPath, "bun.lock"))) return "bun";
   return "npm";
 }
 
 // src/scanner/figma.ts
-import path7 from "path";
+import path8 from "path";
 function detectFigma(projectPath, pkg) {
   return {
     figmaMcp: detectFigmaMcp(projectPath),
@@ -297,9 +382,9 @@ function detectFigma(projectPath, pkg) {
 }
 function detectFigmaMcp(projectPath) {
   const settingsPaths = [
-    path7.join(projectPath, ".claude", "settings.json"),
-    path7.join(projectPath, ".claude", "settings.local.json"),
-    path7.join(projectPath, ".mcp.json")
+    path8.join(projectPath, ".claude", "settings.json"),
+    path8.join(projectPath, ".claude", "settings.local.json"),
+    path8.join(projectPath, ".mcp.json")
   ];
   for (const settingsPath of settingsPaths) {
     const content = readFileSafe(settingsPath);
@@ -320,28 +405,28 @@ function detectFigmaCodeCli(pkg) {
 }
 function detectDesignTokens(projectPath) {
   const tokenPaths = [
-    path7.join(projectPath, "tokens.json"),
-    path7.join(projectPath, "tokens"),
-    path7.join(projectPath, "design-tokens.json"),
-    path7.join(projectPath, "src", "tokens")
+    path8.join(projectPath, "tokens.json"),
+    path8.join(projectPath, "tokens"),
+    path8.join(projectPath, "design-tokens.json"),
+    path8.join(projectPath, "src", "tokens")
   ];
   for (const tokenPath of tokenPaths) {
     if (fileExists(tokenPath)) return true;
   }
   const globalsCss = readFileSafe(
-    path7.join(projectPath, "src", "app", "globals.css")
+    path8.join(projectPath, "src", "app", "globals.css")
   );
   if (globalsCss && globalsCss.includes("@theme")) return true;
   return false;
 }
 function detectTokenFormat(projectPath) {
   const globalsCss = readFileSafe(
-    path7.join(projectPath, "src", "app", "globals.css")
+    path8.join(projectPath, "src", "app", "globals.css")
   );
   if (globalsCss && globalsCss.includes("@theme")) return "tailwind-v4";
   const twConfigPaths = [
-    path7.join(projectPath, "tailwind.config.ts"),
-    path7.join(projectPath, "tailwind.config.js")
+    path8.join(projectPath, "tailwind.config.ts"),
+    path8.join(projectPath, "tailwind.config.js")
   ];
   for (const twPath of twConfigPaths) {
     const content = readFileSafe(twPath);
@@ -356,12 +441,12 @@ function detectVisualTests(projectPath, pkg) {
     ...pkg.devDependencies
   };
   const hasPlaywright = "@playwright/test" in deps || "playwright" in deps;
-  const hasPlaywrightConfig = fileExists(path7.join(projectPath, "playwright.config.ts")) || fileExists(path7.join(projectPath, "playwright.config.js"));
+  const hasPlaywrightConfig = fileExists(path8.join(projectPath, "playwright.config.ts")) || fileExists(path8.join(projectPath, "playwright.config.js"));
   return hasPlaywright || hasPlaywrightConfig;
 }
 
 // src/scanner/tools.ts
-import path8 from "path";
+import path9 from "path";
 function detectTools(projectPath, pkg) {
   const deps = {
     ...pkg.dependencies,
@@ -381,13 +466,13 @@ function detectTools(projectPath, pkg) {
 }
 function detectPlaywright(projectPath, deps) {
   if ("@playwright/test" in deps) return true;
-  if (fileExists(path8.join(projectPath, "playwright.config.ts"))) return true;
-  if (fileExists(path8.join(projectPath, "playwright.config.js"))) return true;
+  if (fileExists(path9.join(projectPath, "playwright.config.ts"))) return true;
+  if (fileExists(path9.join(projectPath, "playwright.config.js"))) return true;
   return false;
 }
 function detectStorybook(projectPath, deps) {
   if ("@storybook/react" in deps) return true;
-  if (dirExists(path8.join(projectPath, ".storybook"))) return true;
+  if (dirExists(path9.join(projectPath, ".storybook"))) return true;
   return false;
 }
 function detectEslint(projectPath, deps) {
@@ -405,7 +490,7 @@ function detectEslint(projectPath, deps) {
     "eslint.config.ts"
   ];
   for (const config of eslintConfigs) {
-    if (fileExists(path8.join(projectPath, config))) return true;
+    if (fileExists(path9.join(projectPath, config))) return true;
   }
   return false;
 }
@@ -424,14 +509,14 @@ function detectPrettier(projectPath, deps) {
     "prettier.config.ts"
   ];
   for (const config of prettierConfigs) {
-    if (fileExists(path8.join(projectPath, config))) return true;
+    if (fileExists(path9.join(projectPath, config))) return true;
   }
   return false;
 }
 function detectBiome(projectPath, deps) {
   if ("@biomejs/biome" in deps) return true;
-  if (fileExists(path8.join(projectPath, "biome.json"))) return true;
-  if (fileExists(path8.join(projectPath, "biome.jsonc"))) return true;
+  if (fileExists(path9.join(projectPath, "biome.json"))) return true;
+  if (fileExists(path9.join(projectPath, "biome.jsonc"))) return true;
   return false;
 }
 function detectAxeCore(deps) {
@@ -439,13 +524,13 @@ function detectAxeCore(deps) {
 }
 function detectSnyk(projectPath, deps) {
   if ("snyk" in deps) return true;
-  if (fileExists(path8.join(projectPath, ".snyk"))) return true;
+  if (fileExists(path9.join(projectPath, ".snyk"))) return true;
   return false;
 }
 function detectKnip(projectPath, deps) {
   if ("knip" in deps) return true;
-  if (fileExists(path8.join(projectPath, "knip.json"))) return true;
-  if (fileExists(path8.join(projectPath, "knip.config.ts"))) return true;
+  if (fileExists(path9.join(projectPath, "knip.json"))) return true;
+  if (fileExists(path9.join(projectPath, "knip.config.ts"))) return true;
   return false;
 }
 function detectBundleAnalyzer(deps) {
@@ -453,12 +538,12 @@ function detectBundleAnalyzer(deps) {
 }
 
 // src/scanner/mcp.ts
-import path9 from "path";
+import path10 from "path";
 function detectMcpServers(projectPath) {
   const settingsPaths = [
-    path9.join(projectPath, ".claude", "settings.json"),
-    path9.join(projectPath, ".claude", "settings.local.json"),
-    path9.join(projectPath, ".mcp.json")
+    path10.join(projectPath, ".claude", "settings.json"),
+    path10.join(projectPath, ".claude", "settings.local.json"),
+    path10.join(projectPath, ".mcp.json")
   ];
   let combined = "";
   for (const settingsPath of settingsPaths) {
@@ -477,18 +562,18 @@ function detectMcpServers(projectPath) {
 }
 
 // src/scanner/design-tokens.ts
-import path10 from "path";
+import path11 from "path";
 function detectDesignTokens2(projectPath) {
   const globalsCss = readFileSafe(
-    path10.join(projectPath, "src", "app", "globals.css")
+    path11.join(projectPath, "src", "app", "globals.css")
   );
   if (globalsCss && globalsCss.includes("@theme")) {
     return parseThemeInline(globalsCss);
   }
   const twConfigPaths = [
-    path10.join(projectPath, "tailwind.config.ts"),
-    path10.join(projectPath, "tailwind.config.js"),
-    path10.join(projectPath, "tailwind.config.mjs")
+    path11.join(projectPath, "tailwind.config.ts"),
+    path11.join(projectPath, "tailwind.config.js"),
+    path11.join(projectPath, "tailwind.config.mjs")
   ];
   for (const twPath of twConfigPaths) {
     const content = readFileSafe(twPath);
@@ -622,7 +707,7 @@ function parseCssVariables(css) {
 }
 
 // src/scanner/static-site.ts
-import path11 from "path";
+import path12 from "path";
 import fs2 from "fs-extra";
 function detectStaticSite(projectPath, pkg) {
   const hasStaticExport = checkStaticExport(projectPath);
@@ -651,9 +736,9 @@ function detectStaticSite(projectPath, pkg) {
 }
 function checkStaticExport(projectPath) {
   const configPaths = [
-    path11.join(projectPath, "next.config.js"),
-    path11.join(projectPath, "next.config.ts"),
-    path11.join(projectPath, "next.config.mjs")
+    path12.join(projectPath, "next.config.js"),
+    path12.join(projectPath, "next.config.ts"),
+    path12.join(projectPath, "next.config.mjs")
   ];
   for (const configPath of configPaths) {
     const content = readFileSafe(configPath);
@@ -665,8 +750,8 @@ function checkStaticExport(projectPath) {
 }
 function checkGenerateStaticParams(projectPath) {
   const appDirs = [
-    path11.join(projectPath, "app"),
-    path11.join(projectPath, "src", "app")
+    path12.join(projectPath, "app"),
+    path12.join(projectPath, "src", "app")
   ];
   for (const appDir of appDirs) {
     if (dirExists(appDir) && hasPatternInDir(appDir, /generateStaticParams/)) {
@@ -674,8 +759,8 @@ function checkGenerateStaticParams(projectPath) {
     }
   }
   const pagesDirs = [
-    path11.join(projectPath, "pages"),
-    path11.join(projectPath, "src", "pages")
+    path12.join(projectPath, "pages"),
+    path12.join(projectPath, "src", "pages")
   ];
   for (const pagesDir of pagesDirs) {
     if (dirExists(pagesDir) && hasPatternInDir(pagesDir, /getStaticPaths/)) {
@@ -686,8 +771,8 @@ function checkGenerateStaticParams(projectPath) {
 }
 function checkRevalidatePatterns(projectPath) {
   const appDirs = [
-    path11.join(projectPath, "app"),
-    path11.join(projectPath, "src", "app")
+    path12.join(projectPath, "app"),
+    path12.join(projectPath, "src", "app")
   ];
   for (const appDir of appDirs) {
     if (dirExists(appDir) && hasPatternInDir(appDir, /revalidate\s*[:=]/)) {
@@ -698,8 +783,8 @@ function checkRevalidatePatterns(projectPath) {
 }
 function checkServerActions(projectPath) {
   const srcDirs = [
-    path11.join(projectPath, "app"),
-    path11.join(projectPath, "src")
+    path12.join(projectPath, "app"),
+    path12.join(projectPath, "src")
   ];
   for (const srcDir of srcDirs) {
     if (dirExists(srcDir) && hasPatternInDir(srcDir, /['"]use server['"]/)) {
@@ -710,15 +795,15 @@ function checkServerActions(projectPath) {
 }
 function checkApiRoutes(projectPath) {
   const appApiDirs = [
-    path11.join(projectPath, "app", "api"),
-    path11.join(projectPath, "src", "app", "api")
+    path12.join(projectPath, "app", "api"),
+    path12.join(projectPath, "src", "app", "api")
   ];
   for (const apiDir of appApiDirs) {
     if (dirExists(apiDir)) return true;
   }
   const pagesApiDirs = [
-    path11.join(projectPath, "pages", "api"),
-    path11.join(projectPath, "src", "pages", "api")
+    path12.join(projectPath, "pages", "api"),
+    path12.join(projectPath, "src", "pages", "api")
   ];
   for (const apiDir of pagesApiDirs) {
     if (dirExists(apiDir)) return true;
@@ -732,7 +817,7 @@ function hasPatternInDir(dir, pattern, depth = 0) {
     const entries = fs2.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (SCAN_IGNORE.includes(entry.name)) continue;
-      const full = path11.join(dir, entry.name);
+      const full = path12.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (hasPatternInDir(full, pattern, depth + 1)) return true;
       } else if (/\.(tsx?|jsx?|mjs)$/.test(entry.name)) {
@@ -746,19 +831,19 @@ function hasPatternInDir(dir, pattern, depth = 0) {
 }
 
 // src/scanner/aiignore.ts
-import path12 from "path";
+import path13 from "path";
 function loadAiIgnorePatterns(projectPath) {
-  const content = readFileSafe(path12.join(projectPath, ".aiignore"));
+  const content = readFileSafe(path13.join(projectPath, ".aiignore"));
   if (!content) return [];
   return content.split("\n").map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
 }
 
 // src/scanner/index.ts
 async function scanProject(projectPath) {
-  const pkgPath = path13.join(projectPath, "package.json");
+  const pkgPath = path14.join(projectPath, "package.json");
   const pkg = readJsonSafe(pkgPath) || {};
   const scripts = pkg.scripts || {};
-  const projectName = pkg.name || path13.basename(projectPath);
+  const projectName = pkg.name || path14.basename(projectPath);
   const nextjsResult = detectNextjs(projectPath, pkg);
   const sitecoreResult = detectSitecore(pkg);
   const optimizelyResult = detectOptimizely(pkg);
@@ -801,10 +886,10 @@ async function scanProject(projectPath) {
 }
 
 // src/generator/assembler.ts
-import path14 from "path";
+import path15 from "path";
 import fs3 from "fs-extra";
 function readTemplate(relativePath) {
-  const fullPath = path14.join(TEMPLATES_DIR, relativePath);
+  const fullPath = path15.join(TEMPLATES_DIR, relativePath);
   const content = readFileSafe(fullPath);
   if (!content) {
     throw new Error(`Template not found: ${relativePath}`);
@@ -812,12 +897,12 @@ function readTemplate(relativePath) {
   return content.trim();
 }
 function loadCustomFragments(projectPath) {
-  const customDir = path14.join(projectPath, ".ai-kit", "fragments");
+  const customDir = path15.join(projectPath, ".ai-kit", "fragments");
   if (!fs3.existsSync(customDir)) return [];
   try {
     const files = fs3.readdirSync(customDir).filter((f) => f.endsWith(".md"));
     return files.map((f) => {
-      const content = fs3.readFileSync(path14.join(customDir, f), "utf-8");
+      const content = fs3.readFileSync(path15.join(customDir, f), "utf-8");
       return content.trim();
     }).filter(Boolean);
   } catch {
@@ -1138,10 +1223,33 @@ function generateConfig(scan, templates, commands, guides, options) {
 // src/generator/hooks.ts
 function generateHooks(scan, profile = "standard") {
   const hooks = {};
+  const sessionStart = [];
   const preToolUse = [];
   const postToolUse = [];
   const postCompact = [];
   const stop = [];
+  const stackParts = [
+    scan.framework === "nextjs" ? `Next.js ${scan.nextjsVersion || ""}`.trim() : scan.framework,
+    scan.routerType ? `(${scan.routerType} router)` : "",
+    scan.cms !== "none" ? scan.cms : "",
+    scan.styling.length > 0 ? scan.styling.join(", ") : ""
+  ].filter(Boolean);
+  const scriptNames = Object.keys(scan.scripts).slice(0, 8).join(", ");
+  const stackStr = stackParts.join(" + ");
+  sessionStart.push({
+    matcher: "",
+    hooks: [
+      {
+        type: "command",
+        command: [
+          `echo "\u{1F4CB} ai-kit v${VERSION} | Stack: ${stackStr}"`,
+          `echo "   PM: ${scan.packageManager} | Scripts: ${scriptNames}"`,
+          scan.monorepo ? `echo "   Monorepo: ${scan.monorepoTool || "yes"}"` : "",
+          `if [ -f "ai-kit.config.json" ]; then SCAN_DATE=$(node -e "try{const c=JSON.parse(require('fs').readFileSync('ai-kit.config.json','utf8'));console.log(c.generatedAt?.split('T')[0]||'unknown')}catch{console.log('unknown')}" 2>/dev/null); echo "   Last scan: $SCAN_DATE"; fi`
+        ].filter(Boolean).join("\n")
+      }
+    ]
+  });
   preToolUse.push({
     matcher: "Bash(git push*)",
     hooks: [
@@ -1345,6 +1453,7 @@ function generateHooks(scan, profile = "standard") {
       ]
     });
   }
+  if (sessionStart.length > 0) hooks.SessionStart = sessionStart;
   if (preToolUse.length > 0) hooks.PreToolUse = preToolUse;
   if (postToolUse.length > 0) hooks.PostToolUse = postToolUse;
   if (postCompact.length > 0) hooks.PostCompact = postCompact;
@@ -1359,9 +1468,9 @@ function generateSettingsLocal(scan, profile = "standard") {
 }
 
 // src/copier/skills.ts
-import path15 from "path";
+import path16 from "path";
 import fs4 from "fs-extra";
-var AVAILABLE_SKILLS = [
+var BASE_SKILLS = [
   "prompt-help",
   "review",
   "fix-bug",
@@ -1413,7 +1522,8 @@ var AVAILABLE_SKILLS = [
   // New skills (v1.10.0) — documentation freshness
   "fetch-docs"
 ];
-var SKILL_DESCRIPTIONS = {
+var AVAILABLE_SKILLS = BASE_SKILLS.map((s) => `${SKILL_PREFIX}${s}`);
+var BASE_SKILL_DESCRIPTIONS = {
   "prompt-help": "Help developers write effective AI prompts with structured context",
   "review": "Deep code review following project coding standards",
   "fix-bug": "Systematic debugging workflow with root cause analysis and regression testing",
@@ -1440,7 +1550,6 @@ var SKILL_DESCRIPTIONS = {
   "responsive-check": "Audit responsive design \u2014 breakpoints, touch targets, overflow",
   "document": "Generate documentation for existing components and utilities",
   "token-tips": "Token usage optimization strategies for AI coding assistants",
-  // New skills (v1.1.0)
   "perf-audit": "Lighthouse-style performance audit covering Core Web Vitals, resource loading, and caching",
   "bundle-check": "Analyze bundle size, find heavy imports, suggest tree-shaking and code splitting",
   "i18n-check": "Find hardcoded strings, missing translation keys, and internationalization gaps",
@@ -1448,7 +1557,6 @@ var SKILL_DESCRIPTIONS = {
   "changelog": "Generate formatted changelogs from git history following Keep a Changelog format",
   "release": "Guided release workflow with versioning, changelog, tagging, and release notes",
   "storybook-gen": "Generate Storybook stories with controls, play functions, and visual tests",
-  // New skills (v1.2.0) — hooks, agents, sessions, orchestration
   "search-first": "Research-before-coding \u2014 search docs, existing patterns, and APIs before writing code",
   "quality-gate-check": "Post-implementation quality checklist \u2014 type safety, a11y, security, performance, Sitecore",
   "server-action": "Scaffold Next.js Server Actions with Zod validation, error handling, and revalidation",
@@ -1459,43 +1567,44 @@ var SKILL_DESCRIPTIONS = {
   "orchestrate": "Multi-agent orchestration \u2014 break complex tasks into subtasks and delegate to agents",
   "quality-gate": "Run comprehensive quality checks: types, lint, format, tests, bundle, a11y, security",
   "harness-audit": "Audit AI agent configuration \u2014 check CLAUDE.md, hooks, agents, skills, MCP servers",
-  // New skills (v1.7.0) — requirements clarification
   "deep-interview": "Socratic requirements gathering \u2014 structured interview to transform vague ideas into detailed specifications",
   "clarify-requirements": "Quick task clarification \u2014 identify gaps and ambiguities in under 5 minutes before coding",
-  // New skills (v1.10.0) — documentation freshness
   "fetch-docs": "Pre-load current, version-specific docs for your tech stack using Context7 MCP \u2014 run at session start to prevent outdated API usage"
 };
+var SKILL_DESCRIPTIONS = Object.fromEntries(
+  Object.entries(BASE_SKILL_DESCRIPTIONS).map(([k, v]) => [`${SKILL_PREFIX}${k}`, v])
+);
 async function copySkills(targetDir) {
   const copied = [];
   for (const skill of AVAILABLE_SKILLS) {
-    const src = path15.join(COMMANDS_DIR, `${skill}.md`);
+    const src = path16.join(COMMANDS_DIR, `${skill}.md`);
     if (!await fs4.pathExists(src)) continue;
     const content = await fs4.readFile(src, "utf-8");
     const description = SKILL_DESCRIPTIONS[skill] || skill;
-    const claudeSkillDir = path15.join(targetDir, ".claude", "skills", skill);
+    const claudeSkillDir = path16.join(targetDir, ".claude", "skills", skill);
     await fs4.ensureDir(claudeSkillDir);
     await fs4.writeFile(
-      path15.join(claudeSkillDir, "SKILL.md"),
+      path16.join(claudeSkillDir, "SKILL.md"),
       content,
       "utf-8"
     );
-    const cursorSkillDir = path15.join(targetDir, ".cursor", "skills", skill);
+    const cursorSkillDir = path16.join(targetDir, ".cursor", "skills", skill);
     await fs4.ensureDir(cursorSkillDir);
     await fs4.writeFile(
-      path15.join(cursorSkillDir, "SKILL.md"),
+      path16.join(cursorSkillDir, "SKILL.md"),
       content,
       "utf-8"
     );
-    const legacyDir = path15.join(targetDir, ".claude", "commands");
+    const legacyDir = path16.join(targetDir, ".claude", "commands");
     await fs4.ensureDir(legacyDir);
-    await fs4.copy(src, path15.join(legacyDir, `${skill}.md`), { overwrite: true });
+    await fs4.copy(src, path16.join(legacyDir, `${skill}.md`), { overwrite: true });
     copied.push(skill);
   }
   return copied;
 }
 
 // src/copier/guides.ts
-import path16 from "path";
+import path17 from "path";
 import fs5 from "fs-extra";
 var AVAILABLE_GUIDES = [
   "getting-started",
@@ -1506,12 +1615,12 @@ var AVAILABLE_GUIDES = [
   "hooks-and-agents"
 ];
 async function copyGuides(targetDir) {
-  const guidesTarget = path16.join(targetDir, "ai-kit", "guides");
+  const guidesTarget = path17.join(targetDir, "ai-kit", "guides");
   await fs5.ensureDir(guidesTarget);
   const copied = [];
   for (const guide of AVAILABLE_GUIDES) {
-    const src = path16.join(GUIDES_DIR, `${guide}.md`);
-    const dest = path16.join(guidesTarget, `${guide}.md`);
+    const src = path17.join(GUIDES_DIR, `${guide}.md`);
+    const dest = path17.join(guidesTarget, `${guide}.md`);
     if (await fs5.pathExists(src)) {
       await fs5.copy(src, dest, { overwrite: true });
       copied.push(guide);
@@ -1521,16 +1630,16 @@ async function copyGuides(targetDir) {
 }
 
 // src/copier/docs.ts
-import path17 from "path";
+import path18 from "path";
 import fs6 from "fs-extra";
 var DOC_SCAFFOLDS = ["mistakes-log", "decisions-log", "time-log"];
 async function scaffoldDocs(targetDir) {
-  const docsTarget = path17.join(targetDir, "docs");
+  const docsTarget = path18.join(targetDir, "docs");
   await fs6.ensureDir(docsTarget);
   const created = [];
   for (const doc of DOC_SCAFFOLDS) {
-    const src = path17.join(DOCS_SCAFFOLDS_DIR, `${doc}.md`);
-    const dest = path17.join(docsTarget, `${doc}.md`);
+    const src = path18.join(DOCS_SCAFFOLDS_DIR, `${doc}.md`);
+    const dest = path18.join(docsTarget, `${doc}.md`);
     if (await fs6.pathExists(dest)) {
       continue;
     }
@@ -1543,9 +1652,9 @@ async function scaffoldDocs(targetDir) {
 }
 
 // src/copier/agents.ts
-import path18 from "path";
+import path19 from "path";
 import fs7 from "fs-extra";
-var UNIVERSAL_AGENTS = [
+var BASE_UNIVERSAL_AGENTS = [
   "planner",
   "code-reviewer",
   "security-reviewer",
@@ -1560,37 +1669,38 @@ var UNIVERSAL_AGENTS = [
   "dependency-auditor",
   "api-designer"
 ];
+var UNIVERSAL_AGENTS = BASE_UNIVERSAL_AGENTS.map((a) => `${SKILL_PREFIX}${a}`);
 var CONDITIONAL_AGENTS = [
   {
-    name: "e2e-runner",
+    name: `${SKILL_PREFIX}e2e-runner`,
     condition: (scan) => scan.tools.playwright
   },
   {
-    name: "sitecore-specialist",
+    name: `${SKILL_PREFIX}sitecore-specialist`,
     condition: (scan) => scan.cms !== "none"
   },
   {
-    name: "tdd-guide",
+    name: `${SKILL_PREFIX}tdd-guide`,
     condition: (scan) => scan.tools.playwright || !!scan.scripts["test"]
   }
 ];
 async function copyAgents(targetDir, scan) {
-  const agentsTarget = path18.join(targetDir, ".claude", "agents");
+  const agentsTarget = path19.join(targetDir, ".claude", "agents");
   await fs7.ensureDir(agentsTarget);
   const copied = [];
   for (const agent of UNIVERSAL_AGENTS) {
-    const src = path18.join(AGENTS_DIR, `${agent}.md`);
+    const src = path19.join(AGENTS_DIR, `${agent}.md`);
     if (!await fs7.pathExists(src)) continue;
-    await fs7.copy(src, path18.join(agentsTarget, `${agent}.md`), {
+    await fs7.copy(src, path19.join(agentsTarget, `${agent}.md`), {
       overwrite: true
     });
     copied.push(agent);
   }
   for (const { name, condition } of CONDITIONAL_AGENTS) {
     if (!condition(scan)) continue;
-    const src = path18.join(AGENTS_DIR, `${name}.md`);
+    const src = path19.join(AGENTS_DIR, `${name}.md`);
     if (!await fs7.pathExists(src)) continue;
-    await fs7.copy(src, path18.join(agentsTarget, `${name}.md`), {
+    await fs7.copy(src, path19.join(agentsTarget, `${name}.md`), {
       overwrite: true
     });
     copied.push(name);
@@ -1599,17 +1709,17 @@ async function copyAgents(targetDir, scan) {
 }
 
 // src/copier/contexts.ts
-import path19 from "path";
+import path20 from "path";
 import fs8 from "fs-extra";
 var AVAILABLE_CONTEXTS = ["dev", "review", "research"];
 async function copyContexts(targetDir) {
-  const contextsTarget = path19.join(targetDir, ".claude", "contexts");
+  const contextsTarget = path20.join(targetDir, ".claude", "contexts");
   await fs8.ensureDir(contextsTarget);
   const copied = [];
   for (const context of AVAILABLE_CONTEXTS) {
-    const src = path19.join(CONTEXTS_DIR, `${context}.md`);
+    const src = path20.join(CONTEXTS_DIR, `${context}.md`);
     if (!await fs8.pathExists(src)) continue;
-    await fs8.copy(src, path19.join(contextsTarget, `${context}.md`), {
+    await fs8.copy(src, path20.join(contextsTarget, `${context}.md`), {
       overwrite: true
     });
     copied.push(context);
@@ -1619,10 +1729,10 @@ async function copyContexts(targetDir) {
 
 // src/commands/init.ts
 async function initCommand(targetPath) {
-  const projectDir = path20.resolve(targetPath || process.cwd());
+  const projectDir = path21.resolve(targetPath || process.cwd());
   logSection("AI Kit \u2014 Project Setup");
   logInfo(`Scanning: ${projectDir}`);
-  const configPath = path20.join(projectDir, AI_KIT_CONFIG_FILE);
+  const configPath = path21.join(projectDir, AI_KIT_CONFIG_FILE);
   let savedConfig = null;
   let reuseMode = false;
   if (fileExists(configPath)) {
@@ -1799,7 +1909,7 @@ async function selectHookProfile() {
   });
 }
 async function selectConflictStrategy(projectDir) {
-  const hasExisting = fileExists(path20.join(projectDir, GENERATED_FILES.claudeMd)) || fileExists(path20.join(projectDir, GENERATED_FILES.cursorRules));
+  const hasExisting = fileExists(path21.join(projectDir, GENERATED_FILES.claudeMd)) || fileExists(path21.join(projectDir, GENERATED_FILES.cursorRules));
   if (!hasExisting) return "overwrite";
   return select({
     message: "Existing AI config files detected. How should we handle conflicts?",
@@ -1829,7 +1939,7 @@ async function generate(projectDir, scan, tools, conflict, opts) {
     docs: []
   };
   if (tools.claude) {
-    const claudeMdPath = path20.join(projectDir, GENERATED_FILES.claudeMd);
+    const claudeMdPath = path21.join(projectDir, GENERATED_FILES.claudeMd);
     if (conflict === "overwrite" || !fileExists(claudeMdPath)) {
       const content = generateClaudeMd(scan, { strictness: opts?.strictness, customFragments: opts?.customFragments });
       await fs9.writeFile(claudeMdPath, content, "utf-8");
@@ -1841,14 +1951,14 @@ async function generate(projectDir, scan, tools, conflict, opts) {
     result.agents = await copyAgents(projectDir, scan);
     result.contexts = await copyContexts(projectDir);
     const hookProfile = opts?.hookProfile || "standard";
-    const settingsLocalPath = path20.join(projectDir, GENERATED_FILES.claudeSettingsLocal);
+    const settingsLocalPath = path21.join(projectDir, GENERATED_FILES.claudeSettingsLocal);
     const settingsLocal = generateSettingsLocal(scan, hookProfile);
-    await fs9.ensureDir(path20.dirname(settingsLocalPath));
+    await fs9.ensureDir(path21.dirname(settingsLocalPath));
     await fs9.writeJson(settingsLocalPath, settingsLocal, { spaces: 2 });
     result.hooks = true;
   }
   if (tools.cursor) {
-    const cursorPath = path20.join(projectDir, GENERATED_FILES.cursorRules);
+    const cursorPath = path21.join(projectDir, GENERATED_FILES.cursorRules);
     if (conflict === "overwrite" || !fileExists(cursorPath)) {
       const content = generateCursorRules(scan, { strictness: opts?.strictness, customFragments: opts?.customFragments });
       await fs9.writeFile(cursorPath, content, "utf-8");
@@ -1856,11 +1966,11 @@ async function generate(projectDir, scan, tools, conflict, opts) {
     } else {
       logWarning(".cursorrules exists, skipping");
     }
-    const mdcDir = path20.join(projectDir, GENERATED_FILES.cursorMdcDir);
+    const mdcDir = path21.join(projectDir, GENERATED_FILES.cursorMdcDir);
     await fs9.ensureDir(mdcDir);
     const mdcFiles = generateMdcFiles(scan);
     for (const mdc of mdcFiles) {
-      await fs9.writeFile(path20.join(mdcDir, mdc.filename), mdc.content, "utf-8");
+      await fs9.writeFile(path21.join(mdcDir, mdc.filename), mdc.content, "utf-8");
     }
     result.cursorMdcFiles = mdcFiles.length;
   }
@@ -1879,7 +1989,7 @@ async function generate(projectDir, scan, tools, conflict, opts) {
     tools
   });
   await fs9.writeJson(
-    path20.join(projectDir, AI_KIT_CONFIG_FILE),
+    path21.join(projectDir, AI_KIT_CONFIG_FILE),
     config,
     { spaces: 2 }
   );
@@ -1955,13 +2065,13 @@ function showRecommendations(scan) {
 }
 
 // src/commands/update.ts
-import path21 from "path";
+import path22 from "path";
 import fs10 from "fs-extra";
 import ora2 from "ora";
 import { confirm as confirm2 } from "@inquirer/prompts";
 async function updateCommand(targetPath) {
-  const projectDir = path21.resolve(targetPath || process.cwd());
-  const configPath = path21.join(projectDir, AI_KIT_CONFIG_FILE);
+  const projectDir = path22.resolve(targetPath || process.cwd());
+  const configPath = path22.join(projectDir, AI_KIT_CONFIG_FILE);
   if (!fileExists(configPath)) {
     logError("No ai-kit.config.json found. Run `ai-kit init` first.");
     return;
@@ -1986,6 +2096,17 @@ async function updateCommand(targetPath) {
   const spinner = ora2("Re-scanning project...").start();
   const scan = await scanProject(projectDir);
   spinner.succeed("Project re-scanned");
+  const filesToBackup = [
+    GENERATED_FILES.claudeMd,
+    GENERATED_FILES.cursorRules,
+    GENERATED_FILES.claudeSettingsLocal,
+    AI_KIT_CONFIG_FILE
+  ];
+  const backupPath = await backupFiles(projectDir, filesToBackup);
+  if (backupPath) {
+    logSuccess(`Backed up current configs to ${path22.relative(projectDir, backupPath)}`);
+  }
+  await cleanupUnprefixedFiles(projectDir);
   logSection("Updating Files");
   const strictness = existingConfig.strictness || "standard";
   const hookProfile = existingConfig.hookProfile || "standard";
@@ -1994,8 +2115,8 @@ async function updateCommand(targetPath) {
   const genOpts = { strictness, customFragments };
   logInfo(`Using saved profile \u2014 Tools: ${tools.claude && tools.cursor ? "Claude Code + Cursor" : tools.claude ? "Claude Code" : "Cursor"} \xB7 Strictness: ${strictness} \xB7 Hooks: ${hookProfile}`);
   const templates = [];
-  if (tools.claude && (existingConfig.templates.includes("CLAUDE.md") || fileExists(path21.join(projectDir, GENERATED_FILES.claudeMd)))) {
-    const claudeMdPath = path21.join(projectDir, GENERATED_FILES.claudeMd);
+  if (tools.claude && (existingConfig.templates.includes("CLAUDE.md") || fileExists(path22.join(projectDir, GENERATED_FILES.claudeMd)))) {
+    const claudeMdPath = path22.join(projectDir, GENERATED_FILES.claudeMd);
     const newContent = generateClaudeMd(scan, genOpts);
     const existing = readFileSafe(claudeMdPath);
     if (existing) {
@@ -2006,8 +2127,8 @@ async function updateCommand(targetPath) {
     templates.push("CLAUDE.md");
     logSuccess("CLAUDE.md updated");
   }
-  if (tools.cursor && (existingConfig.templates.includes(".cursorrules") || fileExists(path21.join(projectDir, GENERATED_FILES.cursorRules)))) {
-    const cursorRulesPath = path21.join(projectDir, GENERATED_FILES.cursorRules);
+  if (tools.cursor && (existingConfig.templates.includes(".cursorrules") || fileExists(path22.join(projectDir, GENERATED_FILES.cursorRules)))) {
+    const cursorRulesPath = path22.join(projectDir, GENERATED_FILES.cursorRules);
     const newContent = generateCursorRules(scan, genOpts);
     const existing = readFileSafe(cursorRulesPath);
     if (existing) {
@@ -2017,11 +2138,11 @@ async function updateCommand(targetPath) {
     }
     templates.push(".cursorrules");
     logSuccess(".cursorrules updated");
-    const mdcDir = path21.join(projectDir, GENERATED_FILES.cursorMdcDir);
+    const mdcDir = path22.join(projectDir, GENERATED_FILES.cursorMdcDir);
     await fs10.ensureDir(mdcDir);
     const mdcFiles = generateMdcFiles(scan);
     for (const mdc of mdcFiles) {
-      await fs10.writeFile(path21.join(mdcDir, mdc.filename), mdc.content, "utf-8");
+      await fs10.writeFile(path22.join(mdcDir, mdc.filename), mdc.content, "utf-8");
     }
     logSuccess(`${mdcFiles.length} .cursor/rules/*.mdc files updated`);
   }
@@ -2032,9 +2153,9 @@ async function updateCommand(targetPath) {
   const contexts = await copyContexts(projectDir);
   logSuccess(`${contexts.length} context modes updated (.claude/contexts/)`);
   if (existingConfig.hooks !== false) {
-    const settingsLocalPath = path21.join(projectDir, GENERATED_FILES.claudeSettingsLocal);
+    const settingsLocalPath = path22.join(projectDir, GENERATED_FILES.claudeSettingsLocal);
     const settingsLocal = generateSettingsLocal(scan, hookProfile);
-    await fs10.ensureDir(path21.dirname(settingsLocalPath));
+    await fs10.ensureDir(path22.dirname(settingsLocalPath));
     await fs10.writeJson(settingsLocalPath, settingsLocal, { spaces: 2 });
     logSuccess(`Hooks updated (profile: ${hookProfile})`);
   }
@@ -2052,14 +2173,44 @@ async function updateCommand(targetPath) {
   logSuccess("ai-kit.config.json updated");
   console.log("");
   logInfo("All AI configs refreshed with latest project scan.");
+  if (backupPath) {
+    logInfo("Rollback available: `ai-kit rollback --latest`");
+  }
+}
+async function cleanupUnprefixedFiles(projectDir) {
+  let cleaned = 0;
+  for (const name of BASE_SKILLS) {
+    for (const root of [".claude/skills", ".cursor/skills"]) {
+      const oldDir = path22.join(projectDir, root, name);
+      if (await fs10.pathExists(oldDir)) {
+        await fs10.remove(oldDir);
+        cleaned++;
+      }
+    }
+    const oldCmd = path22.join(projectDir, ".claude", "commands", `${name}.md`);
+    if (await fs10.pathExists(oldCmd)) {
+      await fs10.remove(oldCmd);
+      cleaned++;
+    }
+  }
+  for (const name of BASE_UNIVERSAL_AGENTS) {
+    const oldAgent = path22.join(projectDir, ".claude", "agents", `${name}.md`);
+    if (await fs10.pathExists(oldAgent)) {
+      await fs10.remove(oldAgent);
+      cleaned++;
+    }
+  }
+  if (cleaned > 0) {
+    logInfo(`Cleaned up ${cleaned} old unprefixed skill/agent files (migrated to kit- prefix)`);
+  }
 }
 
 // src/commands/reset.ts
-import path22 from "path";
+import path23 from "path";
 import fs11 from "fs-extra";
 import { confirm as confirm3 } from "@inquirer/prompts";
 async function resetCommand(targetPath) {
-  const projectDir = path22.resolve(targetPath || process.cwd());
+  const projectDir = path23.resolve(targetPath || process.cwd());
   logSection("AI Kit \u2014 Reset");
   logWarning("This will remove all AI Kit generated files:");
   logInfo(`  - ${GENERATED_FILES.claudeMd}`);
@@ -2080,42 +2231,42 @@ async function resetCommand(targetPath) {
     return;
   }
   const removed = [];
-  const claudeMdPath = path22.join(projectDir, GENERATED_FILES.claudeMd);
+  const claudeMdPath = path23.join(projectDir, GENERATED_FILES.claudeMd);
   if (fileExists(claudeMdPath)) {
     await fs11.remove(claudeMdPath);
     removed.push(GENERATED_FILES.claudeMd);
   }
-  const cursorPath = path22.join(projectDir, GENERATED_FILES.cursorRules);
+  const cursorPath = path23.join(projectDir, GENERATED_FILES.cursorRules);
   if (fileExists(cursorPath)) {
     await fs11.remove(cursorPath);
     removed.push(GENERATED_FILES.cursorRules);
   }
-  const cursorMdcDir = path22.join(projectDir, GENERATED_FILES.cursorMdcDir);
+  const cursorMdcDir = path23.join(projectDir, GENERATED_FILES.cursorMdcDir);
   if (fileExists(cursorMdcDir)) {
     await fs11.remove(cursorMdcDir);
     removed.push(GENERATED_FILES.cursorMdcDir);
   }
-  const commandsDir = path22.join(projectDir, GENERATED_FILES.claudeCommands);
+  const commandsDir = path23.join(projectDir, GENERATED_FILES.claudeCommands);
   if (fileExists(commandsDir)) {
     await fs11.remove(commandsDir);
     removed.push(GENERATED_FILES.claudeCommands);
   }
-  const claudeSkillsDir = path22.join(projectDir, GENERATED_FILES.claudeSkills);
+  const claudeSkillsDir = path23.join(projectDir, GENERATED_FILES.claudeSkills);
   if (fileExists(claudeSkillsDir)) {
     await fs11.remove(claudeSkillsDir);
     removed.push(GENERATED_FILES.claudeSkills);
   }
-  const cursorSkillsDir = path22.join(projectDir, GENERATED_FILES.cursorSkills);
+  const cursorSkillsDir = path23.join(projectDir, GENERATED_FILES.cursorSkills);
   if (fileExists(cursorSkillsDir)) {
     await fs11.remove(cursorSkillsDir);
     removed.push(GENERATED_FILES.cursorSkills);
   }
-  const aiKitDir = path22.join(projectDir, "ai-kit");
+  const aiKitDir = path23.join(projectDir, "ai-kit");
   if (fileExists(aiKitDir)) {
     await fs11.remove(aiKitDir);
     removed.push("ai-kit/");
   }
-  const configPath = path22.join(projectDir, AI_KIT_CONFIG_FILE);
+  const configPath = path23.join(projectDir, AI_KIT_CONFIG_FILE);
   if (fileExists(configPath)) {
     await fs11.remove(configPath);
     removed.push(AI_KIT_CONFIG_FILE);
@@ -2129,7 +2280,7 @@ async function resetCommand(targetPath) {
 }
 
 // src/commands/tokens.ts
-import path23 from "path";
+import path24 from "path";
 import fs12 from "fs-extra";
 import chalk2 from "chalk";
 import ora3 from "ora";
@@ -2140,14 +2291,14 @@ var PRICING = {
 };
 var PLAN_BUDGET = 20;
 function findSessionFiles() {
-  const claudeDir = path23.join(os.homedir(), ".claude", "projects");
+  const claudeDir = path24.join(os.homedir(), ".claude", "projects");
   if (!fs12.existsSync(claudeDir)) return [];
   const files = [];
   function walkDir(dir) {
     try {
       const entries = fs12.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const full = path23.join(dir, entry.name);
+        const full = path24.join(dir, entry.name);
         if (entry.isDirectory()) {
           walkDir(full);
         } else if (entry.name.endsWith(".jsonl")) {
@@ -2202,8 +2353,8 @@ function parseSessionFile(filePath) {
       const stat = fs12.statSync(filePath);
       sessionDate = stat.mtime.toISOString().slice(0, 10);
     }
-    const sessionId = path23.basename(filePath, ".jsonl");
-    const projectName = path23.basename(path23.dirname(filePath));
+    const sessionId = path24.basename(filePath, ".jsonl");
+    const projectName = path24.basename(path24.dirname(filePath));
     return {
       sessionId,
       filePath,
@@ -2425,14 +2576,14 @@ ${chalk2.bold("Model Recommendation")}`);
   printRoiEstimate(monthSessions, monthCost);
   console.log(
     `
-${chalk2.dim("Tip: Use /understand before modifying unfamiliar code \u2014")}`
+${chalk2.dim("Tip: Use /kit-understand before modifying unfamiliar code \u2014")}`
   );
   console.log(
     chalk2.dim("     it's cheaper than a failed implementation attempt.")
   );
   console.log("");
   if (options.csv) {
-    const csvPath = path23.join(process.cwd(), "token-usage.csv");
+    const csvPath = path24.join(process.cwd(), "token-usage.csv");
     const csvHeader = "Date,Sessions,Input Tokens,Output Tokens,Cache Tokens,Cost\n";
     const daily = aggregateByDate(sessions);
     const csvRows = daily.map(
@@ -2475,9 +2626,9 @@ async function exportDashboard(allSessions, todaySessions, weekSessions, monthSe
     }
   };
   const outputDir = process.cwd();
-  const dataPath = path23.join(outputDir, "token-data.json");
-  const dashboardSrc = path23.join(PACKAGE_ROOT, "templates", "token-dashboard.html");
-  const dashboardDest = path23.join(outputDir, "token-dashboard.html");
+  const dataPath = path24.join(outputDir, "token-data.json");
+  const dashboardSrc = path24.join(PACKAGE_ROOT, "templates", "token-dashboard.html");
+  const dashboardDest = path24.join(outputDir, "token-dashboard.html");
   await fs12.writeJson(dataPath, exportData, { spaces: 2 });
   logInfo(`Token data written to ${dataPath}`);
   if (await fs12.pathExists(dashboardSrc)) {
@@ -2488,9 +2639,9 @@ async function exportDashboard(allSessions, todaySessions, weekSessions, monthSe
   }
   spinner.succeed("Dashboard exported");
   try {
-    const { exec } = await import("child_process");
+    const { execFile } = await import("child_process");
     const openCmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
-    exec(`${openCmd} "${dashboardDest}"`);
+    execFile(openCmd, [dashboardDest]);
     logInfo("Opening dashboard in browser...");
   } catch {
     logInfo(`Open ${dashboardDest} in your browser to view the dashboard.`);
@@ -2498,12 +2649,12 @@ async function exportDashboard(allSessions, todaySessions, weekSessions, monthSe
 }
 
 // src/commands/doctor.ts
-import path24 from "path";
+import path25 from "path";
 import chalk3 from "chalk";
 import ora4 from "ora";
 async function doctorCommand(targetPath) {
-  const projectDir = path24.resolve(targetPath || process.cwd());
-  const configPath = path24.join(projectDir, AI_KIT_CONFIG_FILE);
+  const projectDir = path25.resolve(targetPath || process.cwd());
+  const configPath = path25.join(projectDir, AI_KIT_CONFIG_FILE);
   let passed = 0;
   let warnings = 0;
   let issues = 0;
@@ -2535,7 +2686,7 @@ async function doctorCommand(targetPath) {
   }
   for (const template of config.templates) {
     const templateFile = template === "CLAUDE.md" ? GENERATED_FILES.claudeMd : template === ".cursorrules" ? GENERATED_FILES.cursorRules : template;
-    const templatePath = path24.join(projectDir, templateFile);
+    const templatePath = path25.join(projectDir, templateFile);
     if (fileExists(templatePath)) {
       logSuccess(`${template} exists and in sync`);
       passed++;
@@ -2546,8 +2697,8 @@ async function doctorCommand(targetPath) {
   }
   const missingSkills = [];
   for (const skill of config.commands) {
-    const claudeSkillPath = path24.join(projectDir, GENERATED_FILES.claudeSkills, skill);
-    const cursorSkillPath = path24.join(projectDir, GENERATED_FILES.cursorSkills, skill);
+    const claudeSkillPath = path25.join(projectDir, GENERATED_FILES.claudeSkills, skill);
+    const cursorSkillPath = path25.join(projectDir, GENERATED_FILES.cursorSkills, skill);
     if (!fileExists(claudeSkillPath) && !fileExists(cursorSkillPath)) {
       missingSkills.push(skill);
     }
@@ -2561,10 +2712,10 @@ async function doctorCommand(targetPath) {
     );
     issues++;
   }
-  const guidesDir = path24.join(projectDir, "ai-kit", "guides");
+  const guidesDir = path25.join(projectDir, "ai-kit", "guides");
   const missingGuides = [];
   for (const guide of config.guides) {
-    const guidePath = path24.join(guidesDir, guide);
+    const guidePath = path25.join(guidesDir, guide);
     if (!fileExists(guidePath)) {
       missingGuides.push(guide);
     }
@@ -2702,13 +2853,13 @@ function compareScanResults(previous, current) {
 }
 
 // src/commands/diff.ts
-import path25 from "path";
+import path26 from "path";
 import fs13 from "fs-extra";
 import chalk4 from "chalk";
 import ora5 from "ora";
 async function diffCommand(targetPath) {
-  const projectDir = path25.resolve(targetPath || process.cwd());
-  const configPath = path25.join(projectDir, AI_KIT_CONFIG_FILE);
+  const projectDir = path26.resolve(targetPath || process.cwd());
+  const configPath = path26.join(projectDir, AI_KIT_CONFIG_FILE);
   console.log(chalk4.bold("AI Kit \u2014 Diff (dry run)\n"));
   if (!fileExists(configPath)) {
     logError("No ai-kit.config.json found. Run `ai-kit init` first.");
@@ -2775,11 +2926,11 @@ async function diffCommand(targetPath) {
   if (cursorRulesStatus.status === "modified") modified++;
   else if (cursorRulesStatus.status === "added") added++;
   else unchanged++;
-  const skillsDir = path25.join(projectDir, GENERATED_FILES.claudeSkills);
+  const skillsDir = path26.join(projectDir, GENERATED_FILES.claudeSkills);
   const skillCount = countFilesInDir(skillsDir);
   console.log(chalk4.dim(`  unchanged ${GENERATED_FILES.claudeSkills}/ (${skillCount} skills)`));
   unchanged++;
-  const guidesDir = path25.join(projectDir, AI_KIT_FOLDER_NAME, "guides");
+  const guidesDir = path26.join(projectDir, AI_KIT_FOLDER_NAME, "guides");
   const guideCount = existingConfig.guides?.length || 0;
   console.log(chalk4.dim(`  unchanged ai-kit/guides/ (${guideCount} guides)`));
   unchanged++;
@@ -2888,7 +3039,7 @@ function diffStack(oldScan, newScan) {
   return changes;
 }
 function diffGeneratedFile(projectDir, filename, config, generate2, oldFragments, newFragments) {
-  const filePath = path25.join(projectDir, filename);
+  const filePath = path26.join(projectDir, filename);
   const currentContent = readFileSafe(filePath);
   const newContent = generate2();
   if (!currentContent) {
@@ -2934,7 +3085,7 @@ function countFilesInDir(dirPath) {
 }
 
 // src/commands/export.ts
-import path26 from "path";
+import path27 from "path";
 import fs14 from "fs-extra";
 import ora6 from "ora";
 import { select as select2 } from "@inquirer/prompts";
@@ -2971,9 +3122,9 @@ function toCline(content) {
 ${stripped}`;
 }
 async function exportCommand(targetPath, options) {
-  const projectDir = path26.resolve(targetPath || process.cwd());
-  const configPath = path26.join(projectDir, AI_KIT_CONFIG_FILE);
-  const claudeMdPath = path26.join(projectDir, GENERATED_FILES.claudeMd);
+  const projectDir = path27.resolve(targetPath || process.cwd());
+  const configPath = path27.join(projectDir, AI_KIT_CONFIG_FILE);
+  const claudeMdPath = path27.join(projectDir, GENERATED_FILES.claudeMd);
   logSection("AI Kit \u2014 Export");
   if (!fileExists(configPath) && !fileExists(claudeMdPath)) {
     logError("No ai-kit.config.json or CLAUDE.md found. Run `ai-kit init` first.");
@@ -3015,7 +3166,7 @@ async function exportCommand(targetPath, options) {
   for (const fmt2 of formats) {
     const target = EXPORT_TARGETS[fmt2];
     const transformer = transformers[fmt2];
-    const outputPath = path26.join(projectDir, target.file);
+    const outputPath = path27.join(projectDir, target.file);
     const transformed = transformer(claudeContent);
     await fs14.writeFile(outputPath, transformed, "utf-8");
     exported++;
@@ -3033,7 +3184,7 @@ async function exportCommand(targetPath, options) {
 }
 
 // src/commands/stats.ts
-import path27 from "path";
+import path28 from "path";
 import chalk5 from "chalk";
 var SKILL_CATEGORIES = {
   "Getting Started": ["prompt-help", "understand"],
@@ -3136,8 +3287,8 @@ var MCP_DISPLAY_NAMES = {
   perplexity: "Perplexity"
 };
 async function statsCommand(targetPath) {
-  const projectDir = path27.resolve(targetPath || process.cwd());
-  const configPath = path27.join(projectDir, AI_KIT_CONFIG_FILE);
+  const projectDir = path28.resolve(targetPath || process.cwd());
+  const configPath = path28.join(projectDir, AI_KIT_CONFIG_FILE);
   logSection("AI Kit \u2014 Project Stats");
   console.log("");
   if (!fileExists(configPath)) {
@@ -3231,21 +3382,21 @@ async function statsCommand(targetPath) {
 }
 
 // src/commands/audit.ts
-import path28 from "path";
+import path29 from "path";
 import fs15 from "fs-extra";
 import chalk6 from "chalk";
 async function auditCommand(targetPath) {
-  const projectDir = path28.resolve(targetPath || process.cwd());
+  const projectDir = path29.resolve(targetPath || process.cwd());
   logSection("AI Kit \u2014 Security & Configuration Audit");
   logInfo(`Auditing: ${projectDir}`);
   const checks = [];
-  const configPath = path28.join(projectDir, AI_KIT_CONFIG_FILE);
+  const configPath = path29.join(projectDir, AI_KIT_CONFIG_FILE);
   if (fileExists(configPath)) {
     checks.push({ name: "Config file", status: "pass", message: "ai-kit.config.json found" });
   } else {
     checks.push({ name: "Config file", status: "fail", message: "ai-kit.config.json missing \u2014 run `ai-kit init`" });
   }
-  const claudeMdPath = path28.join(projectDir, GENERATED_FILES.claudeMd);
+  const claudeMdPath = path29.join(projectDir, GENERATED_FILES.claudeMd);
   const claudeMd = readFileSafe(claudeMdPath);
   if (claudeMd) {
     if (claudeMd.includes("AI-KIT:START") && claudeMd.includes("AI-KIT:END")) {
@@ -3270,7 +3421,7 @@ async function auditCommand(targetPath) {
       checks.push({ name: "Secrets in CLAUDE.md", status: "pass", message: "No secrets detected" });
     }
   }
-  const settingsLocalPath = path28.join(projectDir, GENERATED_FILES.claudeSettingsLocal);
+  const settingsLocalPath = path29.join(projectDir, GENERATED_FILES.claudeSettingsLocal);
   if (fileExists(settingsLocalPath)) {
     const settings2 = readJsonSafe(settingsLocalPath);
     if (settings2?.hooks) {
@@ -3281,14 +3432,14 @@ async function auditCommand(targetPath) {
   } else {
     checks.push({ name: "Hooks", status: "warn", message: "No hooks configured \u2014 run `ai-kit init` to generate" });
   }
-  const agentsDir = path28.join(projectDir, GENERATED_FILES.claudeAgents);
+  const agentsDir = path29.join(projectDir, GENERATED_FILES.claudeAgents);
   if (await fs15.pathExists(agentsDir)) {
     const agentFiles = (await fs15.readdir(agentsDir)).filter((f) => f.endsWith(".md"));
     if (agentFiles.length > 0) {
       checks.push({ name: "Agents", status: "pass", message: `${agentFiles.length} agent(s) configured` });
       let invalidAgents = 0;
       for (const file of agentFiles) {
-        const content = readFileSafe(path28.join(agentsDir, file));
+        const content = readFileSafe(path29.join(agentsDir, file));
         if (content && !content.startsWith("---")) {
           invalidAgents++;
         }
@@ -3302,18 +3453,18 @@ async function auditCommand(targetPath) {
   } else {
     checks.push({ name: "Agents", status: "warn", message: "No agents directory \u2014 run `ai-kit init` to generate" });
   }
-  const contextsDir = path28.join(projectDir, GENERATED_FILES.claudeContexts);
+  const contextsDir = path29.join(projectDir, GENERATED_FILES.claudeContexts);
   if (await fs15.pathExists(contextsDir)) {
     const contextFiles = (await fs15.readdir(contextsDir)).filter((f) => f.endsWith(".md"));
     checks.push({ name: "Contexts", status: contextFiles.length > 0 ? "pass" : "warn", message: `${contextFiles.length} context mode(s) available` });
   } else {
     checks.push({ name: "Contexts", status: "warn", message: "No contexts directory" });
   }
-  const skillsDir = path28.join(projectDir, GENERATED_FILES.claudeSkills);
+  const skillsDir = path29.join(projectDir, GENERATED_FILES.claudeSkills);
   if (await fs15.pathExists(skillsDir)) {
     const skillDirs = (await fs15.readdir(skillsDir)).filter(async (f) => {
       try {
-        return (await fs15.stat(path28.join(skillsDir, f))).isDirectory();
+        return (await fs15.stat(path29.join(skillsDir, f))).isDirectory();
       } catch {
         return false;
       }
@@ -3322,7 +3473,7 @@ async function auditCommand(targetPath) {
   } else {
     checks.push({ name: "Skills", status: "warn", message: "No skills directory" });
   }
-  const gitignorePath = path28.join(projectDir, ".gitignore");
+  const gitignorePath = path29.join(projectDir, ".gitignore");
   const gitignore = readFileSafe(gitignorePath);
   if (gitignore) {
     const envIgnored = gitignore.includes(".env") || gitignore.includes(".env.local");
@@ -3338,7 +3489,7 @@ async function auditCommand(targetPath) {
       checks.push({ name: "Settings gitignore", status: "warn", message: "settings.local.json not in .gitignore \u2014 may leak local config" });
     }
   }
-  const settingsPath = path28.join(projectDir, ".claude", "settings.json");
+  const settingsPath = path29.join(projectDir, ".claude", "settings.json");
   const settings = readFileSafe(settingsPath);
   if (settings) {
     const hasEnvVarsInSettings = /(?:api[_-]?key|token|secret|password)\s*[:=]\s*"[^"]+"/i.test(settings);
@@ -3371,7 +3522,7 @@ async function auditCommand(targetPath) {
 }
 
 // src/commands/health.ts
-import path29 from "path";
+import path30 from "path";
 import fs16 from "fs-extra";
 import chalk7 from "chalk";
 import ora7 from "ora";
@@ -3413,7 +3564,7 @@ function checkSetup(projectDir, config) {
       detail: `config v${config.version} \u2260 CLI v${VERSION} \u2014 run \`ai-kit update\``
     });
   }
-  const claudeMd = readFileSafe(path29.join(projectDir, GENERATED_FILES.claudeMd));
+  const claudeMd = readFileSafe(path30.join(projectDir, GENERATED_FILES.claudeMd));
   if (claudeMd && claudeMd.includes("AI-KIT:START")) {
     checks.push({ name: "CLAUDE.md", status: "pass", detail: "Present with markers" });
   } else if (claudeMd) {
@@ -3421,19 +3572,19 @@ function checkSetup(projectDir, config) {
   } else {
     checks.push({ name: "CLAUDE.md", status: "fail", detail: "Not found" });
   }
-  if (fileExists(path29.join(projectDir, GENERATED_FILES.cursorRules))) {
+  if (fileExists(path30.join(projectDir, GENERATED_FILES.cursorRules))) {
     checks.push({ name: ".cursorrules", status: "pass", detail: "Present" });
   } else {
     checks.push({ name: ".cursorrules", status: "warn", detail: "Not generated" });
   }
-  const skillsDir = path29.join(projectDir, GENERATED_FILES.claudeSkills);
+  const skillsDir = path30.join(projectDir, GENERATED_FILES.claudeSkills);
   if (dirExists(skillsDir)) {
     const count = config.commands.length;
     checks.push({ name: "Skills", status: "pass", detail: `${count} installed` });
   } else {
     checks.push({ name: "Skills", status: "warn", detail: "No skills directory" });
   }
-  const agentsDir = path29.join(projectDir, GENERATED_FILES.claudeAgents);
+  const agentsDir = path30.join(projectDir, GENERATED_FILES.claudeAgents);
   if (dirExists(agentsDir)) {
     try {
       const agentFiles = fs16.readdirSync(agentsDir).filter((f) => f.endsWith(".md"));
@@ -3444,7 +3595,7 @@ function checkSetup(projectDir, config) {
   } else {
     checks.push({ name: "Agents", status: "warn", detail: "Not configured" });
   }
-  const settingsLocal = readFileSafe(path29.join(projectDir, GENERATED_FILES.claudeSettingsLocal));
+  const settingsLocal = readFileSafe(path30.join(projectDir, GENERATED_FILES.claudeSettingsLocal));
   if (settingsLocal && settingsLocal.includes('"hooks"')) {
     checks.push({ name: "Hooks", status: "pass", detail: "Configured" });
   } else {
@@ -3454,7 +3605,7 @@ function checkSetup(projectDir, config) {
 }
 function checkSecurity(projectDir) {
   const checks = [];
-  const claudeMd = readFileSafe(path29.join(projectDir, GENERATED_FILES.claudeMd));
+  const claudeMd = readFileSafe(path30.join(projectDir, GENERATED_FILES.claudeMd));
   if (claudeMd) {
     const secretPatterns = [
       /(?:api[_-]?key|secret|token|password|credential)\s*[:=]\s*['"][^'"]+['"]/i,
@@ -3469,7 +3620,7 @@ function checkSecurity(projectDir) {
       detail: hasSecrets ? "Potential secrets detected \u2014 remove immediately" : "Clean"
     });
   }
-  const gitignore = readFileSafe(path29.join(projectDir, ".gitignore"));
+  const gitignore = readFileSafe(path30.join(projectDir, ".gitignore"));
   if (gitignore) {
     const envIgnored = gitignore.includes(".env") || gitignore.includes(".env.local");
     checks.push({
@@ -3478,7 +3629,7 @@ function checkSecurity(projectDir) {
       detail: envIgnored ? "Protected" : "NOT gitignored \u2014 add .env to .gitignore"
     });
   }
-  const settingsJson = readFileSafe(path29.join(projectDir, ".claude", "settings.json"));
+  const settingsJson = readFileSafe(path30.join(projectDir, ".claude", "settings.json"));
   if (settingsJson) {
     const hasHardcoded = /(?:api[_-]?key|token|secret|password)\s*[:=]\s*"[^"]+"/i.test(settingsJson);
     checks.push({
@@ -3587,7 +3738,7 @@ function checkDocs(projectDir) {
     { name: "Time Log", path: "docs/time-log.md" }
   ];
   for (const doc of docsToCheck) {
-    const content = readFileSafe(path29.join(projectDir, doc.path));
+    const content = readFileSafe(path30.join(projectDir, doc.path));
     if (content) {
       const hasEntries = content.includes("## 20") || content.split("---").length > 2;
       checks.push({
@@ -3602,8 +3753,8 @@ function checkDocs(projectDir) {
   return { title: "Documentation", checks };
 }
 async function healthCommand(targetPath) {
-  const projectDir = path29.resolve(targetPath || process.cwd());
-  const configPath = path29.join(projectDir, AI_KIT_CONFIG_FILE);
+  const projectDir = path30.resolve(targetPath || process.cwd());
+  const configPath = path30.join(projectDir, AI_KIT_CONFIG_FILE);
   console.log("");
   logSection("AI Kit \u2014 Project Health");
   console.log(chalk7.dim(`  ${projectDir}`));
@@ -3687,7 +3838,7 @@ async function healthCommand(targetPath) {
 }
 
 // src/commands/patterns.ts
-import path30 from "path";
+import path31 from "path";
 import fs17 from "fs-extra";
 import chalk8 from "chalk";
 import ora8 from "ora";
@@ -3774,7 +3925,7 @@ function walkTsFiles(dir, files) {
   try {
     const entries = fs17.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const full = path30.join(dir, entry.name);
+      const full = path31.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (IGNORE_DIRS.includes(entry.name)) continue;
         walkTsFiles(full, files);
@@ -3786,8 +3937,8 @@ function walkTsFiles(dir, files) {
   }
 }
 async function patternsCommand(targetPath) {
-  const projectDir = path30.resolve(targetPath || process.cwd());
-  const configPath = path30.join(projectDir, AI_KIT_CONFIG_FILE);
+  const projectDir = path31.resolve(targetPath || process.cwd());
+  const configPath = path31.join(projectDir, AI_KIT_CONFIG_FILE);
   console.log("");
   logSection("AI Kit \u2014 Pattern Library");
   console.log(chalk8.dim(`  ${projectDir}`));
@@ -3798,7 +3949,7 @@ async function patternsCommand(targetPath) {
   }
   const spinner = ora8("Scanning for code patterns...").start();
   const files = [];
-  const srcDir = path30.join(projectDir, "src");
+  const srcDir = path31.join(projectDir, "src");
   if (dirExists(srcDir)) {
     walkTsFiles(srcDir, files);
   } else {
@@ -3820,7 +3971,7 @@ async function patternsCommand(targetPath) {
           if (pattern.regex.test(lines2[i])) {
             pattern.matches.push({
               pattern: pattern.label,
-              file: path30.relative(projectDir, file),
+              file: path31.relative(projectDir, file),
               line: i + 1
             });
           }
@@ -3848,9 +3999,9 @@ async function patternsCommand(targetPath) {
     logInfo("No recognizable patterns found.");
     return;
   }
-  const outputDir = path30.join(projectDir, "ai-kit");
+  const outputDir = path31.join(projectDir, "ai-kit");
   fs17.ensureDirSync(outputDir);
-  const outputPath = path30.join(outputDir, "patterns.md");
+  const outputPath = path31.join(outputDir, "patterns.md");
   const lines = [
     "# Code Patterns",
     "",
@@ -3891,13 +4042,13 @@ async function patternsCommand(targetPath) {
 }
 
 // src/commands/dead-code.ts
-import path32 from "path";
+import path33 from "path";
 import fs19 from "fs-extra";
 import chalk9 from "chalk";
 import ora9 from "ora";
 
 // src/scanner/components.ts
-import path31 from "path";
+import path32 from "path";
 import fs18 from "fs-extra";
 var COMPONENT_DIRS = [
   "src/components",
@@ -3925,7 +4076,7 @@ function findComponentFiles(projectPath) {
   const files = [];
   const directories = /* @__PURE__ */ new Set();
   for (const dir of COMPONENT_DIRS) {
-    const fullDir = path31.join(projectPath, dir);
+    const fullDir = path32.join(projectPath, dir);
     if (dirExists(fullDir)) {
       walkForComponents(fullDir, files, directories);
     }
@@ -3936,7 +4087,7 @@ function walkForComponents(dir, files, directories) {
   try {
     const entries = fs18.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const full = path31.join(dir, entry.name);
+      const full = path32.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (IGNORE_PATTERNS.includes(entry.name)) continue;
         walkForComponents(full, files, directories);
@@ -3976,7 +4127,7 @@ function extractComponentName(filePath, content) {
     /export\s+(?:const|function)\s+(\w+)/
   );
   if (namedExport) return namedExport[1];
-  return path31.basename(filePath, ".tsx");
+  return path32.basename(filePath, ".tsx");
 }
 function extractExportType(content) {
   const hasDefault = /export\s+default\s/.test(content);
@@ -4065,7 +4216,7 @@ function extractDependencies(content) {
   for (const match of imports) {
     const importPath = match[1];
     if (importPath.startsWith(".") || importPath.startsWith("..")) {
-      const basename = path31.basename(importPath).replace(/\.\w+$/, "");
+      const basename = path32.basename(importPath).replace(/\.\w+$/, "");
       if (/^[A-Z]/.test(basename)) {
         deps.push(basename);
       }
@@ -4074,33 +4225,33 @@ function extractDependencies(content) {
   return deps;
 }
 function checkForTests(componentPath, componentName) {
-  const dir = path31.dirname(componentPath);
-  const base = path31.basename(componentPath, ".tsx");
+  const dir = path32.dirname(componentPath);
+  const base = path32.basename(componentPath, ".tsx");
   for (const suffix of TEST_SUFFIXES) {
-    if (fs18.existsSync(path31.join(dir, base + suffix))) return true;
+    if (fs18.existsSync(path32.join(dir, base + suffix))) return true;
   }
-  const testsDir = path31.join(dir, "__tests__");
+  const testsDir = path32.join(dir, "__tests__");
   if (dirExists(testsDir)) {
     for (const suffix of TEST_SUFFIXES) {
-      if (fs18.existsSync(path31.join(testsDir, base + suffix))) return true;
-      if (fs18.existsSync(path31.join(testsDir, componentName + suffix))) return true;
+      if (fs18.existsSync(path32.join(testsDir, base + suffix))) return true;
+      if (fs18.existsSync(path32.join(testsDir, componentName + suffix))) return true;
     }
   }
   return false;
 }
 function checkForStory(componentPath, componentName) {
-  const dir = path31.dirname(componentPath);
-  const base = path31.basename(componentPath, ".tsx");
+  const dir = path32.dirname(componentPath);
+  const base = path32.basename(componentPath, ".tsx");
   for (const suffix of STORY_SUFFIXES) {
-    if (fs18.existsSync(path31.join(dir, base + suffix))) return true;
-    if (fs18.existsSync(path31.join(dir, componentName + suffix))) return true;
+    if (fs18.existsSync(path32.join(dir, base + suffix))) return true;
+    if (fs18.existsSync(path32.join(dir, componentName + suffix))) return true;
   }
   return false;
 }
 function checkForAiDoc(componentPath) {
-  const dir = path31.dirname(componentPath);
-  const base = path31.basename(componentPath, ".tsx");
-  return fs18.existsSync(path31.join(dir, `${base}.ai.md`)) || fs18.existsSync(path31.join(dir, "component.ai.md"));
+  const dir = path32.dirname(componentPath);
+  const base = path32.basename(componentPath, ".tsx");
+  return fs18.existsSync(path32.join(dir, `${base}.ai.md`)) || fs18.existsSync(path32.join(dir, "component.ai.md"));
 }
 function categorizeComponent(relativePath) {
   const lower = relativePath.toLowerCase();
@@ -4118,7 +4269,7 @@ function parseComponent(filePath, projectPath) {
   const content = readFileSafe(filePath);
   if (!content) return null;
   const name = extractComponentName(filePath, content);
-  const relativePath = path31.relative(projectPath, filePath);
+  const relativePath = path32.relative(projectPath, filePath);
   return {
     name,
     filePath,
@@ -4166,7 +4317,7 @@ function collectAllFiles(dir, files) {
   try {
     const entries = fs19.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const full = path32.join(dir, entry.name);
+      const full = path33.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (IGNORE_DIRS2.includes(entry.name)) continue;
         collectAllFiles(full, files);
@@ -4178,12 +4329,12 @@ function collectAllFiles(dir, files) {
   }
 }
 function isTestOrStoryFile(filePath) {
-  const name = path32.basename(filePath).toLowerCase();
+  const name = path33.basename(filePath).toLowerCase();
   return name.includes(".test.") || name.includes(".spec.") || name.includes(".stories.") || name.includes("__tests__") || name.includes("__mocks__");
 }
 async function deadCodeCommand(targetPath) {
-  const projectDir = path32.resolve(targetPath || process.cwd());
-  const configPath = path32.join(projectDir, AI_KIT_CONFIG_FILE);
+  const projectDir = path33.resolve(targetPath || process.cwd());
+  const configPath = path33.join(projectDir, AI_KIT_CONFIG_FILE);
   console.log("");
   logSection("AI Kit \u2014 Dead Code Report");
   console.log(chalk9.dim(`  ${projectDir}`));
@@ -4200,7 +4351,7 @@ async function deadCodeCommand(targetPath) {
   }
   spinner.text = `Found ${scanResult.components.length} components. Checking imports...`;
   const allFiles = [];
-  const srcDir = path32.join(projectDir, "src");
+  const srcDir = path33.join(projectDir, "src");
   if (fs19.existsSync(srcDir)) {
     collectAllFiles(srcDir, allFiles);
   } else {
@@ -4224,7 +4375,7 @@ async function deadCodeCommand(targetPath) {
       `(?:import|from)\\s+.*['"][^'"]*(?:/|\\b)${escapeRegex(component.name)}(?:[/'"]|\\b)`
     );
     for (const [file, content] of fileContents) {
-      if (path32.resolve(file) === path32.resolve(componentFile)) continue;
+      if (path33.resolve(file) === path33.resolve(componentFile)) continue;
       if (namePattern.test(content)) {
         importCount++;
         if (isTestOrStoryFile(file)) {
@@ -4303,7 +4454,7 @@ function escapeRegex(str) {
 }
 
 // src/commands/drift.ts
-import path33 from "path";
+import path34 from "path";
 import fs20 from "fs-extra";
 import chalk10 from "chalk";
 import ora10 from "ora";
@@ -4340,11 +4491,11 @@ function parseAiDocFrontmatter(content) {
   return { props, fields };
 }
 function findAiDocPath(componentPath) {
-  const dir = path33.dirname(componentPath);
-  const base = path33.basename(componentPath, ".tsx");
+  const dir = path34.dirname(componentPath);
+  const base = path34.basename(componentPath, ".tsx");
   const candidates = [
-    path33.join(dir, `${base}.ai.md`),
-    path33.join(dir, "component.ai.md")
+    path34.join(dir, `${base}.ai.md`),
+    path34.join(dir, "component.ai.md")
   ];
   for (const candidate of candidates) {
     if (fs20.existsSync(candidate)) return candidate;
@@ -4388,8 +4539,8 @@ function analyzeDrift(component, projectDir) {
   };
 }
 async function driftCommand(targetPath) {
-  const projectDir = path33.resolve(targetPath || process.cwd());
-  const configPath = path33.join(projectDir, AI_KIT_CONFIG_FILE);
+  const projectDir = path34.resolve(targetPath || process.cwd());
+  const configPath = path34.join(projectDir, AI_KIT_CONFIG_FILE);
   console.log("");
   logSection("AI Kit \u2014 Component Drift Detector");
   console.log(chalk10.dim(`  ${projectDir}`));
@@ -4491,7 +4642,7 @@ async function driftCommand(targetPath) {
 }
 
 // src/commands/component-registry.ts
-import path34 from "path";
+import path35 from "path";
 import fs22 from "fs-extra";
 import chalk11 from "chalk";
 import ora11 from "ora";
@@ -4516,12 +4667,12 @@ function calculateHealthScore(component) {
 
 // src/commands/component-registry.ts
 async function componentRegistryCommand(targetPath) {
-  const projectDir = path34.resolve(targetPath || process.cwd());
+  const projectDir = path35.resolve(targetPath || process.cwd());
   console.log("");
   logSection("AI Kit \u2014 Component Registry");
   console.log(chalk11.dim(`  ${projectDir}`));
   console.log("");
-  if (!fileExists(path34.join(projectDir, AI_KIT_CONFIG_FILE))) {
+  if (!fileExists(path35.join(projectDir, AI_KIT_CONFIG_FILE))) {
     logWarning("ai-kit.config.json not found. Run `ai-kit init` first.");
     return;
   }
@@ -4555,20 +4706,20 @@ async function componentRegistryCommand(targetPath) {
   for (const entry of entries) {
     categories[entry.category] = (categories[entry.category] || 0) + 1;
   }
-  const pkgPath = path34.join(projectDir, "package.json");
+  const pkgPath = path35.join(projectDir, "package.json");
   const pkg = fs22.readJsonSync(pkgPath, { throws: false }) || {};
   const registry = {
     version: "1.0.0",
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    projectName: pkg.name || path34.basename(projectDir),
+    projectName: pkg.name || path35.basename(projectDir),
     totalComponents: entries.length,
     categories,
     components: entries
   };
-  const outputPath = path34.join(projectDir, "ai-kit", "component-registry.json");
-  await fs22.ensureDir(path34.dirname(outputPath));
+  const outputPath = path35.join(projectDir, "ai-kit", "component-registry.json");
+  await fs22.ensureDir(path35.dirname(outputPath));
   await fs22.writeJson(outputPath, registry, { spaces: 2 });
-  const mdPath = path34.join(projectDir, "ai-kit", "component-registry.md");
+  const mdPath = path35.join(projectDir, "ai-kit", "component-registry.md");
   const md = generateRegistryMarkdown(registry);
   await fs22.writeFile(mdPath, md, "utf-8");
   console.log("");
@@ -4628,6 +4779,220 @@ function generateRegistryMarkdown(registry) {
   return lines.join("\n");
 }
 
+// src/commands/rollback.ts
+import path36 from "path";
+import { select as select3, confirm as confirm4 } from "@inquirer/prompts";
+async function rollbackCommand(targetPath, latest) {
+  const projectDir = path36.resolve(targetPath || process.cwd());
+  const backups = await listBackups(projectDir);
+  if (backups.length === 0) {
+    logInfo("No backups found. Backups are created when you run `ai-kit update`.");
+    return;
+  }
+  logSection("Available Backups");
+  let selected;
+  if (latest) {
+    selected = backups[0];
+    logInfo(`Restoring latest backup: ${selected}`);
+  } else {
+    for (const b of backups) {
+      const label = b === backups[0] ? `${b}  (latest)` : b;
+      logInfo(label);
+    }
+    console.log("");
+    selected = await select3({
+      message: "Which backup do you want to restore?",
+      choices: backups.map((b, i) => ({
+        name: i === 0 ? `${b}  (latest)` : b,
+        value: b
+      }))
+    });
+  }
+  const proceed = await confirm4({
+    message: `Restore configs from backup ${selected}? This will overwrite current files.`,
+    default: true
+  });
+  if (!proceed) {
+    logInfo("Cancelled.");
+    return;
+  }
+  try {
+    const restored = await restoreBackup(projectDir, selected);
+    logSection("Restored Files");
+    for (const file of restored) {
+      logSuccess(`Restored: ${file}`);
+    }
+    console.log("");
+    logInfo(`Configs restored from backup ${selected}`);
+  } catch (err) {
+    logError(`Failed to restore backup: ${String(err)}`);
+  }
+}
+
+// src/commands/migrate.ts
+import path37 from "path";
+import fs23 from "fs-extra";
+import { confirm as confirm5 } from "@inquirer/prompts";
+import ora12 from "ora";
+var AI_KIT_START2 = "<!-- AI-KIT:START -->";
+var AI_KIT_END2 = "<!-- AI-KIT:END -->";
+var CUSTOM_START = "<!-- CUSTOM RULES (preserved by ai-kit) -->";
+var CUSTOM_END = "<!-- /CUSTOM RULES -->";
+async function migrateCommand(targetPath, opts) {
+  const projectDir = path37.resolve(targetPath || process.cwd());
+  const configPath = path37.join(projectDir, AI_KIT_CONFIG_FILE);
+  const dryRun = opts?.dryRun ?? false;
+  logSection("AI Kit \u2014 Migrate Existing Project");
+  const existingConfig = readJsonSafe(configPath);
+  if (existingConfig) {
+    logInfo("This project is already managed by ai-kit.");
+    logInfo("Use `ai-kit update` to refresh configs.");
+    return;
+  }
+  const claudeMdPath = path37.join(projectDir, GENERATED_FILES.claudeMd);
+  const cursorRulesPath = path37.join(projectDir, GENERATED_FILES.cursorRules);
+  const existingClaudeMd = readFileSafe(claudeMdPath);
+  const existingCursorRules = readFileSafe(cursorRulesPath);
+  if (!existingClaudeMd && !existingCursorRules) {
+    logInfo("No existing AI config files found (CLAUDE.md or .cursorrules).");
+    logInfo("Use `ai-kit init` for a fresh setup.");
+    return;
+  }
+  const spinner = ora12("Scanning project...").start();
+  const scan = await scanProject(projectDir);
+  spinner.succeed("Project scanned");
+  logSection("Detected Stack");
+  const frameworkLabel = scan.framework === "nextjs" ? `Next.js ${scan.nextjsVersion || ""} (${scan.routerType || "unknown"} router)`.trim() : scan.framework;
+  logInfo(`Framework: ${frameworkLabel}`);
+  logInfo(`CMS: ${scan.cms === "none" ? "None" : scan.cms}`);
+  logInfo(`Styling: ${scan.styling.join(", ") || "None"}`);
+  logInfo(`TypeScript: ${scan.typescript ? "Yes" : "No"}`);
+  logInfo(`Package Manager: ${scan.packageManager}`);
+  const customSections = existingClaudeMd ? parseSections(existingClaudeMd) : [];
+  const customFragments = loadCustomFragments(projectDir);
+  const strictness = "standard";
+  const hookProfile = "standard";
+  const tools = {
+    claude: true,
+    cursor: !!existingCursorRules || fileExists(path37.join(projectDir, ".cursor"))
+  };
+  const aiKitClaudeMd = generateClaudeMd(scan, { strictness, customFragments });
+  const aiKitSections = parseSections(
+    aiKitClaudeMd.replace(AI_KIT_START2, "").replace(AI_KIT_END2, "")
+  );
+  logSection("Migration Plan");
+  if (customSections.length > 0) {
+    logInfo(`Your existing CLAUDE.md has ${customSections.length} section(s):`);
+    for (const s of customSections) {
+      logSuccess(`  KEEP: "${s.heading}"`);
+    }
+  }
+  logInfo(`ai-kit will generate ${aiKitSections.length} section(s) for your stack:`);
+  for (const s of aiKitSections) {
+    logInfo(`  + ADD: "${s.heading}"`);
+  }
+  console.log("");
+  logInfo("Your custom sections will be placed at the TOP of the file.");
+  logInfo("ai-kit sections will be wrapped in AI-KIT markers below.");
+  logInfo("Future `ai-kit update` will only touch the marked section.");
+  if (dryRun) {
+    console.log("");
+    logInfo("Dry run \u2014 no files were modified.");
+    return;
+  }
+  console.log("");
+  const proceed = await confirm5({
+    message: "Apply this migration?",
+    default: true
+  });
+  if (!proceed) {
+    logInfo("Cancelled.");
+    return;
+  }
+  const filesToBackup = [
+    GENERATED_FILES.claudeMd,
+    GENERATED_FILES.cursorRules
+  ].filter((f) => fileExists(path37.join(projectDir, f)));
+  if (filesToBackup.length > 0) {
+    const backupPath = await backupFiles(projectDir, filesToBackup);
+    if (backupPath) {
+      logSuccess(
+        `Backed up existing files to ${path37.relative(projectDir, backupPath)}`
+      );
+    }
+  }
+  logSection("Migrating");
+  if (tools.claude) {
+    const customBlock = customSections.length > 0 ? `${CUSTOM_START}
+
+${customSections.map((s) => s.raw).join("\n\n")}
+
+${CUSTOM_END}
+
+` : "";
+    const merged = `${customBlock}${aiKitClaudeMd}`;
+    await fs23.writeFile(claudeMdPath, merged, "utf-8");
+    logSuccess("CLAUDE.md migrated (custom rules preserved at top)");
+  }
+  if (tools.cursor) {
+    const cursorContent = generateCursorRules(scan, {
+      strictness,
+      customFragments
+    });
+    await fs23.writeFile(cursorRulesPath, cursorContent, "utf-8");
+    logSuccess(".cursorrules generated");
+    const mdcDir = path37.join(projectDir, GENERATED_FILES.cursorMdcDir);
+    await fs23.ensureDir(mdcDir);
+    const mdcFiles = generateMdcFiles(scan);
+    for (const mdc of mdcFiles) {
+      await fs23.writeFile(path37.join(mdcDir, mdc.filename), mdc.content, "utf-8");
+    }
+    logSuccess(`${mdcFiles.length} .cursor/rules/*.mdc files generated`);
+  }
+  const commands = await copySkills(projectDir);
+  logSuccess(`${commands.length} skills copied`);
+  const agents = await copyAgents(projectDir, scan);
+  logSuccess(`${agents.length} agents copied`);
+  const contexts = await copyContexts(projectDir);
+  logSuccess(`${contexts.length} context modes copied`);
+  const settingsLocalPath = path37.join(
+    projectDir,
+    GENERATED_FILES.claudeSettingsLocal
+  );
+  const settingsLocal = generateSettingsLocal(scan, hookProfile);
+  await fs23.ensureDir(path37.dirname(settingsLocalPath));
+  await fs23.writeJson(settingsLocalPath, settingsLocal, { spaces: 2 });
+  logSuccess(`Hooks configured (profile: ${hookProfile})`);
+  const guides = await copyGuides(projectDir);
+  logSuccess(`${guides.length} guides copied`);
+  const templates = [];
+  if (tools.claude) templates.push("CLAUDE.md");
+  if (tools.cursor) templates.push(".cursorrules");
+  const config = generateConfig(scan, templates, commands, guides, {
+    strictness,
+    customFragments,
+    agents,
+    contexts,
+    hooks: true,
+    hookProfile,
+    tools
+  });
+  await fs23.writeJson(configPath, config, { spaces: 2 });
+  logSuccess("ai-kit.config.json created");
+  logSection("Migration Complete");
+  if (customSections.length > 0) {
+    logInfo(
+      `${customSections.length} custom section(s) preserved in CLAUDE.md`
+    );
+  }
+  logInfo("This project is now managed by ai-kit.");
+  logInfo("Run `ai-kit update` anytime to refresh generated sections.");
+  logInfo("Your custom rules above the AI-KIT markers will never be touched.");
+  if (filesToBackup.length > 0) {
+    logInfo("Rollback available: `ai-kit rollback --latest`");
+  }
+}
+
 // src/cli/error-handler.ts
 function withErrorHandler(fn) {
   const wrapped = async (...args) => {
@@ -4688,6 +5053,12 @@ function registerCommands(program2) {
   program2.command("component-registry").description("Generate a component registry for AI agent discovery").argument("[path]", "Project directory (defaults to current directory)").action(withErrorHandler(async (targetPath) => {
     await componentRegistryCommand(targetPath);
   }));
+  program2.command("rollback").description("Restore AI configs from a previous backup").argument("[path]", "Project directory (defaults to current directory)").option("--latest", "Restore most recent backup without selection prompt").action(withErrorHandler(async (targetPath, opts) => {
+    await rollbackCommand(targetPath, opts?.latest);
+  }));
+  program2.command("migrate").description("Adopt ai-kit in a project with existing CLAUDE.md/.cursorrules").argument("[path]", "Project directory (defaults to current directory)").option("--dry-run", "Preview migration without writing files").action(withErrorHandler(async (targetPath, opts) => {
+    await migrateCommand(targetPath, opts);
+  }));
 }
 
 // src/index.ts