claudekit-cli 4.5.0-dev.5 → 4.5.0-dev.7

package/dist/index.js

@@ -52475,11 +52475,56 @@ function getRulesSourcePath(globalOnly = false) {
     return globalPath;
   return findExistingProjectLayoutPath(process.cwd(), "rules") ?? globalPath;
 }
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isClaudeKitPluginEnabled(settings) {
+  if (!isRecord2(settings))
+    return false;
+  const enabledPlugins = settings.enabledPlugins;
+  if (Array.isArray(enabledPlugins)) {
+    return enabledPlugins.includes("ck@claudekit");
+  }
+  return isRecord2(enabledPlugins) && enabledPlugins["ck@claudekit"] === true;
+}
+function readJsonSafe2(filePath) {
+  try {
+    return JSON.parse(readFileSync7(filePath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function resolveConfiguredClaudeKitPluginSourceSubpath(relativePath) {
+  const claudeDir3 = join42(homedir23(), ".claude");
+  const settings = readJsonSafe2(join42(claudeDir3, "settings.json"));
+  if (!isClaudeKitPluginEnabled(settings) || !isRecord2(settings))
+    return null;
+  const marketplaces = settings.extraKnownMarketplaces;
+  const claudekit = isRecord2(marketplaces) ? marketplaces.claudekit : null;
+  const source = isRecord2(claudekit) ? claudekit.source : null;
+  const sourcePath = isRecord2(source) && typeof source.path === "string" ? source.path : null;
+  if (!sourcePath)
+    return null;
+  const candidates = [join42(sourcePath, ".claude", relativePath), join42(sourcePath, relativePath)];
+  return candidates.find((candidate) => existsSync24(candidate)) ?? null;
+}
+function hasAdjacentSettings(sourceDir) {
+  return existsSync24(join42(dirname12(sourceDir), "settings.json"));
+}
+function resolveClaudeKitPluginHooksSourcePath() {
+  const candidates = [
+    resolveConfiguredClaudeKitPluginSourceSubpath("hooks"),
+    resolveInstalledPluginCacheSubpath("hooks", join42(homedir23(), ".claude"))
+  ].filter((path4) => typeof path4 === "string");
+  return candidates.find((candidate) => hasAdjacentSettings(candidate)) ?? null;
+}
 function getHooksSourcePath(globalOnly = false) {
   const globalPath = join42(homedir23(), ".claude", "hooks");
+  const pluginPath = resolveClaudeKitPluginHooksSourcePath();
+  const globalCandidate = pluginPath ?? globalPath;
   if (globalOnly)
-    return globalPath;
-  return findExistingProjectLayoutPath(process.cwd(), "hooks") ?? globalPath;
+    return globalCandidate;
+  return findExistingProjectLayoutPath(process.cwd(), "hooks") ?? globalCandidate;
 }
 async function discoverConfig(sourcePath) {
   const path4 = sourcePath ?? getConfigSourcePath();
@@ -52725,6 +52770,7 @@ async function discoverPortableFiles(dir, baseDir, options2) {
 }
 var HOOK_EXTENSIONS, SHELL_HOOK_EXTENSIONS, HOOK_ASSET_EXTENSIONS, HOOK_DEPENDENCY_SKIP_SEGMENTS, HOOKS_SKIP_DIR_NAMES, HOOKS_COMPANION_DOTFILES;
 var init_config_discovery = __esm(() => {
+  init_install_mode_detector();
   init_kit_layout();
   init_hook_migration_compatibility();
   HOOK_EXTENSIONS = new Set([".js", ".cjs", ".mjs", ".ts"]);
@@ -55317,13 +55363,25 @@ var init_gemini_hook_event_map = __esm(() => {
 });
 
 // src/commands/portable/hooks-settings-merger.ts
-import { existsSync as existsSync27 } from "node:fs";
+import { existsSync as existsSync27, readFileSync as readFileSync8 } from "node:fs";
 import { mkdir as mkdir13, readFile as readFile22, rename as rename8, rm as rm6, writeFile as writeFile13 } from "node:fs/promises";
 import { homedir as homedir26 } from "node:os";
-import { basename as basename14, dirname as dirname16, extname as extname4, join as join45, resolve as resolve20 } from "node:path";
+import { basename as basename14, dirname as dirname16, extname as extname4, isAbsolute as isAbsolute6, join as join45, resolve as resolve20 } from "node:path";
+function resolveSettingsPath(pathValue, isGlobal) {
+  if (isGlobal || isAbsolute6(pathValue))
+    return pathValue;
+  return join45(process.cwd(), pathValue);
+}
 function isCodexWrappableHookPath(filePath) {
   return hookAssetBasename(filePath) !== "node-hook-runner.sh" && CODEX_WRAPPABLE_HOOK_EXTENSIONS.has(extname4(filePath).toLowerCase());
 }
+function collectSourceHookDirs(sourceHooksDirOverride, providerSourceHooksDir) {
+  const dirs = [sourceHooksDirOverride, providerSourceHooksDir].filter((value) => typeof value === "string" && value.length > 0);
+  return Array.from(new Set(dirs));
+}
+function rewriteHookPathsFromSourceDirs(hooks, sourceHooksDirs, targetHooksDir) {
+  return sourceHooksDirs.reduce((currentHooks, sourceHooksDir) => rewriteHookPaths(currentHooks, sourceHooksDir, targetHooksDir), hooks);
+}
 function validateHooksSectionShape(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return "hooks must be a non-null object";
@@ -55523,8 +55581,9 @@ function pruneIncompatibleHookRegistrations(hooks, options2) {
       const keptHooks = group.hooks.filter((entry) => {
         const refs = extractHookReferencesFromCommand(entry.command);
         const targetOwned = commandTargetsHookDir(entry.command, targetHooksDir);
+        const foreignCkOwned = commandTargetsForeignCkHookDir(entry.command, targetHooksDir);
         const incompatible = !isCodexSupportedHookEvent(event) || refs.some((ref) => isExcludedHookAsset(ref));
-        if (targetOwned && incompatible) {
+        if (foreignCkOwned || targetOwned && incompatible) {
           hooksPruned += 1;
           return false;
         }
@@ -55569,10 +55628,44 @@ function commandTargetsHookDir(command, targetHooksDir) {
   const normalizedDir = targetHooksDir.replace(/\\/g, "/").replace(/\/+$/, "");
   return normalizedCommand.includes(`${normalizedDir}/`) || normalizedCommand.includes("$HOME/.codex/hooks/") || normalizedCommand.includes("~/.codex/hooks/");
 }
+function commandTargetsForeignCkHookDir(command, targetHooksDir) {
+  const normalizedCommand = command.replace(/\\/g, "/");
+  const normalizedDir = targetHooksDir.replace(/\\/g, "/").replace(/\/+$/, "");
+  const targetTokens = [
+    `${normalizedDir}/`,
+    "$HOME/.codex/hooks/",
+    "~/.codex/hooks/",
+    ".codex/hooks/"
+  ];
+  if (targetTokens.some((token) => normalizedCommand.includes(token)))
+    return false;
+  return normalizedCommand.includes("$HOME/.claude/hooks/") || normalizedCommand.includes("~/.claude/hooks/") || normalizedCommand.includes(".claude/hooks/");
+}
 function isCkManagedHookPath(absPath) {
   const normalized = absPath.replace(/\\/g, "/");
   return normalized.includes("/.claude/hooks/") || normalized.includes("/.codex/hooks/") || normalized.includes("/.gemini/hooks/");
 }
+function readCodexWrapperOriginalHookPath(wrapperPath) {
+  try {
+    const content = readFileSync8(wrapperPath, "utf8");
+    const match = content.match(/const\s+ORIGINAL_HOOK\s*=\s*("(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*')/);
+    if (!match)
+      return null;
+    const literal = match[1];
+    if (literal.startsWith('"')) {
+      return JSON.parse(literal);
+    }
+    return literal.slice(1, -1).replace(/\\'/g, "'").replace(/\\\\/g, "\\");
+  } catch {
+    return null;
+  }
+}
+function codexWrapperReferencesMissingOriginal(wrapperPath) {
+  const originalPath = readCodexWrapperOriginalHookPath(wrapperPath);
+  if (!originalPath || !isCkManagedHookPath(originalPath))
+    return false;
+  return !existsSync27(originalPath);
+}
 function extractAbsolutePaths(command) {
   const matches = [];
   const pathPattern = /(?:^|[\s"'(])(\/[^\s"'()]+)/g;
@@ -55593,7 +55686,7 @@ function pruneStaleFileHooks(existing) {
         const ckPaths = paths.filter(isCkManagedHookPath);
         if (ckPaths.length === 0)
           return true;
-        return ckPaths.some((p) => existsSync27(p));
+        return ckPaths.some((p) => existsSync27(p) && !codexWrapperReferencesMissingOriginal(p));
       });
       if (survivingHooks.length > 0) {
         prunedGroups.push({ ...group, hooks: survivingHooks });
@@ -55658,7 +55751,7 @@ async function migrateHooksSettings(options2) {
       targetSettingsPath: null
     };
   }
-  const sourceSettingsPath = isGlobal ? sourceConfig.settingsJsonPath?.globalPath : sourceConfig.settingsJsonPath?.projectPath;
+  const sourceSettingsPath = options2.sourceSettingsPath ?? (isGlobal ? sourceConfig.settingsJsonPath?.globalPath : sourceConfig.settingsJsonPath?.projectPath);
   const targetSettingsPath = isGlobal ? targetConfig.settingsJsonPath?.globalPath : targetConfig.settingsJsonPath?.projectPath;
   if (!sourceSettingsPath) {
     return {
@@ -55682,7 +55775,7 @@ async function migrateHooksSettings(options2) {
       targetSettingsPath: null
     };
   }
-  const resolvedSourcePath = isGlobal ? sourceSettingsPath : join45(process.cwd(), sourceSettingsPath);
+  const resolvedSourcePath = resolveSettingsPath(sourceSettingsPath, isGlobal);
   const resolvedTargetPath = isGlobal ? targetSettingsPath : join45(process.cwd(), targetSettingsPath);
   const sourceHooksResult = await inspectHooksSettings(resolvedSourcePath);
   if (sourceHooksResult.status === "missing-file") {
@@ -55730,14 +55823,15 @@ async function migrateHooksSettings(options2) {
       targetSettingsPath: resolvedTargetPath
     };
   }
-  const sourceHooksDir = isGlobal ? sourceConfig.hooks?.globalPath ?? "" : sourceConfig.hooks?.projectPath ?? "";
+  const providerSourceHooksDir = isGlobal ? sourceConfig.hooks?.globalPath ?? "" : sourceConfig.hooks?.projectPath ?? "";
+  const sourceHooksDirs = collectSourceHookDirs(options2.sourceHooksDir, providerSourceHooksDir);
   const targetHooksDir = isGlobal ? targetConfig.hooks?.globalPath ?? "" : targetConfig.hooks?.projectPath ?? "";
   const warnings = [];
   const filtered = filterToInstalledHooks(sourceHooks, installedHookFiles, {
     targetProvider,
     warnings
   });
-  const rewritten = rewriteHookPaths(filtered, sourceHooksDir, targetHooksDir);
+  const rewritten = rewriteHookPathsFromSourceDirs(filtered, sourceHooksDirs, targetHooksDir);
   const eventMapped = mapHookEventsForProvider(rewritten, targetProvider);
   let hooksRegistered = 0;
   for (const groups of Object.values(eventMapped)) {
@@ -55815,7 +55909,7 @@ async function migrateHooksSettingsForCodex(options2) {
     };
   }
   const capabilities = await detectCodexCapabilities();
-  const sourceSettingsPath = isGlobal ? sourceConfig.settingsJsonPath.globalPath : sourceConfig.settingsJsonPath.projectPath;
+  const sourceSettingsPath = options2.sourceSettingsPath ?? (isGlobal ? sourceConfig.settingsJsonPath.globalPath : sourceConfig.settingsJsonPath.projectPath);
   const targetSettingsPath = isGlobal ? codexConfig.settingsJsonPath?.globalPath ?? null : codexConfig.settingsJsonPath?.projectPath ?? null;
   if (!targetSettingsPath) {
     return {
@@ -55828,7 +55922,7 @@ async function migrateHooksSettingsForCodex(options2) {
       targetSettingsPath: null
     };
   }
-  const resolvedSourcePath = isGlobal ? sourceSettingsPath : join45(process.cwd(), sourceSettingsPath);
+  const resolvedSourcePath = resolveSettingsPath(sourceSettingsPath, isGlobal);
   const resolvedTargetPath = isGlobal ? targetSettingsPath : join45(process.cwd(), targetSettingsPath);
   const projectDir = isGlobal ? undefined : process.cwd();
   const sourceHooksResult = await inspectHooksSettings(resolvedSourcePath);
@@ -55875,7 +55969,9 @@ async function migrateHooksSettingsForCodex(options2) {
     warnings
   });
   const targetHooksDir = isGlobal ? codexConfig.hooks?.globalPath ?? "" : codexConfig.hooks?.projectPath ?? "";
-  const sourceHooksDir = isGlobal ? sourceConfig.hooks?.globalPath ?? "" : sourceConfig.hooks?.projectPath ?? "";
+  const providerSourceHooksDir = isGlobal ? sourceConfig.hooks?.globalPath ?? "" : sourceConfig.hooks?.projectPath ?? "";
+  const sourceHooksDir = options2.sourceHooksDir ?? providerSourceHooksDir;
+  const sourceHookCommandDirs = collectSourceHookDirs(options2.sourceHooksDir, providerSourceHooksDir);
   const wrapperPaths = [];
   const commandSubstitutions = new Map;
   if (installedHookAbsolutePaths && installedHookAbsolutePaths.length > 0 && targetHooksDir) {
@@ -55891,11 +55987,11 @@ async function migrateHooksSettingsForCodex(options2) {
           addKey(join45(targetHooksDir, base));
           addKey(`./${join45(targetHooksDir, base)}`);
         }
-        if (sourceHooksDir) {
-          const sourceAbs = join45(resolve20(sourceHooksDir), base);
+        for (const commandSourceHooksDir of sourceHookCommandDirs) {
+          const sourceAbs = join45(resolve20(commandSourceHooksDir), base);
           addKey(sourceAbs);
-          addKey(join45(sourceHooksDir, base));
-          addKey(`./${join45(sourceHooksDir, base)}`);
+          addKey(join45(commandSourceHooksDir, base));
+          addKey(`./${join45(commandSourceHooksDir, base)}`);
           if (sourceAbs.startsWith("/private/")) {
             addKey(sourceAbs.slice("/private".length));
           } else if (sourceAbs.startsWith("/var/")) {
@@ -55905,7 +56001,8 @@ async function migrateHooksSettingsForCodex(options2) {
       }
     }
   }
-  if (!sourceHooksDir) {
+  const pathRewriteSourceDir = providerSourceHooksDir || sourceHooksDir;
+  if (!pathRewriteSourceDir) {
     const convertedNoRewrite = convertClaudeHooksToCodex(filtered, capabilities);
     let hooksRegisteredNoRewrite = 0;
     for (const groups of Object.values(convertedNoRewrite)) {
@@ -55944,7 +56041,7 @@ async function migrateHooksSettingsForCodex(options2) {
   }
   const effectiveTargetDir = targetHooksDir || sourceHooksDir;
   const converted = convertClaudeHooksToCodex(filtered, capabilities, {
-    sourceDir: sourceHooksDir,
+    sourceDir: pathRewriteSourceDir,
     targetDir: effectiveTargetDir,
     commandSubstitutions: commandSubstitutions.size > 0 ? commandSubstitutions : undefined,
     projectDir
@@ -56055,7 +56152,7 @@ var init_generated_context_hooks = __esm(() => {
 // src/commands/portable/migrated-hook-settings-cleanup.ts
 import { existsSync as existsSync28, realpathSync } from "node:fs";
 import { readFile as readFile23, rename as rename9, rm as rm7, unlink as unlink7, writeFile as writeFile14 } from "node:fs/promises";
-import { basename as basename16, isAbsolute as isAbsolute6, relative as relative10, resolve as resolve21 } from "node:path";
+import { basename as basename16, isAbsolute as isAbsolute7, relative as relative10, resolve as resolve21 } from "node:path";
 async function pruneSettingsHooks(settingsPath, hooksDir) {
   const filesToRemove = new Set;
   const warnings = [];
@@ -56138,7 +56235,7 @@ function hookFilesFromCommand(command, hooksDir) {
     const name = basename16(cleaned);
     if (!name || !isGeneratedContextHookName(name))
       continue;
-    if (isAbsolute6(cleaned) && isPathWithin(cleaned, hooksDir))
+    if (isAbsolute7(cleaned) && isPathWithin(cleaned, hooksDir))
       files.add(resolve21(cleaned));
     else if (referencesHooksDir(cleaned, hooksDir) || cleaned.includes(".claude/hooks/")) {
       files.add(resolve21(hooksDir, name));
@@ -56153,7 +56250,7 @@ function referencesHooksDir(command, hooksDir) {
 }
 function isPathWithin(filePath, parentDir) {
   const rel = relative10(resolvePathForContainment(parentDir), resolvePathForContainment(filePath));
-  return rel === "" || !!rel && !rel.startsWith("..") && !isAbsolute6(rel);
+  return rel === "" || !!rel && !rel.startsWith("..") && !isAbsolute7(rel);
 }
 function resolvePathForContainment(pathValue) {
   try {
@@ -56186,7 +56283,7 @@ __export(exports_migrated_hooks_cleanup, {
   isGeneratedContextHookName: () => isGeneratedContextHookName,
   cleanupMigratedHooksForProviders: () => cleanupMigratedHooksForProviders
 });
-import { isAbsolute as isAbsolute7, resolve as resolve22 } from "node:path";
+import { isAbsolute as isAbsolute8, resolve as resolve22 } from "node:path";
 async function cleanupMigratedHooksForProviders(providerIds, options2) {
   const uniqueProviders = Array.from(new Set(providerIds));
   const results = [];
@@ -56240,7 +56337,7 @@ async function cleanupMigratedHooksForProvider(provider, options2) {
 function resolveProviderPath(pathValue) {
   if (!pathValue)
     return null;
-  return isAbsolute7(pathValue) ? pathValue : resolve22(process.cwd(), pathValue);
+  return isAbsolute8(pathValue) ? pathValue : resolve22(process.cwd(), pathValue);
 }
 var init_migrated_hooks_cleanup = __esm(() => {
   init_generated_context_hooks();
@@ -59296,10 +59393,10 @@ var init_migration_routes = __esm(() => {
 });
 
 // src/domains/plan-parser/plan-metadata.ts
-import { readFileSync as readFileSync8, statSync as statSync7 } from "node:fs";
+import { readFileSync as readFileSync9, statSync as statSync7 } from "node:fs";
 function readMatter(filePath) {
   try {
-    return import_gray_matter6.default(readFileSync8(filePath, "utf8")).data;
+    return import_gray_matter6.default(readFileSync9(filePath, "utf8")).data;
   } catch {
     return {};
   }
@@ -59406,7 +59503,7 @@ var init_plan_metadata = __esm(() => {
 });
 
 // src/domains/plan-parser/plan-table-parser.ts
-import { readFileSync as readFileSync9 } from "node:fs";
+import { readFileSync as readFileSync10 } from "node:fs";
 import { dirname as dirname18, resolve as resolve24 } from "node:path";
 function normalizeStatus(raw) {
   const s = raw.toLowerCase().trim();
@@ -59771,7 +59868,7 @@ function parsePhasesFromBody(body, dir, options2) {
   return parseFormat6(normalizedBody, dir, options2);
 }
 function parsePlanFile(planFilePath, options2) {
-  const content = readFileSync9(planFilePath, "utf8");
+  const content = readFileSync10(planFilePath, "utf8");
   const dir = dirname18(planFilePath);
   const { data: frontmatter, content: body } = import_gray_matter7.default(content, {
     engines: { javascript: { parse: () => ({}) } }
@@ -59919,13 +60016,13 @@ var init_plan_scanner = () => {};
 
 // src/domains/plan-parser/plan-scope.ts
 import { homedir as homedir29 } from "node:os";
-import { isAbsolute as isAbsolute8, join as join50, relative as relative12, resolve as resolve25 } from "node:path";
+import { isAbsolute as isAbsolute9, join as join50, relative as relative12, resolve as resolve25 } from "node:path";
 function resolveConfiguredDir(configuredPath, baseDir) {
   const trimmed = configuredPath?.trim();
   if (!trimmed) {
     return join50(baseDir, DEFAULT_PLANS_DIRNAME);
   }
-  return isAbsolute8(trimmed) ? resolve25(trimmed) : resolve25(baseDir, trimmed);
+  return isAbsolute9(trimmed) ? resolve25(trimmed) : resolve25(baseDir, trimmed);
 }
 function resolveProjectPlansDir(projectRoot, config) {
   return resolveConfiguredDir(config?.paths?.plans, projectRoot);
@@ -59940,7 +60037,7 @@ function isWithinDir(targetPath, baseDir) {
   const resolvedTarget = resolve25(targetPath);
   const resolvedBase = resolve25(baseDir);
   const relativePath = relative12(resolvedBase, resolvedTarget);
-  return relativePath === "" || !relativePath.startsWith("..") && relativePath !== ".." && !isAbsolute8(relativePath);
+  return relativePath === "" || !relativePath.startsWith("..") && relativePath !== ".." && !isAbsolute9(relativePath);
 }
 function inferPlanScopeForDir(planDir, config) {
   return isWithinDir(planDir, resolveGlobalPlansDir(config)) ? "global" : "project";
@@ -59949,7 +60046,7 @@ function parsePlanReference(reference, defaultScope) {
   const trimmed = reference.trim();
   const normalizePlanId = (rawPlanId) => {
     const planId = rawPlanId.trim();
-    const valid = planId.length > 0 && !isAbsolute8(planId) && !planId.includes("/") && !planId.includes("\\") && PLAN_ID_PATTERN.test(planId);
+    const valid = planId.length > 0 && !isAbsolute9(planId) && !planId.includes("/") && !planId.includes("\\") && PLAN_ID_PATTERN.test(planId);
     return { planId, valid };
   };
   if (trimmed.startsWith(GLOBAL_PLAN_PREFIX)) {
@@ -60067,10 +60164,10 @@ var init_timeline_builder = __esm(() => {
 });
 
 // src/domains/plan-parser/plan-validator.ts
-import { existsSync as existsSync34, readFileSync as readFileSync10 } from "node:fs";
+import { existsSync as existsSync34, readFileSync as readFileSync11 } from "node:fs";
 import { basename as basename18, dirname as dirname19 } from "node:path";
 function validatePlanFile(filePath, strict = false) {
-  const rawContent = readFileSync10(filePath, "utf8");
+  const rawContent = readFileSync11(filePath, "utf8");
   const content = rawContent.replace(/\r\n/g, `
 `);
   const dir = dirname19(filePath);
@@ -60137,7 +60234,7 @@ var init_plan_validator = __esm(() => {
 
 // src/domains/plan-parser/plan-writer.ts
 import { execSync } from "node:child_process";
-import { mkdirSync as mkdirSync2, readFileSync as readFileSync11, writeFileSync as writeFileSync3 } from "node:fs";
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync12, writeFileSync as writeFileSync3 } from "node:fs";
 import { existsSync as existsSync35 } from "node:fs";
 import { basename as basename19, dirname as dirname20, join as join52 } from "node:path";
 function phaseNameToFilename(id, name) {
@@ -60310,7 +60407,7 @@ function isCanonicalFormat(content) {
   return /^\|\s*phase\s*\|\s*name\s*\|\s*status\s*\|/im.test(content);
 }
 function updatePhaseStatus(planFile, phaseId, newStatus) {
-  const raw = readFileSync11(planFile, "utf8").replace(/\r\n/g, `
+  const raw = readFileSync12(planFile, "utf8").replace(/\r\n/g, `
 `);
   if (!isCanonicalFormat(raw)) {
     console.error("[!] plan.md is not in canonical format — skipping status update");
@@ -60372,7 +60469,7 @@ function phaseNameFilenameFromTableRow(body, phaseId, planDir) {
   return null;
 }
 function updatePhaseFileFrontmatter(phaseFile, newStatus) {
-  const raw = readFileSync11(phaseFile, "utf8");
+  const raw = readFileSync12(phaseFile, "utf8");
   const { data: frontmatter, content: body } = import_gray_matter9.default(raw, {
     engines: { javascript: { parse: () => ({}) } }
   });
@@ -60380,7 +60477,7 @@ function updatePhaseFileFrontmatter(phaseFile, newStatus) {
   writeFileSync3(phaseFile, import_gray_matter9.default.stringify(body, updated), "utf8");
 }
 function addPhase(planFile, name, afterId) {
-  const raw = readFileSync11(planFile, "utf8").replace(/\r\n/g, `
+  const raw = readFileSync12(planFile, "utf8").replace(/\r\n/g, `
 `);
   if (!isCanonicalFormat(raw)) {
     console.error("[!] plan.md is not in canonical format — cannot add phase");
@@ -60725,12 +60822,12 @@ var init_plan_types = __esm(() => {
 import {
   existsSync as existsSync36,
   mkdirSync as mkdirSync3,
-  readFileSync as readFileSync12,
+  readFileSync as readFileSync13,
   renameSync,
   unlinkSync,
   writeFileSync as writeFileSync4
 } from "node:fs";
-import { dirname as dirname22, isAbsolute as isAbsolute9, join as join53, parse as parse2, relative as relative13, resolve as resolve26 } from "node:path";
+import { dirname as dirname22, isAbsolute as isAbsolute10, join as join53, parse as parse2, relative as relative13, resolve as resolve26 } from "node:path";
 function createEmptyRegistry() {
   return {
     version: 1,
@@ -60756,7 +60853,7 @@ function migrateFromProjectLocal(cwd2, globalPath) {
     return;
   }
   try {
-    const oldData = JSON.parse(readFileSync12(oldPath, "utf8"));
+    const oldData = JSON.parse(readFileSync13(oldPath, "utf8"));
     if (oldData && typeof oldData === "object" && Array.isArray(oldData.plans)) {
       const migrated = {
         version: 1,
@@ -60785,7 +60882,7 @@ function migrateFromProjectLocal(cwd2, globalPath) {
   }
 }
 function normalizeRegistryDir(cwd2, dir) {
-  const absoluteDir = isAbsolute9(dir) ? dir : resolve26(cwd2, dir);
+  const absoluteDir = isAbsolute10(dir) ? dir : resolve26(cwd2, dir);
   const relativeDir = relative13(cwd2, absoluteDir) || dir;
   return relativeDir.replace(/\\/g, "/");
 }
@@ -60807,7 +60904,7 @@ function readRegistry(cwd2 = process.cwd()) {
     return createEmptyRegistry();
   }
   try {
-    const parsed = PlansRegistrySchema.safeParse(JSON.parse(readFileSync12(globalPath, "utf8")));
+    const parsed = PlansRegistrySchema.safeParse(JSON.parse(readFileSync13(globalPath, "utf8")));
     return parsed.success ? parsed.data : createEmptyRegistry();
   } catch {
     return createEmptyRegistry();
@@ -60820,7 +60917,7 @@ function writeRegistry(registry, cwd2 = process.cwd()) {
   mkdirSync3(dirname22(globalPath), { recursive: true });
   if (existsSync36(globalPath)) {
     try {
-      writeFileSync4(`${globalPath}.bak`, readFileSync12(globalPath));
+      writeFileSync4(`${globalPath}.bak`, readFileSync13(globalPath));
     } catch {}
   }
   const tempPath = `${globalPath}.tmp-${process.pid}-${Date.now()}`;
@@ -61202,7 +61299,7 @@ var init_p_limit = __esm(() => {
 });
 
 // src/domains/web-server/routes/plan-routes.ts
-import { existsSync as existsSync37, readFileSync as readFileSync13, realpathSync as realpathSync2 } from "node:fs";
+import { existsSync as existsSync37, readFileSync as readFileSync14, realpathSync as realpathSync2 } from "node:fs";
 import { homedir as homedir30 } from "node:os";
 import { basename as basename20, dirname as dirname24, join as join55, relative as relative14, resolve as resolve27, sep as sep8 } from "node:path";
 function sanitizeError(err) {
@@ -61251,7 +61348,7 @@ function getGlobalPlanRoot() {
     if (!existsSync37(configPath)) {
       value = resolveGlobalPlansDir();
     } else {
-      const raw = JSON.parse(readFileSync13(configPath, "utf8"));
+      const raw = JSON.parse(readFileSync14(configPath, "utf8"));
       const parsed = CkConfigSchema.parse(normalizeCkConfigInput(raw));
       value = resolveGlobalPlansDir(parsed);
     }
@@ -61581,7 +61678,7 @@ function registerPlanRoutes(app) {
       return;
     }
     try {
-      const raw = readFileSync13(file, "utf8");
+      const raw = readFileSync14(file, "utf8");
       const parsed = import_gray_matter10.default(raw);
       res.json({
         file: relative14(process.cwd(), file),
@@ -63153,12 +63250,12 @@ function getCliVersion3() {
     if (process.env.npm_package_version) {
       return process.env.npm_package_version;
     }
-    const { readFileSync: readFileSync14 } = __require("node:fs");
+    const { readFileSync: readFileSync15 } = __require("node:fs");
     const { dirname: dirname27, join: joinPath } = __require("node:path");
     const { fileURLToPath: fileURLToPath2 } = __require("node:url");
     const __dirname3 = dirname27(fileURLToPath2(import.meta.url));
     const pkgPath = joinPath(__dirname3, "../../../package.json");
-    const pkg = JSON.parse(readFileSync14(pkgPath, "utf-8"));
+    const pkg = JSON.parse(readFileSync15(pkgPath, "utf-8"));
     return pkg.version || "unknown";
   } catch {
     return "unknown";
@@ -64421,7 +64518,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "claudekit-cli",
-    version: "4.5.0-dev.5",
+    version: "4.5.0-dev.7",
     description: "CLI tool for bootstrapping and updating ClaudeKit projects",
     type: "module",
     repository: {
@@ -64923,7 +65020,7 @@ var init_package_manager_runner = __esm(() => {
 // src/domains/installation/merger/zombie-wirings-pruner.ts
 import { existsSync as existsSync45, readdirSync as readdirSync8 } from "node:fs";
 import { homedir as homedir39 } from "node:os";
-import { basename as basename23, dirname as dirname28, isAbsolute as isAbsolute10, resolve as resolve32, sep as sep10 } from "node:path";
+import { basename as basename23, dirname as dirname28, isAbsolute as isAbsolute11, resolve as resolve32, sep as sep10 } from "node:path";
 function pruneZombieEngineerWirings(settings, hookDir, preserveCommands = new Set) {
   const pruned = [];
   const normalizedPreserveCommands = new Set(Array.from(preserveCommands).map((command) => normalizeCommand(command)));
@@ -65021,7 +65118,7 @@ function extractHookFilePath(command, hookDir) {
     const bashMatch = command.match(/^bash\s+["']([^"']+\.sh)["']/);
     if (bashMatch) {
       const rawPath = bashMatch[1].replace(/\\/g, "/");
-      const resolved = isAbsolute10(rawPath) || /^[A-Za-z]:[\\/]/.test(rawPath) ? rawPath : resolve32(hookDir, rawPath);
+      const resolved = isAbsolute11(rawPath) || /^[A-Za-z]:[\\/]/.test(rawPath) ? rawPath : resolve32(hookDir, rawPath);
       return process.platform === "win32" ? resolved.replace(/\//g, sep10) : resolved;
     }
     return null;
@@ -65043,7 +65140,7 @@ function extractHookFilePath(command, hookDir) {
       return process.platform === "win32" ? resolved.replace(/\//g, sep10) : resolved;
     }
     const tildeResolved = rawArg.replace(/^~(?=\/)/, home5);
-    if (isAbsolute10(tildeResolved) || /^[A-Za-z]:[\\/]/.test(tildeResolved)) {
+    if (isAbsolute11(tildeResolved) || /^[A-Za-z]:[\\/]/.test(tildeResolved)) {
       return process.platform === "win32" ? tildeResolved.replace(/\//g, sep10) : tildeResolved;
     }
     return resolve32(hookDir, tildeResolved);
@@ -65057,7 +65154,7 @@ function extractHookFilePath(command, hookDir) {
       return process.platform === "win32" ? resolved.replace(/\//g, sep10) : resolved;
     }
     const tildeResolved = rawArg.replace(/^~(?=\/)/, home5);
-    if (isAbsolute10(tildeResolved) || /^[A-Za-z]:[\\/]/.test(tildeResolved)) {
+    if (isAbsolute11(tildeResolved) || /^[A-Za-z]:[\\/]/.test(tildeResolved)) {
       return process.platform === "win32" ? tildeResolved.replace(/\//g, sep10) : tildeResolved;
     }
     return resolve32(hookDir, tildeResolved);
@@ -65080,7 +65177,7 @@ var init_shared2 = __esm(() => {
 
 // src/domains/health-checks/checkers/hook-health-checker.ts
 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 { existsSync as existsSync46, readFileSync as readFileSync15, 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, sep as sep11 } from "node:path";
@@ -65120,7 +65217,7 @@ function readManagedHookNamesForClaudeDir(claudeDir3) {
   if (!existsSync46(manifestPath))
     return new Set;
   try {
-    const data = JSON.parse(readFileSync14(manifestPath, "utf-8"));
+    const data = JSON.parse(readFileSync15(manifestPath, "utf-8"));
     if (!Array.isArray(data.managedHooks))
       return new Set;
     return new Set(data.managedHooks.filter((name) => typeof name === "string"));
@@ -65591,7 +65688,7 @@ async function checkHookDeps(projectDir) {
       const filePath = join65(hooksDir, file);
       if (!isPathWithin2(filePath, hooksDir))
         continue;
-      const content = readFileSync14(filePath, "utf-8");
+      const content = readFileSync15(filePath, "utf-8");
       for (let match = requireRegex.exec(content);match !== null; match = requireRegex.exec(content)) {
         const depPath = match[1];
         if (depPath.startsWith("node:") || isNodeBuiltin(depPath)) {
@@ -66140,7 +66237,7 @@ async function checkHookConfig(projectDir) {
     };
   }
   try {
-    const configContent = readFileSync14(configPath, "utf-8");
+    const configContent = readFileSync15(configPath, "utf-8");
     const config = JSON.parse(configContent);
     if (!config.hooks || typeof config.hooks !== "object") {
       return {
@@ -66276,7 +66373,7 @@ async function checkHookLogs(projectDir) {
         }
       };
     }
-    const logContent = readFileSync14(logPath, "utf-8");
+    const logContent = readFileSync15(logPath, "utf-8");
     const lines = logContent.trim().split(`
 `).filter(Boolean);
     const now = Date.now();
@@ -74784,6 +74881,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) {
@@ -74968,100 +75223,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 { existsSync as existsSync62, readFileSync as readFileSync20, unlinkSync as unlinkSync3 } from "node:fs";
+import { join as join92 } from "node:path";
 function parseNameReason(str2) {
   const colonIndex = str2.indexOf(":");
   if (colonIndex === -1) {
@@ -75124,14 +75288,14 @@ 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;
   }
   let summary;
   try {
-    summary = JSON.parse(readFileSync19(summaryPath, "utf-8"));
+    summary = JSON.parse(readFileSync20(summaryPath, "utf-8"));
   } catch (parseError) {
     logger.error("Failed to parse error summary. File may be corrupted.");
     logger.debug(`Parse error: ${parseError instanceof Error ? parseError.message : String(parseError)}`);
@@ -75223,7 +75387,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;
@@ -75241,7 +75405,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";
@@ -75267,7 +75431,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) {
@@ -75283,7 +75447,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");
@@ -75330,7 +75494,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,
@@ -75451,7 +75615,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");
@@ -75494,10 +75658,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");
@@ -75508,36 +75672,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}`);
@@ -75552,8 +75719,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";
@@ -75564,10 +75731,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) {
@@ -75578,12 +75749,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";
@@ -75594,19 +75765,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);
@@ -75622,41 +75794,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)) {
@@ -75667,14 +75839,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 {
@@ -75690,21 +75862,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 {
@@ -75713,50 +75885,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();
@@ -75773,11 +75945,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,
@@ -75786,9 +75958,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()) {
@@ -75810,28 +75983,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);
       }
     }
   }
@@ -75840,13 +76013,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();
 });
 
@@ -78084,9 +78257,9 @@ __export(exports_worktree_manager, {
 });
 import { existsSync as existsSync77 } from "node:fs";
 import { readFile as readFile70, writeFile as writeFile41 } from "node:fs/promises";
-import { join as join159 } from "node:path";
+import { join as join160 } from "node:path";
 async function createWorktree(projectDir, issueNumber, baseBranch) {
-  const worktreePath = join159(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`);
@@ -78104,7 +78277,7 @@ async function createWorktree(projectDir, issueNumber, baseBranch) {
   return worktreePath;
 }
 async function removeWorktree(projectDir, issueNumber) {
-  const worktreePath = join159(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);
@@ -78118,7 +78291,7 @@ async function listActiveWorktrees(projectDir) {
   try {
     const output2 = await spawnAndCollect("git", ["worktree", "list", "--porcelain"], projectDir);
     const issueNumbers = [];
-    const worktreePrefix = join159(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 ")) {
@@ -78146,7 +78319,7 @@ async function cleanupAllWorktrees(projectDir) {
   await spawnAndCollect("git", ["worktree", "prune"], projectDir).catch(() => {});
 }
 async function ensureGitignore(projectDir) {
-  const gitignorePath = join159(projectDir, ".gitignore");
+  const gitignorePath = join160(projectDir, ".gitignore");
   try {
     const content = existsSync77(gitignorePath) ? await readFile70(gitignorePath, "utf-8") : "";
     if (!content.includes(".worktrees")) {
@@ -78250,16 +78423,16 @@ 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 { existsSync as existsSync83, mkdirSync as mkdirSync7, readFileSync as readFileSync23, readdirSync as readdirSync14, statSync as statSync15 } from "node:fs";
 import { rename as rename16, writeFile as writeFile43 } from "node:fs/promises";
 import { homedir as homedir54 } from "node:os";
-import { basename as basename34, join as join166 } from "node:path";
+import { basename as basename34, join as join167 } from "node:path";
 function getCachedContext(repoPath) {
   const cachePath = getCacheFilePath(repoPath);
   if (!existsSync83(cachePath))
     return null;
   try {
-    const raw2 = readFileSync22(cachePath, "utf-8");
+    const raw2 = readFileSync23(cachePath, "utf-8");
     const cache5 = JSON.parse(raw2);
     const age = Date.now() - new Date(cache5.createdAt).getTime();
     if (age >= CACHE_TTL_MS5)
@@ -78296,25 +78469,25 @@ function computeSourceHash(repoPath) {
 }
 function getDocSourcePaths(repoPath) {
   const paths = [];
-  const docsDir = join166(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(join166(docsDir, f3));
+          paths.push(join167(docsDir, f3));
       }
     } catch {}
   }
-  const readme = join166(repoPath, "README.md");
+  const readme = join167(repoPath, "README.md");
   if (existsSync83(readme))
     paths.push(readme);
-  const stylesDir = join166(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(join166(stylesDir, f3));
+        paths.push(join167(stylesDir, f3));
       }
     } catch {}
   }
@@ -78323,11 +78496,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 join166(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 = join166(homedir54(), ".claudekit", "cache");
+  CACHE_DIR = join167(homedir54(), ".claudekit", "cache");
   CACHE_TTL_MS5 = 24 * 60 * 60 * 1000;
 });
 
@@ -78507,8 +78680,8 @@ 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 join167 } from "node:path";
+import { existsSync as existsSync84, readFileSync as readFileSync24, readdirSync as readdirSync15 } from "node:fs";
+import { join as join168 } from "node:path";
 async function summarizeProjectDocs(repoPath, contentLogger) {
   const rawContent = collectRawDocs(repoPath);
   if (rawContent.total.length < 200) {
@@ -78556,18 +78729,18 @@ function collectRawDocs(repoPath) {
       return "";
     if (totalChars >= MAX_RAW_CONTENT_CHARS)
       return "";
-    const content = readFileSync23(filePath, "utf-8");
+    const content = readFileSync24(filePath, "utf-8");
     const capped = content.slice(0, Math.min(maxChars, MAX_RAW_CONTENT_CHARS - totalChars));
     totalChars += capped.length;
     return capped;
   };
   const docsContent = [];
-  const docsDir = join167(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(join167(docsDir, f3), 5000);
+        const content = readCapped(join168(docsDir, f3), 5000);
         if (content) {
           docsContent.push(`### ${f3}
 ${content}`);
@@ -78581,21 +78754,21 @@ ${content}`);
   let brand = "";
   const brandCandidates = ["docs/brand-guidelines.md", "docs/design-guidelines.md"];
   for (const p of brandCandidates) {
-    brand = readCapped(join167(repoPath, p), 3000);
+    brand = readCapped(join168(repoPath, p), 3000);
     if (brand)
       break;
   }
   let styles3 = "";
-  const stylesDir = join167(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(join167(stylesDir, f3), 1000)).filter(Boolean).join(`
+      styles3 = files.map((f3) => readCapped(join168(stylesDir, f3), 1000)).filter(Boolean).join(`
 
 `);
     } catch {}
   }
-  const readme = readCapped(join167(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 };
@@ -78782,9 +78955,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 join168 } from "node:path";
+import { join as join169 } from "node:path";
 async function generatePhoto(_content, context, config, platform18, contentId, contentLogger) {
-  const mediaDir = join168(config.contentDir.replace(/^~/, homedir55()), "media", String(contentId));
+  const mediaDir = join169(config.contentDir.replace(/^~/, homedir55()), "media", String(contentId));
   if (!existsSync85(mediaDir)) {
     mkdirSync8(mediaDir, { recursive: true });
   }
@@ -78809,7 +78982,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: join168(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;
@@ -78899,7 +79072,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 join169 } from "node:path";
+import { join as join170 } from "node:path";
 
 class ContentLogger {
   stream = null;
@@ -78907,7 +79080,7 @@ class ContentLogger {
   logDir;
   maxBytes;
   constructor(maxBytes = 0) {
-    this.logDir = join169(homedir56(), ".claudekit", "logs");
+    this.logDir = join170(homedir56(), ".claudekit", "logs");
     this.maxBytes = maxBytes;
   }
   init() {
@@ -78939,7 +79112,7 @@ class ContentLogger {
     }
   }
   getLogPath() {
-    return join169(this.logDir, `content-${this.getDateStr()}.log`);
+    return join170(this.logDir, `content-${this.getDateStr()}.log`);
   }
   write(level, message) {
     this.rotateIfNeeded();
@@ -78956,18 +79129,18 @@ class ContentLogger {
     if (dateStr !== this.currentDate) {
       this.close();
       this.currentDate = dateStr;
-      const logPath = join169(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 = join169(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 = join169(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 });
         }
@@ -79050,7 +79223,7 @@ var init_sqlite_client = __esm(() => {
 
 // src/commands/content/phases/db-manager.ts
 import { existsSync as existsSync87, mkdirSync as mkdirSync10 } from "node:fs";
-import { dirname as dirname55 } from "node:path";
+import { dirname as dirname56 } from "node:path";
 function initDatabase(dbPath) {
   ensureParentDir(dbPath);
   const db = openDatabase(dbPath);
@@ -79071,7 +79244,7 @@ function runRetentionCleanup(db, retentionDays = 90) {
   db.prepare("DELETE FROM git_events WHERE processed = 1 AND created_at < ?").run(cutoff);
 }
 function ensureParentDir(dbPath) {
-  const dir = dirname55(dbPath);
+  const dir = dirname56(dbPath);
   if (dir && !existsSync87(dir)) {
     mkdirSync10(dir, { recursive: true });
   }
@@ -79237,8 +79410,8 @@ 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 join170 } from "node:path";
+import { existsSync as existsSync88, readFileSync as readFileSync25, readdirSync as readdirSync17, statSync as statSync17 } from "node:fs";
+import { join as join171 } from "node:path";
 function detectCommits(repo, since) {
   try {
     const fetchUrl = sshToHttps(repo.remoteUrl);
@@ -79347,7 +79520,7 @@ function detectTags(repo, since) {
   }
 }
 function detectCompletedPlans(repo, since) {
-  const plansDir = join170(repo.path, "plans");
+  const plansDir = join171(repo.path, "plans");
   if (!existsSync88(plansDir))
     return [];
   const sinceMs = new Date(since).getTime();
@@ -79357,14 +79530,14 @@ function detectCompletedPlans(repo, since) {
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
-      const planFile = join170(plansDir, entry.name, "plan.md");
+      const planFile = join171(plansDir, entry.name, "plan.md");
       if (!existsSync88(planFile))
         continue;
       try {
         const stat26 = statSync17(planFile);
         if (stat26.mtimeMs < sinceMs)
           continue;
-        const content = readFileSync24(planFile, "utf-8");
+        const content = readFileSync25(planFile, "utf-8");
         const frontmatterMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
         if (!frontmatterMatch)
           continue;
@@ -79435,7 +79608,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 join171 } from "node:path";
+import { join as join172 } from "node:path";
 function discoverRepos2(cwd2) {
   const repos = [];
   if (isGitRepoRoot(cwd2)) {
@@ -79448,7 +79621,7 @@ function discoverRepos2(cwd2) {
     for (const entry of entries) {
       if (!entry.isDirectory() || entry.name.startsWith("."))
         continue;
-      const dirPath = join171(cwd2, entry.name);
+      const dirPath = join172(cwd2, entry.name);
       if (isGitRepoRoot(dirPath)) {
         const info = getRepoInfo(dirPath);
         if (info)
@@ -80116,9 +80289,9 @@ var init_types6 = __esm(() => {
 
 // src/commands/content/phases/state-manager.ts
 import { readFile as readFile72, rename as rename17, writeFile as writeFile44 } from "node:fs/promises";
-import { join as join172 } from "node:path";
+import { join as join173 } from "node:path";
 async function loadContentConfig(projectDir) {
-  const configPath = join172(projectDir, CK_CONFIG_FILE2);
+  const configPath = join173(projectDir, CK_CONFIG_FILE2);
   try {
     const raw2 = await readFile72(configPath, "utf-8");
     const json = JSON.parse(raw2);
@@ -80128,13 +80301,13 @@ async function loadContentConfig(projectDir) {
   }
 }
 async function saveContentConfig(projectDir, config) {
-  const configPath = join172(projectDir, CK_CONFIG_FILE2);
-  const json = await readJsonSafe4(configPath);
+  const configPath = join173(projectDir, CK_CONFIG_FILE2);
+  const json = await readJsonSafe5(configPath);
   json.content = { ...json.content, ...config };
   await atomicWrite3(configPath, json);
 }
 async function loadContentState(projectDir) {
-  const configPath = join172(projectDir, CK_CONFIG_FILE2);
+  const configPath = join173(projectDir, CK_CONFIG_FILE2);
   try {
     const raw2 = await readFile72(configPath, "utf-8");
     const json = JSON.parse(raw2);
@@ -80145,7 +80318,7 @@ async function loadContentState(projectDir) {
   }
 }
 async function saveContentState(projectDir, state) {
-  const configPath = join172(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);
@@ -80154,14 +80327,14 @@ async function saveContentState(projectDir, state) {
     }
   }
   ContentStateSchema.parse(state);
-  const json = await readJsonSafe4(configPath);
+  const json = await readJsonSafe5(configPath);
   if (!json.content || typeof json.content !== "object") {
     json.content = {};
   }
   json.content.state = state;
   await atomicWrite3(configPath, json);
 }
-async function readJsonSafe4(filePath) {
+async function readJsonSafe5(filePath) {
   try {
     const raw2 = await readFile72(filePath, "utf-8");
     return JSON.parse(raw2);
@@ -80427,7 +80600,7 @@ var init_platform_setup_x = __esm(() => {
 
 // src/commands/content/phases/setup-wizard.ts
 import { existsSync as existsSync89 } from "node:fs";
-import { join as join173 } 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 ")));
@@ -80495,8 +80668,8 @@ async function showRepoSummary(cwd2) {
 function detectBrandAssets(cwd2, contentLogger) {
   const repos = discoverRepos2(cwd2);
   for (const repo of repos) {
-    const hasGuidelines = existsSync89(join173(repo.path, "docs", "brand-guidelines.md"));
-    const hasStyles = existsSync89(join173(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`);
@@ -80636,15 +80809,15 @@ __export(exports_content_subcommands, {
   logsContent: () => logsContent,
   approveContentCmd: () => approveContentCmd
 });
-import { existsSync as existsSync91, readFileSync as readFileSync25, unlinkSync as unlinkSync6 } from "node:fs";
+import { existsSync as existsSync91, readFileSync as readFileSync26, unlinkSync as unlinkSync6 } from "node:fs";
 import { homedir as homedir58 } from "node:os";
-import { join as join174 } from "node:path";
+import { join as join175 } from "node:path";
 function isDaemonRunning() {
-  const lockFile = join174(LOCK_DIR, `${LOCK_NAME2}.lock`);
+  const lockFile = join175(LOCK_DIR, `${LOCK_NAME2}.lock`);
   if (!existsSync91(lockFile))
     return { running: false, pid: null };
   try {
-    const pidStr = readFileSync25(lockFile, "utf-8").trim();
+    const pidStr = readFileSync26(lockFile, "utf-8").trim();
     const pid = Number.parseInt(pidStr, 10);
     if (Number.isNaN(pid)) {
       unlinkSync6(lockFile);
@@ -80672,13 +80845,13 @@ async function startContent(options2) {
   await contentCommand(options2);
 }
 async function stopContent() {
-  const lockFile = join174(LOCK_DIR, `${LOCK_NAME2}.lock`);
+  const lockFile = join175(LOCK_DIR, `${LOCK_NAME2}.lock`);
   if (!existsSync91(lockFile)) {
     logger.info("Content daemon is not running.");
     return;
   }
   try {
-    const pidStr = readFileSync25(lockFile, "utf-8").trim();
+    const pidStr = readFileSync26(lockFile, "utf-8").trim();
     const pid = Number.parseInt(pidStr, 10);
     if (!Number.isNaN(pid)) {
       process.kill(pid, "SIGTERM");
@@ -80711,9 +80884,9 @@ async function statusContent() {
   } catch {}
 }
 async function logsContent(options2) {
-  const logDir = join174(homedir58(), ".claudekit", "logs");
+  const logDir = join175(homedir58(), ".claudekit", "logs");
   const dateStr = new Date().toISOString().slice(0, 10).replace(/-/g, "");
-  const logPath = join174(logDir, `content-${dateStr}.log`);
+  const logPath = join175(logDir, `content-${dateStr}.log`);
   if (!existsSync91(logPath)) {
     logger.info("No content logs found for today.");
     return;
@@ -80726,7 +80899,7 @@ async function logsContent(options2) {
       process.exit(0);
     });
   } else {
-    const content = readFileSync25(logPath, "utf-8");
+    const content = readFileSync26(logPath, "utf-8");
     console.log(content);
   }
 }
@@ -80745,13 +80918,13 @@ var init_content_subcommands = __esm(() => {
   init_setup_wizard();
   init_state_manager();
   init_content_review_commands();
-  LOCK_DIR = join174(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 join175 } from "node:path";
+import { join as join176 } from "node:path";
 async function contentCommand(options2) {
   const cwd2 = process.cwd();
   const contentLogger = new ContentLogger;
@@ -80929,8 +81102,8 @@ var init_content_command = __esm(() => {
   init_publisher();
   init_review_manager();
   init_state_manager();
-  LOCK_DIR2 = join175(homedir59(), ".claudekit", "locks");
-  LOCK_FILE = join175(LOCK_DIR2, "ck-content.lock");
+  LOCK_DIR2 = join176(homedir59(), ".claudekit", "locks");
+  LOCK_FILE = join176(LOCK_DIR2, "ck-content.lock");
 });
 
 // src/commands/content/index.ts
@@ -88101,7 +88274,7 @@ import { promisify as promisify14 } from "node:util";
 // src/domains/github/gh-cli-utils.ts
 init_environment();
 init_logger();
-import { readFileSync as readFileSync15 } from "node:fs";
+import { readFileSync as readFileSync16 } from "node:fs";
 var MIN_GH_CLI_VERSION = "2.20.0";
 var GH_COMMAND_TIMEOUT_MS = 1e4;
 function compareVersions6(a3, b3) {
@@ -88122,7 +88295,7 @@ function isWSL2() {
   if (process.platform !== "linux")
     return false;
   try {
-    const release = readFileSync15("/proc/version", "utf-8").toLowerCase();
+    const release = readFileSync16("/proc/version", "utf-8").toLowerCase();
     return release.includes("microsoft") || release.includes("wsl");
   } catch (error) {
     logger.debug(`WSL detection skipped: ${error instanceof Error ? error.message : "unknown error"}`);
@@ -88951,7 +89124,7 @@ function checkClaudeMdFile(path7, name, id) {
   }
 }
 // src/domains/health-checks/checkers/active-plan-checker.ts
-import { existsSync as existsSync53, readFileSync as readFileSync17 } from "node:fs";
+import { existsSync as existsSync53, readFileSync as readFileSync18 } from "node:fs";
 import { join as join74 } from "node:path";
 function checkActivePlan(projectDir) {
   const activePlanPath = join74(projectDir, ".claude", "active-plan");
@@ -88967,7 +89140,7 @@ function checkActivePlan(projectDir) {
     };
   }
   try {
-    const targetPath = readFileSync17(activePlanPath, "utf-8").trim();
+    const targetPath = readFileSync18(activePlanPath, "utf-8").trim();
     const fullPath = join74(projectDir, targetPath);
     if (!existsSync53(fullPath)) {
       return {
@@ -91508,7 +91681,7 @@ class AutoHealer {
 }
 // src/domains/health-checks/report-generator.ts
 import { execSync as execSync4, spawnSync as spawnSync6 } from "node:child_process";
-import { readFileSync as readFileSync18, unlinkSync as unlinkSync2, writeFileSync as writeFileSync6 } from "node:fs";
+import { readFileSync as readFileSync19, unlinkSync as unlinkSync2, writeFileSync as writeFileSync6 } from "node:fs";
 import { tmpdir as tmpdir3 } from "node:os";
 import { dirname as dirname33, join as join88 } from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
@@ -91519,7 +91692,7 @@ function getCliVersion4() {
   try {
     const __dirname4 = dirname33(fileURLToPath4(import.meta.url));
     const pkgPath = join88(__dirname4, "../../../package.json");
-    const pkg = JSON.parse(readFileSync18(pkgPath, "utf-8"));
+    const pkg = JSON.parse(readFileSync19(pkgPath, "utf-8"));
     return pkg.version || "unknown";
   } catch (err) {
     logger.debug(`Failed to read CLI version: ${err}`);
@@ -91999,7 +92172,7 @@ init_config_version_checker();
 
 // src/domains/sync/sync-engine.ts
 import { lstat as lstat6, readFile as readFile48, readlink as readlink2, realpath as realpath8, stat as stat14 } from "node:fs/promises";
-import { isAbsolute as isAbsolute11, join as join89, normalize as normalize8, relative as relative18 } from "node:path";
+import { isAbsolute as isAbsolute12, join as join89, normalize as normalize8, relative as relative18 } from "node:path";
 
 // src/services/file-operations/ownership-checker.ts
 init_metadata_migration();
@@ -93214,10 +93387,10 @@ async function validateSymlinkChain(path8, basePath, maxDepth = MAX_SYMLINK_DEPT
       if (!stats.isSymbolicLink())
         break;
       const target = await readlink2(current);
-      const resolvedTarget = isAbsolute11(target) ? target : join89(current, "..", target);
+      const resolvedTarget = isAbsolute12(target) ? target : join89(current, "..", target);
       const normalizedTarget = normalize8(resolvedTarget);
       const rel = relative18(basePath, normalizedTarget);
-      if (rel.startsWith("..") || isAbsolute11(rel)) {
+      if (rel.startsWith("..") || isAbsolute12(rel)) {
         throw new Error(`Symlink chain escapes base directory at depth ${depth}: ${path8}`);
       }
       current = normalizedTarget;
@@ -93244,7 +93417,7 @@ async function validateSyncPath(basePath, filePath) {
     throw new Error(`Path too long: ${filePath.slice(0, 50)}...`);
   }
   const normalized = normalize8(filePath);
-  if (isAbsolute11(normalized)) {
+  if (isAbsolute12(normalized)) {
     throw new Error(`Absolute paths not allowed: ${filePath}`);
   }
   if (normalized.startsWith("..") || normalized.includes("/../")) {
@@ -93252,7 +93425,7 @@ async function validateSyncPath(basePath, filePath) {
   }
   const fullPath = join89(basePath, normalized);
   const rel = relative18(basePath, fullPath);
-  if (rel.startsWith("..") || isAbsolute11(rel)) {
+  if (rel.startsWith("..") || isAbsolute12(rel)) {
     throw new Error(`Path escapes base directory: ${filePath}`);
   }
   await validateSymlinkChain(fullPath, basePath);
@@ -93260,7 +93433,7 @@ async function validateSyncPath(basePath, filePath) {
     const resolvedBase = await realpath8(basePath);
     const resolvedFull = await realpath8(fullPath);
     const resolvedRel = relative18(resolvedBase, resolvedFull);
-    if (resolvedRel.startsWith("..") || isAbsolute11(resolvedRel)) {
+    if (resolvedRel.startsWith("..") || isAbsolute12(resolvedRel)) {
       throw new Error(`Symlink escapes base directory: ${filePath}`);
     }
   } catch (error) {
@@ -93270,7 +93443,7 @@ async function validateSyncPath(basePath, filePath) {
         const resolvedBase = await realpath8(basePath);
         const resolvedParent = await realpath8(parentPath);
         const resolvedRel = relative18(resolvedBase, resolvedParent);
-        if (resolvedRel.startsWith("..") || isAbsolute11(resolvedRel)) {
+        if (resolvedRel.startsWith("..") || isAbsolute12(resolvedRel)) {
           throw new Error(`Parent symlink escapes base directory: ${filePath}`);
         }
       } catch (parentError) {
@@ -94174,7 +94347,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?"
@@ -94216,7 +94389,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}`);
@@ -94386,12 +94559,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 {
@@ -94403,20 +94576,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() {
@@ -94432,11 +94605,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) {
@@ -94444,7 +94617,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) {
@@ -94493,7 +94666,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;
@@ -94502,7 +94675,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;
   }
@@ -94517,7 +94690,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");
@@ -94614,7 +94787,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();
@@ -94633,7 +94806,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();
@@ -94843,7 +95016,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", {
@@ -94928,7 +95101,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 = {};
@@ -95014,7 +95187,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);
@@ -95033,7 +95206,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;
       }
@@ -95043,7 +95216,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;
       }
@@ -95068,7 +95241,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";
@@ -99119,11 +99292,11 @@ var modeFix = (mode, isDir2, portable) => {
 
 // node_modules/tar/dist/esm/strip-absolute-path.js
 import { win32 as win322 } from "node:path";
-var { isAbsolute: isAbsolute12, parse: parse5 } = win322;
+var { isAbsolute: isAbsolute13, parse: parse5 } = win322;
 var stripAbsolutePath = (path8) => {
   let r2 = "";
   let parsed = parse5(path8);
-  while (isAbsolute12(path8) || parsed.root) {
+  while (isAbsolute13(path8) || parsed.root) {
     const root = path8.charAt(0) === "/" && path8.slice(0, 4) !== "//?/" ? "/" : parsed.root;
     path8 = path8.slice(root.length);
     r2 += root;
@@ -100830,7 +101003,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);
@@ -100863,7 +101036,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;
@@ -100877,7 +101050,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 });
@@ -101937,7 +102110,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 {
@@ -101959,8 +102132,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}`);
@@ -101987,8 +102160,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}`);
@@ -102036,7 +102209,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" });
@@ -102052,7 +102225,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");
@@ -102074,7 +102247,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
@@ -102166,7 +102339,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" });
@@ -102182,7 +102355,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");
@@ -102283,7 +102456,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}`);
@@ -102300,7 +102473,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}`);
@@ -102760,20 +102933,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 sep12 } 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;
   }
@@ -102959,7 +103132,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));
@@ -103027,7 +103200,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;
   }
@@ -103082,7 +103255,7 @@ 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}${sep12}`)) {
@@ -103122,7 +103295,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";
@@ -103298,7 +103471,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,
@@ -103326,7 +103499,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);
@@ -103376,7 +103549,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) => {
@@ -104832,7 +105005,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);
@@ -104868,13 +105041,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 {
@@ -104888,9 +105061,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();
@@ -105158,10 +105331,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"}`);
@@ -105548,7 +105721,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() {
@@ -105568,7 +105741,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;
     }
@@ -105665,7 +105838,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;
@@ -105806,7 +105979,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}`);
@@ -105830,7 +106003,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++;
@@ -106042,15 +106215,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}$/),
@@ -106065,7 +106238,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);
@@ -106088,12 +106261,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;
@@ -106165,7 +106338,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;
@@ -106197,7 +106370,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, "/")));
@@ -106378,7 +106551,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({
@@ -106489,7 +106662,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);
@@ -106599,7 +106772,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());
@@ -106620,7 +106793,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;
@@ -106726,7 +106899,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) {
@@ -106742,7 +106915,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;
@@ -106777,8 +106950,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}"`);
@@ -106819,12 +106992,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",
@@ -106884,7 +107057,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;
@@ -106959,14 +107132,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) {
@@ -106974,7 +107147,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");
@@ -106984,17 +107157,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
@@ -107012,7 +107185,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()
@@ -107050,20 +107223,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;
@@ -107191,8 +107364,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,
@@ -107234,7 +107407,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);
@@ -107291,7 +107464,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 {
@@ -107330,7 +107503,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);
   }
@@ -107359,8 +107532,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)) {
@@ -107418,7 +107591,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();
@@ -107434,7 +107607,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";
@@ -107456,12 +107629,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;
@@ -107484,7 +107657,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) {
@@ -107503,7 +107676,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,
@@ -107515,11 +107688,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,
@@ -107549,7 +107722,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;
       }
@@ -107671,7 +107844,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", []];
@@ -107684,12 +107857,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) {
@@ -107846,12 +108019,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
@@ -108016,8 +108189,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;
     }
@@ -108032,7 +108205,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) {
@@ -108053,9 +108226,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);
@@ -108122,7 +108295,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`);
@@ -108148,7 +108321,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 });
@@ -108199,7 +108372,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) {
@@ -108227,8 +108400,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;
       }
@@ -108244,7 +108417,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;
       }
@@ -108280,12 +108453,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;
     }
@@ -108412,7 +108585,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`);
@@ -108433,13 +108606,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) {
@@ -108449,7 +108622,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));
       }
@@ -108459,7 +108632,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 };
   }
@@ -108468,8 +108641,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 };
     }
@@ -108563,7 +108736,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}`);
       }
@@ -108624,7 +108797,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;
@@ -108648,13 +108821,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/";
@@ -108715,7 +108888,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;
@@ -108754,7 +108927,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;
@@ -108772,8 +108945,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}`);
@@ -108872,7 +109045,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);
@@ -108881,8 +109054,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);
@@ -108905,24 +109078,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
         });
       }
@@ -108930,7 +109103,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,
@@ -108952,13 +109125,13 @@ 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 { cpSync as cpSync2, existsSync as existsSync69, mkdirSync as mkdirSync6, readFileSync as readFileSync22, rmSync as rmSync4, writeFileSync as writeFileSync8 } from "node:fs";
+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 { cpSync, existsSync as existsSync68, mkdirSync as mkdirSync5, readFileSync as readFileSync21, rmSync as rmSync3, writeFileSync as writeFileSync7 } from "node:fs";
+import { dirname as dirname43, join as join135 } from "node:path";
 
 // src/domains/installation/plugin/plugin-installer.ts
 init_install_mode_detector();
@@ -109090,7 +109263,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);
   }
@@ -109124,7 +109297,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 = readJsonSafe3(join135(claudeDir3, "metadata.json"));
   const files = collectTrackedFiles2(meta);
   const removed = [];
   for (const file of files) {
@@ -109132,10 +109305,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 });
@@ -109148,22 +109321,22 @@ function isPluginSuppliedLegacyPath(pathValue) {
   return PLUGIN_SUPPLIED_LEGACY_PREFIXES2.some((prefix) => normalized.startsWith(prefix));
 }
 function collectTrackedFiles2(meta) {
-  if (!isRecord2(meta))
+  if (!isRecord3(meta))
     return [];
   const out = [];
   const push2 = (arr) => {
     if (!Array.isArray(arr))
       return;
     for (const f3 of arr) {
-      if (isRecord2(f3) && typeof f3.path === "string") {
+      if (isRecord3(f3) && typeof f3.path === "string") {
         const ownership = f3.ownership === "user" || f3.ownership === "ck-modified" ? f3.ownership : "ck";
         out.push({ path: f3.path, ownership });
       }
     }
   };
-  if (isRecord2(meta.kits)) {
+  if (isRecord3(meta.kits)) {
     const engineer = meta.kits[ENGINEER_KIT_KEY];
-    if (isRecord2(engineer))
+    if (isRecord3(engineer))
       push2(engineer.files);
   } else {
     push2(meta.files);
@@ -109171,22 +109344,22 @@ function collectTrackedFiles2(meta) {
   return out;
 }
 function writeReceipt(claudeDir3, receipt) {
-  const receiptPath = join134(claudeDir3, ".ck-migration-log.json");
-  const existing = readJsonSafe2(receiptPath);
+  const receiptPath = join135(claudeDir3, ".ck-migration-log.json");
+  const existing = readJsonSafe3(receiptPath);
   const history = Array.isArray(existing) ? existing : [];
   history.push(receipt);
   writeFileSync7(receiptPath, `${JSON.stringify(history, null, 2)}
 `, "utf-8");
   return receiptPath;
 }
-function readJsonSafe2(filePath) {
+function readJsonSafe3(filePath) {
   try {
-    return JSON.parse(readFileSync20(filePath, "utf-8"));
+    return JSON.parse(readFileSync21(filePath, "utf-8"));
   } catch {
     return null;
   }
 }
-function isRecord2(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -109220,14 +109393,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 = {
@@ -109235,8 +109408,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",
@@ -109250,16 +109423,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 = readJsonSafe4(join136(pluginRoot, ".claude-plugin", "plugin.json"));
   const manifest = pruneUndefined({
     name: stringField(claudeManifest, "name") ?? "ck",
     version: stringField(claudeManifest, "version") ?? "0.0.0",
@@ -109280,14 +109453,14 @@ 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");
 }
-function readJsonSafe3(filePath) {
+function readJsonSafe4(filePath) {
   try {
-    const parsed = JSON.parse(readFileSync21(filePath, "utf-8"));
-    return isRecord3(parsed) ? parsed : null;
+    const parsed = JSON.parse(readFileSync22(filePath, "utf-8"));
+    return isRecord4(parsed) ? parsed : null;
   } catch {
     return null;
   }
@@ -109298,7 +109471,7 @@ function stringField(source, key) {
 }
 function authorField(source) {
   const author = source?.author;
-  if (isRecord3(author) && typeof author.name === "string" && author.name.trim() !== "") {
+  if (isRecord4(author) && typeof author.name === "string" && author.name.trim() !== "") {
     return { name: author.name };
   }
   return { name: "ClaudeKit" };
@@ -109306,7 +109479,7 @@ function authorField(source) {
 function pruneUndefined(value) {
   return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined));
 }
-function isRecord3(value) {
+function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function logPluginResult(result) {
@@ -109345,7 +109518,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();
@@ -109518,7 +109691,7 @@ 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);
@@ -109600,7 +109773,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;
     }
@@ -109628,7 +109801,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)) {
@@ -109659,8 +109832,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 {
@@ -109682,7 +109855,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++;
@@ -109690,7 +109863,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");
@@ -109768,7 +109941,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",
@@ -109807,10 +109980,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`);
@@ -109828,7 +110001,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;
     }
   }
@@ -110130,7 +110303,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) {
@@ -110167,7 +110340,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 };
@@ -110187,7 +110360,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) {
@@ -110256,7 +110429,7 @@ 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)) {
@@ -110285,7 +110458,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);
@@ -110295,13 +110468,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.
@@ -110401,7 +110574,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 });
@@ -110447,11 +110620,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);
@@ -110513,7 +110686,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) {
@@ -110684,7 +110857,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);
       }
@@ -110699,7 +110872,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();
@@ -110710,38 +110883,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)
       });
     }
   }
@@ -110782,7 +110955,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",
@@ -110835,7 +111008,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;
@@ -110972,7 +111145,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() {
@@ -110982,7 +111155,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)
@@ -111113,7 +111286,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;
@@ -111192,7 +111365,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,
@@ -111419,7 +111592,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, dirname as dirname49, join as join148, resolve as resolve48 } from "node:path";
 init_logger();
 
 // src/ui/ck-cli-design/next-steps-footer.ts
@@ -111634,13 +111807,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) {
@@ -111652,13 +111825,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);
@@ -111733,14 +111906,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);
@@ -111842,9 +112015,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 {
@@ -112717,7 +112890,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"
       });
     }
@@ -112935,10 +113108,28 @@ function createSkippedPathMigrationCleanupResult2(action) {
     skipReason: "Legacy path cleanup skipped because no successful replacement write was recorded"
   };
 }
+function resolveHookTargetPath(item, provider, global3) {
+  const pathConfig = providers[provider].hooks;
+  if (!pathConfig)
+    return null;
+  const basePath = global3 ? pathConfig.globalPath : pathConfig.projectPath;
+  if (!basePath)
+    return null;
+  const converted = convertItem(item, pathConfig.format, provider, { global: global3 });
+  if (converted.error)
+    return null;
+  const targetPath = pathConfig.writeStrategy === "single-file" ? basePath : join148(basePath, converted.filename);
+  const resolvedTarget = resolve48(targetPath).replace(/\\/g, "/");
+  const resolvedBase = resolve48(basePath).replace(/\\/g, "/").replace(/\/+$/, "");
+  if (resolvedTarget !== resolvedBase && !resolvedTarget.startsWith(`${resolvedBase}/`)) {
+    return null;
+  }
+  return targetPath;
+}
 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;
@@ -112951,7 +113142,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 {
@@ -113079,8 +113270,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: [
@@ -113153,7 +113344,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()}`));
     }
@@ -113342,23 +113533,31 @@ async function migrateCommand(options2) {
     }
     const progressSink = createMigrateProgressSink(writeTasks.length + plannedDeleteActions.length);
     const writtenPaths = new Set;
+    const recordHookTargetForSettings = (provider, global3, targetPath) => {
+      if (targetPath.length === 0 || !existsSync71(targetPath))
+        return;
+      const resolvedPath = resolve48(targetPath);
+      const entry = successfulHookFiles.get(provider) ?? {
+        files: [],
+        global: global3
+      };
+      const hookFile = basename30(targetPath);
+      if (!entry.files.includes(hookFile))
+        entry.files.push(hookFile);
+      successfulHookFiles.set(provider, entry);
+      const absExisting = successfulHookAbsPaths.get(provider) ?? [];
+      if (!absExisting.includes(resolvedPath)) {
+        absExisting.push(resolvedPath);
+        successfulHookAbsPaths.set(provider, absExisting);
+      }
+    };
     const recordSuccessfulWrites = (task, taskResults) => {
-      for (const result of taskResults.filter((entry) => entry.success && !entry.skipped)) {
-        if (result.path.length > 0) {
+      for (const result of taskResults.filter((entry) => entry.success)) {
+        if (!result.skipped && result.path.length > 0) {
           writtenPaths.add(resolve48(result.path));
         }
         if (task.type === "hooks") {
-          const existing = successfulHookFiles.get(task.provider) ?? {
-            files: [],
-            global: task.global
-          };
-          existing.files.push(basename30(result.path));
-          successfulHookFiles.set(task.provider, existing);
-          if (result.path.length > 0) {
-            const absExisting = successfulHookAbsPaths.get(task.provider) ?? [];
-            absExisting.push(resolve48(result.path));
-            successfulHookAbsPaths.set(task.provider, absExisting);
-          }
+          recordHookTargetForSettings(task.provider, task.global, result.path);
         }
       }
     };
@@ -113393,6 +113592,18 @@ async function migrateCommand(options2) {
       recordSuccessfulWrites(task, taskResults);
       progressSink.tick(progressLabelForType(task.type));
     }
+    if (hooksSource && effectiveHookItems.length > 0) {
+      for (const provider of selectedProviders) {
+        if (!getProvidersSupporting("hooks").includes(provider))
+          continue;
+        const global3 = resolvePortableTypeGlobal(provider, "hooks", installGlobally);
+        for (const item of effectiveHookItems) {
+          const targetPath = resolveHookTargetPath(item, provider, global3);
+          if (targetPath)
+            recordHookTargetForSettings(provider, global3, targetPath);
+        }
+      }
+    }
     if (selectedProviders.includes("opencode")) {
       try {
         const result = await ensureOpenCodeModel({
@@ -113442,12 +113653,15 @@ async function migrateCommand(options2) {
     for (const [hooksProvider, entry] of successfulHookFiles) {
       if (entry.files.length === 0)
         continue;
+      const sourceSettingsPath = hooksSource ? join148(dirname49(hooksSource), "settings.json") : undefined;
       const mergeResult = await migrateHooksSettings({
         sourceProvider: "claude-code",
         targetProvider: hooksProvider,
         installedHookFiles: entry.files,
         installedHookAbsolutePaths: successfulHookAbsPaths.get(hooksProvider),
-        global: entry.global
+        global: entry.global,
+        sourceSettingsPath,
+        sourceHooksDir: hooksSource ?? undefined
       });
       appendMigrationWarningMessages(postProgressWarnings, mergeResult.warnings);
       if (mergeResult.success && mergeResult.hooksRegistered > 0) {
@@ -113817,7 +114031,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();
@@ -113943,7 +114157,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);
@@ -113990,28 +114204,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) {
@@ -114022,9 +114236,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,
@@ -114094,7 +114308,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 dirname53, isAbsolute as isAbsolute15, join as join153, parse as parse7, resolve as resolve53 } from "node:path";
 
 // src/commands/plan/plan-read-handlers.ts
 init_config();
@@ -114104,18 +114318,18 @@ 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 dirname51, 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 dirname50, join as join151 } from "node:path";
 async function resolvePlanDependencies(references, currentPlanFile, options2 = {}) {
   if (references.length === 0)
     return [];
-  const currentPlanDir = dirname49(currentPlanFile);
+  const currentPlanDir = dirname50(currentPlanFile);
   const projectRoot = findProjectRoot(currentPlanDir);
   const config = options2.preloadedConfig ?? (await CkConfigManager.loadFull(projectRoot)).config;
   const defaultScope = inferPlanScopeForDir(currentPlanDir, config);
@@ -114131,7 +114345,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 {
@@ -114162,14 +114376,14 @@ init_config();
 init_plan_parser();
 init_plan_scope();
 init_plans_registry();
-import { isAbsolute as isAbsolute13, resolve as resolve50 } from "node:path";
+import { isAbsolute as isAbsolute14, resolve as resolve50 } from "node:path";
 async function getGlobalPlansDirFromCwd() {
   const projectRoot = findProjectRoot(process.cwd());
   const { config } = await CkConfigManager.loadFull(projectRoot);
   return resolveGlobalPlansDir(config);
 }
 function resolveTargetFromBase(target, baseDir) {
-  const resolvedTarget = isAbsolute13(target) ? resolve50(target) : resolve50(baseDir, target);
+  const resolvedTarget = isAbsolute14(target) ? resolve50(target) : resolve50(baseDir, target);
   return isWithinDir(resolvedTarget, baseDir) ? resolvedTarget : null;
 }
 
@@ -114202,7 +114416,7 @@ async function handleParse(target, options2) {
     console.log(JSON.stringify({ file: relative32(process.cwd(), planFile), frontmatter, phases }, null, 2));
     return;
   }
-  const title = typeof frontmatter.title === "string" ? frontmatter.title : basename31(dirname50(planFile));
+  const title = typeof frontmatter.title === "string" ? frontmatter.title : basename31(dirname51(planFile));
   console.log();
   console.log(import_picocolors32.default.bold(`  Plan: ${title}`));
   console.log(`  File: ${planFile}`);
@@ -114273,7 +114487,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) {
@@ -114313,7 +114527,7 @@ async function handleStatus(target, options2) {
         const blockedBy2 = await resolvePlanDependencies(s.blockedBy, pf, { preloadedConfig });
         const blocks2 = await resolvePlanDependencies(s.blocks, pf, { preloadedConfig });
         const bar = progressBar(s.completed, s.totalPhases);
-        const title2 = s.title ?? basename31(dirname50(pf));
+        const title2 = s.title ?? basename31(dirname51(pf));
         console.log(`  ${import_picocolors32.default.bold(title2)}`);
         console.log(`  ${bar}`);
         if (s.inProgress > 0)
@@ -114332,7 +114546,7 @@ async function handleStatus(target, options2) {
         }
         console.log();
       } catch {
-        console.log(`  [X] Failed to read: ${basename31(dirname50(pf))}`);
+        console.log(`  [X] Failed to read: ${basename31(dirname51(pf))}`);
         console.log();
       }
     }
@@ -114359,7 +114573,7 @@ async function handleStatus(target, options2) {
     console.log(JSON.stringify({ ...summary, dependencyStatus: { blockedBy, blocks } }, null, 2));
     return;
   }
-  const title = summary.title ?? basename31(dirname50(planFile));
+  const title = summary.title ?? basename31(dirname51(planFile));
   console.log();
   console.log(import_picocolors32.default.bold(`  ${title}`));
   if (summary.status)
@@ -114422,7 +114636,7 @@ async function handleKanban(target, options2) {
     process.exitCode = 1;
     return;
   }
-  const route = `/plans?dir=${encodeURIComponent(dirname50(dirname50(planFile)))}&view=kanban`;
+  const route = `/plans?dir=${encodeURIComponent(dirname51(dirname51(planFile)))}&view=kanban`;
   const url = `http://localhost:${server.port}${route}`;
   console.log();
   console.log(import_picocolors32.default.bold("  ClaudeKit Dashboard — Plans"));
@@ -114457,7 +114671,7 @@ init_plan_parser();
 init_plans_registry();
 init_output_manager();
 var import_picocolors33 = __toESM(require_picocolors(), 1);
-import { basename as basename32, dirname as dirname51, relative as relative33, resolve as resolve52 } from "node:path";
+import { basename as basename32, dirname as dirname52, relative as relative33, resolve as resolve52 } from "node:path";
 function quoteReadTarget(filePath) {
   return `"${filePath.replace(/\\/g, "/").replace(/"/g, "\\\"")}"`;
 }
@@ -114571,7 +114785,7 @@ async function handleCheck(target, options2) {
     process.exitCode = 1;
     return;
   }
-  const planDir = dirname51(planFile);
+  const planDir = dirname52(planFile);
   let planStatus = "pending";
   try {
     const projectRoot = findProjectRoot(planDir);
@@ -114620,7 +114834,7 @@ async function handleUncheck(target, options2) {
     process.exitCode = 1;
     return;
   }
-  const planDir = dirname51(planFile);
+  const planDir = dirname52(planFile);
   try {
     const projectRoot = findProjectRoot(planDir);
     const summary = buildPlanSummary(planFile);
@@ -114659,7 +114873,7 @@ async function handleAddPhase(target, options2) {
   try {
     const result = addPhase(planFile, target, options2.after);
     try {
-      const planDir = dirname51(planFile);
+      const planDir = dirname52(planFile);
       const projectRoot = findProjectRoot(planDir);
       updateRegistryAddPhase({
         planDir,
@@ -114687,7 +114901,7 @@ function resolveTargetPath(target, baseDir) {
   if (!baseDir) {
     return resolve53(target);
   }
-  if (isAbsolute14(target)) {
+  if (isAbsolute15(target)) {
     return resolve53(target);
   }
   const cwdCandidate = resolve53(target);
@@ -114702,7 +114916,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;
   }
@@ -114710,10 +114924,10 @@ 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);
+      dir = dirname53(dir);
     }
   }
   return null;
@@ -115072,7 +115286,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) {
@@ -115102,23 +115316,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"}`);
       }
     }
   }
@@ -115230,10 +115444,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,
@@ -115245,8 +115459,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));
@@ -115407,7 +115621,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, {
@@ -115943,7 +116157,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();
@@ -115957,7 +116171,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;
@@ -116015,7 +116229,7 @@ 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 join158, resolve as resolve56, sep as sep14 } 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();
@@ -116024,7 +116238,7 @@ 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 dirname54, join as join157 } from "node:path";
 init_logger();
 init_safe_prompts();
 var import_fs_extra42 = __toESM(require_lib(), 1);
@@ -116046,7 +116260,7 @@ function classifyFileByOwnership(ownership, forceOverwrite, deleteReason) {
 }
 async function cleanupEmptyDirectories3(filePath, installationRoot) {
   let cleaned = 0;
-  let currentDir = dirname53(filePath);
+  let currentDir = dirname54(filePath);
   while (currentDir !== installationRoot && currentDir.startsWith(installationRoot)) {
     try {
       const entries = readdirSync12(currentDir);
@@ -116054,7 +116268,7 @@ async function cleanupEmptyDirectories3(filePath, installationRoot) {
         rmSync7(currentDir, { recursive: true });
         cleaned++;
         logger.debug(`Removed empty directory: ${currentDir}`);
-        currentDir = dirname53(currentDir);
+        currentDir = dirname54(currentDir);
       } else {
         break;
       }
@@ -116084,7 +116298,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);
         }
       }
@@ -116092,7 +116306,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;
@@ -116125,7 +116339,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;
@@ -116176,7 +116390,7 @@ init_settings_merger();
 init_command_normalizer();
 init_logger();
 var import_fs_extra43 = __toESM(require_lib(), 1);
-import { join as join157 } from "node:path";
+import { join as join158 } from "node:path";
 var CK_JSON_FILE2 = ".ck.json";
 var SETTINGS_FILE = "settings.json";
 var EMPTY_RESULT = {
@@ -116298,7 +116512,7 @@ async function cleanupCkJson(ckJsonPath, data, removedKitNames, dryRun) {
   return false;
 }
 async function cleanupUninstalledSettings(installationPath, options2) {
-  const ckJsonPath = join157(installationPath, CK_JSON_FILE2);
+  const ckJsonPath = join158(installationPath, CK_JSON_FILE2);
   if (!await import_fs_extra43.pathExists(ckJsonPath)) {
     return { ...EMPTY_RESULT };
   }
@@ -116313,7 +116527,7 @@ async function cleanupUninstalledSettings(installationPath, options2) {
   const removedKitNames = options2.kit ? [options2.kit] : Object.keys(kits);
   const { hooks, servers } = resolveRemovalTargets(kits, removedKitNames, options2.remainingKits);
   const result = { ...EMPTY_RESULT };
-  const settingsPath = join157(installationPath, SETTINGS_FILE);
+  const settingsPath = join158(installationPath, SETTINGS_FILE);
   const settings = await SettingsMerger.readSettingsFile(settingsPath);
   if (settings) {
     result.hooksRemoved = removeHooksFromSettings(settings, hooks);
@@ -116427,8 +116641,8 @@ async function removeInstallations(installations, options2) {
       }
       const mutatePaths = getUninstallMutatePaths({
         retainedManifestPaths: analysis.retainedManifestPaths,
-        settingsFileExists: await import_fs_extra44.pathExists(join158(installation.path, "settings.json")),
-        ckJsonExists: await import_fs_extra44.pathExists(join158(installation.path, ".ck.json"))
+        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) {
@@ -116456,7 +116670,7 @@ async function removeInstallations(installations, options2) {
         let removedCount = 0;
         let cleanedDirs = 0;
         for (const item of analysis.toDelete) {
-          const filePath = join158(installation.path, item.path);
+          const filePath = join159(installation.path, item.path);
           if (!await import_fs_extra44.pathExists(filePath))
             continue;
           if (!await isPathSafeToRemove(filePath, installation.path)) {
@@ -116883,7 +117097,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 join165 } from "node:path";
+import { join as join166 } from "node:path";
 var import_picocolors41 = __toESM(require_picocolors(), 1);
 
 // src/commands/watch/phases/implementation-runner.ts
@@ -117402,7 +117616,7 @@ function spawnAndCollect3(command, args) {
 
 // src/commands/watch/phases/issue-processor.ts
 import { mkdir as mkdir40, writeFile as writeFile42 } from "node:fs/promises";
-import { join as join161 } from "node:path";
+import { join as join162 } from "node:path";
 
 // src/commands/watch/phases/approval-detector.ts
 init_logger();
@@ -117780,9 +117994,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 join160 } from "node:path";
+import { join as join161 } from "node:path";
 async function findRecentPlanDir(cwd2, issueNumber, watchLog) {
-  const plansRoot = join160(cwd2, "plans");
+  const plansRoot = join161(cwd2, "plans");
   try {
     const entries = await readdir46(plansRoot);
     const tenMinAgo = Date.now() - 10 * 60 * 1000;
@@ -117791,14 +118005,14 @@ async function findRecentPlanDir(cwd2, issueNumber, watchLog) {
     for (const entry of entries) {
       if (entry === "watch" || entry === "reports" || entry === "visuals")
         continue;
-      const dirPath = join160(plansRoot, entry);
+      const dirPath = join161(plansRoot, entry);
       const dirStat = await stat24(dirPath);
       if (!dirStat.isDirectory())
         continue;
       if (dirStat.mtimeMs < tenMinAgo)
         continue;
       try {
-        await stat24(join160(dirPath, "plan.md"));
+        await stat24(join161(dirPath, "plan.md"));
       } catch {
         continue;
       }
@@ -118029,13 +118243,13 @@ 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 = join161(detectedPlanDir, "plan.md");
+      state.activeIssues[numStr].planPath = join162(detectedPlanDir, "plan.md");
       watchLog.info(`Plan directory detected: ${detectedPlanDir}`);
     } else {
       try {
-        const planDir = join161(projectDir, "plans", "watch");
+        const planDir = join162(projectDir, "plans", "watch");
         await mkdir40(planDir, { recursive: true });
-        const planFilePath = join161(planDir, `issue-${issue.number}-plan.md`);
+        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}`);
@@ -118182,7 +118396,7 @@ init_file_io();
 init_logger();
 import { existsSync as existsSync78 } from "node:fs";
 import { mkdir as mkdir41, readFile as readFile71 } from "node:fs/promises";
-import { dirname as dirname54 } from "node:path";
+import { dirname as dirname55 } from "node:path";
 var PROCESSED_ISSUES_CAP = 500;
 async function readCkJson(projectDir) {
   const configPath = CkConfigManager.getProjectConfigPath(projectDir);
@@ -118212,7 +118426,7 @@ async function loadWatchState(projectDir) {
 }
 async function saveWatchState(projectDir, state) {
   const configPath = CkConfigManager.getProjectConfigPath(projectDir);
-  const configDir = dirname54(configPath);
+  const configDir = dirname55(configPath);
   if (!existsSync78(configDir)) {
     await mkdir41(configDir, { recursive: true });
   }
@@ -118342,18 +118556,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 join162 } 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 = join162(parentDir, entry);
+    const fullPath = join163(parentDir, entry);
     const entryStat = await stat25(fullPath);
     if (!entryStat.isDirectory())
       continue;
-    const gitDir = join162(fullPath, ".git");
+    const gitDir = join163(fullPath, ".git");
     if (!existsSync79(gitDir))
       continue;
     const result = spawnSync7("gh", ["repo", "view", "--json", "owner,name"], {
@@ -118380,7 +118594,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 join163 } 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 });
@@ -118411,7 +118625,7 @@ Run this command from a directory with a GitHub remote.`);
   } catch {
     throw new Error(`Failed to parse repository info: ${ghRepo.stdout}`);
   }
-  const skillsPath = join163(homedir53(), ".claude", "skills");
+  const skillsPath = join164(homedir53(), ".claude", "skills");
   const skillsAvailable = existsSync80(skillsPath);
   if (!skillsAvailable) {
     logger.warning(`ClaudeKit Engineer skills not found at ${skillsPath}`);
@@ -118430,7 +118644,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 join164 } from "node:path";
+import { join as join165 } from "node:path";
 
 class WatchLogger {
   logStream = null;
@@ -118438,7 +118652,7 @@ class WatchLogger {
   logPath = null;
   maxBytes;
   constructor(logDir, maxBytes = 0) {
-    this.logDir = logDir ?? join164(PathResolver.getClaudeKitDir(), "logs");
+    this.logDir = logDir ?? join165(PathResolver.getClaudeKitDir(), "logs");
     this.maxBytes = maxBytes;
   }
   async init() {
@@ -118447,7 +118661,7 @@ class WatchLogger {
         await mkdir42(this.logDir, { recursive: true });
       }
       const dateStr = formatDate(new Date);
-      this.logPath = join164(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"}`);
@@ -118629,7 +118843,7 @@ async function watchCommand(options2) {
 }
 async function discoverRepos(options2, watchLog) {
   const cwd2 = process.cwd();
-  const isGitRepo = existsSync82(join165(cwd2, ".git"));
+  const isGitRepo = existsSync82(join166(cwd2, ".git"));
   if (options2.force) {
     await forceRemoveLock(watchLog);
   }
@@ -118886,8 +119100,8 @@ function registerCommands(cli) {
 // src/cli/version-display.ts
 init_package();
 init_config_version_checker();
-import { existsSync as existsSync94, readFileSync as readFileSync26 } from "node:fs";
-import { join as join177 } from "node:path";
+import { existsSync as existsSync94, readFileSync as readFileSync27 } from "node:fs";
+import { join as join178 } from "node:path";
 
 // src/domains/versioning/version-checker.ts
 init_version_utils();
@@ -118902,14 +119116,14 @@ init_logger();
 init_path_resolver();
 import { existsSync as existsSync93 } from "node:fs";
 import { mkdir as mkdir43, readFile as readFile73, writeFile as writeFile45 } from "node:fs/promises";
-import { join as join176 } from "node:path";
+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 join176(cacheDir, VersionCacheManager.CACHE_FILENAME);
+    return join177(cacheDir, VersionCacheManager.CACHE_FILENAME);
   }
   static async load() {
     const cacheFile = VersionCacheManager.getCacheFile();
@@ -119220,13 +119434,13 @@ async function displayVersion() {
   let localInstalledKits = [];
   let globalInstalledKits = [];
   const globalKitDir = PathResolver.getGlobalKitDir();
-  const globalMetadataPath = join177(globalKitDir, "metadata.json");
+  const globalMetadataPath = join178(globalKitDir, "metadata.json");
   const prefix = PathResolver.getPathPrefix(false);
-  const localMetadataPath = prefix ? join177(process.cwd(), prefix, "metadata.json") : join177(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 {
-      const rawMetadata = JSON.parse(readFileSync26(localMetadataPath, "utf-8"));
+      const rawMetadata = JSON.parse(readFileSync27(localMetadataPath, "utf-8"));
       const metadata = MetadataSchema.parse(rawMetadata);
       const kitsDisplay = formatInstalledKits(metadata);
       if (kitsDisplay) {
@@ -119240,7 +119454,7 @@ async function displayVersion() {
   }
   if (existsSync94(globalMetadataPath)) {
     try {
-      const rawMetadata = JSON.parse(readFileSync26(globalMetadataPath, "utf-8"));
+      const rawMetadata = JSON.parse(readFileSync27(globalMetadataPath, "utf-8"));
       const metadata = MetadataSchema.parse(rawMetadata);
       const kitsDisplay = formatInstalledKits(metadata);
       if (kitsDisplay) {