claudekit-cli 3.22.1 → 3.24.0

package/dist/index.js

@@ -18468,6 +18468,25 @@ class PathResolver {
     }
     return join(homedir(), ".claude");
   }
+  static getOpenCodeDir(global2, baseDir) {
+    const testHome = PathResolver.getTestHomeDir();
+    if (testHome) {
+      return global2 ? join(testHome, ".config", "opencode") : join(baseDir || testHome, ".opencode");
+    }
+    if (!global2) {
+      return join(baseDir || process.cwd(), ".opencode");
+    }
+    const os = platform();
+    if (os === "win32") {
+      const appData = process.env.APPDATA || join(homedir(), "AppData", "Roaming");
+      return join(appData, "opencode");
+    }
+    const xdgConfigHome = process.env.XDG_CONFIG_HOME;
+    if (xdgConfigHome) {
+      return join(xdgConfigHome, "opencode");
+    }
+    return join(homedir(), ".config", "opencode");
+  }
   static getPathPrefix(global2) {
     return global2 ? "" : ".claude";
   }
@@ -34271,7 +34290,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 +36227,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 +36425,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 +36556,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 +36587,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 +37800,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 +37951,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 +37976,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 +38003,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 +38040,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 +38162,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 +38191,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 +38249,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 +38313,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 +38342,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 +38354,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 +38379,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 +38401,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 +38423,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 +38435,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 +38462,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 +38470,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 +38593,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 +38607,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 +38769,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 +38937,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 +38955,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 +38976,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 +39044,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 +39071,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 +39121,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 +39148,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 +39165,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 +39201,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 +39240,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 +39333,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 +39350,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 +39371,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 +39381,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 +39485,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 +39545,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;
@@ -39367,13 +39567,156 @@ async function handleMigration(ctx) {
   }
   return ctx;
 }
+// src/commands/init/phases/opencode-handler.ts
+import { cp, readdir as readdir22, rm as rm5 } from "node:fs/promises";
+import { join as join60 } from "node:path";
+
+// src/services/transformers/opencode-path-transformer.ts
+init_logger();
+import { readFile as readFile20, readdir as readdir21, writeFile as writeFile16 } from "node:fs/promises";
+import { platform as platform10 } from "node:os";
+import { extname as extname2, join as join59 } from "node:path";
+var IS_WINDOWS3 = platform10() === "win32";
+function getOpenCodeGlobalPath() {
+  return IS_WINDOWS3 ? "%APPDATA%/opencode/" : "$HOME/.config/opencode/";
+}
+var TRANSFORMABLE_EXTENSIONS2 = new Set([
+  ".md",
+  ".js",
+  ".ts",
+  ".json",
+  ".sh",
+  ".ps1",
+  ".yaml",
+  ".yml",
+  ".toml"
+]);
+function transformOpenCodeContent(content) {
+  let changes = 0;
+  let transformed = content;
+  const globalPath = getOpenCodeGlobalPath();
+  transformed = transformed.replace(/\.\/\.opencode\//g, () => {
+    changes++;
+    return globalPath;
+  });
+  transformed = transformed.replace(/(["'`])\.opencode\//g, (_match, quote) => {
+    changes++;
+    return `${quote}${globalPath}`;
+  });
+  transformed = transformed.replace(/\(\.opencode\//g, () => {
+    changes++;
+    return `(${globalPath}`;
+  });
+  transformed = transformed.replace(/ \.opencode\//g, () => {
+    changes++;
+    return ` ${globalPath}`;
+  });
+  transformed = transformed.replace(/^\.opencode\//gm, () => {
+    changes++;
+    return globalPath;
+  });
+  transformed = transformed.replace(/: \.opencode\//g, () => {
+    changes++;
+    return `: ${globalPath}`;
+  });
+  transformed = transformed.replace(/:\.opencode\//g, () => {
+    changes++;
+    return `:${globalPath}`;
+  });
+  return { transformed, changes };
+}
+function shouldTransformFile2(filename) {
+  const ext2 = extname2(filename).toLowerCase();
+  return TRANSFORMABLE_EXTENSIONS2.has(ext2);
+}
+async function transformPathsForGlobalOpenCode(directory, options = {}) {
+  let filesTransformed = 0;
+  let totalChanges = 0;
+  let filesSkipped = 0;
+  async function processDirectory2(dir) {
+    const entries = await readdir21(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join59(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (entry.name === "node_modules" || entry.name.startsWith(".")) {
+          continue;
+        }
+        await processDirectory2(fullPath);
+      } else if (entry.isFile() && shouldTransformFile2(entry.name)) {
+        try {
+          const content = await readFile20(fullPath, "utf-8");
+          const { transformed, changes } = transformOpenCodeContent(content);
+          if (changes > 0) {
+            await writeFile16(fullPath, transformed, "utf-8");
+            filesTransformed++;
+            totalChanges += changes;
+            if (options.verbose) {
+              logger.verbose(`Transformed ${changes} OpenCode path(s) in ${fullPath}`);
+            }
+          }
+        } catch (error) {
+          filesSkipped++;
+          if (options.verbose) {
+            logger.verbose(`Skipping ${fullPath}: ${error instanceof Error ? error.message : "unknown error"}`);
+          }
+        }
+      }
+    }
+  }
+  await processDirectory2(directory);
+  return { filesTransformed, totalChanges, filesSkipped };
+}
+
+// src/commands/init/phases/opencode-handler.ts
+init_logger();
+var import_fs_extra25 = __toESM(require_lib(), 1);
+async function handleOpenCode(ctx) {
+  if (ctx.cancelled || !ctx.extractDir || !ctx.resolvedDir) {
+    return ctx;
+  }
+  const openCodeSource = join60(ctx.extractDir, ".opencode");
+  if (!await import_fs_extra25.pathExists(openCodeSource)) {
+    logger.debug("No .opencode directory in archive, skipping");
+    return ctx;
+  }
+  logger.info("Processing .opencode configuration...");
+  if (ctx.options.global) {
+    const targetDir = PathResolver.getOpenCodeDir(true);
+    logger.verbose(`Relocating .opencode to ${targetDir}`);
+    const transformResult = await transformPathsForGlobalOpenCode(openCodeSource, {
+      verbose: logger.isVerbose()
+    });
+    if (transformResult.totalChanges > 0) {
+      logger.success(`Transformed ${transformResult.totalChanges} OpenCode path(s) in ${transformResult.filesTransformed} file(s)`);
+    }
+    await import_fs_extra25.ensureDir(targetDir);
+    const entries = await readdir22(openCodeSource, { withFileTypes: true });
+    for (const entry of entries) {
+      const sourcePath = join60(openCodeSource, entry.name);
+      const targetPath = join60(targetDir, entry.name);
+      if (await import_fs_extra25.pathExists(targetPath)) {
+        if (!ctx.options.forceOverwrite) {
+          logger.verbose(`Skipping existing: ${entry.name}`);
+          continue;
+        }
+      }
+      await cp(sourcePath, targetPath, { recursive: true });
+      logger.verbose(`Copied: ${entry.name}`);
+    }
+    await rm5(openCodeSource, { recursive: true, force: true });
+    logger.success(`OpenCode config installed to ${targetDir}`);
+  } else {
+    logger.debug("Local mode: .opencode will be placed at project root");
+  }
+  return 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 readFile21, rename as rename2, rm as rm6, writeFile as writeFile17 } 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 { platform as platform11 } from "node:os";
+import { join as join61 } from "node:path";
 init_types2();
 var PROJECT_CONFIG_FILE = ".ck.json";
 
@@ -39381,7 +39724,7 @@ class ConfigManager {
   static config = null;
   static globalFlag = false;
   static getProjectConfigDir(projectDir, global3) {
-    return global3 ? projectDir : join58(projectDir, ".claude");
+    return global3 ? projectDir : join61(projectDir, ".claude");
   }
   static setGlobalFlag(global3) {
     ConfigManager.globalFlag = global3;
@@ -39397,7 +39740,7 @@ class ConfigManager {
     const configFile = PathResolver.getConfigFile(ConfigManager.globalFlag);
     try {
       if (existsSync18(configFile)) {
-        const content = await readFile19(configFile, "utf-8");
+        const content = await readFile21(configFile, "utf-8");
         const data = JSON.parse(content);
         ConfigManager.config = ConfigSchema.parse(data);
         logger.debug(`Config loaded from ${configFile}`);
@@ -39416,12 +39759,12 @@ class ConfigManager {
       const configFile = PathResolver.getConfigFile(ConfigManager.globalFlag);
       if (!existsSync18(configDir)) {
         await mkdir19(configDir, { recursive: true });
-        if (platform10() !== "win32") {
+        if (platform11() !== "win32") {
           await chmod2(configDir, 448);
         }
       }
-      await writeFile15(configFile, JSON.stringify(validConfig, null, 2), "utf-8");
-      if (platform10() !== "win32") {
+      await writeFile17(configFile, JSON.stringify(validConfig, null, 2), "utf-8");
+      if (platform11() !== "win32") {
         await chmod2(configFile, 384);
       }
       ConfigManager.config = validConfig;
@@ -39448,10 +39791,10 @@ class ConfigManager {
   }
   static async loadProjectConfig(projectDir, global3 = false) {
     const configDir = ConfigManager.getProjectConfigDir(projectDir, global3);
-    const configPath = join58(configDir, PROJECT_CONFIG_FILE);
+    const configPath = join61(configDir, PROJECT_CONFIG_FILE);
     try {
       if (existsSync18(configPath)) {
-        const content = await readFile19(configPath, "utf-8");
+        const content = await readFile21(configPath, "utf-8");
         const data = JSON.parse(content);
         const folders = FoldersConfigSchema.parse(data.paths || data);
         logger.debug(`Project config loaded from ${configPath}`);
@@ -39464,7 +39807,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 = join61(configDir, PROJECT_CONFIG_FILE);
     try {
       if (!existsSync18(configDir)) {
         await mkdir19(configDir, { recursive: true });
@@ -39472,7 +39815,7 @@ class ConfigManager {
       let existingConfig = {};
       if (existsSync18(configPath)) {
         try {
-          const content = await readFile19(configPath, "utf-8");
+          const content = await readFile21(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 +39830,7 @@ class ConfigManager {
           ...validFolders
         }
       };
-      await writeFile15(configPath, JSON.stringify(mergedConfig, null, 2), "utf-8");
+      await writeFile17(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 +39856,11 @@ class ConfigManager {
   }
   static projectConfigExists(projectDir, global3 = false) {
     const configDir = ConfigManager.getProjectConfigDir(projectDir, global3);
-    return existsSync18(join58(configDir, PROJECT_CONFIG_FILE));
+    return existsSync18(join61(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 = join61(globalDir, PROJECT_CONFIG_FILE);
+    const incorrectPath = join61(globalDir, ".claude", PROJECT_CONFIG_FILE);
     if (existsSync18(correctPath)) {
       logger.debug("Config already exists at correct location, skipping migration");
       return false;
@@ -39527,9 +39870,9 @@ 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 = join61(globalDir, ".claude");
         try {
-          await rm5(nestedClaudeDir, { recursive: false });
+          await rm6(nestedClaudeDir, { recursive: false });
           logger.debug("Removed empty nested .claude directory");
         } catch (rmError) {
           logger.debug(`Could not remove nested .claude dir (may contain other files): ${rmError instanceof Error ? rmError.message : "Unknown"}`);
@@ -39618,14 +39961,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 join64 } from "node:path";
 
 // src/domains/installation/setup-wizard.ts
-import { join as join60 } from "node:path";
+import { join as join63 } from "node:path";
 
 // src/domains/config/config-generator.ts
-var import_fs_extra25 = __toESM(require_lib(), 1);
-import { join as join59 } from "node:path";
+var import_fs_extra26 = __toESM(require_lib(), 1);
+import { join as join62 } from "node:path";
 async function generateEnvFile(targetDir, values) {
   const lines = [
     "# Generated by ClaudeKit CLI setup wizard",
@@ -39667,8 +40010,8 @@ async function generateEnvFile(targetDir, values) {
   for (const [key, value] of otherValues) {
     lines.push(`${key}=${value}`);
   }
-  const envPath = join59(targetDir, ".env");
-  await import_fs_extra25.writeFile(envPath, `${lines.join(`
+  const envPath = join62(targetDir, ".env");
+  await import_fs_extra26.writeFile(envPath, `${lines.join(`
 `)}
 `, { mode: 384 });
 }
@@ -39686,7 +40029,7 @@ function validateApiKey(value, pattern) {
 // src/domains/installation/setup-wizard.ts
 init_logger();
 init_dist2();
-var import_fs_extra26 = __toESM(require_lib(), 1);
+var import_fs_extra27 = __toESM(require_lib(), 1);
 var ESSENTIAL_CONFIGS = [
   {
     key: "GEMINI_API_KEY",
@@ -39715,7 +40058,7 @@ var ESSENTIAL_CONFIGS = [
 ];
 async function parseEnvFile(path11) {
   try {
-    const content = await import_fs_extra26.readFile(path11, "utf-8");
+    const content = await import_fs_extra27.readFile(path11, "utf-8");
     const env2 = {};
     for (const line of content.split(`
 `)) {
@@ -39741,8 +40084,8 @@ async function parseEnvFile(path11) {
   }
 }
 async function checkGlobalConfig() {
-  const globalEnvPath = join60(PathResolver.getGlobalKitDir(), ".env");
-  if (!await import_fs_extra26.pathExists(globalEnvPath))
+  const globalEnvPath = join63(PathResolver.getGlobalKitDir(), ".env");
+  if (!await import_fs_extra27.pathExists(globalEnvPath))
     return false;
   const env2 = await parseEnvFile(globalEnvPath);
   return Object.keys(env2).length > 0;
@@ -39757,8 +40100,8 @@ async function runSetupWizard(options) {
   let globalEnv = {};
   const hasGlobalConfig = !isGlobal && await checkGlobalConfig();
   if (!isGlobal) {
-    const globalEnvPath = join60(PathResolver.getGlobalKitDir(), ".env");
-    if (await import_fs_extra26.pathExists(globalEnvPath)) {
+    const globalEnvPath = join63(PathResolver.getGlobalKitDir(), ".env");
+    if (await import_fs_extra27.pathExists(globalEnvPath)) {
       globalEnv = await parseEnvFile(globalEnvPath);
     }
   }
@@ -39820,7 +40163,7 @@ async function runSetupWizard(options) {
     }
   }
   await generateEnvFile(targetDir, values);
-  f2.success(`Configuration saved to ${join60(targetDir, ".env")}`);
+  f2.success(`Configuration saved to ${join63(targetDir, ".env")}`);
   return true;
 }
 async function promptForAdditionalGeminiKeys(primaryKey) {
@@ -39870,17 +40213,17 @@ async function promptForAdditionalGeminiKeys(primaryKey) {
 
 // src/commands/init/phases/post-install-handler.ts
 init_logger();
-var import_fs_extra27 = __toESM(require_lib(), 1);
+var import_fs_extra28 = __toESM(require_lib(), 1);
 async function handlePostInstall(ctx) {
   if (ctx.cancelled || !ctx.extractDir || !ctx.resolvedDir || !ctx.claudeDir) {
     return ctx;
   }
   if (ctx.options.global) {
-    const claudeMdSource = join61(ctx.extractDir, "CLAUDE.md");
-    const claudeMdDest = join61(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);
+    const claudeMdSource = join64(ctx.extractDir, "CLAUDE.md");
+    const claudeMdDest = join64(ctx.resolvedDir, "CLAUDE.md");
+    if (await import_fs_extra28.pathExists(claudeMdSource)) {
+      if (!await import_fs_extra28.pathExists(claudeMdDest)) {
+        await import_fs_extra28.copy(claudeMdSource, claudeMdDest);
         logger.success("Copied CLAUDE.md to global directory");
       } else {
         logger.debug("CLAUDE.md already exists in global directory (preserved)");
@@ -39924,8 +40267,8 @@ async function handlePostInstall(ctx) {
     }
   }
   if (!ctx.options.skipSetup && !ctx.isNonInteractive) {
-    const envPath = join61(ctx.claudeDir, ".env");
-    if (!await import_fs_extra27.pathExists(envPath)) {
+    const envPath = join64(ctx.claudeDir, ".env");
+    if (!await import_fs_extra28.pathExists(envPath)) {
       const shouldSetup = await ctx.prompts.confirm("Set up API keys now? (Gemini API key for ai-multimodal skill, optional webhooks)");
       if (shouldSetup) {
         await runSetupWizard({
@@ -39946,7 +40289,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 join66, resolve as resolve7 } from "node:path";
 
 // src/domains/github/kit-access-checker.ts
 init_logger();
@@ -39975,11 +40318,11 @@ async function detectAccessibleKits() {
 
 // src/domains/installation/fresh-installer.ts
 init_logger();
-import { join as join62 } from "node:path";
-var import_fs_extra28 = __toESM(require_lib(), 1);
+import { join as join65 } from "node:path";
+var import_fs_extra29 = __toESM(require_lib(), 1);
 var CLAUDEKIT_SUBDIRECTORIES = ["commands", "agents", "skills", "workflows", "hooks"];
 async function handleFreshInstallation(claudeDir, prompts) {
-  if (!await import_fs_extra28.pathExists(claudeDir)) {
+  if (!await import_fs_extra29.pathExists(claudeDir)) {
     logger.info(".claude directory does not exist, proceeding with fresh installation");
     return true;
   }
@@ -39994,8 +40337,8 @@ 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);
-      if (await import_fs_extra28.pathExists(subdirPath)) {
+      const subdirPath = join65(claudeDir, subdir);
+      if (await import_fs_extra29.pathExists(subdirPath)) {
         rmSync(subdirPath, { recursive: true, force: true });
         removedCount++;
         logger.debug(`Removed subdirectory: ${subdir}/`);
@@ -40012,7 +40355,7 @@ async function handleFreshInstallation(claudeDir, prompts) {
 // src/commands/init/phases/selection-handler.ts
 init_logger();
 init_types2();
-var import_fs_extra29 = __toESM(require_lib(), 1);
+var import_fs_extra30 = __toESM(require_lib(), 1);
 
 // src/commands/init/types.ts
 function isSyncContext(ctx) {
@@ -40176,7 +40519,7 @@ async function handleSelection(ctx) {
       return { ...ctx, cancelled: true };
     }
   }
-  if (!await import_fs_extra29.pathExists(resolvedDir)) {
+  if (!await import_fs_extra30.pathExists(resolvedDir)) {
     if (ctx.options.global) {
       await mkdir20(resolvedDir, { recursive: true });
       logger.info(`Created global directory: ${resolvedDir}`);
@@ -40188,7 +40531,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 ? join66(resolvedDir, prefix) : resolvedDir;
     try {
       const existingMetadata = await readManifest(claudeDir);
       if (existingMetadata?.kits) {
@@ -40220,7 +40563,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 ? join66(resolvedDir, prefix) : resolvedDir;
     const canProceed = await handleFreshInstallation(claudeDir, ctx.prompts);
     if (!canProceed) {
       return { ...ctx, cancelled: true };
@@ -40238,7 +40581,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 ? join66(PathResolver.getGlobalKitDir(), "metadata.json") : join66(resolvedDir, ".claude", "metadata.json");
       const metadata = await readClaudeKitMetadata(metadataPath);
       currentVersion = metadata?.version || null;
       if (currentVersion) {
@@ -40306,24 +40649,24 @@ 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 writeFile19 } from "node:fs/promises";
+import { dirname as dirname9, join as join67, resolve as resolve8 } from "node:path";
 init_logger();
-var import_fs_extra30 = __toESM(require_lib(), 1);
+var import_fs_extra31 = __toESM(require_lib(), 1);
 var import_picocolors19 = __toESM(require_picocolors(), 1);
 async function handleSync(ctx) {
   if (!ctx.options.sync) {
     return ctx;
   }
   const resolvedDir = ctx.options.global ? PathResolver.getGlobalKitDir() : resolve8(ctx.options.dir || ".");
-  const claudeDir = ctx.options.global ? resolvedDir : join64(resolvedDir, ".claude");
-  if (!await import_fs_extra30.pathExists(claudeDir)) {
+  const claudeDir = ctx.options.global ? resolvedDir : join67(resolvedDir, ".claude");
+  if (!await import_fs_extra31.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");
-  if (!await import_fs_extra30.pathExists(metadataPath)) {
+  const metadataPath = join67(claudeDir, "metadata.json");
+  if (!await import_fs_extra31.pathExists(metadataPath)) {
     logger.error("Cannot sync: no metadata.json found");
     ctx.prompts.note(`Your installation may be from an older version.
 Run 'ck init' to update.`, "Legacy Installation");
@@ -40422,7 +40765,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 = join67(cacheDir, ".sync-lock");
   const startTime = Date.now();
   const lockTimeout = getLockTimeout();
   await mkdir21(dirname9(lockPath), { recursive: true });
@@ -40468,7 +40811,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 ? join67(ctx.extractDir, ".claude") : ctx.extractDir;
     logger.info("Analyzing file changes...");
     const plan = await SyncEngine.createSyncPlan(trackedFiles, ctx.claudeDir, upstreamDir);
     displaySyncPlan(plan);
@@ -40487,7 +40830,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 = join67(targetPath, "..");
           try {
             await mkdir21(targetDir, { recursive: true });
           } catch (mkdirError) {
@@ -40568,7 +40911,7 @@ async function executeSyncMerge(ctx) {
         try {
           const tempPath = `${currentPath}.tmp.${Date.now()}`;
           try {
-            await writeFile17(tempPath, result.result, "utf-8");
+            await writeFile19(tempPath, result.result, "utf-8");
             await rename3(tempPath, currentPath);
           } catch (atomicError) {
             await unlink7(tempPath).catch(() => {});
@@ -40656,9 +40999,9 @@ async function createBackup(claudeDir, files, backupDir) {
   for (const file of files) {
     try {
       const sourcePath = await validateSyncPath(claudeDir, file.path);
-      if (await import_fs_extra30.pathExists(sourcePath)) {
+      if (await import_fs_extra31.pathExists(sourcePath)) {
         const targetPath = await validateSyncPath(backupDir, file.path);
-        const targetDir = join64(targetPath, "..");
+        const targetDir = join67(targetPath, "..");
         await mkdir21(targetDir, { recursive: true });
         await copyFile6(sourcePath, targetPath);
       }
@@ -40672,7 +41015,7 @@ async function createBackup(claudeDir, files, backupDir) {
   }
 }
 // src/commands/init/phases/transform-handler.ts
-import { join as join68 } from "node:path";
+import { join as join71 } from "node:path";
 
 // src/services/transformers/folder-path-transformer.ts
 init_logger();
@@ -40681,40 +41024,40 @@ init_types2();
 // src/services/transformers/folder-transform/folder-renamer.ts
 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";
+var import_fs_extra32 = __toESM(require_lib(), 1);
+import { rename as rename4, rm as rm7 } from "node:fs/promises";
+import { join as join68, 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);
-    if (await import_fs_extra31.pathExists(docsPath)) {
+    const docsPath = join68(extractDir, DEFAULT_FOLDERS.docs);
+    if (await import_fs_extra32.pathExists(docsPath)) {
       dirsToRename.push({
         from: docsPath,
-        to: join65(extractDir, folders.docs)
+        to: join68(extractDir, folders.docs)
       });
     }
-    const claudeDocsPath = join65(extractDir, ".claude", DEFAULT_FOLDERS.docs);
-    if (await import_fs_extra31.pathExists(claudeDocsPath)) {
+    const claudeDocsPath = join68(extractDir, ".claude", DEFAULT_FOLDERS.docs);
+    if (await import_fs_extra32.pathExists(claudeDocsPath)) {
       dirsToRename.push({
         from: claudeDocsPath,
-        to: join65(extractDir, ".claude", folders.docs)
+        to: join68(extractDir, ".claude", folders.docs)
       });
     }
   }
   if (folders.plans !== DEFAULT_FOLDERS.plans) {
-    const plansPath = join65(extractDir, DEFAULT_FOLDERS.plans);
-    if (await import_fs_extra31.pathExists(plansPath)) {
+    const plansPath = join68(extractDir, DEFAULT_FOLDERS.plans);
+    if (await import_fs_extra32.pathExists(plansPath)) {
       dirsToRename.push({
         from: plansPath,
-        to: join65(extractDir, folders.plans)
+        to: join68(extractDir, folders.plans)
       });
     }
-    const claudePlansPath = join65(extractDir, ".claude", DEFAULT_FOLDERS.plans);
-    if (await import_fs_extra31.pathExists(claudePlansPath)) {
+    const claudePlansPath = join68(extractDir, ".claude", DEFAULT_FOLDERS.plans);
+    if (await import_fs_extra32.pathExists(claudePlansPath)) {
       dirsToRename.push({
         from: claudePlansPath,
-        to: join65(extractDir, ".claude", folders.plans)
+        to: join68(extractDir, ".claude", folders.plans)
       });
     }
   }
@@ -40726,8 +41069,8 @@ async function moveAcrossDevices(src, dest) {
   } catch (e2) {
     if (e2.code === "EXDEV") {
       logger.debug(`Cross-device move detected, using copy+delete: ${src} -> ${dest}`);
-      await import_fs_extra31.copy(src, dest, { overwrite: true });
-      await rm6(src, { recursive: true, force: true });
+      await import_fs_extra32.copy(src, dest, { overwrite: true });
+      await rm7(src, { recursive: true, force: true });
     } else {
       throw e2;
     }
@@ -40754,8 +41097,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 readFile23, readdir as readdir23, writeFile as writeFile20 } from "node:fs/promises";
+import { join as join69, relative as relative13 } from "node:path";
 var TRANSFORMABLE_FILE_PATTERNS = [
   ".md",
   ".txt",
@@ -40806,9 +41149,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 readdir23(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = join66(dir, entry.name);
+    const fullPath = join69(dir, entry.name);
     if (entry.isDirectory()) {
       if (entry.name === "node_modules" || entry.name === ".git") {
         continue;
@@ -40821,7 +41164,7 @@ async function transformFileContents(dir, compiledReplacements, options) {
       if (!shouldTransform)
         continue;
       try {
-        const content = await readFile21(fullPath, "utf-8");
+        const content = await readFile23(fullPath, "utf-8");
         let newContent = content;
         let changeCount = 0;
         for (const { regex: regex2, replacement } of compiledReplacements) {
@@ -40837,7 +41180,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 writeFile20(fullPath, newContent, "utf-8");
             logger.debug(`Updated ${relative13(dir, fullPath)}: ${changeCount} replacement(s)`);
           }
           filesChanged++;
@@ -40943,15 +41286,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 { platform as platform11 } from "node:os";
-import { extname as extname2, join as join67 } from "node:path";
-var IS_WINDOWS3 = platform11() === "win32";
-var HOME_PREFIX = IS_WINDOWS3 ? "%USERPROFILE%" : "$HOME";
+import { readFile as readFile24, readdir as readdir24, writeFile as writeFile21 } from "node:fs/promises";
+import { platform as platform12 } from "node:os";
+import { extname as extname3, join as join70 } from "node:path";
+var IS_WINDOWS4 = platform12() === "win32";
+var HOME_PREFIX = IS_WINDOWS4 ? "%USERPROFILE%" : "$HOME";
 function getHomeDirPrefix() {
   return HOME_PREFIX;
 }
-var TRANSFORMABLE_EXTENSIONS = new Set([
+var TRANSFORMABLE_EXTENSIONS3 = new Set([
   ".md",
   ".js",
   ".ts",
@@ -40968,7 +41311,7 @@ function transformContent(content) {
   let transformed = content;
   const homePrefix = getHomeDirPrefix();
   const claudePath = `${homePrefix}/.claude/`;
-  if (IS_WINDOWS3) {
+  if (IS_WINDOWS4) {
     transformed = transformed.replace(/\$HOME\/\.claude\//g, () => {
       changes++;
       return claudePath;
@@ -40998,7 +41341,7 @@ function transformContent(content) {
     changes++;
     return claudePath;
   });
-  if (IS_WINDOWS3) {
+  if (IS_WINDOWS4) {
     transformed = transformed.replace(/%CLAUDE_PROJECT_DIR%\/\.claude\//g, () => {
       changes++;
       return claudePath;
@@ -41042,10 +41385,10 @@ function transformContent(content) {
   });
   return { transformed, changes };
 }
-function shouldTransformFile(filename) {
-  const ext2 = extname2(filename).toLowerCase();
+function shouldTransformFile3(filename) {
+  const ext2 = extname3(filename).toLowerCase();
   const basename3 = filename.split("/").pop() || filename;
-  return TRANSFORMABLE_EXTENSIONS.has(ext2) || ALWAYS_TRANSFORM_FILES.has(basename3);
+  return TRANSFORMABLE_EXTENSIONS3.has(ext2) || ALWAYS_TRANSFORM_FILES.has(basename3);
 }
 async function transformPathsForGlobalInstall(directory, options = {}) {
   let filesTransformed = 0;
@@ -41053,20 +41396,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 readdir24(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join67(dir, entry.name);
+      const fullPath = join70(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() && shouldTransformFile3(entry.name)) {
         try {
-          const content = await readFile22(fullPath, "utf-8");
+          const content = await readFile24(fullPath, "utf-8");
           const { transformed, changes } = transformContent(content);
           if (changes > 0) {
-            await writeFile19(fullPath, transformed, "utf-8");
+            await writeFile21(fullPath, transformed, "utf-8");
             filesTransformed++;
             totalChanges += changes;
             if (options.verbose) {
@@ -41131,7 +41474,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 : join71(ctx.resolvedDir, ".claude");
   return {
     ...ctx,
     foldersConfig,
@@ -41169,6 +41512,9 @@ Installing additional kit: ${kit.name}`);
     extractDir: undefined
   };
   ctx = await handleDownload(ctx);
+  if (ctx.cancelled)
+    return ctx;
+  ctx = await handleOpenCode(ctx);
   if (ctx.cancelled)
     return ctx;
   ctx = await handleTransforms(ctx);
@@ -41235,6 +41581,11 @@ async function executeInit(options, prompts) {
   ctx = await handleDownload(ctx);
   if (ctx.cancelled)
     return;
+  if (!isSyncMode) {
+    ctx = await handleOpenCode(ctx);
+    if (ctx.cancelled)
+      return;
+  }
   if (!isSyncMode) {
     ctx = await handleTransforms(ctx);
     if (ctx.cancelled)
@@ -41316,7 +41667,7 @@ var import_picocolors20 = __toESM(require_picocolors(), 1);
 import { resolve as resolve9 } from "node:path";
 init_logger();
 init_types2();
-var import_fs_extra32 = __toESM(require_lib(), 1);
+var import_fs_extra33 = __toESM(require_lib(), 1);
 async function directorySetup(validOptions, prompts) {
   const isNonInteractive2 = !process.stdin.isTTY || process.env.CI === "true" || process.env.NON_INTERACTIVE === "true";
   const config = await ConfigManager.get();
@@ -41415,8 +41766,8 @@ async function directorySetup(validOptions, prompts) {
       return null;
     }
   }
-  if (await import_fs_extra32.pathExists(resolvedDir)) {
-    const files = await import_fs_extra32.readdir(resolvedDir);
+  if (await import_fs_extra33.pathExists(resolvedDir)) {
+    const files = await import_fs_extra33.readdir(resolvedDir);
     const isEmpty = files.length === 0;
     if (!isEmpty) {
       if (isNonInteractive2) {
@@ -41452,7 +41803,7 @@ async function handleDirectorySetup(ctx) {
   };
 }
 // src/commands/new/phases/project-creation.ts
-import { join as join69 } from "node:path";
+import { join as join72 } from "node:path";
 init_logger();
 init_output_manager();
 init_types2();
@@ -41562,7 +41913,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 = join72(resolvedDir, ".claude");
   merger.setMultiKitContext(claudeDir, kit);
   if (validOptions.exclude && validOptions.exclude.length > 0) {
     merger.addIgnorePatterns(validOptions.exclude);
@@ -41699,7 +42050,7 @@ init_types2();
 var import_picocolors22 = __toESM(require_picocolors(), 1);
 
 // src/commands/uninstall/installation-detector.ts
-var import_fs_extra33 = __toESM(require_lib(), 1);
+var import_fs_extra34 = __toESM(require_lib(), 1);
 async function detectInstallations() {
   const installations = [];
   const setup = await getClaudeKitSetup(process.cwd());
@@ -41708,14 +42059,14 @@ async function detectInstallations() {
     installations.push({
       type: "local",
       path: setup.project.path,
-      exists: await import_fs_extra33.pathExists(setup.project.path)
+      exists: await import_fs_extra34.pathExists(setup.project.path)
     });
   }
   if (setup.global.path && setup.global.metadata) {
     installations.push({
       type: "global",
       path: setup.global.path,
-      exists: await import_fs_extra33.pathExists(setup.global.path)
+      exists: await import_fs_extra34.pathExists(setup.global.path)
     });
   }
   return installations.filter((i) => i.exists);
@@ -41723,13 +42074,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 join74 } from "node:path";
 init_logger();
-var import_fs_extra34 = __toESM(require_lib(), 1);
+var import_fs_extra35 = __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 join73 } from "node:path";
 init_logger();
 var import_picocolors21 = __toESM(require_picocolors(), 1);
 function classifyFileByOwnership(ownership, forceOverwrite, deleteReason) {
@@ -41776,7 +42127,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 = join73(installation.path, trackedFile.path);
       if (uninstallManifest.filesToPreserve.includes(trackedFile.path)) {
         result.toPreserve.push({ path: trackedFile.path, reason: "shared with other kit" });
         continue;
@@ -41806,7 +42157,7 @@ async function analyzeInstallation(installation, forceOverwrite, kit) {
     return result;
   }
   for (const trackedFile of allTrackedFiles) {
-    const filePath = join70(installation.path, trackedFile.path);
+    const filePath = join73(installation.path, trackedFile.path);
     const ownershipResult = await OwnershipChecker.checkOwnership(filePath, metadata, installation.path);
     if (!ownershipResult.exists)
       continue;
@@ -41866,9 +42217,9 @@ async function removeInstallations(installations, options) {
       let removedCount = 0;
       let cleanedDirs = 0;
       for (const item of analysis.toDelete) {
-        const filePath = join71(installation.path, item.path);
-        if (await import_fs_extra34.pathExists(filePath)) {
-          await import_fs_extra34.remove(filePath);
+        const filePath = join74(installation.path, item.path);
+        if (await import_fs_extra35.pathExists(filePath)) {
+          await import_fs_extra35.remove(filePath);
           removedCount++;
           logger.debug(`Removed: ${item.path}`);
           cleanedDirs += await cleanupEmptyDirectories(filePath, installation.path);
@@ -42037,6 +42388,7 @@ ${import_picocolors22.default.yellow("User modifications will be permanently del
 }
 // src/commands/update-cli.ts
 import { exec as exec7 } from "node:child_process";
+import { join as join76 } from "node:path";
 import { promisify as promisify7 } from "node:util";
 
 // src/domains/github/npm-registry.ts
@@ -42198,14 +42550,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 readFile25, writeFile as writeFile22 } from "node:fs/promises";
+import { join as join75 } 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 join75(cacheDir, VersionCacheManager.CACHE_FILENAME);
   }
   static async load() {
     const cacheFile = VersionCacheManager.getCacheFile();
@@ -42214,7 +42566,7 @@ class VersionCacheManager {
         logger.debug("Version check cache not found");
         return null;
       }
-      const content = await readFile23(cacheFile, "utf-8");
+      const content = await readFile25(cacheFile, "utf-8");
       const cache2 = JSON.parse(content);
       if (!cache2.lastCheck || !cache2.currentVersion || !cache2.latestVersion) {
         logger.debug("Invalid cache structure, ignoring");
@@ -42234,7 +42586,7 @@ class VersionCacheManager {
       if (!existsSync19(cacheDir)) {
         await mkdir22(cacheDir, { recursive: true, mode: 448 });
       }
-      await writeFile20(cacheFile, JSON.stringify(cache2, null, 2), "utf-8");
+      await writeFile22(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}`);
@@ -42443,11 +42795,12 @@ init_logger();
 init_types2();
 init_types2();
 var import_compare_versions5 = __toESM(require_umd(), 1);
+var import_fs_extra36 = __toESM(require_lib(), 1);
 var import_picocolors24 = __toESM(require_picocolors(), 1);
 // package.json
 var package_default = {
   name: "claudekit-cli",
-  version: "3.22.1",
+  version: "3.24.0",
   description: "CLI tool for bootstrapping and updating ClaudeKit projects",
   type: "module",
   repository: {
@@ -42548,18 +42901,51 @@ class CliUpdateError extends ClaudeKitError {
 }
 var PACKAGE_NAME2 = "claudekit-cli";
 var KIT_UPDATE_REMINDER_HEADER = "Note: 'ck update' only updates the CLI tool itself.";
+function buildInitCommand(isGlobal, kit) {
+  const parts = ["ck init"];
+  if (isGlobal)
+    parts.push("-g");
+  if (kit)
+    parts.push(`--kit ${kit}`);
+  parts.push("--yes --install-skills");
+  return parts.join(" ");
+}
+async function readMetadataFile(claudeDir) {
+  const metadataPath = join76(claudeDir, "metadata.json");
+  try {
+    if (!await import_fs_extra36.pathExists(metadataPath)) {
+      return null;
+    }
+    const content = await import_fs_extra36.readFile(metadataPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
 async function displayKitUpdateReminder() {
   try {
     const setup = await getClaudeKitSetup();
     const hasLocal = !!setup.project.metadata;
     const hasGlobal = !!setup.global.metadata;
-    const localVersion = setup.project.metadata?.version;
-    const globalVersion = setup.global.metadata?.version;
+    const localMetadata = hasLocal ? await readMetadataFile(setup.project.path) : null;
+    const globalMetadata = hasGlobal ? await readMetadataFile(setup.global.path) : null;
+    const localKits = localMetadata ? getInstalledKits(localMetadata) : [];
+    const globalKits = globalMetadata ? getInstalledKits(globalMetadata) : [];
     const versionsToCheck = new Set;
-    if (localVersion)
-      versionsToCheck.add(localVersion);
-    if (globalVersion)
-      versionsToCheck.add(globalVersion);
+    if (localMetadata) {
+      for (const kit of localKits) {
+        const version = localMetadata.kits?.[kit]?.version || localMetadata.version;
+        if (version)
+          versionsToCheck.add(version);
+      }
+    }
+    if (globalMetadata) {
+      for (const kit of globalKits) {
+        const version = globalMetadata.kits?.[kit]?.version || globalMetadata.version;
+        if (version)
+          versionsToCheck.add(version);
+      }
+    }
     const versionCheckResults = new Map;
     if (versionsToCheck.size > 0) {
       const checkPromises = [...versionsToCheck].map(async (version) => {
@@ -42571,33 +42957,52 @@ async function displayKitUpdateReminder() {
         versionCheckResults.set(version, result);
       }
     }
-    const cmdLocal = "ck init";
-    const cmdGlobal = "ck init -g";
-    const maxCmdLen = Math.max(cmdLocal.length, cmdGlobal.length);
+    const commands = [];
+    if (localKits.length > 0) {
+      for (const kit of localKits) {
+        const cmd = buildInitCommand(false, kit);
+        const version = localMetadata?.kits?.[kit]?.version || localMetadata?.version;
+        commands.push({
+          cmd,
+          desc: `Update local project (${kit}${version ? `@${version}` : ""})`,
+          version
+        });
+      }
+    } else if (hasLocal) {
+      commands.push({ cmd: "ck init", desc: "Update local project" });
+    } else {
+      commands.push({ cmd: "ck init", desc: "Initialize in current project" });
+    }
+    if (globalKits.length > 0) {
+      for (const kit of globalKits) {
+        const cmd = buildInitCommand(true, kit);
+        const version = globalMetadata?.kits?.[kit]?.version || globalMetadata?.version;
+        commands.push({
+          cmd,
+          desc: `Update global ~/.claude (${kit}${version ? `@${version}` : ""})`,
+          version
+        });
+      }
+    } else if (hasGlobal) {
+      commands.push({ cmd: "ck init -g", desc: "Update global ~/.claude" });
+    } else {
+      commands.push({ cmd: "ck init -g", desc: "Initialize global ~/.claude" });
+    }
+    const maxCmdLen = Math.max(...commands.map((c2) => c2.cmd.length));
     const pad = (cmd) => cmd.padEnd(maxCmdLen);
     const lines = [];
     lines.push(import_picocolors24.default.yellow(KIT_UPDATE_REMINDER_HEADER));
     lines.push("");
     lines.push("To update your ClaudeKit content (skills, commands, workflows):");
-    if (hasLocal && localVersion) {
-      lines.push(`  ${import_picocolors24.default.cyan(pad(cmdLocal))}  Update local project (${localVersion})`);
-      const localCheck = versionCheckResults.get(localVersion);
-      if (localCheck?.updateAvailable) {
-        const indent = " ".repeat(maxCmdLen + 4);
-        lines.push(`${indent}${import_picocolors24.default.green(`→ ${localCheck.latestVersion} available!`)}`);
-      }
-    } else {
-      lines.push(`  ${import_picocolors24.default.cyan(pad(cmdLocal))}  Initialize in current project`);
-    }
-    if (hasGlobal && globalVersion) {
-      lines.push(`  ${import_picocolors24.default.cyan(pad(cmdGlobal))}  Update global ~/.claude (${globalVersion})`);
-      const globalCheck = versionCheckResults.get(globalVersion);
-      if (globalCheck?.updateAvailable) {
-        const indent = " ".repeat(maxCmdLen + 4);
-        lines.push(`${indent}${import_picocolors24.default.green(`→ ${globalCheck.latestVersion} available!`)}`);
+    for (const { cmd, desc: desc2, version } of commands) {
+      lines.push(`  ${import_picocolors24.default.cyan(pad(cmd))}  ${desc2}`);
+      if (version) {
+        const versionCheck = versionCheckResults.get(version);
+        if (versionCheck?.updateAvailable) {
+          const indent = " ".repeat(maxCmdLen + 4);
+          lines.push(`${indent}${import_picocolors24.default.green(`→ ${versionCheck.latestVersion} available!`)}`);
+        }
       }
-    } else {
-      lines.push(`  ${import_picocolors24.default.cyan(pad(cmdGlobal))}  Initialize global ~/.claude`);
     }
     logger.info("");
     log.info(lines.join(`
@@ -42872,7 +43277,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 join77 } from "node:path";
 init_logger();
 init_types2();
 var packageVersion = package_default.version;
@@ -42906,9 +43311,9 @@ async function displayVersion() {
   let localKitVersion = null;
   let isGlobalOnlyKit = false;
   const globalKitDir = PathResolver.getGlobalKitDir();
-  const globalMetadataPath = join73(globalKitDir, "metadata.json");
+  const globalMetadataPath = join77(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 ? join77(process.cwd(), prefix, "metadata.json") : join77(process.cwd(), "metadata.json");
   const isLocalSameAsGlobal = localMetadataPath === globalMetadataPath;
   if (!isLocalSameAsGlobal && existsSync20(localMetadataPath)) {
     try {