claudekit-cli 4.5.0-dev.4 → 4.5.0-dev.6

package/dist/index.js

@@ -64421,7 +64421,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "claudekit-cli",
-    version: "4.5.0-dev.4",
+    version: "4.5.0-dev.6",
     description: "CLI tool for bootstrapping and updating ClaudeKit projects",
     type: "module",
     repository: {
@@ -65083,7 +65083,7 @@ import { spawnSync as spawnSync3 } from "node:child_process";
 import { existsSync as existsSync46, readFileSync as readFileSync14, readdirSync as readdirSync9, statSync as statSync10, writeFileSync as writeFileSync5 } from "node:fs";
 import { readdir as readdir17 } from "node:fs/promises";
 import { homedir as homedir40, tmpdir } from "node:os";
-import { dirname as dirname29, join as join65, resolve as resolve33 } from "node:path";
+import { dirname as dirname29, join as join65, resolve as resolve33, sep as sep11 } from "node:path";
 function resolveDoctorCkExecutable(platformName = process.platform) {
   return platformName === "win32" ? "ck.cmd" : "ck";
 }
@@ -66085,6 +66085,21 @@ async function countMissingHookFileReferences(projectDir = process.cwd()) {
   }
   return count;
 }
+async function countMissingHookFileReferencesForClaudeDir(claudeDir3, projectRoot = dirname29(claudeDir3)) {
+  const hooksDirPrefix = `${resolve33(claudeDir3, "hooks")}${sep11}`;
+  let count = 0;
+  for (const fileName of ["settings.json", "settings.local.json"]) {
+    const filePath = resolve33(claudeDir3, fileName);
+    if (!existsSync46(filePath))
+      continue;
+    const settings = await SettingsMerger.readSettingsFile(filePath);
+    if (!settings)
+      continue;
+    const descriptor = { path: filePath, label: fileName, root: "$HOME" };
+    count += collectMissingHookReferences(settings, descriptor, projectRoot).filter((finding) => finding.resolvedPath.startsWith(hooksDirPrefix)).length;
+  }
+  return count;
+}
 async function repairMissingHookFileReferences(projectDir = process.cwd()) {
   const result = await checkHookFileReferences(projectDir);
   if (result.status !== "fail" || !result.fix) {
@@ -74769,6 +74784,164 @@ var init_process_executor = __esm(() => {
   execFileAsync7 = promisify15(execFile10);
 });
 
+// src/services/package-installer/agy-installer.ts
+import { join as join90 } from "node:path";
+async function isAgyInstalled() {
+  try {
+    await execAsync7("agy --version", { timeout: 1e4 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function installAgyUnix() {
+  const { unlink: unlink13 } = await import("node:fs/promises");
+  const { tmpdir: tmpdir4 } = await import("node:os");
+  const tempScriptPath = join90(tmpdir4(), "agy-install.sh");
+  try {
+    logger.info("Downloading Antigravity CLI installation script...");
+    await execFileAsync7("curl", ["-fsSL", AGY_INSTALL_SH_URL, "-o", tempScriptPath], {
+      timeout: 30000
+    });
+    await execFileAsync7("chmod", ["+x", tempScriptPath], { timeout: 5000 });
+    logger.info("Executing Antigravity CLI installation script...");
+    await execFileAsync7("bash", [tempScriptPath], {
+      timeout: 120000
+    });
+  } finally {
+    try {
+      await unlink13(tempScriptPath);
+    } catch {}
+  }
+}
+async function installAgyWindows() {
+  logger.info("Executing Antigravity CLI installation script (PowerShell)...");
+  await execFileAsync7("powershell.exe", ["-NoLogo", "-ExecutionPolicy", "Bypass", "-Command", `irm ${AGY_INSTALL_PS1_URL} | iex`], { timeout: 120000 });
+}
+async function installAgy() {
+  const displayName = AGY_DISPLAY_NAME;
+  if (isCIEnvironment()) {
+    logger.info("CI environment detected: skipping Antigravity CLI installation");
+    return {
+      success: false,
+      package: displayName,
+      error: "Installation skipped in CI environment",
+      skipped: true
+    };
+  }
+  try {
+    logger.info(`Installing ${displayName}...`);
+    if (isWindows()) {
+      await installAgyWindows();
+    } else {
+      await installAgyUnix();
+    }
+    const installed = await isAgyInstalled();
+    if (installed) {
+      logger.success(`${displayName} installed successfully`);
+      return {
+        success: true,
+        package: displayName
+      };
+    }
+    const pathHint = isWindows() ? "%LOCALAPPDATA%\\agy\\bin" : "~/.local/bin";
+    logger.warning(`${displayName} installed, but 'agy' is not on your PATH yet. Restart your shell or add "${pathHint}" to PATH.`);
+    return {
+      success: false,
+      package: displayName,
+      error: `Installed but 'agy' not found on PATH. Restart your shell or add "${pathHint}" to PATH.`
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    logger.error(`Failed to install ${displayName}: ${errorMessage}`);
+    return {
+      success: false,
+      package: displayName,
+      error: errorMessage
+    };
+  }
+}
+var AGY_DISPLAY_NAME = "Antigravity CLI (agy)", AGY_INSTALL_SH_URL = "https://antigravity.google/cli/install.sh", AGY_INSTALL_PS1_URL = "https://antigravity.google/cli/install.ps1";
+var init_agy_installer = __esm(() => {
+  init_environment();
+  init_logger();
+  init_process_executor();
+});
+
+// src/services/package-installer/opencode-installer.ts
+import { join as join91 } from "node:path";
+async function isOpenCodeInstalled() {
+  try {
+    await execAsync7("opencode --version", { timeout: 5000 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function installOpenCode() {
+  const displayName = "OpenCode CLI";
+  if (isCIEnvironment()) {
+    logger.info("CI environment detected: skipping OpenCode installation");
+    return {
+      success: false,
+      package: displayName,
+      error: "Installation skipped in CI environment"
+    };
+  }
+  try {
+    logger.info(`Installing ${displayName}...`);
+    const { unlink: unlink13 } = await import("node:fs/promises");
+    const { tmpdir: tmpdir4 } = await import("node:os");
+    const tempScriptPath = join91(tmpdir4(), "opencode-install.sh");
+    try {
+      logger.info("Downloading OpenCode installation script...");
+      await execFileAsync7("curl", ["-fsSL", "https://opencode.ai/install", "-o", tempScriptPath], {
+        timeout: 30000
+      });
+      await execFileAsync7("chmod", ["+x", tempScriptPath], {
+        timeout: 5000
+      });
+      logger.info("Executing OpenCode installation script...");
+      await execFileAsync7("bash", [tempScriptPath], {
+        timeout: 120000
+      });
+    } finally {
+      try {
+        await unlink13(tempScriptPath);
+      } catch {}
+    }
+    const installed = await isOpenCodeInstalled();
+    if (installed) {
+      logger.success(`${displayName} installed successfully`);
+      return {
+        success: true,
+        package: displayName
+      };
+    }
+    return {
+      success: false,
+      package: displayName,
+      error: "Installation completed but opencode command not found in PATH"
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    logger.error(`Failed to install ${displayName}: ${errorMessage}`);
+    return {
+      success: false,
+      package: displayName,
+      error: errorMessage
+    };
+  }
+}
+var init_opencode_installer = __esm(() => {
+  init_environment();
+  init_logger();
+  init_process_executor();
+});
+
+// src/services/package-installer/types.ts
+var PARTIAL_INSTALL_VERSION = "partial", EXIT_CODE_CRITICAL_FAILURE = 1, EXIT_CODE_PARTIAL_SUCCESS = 2;
+
 // src/services/package-installer/validators.ts
 import { resolve as resolve38 } from "node:path";
 function validatePackageName(packageName) {
@@ -74953,100 +75126,9 @@ var init_npm_package_manager = __esm(() => {
   init_validators();
 });
 
-// src/services/package-installer/gemini-installer.ts
-async function isGeminiInstalled() {
-  try {
-    await execAsync7("gemini --version", { timeout: 1e4 });
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function installGemini() {
-  return installPackageGlobally("@google/gemini-cli", "Google Gemini CLI");
-}
-var init_gemini_installer = __esm(() => {
-  init_npm_package_manager();
-  init_process_executor();
-});
-
-// src/services/package-installer/opencode-installer.ts
-import { join as join90 } from "node:path";
-async function isOpenCodeInstalled() {
-  try {
-    await execAsync7("opencode --version", { timeout: 5000 });
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function installOpenCode() {
-  const displayName = "OpenCode CLI";
-  if (isCIEnvironment()) {
-    logger.info("CI environment detected: skipping OpenCode installation");
-    return {
-      success: false,
-      package: displayName,
-      error: "Installation skipped in CI environment"
-    };
-  }
-  try {
-    logger.info(`Installing ${displayName}...`);
-    const { unlink: unlink13 } = await import("node:fs/promises");
-    const { tmpdir: tmpdir4 } = await import("node:os");
-    const tempScriptPath = join90(tmpdir4(), "opencode-install.sh");
-    try {
-      logger.info("Downloading OpenCode installation script...");
-      await execFileAsync7("curl", ["-fsSL", "https://opencode.ai/install", "-o", tempScriptPath], {
-        timeout: 30000
-      });
-      await execFileAsync7("chmod", ["+x", tempScriptPath], {
-        timeout: 5000
-      });
-      logger.info("Executing OpenCode installation script...");
-      await execFileAsync7("bash", [tempScriptPath], {
-        timeout: 120000
-      });
-    } finally {
-      try {
-        await unlink13(tempScriptPath);
-      } catch {}
-    }
-    const installed = await isOpenCodeInstalled();
-    if (installed) {
-      logger.success(`${displayName} installed successfully`);
-      return {
-        success: true,
-        package: displayName
-      };
-    }
-    return {
-      success: false,
-      package: displayName,
-      error: "Installation completed but opencode command not found in PATH"
-    };
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : "Unknown error";
-    logger.error(`Failed to install ${displayName}: ${errorMessage}`);
-    return {
-      success: false,
-      package: displayName,
-      error: errorMessage
-    };
-  }
-}
-var init_opencode_installer = __esm(() => {
-  init_environment();
-  init_logger();
-  init_process_executor();
-});
-
-// src/services/package-installer/types.ts
-var PARTIAL_INSTALL_VERSION = "partial", EXIT_CODE_CRITICAL_FAILURE = 1, EXIT_CODE_PARTIAL_SUCCESS = 2;
-
 // src/services/package-installer/install-error-handler.ts
 import { existsSync as existsSync62, readFileSync as readFileSync19, unlinkSync as unlinkSync3 } from "node:fs";
-import { join as join91 } from "node:path";
+import { join as join92 } from "node:path";
 function parseNameReason(str2) {
   const colonIndex = str2.indexOf(":");
   if (colonIndex === -1) {
@@ -75109,7 +75191,7 @@ function getSystemPackageCommands(summary, systemFailures) {
   return summary.remediation.sudo_packages ? [summary.remediation.sudo_packages] : [];
 }
 function displayInstallErrors(skillsDir2) {
-  const summaryPath = join91(skillsDir2, ".install-error-summary.json");
+  const summaryPath = join92(skillsDir2, ".install-error-summary.json");
   if (!existsSync62(summaryPath)) {
     logger.error("Skills installation failed. Run with --verbose for details.");
     return;
@@ -75208,7 +75290,7 @@ async function checkNeedsSudoPackages() {
   }
 }
 function hasInstallState(skillsDir2) {
-  const stateFilePath = join91(skillsDir2, ".install-state.json");
+  const stateFilePath = join92(skillsDir2, ".install-state.json");
   return existsSync62(stateFilePath);
 }
 var WHICH_COMMAND_TIMEOUT_MS = 5000, WINDOWS_SYSTEM_PACKAGES, SYSTEM_TOOL_KEYS, WINDOWS_RSVG_COMMANDS;
@@ -75226,7 +75308,7 @@ var init_install_error_handler = __esm(() => {
 });
 
 // src/services/package-installer/skills-installer.ts
-import { join as join92 } from "node:path";
+import { join as join93 } from "node:path";
 async function installSkillsDependencies(skillsDir2, options2 = {}) {
   const { skipConfirm = false, withSudo = false } = options2;
   const displayName = "Skills Dependencies";
@@ -75252,7 +75334,7 @@ async function installSkillsDependencies(skillsDir2, options2 = {}) {
     const clack = await Promise.resolve().then(() => (init_dist2(), exports_dist));
     const platform10 = process.platform;
     const scriptName = platform10 === "win32" ? "install.ps1" : "install.sh";
-    const scriptPath = join92(skillsDir2, scriptName);
+    const scriptPath = join93(skillsDir2, scriptName);
     try {
       validateScriptPath(skillsDir2, scriptPath);
     } catch (error) {
@@ -75268,7 +75350,7 @@ async function installSkillsDependencies(skillsDir2, options2 = {}) {
       logger.warning(`Skills installation script not found: ${scriptPath}`);
       logger.info("");
       logger.info("\uD83D\uDCD6 Manual Installation Instructions:");
-      logger.info(`  See: ${join92(skillsDir2, "INSTALLATION.md")}`);
+      logger.info(`  See: ${join93(skillsDir2, "INSTALLATION.md")}`);
       logger.info("");
       logger.info("Quick start:");
       logger.info("  cd .claude/skills/ai-multimodal/scripts");
@@ -75315,7 +75397,7 @@ async function installSkillsDependencies(skillsDir2, options2 = {}) {
       logger.info(`  ${platform10 === "win32" ? `powershell -File "${scriptPath}"` : `bash ${scriptPath}`}`);
       logger.info("");
       logger.info("Or see complete guide:");
-      logger.info(`  ${join92(skillsDir2, "INSTALLATION.md")}`);
+      logger.info(`  ${join93(skillsDir2, "INSTALLATION.md")}`);
       return {
         success: false,
         package: displayName,
@@ -75436,7 +75518,7 @@ async function installSkillsDependencies(skillsDir2, options2 = {}) {
     logger.info("\uD83D\uDCD6 Manual Installation Instructions:");
     logger.info("");
     logger.info("See complete guide:");
-    logger.info(`  cat ${join92(skillsDir2, "INSTALLATION.md")}`);
+    logger.info(`  cat ${join93(skillsDir2, "INSTALLATION.md")}`);
     logger.info("");
     logger.info("Quick start:");
     logger.info("  cd .claude/skills/ai-multimodal/scripts");
@@ -75479,10 +75561,10 @@ var init_skills_installer2 = __esm(() => {
   init_validators();
 });
 
-// src/services/package-installer/gemini-mcp/config-manager.ts
+// src/services/package-installer/agy-mcp/config-manager.ts
 import { existsSync as existsSync63 } from "node:fs";
 import { mkdir as mkdir23, readFile as readFile49, writeFile as writeFile25 } from "node:fs/promises";
-import { dirname as dirname34, join as join93 } from "node:path";
+import { dirname as dirname34, join as join94 } from "node:path";
 async function readJsonFile(filePath) {
   try {
     const content = await readFile49(filePath, "utf-8");
@@ -75493,36 +75575,39 @@ async function readJsonFile(filePath) {
     return null;
   }
 }
-async function addGeminiToGitignore(projectDir) {
-  const gitignorePath = join93(projectDir, ".gitignore");
-  const geminiPattern = ".gemini/";
+async function addAgyToGitignore(projectDir) {
+  const gitignorePath = join94(projectDir, ".gitignore");
   try {
     let content = "";
     if (existsSync63(gitignorePath)) {
       content = await readFile49(gitignorePath, "utf-8");
       const lines = content.split(`
 `).map((line) => line.trim()).filter((line) => !line.startsWith("#"));
-      const geminiPatterns = [".gemini/", ".gemini", "/.gemini/", "/.gemini"];
-      if (lines.some((line) => geminiPatterns.includes(line))) {
-        logger.debug(".gemini/ already in .gitignore");
+      const agyPatterns = [
+        ".agents/mcp_config.json",
+        "/.agents/mcp_config.json",
+        ".agents/mcp_config.json/"
+      ];
+      if (lines.some((line) => agyPatterns.includes(line))) {
+        logger.debug(".agents/mcp_config.json already in .gitignore");
         return;
       }
     }
     const newLine = content.endsWith(`
 `) || content === "" ? "" : `
 `;
-    const comment = "# Gemini CLI settings (contains user-specific config)";
+    const comment = "# Antigravity CLI MCP config (symlinked to your Claude MCP config)";
     await writeFile25(gitignorePath, `${content}${newLine}${comment}
-${geminiPattern}
+${AGY_GITIGNORE_PATTERN}
 `, "utf-8");
-    logger.debug(`Added ${geminiPattern} to .gitignore`);
+    logger.debug(`Added ${AGY_GITIGNORE_PATTERN} to .gitignore`);
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : "Unknown error";
     logger.warning(`Failed to update .gitignore: ${errorMessage}`);
   }
 }
-async function createNewSettingsWithMerge(geminiSettingsPath, mcpConfigPath) {
-  const linkDir = dirname34(geminiSettingsPath);
+async function createNewSettingsWithMerge(agyConfigPath, mcpConfigPath) {
+  const linkDir = dirname34(agyConfigPath);
   if (!existsSync63(linkDir)) {
     await mkdir23(linkDir, { recursive: true });
     logger.debug(`Created directory: ${linkDir}`);
@@ -75537,8 +75622,8 @@ async function createNewSettingsWithMerge(geminiSettingsPath, mcpConfigPath) {
   }
   const newSettings = { mcpServers };
   try {
-    await writeFile25(geminiSettingsPath, JSON.stringify(newSettings, null, 2), "utf-8");
-    logger.debug(`Created new Gemini settings with mcpServers: ${geminiSettingsPath}`);
+    await writeFile25(agyConfigPath, JSON.stringify(newSettings, null, 2), "utf-8");
+    logger.debug(`Created new agy mcp_config.json with mcpServers: ${agyConfigPath}`);
     return { success: true, method: "merge", targetPath: mcpConfigPath };
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : "Unknown error";
@@ -75549,10 +75634,14 @@ async function createNewSettingsWithMerge(geminiSettingsPath, mcpConfigPath) {
     };
   }
 }
-async function mergeGeminiSettings(geminiSettingsPath, mcpConfigPath) {
-  const geminiSettings = await readJsonFile(geminiSettingsPath);
-  if (!geminiSettings) {
-    return { success: false, method: "merge", error: "Failed to read existing Gemini settings" };
+async function mergeAgySettings(agyConfigPath, mcpConfigPath) {
+  const agyConfig = await readJsonFile(agyConfigPath);
+  if (!agyConfig) {
+    return {
+      success: false,
+      method: "merge",
+      error: "Failed to read existing agy mcp_config.json"
+    };
   }
   const mcpConfig = await readJsonFile(mcpConfigPath);
   if (!mcpConfig) {
@@ -75563,12 +75652,12 @@ async function mergeGeminiSettings(geminiSettingsPath, mcpConfigPath) {
     return { success: false, method: "merge", error: "MCP config has no valid mcpServers object" };
   }
   const mergedSettings = {
-    ...geminiSettings,
+    ...agyConfig,
     mcpServers
   };
   try {
-    await writeFile25(geminiSettingsPath, JSON.stringify(mergedSettings, null, 2), "utf-8");
-    logger.debug(`Merged mcpServers into: ${geminiSettingsPath}`);
+    await writeFile25(agyConfigPath, JSON.stringify(mergedSettings, null, 2), "utf-8");
+    logger.debug(`Merged mcpServers into: ${agyConfigPath}`);
     return { success: true, method: "merge", targetPath: mcpConfigPath };
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : "Unknown error";
@@ -75579,19 +75668,20 @@ async function mergeGeminiSettings(geminiSettingsPath, mcpConfigPath) {
     };
   }
 }
+var AGY_GITIGNORE_PATTERN = ".agents/mcp_config.json";
 var init_config_manager2 = __esm(() => {
   init_logger();
 });
 
-// src/services/package-installer/gemini-mcp/validation.ts
+// src/services/package-installer/agy-mcp/validation.ts
 import { existsSync as existsSync64, lstatSync, readlinkSync } from "node:fs";
 import { homedir as homedir45 } from "node:os";
-import { join as join94 } from "node:path";
+import { join as join95 } from "node:path";
 function getGlobalMcpConfigPath() {
-  return join94(homedir45(), ".claude", ".mcp.json");
+  return join95(homedir45(), ".claude", ".mcp.json");
 }
 function getLocalMcpConfigPath(projectDir) {
-  return join94(projectDir, ".mcp.json");
+  return join95(projectDir, ".mcp.json");
 }
 function findMcpConfigPath(projectDir) {
   const localPath = getLocalMcpConfigPath(projectDir);
@@ -75607,41 +75697,41 @@ function findMcpConfigPath(projectDir) {
   logger.debug("No MCP config found (local or global)");
   return null;
 }
-function getGeminiSettingsPath(projectDir, isGlobal) {
+function getAgyMcpConfigPath(projectDir, isGlobal) {
   if (isGlobal) {
-    return join94(homedir45(), ".gemini", "settings.json");
+    return join95(homedir45(), ".gemini", "config", "mcp_config.json");
   }
-  return join94(projectDir, ".gemini", "settings.json");
+  return join95(projectDir, ".agents", "mcp_config.json");
 }
-function checkExistingGeminiConfig(projectDir, isGlobal = false) {
-  const geminiSettingsPath = getGeminiSettingsPath(projectDir, isGlobal);
-  if (!existsSync64(geminiSettingsPath)) {
-    return { exists: false, isSymlink: false, settingsPath: geminiSettingsPath };
+function checkExistingAgyConfig(projectDir, isGlobal = false) {
+  const agyConfigPath = getAgyMcpConfigPath(projectDir, isGlobal);
+  if (!existsSync64(agyConfigPath)) {
+    return { exists: false, isSymlink: false, settingsPath: agyConfigPath };
   }
   try {
-    const stats = lstatSync(geminiSettingsPath);
+    const stats = lstatSync(agyConfigPath);
     if (stats.isSymbolicLink()) {
-      const target = readlinkSync(geminiSettingsPath);
+      const target = readlinkSync(agyConfigPath);
       return {
         exists: true,
         isSymlink: true,
         currentTarget: target,
-        settingsPath: geminiSettingsPath
+        settingsPath: agyConfigPath
       };
     }
-    return { exists: true, isSymlink: false, settingsPath: geminiSettingsPath };
+    return { exists: true, isSymlink: false, settingsPath: agyConfigPath };
   } catch {
-    return { exists: true, isSymlink: false, settingsPath: geminiSettingsPath };
+    return { exists: true, isSymlink: false, settingsPath: agyConfigPath };
   }
 }
 var init_validation = __esm(() => {
   init_logger();
 });
 
-// src/services/package-installer/gemini-mcp/linker-core.ts
+// src/services/package-installer/agy-mcp/linker-core.ts
 import { existsSync as existsSync65 } from "node:fs";
 import { mkdir as mkdir24, symlink as symlink3 } from "node:fs/promises";
-import { dirname as dirname35, join as join95 } from "node:path";
+import { dirname as dirname35, join as join96 } from "node:path";
 async function createSymlink(targetPath, linkPath, projectDir, isGlobal) {
   const linkDir = dirname35(linkPath);
   if (!existsSync65(linkDir)) {
@@ -75652,14 +75742,14 @@ async function createSymlink(targetPath, linkPath, projectDir, isGlobal) {
   if (isGlobal) {
     symlinkTarget = getGlobalMcpConfigPath();
   } else {
-    const localMcpPath = join95(projectDir, ".mcp.json");
+    const localMcpPath = join96(projectDir, ".mcp.json");
     const isLocalConfig = targetPath === localMcpPath;
     symlinkTarget = isLocalConfig ? "../.mcp.json" : targetPath;
   }
   try {
     await symlink3(symlinkTarget, linkPath, isWindows() ? "file" : undefined);
     logger.debug(`Created symlink: ${linkPath} → ${symlinkTarget}`);
-    return { success: true, method: "symlink", targetPath, geminiSettingsPath: linkPath };
+    return { success: true, method: "symlink", targetPath, agyConfigPath: linkPath };
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : "Unknown error";
     return {
@@ -75675,21 +75765,21 @@ var init_linker_core = __esm(() => {
   init_validation();
 });
 
-// src/services/package-installer/gemini-mcp-linker.ts
-var exports_gemini_mcp_linker = {};
-__export(exports_gemini_mcp_linker, {
-  processGeminiMcpLinking: () => processGeminiMcpLinking,
-  linkGeminiMcpConfig: () => linkGeminiMcpConfig,
-  getGeminiSettingsPath: () => getGeminiSettingsPath,
+// src/services/package-installer/agy-mcp-linker.ts
+var exports_agy_mcp_linker = {};
+__export(exports_agy_mcp_linker, {
+  processAgyMcpLinking: () => processAgyMcpLinking,
+  linkAgyMcpConfig: () => linkAgyMcpConfig,
+  getAgyMcpConfigPath: () => getAgyMcpConfigPath,
   findMcpConfigPath: () => findMcpConfigPath,
-  checkExistingGeminiConfig: () => checkExistingGeminiConfig,
-  addGeminiToGitignore: () => addGeminiToGitignore
+  checkExistingAgyConfig: () => checkExistingAgyConfig,
+  addAgyToGitignore: () => addAgyToGitignore
 });
 import { resolve as resolve39 } from "node:path";
-async function linkGeminiMcpConfig(projectDir, options2 = {}) {
+async function linkAgyMcpConfig(projectDir, options2 = {}) {
   const { skipGitignore = false, isGlobal = false } = options2;
   const resolvedProjectDir = resolve39(projectDir);
-  const geminiSettingsPath = getGeminiSettingsPath(resolvedProjectDir, isGlobal);
+  const agyConfigPath = getAgyMcpConfigPath(resolvedProjectDir, isGlobal);
   const mcpConfigPath = findMcpConfigPath(resolvedProjectDir);
   if (!mcpConfigPath) {
     return {
@@ -75698,50 +75788,50 @@ async function linkGeminiMcpConfig(projectDir, options2 = {}) {
       error: "No MCP config found. Create .mcp.json or ~/.claude/.mcp.json first."
     };
   }
-  const existing = checkExistingGeminiConfig(resolvedProjectDir, isGlobal);
+  const existing = checkExistingAgyConfig(resolvedProjectDir, isGlobal);
   let result;
   if (!existing.exists) {
-    result = await createSymlink(mcpConfigPath, geminiSettingsPath, resolvedProjectDir, isGlobal);
+    result = await createSymlink(mcpConfigPath, agyConfigPath, resolvedProjectDir, isGlobal);
     if (!result.success && process.platform === "win32") {
       logger.debug("Symlink failed on Windows, falling back to merge");
-      result = await createNewSettingsWithMerge(geminiSettingsPath, mcpConfigPath);
+      result = await createNewSettingsWithMerge(agyConfigPath, mcpConfigPath);
     }
   } else if (existing.isSymlink) {
     result = {
       success: true,
       method: "skipped",
       targetPath: existing.currentTarget,
-      geminiSettingsPath
+      agyConfigPath
     };
   } else {
-    result = await mergeGeminiSettings(geminiSettingsPath, mcpConfigPath);
+    result = await mergeAgySettings(agyConfigPath, mcpConfigPath);
   }
   if (result.success && !skipGitignore && !isGlobal) {
-    await addGeminiToGitignore(resolvedProjectDir);
+    await addAgyToGitignore(resolvedProjectDir);
   }
   return result;
 }
-async function processGeminiMcpLinking(projectDir, options2 = {}) {
-  logger.info("Setting up Gemini CLI MCP integration...");
-  const result = await linkGeminiMcpConfig(projectDir, options2);
-  const settingsPath = result.geminiSettingsPath || (options2.isGlobal ? "~/.gemini/settings.json" : ".gemini/settings.json");
+async function processAgyMcpLinking(projectDir, options2 = {}) {
+  logger.info("Setting up Antigravity (agy) CLI MCP integration...");
+  const result = await linkAgyMcpConfig(projectDir, options2);
+  const configPath = result.agyConfigPath || (options2.isGlobal ? "~/.gemini/config/mcp_config.json" : ".agents/mcp_config.json");
   if (result.success) {
     if (result.method === "symlink") {
-      logger.success(`Gemini MCP linked: ${settingsPath} → ${result.targetPath}`);
+      logger.success(`agy MCP linked: ${configPath} → ${result.targetPath}`);
       logger.info("MCP servers will auto-sync with your Claude config.");
     } else if (result.method === "merge") {
-      logger.success("Gemini MCP config updated (merged mcpServers, preserved your settings)");
+      logger.success("agy MCP config updated (merged mcpServers, preserved your settings)");
       logger.info("Note: Run 'ck init' again to sync MCP config changes.");
     } else {
-      logger.info("Gemini MCP config already configured.");
+      logger.info("agy MCP config already configured.");
     }
   } else {
-    logger.warning(`Gemini MCP setup incomplete: ${result.error}`);
-    const cmd = options2.isGlobal ? "mkdir -p ~/.gemini && ln -sf ~/.claude/.mcp.json ~/.gemini/settings.json" : "mkdir -p .gemini && ln -sf ../.mcp.json .gemini/settings.json";
+    logger.warning(`agy MCP setup incomplete: ${result.error}`);
+    const cmd = options2.isGlobal ? "mkdir -p ~/.gemini/config && ln -sf ~/.claude/.mcp.json ~/.gemini/config/mcp_config.json" : "mkdir -p .agents && ln -sf ../.mcp.json .agents/mcp_config.json";
     logger.info(`Manual setup: ${cmd}`);
   }
 }
-var init_gemini_mcp_linker = __esm(() => {
+var init_agy_mcp_linker = __esm(() => {
   init_logger();
   init_config_manager2();
   init_linker_core();
@@ -75758,11 +75848,11 @@ __export(exports_package_installer, {
   processPackageInstallations: () => processPackageInstallations,
   isPackageInstalled: () => isPackageInstalled,
   isOpenCodeInstalled: () => isOpenCodeInstalled,
-  isGeminiInstalled: () => isGeminiInstalled,
+  isAgyInstalled: () => isAgyInstalled,
   installSkillsDependencies: () => installSkillsDependencies,
   installPackageGlobally: () => installPackageGlobally,
   installOpenCode: () => installOpenCode,
-  installGemini: () => installGemini,
+  installAgy: () => installAgy,
   handleSkillsInstallation: () => handleSkillsInstallation,
   getPackageVersion: () => getPackageVersion,
   getNpmCommand: () => getNpmCommand,
@@ -75771,9 +75861,10 @@ __export(exports_package_installer, {
   execAsync: () => execAsync7,
   PARTIAL_INSTALL_VERSION: () => PARTIAL_INSTALL_VERSION,
   EXIT_CODE_PARTIAL_SUCCESS: () => EXIT_CODE_PARTIAL_SUCCESS,
-  EXIT_CODE_CRITICAL_FAILURE: () => EXIT_CODE_CRITICAL_FAILURE
+  EXIT_CODE_CRITICAL_FAILURE: () => EXIT_CODE_CRITICAL_FAILURE,
+  AGY_DISPLAY_NAME: () => AGY_DISPLAY_NAME
 });
-async function processPackageInstallations(shouldInstallOpenCode, shouldInstallGemini, projectDir) {
+async function processPackageInstallations(shouldInstallOpenCode, shouldInstallAgy, projectDir) {
   const results = {};
   if (shouldInstallOpenCode) {
     if (isTestEnvironment()) {
@@ -75795,28 +75886,28 @@ async function processPackageInstallations(shouldInstallOpenCode, shouldInstallG
       }
     }
   }
-  if (shouldInstallGemini) {
+  if (shouldInstallAgy) {
     if (isTestEnvironment()) {
-      results.gemini = {
+      results.agy = {
         success: true,
-        package: "Google Gemini CLI",
+        package: AGY_DISPLAY_NAME,
         skipped: true
       };
     } else {
-      const alreadyInstalled = await isGeminiInstalled();
+      const alreadyInstalled = await isAgyInstalled();
       if (alreadyInstalled) {
-        logger.info("Google Gemini CLI already installed");
-        results.gemini = {
+        logger.info(`${AGY_DISPLAY_NAME} already installed`);
+        results.agy = {
           success: true,
-          package: "Google Gemini CLI"
+          package: AGY_DISPLAY_NAME
         };
       } else {
-        results.gemini = await installGemini();
+        results.agy = await installAgy();
       }
-      const geminiAvailable = alreadyInstalled || results.gemini?.success;
-      if (projectDir && geminiAvailable) {
-        const { processGeminiMcpLinking: processGeminiMcpLinking2 } = await Promise.resolve().then(() => (init_gemini_mcp_linker(), exports_gemini_mcp_linker));
-        await processGeminiMcpLinking2(projectDir);
+      const agyAvailable = alreadyInstalled || results.agy?.success;
+      if (projectDir && agyAvailable) {
+        const { processAgyMcpLinking: processAgyMcpLinking2 } = await Promise.resolve().then(() => (init_agy_mcp_linker(), exports_agy_mcp_linker));
+        await processAgyMcpLinking2(projectDir);
       }
     }
   }
@@ -75825,13 +75916,13 @@ async function processPackageInstallations(shouldInstallOpenCode, shouldInstallG
 var init_package_installer = __esm(() => {
   init_environment();
   init_logger();
-  init_gemini_installer();
+  init_agy_installer();
   init_opencode_installer();
   init_validators();
   init_process_executor();
   init_npm_package_manager();
   init_opencode_installer();
-  init_gemini_installer();
+  init_agy_installer();
   init_skills_installer2();
 });
 
@@ -78068,10 +78159,10 @@ __export(exports_worktree_manager, {
   cleanupAllWorktrees: () => cleanupAllWorktrees
 });
 import { existsSync as existsSync77 } from "node:fs";
-import { readFile as readFile69, writeFile as writeFile40 } from "node:fs/promises";
-import { join as join158 } from "node:path";
+import { readFile as readFile70, writeFile as writeFile41 } from "node:fs/promises";
+import { join as join160 } from "node:path";
 async function createWorktree(projectDir, issueNumber, baseBranch) {
-  const worktreePath = join158(projectDir, WORKTREE_DIR, `issue-${issueNumber}`);
+  const worktreePath = join160(projectDir, WORKTREE_DIR, `issue-${issueNumber}`);
   const branchName = `ck-watch/issue-${issueNumber}`;
   await spawnAndCollect("git", ["fetch", "origin", baseBranch], projectDir).catch(() => {
     logger.warning(`[worktree] Could not fetch origin/${baseBranch}, using local`);
@@ -78089,7 +78180,7 @@ async function createWorktree(projectDir, issueNumber, baseBranch) {
   return worktreePath;
 }
 async function removeWorktree(projectDir, issueNumber) {
-  const worktreePath = join158(projectDir, WORKTREE_DIR, `issue-${issueNumber}`);
+  const worktreePath = join160(projectDir, WORKTREE_DIR, `issue-${issueNumber}`);
   const branchName = `ck-watch/issue-${issueNumber}`;
   try {
     await spawnAndCollect("git", ["worktree", "remove", worktreePath, "--force"], projectDir);
@@ -78103,7 +78194,7 @@ async function listActiveWorktrees(projectDir) {
   try {
     const output2 = await spawnAndCollect("git", ["worktree", "list", "--porcelain"], projectDir);
     const issueNumbers = [];
-    const worktreePrefix = join158(projectDir, WORKTREE_DIR, "issue-").replace(/\\/g, "/");
+    const worktreePrefix = join160(projectDir, WORKTREE_DIR, "issue-").replace(/\\/g, "/");
     for (const line of output2.split(`
 `)) {
       if (line.startsWith("worktree ")) {
@@ -78131,16 +78222,16 @@ async function cleanupAllWorktrees(projectDir) {
   await spawnAndCollect("git", ["worktree", "prune"], projectDir).catch(() => {});
 }
 async function ensureGitignore(projectDir) {
-  const gitignorePath = join158(projectDir, ".gitignore");
+  const gitignorePath = join160(projectDir, ".gitignore");
   try {
-    const content = existsSync77(gitignorePath) ? await readFile69(gitignorePath, "utf-8") : "";
+    const content = existsSync77(gitignorePath) ? await readFile70(gitignorePath, "utf-8") : "";
     if (!content.includes(".worktrees")) {
       const newContent = content.endsWith(`
 `) ? `${content}.worktrees/
 ` : `${content}
 .worktrees/
 `;
-      await writeFile40(gitignorePath, newContent, "utf-8");
+      await writeFile41(gitignorePath, newContent, "utf-8");
       logger.info("[worktree] Added .worktrees/ to .gitignore");
     }
   } catch (err) {
@@ -78236,9 +78327,9 @@ var init_content_validator = __esm(() => {
 // src/commands/content/phases/context-cache-manager.ts
 import { createHash as createHash9 } from "node:crypto";
 import { existsSync as existsSync83, mkdirSync as mkdirSync7, readFileSync as readFileSync22, readdirSync as readdirSync14, statSync as statSync15 } from "node:fs";
-import { rename as rename16, writeFile as writeFile42 } from "node:fs/promises";
+import { rename as rename16, writeFile as writeFile43 } from "node:fs/promises";
 import { homedir as homedir54 } from "node:os";
-import { basename as basename34, join as join165 } from "node:path";
+import { basename as basename34, join as join167 } from "node:path";
 function getCachedContext(repoPath) {
   const cachePath = getCacheFilePath(repoPath);
   if (!existsSync83(cachePath))
@@ -78263,7 +78354,7 @@ async function saveCachedContext(repoPath, cache5) {
   }
   const cachePath = getCacheFilePath(repoPath);
   const tmpPath = `${cachePath}.tmp`;
-  await writeFile42(tmpPath, JSON.stringify(cache5, null, 2), "utf-8");
+  await writeFile43(tmpPath, JSON.stringify(cache5, null, 2), "utf-8");
   await rename16(tmpPath, cachePath);
 }
 function computeSourceHash(repoPath) {
@@ -78281,25 +78372,25 @@ function computeSourceHash(repoPath) {
 }
 function getDocSourcePaths(repoPath) {
   const paths = [];
-  const docsDir = join165(repoPath, "docs");
+  const docsDir = join167(repoPath, "docs");
   if (existsSync83(docsDir)) {
     try {
       const files = readdirSync14(docsDir);
       for (const f3 of files) {
         if (f3.endsWith(".md"))
-          paths.push(join165(docsDir, f3));
+          paths.push(join167(docsDir, f3));
       }
     } catch {}
   }
-  const readme = join165(repoPath, "README.md");
+  const readme = join167(repoPath, "README.md");
   if (existsSync83(readme))
     paths.push(readme);
-  const stylesDir = join165(repoPath, "assets", "writing-styles");
+  const stylesDir = join167(repoPath, "assets", "writing-styles");
   if (existsSync83(stylesDir)) {
     try {
       const files = readdirSync14(stylesDir);
       for (const f3 of files) {
-        paths.push(join165(stylesDir, f3));
+        paths.push(join167(stylesDir, f3));
       }
     } catch {}
   }
@@ -78308,11 +78399,11 @@ function getDocSourcePaths(repoPath) {
 function getCacheFilePath(repoPath) {
   const repoName = basename34(repoPath).replace(/[^a-zA-Z0-9_-]/g, "_");
   const pathHash = createHash9("sha256").update(repoPath).digest("hex").slice(0, 8);
-  return join165(CACHE_DIR, `${repoName}-${pathHash}-context-cache.json`);
+  return join167(CACHE_DIR, `${repoName}-${pathHash}-context-cache.json`);
 }
 var CACHE_DIR, CACHE_TTL_MS5;
 var init_context_cache_manager = __esm(() => {
-  CACHE_DIR = join165(homedir54(), ".claudekit", "cache");
+  CACHE_DIR = join167(homedir54(), ".claudekit", "cache");
   CACHE_TTL_MS5 = 24 * 60 * 60 * 1000;
 });
 
@@ -78493,7 +78584,7 @@ function extractContentFromResponse(response) {
 // src/commands/content/phases/docs-summarizer.ts
 import { execSync as execSync7 } from "node:child_process";
 import { existsSync as existsSync84, readFileSync as readFileSync23, readdirSync as readdirSync15 } from "node:fs";
-import { join as join166 } from "node:path";
+import { join as join168 } from "node:path";
 async function summarizeProjectDocs(repoPath, contentLogger) {
   const rawContent = collectRawDocs(repoPath);
   if (rawContent.total.length < 200) {
@@ -78547,12 +78638,12 @@ function collectRawDocs(repoPath) {
     return capped;
   };
   const docsContent = [];
-  const docsDir = join166(repoPath, "docs");
+  const docsDir = join168(repoPath, "docs");
   if (existsSync84(docsDir)) {
     try {
       const files = readdirSync15(docsDir).filter((f3) => f3.endsWith(".md")).sort();
       for (const f3 of files) {
-        const content = readCapped(join166(docsDir, f3), 5000);
+        const content = readCapped(join168(docsDir, f3), 5000);
         if (content) {
           docsContent.push(`### ${f3}
 ${content}`);
@@ -78566,21 +78657,21 @@ ${content}`);
   let brand = "";
   const brandCandidates = ["docs/brand-guidelines.md", "docs/design-guidelines.md"];
   for (const p of brandCandidates) {
-    brand = readCapped(join166(repoPath, p), 3000);
+    brand = readCapped(join168(repoPath, p), 3000);
     if (brand)
       break;
   }
   let styles3 = "";
-  const stylesDir = join166(repoPath, "assets", "writing-styles");
+  const stylesDir = join168(repoPath, "assets", "writing-styles");
   if (existsSync84(stylesDir)) {
     try {
       const files = readdirSync15(stylesDir).slice(0, 3);
-      styles3 = files.map((f3) => readCapped(join166(stylesDir, f3), 1000)).filter(Boolean).join(`
+      styles3 = files.map((f3) => readCapped(join168(stylesDir, f3), 1000)).filter(Boolean).join(`
 
 `);
     } catch {}
   }
-  const readme = readCapped(join166(repoPath, "README.md"), 3000);
+  const readme = readCapped(join168(repoPath, "README.md"), 3000);
   const total = [docs, brand, styles3, readme].join(`
 `);
   return { docs, brand, styles: styles3, readme, total };
@@ -78767,9 +78858,9 @@ IMPORTANT: Generate the image and output the path as JSON: {"imagePath": "/path/
 import { execSync as execSync8 } from "node:child_process";
 import { existsSync as existsSync85, mkdirSync as mkdirSync8, readdirSync as readdirSync16 } from "node:fs";
 import { homedir as homedir55 } from "node:os";
-import { join as join167 } from "node:path";
+import { join as join169 } from "node:path";
 async function generatePhoto(_content, context, config, platform18, contentId, contentLogger) {
-  const mediaDir = join167(config.contentDir.replace(/^~/, homedir55()), "media", String(contentId));
+  const mediaDir = join169(config.contentDir.replace(/^~/, homedir55()), "media", String(contentId));
   if (!existsSync85(mediaDir)) {
     mkdirSync8(mediaDir, { recursive: true });
   }
@@ -78794,7 +78885,7 @@ async function generatePhoto(_content, context, config, platform18, contentId, c
     const imageFile = files.find((f3) => /\.(png|jpg|jpeg|webp)$/i.test(f3));
     if (imageFile) {
       const ext2 = imageFile.split(".").pop() ?? "png";
-      return { path: join167(mediaDir, imageFile), ...dimensions, format: ext2 };
+      return { path: join169(mediaDir, imageFile), ...dimensions, format: ext2 };
     }
     contentLogger.warn(`Photo generation produced no image for content ${contentId}`);
     return null;
@@ -78884,7 +78975,7 @@ var init_content_creator = __esm(() => {
 // src/commands/content/phases/content-logger.ts
 import { createWriteStream as createWriteStream4, existsSync as existsSync86, mkdirSync as mkdirSync9, statSync as statSync16 } from "node:fs";
 import { homedir as homedir56 } from "node:os";
-import { join as join168 } from "node:path";
+import { join as join170 } from "node:path";
 
 class ContentLogger {
   stream = null;
@@ -78892,7 +78983,7 @@ class ContentLogger {
   logDir;
   maxBytes;
   constructor(maxBytes = 0) {
-    this.logDir = join168(homedir56(), ".claudekit", "logs");
+    this.logDir = join170(homedir56(), ".claudekit", "logs");
     this.maxBytes = maxBytes;
   }
   init() {
@@ -78924,7 +79015,7 @@ class ContentLogger {
     }
   }
   getLogPath() {
-    return join168(this.logDir, `content-${this.getDateStr()}.log`);
+    return join170(this.logDir, `content-${this.getDateStr()}.log`);
   }
   write(level, message) {
     this.rotateIfNeeded();
@@ -78941,18 +79032,18 @@ class ContentLogger {
     if (dateStr !== this.currentDate) {
       this.close();
       this.currentDate = dateStr;
-      const logPath = join168(this.logDir, `content-${dateStr}.log`);
+      const logPath = join170(this.logDir, `content-${dateStr}.log`);
       this.stream = createWriteStream4(logPath, { flags: "a", mode: 384 });
       return;
     }
     if (this.maxBytes > 0 && this.stream) {
-      const logPath = join168(this.logDir, `content-${this.currentDate}.log`);
+      const logPath = join170(this.logDir, `content-${this.currentDate}.log`);
       try {
         const stat26 = statSync16(logPath);
         if (stat26.size >= this.maxBytes) {
           this.close();
           const suffix = Date.now();
-          const rotatedPath = join168(this.logDir, `content-${this.currentDate}-${suffix}.log`);
+          const rotatedPath = join170(this.logDir, `content-${this.currentDate}-${suffix}.log`);
           import("node:fs/promises").then(({ rename: rename17 }) => rename17(logPath, rotatedPath).catch(() => {}));
           this.stream = createWriteStream4(logPath, { flags: "w", mode: 384 });
         }
@@ -79223,7 +79314,7 @@ function isNoiseCommit(title, author) {
 // src/commands/content/phases/change-detector.ts
 import { execSync as execSync10, spawnSync as spawnSync9 } from "node:child_process";
 import { existsSync as existsSync88, readFileSync as readFileSync24, readdirSync as readdirSync17, statSync as statSync17 } from "node:fs";
-import { join as join169 } from "node:path";
+import { join as join171 } from "node:path";
 function detectCommits(repo, since) {
   try {
     const fetchUrl = sshToHttps(repo.remoteUrl);
@@ -79332,7 +79423,7 @@ function detectTags(repo, since) {
   }
 }
 function detectCompletedPlans(repo, since) {
-  const plansDir = join169(repo.path, "plans");
+  const plansDir = join171(repo.path, "plans");
   if (!existsSync88(plansDir))
     return [];
   const sinceMs = new Date(since).getTime();
@@ -79342,7 +79433,7 @@ function detectCompletedPlans(repo, since) {
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
-      const planFile = join169(plansDir, entry.name, "plan.md");
+      const planFile = join171(plansDir, entry.name, "plan.md");
       if (!existsSync88(planFile))
         continue;
       try {
@@ -79420,7 +79511,7 @@ function classifyCommit(event) {
 // src/commands/content/phases/repo-discoverer.ts
 import { execSync as execSync11 } from "node:child_process";
 import { readdirSync as readdirSync18 } from "node:fs";
-import { join as join170 } from "node:path";
+import { join as join172 } from "node:path";
 function discoverRepos2(cwd2) {
   const repos = [];
   if (isGitRepoRoot(cwd2)) {
@@ -79433,7 +79524,7 @@ function discoverRepos2(cwd2) {
     for (const entry of entries) {
       if (!entry.isDirectory() || entry.name.startsWith("."))
         continue;
-      const dirPath = join170(cwd2, entry.name);
+      const dirPath = join172(cwd2, entry.name);
       if (isGitRepoRoot(dirPath)) {
         const info = getRepoInfo(dirPath);
         if (info)
@@ -80100,12 +80191,12 @@ var init_types6 = __esm(() => {
 });
 
 // src/commands/content/phases/state-manager.ts
-import { readFile as readFile71, rename as rename17, writeFile as writeFile43 } from "node:fs/promises";
-import { join as join171 } from "node:path";
+import { readFile as readFile72, rename as rename17, writeFile as writeFile44 } from "node:fs/promises";
+import { join as join173 } from "node:path";
 async function loadContentConfig(projectDir) {
-  const configPath = join171(projectDir, CK_CONFIG_FILE2);
+  const configPath = join173(projectDir, CK_CONFIG_FILE2);
   try {
-    const raw2 = await readFile71(configPath, "utf-8");
+    const raw2 = await readFile72(configPath, "utf-8");
     const json = JSON.parse(raw2);
     return ContentConfigSchema.parse(json.content ?? {});
   } catch {
@@ -80113,15 +80204,15 @@ async function loadContentConfig(projectDir) {
   }
 }
 async function saveContentConfig(projectDir, config) {
-  const configPath = join171(projectDir, CK_CONFIG_FILE2);
+  const configPath = join173(projectDir, CK_CONFIG_FILE2);
   const json = await readJsonSafe4(configPath);
   json.content = { ...json.content, ...config };
   await atomicWrite3(configPath, json);
 }
 async function loadContentState(projectDir) {
-  const configPath = join171(projectDir, CK_CONFIG_FILE2);
+  const configPath = join173(projectDir, CK_CONFIG_FILE2);
   try {
-    const raw2 = await readFile71(configPath, "utf-8");
+    const raw2 = await readFile72(configPath, "utf-8");
     const json = JSON.parse(raw2);
     const contentBlock = json.content ?? {};
     return ContentStateSchema.parse(contentBlock.state ?? {});
@@ -80130,7 +80221,7 @@ async function loadContentState(projectDir) {
   }
 }
 async function saveContentState(projectDir, state) {
-  const configPath = join171(projectDir, CK_CONFIG_FILE2);
+  const configPath = join173(projectDir, CK_CONFIG_FILE2);
   const sevenDaysAgo = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString().slice(0, 10);
   for (const key of Object.keys(state.dailyPostCounts)) {
     const dateStr = key.slice(-10);
@@ -80148,7 +80239,7 @@ async function saveContentState(projectDir, state) {
 }
 async function readJsonSafe4(filePath) {
   try {
-    const raw2 = await readFile71(filePath, "utf-8");
+    const raw2 = await readFile72(filePath, "utf-8");
     return JSON.parse(raw2);
   } catch {
     return {};
@@ -80156,7 +80247,7 @@ async function readJsonSafe4(filePath) {
 }
 async function atomicWrite3(filePath, data) {
   const tmpPath = `${filePath}.tmp`;
-  await writeFile43(tmpPath, JSON.stringify(data, null, 2), "utf-8");
+  await writeFile44(tmpPath, JSON.stringify(data, null, 2), "utf-8");
   await rename17(tmpPath, filePath);
 }
 var CK_CONFIG_FILE2 = ".ck.json";
@@ -80412,7 +80503,7 @@ var init_platform_setup_x = __esm(() => {
 
 // src/commands/content/phases/setup-wizard.ts
 import { existsSync as existsSync89 } from "node:fs";
-import { join as join172 } from "node:path";
+import { join as join174 } from "node:path";
 async function runSetupWizard2(cwd2, contentLogger) {
   console.log();
   oe(import_picocolors43.default.bgCyan(import_picocolors43.default.white(" CK Content — Multi-Channel Content Engine ")));
@@ -80480,8 +80571,8 @@ async function showRepoSummary(cwd2) {
 function detectBrandAssets(cwd2, contentLogger) {
   const repos = discoverRepos2(cwd2);
   for (const repo of repos) {
-    const hasGuidelines = existsSync89(join172(repo.path, "docs", "brand-guidelines.md"));
-    const hasStyles = existsSync89(join172(repo.path, "assets", "writing-styles"));
+    const hasGuidelines = existsSync89(join174(repo.path, "docs", "brand-guidelines.md"));
+    const hasStyles = existsSync89(join174(repo.path, "assets", "writing-styles"));
     if (!hasGuidelines) {
       f2.warning(`${repo.name}: No docs/brand-guidelines.md — content will use generic tone.`);
       contentLogger.warn(`${repo.name}: missing docs/brand-guidelines.md`);
@@ -80623,9 +80714,9 @@ __export(exports_content_subcommands, {
 });
 import { existsSync as existsSync91, readFileSync as readFileSync25, unlinkSync as unlinkSync6 } from "node:fs";
 import { homedir as homedir58 } from "node:os";
-import { join as join173 } from "node:path";
+import { join as join175 } from "node:path";
 function isDaemonRunning() {
-  const lockFile = join173(LOCK_DIR, `${LOCK_NAME2}.lock`);
+  const lockFile = join175(LOCK_DIR, `${LOCK_NAME2}.lock`);
   if (!existsSync91(lockFile))
     return { running: false, pid: null };
   try {
@@ -80657,7 +80748,7 @@ async function startContent(options2) {
   await contentCommand(options2);
 }
 async function stopContent() {
-  const lockFile = join173(LOCK_DIR, `${LOCK_NAME2}.lock`);
+  const lockFile = join175(LOCK_DIR, `${LOCK_NAME2}.lock`);
   if (!existsSync91(lockFile)) {
     logger.info("Content daemon is not running.");
     return;
@@ -80696,9 +80787,9 @@ async function statusContent() {
   } catch {}
 }
 async function logsContent(options2) {
-  const logDir = join173(homedir58(), ".claudekit", "logs");
+  const logDir = join175(homedir58(), ".claudekit", "logs");
   const dateStr = new Date().toISOString().slice(0, 10).replace(/-/g, "");
-  const logPath = join173(logDir, `content-${dateStr}.log`);
+  const logPath = join175(logDir, `content-${dateStr}.log`);
   if (!existsSync91(logPath)) {
     logger.info("No content logs found for today.");
     return;
@@ -80730,13 +80821,13 @@ var init_content_subcommands = __esm(() => {
   init_setup_wizard();
   init_state_manager();
   init_content_review_commands();
-  LOCK_DIR = join173(homedir58(), ".claudekit", "locks");
+  LOCK_DIR = join175(homedir58(), ".claudekit", "locks");
 });
 
 // src/commands/content/content-command.ts
 import { existsSync as existsSync92, mkdirSync as mkdirSync11, unlinkSync as unlinkSync7, writeFileSync as writeFileSync9 } from "node:fs";
 import { homedir as homedir59 } from "node:os";
-import { join as join174 } from "node:path";
+import { join as join176 } from "node:path";
 async function contentCommand(options2) {
   const cwd2 = process.cwd();
   const contentLogger = new ContentLogger;
@@ -80914,8 +81005,8 @@ var init_content_command = __esm(() => {
   init_publisher();
   init_review_manager();
   init_state_manager();
-  LOCK_DIR2 = join174(homedir59(), ".claudekit", "locks");
-  LOCK_FILE = join174(LOCK_DIR2, "ck-content.lock");
+  LOCK_DIR2 = join176(homedir59(), ".claudekit", "locks");
+  LOCK_FILE = join176(LOCK_DIR2, "ck-content.lock");
 });
 
 // src/commands/content/index.ts
@@ -94159,7 +94250,7 @@ async function getLatestVersion(kit, includePrereleases = false) {
 init_logger();
 init_path_resolver();
 init_safe_prompts();
-import { join as join96 } from "node:path";
+import { join as join97 } from "node:path";
 async function promptUpdateMode() {
   const updateEverything = await se({
     message: "Do you want to update everything?"
@@ -94201,7 +94292,7 @@ async function promptDirectorySelection(global3 = false) {
   return selectedCategories;
 }
 async function promptFreshConfirmation(targetPath, analysis) {
-  const backupRoot = join96(PathResolver.getConfigDir(false), "backups");
+  const backupRoot = join97(PathResolver.getConfigDir(false), "backups");
   logger.warning("[!] Fresh installation will remove ClaudeKit files:");
   logger.info(`Path: ${targetPath}`);
   logger.info(`Recovery backup: ${backupRoot}`);
@@ -94371,12 +94462,12 @@ class PromptsManager {
   }
   async promptPackageInstallations() {
     log.step("Optional Package Installations");
-    const [openCodeInstalled, geminiInstalled] = await Promise.all([
+    const [openCodeInstalled, agyInstalled] = await Promise.all([
       isOpenCodeInstalled(),
-      isGeminiInstalled()
+      isAgyInstalled()
     ]);
     let installOpenCode2 = false;
-    let installGemini2 = false;
+    let installAgy2 = false;
     if (openCodeInstalled) {
       logger.success("OpenCode CLI is already installed");
     } else {
@@ -94388,20 +94479,20 @@ class PromptsManager {
       }
       installOpenCode2 = shouldInstallOpenCode;
     }
-    if (geminiInstalled) {
-      logger.success("Google Gemini CLI is already installed");
+    if (agyInstalled) {
+      logger.success("Antigravity CLI (agy) is already installed");
     } else {
-      const shouldInstallGemini = await se({
-        message: "Install Google Gemini CLI for AI-powered assistance? (Optional additional AI capabilities)"
+      const shouldInstallAgy = await se({
+        message: "Install Antigravity CLI (agy) for AI-powered assistance? (Optional additional AI capabilities)"
       });
-      if (lD(shouldInstallGemini)) {
+      if (lD(shouldInstallAgy)) {
         throw new Error("Package installation cancelled");
       }
-      installGemini2 = shouldInstallGemini;
+      installAgy2 = shouldInstallAgy;
     }
     return {
       installOpenCode: installOpenCode2,
-      installGemini: installGemini2
+      installAgy: installAgy2
     };
   }
   async promptSkillsInstallation() {
@@ -94417,11 +94508,11 @@ class PromptsManager {
         failedInstalls.push(`${results.opencode.package}: ${results.opencode.error || "Installation failed"}`);
       }
     }
-    if (results.gemini) {
-      if (results.gemini.success) {
-        successfulInstalls.push(`${results.gemini.package}${results.gemini.version ? ` v${results.gemini.version}` : ""}`);
+    if (results.agy) {
+      if (results.agy.success) {
+        successfulInstalls.push(`${results.agy.package}${results.agy.version ? ` v${results.agy.version}` : ""}`);
       } else {
-        failedInstalls.push(`${results.gemini.package}: ${results.gemini.error || "Installation failed"}`);
+        failedInstalls.push(`${results.agy.package}: ${results.agy.error || "Installation failed"}`);
       }
     }
     if (successfulInstalls.length > 0) {
@@ -94429,7 +94520,7 @@ class PromptsManager {
     }
     if (failedInstalls.length > 0) {
       logger.warning(`Failed to install: ${failedInstalls.join(", ")}`);
-      logger.info("You can install these manually later using npm install -g <package>");
+      logger.info("You can install these manually later from each tool's official install guide.");
     }
   }
   async promptFreshConfirmation(targetPath, analysis) {
@@ -94478,7 +94569,7 @@ init_logger();
 init_logger();
 init_path_resolver();
 var import_fs_extra10 = __toESM(require_lib(), 1);
-import { join as join97 } from "node:path";
+import { join as join98 } from "node:path";
 async function handleConflicts(ctx) {
   if (ctx.cancelled)
     return ctx;
@@ -94487,7 +94578,7 @@ async function handleConflicts(ctx) {
   if (PathResolver.isLocalSameAsGlobal()) {
     return ctx;
   }
-  const localSettingsPath = join97(process.cwd(), ".claude", "settings.json");
+  const localSettingsPath = join98(process.cwd(), ".claude", "settings.json");
   if (!await import_fs_extra10.pathExists(localSettingsPath)) {
     return ctx;
   }
@@ -94502,7 +94593,7 @@ async function handleConflicts(ctx) {
     return { ...ctx, cancelled: true };
   }
   if (choice === "remove") {
-    const localClaudeDir = join97(process.cwd(), ".claude");
+    const localClaudeDir = join98(process.cwd(), ".claude");
     try {
       await import_fs_extra10.remove(localClaudeDir);
       logger.success("Removed local .claude/ directory");
@@ -94599,7 +94690,7 @@ init_logger();
 init_safe_spinner();
 import { mkdir as mkdir30, stat as stat17 } from "node:fs/promises";
 import { tmpdir as tmpdir4 } from "node:os";
-import { join as join104 } from "node:path";
+import { join as join105 } from "node:path";
 
 // src/shared/temp-cleanup.ts
 init_logger();
@@ -94618,7 +94709,7 @@ init_logger();
 init_output_manager();
 import { createWriteStream as createWriteStream2, rmSync } from "node:fs";
 import { mkdir as mkdir25 } from "node:fs/promises";
-import { join as join98 } from "node:path";
+import { join as join99 } from "node:path";
 
 // src/shared/progress-bar.ts
 init_output_manager();
@@ -94828,7 +94919,7 @@ var MAX_DOWNLOAD_SIZE = 500 * 1024 * 1024;
 class FileDownloader {
   async downloadAsset(asset, destDir) {
     try {
-      const destPath = join98(destDir, asset.name);
+      const destPath = join99(destDir, asset.name);
       await mkdir25(destDir, { recursive: true });
       output.info(`Downloading ${asset.name} (${formatBytes2(asset.size)})...`);
       logger.verbose("Download details", {
@@ -94913,7 +95004,7 @@ class FileDownloader {
   }
   async downloadFile(params) {
     const { url, name, size, destDir, token } = params;
-    const destPath = join98(destDir, name);
+    const destPath = join99(destDir, name);
     await mkdir25(destDir, { recursive: true });
     output.info(`Downloading ${name}${size ? ` (${formatBytes2(size)})` : ""}...`);
     const headers = {};
@@ -94999,7 +95090,7 @@ init_logger();
 init_types3();
 import { constants as constants4 } from "node:fs";
 import { access as access5, readdir as readdir23 } from "node:fs/promises";
-import { join as join99 } from "node:path";
+import { join as join100 } from "node:path";
 async function pathExists11(path8) {
   try {
     await access5(path8, constants4.F_OK);
@@ -95018,7 +95109,7 @@ async function validateExtraction(extractDir) {
     const criticalPaths = [".claude"];
     const missingPaths = [];
     for (const path8 of criticalPaths) {
-      if (await pathExists11(join99(extractDir, path8))) {
+      if (await pathExists11(join100(extractDir, path8))) {
         logger.debug(`Found: ${path8}`);
         continue;
       }
@@ -95028,7 +95119,7 @@ async function validateExtraction(extractDir) {
     const guidancePaths = ["CLAUDE.md", ".claude/CLAUDE.md", ".claude/rules/CLAUDE.md"];
     let guidancePath = null;
     for (const path8 of guidancePaths) {
-      if (await pathExists11(join99(extractDir, path8))) {
+      if (await pathExists11(join100(extractDir, path8))) {
         guidancePath = path8;
         break;
       }
@@ -95053,7 +95144,7 @@ async function validateExtraction(extractDir) {
 // src/domains/installation/extraction/tar-extractor.ts
 init_logger();
 import { copyFile as copyFile4, mkdir as mkdir28, readdir as readdir25, rm as rm11, stat as stat15 } from "node:fs/promises";
-import { join as join102 } from "node:path";
+import { join as join103 } from "node:path";
 
 // node_modules/@isaacs/fs-minipass/dist/esm/index.js
 import EE from "events";
@@ -100815,7 +100906,7 @@ var mkdirSync4 = (dir, opt) => {
 };
 
 // node_modules/tar/dist/esm/path-reservations.js
-import { join as join100 } from "node:path";
+import { join as join101 } from "node:path";
 
 // node_modules/tar/dist/esm/normalize-unicode.js
 var normalizeCache = Object.create(null);
@@ -100848,7 +100939,7 @@ var getDirs = (path13) => {
   const dirs = path13.split("/").slice(0, -1).reduce((set, path14) => {
     const s = set[set.length - 1];
     if (s !== undefined) {
-      path14 = join100(s, path14);
+      path14 = join101(s, path14);
     }
     set.push(path14 || "/");
     return set;
@@ -100862,7 +100953,7 @@ class PathReservations {
   #running = new Set;
   reserve(paths, fn) {
     paths = isWindows4 ? ["win32 parallelization disabled"] : paths.map((p) => {
-      return stripTrailingSlashes(join100(normalizeUnicode(p))).toLowerCase();
+      return stripTrailingSlashes(join101(normalizeUnicode(p))).toLowerCase();
     });
     const dirs = new Set(paths.map((path13) => getDirs(path13)).reduce((a3, b3) => a3.concat(b3)));
     this.#reservations.set(fn, { dirs, paths });
@@ -101922,7 +102013,7 @@ function decodeFilePath(path15) {
 init_logger();
 init_types3();
 import { copyFile as copyFile3, lstat as lstat7, mkdir as mkdir27, readdir as readdir24 } from "node:fs/promises";
-import { join as join101, relative as relative20 } from "node:path";
+import { join as join102, relative as relative20 } from "node:path";
 async function withRetry(fn, retries = 3) {
   for (let i = 0;i < retries; i++) {
     try {
@@ -101944,8 +102035,8 @@ async function moveDirectoryContents(sourceDir, destDir, shouldExclude, sizeTrac
   await mkdir27(destDir, { recursive: true });
   const entries = await readdir24(sourceDir, { encoding: "utf8" });
   for (const entry of entries) {
-    const sourcePath = join101(sourceDir, entry);
-    const destPath = join101(destDir, entry);
+    const sourcePath = join102(sourceDir, entry);
+    const destPath = join102(destDir, entry);
     const relativePath = relative20(sourceDir, sourcePath);
     if (!isPathSafe(destDir, destPath)) {
       logger.warning(`Skipping unsafe path: ${relativePath}`);
@@ -101972,8 +102063,8 @@ async function copyDirectory(sourceDir, destDir, shouldExclude, sizeTracker) {
   await mkdir27(destDir, { recursive: true });
   const entries = await readdir24(sourceDir, { encoding: "utf8" });
   for (const entry of entries) {
-    const sourcePath = join101(sourceDir, entry);
-    const destPath = join101(destDir, entry);
+    const sourcePath = join102(sourceDir, entry);
+    const destPath = join102(destDir, entry);
     const relativePath = relative20(sourceDir, sourcePath);
     if (!isPathSafe(destDir, destPath)) {
       logger.warning(`Skipping unsafe path: ${relativePath}`);
@@ -102021,7 +102112,7 @@ class TarExtractor {
       logger.debug(`Root entries: ${entries.join(", ")}`);
       if (entries.length === 1) {
         const rootEntry = entries[0];
-        const rootPath = join102(tempExtractDir, rootEntry);
+        const rootPath = join103(tempExtractDir, rootEntry);
         const rootStat = await stat15(rootPath);
         if (rootStat.isDirectory()) {
           const rootContents = await readdir25(rootPath, { encoding: "utf8" });
@@ -102037,7 +102128,7 @@ class TarExtractor {
           }
         } else {
           await mkdir28(destDir, { recursive: true });
-          await copyFile4(rootPath, join102(destDir, rootEntry));
+          await copyFile4(rootPath, join103(destDir, rootEntry));
         }
       } else {
         logger.debug("Multiple root entries - moving all");
@@ -102059,7 +102150,7 @@ init_logger();
 var import_extract_zip = __toESM(require_extract_zip(), 1);
 import { execFile as execFile11 } from "node:child_process";
 import { copyFile as copyFile5, mkdir as mkdir29, readdir as readdir26, rm as rm12, stat as stat16 } from "node:fs/promises";
-import { join as join103 } from "node:path";
+import { join as join104 } from "node:path";
 import { promisify as promisify16 } from "node:util";
 
 // src/domains/installation/extraction/native-zip-commands.ts
@@ -102151,7 +102242,7 @@ class ZipExtractor {
       logger.debug(`Root entries: ${entries.join(", ")}`);
       if (entries.length === 1) {
         const rootEntry = entries[0];
-        const rootPath = join103(tempExtractDir, rootEntry);
+        const rootPath = join104(tempExtractDir, rootEntry);
         const rootStat = await stat16(rootPath);
         if (rootStat.isDirectory()) {
           const rootContents = await readdir26(rootPath, { encoding: "utf8" });
@@ -102167,7 +102258,7 @@ class ZipExtractor {
           }
         } else {
           await mkdir29(destDir, { recursive: true });
-          await copyFile5(rootPath, join103(destDir, rootEntry));
+          await copyFile5(rootPath, join104(destDir, rootEntry));
         }
       } else {
         logger.debug("Multiple root entries - moving all");
@@ -102268,7 +102359,7 @@ class DownloadManager {
   async createTempDir() {
     const timestamp = Date.now();
     const counter = DownloadManager.tempDirCounter++;
-    const primaryTempDir = join104(tmpdir4(), `claudekit-${timestamp}-${counter}`);
+    const primaryTempDir = join105(tmpdir4(), `claudekit-${timestamp}-${counter}`);
     try {
       await mkdir30(primaryTempDir, { recursive: true });
       logger.debug(`Created temp directory: ${primaryTempDir}`);
@@ -102285,7 +102376,7 @@ Solutions:
   2. Set HOME environment variable
   3. Try running from a different directory`);
       }
-      const fallbackTempDir = join104(homeDir, ".claudekit", "tmp", `claudekit-${timestamp}-${counter}`);
+      const fallbackTempDir = join105(homeDir, ".claudekit", "tmp", `claudekit-${timestamp}-${counter}`);
       try {
         await mkdir30(fallbackTempDir, { recursive: true });
         logger.debug(`Created temp directory (fallback): ${fallbackTempDir}`);
@@ -102745,20 +102836,20 @@ async function handleDownload(ctx) {
   };
 }
 // src/commands/init/phases/merge-handler.ts
-import { join as join122 } from "node:path";
+import { join as join123 } from "node:path";
 
 // src/domains/installation/deletion-handler.ts
 import { existsSync as existsSync66, lstatSync as lstatSync3, readdirSync as readdirSync10, rmSync as rmSync2, rmdirSync, unlinkSync as unlinkSync4 } from "node:fs";
-import { dirname as dirname38, join as join107, relative as relative21, resolve as resolve42, sep as sep11 } from "node:path";
+import { dirname as dirname38, join as join108, relative as relative21, resolve as resolve42, sep as sep12 } from "node:path";
 
 // src/services/file-operations/manifest/manifest-reader.ts
 init_metadata_migration();
 init_logger();
 init_types3();
 var import_fs_extra11 = __toESM(require_lib(), 1);
-import { join as join106 } from "node:path";
+import { join as join107 } from "node:path";
 async function readManifest(claudeDir3) {
-  const metadataPath = join106(claudeDir3, "metadata.json");
+  const metadataPath = join107(claudeDir3, "metadata.json");
   if (!await import_fs_extra11.pathExists(metadataPath)) {
     return null;
   }
@@ -102944,7 +103035,7 @@ function collectFilesRecursively(dir, baseDir) {
   try {
     const entries = readdirSync10(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join107(dir, entry.name);
+      const fullPath = join108(dir, entry.name);
       const relativePath = relative21(baseDir, fullPath);
       if (entry.isDirectory()) {
         results.push(...collectFilesRecursively(fullPath, baseDir));
@@ -102996,7 +103087,7 @@ function cleanupEmptyDirectories(filePath, claudeDir3) {
 function deletePath(fullPath, claudeDir3) {
   const normalizedPath = resolve42(fullPath);
   const normalizedClaudeDir = resolve42(claudeDir3);
-  if (!normalizedPath.startsWith(`${normalizedClaudeDir}${sep11}`) && normalizedPath !== normalizedClaudeDir) {
+  if (!normalizedPath.startsWith(`${normalizedClaudeDir}${sep12}`) && normalizedPath !== normalizedClaudeDir) {
     throw new Error(`Path traversal detected: ${fullPath}`);
   }
   try {
@@ -103012,7 +103103,7 @@ function deletePath(fullPath, claudeDir3) {
   }
 }
 async function updateMetadataAfterDeletion(claudeDir3, deletedPaths) {
-  const metadataPath = join107(claudeDir3, "metadata.json");
+  const metadataPath = join108(claudeDir3, "metadata.json");
   if (!await import_fs_extra12.pathExists(metadataPath)) {
     return;
   }
@@ -103067,10 +103158,10 @@ async function handleDeletions(sourceMetadata, claudeDir3, kitType) {
   const userMetadata = await readManifest(claudeDir3);
   const result = { deletedPaths: [], preservedPaths: [], errors: [] };
   for (const path16 of deletions) {
-    const fullPath = join107(claudeDir3, path16);
+    const fullPath = join108(claudeDir3, path16);
     const normalizedPath = resolve42(fullPath);
     const normalizedClaudeDir = resolve42(claudeDir3);
-    if (!normalizedPath.startsWith(`${normalizedClaudeDir}${sep11}`)) {
+    if (!normalizedPath.startsWith(`${normalizedClaudeDir}${sep12}`)) {
       logger.warning(`Skipping invalid path: ${path16}`);
       result.errors.push(path16);
       continue;
@@ -103107,7 +103198,7 @@ init_logger();
 init_types3();
 var import_fs_extra16 = __toESM(require_lib(), 1);
 var import_ignore3 = __toESM(require_ignore(), 1);
-import { dirname as dirname42, join as join112, relative as relative24 } from "node:path";
+import { dirname as dirname42, join as join113, relative as relative24 } from "node:path";
 
 // src/domains/installation/selective-merger.ts
 import { stat as stat18 } from "node:fs/promises";
@@ -103283,7 +103374,7 @@ class SelectiveMerger {
 
 // src/domains/installation/merger/deleted-skill-preservation.ts
 init_metadata_migration();
-import { dirname as dirname39, join as join108, relative as relative22 } from "node:path";
+import { dirname as dirname39, join as join109, relative as relative22 } from "node:path";
 var import_fs_extra13 = __toESM(require_lib(), 1);
 async function findIgnoredSkillDirectories({
   files,
@@ -103311,7 +103402,7 @@ async function findIgnoredSkillDirectories({
     return root ? [root] : [];
   }));
   for (const [metadataRoot, sourceRoot] of sourceSkillRoots) {
-    const destSkillRoot = join108(destDir, ...sourceRoot.split("/"));
+    const destSkillRoot = join109(destDir, ...sourceRoot.split("/"));
     const skillExists = await import_fs_extra13.pathExists(destSkillRoot);
     if (existingIgnoredRoots.has(metadataRoot) || !skillExists && previouslyTrackedRoots.has(metadataRoot)) {
       ignoredSkillDirectories.add(metadataRoot);
@@ -103361,7 +103452,7 @@ init_logger();
 var import_fs_extra14 = __toESM(require_lib(), 1);
 var import_ignore2 = __toESM(require_ignore(), 1);
 import { relative as relative23 } from "node:path";
-import { join as join109 } from "node:path";
+import { join as join110 } from "node:path";
 
 // node_modules/@isaacs/balanced-match/dist/esm/index.js
 var balanced = (a3, b3, str2) => {
@@ -104168,8 +104259,8 @@ var path16 = {
   win32: { sep: "\\" },
   posix: { sep: "/" }
 };
-var sep12 = defaultPlatform === "win32" ? path16.win32.sep : path16.posix.sep;
-minimatch.sep = sep12;
+var sep13 = defaultPlatform === "win32" ? path16.win32.sep : path16.posix.sep;
+minimatch.sep = sep13;
 var GLOBSTAR = Symbol("globstar **");
 minimatch.GLOBSTAR = GLOBSTAR;
 var qmark2 = "[^/]";
@@ -104817,7 +104908,7 @@ class FileScanner {
     const files = [];
     const entries = await import_fs_extra14.readdir(dir, { encoding: "utf8" });
     for (const entry of entries) {
-      const fullPath = join109(dir, entry);
+      const fullPath = join110(dir, entry);
       const relativePath = relative23(baseDir, fullPath);
       const normalizedRelativePath = relativePath.replace(/\\/g, "/");
       const stats = await import_fs_extra14.lstat(fullPath);
@@ -104853,13 +104944,13 @@ class FileScanner {
 // src/domains/installation/merger/settings-processor.ts
 import { execSync as execSync5 } from "node:child_process";
 import { homedir as homedir46 } from "node:os";
-import { dirname as dirname41, join as join111 } from "node:path";
+import { dirname as dirname41, join as join112 } from "node:path";
 
 // src/domains/config/installed-settings-tracker.ts
 init_shared();
 import { existsSync as existsSync67 } from "node:fs";
 import { mkdir as mkdir31, readFile as readFile52, writeFile as writeFile27 } from "node:fs/promises";
-import { dirname as dirname40, join as join110 } from "node:path";
+import { dirname as dirname40, join as join111 } from "node:path";
 var CK_JSON_FILE = ".ck.json";
 
 class InstalledSettingsTracker {
@@ -104873,9 +104964,9 @@ class InstalledSettingsTracker {
   }
   getCkJsonPath() {
     if (this.isGlobal) {
-      return join110(this.projectDir, CK_JSON_FILE);
+      return join111(this.projectDir, CK_JSON_FILE);
     }
-    return join110(this.projectDir, ".claude", CK_JSON_FILE);
+    return join111(this.projectDir, ".claude", CK_JSON_FILE);
   }
   async loadInstalledSettings() {
     const ckJsonPath = this.getCkJsonPath();
@@ -105143,10 +105234,10 @@ class SettingsProcessor {
     };
     try {
       if (this.isGlobal) {
-        await addFromConfig(join111(this.projectDir, ".ck.json"));
+        await addFromConfig(join112(this.projectDir, ".ck.json"));
       } else {
-        await addFromConfig(join111(PathResolver.getGlobalKitDir(), ".ck.json"));
-        await addFromConfig(join111(this.projectDir, ".claude", ".ck.json"));
+        await addFromConfig(join112(PathResolver.getGlobalKitDir(), ".ck.json"));
+        await addFromConfig(join112(this.projectDir, ".claude", ".ck.json"));
       }
     } catch (error) {
       logger.debug(`Failed to load .ck.json hook preferences: ${error instanceof Error ? error.message : "unknown"}`);
@@ -105533,7 +105624,7 @@ class SettingsProcessor {
       return false;
     }
     const configuredGlobalDir = PathResolver.getGlobalKitDir().replace(/\\/g, "/").replace(/\/+$/, "");
-    const defaultGlobalDir = join111(homedir46(), ".claude").replace(/\\/g, "/");
+    const defaultGlobalDir = join112(homedir46(), ".claude").replace(/\\/g, "/");
     return configuredGlobalDir !== defaultGlobalDir;
   }
   getClaudeCommandRoot() {
@@ -105553,7 +105644,7 @@ class SettingsProcessor {
     return true;
   }
   async repairSiblingSettingsLocal(destFile) {
-    const settingsLocalPath = join111(dirname41(destFile), "settings.local.json");
+    const settingsLocalPath = join112(dirname41(destFile), "settings.local.json");
     if (settingsLocalPath === destFile || !await import_fs_extra15.pathExists(settingsLocalPath)) {
       return;
     }
@@ -105650,7 +105741,7 @@ class SettingsProcessor {
     }
   }
   async dynamicTeamHookHandlerExists(destFile, handler) {
-    return import_fs_extra15.pathExists(join111(dirname41(destFile), "hooks", handler));
+    return import_fs_extra15.pathExists(join112(dirname41(destFile), "hooks", handler));
   }
   removeDynamicTeamHookRegistrations(settings) {
     let removed = 0;
@@ -105791,7 +105882,7 @@ class CopyExecutor {
     for (const file of files) {
       const relativePath = relative24(sourceDir, file);
       const normalizedRelativePath = relativePath.replace(/\\/g, "/");
-      const destPath = join112(destDir, relativePath);
+      const destPath = join113(destDir, relativePath);
       if (await import_fs_extra16.pathExists(destPath)) {
         if (this.fileScanner.shouldNeverCopy(normalizedRelativePath)) {
           logger.debug(`Security-sensitive file exists but won't be overwritten: ${normalizedRelativePath}`);
@@ -105815,7 +105906,7 @@ class CopyExecutor {
     for (const file of files) {
       const relativePath = relative24(sourceDir, file);
       const normalizedRelativePath = relativePath.replace(/\\/g, "/");
-      const destPath = join112(destDir, relativePath);
+      const destPath = join113(destDir, relativePath);
       if (this.fileScanner.shouldNeverCopy(normalizedRelativePath)) {
         logger.debug(`Skipping security-sensitive file: ${normalizedRelativePath}`);
         skippedCount++;
@@ -106027,15 +106118,15 @@ class FileMerger {
 
 // src/domains/migration/legacy-migration.ts
 import { readdir as readdir28, stat as stat19 } from "node:fs/promises";
-import { join as join116, relative as relative25 } from "node:path";
+import { join as join117, relative as relative25 } from "node:path";
 // src/services/file-operations/manifest/manifest-tracker.ts
-import { join as join115 } from "node:path";
+import { join as join116 } from "node:path";
 
 // src/domains/migration/release-manifest.ts
 init_logger();
 init_zod();
 var import_fs_extra17 = __toESM(require_lib(), 1);
-import { join as join113 } from "node:path";
+import { join as join114 } from "node:path";
 var ReleaseManifestFileSchema = exports_external.object({
   path: exports_external.string(),
   checksum: exports_external.string().regex(/^[a-f0-9]{64}$/),
@@ -106050,7 +106141,7 @@ var ReleaseManifestSchema = exports_external.object({
 
 class ReleaseManifestLoader {
   static async load(extractDir) {
-    const manifestPath = join113(extractDir, "release-manifest.json");
+    const manifestPath = join114(extractDir, "release-manifest.json");
     try {
       const content = await import_fs_extra17.readFile(manifestPath, "utf-8");
       const parsed = JSON.parse(content);
@@ -106073,12 +106164,12 @@ init_p_limit();
 
 // src/services/file-operations/manifest/manifest-updater.ts
 init_metadata_migration();
-import { join as join114 } from "node:path";
+import { join as join115 } from "node:path";
 init_logger();
 init_types3();
 var import_fs_extra18 = __toESM(require_lib(), 1);
 async function writeManifest(claudeDir3, kitName, version, scope, kitType, trackedFiles, userConfigFiles, ignoredSkills = []) {
-  const metadataPath = join114(claudeDir3, "metadata.json");
+  const metadataPath = join115(claudeDir3, "metadata.json");
   const kit = kitType || (/\bmarketing\b/i.test(kitName) ? "marketing" : "engineer");
   await import_fs_extra18.ensureFile(metadataPath);
   let release = null;
@@ -106150,7 +106241,7 @@ function uniqueNormalizedSkillRoots(paths) {
   }))).sort();
 }
 async function removeKitFromManifest(claudeDir3, kit, options2) {
-  const metadataPath = join114(claudeDir3, "metadata.json");
+  const metadataPath = join115(claudeDir3, "metadata.json");
   if (!await import_fs_extra18.pathExists(metadataPath))
     return false;
   let release = null;
@@ -106182,7 +106273,7 @@ async function removeKitFromManifest(claudeDir3, kit, options2) {
   }
 }
 async function retainTrackedFilesInManifest(claudeDir3, retainedPaths, options2) {
-  const metadataPath = join114(claudeDir3, "metadata.json");
+  const metadataPath = join115(claudeDir3, "metadata.json");
   if (!await import_fs_extra18.pathExists(metadataPath))
     return false;
   const normalizedPaths = new Set(retainedPaths.map((path17) => path17.replace(/\\/g, "/")));
@@ -106363,7 +106454,7 @@ function buildFileTrackingList(options2) {
     if (!isGlobal && !installedPath.startsWith(".claude/"))
       continue;
     const relativePath = isGlobal ? installedPath : installedPath.replace(/^\.claude\//, "");
-    const filePath = join115(claudeDir3, relativePath);
+    const filePath = join116(claudeDir3, relativePath);
     const manifestEntry = releaseManifest ? ReleaseManifestLoader.findFile(releaseManifest, installedPath) : null;
     const ownership = manifestEntry ? "ck" : "user";
     filesToTrack.push({
@@ -106474,7 +106565,7 @@ class LegacyMigration {
         continue;
       if (SKIP_DIRS_ALL.includes(entry))
         continue;
-      const fullPath = join116(dir, entry);
+      const fullPath = join117(dir, entry);
       let stats;
       try {
         stats = await stat19(fullPath);
@@ -106584,7 +106675,7 @@ User-created files (sample):`);
     ];
     if (filesToChecksum.length > 0) {
       const checksumResults = await mapWithLimit(filesToChecksum, async ({ relativePath, ownership }) => {
-        const fullPath = join116(claudeDir3, relativePath);
+        const fullPath = join117(claudeDir3, relativePath);
         const checksum = await OwnershipChecker.calculateChecksum(fullPath);
         return { relativePath, checksum, ownership };
       }, getOptimalConcurrency());
@@ -106605,7 +106696,7 @@ User-created files (sample):`);
       installedAt: new Date().toISOString(),
       files: trackedFiles
     };
-    const metadataPath = join116(claudeDir3, "metadata.json");
+    const metadataPath = join117(claudeDir3, "metadata.json");
     await import_fs_extra19.writeFile(metadataPath, JSON.stringify(updatedMetadata, null, 2));
     logger.success(`Migration complete: tracked ${trackedFiles.length} files`);
     return true;
@@ -106711,7 +106802,7 @@ function buildConflictSummary(fileConflicts, hookConflicts, mcpConflicts) {
 init_logger();
 init_skip_directories();
 var import_fs_extra20 = __toESM(require_lib(), 1);
-import { join as join117, relative as relative26, resolve as resolve43 } from "node:path";
+import { join as join118, relative as relative26, resolve as resolve43 } from "node:path";
 
 class FileScanner2 {
   static async getFiles(dirPath, relativeTo) {
@@ -106727,7 +106818,7 @@ class FileScanner2 {
           logger.debug(`Skipping directory: ${entry}`);
           continue;
         }
-        const fullPath = join117(dirPath, entry);
+        const fullPath = join118(dirPath, entry);
         if (!FileScanner2.isSafePath(basePath, fullPath)) {
           logger.warning(`Skipping potentially unsafe path: ${entry}`);
           continue;
@@ -106762,8 +106853,8 @@ class FileScanner2 {
     return files;
   }
   static async findCustomFiles(destDir, sourceDir, subPath) {
-    const destSubDir = join117(destDir, subPath);
-    const sourceSubDir = join117(sourceDir, subPath);
+    const destSubDir = join118(destDir, subPath);
+    const sourceSubDir = join118(sourceDir, subPath);
     logger.debug(`findCustomFiles - destDir: ${destDir}`);
     logger.debug(`findCustomFiles - sourceDir: ${sourceDir}`);
     logger.debug(`findCustomFiles - subPath: "${subPath}"`);
@@ -106804,12 +106895,12 @@ class FileScanner2 {
 init_logger();
 var import_fs_extra21 = __toESM(require_lib(), 1);
 import { lstat as lstat10, mkdir as mkdir32, readdir as readdir31, stat as stat20 } from "node:fs/promises";
-import { join as join119 } from "node:path";
+import { join as join120 } from "node:path";
 
 // src/services/transformers/commands-prefix/content-transformer.ts
 init_logger();
 import { readFile as readFile56, readdir as readdir30, writeFile as writeFile31 } from "node:fs/promises";
-import { join as join118 } from "node:path";
+import { join as join119 } from "node:path";
 var TRANSFORMABLE_EXTENSIONS = new Set([
   ".md",
   ".txt",
@@ -106869,7 +106960,7 @@ async function transformCommandReferences(directory, options2 = {}) {
   async function processDirectory(dir) {
     const entries = await readdir30(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join118(dir, entry.name);
+      const fullPath = join119(dir, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name.startsWith(".") && entry.name !== ".claude") {
           continue;
@@ -106944,14 +107035,14 @@ function shouldApplyPrefix(options2) {
 // src/services/transformers/commands-prefix/prefix-applier.ts
 async function applyPrefix(extractDir) {
   validatePath(extractDir, "extractDir");
-  const commandsDir = join119(extractDir, ".claude", "commands");
+  const commandsDir = join120(extractDir, ".claude", "commands");
   if (!await import_fs_extra21.pathExists(commandsDir)) {
     logger.verbose("No commands directory found, skipping prefix application");
     return;
   }
   logger.info("Applying /ck: prefix to slash commands...");
-  const backupDir = join119(extractDir, ".commands-backup");
-  const tempDir = join119(extractDir, ".commands-prefix-temp");
+  const backupDir = join120(extractDir, ".commands-backup");
+  const tempDir = join120(extractDir, ".commands-prefix-temp");
   try {
     const entries = await readdir31(commandsDir);
     if (entries.length === 0) {
@@ -106959,7 +107050,7 @@ async function applyPrefix(extractDir) {
       return;
     }
     if (entries.length === 1 && entries[0] === "ck") {
-      const ckDir2 = join119(commandsDir, "ck");
+      const ckDir2 = join120(commandsDir, "ck");
       const ckStat = await stat20(ckDir2);
       if (ckStat.isDirectory()) {
         logger.verbose("Commands already have /ck: prefix, skipping");
@@ -106969,17 +107060,17 @@ async function applyPrefix(extractDir) {
     await import_fs_extra21.copy(commandsDir, backupDir);
     logger.verbose("Created backup of commands directory");
     await mkdir32(tempDir, { recursive: true });
-    const ckDir = join119(tempDir, "ck");
+    const ckDir = join120(tempDir, "ck");
     await mkdir32(ckDir, { recursive: true });
     let processedCount = 0;
     for (const entry of entries) {
-      const sourcePath = join119(commandsDir, entry);
+      const sourcePath = join120(commandsDir, entry);
       const stats = await lstat10(sourcePath);
       if (stats.isSymbolicLink()) {
         logger.warning(`Skipping symlink for security: ${entry}`);
         continue;
       }
-      const destPath = join119(ckDir, entry);
+      const destPath = join120(ckDir, entry);
       await import_fs_extra21.copy(sourcePath, destPath, {
         overwrite: false,
         errorOnExist: true
@@ -106997,7 +107088,7 @@ async function applyPrefix(extractDir) {
     await import_fs_extra21.move(tempDir, commandsDir);
     await import_fs_extra21.remove(backupDir);
     logger.success("Successfully reorganized commands to /ck: prefix");
-    const claudeDir3 = join119(extractDir, ".claude");
+    const claudeDir3 = join120(extractDir, ".claude");
     logger.info("Transforming command references in file contents...");
     const transformResult = await transformCommandReferences(claudeDir3, {
       verbose: logger.isVerbose()
@@ -107035,20 +107126,20 @@ async function applyPrefix(extractDir) {
 // src/services/transformers/commands-prefix/prefix-cleaner.ts
 init_metadata_migration();
 import { lstat as lstat12, readdir as readdir33 } from "node:fs/promises";
-import { join as join121 } from "node:path";
+import { join as join122 } from "node:path";
 init_logger();
 var import_fs_extra23 = __toESM(require_lib(), 1);
 
 // src/services/transformers/commands-prefix/file-processor.ts
 import { lstat as lstat11, readdir as readdir32 } from "node:fs/promises";
-import { join as join120 } from "node:path";
+import { join as join121 } from "node:path";
 init_logger();
 var import_fs_extra22 = __toESM(require_lib(), 1);
 async function scanDirectoryFiles(dir) {
   const files = [];
   const entries = await readdir32(dir);
   for (const entry of entries) {
-    const fullPath = join120(dir, entry);
+    const fullPath = join121(dir, entry);
     const stats = await lstat11(fullPath);
     if (stats.isSymbolicLink()) {
       continue;
@@ -107176,8 +107267,8 @@ function isDifferentKitDirectory(dirName, currentKit) {
 async function cleanupCommandsDirectory(targetDir, isGlobal, options2 = {}) {
   const { dryRun = false } = options2;
   validatePath(targetDir, "targetDir");
-  const claudeDir3 = isGlobal ? targetDir : join121(targetDir, ".claude");
-  const commandsDir = join121(claudeDir3, "commands");
+  const claudeDir3 = isGlobal ? targetDir : join122(targetDir, ".claude");
+  const commandsDir = join122(claudeDir3, "commands");
   const accumulator = {
     results: [],
     deletedCount: 0,
@@ -107219,7 +107310,7 @@ async function cleanupCommandsDirectory(targetDir, isGlobal, options2 = {}) {
   }
   const metadataForChecks = options2.kitType ? createKitSpecificMetadata(metadata, options2.kitType) : metadata;
   for (const entry of entries) {
-    const entryPath = join121(commandsDir, entry);
+    const entryPath = join122(commandsDir, entry);
     const stats = await lstat12(entryPath);
     if (stats.isSymbolicLink()) {
       addSymlinkSkip(entry, accumulator);
@@ -107276,7 +107367,7 @@ async function handleMerge(ctx) {
   let customClaudeFiles = [];
   if (!ctx.options.fresh) {
     logger.info("Scanning for custom .claude files...");
-    const scanSourceDir = ctx.options.global ? join122(ctx.extractDir, ".claude") : ctx.extractDir;
+    const scanSourceDir = ctx.options.global ? join123(ctx.extractDir, ".claude") : ctx.extractDir;
     const scanTargetSubdir = ctx.options.global ? "" : ".claude";
     customClaudeFiles = await FileScanner2.findCustomFiles(ctx.resolvedDir, scanSourceDir, scanTargetSubdir);
   } else {
@@ -107315,7 +107406,7 @@ async function handleMerge(ctx) {
   merger.setRestoreCkHooks(ctx.options.restoreCkHooks);
   merger.setProjectDir(ctx.resolvedDir);
   merger.setKitName(ctx.kit.name);
-  merger.setZombiePrunerHookDir(join122(ctx.claudeDir, "hooks"));
+  merger.setZombiePrunerHookDir(join123(ctx.claudeDir, "hooks"));
   if (ctx.kitType) {
     merger.setMultiKitContext(ctx.claudeDir, ctx.kitType);
   }
@@ -107344,8 +107435,8 @@ async function handleMerge(ctx) {
       return { ...ctx, cancelled: true };
     }
   }
-  const sourceDir = ctx.options.global ? join122(ctx.extractDir, ".claude") : ctx.extractDir;
-  const sourceMetadataPath = ctx.options.global ? join122(sourceDir, "metadata.json") : join122(sourceDir, ".claude", "metadata.json");
+  const sourceDir = ctx.options.global ? join123(ctx.extractDir, ".claude") : ctx.extractDir;
+  const sourceMetadataPath = ctx.options.global ? join123(sourceDir, "metadata.json") : join123(sourceDir, ".claude", "metadata.json");
   let sourceMetadata = null;
   try {
     if (await import_fs_extra24.pathExists(sourceMetadataPath)) {
@@ -107403,7 +107494,7 @@ async function handleMerge(ctx) {
   };
 }
 // src/commands/init/phases/migration-handler.ts
-import { join as join130 } from "node:path";
+import { join as join131 } from "node:path";
 
 // src/domains/skills/skills-detector.ts
 init_logger();
@@ -107419,7 +107510,7 @@ init_types3();
 var import_fs_extra25 = __toESM(require_lib(), 1);
 import { createHash as createHash7 } from "node:crypto";
 import { readFile as readFile58, readdir as readdir34, writeFile as writeFile32 } from "node:fs/promises";
-import { join as join123, relative as relative27 } from "node:path";
+import { join as join124, relative as relative27 } from "node:path";
 
 class SkillsManifestManager {
   static MANIFEST_FILENAME = ".skills-manifest.json";
@@ -107441,12 +107532,12 @@ class SkillsManifestManager {
     return manifest;
   }
   static async writeManifest(skillsDir2, manifest) {
-    const manifestPath = join123(skillsDir2, SkillsManifestManager.MANIFEST_FILENAME);
+    const manifestPath = join124(skillsDir2, SkillsManifestManager.MANIFEST_FILENAME);
     await writeFile32(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
     logger.debug(`Wrote manifest to: ${manifestPath}`);
   }
   static async readManifest(skillsDir2) {
-    const manifestPath = join123(skillsDir2, SkillsManifestManager.MANIFEST_FILENAME);
+    const manifestPath = join124(skillsDir2, SkillsManifestManager.MANIFEST_FILENAME);
     if (!await import_fs_extra25.pathExists(manifestPath)) {
       logger.debug(`No manifest found at: ${manifestPath}`);
       return null;
@@ -107469,7 +107560,7 @@ class SkillsManifestManager {
       return "flat";
     }
     for (const dir of dirs.slice(0, 3)) {
-      const dirPath = join123(skillsDir2, dir.name);
+      const dirPath = join124(skillsDir2, dir.name);
       const subEntries = await readdir34(dirPath, { withFileTypes: true });
       const hasSubdirs = subEntries.some((entry) => entry.isDirectory());
       if (hasSubdirs) {
@@ -107488,7 +107579,7 @@ class SkillsManifestManager {
       const entries = await readdir34(skillsDir2, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isDirectory() && !BUILD_ARTIFACT_DIRS.includes(entry.name) && !entry.name.startsWith(".")) {
-          const skillPath = join123(skillsDir2, entry.name);
+          const skillPath = join124(skillsDir2, entry.name);
           const hash = await SkillsManifestManager.hashDirectory(skillPath);
           skills.push({
             name: entry.name,
@@ -107500,11 +107591,11 @@ class SkillsManifestManager {
       const categories = await readdir34(skillsDir2, { withFileTypes: true });
       for (const category of categories) {
         if (category.isDirectory() && !BUILD_ARTIFACT_DIRS.includes(category.name) && !category.name.startsWith(".")) {
-          const categoryPath = join123(skillsDir2, category.name);
+          const categoryPath = join124(skillsDir2, category.name);
           const skillEntries = await readdir34(categoryPath, { withFileTypes: true });
           for (const skillEntry of skillEntries) {
             if (skillEntry.isDirectory() && !skillEntry.name.startsWith(".")) {
-              const skillPath = join123(categoryPath, skillEntry.name);
+              const skillPath = join124(categoryPath, skillEntry.name);
               const hash = await SkillsManifestManager.hashDirectory(skillPath);
               skills.push({
                 name: skillEntry.name,
@@ -107534,7 +107625,7 @@ class SkillsManifestManager {
     const files = [];
     const entries = await readdir34(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join123(dirPath, entry.name);
+      const fullPath = join124(dirPath, entry.name);
       if (entry.name.startsWith(".") || BUILD_ARTIFACT_DIRS.includes(entry.name)) {
         continue;
       }
@@ -107656,7 +107747,7 @@ function getPathMapping(skillName, oldBasePath, newBasePath) {
 // src/domains/skills/detection/script-detector.ts
 var import_fs_extra26 = __toESM(require_lib(), 1);
 import { readdir as readdir35 } from "node:fs/promises";
-import { join as join124 } from "node:path";
+import { join as join125 } from "node:path";
 async function scanDirectory(skillsDir2) {
   if (!await import_fs_extra26.pathExists(skillsDir2)) {
     return ["flat", []];
@@ -107669,12 +107760,12 @@ async function scanDirectory(skillsDir2) {
   let totalSkillLikeCount = 0;
   const allSkills = [];
   for (const dir of dirs) {
-    const dirPath = join124(skillsDir2, dir.name);
+    const dirPath = join125(skillsDir2, dir.name);
     const subEntries = await readdir35(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 = join124(dirPath, subdir.name);
+        const subdirPath = join125(dirPath, subdir.name);
         const subdirFiles = await readdir35(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) {
@@ -107831,12 +107922,12 @@ class SkillsMigrationDetector {
 // src/domains/skills/skills-migrator.ts
 init_logger();
 init_types3();
-import { join as join129 } from "node:path";
+import { join as join130 } from "node:path";
 
 // src/domains/skills/migrator/migration-executor.ts
 init_logger();
 import { copyFile as copyFile6, mkdir as mkdir33, readdir as readdir36, rm as rm13 } from "node:fs/promises";
-import { join as join125 } from "node:path";
+import { join as join126 } from "node:path";
 var import_fs_extra28 = __toESM(require_lib(), 1);
 
 // src/domains/skills/skills-migration-prompts.ts
@@ -108001,8 +108092,8 @@ async function copySkillDirectory(sourceDir, destDir) {
   await mkdir33(destDir, { recursive: true });
   const entries = await readdir36(sourceDir, { withFileTypes: true });
   for (const entry of entries) {
-    const sourcePath = join125(sourceDir, entry.name);
-    const destPath = join125(destDir, entry.name);
+    const sourcePath = join126(sourceDir, entry.name);
+    const destPath = join126(destDir, entry.name);
     if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.isSymbolicLink()) {
       continue;
     }
@@ -108017,7 +108108,7 @@ async function executeInternal(mappings, customizations, currentSkillsDir, inter
   const migrated = [];
   const preserved = [];
   const errors2 = [];
-  const tempDir = join125(currentSkillsDir, "..", ".skills-migration-temp");
+  const tempDir = join126(currentSkillsDir, "..", ".skills-migration-temp");
   await mkdir33(tempDir, { recursive: true });
   try {
     for (const mapping of mappings) {
@@ -108038,9 +108129,9 @@ async function executeInternal(mappings, customizations, currentSkillsDir, inter
           }
         }
         const category = mapping.category;
-        const targetPath = category ? join125(tempDir, category, skillName) : join125(tempDir, skillName);
+        const targetPath = category ? join126(tempDir, category, skillName) : join126(tempDir, skillName);
         if (category) {
-          await mkdir33(join125(tempDir, category), { recursive: true });
+          await mkdir33(join126(tempDir, category), { recursive: true });
         }
         await copySkillDirectory(currentSkillPath, targetPath);
         migrated.push(skillName);
@@ -108107,7 +108198,7 @@ init_logger();
 init_types3();
 var import_fs_extra29 = __toESM(require_lib(), 1);
 import { copyFile as copyFile7, mkdir as mkdir34, readdir as readdir37, rm as rm14, stat as stat21 } from "node:fs/promises";
-import { basename as basename27, join as join126, normalize as normalize9 } from "node:path";
+import { basename as basename27, join as join127, normalize as normalize9 } from "node:path";
 function validatePath2(path17, paramName) {
   if (!path17 || typeof path17 !== "string") {
     throw new SkillsMigrationError(`${paramName} must be a non-empty string`);
@@ -108133,7 +108224,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 ? join126(parentDir, backupDirName) : join126(skillsDir2, "..", backupDirName);
+    const backupDir = parentDir ? join127(parentDir, backupDirName) : join127(skillsDir2, "..", backupDirName);
     logger.info(`Creating backup at: ${backupDir}`);
     try {
       await mkdir34(backupDir, { recursive: true });
@@ -108184,7 +108275,7 @@ class SkillsBackupManager {
     }
     try {
       const entries = await readdir37(parentDir, { withFileTypes: true });
-      const backups = entries.filter((entry) => entry.isDirectory() && entry.name.startsWith(SkillsBackupManager.BACKUP_PREFIX)).map((entry) => join126(parentDir, entry.name));
+      const backups = entries.filter((entry) => entry.isDirectory() && entry.name.startsWith(SkillsBackupManager.BACKUP_PREFIX)).map((entry) => join127(parentDir, entry.name));
       backups.sort().reverse();
       return backups;
     } catch (error) {
@@ -108212,8 +108303,8 @@ class SkillsBackupManager {
   static async copyDirectory(sourceDir, destDir) {
     const entries = await readdir37(sourceDir, { withFileTypes: true });
     for (const entry of entries) {
-      const sourcePath = join126(sourceDir, entry.name);
-      const destPath = join126(destDir, entry.name);
+      const sourcePath = join127(sourceDir, entry.name);
+      const destPath = join127(destDir, entry.name);
       if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.isSymbolicLink()) {
         continue;
       }
@@ -108229,7 +108320,7 @@ class SkillsBackupManager {
     let size = 0;
     const entries = await readdir37(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join126(dirPath, entry.name);
+      const fullPath = join127(dirPath, entry.name);
       if (entry.isSymbolicLink()) {
         continue;
       }
@@ -108265,12 +108356,12 @@ init_skip_directories();
 import { createHash as createHash8 } from "node:crypto";
 import { createReadStream as createReadStream2 } from "node:fs";
 import { readFile as readFile59, readdir as readdir38 } from "node:fs/promises";
-import { join as join127, relative as relative28 } from "node:path";
+import { join as join128, relative as relative28 } from "node:path";
 async function getAllFiles(dirPath) {
   const files = [];
   const entries = await readdir38(dirPath, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = join127(dirPath, entry.name);
+    const fullPath = join128(dirPath, entry.name);
     if (entry.name.startsWith(".") || BUILD_ARTIFACT_DIRS.includes(entry.name) || entry.isSymbolicLink()) {
       continue;
     }
@@ -108397,7 +108488,7 @@ async function detectFileChanges(currentSkillPath, baselineSkillPath) {
 init_types3();
 var import_fs_extra31 = __toESM(require_lib(), 1);
 import { readdir as readdir39 } from "node:fs/promises";
-import { join as join128, normalize as normalize10 } from "node:path";
+import { join as join129, normalize as normalize10 } from "node:path";
 function validatePath3(path17, paramName) {
   if (!path17 || typeof path17 !== "string") {
     throw new SkillsMigrationError(`${paramName} must be a non-empty string`);
@@ -108418,13 +108509,13 @@ async function scanSkillsDirectory(skillsDir2) {
   if (dirs.length === 0) {
     return ["flat", []];
   }
-  const firstDirPath = join128(skillsDir2, dirs[0].name);
+  const firstDirPath = join129(skillsDir2, dirs[0].name);
   const subEntries = await readdir39(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 = join128(firstDirPath, subdir.name);
+      const subdirPath = join129(firstDirPath, subdir.name);
       const subdirFiles = await readdir39(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) {
@@ -108434,7 +108525,7 @@ async function scanSkillsDirectory(skillsDir2) {
     if (skillLikeCount > 0) {
       const skills = [];
       for (const dir of dirs) {
-        const categoryPath = join128(skillsDir2, dir.name);
+        const categoryPath = join129(skillsDir2, dir.name);
         const skillDirs = await readdir39(categoryPath, { withFileTypes: true });
         skills.push(...skillDirs.filter((entry) => entry.isDirectory() && !entry.name.startsWith(".")).map((entry) => entry.name));
       }
@@ -108444,7 +108535,7 @@ async function scanSkillsDirectory(skillsDir2) {
   return ["flat", dirs.map((dir) => dir.name)];
 }
 async function findSkillPath(skillsDir2, skillName) {
-  const flatPath = join128(skillsDir2, skillName);
+  const flatPath = join129(skillsDir2, skillName);
   if (await import_fs_extra31.pathExists(flatPath)) {
     return { path: flatPath, category: undefined };
   }
@@ -108453,8 +108544,8 @@ async function findSkillPath(skillsDir2, skillName) {
     if (!entry.isDirectory() || entry.name.startsWith(".") || entry.name === "node_modules") {
       continue;
     }
-    const categoryPath = join128(skillsDir2, entry.name);
-    const skillPath = join128(categoryPath, skillName);
+    const categoryPath = join129(skillsDir2, entry.name);
+    const skillPath = join129(categoryPath, skillName);
     if (await import_fs_extra31.pathExists(skillPath)) {
       return { path: skillPath, category: entry.name };
     }
@@ -108548,7 +108639,7 @@ class SkillsMigrator {
         }
       }
       if (options2.backup && !options2.dryRun) {
-        const claudeDir3 = join129(currentSkillsDir, "..");
+        const claudeDir3 = join130(currentSkillsDir, "..");
         result.backupPath = await SkillsBackupManager.createBackup(currentSkillsDir, claudeDir3);
         logger.success(`Backup created at: ${result.backupPath}`);
       }
@@ -108609,7 +108700,7 @@ async function handleMigration(ctx) {
     logger.debug("Skipping skills migration (fresh installation)");
     return ctx;
   }
-  const newSkillsDir = join130(ctx.extractDir, ".claude", "skills");
+  const newSkillsDir = join131(ctx.extractDir, ".claude", "skills");
   const currentSkillsDir = PathResolver.buildSkillsPath(ctx.resolvedDir, ctx.options.global);
   if (!await import_fs_extra32.pathExists(newSkillsDir) || !await import_fs_extra32.pathExists(currentSkillsDir)) {
     return ctx;
@@ -108633,13 +108724,13 @@ async function handleMigration(ctx) {
 }
 // src/commands/init/phases/opencode-handler.ts
 import { cp as cp4, readdir as readdir41, rm as rm15 } from "node:fs/promises";
-import { join as join132 } from "node:path";
+import { join as join133 } from "node:path";
 
 // src/services/transformers/opencode-path-transformer.ts
 init_logger();
 import { readFile as readFile60, readdir as readdir40, writeFile as writeFile33 } from "node:fs/promises";
 import { platform as platform15 } from "node:os";
-import { extname as extname6, join as join131 } from "node:path";
+import { extname as extname6, join as join132 } from "node:path";
 var IS_WINDOWS2 = platform15() === "win32";
 function getOpenCodeGlobalPath() {
   return "$HOME/.config/opencode/";
@@ -108700,7 +108791,7 @@ async function transformPathsForGlobalOpenCode(directory, options2 = {}) {
   async function processDirectory2(dir) {
     const entries = await readdir40(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join131(dir, entry.name);
+      const fullPath = join132(dir, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name.startsWith(".")) {
           continue;
@@ -108739,7 +108830,7 @@ async function handleOpenCode(ctx) {
   if (ctx.cancelled || !ctx.extractDir || !ctx.resolvedDir) {
     return ctx;
   }
-  const openCodeSource = join132(ctx.extractDir, ".opencode");
+  const openCodeSource = join133(ctx.extractDir, ".opencode");
   if (!await import_fs_extra33.pathExists(openCodeSource)) {
     logger.debug("No .opencode directory in archive, skipping");
     return ctx;
@@ -108757,8 +108848,8 @@ async function handleOpenCode(ctx) {
     await import_fs_extra33.ensureDir(targetDir);
     const entries = await readdir41(openCodeSource, { withFileTypes: true });
     for (const entry of entries) {
-      const sourcePath = join132(openCodeSource, entry.name);
-      const targetPath = join132(targetDir, entry.name);
+      const sourcePath = join133(openCodeSource, entry.name);
+      const targetPath = join133(targetDir, entry.name);
       if (await import_fs_extra33.pathExists(targetPath)) {
         if (!ctx.options.forceOverwrite) {
           logger.verbose(`Skipping existing: ${entry.name}`);
@@ -108857,7 +108948,7 @@ Please use only one download method.`);
 }
 // src/commands/init/phases/post-install-handler.ts
 init_projects_registry();
-import { join as join133 } from "node:path";
+import { join as join134 } from "node:path";
 init_logger();
 init_path_resolver();
 var import_fs_extra34 = __toESM(require_lib(), 1);
@@ -108866,8 +108957,8 @@ async function handlePostInstall(ctx) {
     return ctx;
   }
   if (ctx.options.global) {
-    const claudeMdSource = join133(ctx.extractDir, "CLAUDE.md");
-    const claudeMdDest = join133(ctx.resolvedDir, "CLAUDE.md");
+    const claudeMdSource = join134(ctx.extractDir, "CLAUDE.md");
+    const claudeMdDest = join134(ctx.resolvedDir, "CLAUDE.md");
     if (await import_fs_extra34.pathExists(claudeMdSource)) {
       if (ctx.options.fresh || !await import_fs_extra34.pathExists(claudeMdDest)) {
         await import_fs_extra34.copy(claudeMdSource, claudeMdDest);
@@ -108890,24 +108981,24 @@ async function handlePostInstall(ctx) {
     });
   }
   if (!ctx.isNonInteractive) {
-    const { isGeminiInstalled: isGeminiInstalled2 } = await Promise.resolve().then(() => (init_package_installer(), exports_package_installer));
-    const { checkExistingGeminiConfig: checkExistingGeminiConfig2, findMcpConfigPath: findMcpConfigPath2, processGeminiMcpLinking: processGeminiMcpLinking2 } = await Promise.resolve().then(() => (init_gemini_mcp_linker(), exports_gemini_mcp_linker));
-    const geminiInstalled = await isGeminiInstalled2();
-    const existingConfig = checkExistingGeminiConfig2(ctx.resolvedDir, ctx.options.global);
+    const { isAgyInstalled: isAgyInstalled2 } = await Promise.resolve().then(() => (init_package_installer(), exports_package_installer));
+    const { checkExistingAgyConfig: checkExistingAgyConfig2, findMcpConfigPath: findMcpConfigPath2, processAgyMcpLinking: processAgyMcpLinking2 } = await Promise.resolve().then(() => (init_agy_mcp_linker(), exports_agy_mcp_linker));
+    const agyInstalled = await isAgyInstalled2();
+    const existingConfig = checkExistingAgyConfig2(ctx.resolvedDir, ctx.options.global);
     const mcpConfigPath = findMcpConfigPath2(ctx.resolvedDir);
     const mcpConfigExists = mcpConfigPath !== null;
-    if (geminiInstalled && !existingConfig.exists && mcpConfigExists) {
-      const geminiPath = ctx.options.global ? "~/.gemini/settings.json" : ".gemini/settings.json";
+    if (agyInstalled && !existingConfig.exists && mcpConfigExists) {
+      const agyPath = ctx.options.global ? "~/.gemini/config/mcp_config.json" : ".agents/mcp_config.json";
       const mcpPath = ctx.options.global ? "~/.claude/.mcp.json" : ".mcp.json";
       const promptMessage = [
-        "Gemini CLI detected. Set up MCP integration?",
-        `  → Creates ${geminiPath} symlink to ${mcpPath}`,
-        "  → Gemini CLI will share MCP servers with Claude Code"
+        "Antigravity CLI (agy) detected. Set up MCP integration?",
+        `  → Creates ${agyPath} symlink to ${mcpPath}`,
+        "  → agy will share MCP servers with Claude Code"
       ].join(`
 `);
-      const shouldSetupGemini = await ctx.prompts.confirm(promptMessage);
-      if (shouldSetupGemini) {
-        await processGeminiMcpLinking2(ctx.resolvedDir, {
+      const shouldSetupAgy = await ctx.prompts.confirm(promptMessage);
+      if (shouldSetupAgy) {
+        await processAgyMcpLinking2(ctx.resolvedDir, {
           isGlobal: ctx.options.global
         });
       }
@@ -108915,7 +109006,7 @@ async function handlePostInstall(ctx) {
   }
   if (!ctx.options.skipSetup) {
     await promptSetupWizardIfNeeded({
-      envPath: join133(ctx.claudeDir, ".env"),
+      envPath: join134(ctx.claudeDir, ".env"),
       claudeDir: ctx.claudeDir,
       isGlobal: ctx.options.global,
       isNonInteractive: ctx.isNonInteractive,
@@ -108938,12 +109029,12 @@ async function handlePostInstall(ctx) {
 // src/commands/init/phases/plugin-install-handler.ts
 init_codex_plugin_installer();
 import { cpSync as cpSync2, existsSync as existsSync69, mkdirSync as mkdirSync6, readFileSync as readFileSync21, rmSync as rmSync4, writeFileSync as writeFileSync8 } from "node:fs";
-import { join as join135 } from "node:path";
+import { join as join136 } from "node:path";
 
 // src/domains/installation/plugin/migrate-legacy-to-plugin.ts
 init_install_mode_detector();
 import { cpSync, existsSync as existsSync68, mkdirSync as mkdirSync5, readFileSync as readFileSync20, rmSync as rmSync3, writeFileSync as writeFileSync7 } from "node:fs";
-import { dirname as dirname43, join as join134 } from "node:path";
+import { dirname as dirname43, join as join135 } from "node:path";
 
 // src/domains/installation/plugin/plugin-installer.ts
 init_install_mode_detector();
@@ -109075,7 +109166,7 @@ async function migrateLegacyToPlugin(opts) {
   let backupDir = null;
   let removedPaths = [];
   if (before.legacy.installed) {
-    backupDir = join134(claudeDir3, "backups", `ck-legacy-${ts.replace(/[:.]/g, "-")}`);
+    backupDir = join135(claudeDir3, "backups", `ck-legacy-${ts.replace(/[:.]/g, "-")}`);
     mkdirSync5(backupDir, { recursive: true });
     removedPaths = removeLegacy(claudeDir3, backupDir);
   }
@@ -109109,7 +109200,7 @@ function base(action, modeBefore, pluginVerified) {
 }
 var PLUGIN_SUPPLIED_LEGACY_PREFIXES2 = ["agents/", "skills/"];
 function defaultLegacyRemover(claudeDir3, backupDir) {
-  const meta = readJsonSafe2(join134(claudeDir3, "metadata.json"));
+  const meta = readJsonSafe2(join135(claudeDir3, "metadata.json"));
   const files = collectTrackedFiles2(meta);
   const removed = [];
   for (const file of files) {
@@ -109117,10 +109208,10 @@ function defaultLegacyRemover(claudeDir3, backupDir) {
       continue;
     if (!isPluginSuppliedLegacyPath(file.path))
       continue;
-    const abs = join134(claudeDir3, file.path);
+    const abs = join135(claudeDir3, file.path);
     if (!existsSync68(abs))
       continue;
-    const backupTarget = join134(backupDir, file.path);
+    const backupTarget = join135(backupDir, file.path);
     mkdirSync5(dirname43(backupTarget), { recursive: true });
     cpSync(abs, backupTarget, { recursive: true });
     rmSync3(abs, { recursive: true, force: true });
@@ -109156,7 +109247,7 @@ function collectTrackedFiles2(meta) {
   return out;
 }
 function writeReceipt(claudeDir3, receipt) {
-  const receiptPath = join134(claudeDir3, ".ck-migration-log.json");
+  const receiptPath = join135(claudeDir3, ".ck-migration-log.json");
   const existing = readJsonSafe2(receiptPath);
   const history = Array.isArray(existing) ? existing : [];
   history.push(receipt);
@@ -109205,14 +109296,14 @@ async function handlePluginInstall(ctx, deps = {}) {
   return ctx;
 }
 function stagePluginSource(extractDir, stageBaseDir) {
-  const base2 = stageBaseDir ?? join135(PathResolver.getCacheDir(true), "ck-plugin-source");
-  const payloadSrc = join135(extractDir, ".claude");
+  const base2 = stageBaseDir ?? join136(PathResolver.getCacheDir(true), "ck-plugin-source");
+  const payloadSrc = join136(extractDir, ".claude");
   if (!existsSync69(payloadSrc)) {
     throw new Error(`plugin payload not found in archive: ${payloadSrc}`);
   }
   rmSync4(base2, { recursive: true, force: true });
   mkdirSync6(base2, { recursive: true });
-  const stagedPayload = join135(base2, ".claude");
+  const stagedPayload = join136(base2, ".claude");
   cpSync2(payloadSrc, stagedPayload, { recursive: true });
   ensureCodexPluginManifest(stagedPayload);
   const claudeMarketplace = {
@@ -109220,8 +109311,8 @@ function stagePluginSource(extractDir, stageBaseDir) {
     owner: { name: "ClaudeKit" },
     plugins: [{ name: "ck", source: "./.claude", description: "ClaudeKit Engineer" }]
   };
-  mkdirSync6(join135(base2, ".claude-plugin"), { recursive: true });
-  writeFileSync8(join135(base2, ".claude-plugin", "marketplace.json"), `${JSON.stringify(claudeMarketplace, null, 2)}
+  mkdirSync6(join136(base2, ".claude-plugin"), { recursive: true });
+  writeFileSync8(join136(base2, ".claude-plugin", "marketplace.json"), `${JSON.stringify(claudeMarketplace, null, 2)}
 `, "utf-8");
   const codexMarketplace = {
     name: "claudekit",
@@ -109235,16 +109326,16 @@ function stagePluginSource(extractDir, stageBaseDir) {
       }
     ]
   };
-  mkdirSync6(join135(base2, ".agents", "plugins"), { recursive: true });
-  writeFileSync8(join135(base2, ".agents", "plugins", "marketplace.json"), `${JSON.stringify(codexMarketplace, null, 2)}
+  mkdirSync6(join136(base2, ".agents", "plugins"), { recursive: true });
+  writeFileSync8(join136(base2, ".agents", "plugins", "marketplace.json"), `${JSON.stringify(codexMarketplace, null, 2)}
 `, "utf-8");
   return base2;
 }
 function ensureCodexPluginManifest(pluginRoot) {
-  const manifestPath = join135(pluginRoot, ".codex-plugin", "plugin.json");
+  const manifestPath = join136(pluginRoot, ".codex-plugin", "plugin.json");
   if (existsSync69(manifestPath))
     return;
-  const claudeManifest = readJsonSafe3(join135(pluginRoot, ".claude-plugin", "plugin.json"));
+  const claudeManifest = readJsonSafe3(join136(pluginRoot, ".claude-plugin", "plugin.json"));
   const manifest = pruneUndefined({
     name: stringField(claudeManifest, "name") ?? "ck",
     version: stringField(claudeManifest, "version") ?? "0.0.0",
@@ -109265,7 +109356,7 @@ function ensureCodexPluginManifest(pluginRoot) {
       websiteURL: "https://github.com/claudekit/claudekit-engineer"
     }
   });
-  mkdirSync6(join135(pluginRoot, ".codex-plugin"), { recursive: true });
+  mkdirSync6(join136(pluginRoot, ".codex-plugin"), { recursive: true });
   writeFileSync8(manifestPath, `${JSON.stringify(manifest, null, 2)}
 `, "utf-8");
 }
@@ -109330,7 +109421,7 @@ function logCodexPluginResult(result) {
 init_config_manager();
 init_github_client();
 import { mkdir as mkdir36 } from "node:fs/promises";
-import { join as join138, resolve as resolve46 } from "node:path";
+import { join as join139, resolve as resolve46 } from "node:path";
 
 // src/domains/github/kit-access-checker.ts
 init_error2();
@@ -109497,10 +109588,13 @@ async function runPreflightChecks() {
   return result;
 }
 
+// src/commands/init/phases/selection-handler.ts
+init_hook_health_checker();
+
 // src/domains/installation/fresh-installer.ts
 init_metadata_migration();
 import { existsSync as existsSync70, readdirSync as readdirSync11, rmSync as rmSync5, rmdirSync as rmdirSync2, unlinkSync as unlinkSync5 } from "node:fs";
-import { basename as basename28, dirname as dirname44, join as join136, resolve as resolve44 } from "node:path";
+import { basename as basename28, dirname as dirname44, join as join137, resolve as resolve44 } from "node:path";
 init_logger();
 init_safe_spinner();
 var import_fs_extra35 = __toESM(require_lib(), 1);
@@ -109582,7 +109676,7 @@ async function removeFilesByOwnership(claudeDir3, analysis, includeModified) {
     logger.debug(`${KIT_MANIFEST_FILE} was self-tracked; skipping from delete loop — will be rewritten by updateMetadataAfterFresh`);
   }
   for (const file of filesToRemove) {
-    const fullPath = join136(claudeDir3, file.path);
+    const fullPath = join137(claudeDir3, file.path);
     if (!existsSync70(fullPath)) {
       continue;
     }
@@ -109610,7 +109704,7 @@ async function removeFilesByOwnership(claudeDir3, analysis, includeModified) {
   };
 }
 async function updateMetadataAfterFresh(claudeDir3, removedFiles, metadata) {
-  const metadataPath = join136(claudeDir3, KIT_MANIFEST_FILE);
+  const metadataPath = join137(claudeDir3, KIT_MANIFEST_FILE);
   const removedSet = new Set(removedFiles);
   if (metadata.kits) {
     for (const kitName of Object.keys(metadata.kits)) {
@@ -109641,8 +109735,8 @@ function getFreshBackupTargets(claudeDir3, analysis, includeModified) {
       mutatePaths: filesToRemove.length > 0 ? ["metadata.json"] : []
     };
   }
-  const deletePaths = CLAUDEKIT_SUBDIRECTORIES.filter((subdir) => existsSync70(join136(claudeDir3, subdir)));
-  if (existsSync70(join136(claudeDir3, "metadata.json"))) {
+  const deletePaths = CLAUDEKIT_SUBDIRECTORIES.filter((subdir) => existsSync70(join137(claudeDir3, subdir)));
+  if (existsSync70(join137(claudeDir3, "metadata.json"))) {
     deletePaths.push("metadata.json");
   }
   return {
@@ -109664,7 +109758,7 @@ async function removeSubdirectoriesFallback(claudeDir3) {
   const removedFiles = [];
   let removedDirCount = 0;
   for (const subdir of CLAUDEKIT_SUBDIRECTORIES) {
-    const subdirPath = join136(claudeDir3, subdir);
+    const subdirPath = join137(claudeDir3, subdir);
     if (await import_fs_extra35.pathExists(subdirPath)) {
       rmSync5(subdirPath, { recursive: true, force: true });
       removedDirCount++;
@@ -109672,7 +109766,7 @@ async function removeSubdirectoriesFallback(claudeDir3) {
       logger.debug(`Removed subdirectory: ${subdir}/`);
     }
   }
-  const metadataPath = join136(claudeDir3, "metadata.json");
+  const metadataPath = join137(claudeDir3, "metadata.json");
   if (await import_fs_extra35.pathExists(metadataPath)) {
     unlinkSync5(metadataPath);
     removedFiles.push("metadata.json");
@@ -109750,7 +109844,7 @@ async function handleFreshInstallation(claudeDir3, prompts) {
 var import_fs_extra36 = __toESM(require_lib(), 1);
 import { cp as cp5, mkdir as mkdir35, readdir as readdir42, rename as rename11, rm as rm16, stat as stat22 } from "node:fs/promises";
 import { homedir as homedir47 } from "node:os";
-import { dirname as dirname45, join as join137, normalize as normalize11, resolve as resolve45 } from "node:path";
+import { dirname as dirname45, join as join138, normalize as normalize11, resolve as resolve45 } from "node:path";
 var LEGACY_KIT_MARKERS = [
   "metadata.json",
   ".ck.json",
@@ -109789,10 +109883,10 @@ function getLegacyWindowsGlobalKitDirCandidates(env2 = process.env, homeDir = ho
   const localAppData = safeEnvPath(env2.LOCALAPPDATA);
   const appData = safeEnvPath(env2.APPDATA);
   if (localAppData) {
-    candidates.push(join137(localAppData, ".claude"));
+    candidates.push(join138(localAppData, ".claude"));
   }
   if (appData) {
-    candidates.push(join137(appData, ".claude"));
+    candidates.push(join138(appData, ".claude"));
   }
   if (homeDir) {
     candidates.push(`${withoutTrailingSeparators(homeDir)}.claude`);
@@ -109810,7 +109904,7 @@ async function hasKitMarkers(dir) {
   if (!await isDirectory(dir))
     return false;
   for (const marker of LEGACY_KIT_MARKERS) {
-    if (await import_fs_extra36.pathExists(join137(dir, marker))) {
+    if (await import_fs_extra36.pathExists(join138(dir, marker))) {
       return true;
     }
   }
@@ -110112,7 +110206,7 @@ async function handleSelection(ctx) {
   }
   if (!ctx.options.fresh) {
     const prefix = PathResolver.getPathPrefix(ctx.options.global);
-    const claudeDir3 = prefix ? join138(resolvedDir, prefix) : resolvedDir;
+    const claudeDir3 = prefix ? join139(resolvedDir, prefix) : resolvedDir;
     try {
       const existingMetadata = await readManifest(claudeDir3);
       if (existingMetadata?.kits) {
@@ -110149,7 +110243,7 @@ async function handleSelection(ctx) {
   }
   if (ctx.options.fresh) {
     const prefix = PathResolver.getPathPrefix(ctx.options.global);
-    const claudeDir3 = prefix ? join138(resolvedDir, prefix) : resolvedDir;
+    const claudeDir3 = prefix ? join139(resolvedDir, prefix) : resolvedDir;
     const canProceed = await handleFreshInstallation(claudeDir3, ctx.prompts);
     if (!canProceed) {
       return { ...ctx, cancelled: true };
@@ -110169,7 +110263,7 @@ async function handleSelection(ctx) {
     let currentVersion = null;
     try {
       const prefix = PathResolver.getPathPrefix(ctx.options.global);
-      const claudeDir3 = prefix ? join138(resolvedDir, prefix) : resolvedDir;
+      const claudeDir3 = prefix ? join139(resolvedDir, prefix) : resolvedDir;
       const existingMetadata = await readManifest(claudeDir3);
       currentVersion = existingMetadata?.kits?.[kitType]?.version || null;
       if (currentVersion) {
@@ -110238,12 +110332,17 @@ async function handleSelection(ctx) {
   if (ctx.options.yes && !ctx.options.fresh && !ctx.options.force && !ctx.options.restoreCkHooks && releaseTag && !isOfflineMode && !pendingKits?.length) {
     try {
       const prefix = PathResolver.getPathPrefix(ctx.options.global);
-      const claudeDir3 = prefix ? join138(resolvedDir, prefix) : resolvedDir;
+      const claudeDir3 = prefix ? join139(resolvedDir, prefix) : resolvedDir;
       const existingMetadata = await readManifest(claudeDir3);
       const installedKitVersion = existingMetadata?.kits?.[kitType]?.version;
       if (installedKitVersion && versionsMatch(installedKitVersion, releaseTag)) {
-        logger.success(`Already at latest version (${kitType}@${installedKitVersion}), skipping reinstall`);
-        return { ...ctx, cancelled: true };
+        const missingHookFiles = await countMissingHookFileReferencesForClaudeDir(claudeDir3);
+        if (missingHookFiles > 0) {
+          logger.warning(`Detected ${missingHookFiles} registered hook(s) whose script is missing on disk; reinstalling to restore them`);
+        } else {
+          logger.success(`Already at latest version (${kitType}@${installedKitVersion}), skipping reinstall`);
+          return { ...ctx, cancelled: true };
+        }
       }
     } catch (error) {
       logger.verbose(`Metadata read failed, proceeding with installation: ${error instanceof Error ? error.message : "unknown"}`);
@@ -110262,7 +110361,7 @@ async function handleSelection(ctx) {
 }
 // src/commands/init/phases/sync-handler.ts
 import { copyFile as copyFile8, mkdir as mkdir37, open as open5, readFile as readFile61, rename as rename12, stat as stat23, unlink as unlink13, writeFile as writeFile35 } from "node:fs/promises";
-import { dirname as dirname46, join as join139, resolve as resolve47 } from "node:path";
+import { dirname as dirname46, join as join140, resolve as resolve47 } from "node:path";
 init_logger();
 init_path_resolver();
 var import_fs_extra38 = __toESM(require_lib(), 1);
@@ -110272,13 +110371,13 @@ async function handleSync(ctx) {
     return ctx;
   }
   const resolvedDir = ctx.options.global ? PathResolver.getGlobalKitDir() : resolve47(ctx.options.dir || ".");
-  const claudeDir3 = ctx.options.global ? resolvedDir : join139(resolvedDir, ".claude");
+  const claudeDir3 = ctx.options.global ? resolvedDir : join140(resolvedDir, ".claude");
   if (!await import_fs_extra38.pathExists(claudeDir3)) {
     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 = join139(claudeDir3, "metadata.json");
+  const metadataPath = join140(claudeDir3, "metadata.json");
   if (!await import_fs_extra38.pathExists(metadataPath)) {
     logger.error("Cannot sync: no metadata.json found");
     ctx.prompts.note(`Your installation may be from an older version.
@@ -110378,7 +110477,7 @@ function getLockTimeout() {
 var STALE_LOCK_THRESHOLD_MS = 5 * 60 * 1000;
 async function acquireSyncLock(global3) {
   const cacheDir = PathResolver.getCacheDir(global3);
-  const lockPath = join139(cacheDir, ".sync-lock");
+  const lockPath = join140(cacheDir, ".sync-lock");
   const startTime = Date.now();
   const lockTimeout = getLockTimeout();
   await mkdir37(dirname46(lockPath), { recursive: true });
@@ -110424,11 +110523,11 @@ async function executeSyncMerge(ctx) {
   const releaseLock = await acquireSyncLock(ctx.options.global);
   try {
     const trackedFiles = ctx.syncTrackedFiles;
-    const upstreamDir = ctx.options.global ? join139(ctx.extractDir, ".claude") : ctx.extractDir;
+    const upstreamDir = ctx.options.global ? join140(ctx.extractDir, ".claude") : ctx.extractDir;
     let sourceMetadata = null;
     let deletions = [];
     try {
-      const sourceMetadataPath = join139(upstreamDir, "metadata.json");
+      const sourceMetadataPath = join140(upstreamDir, "metadata.json");
       if (await import_fs_extra38.pathExists(sourceMetadataPath)) {
         const content = await readFile61(sourceMetadataPath, "utf-8");
         sourceMetadata = JSON.parse(content);
@@ -110490,7 +110589,7 @@ async function executeSyncMerge(ctx) {
         try {
           const sourcePath = await validateSyncPath(upstreamDir, file.path);
           const targetPath = await validateSyncPath(ctx.claudeDir, file.path);
-          const targetDir = join139(targetPath, "..");
+          const targetDir = join140(targetPath, "..");
           try {
             await mkdir37(targetDir, { recursive: true });
           } catch (mkdirError) {
@@ -110661,7 +110760,7 @@ async function createBackup(claudeDir3, files, backupDir) {
       const sourcePath = await validateSyncPath(claudeDir3, file.path);
       if (await import_fs_extra38.pathExists(sourcePath)) {
         const targetPath = await validateSyncPath(backupDir, file.path);
-        const targetDir = join139(targetPath, "..");
+        const targetDir = join140(targetPath, "..");
         await mkdir37(targetDir, { recursive: true });
         await copyFile8(sourcePath, targetPath);
       }
@@ -110676,7 +110775,7 @@ async function createBackup(claudeDir3, files, backupDir) {
 }
 // src/commands/init/phases/transform-handler.ts
 init_config_manager();
-import { join as join143 } from "node:path";
+import { join as join144 } from "node:path";
 
 // src/services/transformers/folder-path-transformer.ts
 init_logger();
@@ -110687,38 +110786,38 @@ init_logger();
 init_types3();
 var import_fs_extra39 = __toESM(require_lib(), 1);
 import { rename as rename13, rm as rm17 } from "node:fs/promises";
-import { join as join140, relative as relative30 } from "node:path";
+import { join as join141, relative as relative30 } from "node:path";
 async function collectDirsToRename(extractDir, folders) {
   const dirsToRename = [];
   if (folders.docs !== DEFAULT_FOLDERS.docs) {
-    const docsPath = join140(extractDir, DEFAULT_FOLDERS.docs);
+    const docsPath = join141(extractDir, DEFAULT_FOLDERS.docs);
     if (await import_fs_extra39.pathExists(docsPath)) {
       dirsToRename.push({
         from: docsPath,
-        to: join140(extractDir, folders.docs)
+        to: join141(extractDir, folders.docs)
       });
     }
-    const claudeDocsPath = join140(extractDir, ".claude", DEFAULT_FOLDERS.docs);
+    const claudeDocsPath = join141(extractDir, ".claude", DEFAULT_FOLDERS.docs);
     if (await import_fs_extra39.pathExists(claudeDocsPath)) {
       dirsToRename.push({
         from: claudeDocsPath,
-        to: join140(extractDir, ".claude", folders.docs)
+        to: join141(extractDir, ".claude", folders.docs)
       });
     }
   }
   if (folders.plans !== DEFAULT_FOLDERS.plans) {
-    const plansPath = join140(extractDir, DEFAULT_FOLDERS.plans);
+    const plansPath = join141(extractDir, DEFAULT_FOLDERS.plans);
     if (await import_fs_extra39.pathExists(plansPath)) {
       dirsToRename.push({
         from: plansPath,
-        to: join140(extractDir, folders.plans)
+        to: join141(extractDir, folders.plans)
       });
     }
-    const claudePlansPath = join140(extractDir, ".claude", DEFAULT_FOLDERS.plans);
+    const claudePlansPath = join141(extractDir, ".claude", DEFAULT_FOLDERS.plans);
     if (await import_fs_extra39.pathExists(claudePlansPath)) {
       dirsToRename.push({
         from: claudePlansPath,
-        to: join140(extractDir, ".claude", folders.plans)
+        to: join141(extractDir, ".claude", folders.plans)
       });
     }
   }
@@ -110759,7 +110858,7 @@ async function renameFolders(dirsToRename, extractDir, options2) {
 init_logger();
 init_types3();
 import { readFile as readFile62, readdir as readdir43, writeFile as writeFile36 } from "node:fs/promises";
-import { join as join141, relative as relative31 } from "node:path";
+import { join as join142, relative as relative31 } from "node:path";
 var TRANSFORMABLE_FILE_PATTERNS = [
   ".md",
   ".txt",
@@ -110812,7 +110911,7 @@ async function transformFileContents(dir, compiledReplacements, options2) {
   let replacementsCount = 0;
   const entries = await readdir43(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = join141(dir, entry.name);
+    const fullPath = join142(dir, entry.name);
     if (entry.isDirectory()) {
       if (entry.name === "node_modules" || entry.name === ".git") {
         continue;
@@ -110949,7 +111048,7 @@ async function transformFolderPaths(extractDir, folders, options2 = {}) {
 init_logger();
 import { readFile as readFile63, readdir as readdir44, writeFile as writeFile37 } from "node:fs/promises";
 import { homedir as homedir48, platform as platform16 } from "node:os";
-import { extname as extname7, join as join142 } from "node:path";
+import { extname as extname7, join as join143 } from "node:path";
 var IS_WINDOWS3 = platform16() === "win32";
 var HOME_PREFIX = "$HOME";
 function getHomeDirPrefix() {
@@ -110959,7 +111058,7 @@ function normalizeInstallPath(path17) {
   return path17.replace(/\\/g, "/").replace(/\/+$/, "");
 }
 function getDefaultGlobalClaudeDir() {
-  return normalizeInstallPath(join142(homedir48(), ".claude"));
+  return normalizeInstallPath(join143(homedir48(), ".claude"));
 }
 function getCustomGlobalClaudeDir(targetClaudeDir) {
   if (!targetClaudeDir)
@@ -111090,7 +111189,7 @@ async function transformPathsForGlobalInstall(directory, options2 = {}) {
   async function processDirectory2(dir) {
     const entries = await readdir44(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join142(dir, entry.name);
+      const fullPath = join143(dir, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name.startsWith(".") && entry.name !== ".claude") {
           continue;
@@ -111169,7 +111268,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 claudeDir3 = ctx.options.global ? ctx.resolvedDir : join143(ctx.resolvedDir, ".claude");
+  const claudeDir3 = ctx.options.global ? ctx.resolvedDir : join144(ctx.resolvedDir, ".claude");
   return {
     ...ctx,
     foldersConfig,
@@ -111396,7 +111495,7 @@ var import_picocolors30 = __toESM(require_picocolors(), 1);
 import { existsSync as existsSync71 } from "node:fs";
 import { readFile as readFile67, rm as rm18, unlink as unlink14 } from "node:fs/promises";
 import { homedir as homedir52 } from "node:os";
-import { basename as basename30, join as join147, resolve as resolve48 } from "node:path";
+import { basename as basename30, join as join148, resolve as resolve48 } from "node:path";
 init_logger();
 
 // src/ui/ck-cli-design/next-steps-footer.ts
@@ -111611,13 +111710,13 @@ init_dist2();
 init_model_taxonomy();
 import { mkdir as mkdir39, readFile as readFile66, writeFile as writeFile39 } from "node:fs/promises";
 import { homedir as homedir51 } from "node:os";
-import { dirname as dirname47, join as join146 } from "node:path";
+import { dirname as dirname47, join as join147 } from "node:path";
 
 // src/commands/portable/models-dev-cache.ts
 init_logger();
 import { mkdir as mkdir38, readFile as readFile64, rename as rename14, writeFile as writeFile38 } from "node:fs/promises";
 import { homedir as homedir49 } from "node:os";
-import { join as join144 } from "node:path";
+import { join as join145 } from "node:path";
 
 class ModelsDevUnavailableError extends Error {
   constructor(message, cause) {
@@ -111629,13 +111728,13 @@ var MODELS_DEV_URL = "https://models.dev/api.json";
 var CACHE_TTL_MS3 = 24 * 60 * 60 * 1000;
 var FETCH_TIMEOUT_MS = 1e4;
 function defaultCacheDir() {
-  return join144(homedir49(), ".config", "claudekit", "cache");
+  return join145(homedir49(), ".config", "claudekit", "cache");
 }
 function cacheFilePath(cacheDir) {
-  return join144(cacheDir, "models-dev.json");
+  return join145(cacheDir, "models-dev.json");
 }
 function tmpFilePath(cacheDir) {
-  return join144(cacheDir, "models-dev.json.tmp");
+  return join145(cacheDir, "models-dev.json.tmp");
 }
 async function readCacheEntry(cacheDir) {
   const filePath = cacheFilePath(cacheDir);
@@ -111710,14 +111809,14 @@ async function getModelsDevCatalog(opts = {}) {
 init_logger();
 import { readFile as readFile65 } from "node:fs/promises";
 import { homedir as homedir50, platform as platform17 } from "node:os";
-import { join as join145 } from "node:path";
+import { join as join146 } from "node:path";
 function resolveOpenCodeAuthPath(homeDir) {
   if (platform17() === "win32") {
-    const dataRoot2 = process.env.LOCALAPPDATA ?? join145(homeDir, "AppData", "Local");
-    return join145(dataRoot2, "opencode", "auth.json");
+    const dataRoot2 = process.env.LOCALAPPDATA ?? join146(homeDir, "AppData", "Local");
+    return join146(dataRoot2, "opencode", "auth.json");
   }
-  const dataRoot = process.env.XDG_DATA_HOME ?? join145(homeDir, ".local", "share");
-  return join145(dataRoot, "opencode", "auth.json");
+  const dataRoot = process.env.XDG_DATA_HOME ?? join146(homeDir, ".local", "share");
+  return join146(dataRoot, "opencode", "auth.json");
 }
 async function readAuthedProviders(homeDir) {
   const authPath = resolveOpenCodeAuthPath(homeDir);
@@ -111819,9 +111918,9 @@ function messageForReason(reason) {
 }
 function getOpenCodeConfigPath(options2) {
   if (options2.global) {
-    return join146(options2.homeDir ?? homedir51(), ".config", "opencode", "opencode.json");
+    return join147(options2.homeDir ?? homedir51(), ".config", "opencode", "opencode.json");
   }
-  return join146(options2.cwd ?? process.cwd(), "opencode.json");
+  return join147(options2.cwd ?? process.cwd(), "opencode.json");
 }
 function makeCatalogOpts(options2) {
   return {
@@ -112694,7 +112793,7 @@ function appendFallbackSkillActionsToPlan(plan, skills, selectedProviders, insta
         reason: "New item, not previously installed",
         reasonCode: "new-item",
         reasonCopy: "New - not previously installed",
-        targetPath: join147(basePath, skill.name),
+        targetPath: join148(basePath, skill.name),
         type: "skill"
       });
     }
@@ -112915,7 +113014,7 @@ function createSkippedPathMigrationCleanupResult2(action) {
 async function processMetadataDeletions(skillSourcePath, installGlobally) {
   if (!skillSourcePath)
     return;
-  const sourceMetadataPath = join147(resolve48(skillSourcePath, ".."), "metadata.json");
+  const sourceMetadataPath = join148(resolve48(skillSourcePath, ".."), "metadata.json");
   if (!existsSync71(sourceMetadataPath))
     return;
   let sourceMetadata;
@@ -112928,7 +113027,7 @@ async function processMetadataDeletions(skillSourcePath, installGlobally) {
   }
   if (!sourceMetadata.deletions || sourceMetadata.deletions.length === 0)
     return;
-  const claudeDir3 = installGlobally ? join147(homedir52(), ".claude") : join147(process.cwd(), ".claude");
+  const claudeDir3 = installGlobally ? join148(homedir52(), ".claude") : join148(process.cwd(), ".claude");
   if (!existsSync71(claudeDir3))
     return;
   try {
@@ -113056,8 +113155,8 @@ async function migrateCommand(options2) {
     let requestedGlobal = options2.global ?? false;
     let installGlobally = requestedGlobal;
     if (options2.global === undefined && !options2.yes) {
-      const projectTarget = join147(process.cwd(), ".claude");
-      const globalTarget = join147(homedir52(), ".claude");
+      const projectTarget = join148(process.cwd(), ".claude");
+      const globalTarget = join148(homedir52(), ".claude");
       const scopeChoice = await ie({
         message: "Installation scope",
         options: [
@@ -113130,7 +113229,7 @@ async function migrateCommand(options2) {
     }).join(`
 `));
     if (sourceGlobalOnly) {
-      f2.info(import_picocolors30.default.dim(`  Scope: global (--global / -g) - reading from ${formatDisplayPath(join147(homedir52(), ".claude"))}`));
+      f2.info(import_picocolors30.default.dim(`  Scope: global (--global / -g) - reading from ${formatDisplayPath(join148(homedir52(), ".claude"))}`));
     } else {
       f2.info(import_picocolors30.default.dim(`  CWD: ${process.cwd()}`));
     }
@@ -113794,7 +113893,7 @@ async function handleDirectorySetup(ctx) {
 // src/commands/new/phases/project-creation.ts
 init_config_manager();
 init_github_client();
-import { join as join148 } from "node:path";
+import { join as join149 } from "node:path";
 init_logger();
 init_output_manager();
 init_types3();
@@ -113920,7 +114019,7 @@ async function projectCreation(kit, resolvedDir, validOptions, isNonInteractive2
   output.section("Installing");
   logger.verbose("Installation target", { directory: resolvedDir });
   const merger = new FileMerger;
-  const claudeDir3 = join148(resolvedDir, ".claude");
+  const claudeDir3 = join149(resolvedDir, ".claude");
   merger.setMultiKitContext(claudeDir3, kit);
   if (validOptions.exclude && validOptions.exclude.length > 0) {
     merger.addIgnorePatterns(validOptions.exclude);
@@ -113967,28 +114066,28 @@ async function handleProjectCreation(ctx) {
 }
 // src/commands/new/phases/post-setup.ts
 init_projects_registry();
-import { join as join149 } from "node:path";
+import { join as join150 } from "node:path";
 init_package_installer();
 init_logger();
 init_path_resolver();
 async function postSetup(resolvedDir, validOptions, isNonInteractive2, prompts) {
   let installOpenCode2 = validOptions.opencode;
-  let installGemini2 = validOptions.gemini;
+  let installAgy2 = validOptions.gemini;
   let installSkills = validOptions.installSkills;
-  if (!isNonInteractive2 && !installOpenCode2 && !installGemini2 && !installSkills) {
+  if (!isNonInteractive2 && !installOpenCode2 && !installAgy2 && !installSkills) {
     const packageChoices = await prompts.promptPackageInstallations();
     installOpenCode2 = packageChoices.installOpenCode;
-    installGemini2 = packageChoices.installGemini;
+    installAgy2 = packageChoices.installAgy;
     installSkills = await prompts.promptSkillsInstallation();
   }
-  if (installOpenCode2 || installGemini2) {
+  if (installOpenCode2 || installAgy2) {
     logger.info("Installing optional packages...");
     try {
-      const installationResults = await processPackageInstallations(installOpenCode2, installGemini2, resolvedDir);
+      const installationResults = await processPackageInstallations(installOpenCode2, installAgy2, resolvedDir);
       prompts.showPackageInstallationResults(installationResults);
     } catch (error) {
       logger.warning(`Package installation failed: ${error instanceof Error ? error.message : String(error)}`);
-      logger.info("You can install these packages manually later using npm install -g <package>");
+      logger.info("You can install these packages manually later from each tool's official install guide.");
     }
   }
   if (installSkills) {
@@ -113999,9 +114098,9 @@ async function postSetup(resolvedDir, validOptions, isNonInteractive2, prompts)
       withSudo: validOptions.withSudo
     });
   }
-  const claudeDir3 = join149(resolvedDir, ".claude");
+  const claudeDir3 = join150(resolvedDir, ".claude");
   await promptSetupWizardIfNeeded({
-    envPath: join149(claudeDir3, ".env"),
+    envPath: join150(claudeDir3, ".env"),
     claudeDir: claudeDir3,
     isGlobal: false,
     isNonInteractive: isNonInteractive2,
@@ -114071,7 +114170,7 @@ Please use only one download method.`);
 // src/commands/plan/plan-command.ts
 init_output_manager();
 import { existsSync as existsSync74, statSync as statSync13 } from "node:fs";
-import { dirname as dirname52, isAbsolute as isAbsolute14, join as join152, parse as parse7, resolve as resolve53 } from "node:path";
+import { dirname as dirname52, isAbsolute as isAbsolute14, join as join153, parse as parse7, resolve as resolve53 } from "node:path";
 
 // src/commands/plan/plan-read-handlers.ts
 init_config();
@@ -114081,14 +114180,14 @@ init_logger();
 init_output_manager();
 var import_picocolors32 = __toESM(require_picocolors(), 1);
 import { existsSync as existsSync73, statSync as statSync12 } from "node:fs";
-import { basename as basename31, dirname as dirname50, join as join151, relative as relative32, resolve as resolve51 } from "node:path";
+import { basename as basename31, dirname as dirname50, join as join152, relative as relative32, resolve as resolve51 } from "node:path";
 
 // src/commands/plan/plan-dependencies.ts
 init_config();
 init_plan_parser();
 init_plans_registry();
 import { existsSync as existsSync72 } from "node:fs";
-import { dirname as dirname49, join as join150 } from "node:path";
+import { dirname as dirname49, join as join151 } from "node:path";
 async function resolvePlanDependencies(references, currentPlanFile, options2 = {}) {
   if (references.length === 0)
     return [];
@@ -114108,7 +114207,7 @@ async function resolvePlanDependencies(references, currentPlanFile, options2 = {
       };
     }
     const scopeRoot = resolvePlanDirForScope(scope, projectRoot, config);
-    const planFile = join150(scopeRoot, planId, "plan.md");
+    const planFile = join151(scopeRoot, planId, "plan.md");
     const isSelfReference = planFile === currentPlanFile;
     if (!existsSync72(planFile)) {
       return {
@@ -114250,7 +114349,7 @@ async function handleStatus(target, options2) {
   }
   const effectiveTarget = !resolvedTarget && globalBaseDir ? globalBaseDir : resolvedTarget;
   const t = effectiveTarget ? resolve51(effectiveTarget) : null;
-  const plansDir = t && existsSync73(t) && statSync12(t).isDirectory() && !existsSync73(join151(t, "plan.md")) ? t : null;
+  const plansDir = t && existsSync73(t) && statSync12(t).isDirectory() && !existsSync73(join152(t, "plan.md")) ? t : null;
   if (plansDir) {
     const planFiles = scanPlanDir(plansDir);
     if (planFiles.length === 0) {
@@ -114679,7 +114778,7 @@ function resolvePlanFile(target, baseDir) {
     const stat24 = statSync13(t);
     if (stat24.isFile())
       return t;
-    const candidate = join152(t, "plan.md");
+    const candidate = join153(t, "plan.md");
     if (existsSync74(candidate))
       return candidate;
   }
@@ -114687,7 +114786,7 @@ function resolvePlanFile(target, baseDir) {
     let dir = process.cwd();
     const root = parse7(dir).root;
     while (dir !== root) {
-      const candidate = join152(dir, "plan.md");
+      const candidate = join153(dir, "plan.md");
       if (existsSync74(candidate))
         return candidate;
       dir = dirname52(dir);
@@ -115049,7 +115148,7 @@ async function handleEnvironmentConfig(ctx) {
   };
 }
 // src/commands/setup/phases/packages-optional.ts
-init_gemini_installer();
+init_agy_installer();
 init_opencode_installer();
 init_dist2();
 async function handleOptionalPackages(ctx) {
@@ -115079,23 +115178,23 @@ async function handleOptionalPackages(ctx) {
       }
     }
   }
-  const hasGemini = await isGeminiInstalled();
-  if (hasGemini) {
-    f2.success("Google Gemini CLI: already installed");
+  const hasAgy = await isAgyInstalled();
+  if (hasAgy) {
+    f2.success("Antigravity CLI (agy): already installed");
   } else {
-    const installGem = await se({
-      message: "Install Google Gemini CLI? (AI assistant)",
+    const installAgyChoice = await se({
+      message: "Install Antigravity CLI (agy)? (AI assistant)",
       initialValue: false
     });
-    if (lD(installGem)) {
+    if (lD(installAgyChoice)) {
       return { ...ctx, cancelled: true };
     }
-    if (installGem) {
-      const result = await installGemini();
+    if (installAgyChoice) {
+      const result = await installAgy();
       if (result.success) {
-        installedPackages.push("Google Gemini CLI");
+        installedPackages.push("Antigravity CLI (agy)");
       } else {
-        f2.warning(`Failed to install Gemini CLI: ${result.error || "Unknown error"}`);
+        f2.warning(`Failed to install Antigravity CLI (agy): ${result.error || "Unknown error"}`);
       }
     }
   }
@@ -115207,10 +115306,10 @@ init_agents();
 var import_gray_matter12 = __toESM(require_gray_matter(), 1);
 var import_picocolors37 = __toESM(require_picocolors(), 1);
 import { readFile as readFile68 } from "node:fs/promises";
-import { join as join154 } from "node:path";
+import { join as join155 } from "node:path";
 
 // src/commands/skills/installed-skills-inventory.ts
-import { join as join153, resolve as resolve55 } from "node:path";
+import { join as join154, resolve as resolve55 } from "node:path";
 init_path_resolver();
 var SCOPE_SORT_ORDER = {
   project: 0,
@@ -115222,8 +115321,8 @@ async function getActiveClaudeSkillInstallations(options2 = {}) {
   const projectClaudeDir = resolve55(projectDir, ".claude");
   const projectScopeAliasesGlobal = projectClaudeDir === globalDir;
   const [projectSkills, globalSkills] = await Promise.all([
-    projectScopeAliasesGlobal ? Promise.resolve([]) : scanSkills2(join153(projectClaudeDir, "skills")),
-    scanSkills2(join153(globalDir, "skills"))
+    projectScopeAliasesGlobal ? Promise.resolve([]) : scanSkills2(join154(projectClaudeDir, "skills")),
+    scanSkills2(join154(globalDir, "skills"))
   ]);
   const projectIds = new Set(projectSkills.map((skill) => skill.id));
   const globalIds = new Set(globalSkills.map((skill) => skill.id));
@@ -115384,7 +115483,7 @@ async function handleValidate2(sourcePath) {
   spinner.stop(`Checked ${skills.length} skill(s)`);
   let hasIssues = false;
   for (const skill of skills) {
-    const skillMdPath = join154(skill.path, "SKILL.md");
+    const skillMdPath = join155(skill.path, "SKILL.md");
     try {
       const content = await readFile68(skillMdPath, "utf-8");
       const { data } = import_gray_matter12.default(content, {
@@ -115920,7 +116019,7 @@ init_skills_uninstaller();
 // src/domains/installation/plugin/uninstall-plugin.ts
 init_install_mode_detector();
 import { existsSync as existsSync76, rmSync as rmSync6 } from "node:fs";
-import { join as join155 } from "node:path";
+import { join as join156 } from "node:path";
 init_path_resolver();
 async function uninstallEnginePlugin(opts = {}) {
   const claudeDir3 = opts.claudeDir ?? PathResolver.getGlobalKitDir();
@@ -115934,7 +116033,7 @@ async function uninstallEnginePlugin(opts = {}) {
   }
   let staleCacheRemoved = false;
   const marketplace = state.marketplace ?? CK_MARKETPLACE_NAME;
-  const cacheDir = join155(claudeDir3, "plugins", "cache", marketplace, CK_PLUGIN_NAME);
+  const cacheDir = join156(claudeDir3, "plugins", "cache", marketplace, CK_PLUGIN_NAME);
   if (existsSync76(cacheDir)) {
     rmSync6(cacheDir, { recursive: true, force: true });
     staleCacheRemoved = true;
@@ -115992,16 +116091,16 @@ async function detectInstallations() {
 
 // src/commands/uninstall/removal-handler.ts
 import { readdirSync as readdirSync13, rmSync as rmSync8 } from "node:fs";
-import { basename as basename33, join as join157, resolve as resolve56, sep as sep13 } from "node:path";
+import { basename as basename33, join as join159, resolve as resolve56, sep as sep14 } from "node:path";
 init_logger();
 init_safe_prompts();
 init_safe_spinner();
-var import_fs_extra43 = __toESM(require_lib(), 1);
+var import_fs_extra44 = __toESM(require_lib(), 1);
 
 // src/commands/uninstall/analysis-handler.ts
 init_metadata_migration();
 import { readdirSync as readdirSync12, rmSync as rmSync7 } from "node:fs";
-import { dirname as dirname53, join as join156 } from "node:path";
+import { dirname as dirname53, join as join157 } from "node:path";
 init_logger();
 init_safe_prompts();
 var import_fs_extra42 = __toESM(require_lib(), 1);
@@ -116061,7 +116160,7 @@ async function analyzeInstallation(installation, forceOverwrite, kit) {
       const remainingFiles = metadata.kits?.[remainingKit]?.files || [];
       for (const file of remainingFiles) {
         const relativePath = normalizeTrackedPath(file.path);
-        if (await import_fs_extra42.pathExists(join156(installation.path, relativePath))) {
+        if (await import_fs_extra42.pathExists(join157(installation.path, relativePath))) {
           result.retainedManifestPaths.push(relativePath);
         }
       }
@@ -116069,7 +116168,7 @@ async function analyzeInstallation(installation, forceOverwrite, kit) {
     const kitFiles = metadata.kits[kit].files || [];
     for (const trackedFile of kitFiles) {
       const relativePath = normalizeTrackedPath(trackedFile.path);
-      const filePath = join156(installation.path, relativePath);
+      const filePath = join157(installation.path, relativePath);
       if (preservedPaths.has(relativePath)) {
         result.toPreserve.push({ path: relativePath, reason: "shared with other kit" });
         continue;
@@ -116102,7 +116201,7 @@ async function analyzeInstallation(installation, forceOverwrite, kit) {
   }
   for (const trackedFile of allTrackedFiles) {
     const relativePath = normalizeTrackedPath(trackedFile.path);
-    const filePath = join156(installation.path, relativePath);
+    const filePath = join157(installation.path, relativePath);
     const ownershipResult = await OwnershipChecker.checkOwnership(filePath, metadata, installation.path);
     if (!ownershipResult.exists)
       continue;
@@ -116148,10 +116247,170 @@ function displayDryRunPreview(analysis, installationType) {
   }
 }
 
+// src/commands/uninstall/settings-cleanup.ts
+init_settings_merger();
+init_command_normalizer();
+init_logger();
+var import_fs_extra43 = __toESM(require_lib(), 1);
+import { join as join158 } from "node:path";
+var CK_JSON_FILE2 = ".ck.json";
+var SETTINGS_FILE = "settings.json";
+var EMPTY_RESULT = {
+  hooksRemoved: 0,
+  mcpServersRemoved: 0,
+  settingsFileRemoved: false,
+  ckJsonRemoved: false
+};
+function resolveRemovalTargets(kits, removedKitNames, remainingKits) {
+  const retainedHooks = new Set;
+  const retainedServers = new Set;
+  for (const remainingKit of remainingKits) {
+    const installed = kits[remainingKit]?.installedSettings;
+    for (const command of installed?.hooks ?? []) {
+      const normalized = normalizeCommand(command);
+      if (normalized)
+        retainedHooks.add(normalized);
+    }
+    for (const server of installed?.mcpServers ?? []) {
+      retainedServers.add(server);
+    }
+  }
+  const hooks = new Set;
+  const servers = new Set;
+  for (const kitName of removedKitNames) {
+    const installed = kits[kitName]?.installedSettings;
+    for (const command of installed?.hooks ?? []) {
+      const normalized = normalizeCommand(command);
+      if (normalized && !retainedHooks.has(normalized))
+        hooks.add(normalized);
+    }
+    for (const server of installed?.mcpServers ?? []) {
+      if (!retainedServers.has(server))
+        servers.add(server);
+    }
+  }
+  return { hooks, servers };
+}
+function removeHooksFromSettings(settings, normalizedToRemove) {
+  if (!settings.hooks || normalizedToRemove.size === 0)
+    return 0;
+  let removed = 0;
+  const eventKeysToDelete = [];
+  for (const [eventName, entries] of Object.entries(settings.hooks)) {
+    const keptEntries = [];
+    for (const entry of entries) {
+      if (Array.isArray(entry.hooks)) {
+        const keptHooks = entry.hooks.filter((hook) => {
+          if (typeof hook.command === "string" && normalizedToRemove.has(normalizeCommand(hook.command))) {
+            removed++;
+            return false;
+          }
+          return true;
+        });
+        if (keptHooks.length > 0) {
+          keptEntries.push({ ...entry, hooks: keptHooks });
+        }
+        continue;
+      }
+      if (typeof entry.command === "string" && normalizedToRemove.has(normalizeCommand(entry.command))) {
+        removed++;
+        continue;
+      }
+      keptEntries.push(entry);
+    }
+    if (keptEntries.length > 0) {
+      settings.hooks[eventName] = keptEntries;
+    } else {
+      eventKeysToDelete.push(eventName);
+    }
+  }
+  for (const eventName of eventKeysToDelete) {
+    delete settings.hooks[eventName];
+  }
+  if (Object.keys(settings.hooks).length === 0) {
+    Reflect.deleteProperty(settings, "hooks");
+  }
+  return removed;
+}
+function removeMcpServersFromSettings(settings, serversToRemove) {
+  const servers = settings.mcp?.servers;
+  if (!servers || serversToRemove.size === 0)
+    return 0;
+  let removed = 0;
+  for (const name2 of serversToRemove) {
+    if (Object.hasOwn(servers, name2)) {
+      delete servers[name2];
+      removed++;
+    }
+  }
+  if (removed > 0 && settings.mcp) {
+    if (Object.keys(servers).length === 0) {
+      Reflect.deleteProperty(settings.mcp, "servers");
+    }
+    if (Object.keys(settings.mcp).length === 0) {
+      Reflect.deleteProperty(settings, "mcp");
+    }
+  }
+  return removed;
+}
+async function cleanupCkJson(ckJsonPath, data, removedKitNames, dryRun) {
+  if (!data.kits)
+    return false;
+  for (const kitName of removedKitNames) {
+    delete data.kits[kitName];
+  }
+  const noKitsLeft = Object.keys(data.kits).length === 0;
+  const otherTopLevelKeys = Object.keys(data).filter((key) => key !== "kits");
+  if (dryRun)
+    return noKitsLeft && otherTopLevelKeys.length === 0;
+  if (noKitsLeft && otherTopLevelKeys.length === 0) {
+    await import_fs_extra43.remove(ckJsonPath);
+    return true;
+  }
+  if (noKitsLeft) {
+    Reflect.deleteProperty(data, "kits");
+  }
+  await import_fs_extra43.writeFile(ckJsonPath, JSON.stringify(data, null, 2), "utf-8");
+  return false;
+}
+async function cleanupUninstalledSettings(installationPath, options2) {
+  const ckJsonPath = join158(installationPath, CK_JSON_FILE2);
+  if (!await import_fs_extra43.pathExists(ckJsonPath)) {
+    return { ...EMPTY_RESULT };
+  }
+  let data;
+  try {
+    data = parseJsonContent(await import_fs_extra43.readFile(ckJsonPath, "utf-8"));
+  } catch (error) {
+    logger.debug(`Settings cleanup: failed to parse ${ckJsonPath}: ${error instanceof Error ? error.message : "unknown error"}`);
+    return { ...EMPTY_RESULT };
+  }
+  const kits = data.kits ?? {};
+  const removedKitNames = options2.kit ? [options2.kit] : Object.keys(kits);
+  const { hooks, servers } = resolveRemovalTargets(kits, removedKitNames, options2.remainingKits);
+  const result = { ...EMPTY_RESULT };
+  const settingsPath = join158(installationPath, SETTINGS_FILE);
+  const settings = await SettingsMerger.readSettingsFile(settingsPath);
+  if (settings) {
+    result.hooksRemoved = removeHooksFromSettings(settings, hooks);
+    result.mcpServersRemoved = removeMcpServersFromSettings(settings, servers);
+    if (!options2.dryRun && (result.hooksRemoved > 0 || result.mcpServersRemoved > 0)) {
+      if (Object.keys(settings).length === 0) {
+        await import_fs_extra43.remove(settingsPath);
+        result.settingsFileRemoved = true;
+      } else {
+        await SettingsMerger.writeSettingsFile(settingsPath, settings);
+      }
+    }
+  }
+  result.ckJsonRemoved = await cleanupCkJson(ckJsonPath, data, removedKitNames, options2.dryRun ?? false);
+  return result;
+}
+
 // src/commands/uninstall/removal-handler.ts
 async function isDirectory2(filePath) {
   try {
-    const stats = await import_fs_extra43.lstat(filePath);
+    const stats = await import_fs_extra44.lstat(filePath);
     return stats.isDirectory();
   } catch {
     logger.debug(`Failed to check if path is directory: ${filePath}`);
@@ -116159,10 +116418,30 @@ async function isDirectory2(filePath) {
   }
 }
 function getUninstallMutatePaths(options2) {
+  const paths = [];
   if (options2.retainedManifestPaths.length > 0) {
-    return ["metadata.json"];
+    paths.push("metadata.json");
   }
-  return [];
+  if (options2.settingsFileExists) {
+    paths.push("settings.json");
+  }
+  if (options2.ckJsonExists) {
+    paths.push(".ck.json");
+  }
+  return paths;
+}
+function logSettingsCleanup(result, dryRun) {
+  if (result.hooksRemoved === 0 && result.mcpServersRemoved === 0)
+    return;
+  const parts = [];
+  if (result.hooksRemoved > 0) {
+    parts.push(`${result.hooksRemoved} hook${result.hooksRemoved === 1 ? "" : "s"}`);
+  }
+  if (result.mcpServersRemoved > 0) {
+    parts.push(`${result.mcpServersRemoved} MCP server${result.mcpServersRemoved === 1 ? "" : "s"}`);
+  }
+  const verb = dryRun ? "Would remove" : "Removed";
+  log.info(`${verb} ${parts.join(" and ")} from settings.json`);
 }
 async function restoreUninstallBackup(backup) {
   const restoreSpinner = createSpinner("Restoring installation from recovery backup...").start();
@@ -116178,15 +116457,15 @@ async function isPathSafeToRemove(filePath, baseDir) {
   try {
     const resolvedPath = resolve56(filePath);
     const resolvedBase = resolve56(baseDir);
-    if (!resolvedPath.startsWith(resolvedBase + sep13) && resolvedPath !== resolvedBase) {
+    if (!resolvedPath.startsWith(resolvedBase + sep14) && resolvedPath !== resolvedBase) {
       logger.debug(`Path outside installation directory: ${filePath}`);
       return false;
     }
-    const stats = await import_fs_extra43.lstat(filePath);
+    const stats = await import_fs_extra44.lstat(filePath);
     if (stats.isSymbolicLink()) {
-      const realPath = await import_fs_extra43.realpath(filePath);
+      const realPath = await import_fs_extra44.realpath(filePath);
       const resolvedReal = resolve56(realPath);
-      if (!resolvedReal.startsWith(resolvedBase + sep13) && resolvedReal !== resolvedBase) {
+      if (!resolvedReal.startsWith(resolvedBase + sep14) && resolvedReal !== resolvedBase) {
         logger.debug(`Symlink points outside installation directory: ${filePath} -> ${realPath}`);
         return false;
       }
@@ -116208,6 +116487,12 @@ async function removeInstallations(installations, options2) {
         const label = options2.kit ? `${installation.type} (${options2.kit} kit)` : installation.type;
         const legacyLabel2 = !installation.hasMetadata ? " [legacy]" : "";
         displayDryRunPreview(analysis, `${label}${legacyLabel2}`);
+        const settingsPreview = await cleanupUninstalledSettings(installation.path, {
+          kit: options2.kit,
+          remainingKits: analysis.remainingKits,
+          dryRun: true
+        });
+        logSettingsCleanup(settingsPreview, true);
         if (analysis.remainingKits.length > 0) {
           log.info(`Remaining kits after uninstall: ${analysis.remainingKits.join(", ")}`);
         }
@@ -116217,7 +116502,9 @@ async function removeInstallations(installations, options2) {
         continue;
       }
       const mutatePaths = getUninstallMutatePaths({
-        retainedManifestPaths: analysis.retainedManifestPaths
+        retainedManifestPaths: analysis.retainedManifestPaths,
+        settingsFileExists: await import_fs_extra44.pathExists(join159(installation.path, "settings.json")),
+        ckJsonExists: await import_fs_extra44.pathExists(join159(installation.path, ".ck.json"))
       });
       let backup = null;
       if (analysis.toDelete.length > 0 || mutatePaths.length > 0) {
@@ -116245,15 +116532,15 @@ async function removeInstallations(installations, options2) {
         let removedCount = 0;
         let cleanedDirs = 0;
         for (const item of analysis.toDelete) {
-          const filePath = join157(installation.path, item.path);
-          if (!await import_fs_extra43.pathExists(filePath))
+          const filePath = join159(installation.path, item.path);
+          if (!await import_fs_extra44.pathExists(filePath))
             continue;
           if (!await isPathSafeToRemove(filePath, installation.path)) {
             logger.debug(`Skipping unsafe path: ${item.path}`);
             continue;
           }
           const isDir2 = await isDirectory2(filePath);
-          await import_fs_extra43.remove(filePath);
+          await import_fs_extra44.remove(filePath);
           removedCount++;
           logger.debug(`Removed ${isDir2 ? "directory" : "file"}: ${item.path}`);
           if (!isDir2) {
@@ -116269,6 +116556,11 @@ async function removeInstallations(installations, options2) {
             throw new Error("Failed to update metadata.json after partial uninstall");
           }
         }
+        const settingsCleanup = await cleanupUninstalledSettings(installation.path, {
+          kit: options2.kit,
+          remainingKits: analysis.remainingKits
+        });
+        logSettingsCleanup(settingsCleanup, false);
         try {
           const remaining = readdirSync13(installation.path);
           if (remaining.length === 0) {
@@ -116667,7 +116959,7 @@ ${import_picocolors40.default.bold(import_picocolors40.default.cyan(result.kitCo
 init_logger();
 import { existsSync as existsSync82 } from "node:fs";
 import { rm as rm19 } from "node:fs/promises";
-import { join as join164 } from "node:path";
+import { join as join166 } from "node:path";
 var import_picocolors41 = __toESM(require_picocolors(), 1);
 
 // src/commands/watch/phases/implementation-runner.ts
@@ -117185,8 +117477,8 @@ function spawnAndCollect3(command, args) {
 }
 
 // src/commands/watch/phases/issue-processor.ts
-import { mkdir as mkdir40, writeFile as writeFile41 } from "node:fs/promises";
-import { join as join160 } from "node:path";
+import { mkdir as mkdir40, writeFile as writeFile42 } from "node:fs/promises";
+import { join as join162 } from "node:path";
 
 // src/commands/watch/phases/approval-detector.ts
 init_logger();
@@ -117564,9 +117856,9 @@ async function checkAwaitingApproval(state, setup, options2, watchLog, projectDi
 
 // src/commands/watch/phases/plan-dir-finder.ts
 import { readdir as readdir46, stat as stat24 } from "node:fs/promises";
-import { join as join159 } from "node:path";
+import { join as join161 } from "node:path";
 async function findRecentPlanDir(cwd2, issueNumber, watchLog) {
-  const plansRoot = join159(cwd2, "plans");
+  const plansRoot = join161(cwd2, "plans");
   try {
     const entries = await readdir46(plansRoot);
     const tenMinAgo = Date.now() - 10 * 60 * 1000;
@@ -117575,14 +117867,14 @@ async function findRecentPlanDir(cwd2, issueNumber, watchLog) {
     for (const entry of entries) {
       if (entry === "watch" || entry === "reports" || entry === "visuals")
         continue;
-      const dirPath = join159(plansRoot, entry);
+      const dirPath = join161(plansRoot, entry);
       const dirStat = await stat24(dirPath);
       if (!dirStat.isDirectory())
         continue;
       if (dirStat.mtimeMs < tenMinAgo)
         continue;
       try {
-        await stat24(join159(dirPath, "plan.md"));
+        await stat24(join161(dirPath, "plan.md"));
       } catch {
         continue;
       }
@@ -117813,14 +118105,14 @@ async function handlePlanGeneration(issue, state, config, setup, options2, watch
     stats.plansCreated++;
     const detectedPlanDir = await findRecentPlanDir(projectDir, issue.number, watchLog);
     if (detectedPlanDir) {
-      state.activeIssues[numStr].planPath = join160(detectedPlanDir, "plan.md");
+      state.activeIssues[numStr].planPath = join162(detectedPlanDir, "plan.md");
       watchLog.info(`Plan directory detected: ${detectedPlanDir}`);
     } else {
       try {
-        const planDir = join160(projectDir, "plans", "watch");
+        const planDir = join162(projectDir, "plans", "watch");
         await mkdir40(planDir, { recursive: true });
-        const planFilePath = join160(planDir, `issue-${issue.number}-plan.md`);
-        await writeFile41(planFilePath, planResult.planText, "utf-8");
+        const planFilePath = join162(planDir, `issue-${issue.number}-plan.md`);
+        await writeFile42(planFilePath, planResult.planText, "utf-8");
         state.activeIssues[numStr].planPath = planFilePath;
         watchLog.info(`Plan saved (fallback) to ${planFilePath}`);
       } catch (err) {
@@ -117965,7 +118257,7 @@ init_ck_config_manager();
 init_file_io();
 init_logger();
 import { existsSync as existsSync78 } from "node:fs";
-import { mkdir as mkdir41, readFile as readFile70 } from "node:fs/promises";
+import { mkdir as mkdir41, readFile as readFile71 } from "node:fs/promises";
 import { dirname as dirname54 } from "node:path";
 var PROCESSED_ISSUES_CAP = 500;
 async function readCkJson(projectDir) {
@@ -117973,7 +118265,7 @@ async function readCkJson(projectDir) {
   try {
     if (!existsSync78(configPath))
       return {};
-    const content = await readFile70(configPath, "utf-8");
+    const content = await readFile71(configPath, "utf-8");
     return JSON.parse(content);
   } catch (error) {
     logger.warning(`Failed to parse .ck.json: ${error instanceof Error ? error.message : "Unknown"}`);
@@ -118126,18 +118418,18 @@ init_logger();
 import { spawnSync as spawnSync7 } from "node:child_process";
 import { existsSync as existsSync79 } from "node:fs";
 import { readdir as readdir47, stat as stat25 } from "node:fs/promises";
-import { join as join161 } from "node:path";
+import { join as join163 } from "node:path";
 async function scanForRepos(parentDir) {
   const repos = [];
   const entries = await readdir47(parentDir);
   for (const entry of entries) {
     if (entry.startsWith("."))
       continue;
-    const fullPath = join161(parentDir, entry);
+    const fullPath = join163(parentDir, entry);
     const entryStat = await stat25(fullPath);
     if (!entryStat.isDirectory())
       continue;
-    const gitDir = join161(fullPath, ".git");
+    const gitDir = join163(fullPath, ".git");
     if (!existsSync79(gitDir))
       continue;
     const result = spawnSync7("gh", ["repo", "view", "--json", "owner,name"], {
@@ -118164,7 +118456,7 @@ init_logger();
 import { spawnSync as spawnSync8 } from "node:child_process";
 import { existsSync as existsSync80 } from "node:fs";
 import { homedir as homedir53 } from "node:os";
-import { join as join162 } from "node:path";
+import { join as join164 } from "node:path";
 async function validateSetup(cwd2) {
   const workDir = cwd2 ?? process.cwd();
   const ghVersion = spawnSync8("gh", ["--version"], { encoding: "utf-8", timeout: 1e4 });
@@ -118195,7 +118487,7 @@ Run this command from a directory with a GitHub remote.`);
   } catch {
     throw new Error(`Failed to parse repository info: ${ghRepo.stdout}`);
   }
-  const skillsPath = join162(homedir53(), ".claude", "skills");
+  const skillsPath = join164(homedir53(), ".claude", "skills");
   const skillsAvailable = existsSync80(skillsPath);
   if (!skillsAvailable) {
     logger.warning(`ClaudeKit Engineer skills not found at ${skillsPath}`);
@@ -118214,7 +118506,7 @@ init_path_resolver();
 import { createWriteStream as createWriteStream3, statSync as statSync14 } from "node:fs";
 import { existsSync as existsSync81 } from "node:fs";
 import { mkdir as mkdir42, rename as rename15 } from "node:fs/promises";
-import { join as join163 } from "node:path";
+import { join as join165 } from "node:path";
 
 class WatchLogger {
   logStream = null;
@@ -118222,7 +118514,7 @@ class WatchLogger {
   logPath = null;
   maxBytes;
   constructor(logDir, maxBytes = 0) {
-    this.logDir = logDir ?? join163(PathResolver.getClaudeKitDir(), "logs");
+    this.logDir = logDir ?? join165(PathResolver.getClaudeKitDir(), "logs");
     this.maxBytes = maxBytes;
   }
   async init() {
@@ -118231,7 +118523,7 @@ class WatchLogger {
         await mkdir42(this.logDir, { recursive: true });
       }
       const dateStr = formatDate(new Date);
-      this.logPath = join163(this.logDir, `watch-${dateStr}.log`);
+      this.logPath = join165(this.logDir, `watch-${dateStr}.log`);
       this.logStream = createWriteStream3(this.logPath, { flags: "a", mode: 384 });
     } catch (error) {
       logger.warning(`Cannot create watch log file: ${error instanceof Error ? error.message : "Unknown"}`);
@@ -118413,7 +118705,7 @@ async function watchCommand(options2) {
 }
 async function discoverRepos(options2, watchLog) {
   const cwd2 = process.cwd();
-  const isGitRepo = existsSync82(join164(cwd2, ".git"));
+  const isGitRepo = existsSync82(join166(cwd2, ".git"));
   if (options2.force) {
     await forceRemoveLock(watchLog);
   }
@@ -118671,7 +118963,7 @@ function registerCommands(cli) {
 init_package();
 init_config_version_checker();
 import { existsSync as existsSync94, readFileSync as readFileSync26 } from "node:fs";
-import { join as join176 } from "node:path";
+import { join as join178 } from "node:path";
 
 // src/domains/versioning/version-checker.ts
 init_version_utils();
@@ -118685,15 +118977,15 @@ init_types3();
 init_logger();
 init_path_resolver();
 import { existsSync as existsSync93 } from "node:fs";
-import { mkdir as mkdir43, readFile as readFile72, writeFile as writeFile44 } from "node:fs/promises";
-import { join as join175 } from "node:path";
+import { mkdir as mkdir43, readFile as readFile73, writeFile as writeFile45 } from "node:fs/promises";
+import { join as join177 } 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 join175(cacheDir, VersionCacheManager.CACHE_FILENAME);
+    return join177(cacheDir, VersionCacheManager.CACHE_FILENAME);
   }
   static async load() {
     const cacheFile = VersionCacheManager.getCacheFile();
@@ -118702,7 +118994,7 @@ class VersionCacheManager {
         logger.debug("Version check cache not found");
         return null;
       }
-      const content = await readFile72(cacheFile, "utf-8");
+      const content = await readFile73(cacheFile, "utf-8");
       const cache5 = JSON.parse(content);
       if (!cache5.lastCheck || !cache5.currentVersion || !cache5.latestVersion) {
         logger.debug("Invalid cache structure, ignoring");
@@ -118722,7 +119014,7 @@ class VersionCacheManager {
       if (!existsSync93(cacheDir)) {
         await mkdir43(cacheDir, { recursive: true, mode: 448 });
       }
-      await writeFile44(cacheFile, JSON.stringify(cache5, null, 2), "utf-8");
+      await writeFile45(cacheFile, JSON.stringify(cache5, null, 2), "utf-8");
       logger.debug(`Version check cache saved to ${cacheFile}`);
     } catch (error) {
       logger.debug(`Failed to save version check cache: ${error}`);
@@ -119004,9 +119296,9 @@ async function displayVersion() {
   let localInstalledKits = [];
   let globalInstalledKits = [];
   const globalKitDir = PathResolver.getGlobalKitDir();
-  const globalMetadataPath = join176(globalKitDir, "metadata.json");
+  const globalMetadataPath = join178(globalKitDir, "metadata.json");
   const prefix = PathResolver.getPathPrefix(false);
-  const localMetadataPath = prefix ? join176(process.cwd(), prefix, "metadata.json") : join176(process.cwd(), "metadata.json");
+  const localMetadataPath = prefix ? join178(process.cwd(), prefix, "metadata.json") : join178(process.cwd(), "metadata.json");
   const isLocalSameAsGlobal = localMetadataPath === globalMetadataPath;
   if (!isLocalSameAsGlobal && existsSync94(localMetadataPath)) {
     try {
@@ -119394,7 +119686,7 @@ var output2 = new OutputManager2;
 
 // src/shared/temp-cleanup.ts
 init_logger();
-var import_fs_extra44 = __toESM(require_lib(), 1);
+var import_fs_extra45 = __toESM(require_lib(), 1);
 import { rmSync as rmSync9 } from "node:fs";
 var tempDirs2 = new Set;
 async function cleanup() {
@@ -119403,7 +119695,7 @@ async function cleanup() {
   logger.debug(`Cleaning up ${tempDirs2.size} temporary director(ies)...`);
   for (const dir of tempDirs2) {
     try {
-      await import_fs_extra44.remove(dir);
+      await import_fs_extra45.remove(dir);
       logger.debug(`Cleaned up temp directory: ${dir}`);
     } catch (error) {
       logger.debug(`Failed to clean temp directory ${dir}: ${error}`);