claudekit-cli 3.41.4-dev.49 → 3.41.4-dev.50

package/dist/index.js

@@ -51181,9 +51181,87 @@ var init_skill_directory_installer = __esm(() => {
 
 // src/commands/portable/config-discovery.ts
 import { existsSync as existsSync22 } from "node:fs";
-import { readFile as readFile19, readdir as readdir10 } from "node:fs/promises";
+import { cp as cp2, mkdir as mkdir9, readFile as readFile19, readdir as readdir10, stat as stat7 } from "node:fs/promises";
 import { homedir as homedir24 } from "node:os";
-import { extname as extname3, join as join36, relative as relative7, sep as sep3 } from "node:path";
+import { basename as basename10, extname as extname3, join as join36, relative as relative7, resolve as resolve11, sep as sep3 } from "node:path";
+async function copyHooksCompanionDirs(sourceDir, targetDir) {
+  const result = {
+    copiedDirs: [],
+    copiedDotfiles: [],
+    errors: []
+  };
+  if (resolve11(sourceDir) === resolve11(targetDir)) {
+    return result;
+  }
+  if (!existsSync22(sourceDir)) {
+    return result;
+  }
+  let entries;
+  try {
+    entries = await readdir10(sourceDir, { withFileTypes: true, encoding: "utf8" });
+  } catch {
+    return result;
+  }
+  try {
+    await mkdir9(targetDir, { recursive: true });
+  } catch (err) {
+    result.errors.push({
+      name: targetDir,
+      error: err instanceof Error ? err.message : String(err)
+    });
+    return result;
+  }
+  const sourceParent = resolve11(sourceDir, "..");
+  const targetParent = resolve11(targetDir, "..");
+  if (sourceParent !== targetParent) {
+    for (const dotfile of HOOKS_COMPANION_DOTFILES) {
+      const srcPath = join36(sourceParent, dotfile);
+      if (!existsSync22(srcPath))
+        continue;
+      const dstPath = join36(targetParent, dotfile);
+      try {
+        await mkdir9(targetParent, { recursive: true });
+        await cp2(srcPath, dstPath, { force: true });
+        result.copiedDotfiles.push(dotfile);
+      } catch (err) {
+        result.errors.push({
+          name: dotfile,
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory())
+      continue;
+    if (entry.name.startsWith(".") || HOOKS_SKIP_DIR_NAMES.has(entry.name))
+      continue;
+    const safeName = basename10(entry.name);
+    if (!safeName || safeName === "." || safeName === ".." || safeName !== entry.name)
+      continue;
+    const srcDir = join36(sourceDir, entry.name);
+    const dstDir = join36(targetDir, entry.name);
+    if (resolve11(srcDir) === resolve11(dstDir))
+      continue;
+    try {
+      const s = await stat7(srcDir);
+      if (!s.isDirectory())
+        continue;
+    } catch {
+      continue;
+    }
+    try {
+      await cp2(srcDir, dstDir, { recursive: true, force: true });
+      result.copiedDirs.push(entry.name);
+    } catch (err) {
+      result.errors.push({
+        name: entry.name,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  return result;
+}
 function resolveSourceOrigin(sourcePath) {
   if (!sourcePath)
     return "global";
@@ -51318,11 +51396,13 @@ async function discoverPortableFiles(dir, baseDir, options2) {
   }
   return items;
 }
-var HOOK_EXTENSIONS, SHELL_HOOK_EXTENSIONS;
+var HOOK_EXTENSIONS, SHELL_HOOK_EXTENSIONS, HOOKS_SKIP_DIR_NAMES, HOOKS_COMPANION_DOTFILES;
 var init_config_discovery = __esm(() => {
   init_kit_layout();
   HOOK_EXTENSIONS = new Set([".js", ".cjs", ".mjs", ".ts"]);
   SHELL_HOOK_EXTENSIONS = new Set([".sh", ".ps1", ".bat", ".cmd"]);
+  HOOKS_SKIP_DIR_NAMES = new Set(["__tests__", "tests", ".logs", "docs"]);
+  HOOKS_COMPANION_DOTFILES = new Set([".ckignore"]);
 });
 
 // node_modules/semver/internal/constants.js
@@ -53211,19 +53291,19 @@ var init_codex_capabilities = __esm(() => {
 
 // src/commands/portable/codex-path-safety.ts
 import { existsSync as existsSync23 } from "node:fs";
-import { mkdir as mkdir9, realpath as realpath3 } from "node:fs/promises";
+import { mkdir as mkdir10, realpath as realpath3 } from "node:fs/promises";
 import { homedir as homedir25 } from "node:os";
-import { dirname as dirname9, join as join37, resolve as resolve11, sep as sep4 } from "node:path";
+import { dirname as dirname9, join as join37, resolve as resolve12, sep as sep4 } from "node:path";
 function isPathWithinBoundary3(targetPath, boundaryPath) {
-  const resolvedTarget = resolve11(targetPath);
-  const resolvedBoundary = resolve11(boundaryPath);
+  const resolvedTarget = resolve12(targetPath);
+  const resolvedBoundary = resolve12(boundaryPath);
   return resolvedTarget === resolvedBoundary || resolvedTarget.startsWith(`${resolvedBoundary}${sep4}`);
 }
 async function resolveRealPathSafe2(path3) {
   try {
     return await realpath3(path3);
   } catch {
-    return resolve11(path3);
+    return resolve12(path3);
   }
 }
 async function isCanonicalPathWithinBoundary2(targetPath, boundaryPath) {
@@ -53232,13 +53312,13 @@ async function isCanonicalPathWithinBoundary2(targetPath, boundaryPath) {
   return isPathWithinBoundary3(canonicalTarget, canonicalBoundary);
 }
 function getCodexLockPath2(targetFilePath) {
-  return join37(dirname9(resolve11(targetFilePath)), ".config.toml.ck-codex.lock");
+  return join37(dirname9(resolve12(targetFilePath)), ".config.toml.ck-codex.lock");
 }
 async function withCodexTargetLock2(targetFilePath, operation) {
-  const resolvedTargetPath = resolve11(targetFilePath);
+  const resolvedTargetPath = resolve12(targetFilePath);
   const dir = dirname9(resolvedTargetPath);
   if (!existsSync23(dir)) {
-    await mkdir9(dir, { recursive: true });
+    await mkdir10(dir, { recursive: true });
   }
   const release = await import_proper_lockfile4.default.lock(dir, {
     realpath: false,
@@ -53269,10 +53349,10 @@ var init_codex_path_safety = __esm(() => {
 // src/commands/portable/codex-features-flag.ts
 import { existsSync as existsSync24 } from "node:fs";
 import { readFile as readFile20, rename as rename6, unlink as unlink6, writeFile as writeFile11 } from "node:fs/promises";
-import { dirname as dirname10, resolve as resolve12 } from "node:path";
+import { dirname as dirname10, resolve as resolve13 } from "node:path";
 async function ensureCodexHooksFeatureFlag(configTomlPath, isGlobal = false) {
-  const boundary = isGlobal ? getCodexGlobalBoundary() : dirname10(resolve12(configTomlPath));
-  if (!await isCanonicalPathWithinBoundary2(dirname10(resolve12(configTomlPath)), boundary)) {
+  const boundary = isGlobal ? getCodexGlobalBoundary() : dirname10(resolve13(configTomlPath));
+  if (!await isCanonicalPathWithinBoundary2(dirname10(resolve13(configTomlPath)), boundary)) {
     return {
       status: "failed",
       configPath: configTomlPath,
@@ -53431,16 +53511,16 @@ ${SENTINEL_END2}`;
 // src/commands/portable/codex-hook-wrapper.ts
 import { createHash as createHash4 } from "node:crypto";
 import { mkdirSync, writeFileSync as writeFileSync2 } from "node:fs";
-import { dirname as dirname11, join as join38, resolve as resolve13 } from "node:path";
+import { dirname as dirname11, join as join38, resolve as resolve14 } from "node:path";
 function wrapperFilename(originalPath) {
-  const abs = resolve13(originalPath);
+  const abs = resolve14(originalPath);
   const hash = createHash4("sha256").update(abs).digest("hex").slice(0, 8);
   const base = abs.split(/[\\/]/).pop() ?? "hook.cjs";
   return `${hash}-${base}`;
 }
 function generateCodexHookWrappers(originalPaths, wrapperDir, capabilities, timeoutsByPath) {
   const results = [];
-  const resolvedWrapperDir = resolve13(wrapperDir);
+  const resolvedWrapperDir = resolve14(wrapperDir);
   for (const originalPath of originalPaths) {
     const filename = wrapperFilename(originalPath);
     const wrapperPath = join38(resolvedWrapperDir, filename);
@@ -53455,7 +53535,7 @@ function generateCodexHookWrappers(originalPaths, wrapperDir, capabilities, time
     }
     try {
       mkdirSync(dirname11(wrapperPath), { recursive: true });
-      const resolvedPath = resolve13(originalPath);
+      const resolvedPath = resolve14(originalPath);
       const hookTimeoutMs = timeoutsByPath?.[resolvedPath] ?? timeoutsByPath?.[originalPath];
       const content = buildWrapperScript(originalPath, capabilities, hookTimeoutMs);
       writeFileSync2(wrapperPath, content, { mode: 493 });
@@ -53729,9 +53809,9 @@ var init_gemini_hook_event_map = __esm(() => {
 
 // src/commands/portable/hooks-settings-merger.ts
 import { existsSync as existsSync25 } from "node:fs";
-import { mkdir as mkdir10, readFile as readFile21, rename as rename7, rm as rm5, writeFile as writeFile12 } from "node:fs/promises";
+import { mkdir as mkdir11, readFile as readFile21, rename as rename7, rm as rm5, writeFile as writeFile12 } from "node:fs/promises";
 import { homedir as homedir27 } from "node:os";
-import { basename as basename10, dirname as dirname12, join as join39, resolve as resolve14 } from "node:path";
+import { basename as basename11, dirname as dirname12, join as join39, resolve as resolve15 } from "node:path";
 function validateHooksSectionShape(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return "hooks must be a non-null object";
@@ -53856,7 +53936,7 @@ function extractFilenameFromCommand(command) {
   for (const token of tokens) {
     const clean = token.replace(/["']/g, "");
     if (/\.\w+$/.test(clean))
-      return basename10(clean);
+      return basename11(clean);
   }
   return null;
 }
@@ -53882,7 +53962,7 @@ async function mergeHooksIntoSettings(targetSettingsPath, newHooks) {
   const merged = deduplicateMerge(existingHooks, newHooks);
   existingSettings.hooks = merged;
   const dir = dirname12(targetSettingsPath);
-  await mkdir10(dir, { recursive: true });
+  await mkdir11(dir, { recursive: true });
   const tempPath = `${targetSettingsPath}.tmp`;
   try {
     await writeFile12(tempPath, JSON.stringify(existingSettings, null, 2), "utf8");
@@ -54168,10 +54248,10 @@ async function migrateHooksSettingsForCodex(options2) {
       if (wr.success) {
         wrapperPaths.push(wr.wrapperPath);
         const addKey = (p) => commandSubstitutions.set(p, wr.wrapperPath);
-        const base = basename10(wr.originalPath);
+        const base = basename11(wr.originalPath);
         addKey(wr.originalPath);
         if (sourceHooksDir) {
-          const sourceAbs = join39(resolve14(sourceHooksDir), base);
+          const sourceAbs = join39(resolve15(sourceHooksDir), base);
           addKey(sourceAbs);
           if (sourceAbs.startsWith("/private/")) {
             addKey(sourceAbs.slice("/private".length));
@@ -54527,9 +54607,9 @@ function buildTypeDirectoryStates(providerConfigs, types4) {
         });
         continue;
       }
-      let stat7 = null;
+      let stat8 = null;
       try {
-        stat7 = statSync5(dirPath);
+        stat8 = statSync5(dirPath);
       } catch {
         results.push({
           provider,
@@ -54542,7 +54622,7 @@ function buildTypeDirectoryStates(providerConfigs, types4) {
         });
         continue;
       }
-      if (!stat7.isDirectory()) {
+      if (!stat8.isDirectory()) {
         results.push({
           provider,
           type,
@@ -55397,7 +55477,7 @@ __export(exports_skills_discovery, {
   discoverSkillsEnriched: () => discoverSkillsEnriched,
   discoverSkills: () => discoverSkills
 });
-import { readFile as readFile24, readdir as readdir11, stat as stat7 } from "node:fs/promises";
+import { readFile as readFile24, readdir as readdir11, stat as stat8 } from "node:fs/promises";
 import { homedir as homedir28 } from "node:os";
 import { dirname as dirname13, join as join40 } from "node:path";
 function getSkillSourcePath() {
@@ -55412,7 +55492,7 @@ function getSkillSourcePath() {
 async function hasSkillMd(dir) {
   try {
     const skillPath = join40(dir, "SKILL.md");
-    const stats = await stat7(skillPath);
+    const stats = await stat8(skillPath);
     return stats.isFile();
   } catch {
     return false;
@@ -55629,7 +55709,7 @@ var init_migration_result_utils = __esm(() => {
 import { existsSync as existsSync28 } from "node:fs";
 import { readFile as readFile25, rm as rm6 } from "node:fs/promises";
 import { homedir as homedir29 } from "node:os";
-import { basename as basename11, join as join41, resolve as resolve15 } from "node:path";
+import { basename as basename12, join as join41, resolve as resolve16 } from "node:path";
 function isDisallowedControlCode(codePoint) {
   return codePoint >= 0 && codePoint <= 8 || codePoint >= 11 && codePoint <= 31 || codePoint >= 127 && codePoint <= 159;
 }
@@ -55779,8 +55859,8 @@ function parseConfigSource(input) {
   if (!trimmed) {
     return { ok: true, value: undefined };
   }
-  const projectSourcePath = resolve15(process.cwd(), "CLAUDE.md");
-  const globalSourcePath = resolve15(getGlobalConfigSourcePath());
+  const projectSourcePath = resolve16(process.cwd(), "CLAUDE.md");
+  const globalSourcePath = resolve16(getGlobalConfigSourcePath());
   const sourceMap = {
     default: undefined,
     global: globalSourcePath,
@@ -55791,7 +55871,7 @@ function parseConfigSource(input) {
   if (normalizedKey in sourceMap) {
     return { ok: true, value: sourceMap[normalizedKey] };
   }
-  const resolved = resolve15(trimmed);
+  const resolved = resolve16(trimmed);
   if (resolved === globalSourcePath || resolved === projectSourcePath) {
     return { ok: true, value: resolved };
   }
@@ -55859,7 +55939,7 @@ function shouldExecuteAction(action) {
 }
 async function executePlanDeleteAction(action, options2) {
   const preservePaths = options2?.preservePaths ?? new Set;
-  const shouldPreserveTarget = action.targetPath.length > 0 && preservePaths.has(resolve15(action.targetPath));
+  const shouldPreserveTarget = action.targetPath.length > 0 && preservePaths.has(resolve16(action.targetPath));
   try {
     if (!shouldPreserveTarget && action.targetPath && existsSync28(action.targetPath)) {
       await rm6(action.targetPath, { recursive: true, force: true });
@@ -56661,11 +56741,11 @@ function registerMigrationRoutes(app) {
                 files: [],
                 global: action.global
               };
-              entry.files.push(basename11(r2.path));
+              entry.files.push(basename12(r2.path));
               successfulHookFiles2.set(provider, entry);
               if (r2.path.length > 0) {
                 const absEntry = successfulHookAbsPaths2.get(provider) ?? [];
-                absEntry.push(resolve15(r2.path));
+                absEntry.push(resolve16(r2.path));
                 successfulHookAbsPaths2.set(provider, absEntry);
               }
             }
@@ -56700,7 +56780,7 @@ function registerMigrationRoutes(app) {
             }
           }
         }
-        const writtenPaths = new Set(allResults.filter((r2) => r2.success && !r2.skipped && r2.path.length > 0).map((r2) => resolve15(r2.path)));
+        const writtenPaths = new Set(allResults.filter((r2) => r2.success && !r2.skipped && r2.path.length > 0).map((r2) => resolve16(r2.path)));
         for (const deleteAction of deleteActions) {
           const deleteResult = await executePlanDeleteAction(deleteAction, {
             preservePaths: writtenPaths
@@ -56728,7 +56808,7 @@ function registerMigrationRoutes(app) {
             });
             if (staleSlugs.length > 0) {
               const staleSlugSet = new Set(staleSlugs.map((s) => `${s}.toml`));
-              await removeInstallationsByFilter((i) => i.type === "agent" && i.provider === provider && i.global === scope && staleSlugSet.has(basename11(i.path)));
+              await removeInstallationsByFilter((i) => i.type === "agent" && i.provider === provider && i.global === scope && staleSlugSet.has(basename12(i.path)));
             }
           }
         }
@@ -56736,7 +56816,7 @@ function registerMigrationRoutes(app) {
           const agentSrc = getAgentSourcePath();
           const cmdSrc = getCommandSourcePath();
           const skillSrc = getSkillSourcePath();
-          const kitRoot = (agentSrc ? resolve15(agentSrc, "..") : null) ?? (cmdSrc ? resolve15(cmdSrc, "..") : null) ?? (skillSrc ? resolve15(skillSrc, "..") : null) ?? null;
+          const kitRoot = (agentSrc ? resolve16(agentSrc, "..") : null) ?? (cmdSrc ? resolve16(cmdSrc, "..") : null) ?? (skillSrc ? resolve16(skillSrc, "..") : null) ?? null;
           const manifest = kitRoot ? await loadPortableManifest(kitRoot) : null;
           if (manifest?.cliVersion) {
             await updateAppliedManifestVersion(manifest.cliVersion);
@@ -56891,11 +56971,11 @@ function registerMigrationRoutes(app) {
             tagResults(batch, "hooks", hook.name);
             for (const result of batch.filter((entry) => entry.success && !entry.skipped)) {
               const existing = successfulHookFiles.get(result.provider) ?? [];
-              existing.push(basename11(result.path));
+              existing.push(basename12(result.path));
               successfulHookFiles.set(result.provider, existing);
               if (result.path.length > 0) {
                 const absExisting = successfulHookAbsPaths.get(result.provider) ?? [];
-                absExisting.push(resolve15(result.path));
+                absExisting.push(resolve16(result.path));
                 successfulHookAbsPaths.set(result.provider, absExisting);
               }
             }
@@ -57145,7 +57225,7 @@ var init_plan_metadata = __esm(() => {
 
 // src/domains/plan-parser/plan-table-parser.ts
 import { readFileSync as readFileSync7 } from "node:fs";
-import { dirname as dirname14, resolve as resolve16 } from "node:path";
+import { dirname as dirname14, resolve as resolve17 } from "node:path";
 function normalizeStatus(raw) {
   const s = raw.toLowerCase().trim();
   if (s.includes("complete") || s.includes("done") || s.includes("✓") || s.includes("✅")) {
@@ -57228,7 +57308,7 @@ function parseHeaderAwareTable(content, dir, options2) {
         hasLinks = true;
         linkText = linkMatch[1].trim();
         name = filenameToTitle(linkText);
-        file = resolve16(dir, linkMatch[2]);
+        file = resolve17(dir, linkMatch[2]);
       } else {
         name = nameRaw.replace(/\[.*?\]\(.*?\)/g, "").trim() || `Phase ${phaseId}`;
         linkText = name;
@@ -57268,7 +57348,7 @@ function parseFormat1(content, dir, options2) {
       phaseId,
       name: name.trim(),
       status: normalizeStatus(status),
-      file: resolve16(dir, linkPath),
+      file: resolve17(dir, linkPath),
       linkText: linkText.trim(),
       anchor
     });
@@ -57288,7 +57368,7 @@ function parseFormat2(content, dir, options2) {
       phaseId,
       name: name.trim(),
       status: normalizeStatus(status),
-      file: resolve16(dir, linkPath),
+      file: resolve17(dir, linkPath),
       linkText,
       anchor
     });
@@ -57307,7 +57387,7 @@ function parseFormat2b(content, dir, options2) {
       phaseId,
       name: name.trim(),
       status: normalizeStatus(status),
-      file: resolve16(dir, linkPath),
+      file: resolve17(dir, linkPath),
       linkText: name.trim(),
       anchor
     });
@@ -57406,7 +57486,7 @@ function parseFormat4(content, planFilePath, options2) {
       current = { name, status: hasCheck ? "completed" : "pending" };
     } else if (fileMatch && current) {
       const planDir = dirname14(planFilePath);
-      current.file = resolve16(planDir, fileMatch[1].trim());
+      current.file = resolve17(planDir, fileMatch[1].trim());
     } else if (statusMatch && current) {
       current.status = normalizeStatus(statusMatch[2]);
     }
@@ -57472,7 +57552,7 @@ function parseFormat6(content, dir, options2) {
       phaseId,
       name: phaseName,
       status: checked.toLowerCase() === "x" ? "completed" : "pending",
-      file: resolve16(dir, linkPath),
+      file: resolve17(dir, linkPath),
       linkText: phaseName,
       anchor
     });
@@ -57657,13 +57737,13 @@ var init_plan_scanner = () => {};
 
 // src/domains/plan-parser/plan-scope.ts
 import { homedir as homedir30 } from "node:os";
-import { isAbsolute as isAbsolute5, join as join44, relative as relative9, resolve as resolve17 } from "node:path";
+import { isAbsolute as isAbsolute5, join as join44, relative as relative9, resolve as resolve18 } from "node:path";
 function resolveConfiguredDir(configuredPath, baseDir) {
   const trimmed = configuredPath?.trim();
   if (!trimmed) {
     return join44(baseDir, DEFAULT_PLANS_DIRNAME);
   }
-  return isAbsolute5(trimmed) ? resolve17(trimmed) : resolve17(baseDir, trimmed);
+  return isAbsolute5(trimmed) ? resolve18(trimmed) : resolve18(baseDir, trimmed);
 }
 function resolveProjectPlansDir(projectRoot, config) {
   return resolveConfiguredDir(config?.paths?.plans, projectRoot);
@@ -57675,8 +57755,8 @@ function resolvePlanDirForScope(scope, projectRoot, config) {
   return scope === "global" ? resolveGlobalPlansDir(config) : resolveProjectPlansDir(projectRoot, config);
 }
 function isWithinDir(targetPath, baseDir) {
-  const resolvedTarget = resolve17(targetPath);
-  const resolvedBase = resolve17(baseDir);
+  const resolvedTarget = resolve18(targetPath);
+  const resolvedBase = resolve18(baseDir);
   const relativePath = relative9(resolvedBase, resolvedTarget);
   return relativePath === "" || !relativePath.startsWith("..") && relativePath !== ".." && !isAbsolute5(relativePath);
 }
@@ -57806,7 +57886,7 @@ var init_timeline_builder = __esm(() => {
 
 // src/domains/plan-parser/plan-validator.ts
 import { existsSync as existsSync31, readFileSync as readFileSync8 } from "node:fs";
-import { basename as basename12, dirname as dirname15 } from "node:path";
+import { basename as basename13, dirname as dirname15 } from "node:path";
 function validatePlanFile(filePath, strict = false) {
   const rawContent = readFileSync8(filePath, "utf8");
   const content = rawContent.replace(/\r\n/g, `
@@ -57850,13 +57930,13 @@ function validatePlanFile(filePath, strict = false) {
   }
   for (const phase of phases) {
     if (phase.file && !existsSync31(phase.file)) {
-      const fileBasename = basename12(phase.file);
+      const fileBasename = basename13(phase.file);
       const refLine = lines.findIndex((l2) => l2.includes(fileBasename));
       issues.push({
         line: refLine >= 0 ? refLine + 1 : 1,
         severity: "warning",
         code: "missing-phase-file",
-        message: `Phase ${phase.phaseId} references '${basename12(phase.file)}' which doesn't exist`
+        message: `Phase ${phase.phaseId} references '${basename13(phase.file)}' which doesn't exist`
       });
     }
   }
@@ -57877,7 +57957,7 @@ var init_plan_validator = __esm(() => {
 import { execSync } from "node:child_process";
 import { mkdirSync as mkdirSync2, readFileSync as readFileSync9, writeFileSync as writeFileSync3 } from "node:fs";
 import { existsSync as existsSync32 } from "node:fs";
-import { basename as basename13, dirname as dirname16, join as join46 } from "node:path";
+import { basename as basename14, dirname as dirname16, join as join46 } from "node:path";
 function phaseNameToFilename(id, name) {
   const numMatch = /^(\d+)([a-z]*)$/i.exec(id);
   const num = numMatch ? numMatch[1] : id;
@@ -58156,7 +58236,7 @@ function addPhase(planFile, name, afterId) {
         insertIdx = i;
     }
     if (insertIdx === -1) {
-      throw new Error(`Phase ID "${afterId}" not found in ${basename13(planFile)}`);
+      throw new Error(`Phase ID "${afterId}" not found in ${basename14(planFile)}`);
     }
     lines.splice(insertIdx + 1, 0, newRow);
     updatedBody = lines.join(`
@@ -58468,7 +58548,7 @@ import {
   unlinkSync,
   writeFileSync as writeFileSync4
 } from "node:fs";
-import { dirname as dirname18, isAbsolute as isAbsolute6, join as join47, parse as parse2, relative as relative10, resolve as resolve18 } from "node:path";
+import { dirname as dirname18, isAbsolute as isAbsolute6, join as join47, parse as parse2, relative as relative10, resolve as resolve19 } from "node:path";
 function createEmptyRegistry() {
   return {
     version: 1,
@@ -58523,7 +58603,7 @@ function migrateFromProjectLocal(cwd2, globalPath) {
   }
 }
 function normalizeRegistryDir(cwd2, dir) {
-  const absoluteDir = isAbsolute6(dir) ? dir : resolve18(cwd2, dir);
+  const absoluteDir = isAbsolute6(dir) ? dir : resolve19(cwd2, dir);
   const relativeDir = relative10(cwd2, absoluteDir) || dir;
   return relativeDir.replace(/\\/g, "/");
 }
@@ -58878,24 +58958,24 @@ function pLimit(concurrency) {
     activeCount--;
     resumeNext();
   };
-  const run = async (function_, resolve19, arguments_) => {
+  const run = async (function_, resolve20, arguments_) => {
     const result = (async () => function_(...arguments_))();
-    resolve19(result);
+    resolve20(result);
     try {
       await result;
     } catch {}
     next();
   };
-  const enqueue = (function_, resolve19, arguments_) => {
+  const enqueue = (function_, resolve20, arguments_) => {
     new Promise((internalResolve) => {
       queue.enqueue(internalResolve);
-    }).then(run.bind(undefined, function_, resolve19, arguments_));
+    }).then(run.bind(undefined, function_, resolve20, arguments_));
     if (activeCount < concurrency) {
       resumeNext();
     }
   };
-  const generator = (function_, ...arguments_) => new Promise((resolve19) => {
-    enqueue(function_, resolve19, arguments_);
+  const generator = (function_, ...arguments_) => new Promise((resolve20) => {
+    enqueue(function_, resolve20, arguments_);
   });
   Object.defineProperties(generator, {
     activeCount: {
@@ -58942,7 +59022,7 @@ var init_p_limit = __esm(() => {
 // src/domains/web-server/routes/plan-routes.ts
 import { existsSync as existsSync34, readFileSync as readFileSync11, realpathSync } from "node:fs";
 import { homedir as homedir31 } from "node:os";
-import { basename as basename14, dirname as dirname20, join as join49, relative as relative11, resolve as resolve19, sep as sep5 } from "node:path";
+import { basename as basename15, dirname as dirname20, join as join49, relative as relative11, resolve as resolve20, sep as sep5 } from "node:path";
 function sanitizeError(err) {
   if (err instanceof Error) {
     if (/^(ENOENT|EACCES|EPERM|EISDIR)/.test(err.message))
@@ -58957,8 +59037,8 @@ function hasBasePrefix(targetPath, baseDir) {
   return targetPath === baseDir || targetPath.startsWith(basePrefix);
 }
 function isWithinBase(targetPath, baseDir) {
-  const resolvedTarget = resolve19(targetPath);
-  const resolvedBase = resolve19(baseDir);
+  const resolvedTarget = resolve20(targetPath);
+  const resolvedBase = resolve20(baseDir);
   const logicalMatch = hasBasePrefix(resolvedTarget, resolvedBase);
   if (existsSync34(resolvedTarget)) {
     try {
@@ -59042,7 +59122,7 @@ async function getAllowedRoots(projectId) {
     roots.push(projectPlansDir);
     roots.push(getGlobalPlanRoot());
   } catch {}
-  return Array.from(new Set(roots.map((root) => resolve19(root))));
+  return Array.from(new Set(roots.map((root) => resolve20(root))));
 }
 async function isWithinAllowedRoots(targetPath, projectId) {
   const allowedRoots = await getAllowedRoots(projectId);
@@ -59064,7 +59144,7 @@ async function getSafePath(value, kind, res, projectId) {
     return null;
   }
   try {
-    return realpathSync(resolve19(value));
+    return realpathSync(resolve20(value));
   } catch {
     res.status(403).json({ error: "Cannot resolve path" });
     return null;
@@ -59077,7 +59157,7 @@ function getPlanFilePath(value, res, projectId) {
   return getSafePath(value, "file", res, projectId);
 }
 function toProjectPathKey(projectPath) {
-  const resolvedPath = resolve19(projectPath);
+  const resolvedPath = resolve20(projectPath);
   if (!existsSync34(resolvedPath)) {
     return resolvedPath;
   }
@@ -59093,8 +59173,8 @@ function createDiscoveredProjectId(projectPath) {
 function toProjectPlanListItem(summary, plansDir) {
   return {
     file: relative11(plansDir, summary.planFile),
-    name: basename14(dirname20(summary.planFile)),
-    slug: basename14(dirname20(summary.planFile)),
+    name: basename15(dirname20(summary.planFile)),
+    slug: basename15(dirname20(summary.planFile)),
     summary: {
       ...summary,
       planDir: relative11(plansDir, summary.planDir),
@@ -59176,8 +59256,8 @@ function registerPlanRoutes(app) {
       const summaries = buildPlanSummaries(entries.slice(offset, offset + limit));
       const plans = summaries.map((summary) => ({
         file: relative11(process.cwd(), summary.planFile),
-        name: basename14(dirname20(summary.planFile)),
-        slug: basename14(dirname20(summary.planFile)),
+        name: basename15(dirname20(summary.planFile)),
+        slug: basename15(dirname20(summary.planFile)),
         summary: {
           ...summary,
           planDir: relative11(process.cwd(), summary.planDir),
@@ -59201,7 +59281,7 @@ function registerPlanRoutes(app) {
       const seenProjectKeys = new Set;
       const scanTargets = [];
       for (const project of await ProjectsRegistryManager.listProjects()) {
-        if (!existsSync34(resolve19(project.path)))
+        if (!existsSync34(resolve20(project.path)))
           continue;
         const projectKey = toProjectPathKey(project.path);
         if (projectKey === globalProjectKey || seenProjectKeys.has(projectKey))
@@ -59220,16 +59300,16 @@ function registerPlanRoutes(app) {
         seenProjectKeys.add(projectKey);
         scanTargets.push({
           id: createDiscoveredProjectId(project.path),
-          name: basename14(project.path),
+          name: basename15(project.path),
           path: project.path
         });
       }
-      const currentPath = resolve19(process.cwd());
+      const currentPath = resolve20(process.cwd());
       const currentProjectKey = toProjectPathKey(currentPath);
       if (isCurrentProjectFallbackCandidate(currentPath, globalProjectKey) && !seenProjectKeys.has(currentProjectKey)) {
         scanTargets.push({
           id: "current",
-          name: basename14(currentPath),
+          name: basename15(currentPath),
           path: currentPath
         });
       }
@@ -59313,7 +59393,7 @@ function registerPlanRoutes(app) {
     const file = await getPlanFilePath(String(req.query.file ?? ""), res, projectId);
     if (!file)
       return;
-    const dir = req.query.dir ? resolve19(String(req.query.dir)) : null;
+    const dir = req.query.dir ? resolve20(String(req.query.dir)) : null;
     if (dir && (!await isWithinAllowedRoots(dir, projectId) || !isWithinBase(file, dir))) {
       res.status(403).json({ error: "File must stay within the selected plan directory" });
       return;
@@ -59445,7 +59525,7 @@ var init_project_plan_data = __esm(() => {
 import { existsSync as existsSync35 } from "node:fs";
 import { readFile as readFile26 } from "node:fs/promises";
 import { homedir as homedir32 } from "node:os";
-import { basename as basename15, join as join50, resolve as resolve20 } from "node:path";
+import { basename as basename16, join as join50, resolve as resolve21 } from "node:path";
 function registerProjectRoutes(app) {
   app.get("/api/projects", async (req, res) => {
     try {
@@ -59471,7 +59551,7 @@ function registerProjectRoutes(app) {
         if (projectInfo) {
           const encodedPath = Buffer.from(discovered.path).toString("base64url");
           projectInfo.id = `discovered-${encodedPath}`;
-          projectInfo.name = basename15(discovered.path);
+          projectInfo.name = basename16(discovered.path);
           projects.push(projectInfo);
         }
       }
@@ -59557,7 +59637,7 @@ function registerProjectRoutes(app) {
       } else if (projectPath.startsWith("~\\")) {
         projectPath = join50(homedir32(), projectPath.slice(1));
       }
-      projectPath = resolve20(projectPath);
+      projectPath = resolve21(projectPath);
       const homeDir = homedir32();
       if (projectPath.includes("..") || !projectPath.startsWith(homeDir)) {
         res.status(400).json({ error: "Invalid path after expansion" });
@@ -59603,7 +59683,7 @@ function registerProjectRoutes(app) {
           const projectInfo = await detectAndBuildProjectInfo(projectPath2, id);
           if (projectInfo) {
             projectInfo.id = id;
-            projectInfo.name = basename15(projectPath2);
+            projectInfo.name = basename16(projectPath2);
             res.json(projectInfo);
             return;
           }
@@ -59744,7 +59824,7 @@ async function detectAndBuildProjectInfo(path5, id, cachedSettings, cachedSkills
   const planData = includePlanData ? await buildProjectPlanData(id === "global" ? null : path5, scope) : null;
   return {
     id,
-    name: basename15(path5) || (id === "global" ? "Global" : "Current"),
+    name: basename16(path5) || (id === "global" ? "Global" : "Current"),
     path: path5,
     hasLocalConfig,
     kitType: metadata.kit || null,
@@ -59784,9 +59864,9 @@ var init_project_routes = __esm(() => {
 
 // src/domains/web-server/routes/session-routes.ts
 import { existsSync as existsSync36 } from "node:fs";
-import { readFile as readFile27, readdir as readdir12, stat as stat8 } from "node:fs/promises";
+import { readFile as readFile27, readdir as readdir12, stat as stat9 } from "node:fs/promises";
 import { homedir as homedir33 } from "node:os";
-import { basename as basename16, join as join51 } from "node:path";
+import { basename as basename17, join as join51 } from "node:path";
 function toDateStr(d3) {
   const y3 = d3.getFullYear();
   const m2 = String(d3.getMonth() + 1).padStart(2, "0");
@@ -59836,7 +59916,7 @@ async function scanActivityMetrics(periodDays) {
     for (const sessionFile of sessionFiles) {
       const filePath = join51(dirPath, sessionFile);
       try {
-        const fileStat = await stat8(filePath);
+        const fileStat = await stat9(filePath);
         const mtime = fileStat.mtime;
         const mtimeMs = mtime.getTime();
         if (mtime >= cutoff) {
@@ -59926,7 +60006,7 @@ function extractResultContent(block) {
 }
 async function parseSessionDetail(filePath, limit, offset) {
   const MAX_SESSION_FILE_BYTES = 50 * 1024 * 1024;
-  const fileStats = await stat8(filePath);
+  const fileStats = await stat9(filePath);
   if (fileStats.size > MAX_SESSION_FILE_BYTES) {
     return {
       messages: [
@@ -60050,7 +60130,7 @@ function registerSessionRoutes(app) {
       const projects = [];
       for (const entry of entries) {
         const entryPath = join51(projectsDir2, entry);
-        const entryStat = await stat8(entryPath).catch(() => null);
+        const entryStat = await stat9(entryPath).catch(() => null);
         if (!entryStat?.isDirectory())
           continue;
         const files = await readdir12(entryPath).catch(() => []);
@@ -60059,7 +60139,7 @@ function registerSessionRoutes(app) {
           continue;
         let lastActive = new Date(0);
         for (const file of jsonlFiles.slice(-5)) {
-          const fileStat = await stat8(join51(entryPath, file)).catch(() => null);
+          const fileStat = await stat9(join51(entryPath, file)).catch(() => null);
           if (fileStat && fileStat.mtime > lastActive) {
             lastActive = fileStat.mtime;
           }
@@ -60073,7 +60153,7 @@ function registerSessionRoutes(app) {
         const encodedPath = Buffer.from(decodedPath).toString("base64url");
         projects.push({
           id: `discovered-${encodedPath}`,
-          name: basename16(decodedPath),
+          name: basename17(decodedPath),
           path: decodedPath,
           sessionCount: jsonlFiles.length,
           lastActive: lastActive.toISOString()
@@ -60261,7 +60341,7 @@ var init_settings_routes = __esm(() => {
 });
 
 // src/domains/skills/skill-catalog-generator.ts
-import { mkdir as mkdir11, readFile as readFile28, readdir as readdir13, rename as rename8, stat as stat9, writeFile as writeFile13 } from "node:fs/promises";
+import { mkdir as mkdir12, readFile as readFile28, readdir as readdir13, rename as rename8, stat as stat10, writeFile as writeFile13 } from "node:fs/promises";
 import { homedir as homedir35 } from "node:os";
 import { dirname as dirname21, join as join52, relative as relative12 } from "node:path";
 async function hasScripts(skillPath) {
@@ -60329,7 +60409,7 @@ class SkillCatalogGenerator {
     };
   }
   async write(catalog) {
-    await mkdir11(dirname21(CATALOG_PATH), { recursive: true });
+    await mkdir12(dirname21(CATALOG_PATH), { recursive: true });
     const tmpPath = `${CATALOG_PATH}.tmp`;
     const json = JSON.stringify(catalog, null, 2);
     await writeFile13(tmpPath, json, "utf-8");
@@ -60360,7 +60440,7 @@ class SkillCatalogGenerator {
           continue;
         const skillMdPath = join52(skillsBasePath, entry.name, "SKILL.md");
         try {
-          const stats = await stat9(skillMdPath);
+          const stats = await stat10(skillMdPath);
           if (stats.mtimeMs > catalogTime)
             return true;
         } catch {}
@@ -60702,11 +60782,11 @@ function hasInstallSignal2(path6) {
     return false;
   }
   try {
-    const stat10 = statSync8(path6);
-    if (stat10.isDirectory()) {
+    const stat11 = statSync8(path6);
+    if (stat11.isDirectory()) {
       return readdirSync6(path6).length > 0;
     }
-    if (stat10.isFile()) {
+    if (stat11.isFile()) {
       return true;
     }
     return false;
@@ -60858,7 +60938,7 @@ var init_agents = __esm(() => {
 
 // src/commands/skills/skills-registry.ts
 import { existsSync as existsSync38 } from "node:fs";
-import { mkdir as mkdir12, readFile as readFile30, writeFile as writeFile14 } from "node:fs/promises";
+import { mkdir as mkdir13, readFile as readFile30, writeFile as writeFile14 } from "node:fs/promises";
 import { homedir as homedir38 } from "node:os";
 import { dirname as dirname22, join as join55, sep as sep7 } from "node:path";
 function getCliVersion3() {
@@ -60914,7 +60994,7 @@ async function readRegistry2() {
 async function writeRegistry2(registry) {
   const dir = dirname22(REGISTRY_PATH2);
   if (!existsSync38(dir)) {
-    await mkdir12(dir, { recursive: true });
+    await mkdir13(dir, { recursive: true });
   }
   await writeFile14(REGISTRY_PATH2, JSON.stringify(registry, null, 2), "utf-8");
 }
@@ -61002,12 +61082,12 @@ var init_skills_registry = __esm(() => {
 
 // src/commands/skills/skills-installer.ts
 import { existsSync as existsSync39 } from "node:fs";
-import { cp as cp2, mkdir as mkdir13, rm as rm7, stat as stat10 } from "node:fs/promises";
+import { cp as cp3, mkdir as mkdir14, rm as rm7, stat as stat11 } from "node:fs/promises";
 import { homedir as homedir39 } from "node:os";
-import { dirname as dirname23, join as join56, resolve as resolve22 } from "node:path";
+import { dirname as dirname23, join as join56, resolve as resolve23 } from "node:path";
 function isSamePath2(path1, path22) {
   try {
-    return resolve22(path1) === resolve22(path22);
+    return resolve23(path1) === resolve23(path22);
   } catch {
     return false;
   }
@@ -61075,10 +61155,10 @@ async function installSkillForAgent(skill, agent, options2) {
     } catch {}
     const parentDir = dirname23(targetPath);
     if (!existsSync39(parentDir)) {
-      await mkdir13(parentDir, { recursive: true });
+      await mkdir14(parentDir, { recursive: true });
     }
     if (existsSync39(targetPath)) {
-      const stats = await stat10(targetPath);
+      const stats = await stat11(targetPath);
       if (stats.isFile()) {
         return {
           agent,
@@ -61089,7 +61169,7 @@ async function installSkillForAgent(skill, agent, options2) {
         };
       }
     }
-    await cp2(skill.path, targetPath, {
+    await cp3(skill.path, targetPath, {
       recursive: true,
       force: true
     });
@@ -61142,10 +61222,10 @@ var init_skills_installer = __esm(() => {
 // src/commands/skills/skills-uninstaller.ts
 import { existsSync as existsSync40 } from "node:fs";
 import { rm as rm8 } from "node:fs/promises";
-import { join as join57, resolve as resolve23 } from "node:path";
+import { join as join57, resolve as resolve24 } from "node:path";
 function isSamePath3(path1, path22) {
   try {
-    return resolve23(path1) === resolve23(path22);
+    return resolve24(path1) === resolve24(path22);
   } catch {
     return false;
   }
@@ -61749,7 +61829,7 @@ var init_pnpm_detector = __esm(() => {
 
 // src/domains/installation/package-managers/detection-core.ts
 import { existsSync as existsSync41, realpathSync as realpathSync2 } from "node:fs";
-import { chmod as chmod2, mkdir as mkdir14, readFile as readFile31, writeFile as writeFile15 } from "node:fs/promises";
+import { chmod as chmod2, mkdir as mkdir15, readFile as readFile31, writeFile as writeFile15 } from "node:fs/promises";
 import { platform as platform6 } from "node:os";
 import { join as join58 } from "node:path";
 function detectFromBinaryPath() {
@@ -61861,7 +61941,7 @@ async function saveCachedPm(pm, getVersion) {
     const configDir = PathResolver.getConfigDir(false);
     const cacheFile = join58(configDir, CACHE_FILE);
     if (!existsSync41(configDir)) {
-      await mkdir14(configDir, { recursive: true });
+      await mkdir15(configDir, { recursive: true });
       if (platform6() !== "win32") {
         await chmod2(configDir, 448);
       }
@@ -62083,7 +62163,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "claudekit-cli",
-    version: "3.41.4-dev.49",
+    version: "3.41.4-dev.50",
     description: "CLI tool for bootstrapping and updating ClaudeKit projects",
     type: "module",
     repository: {
@@ -62779,8 +62859,8 @@ async function scanClaudeKitDirectory(directoryPath) {
           continue;
         }
         const itemPath = join60(skillsPath, item);
-        const stat11 = await import_fs_extra4.readdir(itemPath).catch(() => null);
-        if (stat11?.includes("SKILL.md")) {
+        const stat12 = await import_fs_extra4.readdir(itemPath).catch(() => null);
+        if (stat12?.includes("SKILL.md")) {
           skillCount++;
         }
       }
@@ -63284,7 +63364,7 @@ var init_error_handler2 = __esm(() => {
 
 // src/domains/versioning/release-cache.ts
 import { existsSync as existsSync42 } from "node:fs";
-import { mkdir as mkdir15, readFile as readFile34, unlink as unlink7, writeFile as writeFile17 } from "node:fs/promises";
+import { mkdir as mkdir16, readFile as readFile34, unlink as unlink7, writeFile as writeFile17 } from "node:fs/promises";
 import { join as join61 } from "node:path";
 var ReleaseCacheEntrySchema, ReleaseCache;
 var init_release_cache = __esm(() => {
@@ -63330,7 +63410,7 @@ var init_release_cache = __esm(() => {
     async set(key, releases) {
       const cacheFile = this.getCachePath(key);
       try {
-        await mkdir15(this.cacheDir, { recursive: true, mode: 448 });
+        await mkdir16(this.cacheDir, { recursive: true, mode: 448 });
         const cacheEntry = {
           timestamp: Date.now(),
           releases
@@ -64179,12 +64259,12 @@ async function promptKitUpdate(beta, yes, deps) {
         args.push("--beta");
       const displayCmd = `ck ${args.join(" ")}`;
       logger.info(`Running: ${displayCmd}`);
-      const spawnFn = deps?.spawnInitFn ?? ((spawnArgs) => new Promise((resolve24) => {
+      const spawnFn = deps?.spawnInitFn ?? ((spawnArgs) => new Promise((resolve25) => {
         const child = spawn2("ck", spawnArgs, { stdio: "inherit", shell: true });
-        child.on("close", (code) => resolve24(code ?? 1));
+        child.on("close", (code) => resolve25(code ?? 1));
         child.on("error", (err) => {
           logger.verbose(`Failed to spawn ck init: ${err.message}`);
-          resolve24(1);
+          resolve25(1);
         });
       }));
       const exitCode = await spawnFn(args);
@@ -64411,7 +64491,7 @@ var init_update_cli = __esm(() => {
 });
 
 // src/domains/sync/config-version-checker.ts
-import { mkdir as mkdir16, readFile as readFile36, unlink as unlink8, writeFile as writeFile18 } from "node:fs/promises";
+import { mkdir as mkdir17, readFile as readFile36, unlink as unlink8, writeFile as writeFile18 } from "node:fs/promises";
 import { join as join63 } from "node:path";
 function parseCacheTtl() {
   const envValue = process.env.CK_SYNC_CACHE_TTL;
@@ -64513,7 +64593,7 @@ class ConfigVersionChecker {
     try {
       const cachePath = ConfigVersionChecker.getCacheFilePath(kitType, global3, channel);
       const cacheDir = PathResolver.getCacheDir(global3);
-      await mkdir16(cacheDir, { recursive: true });
+      await mkdir17(cacheDir, { recursive: true });
       await writeFile18(cachePath, JSON.stringify(cache3, null, 2));
     } catch (error) {
       logger.debug(`Cache write failed: ${error instanceof Error ? error.message : "Unknown error"}`);
@@ -64574,7 +64654,7 @@ class ConfigVersionChecker {
           return null;
         }
         const delay = baseBackoff * 2 ** attempt;
-        await new Promise((resolve24) => setTimeout(resolve24, delay));
+        await new Promise((resolve25) => setTimeout(resolve25, delay));
       }
     }
     return null;
@@ -64680,12 +64760,12 @@ import { readFile as readFile37 } from "node:fs/promises";
 import { cpus, homedir as homedir40, totalmem } from "node:os";
 import { join as join64 } from "node:path";
 function runCommand(cmd, args, fallback2) {
-  return new Promise((resolve24) => {
+  return new Promise((resolve25) => {
     execFile8(cmd, args, { timeout: 5000 }, (err, stdout) => {
       if (err) {
-        resolve24(fallback2);
+        resolve25(fallback2);
       } else {
-        resolve24(stdout.trim() || fallback2);
+        resolve25(stdout.trim() || fallback2);
       }
     });
   });
@@ -65121,7 +65201,7 @@ var init_routes = __esm(() => {
 
 // src/domains/web-server/static-server.ts
 import { existsSync as existsSync44 } from "node:fs";
-import { basename as basename17, dirname as dirname24, join as join65, resolve as resolve24 } from "node:path";
+import { basename as basename18, dirname as dirname24, join as join65, resolve as resolve25 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 function addRuntimeUiCandidate(candidates, runtimePath) {
   if (!runtimePath) {
@@ -65131,8 +65211,8 @@ function addRuntimeUiCandidate(candidates, runtimePath) {
   if (!looksLikePath) {
     return;
   }
-  const entryDir = dirname24(resolve24(runtimePath));
-  if (basename17(entryDir) === "dist") {
+  const entryDir = dirname24(resolve25(runtimePath));
+  if (basename18(entryDir) === "dist") {
     candidates.add(join65(entryDir, "ui"));
   }
   candidates.add(join65(entryDir, "..", "dist", "ui"));
@@ -68163,10 +68243,10 @@ async function createAppServer(options2 = {}) {
     wsManager = new WebSocketManager(server);
     fileWatcher = new FileWatcher({ wsManager });
     fileWatcher.start();
-    await new Promise((resolve25, reject) => {
+    await new Promise((resolve26, reject) => {
       const onListening = () => {
         server.off("error", onError);
-        resolve25();
+        resolve26();
       };
       const onError = (error) => {
         server.off("listening", onListening);
@@ -68203,16 +68283,16 @@ async function createAppServer(options2 = {}) {
   };
 }
 async function closeHttpServer(server) {
-  await new Promise((resolve25) => {
+  await new Promise((resolve26) => {
     if (!server.listening) {
-      resolve25();
+      resolve26();
       return;
     }
     server.close((err) => {
       if (err) {
         logger.debug(`Server close error: ${err.message}`);
       }
-      resolve25();
+      resolve26();
     });
   });
 }
@@ -68519,7 +68599,7 @@ var require_get_stream = __commonJS((exports, module) => {
     };
     const { maxBuffer } = options2;
     let stream;
-    await new Promise((resolve25, reject) => {
+    await new Promise((resolve26, reject) => {
       const rejectPromise = (error) => {
         if (error && stream.getBufferedLength() <= BufferConstants.MAX_LENGTH) {
           error.bufferedData = stream.getBufferedValue();
@@ -68531,7 +68611,7 @@ var require_get_stream = __commonJS((exports, module) => {
           rejectPromise(error);
           return;
         }
-        resolve25();
+        resolve26();
       });
       stream.on("data", () => {
         if (stream.getBufferedLength() > maxBuffer) {
@@ -69892,7 +69972,7 @@ var require_extract_zip = __commonJS((exports, module) => {
       debug("opening", this.zipPath, "with opts", this.opts);
       this.zipfile = await openZip(this.zipPath, { lazyEntries: true });
       this.canceled = false;
-      return new Promise((resolve25, reject) => {
+      return new Promise((resolve26, reject) => {
         this.zipfile.on("error", (err) => {
           this.canceled = true;
           reject(err);
@@ -69901,7 +69981,7 @@ var require_extract_zip = __commonJS((exports, module) => {
         this.zipfile.on("close", () => {
           if (!this.canceled) {
             debug("zip extraction complete");
-            resolve25();
+            resolve26();
           }
         });
         this.zipfile.on("entry", async (entry) => {
@@ -71678,7 +71758,7 @@ var require_picomatch2 = __commonJS((exports, module) => {
 import { exec as exec7, execFile as execFile10, spawn as spawn5 } from "node:child_process";
 import { promisify as promisify15 } from "node:util";
 function executeInteractiveScript(command, args, options2) {
-  return new Promise((resolve31, reject) => {
+  return new Promise((resolve32, reject) => {
     const child = spawn5(command, args, {
       stdio: ["ignore", "inherit", "inherit"],
       cwd: options2?.cwd,
@@ -71699,7 +71779,7 @@ function executeInteractiveScript(command, args, options2) {
       } else if (code !== 0) {
         reject(new Error(`Command exited with code ${code}`));
       } else {
-        resolve31();
+        resolve32();
       }
     });
     child.on("error", (error) => {
@@ -71720,7 +71800,7 @@ var init_process_executor = __esm(() => {
 });
 
 // src/services/package-installer/validators.ts
-import { resolve as resolve31 } from "node:path";
+import { resolve as resolve32 } from "node:path";
 function validatePackageName(packageName) {
   if (!packageName || typeof packageName !== "string") {
     throw new Error("Package name must be a non-empty string");
@@ -71733,8 +71813,8 @@ function validatePackageName(packageName) {
   }
 }
 function validateScriptPath(skillsDir2, scriptPath) {
-  const skillsDirResolved = resolve31(skillsDir2);
-  const scriptPathResolved = resolve31(scriptPath);
+  const skillsDirResolved = resolve32(skillsDir2);
+  const scriptPathResolved = resolve32(scriptPath);
   const skillsDirNormalized = isWindows() ? skillsDirResolved.toLowerCase() : skillsDirResolved;
   const scriptPathNormalized = isWindows() ? scriptPathResolved.toLowerCase() : scriptPathResolved;
   if (!scriptPathNormalized.startsWith(skillsDirNormalized)) {
@@ -72360,7 +72440,7 @@ var init_skills_installer2 = __esm(() => {
 
 // src/services/package-installer/gemini-mcp/config-manager.ts
 import { existsSync as existsSync58 } from "node:fs";
-import { mkdir as mkdir22, readFile as readFile44, writeFile as writeFile22 } from "node:fs/promises";
+import { mkdir as mkdir23, readFile as readFile44, writeFile as writeFile22 } from "node:fs/promises";
 import { dirname as dirname31, join as join95 } from "node:path";
 async function readJsonFile(filePath) {
   try {
@@ -72403,7 +72483,7 @@ ${geminiPattern}
 async function createNewSettingsWithMerge(geminiSettingsPath, mcpConfigPath) {
   const linkDir = dirname31(geminiSettingsPath);
   if (!existsSync58(linkDir)) {
-    await mkdir22(linkDir, { recursive: true });
+    await mkdir23(linkDir, { recursive: true });
     logger.debug(`Created directory: ${linkDir}`);
   }
   const mcpConfig = await readJsonFile(mcpConfigPath);
@@ -72519,12 +72599,12 @@ var init_validation = __esm(() => {
 
 // src/services/package-installer/gemini-mcp/linker-core.ts
 import { existsSync as existsSync60 } from "node:fs";
-import { mkdir as mkdir23, symlink as symlink3 } from "node:fs/promises";
+import { mkdir as mkdir24, symlink as symlink3 } from "node:fs/promises";
 import { dirname as dirname32, join as join97 } from "node:path";
 async function createSymlink(targetPath, linkPath, projectDir, isGlobal) {
   const linkDir = dirname32(linkPath);
   if (!existsSync60(linkDir)) {
-    await mkdir23(linkDir, { recursive: true });
+    await mkdir24(linkDir, { recursive: true });
     logger.debug(`Created directory: ${linkDir}`);
   }
   let symlinkTarget;
@@ -72564,10 +72644,10 @@ __export(exports_gemini_mcp_linker, {
   checkExistingGeminiConfig: () => checkExistingGeminiConfig,
   addGeminiToGitignore: () => addGeminiToGitignore
 });
-import { resolve as resolve32 } from "node:path";
+import { resolve as resolve33 } from "node:path";
 async function linkGeminiMcpConfig(projectDir, options2 = {}) {
   const { skipGitignore = false, isGlobal = false } = options2;
-  const resolvedProjectDir = resolve32(projectDir);
+  const resolvedProjectDir = resolve33(projectDir);
   const geminiSettingsPath = getGeminiSettingsPath(resolvedProjectDir, isGlobal);
   const mcpConfigPath = findMcpConfigPath(resolvedProjectDir);
   if (!mcpConfigPath) {
@@ -73186,7 +73266,7 @@ async function restoreOriginalBranch(branchName, cwd2, issueNumber) {
   }
 }
 function spawnAndCollect(command, args, cwd2) {
-  return new Promise((resolve48, reject) => {
+  return new Promise((resolve49, reject) => {
     const child = spawn6(command, args, { ...cwd2 && { cwd: cwd2 }, stdio: ["ignore", "pipe", "pipe"] });
     const chunks = [];
     const stderrChunks = [];
@@ -73199,7 +73279,7 @@ function spawnAndCollect(command, args, cwd2) {
         reject(new Error(`${command} ${args[0] ?? ""} exited with code ${code2}: ${stderr}`));
         return;
       }
-      resolve48(Buffer.concat(chunks).toString("utf-8"));
+      resolve49(Buffer.concat(chunks).toString("utf-8"));
     });
   });
 }
@@ -73309,8 +73389,8 @@ function countTwitterChars(text) {
   const withoutUrls = text.replace(urlPattern, "");
   let count = urlCount * 23;
   for (const char of withoutUrls) {
-    const cp4 = char.codePointAt(0) ?? 0;
-    if (cp4 >= 19968 && cp4 <= 40959 || cp4 >= 13312 && cp4 <= 19903 || cp4 >= 131072 && cp4 <= 173791 || cp4 >= 173824 && cp4 <= 191471 || cp4 >= 196608 && cp4 <= 205743 || cp4 >= 63744 && cp4 <= 64255 || cp4 >= 12288 && cp4 <= 12351 || cp4 >= 12352 && cp4 <= 12447 || cp4 >= 12448 && cp4 <= 12543 || cp4 >= 65280 && cp4 <= 65519) {
+    const cp5 = char.codePointAt(0) ?? 0;
+    if (cp5 >= 19968 && cp5 <= 40959 || cp5 >= 13312 && cp5 <= 19903 || cp5 >= 131072 && cp5 <= 173791 || cp5 >= 173824 && cp5 <= 191471 || cp5 >= 196608 && cp5 <= 205743 || cp5 >= 63744 && cp5 <= 64255 || cp5 >= 12288 && cp5 <= 12351 || cp5 >= 12352 && cp5 <= 12447 || cp5 >= 12448 && cp5 <= 12543 || cp5 >= 65280 && cp5 <= 65519) {
       count += 2;
     } else {
       count += 1;
@@ -73387,7 +73467,7 @@ import { createHash as createHash9 } from "node:crypto";
 import { existsSync as existsSync75, mkdirSync as mkdirSync5, readFileSync as readFileSync18, readdirSync as readdirSync11, statSync as statSync14 } from "node:fs";
 import { rename as rename14, writeFile as writeFile38 } from "node:fs/promises";
 import { homedir as homedir52 } from "node:os";
-import { basename as basename30, join as join158 } from "node:path";
+import { basename as basename31, join as join158 } from "node:path";
 function getCachedContext(repoPath) {
   const cachePath = getCacheFilePath(repoPath);
   if (!existsSync75(cachePath))
@@ -73420,8 +73500,8 @@ function computeSourceHash(repoPath) {
   const paths = getDocSourcePaths(repoPath);
   for (const filePath of paths) {
     try {
-      const stat25 = statSync14(filePath);
-      hash.update(`${filePath}:${stat25.mtimeMs}`);
+      const stat26 = statSync14(filePath);
+      hash.update(`${filePath}:${stat26.mtimeMs}`);
     } catch {
       hash.update(`${filePath}:0`);
     }
@@ -73455,7 +73535,7 @@ function getDocSourcePaths(repoPath) {
   return paths.sort();
 }
 function getCacheFilePath(repoPath) {
-  const repoName = basename30(repoPath).replace(/[^a-zA-Z0-9_-]/g, "_");
+  const repoName = basename31(repoPath).replace(/[^a-zA-Z0-9_-]/g, "_");
   const pathHash = createHash9("sha256").update(repoPath).digest("hex").slice(0, 8);
   return join158(CACHE_DIR, `${repoName}-${pathHash}-context-cache.json`);
 }
@@ -74097,8 +74177,8 @@ class ContentLogger {
     if (this.maxBytes > 0 && this.stream) {
       const logPath = join161(this.logDir, `content-${this.currentDate}.log`);
       try {
-        const stat25 = statSync15(logPath);
-        if (stat25.size >= this.maxBytes) {
+        const stat26 = statSync15(logPath);
+        if (stat26.size >= this.maxBytes) {
           this.close();
           const suffix = Date.now();
           const rotatedPath = join161(this.logDir, `content-${this.currentDate}-${suffix}.log`);
@@ -74450,8 +74530,8 @@ function detectCompletedPlans(repo, since) {
       if (!existsSync80(planFile))
         continue;
       try {
-        const stat25 = statSync16(planFile);
-        if (stat25.mtimeMs < sinceMs)
+        const stat26 = statSync16(planFile);
+        if (stat26.mtimeMs < sinceMs)
           continue;
         const content = readFileSync20(planFile, "utf-8");
         const frontmatterMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
@@ -74467,7 +74547,7 @@ function detectCompletedPlans(repo, since) {
           title: `Plan completed: ${entry.name}`,
           body: "",
           author: "",
-          createdAt: new Date(stat25.mtimeMs).toISOString()
+          createdAt: new Date(stat26.mtimeMs).toISOString()
         });
       } catch {}
     }
@@ -76001,8 +76081,8 @@ function shouldRunCleanup(lastAt) {
   return Date.now() - new Date(lastAt).getTime() >= 86400000;
 }
 function sleep2(ms) {
-  return new Promise((resolve48) => {
-    setTimeout(resolve48, ms);
+  return new Promise((resolve49) => {
+    setTimeout(resolve49, ms);
   });
 }
 var LOCK_DIR2, LOCK_FILE, MAX_CREATION_RETRIES = 3, MAX_PUBLISH_RETRIES_PER_CYCLE = 3, PUBLISH_RETRY_WINDOW_HOURS = 24;
@@ -78261,7 +78341,7 @@ function getPagerArgs(pagerCmd) {
   return [];
 }
 async function trySystemPager(content) {
-  return new Promise((resolve48) => {
+  return new Promise((resolve49) => {
     const pagerCmd = process.env.PAGER || "less";
     const pagerArgs = getPagerArgs(pagerCmd);
     try {
@@ -78271,20 +78351,20 @@ async function trySystemPager(content) {
       });
       const timeout2 = setTimeout(() => {
         pager.kill();
-        resolve48(false);
+        resolve49(false);
       }, 30000);
       pager.stdin.write(content);
       pager.stdin.end();
       pager.on("close", (code2) => {
         clearTimeout(timeout2);
-        resolve48(code2 === 0);
+        resolve49(code2 === 0);
       });
       pager.on("error", () => {
         clearTimeout(timeout2);
-        resolve48(false);
+        resolve49(false);
       });
     } catch {
-      resolve48(false);
+      resolve49(false);
     }
   });
 }
@@ -78311,16 +78391,16 @@ async function basicPager(content) {
       break;
     }
     const remaining = lines.length - currentLine;
-    await new Promise((resolve48) => {
+    await new Promise((resolve49) => {
       rl.question(`-- More (${remaining} lines) [Enter/q] --`, (answer) => {
         if (answer.toLowerCase() === "q") {
           rl.close();
           process.exitCode = 0;
-          resolve48();
+          resolve49();
           return;
         }
         process.stdout.write("\x1B[1A\x1B[2K");
-        resolve48();
+        resolve49();
       });
     });
   }
@@ -81189,12 +81269,12 @@ async function configUICommand(options2 = {}) {
     console.log();
     console.log(import_picocolors12.default.dim("  Press Ctrl+C to stop"));
     console.log();
-    await new Promise((resolve25) => {
+    await new Promise((resolve26) => {
       const shutdown = async () => {
         console.log();
         logger.info("Shutting down...");
         await server.close();
-        resolve25();
+        resolve26();
       };
       process.on("SIGINT", shutdown);
       process.on("SIGTERM", shutdown);
@@ -81215,12 +81295,12 @@ async function configUICommand(options2 = {}) {
 }
 async function checkPort(port, host) {
   const { createServer: createServer2 } = await import("node:net");
-  return new Promise((resolve25) => {
+  return new Promise((resolve26) => {
     const server = createServer2();
-    server.once("error", () => resolve25(false));
+    server.once("error", () => resolve26(false));
     server.once("listening", () => {
       server.close();
-      resolve25(true);
+      resolve26(true);
     });
     server.listen(port, host);
   });
@@ -81401,11 +81481,11 @@ async function fetchDesktopReleaseManifest(opts, fetchFn = globalThis.fetch) {
 import { existsSync as existsSync45 } from "node:fs";
 
 // src/domains/desktop/desktop-install-metadata.ts
-import { basename as basename18, dirname as dirname26, join as join67 } from "node:path";
+import { basename as basename19, dirname as dirname26, join as join67 } from "node:path";
 init_desktop();
 var import_fs_extra6 = __toESM(require_lib3(), 1);
 function getDesktopDownloadMetadataPath(downloadPath) {
-  return join67(dirname26(downloadPath), `${basename18(downloadPath)}.metadata.json`);
+  return join67(dirname26(downloadPath), `${basename19(downloadPath)}.metadata.json`);
 }
 async function readMetadataAt(metadataPath, options2 = {}) {
   const pathExistsFn = options2.pathExistsFn || import_fs_extra6.pathExists;
@@ -81448,7 +81528,7 @@ async function clearDesktopInstallMetadata(options2 = {}) {
 }
 
 // src/domains/desktop/desktop-installed-artifact-validator.ts
-import { readFile as readFile38, stat as stat11 } from "node:fs/promises";
+import { readFile as readFile38, stat as stat12 } from "node:fs/promises";
 import { join as join68 } from "node:path";
 function escapeRegExp2(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -81470,7 +81550,7 @@ async function readInstalledDesktopArtifactVersion(binaryPath, options2 = {}) {
 async function validateInstalledDesktopArtifact(binaryPath, metadata, options2 = {}) {
   const platform7 = options2.platform || process.platform;
   const readFileFn = options2.readFileFn || readFile38;
-  const statFn = options2.statFn || stat11;
+  const statFn = options2.statFn || stat12;
   try {
     if (platform7 === "linux" || platform7 === "win32") {
       const fileStat = await statFn(binaryPath);
@@ -81497,7 +81577,7 @@ async function validateInstalledDesktopArtifact(binaryPath, metadata, options2 =
 import { execFile as execFile9 } from "node:child_process";
 import { chmod as chmod3, mkdtemp, readdir as readdir16, rename as rename9 } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { basename as basename19, dirname as dirname27, join as join69 } from "node:path";
+import { basename as basename20, dirname as dirname27, join as join69 } from "node:path";
 import { promisify as promisify10 } from "node:util";
 init_logger();
 var import_fs_extra7 = __toESM(require_lib3(), 1);
@@ -81555,8 +81635,8 @@ async function installDesktopBinary(downloadPath, options2 = {}) {
       await execFileAsync6("xattr", ["-dr", "com.apple.quarantine", path6]);
     });
     const stagingDir = await mkdtemp(join69(tmpdir(), "ck-desktop-app-"));
-    const stagedInstallPath = join69(dirname27(targetPath), `${basename19(targetPath)}.new`);
-    const backupInstallPath = join69(dirname27(targetPath), `${basename19(targetPath)}.backup`);
+    const stagedInstallPath = join69(dirname27(targetPath), `${basename20(targetPath)}.new`);
+    const backupInstallPath = join69(dirname27(targetPath), `${basename20(targetPath)}.backup`);
     let swappedInstall = false;
     try {
       await extractZipFn(downloadPath, { dir: stagingDir });
@@ -81589,7 +81669,7 @@ async function installDesktopBinary(downloadPath, options2 = {}) {
     return targetPath;
   }
   if (platform7 === "linux") {
-    const backupInstallPath = join69(dirname27(targetPath), `${basename19(targetPath)}.backup`);
+    const backupInstallPath = join69(dirname27(targetPath), `${basename20(targetPath)}.backup`);
     try {
       await import_fs_extra7.remove(backupInstallPath);
       if (await import_fs_extra7.pathExists(targetPath)) {
@@ -81613,7 +81693,7 @@ async function installDesktopBinary(downloadPath, options2 = {}) {
     return targetPath;
   }
   if (platform7 === "win32") {
-    const backupInstallPath = join69(dirname27(targetPath), `${basename19(targetPath)}.backup`);
+    const backupInstallPath = join69(dirname27(targetPath), `${basename20(targetPath)}.backup`);
     try {
       await import_fs_extra7.remove(backupInstallPath);
       if (await import_fs_extra7.pathExists(targetPath)) {
@@ -81642,7 +81722,7 @@ async function installDesktopBinary(downloadPath, options2 = {}) {
 init_logger();
 init_output_manager();
 import { createWriteStream as createWriteStream2, rmSync } from "node:fs";
-import { mkdir as mkdir17 } from "node:fs/promises";
+import { mkdir as mkdir18 } from "node:fs/promises";
 import { join as join70 } from "node:path";
 
 // src/shared/progress-bar.ts
@@ -81808,20 +81888,20 @@ init_types3();
 // src/domains/installation/utils/path-security.ts
 init_types3();
 import { lstatSync, realpathSync as realpathSync3 } from "node:fs";
-import { relative as relative13, resolve as resolve25 } from "node:path";
+import { relative as relative13, resolve as resolve26 } from "node:path";
 var MAX_EXTRACTION_SIZE = 500 * 1024 * 1024;
 function isPathSafe(basePath, targetPath) {
-  const resolvedBase = resolve25(basePath);
+  const resolvedBase = resolve26(basePath);
   try {
-    const stat12 = lstatSync(targetPath);
-    if (stat12.isSymbolicLink()) {
+    const stat13 = lstatSync(targetPath);
+    if (stat13.isSymbolicLink()) {
       const realTarget = realpathSync3(targetPath);
       if (!realTarget.startsWith(resolvedBase)) {
         return false;
       }
     }
   } catch {}
-  const resolvedTarget = resolve25(targetPath);
+  const resolvedTarget = resolve26(targetPath);
   const relativePath = relative13(resolvedBase, resolvedTarget);
   return !relativePath.startsWith("..") && !relativePath.startsWith("/") && resolvedTarget.startsWith(resolvedBase);
 }
@@ -81854,7 +81934,7 @@ class FileDownloader {
   async downloadAsset(asset, destDir) {
     try {
       const destPath = join70(destDir, asset.name);
-      await mkdir17(destDir, { recursive: true });
+      await mkdir18(destDir, { recursive: true });
       output.info(`Downloading ${asset.name} (${formatBytes(asset.size)})...`);
       logger.verbose("Download details", {
         url: asset.browser_download_url,
@@ -81909,7 +81989,7 @@ class FileDownloader {
         }
         if (downloadedSize !== totalSize) {
           fileStream.end();
-          await new Promise((resolve26) => fileStream.once("close", resolve26));
+          await new Promise((resolve27) => fileStream.once("close", resolve27));
           try {
             rmSync(destPath, { force: true });
           } catch (cleanupError) {
@@ -81923,7 +82003,7 @@ class FileDownloader {
         return destPath;
       } catch (error) {
         fileStream.end();
-        await new Promise((resolve26) => fileStream.once("close", resolve26));
+        await new Promise((resolve27) => fileStream.once("close", resolve27));
         try {
           rmSync(destPath, { force: true });
         } catch (cleanupError) {
@@ -81939,7 +82019,7 @@ class FileDownloader {
   async downloadFile(params) {
     const { url, name, size, destDir, token } = params;
     const destPath = join70(destDir, name);
-    await mkdir17(destDir, { recursive: true });
+    await mkdir18(destDir, { recursive: true });
     output.info(`Downloading ${name}${size ? ` (${formatBytes(size)})` : ""}...`);
     const headers = {};
     if (token && url.includes("api.github.com")) {
@@ -81989,7 +82069,7 @@ class FileDownloader {
       const expectedSize = Number(response.headers.get("content-length"));
       if (expectedSize > 0 && downloadedSize !== expectedSize) {
         fileStream.end();
-        await new Promise((resolve26) => fileStream.once("close", resolve26));
+        await new Promise((resolve27) => fileStream.once("close", resolve27));
         try {
           rmSync(destPath, { force: true });
         } catch (cleanupError) {
@@ -82007,7 +82087,7 @@ class FileDownloader {
       return destPath;
     } catch (error) {
       fileStream.end();
-      await new Promise((resolve26) => fileStream.once("close", resolve26));
+      await new Promise((resolve27) => fileStream.once("close", resolve27));
       try {
         rmSync(destPath, { force: true });
       } catch (cleanupError) {
@@ -82302,16 +82382,16 @@ function registerAppCommand(cli) {
   });
 }
 // src/services/file-operations/destructive-operation-backup-manager.ts
-import { readdir as readdir18, stat as stat12 } from "node:fs/promises";
-import { basename as basename21, join as join72, resolve as resolve27, sep as sep9 } from "node:path";
+import { readdir as readdir18, stat as stat13 } from "node:fs/promises";
+import { basename as basename22, join as join72, resolve as resolve28, sep as sep9 } from "node:path";
 
 // src/services/file-operations/destructive-operation-backup.ts
 init_logger();
 init_path_resolver();
 init_zod();
 var import_fs_extra9 = __toESM(require_lib3(), 1);
-import { mkdir as mkdir18, readdir as readdir17, readlink, rename as rename10, symlink } from "node:fs/promises";
-import { basename as basename20, dirname as dirname28, isAbsolute as isAbsolute7, join as join71, normalize as normalize4, resolve as resolve26, sep as sep8 } from "node:path";
+import { mkdir as mkdir19, readdir as readdir17, readlink, rename as rename10, symlink } from "node:fs/promises";
+import { basename as basename21, dirname as dirname28, isAbsolute as isAbsolute7, join as join71, normalize as normalize4, resolve as resolve27, sep as sep8 } from "node:path";
 var SNAPSHOT_DIR = "snapshot";
 var MANIFEST_FILE = "manifest.json";
 function normalizeRelativePath(rootDir, inputPath) {
@@ -82319,21 +82399,21 @@ function normalizeRelativePath(rootDir, inputPath) {
     throw new Error(`Unsafe backup path: ${inputPath}`);
   }
   const normalized = normalize4(inputPath).replaceAll("\\", "/");
-  const resolvedRoot = resolve26(rootDir);
-  const resolvedPath = resolve26(rootDir, normalized);
+  const resolvedRoot = resolve27(rootDir);
+  const resolvedPath = resolve27(rootDir, normalized);
   if (normalized === ".." || normalized.startsWith("../") || !resolvedPath.startsWith(`${resolvedRoot}${sep8}`) && resolvedPath !== resolvedRoot) {
     throw new Error(`Path escapes installation root: ${inputPath}`);
   }
   return normalized;
 }
 function getManagedBackupRoot() {
-  return resolve26(PathResolver.getConfigDir(false), "backups");
+  return resolve27(PathResolver.getConfigDir(false), "backups");
 }
 async function getExistingRealpath(pathToResolve) {
   if (await import_fs_extra9.pathExists(pathToResolve)) {
-    return resolve26(await import_fs_extra9.realpath(pathToResolve));
+    return resolve27(await import_fs_extra9.realpath(pathToResolve));
   }
-  return resolve26(pathToResolve);
+  return resolve27(pathToResolve);
 }
 async function assertManagedBackupDir(backupDir) {
   const resolvedBackupDir = await getExistingRealpath(backupDir);
@@ -82378,13 +82458,13 @@ function buildTargets(sourceRoot, deletePaths, mutatePaths) {
   });
 }
 async function snapshotItem(sourceRoot, backupDir, target) {
-  const sourcePath = resolve26(sourceRoot, target.path);
+  const sourcePath = resolve27(sourceRoot, target.path);
   if (!await import_fs_extra9.pathExists(sourcePath)) {
     return null;
   }
   const stats = await import_fs_extra9.lstat(sourcePath);
   if (stats.isSymbolicLink()) {
-    const realTargetPath = resolve26(await import_fs_extra9.realpath(sourcePath));
+    const realTargetPath = resolve27(await import_fs_extra9.realpath(sourcePath));
     const resolvedSourceRoot = await getExistingRealpath(sourceRoot);
     if (!realTargetPath.startsWith(`${resolvedSourceRoot}${sep8}`) && realTargetPath !== resolvedSourceRoot) {
       throw new Error(`Symlink target escapes installation root: ${target.path}`);
@@ -82392,7 +82472,7 @@ async function snapshotItem(sourceRoot, backupDir, target) {
     const snapshotPath2 = join71(SNAPSHOT_DIR, target.path);
     const snapshotFullPath2 = join71(backupDir, snapshotPath2);
     const linkTarget = await readlink(sourcePath);
-    await mkdir18(dirname28(snapshotFullPath2), { recursive: true });
+    await mkdir19(dirname28(snapshotFullPath2), { recursive: true });
     await symlink(linkTarget, snapshotFullPath2);
     return {
       path: target.path,
@@ -82404,7 +82484,7 @@ async function snapshotItem(sourceRoot, backupDir, target) {
   const kind = stats.isDirectory() ? "directory" : "file";
   const snapshotPath = join71(SNAPSHOT_DIR, target.path);
   const snapshotFullPath = join71(backupDir, snapshotPath);
-  await mkdir18(dirname28(snapshotFullPath), { recursive: true });
+  await mkdir19(dirname28(snapshotFullPath), { recursive: true });
   if (kind === "directory") {
     await copyDirectorySnapshot(sourcePath, snapshotFullPath, sourceRoot);
   } else {
@@ -82418,13 +82498,13 @@ async function snapshotItem(sourceRoot, backupDir, target) {
   };
 }
 async function copyDirectorySnapshot(sourceDir, destDir, rootDir) {
-  await mkdir18(destDir, { recursive: true });
+  await mkdir19(destDir, { recursive: true });
   const entries = await readdir17(sourceDir, { withFileTypes: true });
   for (const entry of entries) {
     const sourceEntry = join71(sourceDir, entry.name);
     const destEntry = join71(destDir, entry.name);
     if (entry.isSymbolicLink()) {
-      const realTargetPath = resolve26(await import_fs_extra9.realpath(sourceEntry));
+      const realTargetPath = resolve27(await import_fs_extra9.realpath(sourceEntry));
       const resolvedRoot = await getExistingRealpath(rootDir);
       if (!realTargetPath.startsWith(`${resolvedRoot}${sep8}`) && realTargetPath !== resolvedRoot) {
         throw new Error(`Nested symlink target escapes installation root: ${sourceEntry}`);
@@ -82443,14 +82523,14 @@ async function copyDirectorySnapshot(sourceDir, destDir, rootDir) {
 }
 function buildRestoreTempPath(sourcePath, suffix) {
   const random = Math.random().toString(36).slice(2, 8);
-  return join71(dirname28(sourcePath), `.ck-${suffix}-${basename20(sourcePath)}-${Date.now()}-${random}`);
+  return join71(dirname28(sourcePath), `.ck-${suffix}-${basename21(sourcePath)}-${Date.now()}-${random}`);
 }
 async function assertSafeRestoreDestination(targetPath, rootDir) {
   const resolvedRoot = await getExistingRealpath(rootDir);
-  const lexicalRoot = resolve26(rootDir);
+  const lexicalRoot = resolve27(rootDir);
   let currentPath = dirname28(targetPath);
   while (true) {
-    const resolvedCurrent = resolve26(currentPath);
+    const resolvedCurrent = resolve27(currentPath);
     if (!resolvedCurrent.startsWith(`${lexicalRoot}${sep8}`) && resolvedCurrent !== lexicalRoot) {
       throw new Error(`Restore target escapes installation root: ${targetPath}`);
     }
@@ -82471,15 +82551,15 @@ async function assertSafeRestoreDestination(targetPath, rootDir) {
   }
 }
 async function copySnapshotDirectoryForRestore(snapshotDir, destDir, rootDir) {
-  await mkdir18(destDir, { recursive: true });
+  await mkdir19(destDir, { recursive: true });
   const entries = await readdir17(snapshotDir, { withFileTypes: true });
   for (const entry of entries) {
     const sourceEntry = join71(snapshotDir, entry.name);
     const destEntry = join71(destDir, entry.name);
     if (entry.isSymbolicLink()) {
       const linkTarget = await readlink(sourceEntry);
-      const resolvedTarget = resolve26(dirname28(destEntry), linkTarget);
-      const lexicalRoot = resolve26(rootDir);
+      const resolvedTarget = resolve27(dirname28(destEntry), linkTarget);
+      const lexicalRoot = resolve27(rootDir);
       if (!resolvedTarget.startsWith(`${lexicalRoot}${sep8}`) && resolvedTarget !== lexicalRoot) {
         throw new Error(`Nested restore symlink escapes installation root: ${destEntry}`);
       }
@@ -82496,7 +82576,7 @@ async function copySnapshotDirectoryForRestore(snapshotDir, destDir, rootDir) {
   }
 }
 async function stageRestorePlan(plan, rootDir) {
-  await mkdir18(dirname28(plan.restoreTempPath), { recursive: true });
+  await mkdir19(dirname28(plan.restoreTempPath), { recursive: true });
   const snapshotStats = await import_fs_extra9.lstat(plan.snapshotPath);
   if (snapshotStats.isSymbolicLink()) {
     await symlink(await readlink(plan.snapshotPath), plan.restoreTempPath);
@@ -82542,7 +82622,7 @@ async function createDestructiveOperationBackup(request) {
   const manifestPath = join71(backupDir, MANIFEST_FILE);
   const targets = buildTargets(request.sourceRoot, request.deletePaths, request.mutatePaths ?? []);
   try {
-    await mkdir18(join71(backupDir, SNAPSHOT_DIR), { recursive: true });
+    await mkdir19(join71(backupDir, SNAPSHOT_DIR), { recursive: true });
     const items = [];
     for (const target of targets) {
       const snapshot = await snapshotItem(request.sourceRoot, backupDir, target);
@@ -82554,7 +82634,7 @@ async function createDestructiveOperationBackup(request) {
       version: 1,
       operation: request.operation,
       createdAt: new Date().toISOString(),
-      sourceRoot: resolve26(request.sourceRoot),
+      sourceRoot: resolve27(request.sourceRoot),
       scope: request.scope,
       kit: request.kit,
       items,
@@ -82578,7 +82658,7 @@ async function loadDestructiveOperationBackup(backupDir) {
   if (!isAbsolute7(manifest.sourceRoot)) {
     throw new Error(`Backup manifest source root must be absolute: ${manifest.sourceRoot}`);
   }
-  const resolvedSourceRoot = resolve26(manifest.sourceRoot);
+  const resolvedSourceRoot = resolve27(manifest.sourceRoot);
   for (const item of manifest.items) {
     normalizeRelativePath(resolvedSourceRoot, item.path);
     const normalizedSnapshotPath = normalizeRelativePath(resolvedBackupDir, item.snapshotPath);
@@ -82598,8 +82678,8 @@ async function loadDestructiveOperationBackup(backupDir) {
 async function restoreDestructiveOperationBackup(backup) {
   const restorePlans = [];
   for (const item of backup.manifest.items) {
-    const sourcePath = resolve26(backup.manifest.sourceRoot, normalizeRelativePath(backup.manifest.sourceRoot, item.path));
-    const snapshotPath = resolve26(backup.backupDir, normalizeRelativePath(backup.backupDir, item.snapshotPath));
+    const sourcePath = resolve27(backup.manifest.sourceRoot, normalizeRelativePath(backup.manifest.sourceRoot, item.path));
+    const snapshotPath = resolve27(backup.backupDir, normalizeRelativePath(backup.backupDir, item.snapshotPath));
     try {
       await import_fs_extra9.lstat(snapshotPath);
     } catch {
@@ -82641,7 +82721,7 @@ init_path_resolver();
 var import_fs_extra10 = __toESM(require_lib3(), 1);
 var DEFAULT_DESTRUCTIVE_BACKUP_KEEP_COUNT = 10;
 function getBackupsRoot() {
-  return resolve27(PathResolver.getConfigDir(false), "backups");
+  return resolve28(PathResolver.getConfigDir(false), "backups");
 }
 function validateBackupId(backupId) {
   if (!backupId || !/^[A-Za-z0-9._:-]+$/.test(backupId) || backupId.includes("..")) {
@@ -82651,7 +82731,7 @@ function validateBackupId(backupId) {
 function resolveBackupDir(backupId) {
   validateBackupId(backupId);
   const backupsRoot = getBackupsRoot();
-  const backupDir = resolve27(backupsRoot, backupId);
+  const backupDir = resolve28(backupsRoot, backupId);
   if (!backupDir.startsWith(`${backupsRoot}${sep9}`) && backupDir !== backupsRoot) {
     throw new Error(`Backup id escapes backup root: ${backupId}`);
   }
@@ -82670,7 +82750,7 @@ async function getDirectorySize(dirPath) {
       continue;
     }
     if (entry.isFile()) {
-      size += (await stat12(fullPath)).size;
+      size += (await stat13(fullPath)).size;
     }
   }
   return size;
@@ -82681,7 +82761,7 @@ async function listBackupDirs() {
     return [];
   }
   const entries = await readdir18(backupsRoot, { withFileTypes: true });
-  return entries.filter((entry) => entry.isDirectory()).map((entry) => join72(backupsRoot, entry.name)).sort((left, right) => basename21(right).localeCompare(basename21(left)));
+  return entries.filter((entry) => entry.isDirectory()).map((entry) => join72(backupsRoot, entry.name)).sort((left, right) => basename22(right).localeCompare(basename22(left)));
 }
 function sortBackupSummaries(left, right) {
   if (left.valid && right.valid) {
@@ -82694,7 +82774,7 @@ function sortBackupSummaries(left, right) {
   return right.id.localeCompare(left.id);
 }
 async function summarizeBackup(backupDir) {
-  const id = basename21(backupDir);
+  const id = basename22(backupDir);
   const sizeBytes = await getDirectorySize(backupDir).catch(() => 0);
   try {
     const backup = await loadDestructiveOperationBackup(backupDir);
@@ -82750,7 +82830,7 @@ async function pruneDestructiveOperationBackups(options2) {
   const keptIds = [];
   let targets;
   if (options2?.all) {
-    targets = backupDirs.filter((backupDir) => !exclude.has(basename21(backupDir)));
+    targets = backupDirs.filter((backupDir) => !exclude.has(basename22(backupDir)));
   } else if (options2?.backupIds?.length) {
     targets = options2.backupIds.map(resolveBackupDir);
   } else {
@@ -82761,7 +82841,7 @@ async function pruneDestructiveOperationBackups(options2) {
     keptIds.push(...[...keepIds]);
   }
   for (const backupDir of targets) {
-    const backupId = basename21(backupDir);
+    const backupId = basename22(backupDir);
     if (!await import_fs_extra10.pathExists(backupDir)) {
       continue;
     }
@@ -82771,7 +82851,7 @@ async function pruneDestructiveOperationBackups(options2) {
   if (!options2?.all && !options2?.backupIds?.length) {
     const deleted = new Set(deletedIds);
     for (const backupDir of backupDirs) {
-      const backupId = basename21(backupDir);
+      const backupId = basename22(backupDir);
       if (!deleted.has(backupId) && !keptIds.includes(backupId)) {
         keptIds.push(backupId);
       }
@@ -82865,7 +82945,7 @@ async function handleBackupsList(options2) {
 // src/shared/process-lock.ts
 init_logger();
 var import_proper_lockfile5 = __toESM(require_proper_lockfile(), 1);
-import { mkdir as mkdir19 } from "node:fs/promises";
+import { mkdir as mkdir20 } from "node:fs/promises";
 import os5 from "node:os";
 import { join as join73 } from "node:path";
 var LOCK_CONFIGS = {
@@ -82897,7 +82977,7 @@ function registerCleanupHandlers() {
 }
 async function ensureLocksDir() {
   const lockDir = getLocksDir();
-  await mkdir19(lockDir, { recursive: true });
+  await mkdir20(lockDir, { recursive: true });
 }
 function getLockPaths(lockName) {
   const resource = join73(getLocksDir(), `${lockName}.lock`);
@@ -83025,7 +83105,7 @@ init_path_resolver();
 var import_fs_extra11 = __toESM(require_lib3(), 1);
 var import_proper_lockfile6 = __toESM(require_proper_lockfile(), 1);
 import { createHash as createHash5 } from "node:crypto";
-import { join as join74, resolve as resolve28 } from "node:path";
+import { join as join74, resolve as resolve29 } from "node:path";
 var LOCK_OPTIONS = {
   realpath: false,
   retries: { retries: 5, minTimeout: 100, maxTimeout: 1000 },
@@ -83033,9 +83113,9 @@ var LOCK_OPTIONS = {
 };
 async function getCanonicalInstallationRoot(installationRoot) {
   if (await import_fs_extra11.pathExists(installationRoot)) {
-    return resolve28(await import_fs_extra11.realpath(installationRoot));
+    return resolve29(await import_fs_extra11.realpath(installationRoot));
   }
-  return resolve28(installationRoot);
+  return resolve29(installationRoot);
 }
 async function getInstallationStateLockPath(installationRoot) {
   const normalizedRoot = await getCanonicalInstallationRoot(installationRoot);
@@ -84855,9 +84935,9 @@ function checkClaudeMdFile(path6, name, id) {
     };
   }
   try {
-    const stat13 = statSync9(path6);
-    const sizeKB = (stat13.size / 1024).toFixed(1);
-    if (stat13.size === 0) {
+    const stat14 = statSync9(path6);
+    const sizeKB = (stat14.size / 1024).toFixed(1);
+    if (stat14.size === 0) {
       return {
         id,
         name,
@@ -85252,7 +85332,7 @@ init_path_resolver();
 import { existsSync as existsSync53 } from "node:fs";
 import { readFile as readFile40 } from "node:fs/promises";
 import { homedir as homedir42 } from "node:os";
-import { dirname as dirname29, join as join82, normalize as normalize6, resolve as resolve29 } from "node:path";
+import { dirname as dirname29, join as join82, normalize as normalize6, resolve as resolve30 } from "node:path";
 async function checkPathRefsValid(projectDir) {
   const globalClaudeMd = join82(PathResolver.getGlobalKitDir(), "CLAUDE.md");
   const projectClaudeMd = join82(projectDir, ".claude", "CLAUDE.md");
@@ -85299,7 +85379,7 @@ async function checkPathRefsValid(projectDir) {
       } else if (/^[A-Za-z]:/.test(ref)) {
         refPath = normalize6(ref);
       } else {
-        refPath = resolve29(baseDir, ref);
+        refPath = resolve30(baseDir, ref);
       }
       const normalizedPath = normalize6(refPath);
       const isWithinHome = normalizedPath.startsWith(home9);
@@ -85869,13 +85949,13 @@ import { spawnSync as spawnSync3 } from "node:child_process";
 import { existsSync as existsSync55, readFileSync as readFileSync15, statSync as statSync10, writeFileSync as writeFileSync5 } from "node:fs";
 import { readdir as readdir21 } from "node:fs/promises";
 import { homedir as homedir43, tmpdir as tmpdir2 } from "node:os";
-import { join as join86, resolve as resolve30 } from "node:path";
+import { join as join86, resolve as resolve31 } from "node:path";
 var HOOK_CHECK_TIMEOUT_MS = 5000;
 var PYTHON_CHECK_TIMEOUT_MS = 3000;
 var MAX_LOG_FILE_SIZE_BYTES = 10 * 1024 * 1024;
 function getHooksDir(projectDir) {
-  const projectHooksDir = resolve30(projectDir, ".claude", "hooks");
-  const globalHooksDir = resolve30(PathResolver.getGlobalKitDir(), "hooks");
+  const projectHooksDir = resolve31(projectDir, ".claude", "hooks");
+  const globalHooksDir = resolve31(PathResolver.getGlobalKitDir(), "hooks");
   if (existsSync55(projectHooksDir))
     return projectHooksDir;
   if (existsSync55(globalHooksDir))
@@ -85883,7 +85963,7 @@ function getHooksDir(projectDir) {
   return null;
 }
 function isPathWithin(filePath, parentDir) {
-  return resolve30(filePath).startsWith(resolve30(parentDir));
+  return resolve31(filePath).startsWith(resolve31(parentDir));
 }
 function getCanonicalGlobalCommandRoot() {
   const configuredGlobalDir = PathResolver.getGlobalKitDir().replace(/\\/g, "/").replace(/\/+$/, "");
@@ -85894,22 +85974,22 @@ function getClaudeSettingsFiles(projectDir) {
   const globalClaudeDir = PathResolver.getGlobalKitDir();
   const candidates = [
     {
-      path: resolve30(projectDir, ".claude", "settings.json"),
+      path: resolve31(projectDir, ".claude", "settings.json"),
       label: "project settings.json",
       root: "$CLAUDE_PROJECT_DIR"
     },
     {
-      path: resolve30(projectDir, ".claude", "settings.local.json"),
+      path: resolve31(projectDir, ".claude", "settings.local.json"),
       label: "project settings.local.json",
       root: "$CLAUDE_PROJECT_DIR"
     },
     {
-      path: resolve30(globalClaudeDir, "settings.json"),
+      path: resolve31(globalClaudeDir, "settings.json"),
       label: "global settings.json",
       root: getCanonicalGlobalCommandRoot()
     },
     {
-      path: resolve30(globalClaudeDir, "settings.local.json"),
+      path: resolve31(globalClaudeDir, "settings.local.json"),
       label: "global settings.local.json",
       root: getCanonicalGlobalCommandRoot()
     }
@@ -86402,7 +86482,7 @@ function resolveHookScriptPath(scriptPath, projectDir) {
   if (resolved.startsWith(".claude/") || resolved === ".claude") {
     resolved = join86(projectDir, resolved);
   }
-  return resolve30(resolved);
+  return resolve31(resolved);
 }
 function collectMissingHookReferences(settings, settingsFile, projectDir) {
   if (!settings.hooks)
@@ -87441,7 +87521,7 @@ import { platform as platform8 } from "node:os";
 // src/domains/health-checks/platform/environment-checker.ts
 init_environment();
 init_path_resolver();
-import { constants as constants3, access as access4, mkdir as mkdir20, readFile as readFile42, unlink as unlink10, writeFile as writeFile20 } from "node:fs/promises";
+import { constants as constants3, access as access4, mkdir as mkdir21, readFile as readFile42, unlink as unlink10, writeFile as writeFile20 } from "node:fs/promises";
 import { arch as arch2, homedir as homedir44, platform as platform7 } from "node:os";
 import { join as join88, normalize as normalize7 } from "node:path";
 function shouldSkipExpensiveOperations4() {
@@ -87536,7 +87616,7 @@ async function checkGlobalDirAccess() {
   }
   const testFile = join88(globalDir, ".ck-doctor-access-test");
   try {
-    await mkdir20(globalDir, { recursive: true });
+    await mkdir21(globalDir, { recursive: true });
     await writeFile20(testFile, "test", "utf-8");
     const content = await readFile42(testFile, "utf-8");
     await unlink10(testFile);
@@ -87611,7 +87691,7 @@ async function checkWSLBoundary() {
 
 // src/domains/health-checks/platform/windows-checker.ts
 init_path_resolver();
-import { mkdir as mkdir21, symlink as symlink2, unlink as unlink11, writeFile as writeFile21 } from "node:fs/promises";
+import { mkdir as mkdir22, symlink as symlink2, unlink as unlink11, writeFile as writeFile21 } from "node:fs/promises";
 import { join as join89 } from "node:path";
 async function checkLongPathSupport() {
   if (shouldSkipExpensiveOperations4()) {
@@ -87667,7 +87747,7 @@ async function checkSymlinkSupport() {
   const target = join89(testDir, ".ck-symlink-test-target");
   const link = join89(testDir, ".ck-symlink-test-link");
   try {
-    await mkdir21(testDir, { recursive: true });
+    await mkdir22(testDir, { recursive: true });
     await writeFile21(target, "test", "utf-8");
     await symlink2(target, link);
     await unlink11(link);
@@ -88430,14 +88510,14 @@ init_github_client();
 init_config_version_checker();
 
 // src/domains/sync/sync-engine.ts
-import { lstat as lstat4, readFile as readFile43, readlink as readlink2, realpath as realpath6, stat as stat14 } from "node:fs/promises";
+import { lstat as lstat4, readFile as readFile43, readlink as readlink2, realpath as realpath6, stat as stat15 } from "node:fs/promises";
 import { isAbsolute as isAbsolute8, join as join91, normalize as normalize8, relative as relative15 } from "node:path";
 
 // src/services/file-operations/ownership-checker.ts
 init_metadata_migration();
 import { createHash as createHash6 } from "node:crypto";
 import { createReadStream as createReadStream2 } from "node:fs";
-import { stat as stat13 } from "node:fs/promises";
+import { stat as stat14 } from "node:fs/promises";
 import { relative as relative14 } from "node:path";
 
 // src/shared/concurrent-file-ops.ts
@@ -88451,12 +88531,12 @@ async function mapWithLimit(items, fn, concurrency = DEFAULT_CONCURRENCY) {
 // src/services/file-operations/ownership-checker.ts
 class OwnershipChecker {
   static async calculateChecksum(filePath) {
-    return new Promise((resolve31, reject) => {
+    return new Promise((resolve32, reject) => {
       const hash = createHash6("sha256");
       const stream = createReadStream2(filePath);
       stream.on("data", (chunk) => hash.update(chunk));
       stream.on("end", () => {
-        resolve31(hash.digest("hex"));
+        resolve32(hash.digest("hex"));
       });
       stream.on("error", (err) => {
         stream.destroy();
@@ -88466,7 +88546,7 @@ class OwnershipChecker {
   }
   static async checkOwnership(filePath, metadata, claudeDir3) {
     try {
-      await stat13(filePath);
+      await stat14(filePath);
     } catch {
       return { path: filePath, ownership: "user", exists: false };
     }
@@ -89741,7 +89821,7 @@ class SyncEngine {
         continue;
       }
       try {
-        await stat14(upstreamPath);
+        await stat15(upstreamPath);
       } catch {
         plan.skipped.push(file);
         continue;
@@ -89755,7 +89835,7 @@ class SyncEngine {
         continue;
       }
       try {
-        await stat14(localPath);
+        await stat15(localPath);
       } catch {
         plan.autoUpdate.push(file);
         continue;
@@ -91051,7 +91131,7 @@ init_github_client();
 init_environment();
 init_logger();
 init_safe_spinner();
-import { mkdir as mkdir28, stat as stat17 } from "node:fs/promises";
+import { mkdir as mkdir29, stat as stat18 } from "node:fs/promises";
 import { tmpdir as tmpdir5 } from "node:os";
 import { join as join105 } from "node:path";
 
@@ -91105,7 +91185,7 @@ async function validateExtraction(extractDir) {
 
 // src/domains/installation/extraction/tar-extractor.ts
 init_logger();
-import { copyFile as copyFile5, mkdir as mkdir26, readdir as readdir24, rm as rm10, stat as stat15 } from "node:fs/promises";
+import { copyFile as copyFile5, mkdir as mkdir27, readdir as readdir24, rm as rm10, stat as stat16 } from "node:fs/promises";
 import { join as join103 } from "node:path";
 
 // node_modules/@isaacs/fs-minipass/dist/esm/index.js
@@ -91654,10 +91734,10 @@ class Minipass extends EventEmitter3 {
     return this[ENCODING] ? buf.join("") : Buffer.concat(buf, buf.dataLength);
   }
   async promise() {
-    return new Promise((resolve33, reject) => {
+    return new Promise((resolve34, reject) => {
       this.on(DESTROYED, () => reject(new Error("stream destroyed")));
       this.on("error", (er) => reject(er));
-      this.on("end", () => resolve33());
+      this.on("end", () => resolve34());
     });
   }
   [Symbol.asyncIterator]() {
@@ -91676,7 +91756,7 @@ class Minipass extends EventEmitter3 {
         return Promise.resolve({ done: false, value: res });
       if (this[EOF])
         return stop();
-      let resolve33;
+      let resolve34;
       let reject;
       const onerr = (er) => {
         this.off("data", ondata);
@@ -91690,19 +91770,19 @@ class Minipass extends EventEmitter3 {
         this.off("end", onend);
         this.off(DESTROYED, ondestroy);
         this.pause();
-        resolve33({ value, done: !!this[EOF] });
+        resolve34({ value, done: !!this[EOF] });
       };
       const onend = () => {
         this.off("error", onerr);
         this.off("data", ondata);
         this.off(DESTROYED, ondestroy);
         stop();
-        resolve33({ done: true, value: undefined });
+        resolve34({ done: true, value: undefined });
       };
       const ondestroy = () => onerr(new Error("stream destroyed"));
       return new Promise((res2, rej) => {
         reject = rej;
-        resolve33 = res2;
+        resolve34 = res2;
         this.once(DESTROYED, ondestroy);
         this.once("error", onerr);
         this.once("end", onend);
@@ -92808,10 +92888,10 @@ class Minipass2 extends EventEmitter4 {
     return this[ENCODING2] ? buf.join("") : Buffer.concat(buf, buf.dataLength);
   }
   async promise() {
-    return new Promise((resolve33, reject) => {
+    return new Promise((resolve34, reject) => {
       this.on(DESTROYED2, () => reject(new Error("stream destroyed")));
       this.on("error", (er) => reject(er));
-      this.on("end", () => resolve33());
+      this.on("end", () => resolve34());
     });
   }
   [Symbol.asyncIterator]() {
@@ -92830,7 +92910,7 @@ class Minipass2 extends EventEmitter4 {
         return Promise.resolve({ done: false, value: res });
       if (this[EOF2])
         return stop();
-      let resolve33;
+      let resolve34;
       let reject;
       const onerr = (er) => {
         this.off("data", ondata);
@@ -92844,19 +92924,19 @@ class Minipass2 extends EventEmitter4 {
         this.off("end", onend);
         this.off(DESTROYED2, ondestroy);
         this.pause();
-        resolve33({ value, done: !!this[EOF2] });
+        resolve34({ value, done: !!this[EOF2] });
       };
       const onend = () => {
         this.off("error", onerr);
         this.off("data", ondata);
         this.off(DESTROYED2, ondestroy);
         stop();
-        resolve33({ done: true, value: undefined });
+        resolve34({ done: true, value: undefined });
       };
       const ondestroy = () => onerr(new Error("stream destroyed"));
       return new Promise((res2, rej) => {
         reject = rej;
-        resolve33 = res2;
+        resolve34 = res2;
         this.once(DESTROYED2, ondestroy);
         this.once("error", onerr);
         this.once("end", onend);
@@ -93629,7 +93709,7 @@ var NULLS = new Array(156).join("\x00");
 var encString = (buf, off, size, str2) => str2 === undefined ? false : (buf.write(str2 + NULLS, off, size, "utf8"), str2.length !== Buffer.byteLength(str2) || str2.length > size);
 
 // node_modules/tar/dist/esm/pax.js
-import { basename as basename22 } from "node:path";
+import { basename as basename23 } from "node:path";
 class Pax {
   atime;
   mtime;
@@ -93678,7 +93758,7 @@ class Pax {
       buf[i] = 0;
     }
     new Header({
-      path: ("PaxHeader/" + basename22(this.path ?? "")).slice(0, 99),
+      path: ("PaxHeader/" + basename23(this.path ?? "")).slice(0, 99),
       mode: this.mode || 420,
       uid: this.uid,
       gid: this.gid,
@@ -94284,10 +94364,10 @@ class Minipass3 extends EventEmitter5 {
     return this[ENCODING3] ? buf.join("") : Buffer.concat(buf, buf.dataLength);
   }
   async promise() {
-    return new Promise((resolve33, reject) => {
+    return new Promise((resolve34, reject) => {
       this.on(DESTROYED3, () => reject(new Error("stream destroyed")));
       this.on("error", (er) => reject(er));
-      this.on("end", () => resolve33());
+      this.on("end", () => resolve34());
     });
   }
   [Symbol.asyncIterator]() {
@@ -94306,7 +94386,7 @@ class Minipass3 extends EventEmitter5 {
         return Promise.resolve({ done: false, value: res });
       if (this[EOF3])
         return stop();
-      let resolve33;
+      let resolve34;
       let reject;
       const onerr = (er) => {
         this.off("data", ondata);
@@ -94320,19 +94400,19 @@ class Minipass3 extends EventEmitter5 {
         this.off("end", onend);
         this.off(DESTROYED3, ondestroy);
         this.pause();
-        resolve33({ value, done: !!this[EOF3] });
+        resolve34({ value, done: !!this[EOF3] });
       };
       const onend = () => {
         this.off("error", onerr);
         this.off("data", ondata);
         this.off(DESTROYED3, ondestroy);
         stop();
-        resolve33({ done: true, value: undefined });
+        resolve34({ done: true, value: undefined });
       };
       const ondestroy = () => onerr(new Error("stream destroyed"));
       return new Promise((res2, rej) => {
         reject = rej;
-        resolve33 = res2;
+        resolve34 = res2;
         this.once(DESTROYED3, ondestroy);
         this.once("error", onerr);
         this.once("end", onend);
@@ -95073,16 +95153,16 @@ var listFileSync = (opt) => {
   let fd;
   try {
     fd = fs10.openSync(file, "r");
-    const stat15 = fs10.fstatSync(fd);
+    const stat16 = fs10.fstatSync(fd);
     const readSize = opt.maxReadSize || 16 * 1024 * 1024;
-    if (stat15.size < readSize) {
-      const buf = Buffer.allocUnsafe(stat15.size);
-      const read = fs10.readSync(fd, buf, 0, stat15.size, 0);
+    if (stat16.size < readSize) {
+      const buf = Buffer.allocUnsafe(stat16.size);
+      const read = fs10.readSync(fd, buf, 0, stat16.size, 0);
       p.end(read === buf.byteLength ? buf : buf.subarray(0, read));
     } else {
       let pos2 = 0;
       const buf = Buffer.allocUnsafe(readSize);
-      while (pos2 < stat15.size) {
+      while (pos2 < stat16.size) {
         const bytesRead = fs10.readSync(fd, buf, 0, readSize, pos2);
         if (bytesRead === 0)
           break;
@@ -95103,16 +95183,16 @@ var listFile = (opt, _files) => {
   const parse5 = new Parser(opt);
   const readSize = opt.maxReadSize || 16 * 1024 * 1024;
   const file = opt.file;
-  const p = new Promise((resolve33, reject) => {
+  const p = new Promise((resolve34, reject) => {
     parse5.on("error", reject);
-    parse5.on("end", resolve33);
-    fs10.stat(file, (er, stat15) => {
+    parse5.on("end", resolve34);
+    fs10.stat(file, (er, stat16) => {
       if (er) {
         reject(er);
       } else {
         const stream = new ReadStream(file, {
           readSize,
-          size: stat15.size
+          size: stat16.size
         });
         stream.on("error", reject);
         stream.pipe(parse5);
@@ -95296,21 +95376,21 @@ class WriteEntry extends Minipass3 {
     return super.emit(ev, ...data);
   }
   [LSTAT]() {
-    fs11.lstat(this.absolute, (er, stat15) => {
+    fs11.lstat(this.absolute, (er, stat16) => {
       if (er) {
         return this.emit("error", er);
       }
-      this[ONLSTAT](stat15);
+      this[ONLSTAT](stat16);
     });
   }
-  [ONLSTAT](stat15) {
-    this.statCache.set(this.absolute, stat15);
-    this.stat = stat15;
-    if (!stat15.isFile()) {
-      stat15.size = 0;
+  [ONLSTAT](stat16) {
+    this.statCache.set(this.absolute, stat16);
+    this.stat = stat16;
+    if (!stat16.isFile()) {
+      stat16.size = 0;
     }
-    this.type = getType(stat15);
-    this.emit("stat", stat15);
+    this.type = getType(stat16);
+    this.emit("stat", stat16);
     this[PROCESS]();
   }
   [PROCESS]() {
@@ -95743,7 +95823,7 @@ class WriteEntryTar extends Minipass3 {
     return this;
   }
 }
-var getType = (stat15) => stat15.isFile() ? "File" : stat15.isDirectory() ? "Directory" : stat15.isSymbolicLink() ? "SymbolicLink" : "Unsupported";
+var getType = (stat16) => stat16.isFile() ? "File" : stat16.isDirectory() ? "Directory" : stat16.isSymbolicLink() ? "SymbolicLink" : "Unsupported";
 
 // node_modules/yallist/dist/esm/index.js
 class Yallist {
@@ -96302,21 +96382,21 @@ class Pack extends Minipass3 {
   [STAT](job) {
     job.pending = true;
     this[JOBS] += 1;
-    const stat15 = this.follow ? "stat" : "lstat";
-    fs12[stat15](job.absolute, (er, stat16) => {
+    const stat16 = this.follow ? "stat" : "lstat";
+    fs12[stat16](job.absolute, (er, stat17) => {
       job.pending = false;
       this[JOBS] -= 1;
       if (er) {
         this.emit("error", er);
       } else {
-        this[ONSTAT](job, stat16);
+        this[ONSTAT](job, stat17);
       }
     });
   }
-  [ONSTAT](job, stat15) {
-    this.statCache.set(job.absolute, stat15);
-    job.stat = stat15;
-    if (!this.filter(job.path, stat15)) {
+  [ONSTAT](job, stat16) {
+    this.statCache.set(job.absolute, stat16);
+    job.stat = stat16;
+    if (!this.filter(job.path, stat16)) {
       job.ignore = true;
     }
     this[PROCESS2]();
@@ -96492,8 +96572,8 @@ class PackSync extends Pack {
   pause() {}
   resume() {}
   [STAT](job) {
-    const stat15 = this.follow ? "statSync" : "lstatSync";
-    this[ONSTAT](job, fs12[stat15](job.absolute));
+    const stat16 = this.follow ? "statSync" : "lstatSync";
+    this[ONSTAT](job, fs12[stat16](job.absolute));
   }
   [READDIR](job) {
     this[ONREADDIR](job, fs12.readdirSync(job.absolute));
@@ -96735,7 +96815,7 @@ var checkCwd = (dir, cb) => {
     cb(er);
   });
 };
-var mkdir24 = (dir, opt, cb) => {
+var mkdir25 = (dir, opt, cb) => {
   dir = normalizeWindowsPath(dir);
   const umask = opt.umask ?? 18;
   const mode = opt.mode | 448;
@@ -97258,7 +97338,7 @@ class Unpack extends Parser {
     }
   }
   [MKDIR](dir, mode, cb) {
-    mkdir24(normalizeWindowsPath(dir), {
+    mkdir25(normalizeWindowsPath(dir), {
       uid: this.uid,
       gid: this.gid,
       processUid: this.processUid,
@@ -97673,11 +97753,11 @@ class UnpackSync extends Unpack {
 var extractFileSync = (opt) => {
   const u = new UnpackSync(opt);
   const file = opt.file;
-  const stat15 = fs17.statSync(file);
+  const stat16 = fs17.statSync(file);
   const readSize = opt.maxReadSize || 16 * 1024 * 1024;
   const stream = new ReadStreamSync(file, {
     readSize,
-    size: stat15.size
+    size: stat16.size
   });
   stream.pipe(u);
 };
@@ -97685,16 +97765,16 @@ var extractFile = (opt, _3) => {
   const u = new Unpack(opt);
   const readSize = opt.maxReadSize || 16 * 1024 * 1024;
   const file = opt.file;
-  const p = new Promise((resolve33, reject) => {
+  const p = new Promise((resolve34, reject) => {
     u.on("error", reject);
-    u.on("close", resolve33);
-    fs17.stat(file, (er, stat15) => {
+    u.on("close", resolve34);
+    fs17.stat(file, (er, stat16) => {
       if (er) {
         reject(er);
       } else {
         const stream = new ReadStream(file, {
           readSize,
-          size: stat15.size
+          size: stat16.size
         });
         stream.on("error", reject);
         stream.pipe(u);
@@ -97820,7 +97900,7 @@ var replaceAsync = (opt, files) => {
     };
     fs18.read(fd, headBuf, 0, 512, position, onread);
   };
-  const promise = new Promise((resolve33, reject) => {
+  const promise = new Promise((resolve34, reject) => {
     p.on("error", reject);
     let flag = "r+";
     const onopen = (er, fd) => {
@@ -97845,7 +97925,7 @@ var replaceAsync = (opt, files) => {
           });
           p.pipe(stream);
           stream.on("error", reject);
-          stream.on("close", resolve33);
+          stream.on("close", resolve34);
           addFilesAsync2(p, files);
         });
       });
@@ -97909,7 +97989,7 @@ var mtimeFilter = (opt) => {
   if (!opt.mtimeCache) {
     opt.mtimeCache = new Map;
   }
-  opt.filter = filter ? (path14, stat15) => filter(path14, stat15) && !((opt.mtimeCache?.get(path14) ?? stat15.mtime ?? 0) > (stat15.mtime ?? 0)) : (path14, stat15) => !((opt.mtimeCache?.get(path14) ?? stat15.mtime ?? 0) > (stat15.mtime ?? 0));
+  opt.filter = filter ? (path14, stat16) => filter(path14, stat16) && !((opt.mtimeCache?.get(path14) ?? stat16.mtime ?? 0) > (stat16.mtime ?? 0)) : (path14, stat16) => !((opt.mtimeCache?.get(path14) ?? stat16.mtime ?? 0) > (stat16.mtime ?? 0));
 };
 // src/domains/installation/utils/archive-utils.ts
 init_types3();
@@ -97974,7 +98054,7 @@ function decodeFilePath(path14) {
 // src/domains/installation/utils/file-utils.ts
 init_logger();
 init_types3();
-import { copyFile as copyFile4, lstat as lstat5, mkdir as mkdir25, readdir as readdir23 } from "node:fs/promises";
+import { copyFile as copyFile4, lstat as lstat5, mkdir as mkdir26, readdir as readdir23 } from "node:fs/promises";
 import { join as join102, relative as relative16 } from "node:path";
 async function withRetry(fn, retries = 3) {
   for (let i = 0;i < retries; i++) {
@@ -97994,7 +98074,7 @@ var isRetryable = (e2) => {
 };
 var delay = (ms) => new Promise((r2) => setTimeout(r2, ms));
 async function moveDirectoryContents(sourceDir, destDir, shouldExclude, sizeTracker) {
-  await mkdir25(destDir, { recursive: true });
+  await mkdir26(destDir, { recursive: true });
   const entries = await readdir23(sourceDir, { encoding: "utf8" });
   for (const entry of entries) {
     const sourcePath = join102(sourceDir, entry);
@@ -98022,7 +98102,7 @@ async function moveDirectoryContents(sourceDir, destDir, shouldExclude, sizeTrac
   }
 }
 async function copyDirectory(sourceDir, destDir, shouldExclude, sizeTracker) {
-  await mkdir25(destDir, { recursive: true });
+  await mkdir26(destDir, { recursive: true });
   const entries = await readdir23(sourceDir, { encoding: "utf8" });
   for (const entry of entries) {
     const sourcePath = join102(sourceDir, entry);
@@ -98054,7 +98134,7 @@ async function copyDirectory(sourceDir, destDir, shouldExclude, sizeTracker) {
 class TarExtractor {
   async extract(archivePath, destDir, shouldExclude, sizeTracker) {
     const tempExtractDir = `${destDir}-temp`;
-    await mkdir26(tempExtractDir, { recursive: true });
+    await mkdir27(tempExtractDir, { recursive: true });
     try {
       await extract({
         file: archivePath,
@@ -98075,7 +98155,7 @@ class TarExtractor {
       if (entries.length === 1) {
         const rootEntry = entries[0];
         const rootPath = join103(tempExtractDir, rootEntry);
-        const rootStat = await stat15(rootPath);
+        const rootStat = await stat16(rootPath);
         if (rootStat.isDirectory()) {
           const rootContents = await readdir24(rootPath, { encoding: "utf8" });
           logger.debug(`Root directory '${rootEntry}' contains: ${rootContents.join(", ")}`);
@@ -98089,7 +98169,7 @@ class TarExtractor {
             await moveDirectoryContents(tempExtractDir, destDir, shouldExclude, sizeTracker);
           }
         } else {
-          await mkdir26(destDir, { recursive: true });
+          await mkdir27(destDir, { recursive: true });
           await copyFile5(rootPath, join103(destDir, rootEntry));
         }
       } else {
@@ -98112,33 +98192,33 @@ init_environment();
 init_logger();
 var import_extract_zip = __toESM(require_extract_zip(), 1);
 import { execFile as execFile11 } from "node:child_process";
-import { copyFile as copyFile6, mkdir as mkdir27, readdir as readdir25, rm as rm11, stat as stat16 } from "node:fs/promises";
+import { copyFile as copyFile6, mkdir as mkdir28, readdir as readdir25, rm as rm11, stat as stat17 } from "node:fs/promises";
 import { join as join104 } from "node:path";
 class ZipExtractor {
   async tryNativeUnzip(archivePath, destDir) {
     if (!isMacOS()) {
       return false;
     }
-    return new Promise((resolve33) => {
-      mkdir27(destDir, { recursive: true }).then(() => {
+    return new Promise((resolve34) => {
+      mkdir28(destDir, { recursive: true }).then(() => {
         execFile11("unzip", ["-o", "-q", archivePath, "-d", destDir], (error, _stdout, stderr) => {
           if (error) {
             logger.debug(`Native unzip failed: ${stderr || error.message}`);
-            resolve33(false);
+            resolve34(false);
             return;
           }
           logger.debug("Native unzip succeeded");
-          resolve33(true);
+          resolve34(true);
         });
       }).catch((err) => {
         logger.debug(`Failed to create directory for native unzip: ${err.message}`);
-        resolve33(false);
+        resolve34(false);
       });
     });
   }
   async extract(archivePath, destDir, shouldExclude, sizeTracker) {
     const tempExtractDir = `${destDir}-temp`;
-    await mkdir27(tempExtractDir, { recursive: true });
+    await mkdir28(tempExtractDir, { recursive: true });
     try {
       const nativeSuccess = await this.tryNativeUnzip(archivePath, tempExtractDir);
       if (!nativeSuccess) {
@@ -98162,7 +98242,7 @@ class ZipExtractor {
       if (entries.length === 1) {
         const rootEntry = entries[0];
         const rootPath = join104(tempExtractDir, rootEntry);
-        const rootStat = await stat16(rootPath);
+        const rootStat = await stat17(rootPath);
         if (rootStat.isDirectory()) {
           const rootContents = await readdir25(rootPath, { encoding: "utf8" });
           logger.debug(`Root directory '${rootEntry}' contains: ${rootContents.join(", ")}`);
@@ -98176,7 +98256,7 @@ class ZipExtractor {
             await moveDirectoryContents(tempExtractDir, destDir, shouldExclude, sizeTracker);
           }
         } else {
-          await mkdir27(destDir, { recursive: true });
+          await mkdir28(destDir, { recursive: true });
           await copyFile6(rootPath, join104(destDir, rootEntry));
         }
       } else {
@@ -98237,7 +98317,7 @@ class DownloadManager {
     return this.fileDownloader.downloadFile(params);
   }
   async extractArchive(archivePath, destDir, archiveType) {
-    const archiveStats = await stat17(archivePath);
+    const archiveStats = await stat18(archivePath);
     if (archiveStats.size > MAX_ARCHIVE_SIZE) {
       throw new ExtractionError(`Archive exceeds ${formatBytes(MAX_ARCHIVE_SIZE)} limit: ${formatBytes(archiveStats.size)}`);
     }
@@ -98251,7 +98331,7 @@ class DownloadManager {
     try {
       this.sizeTracker.reset();
       const detectedType = archiveType || detectArchiveType(archivePath);
-      await mkdir28(destDir, { recursive: true });
+      await mkdir29(destDir, { recursive: true });
       if (detectedType === "tar.gz") {
         await this.tarExtractor.extract(archivePath, destDir, this.shouldExclude, this.sizeTracker);
       } else if (detectedType === "zip") {
@@ -98278,7 +98358,7 @@ class DownloadManager {
     const counter = DownloadManager.tempDirCounter++;
     const primaryTempDir = join105(tmpdir5(), `claudekit-${timestamp}-${counter}`);
     try {
-      await mkdir28(primaryTempDir, { recursive: true });
+      await mkdir29(primaryTempDir, { recursive: true });
       logger.debug(`Created temp directory: ${primaryTempDir}`);
       registerTempDir(primaryTempDir);
       return primaryTempDir;
@@ -98295,7 +98375,7 @@ Solutions:
       }
       const fallbackTempDir = join105(homeDir, ".claudekit", "tmp", `claudekit-${timestamp}-${counter}`);
       try {
-        await mkdir28(fallbackTempDir, { recursive: true });
+        await mkdir29(fallbackTempDir, { recursive: true });
         logger.debug(`Created temp directory (fallback): ${fallbackTempDir}`);
         logger.warning(`Using fallback temp directory: ${fallbackTempDir}
   (OS temp directory was not accessible)`);
@@ -98341,8 +98421,8 @@ function buildReleaseAllowlist(layout) {
 async function ensureLayoutSourceDir(projectRoot, layout, strict) {
   const sourceDir = path14.join(projectRoot, layout.sourceDir);
   try {
-    const stat18 = await fs19.promises.stat(sourceDir);
-    if (!stat18.isDirectory()) {
+    const stat19 = await fs19.promises.stat(sourceDir);
+    if (!stat19.isDirectory()) {
       throw new Error(`Expected source directory "${layout.sourceDir}" exists but is not a directory.`);
     }
     return sourceDir;
@@ -98535,8 +98615,8 @@ async function useLocalKitPath(kitPath) {
   output.section("Using local kit");
   const absolutePath = path14.resolve(kitPath);
   try {
-    const stat18 = await fs19.promises.stat(absolutePath);
-    if (!stat18.isDirectory()) {
+    const stat19 = await fs19.promises.stat(absolutePath);
+    if (!stat19.isDirectory()) {
       throw new Error(`--kit-path must point to a directory, not a file.
 
 Provided path: ${absolutePath}
@@ -98569,8 +98649,8 @@ Please verify the path exists and is accessible.`);
   }
   const claudeDir3 = path14.join(kitRoot, layout.runtimeDir);
   try {
-    const stat18 = await fs19.promises.stat(claudeDir3);
-    if (!stat18.isDirectory()) {
+    const stat19 = await fs19.promises.stat(claudeDir3);
+    if (!stat19.isDirectory()) {
       logger.warning(`Warning: ${claudeDir3} exists but is not a directory.
 This may not be a valid ClaudeKit installation.`);
     }
@@ -98604,15 +98684,15 @@ async function extractLocalArchive(archivePath, exclude) {
   const absolutePath = path14.resolve(archivePath);
   validateArchiveFormat(absolutePath);
   try {
-    const stat18 = await fs19.promises.stat(absolutePath);
-    if (!stat18.isFile()) {
+    const stat19 = await fs19.promises.stat(absolutePath);
+    if (!stat19.isFile()) {
       throw new Error(`--archive must point to a file, not a directory.
 
 Provided path: ${absolutePath}
 
 If you meant to use an extracted kit directory, use --kit-path instead.`);
     }
-    if (stat18.size === 0) {
+    if (stat19.size === 0) {
       throw new Error(`Archive file is empty: ${absolutePath}
 
 The file exists but contains no data. Please verify the archive is not corrupted.`);
@@ -98757,7 +98837,7 @@ import { join as join122 } from "node:path";
 
 // src/domains/installation/deletion-handler.ts
 import { existsSync as existsSync61, lstatSync as lstatSync3, readdirSync as readdirSync7, rmSync as rmSync2, rmdirSync, unlinkSync as unlinkSync4 } from "node:fs";
-import { dirname as dirname35, join as join108, relative as relative17, resolve as resolve34, sep as sep10 } from "node:path";
+import { dirname as dirname35, join as join108, relative as relative17, resolve as resolve35, sep as sep10 } from "node:path";
 
 // src/services/file-operations/manifest/manifest-reader.ts
 init_metadata_migration();
@@ -98982,8 +99062,8 @@ function expandGlobPatterns(patterns, claudeDir3) {
 }
 var MAX_CLEANUP_ITERATIONS = 50;
 function cleanupEmptyDirectories(filePath, claudeDir3) {
-  const normalizedClaudeDir = resolve34(claudeDir3);
-  let currentDir = resolve34(dirname35(filePath));
+  const normalizedClaudeDir = resolve35(claudeDir3);
+  let currentDir = resolve35(dirname35(filePath));
   let iterations = 0;
   while (currentDir !== normalizedClaudeDir && currentDir.startsWith(normalizedClaudeDir) && iterations < MAX_CLEANUP_ITERATIONS) {
     iterations++;
@@ -98992,7 +99072,7 @@ function cleanupEmptyDirectories(filePath, claudeDir3) {
       if (entries.length === 0) {
         rmdirSync(currentDir);
         logger.debug(`Removed empty directory: ${currentDir}`);
-        currentDir = resolve34(dirname35(currentDir));
+        currentDir = resolve35(dirname35(currentDir));
       } else {
         break;
       }
@@ -99002,14 +99082,14 @@ function cleanupEmptyDirectories(filePath, claudeDir3) {
   }
 }
 function deletePath(fullPath, claudeDir3) {
-  const normalizedPath = resolve34(fullPath);
-  const normalizedClaudeDir = resolve34(claudeDir3);
+  const normalizedPath = resolve35(fullPath);
+  const normalizedClaudeDir = resolve35(claudeDir3);
   if (!normalizedPath.startsWith(`${normalizedClaudeDir}${sep10}`) && normalizedPath !== normalizedClaudeDir) {
     throw new Error(`Path traversal detected: ${fullPath}`);
   }
   try {
-    const stat18 = lstatSync3(fullPath);
-    if (stat18.isDirectory()) {
+    const stat19 = lstatSync3(fullPath);
+    if (stat19.isDirectory()) {
       rmSync2(fullPath, { recursive: true, force: true });
     } else {
       unlinkSync4(fullPath);
@@ -99076,8 +99156,8 @@ async function handleDeletions(sourceMetadata, claudeDir3, kitType) {
   const result = { deletedPaths: [], preservedPaths: [], errors: [] };
   for (const path15 of deletions) {
     const fullPath = join108(claudeDir3, path15);
-    const normalizedPath = resolve34(fullPath);
-    const normalizedClaudeDir = resolve34(claudeDir3);
+    const normalizedPath = resolve35(fullPath);
+    const normalizedClaudeDir = resolve35(claudeDir3);
     if (!normalizedPath.startsWith(`${normalizedClaudeDir}${sep10}`)) {
       logger.warning(`Skipping invalid path: ${path15}`);
       result.errors.push(path15);
@@ -99118,7 +99198,7 @@ var import_ignore3 = __toESM(require_ignore(), 1);
 import { dirname as dirname38, join as join112, relative as relative19 } from "node:path";
 
 // src/domains/installation/selective-merger.ts
-import { stat as stat18 } from "node:fs/promises";
+import { stat as stat19 } from "node:fs/promises";
 init_logger();
 var import_semver3 = __toESM(require_semver2(), 1);
 
@@ -99143,7 +99223,7 @@ class SelectiveMerger {
   async shouldCopyFile(destPath, relativePath) {
     let destStat;
     try {
-      destStat = await stat18(destPath);
+      destStat = await stat19(destPath);
     } catch {
       if (this.claudeDir && this.installingKit) {
         const installed = await findFileInInstalledKits(this.claudeDir, relativePath, this.installingKit);
@@ -100791,7 +100871,7 @@ import { dirname as dirname37, join as join111 } from "node:path";
 // src/domains/config/installed-settings-tracker.ts
 init_shared();
 import { existsSync as existsSync62 } from "node:fs";
-import { mkdir as mkdir29, readFile as readFile47, writeFile as writeFile24 } from "node:fs/promises";
+import { mkdir as mkdir30, readFile as readFile47, writeFile as writeFile24 } from "node:fs/promises";
 import { dirname as dirname36, join as join110 } from "node:path";
 var CK_JSON_FILE = ".ck.json";
 
@@ -100843,7 +100923,7 @@ class InstalledSettingsTracker {
         data.kits[this.kitName] = {};
       }
       data.kits[this.kitName].installedSettings = settings;
-      await mkdir29(dirname36(ckJsonPath), { recursive: true });
+      await mkdir30(dirname36(ckJsonPath), { recursive: true });
       await writeFile24(ckJsonPath, JSON.stringify(data, null, 2), "utf-8");
       logger.debug(`Saved installed settings to ${ckJsonPath}`);
     } catch (error) {
@@ -101647,7 +101727,7 @@ class FileMerger {
 }
 
 // src/domains/migration/legacy-migration.ts
-import { readdir as readdir27, stat as stat19 } from "node:fs/promises";
+import { readdir as readdir27, stat as stat20 } from "node:fs/promises";
 import { join as join116, relative as relative20 } from "node:path";
 // src/services/file-operations/manifest/manifest-tracker.ts
 import { join as join115 } from "node:path";
@@ -102078,7 +102158,7 @@ class LegacyMigration {
       const fullPath = join116(dir, entry);
       let stats;
       try {
-        stats = await stat19(fullPath);
+        stats = await stat20(fullPath);
       } catch (err) {
         const error = err;
         if (error.code === "ENOENT") {
@@ -102312,7 +102392,7 @@ function buildConflictSummary(fileConflicts, hookConflicts, mcpConflicts) {
 init_logger();
 init_skip_directories();
 var import_fs_extra22 = __toESM(require_lib3(), 1);
-import { join as join117, relative as relative21, resolve as resolve35 } from "node:path";
+import { join as join117, relative as relative21, resolve as resolve36 } from "node:path";
 
 class FileScanner2 {
   static async getFiles(dirPath, relativeTo) {
@@ -102392,8 +102472,8 @@ class FileScanner2 {
     return customFiles;
   }
   static isSafePath(basePath, targetPath) {
-    const resolvedBase = resolve35(basePath);
-    const resolvedTarget = resolve35(targetPath);
+    const resolvedBase = resolve36(basePath);
+    const resolvedTarget = resolve36(targetPath);
     return resolvedTarget.startsWith(resolvedBase);
   }
   static toPosixPath(path16) {
@@ -102404,7 +102484,7 @@ class FileScanner2 {
 // src/services/transformers/commands-prefix/prefix-applier.ts
 init_logger();
 var import_fs_extra23 = __toESM(require_lib3(), 1);
-import { lstat as lstat8, mkdir as mkdir30, readdir as readdir30, stat as stat20 } from "node:fs/promises";
+import { lstat as lstat8, mkdir as mkdir31, readdir as readdir30, stat as stat21 } from "node:fs/promises";
 import { join as join119 } from "node:path";
 
 // src/services/transformers/commands-prefix/content-transformer.ts
@@ -102562,7 +102642,7 @@ async function applyPrefix(extractDir) {
     }
     if (entries.length === 1 && entries[0] === "ck") {
       const ckDir2 = join119(commandsDir, "ck");
-      const ckStat = await stat20(ckDir2);
+      const ckStat = await stat21(ckDir2);
       if (ckStat.isDirectory()) {
         logger.verbose("Commands already have /ck: prefix, skipping");
         return;
@@ -102570,9 +102650,9 @@ async function applyPrefix(extractDir) {
     }
     await import_fs_extra23.copy(commandsDir, backupDir);
     logger.verbose("Created backup of commands directory");
-    await mkdir30(tempDir, { recursive: true });
+    await mkdir31(tempDir, { recursive: true });
     const ckDir = join119(tempDir, "ck");
-    await mkdir30(ckDir, { recursive: true });
+    await mkdir31(ckDir, { recursive: true });
     let processedCount = 0;
     for (const entry of entries) {
       const sourcePath = join119(commandsDir, entry);
@@ -103433,7 +103513,7 @@ import { join as join129 } from "node:path";
 
 // src/domains/skills/migrator/migration-executor.ts
 init_logger();
-import { copyFile as copyFile7, mkdir as mkdir31, readdir as readdir35, rm as rm12 } from "node:fs/promises";
+import { copyFile as copyFile7, mkdir as mkdir32, readdir as readdir35, rm as rm12 } from "node:fs/promises";
 import { join as join125 } from "node:path";
 var import_fs_extra30 = __toESM(require_lib3(), 1);
 
@@ -103596,7 +103676,7 @@ Detected changes:`;
 
 // src/domains/skills/migrator/migration-executor.ts
 async function copySkillDirectory(sourceDir, destDir) {
-  await mkdir31(destDir, { recursive: true });
+  await mkdir32(destDir, { recursive: true });
   const entries = await readdir35(sourceDir, { withFileTypes: true });
   for (const entry of entries) {
     const sourcePath = join125(sourceDir, entry.name);
@@ -103616,7 +103696,7 @@ async function executeInternal(mappings, customizations, currentSkillsDir, inter
   const preserved = [];
   const errors2 = [];
   const tempDir = join125(currentSkillsDir, "..", ".skills-migration-temp");
-  await mkdir31(tempDir, { recursive: true });
+  await mkdir32(tempDir, { recursive: true });
   try {
     for (const mapping of mappings) {
       try {
@@ -103638,7 +103718,7 @@ async function executeInternal(mappings, customizations, currentSkillsDir, inter
         const category = mapping.category;
         const targetPath = category ? join125(tempDir, category, skillName) : join125(tempDir, skillName);
         if (category) {
-          await mkdir31(join125(tempDir, category), { recursive: true });
+          await mkdir32(join125(tempDir, category), { recursive: true });
         }
         await copySkillDirectory(currentSkillPath, targetPath);
         migrated.push(skillName);
@@ -103657,7 +103737,7 @@ async function executeInternal(mappings, customizations, currentSkillsDir, inter
       }
     }
     await rm12(currentSkillsDir, { recursive: true, force: true });
-    await mkdir31(currentSkillsDir, { recursive: true });
+    await mkdir32(currentSkillsDir, { recursive: true });
     await copySkillDirectory(tempDir, currentSkillsDir);
     await rm12(tempDir, { recursive: true, force: true });
     return { migrated, preserved, errors: errors2 };
@@ -103704,8 +103784,8 @@ function validateMigrationPath(path16, paramName) {
 init_logger();
 init_types3();
 var import_fs_extra31 = __toESM(require_lib3(), 1);
-import { copyFile as copyFile8, mkdir as mkdir32, readdir as readdir36, rm as rm13, stat as stat21 } from "node:fs/promises";
-import { basename as basename23, join as join126, normalize as normalize9 } from "node:path";
+import { copyFile as copyFile8, mkdir as mkdir33, readdir as readdir36, rm as rm13, stat as stat22 } from "node:fs/promises";
+import { basename as basename24, join as join126, normalize as normalize9 } from "node:path";
 function validatePath2(path16, paramName) {
   if (!path16 || typeof path16 !== "string") {
     throw new SkillsMigrationError(`${paramName} must be a non-empty string`);
@@ -103734,7 +103814,7 @@ class SkillsBackupManager {
     const backupDir = parentDir ? join126(parentDir, backupDirName) : join126(skillsDir2, "..", backupDirName);
     logger.info(`Creating backup at: ${backupDir}`);
     try {
-      await mkdir32(backupDir, { recursive: true });
+      await mkdir33(backupDir, { recursive: true });
       await SkillsBackupManager.copyDirectory(skillsDir2, backupDir);
       logger.success("Backup created successfully");
       return backupDir;
@@ -103756,7 +103836,7 @@ class SkillsBackupManager {
       if (await import_fs_extra31.pathExists(targetDir)) {
         await rm13(targetDir, { recursive: true, force: true });
       }
-      await mkdir32(targetDir, { recursive: true });
+      await mkdir33(targetDir, { recursive: true });
       await SkillsBackupManager.copyDirectory(backupDir, targetDir);
       logger.success("Backup restored successfully");
     } catch (error) {
@@ -103816,7 +103896,7 @@ class SkillsBackupManager {
         continue;
       }
       if (entry.isDirectory()) {
-        await mkdir32(destPath, { recursive: true });
+        await mkdir33(destPath, { recursive: true });
         await SkillsBackupManager.copyDirectory(sourcePath, destPath);
       } else if (entry.isFile()) {
         await copyFile8(sourcePath, destPath);
@@ -103834,14 +103914,14 @@ class SkillsBackupManager {
       if (entry.isDirectory()) {
         size += await SkillsBackupManager.getDirectorySize(fullPath);
       } else if (entry.isFile()) {
-        const stats = await stat21(fullPath);
+        const stats = await stat22(fullPath);
         size += stats.size;
       }
     }
     return size;
   }
   static extractBackupTimestamp(backupPath) {
-    const dirName = basename23(backupPath);
+    const dirName = basename24(backupPath);
     if (!dirName.startsWith(SkillsBackupManager.BACKUP_PREFIX)) {
       return null;
     }
@@ -103882,12 +103962,12 @@ async function getAllFiles(dirPath) {
   return files;
 }
 async function hashFile(filePath) {
-  return new Promise((resolve36, reject) => {
+  return new Promise((resolve37, reject) => {
     const hash = createHash8("sha256");
     const stream = createReadStream3(filePath);
     stream.on("data", (chunk) => hash.update(chunk));
     stream.on("end", () => {
-      resolve36(hash.digest("hex"));
+      resolve37(hash.digest("hex"));
     });
     stream.on("error", (error) => {
       stream.destroy();
@@ -104230,7 +104310,7 @@ async function handleMigration(ctx) {
   return ctx;
 }
 // src/commands/init/phases/opencode-handler.ts
-import { cp as cp3, readdir as readdir40, rm as rm14 } from "node:fs/promises";
+import { cp as cp4, readdir as readdir40, rm as rm14 } from "node:fs/promises";
 import { join as join132 } from "node:path";
 
 // src/services/transformers/opencode-path-transformer.ts
@@ -104363,7 +104443,7 @@ async function handleOpenCode(ctx) {
           continue;
         }
       }
-      await cp3(sourcePath, targetPath, { recursive: true });
+      await cp4(sourcePath, targetPath, { recursive: true });
       logger.verbose(`Copied: ${entry.name}`);
     }
     await rm14(openCodeSource, { recursive: true, force: true });
@@ -104535,8 +104615,8 @@ async function handlePostInstall(ctx) {
 // src/commands/init/phases/selection-handler.ts
 init_config_manager();
 init_github_client();
-import { mkdir as mkdir33 } from "node:fs/promises";
-import { join as join135, resolve as resolve37 } from "node:path";
+import { mkdir as mkdir34 } from "node:fs/promises";
+import { join as join135, resolve as resolve38 } from "node:path";
 
 // src/domains/github/kit-access-checker.ts
 init_logger();
@@ -104667,7 +104747,7 @@ async function runPreflightChecks() {
 // src/domains/installation/fresh-installer.ts
 init_metadata_migration();
 import { existsSync as existsSync63, readdirSync as readdirSync8, rmSync as rmSync3, rmdirSync as rmdirSync2, unlinkSync as unlinkSync5 } from "node:fs";
-import { basename as basename24, dirname as dirname39, join as join134, resolve as resolve36 } from "node:path";
+import { basename as basename25, dirname as dirname39, join as join134, resolve as resolve37 } from "node:path";
 init_logger();
 init_safe_spinner();
 var import_fs_extra37 = __toESM(require_lib3(), 1);
@@ -104715,15 +104795,15 @@ async function analyzeFreshInstallation(claudeDir3) {
   };
 }
 function cleanupEmptyDirectories2(filePath, claudeDir3) {
-  const normalizedClaudeDir = resolve36(claudeDir3);
-  let currentDir = resolve36(dirname39(filePath));
+  const normalizedClaudeDir = resolve37(claudeDir3);
+  let currentDir = resolve37(dirname39(filePath));
   while (currentDir !== normalizedClaudeDir && currentDir.startsWith(normalizedClaudeDir)) {
     try {
       const entries = readdirSync8(currentDir);
       if (entries.length === 0) {
         rmdirSync2(currentDir);
         logger.debug(`Removed empty directory: ${currentDir}`);
-        currentDir = resolve36(dirname39(currentDir));
+        currentDir = resolve37(dirname39(currentDir));
       } else {
         break;
       }
@@ -104881,7 +104961,7 @@ async function handleFreshInstallation(claudeDir3, prompts) {
           mutatePaths: backupTargets.mutatePaths,
           scope: "claude"
         });
-        await cleanupOldDestructiveOperationBackups(undefined, basename24(backup.backupDir));
+        await cleanupOldDestructiveOperationBackups(undefined, basename25(backup.backupDir));
         backupSpinner.succeed(`Recovery backup saved to ${backup.backupDir}`);
       } catch (error) {
         backupSpinner.fail("Failed to create recovery backup");
@@ -105090,7 +105170,7 @@ async function handleSelection(ctx) {
       }
     }
   }
-  const resolvedDir = resolve37(targetDir);
+  const resolvedDir = resolve38(targetDir);
   logger.info(`Target directory: ${resolvedDir}`);
   if (!ctx.options.global && PathResolver.isLocalSameAsGlobal(resolvedDir)) {
     logger.warning("You're at HOME directory. Installing here modifies your GLOBAL ClaudeKit.");
@@ -105114,7 +105194,7 @@ async function handleSelection(ctx) {
   }
   if (!await import_fs_extra38.pathExists(resolvedDir)) {
     if (ctx.options.global) {
-      await mkdir33(resolvedDir, { recursive: true });
+      await mkdir34(resolvedDir, { recursive: true });
       logger.info(`Created global directory: ${resolvedDir}`);
     } else {
       logger.error(`Directory does not exist: ${resolvedDir}`);
@@ -105268,8 +105348,8 @@ async function handleSelection(ctx) {
   };
 }
 // src/commands/init/phases/sync-handler.ts
-import { copyFile as copyFile9, mkdir as mkdir34, open as open5, readFile as readFile57, rename as rename11, stat as stat22, unlink as unlink12, writeFile as writeFile32 } from "node:fs/promises";
-import { dirname as dirname40, join as join136, resolve as resolve38 } from "node:path";
+import { copyFile as copyFile9, mkdir as mkdir35, open as open5, readFile as readFile57, rename as rename11, stat as stat23, unlink as unlink12, writeFile as writeFile32 } from "node:fs/promises";
+import { dirname as dirname40, join as join136, resolve as resolve39 } from "node:path";
 init_logger();
 init_path_resolver();
 var import_fs_extra39 = __toESM(require_lib3(), 1);
@@ -105278,7 +105358,7 @@ async function handleSync(ctx) {
   if (!ctx.options.sync) {
     return ctx;
   }
-  const resolvedDir = ctx.options.global ? PathResolver.getGlobalKitDir() : resolve38(ctx.options.dir || ".");
+  const resolvedDir = ctx.options.global ? PathResolver.getGlobalKitDir() : resolve39(ctx.options.dir || ".");
   const claudeDir3 = ctx.options.global ? resolvedDir : join136(resolvedDir, ".claude");
   if (!await import_fs_extra39.pathExists(claudeDir3)) {
     logger.error("Cannot sync: no .claude directory found");
@@ -105388,7 +105468,7 @@ async function acquireSyncLock(global3) {
   const lockPath = join136(cacheDir, ".sync-lock");
   const startTime = Date.now();
   const lockTimeout = getLockTimeout();
-  await mkdir34(dirname40(lockPath), { recursive: true });
+  await mkdir35(dirname40(lockPath), { recursive: true });
   while (Date.now() - startTime < lockTimeout) {
     try {
       const handle = await open5(lockPath, "wx");
@@ -105399,7 +105479,7 @@ async function acquireSyncLock(global3) {
     } catch (err) {
       if (err.code === "EEXIST") {
         try {
-          const lockStat = await stat22(lockPath);
+          const lockStat = await stat23(lockPath);
           const lockAge = Math.abs(Date.now() - lockStat.mtimeMs);
           if (lockAge > STALE_LOCK_THRESHOLD_MS) {
             logger.warning(`Removing stale sync lock (age: ${Math.round(lockAge / 1000)}s)`);
@@ -105412,7 +105492,7 @@ async function acquireSyncLock(global3) {
           }
           logger.debug(`Lock stat failed: ${statError}`);
         }
-        await new Promise((resolve39) => setTimeout(resolve39, 100));
+        await new Promise((resolve40) => setTimeout(resolve40, 100));
         continue;
       }
       throw err;
@@ -105468,7 +105548,7 @@ async function executeSyncMerge(ctx) {
           const targetPath = await validateSyncPath(ctx.claudeDir, file.path);
           const targetDir = join136(targetPath, "..");
           try {
-            await mkdir34(targetDir, { recursive: true });
+            await mkdir35(targetDir, { recursive: true });
           } catch (mkdirError) {
             const errCode = mkdirError.code;
             if (errCode === "ENOSPC") {
@@ -105631,14 +105711,14 @@ function displaySyncPlan(plan) {
   console.log(import_picocolors26.default.dim("─".repeat(40)));
 }
 async function createBackup(claudeDir3, files, backupDir) {
-  await mkdir34(backupDir, { recursive: true });
+  await mkdir35(backupDir, { recursive: true });
   for (const file of files) {
     try {
       const sourcePath = await validateSyncPath(claudeDir3, file.path);
       if (await import_fs_extra39.pathExists(sourcePath)) {
         const targetPath = await validateSyncPath(backupDir, file.path);
         const targetDir = join136(targetPath, "..");
-        await mkdir34(targetDir, { recursive: true });
+        await mkdir35(targetDir, { recursive: true });
         await copyFile9(sourcePath, targetPath);
       }
     } catch (error) {
@@ -106055,8 +106135,8 @@ function transformContent(content, options2 = {}) {
 }
 function shouldTransformFile3(filename) {
   const ext2 = extname6(filename).toLowerCase();
-  const basename25 = filename.split("/").pop() || filename;
-  return TRANSFORMABLE_EXTENSIONS3.has(ext2) || ALWAYS_TRANSFORM_FILES.has(basename25);
+  const basename26 = filename.split("/").pop() || filename;
+  return TRANSFORMABLE_EXTENSIONS3.has(ext2) || ALWAYS_TRANSFORM_FILES.has(basename26);
 }
 async function transformPathsForGlobalInstall(directory, options2 = {}) {
   let filesTransformed = 0;
@@ -106337,13 +106417,13 @@ var import_picocolors30 = __toESM(require_picocolors(), 1);
 import { existsSync as existsSync64 } from "node:fs";
 import { readFile as readFile61, rm as rm16, unlink as unlink13 } from "node:fs/promises";
 import { homedir as homedir50 } from "node:os";
-import { basename as basename26, join as join142, resolve as resolve40 } from "node:path";
+import { basename as basename27, join as join142, resolve as resolve41 } from "node:path";
 init_logger();
 
 // src/ui/ck-cli-design/tokens.ts
 var import_picocolors27 = __toESM(require_picocolors(), 1);
 import { homedir as homedir48, platform as platform16 } from "node:os";
-import { resolve as resolve39, win32 as win323 } from "node:path";
+import { resolve as resolve40, win32 as win323 } from "node:path";
 var PANEL_MIN_WIDTH = 60;
 var PANEL_MAX_WIDTH = 72;
 var DEFAULT_WIDTH = PANEL_MAX_WIDTH;
@@ -106513,7 +106593,7 @@ function formatCdHint(value, currentPlatform = platform16()) {
     const absolutePath2 = win323.resolve(value);
     return `cd /d "${absolutePath2}"`;
   }
-  const absolutePath = resolve39(value);
+  const absolutePath = resolve40(value);
   const displayPath = formatDisplayPath(absolutePath);
   if (displayPath.includes(" ")) {
     return `cd "${displayPath}"`;
@@ -106809,7 +106889,7 @@ init_model_taxonomy();
 init_logger();
 init_dist2();
 init_model_taxonomy();
-import { mkdir as mkdir35, readFile as readFile60, writeFile as writeFile35 } from "node:fs/promises";
+import { mkdir as mkdir36, readFile as readFile60, writeFile as writeFile35 } from "node:fs/promises";
 import { homedir as homedir49 } from "node:os";
 import { dirname as dirname41, join as join141 } from "node:path";
 function getOpenCodeConfigPath(options2) {
@@ -106913,7 +106993,7 @@ async function ensureOpenCodeModel(options2) {
     }
   }
   const next = { ...existing ?? {}, model: chosenModel };
-  await mkdir35(dirname41(configPath), { recursive: true });
+  await mkdir36(dirname41(configPath), { recursive: true });
   await writeFile35(configPath, `${JSON.stringify(next, null, 2)}
 `, "utf-8");
   return {
@@ -106926,7 +107006,7 @@ async function ensureOpenCodeModel(options2) {
 
 // src/commands/portable/plan-display.ts
 var import_picocolors28 = __toESM(require_picocolors(), 1);
-import { basename as basename25, dirname as dirname42, extname as extname7 } from "node:path";
+import { basename as basename26, dirname as dirname42, extname as extname7 } from "node:path";
 var DEFAULT_MAX_PLAN_GROUP_ITEMS = 20;
 var TYPE_ORDER = [
   "agent",
@@ -107162,7 +107242,7 @@ function normalizeWhereDestination(path16, portableType) {
     return dirname42(path16);
   }
   if (portableType === "rules") {
-    const fileName = basename25(path16).toLowerCase();
+    const fileName = basename26(path16).toLowerCase();
     if (fileName === "agents.md" || fileName === "gemini.md" || fileName === ".goosehints" || fileName === "custom_modes.yaml" || fileName === "custom_modes.yml") {
       return path16;
     }
@@ -107636,7 +107716,7 @@ function shouldExecuteAction2(action) {
 }
 async function executeDeleteAction(action, options2) {
   const preservePaths = options2?.preservePaths ?? new Set;
-  const shouldPreserveTarget = action.targetPath.length > 0 && preservePaths.has(resolve40(action.targetPath));
+  const shouldPreserveTarget = action.targetPath.length > 0 && preservePaths.has(resolve41(action.targetPath));
   try {
     if (!shouldPreserveTarget && action.targetPath && existsSync64(action.targetPath)) {
       await rm16(action.targetPath, { recursive: true, force: true });
@@ -107669,7 +107749,7 @@ async function executeDeleteAction(action, options2) {
 async function processMetadataDeletions(skillSourcePath, installGlobally) {
   if (!skillSourcePath)
     return;
-  const sourceMetadataPath = join142(resolve40(skillSourcePath, ".."), "metadata.json");
+  const sourceMetadataPath = join142(resolve41(skillSourcePath, ".."), "metadata.json");
   if (!existsSync64(sourceMetadataPath))
     return;
   let sourceMetadata;
@@ -108080,15 +108160,15 @@ async function migrateCommand(options2) {
       allResults.push(...taskResults);
       for (const result of taskResults.filter((entry) => entry.success && !entry.skipped)) {
         if (result.path.length > 0) {
-          writtenPaths.add(resolve40(result.path));
+          writtenPaths.add(resolve41(result.path));
         }
         if (task.type === "hooks") {
           const existing = successfulHookFiles.get(task.provider) ?? [];
-          existing.push(basename26(result.path));
+          existing.push(basename27(result.path));
           successfulHookFiles.set(task.provider, existing);
           if (result.path.length > 0) {
             const absExisting = successfulHookAbsPaths.get(task.provider) ?? [];
-            absExisting.push(resolve40(result.path));
+            absExisting.push(resolve41(result.path));
             successfulHookAbsPaths.set(task.provider, absExisting);
           }
         }
@@ -108111,6 +108191,31 @@ async function migrateCommand(options2) {
         postProgressWarnings.push(`Could not update opencode.json model (${err instanceof Error ? err.message : String(err)}). Agents may fail with ProviderModelNotFoundError until a model is set.`);
       }
     }
+    if (hooksSource && successfulHookFiles.size > 0) {
+      for (const hooksProvider of successfulHookFiles.keys()) {
+        const providerCfg = providers[hooksProvider];
+        const targetHooksDir = installGlobally ? providerCfg.hooks?.globalPath : providerCfg.hooks?.projectPath;
+        if (!targetHooksDir)
+          continue;
+        const companionResult = await copyHooksCompanionDirs(hooksSource, targetHooksDir);
+        if (companionResult.errors.length > 0) {
+          for (const e2 of companionResult.errors) {
+            postProgressWarnings.push(`Hook companion copy warning (${e2.name}): ${e2.error}`);
+          }
+        }
+        logger.verbose(`[migrate] Copied hook companions to ${hooksProvider}: dirs=[${companionResult.copiedDirs.join(",")}] dotfiles=[${companionResult.copiedDotfiles.join(",")}]`);
+        const companionParts = [];
+        if (companionResult.copiedDirs.length > 0) {
+          companionParts.push(`${companionResult.copiedDirs.join(", ")}`);
+        }
+        if (companionResult.copiedDotfiles.length > 0) {
+          companionParts.push(companionResult.copiedDotfiles.join(", "));
+        }
+        if (companionParts.length > 0) {
+          f2.info(import_picocolors30.default.dim(`Copied hook companions to ${hooksProvider}: ${companionParts.join(" + ")}`));
+        }
+      }
+    }
     for (const [hooksProvider, files] of successfulHookFiles) {
       if (files.length === 0)
         continue;
@@ -108156,14 +108261,14 @@ async function migrateCommand(options2) {
       });
       if (staleSlugs.length > 0) {
         const staleSlugSet = new Set(staleSlugs.map((s) => `${s}.toml`));
-        const removed = await removeInstallationsByFilter((i) => i.type === "agent" && i.provider === provider && i.global === installGlobally && staleSlugSet.has(basename26(i.path)));
+        const removed = await removeInstallationsByFilter((i) => i.type === "agent" && i.provider === provider && i.global === installGlobally && staleSlugSet.has(basename27(i.path)));
         for (const entry of removed) {
           logger.verbose(`[migrate] Cleaned stale registry entry: ${entry.item} (${provider})`);
         }
       }
     }
     try {
-      const kitRoot = (agentSource ? resolve40(agentSource, "..") : null) ?? (commandSource ? resolve40(commandSource, "..") : null) ?? (skillSource ? resolve40(skillSource, "..") : null) ?? null;
+      const kitRoot = (agentSource ? resolve41(agentSource, "..") : null) ?? (commandSource ? resolve41(commandSource, "..") : null) ?? (skillSource ? resolve41(skillSource, "..") : null) ?? null;
       const manifest = kitRoot ? await loadPortableManifest(kitRoot) : null;
       if (manifest?.cliVersion) {
         await updateAppliedManifestVersion(manifest.cliVersion);
@@ -108216,8 +108321,8 @@ async function rollbackResults(results) {
     try {
       if (result.overwritten)
         continue;
-      const stat23 = await import("node:fs/promises").then((fs20) => fs20.stat(result.path));
-      if (stat23.isDirectory()) {
+      const stat24 = await import("node:fs/promises").then((fs20) => fs20.stat(result.path));
+      if (stat24.isDirectory()) {
         await rm16(result.path, { recursive: true, force: true });
       } else {
         await unlink13(result.path);
@@ -108358,7 +108463,7 @@ var import_picocolors31 = __toESM(require_picocolors(), 1);
 
 // src/commands/new/phases/directory-setup.ts
 init_config_manager();
-import { resolve as resolve41 } from "node:path";
+import { resolve as resolve42 } from "node:path";
 init_logger();
 init_path_resolver();
 init_types3();
@@ -108443,7 +108548,7 @@ async function directorySetup(validOptions, prompts) {
       targetDir = await prompts.getDirectory(targetDir);
     }
   }
-  const resolvedDir = resolve41(targetDir);
+  const resolvedDir = resolve42(targetDir);
   logger.info(`Target directory: ${resolvedDir}`);
   if (PathResolver.isLocalSameAsGlobal(resolvedDir)) {
     logger.warning("You're creating a project at HOME directory.");
@@ -108777,7 +108882,7 @@ Please use only one download method.`);
 // src/commands/plan/plan-command.ts
 init_output_manager();
 import { existsSync as existsSync67, statSync as statSync12 } from "node:fs";
-import { dirname as dirname46, isAbsolute as isAbsolute11, join as join147, parse as parse7, resolve as resolve45 } from "node:path";
+import { dirname as dirname46, isAbsolute as isAbsolute11, join as join147, parse as parse7, resolve as resolve46 } from "node:path";
 
 // src/commands/plan/plan-read-handlers.ts
 init_config();
@@ -108787,7 +108892,7 @@ init_logger();
 init_output_manager();
 var import_picocolors32 = __toESM(require_picocolors(), 1);
 import { existsSync as existsSync66, statSync as statSync11 } from "node:fs";
-import { basename as basename27, dirname as dirname44, join as join146, relative as relative27, resolve as resolve43 } from "node:path";
+import { basename as basename28, dirname as dirname44, join as join146, relative as relative27, resolve as resolve44 } from "node:path";
 
 // src/commands/plan/plan-dependencies.ts
 init_config();
@@ -108845,14 +108950,14 @@ init_config();
 init_plan_parser();
 init_plan_scope();
 init_plans_registry();
-import { isAbsolute as isAbsolute10, resolve as resolve42 } from "node:path";
+import { isAbsolute as isAbsolute10, resolve as resolve43 } 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 = isAbsolute10(target) ? resolve42(target) : resolve42(baseDir, target);
+  const resolvedTarget = isAbsolute10(target) ? resolve43(target) : resolve43(baseDir, target);
   return isWithinDir(resolvedTarget, baseDir) ? resolvedTarget : null;
 }
 
@@ -108885,7 +108990,7 @@ async function handleParse(target, options2) {
     console.log(JSON.stringify({ file: relative27(process.cwd(), planFile), frontmatter, phases }, null, 2));
     return;
   }
-  const title = typeof frontmatter.title === "string" ? frontmatter.title : basename27(dirname44(planFile));
+  const title = typeof frontmatter.title === "string" ? frontmatter.title : basename28(dirname44(planFile));
   console.log();
   console.log(import_picocolors32.default.bold(`  Plan: ${title}`));
   console.log(`  File: ${planFile}`);
@@ -108955,7 +109060,7 @@ async function handleStatus(target, options2) {
     return;
   }
   const effectiveTarget = !resolvedTarget && globalBaseDir ? globalBaseDir : resolvedTarget;
-  const t = effectiveTarget ? resolve43(effectiveTarget) : null;
+  const t = effectiveTarget ? resolve44(effectiveTarget) : null;
   const plansDir = t && existsSync66(t) && statSync11(t).isDirectory() && !existsSync66(join146(t, "plan.md")) ? t : null;
   if (plansDir) {
     const planFiles = scanPlanDir(plansDir);
@@ -108996,7 +109101,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 ?? basename27(dirname44(pf));
+        const title2 = s.title ?? basename28(dirname44(pf));
         console.log(`  ${import_picocolors32.default.bold(title2)}`);
         console.log(`  ${bar}`);
         if (s.inProgress > 0)
@@ -109015,7 +109120,7 @@ async function handleStatus(target, options2) {
         }
         console.log();
       } catch {
-        console.log(`  [X] Failed to read: ${basename27(dirname44(pf))}`);
+        console.log(`  [X] Failed to read: ${basename28(dirname44(pf))}`);
         console.log();
       }
     }
@@ -109042,7 +109147,7 @@ async function handleStatus(target, options2) {
     console.log(JSON.stringify({ ...summary, dependencyStatus: { blockedBy, blocks } }, null, 2));
     return;
   }
-  const title = summary.title ?? basename27(dirname44(planFile));
+  const title = summary.title ?? basename28(dirname44(planFile));
   console.log();
   console.log(import_picocolors32.default.bold(`  ${title}`));
   if (summary.status)
@@ -109140,7 +109245,7 @@ init_plan_parser();
 init_plans_registry();
 init_output_manager();
 var import_picocolors33 = __toESM(require_picocolors(), 1);
-import { basename as basename28, dirname as dirname45, relative as relative28, resolve as resolve44 } from "node:path";
+import { basename as basename29, dirname as dirname45, relative as relative28, resolve as resolve45 } from "node:path";
 async function handleCreate(target, options2) {
   if (!options2.title) {
     output.error("[X] --title is required for create");
@@ -109172,13 +109277,13 @@ async function handleCreate(target, options2) {
     return;
   }
   const globalBaseDir = options2.global ? await getGlobalPlansDirFromCwd() : undefined;
-  const resolvedDir = globalBaseDir ? resolveTargetFromBase(dir, globalBaseDir) : resolve44(dir);
+  const resolvedDir = globalBaseDir ? resolveTargetFromBase(dir, globalBaseDir) : resolve45(dir);
   if (globalBaseDir && !resolvedDir) {
     output.error("[X] Target directory must stay within the configured global plans root");
     process.exitCode = 1;
     return;
   }
-  const safeResolvedDir = resolvedDir ?? resolve44(dir);
+  const safeResolvedDir = resolvedDir ?? resolve45(dir);
   const result = scaffoldPlan({
     title: options2.title,
     phases: phaseNames.map((name2) => ({ name: name2 })),
@@ -109216,7 +109321,7 @@ async function handleCreate(target, options2) {
   console.log(`  Directory: ${safeResolvedDir}`);
   console.log(`  Phases: ${result.phaseFiles.length}`);
   for (const f3 of result.phaseFiles) {
-    console.log(`    [ ] ${basename28(f3)}`);
+    console.log(`    [ ] ${basename29(f3)}`);
   }
   console.log();
 }
@@ -109354,22 +109459,22 @@ async function handleAddPhase(target, options2) {
 // src/commands/plan/plan-command.ts
 function resolveTargetPath(target, baseDir) {
   if (!baseDir) {
-    return resolve45(target);
+    return resolve46(target);
   }
   if (isAbsolute11(target)) {
-    return resolve45(target);
+    return resolve46(target);
   }
-  const cwdCandidate = resolve45(target);
+  const cwdCandidate = resolve46(target);
   if (existsSync67(cwdCandidate)) {
     return cwdCandidate;
   }
-  return resolve45(baseDir, target);
+  return resolve46(baseDir, target);
 }
 function resolvePlanFile(target, baseDir) {
-  const t = target ? resolveTargetPath(target, baseDir) : baseDir ? resolve45(baseDir) : process.cwd();
+  const t = target ? resolveTargetPath(target, baseDir) : baseDir ? resolve46(baseDir) : process.cwd();
   if (existsSync67(t)) {
-    const stat23 = statSync12(t);
-    if (stat23.isFile())
+    const stat24 = statSync12(t);
+    if (stat24.isFile())
       return t;
     const candidate = join147(t, "plan.md");
     if (existsSync67(candidate))
@@ -109430,7 +109535,7 @@ async function planCommand(action, target, options2) {
   let resolvedTarget = target;
   if (resolvedAction && !knownActions.has(resolvedAction)) {
     const looksLikePath = resolvedAction.includes("/") || resolvedAction.includes("\\") || resolvedAction.endsWith(".md") || resolvedAction === "." || resolvedAction === "..";
-    const existsOnDisk = !looksLikePath && existsSync67(resolve45(resolvedAction));
+    const existsOnDisk = !looksLikePath && existsSync67(resolve46(resolvedAction));
     if (looksLikePath || existsOnDisk) {
       resolvedTarget = resolvedAction;
       resolvedAction = undefined;
@@ -109473,11 +109578,11 @@ init_logger();
 init_safe_prompts();
 var import_picocolors34 = __toESM(require_picocolors(), 1);
 import { existsSync as existsSync68 } from "node:fs";
-import { resolve as resolve46 } from "node:path";
+import { resolve as resolve47 } from "node:path";
 async function handleAdd(projectPath, options2) {
   logger.debug(`Adding project: ${projectPath}, options: ${JSON.stringify(options2)}`);
   intro("Add Project");
-  const absolutePath = resolve46(projectPath);
+  const absolutePath = resolve47(projectPath);
   if (!existsSync68(absolutePath)) {
     log.error(`Path does not exist: ${absolutePath}`);
     process.exitCode = 1;
@@ -110582,7 +110687,7 @@ async function detectInstallations() {
 
 // src/commands/uninstall/removal-handler.ts
 import { readdirSync as readdirSync10, rmSync as rmSync5 } from "node:fs";
-import { basename as basename29, join as join150, resolve as resolve47, sep as sep12 } from "node:path";
+import { basename as basename30, join as join150, resolve as resolve48, sep as sep12 } from "node:path";
 init_logger();
 init_safe_prompts();
 init_safe_spinner();
@@ -110763,8 +110868,8 @@ async function restoreUninstallBackup(backup) {
 }
 async function isPathSafeToRemove(filePath, baseDir) {
   try {
-    const resolvedPath = resolve47(filePath);
-    const resolvedBase = resolve47(baseDir);
+    const resolvedPath = resolve48(filePath);
+    const resolvedBase = resolve48(baseDir);
     if (!resolvedPath.startsWith(resolvedBase + sep12) && resolvedPath !== resolvedBase) {
       logger.debug(`Path outside installation directory: ${filePath}`);
       return false;
@@ -110772,7 +110877,7 @@ async function isPathSafeToRemove(filePath, baseDir) {
     const stats = await import_fs_extra44.lstat(filePath);
     if (stats.isSymbolicLink()) {
       const realPath = await import_fs_extra44.realpath(filePath);
-      const resolvedReal = resolve47(realPath);
+      const resolvedReal = resolve48(realPath);
       if (!resolvedReal.startsWith(resolvedBase + sep12) && resolvedReal !== resolvedBase) {
         logger.debug(`Symlink points outside installation directory: ${filePath} -> ${realPath}`);
         return false;
@@ -110818,7 +110923,7 @@ async function removeInstallations(installations, options2) {
             scope: installation.type,
             kit: options2.kit
           });
-          await cleanupOldDestructiveOperationBackups(undefined, basename29(backup.backupDir));
+          await cleanupOldDestructiveOperationBackups(undefined, basename30(backup.backupDir));
           backupSpinner.succeed(`Recovery backup saved to ${backup.backupDir}`);
         } catch (error) {
           backupSpinner.fail("Failed to create recovery backup");
@@ -111235,7 +111340,7 @@ function getDisclaimerMarker() {
   return AI_DISCLAIMER;
 }
 function spawnAndCollect2(command, args) {
-  return new Promise((resolve48, reject) => {
+  return new Promise((resolve49, reject) => {
     const child = spawn7(command, args, { stdio: ["ignore", "pipe", "pipe"] });
     const chunks = [];
     const stderrChunks = [];
@@ -111248,7 +111353,7 @@ function spawnAndCollect2(command, args) {
         reject(new Error(`${command} exited with code ${code2}: ${stderr}`));
         return;
       }
-      resolve48(Buffer.concat(chunks).toString("utf-8"));
+      resolve49(Buffer.concat(chunks).toString("utf-8"));
     });
   });
 }
@@ -111356,7 +111461,7 @@ function formatResponse(content, showBranding) {
   return disclaimer + formatted + branding;
 }
 async function postViaGh(owner, repo, issueNumber, body) {
-  return new Promise((resolve48, reject) => {
+  return new Promise((resolve49, reject) => {
     const args = [
       "issue",
       "comment",
@@ -111378,7 +111483,7 @@ async function postViaGh(owner, repo, issueNumber, body) {
         reject(new Error(`gh exited with code ${code2}: ${stderr}`));
         return;
       }
-      resolve48();
+      resolve49();
     });
   });
 }
@@ -111496,7 +111601,7 @@ After completing the implementation:
     "--allowedTools",
     tools
   ];
-  await new Promise((resolve48, reject) => {
+  await new Promise((resolve49, reject) => {
     const child = spawn9("claude", args, { cwd: cwd2, stdio: ["pipe", "pipe", "pipe"], detached: false });
     child.stdin.write(prompt);
     child.stdin.end();
@@ -111521,7 +111626,7 @@ After completing the implementation:
         reject(new Error(`Claude exited ${code2}: ${stderr.slice(0, 500)}`));
         return;
       }
-      resolve48();
+      resolve49();
     });
   });
 }
@@ -111665,7 +111770,7 @@ function checkRateLimit2(processedThisHour, maxPerHour) {
   return processedThisHour < maxPerHour;
 }
 function spawnAndCollect3(command, args) {
-  return new Promise((resolve48, reject) => {
+  return new Promise((resolve49, reject) => {
     const child = spawn10(command, args, { stdio: ["ignore", "pipe", "pipe"] });
     const chunks = [];
     const stderrChunks = [];
@@ -111678,13 +111783,13 @@ function spawnAndCollect3(command, args) {
         reject(new Error(`${command} exited with code ${code2}: ${stderr}`));
         return;
       }
-      resolve48(Buffer.concat(chunks).toString("utf-8"));
+      resolve49(Buffer.concat(chunks).toString("utf-8"));
     });
   });
 }
 
 // src/commands/watch/phases/issue-processor.ts
-import { mkdir as mkdir36, writeFile as writeFile37 } from "node:fs/promises";
+import { mkdir as mkdir37, writeFile as writeFile37 } from "node:fs/promises";
 import { join as join153 } from "node:path";
 
 // src/commands/watch/phases/approval-detector.ts
@@ -111730,7 +111835,7 @@ async function invokeClaude(options2) {
   return collectClaudeOutput(child, options2.timeoutSec, verbose);
 }
 function collectClaudeOutput(child, timeoutSec, verbose = false) {
-  return new Promise((resolve48, reject) => {
+  return new Promise((resolve49, reject) => {
     const chunks = [];
     const stderrChunks = [];
     child.stdout?.on("data", (chunk) => {
@@ -111760,7 +111865,7 @@ function collectClaudeOutput(child, timeoutSec, verbose = false) {
         reject(new Error(`Claude exited with code ${code2}: ${stderr}`));
         return;
       }
-      resolve48(verbose ? parseStreamJsonOutput(stdout2) : parseClaudeOutput(stdout2));
+      resolve49(verbose ? parseStreamJsonOutput(stdout2) : parseClaudeOutput(stdout2));
     });
   });
 }
@@ -112062,7 +112167,7 @@ async function checkAwaitingApproval(state, setup, options2, watchLog, projectDi
 }
 
 // src/commands/watch/phases/plan-dir-finder.ts
-import { readdir as readdir44, stat as stat23 } from "node:fs/promises";
+import { readdir as readdir44, stat as stat24 } from "node:fs/promises";
 import { join as join152 } from "node:path";
 async function findRecentPlanDir(cwd2, issueNumber, watchLog) {
   const plansRoot = join152(cwd2, "plans");
@@ -112075,13 +112180,13 @@ async function findRecentPlanDir(cwd2, issueNumber, watchLog) {
       if (entry === "watch" || entry === "reports" || entry === "visuals")
         continue;
       const dirPath = join152(plansRoot, entry);
-      const dirStat = await stat23(dirPath);
+      const dirStat = await stat24(dirPath);
       if (!dirStat.isDirectory())
         continue;
       if (dirStat.mtimeMs < tenMinAgo)
         continue;
       try {
-        await stat23(join152(dirPath, "plan.md"));
+        await stat24(join152(dirPath, "plan.md"));
       } catch {
         continue;
       }
@@ -112317,7 +112422,7 @@ async function handlePlanGeneration(issue, state, config, setup, options2, watch
     } else {
       try {
         const planDir = join153(projectDir, "plans", "watch");
-        await mkdir36(planDir, { recursive: true });
+        await mkdir37(planDir, { recursive: true });
         const planFilePath = join153(planDir, `issue-${issue.number}-plan.md`);
         await writeFile37(planFilePath, planResult.planText, "utf-8");
         state.activeIssues[numStr].planPath = planFilePath;
@@ -112464,7 +112569,7 @@ init_ck_config_manager();
 init_file_io();
 init_logger();
 import { existsSync as existsSync70 } from "node:fs";
-import { mkdir as mkdir37, readFile as readFile64 } from "node:fs/promises";
+import { mkdir as mkdir38, readFile as readFile64 } from "node:fs/promises";
 import { dirname as dirname48 } from "node:path";
 var PROCESSED_ISSUES_CAP = 500;
 async function readCkJson(projectDir) {
@@ -112497,7 +112602,7 @@ async function saveWatchState(projectDir, state) {
   const configPath = CkConfigManager.getProjectConfigPath(projectDir);
   const configDir = dirname48(configPath);
   if (!existsSync70(configDir)) {
-    await mkdir37(configDir, { recursive: true });
+    await mkdir38(configDir, { recursive: true });
   }
   const raw2 = await readCkJson(projectDir);
   const watchRaw = raw2.watch ?? {};
@@ -112624,7 +112729,7 @@ async function processImplementationQueue(state, config, setup, options2, watchL
 init_logger();
 import { spawnSync as spawnSync7 } from "node:child_process";
 import { existsSync as existsSync71 } from "node:fs";
-import { readdir as readdir45, stat as stat24 } from "node:fs/promises";
+import { readdir as readdir45, stat as stat25 } from "node:fs/promises";
 import { join as join154 } from "node:path";
 async function scanForRepos(parentDir) {
   const repos = [];
@@ -112633,7 +112738,7 @@ async function scanForRepos(parentDir) {
     if (entry.startsWith("."))
       continue;
     const fullPath = join154(parentDir, entry);
-    const entryStat = await stat24(fullPath);
+    const entryStat = await stat25(fullPath);
     if (!entryStat.isDirectory())
       continue;
     const gitDir = join154(fullPath, ".git");
@@ -112712,7 +112817,7 @@ init_logger();
 init_path_resolver();
 import { createWriteStream as createWriteStream3, statSync as statSync13 } from "node:fs";
 import { existsSync as existsSync73 } from "node:fs";
-import { mkdir as mkdir38, rename as rename13 } from "node:fs/promises";
+import { mkdir as mkdir39, rename as rename13 } from "node:fs/promises";
 import { join as join156 } from "node:path";
 
 class WatchLogger {
@@ -112727,7 +112832,7 @@ class WatchLogger {
   async init() {
     try {
       if (!existsSync73(this.logDir)) {
-        await mkdir38(this.logDir, { recursive: true });
+        await mkdir39(this.logDir, { recursive: true });
       }
       const dateStr = formatDate(new Date);
       this.logPath = join156(this.logDir, `watch-${dateStr}.log`);
@@ -113024,7 +113129,7 @@ function formatQueueInfo(state) {
   return "idle";
 }
 function sleep(ms) {
-  return new Promise((resolve48) => setTimeout(resolve48, ms));
+  return new Promise((resolve49) => setTimeout(resolve49, ms));
 }
 // src/cli/command-registry.ts
 init_logger();
@@ -113185,7 +113290,7 @@ init_types3();
 init_logger();
 init_path_resolver();
 import { existsSync as existsSync85 } from "node:fs";
-import { mkdir as mkdir39, readFile as readFile66, writeFile as writeFile40 } from "node:fs/promises";
+import { mkdir as mkdir40, readFile as readFile66, writeFile as writeFile40 } from "node:fs/promises";
 import { join as join168 } from "node:path";
 
 class VersionCacheManager {
@@ -113220,7 +113325,7 @@ class VersionCacheManager {
     const cacheDir = PathResolver.getCacheDir(false);
     try {
       if (!existsSync85(cacheDir)) {
-        await mkdir39(cacheDir, { recursive: true, mode: 448 });
+        await mkdir40(cacheDir, { recursive: true, mode: 448 });
       }
       await writeFile40(cacheFile, JSON.stringify(cache5, null, 2), "utf-8");
       logger.debug(`Version check cache saved to ${cacheFile}`);