claudekit-cli 3.34.1-dev.4 → 3.35.0-dev.1

package/dist/index.js

@@ -44585,10 +44585,38 @@ var init_pnpm_detector = __esm(() => {
 });
 
 // src/domains/installation/package-managers/detection-core.ts
-import { existsSync as existsSync17 } from "node:fs";
+import { existsSync as existsSync17, realpathSync } from "node:fs";
 import { chmod as chmod2, mkdir as mkdir6, readFile as readFile13, writeFile as writeFile7 } from "node:fs/promises";
 import { platform as platform4 } from "node:os";
-import { join as join23 } from "node:path";
+import { join as join23, sep } from "node:path";
+function detectFromBinaryPath() {
+  try {
+    const scriptPath = process.argv[1];
+    if (!scriptPath)
+      return "unknown";
+    let resolvedPath;
+    try {
+      resolvedPath = realpathSync(scriptPath);
+    } catch {
+      resolvedPath = scriptPath;
+    }
+    const normalized = resolvedPath.split(sep).join("/").toLowerCase();
+    logger.verbose(`Binary path resolved: ${normalized}`);
+    if (normalized.includes("/.bun/install/") || normalized.includes("/bun/install/global/")) {
+      return "bun";
+    }
+    if (normalized.includes("/pnpm/global/") || normalized.includes("/.local/share/pnpm/")) {
+      return "pnpm";
+    }
+    if (normalized.includes("/yarn/global/") || normalized.includes("/.config/yarn/")) {
+      return "yarn";
+    }
+    if (normalized.includes("/npm/node_modules/") || normalized.includes("/usr/local/lib/node_modules/") || normalized.includes("/usr/lib/node_modules/") || normalized.includes("/opt/homebrew/lib/node_modules/") || normalized.includes("/.nvm/versions/node/") || normalized.includes("/n/versions/node/") || normalized.includes("/appdata/roaming/npm/")) {
+      return "npm";
+    }
+  } catch {}
+  return "unknown";
+}
 function detectFromEnv() {
   const userAgent = process.env.npm_config_user_agent;
   if (userAgent) {
@@ -44605,13 +44633,14 @@ function detectFromEnv() {
   const execPath = process.env.npm_execpath;
   if (execPath) {
     logger.debug(`Detected exec path: ${execPath}`);
-    if (execPath.includes("bun"))
+    const normalizedExec = execPath.replace(/\\/g, "/").toLowerCase();
+    if (/\/bun([/.]|$)/.test(normalizedExec) || normalizedExec.startsWith("bun"))
       return "bun";
-    if (execPath.includes("yarn"))
+    if (/\/yarn([/.]|$)/.test(normalizedExec) || normalizedExec.startsWith("yarn"))
       return "yarn";
-    if (execPath.includes("pnpm"))
+    if (/\/pnpm([/.]|$)/.test(normalizedExec) || normalizedExec.startsWith("pnpm"))
       return "pnpm";
-    if (execPath.includes("npm"))
+    if (/\/npm([/.]|$)/.test(normalizedExec) || normalizedExec.startsWith("npm"))
       return "npm";
   }
   return "unknown";
@@ -44629,8 +44658,8 @@ async function readCachedPm() {
       return null;
     }
     const age = Date.now() - data.detectedAt;
-    if (age > CACHE_TTL) {
-      logger.debug("Cache expired, will re-detect");
+    if (age < 0 || age > CACHE_TTL) {
+      logger.debug(age < 0 ? "Cache timestamp in future, ignoring" : "Cache expired, will re-detect");
       return null;
     }
     const validPms = ["npm", "bun", "yarn", "pnpm"];
@@ -44739,6 +44768,18 @@ var init_package_manager_detector = __esm(() => {
   PackageManagerDetector = class PackageManagerDetector {
     static async detect() {
       logger.verbose("PackageManagerDetector: Starting detection");
+      const binaryPm = detectFromBinaryPath();
+      if (binaryPm !== "unknown") {
+        logger.verbose(`PackageManagerDetector: Detected from binary path: ${binaryPm}`);
+        const cachedPm2 = await readCachedPm();
+        if (cachedPm2 && cachedPm2 !== binaryPm) {
+          logger.verbose(`PackageManagerDetector: Cache says ${cachedPm2}, binary says ${binaryPm} — updating cache`);
+          await saveCachedPm(binaryPm, PackageManagerDetector.getVersion);
+        } else if (!cachedPm2) {
+          await saveCachedPm(binaryPm, PackageManagerDetector.getVersion);
+        }
+        return binaryPm;
+      }
       const envPm = detectFromEnv();
       if (envPm !== "unknown") {
         logger.verbose(`PackageManagerDetector: Detected from env: ${envPm}`);
@@ -45236,7 +45277,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "claudekit-cli",
-    version: "3.34.1-dev.4",
+    version: "3.35.0-dev.1",
     description: "CLI tool for bootstrapping and updating ClaudeKit projects",
     type: "module",
     repository: {
@@ -45551,12 +45592,15 @@ Run 'ck update' to install`, "Update Check");
       s.stop("Update failed");
       const errorMessage = error instanceof Error ? error.message : "Unknown error";
       if (errorMessage.includes("EACCES") || errorMessage.includes("EPERM") || errorMessage.includes("permission") || errorMessage.includes("Access is denied")) {
-        throw new CliUpdateError(`Permission denied. Try: sudo ${updateCmd}
+        const permHint = pm === "npm" ? `
 
-Or fix npm permissions: https://docs.npmjs.com/resolving-eacces-permissions-errors-when-installing-packages-globally`);
+Or fix npm permissions: https://docs.npmjs.com/resolving-eacces-permissions-errors-when-installing-packages-globally` : "";
+        const isWindows3 = process.platform === "win32";
+        const elevationHint = isWindows3 ? `Run your terminal as Administrator and retry: ${updateCmd}` : `sudo ${updateCmd}`;
+        throw new CliUpdateError(`Permission denied. Try: ${elevationHint}${permHint}`);
       }
       logger.error(`Update failed: ${errorMessage}`);
-      logger.info("Try running: npm install -g claudekit-cli@latest");
+      logger.info(`Try running: ${updateCmd}`);
       throw new CliUpdateError(`Update failed: ${errorMessage}
 
 Manual update: ${updateCmd}`);
@@ -50573,7 +50617,7 @@ __export(exports_github_api_checker, {
   checkRepositoryAccess: () => checkRepositoryAccess,
   checkRateLimit: () => checkRateLimit
 });
-import { spawnSync } from "node:child_process";
+import { spawnSync as spawnSync2 } from "node:child_process";
 async function checkRateLimit() {
   if (false) {}
   const apiEndpoint = "api.github.com/rate_limit";
@@ -50668,7 +50712,7 @@ async function checkTokenScopes() {
   if (false) {}
   const checkCommand = "gh auth status -h github.com";
   try {
-    const result = spawnSync("gh", ["auth", "status", "-h", "github.com"], {
+    const result = spawnSync2("gh", ["auth", "status", "-h", "github.com"], {
       encoding: "utf8",
       timeout: COMMAND_TIMEOUT_MS
     });
@@ -52236,7 +52280,7 @@ var require_picomatch2 = __commonJS((exports, module) => {
 import { exec as exec7, execFile as execFile7, spawn as spawn3 } from "node:child_process";
 import { promisify as promisify13 } from "node:util";
 function executeInteractiveScript(command, args, options2) {
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve9, reject) => {
     const child = spawn3(command, args, {
       stdio: ["ignore", "inherit", "inherit"],
       cwd: options2?.cwd,
@@ -52257,7 +52301,7 @@ function executeInteractiveScript(command, args, options2) {
       } else if (code !== 0) {
         reject(new Error(`Command exited with code ${code}`));
       } else {
-        resolve8();
+        resolve9();
       }
     });
     child.on("error", (error) => {
@@ -52278,7 +52322,7 @@ var init_process_executor = __esm(() => {
 });
 
 // src/services/package-installer/validators.ts
-import { resolve as resolve8 } from "node:path";
+import { resolve as resolve9 } from "node:path";
 function validatePackageName(packageName) {
   if (!packageName || typeof packageName !== "string") {
     throw new Error("Package name must be a non-empty string");
@@ -52291,8 +52335,8 @@ function validatePackageName(packageName) {
   }
 }
 function validateScriptPath(skillsDir2, scriptPath) {
-  const skillsDirResolved = resolve8(skillsDir2);
-  const scriptPathResolved = resolve8(scriptPath);
+  const skillsDirResolved = resolve9(skillsDir2);
+  const scriptPathResolved = resolve9(scriptPath);
   const skillsDirNormalized = isWindows() ? skillsDirResolved.toLowerCase() : skillsDirResolved;
   const scriptPathNormalized = isWindows() ? scriptPathResolved.toLowerCase() : scriptPathResolved;
   if (!scriptPathNormalized.startsWith(skillsDirNormalized)) {
@@ -52456,7 +52500,7 @@ var init_gemini_installer = __esm(() => {
 });
 
 // src/services/package-installer/opencode-installer.ts
-import { join as join47 } from "node:path";
+import { join as join48 } from "node:path";
 async function isOpenCodeInstalled() {
   try {
     await execAsync7("opencode --version", { timeout: 5000 });
@@ -52478,8 +52522,8 @@ async function installOpenCode() {
   try {
     logger.info(`Installing ${displayName}...`);
     const { unlink: unlink8 } = await import("node:fs/promises");
-    const { tmpdir: tmpdir3 } = await import("node:os");
-    const tempScriptPath = join47(tmpdir3(), "opencode-install.sh");
+    const { tmpdir: tmpdir4 } = await import("node:os");
+    const tempScriptPath = join48(tmpdir4(), "opencode-install.sh");
     try {
       logger.info("Downloading OpenCode installation script...");
       await execFileAsync5("curl", ["-fsSL", "https://opencode.ai/install", "-o", tempScriptPath], {
@@ -52530,8 +52574,8 @@ var init_opencode_installer = __esm(() => {
 var PARTIAL_INSTALL_VERSION = "partial", EXIT_CODE_CRITICAL_FAILURE = 1, EXIT_CODE_PARTIAL_SUCCESS = 2;
 
 // src/services/package-installer/install-error-handler.ts
-import { existsSync as existsSync31, readFileSync as readFileSync7, unlinkSync as unlinkSync2 } from "node:fs";
-import { join as join48 } from "node:path";
+import { existsSync as existsSync32, readFileSync as readFileSync8, unlinkSync as unlinkSync2 } from "node:fs";
+import { join as join49 } from "node:path";
 function parseNameReason(str2) {
   const colonIndex = str2.indexOf(":");
   if (colonIndex === -1) {
@@ -52540,14 +52584,14 @@ function parseNameReason(str2) {
   return [str2.slice(0, colonIndex).trim(), str2.slice(colonIndex + 1).trim()];
 }
 function displayInstallErrors(skillsDir2) {
-  const summaryPath = join48(skillsDir2, ".install-error-summary.json");
-  if (!existsSync31(summaryPath)) {
+  const summaryPath = join49(skillsDir2, ".install-error-summary.json");
+  if (!existsSync32(summaryPath)) {
     logger.error("Skills installation failed. Run with --verbose for details.");
     return;
   }
   let summary;
   try {
-    summary = JSON.parse(readFileSync7(summaryPath, "utf-8"));
+    summary = JSON.parse(readFileSync8(summaryPath, "utf-8"));
   } catch (parseError) {
     logger.error("Failed to parse error summary. File may be corrupted.");
     logger.debug(`Parse error: ${parseError instanceof Error ? parseError.message : String(parseError)}`);
@@ -52631,8 +52675,8 @@ async function checkNeedsSudoPackages() {
   }
 }
 function hasInstallState(skillsDir2) {
-  const stateFilePath = join48(skillsDir2, ".install-state.json");
-  return existsSync31(stateFilePath);
+  const stateFilePath = join49(skillsDir2, ".install-state.json");
+  return existsSync32(stateFilePath);
 }
 var WHICH_COMMAND_TIMEOUT_MS = 5000;
 var init_install_error_handler = __esm(() => {
@@ -52640,7 +52684,7 @@ var init_install_error_handler = __esm(() => {
 });
 
 // src/services/package-installer/skills-installer.ts
-import { join as join49 } from "node:path";
+import { join as join50 } from "node:path";
 async function installSkillsDependencies(skillsDir2, options2 = {}) {
   const { skipConfirm = false, withSudo = false } = options2;
   const displayName = "Skills Dependencies";
@@ -52662,11 +52706,11 @@ async function installSkillsDependencies(skillsDir2, options2 = {}) {
     };
   }
   try {
-    const { existsSync: existsSync32 } = await import("node:fs");
+    const { existsSync: existsSync33 } = await import("node:fs");
     const clack = await Promise.resolve().then(() => (init_dist2(), exports_dist));
     const platform7 = process.platform;
     const scriptName = platform7 === "win32" ? "install.ps1" : "install.sh";
-    const scriptPath = join49(skillsDir2, scriptName);
+    const scriptPath = join50(skillsDir2, scriptName);
     try {
       validateScriptPath(skillsDir2, scriptPath);
     } catch (error) {
@@ -52678,11 +52722,11 @@ async function installSkillsDependencies(skillsDir2, options2 = {}) {
         error: `Path validation failed: ${errorMessage}`
       };
     }
-    if (!existsSync32(scriptPath)) {
+    if (!existsSync33(scriptPath)) {
       logger.warning(`Skills installation script not found: ${scriptPath}`);
       logger.info("");
       logger.info("\uD83D\uDCD6 Manual Installation Instructions:");
-      logger.info(`  See: ${join49(skillsDir2, "INSTALLATION.md")}`);
+      logger.info(`  See: ${join50(skillsDir2, "INSTALLATION.md")}`);
       logger.info("");
       logger.info("Quick start:");
       logger.info("  cd .claude/skills/ai-multimodal/scripts");
@@ -52729,7 +52773,7 @@ async function installSkillsDependencies(skillsDir2, options2 = {}) {
       logger.info(`  ${platform7 === "win32" ? `powershell -File "${scriptPath}"` : `bash ${scriptPath}`}`);
       logger.info("");
       logger.info("Or see complete guide:");
-      logger.info(`  ${join49(skillsDir2, "INSTALLATION.md")}`);
+      logger.info(`  ${join50(skillsDir2, "INSTALLATION.md")}`);
       return {
         success: false,
         package: displayName,
@@ -52850,7 +52894,7 @@ async function installSkillsDependencies(skillsDir2, options2 = {}) {
     logger.info("\uD83D\uDCD6 Manual Installation Instructions:");
     logger.info("");
     logger.info("See complete guide:");
-    logger.info(`  cat ${join49(skillsDir2, "INSTALLATION.md")}`);
+    logger.info(`  cat ${join50(skillsDir2, "INSTALLATION.md")}`);
     logger.info("");
     logger.info("Quick start:");
     logger.info("  cd .claude/skills/ai-multimodal/scripts");
@@ -52894,9 +52938,9 @@ var init_skills_installer2 = __esm(() => {
 });
 
 // src/services/package-installer/gemini-mcp/config-manager.ts
-import { existsSync as existsSync32 } from "node:fs";
+import { existsSync as existsSync33 } from "node:fs";
 import { mkdir as mkdir12, readFile as readFile26, writeFile as writeFile15 } from "node:fs/promises";
-import { dirname as dirname11, join as join50 } from "node:path";
+import { dirname as dirname11, join as join51 } from "node:path";
 async function readJsonFile(filePath) {
   try {
     const content = await readFile26(filePath, "utf-8");
@@ -52908,11 +52952,11 @@ async function readJsonFile(filePath) {
   }
 }
 async function addGeminiToGitignore(projectDir) {
-  const gitignorePath = join50(projectDir, ".gitignore");
+  const gitignorePath = join51(projectDir, ".gitignore");
   const geminiPattern = ".gemini/";
   try {
     let content = "";
-    if (existsSync32(gitignorePath)) {
+    if (existsSync33(gitignorePath)) {
       content = await readFile26(gitignorePath, "utf-8");
       const lines = content.split(`
 `).map((line) => line.trim()).filter((line) => !line.startsWith("#"));
@@ -52937,7 +52981,7 @@ ${geminiPattern}
 }
 async function createNewSettingsWithMerge(geminiSettingsPath, mcpConfigPath) {
   const linkDir = dirname11(geminiSettingsPath);
-  if (!existsSync32(linkDir)) {
+  if (!existsSync33(linkDir)) {
     await mkdir12(linkDir, { recursive: true });
     logger.debug(`Created directory: ${linkDir}`);
   }
@@ -52998,23 +53042,23 @@ var init_config_manager2 = __esm(() => {
 });
 
 // src/services/package-installer/gemini-mcp/validation.ts
-import { existsSync as existsSync33, lstatSync, readlinkSync } from "node:fs";
+import { existsSync as existsSync34, lstatSync, readlinkSync } from "node:fs";
 import { homedir as homedir17 } from "node:os";
-import { join as join51 } from "node:path";
+import { join as join52 } from "node:path";
 function getGlobalMcpConfigPath() {
-  return join51(homedir17(), ".claude", ".mcp.json");
+  return join52(homedir17(), ".claude", ".mcp.json");
 }
 function getLocalMcpConfigPath(projectDir) {
-  return join51(projectDir, ".mcp.json");
+  return join52(projectDir, ".mcp.json");
 }
 function findMcpConfigPath(projectDir) {
   const localPath = getLocalMcpConfigPath(projectDir);
-  if (existsSync33(localPath)) {
+  if (existsSync34(localPath)) {
     logger.debug(`Found local MCP config: ${localPath}`);
     return localPath;
   }
   const globalPath = getGlobalMcpConfigPath();
-  if (existsSync33(globalPath)) {
+  if (existsSync34(globalPath)) {
     logger.debug(`Found global MCP config: ${globalPath}`);
     return globalPath;
   }
@@ -53023,13 +53067,13 @@ function findMcpConfigPath(projectDir) {
 }
 function getGeminiSettingsPath(projectDir, isGlobal) {
   if (isGlobal) {
-    return join51(homedir17(), ".gemini", "settings.json");
+    return join52(homedir17(), ".gemini", "settings.json");
   }
-  return join51(projectDir, ".gemini", "settings.json");
+  return join52(projectDir, ".gemini", "settings.json");
 }
 function checkExistingGeminiConfig(projectDir, isGlobal = false) {
   const geminiSettingsPath = getGeminiSettingsPath(projectDir, isGlobal);
-  if (!existsSync33(geminiSettingsPath)) {
+  if (!existsSync34(geminiSettingsPath)) {
     return { exists: false, isSymlink: false, settingsPath: geminiSettingsPath };
   }
   try {
@@ -53053,12 +53097,12 @@ var init_validation = __esm(() => {
 });
 
 // src/services/package-installer/gemini-mcp/linker-core.ts
-import { existsSync as existsSync34 } from "node:fs";
+import { existsSync as existsSync35 } from "node:fs";
 import { mkdir as mkdir13, symlink as symlink2 } from "node:fs/promises";
-import { dirname as dirname12, join as join52 } from "node:path";
+import { dirname as dirname12, join as join53 } from "node:path";
 async function createSymlink(targetPath, linkPath, projectDir, isGlobal) {
   const linkDir = dirname12(linkPath);
-  if (!existsSync34(linkDir)) {
+  if (!existsSync35(linkDir)) {
     await mkdir13(linkDir, { recursive: true });
     logger.debug(`Created directory: ${linkDir}`);
   }
@@ -53066,7 +53110,7 @@ async function createSymlink(targetPath, linkPath, projectDir, isGlobal) {
   if (isGlobal) {
     symlinkTarget = getGlobalMcpConfigPath();
   } else {
-    const localMcpPath = join52(projectDir, ".mcp.json");
+    const localMcpPath = join53(projectDir, ".mcp.json");
     const isLocalConfig = targetPath === localMcpPath;
     symlinkTarget = isLocalConfig ? "../.mcp.json" : targetPath;
   }
@@ -53099,10 +53143,10 @@ __export(exports_gemini_mcp_linker, {
   checkExistingGeminiConfig: () => checkExistingGeminiConfig,
   addGeminiToGitignore: () => addGeminiToGitignore
 });
-import { resolve as resolve9 } from "node:path";
+import { resolve as resolve10 } from "node:path";
 async function linkGeminiMcpConfig(projectDir, options2 = {}) {
   const { skipGitignore = false, isGlobal = false } = options2;
-  const resolvedProjectDir = resolve9(projectDir);
+  const resolvedProjectDir = resolve10(projectDir);
   const geminiSettingsPath = getGeminiSettingsPath(resolvedProjectDir, isGlobal);
   const mcpConfigPath = findMcpConfigPath(resolvedProjectDir);
   if (!mcpConfigPath) {
@@ -53900,12 +53944,12 @@ var require_adapter = __commonJS((exports, module) => {
     return newFs;
   }
   function toPromise(method) {
-    return (...args) => new Promise((resolve10, reject) => {
+    return (...args) => new Promise((resolve11, reject) => {
       args.push((err, result) => {
         if (err) {
           reject(err);
         } else {
-          resolve10(result);
+          resolve11(result);
         }
       });
       method(...args);
@@ -54475,7 +54519,7 @@ var require_get_stream = __commonJS((exports, module) => {
     };
     const { maxBuffer } = options2;
     let stream;
-    await new Promise((resolve11, reject) => {
+    await new Promise((resolve12, reject) => {
       const rejectPromise = (error) => {
         if (error && stream.getBufferedLength() <= BufferConstants.MAX_LENGTH) {
           error.bufferedData = stream.getBufferedValue();
@@ -54487,7 +54531,7 @@ var require_get_stream = __commonJS((exports, module) => {
           rejectPromise(error);
           return;
         }
-        resolve11();
+        resolve12();
       });
       stream.on("data", () => {
         if (stream.getBufferedLength() > maxBuffer) {
@@ -55848,7 +55892,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((resolve11, reject) => {
+      return new Promise((resolve12, reject) => {
         this.zipfile.on("error", (err) => {
           this.canceled = true;
           reject(err);
@@ -55857,7 +55901,7 @@ var require_extract_zip = __commonJS((exports, module) => {
         this.zipfile.on("close", () => {
           if (!this.canceled) {
             debug("zip extraction complete");
-            resolve11();
+            resolve12();
           }
         });
         this.zipfile.on("entry", async (entry) => {
@@ -58565,7 +58609,7 @@ function getPagerArgs(pagerCmd) {
   return [];
 }
 async function trySystemPager(content) {
-  return new Promise((resolve20) => {
+  return new Promise((resolve21) => {
     const pagerCmd = process.env.PAGER || "less";
     const pagerArgs = getPagerArgs(pagerCmd);
     try {
@@ -58575,20 +58619,20 @@ async function trySystemPager(content) {
       });
       const timeout2 = setTimeout(() => {
         pager.kill();
-        resolve20(false);
+        resolve21(false);
       }, 30000);
       pager.stdin.write(content);
       pager.stdin.end();
       pager.on("close", (code2) => {
         clearTimeout(timeout2);
-        resolve20(code2 === 0);
+        resolve21(code2 === 0);
       });
       pager.on("error", () => {
         clearTimeout(timeout2);
-        resolve20(false);
+        resolve21(false);
       });
     } catch {
-      resolve20(false);
+      resolve21(false);
     }
   });
 }
@@ -58615,16 +58659,16 @@ async function basicPager(content) {
       break;
     }
     const remaining = lines.length - currentLine;
-    await new Promise((resolve20) => {
+    await new Promise((resolve21) => {
       rl.question(`-- More (${remaining} lines) [Enter/q] --`, (answer) => {
         if (answer.toLowerCase() === "q") {
           rl.close();
           process.exitCode = 0;
-          resolve20();
+          resolve21();
           return;
         }
         process.stdout.write("\x1B[1A\x1B[2K");
-        resolve20();
+        resolve21();
       });
     });
   }
@@ -61572,6 +61616,794 @@ async function checkEnvKeys(setup) {
   }
   return results;
 }
+// src/domains/health-checks/checkers/hook-health-checker.ts
+init_logger();
+init_path_resolver();
+import { spawnSync } from "node:child_process";
+import { existsSync as existsSync30, readFileSync as readFileSync6, statSync as statSync5, writeFileSync } from "node:fs";
+import { readdir as readdir9 } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join as join41, resolve as resolve8 } 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 = resolve8(projectDir, ".claude", "hooks");
+  const globalHooksDir = resolve8(PathResolver.getGlobalKitDir(), "hooks");
+  if (existsSync30(projectHooksDir))
+    return projectHooksDir;
+  if (existsSync30(globalHooksDir))
+    return globalHooksDir;
+  return null;
+}
+function isPathWithin(filePath, parentDir) {
+  return resolve8(filePath).startsWith(resolve8(parentDir));
+}
+async function checkHookSyntax(projectDir) {
+  const hooksDir = getHooksDir(projectDir);
+  if (!hooksDir) {
+    return {
+      id: "hook-syntax",
+      name: "Hook Syntax",
+      group: "claudekit",
+      priority: "critical",
+      status: "info",
+      message: "No hooks directory",
+      autoFixable: false
+    };
+  }
+  try {
+    const files = await readdir9(hooksDir);
+    const cjsFiles = files.filter((f3) => f3.endsWith(".cjs"));
+    if (cjsFiles.length === 0) {
+      return {
+        id: "hook-syntax",
+        name: "Hook Syntax",
+        group: "claudekit",
+        priority: "critical",
+        status: "info",
+        message: "No .cjs hooks found",
+        autoFixable: false
+      };
+    }
+    const errors2 = [];
+    for (const file of cjsFiles) {
+      const filePath = join41(hooksDir, file);
+      if (!isPathWithin(filePath, hooksDir))
+        continue;
+      const result = spawnSync("node", ["--check", filePath], {
+        timeout: HOOK_CHECK_TIMEOUT_MS,
+        encoding: "utf-8"
+      });
+      if (result.status !== 0) {
+        errors2.push(`${file}: ${result.stderr?.trim() || "syntax error"}`);
+      }
+    }
+    if (errors2.length > 0) {
+      return {
+        id: "hook-syntax",
+        name: "Hook Syntax",
+        group: "claudekit",
+        priority: "critical",
+        status: "fail",
+        message: `${errors2.length} hook(s) with syntax errors`,
+        details: errors2.join(`
+`),
+        suggestion: "Run: ck init",
+        autoFixable: true,
+        fix: {
+          id: "fix-hook-syntax",
+          description: "Reinstall hooks via ck init",
+          execute: async () => ({
+            success: false,
+            message: "Manual fix required: run 'ck init'"
+          })
+        }
+      };
+    }
+    return {
+      id: "hook-syntax",
+      name: "Hook Syntax",
+      group: "claudekit",
+      priority: "critical",
+      status: "pass",
+      message: `${cjsFiles.length} hook(s) valid`,
+      autoFixable: false
+    };
+  } catch (error) {
+    logger.debug(`Hook syntax check failed: ${error}`);
+    return {
+      id: "hook-syntax",
+      name: "Hook Syntax",
+      group: "claudekit",
+      priority: "critical",
+      status: "fail",
+      message: "Failed to check hook syntax",
+      details: error instanceof Error ? error.message : String(error),
+      autoFixable: false
+    };
+  }
+}
+async function checkHookDeps(projectDir) {
+  const hooksDir = getHooksDir(projectDir);
+  if (!hooksDir) {
+    return {
+      id: "hook-deps",
+      name: "Hook Dependencies",
+      group: "claudekit",
+      priority: "critical",
+      status: "info",
+      message: "No hooks directory",
+      autoFixable: false
+    };
+  }
+  try {
+    const files = await readdir9(hooksDir);
+    const cjsFiles = files.filter((f3) => f3.endsWith(".cjs"));
+    if (cjsFiles.length === 0) {
+      return {
+        id: "hook-deps",
+        name: "Hook Dependencies",
+        group: "claudekit",
+        priority: "critical",
+        status: "info",
+        message: "No .cjs hooks found",
+        autoFixable: false
+      };
+    }
+    const missingDeps = [];
+    const requireRegex = /require\(['"]([^'"]+)['"]\)/g;
+    for (const file of cjsFiles) {
+      const filePath = join41(hooksDir, file);
+      if (!isPathWithin(filePath, hooksDir))
+        continue;
+      const content = readFileSync6(filePath, "utf-8");
+      for (let match = requireRegex.exec(content);match !== null; match = requireRegex.exec(content)) {
+        const depPath = match[1];
+        if (depPath.startsWith("node:") || isNodeBuiltin(depPath)) {
+          continue;
+        }
+        if (depPath.startsWith(".")) {
+          const resolvedPath = join41(hooksDir, depPath);
+          const extensions = [".js", ".cjs", ".mjs", ".json"];
+          const indexFiles = ["index.js", "index.cjs", "index.mjs"];
+          const exists = existsSync30(resolvedPath) || extensions.some((ext) => existsSync30(resolvedPath + ext)) || indexFiles.some((idx) => existsSync30(join41(resolvedPath, idx)));
+          if (!exists) {
+            missingDeps.push(`${file}: ${depPath}`);
+          }
+        }
+      }
+    }
+    if (missingDeps.length > 0) {
+      return {
+        id: "hook-deps",
+        name: "Hook Dependencies",
+        group: "claudekit",
+        priority: "critical",
+        status: "fail",
+        message: `${missingDeps.length} missing dependency(ies)`,
+        details: missingDeps.join(`
+`),
+        suggestion: "Run: ck init",
+        autoFixable: true,
+        fix: {
+          id: "fix-hook-deps",
+          description: "Reinstall hooks via ck init",
+          execute: async () => ({
+            success: false,
+            message: "Manual fix required: run 'ck init'"
+          })
+        }
+      };
+    }
+    return {
+      id: "hook-deps",
+      name: "Hook Dependencies",
+      group: "claudekit",
+      priority: "critical",
+      status: "pass",
+      message: "All dependencies resolved",
+      autoFixable: false
+    };
+  } catch (error) {
+    logger.debug(`Hook deps check failed: ${error}`);
+    return {
+      id: "hook-deps",
+      name: "Hook Dependencies",
+      group: "claudekit",
+      priority: "critical",
+      status: "fail",
+      message: "Failed to check dependencies",
+      details: error instanceof Error ? error.message : String(error),
+      autoFixable: false
+    };
+  }
+}
+function isNodeBuiltin(mod) {
+  try {
+    const { builtinModules } = __require("node:module");
+    return builtinModules.includes(mod);
+  } catch {
+    const builtins = [
+      "fs",
+      "path",
+      "os",
+      "child_process",
+      "util",
+      "stream",
+      "events",
+      "crypto",
+      "http",
+      "https",
+      "net",
+      "dns",
+      "url",
+      "querystring",
+      "readline",
+      "process",
+      "buffer",
+      "console",
+      "timers",
+      "assert",
+      "zlib",
+      "worker_threads",
+      "perf_hooks",
+      "v8",
+      "vm",
+      "tls"
+    ];
+    return builtins.includes(mod);
+  }
+}
+async function checkHookRuntime(projectDir) {
+  const hooksDir = getHooksDir(projectDir);
+  if (!hooksDir) {
+    return {
+      id: "hook-runtime",
+      name: "Hook Runtime",
+      group: "claudekit",
+      priority: "standard",
+      status: "info",
+      message: "No hooks directory",
+      autoFixable: false
+    };
+  }
+  try {
+    const files = await readdir9(hooksDir);
+    const cjsFiles = files.filter((f3) => f3.endsWith(".cjs"));
+    if (cjsFiles.length === 0) {
+      return {
+        id: "hook-runtime",
+        name: "Hook Runtime",
+        group: "claudekit",
+        priority: "standard",
+        status: "info",
+        message: "No .cjs hooks found",
+        autoFixable: false
+      };
+    }
+    const syntheticPayload = JSON.stringify({
+      tool_name: "Read",
+      tool_input: { file_path: join41(tmpdir(), "ck-doctor-test.txt") }
+    });
+    const failures = [];
+    for (const file of cjsFiles) {
+      const filePath = join41(hooksDir, file);
+      if (!isPathWithin(filePath, hooksDir))
+        continue;
+      const result = spawnSync("node", [filePath], {
+        input: syntheticPayload,
+        timeout: HOOK_CHECK_TIMEOUT_MS,
+        encoding: "utf-8"
+      });
+      if (result.status !== null && result.status !== 0 && result.status !== 2) {
+        const error = result.error?.message || result.stderr?.trim() || `exit code ${result.status}`;
+        failures.push(`${file}: ${error}`);
+      } else if (result.status === null && result.error) {
+        const error = result.error.message || "failed to execute";
+        failures.push(`${file}: ${error}`);
+      }
+    }
+    if (failures.length > 0) {
+      return {
+        id: "hook-runtime",
+        name: "Hook Runtime",
+        group: "claudekit",
+        priority: "standard",
+        status: "fail",
+        message: `${failures.length} hook(s) failed dry-run`,
+        details: failures.join(`
+`),
+        suggestion: "Run: ck init",
+        autoFixable: true,
+        fix: {
+          id: "fix-hook-runtime",
+          description: "Reinstall hooks via ck init",
+          execute: async () => ({
+            success: false,
+            message: "Manual fix required: run 'ck init'"
+          })
+        }
+      };
+    }
+    return {
+      id: "hook-runtime",
+      name: "Hook Runtime",
+      group: "claudekit",
+      priority: "standard",
+      status: "pass",
+      message: `${cjsFiles.length} hook(s) passed dry-run`,
+      autoFixable: false
+    };
+  } catch (error) {
+    logger.debug(`Hook runtime check failed: ${error}`);
+    return {
+      id: "hook-runtime",
+      name: "Hook Runtime",
+      group: "claudekit",
+      priority: "standard",
+      status: "fail",
+      message: "Failed to check hook runtime",
+      details: error instanceof Error ? error.message : String(error),
+      autoFixable: false
+    };
+  }
+}
+async function checkHookConfig(projectDir) {
+  const projectConfigPath = join41(projectDir, ".claude", ".ck.json");
+  const globalConfigPath = join41(PathResolver.getGlobalKitDir(), ".ck.json");
+  const configPath = existsSync30(projectConfigPath) ? projectConfigPath : existsSync30(globalConfigPath) ? globalConfigPath : null;
+  if (!configPath) {
+    return {
+      id: "hook-config",
+      name: "Hook Config",
+      group: "claudekit",
+      priority: "standard",
+      status: "info",
+      message: "No .ck.json config",
+      autoFixable: false
+    };
+  }
+  const hooksDir = getHooksDir(projectDir);
+  if (!hooksDir) {
+    return {
+      id: "hook-config",
+      name: "Hook Config",
+      group: "claudekit",
+      priority: "standard",
+      status: "info",
+      message: "No hooks directory",
+      autoFixable: false
+    };
+  }
+  try {
+    const configContent = readFileSync6(configPath, "utf-8");
+    const config = JSON.parse(configContent);
+    if (!config.hooks || typeof config.hooks !== "object") {
+      return {
+        id: "hook-config",
+        name: "Hook Config",
+        group: "claudekit",
+        priority: "standard",
+        status: "pass",
+        message: "No hooks configured",
+        autoFixable: false
+      };
+    }
+    const files = await readdir9(hooksDir);
+    const hookBaseNames = new Set(files.filter((f3) => HOOK_EXTENSIONS.some((ext) => f3.endsWith(ext))).map((f3) => {
+      for (const ext of HOOK_EXTENSIONS) {
+        if (f3.endsWith(ext))
+          return f3.slice(0, -ext.length);
+      }
+      return f3;
+    }));
+    const orphanedEntries = [];
+    for (const hookName of Object.keys(config.hooks)) {
+      if (!hookBaseNames.has(hookName)) {
+        orphanedEntries.push(hookName);
+      }
+    }
+    if (orphanedEntries.length > 0) {
+      return {
+        id: "hook-config",
+        name: "Hook Config",
+        group: "claudekit",
+        priority: "standard",
+        status: "warn",
+        message: `${orphanedEntries.length} orphaned config entry(ies)`,
+        details: orphanedEntries.join(", "),
+        suggestion: "Remove orphaned entries from .ck.json",
+        autoFixable: true,
+        fix: {
+          id: "fix-hook-config",
+          description: "Remove orphaned entries from .ck.json",
+          execute: async () => {
+            try {
+              for (const entry of orphanedEntries) {
+                delete config.hooks[entry];
+              }
+              const updatedConfig = JSON.stringify(config, null, 2);
+              writeFileSync(configPath, updatedConfig, "utf-8");
+              return {
+                success: true,
+                message: `Removed ${orphanedEntries.length} orphaned entry(ies)`
+              };
+            } catch (err) {
+              return {
+                success: false,
+                message: `Failed to update .ck.json: ${err}`
+              };
+            }
+          }
+        }
+      };
+    }
+    return {
+      id: "hook-config",
+      name: "Hook Config",
+      group: "claudekit",
+      priority: "standard",
+      status: "pass",
+      message: "All config entries valid",
+      autoFixable: false
+    };
+  } catch (error) {
+    logger.debug(`Hook config check failed: ${error}`);
+    return {
+      id: "hook-config",
+      name: "Hook Config",
+      group: "claudekit",
+      priority: "standard",
+      status: "fail",
+      message: "Failed to validate config",
+      details: error instanceof Error ? error.message : String(error),
+      autoFixable: false
+    };
+  }
+}
+async function checkHookLogs(projectDir) {
+  const hooksDir = getHooksDir(projectDir);
+  if (!hooksDir) {
+    return {
+      id: "hook-logs",
+      name: "Hook Crash Logs",
+      group: "claudekit",
+      priority: "standard",
+      status: "info",
+      message: "No hooks directory",
+      autoFixable: false
+    };
+  }
+  const logPath = join41(hooksDir, ".logs", "hook-log.jsonl");
+  if (!existsSync30(logPath)) {
+    return {
+      id: "hook-logs",
+      name: "Hook Crash Logs",
+      group: "claudekit",
+      priority: "standard",
+      status: "pass",
+      message: "No crash logs",
+      autoFixable: false
+    };
+  }
+  try {
+    const logStats = statSync5(logPath);
+    if (logStats.size > MAX_LOG_FILE_SIZE_BYTES) {
+      return {
+        id: "hook-logs",
+        name: "Hook Crash Logs",
+        group: "claudekit",
+        priority: "standard",
+        status: "warn",
+        message: `Log file too large (${Math.round(logStats.size / 1024 / 1024)}MB)`,
+        suggestion: "Delete .claude/hooks/.logs/hook-log.jsonl and run: ck init",
+        autoFixable: true,
+        fix: {
+          id: "fix-hook-logs",
+          description: "Clear oversized log file",
+          execute: async () => {
+            try {
+              writeFileSync(logPath, "", "utf-8");
+              return { success: true, message: "Cleared oversized log file" };
+            } catch (err) {
+              return { success: false, message: `Failed to clear log: ${err}` };
+            }
+          }
+        }
+      };
+    }
+    const logContent = readFileSync6(logPath, "utf-8");
+    const lines = logContent.trim().split(`
+`).filter(Boolean);
+    const now = Date.now();
+    const oneDayAgo = now - 24 * 60 * 60 * 1000;
+    const crashes = [];
+    for (const line of lines) {
+      try {
+        const entry = JSON.parse(line);
+        const timestamp = new Date(entry.ts || entry.timestamp).getTime();
+        if (timestamp >= oneDayAgo && entry.status === "crash") {
+          crashes.push({
+            hook: entry.hook || "unknown",
+            error: entry.error || "unknown error"
+          });
+        }
+      } catch {}
+    }
+    if (crashes.length === 0) {
+      return {
+        id: "hook-logs",
+        name: "Hook Crash Logs",
+        group: "claudekit",
+        priority: "standard",
+        status: "pass",
+        message: "No crashes in last 24h",
+        autoFixable: false
+      };
+    }
+    if (crashes.length <= 5) {
+      const hookList = crashes.map((c2) => `${c2.hook}: ${c2.error}`).join(`
+`);
+      return {
+        id: "hook-logs",
+        name: "Hook Crash Logs",
+        group: "claudekit",
+        priority: "standard",
+        status: "warn",
+        message: `${crashes.length} crash(es) in last 24h`,
+        details: hookList,
+        suggestion: "Run: ck init",
+        autoFixable: true,
+        fix: {
+          id: "fix-hook-logs",
+          description: "Clear log file",
+          execute: async () => {
+            try {
+              writeFileSync(logPath, "", "utf-8");
+              return {
+                success: true,
+                message: "Cleared crash log file"
+              };
+            } catch (err) {
+              return {
+                success: false,
+                message: `Failed to clear log: ${err}`
+              };
+            }
+          }
+        }
+      };
+    }
+    const hookCounts = crashes.reduce((acc, c2) => {
+      acc[c2.hook] = (acc[c2.hook] || 0) + 1;
+      return acc;
+    }, {});
+    const topCrashers = Object.entries(hookCounts).sort((a3, b3) => b3[1] - a3[1]).slice(0, 5).map(([hook, count]) => `${hook} (${count}x)`).join(", ");
+    return {
+      id: "hook-logs",
+      name: "Hook Crash Logs",
+      group: "claudekit",
+      priority: "standard",
+      status: "fail",
+      message: `${crashes.length} crashes in last 24h`,
+      details: `Most frequent: ${topCrashers}`,
+      suggestion: "Run: ck init",
+      autoFixable: true,
+      fix: {
+        id: "fix-hook-logs",
+        description: "Clear log file and suggest reinstall",
+        execute: async () => {
+          try {
+            writeFileSync(logPath, "", "utf-8");
+            return {
+              success: true,
+              message: "Cleared crash log. Run 'ck init' to reinstall hooks."
+            };
+          } catch (err) {
+            return {
+              success: false,
+              message: `Failed to clear log: ${err}`
+            };
+          }
+        }
+      }
+    };
+  } catch (error) {
+    logger.debug(`Hook logs check failed: ${error}`);
+    return {
+      id: "hook-logs",
+      name: "Hook Crash Logs",
+      group: "claudekit",
+      priority: "standard",
+      status: "fail",
+      message: "Failed to check crash logs",
+      details: error instanceof Error ? error.message : String(error),
+      autoFixable: false
+    };
+  }
+}
+async function checkCliVersion() {
+  try {
+    const versionResult = spawnSync("ck", ["-V"], {
+      timeout: HOOK_CHECK_TIMEOUT_MS,
+      encoding: "utf-8"
+    });
+    let installedVersion = "unknown";
+    if (versionResult.status === 0 && versionResult.stdout) {
+      installedVersion = versionResult.stdout.trim();
+    }
+    if (installedVersion === "unknown") {
+      return {
+        id: "cli-version",
+        name: "CLI Version",
+        group: "claudekit",
+        priority: "critical",
+        status: "warn",
+        message: "Cannot determine installed version",
+        autoFixable: false
+      };
+    }
+    const npmResult = spawnSync("npm", ["view", "claudekit-cli", "version"], {
+      timeout: HOOK_CHECK_TIMEOUT_MS,
+      encoding: "utf-8"
+    });
+    if (npmResult.status !== 0) {
+      return {
+        id: "cli-version",
+        name: "CLI Version",
+        group: "claudekit",
+        priority: "critical",
+        status: "warn",
+        message: `v${installedVersion} (unable to check for updates)`,
+        autoFixable: false
+      };
+    }
+    const latestVersion = npmResult.stdout?.trim() || installedVersion;
+    const parseVersion = (v2) => v2.replace(/-.*$/, "").split(".").map(Number);
+    const [installedMajor, installedMinor] = parseVersion(installedVersion);
+    const [latestMajor, latestMinor] = parseVersion(latestVersion);
+    if (installedMajor < latestMajor) {
+      return {
+        id: "cli-version",
+        name: "CLI Version",
+        group: "claudekit",
+        priority: "critical",
+        status: "fail",
+        message: `v${installedVersion} (latest: v${latestVersion})`,
+        details: "Major version behind",
+        suggestion: "Run: ck update",
+        autoFixable: true,
+        fix: {
+          id: "fix-cli-version",
+          description: "Update CLI to latest version",
+          execute: async () => ({
+            success: false,
+            message: "Manual fix required: run 'ck update'"
+          })
+        }
+      };
+    }
+    if (installedMajor === latestMajor && installedMinor < latestMinor) {
+      return {
+        id: "cli-version",
+        name: "CLI Version",
+        group: "claudekit",
+        priority: "critical",
+        status: "warn",
+        message: `v${installedVersion} (latest: v${latestVersion})`,
+        details: "Minor version behind",
+        suggestion: "Run: ck update",
+        autoFixable: true,
+        fix: {
+          id: "fix-cli-version",
+          description: "Update CLI to latest version",
+          execute: async () => ({
+            success: false,
+            message: "Manual fix required: run 'ck update'"
+          })
+        }
+      };
+    }
+    return {
+      id: "cli-version",
+      name: "CLI Version",
+      group: "claudekit",
+      priority: "critical",
+      status: "pass",
+      message: `v${installedVersion} (up to date)`,
+      autoFixable: false
+    };
+  } catch (error) {
+    logger.debug(`CLI version check failed: ${error}`);
+    return {
+      id: "cli-version",
+      name: "CLI Version",
+      group: "claudekit",
+      priority: "critical",
+      status: "warn",
+      message: "Failed to check version",
+      details: error instanceof Error ? error.message : String(error),
+      autoFixable: false
+    };
+  }
+}
+async function checkPythonVenv(projectDir) {
+  const isWindows3 = process.platform === "win32";
+  const venvBin = isWindows3 ? join41("Scripts", "python.exe") : join41("bin", "python3");
+  const projectVenvPath = join41(projectDir, ".claude", "skills", ".venv", venvBin);
+  const globalVenvPath = join41(PathResolver.getGlobalKitDir(), "skills", ".venv", venvBin);
+  const venvPath = existsSync30(projectVenvPath) ? projectVenvPath : existsSync30(globalVenvPath) ? globalVenvPath : null;
+  if (!venvPath) {
+    return {
+      id: "python-venv",
+      name: "Python Venv",
+      group: "claudekit",
+      priority: "standard",
+      status: "warn",
+      message: "Virtual environment not found",
+      suggestion: "Delete .venv and run install.sh",
+      autoFixable: true,
+      fix: {
+        id: "fix-python-venv",
+        description: "Delete .venv and suggest reinstall",
+        execute: async () => ({
+          success: false,
+          message: "Manual fix required: delete .venv and run install.sh"
+        })
+      }
+    };
+  }
+  try {
+    const result = spawnSync(venvPath, ["--version"], {
+      timeout: PYTHON_CHECK_TIMEOUT_MS,
+      encoding: "utf-8"
+    });
+    if (result.status !== 0) {
+      return {
+        id: "python-venv",
+        name: "Python Venv",
+        group: "claudekit",
+        priority: "standard",
+        status: "fail",
+        message: "Python venv exists but broken",
+        details: result.stderr?.trim() || "Failed to run python3 --version",
+        suggestion: "Delete .venv and run install.sh",
+        autoFixable: true,
+        fix: {
+          id: "fix-python-venv",
+          description: "Delete .venv",
+          execute: async () => ({
+            success: false,
+            message: "Manual fix required: delete .venv and run install.sh"
+          })
+        }
+      };
+    }
+    const version = result.stdout?.trim() || "unknown";
+    return {
+      id: "python-venv",
+      name: "Python Venv",
+      group: "claudekit",
+      priority: "standard",
+      status: "pass",
+      message: version,
+      autoFixable: false
+    };
+  } catch (error) {
+    logger.debug(`Python venv check failed: ${error}`);
+    return {
+      id: "python-venv",
+      name: "Python Venv",
+      group: "claudekit",
+      priority: "standard",
+      status: "fail",
+      message: "Failed to check venv",
+      details: error instanceof Error ? error.message : String(error),
+      autoFixable: false
+    };
+  }
+}
 // src/domains/health-checks/claudekit-checker.ts
 class ClaudekitChecker {
   group = "claudekit";
@@ -61586,6 +62418,8 @@ class ClaudekitChecker {
     const setup = await getClaudeKitSetup(this.projectDir);
     logger.verbose("ClaudekitChecker: Setup scan complete");
     const results = [];
+    logger.verbose("ClaudekitChecker: Checking CLI version");
+    results.push(await checkCliVersion());
     logger.verbose("ClaudekitChecker: Checking CLI install method");
     results.push(await checkCliInstallMethod());
     logger.verbose("ClaudekitChecker: Checking global install");
@@ -61608,6 +62442,18 @@ class ClaudekitChecker {
     results.push(await checkGlobalDirWritable());
     logger.verbose("ClaudekitChecker: Checking hooks directory");
     results.push(await checkHooksExist(this.projectDir));
+    logger.verbose("ClaudekitChecker: Checking hook syntax");
+    results.push(await checkHookSyntax(this.projectDir));
+    logger.verbose("ClaudekitChecker: Checking hook dependencies");
+    results.push(await checkHookDeps(this.projectDir));
+    logger.verbose("ClaudekitChecker: Checking hook runtime");
+    results.push(await checkHookRuntime(this.projectDir));
+    logger.verbose("ClaudekitChecker: Checking hook config");
+    results.push(await checkHookConfig(this.projectDir));
+    logger.verbose("ClaudekitChecker: Checking hook crash logs");
+    results.push(await checkHookLogs(this.projectDir));
+    logger.verbose("ClaudekitChecker: Checking Python venv");
+    results.push(await checkPythonVenv(this.projectDir));
     logger.verbose("ClaudekitChecker: Checking settings.json validity");
     results.push(await checkSettingsValid(this.projectDir));
     logger.verbose("ClaudekitChecker: Checking path references");
@@ -61620,7 +62466,7 @@ class ClaudekitChecker {
 }
 // src/domains/health-checks/auth-checker.ts
 init_github_auth();
-import { spawnSync as spawnSync2 } from "node:child_process";
+import { spawnSync as spawnSync3 } from "node:child_process";
 
 // src/domains/installation/git-clone-manager.ts
 init_logger();
@@ -61887,7 +62733,7 @@ class AuthChecker {
     if (false) {}
     try {
       logger.verbose("AuthChecker: Running 'gh auth status -h github.com' command");
-      const result = spawnSync2("gh", ["auth", "status", "-h", "github.com"], {
+      const result = spawnSync3("gh", ["auth", "status", "-h", "github.com"], {
         encoding: "utf8",
         timeout: COMMAND_TIMEOUT_MS2
       });
@@ -61966,7 +62812,7 @@ import { platform as platform6 } from "node:os";
 init_path_resolver();
 import { constants as constants3, access as access3, mkdir as mkdir9, readFile as readFile23, unlink as unlink5, writeFile as writeFile12 } from "node:fs/promises";
 import { arch as arch2, homedir as homedir16, platform as platform5 } from "node:os";
-import { join as join42, normalize as normalize6 } from "node:path";
+import { join as join43, normalize as normalize6 } from "node:path";
 var IS_WINDOWS = platform5() === "win32";
 function shouldSkipExpensiveOperations4() {
   if (process.env.CK_TEST_HOME) {
@@ -62060,7 +62906,7 @@ async function checkGlobalDirAccess() {
       autoFixable: false
     };
   }
-  const testFile = join42(globalDir, ".ck-doctor-access-test");
+  const testFile = join43(globalDir, ".ck-doctor-access-test");
   try {
     await mkdir9(globalDir, { recursive: true });
     await writeFile12(testFile, "test", "utf-8");
@@ -62138,7 +62984,7 @@ async function checkWSLBoundary() {
 // src/domains/health-checks/platform/windows-checker.ts
 init_path_resolver();
 import { mkdir as mkdir10, symlink, unlink as unlink6, writeFile as writeFile13 } from "node:fs/promises";
-import { join as join43 } from "node:path";
+import { join as join44 } from "node:path";
 async function checkLongPathSupport() {
   if (shouldSkipExpensiveOperations4()) {
     return {
@@ -62190,8 +63036,8 @@ async function checkSymlinkSupport() {
     };
   }
   const testDir = PathResolver.getGlobalKitDir();
-  const target = join43(testDir, ".ck-symlink-test-target");
-  const link = join43(testDir, ".ck-symlink-test-link");
+  const target = join44(testDir, ".ck-symlink-test-target");
+  const link = join44(testDir, ".ck-symlink-test-link");
   try {
     await mkdir10(testDir, { recursive: true });
     await writeFile13(target, "test", "utf-8");
@@ -62474,10 +63320,10 @@ class AutoHealer {
   }
 }
 // src/domains/health-checks/report-generator.ts
-import { execSync as execSync3, spawnSync as spawnSync3 } from "node:child_process";
-import { readFileSync as readFileSync6, unlinkSync, writeFileSync } from "node:fs";
-import { tmpdir as tmpdir2 } from "node:os";
-import { dirname as dirname10, join as join44 } from "node:path";
+import { execSync as execSync3, spawnSync as spawnSync4 } from "node:child_process";
+import { readFileSync as readFileSync7, unlinkSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { tmpdir as tmpdir3 } from "node:os";
+import { dirname as dirname10, join as join45 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 init_environment();
 init_logger();
@@ -62485,8 +63331,8 @@ init_dist2();
 function getCliVersion2() {
   try {
     const __dirname4 = dirname10(fileURLToPath3(import.meta.url));
-    const pkgPath = join44(__dirname4, "../../../package.json");
-    const pkg = JSON.parse(readFileSync6(pkgPath, "utf-8"));
+    const pkgPath = join45(__dirname4, "../../../package.json");
+    const pkg = JSON.parse(readFileSync7(pkgPath, "utf-8"));
     return pkg.version || "unknown";
   } catch (err) {
     logger.debug(`Failed to read CLI version: ${err}`);
@@ -62624,10 +63470,10 @@ class ReportGenerator {
         return null;
       }
     }
-    const tmpFile = join44(tmpdir2(), `ck-report-${Date.now()}.txt`);
-    writeFileSync(tmpFile, report);
+    const tmpFile = join45(tmpdir3(), `ck-report-${Date.now()}.txt`);
+    writeFileSync2(tmpFile, report);
     try {
-      const result = spawnSync3("gh", ["gist", "create", tmpFile, "--desc", "ClaudeKit Diagnostic Report"], {
+      const result = spawnSync4("gh", ["gist", "create", tmpFile, "--desc", "ClaudeKit Diagnostic Report"], {
         encoding: "utf-8"
       });
       if (result.status !== 0) {
@@ -62949,7 +63795,7 @@ init_logger();
 init_path_resolver();
 var import_compare_versions5 = __toESM(require_umd(), 1);
 import { mkdir as mkdir11, readFile as readFile24, unlink as unlink7, writeFile as writeFile14 } from "node:fs/promises";
-import { join as join45 } from "node:path";
+import { join as join46 } from "node:path";
 var CACHE_TTL_HOURS = 24;
 var DEFAULT_CACHE_TTL_MS = CACHE_TTL_HOURS * 60 * 60 * 1000;
 var MIN_CACHE_TTL_MS = 60 * 1000;
@@ -62986,7 +63832,7 @@ var KIT_REPOS = {
 class ConfigVersionChecker {
   static getCacheFilePath(kitType, global3) {
     const cacheDir = PathResolver.getCacheDir(global3);
-    return join45(cacheDir, `${kitType}-${CACHE_FILENAME}`);
+    return join46(cacheDir, `${kitType}-${CACHE_FILENAME}`);
   }
   static async loadCache(kitType, global3) {
     try {
@@ -63073,7 +63919,7 @@ class ConfigVersionChecker {
           return null;
         }
         const delay = baseBackoff * 2 ** attempt;
-        await new Promise((resolve8) => setTimeout(resolve8, delay));
+        await new Promise((resolve9) => setTimeout(resolve9, delay));
       }
     }
     return null;
@@ -63149,7 +63995,7 @@ class ConfigVersionChecker {
 }
 // src/domains/sync/sync-engine.ts
 import { lstat as lstat3, readFile as readFile25, readlink, realpath as realpath2, stat as stat9 } from "node:fs/promises";
-import { isAbsolute as isAbsolute2, join as join46, normalize as normalize7, relative as relative4 } from "node:path";
+import { isAbsolute as isAbsolute2, join as join47, normalize as normalize7, relative as relative4 } from "node:path";
 
 // src/services/file-operations/ownership-checker.ts
 init_metadata_migration();
@@ -63240,24 +64086,24 @@ function pLimit(concurrency) {
     activeCount--;
     resumeNext();
   };
-  const run = async (function_, resolve8, arguments_) => {
+  const run = async (function_, resolve9, arguments_) => {
     const result = (async () => function_(...arguments_))();
-    resolve8(result);
+    resolve9(result);
     try {
       await result;
     } catch {}
     next();
   };
-  const enqueue = (function_, resolve8, arguments_) => {
+  const enqueue = (function_, resolve9, arguments_) => {
     new Promise((internalResolve) => {
       queue.enqueue(internalResolve);
-    }).then(run.bind(undefined, function_, resolve8, arguments_));
+    }).then(run.bind(undefined, function_, resolve9, arguments_));
     if (activeCount < concurrency) {
       resumeNext();
     }
   };
-  const generator = (function_, ...arguments_) => new Promise((resolve8) => {
-    enqueue(function_, resolve8, arguments_);
+  const generator = (function_, ...arguments_) => new Promise((resolve9) => {
+    enqueue(function_, resolve9, arguments_);
   });
   Object.defineProperties(generator, {
     activeCount: {
@@ -63308,12 +64154,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((resolve8, reject) => {
+    return new Promise((resolve9, reject) => {
       const hash = createHash("sha256");
       const stream = createReadStream2(filePath);
       stream.on("data", (chunk) => hash.update(chunk));
       stream.on("end", () => {
-        resolve8(hash.digest("hex"));
+        resolve9(hash.digest("hex"));
       });
       stream.on("error", (err) => {
         stream.destroy();
@@ -64437,7 +65283,7 @@ async function validateSymlinkChain(path3, basePath, maxDepth = MAX_SYMLINK_DEPT
       if (!stats.isSymbolicLink())
         break;
       const target = await readlink(current);
-      const resolvedTarget = isAbsolute2(target) ? target : join46(current, "..", target);
+      const resolvedTarget = isAbsolute2(target) ? target : join47(current, "..", target);
       const normalizedTarget = normalize7(resolvedTarget);
       const rel = relative4(basePath, normalizedTarget);
       if (rel.startsWith("..") || isAbsolute2(rel)) {
@@ -64473,7 +65319,7 @@ async function validateSyncPath(basePath, filePath) {
   if (normalized.startsWith("..") || normalized.includes("/../")) {
     throw new Error(`Path traversal not allowed: ${filePath}`);
   }
-  const fullPath = join46(basePath, normalized);
+  const fullPath = join47(basePath, normalized);
   const rel = relative4(basePath, fullPath);
   if (rel.startsWith("..") || isAbsolute2(rel)) {
     throw new Error(`Path escapes base directory: ${filePath}`);
@@ -64488,7 +65334,7 @@ async function validateSyncPath(basePath, filePath) {
     }
   } catch (error) {
     if (error.code === "ENOENT") {
-      const parentPath = join46(fullPath, "..");
+      const parentPath = join47(fullPath, "..");
       try {
         const resolvedBase = await realpath2(basePath);
         const resolvedParent = await realpath2(parentPath);
@@ -65670,7 +66516,7 @@ init_logger();
 var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
 import { mkdir as mkdir14 } from "node:fs/promises";
 import os5 from "node:os";
-import { join as join53 } from "node:path";
+import { join as join54 } from "node:path";
 var LOCK_CONFIG = {
   stale: 60000,
   retries: 0
@@ -65678,12 +66524,12 @@ var LOCK_CONFIG = {
 var activeLocks = new Set;
 var cleanupRegistered = false;
 function getLocksDir() {
-  return join53(os5.homedir(), ".claudekit", "locks");
+  return join54(os5.homedir(), ".claudekit", "locks");
 }
 function cleanupLocks() {
   for (const name of activeLocks) {
     try {
-      const lockPath = join53(getLocksDir(), `${name}.lock`);
+      const lockPath = join54(getLocksDir(), `${name}.lock`);
       import_proper_lockfile.default.unlockSync(lockPath, { realpath: false });
     } catch {
       try {
@@ -65706,7 +66552,7 @@ async function ensureLocksDir() {
 async function withProcessLock(lockName, fn) {
   registerCleanupHandlers();
   await ensureLocksDir();
-  const lockPath = join53(getLocksDir(), `${lockName}.lock`);
+  const lockPath = join54(getLocksDir(), `${lockName}.lock`);
   let release;
   try {
     release = await import_proper_lockfile.default.lock(lockPath, { ...LOCK_CONFIG, realpath: false });
@@ -65737,7 +66583,7 @@ init_logger();
 init_logger();
 init_path_resolver();
 var import_fs_extra7 = __toESM(require_lib3(), 1);
-import { join as join54 } from "node:path";
+import { join as join55 } from "node:path";
 async function handleConflicts(ctx) {
   if (ctx.cancelled)
     return ctx;
@@ -65746,7 +66592,7 @@ async function handleConflicts(ctx) {
   if (PathResolver.isLocalSameAsGlobal()) {
     return ctx;
   }
-  const localSettingsPath = join54(process.cwd(), ".claude", "settings.json");
+  const localSettingsPath = join55(process.cwd(), ".claude", "settings.json");
   if (!await import_fs_extra7.pathExists(localSettingsPath)) {
     return ctx;
   }
@@ -65761,7 +66607,7 @@ async function handleConflicts(ctx) {
     return { ...ctx, cancelled: true };
   }
   if (choice === "remove") {
-    const localClaudeDir = join54(process.cwd(), ".claude");
+    const localClaudeDir = join55(process.cwd(), ".claude");
     try {
       await import_fs_extra7.remove(localClaudeDir);
       logger.success("Removed local .claude/ directory");
@@ -65857,8 +66703,8 @@ init_environment();
 init_logger();
 init_safe_spinner();
 import { mkdir as mkdir20, stat as stat12 } from "node:fs/promises";
-import { tmpdir as tmpdir3 } from "node:os";
-import { join as join61 } from "node:path";
+import { tmpdir as tmpdir4 } from "node:os";
+import { join as join62 } from "node:path";
 
 // src/shared/temp-cleanup.ts
 init_logger();
@@ -65877,7 +66723,7 @@ init_logger();
 init_output_manager();
 import { createWriteStream as createWriteStream2, rmSync } from "node:fs";
 import { mkdir as mkdir15 } from "node:fs/promises";
-import { join as join55 } from "node:path";
+import { join as join56 } from "node:path";
 
 // src/shared/progress-bar.ts
 init_output_manager();
@@ -66041,21 +66887,21 @@ init_types2();
 
 // src/domains/installation/utils/path-security.ts
 init_types2();
-import { lstatSync as lstatSync2, realpathSync } from "node:fs";
-import { relative as relative5, resolve as resolve10 } from "node:path";
+import { lstatSync as lstatSync2, realpathSync as realpathSync2 } from "node:fs";
+import { relative as relative5, resolve as resolve11 } from "node:path";
 var MAX_EXTRACTION_SIZE = 500 * 1024 * 1024;
 function isPathSafe(basePath, targetPath) {
-  const resolvedBase = resolve10(basePath);
+  const resolvedBase = resolve11(basePath);
   try {
     const stat10 = lstatSync2(targetPath);
     if (stat10.isSymbolicLink()) {
-      const realTarget = realpathSync(targetPath);
+      const realTarget = realpathSync2(targetPath);
       if (!realTarget.startsWith(resolvedBase)) {
         return false;
       }
     }
   } catch {}
-  const resolvedTarget = resolve10(targetPath);
+  const resolvedTarget = resolve11(targetPath);
   const relativePath = relative5(resolvedBase, resolvedTarget);
   return !relativePath.startsWith("..") && !relativePath.startsWith("/") && resolvedTarget.startsWith(resolvedBase);
 }
@@ -66087,7 +66933,7 @@ var MAX_DOWNLOAD_SIZE = 500 * 1024 * 1024;
 class FileDownloader {
   async downloadAsset(asset, destDir) {
     try {
-      const destPath = join55(destDir, asset.name);
+      const destPath = join56(destDir, asset.name);
       await mkdir15(destDir, { recursive: true });
       output.info(`Downloading ${asset.name} (${formatBytes(asset.size)})...`);
       logger.verbose("Download details", {
@@ -66143,7 +66989,7 @@ class FileDownloader {
         }
         if (downloadedSize !== totalSize) {
           fileStream.end();
-          await new Promise((resolve11) => fileStream.once("close", resolve11));
+          await new Promise((resolve12) => fileStream.once("close", resolve12));
           try {
             rmSync(destPath, { force: true });
           } catch (cleanupError) {
@@ -66157,7 +67003,7 @@ class FileDownloader {
         return destPath;
       } catch (error) {
         fileStream.end();
-        await new Promise((resolve11) => fileStream.once("close", resolve11));
+        await new Promise((resolve12) => fileStream.once("close", resolve12));
         try {
           rmSync(destPath, { force: true });
         } catch (cleanupError) {
@@ -66172,7 +67018,7 @@ class FileDownloader {
   }
   async downloadFile(params) {
     const { url, name, size, destDir, token } = params;
-    const destPath = join55(destDir, name);
+    const destPath = join56(destDir, name);
     await mkdir15(destDir, { recursive: true });
     output.info(`Downloading ${name}${size ? ` (${formatBytes(size)})` : ""}...`);
     const headers = {};
@@ -66223,7 +67069,7 @@ class FileDownloader {
       const expectedSize = Number(response.headers.get("content-length"));
       if (expectedSize > 0 && downloadedSize !== expectedSize) {
         fileStream.end();
-        await new Promise((resolve11) => fileStream.once("close", resolve11));
+        await new Promise((resolve12) => fileStream.once("close", resolve12));
         try {
           rmSync(destPath, { force: true });
         } catch (cleanupError) {
@@ -66241,7 +67087,7 @@ class FileDownloader {
       return destPath;
     } catch (error) {
       fileStream.end();
-      await new Promise((resolve11) => fileStream.once("close", resolve11));
+      await new Promise((resolve12) => fileStream.once("close", resolve12));
       try {
         rmSync(destPath, { force: true });
       } catch (cleanupError) {
@@ -66257,11 +67103,11 @@ class FileDownloader {
 init_logger();
 init_types2();
 import { constants as constants4 } from "node:fs";
-import { access as access4, readdir as readdir9 } from "node:fs/promises";
-import { join as join56 } from "node:path";
+import { access as access4, readdir as readdir10 } from "node:fs/promises";
+import { join as join57 } from "node:path";
 async function validateExtraction(extractDir) {
   try {
-    const entries = await readdir9(extractDir, { encoding: "utf8" });
+    const entries = await readdir10(extractDir, { encoding: "utf8" });
     logger.debug(`Extracted files: ${entries.join(", ")}`);
     if (entries.length === 0) {
       throw new ExtractionError("Extraction resulted in no files");
@@ -66270,7 +67116,7 @@ async function validateExtraction(extractDir) {
     const missingPaths = [];
     for (const path3 of criticalPaths) {
       try {
-        await access4(join56(extractDir, path3), constants4.F_OK);
+        await access4(join57(extractDir, path3), constants4.F_OK);
         logger.debug(`Found: ${path3}`);
       } catch {
         logger.warning(`Expected path not found: ${path3}`);
@@ -66291,8 +67137,8 @@ async function validateExtraction(extractDir) {
 
 // src/domains/installation/extraction/tar-extractor.ts
 init_logger();
-import { copyFile as copyFile3, mkdir as mkdir18, readdir as readdir11, rm as rm3, stat as stat10 } from "node:fs/promises";
-import { join as join59 } from "node:path";
+import { copyFile as copyFile3, mkdir as mkdir18, readdir as readdir12, rm as rm3, stat as stat10 } from "node:fs/promises";
+import { join as join60 } from "node:path";
 
 // node_modules/@isaacs/fs-minipass/dist/esm/index.js
 import EE from "events";
@@ -66840,10 +67686,10 @@ class Minipass extends EventEmitter3 {
     return this[ENCODING] ? buf.join("") : Buffer.concat(buf, buf.dataLength);
   }
   async promise() {
-    return new Promise((resolve11, reject) => {
+    return new Promise((resolve12, reject) => {
       this.on(DESTROYED, () => reject(new Error("stream destroyed")));
       this.on("error", (er) => reject(er));
-      this.on("end", () => resolve11());
+      this.on("end", () => resolve12());
     });
   }
   [Symbol.asyncIterator]() {
@@ -66862,7 +67708,7 @@ class Minipass extends EventEmitter3 {
         return Promise.resolve({ done: false, value: res });
       if (this[EOF])
         return stop();
-      let resolve11;
+      let resolve12;
       let reject;
       const onerr = (er) => {
         this.off("data", ondata);
@@ -66876,19 +67722,19 @@ class Minipass extends EventEmitter3 {
         this.off("end", onend);
         this.off(DESTROYED, ondestroy);
         this.pause();
-        resolve11({ value, done: !!this[EOF] });
+        resolve12({ value, done: !!this[EOF] });
       };
       const onend = () => {
         this.off("error", onerr);
         this.off("data", ondata);
         this.off(DESTROYED, ondestroy);
         stop();
-        resolve11({ done: true, value: undefined });
+        resolve12({ done: true, value: undefined });
       };
       const ondestroy = () => onerr(new Error("stream destroyed"));
       return new Promise((res2, rej) => {
         reject = rej;
-        resolve11 = res2;
+        resolve12 = res2;
         this.once(DESTROYED, ondestroy);
         this.once("error", onerr);
         this.once("end", onend);
@@ -67994,10 +68840,10 @@ class Minipass2 extends EventEmitter4 {
     return this[ENCODING2] ? buf.join("") : Buffer.concat(buf, buf.dataLength);
   }
   async promise() {
-    return new Promise((resolve11, reject) => {
+    return new Promise((resolve12, reject) => {
       this.on(DESTROYED2, () => reject(new Error("stream destroyed")));
       this.on("error", (er) => reject(er));
-      this.on("end", () => resolve11());
+      this.on("end", () => resolve12());
     });
   }
   [Symbol.asyncIterator]() {
@@ -68016,7 +68862,7 @@ class Minipass2 extends EventEmitter4 {
         return Promise.resolve({ done: false, value: res });
       if (this[EOF2])
         return stop();
-      let resolve11;
+      let resolve12;
       let reject;
       const onerr = (er) => {
         this.off("data", ondata);
@@ -68030,19 +68876,19 @@ class Minipass2 extends EventEmitter4 {
         this.off("end", onend);
         this.off(DESTROYED2, ondestroy);
         this.pause();
-        resolve11({ value, done: !!this[EOF2] });
+        resolve12({ value, done: !!this[EOF2] });
       };
       const onend = () => {
         this.off("error", onerr);
         this.off("data", ondata);
         this.off(DESTROYED2, ondestroy);
         stop();
-        resolve11({ done: true, value: undefined });
+        resolve12({ done: true, value: undefined });
       };
       const ondestroy = () => onerr(new Error("stream destroyed"));
       return new Promise((res2, rej) => {
         reject = rej;
-        resolve11 = res2;
+        resolve12 = res2;
         this.once(DESTROYED2, ondestroy);
         this.once("error", onerr);
         this.once("end", onend);
@@ -69470,10 +70316,10 @@ class Minipass3 extends EventEmitter5 {
     return this[ENCODING3] ? buf.join("") : Buffer.concat(buf, buf.dataLength);
   }
   async promise() {
-    return new Promise((resolve11, reject) => {
+    return new Promise((resolve12, reject) => {
       this.on(DESTROYED3, () => reject(new Error("stream destroyed")));
       this.on("error", (er) => reject(er));
-      this.on("end", () => resolve11());
+      this.on("end", () => resolve12());
     });
   }
   [Symbol.asyncIterator]() {
@@ -69492,7 +70338,7 @@ class Minipass3 extends EventEmitter5 {
         return Promise.resolve({ done: false, value: res });
       if (this[EOF3])
         return stop();
-      let resolve11;
+      let resolve12;
       let reject;
       const onerr = (er) => {
         this.off("data", ondata);
@@ -69506,19 +70352,19 @@ class Minipass3 extends EventEmitter5 {
         this.off("end", onend);
         this.off(DESTROYED3, ondestroy);
         this.pause();
-        resolve11({ value, done: !!this[EOF3] });
+        resolve12({ value, done: !!this[EOF3] });
       };
       const onend = () => {
         this.off("error", onerr);
         this.off("data", ondata);
         this.off(DESTROYED3, ondestroy);
         stop();
-        resolve11({ done: true, value: undefined });
+        resolve12({ done: true, value: undefined });
       };
       const ondestroy = () => onerr(new Error("stream destroyed"));
       return new Promise((res2, rej) => {
         reject = rej;
-        resolve11 = res2;
+        resolve12 = res2;
         this.once(DESTROYED3, ondestroy);
         this.once("error", onerr);
         this.once("end", onend);
@@ -70289,9 +71135,9 @@ var listFile = (opt, _files) => {
   const parse4 = new Parser(opt);
   const readSize = opt.maxReadSize || 16 * 1024 * 1024;
   const file = opt.file;
-  const p = new Promise((resolve11, reject) => {
+  const p = new Promise((resolve12, reject) => {
     parse4.on("error", reject);
-    parse4.on("end", resolve11);
+    parse4.on("end", resolve12);
     fs9.stat(file, (er, stat10) => {
       if (er) {
         reject(er);
@@ -72054,7 +72900,7 @@ var mkdirSync = (dir, opt) => {
 };
 
 // node_modules/tar/dist/esm/path-reservations.js
-import { join as join57 } from "node:path";
+import { join as join58 } from "node:path";
 
 // node_modules/tar/dist/esm/normalize-unicode.js
 var normalizeCache = Object.create(null);
@@ -72087,7 +72933,7 @@ var getDirs = (path8) => {
   const dirs = path8.split("/").slice(0, -1).reduce((set, path9) => {
     const s = set[set.length - 1];
     if (s !== undefined) {
-      path9 = join57(s, path9);
+      path9 = join58(s, path9);
     }
     set.push(path9 || "/");
     return set;
@@ -72101,7 +72947,7 @@ class PathReservations {
   #running = new Set;
   reserve(paths, fn) {
     paths = isWindows4 ? ["win32 parallelization disabled"] : paths.map((p) => {
-      return stripTrailingSlashes(join57(normalizeUnicode(p))).toLowerCase();
+      return stripTrailingSlashes(join58(normalizeUnicode(p))).toLowerCase();
     });
     const dirs = new Set(paths.map((path8) => getDirs(path8)).reduce((a3, b3) => a3.concat(b3)));
     this.#reservations.set(fn, { dirs, paths });
@@ -72871,9 +73717,9 @@ var extractFile = (opt, _3) => {
   const u = new Unpack(opt);
   const readSize = opt.maxReadSize || 16 * 1024 * 1024;
   const file = opt.file;
-  const p = new Promise((resolve11, reject) => {
+  const p = new Promise((resolve12, reject) => {
     u.on("error", reject);
-    u.on("close", resolve11);
+    u.on("close", resolve12);
     fs16.stat(file, (er, stat10) => {
       if (er) {
         reject(er);
@@ -73006,7 +73852,7 @@ var replaceAsync = (opt, files) => {
     };
     fs17.read(fd, headBuf, 0, 512, position, onread);
   };
-  const promise = new Promise((resolve11, reject) => {
+  const promise = new Promise((resolve12, reject) => {
     p.on("error", reject);
     let flag = "r+";
     const onopen = (er, fd) => {
@@ -73031,7 +73877,7 @@ var replaceAsync = (opt, files) => {
           });
           p.pipe(stream);
           stream.on("error", reject);
-          stream.on("close", resolve11);
+          stream.on("close", resolve12);
           addFilesAsync2(p, files);
         });
       });
@@ -73160,8 +74006,8 @@ function decodeFilePath(path10) {
 // src/domains/installation/utils/file-utils.ts
 init_logger();
 init_types2();
-import { copyFile as copyFile2, lstat as lstat4, mkdir as mkdir17, readdir as readdir10 } from "node:fs/promises";
-import { join as join58, relative as relative6 } from "node:path";
+import { copyFile as copyFile2, lstat as lstat4, mkdir as mkdir17, readdir as readdir11 } from "node:fs/promises";
+import { join as join59, relative as relative6 } from "node:path";
 async function withRetry(fn, retries = 3) {
   for (let i = 0;i < retries; i++) {
     try {
@@ -73181,10 +74027,10 @@ var isRetryable = (e2) => {
 var delay = (ms) => new Promise((r2) => setTimeout(r2, ms));
 async function moveDirectoryContents(sourceDir, destDir, shouldExclude, sizeTracker) {
   await mkdir17(destDir, { recursive: true });
-  const entries = await readdir10(sourceDir, { encoding: "utf8" });
+  const entries = await readdir11(sourceDir, { encoding: "utf8" });
   for (const entry of entries) {
-    const sourcePath = join58(sourceDir, entry);
-    const destPath = join58(destDir, entry);
+    const sourcePath = join59(sourceDir, entry);
+    const destPath = join59(destDir, entry);
     const relativePath = relative6(sourceDir, sourcePath);
     if (!isPathSafe(destDir, destPath)) {
       logger.warning(`Skipping unsafe path: ${relativePath}`);
@@ -73209,10 +74055,10 @@ async function moveDirectoryContents(sourceDir, destDir, shouldExclude, sizeTrac
 }
 async function copyDirectory(sourceDir, destDir, shouldExclude, sizeTracker) {
   await mkdir17(destDir, { recursive: true });
-  const entries = await readdir10(sourceDir, { encoding: "utf8" });
+  const entries = await readdir11(sourceDir, { encoding: "utf8" });
   for (const entry of entries) {
-    const sourcePath = join58(sourceDir, entry);
-    const destPath = join58(destDir, entry);
+    const sourcePath = join59(sourceDir, entry);
+    const destPath = join59(destDir, entry);
     const relativePath = relative6(sourceDir, sourcePath);
     if (!isPathSafe(destDir, destPath)) {
       logger.warning(`Skipping unsafe path: ${relativePath}`);
@@ -73256,14 +74102,14 @@ class TarExtractor {
         }
       });
       logger.debug(`Extracted TAR.GZ to temp: ${tempExtractDir}`);
-      const entries = await readdir11(tempExtractDir, { encoding: "utf8" });
+      const entries = await readdir12(tempExtractDir, { encoding: "utf8" });
       logger.debug(`Root entries: ${entries.join(", ")}`);
       if (entries.length === 1) {
         const rootEntry = entries[0];
-        const rootPath = join59(tempExtractDir, rootEntry);
+        const rootPath = join60(tempExtractDir, rootEntry);
         const rootStat = await stat10(rootPath);
         if (rootStat.isDirectory()) {
-          const rootContents = await readdir11(rootPath, { encoding: "utf8" });
+          const rootContents = await readdir12(rootPath, { encoding: "utf8" });
           logger.debug(`Root directory '${rootEntry}' contains: ${rootContents.join(", ")}`);
           const isWrapper = isWrapperDirectory(rootEntry);
           logger.debug(`Is wrapper directory: ${isWrapper}`);
@@ -73276,7 +74122,7 @@ class TarExtractor {
           }
         } else {
           await mkdir18(destDir, { recursive: true });
-          await copyFile3(rootPath, join59(destDir, rootEntry));
+          await copyFile3(rootPath, join60(destDir, rootEntry));
         }
       } else {
         logger.debug("Multiple root entries - moving all");
@@ -73298,27 +74144,27 @@ init_environment();
 init_logger();
 var import_extract_zip = __toESM(require_extract_zip(), 1);
 import { execFile as execFile8 } from "node:child_process";
-import { copyFile as copyFile4, mkdir as mkdir19, readdir as readdir12, rm as rm4, stat as stat11 } from "node:fs/promises";
-import { join as join60 } from "node:path";
+import { copyFile as copyFile4, mkdir as mkdir19, readdir as readdir13, rm as rm4, stat as stat11 } from "node:fs/promises";
+import { join as join61 } from "node:path";
 class ZipExtractor {
   async tryNativeUnzip(archivePath, destDir) {
     if (!isMacOS()) {
       return false;
     }
-    return new Promise((resolve11) => {
+    return new Promise((resolve12) => {
       mkdir19(destDir, { recursive: true }).then(() => {
         execFile8("unzip", ["-o", "-q", archivePath, "-d", destDir], (error, _stdout, stderr) => {
           if (error) {
             logger.debug(`Native unzip failed: ${stderr || error.message}`);
-            resolve11(false);
+            resolve12(false);
             return;
           }
           logger.debug("Native unzip succeeded");
-          resolve11(true);
+          resolve12(true);
         });
       }).catch((err) => {
         logger.debug(`Failed to create directory for native unzip: ${err.message}`);
-        resolve11(false);
+        resolve12(false);
       });
     });
   }
@@ -73343,14 +74189,14 @@ class ZipExtractor {
         logger.verbose(`Extracted ${extractedCount} files`);
       }
       logger.debug(`Extracted ZIP to temp: ${tempExtractDir}`);
-      const entries = await readdir12(tempExtractDir, { encoding: "utf8" });
+      const entries = await readdir13(tempExtractDir, { encoding: "utf8" });
       logger.debug(`Root entries: ${entries.join(", ")}`);
       if (entries.length === 1) {
         const rootEntry = entries[0];
-        const rootPath = join60(tempExtractDir, rootEntry);
+        const rootPath = join61(tempExtractDir, rootEntry);
         const rootStat = await stat11(rootPath);
         if (rootStat.isDirectory()) {
-          const rootContents = await readdir12(rootPath, { encoding: "utf8" });
+          const rootContents = await readdir13(rootPath, { encoding: "utf8" });
           logger.debug(`Root directory '${rootEntry}' contains: ${rootContents.join(", ")}`);
           const isWrapper = isWrapperDirectory(rootEntry);
           logger.debug(`Is wrapper directory: ${isWrapper}`);
@@ -73363,7 +74209,7 @@ class ZipExtractor {
           }
         } else {
           await mkdir19(destDir, { recursive: true });
-          await copyFile4(rootPath, join60(destDir, rootEntry));
+          await copyFile4(rootPath, join61(destDir, rootEntry));
         }
       } else {
         logger.debug("Multiple root entries - moving all");
@@ -73462,7 +74308,7 @@ class DownloadManager {
   async createTempDir() {
     const timestamp = Date.now();
     const counter = DownloadManager.tempDirCounter++;
-    const primaryTempDir = join61(tmpdir3(), `claudekit-${timestamp}-${counter}`);
+    const primaryTempDir = join62(tmpdir4(), `claudekit-${timestamp}-${counter}`);
     try {
       await mkdir20(primaryTempDir, { recursive: true });
       logger.debug(`Created temp directory: ${primaryTempDir}`);
@@ -73479,7 +74325,7 @@ Solutions:
   2. Set HOME environment variable
   3. Try running from a different directory`);
       }
-      const fallbackTempDir = join61(homeDir, ".claudekit", "tmp", `claudekit-${timestamp}-${counter}`);
+      const fallbackTempDir = join62(homeDir, ".claudekit", "tmp", `claudekit-${timestamp}-${counter}`);
       try {
         await mkdir20(fallbackTempDir, { recursive: true });
         logger.debug(`Created temp directory (fallback): ${fallbackTempDir}`);
@@ -73828,20 +74674,20 @@ async function handleDownload(ctx) {
   };
 }
 // src/commands/init/phases/merge-handler.ts
-import { join as join77 } from "node:path";
+import { join as join78 } from "node:path";
 
 // src/domains/installation/deletion-handler.ts
-import { existsSync as existsSync35, lstatSync as lstatSync3, readdirSync as readdirSync2, rmSync as rmSync2, rmdirSync, unlinkSync as unlinkSync3 } from "node:fs";
-import { dirname as dirname14, join as join64, relative as relative7, resolve as resolve12, sep } from "node:path";
+import { existsSync as existsSync36, lstatSync as lstatSync3, readdirSync as readdirSync2, rmSync as rmSync2, rmdirSync, unlinkSync as unlinkSync3 } from "node:fs";
+import { dirname as dirname14, join as join65, relative as relative7, resolve as resolve13, sep as sep2 } from "node:path";
 
 // src/services/file-operations/manifest/manifest-reader.ts
 init_metadata_migration();
 init_logger();
 init_types2();
 var import_fs_extra8 = __toESM(require_lib3(), 1);
-import { join as join63 } from "node:path";
+import { join as join64 } from "node:path";
 async function readManifest(claudeDir2) {
-  const metadataPath = join63(claudeDir2, "metadata.json");
+  const metadataPath = join64(claudeDir2, "metadata.json");
   if (!await import_fs_extra8.pathExists(metadataPath)) {
     return null;
   }
@@ -74014,12 +74860,12 @@ function shouldDeletePath(path11, metadata) {
 }
 function collectFilesRecursively(dir, baseDir) {
   const results = [];
-  if (!existsSync35(dir))
+  if (!existsSync36(dir))
     return results;
   try {
     const entries = readdirSync2(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join64(dir, entry.name);
+      const fullPath = join65(dir, entry.name);
       const relativePath = relative7(baseDir, fullPath);
       if (entry.isDirectory()) {
         results.push(...collectFilesRecursively(fullPath, baseDir));
@@ -74049,8 +74895,8 @@ function expandGlobPatterns(patterns, claudeDir2) {
 }
 var MAX_CLEANUP_ITERATIONS = 50;
 function cleanupEmptyDirectories(filePath, claudeDir2) {
-  const normalizedClaudeDir = resolve12(claudeDir2);
-  let currentDir = resolve12(dirname14(filePath));
+  const normalizedClaudeDir = resolve13(claudeDir2);
+  let currentDir = resolve13(dirname14(filePath));
   let iterations = 0;
   while (currentDir !== normalizedClaudeDir && currentDir.startsWith(normalizedClaudeDir) && iterations < MAX_CLEANUP_ITERATIONS) {
     iterations++;
@@ -74059,7 +74905,7 @@ function cleanupEmptyDirectories(filePath, claudeDir2) {
       if (entries.length === 0) {
         rmdirSync(currentDir);
         logger.debug(`Removed empty directory: ${currentDir}`);
-        currentDir = resolve12(dirname14(currentDir));
+        currentDir = resolve13(dirname14(currentDir));
       } else {
         break;
       }
@@ -74069,9 +74915,9 @@ function cleanupEmptyDirectories(filePath, claudeDir2) {
   }
 }
 function deletePath(fullPath, claudeDir2) {
-  const normalizedPath = resolve12(fullPath);
-  const normalizedClaudeDir = resolve12(claudeDir2);
-  if (!normalizedPath.startsWith(`${normalizedClaudeDir}${sep}`) && normalizedPath !== normalizedClaudeDir) {
+  const normalizedPath = resolve13(fullPath);
+  const normalizedClaudeDir = resolve13(claudeDir2);
+  if (!normalizedPath.startsWith(`${normalizedClaudeDir}${sep2}`) && normalizedPath !== normalizedClaudeDir) {
     throw new Error(`Path traversal detected: ${fullPath}`);
   }
   try {
@@ -74087,7 +74933,7 @@ function deletePath(fullPath, claudeDir2) {
   }
 }
 async function updateMetadataAfterDeletion(claudeDir2, deletedPaths) {
-  const metadataPath = join64(claudeDir2, "metadata.json");
+  const metadataPath = join65(claudeDir2, "metadata.json");
   if (!await import_fs_extra9.pathExists(metadataPath)) {
     return;
   }
@@ -74142,10 +74988,10 @@ async function handleDeletions(sourceMetadata, claudeDir2) {
   const userMetadata = await readManifest(claudeDir2);
   const result = { deletedPaths: [], preservedPaths: [], errors: [] };
   for (const path11 of deletions) {
-    const fullPath = join64(claudeDir2, path11);
-    const normalizedPath = resolve12(fullPath);
-    const normalizedClaudeDir = resolve12(claudeDir2);
-    if (!normalizedPath.startsWith(`${normalizedClaudeDir}${sep}`)) {
+    const fullPath = join65(claudeDir2, path11);
+    const normalizedPath = resolve13(fullPath);
+    const normalizedClaudeDir = resolve13(claudeDir2);
+    if (!normalizedPath.startsWith(`${normalizedClaudeDir}${sep2}`)) {
       logger.warning(`Skipping invalid path: ${path11}`);
       result.errors.push(path11);
       continue;
@@ -74155,7 +75001,7 @@ async function handleDeletions(sourceMetadata, claudeDir2) {
       logger.verbose(`Preserved user file: ${path11}`);
       continue;
     }
-    if (existsSync35(fullPath)) {
+    if (existsSync36(fullPath)) {
       try {
         deletePath(fullPath, claudeDir2);
         result.deletedPaths.push(path11);
@@ -74182,7 +75028,7 @@ init_logger();
 init_types2();
 var import_fs_extra12 = __toESM(require_lib3(), 1);
 var import_ignore3 = __toESM(require_ignore(), 1);
-import { dirname as dirname16, join as join67, relative as relative9 } from "node:path";
+import { dirname as dirname16, join as join68, relative as relative9 } from "node:path";
 
 // src/domains/installation/selective-merger.ts
 import { stat as stat13 } from "node:fs/promises";
@@ -74361,7 +75207,7 @@ init_logger();
 var import_fs_extra10 = __toESM(require_lib3(), 1);
 var import_ignore2 = __toESM(require_ignore(), 1);
 import { relative as relative8 } from "node:path";
-import { join as join65 } from "node:path";
+import { join as join66 } from "node:path";
 
 // node_modules/@isaacs/balanced-match/dist/esm/index.js
 var balanced = (a3, b3, str2) => {
@@ -75168,8 +76014,8 @@ var path11 = {
   win32: { sep: "\\" },
   posix: { sep: "/" }
 };
-var sep2 = defaultPlatform === "win32" ? path11.win32.sep : path11.posix.sep;
-minimatch.sep = sep2;
+var sep3 = defaultPlatform === "win32" ? path11.win32.sep : path11.posix.sep;
+minimatch.sep = sep3;
 var GLOBSTAR = Symbol("globstar **");
 minimatch.GLOBSTAR = GLOBSTAR;
 var qmark2 = "[^/]";
@@ -75817,7 +76663,7 @@ class FileScanner {
     const files = [];
     const entries = await import_fs_extra10.readdir(dir, { encoding: "utf8" });
     for (const entry of entries) {
-      const fullPath = join65(dir, entry);
+      const fullPath = join66(dir, entry);
       const relativePath = relative8(baseDir, fullPath);
       const normalizedRelativePath = relativePath.replace(/\\/g, "/");
       const stats = await import_fs_extra10.lstat(fullPath);
@@ -75855,9 +76701,9 @@ import { execSync as execSync4 } from "node:child_process";
 
 // src/domains/config/installed-settings-tracker.ts
 init_shared();
-import { existsSync as existsSync36 } from "node:fs";
+import { existsSync as existsSync37 } from "node:fs";
 import { mkdir as mkdir21, readFile as readFile29, writeFile as writeFile17 } from "node:fs/promises";
-import { dirname as dirname15, join as join66 } from "node:path";
+import { dirname as dirname15, join as join67 } from "node:path";
 var CK_JSON_FILE = ".ck.json";
 
 class InstalledSettingsTracker {
@@ -75871,13 +76717,13 @@ class InstalledSettingsTracker {
   }
   getCkJsonPath() {
     if (this.isGlobal) {
-      return join66(this.projectDir, CK_JSON_FILE);
+      return join67(this.projectDir, CK_JSON_FILE);
     }
-    return join66(this.projectDir, ".claude", CK_JSON_FILE);
+    return join67(this.projectDir, ".claude", CK_JSON_FILE);
   }
   async loadInstalledSettings() {
     const ckJsonPath = this.getCkJsonPath();
-    if (!existsSync36(ckJsonPath)) {
+    if (!existsSync37(ckJsonPath)) {
       return { hooks: [], mcpServers: [] };
     }
     try {
@@ -75897,7 +76743,7 @@ class InstalledSettingsTracker {
     const ckJsonPath = this.getCkJsonPath();
     try {
       let data = {};
-      if (existsSync36(ckJsonPath)) {
+      if (existsSync37(ckJsonPath)) {
         const content = await readFile29(ckJsonPath, "utf-8");
         data = JSON.parse(content);
       }
@@ -76304,7 +77150,7 @@ class CopyExecutor {
     for (const file of files) {
       const relativePath = relative9(sourceDir, file);
       const normalizedRelativePath = relativePath.replace(/\\/g, "/");
-      const destPath = join67(destDir, relativePath);
+      const destPath = join68(destDir, relativePath);
       if (await import_fs_extra12.pathExists(destPath)) {
         if (this.fileScanner.shouldNeverCopy(normalizedRelativePath)) {
           logger.debug(`Security-sensitive file exists but won't be overwritten: ${normalizedRelativePath}`);
@@ -76326,7 +77172,7 @@ class CopyExecutor {
     for (const file of files) {
       const relativePath = relative9(sourceDir, file);
       const normalizedRelativePath = relativePath.replace(/\\/g, "/");
-      const destPath = join67(destDir, relativePath);
+      const destPath = join68(destDir, relativePath);
       if (this.fileScanner.shouldNeverCopy(normalizedRelativePath)) {
         logger.debug(`Skipping security-sensitive file: ${normalizedRelativePath}`);
         skippedCount++;
@@ -76495,16 +77341,16 @@ class FileMerger {
 }
 
 // src/domains/migration/legacy-migration.ts
-import { readdir as readdir14, stat as stat14 } from "node:fs/promises";
-import { join as join71, relative as relative10 } from "node:path";
+import { readdir as readdir15, stat as stat14 } from "node:fs/promises";
+import { join as join72, relative as relative10 } from "node:path";
 // src/services/file-operations/manifest/manifest-tracker.ts
-import { join as join70 } from "node:path";
+import { join as join71 } from "node:path";
 
 // src/domains/migration/release-manifest.ts
 init_logger();
 init_zod();
 var import_fs_extra13 = __toESM(require_lib3(), 1);
-import { join as join68 } from "node:path";
+import { join as join69 } from "node:path";
 var ReleaseManifestFileSchema = exports_external.object({
   path: exports_external.string(),
   checksum: exports_external.string().regex(/^[a-f0-9]{64}$/),
@@ -76519,7 +77365,7 @@ var ReleaseManifestSchema = exports_external.object({
 
 class ReleaseManifestLoader {
   static async load(extractDir) {
-    const manifestPath = join68(extractDir, "release-manifest.json");
+    const manifestPath = join69(extractDir, "release-manifest.json");
     try {
       const content = await import_fs_extra13.readFile(manifestPath, "utf-8");
       const parsed = JSON.parse(content);
@@ -76545,9 +77391,9 @@ init_logger();
 init_types2();
 var import_fs_extra14 = __toESM(require_lib3(), 1);
 var import_proper_lockfile2 = __toESM(require_proper_lockfile(), 1);
-import { join as join69 } from "node:path";
+import { join as join70 } from "node:path";
 async function writeManifest(claudeDir2, kitName, version, scope, kitType, trackedFiles, userConfigFiles) {
-  const metadataPath = join69(claudeDir2, "metadata.json");
+  const metadataPath = join70(claudeDir2, "metadata.json");
   const kit = kitType || (/\bmarketing\b/i.test(kitName) ? "marketing" : "engineer");
   await import_fs_extra14.ensureFile(metadataPath);
   let release = null;
@@ -76603,7 +77449,7 @@ async function writeManifest(claudeDir2, kitName, version, scope, kitType, track
   }
 }
 async function removeKitFromManifest(claudeDir2, kit) {
-  const metadataPath = join69(claudeDir2, "metadata.json");
+  const metadataPath = join70(claudeDir2, "metadata.json");
   if (!await import_fs_extra14.pathExists(metadataPath))
     return false;
   let release = null;
@@ -76733,7 +77579,7 @@ function buildFileTrackingList(options2) {
     if (!isGlobal && !installedPath.startsWith(".claude/"))
       continue;
     const relativePath = isGlobal ? installedPath : installedPath.replace(/^\.claude\//, "");
-    const filePath = join70(claudeDir2, relativePath);
+    const filePath = join71(claudeDir2, relativePath);
     const manifestEntry = releaseManifest ? ReleaseManifestLoader.findFile(releaseManifest, installedPath) : null;
     const ownership = manifestEntry ? "ck" : "user";
     filesToTrack.push({
@@ -76823,7 +77669,7 @@ class LegacyMigration {
     const files = [];
     let entries;
     try {
-      entries = await readdir14(dir);
+      entries = await readdir15(dir);
     } catch (err) {
       const error = err;
       if (error.code === "ENOENT") {
@@ -76840,7 +77686,7 @@ class LegacyMigration {
         continue;
       if (SKIP_DIRS_ALL.includes(entry))
         continue;
-      const fullPath = join71(dir, entry);
+      const fullPath = join72(dir, entry);
       let stats;
       try {
         stats = await stat14(fullPath);
@@ -76942,7 +77788,7 @@ User-created files (sample):`);
     ];
     if (filesToChecksum.length > 0) {
       const checksumResults = await mapWithLimit(filesToChecksum, async ({ relativePath, ownership }) => {
-        const fullPath = join71(claudeDir2, relativePath);
+        const fullPath = join72(claudeDir2, relativePath);
         const checksum = await OwnershipChecker.calculateChecksum(fullPath);
         return { relativePath, checksum, ownership };
       });
@@ -76963,7 +77809,7 @@ User-created files (sample):`);
       installedAt: new Date().toISOString(),
       files: trackedFiles
     };
-    const metadataPath = join71(claudeDir2, "metadata.json");
+    const metadataPath = join72(claudeDir2, "metadata.json");
     await import_fs_extra15.writeFile(metadataPath, JSON.stringify(updatedMetadata, null, 2));
     logger.success(`Migration complete: tracked ${trackedFiles.length} files`);
     return true;
@@ -77069,7 +77915,7 @@ function buildConflictSummary(fileConflicts, hookConflicts, mcpConflicts) {
 init_logger();
 init_skip_directories();
 var import_fs_extra16 = __toESM(require_lib3(), 1);
-import { join as join72, relative as relative11, resolve as resolve13 } from "node:path";
+import { join as join73, relative as relative11, resolve as resolve14 } from "node:path";
 
 class FileScanner2 {
   static async getFiles(dirPath, relativeTo) {
@@ -77085,7 +77931,7 @@ class FileScanner2 {
           logger.debug(`Skipping directory: ${entry}`);
           continue;
         }
-        const fullPath = join72(dirPath, entry);
+        const fullPath = join73(dirPath, entry);
         if (!FileScanner2.isSafePath(basePath, fullPath)) {
           logger.warning(`Skipping potentially unsafe path: ${entry}`);
           continue;
@@ -77120,8 +77966,8 @@ class FileScanner2 {
     return files;
   }
   static async findCustomFiles(destDir, sourceDir, subPath) {
-    const destSubDir = join72(destDir, subPath);
-    const sourceSubDir = join72(sourceDir, subPath);
+    const destSubDir = join73(destDir, subPath);
+    const sourceSubDir = join73(sourceDir, subPath);
     logger.debug(`findCustomFiles - destDir: ${destDir}`);
     logger.debug(`findCustomFiles - sourceDir: ${sourceDir}`);
     logger.debug(`findCustomFiles - subPath: "${subPath}"`);
@@ -77149,8 +77995,8 @@ class FileScanner2 {
     return customFiles;
   }
   static isSafePath(basePath, targetPath) {
-    const resolvedBase = resolve13(basePath);
-    const resolvedTarget = resolve13(targetPath);
+    const resolvedBase = resolve14(basePath);
+    const resolvedTarget = resolve14(targetPath);
     return resolvedTarget.startsWith(resolvedBase);
   }
   static toPosixPath(path12) {
@@ -77161,13 +78007,13 @@ class FileScanner2 {
 // src/services/transformers/commands-prefix/prefix-applier.ts
 init_logger();
 var import_fs_extra17 = __toESM(require_lib3(), 1);
-import { lstat as lstat7, mkdir as mkdir22, readdir as readdir17, stat as stat15 } from "node:fs/promises";
-import { join as join74 } from "node:path";
+import { lstat as lstat7, mkdir as mkdir22, readdir as readdir18, stat as stat15 } from "node:fs/promises";
+import { join as join75 } from "node:path";
 
 // src/services/transformers/commands-prefix/content-transformer.ts
 init_logger();
-import { readFile as readFile33, readdir as readdir16, writeFile as writeFile21 } from "node:fs/promises";
-import { join as join73 } from "node:path";
+import { readFile as readFile33, readdir as readdir17, writeFile as writeFile21 } from "node:fs/promises";
+import { join as join74 } from "node:path";
 var TRANSFORMABLE_EXTENSIONS = new Set([
   ".md",
   ".txt",
@@ -77226,9 +78072,9 @@ async function transformCommandReferences(directory, options2 = {}) {
   let filesTransformed = 0;
   let totalReplacements = 0;
   async function processDirectory(dir) {
-    const entries = await readdir16(dir, { withFileTypes: true });
+    const entries = await readdir17(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join73(dir, entry.name);
+      const fullPath = join74(dir, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name.startsWith(".") && entry.name !== ".claude") {
           continue;
@@ -77303,22 +78149,22 @@ function shouldApplyPrefix(options2) {
 // src/services/transformers/commands-prefix/prefix-applier.ts
 async function applyPrefix(extractDir) {
   validatePath(extractDir, "extractDir");
-  const commandsDir = join74(extractDir, ".claude", "commands");
+  const commandsDir = join75(extractDir, ".claude", "commands");
   if (!await import_fs_extra17.pathExists(commandsDir)) {
     logger.verbose("No commands directory found, skipping prefix application");
     return;
   }
   logger.info("Applying /ck: prefix to slash commands...");
-  const backupDir = join74(extractDir, ".commands-backup");
-  const tempDir = join74(extractDir, ".commands-prefix-temp");
+  const backupDir = join75(extractDir, ".commands-backup");
+  const tempDir = join75(extractDir, ".commands-prefix-temp");
   try {
-    const entries = await readdir17(commandsDir);
+    const entries = await readdir18(commandsDir);
     if (entries.length === 0) {
       logger.verbose("Commands directory is empty, skipping prefix application");
       return;
     }
     if (entries.length === 1 && entries[0] === "ck") {
-      const ckDir2 = join74(commandsDir, "ck");
+      const ckDir2 = join75(commandsDir, "ck");
       const ckStat = await stat15(ckDir2);
       if (ckStat.isDirectory()) {
         logger.verbose("Commands already have /ck: prefix, skipping");
@@ -77328,17 +78174,17 @@ async function applyPrefix(extractDir) {
     await import_fs_extra17.copy(commandsDir, backupDir);
     logger.verbose("Created backup of commands directory");
     await mkdir22(tempDir, { recursive: true });
-    const ckDir = join74(tempDir, "ck");
+    const ckDir = join75(tempDir, "ck");
     await mkdir22(ckDir, { recursive: true });
     let processedCount = 0;
     for (const entry of entries) {
-      const sourcePath = join74(commandsDir, entry);
+      const sourcePath = join75(commandsDir, entry);
       const stats = await lstat7(sourcePath);
       if (stats.isSymbolicLink()) {
         logger.warning(`Skipping symlink for security: ${entry}`);
         continue;
       }
-      const destPath = join74(ckDir, entry);
+      const destPath = join75(ckDir, entry);
       await import_fs_extra17.copy(sourcePath, destPath, {
         overwrite: false,
         errorOnExist: true
@@ -77356,7 +78202,7 @@ async function applyPrefix(extractDir) {
     await import_fs_extra17.move(tempDir, commandsDir);
     await import_fs_extra17.remove(backupDir);
     logger.success("Successfully reorganized commands to /ck: prefix");
-    const claudeDir2 = join74(extractDir, ".claude");
+    const claudeDir2 = join75(extractDir, ".claude");
     logger.info("Transforming command references in file contents...");
     const transformResult = await transformCommandReferences(claudeDir2, {
       verbose: logger.isVerbose()
@@ -77393,21 +78239,21 @@ async function applyPrefix(extractDir) {
 
 // src/services/transformers/commands-prefix/prefix-cleaner.ts
 init_metadata_migration();
-import { lstat as lstat9, readdir as readdir19 } from "node:fs/promises";
-import { join as join76 } from "node:path";
+import { lstat as lstat9, readdir as readdir20 } from "node:fs/promises";
+import { join as join77 } from "node:path";
 init_logger();
 var import_fs_extra19 = __toESM(require_lib3(), 1);
 
 // src/services/transformers/commands-prefix/file-processor.ts
-import { lstat as lstat8, readdir as readdir18 } from "node:fs/promises";
-import { join as join75 } from "node:path";
+import { lstat as lstat8, readdir as readdir19 } from "node:fs/promises";
+import { join as join76 } from "node:path";
 init_logger();
 var import_fs_extra18 = __toESM(require_lib3(), 1);
 async function scanDirectoryFiles(dir) {
   const files = [];
-  const entries = await readdir18(dir);
+  const entries = await readdir19(dir);
   for (const entry of entries) {
-    const fullPath = join75(dir, entry);
+    const fullPath = join76(dir, entry);
     const stats = await lstat8(fullPath);
     if (stats.isSymbolicLink()) {
       continue;
@@ -77535,8 +78381,8 @@ function isDifferentKitDirectory(dirName, currentKit) {
 async function cleanupCommandsDirectory(targetDir, isGlobal, options2 = {}) {
   const { dryRun = false } = options2;
   validatePath(targetDir, "targetDir");
-  const claudeDir2 = isGlobal ? targetDir : join76(targetDir, ".claude");
-  const commandsDir = join76(claudeDir2, "commands");
+  const claudeDir2 = isGlobal ? targetDir : join77(targetDir, ".claude");
+  const commandsDir = join77(claudeDir2, "commands");
   const accumulator = {
     results: [],
     deletedCount: 0,
@@ -77571,14 +78417,14 @@ async function cleanupCommandsDirectory(targetDir, isGlobal, options2 = {}) {
   if (options2.kitType) {
     logger.verbose(`Kit-aware cleanup: only cleaning files owned by '${options2.kitType}'`);
   }
-  const entries = await readdir19(commandsDir);
+  const entries = await readdir20(commandsDir);
   if (entries.length === 0) {
     logger.verbose("Commands directory is empty");
     return result;
   }
   const metadataForChecks = options2.kitType ? createKitSpecificMetadata(metadata, options2.kitType) : metadata;
   for (const entry of entries) {
-    const entryPath = join76(commandsDir, entry);
+    const entryPath = join77(commandsDir, entry);
     const stats = await lstat9(entryPath);
     if (stats.isSymbolicLink()) {
       addSymlinkSkip(entry, accumulator);
@@ -77635,7 +78481,7 @@ async function handleMerge(ctx) {
   let customClaudeFiles = [];
   if (!ctx.options.fresh) {
     logger.info("Scanning for custom .claude files...");
-    const scanSourceDir = ctx.options.global ? join77(ctx.extractDir, ".claude") : ctx.extractDir;
+    const scanSourceDir = ctx.options.global ? join78(ctx.extractDir, ".claude") : ctx.extractDir;
     const scanTargetSubdir = ctx.options.global ? "" : ".claude";
     customClaudeFiles = await FileScanner2.findCustomFiles(ctx.resolvedDir, scanSourceDir, scanTargetSubdir);
   } else {
@@ -77700,7 +78546,7 @@ async function handleMerge(ctx) {
       return { ...ctx, cancelled: true };
     }
   }
-  const sourceDir = ctx.options.global ? join77(ctx.extractDir, ".claude") : ctx.extractDir;
+  const sourceDir = ctx.options.global ? join78(ctx.extractDir, ".claude") : ctx.extractDir;
   await merger.merge(sourceDir, ctx.resolvedDir, ctx.isNonInteractive);
   const fileConflicts = merger.getFileConflicts();
   if (fileConflicts.length > 0 && !ctx.isNonInteractive) {
@@ -77708,7 +78554,7 @@ async function handleMerge(ctx) {
     displayConflictSummary(summary);
   }
   try {
-    const sourceMetadataPath = ctx.options.global ? join77(sourceDir, "metadata.json") : join77(sourceDir, ".claude", "metadata.json");
+    const sourceMetadataPath = ctx.options.global ? join78(sourceDir, "metadata.json") : join78(sourceDir, ".claude", "metadata.json");
     if (await import_fs_extra20.pathExists(sourceMetadataPath)) {
       const metadataContent = await import_fs_extra20.readFile(sourceMetadataPath, "utf-8");
       const sourceMetadata = JSON.parse(metadataContent);
@@ -77752,7 +78598,7 @@ async function handleMerge(ctx) {
   };
 }
 // src/commands/init/phases/migration-handler.ts
-import { join as join85 } from "node:path";
+import { join as join86 } from "node:path";
 
 // src/domains/skills/skills-detector.ts
 init_logger();
@@ -77767,8 +78613,8 @@ init_skip_directories();
 init_types2();
 var import_fs_extra21 = __toESM(require_lib3(), 1);
 import { createHash as createHash2 } from "node:crypto";
-import { readFile as readFile35, readdir as readdir20, writeFile as writeFile22 } from "node:fs/promises";
-import { join as join78, relative as relative12 } from "node:path";
+import { readFile as readFile35, readdir as readdir21, writeFile as writeFile22 } from "node:fs/promises";
+import { join as join79, relative as relative12 } from "node:path";
 
 class SkillsManifestManager {
   static MANIFEST_FILENAME = ".skills-manifest.json";
@@ -77790,12 +78636,12 @@ class SkillsManifestManager {
     return manifest;
   }
   static async writeManifest(skillsDir2, manifest) {
-    const manifestPath = join78(skillsDir2, SkillsManifestManager.MANIFEST_FILENAME);
+    const manifestPath = join79(skillsDir2, SkillsManifestManager.MANIFEST_FILENAME);
     await writeFile22(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
     logger.debug(`Wrote manifest to: ${manifestPath}`);
   }
   static async readManifest(skillsDir2) {
-    const manifestPath = join78(skillsDir2, SkillsManifestManager.MANIFEST_FILENAME);
+    const manifestPath = join79(skillsDir2, SkillsManifestManager.MANIFEST_FILENAME);
     if (!await import_fs_extra21.pathExists(manifestPath)) {
       logger.debug(`No manifest found at: ${manifestPath}`);
       return null;
@@ -77812,14 +78658,14 @@ class SkillsManifestManager {
     }
   }
   static async detectStructure(skillsDir2) {
-    const entries = await readdir20(skillsDir2, { withFileTypes: true });
+    const entries = await readdir21(skillsDir2, { withFileTypes: true });
     const dirs = entries.filter((entry) => entry.isDirectory() && !BUILD_ARTIFACT_DIRS.includes(entry.name) && !entry.name.startsWith("."));
     if (dirs.length === 0) {
       return "flat";
     }
     for (const dir of dirs.slice(0, 3)) {
-      const dirPath = join78(skillsDir2, dir.name);
-      const subEntries = await readdir20(dirPath, { withFileTypes: true });
+      const dirPath = join79(skillsDir2, dir.name);
+      const subEntries = await readdir21(dirPath, { withFileTypes: true });
       const hasSubdirs = subEntries.some((entry) => entry.isDirectory());
       if (hasSubdirs) {
         return "categorized";
@@ -77834,10 +78680,10 @@ class SkillsManifestManager {
   static async scanSkills(skillsDir2, structure) {
     const skills = [];
     if (structure === "flat") {
-      const entries = await readdir20(skillsDir2, { withFileTypes: true });
+      const entries = await readdir21(skillsDir2, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isDirectory() && !BUILD_ARTIFACT_DIRS.includes(entry.name) && !entry.name.startsWith(".")) {
-          const skillPath = join78(skillsDir2, entry.name);
+          const skillPath = join79(skillsDir2, entry.name);
           const hash = await SkillsManifestManager.hashDirectory(skillPath);
           skills.push({
             name: entry.name,
@@ -77846,14 +78692,14 @@ class SkillsManifestManager {
         }
       }
     } else {
-      const categories = await readdir20(skillsDir2, { withFileTypes: true });
+      const categories = await readdir21(skillsDir2, { withFileTypes: true });
       for (const category of categories) {
         if (category.isDirectory() && !BUILD_ARTIFACT_DIRS.includes(category.name) && !category.name.startsWith(".")) {
-          const categoryPath = join78(skillsDir2, category.name);
-          const skillEntries = await readdir20(categoryPath, { withFileTypes: true });
+          const categoryPath = join79(skillsDir2, category.name);
+          const skillEntries = await readdir21(categoryPath, { withFileTypes: true });
           for (const skillEntry of skillEntries) {
             if (skillEntry.isDirectory() && !skillEntry.name.startsWith(".")) {
-              const skillPath = join78(categoryPath, skillEntry.name);
+              const skillPath = join79(categoryPath, skillEntry.name);
               const hash = await SkillsManifestManager.hashDirectory(skillPath);
               skills.push({
                 name: skillEntry.name,
@@ -77881,9 +78727,9 @@ class SkillsManifestManager {
   }
   static async getAllFiles(dirPath) {
     const files = [];
-    const entries = await readdir20(dirPath, { withFileTypes: true });
+    const entries = await readdir21(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join78(dirPath, entry.name);
+      const fullPath = join79(dirPath, entry.name);
       if (entry.name.startsWith(".") || BUILD_ARTIFACT_DIRS.includes(entry.name)) {
         continue;
       }
@@ -78004,13 +78850,13 @@ function getPathMapping(skillName, oldBasePath, newBasePath) {
 
 // src/domains/skills/detection/script-detector.ts
 var import_fs_extra22 = __toESM(require_lib3(), 1);
-import { readdir as readdir21 } from "node:fs/promises";
-import { join as join79 } from "node:path";
+import { readdir as readdir22 } from "node:fs/promises";
+import { join as join80 } from "node:path";
 async function scanDirectory(skillsDir2) {
   if (!await import_fs_extra22.pathExists(skillsDir2)) {
     return ["flat", []];
   }
-  const entries = await readdir21(skillsDir2, { withFileTypes: true });
+  const entries = await readdir22(skillsDir2, { withFileTypes: true });
   const dirs = entries.filter((entry) => entry.isDirectory() && entry.name !== "node_modules" && !entry.name.startsWith("."));
   if (dirs.length === 0) {
     return ["flat", []];
@@ -78018,13 +78864,13 @@ async function scanDirectory(skillsDir2) {
   let totalSkillLikeCount = 0;
   const allSkills = [];
   for (const dir of dirs) {
-    const dirPath = join79(skillsDir2, dir.name);
-    const subEntries = await readdir21(dirPath, { withFileTypes: true });
+    const dirPath = join80(skillsDir2, dir.name);
+    const subEntries = await readdir22(dirPath, { withFileTypes: true });
     const subdirs = subEntries.filter((entry) => entry.isDirectory() && !entry.name.startsWith("."));
     if (subdirs.length > 0) {
       for (const subdir of subdirs.slice(0, 3)) {
-        const subdirPath = join79(dirPath, subdir.name);
-        const subdirFiles = await readdir21(subdirPath, { withFileTypes: true });
+        const subdirPath = join80(dirPath, subdir.name);
+        const subdirFiles = await readdir22(subdirPath, { withFileTypes: true });
         const hasSkillMarker = subdirFiles.some((file) => file.isFile() && (file.name === "skill.md" || file.name === "README.md" || file.name === "readme.md" || file.name === "config.json" || file.name === "package.json"));
         if (hasSkillMarker) {
           totalSkillLikeCount++;
@@ -78180,12 +79026,12 @@ class SkillsMigrationDetector {
 // src/domains/skills/skills-migrator.ts
 init_logger();
 init_types2();
-import { join as join84 } from "node:path";
+import { join as join85 } from "node:path";
 
 // src/domains/skills/migrator/migration-executor.ts
 init_logger();
-import { copyFile as copyFile5, mkdir as mkdir23, readdir as readdir22, rm as rm5 } from "node:fs/promises";
-import { join as join80 } from "node:path";
+import { copyFile as copyFile5, mkdir as mkdir23, readdir as readdir23, rm as rm5 } from "node:fs/promises";
+import { join as join81 } from "node:path";
 var import_fs_extra24 = __toESM(require_lib3(), 1);
 
 // src/domains/skills/skills-migration-prompts.ts
@@ -78348,10 +79194,10 @@ Detected changes:`;
 // src/domains/skills/migrator/migration-executor.ts
 async function copySkillDirectory(sourceDir, destDir) {
   await mkdir23(destDir, { recursive: true });
-  const entries = await readdir22(sourceDir, { withFileTypes: true });
+  const entries = await readdir23(sourceDir, { withFileTypes: true });
   for (const entry of entries) {
-    const sourcePath = join80(sourceDir, entry.name);
-    const destPath = join80(destDir, entry.name);
+    const sourcePath = join81(sourceDir, entry.name);
+    const destPath = join81(destDir, entry.name);
     if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.isSymbolicLink()) {
       continue;
     }
@@ -78366,7 +79212,7 @@ async function executeInternal(mappings, customizations, currentSkillsDir, inter
   const migrated = [];
   const preserved = [];
   const errors2 = [];
-  const tempDir = join80(currentSkillsDir, "..", ".skills-migration-temp");
+  const tempDir = join81(currentSkillsDir, "..", ".skills-migration-temp");
   await mkdir23(tempDir, { recursive: true });
   try {
     for (const mapping of mappings) {
@@ -78387,9 +79233,9 @@ async function executeInternal(mappings, customizations, currentSkillsDir, inter
           }
         }
         const category = mapping.category;
-        const targetPath = category ? join80(tempDir, category, skillName) : join80(tempDir, skillName);
+        const targetPath = category ? join81(tempDir, category, skillName) : join81(tempDir, skillName);
         if (category) {
-          await mkdir23(join80(tempDir, category), { recursive: true });
+          await mkdir23(join81(tempDir, category), { recursive: true });
         }
         await copySkillDirectory(currentSkillPath, targetPath);
         migrated.push(skillName);
@@ -78455,8 +79301,8 @@ function validateMigrationPath(path12, paramName) {
 init_logger();
 init_types2();
 var import_fs_extra25 = __toESM(require_lib3(), 1);
-import { copyFile as copyFile6, mkdir as mkdir24, readdir as readdir23, rm as rm6, stat as stat16 } from "node:fs/promises";
-import { basename as basename8, join as join81, normalize as normalize8 } from "node:path";
+import { copyFile as copyFile6, mkdir as mkdir24, readdir as readdir24, rm as rm6, stat as stat16 } from "node:fs/promises";
+import { basename as basename8, join as join82, normalize as normalize8 } from "node:path";
 function validatePath2(path12, paramName) {
   if (!path12 || typeof path12 !== "string") {
     throw new SkillsMigrationError(`${paramName} must be a non-empty string`);
@@ -78482,7 +79328,7 @@ class SkillsBackupManager {
     const timestamp = Date.now();
     const randomSuffix = Math.random().toString(36).substring(2, 8);
     const backupDirName = `${SkillsBackupManager.BACKUP_PREFIX}${timestamp}-${randomSuffix}`;
-    const backupDir = parentDir ? join81(parentDir, backupDirName) : join81(skillsDir2, "..", backupDirName);
+    const backupDir = parentDir ? join82(parentDir, backupDirName) : join82(skillsDir2, "..", backupDirName);
     logger.info(`Creating backup at: ${backupDir}`);
     try {
       await mkdir24(backupDir, { recursive: true });
@@ -78532,8 +79378,8 @@ class SkillsBackupManager {
       return [];
     }
     try {
-      const entries = await readdir23(parentDir, { withFileTypes: true });
-      const backups = entries.filter((entry) => entry.isDirectory() && entry.name.startsWith(SkillsBackupManager.BACKUP_PREFIX)).map((entry) => join81(parentDir, entry.name));
+      const entries = await readdir24(parentDir, { withFileTypes: true });
+      const backups = entries.filter((entry) => entry.isDirectory() && entry.name.startsWith(SkillsBackupManager.BACKUP_PREFIX)).map((entry) => join82(parentDir, entry.name));
       backups.sort().reverse();
       return backups;
     } catch (error) {
@@ -78559,10 +79405,10 @@ class SkillsBackupManager {
     return await SkillsBackupManager.getDirectorySize(backupDir);
   }
   static async copyDirectory(sourceDir, destDir) {
-    const entries = await readdir23(sourceDir, { withFileTypes: true });
+    const entries = await readdir24(sourceDir, { withFileTypes: true });
     for (const entry of entries) {
-      const sourcePath = join81(sourceDir, entry.name);
-      const destPath = join81(destDir, entry.name);
+      const sourcePath = join82(sourceDir, entry.name);
+      const destPath = join82(destDir, entry.name);
       if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.isSymbolicLink()) {
         continue;
       }
@@ -78576,9 +79422,9 @@ class SkillsBackupManager {
   }
   static async getDirectorySize(dirPath) {
     let size = 0;
-    const entries = await readdir23(dirPath, { withFileTypes: true });
+    const entries = await readdir24(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join81(dirPath, entry.name);
+      const fullPath = join82(dirPath, entry.name);
       if (entry.isSymbolicLink()) {
         continue;
       }
@@ -78613,13 +79459,13 @@ import { relative as relative14 } from "node:path";
 init_skip_directories();
 import { createHash as createHash3 } from "node:crypto";
 import { createReadStream as createReadStream3 } from "node:fs";
-import { readFile as readFile36, readdir as readdir24 } from "node:fs/promises";
-import { join as join82, relative as relative13 } from "node:path";
+import { readFile as readFile36, readdir as readdir25 } from "node:fs/promises";
+import { join as join83, relative as relative13 } from "node:path";
 async function getAllFiles(dirPath) {
   const files = [];
-  const entries = await readdir24(dirPath, { withFileTypes: true });
+  const entries = await readdir25(dirPath, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = join82(dirPath, entry.name);
+    const fullPath = join83(dirPath, entry.name);
     if (entry.name.startsWith(".") || BUILD_ARTIFACT_DIRS.includes(entry.name) || entry.isSymbolicLink()) {
       continue;
     }
@@ -78633,12 +79479,12 @@ async function getAllFiles(dirPath) {
   return files;
 }
 async function hashFile(filePath) {
-  return new Promise((resolve14, reject) => {
+  return new Promise((resolve15, reject) => {
     const hash = createHash3("sha256");
     const stream = createReadStream3(filePath);
     stream.on("data", (chunk) => hash.update(chunk));
     stream.on("end", () => {
-      resolve14(hash.digest("hex"));
+      resolve15(hash.digest("hex"));
     });
     stream.on("error", (error) => {
       stream.destroy();
@@ -78745,8 +79591,8 @@ async function detectFileChanges(currentSkillPath, baselineSkillPath) {
 // src/domains/skills/customization/scan-reporter.ts
 init_types2();
 var import_fs_extra27 = __toESM(require_lib3(), 1);
-import { readdir as readdir25 } from "node:fs/promises";
-import { join as join83, normalize as normalize9 } from "node:path";
+import { readdir as readdir26 } from "node:fs/promises";
+import { join as join84, normalize as normalize9 } from "node:path";
 function validatePath3(path12, paramName) {
   if (!path12 || typeof path12 !== "string") {
     throw new SkillsMigrationError(`${paramName} must be a non-empty string`);
@@ -78762,19 +79608,19 @@ async function scanSkillsDirectory(skillsDir2) {
   if (!await import_fs_extra27.pathExists(skillsDir2)) {
     return ["flat", []];
   }
-  const entries = await readdir25(skillsDir2, { withFileTypes: true });
+  const entries = await readdir26(skillsDir2, { withFileTypes: true });
   const dirs = entries.filter((entry) => entry.isDirectory() && entry.name !== "node_modules" && !entry.name.startsWith("."));
   if (dirs.length === 0) {
     return ["flat", []];
   }
-  const firstDirPath = join83(skillsDir2, dirs[0].name);
-  const subEntries = await readdir25(firstDirPath, { withFileTypes: true });
+  const firstDirPath = join84(skillsDir2, dirs[0].name);
+  const subEntries = await readdir26(firstDirPath, { withFileTypes: true });
   const subdirs = subEntries.filter((entry) => entry.isDirectory() && !entry.name.startsWith("."));
   if (subdirs.length > 0) {
     let skillLikeCount = 0;
     for (const subdir of subdirs.slice(0, 3)) {
-      const subdirPath = join83(firstDirPath, subdir.name);
-      const subdirFiles = await readdir25(subdirPath, { withFileTypes: true });
+      const subdirPath = join84(firstDirPath, subdir.name);
+      const subdirFiles = await readdir26(subdirPath, { withFileTypes: true });
       const hasSkillMarker = subdirFiles.some((file) => file.isFile() && (file.name === "skill.md" || file.name === "README.md" || file.name === "readme.md" || file.name === "config.json" || file.name === "package.json"));
       if (hasSkillMarker) {
         skillLikeCount++;
@@ -78783,8 +79629,8 @@ async function scanSkillsDirectory(skillsDir2) {
     if (skillLikeCount > 0) {
       const skills = [];
       for (const dir of dirs) {
-        const categoryPath = join83(skillsDir2, dir.name);
-        const skillDirs = await readdir25(categoryPath, { withFileTypes: true });
+        const categoryPath = join84(skillsDir2, dir.name);
+        const skillDirs = await readdir26(categoryPath, { withFileTypes: true });
         skills.push(...skillDirs.filter((entry) => entry.isDirectory() && !entry.name.startsWith(".")).map((entry) => entry.name));
       }
       return ["categorized", skills];
@@ -78793,17 +79639,17 @@ async function scanSkillsDirectory(skillsDir2) {
   return ["flat", dirs.map((dir) => dir.name)];
 }
 async function findSkillPath(skillsDir2, skillName) {
-  const flatPath = join83(skillsDir2, skillName);
+  const flatPath = join84(skillsDir2, skillName);
   if (await import_fs_extra27.pathExists(flatPath)) {
     return { path: flatPath, category: undefined };
   }
-  const entries = await readdir25(skillsDir2, { withFileTypes: true });
+  const entries = await readdir26(skillsDir2, { withFileTypes: true });
   for (const entry of entries) {
     if (!entry.isDirectory() || entry.name.startsWith(".") || entry.name === "node_modules") {
       continue;
     }
-    const categoryPath = join83(skillsDir2, entry.name);
-    const skillPath = join83(categoryPath, skillName);
+    const categoryPath = join84(skillsDir2, entry.name);
+    const skillPath = join84(categoryPath, skillName);
     if (await import_fs_extra27.pathExists(skillPath)) {
       return { path: skillPath, category: entry.name };
     }
@@ -78897,7 +79743,7 @@ class SkillsMigrator {
         }
       }
       if (options2.backup && !options2.dryRun) {
-        const claudeDir2 = join84(currentSkillsDir, "..");
+        const claudeDir2 = join85(currentSkillsDir, "..");
         result.backupPath = await SkillsBackupManager.createBackup(currentSkillsDir, claudeDir2);
         logger.success(`Backup created at: ${result.backupPath}`);
       }
@@ -78958,7 +79804,7 @@ async function handleMigration(ctx) {
     logger.debug("Skipping skills migration (fresh installation)");
     return ctx;
   }
-  const newSkillsDir = join85(ctx.extractDir, ".claude", "skills");
+  const newSkillsDir = join86(ctx.extractDir, ".claude", "skills");
   const currentSkillsDir = PathResolver.buildSkillsPath(ctx.resolvedDir, ctx.options.global);
   if (!await import_fs_extra28.pathExists(newSkillsDir) || !await import_fs_extra28.pathExists(currentSkillsDir)) {
     return ctx;
@@ -78981,14 +79827,14 @@ async function handleMigration(ctx) {
   return ctx;
 }
 // src/commands/init/phases/opencode-handler.ts
-import { cp as cp2, readdir as readdir27, rm as rm7 } from "node:fs/promises";
-import { join as join87 } from "node:path";
+import { cp as cp2, readdir as readdir28, rm as rm7 } from "node:fs/promises";
+import { join as join88 } from "node:path";
 
 // src/services/transformers/opencode-path-transformer.ts
 init_logger();
-import { readFile as readFile37, readdir as readdir26, writeFile as writeFile23 } from "node:fs/promises";
+import { readFile as readFile37, readdir as readdir27, writeFile as writeFile23 } from "node:fs/promises";
 import { platform as platform12 } from "node:os";
-import { extname as extname3, join as join86 } from "node:path";
+import { extname as extname3, join as join87 } from "node:path";
 var IS_WINDOWS3 = platform12() === "win32";
 function getOpenCodeGlobalPath() {
   return "$HOME/.config/opencode/";
@@ -79047,9 +79893,9 @@ async function transformPathsForGlobalOpenCode(directory, options2 = {}) {
   let totalChanges = 0;
   let filesSkipped = 0;
   async function processDirectory2(dir) {
-    const entries = await readdir26(dir, { withFileTypes: true });
+    const entries = await readdir27(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join86(dir, entry.name);
+      const fullPath = join87(dir, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name.startsWith(".")) {
           continue;
@@ -79088,7 +79934,7 @@ async function handleOpenCode(ctx) {
   if (ctx.cancelled || !ctx.extractDir || !ctx.resolvedDir) {
     return ctx;
   }
-  const openCodeSource = join87(ctx.extractDir, ".opencode");
+  const openCodeSource = join88(ctx.extractDir, ".opencode");
   if (!await import_fs_extra29.pathExists(openCodeSource)) {
     logger.debug("No .opencode directory in archive, skipping");
     return ctx;
@@ -79104,10 +79950,10 @@ async function handleOpenCode(ctx) {
       logger.success(`Transformed ${transformResult.totalChanges} OpenCode path(s) in ${transformResult.filesTransformed} file(s)`);
     }
     await import_fs_extra29.ensureDir(targetDir);
-    const entries = await readdir27(openCodeSource, { withFileTypes: true });
+    const entries = await readdir28(openCodeSource, { withFileTypes: true });
     for (const entry of entries) {
-      const sourcePath = join87(openCodeSource, entry.name);
-      const targetPath = join87(targetDir, entry.name);
+      const sourcePath = join88(openCodeSource, entry.name);
+      const targetPath = join88(targetDir, entry.name);
       if (await import_fs_extra29.pathExists(targetPath)) {
         if (!ctx.options.forceOverwrite) {
           logger.verbose(`Skipping existing: ${entry.name}`);
@@ -79200,7 +80046,7 @@ Please use only one download method.`);
 }
 // src/commands/init/phases/post-install-handler.ts
 init_projects_registry();
-import { join as join88 } from "node:path";
+import { join as join89 } from "node:path";
 init_logger();
 init_path_resolver();
 var import_fs_extra30 = __toESM(require_lib3(), 1);
@@ -79209,8 +80055,8 @@ async function handlePostInstall(ctx) {
     return ctx;
   }
   if (ctx.options.global) {
-    const claudeMdSource = join88(ctx.extractDir, "CLAUDE.md");
-    const claudeMdDest = join88(ctx.resolvedDir, "CLAUDE.md");
+    const claudeMdSource = join89(ctx.extractDir, "CLAUDE.md");
+    const claudeMdDest = join89(ctx.resolvedDir, "CLAUDE.md");
     if (await import_fs_extra30.pathExists(claudeMdSource)) {
       if (!await import_fs_extra30.pathExists(claudeMdDest)) {
         await import_fs_extra30.copy(claudeMdSource, claudeMdDest);
@@ -79258,7 +80104,7 @@ async function handlePostInstall(ctx) {
   }
   if (!ctx.options.skipSetup) {
     await promptSetupWizardIfNeeded({
-      envPath: join88(ctx.claudeDir, ".env"),
+      envPath: join89(ctx.claudeDir, ".env"),
       claudeDir: ctx.claudeDir,
       isGlobal: ctx.options.global,
       isNonInteractive: ctx.isNonInteractive,
@@ -79282,7 +80128,7 @@ async function handlePostInstall(ctx) {
 init_config_manager();
 init_github_client();
 import { mkdir as mkdir25 } from "node:fs/promises";
-import { join as join90, resolve as resolve15 } from "node:path";
+import { join as join91, resolve as resolve16 } from "node:path";
 
 // src/domains/github/kit-access-checker.ts
 init_logger();
@@ -79412,8 +80258,8 @@ async function runPreflightChecks() {
 
 // src/domains/installation/fresh-installer.ts
 init_metadata_migration();
-import { existsSync as existsSync37, readdirSync as readdirSync3, rmSync as rmSync3, rmdirSync as rmdirSync2, unlinkSync as unlinkSync4 } from "node:fs";
-import { dirname as dirname17, join as join89, resolve as resolve14 } from "node:path";
+import { existsSync as existsSync38, readdirSync as readdirSync3, rmSync as rmSync3, rmdirSync as rmdirSync2, unlinkSync as unlinkSync4 } from "node:fs";
+import { dirname as dirname17, join as join90, resolve as resolve15 } from "node:path";
 init_logger();
 init_safe_spinner();
 var import_fs_extra31 = __toESM(require_lib3(), 1);
@@ -79461,15 +80307,15 @@ async function analyzeFreshInstallation(claudeDir2) {
   };
 }
 function cleanupEmptyDirectories2(filePath, claudeDir2) {
-  const normalizedClaudeDir = resolve14(claudeDir2);
-  let currentDir = resolve14(dirname17(filePath));
+  const normalizedClaudeDir = resolve15(claudeDir2);
+  let currentDir = resolve15(dirname17(filePath));
   while (currentDir !== normalizedClaudeDir && currentDir.startsWith(normalizedClaudeDir)) {
     try {
       const entries = readdirSync3(currentDir);
       if (entries.length === 0) {
         rmdirSync2(currentDir);
         logger.debug(`Removed empty directory: ${currentDir}`);
-        currentDir = resolve14(dirname17(currentDir));
+        currentDir = resolve15(dirname17(currentDir));
       } else {
         break;
       }
@@ -79486,9 +80332,9 @@ async function removeFilesByOwnership(claudeDir2, analysis, includeModified) {
   const filesToRemove = includeModified ? [...analysis.ckFiles, ...analysis.ckModifiedFiles] : analysis.ckFiles;
   const filesToPreserve = includeModified ? analysis.userFiles : [...analysis.ckModifiedFiles, ...analysis.userFiles];
   for (const file of filesToRemove) {
-    const fullPath = join89(claudeDir2, file.path);
+    const fullPath = join90(claudeDir2, file.path);
     try {
-      if (existsSync37(fullPath)) {
+      if (existsSync38(fullPath)) {
         unlinkSync4(fullPath);
         removedFiles.push(file.path);
         logger.debug(`Removed: ${file.path}`);
@@ -79511,7 +80357,7 @@ async function removeFilesByOwnership(claudeDir2, analysis, includeModified) {
   };
 }
 async function updateMetadataAfterFresh(claudeDir2, removedFiles) {
-  const metadataPath = join89(claudeDir2, "metadata.json");
+  const metadataPath = join90(claudeDir2, "metadata.json");
   if (!await import_fs_extra31.pathExists(metadataPath)) {
     return;
   }
@@ -79554,7 +80400,7 @@ async function removeSubdirectoriesFallback(claudeDir2) {
   const removedFiles = [];
   let removedDirCount = 0;
   for (const subdir of CLAUDEKIT_SUBDIRECTORIES) {
-    const subdirPath = join89(claudeDir2, subdir);
+    const subdirPath = join90(claudeDir2, subdir);
     if (await import_fs_extra31.pathExists(subdirPath)) {
       rmSync3(subdirPath, { recursive: true, force: true });
       removedDirCount++;
@@ -79562,7 +80408,7 @@ async function removeSubdirectoriesFallback(claudeDir2) {
       logger.debug(`Removed subdirectory: ${subdir}/`);
     }
   }
-  const metadataPath = join89(claudeDir2, "metadata.json");
+  const metadataPath = join90(claudeDir2, "metadata.json");
   if (await import_fs_extra31.pathExists(metadataPath)) {
     unlinkSync4(metadataPath);
     removedFiles.push("metadata.json");
@@ -79780,7 +80626,7 @@ async function handleSelection(ctx) {
       }
     }
   }
-  const resolvedDir = resolve15(targetDir);
+  const resolvedDir = resolve16(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.");
@@ -79814,7 +80660,7 @@ async function handleSelection(ctx) {
   }
   if (!ctx.options.fresh) {
     const prefix = PathResolver.getPathPrefix(ctx.options.global);
-    const claudeDir2 = prefix ? join90(resolvedDir, prefix) : resolvedDir;
+    const claudeDir2 = prefix ? join91(resolvedDir, prefix) : resolvedDir;
     try {
       const existingMetadata = await readManifest(claudeDir2);
       if (existingMetadata?.kits) {
@@ -79846,7 +80692,7 @@ async function handleSelection(ctx) {
   }
   if (ctx.options.fresh) {
     const prefix = PathResolver.getPathPrefix(ctx.options.global);
-    const claudeDir2 = prefix ? join90(resolvedDir, prefix) : resolvedDir;
+    const claudeDir2 = prefix ? join91(resolvedDir, prefix) : resolvedDir;
     const canProceed = await handleFreshInstallation(claudeDir2, ctx.prompts);
     if (!canProceed) {
       return { ...ctx, cancelled: true };
@@ -79865,7 +80711,7 @@ async function handleSelection(ctx) {
     logger.info("Fetching available versions...");
     let currentVersion = null;
     try {
-      const metadataPath = ctx.options.global ? join90(PathResolver.getGlobalKitDir(), "metadata.json") : join90(resolvedDir, ".claude", "metadata.json");
+      const metadataPath = ctx.options.global ? join91(PathResolver.getGlobalKitDir(), "metadata.json") : join91(resolvedDir, ".claude", "metadata.json");
       const metadata = await readClaudeKitMetadata(metadataPath);
       currentVersion = metadata?.version || null;
       if (currentVersion) {
@@ -79940,7 +80786,7 @@ async function handleSelection(ctx) {
 }
 // src/commands/init/phases/sync-handler.ts
 import { copyFile as copyFile7, mkdir as mkdir26, open as open4, readFile as readFile39, rename as rename3, stat as stat17, unlink as unlink8, writeFile as writeFile25 } from "node:fs/promises";
-import { dirname as dirname18, join as join91, resolve as resolve16 } from "node:path";
+import { dirname as dirname18, join as join92, resolve as resolve17 } from "node:path";
 init_logger();
 init_path_resolver();
 var import_fs_extra33 = __toESM(require_lib3(), 1);
@@ -79949,14 +80795,14 @@ async function handleSync(ctx) {
   if (!ctx.options.sync) {
     return ctx;
   }
-  const resolvedDir = ctx.options.global ? PathResolver.getGlobalKitDir() : resolve16(ctx.options.dir || ".");
-  const claudeDir2 = ctx.options.global ? resolvedDir : join91(resolvedDir, ".claude");
+  const resolvedDir = ctx.options.global ? PathResolver.getGlobalKitDir() : resolve17(ctx.options.dir || ".");
+  const claudeDir2 = ctx.options.global ? resolvedDir : join92(resolvedDir, ".claude");
   if (!await import_fs_extra33.pathExists(claudeDir2)) {
     logger.error("Cannot sync: no .claude directory found");
     ctx.prompts.note("Run 'ck init' without --sync to install first.", "No Installation Found");
     return { ...ctx, cancelled: true };
   }
-  const metadataPath = join91(claudeDir2, "metadata.json");
+  const metadataPath = join92(claudeDir2, "metadata.json");
   if (!await import_fs_extra33.pathExists(metadataPath)) {
     logger.error("Cannot sync: no metadata.json found");
     ctx.prompts.note(`Your installation may be from an older version.
@@ -80056,7 +80902,7 @@ function getLockTimeout() {
 var STALE_LOCK_THRESHOLD_MS = 5 * 60 * 1000;
 async function acquireSyncLock(global3) {
   const cacheDir = PathResolver.getCacheDir(global3);
-  const lockPath = join91(cacheDir, ".sync-lock");
+  const lockPath = join92(cacheDir, ".sync-lock");
   const startTime = Date.now();
   const lockTimeout = getLockTimeout();
   await mkdir26(dirname18(lockPath), { recursive: true });
@@ -80083,7 +80929,7 @@ async function acquireSyncLock(global3) {
           }
           logger.debug(`Lock stat failed: ${statError}`);
         }
-        await new Promise((resolve17) => setTimeout(resolve17, 100));
+        await new Promise((resolve18) => setTimeout(resolve18, 100));
         continue;
       }
       throw err;
@@ -80102,10 +80948,10 @@ async function executeSyncMerge(ctx) {
   const releaseLock = await acquireSyncLock(ctx.options.global);
   try {
     const trackedFiles = ctx.syncTrackedFiles;
-    const upstreamDir = ctx.options.global ? join91(ctx.extractDir, ".claude") : ctx.extractDir;
+    const upstreamDir = ctx.options.global ? join92(ctx.extractDir, ".claude") : ctx.extractDir;
     let deletions = [];
     try {
-      const sourceMetadataPath = join91(upstreamDir, "metadata.json");
+      const sourceMetadataPath = join92(upstreamDir, "metadata.json");
       if (await import_fs_extra33.pathExists(sourceMetadataPath)) {
         const content = await readFile39(sourceMetadataPath, "utf-8");
         const sourceMetadata = JSON.parse(content);
@@ -80137,7 +80983,7 @@ async function executeSyncMerge(ctx) {
         try {
           const sourcePath = await validateSyncPath(upstreamDir, file.path);
           const targetPath = await validateSyncPath(ctx.claudeDir, file.path);
-          const targetDir = join91(targetPath, "..");
+          const targetDir = join92(targetPath, "..");
           try {
             await mkdir26(targetDir, { recursive: true });
           } catch (mkdirError) {
@@ -80308,7 +81154,7 @@ async function createBackup(claudeDir2, files, backupDir) {
       const sourcePath = await validateSyncPath(claudeDir2, file.path);
       if (await import_fs_extra33.pathExists(sourcePath)) {
         const targetPath = await validateSyncPath(backupDir, file.path);
-        const targetDir = join91(targetPath, "..");
+        const targetDir = join92(targetPath, "..");
         await mkdir26(targetDir, { recursive: true });
         await copyFile7(sourcePath, targetPath);
       }
@@ -80323,7 +81169,7 @@ async function createBackup(claudeDir2, files, backupDir) {
 }
 // src/commands/init/phases/transform-handler.ts
 init_config_manager();
-import { join as join95 } from "node:path";
+import { join as join96 } from "node:path";
 
 // src/services/transformers/folder-path-transformer.ts
 init_logger();
@@ -80334,38 +81180,38 @@ init_logger();
 init_types2();
 var import_fs_extra34 = __toESM(require_lib3(), 1);
 import { rename as rename4, rm as rm8 } from "node:fs/promises";
-import { join as join92, relative as relative15 } from "node:path";
+import { join as join93, relative as relative15 } from "node:path";
 async function collectDirsToRename(extractDir, folders) {
   const dirsToRename = [];
   if (folders.docs !== DEFAULT_FOLDERS.docs) {
-    const docsPath = join92(extractDir, DEFAULT_FOLDERS.docs);
+    const docsPath = join93(extractDir, DEFAULT_FOLDERS.docs);
     if (await import_fs_extra34.pathExists(docsPath)) {
       dirsToRename.push({
         from: docsPath,
-        to: join92(extractDir, folders.docs)
+        to: join93(extractDir, folders.docs)
       });
     }
-    const claudeDocsPath = join92(extractDir, ".claude", DEFAULT_FOLDERS.docs);
+    const claudeDocsPath = join93(extractDir, ".claude", DEFAULT_FOLDERS.docs);
     if (await import_fs_extra34.pathExists(claudeDocsPath)) {
       dirsToRename.push({
         from: claudeDocsPath,
-        to: join92(extractDir, ".claude", folders.docs)
+        to: join93(extractDir, ".claude", folders.docs)
       });
     }
   }
   if (folders.plans !== DEFAULT_FOLDERS.plans) {
-    const plansPath = join92(extractDir, DEFAULT_FOLDERS.plans);
+    const plansPath = join93(extractDir, DEFAULT_FOLDERS.plans);
     if (await import_fs_extra34.pathExists(plansPath)) {
       dirsToRename.push({
         from: plansPath,
-        to: join92(extractDir, folders.plans)
+        to: join93(extractDir, folders.plans)
       });
     }
-    const claudePlansPath = join92(extractDir, ".claude", DEFAULT_FOLDERS.plans);
+    const claudePlansPath = join93(extractDir, ".claude", DEFAULT_FOLDERS.plans);
     if (await import_fs_extra34.pathExists(claudePlansPath)) {
       dirsToRename.push({
         from: claudePlansPath,
-        to: join92(extractDir, ".claude", folders.plans)
+        to: join93(extractDir, ".claude", folders.plans)
       });
     }
   }
@@ -80405,8 +81251,8 @@ async function renameFolders(dirsToRename, extractDir, options2) {
 // src/services/transformers/folder-transform/path-replacer.ts
 init_logger();
 init_types2();
-import { readFile as readFile40, readdir as readdir28, writeFile as writeFile26 } from "node:fs/promises";
-import { join as join93, relative as relative16 } from "node:path";
+import { readFile as readFile40, readdir as readdir29, writeFile as writeFile26 } from "node:fs/promises";
+import { join as join94, relative as relative16 } from "node:path";
 var TRANSFORMABLE_FILE_PATTERNS = [
   ".md",
   ".txt",
@@ -80457,9 +81303,9 @@ function compileReplacements(replacements) {
 async function transformFileContents(dir, compiledReplacements, options2) {
   let filesChanged = 0;
   let replacementsCount = 0;
-  const entries = await readdir28(dir, { withFileTypes: true });
+  const entries = await readdir29(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = join93(dir, entry.name);
+    const fullPath = join94(dir, entry.name);
     if (entry.isDirectory()) {
       if (entry.name === "node_modules" || entry.name === ".git") {
         continue;
@@ -80594,9 +81440,9 @@ async function transformFolderPaths(extractDir, folders, options2 = {}) {
 
 // src/services/transformers/global-path-transformer.ts
 init_logger();
-import { readFile as readFile41, readdir as readdir29, writeFile as writeFile27 } from "node:fs/promises";
+import { readFile as readFile41, readdir as readdir30, writeFile as writeFile27 } from "node:fs/promises";
 import { platform as platform13 } from "node:os";
-import { extname as extname4, join as join94 } from "node:path";
+import { extname as extname4, join as join95 } from "node:path";
 var IS_WINDOWS4 = platform13() === "win32";
 var HOME_PREFIX = IS_WINDOWS4 ? "%USERPROFILE%" : "$HOME";
 function getHomeDirPrefix() {
@@ -80704,9 +81550,9 @@ async function transformPathsForGlobalInstall(directory, options2 = {}) {
   let filesSkipped = 0;
   const skippedFiles = [];
   async function processDirectory2(dir) {
-    const entries = await readdir29(dir, { withFileTypes: true });
+    const entries = await readdir30(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join94(dir, entry.name);
+      const fullPath = join95(dir, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name.startsWith(".") && entry.name !== ".claude") {
           continue;
@@ -80782,7 +81628,7 @@ async function handleTransforms(ctx) {
       logger.debug(ctx.options.global ? "Saved folder configuration to ~/.claude/.ck.json" : "Saved folder configuration to .claude/.ck.json");
     }
   }
-  const claudeDir2 = ctx.options.global ? ctx.resolvedDir : join95(ctx.resolvedDir, ".claude");
+  const claudeDir2 = ctx.options.global ? ctx.resolvedDir : join96(ctx.resolvedDir, ".claude");
   return {
     ...ctx,
     foldersConfig,
@@ -80975,7 +81821,7 @@ var import_picocolors22 = __toESM(require_picocolors(), 1);
 
 // src/commands/new/phases/directory-setup.ts
 init_config_manager();
-import { resolve as resolve17 } from "node:path";
+import { resolve as resolve18 } from "node:path";
 init_logger();
 init_path_resolver();
 init_types2();
@@ -81060,7 +81906,7 @@ async function directorySetup(validOptions, prompts) {
       targetDir = await prompts.getDirectory(targetDir);
     }
   }
-  const resolvedDir = resolve17(targetDir);
+  const resolvedDir = resolve18(targetDir);
   logger.info(`Target directory: ${resolvedDir}`);
   if (PathResolver.isLocalSameAsGlobal(resolvedDir)) {
     logger.warning("You're creating a project at HOME directory.");
@@ -81117,7 +81963,7 @@ async function handleDirectorySetup(ctx) {
 // src/commands/new/phases/project-creation.ts
 init_config_manager();
 init_github_client();
-import { join as join96 } from "node:path";
+import { join as join97 } from "node:path";
 init_logger();
 init_output_manager();
 init_types2();
@@ -81243,7 +82089,7 @@ async function projectCreation(kit, resolvedDir, validOptions, isNonInteractive2
   output.section("Installing");
   logger.verbose("Installation target", { directory: resolvedDir });
   const merger = new FileMerger;
-  const claudeDir2 = join96(resolvedDir, ".claude");
+  const claudeDir2 = join97(resolvedDir, ".claude");
   merger.setMultiKitContext(claudeDir2, kit);
   if (validOptions.exclude && validOptions.exclude.length > 0) {
     merger.addIgnorePatterns(validOptions.exclude);
@@ -81290,7 +82136,7 @@ async function handleProjectCreation(ctx) {
 }
 // src/commands/new/phases/post-setup.ts
 init_projects_registry();
-import { join as join97 } from "node:path";
+import { join as join98 } from "node:path";
 init_package_installer();
 init_logger();
 init_path_resolver();
@@ -81322,9 +82168,9 @@ async function postSetup(resolvedDir, validOptions, isNonInteractive2, prompts)
       withSudo: validOptions.withSudo
     });
   }
-  const claudeDir2 = join97(resolvedDir, ".claude");
+  const claudeDir2 = join98(resolvedDir, ".claude");
   await promptSetupWizardIfNeeded({
-    envPath: join97(claudeDir2, ".env"),
+    envPath: join98(claudeDir2, ".env"),
     claudeDir: claudeDir2,
     isGlobal: false,
     isNonInteractive: isNonInteractive2,
@@ -81396,13 +82242,13 @@ init_claudekit_data2();
 init_logger();
 init_safe_prompts();
 var import_picocolors23 = __toESM(require_picocolors(), 1);
-import { existsSync as existsSync38 } from "node:fs";
-import { resolve as resolve18 } from "node:path";
+import { existsSync as existsSync39 } from "node:fs";
+import { resolve as resolve19 } from "node:path";
 async function handleAdd(projectPath, options2) {
   logger.debug(`Adding project: ${projectPath}, options: ${JSON.stringify(options2)}`);
   intro("Add Project");
-  const absolutePath = resolve18(projectPath);
-  if (!existsSync38(absolutePath)) {
+  const absolutePath = resolve19(projectPath);
+  if (!existsSync39(absolutePath)) {
     log.error(`Path does not exist: ${absolutePath}`);
     process.exitCode = 1;
     return;
@@ -82330,7 +83176,7 @@ async function detectInstallations() {
 
 // src/commands/uninstall/removal-handler.ts
 import { readdirSync as readdirSync5, rmSync as rmSync5 } from "node:fs";
-import { join as join99, resolve as resolve19, sep as sep3 } from "node:path";
+import { join as join100, resolve as resolve20, sep as sep4 } from "node:path";
 init_logger();
 init_safe_prompts();
 init_safe_spinner();
@@ -82339,7 +83185,7 @@ var import_fs_extra37 = __toESM(require_lib3(), 1);
 // src/commands/uninstall/analysis-handler.ts
 init_metadata_migration();
 import { readdirSync as readdirSync4, rmSync as rmSync4 } from "node:fs";
-import { dirname as dirname19, join as join98 } from "node:path";
+import { dirname as dirname19, join as join99 } from "node:path";
 init_logger();
 init_safe_prompts();
 var import_picocolors27 = __toESM(require_picocolors(), 1);
@@ -82387,7 +83233,7 @@ async function analyzeInstallation(installation, forceOverwrite, kit) {
   if (uninstallManifest.isMultiKit && kit && metadata?.kits?.[kit]) {
     const kitFiles = metadata.kits[kit].files || [];
     for (const trackedFile of kitFiles) {
-      const filePath = join98(installation.path, trackedFile.path);
+      const filePath = join99(installation.path, trackedFile.path);
       if (uninstallManifest.filesToPreserve.includes(trackedFile.path)) {
         result.toPreserve.push({ path: trackedFile.path, reason: "shared with other kit" });
         continue;
@@ -82417,7 +83263,7 @@ async function analyzeInstallation(installation, forceOverwrite, kit) {
     return result;
   }
   for (const trackedFile of allTrackedFiles) {
-    const filePath = join98(installation.path, trackedFile.path);
+    const filePath = join99(installation.path, trackedFile.path);
     const ownershipResult = await OwnershipChecker.checkOwnership(filePath, metadata, installation.path);
     if (!ownershipResult.exists)
       continue;
@@ -82471,17 +83317,17 @@ async function isDirectory(filePath) {
 }
 async function isPathSafeToRemove(filePath, baseDir) {
   try {
-    const resolvedPath = resolve19(filePath);
-    const resolvedBase = resolve19(baseDir);
-    if (!resolvedPath.startsWith(resolvedBase + sep3) && resolvedPath !== resolvedBase) {
+    const resolvedPath = resolve20(filePath);
+    const resolvedBase = resolve20(baseDir);
+    if (!resolvedPath.startsWith(resolvedBase + sep4) && resolvedPath !== resolvedBase) {
       logger.debug(`Path outside installation directory: ${filePath}`);
       return false;
     }
     const stats = await import_fs_extra37.lstat(filePath);
     if (stats.isSymbolicLink()) {
       const realPath = await import_fs_extra37.realpath(filePath);
-      const resolvedReal = resolve19(realPath);
-      if (!resolvedReal.startsWith(resolvedBase + sep3) && resolvedReal !== resolvedBase) {
+      const resolvedReal = resolve20(realPath);
+      if (!resolvedReal.startsWith(resolvedBase + sep4) && resolvedReal !== resolvedBase) {
         logger.debug(`Symlink points outside installation directory: ${filePath} -> ${realPath}`);
         return false;
       }
@@ -82514,7 +83360,7 @@ async function removeInstallations(installations, options2) {
       let removedCount = 0;
       let cleanedDirs = 0;
       for (const item of analysis.toDelete) {
-        const filePath = join99(installation.path, item.path);
+        const filePath = join100(installation.path, item.path);
         if (!await import_fs_extra37.pathExists(filePath))
           continue;
         if (!await isPathSafeToRemove(filePath, installation.path)) {
@@ -82888,8 +83734,8 @@ init_version_checker();
 init_logger();
 init_path_resolver();
 init_types2();
-import { existsSync as existsSync39, readFileSync as readFileSync8 } from "node:fs";
-import { join as join100 } from "node:path";
+import { existsSync as existsSync40, readFileSync as readFileSync9 } from "node:fs";
+import { join as join101 } from "node:path";
 var packageVersion = package_default.version;
 function formatInstalledKits(metadata) {
   if (!metadata.kits || Object.keys(metadata.kits).length === 0) {
@@ -82921,13 +83767,13 @@ async function displayVersion() {
   let localKitVersion = null;
   let isGlobalOnlyKit = false;
   const globalKitDir = PathResolver.getGlobalKitDir();
-  const globalMetadataPath = join100(globalKitDir, "metadata.json");
+  const globalMetadataPath = join101(globalKitDir, "metadata.json");
   const prefix = PathResolver.getPathPrefix(false);
-  const localMetadataPath = prefix ? join100(process.cwd(), prefix, "metadata.json") : join100(process.cwd(), "metadata.json");
+  const localMetadataPath = prefix ? join101(process.cwd(), prefix, "metadata.json") : join101(process.cwd(), "metadata.json");
   const isLocalSameAsGlobal = localMetadataPath === globalMetadataPath;
-  if (!isLocalSameAsGlobal && existsSync39(localMetadataPath)) {
+  if (!isLocalSameAsGlobal && existsSync40(localMetadataPath)) {
     try {
-      const rawMetadata = JSON.parse(readFileSync8(localMetadataPath, "utf-8"));
+      const rawMetadata = JSON.parse(readFileSync9(localMetadataPath, "utf-8"));
       const metadata = MetadataSchema.parse(rawMetadata);
       const kitsDisplay = formatInstalledKits(metadata);
       if (kitsDisplay) {
@@ -82939,9 +83785,9 @@ async function displayVersion() {
       logger.verbose("Failed to parse local metadata.json", { error });
     }
   }
-  if (existsSync39(globalMetadataPath)) {
+  if (existsSync40(globalMetadataPath)) {
     try {
-      const rawMetadata = JSON.parse(readFileSync8(globalMetadataPath, "utf-8"));
+      const rawMetadata = JSON.parse(readFileSync9(globalMetadataPath, "utf-8"));
       const metadata = MetadataSchema.parse(rawMetadata);
       const kitsDisplay = formatInstalledKits(metadata);
       if (kitsDisplay) {