claudekit-cli 3.22.1 → 3.23.0

package/dist/index.js

@@ -34271,7 +34271,7 @@ async function handleDownload(ctx) {
   };
 }
 // src/commands/init/phases/merge-handler.ts
-import { join as join49 } from "node:path";
+import { join as join50 } from "node:path";
 
 // src/domains/installation/file-merger.ts
 init_logger();
@@ -36208,9 +36208,6 @@ class InstalledSettingsTracker {
   }
 }
 
-// src/domains/config/merger/merge-engine.ts
-init_logger();
-
 // src/domains/config/merger/diff-calculator.ts
 function truncateCommand(cmd, maxLen = 50) {
   if (cmd.length <= maxLen)
@@ -36409,12 +36406,61 @@ function mergeHooks(sourceHooks, destHooks, result, options) {
   const merged = { ...destHooks };
   const installedHooks = options?.installedSettings?.hooks ?? [];
   const sourceKit = options?.sourceKit;
+  const sourceCommands = new Set;
+  for (const entries of Object.values(sourceHooks)) {
+    extractCommands(entries, sourceCommands);
+  }
   for (const [eventName, sourceEntries] of Object.entries(sourceHooks)) {
     const destEntries = destHooks[eventName] || [];
     merged[eventName] = mergeHookEntries(sourceEntries, destEntries, eventName, result, installedHooks, sourceKit);
   }
+  if (installedHooks.length > 0) {
+    const deprecatedHooks = installedHooks.filter((hook) => !sourceCommands.has(normalizeCommand(hook)));
+    if (deprecatedHooks.length > 0) {
+      result.removedHooks = result.removedHooks ?? [];
+      for (const [eventName, entries] of Object.entries(merged)) {
+        const filtered = removeDeprecatedFromEntries(entries, deprecatedHooks, result);
+        if (filtered.length > 0) {
+          merged[eventName] = filtered;
+        } else {
+          delete merged[eventName];
+        }
+      }
+    }
+  }
   return merged;
 }
+function removeDeprecatedFromEntries(entries, deprecatedHooks, result) {
+  const deprecatedSet = new Set(deprecatedHooks.map((h2) => normalizeCommand(h2)));
+  const filtered = [];
+  for (const entry of entries) {
+    if ("hooks" in entry && entry.hooks) {
+      const remainingHooks = entry.hooks.filter((h2) => {
+        if (h2.command && deprecatedSet.has(normalizeCommand(h2.command))) {
+          result.hooksRemoved++;
+          result.removedHooks?.push(h2.command);
+          logger.info(`Removed deprecated hook: ${h2.command.slice(0, 60)}...`);
+          return false;
+        }
+        return true;
+      });
+      if (remainingHooks.length > 0) {
+        filtered.push({ ...entry, hooks: remainingHooks });
+      }
+    } else if ("command" in entry) {
+      if (deprecatedSet.has(normalizeCommand(entry.command))) {
+        result.hooksRemoved++;
+        result.removedHooks?.push(entry.command);
+        logger.info(`Removed deprecated hook: ${entry.command.slice(0, 60)}...`);
+      } else {
+        filtered.push(entry);
+      }
+    } else {
+      filtered.push(entry);
+    }
+  }
+  return filtered;
+}
 function mergeMcp(sourceMcp, destMcp, result, options) {
   if (!sourceMcp)
     return destMcp;
@@ -36491,6 +36537,24 @@ function mergeMcp(sourceMcp, destMcp, result, options) {
       }
     }
   }
+  if (installedServers.length > 0 && merged.servers) {
+    const sourceServerNames = new Set(Object.keys(sourceMcp.servers || {}));
+    const deprecatedServers = installedServers.filter((server) => !sourceServerNames.has(server));
+    if (deprecatedServers.length > 0) {
+      result.removedMcpServers = result.removedMcpServers ?? [];
+      for (const serverName of deprecatedServers) {
+        if (serverName in merged.servers) {
+          delete merged.servers[serverName];
+          result.mcpServersRemoved++;
+          result.removedMcpServers.push(serverName);
+          logger.info(`Removed deprecated MCP server: ${serverName}`);
+        }
+      }
+      if (merged.servers && Object.keys(merged.servers).length === 0) {
+        merged.servers = undefined;
+      }
+    }
+  }
   for (const key of Object.keys(sourceMcp)) {
     if (key !== "servers" && !(key in merged)) {
       merged[key] = sourceMcp[key];
@@ -36504,8 +36568,10 @@ function mergeSettings(source, destination, options) {
     hooksAdded: 0,
     hooksPreserved: 0,
     hooksSkipped: 0,
+    hooksRemoved: 0,
     mcpServersPreserved: 0,
     mcpServersSkipped: 0,
+    mcpServersRemoved: 0,
     conflictsDetected: [],
     newlyInstalledHooks: [],
     newlyInstalledServers: [],
@@ -37715,8 +37781,113 @@ class FileScanner2 {
 // src/services/transformers/commands-prefix/prefix-applier.ts
 init_logger();
 var import_fs_extra13 = __toESM(require_lib(), 1);
-import { lstat as lstat5, mkdir as mkdir16, readdir as readdir11, stat as stat8 } from "node:fs/promises";
+import { lstat as lstat5, mkdir as mkdir16, readdir as readdir12, stat as stat8 } from "node:fs/promises";
+import { join as join47 } from "node:path";
+
+// src/services/transformers/commands-prefix/content-transformer.ts
+init_logger();
+import { readFile as readFile17, readdir as readdir11, writeFile as writeFile14 } from "node:fs/promises";
 import { join as join46 } from "node:path";
+var TRANSFORMABLE_EXTENSIONS = new Set([
+  ".md",
+  ".txt",
+  ".json",
+  ".yaml",
+  ".yml",
+  ".ts",
+  ".js",
+  ".mjs",
+  ".cjs",
+  ".py"
+]);
+var COMMAND_ROOTS = [
+  "plan",
+  "fix",
+  "code",
+  "review",
+  "cook",
+  "brainstorm",
+  "integrate",
+  "bootstrap",
+  "worktree",
+  "scout",
+  "test",
+  "debug",
+  "preview",
+  "kanban",
+  "journal",
+  "watzup"
+];
+function buildCommandPatterns() {
+  const patterns = [];
+  for (const cmd of COMMAND_ROOTS) {
+    patterns.push({
+      regex: new RegExp(`(?<![\\w:])(\\/)${cmd}(:)`, "g"),
+      replacement: "$1ck:$2".replace("$2", `${cmd}:`)
+    });
+    patterns.push({
+      regex: new RegExp(`(?<![\\w:])(\\/)${cmd}(?=[\\s\`"'\\)\\]}>.,;:!?]|$)`, "g"),
+      replacement: `$1ck:${cmd}`
+    });
+  }
+  return patterns;
+}
+function transformCommandContent(content) {
+  let changes = 0;
+  let transformed = content;
+  const patterns = buildCommandPatterns();
+  for (const { regex: regex2, replacement } of patterns) {
+    regex2.lastIndex = 0;
+    const matches = transformed.match(regex2);
+    if (matches) {
+      changes += matches.length;
+      regex2.lastIndex = 0;
+      transformed = transformed.replace(regex2, replacement);
+    }
+  }
+  return { transformed, changes };
+}
+function shouldTransformFile(filename) {
+  const ext2 = filename.toLowerCase().slice(filename.lastIndexOf("."));
+  return TRANSFORMABLE_EXTENSIONS.has(ext2);
+}
+async function transformCommandReferences(directory, options = {}) {
+  let filesTransformed = 0;
+  let totalReplacements = 0;
+  async function processDirectory(dir) {
+    const entries = await readdir11(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join46(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (entry.name === "node_modules" || entry.name.startsWith(".") && entry.name !== ".claude") {
+          continue;
+        }
+        await processDirectory(fullPath);
+      } else if (entry.isFile() && shouldTransformFile(entry.name)) {
+        try {
+          const content = await readFile17(fullPath, "utf-8");
+          const { transformed, changes } = transformCommandContent(content);
+          if (changes > 0) {
+            if (options.dryRun) {
+              logger.debug(`[dry-run] Would transform ${changes} command ref(s) in ${fullPath}`);
+            } else {
+              await writeFile14(fullPath, transformed, "utf-8");
+              if (options.verbose) {
+                logger.verbose(`Transformed ${changes} command ref(s) in ${fullPath}`);
+              }
+            }
+            filesTransformed++;
+            totalReplacements += changes;
+          }
+        } catch (error) {
+          logger.debug(`Skipped ${fullPath}: ${error instanceof Error ? error.message : "unknown"}`);
+        }
+      }
+    }
+  }
+  await processDirectory(directory);
+  return { filesTransformed, totalReplacements };
+}
 
 // src/services/transformers/commands-prefix/prefix-utils.ts
 init_logger();
@@ -37761,22 +37932,22 @@ function shouldApplyPrefix(options) {
 // src/services/transformers/commands-prefix/prefix-applier.ts
 async function applyPrefix(extractDir) {
   validatePath(extractDir, "extractDir");
-  const commandsDir = join46(extractDir, ".claude", "commands");
+  const commandsDir = join47(extractDir, ".claude", "commands");
   if (!await import_fs_extra13.pathExists(commandsDir)) {
     logger.verbose("No commands directory found, skipping prefix application");
     return;
   }
   logger.info("Applying /ck: prefix to slash commands...");
-  const backupDir = join46(extractDir, ".commands-backup");
-  const tempDir = join46(extractDir, ".commands-prefix-temp");
+  const backupDir = join47(extractDir, ".commands-backup");
+  const tempDir = join47(extractDir, ".commands-prefix-temp");
   try {
-    const entries = await readdir11(commandsDir);
+    const entries = await readdir12(commandsDir);
     if (entries.length === 0) {
       logger.verbose("Commands directory is empty, skipping prefix application");
       return;
     }
     if (entries.length === 1 && entries[0] === "ck") {
-      const ckDir2 = join46(commandsDir, "ck");
+      const ckDir2 = join47(commandsDir, "ck");
       const ckStat = await stat8(ckDir2);
       if (ckStat.isDirectory()) {
         logger.verbose("Commands already have /ck: prefix, skipping");
@@ -37786,17 +37957,17 @@ async function applyPrefix(extractDir) {
     await import_fs_extra13.copy(commandsDir, backupDir);
     logger.verbose("Created backup of commands directory");
     await mkdir16(tempDir, { recursive: true });
-    const ckDir = join46(tempDir, "ck");
+    const ckDir = join47(tempDir, "ck");
     await mkdir16(ckDir, { recursive: true });
     let processedCount = 0;
     for (const entry of entries) {
-      const sourcePath = join46(commandsDir, entry);
+      const sourcePath = join47(commandsDir, entry);
       const stats = await lstat5(sourcePath);
       if (stats.isSymbolicLink()) {
         logger.warning(`Skipping symlink for security: ${entry}`);
         continue;
       }
-      const destPath = join46(ckDir, entry);
+      const destPath = join47(ckDir, entry);
       await import_fs_extra13.copy(sourcePath, destPath, {
         overwrite: false,
         errorOnExist: true
@@ -37813,7 +37984,17 @@ async function applyPrefix(extractDir) {
     await import_fs_extra13.remove(commandsDir);
     await import_fs_extra13.move(tempDir, commandsDir);
     await import_fs_extra13.remove(backupDir);
-    logger.success("Successfully applied /ck: prefix to all commands");
+    logger.success("Successfully reorganized commands to /ck: prefix");
+    const claudeDir = join47(extractDir, ".claude");
+    logger.info("Transforming command references in file contents...");
+    const transformResult = await transformCommandReferences(claudeDir, {
+      verbose: logger.isVerbose()
+    });
+    if (transformResult.totalReplacements > 0) {
+      logger.success(`Transformed ${transformResult.totalReplacements} command ref(s) in ${transformResult.filesTransformed} file(s)`);
+    } else {
+      logger.verbose("No command references needed transformation");
+    }
   } catch (error) {
     if (await import_fs_extra13.pathExists(backupDir)) {
       try {
@@ -37840,21 +38021,21 @@ async function applyPrefix(extractDir) {
 }
 
 // src/services/transformers/commands-prefix/prefix-cleaner.ts
-import { lstat as lstat7, readdir as readdir13 } from "node:fs/promises";
-import { join as join48 } from "node:path";
+import { lstat as lstat7, readdir as readdir14 } from "node:fs/promises";
+import { join as join49 } from "node:path";
 init_logger();
 var import_fs_extra15 = __toESM(require_lib(), 1);
 
 // src/services/transformers/commands-prefix/file-processor.ts
-import { lstat as lstat6, readdir as readdir12 } from "node:fs/promises";
-import { join as join47 } from "node:path";
+import { lstat as lstat6, readdir as readdir13 } from "node:fs/promises";
+import { join as join48 } from "node:path";
 init_logger();
 var import_fs_extra14 = __toESM(require_lib(), 1);
 async function scanDirectoryFiles(dir) {
   const files = [];
-  const entries = await readdir12(dir);
+  const entries = await readdir13(dir);
   for (const entry of entries) {
-    const fullPath = join47(dir, entry);
+    const fullPath = join48(dir, entry);
     const stats = await lstat6(fullPath);
     if (stats.isSymbolicLink()) {
       continue;
@@ -37962,8 +38143,8 @@ function logCleanupSummary(deletedCount, preservedCount, dryRun, results) {
 async function cleanupCommandsDirectory(targetDir, isGlobal, options = {}) {
   const { dryRun = false } = options;
   validatePath(targetDir, "targetDir");
-  const claudeDir = isGlobal ? targetDir : join48(targetDir, ".claude");
-  const commandsDir = join48(claudeDir, "commands");
+  const claudeDir = isGlobal ? targetDir : join49(targetDir, ".claude");
+  const commandsDir = join49(claudeDir, "commands");
   const accumulator = {
     results: [],
     deletedCount: 0,
@@ -37991,13 +38172,13 @@ async function cleanupCommandsDirectory(targetDir, isGlobal, options = {}) {
     logger.verbose("All existing files will be preserved as user-owned");
     return result;
   }
-  const entries = await readdir13(commandsDir);
+  const entries = await readdir14(commandsDir);
   if (entries.length === 0) {
     logger.verbose("Commands directory is empty");
     return result;
   }
   for (const entry of entries) {
-    const entryPath = join48(commandsDir, entry);
+    const entryPath = join49(commandsDir, entry);
     const stats = await lstat7(entryPath);
     if (stats.isSymbolicLink()) {
       addSymlinkSkip(entry, accumulator);
@@ -38049,7 +38230,7 @@ async function handleMerge(ctx) {
   let customClaudeFiles = [];
   if (!ctx.options.fresh) {
     logger.info("Scanning for custom .claude files...");
-    const scanSourceDir = ctx.options.global ? join49(ctx.extractDir, ".claude") : ctx.extractDir;
+    const scanSourceDir = ctx.options.global ? join50(ctx.extractDir, ".claude") : ctx.extractDir;
     const scanTargetSubdir = ctx.options.global ? "" : ".claude";
     customClaudeFiles = await FileScanner2.findCustomFiles(ctx.resolvedDir, scanSourceDir, scanTargetSubdir);
   } else {
@@ -38113,7 +38294,7 @@ async function handleMerge(ctx) {
       return { ...ctx, cancelled: true };
     }
   }
-  const sourceDir = ctx.options.global ? join49(ctx.extractDir, ".claude") : ctx.extractDir;
+  const sourceDir = ctx.options.global ? join50(ctx.extractDir, ".claude") : ctx.extractDir;
   await merger.merge(sourceDir, ctx.resolvedDir, ctx.isNonInteractive);
   const fileConflicts = merger.getFileConflicts();
   if (fileConflicts.length > 0 && !ctx.isNonInteractive) {
@@ -38142,7 +38323,7 @@ async function handleMerge(ctx) {
   };
 }
 // src/commands/init/phases/migration-handler.ts
-import { join as join57 } from "node:path";
+import { join as join58 } from "node:path";
 
 // src/domains/skills/skills-detector.ts
 init_logger();
@@ -38154,8 +38335,8 @@ init_logger();
 // src/domains/skills/skills-manifest.ts
 init_logger();
 import { createHash as createHash2 } from "node:crypto";
-import { readFile as readFile17, readdir as readdir14, writeFile as writeFile14 } from "node:fs/promises";
-import { join as join50, relative as relative9 } from "node:path";
+import { readFile as readFile18, readdir as readdir15, writeFile as writeFile15 } from "node:fs/promises";
+import { join as join51, relative as relative9 } from "node:path";
 init_types2();
 var import_fs_extra17 = __toESM(require_lib(), 1);
 
@@ -38179,18 +38360,18 @@ class SkillsManifestManager {
     return manifest;
   }
   static async writeManifest(skillsDir, manifest) {
-    const manifestPath = join50(skillsDir, SkillsManifestManager.MANIFEST_FILENAME);
-    await writeFile14(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
+    const manifestPath = join51(skillsDir, SkillsManifestManager.MANIFEST_FILENAME);
+    await writeFile15(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
     logger.debug(`Wrote manifest to: ${manifestPath}`);
   }
   static async readManifest(skillsDir) {
-    const manifestPath = join50(skillsDir, SkillsManifestManager.MANIFEST_FILENAME);
+    const manifestPath = join51(skillsDir, SkillsManifestManager.MANIFEST_FILENAME);
     if (!await import_fs_extra17.pathExists(manifestPath)) {
       logger.debug(`No manifest found at: ${manifestPath}`);
       return null;
     }
     try {
-      const content = await readFile17(manifestPath, "utf-8");
+      const content = await readFile18(manifestPath, "utf-8");
       const data = JSON.parse(content);
       const manifest = SkillsManifestSchema.parse(data);
       logger.debug(`Read manifest from: ${manifestPath}`);
@@ -38201,14 +38382,14 @@ class SkillsManifestManager {
     }
   }
   static async detectStructure(skillsDir) {
-    const entries = await readdir14(skillsDir, { withFileTypes: true });
+    const entries = await readdir15(skillsDir, { withFileTypes: true });
     const dirs = entries.filter((entry) => entry.isDirectory() && !BUILD_ARTIFACT_DIRS.includes(entry.name) && !entry.name.startsWith("."));
     if (dirs.length === 0) {
       return "flat";
     }
     for (const dir of dirs.slice(0, 3)) {
-      const dirPath = join50(skillsDir, dir.name);
-      const subEntries = await readdir14(dirPath, { withFileTypes: true });
+      const dirPath = join51(skillsDir, dir.name);
+      const subEntries = await readdir15(dirPath, { withFileTypes: true });
       const hasSubdirs = subEntries.some((entry) => entry.isDirectory());
       if (hasSubdirs) {
         return "categorized";
@@ -38223,10 +38404,10 @@ class SkillsManifestManager {
   static async scanSkills(skillsDir, structure) {
     const skills = [];
     if (structure === "flat") {
-      const entries = await readdir14(skillsDir, { withFileTypes: true });
+      const entries = await readdir15(skillsDir, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isDirectory() && !BUILD_ARTIFACT_DIRS.includes(entry.name) && !entry.name.startsWith(".")) {
-          const skillPath = join50(skillsDir, entry.name);
+          const skillPath = join51(skillsDir, entry.name);
           const hash = await SkillsManifestManager.hashDirectory(skillPath);
           skills.push({
             name: entry.name,
@@ -38235,14 +38416,14 @@ class SkillsManifestManager {
         }
       }
     } else {
-      const categories = await readdir14(skillsDir, { withFileTypes: true });
+      const categories = await readdir15(skillsDir, { withFileTypes: true });
       for (const category of categories) {
         if (category.isDirectory() && !BUILD_ARTIFACT_DIRS.includes(category.name) && !category.name.startsWith(".")) {
-          const categoryPath = join50(skillsDir, category.name);
-          const skillEntries = await readdir14(categoryPath, { withFileTypes: true });
+          const categoryPath = join51(skillsDir, category.name);
+          const skillEntries = await readdir15(categoryPath, { withFileTypes: true });
           for (const skillEntry of skillEntries) {
             if (skillEntry.isDirectory() && !skillEntry.name.startsWith(".")) {
-              const skillPath = join50(categoryPath, skillEntry.name);
+              const skillPath = join51(categoryPath, skillEntry.name);
               const hash = await SkillsManifestManager.hashDirectory(skillPath);
               skills.push({
                 name: skillEntry.name,
@@ -38262,7 +38443,7 @@ class SkillsManifestManager {
     files.sort();
     for (const file of files) {
       const relativePath = relative9(dirPath, file);
-      const content = await readFile17(file);
+      const content = await readFile18(file);
       hash.update(relativePath);
       hash.update(content);
     }
@@ -38270,9 +38451,9 @@ class SkillsManifestManager {
   }
   static async getAllFiles(dirPath) {
     const files = [];
-    const entries = await readdir14(dirPath, { withFileTypes: true });
+    const entries = await readdir15(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join50(dirPath, entry.name);
+      const fullPath = join51(dirPath, entry.name);
       if (entry.name.startsWith(".") || BUILD_ARTIFACT_DIRS.includes(entry.name)) {
         continue;
       }
@@ -38393,13 +38574,13 @@ function getPathMapping(skillName, oldBasePath, newBasePath) {
 
 // src/domains/skills/detection/script-detector.ts
 var import_fs_extra18 = __toESM(require_lib(), 1);
-import { readdir as readdir15 } from "node:fs/promises";
-import { join as join51 } from "node:path";
+import { readdir as readdir16 } from "node:fs/promises";
+import { join as join52 } from "node:path";
 async function scanDirectory(skillsDir) {
   if (!await import_fs_extra18.pathExists(skillsDir)) {
     return ["flat", []];
   }
-  const entries = await readdir15(skillsDir, { withFileTypes: true });
+  const entries = await readdir16(skillsDir, { withFileTypes: true });
   const dirs = entries.filter((entry) => entry.isDirectory() && entry.name !== "node_modules" && !entry.name.startsWith("."));
   if (dirs.length === 0) {
     return ["flat", []];
@@ -38407,13 +38588,13 @@ async function scanDirectory(skillsDir) {
   let totalSkillLikeCount = 0;
   const allSkills = [];
   for (const dir of dirs) {
-    const dirPath = join51(skillsDir, dir.name);
-    const subEntries = await readdir15(dirPath, { withFileTypes: true });
+    const dirPath = join52(skillsDir, dir.name);
+    const subEntries = await readdir16(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 = join51(dirPath, subdir.name);
-        const subdirFiles = await readdir15(subdirPath, { withFileTypes: true });
+        const subdirPath = join52(dirPath, subdir.name);
+        const subdirFiles = await readdir16(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++;
@@ -38569,12 +38750,12 @@ class SkillsMigrationDetector {
 // src/domains/skills/skills-migrator.ts
 init_logger();
 init_types2();
-import { join as join56 } from "node:path";
+import { join as join57 } from "node:path";
 
 // src/domains/skills/migrator/migration-executor.ts
 init_logger();
-import { copyFile as copyFile4, mkdir as mkdir17, readdir as readdir16, rm as rm3 } from "node:fs/promises";
-import { join as join52 } from "node:path";
+import { copyFile as copyFile4, mkdir as mkdir17, readdir as readdir17, rm as rm3 } from "node:fs/promises";
+import { join as join53 } from "node:path";
 var import_fs_extra20 = __toESM(require_lib(), 1);
 
 // src/domains/skills/skills-migration-prompts.ts
@@ -38737,10 +38918,10 @@ Detected changes:`;
 // src/domains/skills/migrator/migration-executor.ts
 async function copySkillDirectory(sourceDir, destDir) {
   await mkdir17(destDir, { recursive: true });
-  const entries = await readdir16(sourceDir, { withFileTypes: true });
+  const entries = await readdir17(sourceDir, { withFileTypes: true });
   for (const entry of entries) {
-    const sourcePath = join52(sourceDir, entry.name);
-    const destPath = join52(destDir, entry.name);
+    const sourcePath = join53(sourceDir, entry.name);
+    const destPath = join53(destDir, entry.name);
     if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.isSymbolicLink()) {
       continue;
     }
@@ -38755,7 +38936,7 @@ async function executeInternal(mappings, customizations, currentSkillsDir, inter
   const migrated = [];
   const preserved = [];
   const errors2 = [];
-  const tempDir = join52(currentSkillsDir, "..", ".skills-migration-temp");
+  const tempDir = join53(currentSkillsDir, "..", ".skills-migration-temp");
   await mkdir17(tempDir, { recursive: true });
   try {
     for (const mapping of mappings) {
@@ -38776,9 +38957,9 @@ async function executeInternal(mappings, customizations, currentSkillsDir, inter
           }
         }
         const category = mapping.category;
-        const targetPath = category ? join52(tempDir, category, skillName) : join52(tempDir, skillName);
+        const targetPath = category ? join53(tempDir, category, skillName) : join53(tempDir, skillName);
         if (category) {
-          await mkdir17(join52(tempDir, category), { recursive: true });
+          await mkdir17(join53(tempDir, category), { recursive: true });
         }
         await copySkillDirectory(currentSkillPath, targetPath);
         migrated.push(skillName);
@@ -38844,8 +39025,8 @@ function validateMigrationPath(path11, paramName) {
 init_logger();
 init_types2();
 var import_fs_extra21 = __toESM(require_lib(), 1);
-import { copyFile as copyFile5, mkdir as mkdir18, readdir as readdir17, rm as rm4, stat as stat9 } from "node:fs/promises";
-import { basename as basename2, join as join53, normalize as normalize6 } from "node:path";
+import { copyFile as copyFile5, mkdir as mkdir18, readdir as readdir18, rm as rm4, stat as stat9 } from "node:fs/promises";
+import { basename as basename2, join as join54, normalize as normalize6 } from "node:path";
 function validatePath2(path11, paramName) {
   if (!path11 || typeof path11 !== "string") {
     throw new SkillsMigrationError(`${paramName} must be a non-empty string`);
@@ -38871,7 +39052,7 @@ class SkillsBackupManager {
     const timestamp = Date.now();
     const randomSuffix = Math.random().toString(36).substring(2, 8);
     const backupDirName = `${SkillsBackupManager.BACKUP_PREFIX}${timestamp}-${randomSuffix}`;
-    const backupDir = parentDir ? join53(parentDir, backupDirName) : join53(skillsDir, "..", backupDirName);
+    const backupDir = parentDir ? join54(parentDir, backupDirName) : join54(skillsDir, "..", backupDirName);
     logger.info(`Creating backup at: ${backupDir}`);
     try {
       await mkdir18(backupDir, { recursive: true });
@@ -38921,8 +39102,8 @@ class SkillsBackupManager {
       return [];
     }
     try {
-      const entries = await readdir17(parentDir, { withFileTypes: true });
-      const backups = entries.filter((entry) => entry.isDirectory() && entry.name.startsWith(SkillsBackupManager.BACKUP_PREFIX)).map((entry) => join53(parentDir, entry.name));
+      const entries = await readdir18(parentDir, { withFileTypes: true });
+      const backups = entries.filter((entry) => entry.isDirectory() && entry.name.startsWith(SkillsBackupManager.BACKUP_PREFIX)).map((entry) => join54(parentDir, entry.name));
       backups.sort().reverse();
       return backups;
     } catch (error) {
@@ -38948,10 +39129,10 @@ class SkillsBackupManager {
     return await SkillsBackupManager.getDirectorySize(backupDir);
   }
   static async copyDirectory(sourceDir, destDir) {
-    const entries = await readdir17(sourceDir, { withFileTypes: true });
+    const entries = await readdir18(sourceDir, { withFileTypes: true });
     for (const entry of entries) {
-      const sourcePath = join53(sourceDir, entry.name);
-      const destPath = join53(destDir, entry.name);
+      const sourcePath = join54(sourceDir, entry.name);
+      const destPath = join54(destDir, entry.name);
       if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.isSymbolicLink()) {
         continue;
       }
@@ -38965,9 +39146,9 @@ class SkillsBackupManager {
   }
   static async getDirectorySize(dirPath) {
     let size = 0;
-    const entries = await readdir17(dirPath, { withFileTypes: true });
+    const entries = await readdir18(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join53(dirPath, entry.name);
+      const fullPath = join54(dirPath, entry.name);
       if (entry.isSymbolicLink()) {
         continue;
       }
@@ -39001,13 +39182,13 @@ import { relative as relative11 } from "node:path";
 // src/domains/skills/customization/hash-calculator.ts
 import { createHash as createHash3 } from "node:crypto";
 import { createReadStream as createReadStream2 } from "node:fs";
-import { readFile as readFile18, readdir as readdir18 } from "node:fs/promises";
-import { join as join54, relative as relative10 } from "node:path";
+import { readFile as readFile19, readdir as readdir19 } from "node:fs/promises";
+import { join as join55, relative as relative10 } from "node:path";
 async function getAllFiles(dirPath) {
   const files = [];
-  const entries = await readdir18(dirPath, { withFileTypes: true });
+  const entries = await readdir19(dirPath, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = join54(dirPath, entry.name);
+    const fullPath = join55(dirPath, entry.name);
     if (entry.name.startsWith(".") || BUILD_ARTIFACT_DIRS.includes(entry.name) || entry.isSymbolicLink()) {
       continue;
     }
@@ -39040,7 +39221,7 @@ async function hashDirectory(dirPath) {
   files.sort();
   for (const file of files) {
     const relativePath = relative10(dirPath, file);
-    const content = await readFile18(file);
+    const content = await readFile19(file);
     hash.update(relativePath);
     hash.update(content);
   }
@@ -39133,8 +39314,8 @@ async function detectFileChanges(currentSkillPath, baselineSkillPath) {
 // src/domains/skills/customization/scan-reporter.ts
 init_types2();
 var import_fs_extra23 = __toESM(require_lib(), 1);
-import { readdir as readdir19 } from "node:fs/promises";
-import { join as join55, normalize as normalize7 } from "node:path";
+import { readdir as readdir20 } from "node:fs/promises";
+import { join as join56, normalize as normalize7 } from "node:path";
 function validatePath3(path11, paramName) {
   if (!path11 || typeof path11 !== "string") {
     throw new SkillsMigrationError(`${paramName} must be a non-empty string`);
@@ -39150,19 +39331,19 @@ async function scanSkillsDirectory(skillsDir) {
   if (!await import_fs_extra23.pathExists(skillsDir)) {
     return ["flat", []];
   }
-  const entries = await readdir19(skillsDir, { withFileTypes: true });
+  const entries = await readdir20(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 = join55(skillsDir, dirs[0].name);
-  const subEntries = await readdir19(firstDirPath, { withFileTypes: true });
+  const firstDirPath = join56(skillsDir, dirs[0].name);
+  const subEntries = await readdir20(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 = join55(firstDirPath, subdir.name);
-      const subdirFiles = await readdir19(subdirPath, { withFileTypes: true });
+      const subdirPath = join56(firstDirPath, subdir.name);
+      const subdirFiles = await readdir20(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++;
@@ -39171,8 +39352,8 @@ async function scanSkillsDirectory(skillsDir) {
     if (skillLikeCount > 0) {
       const skills = [];
       for (const dir of dirs) {
-        const categoryPath = join55(skillsDir, dir.name);
-        const skillDirs = await readdir19(categoryPath, { withFileTypes: true });
+        const categoryPath = join56(skillsDir, dir.name);
+        const skillDirs = await readdir20(categoryPath, { withFileTypes: true });
         skills.push(...skillDirs.filter((entry) => entry.isDirectory() && !entry.name.startsWith(".")).map((entry) => entry.name));
       }
       return ["categorized", skills];
@@ -39181,17 +39362,17 @@ async function scanSkillsDirectory(skillsDir) {
   return ["flat", dirs.map((dir) => dir.name)];
 }
 async function findSkillPath(skillsDir, skillName) {
-  const flatPath = join55(skillsDir, skillName);
+  const flatPath = join56(skillsDir, skillName);
   if (await import_fs_extra23.pathExists(flatPath)) {
     return { path: flatPath, category: undefined };
   }
-  const entries = await readdir19(skillsDir, { withFileTypes: true });
+  const entries = await readdir20(skillsDir, { withFileTypes: true });
   for (const entry of entries) {
     if (!entry.isDirectory() || entry.name.startsWith(".") || entry.name === "node_modules") {
       continue;
     }
-    const categoryPath = join55(skillsDir, entry.name);
-    const skillPath = join55(categoryPath, skillName);
+    const categoryPath = join56(skillsDir, entry.name);
+    const skillPath = join56(categoryPath, skillName);
     if (await import_fs_extra23.pathExists(skillPath)) {
       return { path: skillPath, category: entry.name };
     }
@@ -39285,7 +39466,7 @@ class SkillsMigrator {
         }
       }
       if (options.backup && !options.dryRun) {
-        const claudeDir = join56(currentSkillsDir, "..");
+        const claudeDir = join57(currentSkillsDir, "..");
         result.backupPath = await SkillsBackupManager.createBackup(currentSkillsDir, claudeDir);
         logger.success(`Backup created at: ${result.backupPath}`);
       }
@@ -39345,7 +39526,7 @@ async function handleMigration(ctx) {
     logger.debug("Skipping skills migration (fresh installation)");
     return ctx;
   }
-  const newSkillsDir = join57(ctx.extractDir, ".claude", "skills");
+  const newSkillsDir = join58(ctx.extractDir, ".claude", "skills");
   const currentSkillsDir = PathResolver.buildSkillsPath(ctx.resolvedDir, ctx.options.global);
   if (!await import_fs_extra24.pathExists(newSkillsDir) || !await import_fs_extra24.pathExists(currentSkillsDir)) {
     return ctx;
@@ -39370,10 +39551,10 @@ async function handleMigration(ctx) {
 // src/domains/config/config-manager.ts
 init_logger();
 import { existsSync as existsSync18 } from "node:fs";
-import { mkdir as mkdir19, readFile as readFile19, rename as rename2, rm as rm5, writeFile as writeFile15 } from "node:fs/promises";
+import { mkdir as mkdir19, readFile as readFile20, rename as rename2, rm as rm5, writeFile as writeFile16 } from "node:fs/promises";
 import { chmod as chmod2 } from "node:fs/promises";
 import { platform as platform10 } from "node:os";
-import { join as join58 } from "node:path";
+import { join as join59 } from "node:path";
 init_types2();
 var PROJECT_CONFIG_FILE = ".ck.json";
 
@@ -39381,7 +39562,7 @@ class ConfigManager {
   static config = null;
   static globalFlag = false;
   static getProjectConfigDir(projectDir, global3) {
-    return global3 ? projectDir : join58(projectDir, ".claude");
+    return global3 ? projectDir : join59(projectDir, ".claude");
   }
   static setGlobalFlag(global3) {
     ConfigManager.globalFlag = global3;
@@ -39397,7 +39578,7 @@ class ConfigManager {
     const configFile = PathResolver.getConfigFile(ConfigManager.globalFlag);
     try {
       if (existsSync18(configFile)) {
-        const content = await readFile19(configFile, "utf-8");
+        const content = await readFile20(configFile, "utf-8");
         const data = JSON.parse(content);
         ConfigManager.config = ConfigSchema.parse(data);
         logger.debug(`Config loaded from ${configFile}`);
@@ -39420,7 +39601,7 @@ class ConfigManager {
           await chmod2(configDir, 448);
         }
       }
-      await writeFile15(configFile, JSON.stringify(validConfig, null, 2), "utf-8");
+      await writeFile16(configFile, JSON.stringify(validConfig, null, 2), "utf-8");
       if (platform10() !== "win32") {
         await chmod2(configFile, 384);
       }
@@ -39448,10 +39629,10 @@ class ConfigManager {
   }
   static async loadProjectConfig(projectDir, global3 = false) {
     const configDir = ConfigManager.getProjectConfigDir(projectDir, global3);
-    const configPath = join58(configDir, PROJECT_CONFIG_FILE);
+    const configPath = join59(configDir, PROJECT_CONFIG_FILE);
     try {
       if (existsSync18(configPath)) {
-        const content = await readFile19(configPath, "utf-8");
+        const content = await readFile20(configPath, "utf-8");
         const data = JSON.parse(content);
         const folders = FoldersConfigSchema.parse(data.paths || data);
         logger.debug(`Project config loaded from ${configPath}`);
@@ -39464,7 +39645,7 @@ class ConfigManager {
   }
   static async saveProjectConfig(projectDir, folders, global3 = false) {
     const configDir = ConfigManager.getProjectConfigDir(projectDir, global3);
-    const configPath = join58(configDir, PROJECT_CONFIG_FILE);
+    const configPath = join59(configDir, PROJECT_CONFIG_FILE);
     try {
       if (!existsSync18(configDir)) {
         await mkdir19(configDir, { recursive: true });
@@ -39472,7 +39653,7 @@ class ConfigManager {
       let existingConfig = {};
       if (existsSync18(configPath)) {
         try {
-          const content = await readFile19(configPath, "utf-8");
+          const content = await readFile20(configPath, "utf-8");
           existingConfig = JSON.parse(content);
         } catch (error) {
           logger.debug(`Could not parse existing config, starting fresh: ${error instanceof Error ? error.message : "Unknown error"}`);
@@ -39487,7 +39668,7 @@ class ConfigManager {
           ...validFolders
         }
       };
-      await writeFile15(configPath, JSON.stringify(mergedConfig, null, 2), "utf-8");
+      await writeFile16(configPath, JSON.stringify(mergedConfig, null, 2), "utf-8");
       logger.debug(`Project config saved to ${configPath}`);
     } catch (error) {
       throw new Error(`Failed to save project config: ${error instanceof Error ? error.message : "Unknown error"}`);
@@ -39513,11 +39694,11 @@ class ConfigManager {
   }
   static projectConfigExists(projectDir, global3 = false) {
     const configDir = ConfigManager.getProjectConfigDir(projectDir, global3);
-    return existsSync18(join58(configDir, PROJECT_CONFIG_FILE));
+    return existsSync18(join59(configDir, PROJECT_CONFIG_FILE));
   }
   static async migrateNestedConfig(globalDir) {
-    const correctPath = join58(globalDir, PROJECT_CONFIG_FILE);
-    const incorrectPath = join58(globalDir, ".claude", PROJECT_CONFIG_FILE);
+    const correctPath = join59(globalDir, PROJECT_CONFIG_FILE);
+    const incorrectPath = join59(globalDir, ".claude", PROJECT_CONFIG_FILE);
     if (existsSync18(correctPath)) {
       logger.debug("Config already exists at correct location, skipping migration");
       return false;
@@ -39527,7 +39708,7 @@ class ConfigManager {
         logger.info("Migrating .ck.json from nested location to correct location...");
         await rename2(incorrectPath, correctPath);
         logger.success(`Migrated ${PROJECT_CONFIG_FILE} to ${correctPath}`);
-        const nestedClaudeDir = join58(globalDir, ".claude");
+        const nestedClaudeDir = join59(globalDir, ".claude");
         try {
           await rm5(nestedClaudeDir, { recursive: false });
           logger.debug("Removed empty nested .claude directory");
@@ -39618,14 +39799,14 @@ Please use only one download method.`);
   };
 }
 // src/commands/init/phases/post-install-handler.ts
-import { join as join61 } from "node:path";
+import { join as join62 } from "node:path";
 
 // src/domains/installation/setup-wizard.ts
-import { join as join60 } from "node:path";
+import { join as join61 } from "node:path";
 
 // src/domains/config/config-generator.ts
 var import_fs_extra25 = __toESM(require_lib(), 1);
-import { join as join59 } from "node:path";
+import { join as join60 } from "node:path";
 async function generateEnvFile(targetDir, values) {
   const lines = [
     "# Generated by ClaudeKit CLI setup wizard",
@@ -39667,7 +39848,7 @@ async function generateEnvFile(targetDir, values) {
   for (const [key, value] of otherValues) {
     lines.push(`${key}=${value}`);
   }
-  const envPath = join59(targetDir, ".env");
+  const envPath = join60(targetDir, ".env");
   await import_fs_extra25.writeFile(envPath, `${lines.join(`
 `)}
 `, { mode: 384 });
@@ -39741,7 +39922,7 @@ async function parseEnvFile(path11) {
   }
 }
 async function checkGlobalConfig() {
-  const globalEnvPath = join60(PathResolver.getGlobalKitDir(), ".env");
+  const globalEnvPath = join61(PathResolver.getGlobalKitDir(), ".env");
   if (!await import_fs_extra26.pathExists(globalEnvPath))
     return false;
   const env2 = await parseEnvFile(globalEnvPath);
@@ -39757,7 +39938,7 @@ async function runSetupWizard(options) {
   let globalEnv = {};
   const hasGlobalConfig = !isGlobal && await checkGlobalConfig();
   if (!isGlobal) {
-    const globalEnvPath = join60(PathResolver.getGlobalKitDir(), ".env");
+    const globalEnvPath = join61(PathResolver.getGlobalKitDir(), ".env");
     if (await import_fs_extra26.pathExists(globalEnvPath)) {
       globalEnv = await parseEnvFile(globalEnvPath);
     }
@@ -39820,7 +40001,7 @@ async function runSetupWizard(options) {
     }
   }
   await generateEnvFile(targetDir, values);
-  f2.success(`Configuration saved to ${join60(targetDir, ".env")}`);
+  f2.success(`Configuration saved to ${join61(targetDir, ".env")}`);
   return true;
 }
 async function promptForAdditionalGeminiKeys(primaryKey) {
@@ -39876,8 +40057,8 @@ async function handlePostInstall(ctx) {
     return ctx;
   }
   if (ctx.options.global) {
-    const claudeMdSource = join61(ctx.extractDir, "CLAUDE.md");
-    const claudeMdDest = join61(ctx.resolvedDir, "CLAUDE.md");
+    const claudeMdSource = join62(ctx.extractDir, "CLAUDE.md");
+    const claudeMdDest = join62(ctx.resolvedDir, "CLAUDE.md");
     if (await import_fs_extra27.pathExists(claudeMdSource)) {
       if (!await import_fs_extra27.pathExists(claudeMdDest)) {
         await import_fs_extra27.copy(claudeMdSource, claudeMdDest);
@@ -39924,7 +40105,7 @@ async function handlePostInstall(ctx) {
     }
   }
   if (!ctx.options.skipSetup && !ctx.isNonInteractive) {
-    const envPath = join61(ctx.claudeDir, ".env");
+    const envPath = join62(ctx.claudeDir, ".env");
     if (!await import_fs_extra27.pathExists(envPath)) {
       const shouldSetup = await ctx.prompts.confirm("Set up API keys now? (Gemini API key for ai-multimodal skill, optional webhooks)");
       if (shouldSetup) {
@@ -39946,7 +40127,7 @@ Optional: DISCORD_WEBHOOK_URL, TELEGRAM_BOT_TOKEN`, "Configuration skipped");
 }
 // src/commands/init/phases/selection-handler.ts
 import { mkdir as mkdir20 } from "node:fs/promises";
-import { join as join63, resolve as resolve7 } from "node:path";
+import { join as join64, resolve as resolve7 } from "node:path";
 
 // src/domains/github/kit-access-checker.ts
 init_logger();
@@ -39975,7 +40156,7 @@ async function detectAccessibleKits() {
 
 // src/domains/installation/fresh-installer.ts
 init_logger();
-import { join as join62 } from "node:path";
+import { join as join63 } from "node:path";
 var import_fs_extra28 = __toESM(require_lib(), 1);
 var CLAUDEKIT_SUBDIRECTORIES = ["commands", "agents", "skills", "workflows", "hooks"];
 async function handleFreshInstallation(claudeDir, prompts) {
@@ -39994,7 +40175,7 @@ async function handleFreshInstallation(claudeDir, prompts) {
     const { rmSync } = await import("node:fs");
     let removedCount = 0;
     for (const subdir of CLAUDEKIT_SUBDIRECTORIES) {
-      const subdirPath = join62(claudeDir, subdir);
+      const subdirPath = join63(claudeDir, subdir);
       if (await import_fs_extra28.pathExists(subdirPath)) {
         rmSync(subdirPath, { recursive: true, force: true });
         removedCount++;
@@ -40188,7 +40369,7 @@ async function handleSelection(ctx) {
   }
   if (!ctx.options.fresh) {
     const prefix = PathResolver.getPathPrefix(ctx.options.global);
-    const claudeDir = prefix ? join63(resolvedDir, prefix) : resolvedDir;
+    const claudeDir = prefix ? join64(resolvedDir, prefix) : resolvedDir;
     try {
       const existingMetadata = await readManifest(claudeDir);
       if (existingMetadata?.kits) {
@@ -40220,7 +40401,7 @@ async function handleSelection(ctx) {
   }
   if (ctx.options.fresh) {
     const prefix = PathResolver.getPathPrefix(ctx.options.global);
-    const claudeDir = prefix ? join63(resolvedDir, prefix) : resolvedDir;
+    const claudeDir = prefix ? join64(resolvedDir, prefix) : resolvedDir;
     const canProceed = await handleFreshInstallation(claudeDir, ctx.prompts);
     if (!canProceed) {
       return { ...ctx, cancelled: true };
@@ -40238,7 +40419,7 @@ async function handleSelection(ctx) {
     logger.info("Fetching available versions...");
     let currentVersion = null;
     try {
-      const metadataPath = ctx.options.global ? join63(PathResolver.getGlobalKitDir(), "metadata.json") : join63(resolvedDir, ".claude", "metadata.json");
+      const metadataPath = ctx.options.global ? join64(PathResolver.getGlobalKitDir(), "metadata.json") : join64(resolvedDir, ".claude", "metadata.json");
       const metadata = await readClaudeKitMetadata(metadataPath);
       currentVersion = metadata?.version || null;
       if (currentVersion) {
@@ -40306,8 +40487,8 @@ async function handleSelection(ctx) {
   };
 }
 // src/commands/init/phases/sync-handler.ts
-import { copyFile as copyFile6, mkdir as mkdir21, open, rename as rename3, stat as stat10, unlink as unlink7, writeFile as writeFile17 } from "node:fs/promises";
-import { dirname as dirname9, join as join64, resolve as resolve8 } from "node:path";
+import { copyFile as copyFile6, mkdir as mkdir21, open, rename as rename3, stat as stat10, unlink as unlink7, writeFile as writeFile18 } from "node:fs/promises";
+import { dirname as dirname9, join as join65, resolve as resolve8 } from "node:path";
 init_logger();
 var import_fs_extra30 = __toESM(require_lib(), 1);
 var import_picocolors19 = __toESM(require_picocolors(), 1);
@@ -40316,13 +40497,13 @@ async function handleSync(ctx) {
     return ctx;
   }
   const resolvedDir = ctx.options.global ? PathResolver.getGlobalKitDir() : resolve8(ctx.options.dir || ".");
-  const claudeDir = ctx.options.global ? resolvedDir : join64(resolvedDir, ".claude");
+  const claudeDir = ctx.options.global ? resolvedDir : join65(resolvedDir, ".claude");
   if (!await import_fs_extra30.pathExists(claudeDir)) {
     logger.error("Cannot sync: no .claude directory found");
     ctx.prompts.note("Run 'ck init' without --sync to install first.", "No Installation Found");
     return { ...ctx, cancelled: true };
   }
-  const metadataPath = join64(claudeDir, "metadata.json");
+  const metadataPath = join65(claudeDir, "metadata.json");
   if (!await import_fs_extra30.pathExists(metadataPath)) {
     logger.error("Cannot sync: no metadata.json found");
     ctx.prompts.note(`Your installation may be from an older version.
@@ -40422,7 +40603,7 @@ function getLockTimeout() {
 var STALE_LOCK_THRESHOLD_MS = 5 * 60 * 1000;
 async function acquireSyncLock(global3) {
   const cacheDir = PathResolver.getCacheDir(global3);
-  const lockPath = join64(cacheDir, ".sync-lock");
+  const lockPath = join65(cacheDir, ".sync-lock");
   const startTime = Date.now();
   const lockTimeout = getLockTimeout();
   await mkdir21(dirname9(lockPath), { recursive: true });
@@ -40468,7 +40649,7 @@ async function executeSyncMerge(ctx) {
   const releaseLock = await acquireSyncLock(ctx.options.global);
   try {
     const trackedFiles = ctx.syncTrackedFiles;
-    const upstreamDir = ctx.options.global ? join64(ctx.extractDir, ".claude") : ctx.extractDir;
+    const upstreamDir = ctx.options.global ? join65(ctx.extractDir, ".claude") : ctx.extractDir;
     logger.info("Analyzing file changes...");
     const plan = await SyncEngine.createSyncPlan(trackedFiles, ctx.claudeDir, upstreamDir);
     displaySyncPlan(plan);
@@ -40487,7 +40668,7 @@ async function executeSyncMerge(ctx) {
         try {
           const sourcePath = await validateSyncPath(upstreamDir, file.path);
           const targetPath = await validateSyncPath(ctx.claudeDir, file.path);
-          const targetDir = join64(targetPath, "..");
+          const targetDir = join65(targetPath, "..");
           try {
             await mkdir21(targetDir, { recursive: true });
           } catch (mkdirError) {
@@ -40568,7 +40749,7 @@ async function executeSyncMerge(ctx) {
         try {
           const tempPath = `${currentPath}.tmp.${Date.now()}`;
           try {
-            await writeFile17(tempPath, result.result, "utf-8");
+            await writeFile18(tempPath, result.result, "utf-8");
             await rename3(tempPath, currentPath);
           } catch (atomicError) {
             await unlink7(tempPath).catch(() => {});
@@ -40658,7 +40839,7 @@ async function createBackup(claudeDir, files, backupDir) {
       const sourcePath = await validateSyncPath(claudeDir, file.path);
       if (await import_fs_extra30.pathExists(sourcePath)) {
         const targetPath = await validateSyncPath(backupDir, file.path);
-        const targetDir = join64(targetPath, "..");
+        const targetDir = join65(targetPath, "..");
         await mkdir21(targetDir, { recursive: true });
         await copyFile6(sourcePath, targetPath);
       }
@@ -40672,7 +40853,7 @@ async function createBackup(claudeDir, files, backupDir) {
   }
 }
 // src/commands/init/phases/transform-handler.ts
-import { join as join68 } from "node:path";
+import { join as join69 } from "node:path";
 
 // src/services/transformers/folder-path-transformer.ts
 init_logger();
@@ -40683,38 +40864,38 @@ init_logger();
 init_types2();
 var import_fs_extra31 = __toESM(require_lib(), 1);
 import { rename as rename4, rm as rm6 } from "node:fs/promises";
-import { join as join65, relative as relative12 } from "node:path";
+import { join as join66, relative as relative12 } from "node:path";
 async function collectDirsToRename(extractDir, folders) {
   const dirsToRename = [];
   if (folders.docs !== DEFAULT_FOLDERS.docs) {
-    const docsPath = join65(extractDir, DEFAULT_FOLDERS.docs);
+    const docsPath = join66(extractDir, DEFAULT_FOLDERS.docs);
     if (await import_fs_extra31.pathExists(docsPath)) {
       dirsToRename.push({
         from: docsPath,
-        to: join65(extractDir, folders.docs)
+        to: join66(extractDir, folders.docs)
       });
     }
-    const claudeDocsPath = join65(extractDir, ".claude", DEFAULT_FOLDERS.docs);
+    const claudeDocsPath = join66(extractDir, ".claude", DEFAULT_FOLDERS.docs);
     if (await import_fs_extra31.pathExists(claudeDocsPath)) {
       dirsToRename.push({
         from: claudeDocsPath,
-        to: join65(extractDir, ".claude", folders.docs)
+        to: join66(extractDir, ".claude", folders.docs)
       });
     }
   }
   if (folders.plans !== DEFAULT_FOLDERS.plans) {
-    const plansPath = join65(extractDir, DEFAULT_FOLDERS.plans);
+    const plansPath = join66(extractDir, DEFAULT_FOLDERS.plans);
     if (await import_fs_extra31.pathExists(plansPath)) {
       dirsToRename.push({
         from: plansPath,
-        to: join65(extractDir, folders.plans)
+        to: join66(extractDir, folders.plans)
       });
     }
-    const claudePlansPath = join65(extractDir, ".claude", DEFAULT_FOLDERS.plans);
+    const claudePlansPath = join66(extractDir, ".claude", DEFAULT_FOLDERS.plans);
     if (await import_fs_extra31.pathExists(claudePlansPath)) {
       dirsToRename.push({
         from: claudePlansPath,
-        to: join65(extractDir, ".claude", folders.plans)
+        to: join66(extractDir, ".claude", folders.plans)
       });
     }
   }
@@ -40754,8 +40935,8 @@ async function renameFolders(dirsToRename, extractDir, options) {
 // src/services/transformers/folder-transform/path-replacer.ts
 init_logger();
 init_types2();
-import { readFile as readFile21, readdir as readdir20, writeFile as writeFile18 } from "node:fs/promises";
-import { join as join66, relative as relative13 } from "node:path";
+import { readFile as readFile22, readdir as readdir21, writeFile as writeFile19 } from "node:fs/promises";
+import { join as join67, relative as relative13 } from "node:path";
 var TRANSFORMABLE_FILE_PATTERNS = [
   ".md",
   ".txt",
@@ -40806,9 +40987,9 @@ function compileReplacements(replacements) {
 async function transformFileContents(dir, compiledReplacements, options) {
   let filesChanged = 0;
   let replacementsCount = 0;
-  const entries = await readdir20(dir, { withFileTypes: true });
+  const entries = await readdir21(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = join66(dir, entry.name);
+    const fullPath = join67(dir, entry.name);
     if (entry.isDirectory()) {
       if (entry.name === "node_modules" || entry.name === ".git") {
         continue;
@@ -40821,7 +41002,7 @@ async function transformFileContents(dir, compiledReplacements, options) {
       if (!shouldTransform)
         continue;
       try {
-        const content = await readFile21(fullPath, "utf-8");
+        const content = await readFile22(fullPath, "utf-8");
         let newContent = content;
         let changeCount = 0;
         for (const { regex: regex2, replacement } of compiledReplacements) {
@@ -40837,7 +41018,7 @@ async function transformFileContents(dir, compiledReplacements, options) {
           if (options.dryRun) {
             logger.debug(`[dry-run] Would update ${relative13(dir, fullPath)}: ${changeCount} replacement(s)`);
           } else {
-            await writeFile18(fullPath, newContent, "utf-8");
+            await writeFile19(fullPath, newContent, "utf-8");
             logger.debug(`Updated ${relative13(dir, fullPath)}: ${changeCount} replacement(s)`);
           }
           filesChanged++;
@@ -40943,15 +41124,15 @@ async function transformFolderPaths(extractDir, folders, options = {}) {
 
 // src/services/transformers/global-path-transformer.ts
 init_logger();
-import { readFile as readFile22, readdir as readdir21, writeFile as writeFile19 } from "node:fs/promises";
+import { readFile as readFile23, readdir as readdir22, writeFile as writeFile20 } from "node:fs/promises";
 import { platform as platform11 } from "node:os";
-import { extname as extname2, join as join67 } from "node:path";
+import { extname as extname2, join as join68 } from "node:path";
 var IS_WINDOWS3 = platform11() === "win32";
 var HOME_PREFIX = IS_WINDOWS3 ? "%USERPROFILE%" : "$HOME";
 function getHomeDirPrefix() {
   return HOME_PREFIX;
 }
-var TRANSFORMABLE_EXTENSIONS = new Set([
+var TRANSFORMABLE_EXTENSIONS2 = new Set([
   ".md",
   ".js",
   ".ts",
@@ -41042,10 +41223,10 @@ function transformContent(content) {
   });
   return { transformed, changes };
 }
-function shouldTransformFile(filename) {
+function shouldTransformFile2(filename) {
   const ext2 = extname2(filename).toLowerCase();
   const basename3 = filename.split("/").pop() || filename;
-  return TRANSFORMABLE_EXTENSIONS.has(ext2) || ALWAYS_TRANSFORM_FILES.has(basename3);
+  return TRANSFORMABLE_EXTENSIONS2.has(ext2) || ALWAYS_TRANSFORM_FILES.has(basename3);
 }
 async function transformPathsForGlobalInstall(directory, options = {}) {
   let filesTransformed = 0;
@@ -41053,20 +41234,20 @@ async function transformPathsForGlobalInstall(directory, options = {}) {
   let filesSkipped = 0;
   const skippedFiles = [];
   async function processDirectory2(dir) {
-    const entries = await readdir21(dir, { withFileTypes: true });
+    const entries = await readdir22(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join67(dir, entry.name);
+      const fullPath = join68(dir, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name.startsWith(".") && entry.name !== ".claude") {
           continue;
         }
         await processDirectory2(fullPath);
-      } else if (entry.isFile() && shouldTransformFile(entry.name)) {
+      } else if (entry.isFile() && shouldTransformFile2(entry.name)) {
         try {
-          const content = await readFile22(fullPath, "utf-8");
+          const content = await readFile23(fullPath, "utf-8");
           const { transformed, changes } = transformContent(content);
           if (changes > 0) {
-            await writeFile19(fullPath, transformed, "utf-8");
+            await writeFile20(fullPath, transformed, "utf-8");
             filesTransformed++;
             totalChanges += changes;
             if (options.verbose) {
@@ -41131,7 +41312,7 @@ async function handleTransforms(ctx) {
       logger.debug(ctx.options.global ? "Saved folder configuration to ~/.claude/.ck.json" : "Saved folder configuration to .claude/.ck.json");
     }
   }
-  const claudeDir = ctx.options.global ? ctx.resolvedDir : join68(ctx.resolvedDir, ".claude");
+  const claudeDir = ctx.options.global ? ctx.resolvedDir : join69(ctx.resolvedDir, ".claude");
   return {
     ...ctx,
     foldersConfig,
@@ -41452,7 +41633,7 @@ async function handleDirectorySetup(ctx) {
   };
 }
 // src/commands/new/phases/project-creation.ts
-import { join as join69 } from "node:path";
+import { join as join70 } from "node:path";
 init_logger();
 init_output_manager();
 init_types2();
@@ -41562,7 +41743,7 @@ async function projectCreation(kit, resolvedDir, validOptions, isNonInteractive2
   output.section("Installing");
   logger.verbose("Installation target", { directory: resolvedDir });
   const merger = new FileMerger;
-  const claudeDir = join69(resolvedDir, ".claude");
+  const claudeDir = join70(resolvedDir, ".claude");
   merger.setMultiKitContext(claudeDir, kit);
   if (validOptions.exclude && validOptions.exclude.length > 0) {
     merger.addIgnorePatterns(validOptions.exclude);
@@ -41723,13 +41904,13 @@ async function detectInstallations() {
 
 // src/commands/uninstall/removal-handler.ts
 import { readdirSync as readdirSync2, rmSync as rmSync2 } from "node:fs";
-import { join as join71 } from "node:path";
+import { join as join72 } from "node:path";
 init_logger();
 var import_fs_extra34 = __toESM(require_lib(), 1);
 
 // src/commands/uninstall/analysis-handler.ts
 import { readdirSync, rmSync } from "node:fs";
-import { dirname as dirname10, join as join70 } from "node:path";
+import { dirname as dirname10, join as join71 } from "node:path";
 init_logger();
 var import_picocolors21 = __toESM(require_picocolors(), 1);
 function classifyFileByOwnership(ownership, forceOverwrite, deleteReason) {
@@ -41776,7 +41957,7 @@ async function analyzeInstallation(installation, forceOverwrite, kit) {
   if (uninstallManifest.isMultiKit && kit && metadata?.kits?.[kit]) {
     const kitFiles = metadata.kits[kit].files || [];
     for (const trackedFile of kitFiles) {
-      const filePath = join70(installation.path, trackedFile.path);
+      const filePath = join71(installation.path, trackedFile.path);
       if (uninstallManifest.filesToPreserve.includes(trackedFile.path)) {
         result.toPreserve.push({ path: trackedFile.path, reason: "shared with other kit" });
         continue;
@@ -41806,7 +41987,7 @@ async function analyzeInstallation(installation, forceOverwrite, kit) {
     return result;
   }
   for (const trackedFile of allTrackedFiles) {
-    const filePath = join70(installation.path, trackedFile.path);
+    const filePath = join71(installation.path, trackedFile.path);
     const ownershipResult = await OwnershipChecker.checkOwnership(filePath, metadata, installation.path);
     if (!ownershipResult.exists)
       continue;
@@ -41866,7 +42047,7 @@ async function removeInstallations(installations, options) {
       let removedCount = 0;
       let cleanedDirs = 0;
       for (const item of analysis.toDelete) {
-        const filePath = join71(installation.path, item.path);
+        const filePath = join72(installation.path, item.path);
         if (await import_fs_extra34.pathExists(filePath)) {
           await import_fs_extra34.remove(filePath);
           removedCount++;
@@ -42198,14 +42379,14 @@ init_types2();
 // src/domains/versioning/version-cache.ts
 init_logger();
 import { existsSync as existsSync19 } from "node:fs";
-import { mkdir as mkdir22, readFile as readFile23, writeFile as writeFile20 } from "node:fs/promises";
-import { join as join72 } from "node:path";
+import { mkdir as mkdir22, readFile as readFile24, writeFile as writeFile21 } from "node:fs/promises";
+import { join as join73 } 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 join72(cacheDir, VersionCacheManager.CACHE_FILENAME);
+    return join73(cacheDir, VersionCacheManager.CACHE_FILENAME);
   }
   static async load() {
     const cacheFile = VersionCacheManager.getCacheFile();
@@ -42214,7 +42395,7 @@ class VersionCacheManager {
         logger.debug("Version check cache not found");
         return null;
       }
-      const content = await readFile23(cacheFile, "utf-8");
+      const content = await readFile24(cacheFile, "utf-8");
       const cache2 = JSON.parse(content);
       if (!cache2.lastCheck || !cache2.currentVersion || !cache2.latestVersion) {
         logger.debug("Invalid cache structure, ignoring");
@@ -42234,7 +42415,7 @@ class VersionCacheManager {
       if (!existsSync19(cacheDir)) {
         await mkdir22(cacheDir, { recursive: true, mode: 448 });
       }
-      await writeFile20(cacheFile, JSON.stringify(cache2, null, 2), "utf-8");
+      await writeFile21(cacheFile, JSON.stringify(cache2, null, 2), "utf-8");
       logger.debug(`Version check cache saved to ${cacheFile}`);
     } catch (error) {
       logger.debug(`Failed to save version check cache: ${error}`);
@@ -42447,7 +42628,7 @@ var import_picocolors24 = __toESM(require_picocolors(), 1);
 // package.json
 var package_default = {
   name: "claudekit-cli",
-  version: "3.22.1",
+  version: "3.23.0",
   description: "CLI tool for bootstrapping and updating ClaudeKit projects",
   type: "module",
   repository: {
@@ -42872,7 +43053,7 @@ function registerCommands(cli) {
 
 // src/cli/version-display.ts
 import { existsSync as existsSync20, readFileSync as readFileSync6 } from "node:fs";
-import { join as join73 } from "node:path";
+import { join as join74 } from "node:path";
 init_logger();
 init_types2();
 var packageVersion = package_default.version;
@@ -42906,9 +43087,9 @@ async function displayVersion() {
   let localKitVersion = null;
   let isGlobalOnlyKit = false;
   const globalKitDir = PathResolver.getGlobalKitDir();
-  const globalMetadataPath = join73(globalKitDir, "metadata.json");
+  const globalMetadataPath = join74(globalKitDir, "metadata.json");
   const prefix = PathResolver.getPathPrefix(false);
-  const localMetadataPath = prefix ? join73(process.cwd(), prefix, "metadata.json") : join73(process.cwd(), "metadata.json");
+  const localMetadataPath = prefix ? join74(process.cwd(), prefix, "metadata.json") : join74(process.cwd(), "metadata.json");
   const isLocalSameAsGlobal = localMetadataPath === globalMetadataPath;
   if (!isLocalSameAsGlobal && existsSync20(localMetadataPath)) {
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "claudekit-cli",
-	"version": "3.22.1",
+	"version": "3.23.0",
 	"description": "CLI tool for bootstrapping and updating ClaudeKit projects",
 	"type": "module",
 	"repository": {