claudekit-cli 3.1.0 → 3.3.0

package/dist/index.js

@@ -7159,19 +7159,29 @@ __export(exports_types, {
   GitHubReleaseSchema: () => GitHubReleaseSchema,
   GitHubReleaseAssetSchema: () => GitHubReleaseAssetSchema,
   GitHubError: () => GitHubError,
+  FoldersConfigSchema: () => FoldersConfigSchema,
   ExtractionError: () => ExtractionError,
   ExcludePatternSchema: () => ExcludePatternSchema,
   DownloadError: () => DownloadError,
+  DEFAULT_FOLDERS: () => DEFAULT_FOLDERS,
   ConfigSchema: () => ConfigSchema,
   ClaudeKitError: () => ClaudeKitError,
   AuthenticationError: () => AuthenticationError,
   AVAILABLE_KITS: () => AVAILABLE_KITS
 });
-var KitType, ExcludePatternSchema, NewCommandOptionsSchema, UpdateCommandOptionsSchema, VersionCommandOptionsSchema, UninstallCommandOptionsSchema, UpdateCliOptionsSchema, TrackedFileSchema, MetadataSchema, ConfigSchema, GitHubReleaseAssetSchema, GitHubReleaseSchema, KitConfigSchema, AVAILABLE_KITS, NEVER_COPY_PATTERNS, USER_CONFIG_PATTERNS, PROTECTED_PATTERNS, ClaudeKitError, AuthenticationError, GitHubError, DownloadError, ExtractionError, SkillsManifestSchema, SkillsMigrationError;
+var KitType, ExcludePatternSchema, FoldersConfigSchema, DEFAULT_FOLDERS, NewCommandOptionsSchema, UpdateCommandOptionsSchema, VersionCommandOptionsSchema, UninstallCommandOptionsSchema, UpdateCliOptionsSchema, TrackedFileSchema, MetadataSchema, ConfigSchema, GitHubReleaseAssetSchema, GitHubReleaseSchema, KitConfigSchema, AVAILABLE_KITS, NEVER_COPY_PATTERNS, USER_CONFIG_PATTERNS, PROTECTED_PATTERNS, ClaudeKitError, AuthenticationError, GitHubError, DownloadError, ExtractionError, SkillsManifestSchema, SkillsMigrationError;
 var init_types2 = __esm(() => {
   init_zod();
   KitType = exports_external.enum(["engineer", "marketing"]);
   ExcludePatternSchema = exports_external.string().trim().min(1, "Exclude pattern cannot be empty").max(500, "Exclude pattern too long").refine((val) => !val.startsWith("/"), "Absolute paths not allowed in exclude patterns").refine((val) => !val.includes(".."), "Path traversal not allowed in exclude patterns");
+  FoldersConfigSchema = exports_external.object({
+    docs: exports_external.string().optional(),
+    plans: exports_external.string().optional()
+  });
+  DEFAULT_FOLDERS = {
+    docs: "docs",
+    plans: "plans"
+  };
   NewCommandOptionsSchema = exports_external.object({
     dir: exports_external.string().default("."),
     kit: KitType.optional(),
@@ -7184,7 +7194,9 @@ var init_types2 = __esm(() => {
     prefix: exports_external.boolean().default(false),
     beta: exports_external.boolean().default(false),
     dryRun: exports_external.boolean().default(false),
-    refresh: exports_external.boolean().default(false)
+    refresh: exports_external.boolean().default(false),
+    docsDir: exports_external.string().optional(),
+    plansDir: exports_external.string().optional()
   });
   UpdateCommandOptionsSchema = exports_external.object({
     dir: exports_external.string().default("."),
@@ -7200,7 +7212,9 @@ var init_types2 = __esm(() => {
     dryRun: exports_external.boolean().default(false),
     forceOverwrite: exports_external.boolean().default(false),
     skipSetup: exports_external.boolean().default(false),
-    refresh: exports_external.boolean().default(false)
+    refresh: exports_external.boolean().default(false),
+    docsDir: exports_external.string().optional(),
+    plansDir: exports_external.string().optional()
   });
   VersionCommandOptionsSchema = exports_external.object({
     kit: KitType.optional(),
@@ -7241,7 +7255,8 @@ var init_types2 = __esm(() => {
     defaults: exports_external.object({
       kit: KitType.optional(),
       dir: exports_external.string().optional()
-    }).optional()
+    }).optional(),
+    folders: FoldersConfigSchema.optional()
   });
   GitHubReleaseAssetSchema = exports_external.object({
     id: exports_external.number(),
@@ -11390,9 +11405,9 @@ async function installOpenCode() {
   try {
     logger.info(`Installing ${displayName}...`);
     const { unlink: unlink2 } = await import("node:fs/promises");
-    const { join: join24 } = await import("node:path");
+    const { join: join26 } = await import("node:path");
     const { tmpdir: tmpdir3 } = await import("node:os");
-    const tempScriptPath = join24(tmpdir3(), "opencode-install.sh");
+    const tempScriptPath = join26(tmpdir3(), "opencode-install.sh");
     try {
       logger.info("Downloading OpenCode installation script...");
       await execFileAsync("curl", ["-fsSL", "https://opencode.ai/install", "-o", tempScriptPath], {
@@ -11506,12 +11521,12 @@ async function installSkillsDependencies(skillsDir) {
   }
   try {
     const { existsSync: existsSync6 } = await import("node:fs");
-    const { readFile: readFile12 } = await import("node:fs/promises");
-    const { join: join24 } = await import("node:path");
+    const { readFile: readFile13 } = await import("node:fs/promises");
+    const { join: join26 } = await import("node:path");
     const clack = await Promise.resolve().then(() => (init_dist2(), exports_dist));
     const platform9 = process.platform;
     const scriptName = platform9 === "win32" ? "install.ps1" : "install.sh";
-    const scriptPath = join24(skillsDir, scriptName);
+    const scriptPath = join26(skillsDir, scriptName);
     try {
       validateScriptPath(skillsDir, scriptPath);
     } catch (error2) {
@@ -11527,7 +11542,7 @@ async function installSkillsDependencies(skillsDir) {
       logger.warning(`Skills installation script not found: ${scriptPath}`);
       logger.info("");
       logger.info("\uD83D\uDCD6 Manual Installation Instructions:");
-      logger.info(`  See: ${join24(skillsDir, "INSTALLATION.md")}`);
+      logger.info(`  See: ${join26(skillsDir, "INSTALLATION.md")}`);
       logger.info("");
       logger.info("Quick start:");
       logger.info("  cd .claude/skills/ai-multimodal/scripts");
@@ -11543,7 +11558,7 @@ async function installSkillsDependencies(skillsDir) {
     logger.info(`  Platform: ${platform9 === "win32" ? "Windows (PowerShell)" : "Unix (bash)"}`);
     logger.info("");
     try {
-      const scriptContent = await readFile12(scriptPath, "utf-8");
+      const scriptContent = await readFile13(scriptPath, "utf-8");
       const previewLines = scriptContent.split(`
 `).slice(0, 20);
       logger.info("Script preview (first 20 lines):");
@@ -11571,7 +11586,7 @@ async function installSkillsDependencies(skillsDir) {
       logger.info(`  ${platform9 === "win32" ? `powershell -File "${scriptPath}"` : `bash ${scriptPath}`}`);
       logger.info("");
       logger.info("Or see complete guide:");
-      logger.info(`  ${join24(skillsDir, "INSTALLATION.md")}`);
+      logger.info(`  ${join26(skillsDir, "INSTALLATION.md")}`);
       return {
         success: false,
         package: displayName,
@@ -11613,8 +11628,8 @@ async function installSkillsDependencies(skillsDir) {
     logger.info("\uD83D\uDCD6 Manual Installation Instructions:");
     logger.info("");
     logger.info("See complete guide:");
-    const { join: join24 } = await import("node:path");
-    logger.info(`  cat ${join24(skillsDir, "INSTALLATION.md")}`);
+    const { join: join26 } = await import("node:path");
+    logger.info(`  cat ${join26(skillsDir, "INSTALLATION.md")}`);
     logger.info("");
     logger.info("Quick start:");
     logger.info("  cd .claude/skills/ai-multimodal/scripts");
@@ -11734,6 +11749,21 @@ var init_help_commands = __esm(() => {
             description: "Add /ck: prefix to all slash commands"
           }
         ]
+      },
+      {
+        title: "Folder Options",
+        options: [
+          {
+            flags: "--docs-dir <name>",
+            description: "Custom docs folder name to avoid conflicts with existing folders",
+            defaultValue: "docs"
+          },
+          {
+            flags: "--plans-dir <name>",
+            description: "Custom plans folder name to avoid conflicts with existing folders",
+            defaultValue: "plans"
+          }
+        ]
       }
     ]
   };
@@ -11819,6 +11849,21 @@ var init_help_commands = __esm(() => {
             description: "Override ownership protections and delete user-modified files"
           }
         ]
+      },
+      {
+        title: "Folder Options",
+        options: [
+          {
+            flags: "--docs-dir <name>",
+            description: "Custom docs folder name to avoid conflicts with existing folders",
+            defaultValue: "docs"
+          },
+          {
+            flags: "--plans-dir <name>",
+            description: "Custom plans folder name to avoid conflicts with existing folders",
+            defaultValue: "plans"
+          }
+        ]
       }
     ]
   };
@@ -12149,7 +12194,7 @@ async function basicPager(content) {
   });
   rl.on("SIGINT", () => {
     rl.close();
-    process.exit(0);
+    process.exitCode = 0;
   });
   while (currentLine < lines.length) {
     const pageLines = lines.slice(currentLine, currentLine + pageSize);
@@ -12164,7 +12209,9 @@ async function basicPager(content) {
       rl.question(`-- More (${remaining} lines) [Enter/q] --`, (answer) => {
         if (answer.toLowerCase() === "q") {
           rl.close();
-          process.exit(0);
+          process.exitCode = 0;
+          resolve6();
+          return;
         }
         process.stdout.write("\x1B[1A\x1B[2K");
         resolve6();
@@ -12413,7 +12460,7 @@ async function handleHelp(_args) {
     console.error("Error rendering help:", error2);
     return;
   }
-  process.exit(0);
+  process.exitCode = 0;
 }
 function isHelpRequested(argv) {
   return argv.includes("--help") || argv.includes("-h");
@@ -12426,7 +12473,7 @@ var init_help_interceptor = __esm(() => {
 
 // src/index.ts
 import { existsSync as existsSync7, readFileSync as readFileSync4 } from "fs";
-import { join as join29 } from "path";
+import { join as join31 } from "path";
 
 // node_modules/cac/dist/index.mjs
 import { EventEmitter } from "events";
@@ -13031,7 +13078,7 @@ var cac = (name = "") => new CAC(name);
 // package.json
 var package_default = {
   name: "claudekit-cli",
-  version: "3.1.0",
+  version: "3.3.0",
   description: "CLI tool for bootstrapping and updating ClaudeKit projects",
   type: "module",
   repository: {
@@ -15850,8 +15897,8 @@ async function doctorCommand(options = {}) {
 }
 
 // src/commands/init.ts
-var import_fs_extra16 = __toESM(require_lib(), 1);
-import { join as join24, resolve as resolve4 } from "node:path";
+var import_fs_extra17 = __toESM(require_lib(), 1);
+import { join as join26, resolve as resolve4 } from "node:path";
 
 // src/lib/commands-prefix.ts
 init_logger();
@@ -26439,6 +26486,7 @@ class DownloadManager {
     "Thumbs.db",
     "*.log"
   ];
+  static tempDirCounter = 0;
   totalExtractedSize = 0;
   ig;
   userExcludePatterns = [];
@@ -26876,7 +26924,8 @@ class DownloadManager {
   }
   async createTempDir() {
     const timestamp = Date.now();
-    const primaryTempDir = join10(tmpdir2(), `claudekit-${timestamp}`);
+    const counter = DownloadManager.tempDirCounter++;
+    const primaryTempDir = join10(tmpdir2(), `claudekit-${timestamp}-${counter}`);
     try {
       await mkdir5(primaryTempDir, { recursive: true });
       logger.debug(`Created temp directory: ${primaryTempDir}`);
@@ -26892,7 +26941,7 @@ Solutions:
   2. Set HOME environment variable
   3. Try running from a different directory`);
       }
-      const fallbackTempDir = join10(homeDir, ".claudekit", "tmp", `claudekit-${timestamp}`);
+      const fallbackTempDir = join10(homeDir, ".claudekit", "tmp", `claudekit-${timestamp}-${counter}`);
       try {
         await mkdir5(fallbackTempDir, { recursive: true });
         logger.debug(`Created temp directory (fallback): ${fallbackTempDir}`);
@@ -26925,13 +26974,235 @@ Solutions:
   }
 }
 
-// src/lib/fresh-installer.ts
+// src/lib/folder-path-transformer.ts
+init_types2();
 init_logger();
 var import_fs_extra4 = __toESM(require_lib(), 1);
-import { join as join11 } from "node:path";
+import { readFile as readFile5, readdir as readdir3, rename, writeFile as writeFile4 } from "node:fs/promises";
+import { join as join11, relative as relative3 } from "node:path";
+var TRANSFORMABLE_FILE_PATTERNS = [
+  ".md",
+  ".txt",
+  ".json",
+  ".yaml",
+  ".yml",
+  ".toml",
+  ".sh",
+  ".bash",
+  ".zsh",
+  ".ps1",
+  ".ts",
+  ".js",
+  ".mjs",
+  ".cjs"
+];
+async function transformFolderPaths(extractDir, folders, options = {}) {
+  const result = {
+    foldersRenamed: 0,
+    filesTransformed: 0,
+    totalReferences: 0
+  };
+  const needsTransform = folders.docs !== DEFAULT_FOLDERS.docs || folders.plans !== DEFAULT_FOLDERS.plans;
+  if (!needsTransform) {
+    logger.debug("No folder transformation needed (using defaults)");
+    return result;
+  }
+  logger.info("Transforming folder paths...");
+  const replacements = new Map;
+  if (folders.docs !== DEFAULT_FOLDERS.docs) {
+    replacements.set(`${DEFAULT_FOLDERS.docs}/`, `${folders.docs}/`);
+    replacements.set(`"${DEFAULT_FOLDERS.docs}"`, `"${folders.docs}"`);
+    replacements.set(`'${DEFAULT_FOLDERS.docs}'`, `'${folders.docs}'`);
+    replacements.set(`/${DEFAULT_FOLDERS.docs}`, `/${folders.docs}`);
+    replacements.set(`./${DEFAULT_FOLDERS.docs}`, `./${folders.docs}`);
+  }
+  if (folders.plans !== DEFAULT_FOLDERS.plans) {
+    replacements.set(`${DEFAULT_FOLDERS.plans}/`, `${folders.plans}/`);
+    replacements.set(`"${DEFAULT_FOLDERS.plans}"`, `"${folders.plans}"`);
+    replacements.set(`'${DEFAULT_FOLDERS.plans}'`, `'${folders.plans}'`);
+    replacements.set(`/${DEFAULT_FOLDERS.plans}`, `/${folders.plans}`);
+    replacements.set(`./${DEFAULT_FOLDERS.plans}`, `./${folders.plans}`);
+  }
+  const dirsToRename = [];
+  if (folders.docs !== DEFAULT_FOLDERS.docs) {
+    const docsPath = join11(extractDir, DEFAULT_FOLDERS.docs);
+    if (await import_fs_extra4.pathExists(docsPath)) {
+      dirsToRename.push({
+        from: docsPath,
+        to: join11(extractDir, folders.docs)
+      });
+    }
+    const claudeDocsPath = join11(extractDir, ".claude", DEFAULT_FOLDERS.docs);
+    if (await import_fs_extra4.pathExists(claudeDocsPath)) {
+      dirsToRename.push({
+        from: claudeDocsPath,
+        to: join11(extractDir, ".claude", folders.docs)
+      });
+    }
+  }
+  if (folders.plans !== DEFAULT_FOLDERS.plans) {
+    const plansPath = join11(extractDir, DEFAULT_FOLDERS.plans);
+    if (await import_fs_extra4.pathExists(plansPath)) {
+      dirsToRename.push({
+        from: plansPath,
+        to: join11(extractDir, folders.plans)
+      });
+    }
+    const claudePlansPath = join11(extractDir, ".claude", DEFAULT_FOLDERS.plans);
+    if (await import_fs_extra4.pathExists(claudePlansPath)) {
+      dirsToRename.push({
+        from: claudePlansPath,
+        to: join11(extractDir, ".claude", folders.plans)
+      });
+    }
+  }
+  for (const { from, to } of dirsToRename) {
+    if (options.dryRun) {
+      logger.info(`[dry-run] Would rename: ${relative3(extractDir, from)} → ${relative3(extractDir, to)}`);
+    } else {
+      try {
+        await rename(from, to);
+        logger.debug(`Renamed: ${relative3(extractDir, from)} → ${relative3(extractDir, to)}`);
+        result.foldersRenamed++;
+      } catch (error2) {
+        logger.warning(`Failed to rename ${from}: ${error2 instanceof Error ? error2.message : "Unknown error"}`);
+      }
+    }
+  }
+  const compiledReplacements = [];
+  for (const [search, replace3] of replacements) {
+    compiledReplacements.push({
+      regex: new RegExp(escapeRegExp(search), "g"),
+      replacement: replace3
+    });
+  }
+  const transformedFiles = await transformFileContents(extractDir, compiledReplacements, options);
+  result.filesTransformed = transformedFiles.filesChanged;
+  result.totalReferences = transformedFiles.replacementsCount;
+  if (options.verbose) {
+    logger.info(`Folder transformation complete: ${result.foldersRenamed} folders renamed, ` + `${result.filesTransformed} files updated, ${result.totalReferences} references changed`);
+  }
+  return result;
+}
+async function transformFileContents(dir, compiledReplacements, options) {
+  let filesChanged = 0;
+  let replacementsCount = 0;
+  const entries = await readdir3(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join11(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (entry.name === "node_modules" || entry.name === ".git") {
+        continue;
+      }
+      const subResult = await transformFileContents(fullPath, compiledReplacements, options);
+      filesChanged += subResult.filesChanged;
+      replacementsCount += subResult.replacementsCount;
+    } else if (entry.isFile()) {
+      const shouldTransform = TRANSFORMABLE_FILE_PATTERNS.some((ext) => entry.name.toLowerCase().endsWith(ext));
+      if (!shouldTransform)
+        continue;
+      try {
+        const content = await readFile5(fullPath, "utf-8");
+        let newContent = content;
+        let changeCount = 0;
+        for (const { regex: regex2, replacement } of compiledReplacements) {
+          regex2.lastIndex = 0;
+          const matches = newContent.match(regex2);
+          if (matches) {
+            changeCount += matches.length;
+            regex2.lastIndex = 0;
+            newContent = newContent.replace(regex2, replacement);
+          }
+        }
+        if (changeCount > 0) {
+          if (options.dryRun) {
+            logger.debug(`[dry-run] Would update ${relative3(dir, fullPath)}: ${changeCount} replacement(s)`);
+          } else {
+            await writeFile4(fullPath, newContent, "utf-8");
+            logger.debug(`Updated ${relative3(dir, fullPath)}: ${changeCount} replacement(s)`);
+          }
+          filesChanged++;
+          replacementsCount += changeCount;
+        }
+      } catch (error2) {
+        if (error2.code !== "ENOENT") {
+          logger.debug(`Skipped ${entry.name}: ${error2 instanceof Error ? error2.message : "Unknown"}`);
+        }
+      }
+    }
+  }
+  return { filesChanged, replacementsCount };
+}
+function escapeRegExp(string) {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function validateFolderOptions(options) {
+  if (options.docsDir) {
+    const docsError = validateFolderName(options.docsDir);
+    if (docsError) {
+      logger.error(`Invalid --docs-dir value: ${docsError}`);
+      process.exit(1);
+    }
+  }
+  if (options.plansDir) {
+    const plansError = validateFolderName(options.plansDir);
+    if (plansError) {
+      logger.error(`Invalid --plans-dir value: ${plansError}`);
+      process.exit(1);
+    }
+  }
+}
+function validateFolderName(name2) {
+  if (!name2 || name2.trim().length === 0) {
+    return "Folder name cannot be empty";
+  }
+  if (name2.includes("..") || name2.includes("/") || name2.includes("\\")) {
+    return "Folder name cannot contain path separators or parent references";
+  }
+  const invalidChars = /[<>:"|?*\x00-\x1f]/;
+  if (invalidChars.test(name2)) {
+    return "Folder name contains invalid characters";
+  }
+  const reservedNames = [
+    "CON",
+    "PRN",
+    "AUX",
+    "NUL",
+    "COM1",
+    "COM2",
+    "COM3",
+    "COM4",
+    "COM5",
+    "COM6",
+    "COM7",
+    "COM8",
+    "COM9",
+    "LPT1",
+    "LPT2",
+    "LPT3",
+    "LPT4",
+    "LPT5",
+    "LPT6",
+    "LPT7",
+    "LPT8",
+    "LPT9"
+  ];
+  if (reservedNames.includes(name2.toUpperCase())) {
+    return "Folder name is a reserved system name";
+  }
+  if (name2.length > 255) {
+    return "Folder name is too long (max 255 characters)";
+  }
+  return null;
+}
+
+// src/lib/fresh-installer.ts
+init_logger();
+var import_fs_extra5 = __toESM(require_lib(), 1);
+import { join as join12 } from "node:path";
 var CLAUDEKIT_SUBDIRECTORIES = ["commands", "agents", "skills", "workflows", "hooks"];
 async function handleFreshInstallation(claudeDir, prompts) {
-  if (!await import_fs_extra4.pathExists(claudeDir)) {
+  if (!await import_fs_extra5.pathExists(claudeDir)) {
     logger.info(".claude directory does not exist, proceeding with fresh installation");
     return true;
   }
@@ -26946,8 +27217,8 @@ async function handleFreshInstallation(claudeDir, prompts) {
     const { rmSync } = await import("node:fs");
     let removedCount = 0;
     for (const subdir of CLAUDEKIT_SUBDIRECTORIES) {
-      const subdirPath = join11(claudeDir, subdir);
-      if (await import_fs_extra4.pathExists(subdirPath)) {
+      const subdirPath = join12(claudeDir, subdir);
+      if (await import_fs_extra5.pathExists(subdirPath)) {
         rmSync(subdirPath, { recursive: true, force: true });
         removedCount++;
         logger.debug(`Removed subdirectory: ${subdir}/`);
@@ -26963,9 +27234,9 @@ async function handleFreshInstallation(claudeDir, prompts) {
 
 // src/lib/global-path-transformer.ts
 init_logger();
-import { readFile as readFile5, readdir as readdir3, writeFile as writeFile4 } from "node:fs/promises";
+import { readFile as readFile6, readdir as readdir4, writeFile as writeFile5 } from "node:fs/promises";
 import { platform as platform7 } from "node:os";
-import { extname, join as join12 } from "node:path";
+import { extname, join as join13 } from "node:path";
 var IS_WINDOWS = platform7() === "win32";
 var HOME_PREFIX = IS_WINDOWS ? "%USERPROFILE%" : "$HOME";
 function getHomeDirPrefix() {
@@ -27055,9 +27326,9 @@ async function transformPathsForGlobalInstall(directory, options = {}) {
   let filesSkipped = 0;
   const skippedFiles = [];
   async function processDirectory(dir) {
-    const entries = await readdir3(dir, { withFileTypes: true });
+    const entries = await readdir4(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join12(dir, entry.name);
+      const fullPath = join13(dir, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name.startsWith(".") && entry.name !== ".claude") {
           continue;
@@ -27065,10 +27336,10 @@ async function transformPathsForGlobalInstall(directory, options = {}) {
         await processDirectory(fullPath);
       } else if (entry.isFile() && shouldTransformFile(entry.name)) {
         try {
-          const content = await readFile5(fullPath, "utf-8");
+          const content = await readFile6(fullPath, "utf-8");
           const { transformed, changes } = transformContent(content);
           if (changes > 0) {
-            await writeFile4(fullPath, transformed, "utf-8");
+            await writeFile5(fullPath, transformed, "utf-8");
             filesTransformed++;
             totalChanges += changes;
             if (options.verbose) {
@@ -27096,9 +27367,9 @@ async function transformPathsForGlobalInstall(directory, options = {}) {
 
 // src/lib/merge.ts
 init_dist2();
-var import_fs_extra5 = __toESM(require_lib(), 1);
+var import_fs_extra6 = __toESM(require_lib(), 1);
 var import_ignore2 = __toESM(require_ignore(), 1);
-import { dirname as dirname3, join as join13, relative as relative3 } from "node:path";
+import { dirname as dirname3, join as join14, relative as relative4 } from "node:path";
 
 // node_modules/@isaacs/balanced-match/dist/esm/index.js
 var balanced = (a3, b3, str) => {
@@ -28572,10 +28843,10 @@ class FileMerger {
     const conflicts = [];
     const files = await this.getFiles(sourceDir, sourceDir);
     for (const file of files) {
-      const relativePath = relative3(sourceDir, file);
+      const relativePath = relative4(sourceDir, file);
       const normalizedRelativePath = relativePath.replace(/\\/g, "/");
-      const destPath = join13(destDir, relativePath);
-      if (await import_fs_extra5.pathExists(destPath)) {
+      const destPath = join14(destDir, relativePath);
+      if (await import_fs_extra6.pathExists(destPath)) {
         if (this.neverCopyChecker.ignores(normalizedRelativePath)) {
           logger.debug(`Security-sensitive file exists but won't be overwritten: ${normalizedRelativePath}`);
           continue;
@@ -28594,16 +28865,16 @@ class FileMerger {
     let copiedCount = 0;
     let skippedCount = 0;
     for (const file of files) {
-      const relativePath = relative3(sourceDir, file);
+      const relativePath = relative4(sourceDir, file);
       const normalizedRelativePath = relativePath.replace(/\\/g, "/");
-      const destPath = join13(destDir, relativePath);
+      const destPath = join14(destDir, relativePath);
       if (this.neverCopyChecker.ignores(normalizedRelativePath)) {
         logger.debug(`Skipping security-sensitive file: ${normalizedRelativePath}`);
         skippedCount++;
         continue;
       }
       if (this.userConfigChecker.ignores(normalizedRelativePath)) {
-        const fileExists = await import_fs_extra5.pathExists(destPath);
+        const fileExists = await import_fs_extra6.pathExists(destPath);
         if (fileExists) {
           logger.debug(`Skipping existing user config file: ${normalizedRelativePath}`);
           skippedCount++;
@@ -28617,7 +28888,7 @@ class FileMerger {
         copiedCount++;
         continue;
       }
-      await import_fs_extra5.copy(file, destPath, { overwrite: true });
+      await import_fs_extra6.copy(file, destPath, { overwrite: true });
       this.trackInstalledFile(normalizedRelativePath);
       copiedCount++;
     }
@@ -28625,7 +28896,7 @@ class FileMerger {
   }
   async processSettingsJson(sourceFile, destFile) {
     try {
-      const content = await import_fs_extra5.readFile(sourceFile, "utf-8");
+      const content = await import_fs_extra6.readFile(sourceFile, "utf-8");
       const isWindows5 = process.platform === "win32";
       let processedContent = content;
       if (this.isGlobal) {
@@ -28640,20 +28911,20 @@ class FileMerger {
           logger.debug("Converted Unix env var syntax to Windows syntax in settings.json");
         }
       }
-      await import_fs_extra5.writeFile(destFile, processedContent, "utf-8");
+      await import_fs_extra6.writeFile(destFile, processedContent, "utf-8");
     } catch (error2) {
       logger.error(`Failed to process settings.json: ${error2}`);
-      await import_fs_extra5.copy(sourceFile, destFile, { overwrite: true });
+      await import_fs_extra6.copy(sourceFile, destFile, { overwrite: true });
     }
   }
   async getFiles(dir, baseDir = dir) {
     const files = [];
-    const entries = await import_fs_extra5.readdir(dir, { encoding: "utf8" });
+    const entries = await import_fs_extra6.readdir(dir, { encoding: "utf8" });
     for (const entry of entries) {
-      const fullPath = join13(dir, entry);
-      const relativePath = relative3(baseDir, fullPath);
+      const fullPath = join14(dir, entry);
+      const relativePath = relative4(baseDir, fullPath);
       const normalizedRelativePath = relativePath.replace(/\\/g, "/");
-      const stats = await import_fs_extra5.lstat(fullPath);
+      const stats = await import_fs_extra6.lstat(fullPath);
       if (stats.isSymbolicLink()) {
         logger.warning(`Skipping symbolic link: ${normalizedRelativePath}`);
         continue;
@@ -28711,15 +28982,15 @@ class FileMerger {
 
 // src/lib/migration/legacy-migration.ts
 init_logger();
-var import_fs_extra7 = __toESM(require_lib(), 1);
-import { readdir as readdir5, stat as stat3 } from "node:fs/promises";
-import { join as join15, relative as relative4 } from "node:path";
+var import_fs_extra8 = __toESM(require_lib(), 1);
+import { readdir as readdir6, stat as stat3 } from "node:fs/promises";
+import { join as join16, relative as relative5 } from "node:path";
 
 // src/lib/migration/release-manifest.ts
 init_zod();
 init_logger();
-var import_fs_extra6 = __toESM(require_lib(), 1);
-import { join as join14 } from "node:path";
+var import_fs_extra7 = __toESM(require_lib(), 1);
+import { join as join15 } from "node:path";
 var ReleaseManifestFileSchema = exports_external.object({
   path: exports_external.string(),
   checksum: exports_external.string().regex(/^[a-f0-9]{64}$/),
@@ -28733,9 +29004,9 @@ var ReleaseManifestSchema = exports_external.object({
 
 class ReleaseManifestLoader {
   static async load(extractDir) {
-    const manifestPath = join14(extractDir, "release-manifest.json");
+    const manifestPath = join15(extractDir, "release-manifest.json");
     try {
-      const content = await import_fs_extra6.readFile(manifestPath, "utf-8");
+      const content = await import_fs_extra7.readFile(manifestPath, "utf-8");
       const parsed = JSON.parse(content);
       return ReleaseManifestSchema.parse(parsed);
     } catch (error2) {
@@ -28764,7 +29035,7 @@ class LegacyMigration {
     const files = [];
     let entries;
     try {
-      entries = await readdir5(dir);
+      entries = await readdir6(dir);
     } catch (err) {
       const error2 = err;
       if (error2.code === "ENOENT") {
@@ -28779,7 +29050,7 @@ class LegacyMigration {
     for (const entry of entries) {
       if (entry === "metadata.json")
         continue;
-      const fullPath = join15(dir, entry);
+      const fullPath = join16(dir, entry);
       let stats;
       try {
         stats = await stat3(fullPath);
@@ -28812,7 +29083,7 @@ class LegacyMigration {
     };
     const filesInManifest = [];
     for (const file of files) {
-      const relativePath = relative4(claudeDir, file).replace(/\\/g, "/");
+      const relativePath = relative5(claudeDir, file).replace(/\\/g, "/");
       const manifestEntry = ReleaseManifestLoader.findFile(manifest, relativePath);
       if (!manifestEntry) {
         preview.userCreated.push(relativePath);
@@ -28881,7 +29152,7 @@ User-created files (sample):`);
     ];
     if (filesToChecksum.length > 0) {
       const checksumResults = await Promise.all(filesToChecksum.map(async ({ relativePath, ownership }) => {
-        const fullPath = join15(claudeDir, relativePath);
+        const fullPath = join16(claudeDir, relativePath);
         const checksum = await OwnershipChecker.calculateChecksum(fullPath);
         return { relativePath, checksum, ownership };
       }));
@@ -28902,8 +29173,8 @@ User-created files (sample):`);
       installedAt: new Date().toISOString(),
       files: trackedFiles
     };
-    const metadataPath = join15(claudeDir, "metadata.json");
-    await import_fs_extra7.writeFile(metadataPath, JSON.stringify(updatedMetadata, null, 2));
+    const metadataPath = join16(claudeDir, "metadata.json");
+    await import_fs_extra8.writeFile(metadataPath, JSON.stringify(updatedMetadata, null, 2));
     logger.success(`Migration complete: tracked ${trackedFiles.length} files`);
     return true;
   }
@@ -29435,6 +29706,28 @@ class PromptsManager {
     }
     return updateEverything;
   }
+  async promptLocalMigration() {
+    const result = await ie({
+      message: "Local ClaudeKit installation detected. Local settings take precedence over global.",
+      options: [
+        {
+          value: "remove",
+          label: "Remove local installation",
+          hint: "Delete .claude/ and use global only"
+        },
+        {
+          value: "keep",
+          label: "Keep both installations",
+          hint: "Local will take precedence"
+        },
+        { value: "cancel", label: "Cancel", hint: "Abort global installation" }
+      ]
+    });
+    if (lD(result)) {
+      return "cancel";
+    }
+    return result;
+  }
   async promptDirectorySelection(global3 = false) {
     f2.step("Select directories to update");
     const prefix = PathResolver.getPathPrefix(global3);
@@ -29471,12 +29764,12 @@ class PromptsManager {
 // src/lib/setup-wizard.ts
 init_dist2();
 init_logger();
-var import_fs_extra9 = __toESM(require_lib(), 1);
-import { join as join17 } from "node:path";
+var import_fs_extra10 = __toESM(require_lib(), 1);
+import { join as join18 } from "node:path";
 
 // src/lib/config-generator.ts
-var import_fs_extra8 = __toESM(require_lib(), 1);
-import { join as join16 } from "node:path";
+var import_fs_extra9 = __toESM(require_lib(), 1);
+import { join as join17 } from "node:path";
 async function generateEnvFile(targetDir, values) {
   const lines = [
     "# Generated by ClaudeKit CLI setup wizard",
@@ -29488,8 +29781,8 @@ async function generateEnvFile(targetDir, values) {
       lines.push(`${key}=${value}`);
     }
   }
-  const envPath = join16(targetDir, ".env");
-  await import_fs_extra8.writeFile(envPath, `${lines.join(`
+  const envPath = join17(targetDir, ".env");
+  await import_fs_extra9.writeFile(envPath, `${lines.join(`
 `)}
 `, { mode: 384 });
 }
@@ -29533,7 +29826,7 @@ var ESSENTIAL_CONFIGS = [
 ];
 async function parseEnvFile(path9) {
   try {
-    const content = await import_fs_extra9.readFile(path9, "utf-8");
+    const content = await import_fs_extra10.readFile(path9, "utf-8");
     const env2 = {};
     for (const line of content.split(`
 `)) {
@@ -29559,8 +29852,8 @@ async function parseEnvFile(path9) {
   }
 }
 async function checkGlobalConfig() {
-  const globalEnvPath = join17(PathResolver.getGlobalKitDir(), ".env");
-  if (!await import_fs_extra9.pathExists(globalEnvPath))
+  const globalEnvPath = join18(PathResolver.getGlobalKitDir(), ".env");
+  if (!await import_fs_extra10.pathExists(globalEnvPath))
     return false;
   const env2 = await parseEnvFile(globalEnvPath);
   return Object.keys(env2).length > 0;
@@ -29575,8 +29868,8 @@ async function runSetupWizard(options) {
   let globalEnv = {};
   const hasGlobalConfig = !isGlobal && await checkGlobalConfig();
   if (!isGlobal) {
-    const globalEnvPath = join17(PathResolver.getGlobalKitDir(), ".env");
-    if (await import_fs_extra9.pathExists(globalEnvPath)) {
+    const globalEnvPath = join18(PathResolver.getGlobalKitDir(), ".env");
+    if (await import_fs_extra10.pathExists(globalEnvPath)) {
       globalEnv = await parseEnvFile(globalEnvPath);
     }
   }
@@ -29628,30 +29921,30 @@ async function runSetupWizard(options) {
     }
   }
   await generateEnvFile(targetDir, values);
-  f2.success(`Configuration saved to ${join17(targetDir, ".env")}`);
+  f2.success(`Configuration saved to ${join18(targetDir, ".env")}`);
   return true;
 }
 
 // src/lib/skills-detector.ts
 init_logger();
-var import_fs_extra11 = __toESM(require_lib(), 1);
-import { readdir as readdir7 } from "node:fs/promises";
-import { join as join19 } from "node:path";
+var import_fs_extra12 = __toESM(require_lib(), 1);
+import { readdir as readdir8 } from "node:fs/promises";
+import { join as join20 } from "node:path";
 
 // src/lib/skills-manifest.ts
 init_types2();
 init_logger();
-var import_fs_extra10 = __toESM(require_lib(), 1);
+var import_fs_extra11 = __toESM(require_lib(), 1);
 import { createHash as createHash2 } from "node:crypto";
-import { readFile as readFile9, readdir as readdir6, writeFile as writeFile8 } from "node:fs/promises";
-import { join as join18, relative as relative5 } from "node:path";
+import { readFile as readFile10, readdir as readdir7, writeFile as writeFile9 } from "node:fs/promises";
+import { join as join19, relative as relative6 } from "node:path";
 
 class SkillsManifestManager {
   static MANIFEST_FILENAME = ".skills-manifest.json";
   static MANIFEST_VERSION = "1.0.0";
   static async generateManifest(skillsDir) {
     logger.debug(`Generating manifest for: ${skillsDir}`);
-    if (!await import_fs_extra10.pathExists(skillsDir)) {
+    if (!await import_fs_extra11.pathExists(skillsDir)) {
       throw new SkillsMigrationError(`Skills directory does not exist: ${skillsDir}`);
     }
     const structure = await SkillsManifestManager.detectStructure(skillsDir);
@@ -29666,18 +29959,18 @@ class SkillsManifestManager {
     return manifest;
   }
   static async writeManifest(skillsDir, manifest) {
-    const manifestPath = join18(skillsDir, SkillsManifestManager.MANIFEST_FILENAME);
-    await writeFile8(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
+    const manifestPath = join19(skillsDir, SkillsManifestManager.MANIFEST_FILENAME);
+    await writeFile9(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
     logger.debug(`Wrote manifest to: ${manifestPath}`);
   }
   static async readManifest(skillsDir) {
-    const manifestPath = join18(skillsDir, SkillsManifestManager.MANIFEST_FILENAME);
-    if (!await import_fs_extra10.pathExists(manifestPath)) {
+    const manifestPath = join19(skillsDir, SkillsManifestManager.MANIFEST_FILENAME);
+    if (!await import_fs_extra11.pathExists(manifestPath)) {
       logger.debug(`No manifest found at: ${manifestPath}`);
       return null;
     }
     try {
-      const content = await readFile9(manifestPath, "utf-8");
+      const content = await readFile10(manifestPath, "utf-8");
       const data = JSON.parse(content);
       const manifest = SkillsManifestSchema.parse(data);
       logger.debug(`Read manifest from: ${manifestPath}`);
@@ -29688,14 +29981,14 @@ class SkillsManifestManager {
     }
   }
   static async detectStructure(skillsDir) {
-    const entries = await readdir6(skillsDir, { withFileTypes: true });
+    const entries = await readdir7(skillsDir, { withFileTypes: true });
     const dirs = entries.filter((entry) => entry.isDirectory() && entry.name !== "node_modules" && !entry.name.startsWith("."));
     if (dirs.length === 0) {
       return "flat";
     }
     for (const dir of dirs.slice(0, 3)) {
-      const dirPath = join18(skillsDir, dir.name);
-      const subEntries = await readdir6(dirPath, { withFileTypes: true });
+      const dirPath = join19(skillsDir, dir.name);
+      const subEntries = await readdir7(dirPath, { withFileTypes: true });
       const hasSubdirs = subEntries.some((entry) => entry.isDirectory());
       if (hasSubdirs) {
         return "categorized";
@@ -29710,10 +30003,10 @@ class SkillsManifestManager {
   static async scanSkills(skillsDir, structure) {
     const skills = [];
     if (structure === "flat") {
-      const entries = await readdir6(skillsDir, { withFileTypes: true });
+      const entries = await readdir7(skillsDir, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isDirectory() && entry.name !== "node_modules" && !entry.name.startsWith(".")) {
-          const skillPath = join18(skillsDir, entry.name);
+          const skillPath = join19(skillsDir, entry.name);
           const hash = await SkillsManifestManager.hashDirectory(skillPath);
           skills.push({
             name: entry.name,
@@ -29722,14 +30015,14 @@ class SkillsManifestManager {
         }
       }
     } else {
-      const categories = await readdir6(skillsDir, { withFileTypes: true });
+      const categories = await readdir7(skillsDir, { withFileTypes: true });
       for (const category of categories) {
         if (category.isDirectory() && category.name !== "node_modules" && !category.name.startsWith(".")) {
-          const categoryPath = join18(skillsDir, category.name);
-          const skillEntries = await readdir6(categoryPath, { withFileTypes: true });
+          const categoryPath = join19(skillsDir, category.name);
+          const skillEntries = await readdir7(categoryPath, { withFileTypes: true });
           for (const skillEntry of skillEntries) {
             if (skillEntry.isDirectory() && !skillEntry.name.startsWith(".")) {
-              const skillPath = join18(categoryPath, skillEntry.name);
+              const skillPath = join19(categoryPath, skillEntry.name);
               const hash = await SkillsManifestManager.hashDirectory(skillPath);
               skills.push({
                 name: skillEntry.name,
@@ -29748,8 +30041,8 @@ class SkillsManifestManager {
     const files = await SkillsManifestManager.getAllFiles(dirPath);
     files.sort();
     for (const file of files) {
-      const relativePath = relative5(dirPath, file);
-      const content = await readFile9(file);
+      const relativePath = relative6(dirPath, file);
+      const content = await readFile10(file);
       hash.update(relativePath);
       hash.update(content);
     }
@@ -29757,9 +30050,9 @@ class SkillsManifestManager {
   }
   static async getAllFiles(dirPath) {
     const files = [];
-    const entries = await readdir6(dirPath, { withFileTypes: true });
+    const entries = await readdir7(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join18(dirPath, entry.name);
+      const fullPath = join19(dirPath, entry.name);
       if (entry.name.startsWith(".") || entry.name === "node_modules") {
         continue;
       }
@@ -29879,8 +30172,8 @@ function getPathMapping(skillName, oldBasePath, newBasePath) {
 class SkillsMigrationDetector {
   static async detectMigration(oldSkillsDir, currentSkillsDir) {
     logger.debug("Detecting skills migration need...");
-    const oldExists = await import_fs_extra11.pathExists(oldSkillsDir);
-    const currentExists = await import_fs_extra11.pathExists(currentSkillsDir);
+    const oldExists = await import_fs_extra12.pathExists(oldSkillsDir);
+    const currentExists = await import_fs_extra12.pathExists(currentSkillsDir);
     if (!oldExists && !currentExists) {
       logger.debug("No skills directories found, migration not needed");
       return {
@@ -29991,10 +30284,10 @@ class SkillsMigrationDetector {
     };
   }
   static async scanDirectory(skillsDir) {
-    if (!await import_fs_extra11.pathExists(skillsDir)) {
+    if (!await import_fs_extra12.pathExists(skillsDir)) {
       return ["flat", []];
     }
-    const entries = await readdir7(skillsDir, { withFileTypes: true });
+    const entries = await readdir8(skillsDir, { withFileTypes: true });
     const dirs = entries.filter((entry) => entry.isDirectory() && entry.name !== "node_modules" && !entry.name.startsWith("."));
     if (dirs.length === 0) {
       return ["flat", []];
@@ -30002,13 +30295,13 @@ class SkillsMigrationDetector {
     let totalSkillLikeCount = 0;
     const allSkills = [];
     for (const dir of dirs) {
-      const dirPath = join19(skillsDir, dir.name);
-      const subEntries = await readdir7(dirPath, { withFileTypes: true });
+      const dirPath = join20(skillsDir, dir.name);
+      const subEntries = await readdir8(dirPath, { withFileTypes: true });
       const subdirs = subEntries.filter((entry) => entry.isDirectory() && !entry.name.startsWith("."));
       if (subdirs.length > 0) {
         for (const subdir of subdirs.slice(0, 3)) {
-          const subdirPath = join19(dirPath, subdir.name);
-          const subdirFiles = await readdir7(subdirPath, { withFileTypes: true });
+          const subdirPath = join20(dirPath, subdir.name);
+          const subdirFiles = await readdir8(subdirPath, { withFileTypes: true });
           const hasSkillMarker = subdirFiles.some((file) => file.isFile() && (file.name === "skill.md" || file.name === "README.md" || file.name === "readme.md" || file.name === "config.json" || file.name === "package.json"));
           if (hasSkillMarker) {
             totalSkillLikeCount++;
@@ -30044,16 +30337,16 @@ class SkillsMigrationDetector {
 // src/lib/skills-migrator.ts
 init_types2();
 init_logger();
-var import_fs_extra14 = __toESM(require_lib(), 1);
-import { copyFile as copyFile2, mkdir as mkdir7, readdir as readdir10, rm as rm2 } from "node:fs/promises";
-import { join as join22 } from "node:path";
+var import_fs_extra15 = __toESM(require_lib(), 1);
+import { copyFile as copyFile2, mkdir as mkdir7, readdir as readdir11, rm as rm2 } from "node:fs/promises";
+import { join as join23 } from "node:path";
 
 // src/lib/skills-backup-manager.ts
 init_types2();
 init_logger();
-var import_fs_extra12 = __toESM(require_lib(), 1);
-import { copyFile, mkdir as mkdir6, readdir as readdir8, rm, stat as stat4 } from "node:fs/promises";
-import { basename as basename2, join as join20, normalize as normalize2 } from "node:path";
+var import_fs_extra13 = __toESM(require_lib(), 1);
+import { copyFile, mkdir as mkdir6, readdir as readdir9, rm, stat as stat4 } from "node:fs/promises";
+import { basename as basename2, join as join21, normalize as normalize2 } from "node:path";
 function validatePath2(path9, paramName) {
   if (!path9 || typeof path9 !== "string") {
     throw new SkillsMigrationError(`${paramName} must be a non-empty string`);
@@ -30073,13 +30366,13 @@ class SkillsBackupManager {
     if (parentDir) {
       validatePath2(parentDir, "parentDir");
     }
-    if (!await import_fs_extra12.pathExists(skillsDir)) {
+    if (!await import_fs_extra13.pathExists(skillsDir)) {
       throw new SkillsMigrationError(`Cannot create backup: Skills directory does not exist: ${skillsDir}`);
     }
     const timestamp = Date.now();
     const randomSuffix = Math.random().toString(36).substring(2, 8);
     const backupDirName = `${SkillsBackupManager.BACKUP_PREFIX}${timestamp}-${randomSuffix}`;
-    const backupDir = parentDir ? join20(parentDir, backupDirName) : join20(skillsDir, "..", backupDirName);
+    const backupDir = parentDir ? join21(parentDir, backupDirName) : join21(skillsDir, "..", backupDirName);
     logger.info(`Creating backup at: ${backupDir}`);
     try {
       await mkdir6(backupDir, { recursive: true });
@@ -30096,12 +30389,12 @@ class SkillsBackupManager {
   static async restoreBackup(backupDir, targetDir) {
     validatePath2(backupDir, "backupDir");
     validatePath2(targetDir, "targetDir");
-    if (!await import_fs_extra12.pathExists(backupDir)) {
+    if (!await import_fs_extra13.pathExists(backupDir)) {
       throw new SkillsMigrationError(`Cannot restore: Backup directory does not exist: ${backupDir}`);
     }
     logger.info(`Restoring from backup: ${backupDir}`);
     try {
-      if (await import_fs_extra12.pathExists(targetDir)) {
+      if (await import_fs_extra13.pathExists(targetDir)) {
         await rm(targetDir, { recursive: true, force: true });
       }
       await mkdir6(targetDir, { recursive: true });
@@ -30112,7 +30405,7 @@ class SkillsBackupManager {
     }
   }
   static async deleteBackup(backupDir) {
-    if (!await import_fs_extra12.pathExists(backupDir)) {
+    if (!await import_fs_extra13.pathExists(backupDir)) {
       logger.warning(`Backup directory does not exist: ${backupDir}`);
       return;
     }
@@ -30125,12 +30418,12 @@ class SkillsBackupManager {
     }
   }
   static async listBackups(parentDir) {
-    if (!await import_fs_extra12.pathExists(parentDir)) {
+    if (!await import_fs_extra13.pathExists(parentDir)) {
       return [];
     }
     try {
-      const entries = await readdir8(parentDir, { withFileTypes: true });
-      const backups = entries.filter((entry) => entry.isDirectory() && entry.name.startsWith(SkillsBackupManager.BACKUP_PREFIX)).map((entry) => join20(parentDir, entry.name));
+      const entries = await readdir9(parentDir, { withFileTypes: true });
+      const backups = entries.filter((entry) => entry.isDirectory() && entry.name.startsWith(SkillsBackupManager.BACKUP_PREFIX)).map((entry) => join21(parentDir, entry.name));
       backups.sort().reverse();
       return backups;
     } catch (error2) {
@@ -30150,16 +30443,16 @@ class SkillsBackupManager {
     }
   }
   static async getBackupSize(backupDir) {
-    if (!await import_fs_extra12.pathExists(backupDir)) {
+    if (!await import_fs_extra13.pathExists(backupDir)) {
       return 0;
     }
     return await SkillsBackupManager.getDirectorySize(backupDir);
   }
   static async copyDirectory(sourceDir, destDir) {
-    const entries = await readdir8(sourceDir, { withFileTypes: true });
+    const entries = await readdir9(sourceDir, { withFileTypes: true });
     for (const entry of entries) {
-      const sourcePath = join20(sourceDir, entry.name);
-      const destPath = join20(destDir, entry.name);
+      const sourcePath = join21(sourceDir, entry.name);
+      const destPath = join21(destDir, entry.name);
       if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.isSymbolicLink()) {
         continue;
       }
@@ -30173,9 +30466,9 @@ class SkillsBackupManager {
   }
   static async getDirectorySize(dirPath) {
     let size = 0;
-    const entries = await readdir8(dirPath, { withFileTypes: true });
+    const entries = await readdir9(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join20(dirPath, entry.name);
+      const fullPath = join21(dirPath, entry.name);
       if (entry.isSymbolicLink()) {
         continue;
       }
@@ -30202,11 +30495,11 @@ class SkillsBackupManager {
 // src/lib/skills-customization-scanner.ts
 init_types2();
 init_logger();
-var import_fs_extra13 = __toESM(require_lib(), 1);
+var import_fs_extra14 = __toESM(require_lib(), 1);
 import { createHash as createHash3 } from "node:crypto";
 import { createReadStream as createReadStream2 } from "node:fs";
-import { readFile as readFile10, readdir as readdir9 } from "node:fs/promises";
-import { join as join21, normalize as normalize3, relative as relative6 } from "node:path";
+import { readFile as readFile11, readdir as readdir10 } from "node:fs/promises";
+import { join as join22, normalize as normalize3, relative as relative7 } from "node:path";
 function validatePath3(path9, paramName) {
   if (!path9 || typeof path9 !== "string") {
     throw new SkillsMigrationError(`${paramName} must be a non-empty string`);
@@ -30285,14 +30578,14 @@ class SkillsCustomizationScanner {
   static async detectFileChanges(currentSkillPath, baselineSkillPath) {
     const changes = [];
     const currentFiles = await SkillsCustomizationScanner.getAllFiles(currentSkillPath);
-    const baselineFiles = await import_fs_extra13.pathExists(baselineSkillPath) ? await SkillsCustomizationScanner.getAllFiles(baselineSkillPath) : [];
+    const baselineFiles = await import_fs_extra14.pathExists(baselineSkillPath) ? await SkillsCustomizationScanner.getAllFiles(baselineSkillPath) : [];
     const currentFileMap = new Map(await Promise.all(currentFiles.map(async (f3) => {
-      const relPath = relative6(currentSkillPath, f3);
+      const relPath = relative7(currentSkillPath, f3);
       const hash = await SkillsCustomizationScanner.hashFile(f3);
       return [relPath, hash];
     })));
     const baselineFileMap = new Map(await Promise.all(baselineFiles.map(async (f3) => {
-      const relPath = relative6(baselineSkillPath, f3);
+      const relPath = relative7(baselineSkillPath, f3);
       const hash = await SkillsCustomizationScanner.hashFile(f3);
       return [relPath, hash];
     })));
@@ -30330,8 +30623,8 @@ class SkillsCustomizationScanner {
     if (files1.length !== files2.length) {
       return true;
     }
-    const relFiles1 = files1.map((f3) => relative6(dir1, f3)).sort();
-    const relFiles2 = files2.map((f3) => relative6(dir2, f3)).sort();
+    const relFiles1 = files1.map((f3) => relative7(dir1, f3)).sort();
+    const relFiles2 = files2.map((f3) => relative7(dir2, f3)).sort();
     if (JSON.stringify(relFiles1) !== JSON.stringify(relFiles2)) {
       return true;
     }
@@ -30345,22 +30638,22 @@ class SkillsCustomizationScanner {
     return false;
   }
   static async scanSkillsDirectory(skillsDir) {
-    if (!await import_fs_extra13.pathExists(skillsDir)) {
+    if (!await import_fs_extra14.pathExists(skillsDir)) {
       return ["flat", []];
     }
-    const entries = await readdir9(skillsDir, { withFileTypes: true });
+    const entries = await readdir10(skillsDir, { withFileTypes: true });
     const dirs = entries.filter((entry) => entry.isDirectory() && entry.name !== "node_modules" && !entry.name.startsWith("."));
     if (dirs.length === 0) {
       return ["flat", []];
     }
-    const firstDirPath = join21(skillsDir, dirs[0].name);
-    const subEntries = await readdir9(firstDirPath, { withFileTypes: true });
+    const firstDirPath = join22(skillsDir, dirs[0].name);
+    const subEntries = await readdir10(firstDirPath, { withFileTypes: true });
     const subdirs = subEntries.filter((entry) => entry.isDirectory() && !entry.name.startsWith("."));
     if (subdirs.length > 0) {
       let skillLikeCount = 0;
       for (const subdir of subdirs.slice(0, 3)) {
-        const subdirPath = join21(firstDirPath, subdir.name);
-        const subdirFiles = await readdir9(subdirPath, { withFileTypes: true });
+        const subdirPath = join22(firstDirPath, subdir.name);
+        const subdirFiles = await readdir10(subdirPath, { withFileTypes: true });
         const hasSkillMarker = subdirFiles.some((file) => file.isFile() && (file.name === "skill.md" || file.name === "README.md" || file.name === "readme.md" || file.name === "config.json" || file.name === "package.json"));
         if (hasSkillMarker) {
           skillLikeCount++;
@@ -30369,8 +30662,8 @@ class SkillsCustomizationScanner {
       if (skillLikeCount > 0) {
         const skills = [];
         for (const dir of dirs) {
-          const categoryPath = join21(skillsDir, dir.name);
-          const skillDirs = await readdir9(categoryPath, { withFileTypes: true });
+          const categoryPath = join22(skillsDir, dir.name);
+          const skillDirs = await readdir10(categoryPath, { withFileTypes: true });
           skills.push(...skillDirs.filter((entry) => entry.isDirectory() && !entry.name.startsWith(".")).map((entry) => entry.name));
         }
         return ["categorized", skills];
@@ -30379,18 +30672,18 @@ class SkillsCustomizationScanner {
     return ["flat", dirs.map((dir) => dir.name)];
   }
   static async findSkillPath(skillsDir, skillName) {
-    const flatPath = join21(skillsDir, skillName);
-    if (await import_fs_extra13.pathExists(flatPath)) {
+    const flatPath = join22(skillsDir, skillName);
+    if (await import_fs_extra14.pathExists(flatPath)) {
       return { path: flatPath, category: undefined };
     }
-    const entries = await readdir9(skillsDir, { withFileTypes: true });
+    const entries = await readdir10(skillsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory() || entry.name.startsWith(".") || entry.name === "node_modules") {
         continue;
       }
-      const categoryPath = join21(skillsDir, entry.name);
-      const skillPath = join21(categoryPath, skillName);
-      if (await import_fs_extra13.pathExists(skillPath)) {
+      const categoryPath = join22(skillsDir, entry.name);
+      const skillPath = join22(categoryPath, skillName);
+      if (await import_fs_extra14.pathExists(skillPath)) {
         return { path: skillPath, category: entry.name };
       }
     }
@@ -30398,9 +30691,9 @@ class SkillsCustomizationScanner {
   }
   static async getAllFiles(dirPath) {
     const files = [];
-    const entries = await readdir9(dirPath, { withFileTypes: true });
+    const entries = await readdir10(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join21(dirPath, entry.name);
+      const fullPath = join22(dirPath, entry.name);
       if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.isSymbolicLink()) {
         continue;
       }
@@ -30432,8 +30725,8 @@ class SkillsCustomizationScanner {
     const files = await SkillsCustomizationScanner.getAllFiles(dirPath);
     files.sort();
     for (const file of files) {
-      const relativePath = relative6(dirPath, file);
-      const content = await readFile10(file);
+      const relativePath = relative7(dirPath, file);
+      const content = await readFile11(file);
       hash.update(relativePath);
       hash.update(content);
     }
@@ -30643,7 +30936,7 @@ class SkillsMigrator {
         }
       }
       if (options.backup && !options.dryRun) {
-        const claudeDir = join22(currentSkillsDir, "..");
+        const claudeDir = join23(currentSkillsDir, "..");
         result.backupPath = await SkillsBackupManager.createBackup(currentSkillsDir, claudeDir);
         logger.success(`Backup created at: ${result.backupPath}`);
       }
@@ -30695,14 +30988,14 @@ class SkillsMigrator {
     const migrated = [];
     const preserved = [];
     const errors2 = [];
-    const tempDir = join22(currentSkillsDir, "..", ".skills-migration-temp");
+    const tempDir = join23(currentSkillsDir, "..", ".skills-migration-temp");
     await mkdir7(tempDir, { recursive: true });
     try {
       for (const mapping of mappings) {
         try {
           const skillName = mapping.skillName;
           const currentSkillPath = mapping.oldPath;
-          if (!await import_fs_extra14.pathExists(currentSkillPath)) {
+          if (!await import_fs_extra15.pathExists(currentSkillPath)) {
             logger.warning(`Skill not found, skipping: ${skillName}`);
             continue;
           }
@@ -30716,9 +31009,9 @@ class SkillsMigrator {
             }
           }
           const category = mapping.category;
-          const targetPath = category ? join22(tempDir, category, skillName) : join22(tempDir, skillName);
+          const targetPath = category ? join23(tempDir, category, skillName) : join23(tempDir, skillName);
           if (category) {
-            await mkdir7(join22(tempDir, category), { recursive: true });
+            await mkdir7(join23(tempDir, category), { recursive: true });
           }
           await SkillsMigrator.copySkillDirectory(currentSkillPath, targetPath);
           migrated.push(skillName);
@@ -30750,10 +31043,10 @@ class SkillsMigrator {
   }
   static async copySkillDirectory(sourceDir, destDir) {
     await mkdir7(destDir, { recursive: true });
-    const entries = await readdir10(sourceDir, { withFileTypes: true });
+    const entries = await readdir11(sourceDir, { withFileTypes: true });
     for (const entry of entries) {
-      const sourcePath = join22(sourceDir, entry.name);
-      const destPath = join22(destDir, entry.name);
+      const sourcePath = join23(sourceDir, entry.name);
+      const destPath = join23(destDir, entry.name);
       if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.isSymbolicLink()) {
         continue;
       }
@@ -30773,9 +31066,12 @@ init_types2();
 init_types2();
 init_logger();
 import { existsSync as existsSync5 } from "node:fs";
-import { mkdir as mkdir8, readFile as readFile11, writeFile as writeFile9 } from "node:fs/promises";
+import { mkdir as mkdir8, readFile as readFile12, writeFile as writeFile10 } from "node:fs/promises";
 import { chmod as chmod2 } from "node:fs/promises";
 import { platform as platform8 } from "node:os";
+import { join as join24 } from "node:path";
+var PROJECT_CONFIG_FILE = ".ck.json";
+
 class ConfigManager {
   static config = null;
   static globalFlag = false;
@@ -30793,7 +31089,7 @@ class ConfigManager {
     const configFile = PathResolver.getConfigFile(ConfigManager.globalFlag);
     try {
       if (existsSync5(configFile)) {
-        const content = await readFile11(configFile, "utf-8");
+        const content = await readFile12(configFile, "utf-8");
         const data = JSON.parse(content);
         ConfigManager.config = ConfigSchema.parse(data);
         logger.debug(`Config loaded from ${configFile}`);
@@ -30816,7 +31112,7 @@ class ConfigManager {
           await chmod2(configDir, 448);
         }
       }
-      await writeFile9(configFile, JSON.stringify(validConfig, null, 2), "utf-8");
+      await writeFile10(configFile, JSON.stringify(validConfig, null, 2), "utf-8");
       if (platform8() !== "win32") {
         await chmod2(configFile, 384);
       }
@@ -30842,6 +31138,56 @@ class ConfigManager {
     current[keys[keys.length - 1]] = value;
     await ConfigManager.save(config);
   }
+  static async loadProjectConfig(projectDir) {
+    const configPath = join24(projectDir, ".claude", PROJECT_CONFIG_FILE);
+    try {
+      if (existsSync5(configPath)) {
+        const content = await readFile12(configPath, "utf-8");
+        const data = JSON.parse(content);
+        const folders = FoldersConfigSchema.parse(data.paths || data);
+        logger.debug(`Project config loaded from ${configPath}`);
+        return folders;
+      }
+    } catch (error2) {
+      logger.warning(`Failed to load project config from ${configPath}: ${error2 instanceof Error ? error2.message : "Unknown error"}`);
+    }
+    return null;
+  }
+  static async saveProjectConfig(projectDir, folders) {
+    const claudeDir = join24(projectDir, ".claude");
+    const configPath = join24(claudeDir, PROJECT_CONFIG_FILE);
+    try {
+      if (!existsSync5(claudeDir)) {
+        await mkdir8(claudeDir, { recursive: true });
+      }
+      const validFolders = FoldersConfigSchema.parse(folders);
+      await writeFile10(configPath, JSON.stringify({ paths: validFolders }, null, 2), "utf-8");
+      logger.debug(`Project config saved to ${configPath}`);
+    } catch (error2) {
+      throw new Error(`Failed to save project config: ${error2 instanceof Error ? error2.message : "Unknown error"}`);
+    }
+  }
+  static async resolveFoldersConfig(projectDir, cliOptions) {
+    const result = { ...DEFAULT_FOLDERS };
+    const globalConfig = await ConfigManager.load();
+    if (globalConfig.folders?.docs)
+      result.docs = globalConfig.folders.docs;
+    if (globalConfig.folders?.plans)
+      result.plans = globalConfig.folders.plans;
+    const projectConfig = await ConfigManager.loadProjectConfig(projectDir);
+    if (projectConfig?.docs)
+      result.docs = projectConfig.docs;
+    if (projectConfig?.plans)
+      result.plans = projectConfig.plans;
+    if (cliOptions?.docsDir)
+      result.docs = cliOptions.docsDir;
+    if (cliOptions?.plansDir)
+      result.plans = cliOptions.plansDir;
+    return result;
+  }
+  static projectConfigExists(projectDir) {
+    return existsSync5(join24(projectDir, ".claude", PROJECT_CONFIG_FILE));
+  }
 }
 
 // src/commands/init.ts
@@ -30849,8 +31195,8 @@ init_environment();
 
 // src/utils/file-scanner.ts
 init_logger();
-var import_fs_extra15 = __toESM(require_lib(), 1);
-import { join as join23, relative as relative7, resolve as resolve2 } from "node:path";
+var import_fs_extra16 = __toESM(require_lib(), 1);
+import { join as join25, relative as relative8, resolve as resolve2 } from "node:path";
 var SKIP_DIRS = [
   "node_modules",
   ".venv",
@@ -30867,24 +31213,24 @@ class FileScanner {
   static async getFiles(dirPath, relativeTo) {
     const basePath = relativeTo || dirPath;
     const files = [];
-    if (!await import_fs_extra15.pathExists(dirPath)) {
+    if (!await import_fs_extra16.pathExists(dirPath)) {
       return files;
     }
     try {
-      const entries = await import_fs_extra15.readdir(dirPath, { encoding: "utf8" });
+      const entries = await import_fs_extra16.readdir(dirPath, { encoding: "utf8" });
       for (const entry of entries) {
         if (SKIP_DIRS.includes(entry)) {
           logger.debug(`Skipping directory: ${entry}`);
           continue;
         }
-        const fullPath = join23(dirPath, entry);
+        const fullPath = join25(dirPath, entry);
         if (!FileScanner.isSafePath(basePath, fullPath)) {
           logger.warning(`Skipping potentially unsafe path: ${entry}`);
           continue;
         }
         let stats;
         try {
-          stats = await import_fs_extra15.lstat(fullPath);
+          stats = await import_fs_extra16.lstat(fullPath);
         } catch (error2) {
           if (error2 instanceof Error && "code" in error2 && (error2.code === "EACCES" || error2.code === "EPERM")) {
             logger.warning(`Skipping inaccessible path: ${entry}`);
@@ -30900,7 +31246,7 @@ class FileScanner {
           const subFiles = await FileScanner.getFiles(fullPath, basePath);
           files.push(...subFiles);
         } else if (stats.isFile()) {
-          const relativePath = relative7(basePath, fullPath);
+          const relativePath = relative8(basePath, fullPath);
           files.push(FileScanner.toPosixPath(relativePath));
         }
       }
@@ -30912,8 +31258,8 @@ class FileScanner {
     return files;
   }
   static async findCustomFiles(destDir, sourceDir, subPath) {
-    const destSubDir = join23(destDir, subPath);
-    const sourceSubDir = join23(sourceDir, subPath);
+    const destSubDir = join25(destDir, subPath);
+    const sourceSubDir = join25(sourceDir, subPath);
     const destFiles = await FileScanner.getFiles(destSubDir, destDir);
     const sourceFiles = await FileScanner.getFiles(sourceSubDir, sourceDir);
     const sourceFileSet = new Set(sourceFiles);
@@ -30950,6 +31296,34 @@ async function initCommand(options) {
       logger.info("Global mode enabled - using platform-specific user configuration");
     }
     const isNonInteractive2 = !process.stdin.isTTY || process.env.CI === "true" || process.env.NON_INTERACTIVE === "true";
+    if (validOptions.global) {
+      const localSettingsPath = join26(process.cwd(), ".claude", "settings.json");
+      if (await import_fs_extra17.pathExists(localSettingsPath)) {
+        if (isNonInteractive2) {
+          logger.warning("Local .claude/settings.json detected. Local settings take precedence over global.");
+          logger.warning("Consider removing local installation: rm -rf .claude");
+        } else {
+          const choice = await prompts.promptLocalMigration();
+          if (choice === "cancel") {
+            prompts.outro("Installation cancelled.");
+            return;
+          }
+          if (choice === "remove") {
+            const localClaudeDir = join26(process.cwd(), ".claude");
+            try {
+              await import_fs_extra17.remove(localClaudeDir);
+              logger.success("Removed local .claude/ directory");
+            } catch (error2) {
+              logger.error(`Failed to remove local installation: ${error2 instanceof Error ? error2.message : "Unknown error"}`);
+              logger.warning("Proceeding with global installation anyway.");
+            }
+          }
+          if (choice === "keep") {
+            logger.warning("Proceeding with global installation. Local settings will take precedence.");
+          }
+        }
+      }
+    }
     const config = await ConfigManager.get();
     let kit = validOptions.kit || config.defaults?.kit;
     if (!kit) {
@@ -30972,7 +31346,7 @@ async function initCommand(options) {
     }
     const resolvedDir = resolve4(targetDir);
     logger.info(`Target directory: ${resolvedDir}`);
-    if (!await import_fs_extra16.pathExists(resolvedDir)) {
+    if (!await import_fs_extra17.pathExists(resolvedDir)) {
       if (validOptions.global) {
         const { mkdir: mkdir9 } = await import("node:fs/promises");
         await mkdir9(resolvedDir, { recursive: true });
@@ -30985,7 +31359,7 @@ async function initCommand(options) {
     }
     if (validOptions.fresh) {
       const prefix = PathResolver.getPathPrefix(validOptions.global);
-      const claudeDir2 = prefix ? join24(resolvedDir, prefix) : resolvedDir;
+      const claudeDir2 = prefix ? join26(resolvedDir, prefix) : resolvedDir;
       const canProceed = await handleFreshInstallation(claudeDir2, prompts);
       if (!canProceed) {
         return;
@@ -31095,10 +31469,30 @@ async function initCommand(options) {
       });
       logger.success(`Transformed ${transformResult.totalChanges} path(s) in ${transformResult.filesTransformed} file(s)`);
     }
+    const foldersConfig = await ConfigManager.resolveFoldersConfig(resolvedDir, {
+      docsDir: validOptions.docsDir,
+      plansDir: validOptions.plansDir
+    });
+    validateFolderOptions(validOptions);
+    const hasCustomFolders = foldersConfig.docs !== DEFAULT_FOLDERS.docs || foldersConfig.plans !== DEFAULT_FOLDERS.plans;
+    if (hasCustomFolders) {
+      logger.info(`Using custom folder names: docs=${foldersConfig.docs}, plans=${foldersConfig.plans}`);
+      const folderTransformResult = await transformFolderPaths(extractDir, foldersConfig, {
+        verbose: logger.isVerbose()
+      });
+      logger.success(`Transformed ${folderTransformResult.foldersRenamed} folder(s), ${folderTransformResult.totalReferences} reference(s) in ${folderTransformResult.filesTransformed} file(s)`);
+      if (validOptions.docsDir || validOptions.plansDir) {
+        await ConfigManager.saveProjectConfig(resolvedDir, {
+          docs: foldersConfig.docs,
+          plans: foldersConfig.plans
+        });
+        logger.debug("Saved folder configuration to .claude/.ck.json");
+      }
+    }
     if (!validOptions.fresh) {
-      const newSkillsDir = join24(extractDir, ".claude", "skills");
+      const newSkillsDir = join26(extractDir, ".claude", "skills");
       const currentSkillsDir = PathResolver.buildSkillsPath(resolvedDir, validOptions.global);
-      if (await import_fs_extra16.pathExists(newSkillsDir) && await import_fs_extra16.pathExists(currentSkillsDir)) {
+      if (await import_fs_extra17.pathExists(newSkillsDir) && await import_fs_extra17.pathExists(currentSkillsDir)) {
         logger.info("Checking for skills directory migration...");
         const migrationDetection = await SkillsMigrationDetector.detectMigration(newSkillsDir, currentSkillsDir);
         if (migrationDetection.status === "recommended" || migrationDetection.status === "required") {
@@ -31121,7 +31515,7 @@ async function initCommand(options) {
     let customClaudeFiles = [];
     if (!validOptions.fresh) {
       logger.info("Scanning for custom .claude files...");
-      const scanSourceDir = validOptions.global ? join24(extractDir, ".claude") : extractDir;
+      const scanSourceDir = validOptions.global ? join26(extractDir, ".claude") : extractDir;
       const scanTargetSubdir = validOptions.global ? "" : ".claude";
       customClaudeFiles = await FileScanner.findCustomFiles(resolvedDir, scanSourceDir, scanTargetSubdir);
     } else {
@@ -31150,9 +31544,9 @@ async function initCommand(options) {
       merger.addIgnorePatterns(validOptions.exclude);
     }
     merger.setGlobalFlag(validOptions.global);
-    const claudeDir = validOptions.global ? resolvedDir : join24(resolvedDir, ".claude");
+    const claudeDir = validOptions.global ? resolvedDir : join26(resolvedDir, ".claude");
     const releaseManifest = await ReleaseManifestLoader.load(extractDir);
-    if (!validOptions.fresh && await import_fs_extra16.pathExists(claudeDir)) {
+    if (!validOptions.fresh && await import_fs_extra17.pathExists(claudeDir)) {
       const legacyDetection = await LegacyMigration.detectLegacy(claudeDir);
       if (legacyDetection.isLegacy && releaseManifest) {
         logger.info("Legacy installation detected - migrating to ownership tracking...");
@@ -31172,7 +31566,7 @@ async function initCommand(options) {
         return;
       }
     }
-    const sourceDir = validOptions.global ? join24(extractDir, ".claude") : extractDir;
+    const sourceDir = validOptions.global ? join26(extractDir, ".claude") : extractDir;
     await merger.merge(sourceDir, resolvedDir, false);
     const manifestWriter = new ManifestWriter;
     const installedFiles = merger.getAllInstalledFiles();
@@ -31181,7 +31575,7 @@ async function initCommand(options) {
       if (!validOptions.global && !installedPath.startsWith(".claude/"))
         continue;
       const relativePath = validOptions.global ? installedPath : installedPath.replace(/^\.claude\//, "");
-      const filePath = join24(claudeDir, relativePath);
+      const filePath = join26(claudeDir, relativePath);
       const manifestEntry = releaseManifest ? ReleaseManifestLoader.findFile(releaseManifest, installedPath) : null;
       const ownership = manifestEntry ? "ck" : "user";
       filesToTrack.push({
@@ -31202,11 +31596,11 @@ async function initCommand(options) {
     trackingSpinner.succeed(`Tracked ${trackResult.success} files`);
     await manifestWriter.writeManifest(claudeDir, kitConfig.name, release.tag_name, validOptions.global ? "global" : "local");
     if (validOptions.global) {
-      const claudeMdSource = join24(extractDir, "CLAUDE.md");
-      const claudeMdDest = join24(resolvedDir, "CLAUDE.md");
-      if (await import_fs_extra16.pathExists(claudeMdSource)) {
-        if (!await import_fs_extra16.pathExists(claudeMdDest)) {
-          await import_fs_extra16.copy(claudeMdSource, claudeMdDest);
+      const claudeMdSource = join26(extractDir, "CLAUDE.md");
+      const claudeMdDest = join26(resolvedDir, "CLAUDE.md");
+      if (await import_fs_extra17.pathExists(claudeMdSource)) {
+        if (!await import_fs_extra17.pathExists(claudeMdDest)) {
+          await import_fs_extra17.copy(claudeMdSource, claudeMdDest);
           logger.success("Copied CLAUDE.md to global directory");
         } else {
           logger.debug("CLAUDE.md already exists in global directory (preserved)");
@@ -31223,8 +31617,8 @@ async function initCommand(options) {
       await handleSkillsInstallation2(skillsDir);
     }
     if (!validOptions.skipSetup && !isNonInteractive2) {
-      const envPath = join24(claudeDir, ".env");
-      if (!await import_fs_extra16.pathExists(envPath)) {
+      const envPath = join26(claudeDir, ".env");
+      if (!await import_fs_extra17.pathExists(envPath)) {
         const shouldSetup = await prompts.confirm("Set up API keys now? (Gemini API key for ai-multimodal skill, optional webhooks)");
         if (shouldSetup) {
           await runSetupWizard({
@@ -31254,8 +31648,8 @@ Protected files (.env, etc.) were not modified.`;
 }
 
 // src/commands/new.ts
-var import_fs_extra17 = __toESM(require_lib(), 1);
-import { join as join25, resolve as resolve5 } from "node:path";
+var import_fs_extra18 = __toESM(require_lib(), 1);
+import { join as join27, resolve as resolve5 } from "node:path";
 init_types2();
 init_environment();
 init_logger();
@@ -31286,8 +31680,8 @@ async function newCommand(options) {
     }
     const resolvedDir = resolve5(targetDir);
     logger.info(`Target directory: ${resolvedDir}`);
-    if (await import_fs_extra17.pathExists(resolvedDir)) {
-      const files = await import_fs_extra17.readdir(resolvedDir);
+    if (await import_fs_extra18.pathExists(resolvedDir)) {
+      const files = await import_fs_extra18.readdir(resolvedDir);
       const isEmpty = files.length === 0;
       if (!isEmpty) {
         if (isNonInteractive2) {
@@ -31401,6 +31795,23 @@ async function newCommand(options) {
     if (CommandsPrefix.shouldApplyPrefix(validOptions)) {
       await CommandsPrefix.applyPrefix(extractDir);
     }
+    const foldersConfig = await ConfigManager.resolveFoldersConfig(resolvedDir, {
+      docsDir: validOptions.docsDir,
+      plansDir: validOptions.plansDir
+    });
+    validateFolderOptions(validOptions);
+    const hasCustomFolders = foldersConfig.docs !== DEFAULT_FOLDERS.docs || foldersConfig.plans !== DEFAULT_FOLDERS.plans;
+    if (hasCustomFolders) {
+      const transformResult = await transformFolderPaths(extractDir, foldersConfig, {
+        verbose: logger.isVerbose()
+      });
+      logger.success(`Transformed ${transformResult.foldersRenamed} folder(s), ` + `${transformResult.totalReferences} reference(s) in ${transformResult.filesTransformed} file(s)`);
+      await ConfigManager.saveProjectConfig(resolvedDir, {
+        docs: foldersConfig.docs,
+        plans: foldersConfig.plans
+      });
+      logger.debug("Saved folder configuration to .claude/.ck.json");
+    }
     const merger = new FileMerger;
     if (validOptions.exclude && validOptions.exclude.length > 0) {
       merger.addIgnorePatterns(validOptions.exclude);
@@ -31409,7 +31820,7 @@ async function newCommand(options) {
       await CommandsPrefix.cleanupCommandsDirectory(resolvedDir, false);
     }
     await merger.merge(extractDir, resolvedDir, true);
-    const claudeDir = join25(resolvedDir, ".claude");
+    const claudeDir = join27(resolvedDir, ".claude");
     const manifestWriter = new ManifestWriter;
     const releaseManifest = await ReleaseManifestLoader.load(extractDir);
     const installedFiles = merger.getAllInstalledFiles();
@@ -31418,7 +31829,7 @@ async function newCommand(options) {
       if (!installedPath.startsWith(".claude/"))
         continue;
       const relativePath = installedPath.replace(/^\.claude\//, "");
-      const filePath = join25(claudeDir, relativePath);
+      const filePath = join27(claudeDir, relativePath);
       const manifestEntry = releaseManifest ? ReleaseManifestLoader.findFile(releaseManifest, installedPath) : null;
       const ownership = manifestEntry ? "ck" : "user";
       filesToTrack.push({
@@ -31471,10 +31882,10 @@ async function newCommand(options) {
 
 // src/commands/uninstall.ts
 init_dist2();
-var import_fs_extra18 = __toESM(require_lib(), 1);
+var import_fs_extra19 = __toESM(require_lib(), 1);
 var import_picocolors10 = __toESM(require_picocolors(), 1);
 import { readdirSync, rmSync } from "node:fs";
-import { dirname as dirname4, join as join26 } from "node:path";
+import { dirname as dirname4, join as join28 } from "node:path";
 init_types2();
 init_logger();
 async function detectInstallations() {
@@ -31484,14 +31895,14 @@ async function detectInstallations() {
     installations.push({
       type: "local",
       path: setup.project.path,
-      exists: await import_fs_extra18.pathExists(setup.project.path)
+      exists: await import_fs_extra19.pathExists(setup.project.path)
     });
   }
   if (setup.global.path && setup.global.metadata) {
     installations.push({
       type: "global",
       path: setup.global.path,
-      exists: await import_fs_extra18.pathExists(setup.global.path)
+      exists: await import_fs_extra19.pathExists(setup.global.path)
     });
   }
   return installations.filter((i) => i.exists);
@@ -31565,7 +31976,7 @@ async function analyzeInstallation(installation, forceOverwrite) {
     return result;
   }
   for (const trackedFile of metadata.files) {
-    const filePath = join26(installation.path, trackedFile.path);
+    const filePath = join28(installation.path, trackedFile.path);
     const ownershipResult = await OwnershipChecker.checkOwnership(filePath, metadata, installation.path);
     if (!ownershipResult.exists)
       continue;
@@ -31623,9 +32034,9 @@ async function removeInstallations(installations, options) {
       let removedCount = 0;
       let cleanedDirs = 0;
       for (const item of analysis.toDelete) {
-        const filePath = join26(installation.path, item.path);
-        if (await import_fs_extra18.pathExists(filePath)) {
-          await import_fs_extra18.remove(filePath);
+        const filePath = join28(installation.path, item.path);
+        if (await import_fs_extra19.pathExists(filePath)) {
+          await import_fs_extra19.remove(filePath);
           removedCount++;
           logger.debug(`Removed: ${item.path}`);
           cleanedDirs += await cleanupEmptyDirectories(filePath, installation.path);
@@ -31725,7 +32136,7 @@ import { promisify as promisify6 } from "node:util";
 // package.json
 var package_default2 = {
   name: "claudekit-cli",
-  version: "3.1.0",
+  version: "3.3.0",
   description: "CLI tool for bootstrapping and updating ClaudeKit projects",
   type: "module",
   repository: {
@@ -32170,14 +32581,14 @@ var import_picocolors12 = __toESM(require_picocolors(), 1);
 // src/lib/version-cache.ts
 init_logger();
 import { existsSync as existsSync6 } from "node:fs";
-import { mkdir as mkdir9, readFile as readFile12, writeFile as writeFile10 } from "node:fs/promises";
-import { join as join27 } from "node:path";
+import { mkdir as mkdir9, readFile as readFile13, writeFile as writeFile11 } from "node:fs/promises";
+import { join as join29 } from "node:path";
 class VersionCacheManager {
   static CACHE_FILENAME = "version-check.json";
   static CACHE_TTL_MS = 7 * 24 * 60 * 60 * 1000;
   static getCacheFile() {
     const cacheDir = PathResolver.getCacheDir(false);
-    return join27(cacheDir, VersionCacheManager.CACHE_FILENAME);
+    return join29(cacheDir, VersionCacheManager.CACHE_FILENAME);
   }
   static async load() {
     const cacheFile = VersionCacheManager.getCacheFile();
@@ -32186,7 +32597,7 @@ class VersionCacheManager {
         logger.debug("Version check cache not found");
         return null;
       }
-      const content = await readFile12(cacheFile, "utf-8");
+      const content = await readFile13(cacheFile, "utf-8");
       const cache2 = JSON.parse(content);
       if (!cache2.lastCheck || !cache2.currentVersion || !cache2.latestVersion) {
         logger.debug("Invalid cache structure, ignoring");
@@ -32206,7 +32617,7 @@ class VersionCacheManager {
       if (!existsSync6(cacheDir)) {
         await mkdir9(cacheDir, { recursive: true, mode: 448 });
       }
-      await writeFile10(cacheFile, JSON.stringify(cache2, null, 2), "utf-8");
+      await writeFile11(cacheFile, JSON.stringify(cache2, null, 2), "utf-8");
       logger.debug(`Version check cache saved to ${cacheFile}`);
     } catch (error2) {
       logger.debug(`Failed to save version check cache: ${error2}`);
@@ -32417,6 +32828,10 @@ class CliVersionChecker {
 init_zod();
 var KitType2 = exports_external.enum(["engineer", "marketing"]);
 var ExcludePatternSchema2 = exports_external.string().trim().min(1, "Exclude pattern cannot be empty").max(500, "Exclude pattern too long").refine((val) => !val.startsWith("/"), "Absolute paths not allowed in exclude patterns").refine((val) => !val.includes(".."), "Path traversal not allowed in exclude patterns");
+var FoldersConfigSchema2 = exports_external.object({
+  docs: exports_external.string().optional(),
+  plans: exports_external.string().optional()
+});
 var NewCommandOptionsSchema2 = exports_external.object({
   dir: exports_external.string().default("."),
   kit: KitType2.optional(),
@@ -32429,7 +32844,9 @@ var NewCommandOptionsSchema2 = exports_external.object({
   prefix: exports_external.boolean().default(false),
   beta: exports_external.boolean().default(false),
   dryRun: exports_external.boolean().default(false),
-  refresh: exports_external.boolean().default(false)
+  refresh: exports_external.boolean().default(false),
+  docsDir: exports_external.string().optional(),
+  plansDir: exports_external.string().optional()
 });
 var UpdateCommandOptionsSchema2 = exports_external.object({
   dir: exports_external.string().default("."),
@@ -32445,7 +32862,9 @@ var UpdateCommandOptionsSchema2 = exports_external.object({
   dryRun: exports_external.boolean().default(false),
   forceOverwrite: exports_external.boolean().default(false),
   skipSetup: exports_external.boolean().default(false),
-  refresh: exports_external.boolean().default(false)
+  refresh: exports_external.boolean().default(false),
+  docsDir: exports_external.string().optional(),
+  plansDir: exports_external.string().optional()
 });
 var VersionCommandOptionsSchema2 = exports_external.object({
   kit: KitType2.optional(),
@@ -32486,7 +32905,8 @@ var ConfigSchema2 = exports_external.object({
   defaults: exports_external.object({
     kit: KitType2.optional(),
     dir: exports_external.string().optional()
-  }).optional()
+  }).optional(),
+  folders: FoldersConfigSchema2.optional()
 });
 var GitHubReleaseAssetSchema2 = exports_external.object({
   id: exports_external.number(),
@@ -32643,7 +33063,7 @@ var logger2 = new Logger2;
 
 // src/utils/path-resolver.ts
 import { homedir as homedir2, platform as platform9 } from "node:os";
-import { join as join28, normalize as normalize4 } from "node:path";
+import { join as join30, normalize as normalize4 } from "node:path";
 
 class PathResolver2 {
   static getTestHomeDir() {
@@ -32676,50 +33096,50 @@ class PathResolver2 {
   static getConfigDir(global3 = false) {
     const testHome = PathResolver2.getTestHomeDir();
     if (testHome) {
-      return global3 ? join28(testHome, ".config", "claude") : join28(testHome, ".claudekit");
+      return global3 ? join30(testHome, ".config", "claude") : join30(testHome, ".claudekit");
     }
     if (!global3) {
-      return join28(homedir2(), ".claudekit");
+      return join30(homedir2(), ".claudekit");
     }
     const os2 = platform9();
     if (os2 === "win32") {
-      const localAppData = process.env.LOCALAPPDATA || join28(homedir2(), "AppData", "Local");
-      return join28(localAppData, "claude");
+      const localAppData = process.env.LOCALAPPDATA || join30(homedir2(), "AppData", "Local");
+      return join30(localAppData, "claude");
     }
     const xdgConfigHome = process.env.XDG_CONFIG_HOME;
     if (xdgConfigHome) {
-      return join28(xdgConfigHome, "claude");
+      return join30(xdgConfigHome, "claude");
     }
-    return join28(homedir2(), ".config", "claude");
+    return join30(homedir2(), ".config", "claude");
   }
   static getConfigFile(global3 = false) {
-    return join28(PathResolver2.getConfigDir(global3), "config.json");
+    return join30(PathResolver2.getConfigDir(global3), "config.json");
   }
   static getCacheDir(global3 = false) {
     const testHome = PathResolver2.getTestHomeDir();
     if (testHome) {
-      return global3 ? join28(testHome, ".cache", "claude") : join28(testHome, ".claudekit", "cache");
+      return global3 ? join30(testHome, ".cache", "claude") : join30(testHome, ".claudekit", "cache");
     }
     if (!global3) {
-      return join28(homedir2(), ".claudekit", "cache");
+      return join30(homedir2(), ".claudekit", "cache");
     }
     const os2 = platform9();
     if (os2 === "win32") {
-      const localAppData = process.env.LOCALAPPDATA || join28(homedir2(), "AppData", "Local");
-      return join28(localAppData, "claude", "cache");
+      const localAppData = process.env.LOCALAPPDATA || join30(homedir2(), "AppData", "Local");
+      return join30(localAppData, "claude", "cache");
     }
     const xdgCacheHome = process.env.XDG_CACHE_HOME;
     if (xdgCacheHome) {
-      return join28(xdgCacheHome, "claude");
+      return join30(xdgCacheHome, "claude");
     }
-    return join28(homedir2(), ".cache", "claude");
+    return join30(homedir2(), ".cache", "claude");
   }
   static getGlobalKitDir() {
     const testHome = PathResolver2.getTestHomeDir();
     if (testHome) {
-      return join28(testHome, ".claude");
+      return join30(testHome, ".claude");
     }
-    return join28(homedir2(), ".claude");
+    return join30(homedir2(), ".claude");
   }
   static getPathPrefix(global3) {
     return global3 ? "" : ".claude";
@@ -32727,9 +33147,9 @@ class PathResolver2 {
   static buildSkillsPath(baseDir, global3) {
     const prefix = PathResolver2.getPathPrefix(global3);
     if (prefix) {
-      return join28(baseDir, prefix, "skills");
+      return join30(baseDir, prefix, "skills");
     }
-    return join28(baseDir, "skills");
+    return join30(baseDir, "skills");
   }
   static buildComponentPath(baseDir, component, global3) {
     if (!PathResolver2.isPathSafe(component)) {
@@ -32737,9 +33157,9 @@ class PathResolver2 {
     }
     const prefix = PathResolver2.getPathPrefix(global3);
     if (prefix) {
-      return join28(baseDir, prefix, component);
+      return join30(baseDir, prefix, component);
     }
-    return join28(baseDir, component);
+    return join30(baseDir, component);
   }
 }
 
@@ -32757,9 +33177,9 @@ async function displayVersion() {
   let localKitVersion = null;
   let isGlobalOnlyKit = false;
   const globalKitDir = PathResolver2.getGlobalKitDir();
-  const globalMetadataPath = join29(globalKitDir, "metadata.json");
+  const globalMetadataPath = join31(globalKitDir, "metadata.json");
   const prefix = PathResolver2.getPathPrefix(false);
-  const localMetadataPath = prefix ? join29(process.cwd(), prefix, "metadata.json") : join29(process.cwd(), "metadata.json");
+  const localMetadataPath = prefix ? join31(process.cwd(), prefix, "metadata.json") : join31(process.cwd(), "metadata.json");
   const isLocalSameAsGlobal = localMetadataPath === globalMetadataPath;
   if (!isLocalSameAsGlobal && existsSync7(localMetadataPath)) {
     try {
@@ -32817,13 +33237,13 @@ async function displayVersion() {
 var cli = cac("ck");
 cli.option("--verbose", "Enable verbose logging for debugging");
 cli.option("--log-file <path>", "Write logs to file");
-cli.command("new", "Bootstrap a new ClaudeKit project (with interactive version selection)").option("--dir <dir>", "Target directory (default: .)").option("--kit <kit>", "Kit to use (engineer, marketing)").option("-r, --release <version>", "Skip version selection, use specific version (e.g., latest, v1.0.0)").option("--force", "Overwrite existing files without confirmation").option("--exclude <pattern>", "Exclude files matching glob pattern (can be used multiple times)").option("--opencode", "Install OpenCode CLI package (non-interactive mode)").option("--gemini", "Install Google Gemini CLI package (non-interactive mode)").option("--install-skills", "Install skills dependencies (non-interactive mode)").option("--prefix", "Add /ck: prefix to all slash commands by moving them to commands/ck/ subdirectory").option("--beta", "Show beta versions in selection prompt").option("--refresh", "Bypass release cache to fetch latest versions from GitHub").action(async (options) => {
+cli.command("new", "Bootstrap a new ClaudeKit project (with interactive version selection)").option("--dir <dir>", "Target directory (default: .)").option("--kit <kit>", "Kit to use (engineer, marketing)").option("-r, --release <version>", "Skip version selection, use specific version (e.g., latest, v1.0.0)").option("--force", "Overwrite existing files without confirmation").option("--exclude <pattern>", "Exclude files matching glob pattern (can be used multiple times)").option("--opencode", "Install OpenCode CLI package (non-interactive mode)").option("--gemini", "Install Google Gemini CLI package (non-interactive mode)").option("--install-skills", "Install skills dependencies (non-interactive mode)").option("--prefix", "Add /ck: prefix to all slash commands by moving them to commands/ck/ subdirectory").option("--beta", "Show beta versions in selection prompt").option("--refresh", "Bypass release cache to fetch latest versions from GitHub").option("--docs-dir <name>", "Custom docs folder name (default: docs)").option("--plans-dir <name>", "Custom plans folder name (default: plans)").action(async (options) => {
   if (options.exclude && !Array.isArray(options.exclude)) {
     options.exclude = [options.exclude];
   }
   await newCommand(options);
 });
-cli.command("init", "Initialize or update ClaudeKit project (with interactive version selection)").option("--dir <dir>", "Target directory (default: .)").option("--kit <kit>", "Kit to use (engineer, marketing)").option("-r, --release <version>", "Skip version selection, use specific version (e.g., latest, v1.0.0)").option("--exclude <pattern>", "Exclude files matching glob pattern (can be used multiple times)").option("--only <pattern>", "Include only files matching glob pattern (can be used multiple times)").option("-g, --global", "Use platform-specific user configuration directory").option("--fresh", "Completely remove .claude directory before downloading (requires confirmation)").option("--install-skills", "Install skills dependencies (non-interactive mode)").option("--prefix", "Add /ck: prefix to all slash commands by moving them to commands/ck/ subdirectory").option("--beta", "Show beta versions in selection prompt").option("--refresh", "Bypass release cache to fetch latest versions from GitHub").option("--dry-run", "Preview changes without applying them (requires --prefix)").option("--force-overwrite", "Override ownership protections and delete user-modified files (requires --prefix)").option("--skip-setup", "Skip interactive configuration wizard").action(async (options) => {
+cli.command("init", "Initialize or update ClaudeKit project (with interactive version selection)").option("--dir <dir>", "Target directory (default: .)").option("--kit <kit>", "Kit to use (engineer, marketing)").option("-r, --release <version>", "Skip version selection, use specific version (e.g., latest, v1.0.0)").option("--exclude <pattern>", "Exclude files matching glob pattern (can be used multiple times)").option("--only <pattern>", "Include only files matching glob pattern (can be used multiple times)").option("-g, --global", "Use platform-specific user configuration directory").option("--fresh", "Completely remove .claude directory before downloading (requires confirmation)").option("--install-skills", "Install skills dependencies (non-interactive mode)").option("--prefix", "Add /ck: prefix to all slash commands by moving them to commands/ck/ subdirectory").option("--beta", "Show beta versions in selection prompt").option("--refresh", "Bypass release cache to fetch latest versions from GitHub").option("--dry-run", "Preview changes without applying them (requires --prefix)").option("--force-overwrite", "Override ownership protections and delete user-modified files (requires --prefix)").option("--skip-setup", "Skip interactive configuration wizard").option("--docs-dir <name>", "Custom docs folder name (default: docs)").option("--plans-dir <name>", "Custom plans folder name (default: plans)").action(async (options) => {
   if (options.exclude && !Array.isArray(options.exclude)) {
     options.exclude = [options.exclude];
   }
@@ -32868,27 +33288,39 @@ cli.command("uninstall", "Remove ClaudeKit installations").option("-y, --yes", "
 cli.option("-V, --version", "Display version number");
 cli.option("-h, --help", "Display help information");
 var parsed = cli.parse(process.argv, { run: false });
-if (parsed.options.version) {
-  await displayVersion();
-  process.exit(0);
-}
-if (parsed.options.help || !cli.matchedCommand && parsed.args.length === 0) {
-  const { handleHelp: handleHelp2 } = await Promise.resolve().then(() => (init_help_interceptor(), exports_help_interceptor));
-  await handleHelp2(parsed.args);
-}
-var envVerbose = process.env.CLAUDEKIT_VERBOSE === "1" || process.env.CLAUDEKIT_VERBOSE === "true";
-var isVerbose = parsed.options.verbose || envVerbose;
-if (isVerbose) {
-  logger2.setVerbose(true);
-}
-if (parsed.options.logFile) {
-  logger2.setLogFile(parsed.options.logFile);
-}
-logger2.verbose("ClaudeKit CLI starting", {
-  version: packageVersion,
-  command: parsed.args[0] || "none",
-  options: parsed.options,
-  cwd: process.cwd(),
-  node: process.version
+(async () => {
+  try {
+    if (parsed.options.version) {
+      await displayVersion();
+      process.exitCode = 0;
+      return;
+    }
+    if (parsed.options.help || !cli.matchedCommand && parsed.args.length === 0) {
+      const { handleHelp: handleHelp2 } = await Promise.resolve().then(() => (init_help_interceptor(), exports_help_interceptor));
+      await handleHelp2(parsed.args);
+      return;
+    }
+    const envVerbose = process.env.CLAUDEKIT_VERBOSE === "1" || process.env.CLAUDEKIT_VERBOSE === "true";
+    const isVerbose = parsed.options.verbose || envVerbose;
+    if (isVerbose) {
+      logger2.setVerbose(true);
+    }
+    if (parsed.options.logFile) {
+      logger2.setLogFile(parsed.options.logFile);
+    }
+    logger2.verbose("ClaudeKit CLI starting", {
+      version: packageVersion,
+      command: parsed.args[0] || "none",
+      options: parsed.options,
+      cwd: process.cwd(),
+      node: process.version
+    });
+    cli.parse();
+  } catch (error2) {
+    console.error("CLI error:", error2 instanceof Error ? error2.message : error2);
+    process.exitCode = 1;
+  }
+})().catch((error2) => {
+  console.error("Unhandled error:", error2 instanceof Error ? error2.message : error2);
+  process.exitCode = 1;
 });
-cli.parse();