claudekit-cli 3.23.0 → 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";
   }
@@ -39548,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 readFile20, rename as rename2, rm as rm5, writeFile as writeFile16 } 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 join59 } 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";
 
@@ -39562,7 +39724,7 @@ class ConfigManager {
   static config = null;
   static globalFlag = false;
   static getProjectConfigDir(projectDir, global3) {
-    return global3 ? projectDir : join59(projectDir, ".claude");
+    return global3 ? projectDir : join61(projectDir, ".claude");
   }
   static setGlobalFlag(global3) {
     ConfigManager.globalFlag = global3;
@@ -39578,7 +39740,7 @@ class ConfigManager {
     const configFile = PathResolver.getConfigFile(ConfigManager.globalFlag);
     try {
       if (existsSync18(configFile)) {
-        const content = await readFile20(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}`);
@@ -39597,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 writeFile16(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;
@@ -39629,10 +39791,10 @@ class ConfigManager {
   }
   static async loadProjectConfig(projectDir, global3 = false) {
     const configDir = ConfigManager.getProjectConfigDir(projectDir, global3);
-    const configPath = join59(configDir, PROJECT_CONFIG_FILE);
+    const configPath = join61(configDir, PROJECT_CONFIG_FILE);
     try {
       if (existsSync18(configPath)) {
-        const content = await readFile20(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}`);
@@ -39645,7 +39807,7 @@ class ConfigManager {
   }
   static async saveProjectConfig(projectDir, folders, global3 = false) {
     const configDir = ConfigManager.getProjectConfigDir(projectDir, global3);
-    const configPath = join59(configDir, PROJECT_CONFIG_FILE);
+    const configPath = join61(configDir, PROJECT_CONFIG_FILE);
     try {
       if (!existsSync18(configDir)) {
         await mkdir19(configDir, { recursive: true });
@@ -39653,7 +39815,7 @@ class ConfigManager {
       let existingConfig = {};
       if (existsSync18(configPath)) {
         try {
-          const content = await readFile20(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"}`);
@@ -39668,7 +39830,7 @@ class ConfigManager {
           ...validFolders
         }
       };
-      await writeFile16(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"}`);
@@ -39694,11 +39856,11 @@ class ConfigManager {
   }
   static projectConfigExists(projectDir, global3 = false) {
     const configDir = ConfigManager.getProjectConfigDir(projectDir, global3);
-    return existsSync18(join59(configDir, PROJECT_CONFIG_FILE));
+    return existsSync18(join61(configDir, PROJECT_CONFIG_FILE));
   }
   static async migrateNestedConfig(globalDir) {
-    const correctPath = join59(globalDir, PROJECT_CONFIG_FILE);
-    const incorrectPath = join59(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;
@@ -39708,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 = join59(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"}`);
@@ -39799,14 +39961,14 @@ Please use only one download method.`);
   };
 }
 // src/commands/init/phases/post-install-handler.ts
-import { join as join62 } from "node:path";
+import { join as join64 } from "node:path";
 
 // src/domains/installation/setup-wizard.ts
-import { join as join61 } 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 join60 } 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",
@@ -39848,8 +40010,8 @@ async function generateEnvFile(targetDir, values) {
   for (const [key, value] of otherValues) {
     lines.push(`${key}=${value}`);
   }
-  const envPath = join60(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 });
 }
@@ -39867,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",
@@ -39896,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(`
 `)) {
@@ -39922,8 +40084,8 @@ async function parseEnvFile(path11) {
   }
 }
 async function checkGlobalConfig() {
-  const globalEnvPath = join61(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;
@@ -39938,8 +40100,8 @@ async function runSetupWizard(options) {
   let globalEnv = {};
   const hasGlobalConfig = !isGlobal && await checkGlobalConfig();
   if (!isGlobal) {
-    const globalEnvPath = join61(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);
     }
   }
@@ -40001,7 +40163,7 @@ async function runSetupWizard(options) {
     }
   }
   await generateEnvFile(targetDir, values);
-  f2.success(`Configuration saved to ${join61(targetDir, ".env")}`);
+  f2.success(`Configuration saved to ${join63(targetDir, ".env")}`);
   return true;
 }
 async function promptForAdditionalGeminiKeys(primaryKey) {
@@ -40051,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 = 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);
+    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)");
@@ -40105,8 +40267,8 @@ async function handlePostInstall(ctx) {
     }
   }
   if (!ctx.options.skipSetup && !ctx.isNonInteractive) {
-    const envPath = join62(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({
@@ -40127,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 join64, 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();
@@ -40156,11 +40318,11 @@ async function detectAccessibleKits() {
 
 // src/domains/installation/fresh-installer.ts
 init_logger();
-import { join as join63 } 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;
   }
@@ -40175,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 = join63(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}/`);
@@ -40193,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) {
@@ -40357,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}`);
@@ -40369,7 +40531,7 @@ async function handleSelection(ctx) {
   }
   if (!ctx.options.fresh) {
     const prefix = PathResolver.getPathPrefix(ctx.options.global);
-    const claudeDir = prefix ? join64(resolvedDir, prefix) : resolvedDir;
+    const claudeDir = prefix ? join66(resolvedDir, prefix) : resolvedDir;
     try {
       const existingMetadata = await readManifest(claudeDir);
       if (existingMetadata?.kits) {
@@ -40401,7 +40563,7 @@ async function handleSelection(ctx) {
   }
   if (ctx.options.fresh) {
     const prefix = PathResolver.getPathPrefix(ctx.options.global);
-    const claudeDir = prefix ? join64(resolvedDir, prefix) : resolvedDir;
+    const claudeDir = prefix ? join66(resolvedDir, prefix) : resolvedDir;
     const canProceed = await handleFreshInstallation(claudeDir, ctx.prompts);
     if (!canProceed) {
       return { ...ctx, cancelled: true };
@@ -40419,7 +40581,7 @@ async function handleSelection(ctx) {
     logger.info("Fetching available versions...");
     let currentVersion = null;
     try {
-      const metadataPath = ctx.options.global ? join64(PathResolver.getGlobalKitDir(), "metadata.json") : join64(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) {
@@ -40487,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 writeFile18 } from "node:fs/promises";
-import { dirname as dirname9, join as join65, 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 : join65(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 = join65(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");
@@ -40603,7 +40765,7 @@ function getLockTimeout() {
 var STALE_LOCK_THRESHOLD_MS = 5 * 60 * 1000;
 async function acquireSyncLock(global3) {
   const cacheDir = PathResolver.getCacheDir(global3);
-  const lockPath = join65(cacheDir, ".sync-lock");
+  const lockPath = join67(cacheDir, ".sync-lock");
   const startTime = Date.now();
   const lockTimeout = getLockTimeout();
   await mkdir21(dirname9(lockPath), { recursive: true });
@@ -40649,7 +40811,7 @@ async function executeSyncMerge(ctx) {
   const releaseLock = await acquireSyncLock(ctx.options.global);
   try {
     const trackedFiles = ctx.syncTrackedFiles;
-    const upstreamDir = ctx.options.global ? join65(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);
@@ -40668,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 = join65(targetPath, "..");
+          const targetDir = join67(targetPath, "..");
           try {
             await mkdir21(targetDir, { recursive: true });
           } catch (mkdirError) {
@@ -40749,7 +40911,7 @@ async function executeSyncMerge(ctx) {
         try {
           const tempPath = `${currentPath}.tmp.${Date.now()}`;
           try {
-            await writeFile18(tempPath, result.result, "utf-8");
+            await writeFile19(tempPath, result.result, "utf-8");
             await rename3(tempPath, currentPath);
           } catch (atomicError) {
             await unlink7(tempPath).catch(() => {});
@@ -40837,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 = join65(targetPath, "..");
+        const targetDir = join67(targetPath, "..");
         await mkdir21(targetDir, { recursive: true });
         await copyFile6(sourcePath, targetPath);
       }
@@ -40853,7 +41015,7 @@ async function createBackup(claudeDir, files, backupDir) {
   }
 }
 // src/commands/init/phases/transform-handler.ts
-import { join as join69 } from "node:path";
+import { join as join71 } from "node:path";
 
 // src/services/transformers/folder-path-transformer.ts
 init_logger();
@@ -40862,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 join66, 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 = join66(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: join66(extractDir, folders.docs)
+        to: join68(extractDir, folders.docs)
       });
     }
-    const claudeDocsPath = join66(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: join66(extractDir, ".claude", folders.docs)
+        to: join68(extractDir, ".claude", folders.docs)
       });
     }
   }
   if (folders.plans !== DEFAULT_FOLDERS.plans) {
-    const plansPath = join66(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: join66(extractDir, folders.plans)
+        to: join68(extractDir, folders.plans)
       });
     }
-    const claudePlansPath = join66(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: join66(extractDir, ".claude", folders.plans)
+        to: join68(extractDir, ".claude", folders.plans)
       });
     }
   }
@@ -40907,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;
     }
@@ -40935,8 +41097,8 @@ async function renameFolders(dirsToRename, extractDir, options) {
 // src/services/transformers/folder-transform/path-replacer.ts
 init_logger();
 init_types2();
-import { readFile as readFile22, readdir as readdir21, writeFile as writeFile19 } from "node:fs/promises";
-import { join as join67, 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",
@@ -40987,9 +41149,9 @@ function compileReplacements(replacements) {
 async function transformFileContents(dir, compiledReplacements, options) {
   let filesChanged = 0;
   let replacementsCount = 0;
-  const entries = await readdir21(dir, { withFileTypes: true });
+  const entries = await readdir23(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = join67(dir, entry.name);
+    const fullPath = join69(dir, entry.name);
     if (entry.isDirectory()) {
       if (entry.name === "node_modules" || entry.name === ".git") {
         continue;
@@ -41002,7 +41164,7 @@ async function transformFileContents(dir, compiledReplacements, options) {
       if (!shouldTransform)
         continue;
       try {
-        const content = await readFile22(fullPath, "utf-8");
+        const content = await readFile23(fullPath, "utf-8");
         let newContent = content;
         let changeCount = 0;
         for (const { regex: regex2, replacement } of compiledReplacements) {
@@ -41018,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 writeFile19(fullPath, newContent, "utf-8");
+            await writeFile20(fullPath, newContent, "utf-8");
             logger.debug(`Updated ${relative13(dir, fullPath)}: ${changeCount} replacement(s)`);
           }
           filesChanged++;
@@ -41124,15 +41286,15 @@ async function transformFolderPaths(extractDir, folders, options = {}) {
 
 // src/services/transformers/global-path-transformer.ts
 init_logger();
-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 join68 } 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_EXTENSIONS2 = new Set([
+var TRANSFORMABLE_EXTENSIONS3 = new Set([
   ".md",
   ".js",
   ".ts",
@@ -41149,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;
@@ -41179,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;
@@ -41223,10 +41385,10 @@ function transformContent(content) {
   });
   return { transformed, changes };
 }
-function shouldTransformFile2(filename) {
-  const ext2 = extname2(filename).toLowerCase();
+function shouldTransformFile3(filename) {
+  const ext2 = extname3(filename).toLowerCase();
   const basename3 = filename.split("/").pop() || filename;
-  return TRANSFORMABLE_EXTENSIONS2.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;
@@ -41234,20 +41396,20 @@ async function transformPathsForGlobalInstall(directory, options = {}) {
   let filesSkipped = 0;
   const skippedFiles = [];
   async function processDirectory2(dir) {
-    const entries = await readdir22(dir, { withFileTypes: true });
+    const entries = await readdir24(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join68(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() && shouldTransformFile2(entry.name)) {
+      } else if (entry.isFile() && shouldTransformFile3(entry.name)) {
         try {
-          const content = await readFile23(fullPath, "utf-8");
+          const content = await readFile24(fullPath, "utf-8");
           const { transformed, changes } = transformContent(content);
           if (changes > 0) {
-            await writeFile20(fullPath, transformed, "utf-8");
+            await writeFile21(fullPath, transformed, "utf-8");
             filesTransformed++;
             totalChanges += changes;
             if (options.verbose) {
@@ -41312,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 : join69(ctx.resolvedDir, ".claude");
+  const claudeDir = ctx.options.global ? ctx.resolvedDir : join71(ctx.resolvedDir, ".claude");
   return {
     ...ctx,
     foldersConfig,
@@ -41350,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);
@@ -41416,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)
@@ -41497,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();
@@ -41596,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) {
@@ -41633,7 +41803,7 @@ async function handleDirectorySetup(ctx) {
   };
 }
 // src/commands/new/phases/project-creation.ts
-import { join as join70 } from "node:path";
+import { join as join72 } from "node:path";
 init_logger();
 init_output_manager();
 init_types2();
@@ -41743,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 = join70(resolvedDir, ".claude");
+  const claudeDir = join72(resolvedDir, ".claude");
   merger.setMultiKitContext(claudeDir, kit);
   if (validOptions.exclude && validOptions.exclude.length > 0) {
     merger.addIgnorePatterns(validOptions.exclude);
@@ -41880,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());
@@ -41889,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);
@@ -41904,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 join72 } 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 join71 } 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) {
@@ -41957,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 = join71(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;
@@ -41987,7 +42157,7 @@ async function analyzeInstallation(installation, forceOverwrite, kit) {
     return result;
   }
   for (const trackedFile of allTrackedFiles) {
-    const filePath = join71(installation.path, trackedFile.path);
+    const filePath = join73(installation.path, trackedFile.path);
     const ownershipResult = await OwnershipChecker.checkOwnership(filePath, metadata, installation.path);
     if (!ownershipResult.exists)
       continue;
@@ -42047,9 +42217,9 @@ async function removeInstallations(installations, options) {
       let removedCount = 0;
       let cleanedDirs = 0;
       for (const item of analysis.toDelete) {
-        const filePath = join72(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);
@@ -42218,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
@@ -42379,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 readFile24, writeFile as writeFile21 } from "node:fs/promises";
-import { join as join73 } 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 join73(cacheDir, VersionCacheManager.CACHE_FILENAME);
+    return join75(cacheDir, VersionCacheManager.CACHE_FILENAME);
   }
   static async load() {
     const cacheFile = VersionCacheManager.getCacheFile();
@@ -42395,7 +42566,7 @@ class VersionCacheManager {
         logger.debug("Version check cache not found");
         return null;
       }
-      const content = await readFile24(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");
@@ -42415,7 +42586,7 @@ class VersionCacheManager {
       if (!existsSync19(cacheDir)) {
         await mkdir22(cacheDir, { recursive: true, mode: 448 });
       }
-      await writeFile21(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}`);
@@ -42624,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.23.0",
+  version: "3.24.0",
   description: "CLI tool for bootstrapping and updating ClaudeKit projects",
   type: "module",
   repository: {
@@ -42729,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) => {
@@ -42752,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(`
@@ -43053,7 +43277,7 @@ function registerCommands(cli) {
 
 // src/cli/version-display.ts
 import { existsSync as existsSync20, readFileSync as readFileSync6 } from "node:fs";
-import { join as join74 } from "node:path";
+import { join as join77 } from "node:path";
 init_logger();
 init_types2();
 var packageVersion = package_default.version;
@@ -43087,9 +43311,9 @@ async function displayVersion() {
   let localKitVersion = null;
   let isGlobalOnlyKit = false;
   const globalKitDir = PathResolver.getGlobalKitDir();
-  const globalMetadataPath = join74(globalKitDir, "metadata.json");
+  const globalMetadataPath = join77(globalKitDir, "metadata.json");
   const prefix = PathResolver.getPathPrefix(false);
-  const localMetadataPath = prefix ? join74(process.cwd(), prefix, "metadata.json") : join74(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 {

package/package.json

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