claudekit-cli 3.6.2 → 3.7.0

package/dist/index.js

@@ -9329,7 +9329,7 @@ var require_get_stream = __commonJS((exports, module) => {
     };
     const { maxBuffer } = options;
     let stream;
-    await new Promise((resolve, reject) => {
+    await new Promise((resolve2, reject) => {
       const rejectPromise = (error) => {
         if (error && stream.getBufferedLength() <= BufferConstants.MAX_LENGTH) {
           error.bufferedData = stream.getBufferedValue();
@@ -9341,7 +9341,7 @@ var require_get_stream = __commonJS((exports, module) => {
           rejectPromise(error);
           return;
         }
-        resolve();
+        resolve2();
       });
       stream.on("data", () => {
         if (stream.getBufferedLength() > maxBuffer) {
@@ -10702,7 +10702,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((resolve, reject) => {
+      return new Promise((resolve2, reject) => {
         this.zipfile.on("error", (err) => {
           this.canceled = true;
           reject(err);
@@ -10711,7 +10711,7 @@ var require_extract_zip = __commonJS((exports, module) => {
         this.zipfile.on("close", () => {
           if (!this.canceled) {
             debug("zip extraction complete");
-            resolve();
+            resolve2();
           }
         });
         this.zipfile.on("entry", async (entry) => {
@@ -10756,7 +10756,7 @@ var require_extract_zip = __commonJS((exports, module) => {
       const IFMT = 61440;
       const IFDIR = 16384;
       const IFLNK = 40960;
-      const symlink = (mode & IFMT) === IFLNK;
+      const symlink2 = (mode & IFMT) === IFLNK;
       let isDir = (mode & IFMT) === IFDIR;
       if (!isDir && entry.fileName.endsWith("/")) {
         isDir = true;
@@ -10764,7 +10764,7 @@ var require_extract_zip = __commonJS((exports, module) => {
       const madeBy = entry.versionMadeBy >> 8;
       if (!isDir)
         isDir = madeBy === 0 && entry.externalFileAttributes === 16;
-      debug("extracting entry", { filename: entry.fileName, isDir, isSymlink: symlink });
+      debug("extracting entry", { filename: entry.fileName, isDir, isSymlink: symlink2 });
       const procMode = this.getExtractedMode(mode, isDir) & 511;
       const destDir = isDir ? dest : path.dirname(dest);
       const mkdirOptions = { recursive: true };
@@ -10777,7 +10777,7 @@ var require_extract_zip = __commonJS((exports, module) => {
         return;
       debug("opening read stream", dest);
       const readStream = await promisify5(this.zipfile.openReadStream.bind(this.zipfile))(entry);
-      if (symlink) {
+      if (symlink2) {
         const link = await getStream(readStream);
         debug("creating symlink", link, dest);
         await fs2.symlink(link, dest);
@@ -12727,7 +12727,7 @@ var require_emoji_regex2 = __commonJS((exports, module) => {
 
 // src/utils/install-error-handler.ts
 import { existsSync as existsSync5, readFileSync as readFileSync4, unlinkSync as unlinkSync2 } from "node:fs";
-import { join as join17 } from "node:path";
+import { join as join18 } from "node:path";
 function parseNameReason(str) {
   const colonIndex = str.indexOf(":");
   if (colonIndex === -1) {
@@ -12736,7 +12736,7 @@ function parseNameReason(str) {
   return [str.slice(0, colonIndex).trim(), str.slice(colonIndex + 1).trim()];
 }
 function displayInstallErrors(skillsDir) {
-  const summaryPath = join17(skillsDir, ".install-error-summary.json");
+  const summaryPath = join18(skillsDir, ".install-error-summary.json");
   if (!existsSync5(summaryPath)) {
     logger.error("Skills installation failed. Run with --verbose for details.");
     return;
@@ -12827,7 +12827,7 @@ async function checkNeedsSudoPackages() {
   }
 }
 function hasInstallState(skillsDir) {
-  const stateFilePath = join17(skillsDir, ".install-state.json");
+  const stateFilePath = join18(skillsDir, ".install-state.json");
   return existsSync5(stateFilePath);
 }
 var WHICH_COMMAND_TIMEOUT_MS = 5000;
@@ -12851,10 +12851,10 @@ __export(exports_package_installer, {
   getPackageVersion: () => getPackageVersion
 });
 import { exec as exec5, execFile as execFile2, spawn } from "node:child_process";
-import { join as join18, resolve as resolve2 } from "node:path";
+import { join as join19, resolve as resolve3 } from "node:path";
 import { promisify as promisify5 } from "node:util";
 function executeInteractiveScript(command, args, options) {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     const child = spawn(command, args, {
       stdio: ["ignore", "inherit", "inherit"],
       cwd: options?.cwd,
@@ -12875,7 +12875,7 @@ function executeInteractiveScript(command, args, options) {
       } else if (code2 !== 0) {
         reject(new Error(`Command exited with code ${code2}`));
       } else {
-        resolve3();
+        resolve4();
       }
     });
     child.on("error", (error) => {
@@ -12886,8 +12886,8 @@ function executeInteractiveScript(command, args, options) {
   });
 }
 function getNpmCommand() {
-  const platform8 = process.platform;
-  return platform8 === "win32" ? "npm.cmd" : "npm";
+  const platform9 = process.platform;
+  return platform9 === "win32" ? "npm.cmd" : "npm";
 }
 function validatePackageName(packageName) {
   if (!packageName || typeof packageName !== "string") {
@@ -13044,9 +13044,9 @@ async function installOpenCode() {
   }
   try {
     logger.info(`Installing ${displayName}...`);
-    const { unlink: unlink2 } = await import("node:fs/promises");
+    const { unlink: unlink4 } = await import("node:fs/promises");
     const { tmpdir: tmpdir3 } = await import("node:os");
-    const tempScriptPath = join18(tmpdir3(), "opencode-install.sh");
+    const tempScriptPath = join19(tmpdir3(), "opencode-install.sh");
     try {
       logger.info("Downloading OpenCode installation script...");
       await execFileAsync("curl", ["-fsSL", "https://opencode.ai/install", "-o", tempScriptPath], {
@@ -13061,7 +13061,7 @@ async function installOpenCode() {
       });
     } finally {
       try {
-        await unlink2(tempScriptPath);
+        await unlink4(tempScriptPath);
       } catch {}
     }
     const installed = await isOpenCodeInstalled();
@@ -13119,8 +13119,8 @@ async function processPackageInstallations(shouldInstallOpenCode, shouldInstallG
   return results;
 }
 function validateScriptPath(skillsDir, scriptPath) {
-  const skillsDirResolved = resolve2(skillsDir);
-  const scriptPathResolved = resolve2(scriptPath);
+  const skillsDirResolved = resolve3(skillsDir);
+  const scriptPathResolved = resolve3(scriptPath);
   const isWindows5 = process.platform === "win32";
   const skillsDirNormalized = isWindows5 ? skillsDirResolved.toLowerCase() : skillsDirResolved;
   const scriptPathNormalized = isWindows5 ? scriptPathResolved.toLowerCase() : scriptPathResolved;
@@ -13157,11 +13157,11 @@ async function installSkillsDependencies(skillsDir) {
   }
   try {
     const { existsSync: existsSync6 } = await import("node:fs");
-    const { readFile: readFile9 } = await import("node:fs/promises");
+    const { readFile: readFile11 } = await import("node:fs/promises");
     const clack = await Promise.resolve().then(() => (init_dist2(), exports_dist));
-    const platform8 = process.platform;
-    const scriptName = platform8 === "win32" ? "install.ps1" : "install.sh";
-    const scriptPath = join18(skillsDir, scriptName);
+    const platform9 = process.platform;
+    const scriptName = platform9 === "win32" ? "install.ps1" : "install.sh";
+    const scriptPath = join19(skillsDir, scriptName);
     try {
       validateScriptPath(skillsDir, scriptPath);
     } catch (error) {
@@ -13177,7 +13177,7 @@ async function installSkillsDependencies(skillsDir) {
       logger.warning(`Skills installation script not found: ${scriptPath}`);
       logger.info("");
       logger.info("\uD83D\uDCD6 Manual Installation Instructions:");
-      logger.info(`  See: ${join18(skillsDir, "INSTALLATION.md")}`);
+      logger.info(`  See: ${join19(skillsDir, "INSTALLATION.md")}`);
       logger.info("");
       logger.info("Quick start:");
       logger.info("  cd .claude/skills/ai-multimodal/scripts");
@@ -13190,10 +13190,10 @@ async function installSkillsDependencies(skillsDir) {
     }
     logger.warning("⚠️  Installation script will execute with user privileges:");
     logger.info(`  Script: ${scriptPath}`);
-    logger.info(`  Platform: ${platform8 === "win32" ? "Windows (PowerShell)" : "Unix (bash)"}`);
+    logger.info(`  Platform: ${platform9 === "win32" ? "Windows (PowerShell)" : "Unix (bash)"}`);
     logger.info("");
     try {
-      const scriptContent = await readFile9(scriptPath, "utf-8");
+      const scriptContent = await readFile11(scriptPath, "utf-8");
       const previewLines = scriptContent.split(`
 `).slice(0, 20);
       logger.info("Script preview (first 20 lines):");
@@ -13218,10 +13218,10 @@ async function installSkillsDependencies(skillsDir) {
       logger.info("Installation cancelled by user");
       logger.info("");
       logger.info("\uD83D\uDCD6 Manual Installation Instructions:");
-      logger.info(`  ${platform8 === "win32" ? `powershell -File "${scriptPath}"` : `bash ${scriptPath}`}`);
+      logger.info(`  ${platform9 === "win32" ? `powershell -File "${scriptPath}"` : `bash ${scriptPath}`}`);
       logger.info("");
       logger.info("Or see complete guide:");
-      logger.info(`  ${join18(skillsDir, "INSTALLATION.md")}`);
+      logger.info(`  ${join19(skillsDir, "INSTALLATION.md")}`);
       return {
         success: false,
         package: displayName,
@@ -13246,7 +13246,7 @@ async function installSkillsDependencies(skillsDir) {
         }
       }
     }
-    if (platform8 === "linux") {
+    if (platform9 === "linux") {
       const needsSudo = await checkNeedsSudoPackages();
       if (needsSudo) {
         if (isNonInteractive()) {
@@ -13275,7 +13275,7 @@ async function installSkillsDependencies(skillsDir) {
       ...process.env,
       NON_INTERACTIVE: "1"
     };
-    if (platform8 === "win32") {
+    if (platform9 === "win32") {
       logger.warning("⚠️  Windows: Respecting system PowerShell execution policy");
       logger.info("   If the script fails, you may need to set execution policy:");
       logger.info("   Set-ExecutionPolicy RemoteSigned -Scope CurrentUser");
@@ -13326,7 +13326,7 @@ async function installSkillsDependencies(skillsDir) {
     logger.info("\uD83D\uDCD6 Manual Installation Instructions:");
     logger.info("");
     logger.info("See complete guide:");
-    logger.info(`  cat ${join18(skillsDir, "INSTALLATION.md")}`);
+    logger.info(`  cat ${join19(skillsDir, "INSTALLATION.md")}`);
     logger.info("");
     logger.info("Quick start:");
     logger.info("  cd .claude/skills/ai-multimodal/scripts");
@@ -14002,7 +14002,7 @@ function getPagerArgs(pagerCmd) {
   return [];
 }
 async function trySystemPager(content) {
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     const pagerCmd = process.env.PAGER || "less";
     const pagerArgs = getPagerArgs(pagerCmd);
     try {
@@ -14012,20 +14012,20 @@ async function trySystemPager(content) {
       });
       const timeout = setTimeout(() => {
         pager.kill();
-        resolve6(false);
+        resolve7(false);
       }, 30000);
       pager.stdin.write(content);
       pager.stdin.end();
       pager.on("close", (code2) => {
         clearTimeout(timeout);
-        resolve6(code2 === 0);
+        resolve7(code2 === 0);
       });
       pager.on("error", () => {
         clearTimeout(timeout);
-        resolve6(false);
+        resolve7(false);
       });
     } catch {
-      resolve6(false);
+      resolve7(false);
     }
   });
 }
@@ -14052,16 +14052,16 @@ async function basicPager(content) {
       break;
     }
     const remaining = lines.length - currentLine;
-    await new Promise((resolve6) => {
+    await new Promise((resolve7) => {
       rl.question(`-- More (${remaining} lines) [Enter/q] --`, (answer) => {
         if (answer.toLowerCase() === "q") {
           rl.close();
           process.exitCode = 0;
-          resolve6();
+          resolve7();
           return;
         }
         process.stdout.write("\x1B[1A\x1B[2K");
-        resolve6();
+        resolve7();
       });
     });
   }
@@ -14320,7 +14320,7 @@ var init_help_interceptor = __esm(() => {
 
 // src/index.ts
 import { existsSync as existsSync8, readFileSync as readFileSync5 } from "fs";
-import { join as join33 } from "path";
+import { join as join34 } from "path";
 
 // node_modules/cac/dist/index.mjs
 import { EventEmitter } from "events";
@@ -14925,7 +14925,7 @@ var cac = (name = "") => new CAC(name);
 // package.json
 var package_default = {
   name: "claudekit-cli",
-  version: "3.6.2",
+  version: "3.7.0",
   description: "CLI tool for bootstrapping and updating ClaudeKit projects",
   type: "module",
   repository: {
@@ -15016,7 +15016,8 @@ init_dist2();
 // src/lib/health-checks/types.ts
 init_zod();
 var CheckStatusSchema = exports_external.enum(["pass", "warn", "fail", "info"]);
-var CheckGroupSchema = exports_external.enum(["system", "claudekit", "auth"]);
+var CheckPrioritySchema = exports_external.enum(["critical", "standard", "extended"]);
+var CheckGroupSchema = exports_external.enum(["system", "claudekit", "auth", "platform", "network"]);
 var FixResultSchema = exports_external.object({
   success: exports_external.boolean(),
   message: exports_external.string(),
@@ -15026,6 +15027,7 @@ var CheckResultSchema = exports_external.object({
   id: exports_external.string().min(1),
   name: exports_external.string().min(1),
   group: CheckGroupSchema,
+  priority: CheckPrioritySchema.optional().default("standard"),
   status: CheckStatusSchema,
   message: exports_external.string(),
   details: exports_external.string().optional(),
@@ -15039,7 +15041,8 @@ var CheckRunnerOptionsSchema = exports_external.object({
   checkOnly: exports_external.boolean().optional(),
   json: exports_external.boolean().optional(),
   groups: exports_external.array(CheckGroupSchema).optional(),
-  verbose: exports_external.boolean().optional()
+  verbose: exports_external.boolean().optional(),
+  full: exports_external.boolean().optional()
 });
 var CheckSummarySchema = exports_external.object({
   timestamp: exports_external.string().datetime(),
@@ -15091,8 +15094,9 @@ class CheckRunner {
       groups: filteredCheckers.map((c2) => c2.group)
     });
     const allResults = await this.executeCheckersInParallel(filteredCheckers);
+    const filteredResults = this.filterChecksByPriority(allResults);
     logger.verbose("All checks completed, building summary");
-    return this.buildSummary(allResults);
+    return this.buildSummary(filteredResults);
   }
   filterCheckersByGroup() {
     if (!this.options.groups || this.options.groups.length === 0) {
@@ -15101,6 +15105,16 @@ class CheckRunner {
     const allowedGroups = new Set(this.options.groups);
     return this.checkers.filter((checker) => allowedGroups.has(checker.group));
   }
+  filterChecksByPriority(checks) {
+    const includedPriorities = new Set(["critical", "standard"]);
+    if (this.options.full) {
+      includedPriorities.add("extended");
+    }
+    return checks.filter((check) => {
+      const priority = check.priority ?? "standard";
+      return includedPriorities.has(priority);
+    });
+  }
   async executeCheckersInParallel(checkers) {
     const resultsArrays = await Promise.all(checkers.map(async (checker) => {
       logger.verbose(`Starting checker: ${checker.group}`);
@@ -15794,7 +15808,9 @@ class SystemChecker {
 }
 // src/lib/health-checks/claudekit-checker.ts
 import { existsSync as existsSync3, readFileSync as readFileSync2, statSync } from "node:fs";
-import { join as join4 } from "node:path";
+import { constants, access, readFile as readFile3, readdir as readdir2, unlink, writeFile as writeFile2 } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import { dirname, join as join4, normalize as normalize2, resolve } from "node:path";
 
 // src/utils/claudekit-scanner.ts
 var import_fs_extra = __toESM(require_lib(), 1);
@@ -16284,6 +16300,8 @@ class PackageManagerDetector {
 }
 
 // src/lib/health-checks/claudekit-checker.ts
+var HOOK_EXTENSIONS = [".js", ".cjs", ".mjs", ".ts", ".sh", ".ps1"];
+
 class ClaudekitChecker {
   group = "claudekit";
   projectDir;
@@ -16311,6 +16329,18 @@ class ClaudekitChecker {
     results.push(...this.checkSkillsScripts(setup));
     logger.verbose("ClaudekitChecker: Checking component counts");
     results.push(this.checkComponentCounts(setup));
+    logger.verbose("ClaudekitChecker: Checking global dir readability");
+    results.push(await this.checkGlobalDirReadable());
+    logger.verbose("ClaudekitChecker: Checking global dir writability");
+    results.push(await this.checkGlobalDirWritable());
+    logger.verbose("ClaudekitChecker: Checking hooks directory");
+    results.push(await this.checkHooksExist());
+    logger.verbose("ClaudekitChecker: Checking settings.json validity");
+    results.push(await this.checkSettingsValid());
+    logger.verbose("ClaudekitChecker: Checking path references");
+    results.push(await this.checkPathRefsValid());
+    logger.verbose("ClaudekitChecker: Checking project config completeness");
+    results.push(await this.checkProjectConfigCompleteness(setup));
     logger.verbose("ClaudekitChecker: All checks complete");
     return results;
   }
@@ -16323,6 +16353,7 @@ class ClaudekitChecker {
       id: "ck-cli-install-method",
       name: "CLI Installed Via",
       group: "claudekit",
+      priority: "standard",
       status: pm !== "unknown" ? "pass" : "warn",
       message: pmVersion ? `${displayName} (v${pmVersion})` : displayName,
       suggestion: pm === "unknown" ? "Run: npm install -g claudekit-cli" : undefined,
@@ -16338,6 +16369,7 @@ class ClaudekitChecker {
       id: "ck-global-install",
       name: "Global CK",
       group: "claudekit",
+      priority: "critical",
       status: hasGlobal ? "pass" : "warn",
       message: hasGlobal ? `${kitName} ${version}` : "Not installed",
       details: hasGlobal ? setup.global.path : undefined,
@@ -16354,6 +16386,7 @@ class ClaudekitChecker {
       id: "ck-project-install",
       name: "Project CK",
       group: "claudekit",
+      priority: "standard",
       status: hasProject ? "pass" : "info",
       message: hasProject ? `${kitName} ${version}` : "Not a ClaudeKit project",
       details: hasProject ? setup.project.path : undefined,
@@ -16382,6 +16415,7 @@ class ClaudekitChecker {
         id,
         name,
         group: "claudekit",
+        priority: "standard",
         status: "warn",
         message: "Missing",
         suggestion: "Create CLAUDE.md with project instructions",
@@ -16396,6 +16430,7 @@ class ClaudekitChecker {
           id,
           name,
           group: "claudekit",
+          priority: "standard",
           status: "warn",
           message: "Empty (0 bytes)",
           details: path,
@@ -16407,6 +16442,7 @@ class ClaudekitChecker {
         id,
         name,
         group: "claudekit",
+        priority: "standard",
         status: "pass",
         message: `Found (${sizeKB}KB)`,
         details: path,
@@ -16417,6 +16453,7 @@ class ClaudekitChecker {
         id,
         name,
         group: "claudekit",
+        priority: "standard",
         status: "warn",
         message: "Unreadable",
         details: path,
@@ -16432,6 +16469,7 @@ class ClaudekitChecker {
         id: "ck-active-plan",
         name: "Active Plan",
         group: "claudekit",
+        priority: "standard",
         status: "info",
         message: "None",
         autoFixable: false
@@ -16445,6 +16483,7 @@ class ClaudekitChecker {
           id: "ck-active-plan",
           name: "Active Plan",
           group: "claudekit",
+          priority: "standard",
           status: "warn",
           message: "Orphaned (target missing)",
           details: targetPath,
@@ -16456,6 +16495,7 @@ class ClaudekitChecker {
         id: "ck-active-plan",
         name: "Active Plan",
         group: "claudekit",
+        priority: "standard",
         status: "pass",
         message: targetPath,
         autoFixable: false
@@ -16465,6 +16505,7 @@ class ClaudekitChecker {
         id: "ck-active-plan",
         name: "Active Plan",
         group: "claudekit",
+        priority: "standard",
         status: "warn",
         message: "Unreadable",
         details: activePlanPath,
@@ -16483,6 +16524,7 @@ class ClaudekitChecker {
         id: "ck-global-skills-script",
         name: "Global Skills Script",
         group: "claudekit",
+        priority: "standard",
         status: hasGlobalScript ? "pass" : "info",
         message: hasGlobalScript ? "Available" : "Not found",
         details: hasGlobalScript ? globalScriptPath : undefined,
@@ -16497,6 +16539,7 @@ class ClaudekitChecker {
         id: "ck-project-skills-script",
         name: "Project Skills Script",
         group: "claudekit",
+        priority: "standard",
         status: hasProjectScript ? "pass" : "info",
         message: hasProjectScript ? "Available" : "Not found",
         details: hasProjectScript ? projectScriptPath : undefined,
@@ -16518,12 +16561,349 @@ class ClaudekitChecker {
       id: "ck-component-counts",
       name: "ClaudeKit Components",
       group: "claudekit",
+      priority: "standard",
       status: totalComponents > 0 ? "info" : "warn",
       message: totalComponents > 0 ? `${totalAgents} agents, ${totalCommands} commands, ${totalWorkflows} workflows, ${totalSkills} skills` : "No components found",
       suggestion: totalComponents === 0 ? "Install ClaudeKit: ck new --kit engineer" : undefined,
       autoFixable: false
     };
   }
+  async checkGlobalDirReadable() {
+    const globalDir = PathResolver.getGlobalKitDir();
+    try {
+      await access(globalDir, constants.R_OK);
+      return {
+        id: "ck-global-dir-readable",
+        name: "Global Dir Readable",
+        group: "claudekit",
+        priority: "standard",
+        status: "pass",
+        message: "Read access OK",
+        details: globalDir,
+        autoFixable: false
+      };
+    } catch (error) {
+      return {
+        id: "ck-global-dir-readable",
+        name: "Global Dir Readable",
+        group: "claudekit",
+        priority: "standard",
+        status: "fail",
+        message: "Read access denied",
+        details: globalDir,
+        suggestion: "Check file permissions on ~/.claude/",
+        autoFixable: false
+      };
+    }
+  }
+  async checkGlobalDirWritable() {
+    const globalDir = PathResolver.getGlobalKitDir();
+    const timestamp = Date.now();
+    const random = Math.random().toString(36).substring(2);
+    const testFile = join4(globalDir, `.ck-write-test-${timestamp}-${random}`);
+    try {
+      await writeFile2(testFile, "test", { encoding: "utf-8", flag: "wx" });
+    } catch (error) {
+      return {
+        id: "ck-global-dir-writable",
+        name: "Global Dir Writable",
+        group: "claudekit",
+        priority: "standard",
+        status: "fail",
+        message: "Write access denied",
+        details: globalDir,
+        suggestion: "Check file permissions on ~/.claude/",
+        autoFixable: false
+      };
+    }
+    try {
+      await unlink(testFile);
+    } catch (_error) {
+      logger.verbose("Failed to cleanup write test file", { testFile });
+    }
+    return {
+      id: "ck-global-dir-writable",
+      name: "Global Dir Writable",
+      group: "claudekit",
+      priority: "standard",
+      status: "pass",
+      message: "Write access OK",
+      details: globalDir,
+      autoFixable: false
+    };
+  }
+  normalizePath(filePath) {
+    const normalized = normalize2(filePath);
+    const isCaseInsensitive = process.platform === "win32" || process.platform === "darwin";
+    return isCaseInsensitive ? normalized.toLowerCase() : normalized;
+  }
+  async checkHooksExist() {
+    const globalHooksDir = join4(PathResolver.getGlobalKitDir(), "hooks");
+    const projectHooksDir = join4(this.projectDir, ".claude", "hooks");
+    const globalExists = existsSync3(globalHooksDir);
+    const projectExists = existsSync3(projectHooksDir);
+    let hookCount = 0;
+    const checkedFiles = new Set;
+    if (globalExists) {
+      const files = await readdir2(globalHooksDir, { withFileTypes: false });
+      const hooks = files.filter((f3) => HOOK_EXTENSIONS.some((ext) => f3.endsWith(ext)));
+      hooks.forEach((hook) => {
+        const fullPath = join4(globalHooksDir, hook);
+        checkedFiles.add(this.normalizePath(fullPath));
+      });
+    }
+    const normalizedGlobal = this.normalizePath(globalHooksDir);
+    const normalizedProject = this.normalizePath(projectHooksDir);
+    if (projectExists && normalizedProject !== normalizedGlobal) {
+      const files = await readdir2(projectHooksDir, { withFileTypes: false });
+      const hooks = files.filter((f3) => HOOK_EXTENSIONS.some((ext) => f3.endsWith(ext)));
+      hooks.forEach((hook) => {
+        const fullPath = join4(projectHooksDir, hook);
+        checkedFiles.add(this.normalizePath(fullPath));
+      });
+    }
+    hookCount = checkedFiles.size;
+    if (!globalExists && !projectExists) {
+      return {
+        id: "ck-hooks-exist",
+        name: "Hooks Directory",
+        group: "claudekit",
+        priority: "standard",
+        status: "info",
+        message: "No hooks directory",
+        autoFixable: false
+      };
+    }
+    return {
+      id: "ck-hooks-exist",
+      name: "Hooks Directory",
+      group: "claudekit",
+      priority: "standard",
+      status: "pass",
+      message: `${hookCount} hook(s) found`,
+      details: globalExists ? globalHooksDir : projectHooksDir,
+      autoFixable: false
+    };
+  }
+  async checkSettingsValid() {
+    const globalSettings = join4(PathResolver.getGlobalKitDir(), "settings.json");
+    const projectSettings = join4(this.projectDir, ".claude", "settings.json");
+    const settingsPath = existsSync3(globalSettings) ? globalSettings : existsSync3(projectSettings) ? projectSettings : null;
+    if (!settingsPath) {
+      return {
+        id: "ck-settings-valid",
+        name: "Settings.json",
+        group: "claudekit",
+        priority: "extended",
+        status: "info",
+        message: "No settings.json found",
+        autoFixable: false
+      };
+    }
+    try {
+      const content = await readFile3(settingsPath, "utf-8");
+      JSON.parse(content);
+      return {
+        id: "ck-settings-valid",
+        name: "Settings.json",
+        group: "claudekit",
+        priority: "extended",
+        status: "pass",
+        message: "Valid JSON",
+        details: settingsPath,
+        autoFixable: false
+      };
+    } catch (error) {
+      let message = "Invalid JSON";
+      let suggestion = "Fix JSON syntax in settings.json";
+      let details = settingsPath;
+      if (error instanceof SyntaxError) {
+        message = "JSON syntax error";
+        details = `${settingsPath}: ${error.message}`;
+        logger.verbose("Settings.json syntax error", {
+          path: settingsPath,
+          error: error.message
+        });
+      } else if (error instanceof Error) {
+        if (error.message.includes("EACCES") || error.message.includes("EPERM")) {
+          message = "Permission denied";
+          suggestion = "Check file permissions on settings.json";
+        } else if (error.message.includes("ENOENT")) {
+          message = "File not found";
+          suggestion = "Ensure settings.json exists at the expected location";
+        } else {
+          message = `Read error: ${error.message}`;
+          suggestion = "Check file system and permissions";
+        }
+        logger.verbose("Settings.json read error", {
+          path: settingsPath,
+          error: error.message,
+          code: error.code
+        });
+      }
+      return {
+        id: "ck-settings-valid",
+        name: "Settings.json",
+        group: "claudekit",
+        priority: "extended",
+        status: "fail",
+        message,
+        details,
+        suggestion,
+        autoFixable: false
+      };
+    }
+  }
+  async checkPathRefsValid() {
+    const globalClaudeMd = join4(PathResolver.getGlobalKitDir(), "CLAUDE.md");
+    const projectClaudeMd = join4(this.projectDir, ".claude", "CLAUDE.md");
+    const claudeMdPath = existsSync3(globalClaudeMd) ? globalClaudeMd : existsSync3(projectClaudeMd) ? projectClaudeMd : null;
+    if (!claudeMdPath) {
+      return {
+        id: "ck-path-refs-valid",
+        name: "Path References",
+        group: "claudekit",
+        priority: "extended",
+        status: "info",
+        message: "No CLAUDE.md found",
+        autoFixable: false
+      };
+    }
+    try {
+      const content = await readFile3(claudeMdPath, "utf-8");
+      const refPattern = /@([^\s\)]+)/g;
+      const refs = [...content.matchAll(refPattern)].map((m2) => m2[1]);
+      if (refs.length === 0) {
+        return {
+          id: "ck-path-refs-valid",
+          name: "Path References",
+          group: "claudekit",
+          priority: "extended",
+          status: "info",
+          message: "No @path references found",
+          autoFixable: false
+        };
+      }
+      const baseDir = dirname(claudeMdPath);
+      const home = homedir2();
+      const broken = [];
+      for (const ref of refs) {
+        let refPath;
+        if (ref.startsWith("$HOME") || ref.startsWith("%USERPROFILE%")) {
+          refPath = normalize2(ref.replace("$HOME", home).replace("%USERPROFILE%", home));
+        } else if (ref.startsWith("/")) {
+          refPath = normalize2(ref);
+        } else if (ref.includes(":") && ref.startsWith("\\")) {
+          refPath = normalize2(ref);
+        } else {
+          refPath = resolve(baseDir, ref);
+        }
+        const normalizedPath = normalize2(refPath);
+        const isWithinHome = normalizedPath.startsWith(home);
+        const isWithinBase = normalizedPath.startsWith(normalize2(baseDir));
+        const isAbsoluteAllowed = ref.startsWith("/") || ref.includes(":") && ref.startsWith("\\");
+        if (!isWithinHome && !isWithinBase && !isAbsoluteAllowed) {
+          logger.verbose("Skipping potentially unsafe path reference", { ref, refPath });
+          continue;
+        }
+        if (!existsSync3(normalizedPath)) {
+          broken.push(ref);
+        }
+      }
+      if (broken.length > 0) {
+        return {
+          id: "ck-path-refs-valid",
+          name: "Path References",
+          group: "claudekit",
+          priority: "extended",
+          status: "warn",
+          message: `${broken.length}/${refs.length} broken`,
+          details: broken.slice(0, 3).join(", "),
+          suggestion: "Some @path references point to missing files",
+          autoFixable: false
+        };
+      }
+      return {
+        id: "ck-path-refs-valid",
+        name: "Path References",
+        group: "claudekit",
+        priority: "extended",
+        status: "pass",
+        message: `${refs.length} valid`,
+        autoFixable: false
+      };
+    } catch (error) {
+      return {
+        id: "ck-path-refs-valid",
+        name: "Path References",
+        group: "claudekit",
+        priority: "extended",
+        status: "info",
+        message: "Could not parse CLAUDE.md",
+        autoFixable: false
+      };
+    }
+  }
+  async checkProjectConfigCompleteness(setup) {
+    if (setup.project.path === setup.global.path) {
+      return {
+        id: "ck-project-config-complete",
+        name: "Project Config Completeness",
+        group: "claudekit",
+        priority: "standard",
+        status: "info",
+        message: "Not in a project directory",
+        autoFixable: false
+      };
+    }
+    const projectDir = join4(this.projectDir, ".claude");
+    const requiredDirs = ["agents", "commands", "workflows", "skills"];
+    const missingDirs = [];
+    for (const dir of requiredDirs) {
+      const dirPath = join4(projectDir, dir);
+      if (!existsSync3(dirPath)) {
+        missingDirs.push(dir);
+      }
+    }
+    const files = await readdir2(projectDir).catch(() => []);
+    const hasOnlyClaudeMd = files.length === 1 && files.includes("CLAUDE.md");
+    if (hasOnlyClaudeMd || missingDirs.length === requiredDirs.length) {
+      return {
+        id: "ck-project-config-complete",
+        name: "Project Config Completeness",
+        group: "claudekit",
+        priority: "standard",
+        status: "fail",
+        message: "Incomplete configuration",
+        details: "Only CLAUDE.md found - missing agents, commands, workflows, skills",
+        suggestion: "Run 'ck init' to install complete ClaudeKit in project",
+        autoFixable: false
+      };
+    }
+    if (missingDirs.length > 0) {
+      return {
+        id: "ck-project-config-complete",
+        name: "Project Config Completeness",
+        group: "claudekit",
+        priority: "standard",
+        status: "warn",
+        message: `Missing ${missingDirs.length} directories`,
+        details: `Missing: ${missingDirs.join(", ")}`,
+        suggestion: "Run 'ck init' to update project configuration",
+        autoFixable: false
+      };
+    }
+    return {
+      id: "ck-project-config-complete",
+      name: "Project Config Completeness",
+      group: "claudekit",
+      priority: "standard",
+      status: "pass",
+      message: "Complete configuration",
+      details: projectDir,
+      autoFixable: false
+    };
+  }
 }
 // src/lib/health-checks/auth-checker.ts
 init_types2();
@@ -16685,7 +17065,7 @@ import { Octokit } from "@octokit/rest";
 init_zod();
 init_logger();
 import { existsSync as existsSync4 } from "node:fs";
-import { mkdir as mkdir2, readFile as readFile3, unlink, writeFile as writeFile2 } from "node:fs/promises";
+import { mkdir as mkdir2, readFile as readFile4, unlink as unlink2, writeFile as writeFile3 } from "node:fs/promises";
 import { join as join5 } from "node:path";
 var ReleaseCacheEntrySchema = exports_external.object({
   timestamp: exports_external.number(),
@@ -16706,7 +17086,7 @@ class ReleaseCache {
         logger.debug(`Release cache not found for key: ${key}`);
         return null;
       }
-      const content = await readFile3(cacheFile, "utf-8");
+      const content = await readFile4(cacheFile, "utf-8");
       const parsed = JSON.parse(content);
       const cacheEntry = ReleaseCacheEntrySchema.parse(parsed);
       if (this.isExpired(cacheEntry.timestamp)) {
@@ -16732,7 +17112,7 @@ class ReleaseCache {
         timestamp: Date.now(),
         releases
       };
-      await writeFile2(cacheFile, JSON.stringify(cacheEntry, null, 2), "utf-8");
+      await writeFile3(cacheFile, JSON.stringify(cacheEntry, null, 2), "utf-8");
       logger.debug(`Release cache set for key: ${key}, cached ${releases.length} releases`);
     } catch (error) {
       logger.debug(`Failed to set release cache for key ${key}: ${error}`);
@@ -16743,7 +17123,7 @@ class ReleaseCache {
       const cacheFile = this.getCachePath(key);
       try {
         if (existsSync4(cacheFile)) {
-          await unlink(cacheFile);
+          await unlink2(cacheFile);
           logger.debug(`Release cache cleared for key: ${key}`);
         }
       } catch (error) {
@@ -16751,11 +17131,11 @@ class ReleaseCache {
       }
     } else {
       try {
-        const { readdir: readdir2 } = await import("node:fs/promises");
-        const files = await readdir2(this.cacheDir);
+        const { readdir: readdir3 } = await import("node:fs/promises");
+        const files = await readdir3(this.cacheDir);
         for (const file of files) {
           if (file.endsWith(".json")) {
-            await unlink(join5(this.cacheDir, file));
+            await unlink2(join5(this.cacheDir, file));
           }
         }
         logger.debug("All release cache cleared");
@@ -17356,6 +17736,7 @@ class AuthChecker {
     }
   }
   async checkGhToken() {
+    if (false) {}
     try {
       logger.verbose("AuthChecker: Getting GitHub token via AuthManager");
       const { token } = await AuthManager.getToken();
@@ -17448,6 +17829,392 @@ class AuthChecker {
     };
   }
 }
+// src/lib/health-checks/platform-checker.ts
+import { constants as constants2, access as access2, mkdir as mkdir3, readFile as readFile5, symlink, unlink as unlink3, writeFile as writeFile4 } from "node:fs/promises";
+import { arch, homedir as homedir3, platform as platform3 } from "node:os";
+import { join as join6, normalize as normalize3 } from "node:path";
+var IS_WINDOWS = platform3() === "win32";
+
+class PlatformChecker {
+  group = "platform";
+  async run() {
+    const results = [];
+    results.push(await this.checkPlatformDetect());
+    results.push(await this.checkHomeDirResolution());
+    if (IS_WINDOWS) {
+      results.push(await this.checkEnvVarExpansion());
+    }
+    results.push(await this.checkGlobalDirAccess());
+    results.push(await this.checkShellDetection());
+    if (this.isWSL()) {
+      results.push(await this.checkWSLBoundary());
+    }
+    if (IS_WINDOWS) {
+      results.push(await this.checkLongPathSupport());
+      results.push(await this.checkSymlinkSupport());
+    }
+    return results;
+  }
+  isWSL() {
+    return !!process.env.WSL_DISTRO_NAME || process.env.WSLENV !== undefined;
+  }
+  async checkPlatformDetect() {
+    const os = platform3();
+    const architecture = arch();
+    const wslDistro = process.env.WSL_DISTRO_NAME;
+    let message = `${os} (${architecture})`;
+    if (wslDistro)
+      message += ` - WSL: ${wslDistro}`;
+    return {
+      id: "platform-detect",
+      name: "Platform",
+      group: "platform",
+      priority: "standard",
+      status: "info",
+      message,
+      autoFixable: false
+    };
+  }
+  async checkHomeDirResolution() {
+    const nodeHome = normalize3(homedir3());
+    const envHome = normalize3(IS_WINDOWS ? process.env.USERPROFILE || "" : process.env.HOME || "");
+    const match = nodeHome === envHome && envHome !== "";
+    return {
+      id: "home-dir-resolution",
+      name: "Home Directory",
+      group: "platform",
+      priority: "standard",
+      status: match ? "pass" : "warn",
+      message: match ? nodeHome : `Mismatch: Node=${nodeHome}, Env=${envHome || "not set"}`,
+      suggestion: !match ? "homedir() differs from environment. May cause path issues." : undefined,
+      autoFixable: false
+    };
+  }
+  async checkEnvVarExpansion() {
+    const userProfile = process.env.USERPROFILE;
+    if (!userProfile) {
+      return {
+        id: "env-var-expansion",
+        name: "Env Var Expansion",
+        group: "platform",
+        priority: "standard",
+        status: "fail",
+        message: "USERPROFILE not set",
+        suggestion: "Environment variable USERPROFILE is not set",
+        autoFixable: false
+      };
+    }
+    try {
+      await access2(userProfile, constants2.F_OK);
+      return {
+        id: "env-var-expansion",
+        name: "Env Var Expansion",
+        group: "platform",
+        priority: "standard",
+        status: "pass",
+        message: "USERPROFILE expands correctly",
+        details: userProfile,
+        autoFixable: false
+      };
+    } catch {
+      return {
+        id: "env-var-expansion",
+        name: "Env Var Expansion",
+        group: "platform",
+        priority: "standard",
+        status: "fail",
+        message: "USERPROFILE path not accessible",
+        details: userProfile,
+        suggestion: "Check if USERPROFILE directory exists and is accessible",
+        autoFixable: false
+      };
+    }
+  }
+  async checkGlobalDirAccess() {
+    const globalDir = PathResolver.getGlobalKitDir();
+    const testFile = join6(globalDir, ".ck-doctor-access-test");
+    try {
+      await mkdir3(globalDir, { recursive: true });
+      await writeFile4(testFile, "test", "utf-8");
+      const content = await readFile5(testFile, "utf-8");
+      await unlink3(testFile);
+      if (content !== "test")
+        throw new Error("Read mismatch");
+      return {
+        id: "global-dir-access",
+        name: "Global Dir Access",
+        group: "platform",
+        priority: "critical",
+        status: "pass",
+        message: "Read/write OK",
+        details: globalDir,
+        autoFixable: false
+      };
+    } catch (error) {
+      return {
+        id: "global-dir-access",
+        name: "Global Dir Access",
+        group: "platform",
+        priority: "critical",
+        status: "fail",
+        message: `Access denied: ${error instanceof Error ? error.message : "unknown"}`,
+        details: globalDir,
+        suggestion: "Check file permissions on ~/.claude/ directory",
+        autoFixable: false
+      };
+    }
+  }
+  async checkShellDetection() {
+    const shell = process.env.SHELL || process.env.ComSpec || "unknown";
+    let shellName = "Unknown";
+    if (shell.includes("pwsh") || shell.includes("powershell")) {
+      shellName = shell.includes("pwsh") ? "PowerShell Core" : "Windows PowerShell";
+    } else if (shell.includes("cmd")) {
+      shellName = "Command Prompt";
+    } else if (shell.includes("bash")) {
+      shellName = "Bash";
+    } else if (shell.includes("zsh")) {
+      shellName = "Zsh";
+    } else if (shell.includes("fish")) {
+      shellName = "Fish";
+    }
+    return {
+      id: "shell-detection",
+      name: "Shell",
+      group: "platform",
+      priority: "standard",
+      status: "info",
+      message: shellName,
+      details: shell,
+      autoFixable: false
+    };
+  }
+  async checkWSLBoundary() {
+    const cwd = process.cwd();
+    const accessingWindows = cwd.startsWith("/mnt/");
+    return {
+      id: "wsl-boundary",
+      name: "WSL Boundary",
+      group: "platform",
+      priority: "standard",
+      status: accessingWindows ? "warn" : "pass",
+      message: accessingWindows ? "Working in Windows filesystem from WSL" : "Working in native Linux filesystem",
+      details: cwd,
+      suggestion: accessingWindows ? "Performance may be slower. Consider using native Linux paths." : undefined,
+      autoFixable: false
+    };
+  }
+  async checkLongPathSupport() {
+    try {
+      const { execSync: execSync3 } = await import("node:child_process");
+      const result = execSync3('reg query "HKLM\\SYSTEM\\CurrentControlSet\\Control\\FileSystem" /v LongPathsEnabled', { encoding: "utf-8", timeout: 2000 });
+      const enabled = result.includes("0x1");
+      return {
+        id: "long-path-support",
+        name: "Long Path Support",
+        group: "platform",
+        priority: "extended",
+        status: enabled ? "pass" : "warn",
+        message: enabled ? "Enabled" : "Disabled (260 char limit)",
+        suggestion: !enabled ? 'Enable long paths: run as admin: reg add "HKLM\\SYSTEM\\CurrentControlSet\\Control\\FileSystem" /v LongPathsEnabled /t REG_DWORD /d 1 /f' : undefined,
+        autoFixable: false
+      };
+    } catch {
+      return {
+        id: "long-path-support",
+        name: "Long Path Support",
+        group: "platform",
+        priority: "extended",
+        status: "info",
+        message: "Could not determine (requires admin)",
+        autoFixable: false
+      };
+    }
+  }
+  async checkSymlinkSupport() {
+    const testDir = PathResolver.getGlobalKitDir();
+    const target = join6(testDir, ".ck-symlink-test-target");
+    const link = join6(testDir, ".ck-symlink-test-link");
+    try {
+      await mkdir3(testDir, { recursive: true });
+      await writeFile4(target, "test", "utf-8");
+      await symlink(target, link);
+      await unlink3(link);
+      await unlink3(target);
+      return {
+        id: "symlink-support",
+        name: "Symlink Support",
+        group: "platform",
+        priority: "extended",
+        status: "pass",
+        message: "Symlinks work",
+        autoFixable: false
+      };
+    } catch (error) {
+      try {
+        await unlink3(link).catch(() => {});
+        await unlink3(target).catch(() => {});
+      } catch {}
+      return {
+        id: "symlink-support",
+        name: "Symlink Support",
+        group: "platform",
+        priority: "extended",
+        status: "warn",
+        message: "Symlinks not available",
+        suggestion: "Enable Developer Mode or run as admin for symlink support",
+        details: error instanceof Error ? error.message : "unknown error",
+        autoFixable: false
+      };
+    }
+  }
+}
+// src/lib/health-checks/network-checker.ts
+init_logger();
+var NETWORK_TIMEOUT = Number.parseInt(process.env.CLAUDEKIT_NETWORK_TIMEOUT || "3000", 10);
+
+class NetworkChecker {
+  group = "network";
+  async run() {
+    if (this.isCI()) {
+      logger.verbose("NetworkChecker: Skipping in CI environment");
+      return [];
+    }
+    const results = [];
+    results.push(this.checkProxyDetected());
+    results.push(await this.checkGitHubReachable());
+    results.push(await this.checkApiGitHub());
+    return results;
+  }
+  isCI() {
+    return process.env.CI === "true" || process.env.CI_SAFE_MODE === "true" || false || process.env.VITEST === "true" || process.env.JEST_WORKER_ID !== undefined || process.env.TEST === "true";
+  }
+  checkProxyDetected() {
+    const httpProxy = process.env.HTTP_PROXY || process.env.http_proxy;
+    const httpsProxy = process.env.HTTPS_PROXY || process.env.https_proxy;
+    const noProxy = process.env.NO_PROXY || process.env.no_proxy;
+    const hasProxy = !!(httpProxy || httpsProxy);
+    if (!hasProxy) {
+      return {
+        id: "net-proxy-detected",
+        name: "Proxy",
+        group: "network",
+        priority: "standard",
+        status: "info",
+        message: "No proxy configured",
+        autoFixable: false
+      };
+    }
+    const details = [];
+    if (httpProxy)
+      details.push(`HTTP_PROXY=${httpProxy}`);
+    if (httpsProxy)
+      details.push(`HTTPS_PROXY=${httpsProxy}`);
+    if (noProxy)
+      details.push(`NO_PROXY=${noProxy}`);
+    return {
+      id: "net-proxy-detected",
+      name: "Proxy",
+      group: "network",
+      priority: "standard",
+      status: "warn",
+      message: "Proxy detected",
+      details: details.join(", "),
+      suggestion: "Ensure proxy settings allow access to github.com",
+      autoFixable: false
+    };
+  }
+  async checkGitHubReachable() {
+    const startTime = Date.now();
+    try {
+      const response = await fetch("https://github.com", {
+        method: "HEAD",
+        signal: AbortSignal.timeout(NETWORK_TIMEOUT)
+      });
+      const latency = Date.now() - startTime;
+      if (response.ok || response.status === 301 || response.status === 302) {
+        return {
+          id: "net-github-reachable",
+          name: "GitHub",
+          group: "network",
+          priority: "standard",
+          status: "pass",
+          message: `Connected (${latency}ms)`,
+          autoFixable: false
+        };
+      }
+      return {
+        id: "net-github-reachable",
+        name: "GitHub",
+        group: "network",
+        priority: "standard",
+        status: "warn",
+        message: `HTTP ${response.status}`,
+        suggestion: "GitHub returned unexpected status",
+        autoFixable: false
+      };
+    } catch (error) {
+      const isTimeout = error instanceof Error && error.name === "AbortError";
+      return {
+        id: "net-github-reachable",
+        name: "GitHub",
+        group: "network",
+        priority: "standard",
+        status: "fail",
+        message: isTimeout ? `Timeout (>${NETWORK_TIMEOUT}ms)` : "Connection failed",
+        suggestion: "Check internet connection or proxy settings",
+        autoFixable: false
+      };
+    }
+  }
+  async checkApiGitHub() {
+    const startTime = Date.now();
+    try {
+      const response = await fetch("https://api.github.com/rate_limit", {
+        method: "GET",
+        headers: {
+          Accept: "application/vnd.github.v3+json",
+          "User-Agent": "claudekit-cli"
+        },
+        signal: AbortSignal.timeout(NETWORK_TIMEOUT)
+      });
+      const latency = Date.now() - startTime;
+      if (response.ok) {
+        return {
+          id: "net-api-github",
+          name: "GitHub API",
+          group: "network",
+          priority: "standard",
+          status: "pass",
+          message: `Connected (${latency}ms)`,
+          autoFixable: false
+        };
+      }
+      return {
+        id: "net-api-github",
+        name: "GitHub API",
+        group: "network",
+        priority: "standard",
+        status: "warn",
+        message: `HTTP ${response.status}`,
+        suggestion: response.status === 403 ? "Rate limited - wait or authenticate" : "API returned unexpected status",
+        autoFixable: false
+      };
+    } catch (error) {
+      const isTimeout = error instanceof Error && error.name === "AbortError";
+      return {
+        id: "net-api-github",
+        name: "GitHub API",
+        group: "network",
+        priority: "standard",
+        status: "fail",
+        message: isTimeout ? `Timeout (>${NETWORK_TIMEOUT}ms)` : "Connection failed",
+        suggestion: "Check internet connection or proxy settings for api.github.com",
+        autoFixable: false
+      };
+    }
+  }
+}
 // src/lib/health-checks/auto-healer.ts
 class AutoHealer {
   timeout;
@@ -17527,14 +18294,14 @@ init_dist2();
 import { execSync as execSync3, spawnSync } from "node:child_process";
 import { readFileSync as readFileSync3, unlinkSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { dirname, join as join6 } from "node:path";
+import { dirname as dirname2, join as join7 } from "node:path";
 import { fileURLToPath } from "node:url";
 init_environment();
 init_logger();
 function getCliVersion() {
   try {
-    const __dirname2 = dirname(fileURLToPath(import.meta.url));
-    const pkgPath = join6(__dirname2, "../../../package.json");
+    const __dirname2 = dirname2(fileURLToPath(import.meta.url));
+    const pkgPath = join7(__dirname2, "../../../package.json");
     const pkg = JSON.parse(readFileSync3(pkgPath, "utf-8"));
     return pkg.version || "unknown";
   } catch (err) {
@@ -17673,7 +18440,7 @@ class ReportGenerator {
         return null;
       }
     }
-    const tmpFile = join6(tmpdir(), `ck-report-${Date.now()}.txt`);
+    const tmpFile = join7(tmpdir(), `ck-report-${Date.now()}.txt`);
     writeFileSync(tmpFile, report);
     try {
       const result = spawnSync("gh", ["gist", "create", tmpFile, "--desc", "ClaudeKit Diagnostic Report"], {
@@ -17878,12 +18645,13 @@ class DoctorUIRenderer {
 init_environment();
 init_logger();
 async function doctorCommand(options = {}) {
-  const { report, fix, checkOnly, json } = options;
+  const { report, fix, checkOnly, json, full } = options;
   const runnerOptions = {
     fix: fix ?? false,
     checkOnly: checkOnly ?? false,
     json: json ?? false,
-    verbose: logger.isVerbose()
+    verbose: logger.isVerbose(),
+    full: full ?? false
   };
   if (!json && !report) {
     oe("ClaudeKit Health Check");
@@ -17892,6 +18660,8 @@ async function doctorCommand(options = {}) {
   runner.registerChecker(new SystemChecker);
   runner.registerChecker(new ClaudekitChecker);
   runner.registerChecker(new AuthChecker);
+  runner.registerChecker(new PlatformChecker);
+  runner.registerChecker(new NetworkChecker);
   const summary = await runner.run();
   if (json) {
     const generator = new ReportGenerator;
@@ -17946,17 +18716,17 @@ async function doctorCommand(options = {}) {
 
 // src/commands/init.ts
 var import_fs_extra17 = __toESM(require_lib(), 1);
-import { join as join28, resolve as resolve4 } from "node:path";
+import { join as join29, resolve as resolve5 } from "node:path";
 
 // src/lib/commands-prefix.ts
 init_logger();
 var import_fs_extra3 = __toESM(require_lib(), 1);
-import { lstat, mkdir as mkdir3, readdir as readdir2, stat as stat2 } from "node:fs/promises";
-import { join as join8 } from "node:path";
+import { lstat, mkdir as mkdir4, readdir as readdir3, stat as stat2 } from "node:fs/promises";
+import { join as join9 } from "node:path";
 
 // src/utils/manifest-writer.ts
 var import_fs_extra2 = __toESM(require_lib(), 1);
-import { join as join7 } from "node:path";
+import { join as join8 } from "node:path";
 
 // node_modules/yocto-queue/index.js
 class Node {
@@ -18040,24 +18810,24 @@ function pLimit(concurrency) {
     activeCount--;
     resumeNext();
   };
-  const run = async (function_, resolve, arguments_) => {
+  const run = async (function_, resolve2, arguments_) => {
     const result = (async () => function_(...arguments_))();
-    resolve(result);
+    resolve2(result);
     try {
       await result;
     } catch {}
     next();
   };
-  const enqueue = (function_, resolve, arguments_) => {
+  const enqueue = (function_, resolve2, arguments_) => {
     new Promise((internalResolve) => {
       queue.enqueue(internalResolve);
-    }).then(run.bind(undefined, function_, resolve, arguments_));
+    }).then(run.bind(undefined, function_, resolve2, arguments_));
     if (activeCount < concurrency) {
       resumeNext();
     }
   };
-  const generator = (function_, ...arguments_) => new Promise((resolve) => {
-    enqueue(function_, resolve, arguments_);
+  const generator = (function_, ...arguments_) => new Promise((resolve2) => {
+    enqueue(function_, resolve2, arguments_);
   });
   Object.defineProperties(generator, {
     activeCount: {
@@ -18106,12 +18876,12 @@ import { relative } from "node:path";
 
 class OwnershipChecker {
   static async calculateChecksum(filePath) {
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       const hash = createHash("sha256");
       const stream = createReadStream(filePath);
       stream.on("data", (chunk) => hash.update(chunk));
       stream.on("end", () => {
-        resolve(hash.digest("hex"));
+        resolve2(hash.digest("hex"));
       });
       stream.on("error", (err) => {
         stream.destroy();
@@ -18237,7 +19007,7 @@ class ManifestWriter {
     return Array.from(this.trackedFiles.values()).sort((a3, b3) => a3.path.localeCompare(b3.path));
   }
   async writeManifest(claudeDir, kitName, version, scope) {
-    const metadataPath = join7(claudeDir, "metadata.json");
+    const metadataPath = join8(claudeDir, "metadata.json");
     let existingMetadata = {};
     if (await import_fs_extra2.pathExists(metadataPath)) {
       try {
@@ -18263,7 +19033,7 @@ class ManifestWriter {
     logger.debug(`Wrote manifest with ${this.installedFiles.size} installed files, ${trackedFiles.length} tracked`);
   }
   static async readManifest(claudeDir) {
-    const metadataPath = join7(claudeDir, "metadata.json");
+    const metadataPath = join8(claudeDir, "metadata.json");
     if (!await import_fs_extra2.pathExists(metadataPath)) {
       return null;
     }
@@ -18334,22 +19104,22 @@ function validatePath(path, paramName) {
 class CommandsPrefix {
   static async applyPrefix(extractDir) {
     validatePath(extractDir, "extractDir");
-    const commandsDir = join8(extractDir, ".claude", "commands");
+    const commandsDir = join9(extractDir, ".claude", "commands");
     if (!await import_fs_extra3.pathExists(commandsDir)) {
       logger.verbose("No commands directory found, skipping prefix application");
       return;
     }
     logger.info("Applying /ck: prefix to slash commands...");
-    const backupDir = join8(extractDir, ".commands-backup");
-    const tempDir = join8(extractDir, ".commands-prefix-temp");
+    const backupDir = join9(extractDir, ".commands-backup");
+    const tempDir = join9(extractDir, ".commands-prefix-temp");
     try {
-      const entries = await readdir2(commandsDir);
+      const entries = await readdir3(commandsDir);
       if (entries.length === 0) {
         logger.verbose("Commands directory is empty, skipping prefix application");
         return;
       }
       if (entries.length === 1 && entries[0] === "ck") {
-        const ckDir2 = join8(commandsDir, "ck");
+        const ckDir2 = join9(commandsDir, "ck");
         const ckStat = await stat2(ckDir2);
         if (ckStat.isDirectory()) {
           logger.verbose("Commands already have /ck: prefix, skipping");
@@ -18358,18 +19128,18 @@ class CommandsPrefix {
       }
       await import_fs_extra3.copy(commandsDir, backupDir);
       logger.verbose("Created backup of commands directory");
-      await mkdir3(tempDir, { recursive: true });
-      const ckDir = join8(tempDir, "ck");
-      await mkdir3(ckDir, { recursive: true });
+      await mkdir4(tempDir, { recursive: true });
+      const ckDir = join9(tempDir, "ck");
+      await mkdir4(ckDir, { recursive: true });
       let processedCount = 0;
       for (const entry of entries) {
-        const sourcePath = join8(commandsDir, entry);
+        const sourcePath = join9(commandsDir, entry);
         const stats = await lstat(sourcePath);
         if (stats.isSymbolicLink()) {
           logger.warning(`Skipping symlink for security: ${entry}`);
           continue;
         }
-        const destPath = join8(ckDir, entry);
+        const destPath = join9(ckDir, entry);
         await import_fs_extra3.copy(sourcePath, destPath, {
           overwrite: false,
           errorOnExist: true
@@ -18417,8 +19187,8 @@ class CommandsPrefix {
   static async cleanupCommandsDirectory(targetDir, isGlobal, options = {}) {
     const { dryRun = false, forceOverwrite = false } = options;
     validatePath(targetDir, "targetDir");
-    const claudeDir = isGlobal ? targetDir : join8(targetDir, ".claude");
-    const commandsDir = join8(claudeDir, "commands");
+    const claudeDir = isGlobal ? targetDir : join9(targetDir, ".claude");
+    const commandsDir = join9(claudeDir, "commands");
     const result = {
       results: [],
       deletedCount: 0,
@@ -18440,13 +19210,13 @@ class CommandsPrefix {
       logger.verbose("All existing files will be preserved as user-owned");
       return result;
     }
-    const entries = await readdir2(commandsDir);
+    const entries = await readdir3(commandsDir);
     if (entries.length === 0) {
       logger.verbose("Commands directory is empty");
       return result;
     }
     for (const entry of entries) {
-      const entryPath = join8(commandsDir, entry);
+      const entryPath = join9(commandsDir, entry);
       const stats = await lstat(entryPath);
       if (stats.isSymbolicLink()) {
         logger.warning(`Skipping symlink: ${entry}`);
@@ -18610,9 +19380,9 @@ class CommandsPrefix {
   }
   static async scanDirectoryFiles(dir) {
     const files = [];
-    const entries = await readdir2(dir);
+    const entries = await readdir3(dir);
     for (const entry of entries) {
-      const fullPath = join8(dir, entry);
+      const fullPath = join9(dir, entry);
       const stats = await lstat(fullPath);
       if (stats.isSymbolicLink()) {
         continue;
@@ -18634,9 +19404,9 @@ var import_ignore = __toESM(require_ignore(), 1);
 import { Buffer as Buffer3 } from "node:buffer";
 import { execFile } from "node:child_process";
 import { createWriteStream as createWriteStream2 } from "node:fs";
-import { mkdir as mkdir5 } from "node:fs/promises";
+import { mkdir as mkdir6 } from "node:fs/promises";
 import { tmpdir as tmpdir2 } from "node:os";
-import { join as join10, relative as relative2, resolve } from "node:path";
+import { join as join11, relative as relative2, resolve as resolve2 } from "node:path";
 import { TextDecoder } from "node:util";
 
 // node_modules/@isaacs/fs-minipass/dist/esm/index.js
@@ -19185,10 +19955,10 @@ class Minipass extends EventEmitter2 {
     return this[ENCODING] ? buf.join("") : Buffer.concat(buf, buf.dataLength);
   }
   async promise() {
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       this.on(DESTROYED, () => reject(new Error("stream destroyed")));
       this.on("error", (er) => reject(er));
-      this.on("end", () => resolve());
+      this.on("end", () => resolve2());
     });
   }
   [Symbol.asyncIterator]() {
@@ -19207,7 +19977,7 @@ class Minipass extends EventEmitter2 {
         return Promise.resolve({ done: false, value: res });
       if (this[EOF])
         return stop();
-      let resolve;
+      let resolve2;
       let reject;
       const onerr = (er) => {
         this.off("data", ondata);
@@ -19221,19 +19991,19 @@ class Minipass extends EventEmitter2 {
         this.off("end", onend);
         this.off(DESTROYED, ondestroy);
         this.pause();
-        resolve({ value, done: !!this[EOF] });
+        resolve2({ value, done: !!this[EOF] });
       };
       const onend = () => {
         this.off("error", onerr);
         this.off("data", ondata);
         this.off(DESTROYED, ondestroy);
         stop();
-        resolve({ done: true, value: undefined });
+        resolve2({ done: true, value: undefined });
       };
       const ondestroy = () => onerr(new Error("stream destroyed"));
       return new Promise((res2, rej) => {
         reject = rej;
-        resolve = res2;
+        resolve2 = res2;
         this.once(DESTROYED, ondestroy);
         this.once("error", onerr);
         this.once("end", onend);
@@ -19690,7 +20460,7 @@ import path3 from "node:path";
 
 // node_modules/tar/dist/esm/list.js
 import fs3 from "node:fs";
-import { dirname as dirname2, parse as parse2 } from "path";
+import { dirname as dirname3, parse as parse2 } from "path";
 
 // node_modules/tar/dist/esm/options.js
 var argmap = new Map([
@@ -20339,10 +21109,10 @@ class Minipass2 extends EventEmitter3 {
     return this[ENCODING2] ? buf.join("") : Buffer.concat(buf, buf.dataLength);
   }
   async promise() {
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       this.on(DESTROYED2, () => reject(new Error("stream destroyed")));
       this.on("error", (er) => reject(er));
-      this.on("end", () => resolve());
+      this.on("end", () => resolve2());
     });
   }
   [Symbol.asyncIterator]() {
@@ -20361,7 +21131,7 @@ class Minipass2 extends EventEmitter3 {
         return Promise.resolve({ done: false, value: res });
       if (this[EOF2])
         return stop();
-      let resolve;
+      let resolve2;
       let reject;
       const onerr = (er) => {
         this.off("data", ondata);
@@ -20375,19 +21145,19 @@ class Minipass2 extends EventEmitter3 {
         this.off("end", onend);
         this.off(DESTROYED2, ondestroy);
         this.pause();
-        resolve({ value, done: !!this[EOF2] });
+        resolve2({ value, done: !!this[EOF2] });
       };
       const onend = () => {
         this.off("error", onerr);
         this.off("data", ondata);
         this.off(DESTROYED2, ondestroy);
         stop();
-        resolve({ done: true, value: undefined });
+        resolve2({ done: true, value: undefined });
       };
       const ondestroy = () => onerr(new Error("stream destroyed"));
       return new Promise((res2, rej) => {
         reject = rej;
-        resolve = res2;
+        resolve2 = res2;
         this.once(DESTROYED2, ondestroy);
         this.once("error", onerr);
         this.once("end", onend);
@@ -20464,7 +21234,7 @@ import * as realZlib2 from "zlib";
 // node_modules/minizlib/dist/esm/constants.js
 import realZlib from "zlib";
 var realZlibConstants = realZlib.constants || { ZLIB_VERNUM: 4736 };
-var constants = Object.freeze(Object.assign(Object.create(null), {
+var constants3 = Object.freeze(Object.assign(Object.create(null), {
   Z_NO_FLUSH: 0,
   Z_PARTIAL_FLUSH: 1,
   Z_SYNC_FLUSH: 2,
@@ -20743,9 +21513,9 @@ class Zlib extends ZlibBase {
   #strategy;
   constructor(opts, mode) {
     opts = opts || {};
-    opts.flush = opts.flush || constants.Z_NO_FLUSH;
-    opts.finishFlush = opts.finishFlush || constants.Z_FINISH;
-    opts.fullFlushFlag = constants.Z_FULL_FLUSH;
+    opts.flush = opts.flush || constants3.Z_NO_FLUSH;
+    opts.finishFlush = opts.finishFlush || constants3.Z_FINISH;
+    opts.fullFlushFlag = constants3.Z_FULL_FLUSH;
     super(opts, mode);
     this.#level = opts.level;
     this.#strategy = opts.strategy;
@@ -20758,7 +21528,7 @@ class Zlib extends ZlibBase {
     if (!this.handle.params)
       throw new Error("not supported in this implementation");
     if (this.#level !== level || this.#strategy !== strategy) {
-      this.flush(constants.Z_SYNC_FLUSH);
+      this.flush(constants3.Z_SYNC_FLUSH);
       assert(this.handle, "zlib binding closed");
       const origFlush = this.handle.flush;
       this.handle.flush = (flushFlag, cb) => {
@@ -20804,9 +21574,9 @@ class Unzip extends Zlib {
 class Brotli extends ZlibBase {
   constructor(opts, mode) {
     opts = opts || {};
-    opts.flush = opts.flush || constants.BROTLI_OPERATION_PROCESS;
-    opts.finishFlush = opts.finishFlush || constants.BROTLI_OPERATION_FINISH;
-    opts.fullFlushFlag = constants.BROTLI_OPERATION_FLUSH;
+    opts.flush = opts.flush || constants3.BROTLI_OPERATION_PROCESS;
+    opts.finishFlush = opts.finishFlush || constants3.BROTLI_OPERATION_FINISH;
+    opts.fullFlushFlag = constants3.BROTLI_OPERATION_FLUSH;
     super(opts, mode);
   }
 }
@@ -20826,9 +21596,9 @@ class BrotliDecompress extends Brotli {
 class Zstd extends ZlibBase {
   constructor(opts, mode) {
     opts = opts || {};
-    opts.flush = opts.flush || constants.ZSTD_e_continue;
-    opts.finishFlush = opts.finishFlush || constants.ZSTD_e_end;
-    opts.fullFlushFlag = constants.ZSTD_e_flush;
+    opts.flush = opts.flush || constants3.ZSTD_e_continue;
+    opts.finishFlush = opts.finishFlush || constants3.ZSTD_e_end;
+    opts.fullFlushFlag = constants3.ZSTD_e_flush;
     super(opts, mode);
   }
 }
@@ -21815,10 +22585,10 @@ class Minipass3 extends EventEmitter4 {
     return this[ENCODING3] ? buf.join("") : Buffer.concat(buf, buf.dataLength);
   }
   async promise() {
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       this.on(DESTROYED3, () => reject(new Error("stream destroyed")));
       this.on("error", (er) => reject(er));
-      this.on("end", () => resolve());
+      this.on("end", () => resolve2());
     });
   }
   [Symbol.asyncIterator]() {
@@ -21837,7 +22607,7 @@ class Minipass3 extends EventEmitter4 {
         return Promise.resolve({ done: false, value: res });
       if (this[EOF3])
         return stop();
-      let resolve;
+      let resolve2;
       let reject;
       const onerr = (er) => {
         this.off("data", ondata);
@@ -21851,19 +22621,19 @@ class Minipass3 extends EventEmitter4 {
         this.off("end", onend);
         this.off(DESTROYED3, ondestroy);
         this.pause();
-        resolve({ value, done: !!this[EOF3] });
+        resolve2({ value, done: !!this[EOF3] });
       };
       const onend = () => {
         this.off("error", onerr);
         this.off("data", ondata);
         this.off(DESTROYED3, ondestroy);
         stop();
-        resolve({ done: true, value: undefined });
+        resolve2({ done: true, value: undefined });
       };
       const ondestroy = () => onerr(new Error("stream destroyed"));
       return new Promise((res2, rej) => {
         reject = rej;
-        resolve = res2;
+        resolve2 = res2;
         this.once(DESTROYED3, ondestroy);
         this.once("error", onerr);
         this.once("end", onend);
@@ -21935,8 +22705,8 @@ class Minipass3 extends EventEmitter4 {
 }
 
 // node_modules/tar/dist/esm/normalize-windows-path.js
-var platform3 = process.env.TESTING_TAR_FAKE_PLATFORM || process.platform;
-var normalizeWindowsPath = platform3 !== "win32" ? (p) => p : (p) => p && p.replace(/\\/g, "/");
+var platform4 = process.env.TESTING_TAR_FAKE_PLATFORM || process.platform;
+var normalizeWindowsPath = platform4 !== "win32" ? (p) => p : (p) => p && p.replace(/\\/g, "/");
 
 // node_modules/tar/dist/esm/read-entry.js
 class ReadEntry extends Minipass3 {
@@ -22590,7 +23360,7 @@ var filesFilter = (opt, files) => {
       if (m2 !== undefined) {
         ret = m2;
       } else {
-        ret = mapHas(dirname2(file), root);
+        ret = mapHas(dirname3(file), root);
       }
     }
     map.set(file, ret);
@@ -22634,9 +23404,9 @@ var listFile = (opt, _files) => {
   const parse3 = new Parser(opt);
   const readSize = opt.maxReadSize || 16 * 1024 * 1024;
   const file = opt.file;
-  const p = new Promise((resolve, reject) => {
+  const p = new Promise((resolve2, reject) => {
     parse3.on("error", reject);
-    parse3.on("end", resolve);
+    parse3.on("end", resolve2);
     fs3.stat(file, (er, stat3) => {
       if (er) {
         reject(er);
@@ -24134,8 +24904,8 @@ import path6 from "node:path";
 
 // node_modules/tar/dist/esm/get-write-flag.js
 import fs6 from "fs";
-var platform4 = process.env.__FAKE_PLATFORM__ || process.platform;
-var isWindows2 = platform4 === "win32";
+var platform5 = process.env.__FAKE_PLATFORM__ || process.platform;
+var isWindows2 = platform5 === "win32";
 var { O_CREAT, O_TRUNC, O_WRONLY } = fs6.constants;
 var UV_FS_O_FILEMAP = Number(process.env.__FAKE_FS_O_FILENAME__) || fs6.constants.UV_FS_O_FILEMAP || 0;
 var fMapEnabled = isWindows2 && !!UV_FS_O_FILEMAP;
@@ -24247,9 +25017,9 @@ class SymlinkError extends Error {
   symlink;
   syscall = "symlink";
   code = "TAR_SYMLINK_ERROR";
-  constructor(symlink, path5) {
+  constructor(symlink2, path5) {
     super("TAR_SYMLINK_ERROR: Cannot extract through symbolic link");
-    this.symlink = symlink;
+    this.symlink = symlink2;
     this.path = path5;
   }
   get name() {
@@ -24266,7 +25036,7 @@ var checkCwd = (dir, cb) => {
     cb(er);
   });
 };
-var mkdir4 = (dir, opt, cb) => {
+var mkdir5 = (dir, opt, cb) => {
   dir = normalizeWindowsPath(dir);
   const umask = opt.umask ?? 18;
   const mode = opt.mode | 448;
@@ -24275,7 +25045,7 @@ var mkdir4 = (dir, opt, cb) => {
   const gid = opt.gid;
   const doChown = typeof uid === "number" && typeof gid === "number" && (uid !== opt.processUid || gid !== opt.processGid);
   const preserve = opt.preserve;
-  const unlink2 = opt.unlink;
+  const unlink4 = opt.unlink;
   const cwd = normalizeWindowsPath(opt.cwd);
   const done = (er, created) => {
     if (er) {
@@ -24298,30 +25068,30 @@ var mkdir4 = (dir, opt, cb) => {
   }
   const sub = normalizeWindowsPath(path5.relative(cwd, dir));
   const parts = sub.split("/");
-  mkdir_(cwd, parts, mode, unlink2, cwd, undefined, done);
+  mkdir_(cwd, parts, mode, unlink4, cwd, undefined, done);
 };
-var mkdir_ = (base, parts, mode, unlink2, cwd, created, cb) => {
+var mkdir_ = (base, parts, mode, unlink4, cwd, created, cb) => {
   if (!parts.length) {
     return cb(null, created);
   }
   const p = parts.shift();
   const part = normalizeWindowsPath(path5.resolve(base + "/" + p));
-  fs8.mkdir(part, mode, onmkdir(part, parts, mode, unlink2, cwd, created, cb));
+  fs8.mkdir(part, mode, onmkdir(part, parts, mode, unlink4, cwd, created, cb));
 };
-var onmkdir = (part, parts, mode, unlink2, cwd, created, cb) => (er) => {
+var onmkdir = (part, parts, mode, unlink4, cwd, created, cb) => (er) => {
   if (er) {
     fs8.lstat(part, (statEr, st) => {
       if (statEr) {
         statEr.path = statEr.path && normalizeWindowsPath(statEr.path);
         cb(statEr);
       } else if (st.isDirectory()) {
-        mkdir_(part, parts, mode, unlink2, cwd, created, cb);
-      } else if (unlink2) {
+        mkdir_(part, parts, mode, unlink4, cwd, created, cb);
+      } else if (unlink4) {
         fs8.unlink(part, (er2) => {
           if (er2) {
             return cb(er2);
           }
-          fs8.mkdir(part, mode, onmkdir(part, parts, mode, unlink2, cwd, created, cb));
+          fs8.mkdir(part, mode, onmkdir(part, parts, mode, unlink4, cwd, created, cb));
         });
       } else if (st.isSymbolicLink()) {
         return cb(new SymlinkError(part, part + "/" + parts.join("/")));
@@ -24331,7 +25101,7 @@ var onmkdir = (part, parts, mode, unlink2, cwd, created, cb) => (er) => {
     });
   } else {
     created = created || part;
-    mkdir_(part, parts, mode, unlink2, cwd, created, cb);
+    mkdir_(part, parts, mode, unlink4, cwd, created, cb);
   }
 };
 var checkCwdSync = (dir) => {
@@ -24356,7 +25126,7 @@ var mkdirSync = (dir, opt) => {
   const gid = opt.gid;
   const doChown = typeof uid === "number" && typeof gid === "number" && (uid !== opt.processUid || gid !== opt.processGid);
   const preserve = opt.preserve;
-  const unlink2 = opt.unlink;
+  const unlink4 = opt.unlink;
   const cwd = normalizeWindowsPath(opt.cwd);
   const done = (created2) => {
     if (created2 && doChown) {
@@ -24385,7 +25155,7 @@ var mkdirSync = (dir, opt) => {
       const st = fs8.lstatSync(part);
       if (st.isDirectory()) {
         continue;
-      } else if (unlink2) {
+      } else if (unlink4) {
         fs8.unlinkSync(part);
         fs8.mkdirSync(part, mode);
         created = created || part;
@@ -24399,7 +25169,7 @@ var mkdirSync = (dir, opt) => {
 };
 
 // node_modules/tar/dist/esm/path-reservations.js
-import { join as join9 } from "node:path";
+import { join as join10 } from "node:path";
 
 // node_modules/tar/dist/esm/normalize-unicode.js
 var normalizeCache = Object.create(null);
@@ -24426,13 +25196,13 @@ var normalizeUnicode = (s) => {
 };
 
 // node_modules/tar/dist/esm/path-reservations.js
-var platform5 = process.env.TESTING_TAR_FAKE_PLATFORM || process.platform;
-var isWindows3 = platform5 === "win32";
+var platform6 = process.env.TESTING_TAR_FAKE_PLATFORM || process.platform;
+var isWindows3 = platform6 === "win32";
 var getDirs = (path6) => {
   const dirs = path6.split("/").slice(0, -1).reduce((set, path7) => {
     const s = set[set.length - 1];
     if (s !== undefined) {
-      path7 = join9(s, path7);
+      path7 = join10(s, path7);
     }
     set.push(path7 || "/");
     return set;
@@ -24446,7 +25216,7 @@ class PathReservations {
   #running = new Set;
   reserve(paths, fn) {
     paths = isWindows3 ? ["win32 parallelization disabled"] : paths.map((p) => {
-      return stripTrailingSlashes(join9(normalizeUnicode(p))).toLowerCase();
+      return stripTrailingSlashes(join10(normalizeUnicode(p))).toLowerCase();
     });
     const dirs = new Set(paths.map((path6) => getDirs(path6)).reduce((a3, b3) => a3.concat(b3)));
     this.#reservations.set(fn, { dirs, paths });
@@ -24573,8 +25343,8 @@ var DOCHOWN = Symbol("doChown");
 var UID = Symbol("uid");
 var GID = Symbol("gid");
 var CHECKED_CWD = Symbol("checkedCwd");
-var platform6 = process.env.TESTING_TAR_FAKE_PLATFORM || process.platform;
-var isWindows4 = platform6 === "win32";
+var platform7 = process.env.TESTING_TAR_FAKE_PLATFORM || process.platform;
+var isWindows4 = platform7 === "win32";
 var DEFAULT_MAX_DEPTH = 1024;
 var unlinkFile = (path7, cb) => {
   if (!isWindows4) {
@@ -24789,7 +25559,7 @@ class Unpack extends Parser {
     }
   }
   [MKDIR](dir, mode, cb) {
-    mkdir4(normalizeWindowsPath(dir), {
+    mkdir5(normalizeWindowsPath(dir), {
       uid: this.uid,
       gid: this.gid,
       processUid: this.processUid,
@@ -25216,9 +25986,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((resolve, reject) => {
+  const p = new Promise((resolve2, reject) => {
     u.on("error", reject);
-    u.on("close", resolve);
+    u.on("close", resolve2);
     fs10.stat(file, (er, stat3) => {
       if (er) {
         reject(er);
@@ -25351,7 +26121,7 @@ var replaceAsync = (opt, files) => {
     };
     fs11.read(fd, headBuf, 0, 512, position, onread);
   };
-  const promise = new Promise((resolve, reject) => {
+  const promise = new Promise((resolve2, reject) => {
     p.on("error", reject);
     let flag = "r+";
     const onopen = (er, fd) => {
@@ -25376,7 +26146,7 @@ var replaceAsync = (opt, files) => {
           });
           p.pipe(stream);
           stream.on("error", reject);
-          stream.on("close", resolve);
+          stream.on("close", resolve2);
           addFilesAsync2(p, files);
         });
       });
@@ -26843,8 +27613,8 @@ class DownloadManager {
     }
   }
   isPathSafe(basePath, targetPath) {
-    const resolvedBase = resolve(basePath);
-    const resolvedTarget = resolve(targetPath);
+    const resolvedBase = resolve2(basePath);
+    const resolvedTarget = resolve2(targetPath);
     const relativePath = relative2(resolvedBase, resolvedTarget);
     return !relativePath.startsWith("..") && !relativePath.startsWith("/") && resolvedTarget.startsWith(resolvedBase);
   }
@@ -26859,8 +27629,8 @@ class DownloadManager {
   }
   async downloadAsset(asset, destDir) {
     try {
-      const destPath = join10(destDir, asset.name);
-      await mkdir5(destDir, { recursive: true });
+      const destPath = join11(destDir, asset.name);
+      await mkdir6(destDir, { recursive: true });
       logger.info(`Downloading ${asset.name} (${this.formatBytes(asset.size)})...`);
       const progressBar = new import_cli_progress.default.SingleBar({
         format: "Progress |{bar}| {percentage}% | {value}/{total} MB",
@@ -26909,8 +27679,8 @@ class DownloadManager {
   }
   async downloadFile(params) {
     const { url, name: name2, size, destDir, token } = params;
-    const destPath = join10(destDir, name2);
-    await mkdir5(destDir, { recursive: true });
+    const destPath = join11(destDir, name2);
+    await mkdir6(destDir, { recursive: true });
     logger.info(`Downloading ${name2}${size ? ` (${this.formatBytes(size)})` : ""}...`);
     const headers = {};
     if (token && url.includes("api.github.com")) {
@@ -26974,7 +27744,7 @@ class DownloadManager {
     try {
       this.resetExtractionSize();
       const detectedType = archiveType || this.detectArchiveType(archivePath);
-      await mkdir5(destDir, { recursive: true });
+      await mkdir6(destDir, { recursive: true });
       if (detectedType === "tar.gz") {
         await this.extractTarGz(archivePath, destDir);
       } else if (detectedType === "zip") {
@@ -26994,7 +27764,7 @@ class DownloadManager {
     }
   }
   async extractTarGz(archivePath, destDir) {
-    const { readdir: readdir3, stat: stat3, mkdir: mkdirPromise, copyFile, rm } = await import("node:fs/promises");
+    const { readdir: readdir4, stat: stat3, mkdir: mkdirPromise, copyFile, rm } = await import("node:fs/promises");
     const { join: pathJoin } = await import("node:path");
     const tempExtractDir = `${destDir}-temp`;
     await mkdirPromise(tempExtractDir, { recursive: true });
@@ -27013,14 +27783,14 @@ class DownloadManager {
         }
       });
       logger.debug(`Extracted TAR.GZ to temp: ${tempExtractDir}`);
-      const entries = await readdir3(tempExtractDir, { encoding: "utf8" });
+      const entries = await readdir4(tempExtractDir, { encoding: "utf8" });
       logger.debug(`Root entries: ${entries.join(", ")}`);
       if (entries.length === 1) {
         const rootEntry = entries[0];
         const rootPath = pathJoin(tempExtractDir, rootEntry);
         const rootStat = await stat3(rootPath);
         if (rootStat.isDirectory()) {
-          const rootContents = await readdir3(rootPath, { encoding: "utf8" });
+          const rootContents = await readdir4(rootPath, { encoding: "utf8" });
           logger.debug(`Root directory '${rootEntry}' contains: ${rootContents.join(", ")}`);
           const isWrapper = this.isWrapperDirectory(rootEntry);
           logger.debug(`Is wrapper directory: ${isWrapper}`);
@@ -27057,26 +27827,26 @@ class DownloadManager {
     if (!isMacOS()) {
       return false;
     }
-    return new Promise((resolve2) => {
+    return new Promise((resolve3) => {
       const { mkdir: mkdirPromise } = __require("node:fs/promises");
       mkdirPromise(destDir, { recursive: true }).then(() => {
         execFile("unzip", ["-o", "-q", archivePath, "-d", destDir], (error, _stdout, stderr) => {
           if (error) {
             logger.debug(`Native unzip failed: ${stderr || error.message}`);
-            resolve2(false);
+            resolve3(false);
             return;
           }
           logger.debug("Native unzip succeeded");
-          resolve2(true);
+          resolve3(true);
         });
       }).catch((err) => {
         logger.debug(`Failed to create directory for native unzip: ${err.message}`);
-        resolve2(false);
+        resolve3(false);
       });
     });
   }
   async extractZip(archivePath, destDir) {
-    const { readdir: readdir3, stat: stat3, mkdir: mkdirPromise, copyFile, rm } = await import("node:fs/promises");
+    const { readdir: readdir4, stat: stat3, mkdir: mkdirPromise, copyFile, rm } = await import("node:fs/promises");
     const { join: pathJoin } = await import("node:path");
     const tempExtractDir = `${destDir}-temp`;
     await mkdirPromise(tempExtractDir, { recursive: true });
@@ -27095,14 +27865,14 @@ class DownloadManager {
         await import_extract_zip.default(archivePath, zipOptions);
       }
       logger.debug(`Extracted ZIP to temp: ${tempExtractDir}`);
-      const entries = await readdir3(tempExtractDir, { encoding: "utf8" });
+      const entries = await readdir4(tempExtractDir, { encoding: "utf8" });
       logger.debug(`Root entries: ${entries.join(", ")}`);
       if (entries.length === 1) {
         const rootEntry = entries[0];
         const rootPath = pathJoin(tempExtractDir, rootEntry);
         const rootStat = await stat3(rootPath);
         if (rootStat.isDirectory()) {
-          const rootContents = await readdir3(rootPath, { encoding: "utf8" });
+          const rootContents = await readdir4(rootPath, { encoding: "utf8" });
           logger.debug(`Root directory '${rootEntry}' contains: ${rootContents.join(", ")}`);
           const isWrapper = this.isWrapperDirectory(rootEntry);
           logger.debug(`Is wrapper directory: ${isWrapper}`);
@@ -27131,10 +27901,10 @@ class DownloadManager {
     }
   }
   async moveDirectoryContents(sourceDir, destDir) {
-    const { readdir: readdir3, stat: stat3, mkdir: mkdirPromise, copyFile } = await import("node:fs/promises");
+    const { readdir: readdir4, stat: stat3, mkdir: mkdirPromise, copyFile } = await import("node:fs/promises");
     const { join: pathJoin, relative: relative3 } = await import("node:path");
     await mkdirPromise(destDir, { recursive: true });
-    const entries = await readdir3(sourceDir, { encoding: "utf8" });
+    const entries = await readdir4(sourceDir, { encoding: "utf8" });
     for (const entry of entries) {
       const sourcePath = pathJoin(sourceDir, entry);
       const destPath = pathJoin(destDir, entry);
@@ -27157,10 +27927,10 @@ class DownloadManager {
     }
   }
   async copyDirectory(sourceDir, destDir) {
-    const { readdir: readdir3, stat: stat3, mkdir: mkdirPromise, copyFile } = await import("node:fs/promises");
+    const { readdir: readdir4, stat: stat3, mkdir: mkdirPromise, copyFile } = await import("node:fs/promises");
     const { join: pathJoin, relative: relative3 } = await import("node:path");
     await mkdirPromise(destDir, { recursive: true });
-    const entries = await readdir3(sourceDir, { encoding: "utf8" });
+    const entries = await readdir4(sourceDir, { encoding: "utf8" });
     for (const entry of entries) {
       const sourcePath = pathJoin(sourceDir, entry);
       const destPath = pathJoin(destDir, entry);
@@ -27192,11 +27962,11 @@ class DownloadManager {
     throw new ExtractionError(`Cannot detect archive type from filename: ${filename}`);
   }
   async validateExtraction(extractDir) {
-    const { readdir: readdir3, access } = await import("node:fs/promises");
+    const { readdir: readdir4, access: access3 } = await import("node:fs/promises");
     const { join: pathJoin } = await import("node:path");
-    const { constants: constants2 } = await import("node:fs");
+    const { constants: constants4 } = await import("node:fs");
     try {
-      const entries = await readdir3(extractDir, { encoding: "utf8" });
+      const entries = await readdir4(extractDir, { encoding: "utf8" });
       logger.debug(`Extracted files: ${entries.join(", ")}`);
       if (entries.length === 0) {
         throw new ExtractionError("Extraction resulted in no files");
@@ -27205,7 +27975,7 @@ class DownloadManager {
       const missingPaths = [];
       for (const path8 of criticalPaths) {
         try {
-          await access(pathJoin(extractDir, path8), constants2.F_OK);
+          await access3(pathJoin(extractDir, path8), constants4.F_OK);
           logger.debug(`✓ Found: ${path8}`);
         } catch {
           logger.warning(`Expected path not found: ${path8}`);
@@ -27226,9 +27996,9 @@ class DownloadManager {
   async createTempDir() {
     const timestamp = Date.now();
     const counter = DownloadManager.tempDirCounter++;
-    const primaryTempDir = join10(tmpdir2(), `claudekit-${timestamp}-${counter}`);
+    const primaryTempDir = join11(tmpdir2(), `claudekit-${timestamp}-${counter}`);
     try {
-      await mkdir5(primaryTempDir, { recursive: true });
+      await mkdir6(primaryTempDir, { recursive: true });
       logger.debug(`Created temp directory: ${primaryTempDir}`);
       return primaryTempDir;
     } catch (primaryError) {
@@ -27242,9 +28012,9 @@ Solutions:
   2. Set HOME environment variable
   3. Try running from a different directory`);
       }
-      const fallbackTempDir = join10(homeDir, ".claudekit", "tmp", `claudekit-${timestamp}-${counter}`);
+      const fallbackTempDir = join11(homeDir, ".claudekit", "tmp", `claudekit-${timestamp}-${counter}`);
       try {
-        await mkdir5(fallbackTempDir, { recursive: true });
+        await mkdir6(fallbackTempDir, { recursive: true });
         logger.debug(`Created temp directory (fallback): ${fallbackTempDir}`);
         logger.warning(`Using fallback temp directory: ${fallbackTempDir}
   (OS temp directory was not accessible)`);
@@ -27279,8 +28049,8 @@ Solutions:
 init_types2();
 init_logger();
 var import_fs_extra4 = __toESM(require_lib(), 1);
-import { readFile as readFile5, readdir as readdir3, rename, writeFile as writeFile4 } from "node:fs/promises";
-import { join as join11, relative as relative3 } from "node:path";
+import { readFile as readFile7, readdir as readdir4, rename, writeFile as writeFile6 } from "node:fs/promises";
+import { join as join12, relative as relative3 } from "node:path";
 var TRANSFORMABLE_FILE_PATTERNS = [
   ".md",
   ".txt",
@@ -27326,34 +28096,34 @@ async function transformFolderPaths(extractDir, folders, options = {}) {
   }
   const dirsToRename = [];
   if (folders.docs !== DEFAULT_FOLDERS.docs) {
-    const docsPath = join11(extractDir, DEFAULT_FOLDERS.docs);
+    const docsPath = join12(extractDir, DEFAULT_FOLDERS.docs);
     if (await import_fs_extra4.pathExists(docsPath)) {
       dirsToRename.push({
         from: docsPath,
-        to: join11(extractDir, folders.docs)
+        to: join12(extractDir, folders.docs)
       });
     }
-    const claudeDocsPath = join11(extractDir, ".claude", DEFAULT_FOLDERS.docs);
+    const claudeDocsPath = join12(extractDir, ".claude", DEFAULT_FOLDERS.docs);
     if (await import_fs_extra4.pathExists(claudeDocsPath)) {
       dirsToRename.push({
         from: claudeDocsPath,
-        to: join11(extractDir, ".claude", folders.docs)
+        to: join12(extractDir, ".claude", folders.docs)
       });
     }
   }
   if (folders.plans !== DEFAULT_FOLDERS.plans) {
-    const plansPath = join11(extractDir, DEFAULT_FOLDERS.plans);
+    const plansPath = join12(extractDir, DEFAULT_FOLDERS.plans);
     if (await import_fs_extra4.pathExists(plansPath)) {
       dirsToRename.push({
         from: plansPath,
-        to: join11(extractDir, folders.plans)
+        to: join12(extractDir, folders.plans)
       });
     }
-    const claudePlansPath = join11(extractDir, ".claude", DEFAULT_FOLDERS.plans);
+    const claudePlansPath = join12(extractDir, ".claude", DEFAULT_FOLDERS.plans);
     if (await import_fs_extra4.pathExists(claudePlansPath)) {
       dirsToRename.push({
         from: claudePlansPath,
-        to: join11(extractDir, ".claude", folders.plans)
+        to: join12(extractDir, ".claude", folders.plans)
       });
     }
   }
@@ -27388,9 +28158,9 @@ async function transformFolderPaths(extractDir, folders, options = {}) {
 async function transformFileContents(dir, compiledReplacements, options) {
   let filesChanged = 0;
   let replacementsCount = 0;
-  const entries = await readdir3(dir, { withFileTypes: true });
+  const entries = await readdir4(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = join11(dir, entry.name);
+    const fullPath = join12(dir, entry.name);
     if (entry.isDirectory()) {
       if (entry.name === "node_modules" || entry.name === ".git") {
         continue;
@@ -27403,7 +28173,7 @@ async function transformFileContents(dir, compiledReplacements, options) {
       if (!shouldTransform)
         continue;
       try {
-        const content = await readFile5(fullPath, "utf-8");
+        const content = await readFile7(fullPath, "utf-8");
         let newContent = content;
         let changeCount = 0;
         for (const { regex: regex2, replacement } of compiledReplacements) {
@@ -27419,7 +28189,7 @@ async function transformFileContents(dir, compiledReplacements, options) {
           if (options.dryRun) {
             logger.debug(`[dry-run] Would update ${relative3(dir, fullPath)}: ${changeCount} replacement(s)`);
           } else {
-            await writeFile4(fullPath, newContent, "utf-8");
+            await writeFile6(fullPath, newContent, "utf-8");
             logger.debug(`Updated ${relative3(dir, fullPath)}: ${changeCount} replacement(s)`);
           }
           filesChanged++;
@@ -27500,7 +28270,7 @@ function validateFolderName(name2) {
 // src/lib/fresh-installer.ts
 init_logger();
 var import_fs_extra5 = __toESM(require_lib(), 1);
-import { join as join12 } from "node:path";
+import { join as join13 } from "node:path";
 var CLAUDEKIT_SUBDIRECTORIES = ["commands", "agents", "skills", "workflows", "hooks"];
 async function handleFreshInstallation(claudeDir, prompts) {
   if (!await import_fs_extra5.pathExists(claudeDir)) {
@@ -27518,7 +28288,7 @@ async function handleFreshInstallation(claudeDir, prompts) {
     const { rmSync } = await import("node:fs");
     let removedCount = 0;
     for (const subdir of CLAUDEKIT_SUBDIRECTORIES) {
-      const subdirPath = join12(claudeDir, subdir);
+      const subdirPath = join13(claudeDir, subdir);
       if (await import_fs_extra5.pathExists(subdirPath)) {
         rmSync(subdirPath, { recursive: true, force: true });
         removedCount++;
@@ -27535,11 +28305,11 @@ async function handleFreshInstallation(claudeDir, prompts) {
 
 // src/lib/global-path-transformer.ts
 init_logger();
-import { readFile as readFile6, readdir as readdir4, writeFile as writeFile5 } from "node:fs/promises";
-import { platform as platform7 } from "node:os";
-import { extname, join as join13 } from "node:path";
-var IS_WINDOWS = platform7() === "win32";
-var HOME_PREFIX = IS_WINDOWS ? "%USERPROFILE%" : "$HOME";
+import { readFile as readFile8, readdir as readdir5, writeFile as writeFile7 } from "node:fs/promises";
+import { platform as platform8 } from "node:os";
+import { extname, join as join14 } from "node:path";
+var IS_WINDOWS2 = platform8() === "win32";
+var HOME_PREFIX = IS_WINDOWS2 ? "%USERPROFILE%" : "$HOME";
 function getHomeDirPrefix() {
   return HOME_PREFIX;
 }
@@ -27560,7 +28330,7 @@ function transformContent(content) {
   let transformed = content;
   const homePrefix = getHomeDirPrefix();
   const claudePath = `${homePrefix}/.claude/`;
-  if (IS_WINDOWS) {
+  if (IS_WINDOWS2) {
     transformed = transformed.replace(/\$HOME\/\.claude\//g, () => {
       changes++;
       return claudePath;
@@ -27627,9 +28397,9 @@ async function transformPathsForGlobalInstall(directory, options = {}) {
   let filesSkipped = 0;
   const skippedFiles = [];
   async function processDirectory(dir) {
-    const entries = await readdir4(dir, { withFileTypes: true });
+    const entries = await readdir5(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join13(dir, entry.name);
+      const fullPath = join14(dir, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name.startsWith(".") && entry.name !== ".claude") {
           continue;
@@ -27637,10 +28407,10 @@ async function transformPathsForGlobalInstall(directory, options = {}) {
         await processDirectory(fullPath);
       } else if (entry.isFile() && shouldTransformFile(entry.name)) {
         try {
-          const content = await readFile6(fullPath, "utf-8");
+          const content = await readFile8(fullPath, "utf-8");
           const { transformed, changes } = transformContent(content);
           if (changes > 0) {
-            await writeFile5(fullPath, transformed, "utf-8");
+            await writeFile7(fullPath, transformed, "utf-8");
             filesTransformed++;
             totalChanges += changes;
             if (options.verbose) {
@@ -27670,7 +28440,7 @@ async function transformPathsForGlobalInstall(directory, options = {}) {
 init_dist2();
 var import_fs_extra6 = __toESM(require_lib(), 1);
 var import_ignore2 = __toESM(require_ignore(), 1);
-import { dirname as dirname3, join as join14, relative as relative4 } from "node:path";
+import { dirname as dirname4, join as join15, relative as relative4 } from "node:path";
 
 // node_modules/@isaacs/balanced-match/dist/esm/index.js
 var balanced = (a3, b3, str) => {
@@ -29146,7 +29916,7 @@ class FileMerger {
     for (const file of files) {
       const relativePath = relative4(sourceDir, file);
       const normalizedRelativePath = relativePath.replace(/\\/g, "/");
-      const destPath = join14(destDir, relativePath);
+      const destPath = join15(destDir, relativePath);
       if (await import_fs_extra6.pathExists(destPath)) {
         if (this.neverCopyChecker.ignores(normalizedRelativePath)) {
           logger.debug(`Security-sensitive file exists but won't be overwritten: ${normalizedRelativePath}`);
@@ -29168,7 +29938,7 @@ class FileMerger {
     for (const file of files) {
       const relativePath = relative4(sourceDir, file);
       const normalizedRelativePath = relativePath.replace(/\\/g, "/");
-      const destPath = join14(destDir, relativePath);
+      const destPath = join15(destDir, relativePath);
       if (this.neverCopyChecker.ignores(normalizedRelativePath)) {
         logger.debug(`Skipping security-sensitive file: ${normalizedRelativePath}`);
         skippedCount++;
@@ -29238,7 +30008,7 @@ class FileMerger {
     const files = [];
     const entries = await import_fs_extra6.readdir(dir, { encoding: "utf8" });
     for (const entry of entries) {
-      const fullPath = join14(dir, entry);
+      const fullPath = join15(dir, entry);
       const relativePath = relative4(baseDir, fullPath);
       const normalizedRelativePath = relativePath.replace(/\\/g, "/");
       const stats = await import_fs_extra6.lstat(fullPath);
@@ -29289,10 +30059,10 @@ class FileMerger {
   }
   trackInstalledFile(relativePath) {
     this.installedFiles.add(relativePath);
-    let dir = dirname3(relativePath);
+    let dir = dirname4(relativePath);
     while (dir && dir !== "." && dir !== "/") {
       this.installedDirectories.add(`${dir}/`);
-      dir = dirname3(dir);
+      dir = dirname4(dir);
     }
   }
 }
@@ -29300,14 +30070,14 @@ class FileMerger {
 // src/lib/migration/legacy-migration.ts
 init_logger();
 var import_fs_extra8 = __toESM(require_lib(), 1);
-import { readdir as readdir6, stat as stat3 } from "node:fs/promises";
-import { join as join16, relative as relative5 } from "node:path";
+import { readdir as readdir7, stat as stat3 } from "node:fs/promises";
+import { join as join17, relative as relative5 } from "node:path";
 
 // src/lib/migration/release-manifest.ts
 init_zod();
 init_logger();
 var import_fs_extra7 = __toESM(require_lib(), 1);
-import { join as join15 } from "node:path";
+import { join as join16 } from "node:path";
 var ReleaseManifestFileSchema = exports_external.object({
   path: exports_external.string(),
   checksum: exports_external.string().regex(/^[a-f0-9]{64}$/),
@@ -29321,7 +30091,7 @@ var ReleaseManifestSchema = exports_external.object({
 
 class ReleaseManifestLoader {
   static async load(extractDir) {
-    const manifestPath = join15(extractDir, "release-manifest.json");
+    const manifestPath = join16(extractDir, "release-manifest.json");
     try {
       const content = await import_fs_extra7.readFile(manifestPath, "utf-8");
       const parsed = JSON.parse(content);
@@ -29352,7 +30122,7 @@ class LegacyMigration {
     const files = [];
     let entries;
     try {
-      entries = await readdir6(dir);
+      entries = await readdir7(dir);
     } catch (err) {
       const error = err;
       if (error.code === "ENOENT") {
@@ -29367,7 +30137,7 @@ class LegacyMigration {
     for (const entry of entries) {
       if (entry === "metadata.json")
         continue;
-      const fullPath = join16(dir, entry);
+      const fullPath = join17(dir, entry);
       let stats;
       try {
         stats = await stat3(fullPath);
@@ -29469,7 +30239,7 @@ User-created files (sample):`);
     ];
     if (filesToChecksum.length > 0) {
       const checksumResults = await Promise.all(filesToChecksum.map(async ({ relativePath, ownership }) => {
-        const fullPath = join16(claudeDir, relativePath);
+        const fullPath = join17(claudeDir, relativePath);
         const checksum = await OwnershipChecker.calculateChecksum(fullPath);
         return { relativePath, checksum, ownership };
       }));
@@ -29490,7 +30260,7 @@ User-created files (sample):`);
       installedAt: new Date().toISOString(),
       files: trackedFiles
     };
-    const metadataPath = join16(claudeDir, "metadata.json");
+    const metadataPath = join17(claudeDir, "metadata.json");
     await import_fs_extra8.writeFile(metadataPath, JSON.stringify(updatedMetadata, null, 2));
     logger.success(`Migration complete: tracked ${trackedFiles.length} files`);
     return true;
@@ -30099,11 +30869,11 @@ class PromptsManager {
 init_dist2();
 init_logger();
 var import_fs_extra10 = __toESM(require_lib(), 1);
-import { join as join20 } from "node:path";
+import { join as join21 } from "node:path";
 
 // src/lib/config-generator.ts
 var import_fs_extra9 = __toESM(require_lib(), 1);
-import { join as join19 } from "node:path";
+import { join as join20 } from "node:path";
 async function generateEnvFile(targetDir, values) {
   const lines = [
     "# Generated by ClaudeKit CLI setup wizard",
@@ -30115,7 +30885,7 @@ async function generateEnvFile(targetDir, values) {
       lines.push(`${key}=${value}`);
     }
   }
-  const envPath = join19(targetDir, ".env");
+  const envPath = join20(targetDir, ".env");
   await import_fs_extra9.writeFile(envPath, `${lines.join(`
 `)}
 `, { mode: 384 });
@@ -30186,7 +30956,7 @@ async function parseEnvFile(path9) {
   }
 }
 async function checkGlobalConfig() {
-  const globalEnvPath = join20(PathResolver.getGlobalKitDir(), ".env");
+  const globalEnvPath = join21(PathResolver.getGlobalKitDir(), ".env");
   if (!await import_fs_extra10.pathExists(globalEnvPath))
     return false;
   const env2 = await parseEnvFile(globalEnvPath);
@@ -30202,7 +30972,7 @@ async function runSetupWizard(options) {
   let globalEnv = {};
   const hasGlobalConfig = !isGlobal && await checkGlobalConfig();
   if (!isGlobal) {
-    const globalEnvPath = join20(PathResolver.getGlobalKitDir(), ".env");
+    const globalEnvPath = join21(PathResolver.getGlobalKitDir(), ".env");
     if (await import_fs_extra10.pathExists(globalEnvPath)) {
       globalEnv = await parseEnvFile(globalEnvPath);
     }
@@ -30255,23 +31025,23 @@ async function runSetupWizard(options) {
     }
   }
   await generateEnvFile(targetDir, values);
-  f2.success(`Configuration saved to ${join20(targetDir, ".env")}`);
+  f2.success(`Configuration saved to ${join21(targetDir, ".env")}`);
   return true;
 }
 
 // src/lib/skills-detector.ts
 init_logger();
 var import_fs_extra12 = __toESM(require_lib(), 1);
-import { readdir as readdir8 } from "node:fs/promises";
-import { join as join22 } from "node:path";
+import { readdir as readdir9 } from "node:fs/promises";
+import { join as join23 } from "node:path";
 
 // src/lib/skills-manifest.ts
 init_types2();
 init_logger();
 var import_fs_extra11 = __toESM(require_lib(), 1);
 import { createHash as createHash2 } from "node:crypto";
-import { readFile as readFile10, readdir as readdir7, writeFile as writeFile9 } from "node:fs/promises";
-import { join as join21, relative as relative6 } from "node:path";
+import { readFile as readFile12, readdir as readdir8, writeFile as writeFile11 } from "node:fs/promises";
+import { join as join22, relative as relative6 } from "node:path";
 
 class SkillsManifestManager {
   static MANIFEST_FILENAME = ".skills-manifest.json";
@@ -30293,18 +31063,18 @@ class SkillsManifestManager {
     return manifest;
   }
   static async writeManifest(skillsDir, manifest) {
-    const manifestPath = join21(skillsDir, SkillsManifestManager.MANIFEST_FILENAME);
-    await writeFile9(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
+    const manifestPath = join22(skillsDir, SkillsManifestManager.MANIFEST_FILENAME);
+    await writeFile11(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
     logger.debug(`Wrote manifest to: ${manifestPath}`);
   }
   static async readManifest(skillsDir) {
-    const manifestPath = join21(skillsDir, SkillsManifestManager.MANIFEST_FILENAME);
+    const manifestPath = join22(skillsDir, SkillsManifestManager.MANIFEST_FILENAME);
     if (!await import_fs_extra11.pathExists(manifestPath)) {
       logger.debug(`No manifest found at: ${manifestPath}`);
       return null;
     }
     try {
-      const content = await readFile10(manifestPath, "utf-8");
+      const content = await readFile12(manifestPath, "utf-8");
       const data = JSON.parse(content);
       const manifest = SkillsManifestSchema.parse(data);
       logger.debug(`Read manifest from: ${manifestPath}`);
@@ -30315,14 +31085,14 @@ class SkillsManifestManager {
     }
   }
   static async detectStructure(skillsDir) {
-    const entries = await readdir7(skillsDir, { withFileTypes: true });
+    const entries = await readdir8(skillsDir, { withFileTypes: true });
     const dirs = entries.filter((entry) => entry.isDirectory() && entry.name !== "node_modules" && !entry.name.startsWith("."));
     if (dirs.length === 0) {
       return "flat";
     }
     for (const dir of dirs.slice(0, 3)) {
-      const dirPath = join21(skillsDir, dir.name);
-      const subEntries = await readdir7(dirPath, { withFileTypes: true });
+      const dirPath = join22(skillsDir, dir.name);
+      const subEntries = await readdir8(dirPath, { withFileTypes: true });
       const hasSubdirs = subEntries.some((entry) => entry.isDirectory());
       if (hasSubdirs) {
         return "categorized";
@@ -30337,10 +31107,10 @@ class SkillsManifestManager {
   static async scanSkills(skillsDir, structure) {
     const skills = [];
     if (structure === "flat") {
-      const entries = await readdir7(skillsDir, { withFileTypes: true });
+      const entries = await readdir8(skillsDir, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isDirectory() && entry.name !== "node_modules" && !entry.name.startsWith(".")) {
-          const skillPath = join21(skillsDir, entry.name);
+          const skillPath = join22(skillsDir, entry.name);
           const hash = await SkillsManifestManager.hashDirectory(skillPath);
           skills.push({
             name: entry.name,
@@ -30349,14 +31119,14 @@ class SkillsManifestManager {
         }
       }
     } else {
-      const categories = await readdir7(skillsDir, { withFileTypes: true });
+      const categories = await readdir8(skillsDir, { withFileTypes: true });
       for (const category of categories) {
         if (category.isDirectory() && category.name !== "node_modules" && !category.name.startsWith(".")) {
-          const categoryPath = join21(skillsDir, category.name);
-          const skillEntries = await readdir7(categoryPath, { withFileTypes: true });
+          const categoryPath = join22(skillsDir, category.name);
+          const skillEntries = await readdir8(categoryPath, { withFileTypes: true });
           for (const skillEntry of skillEntries) {
             if (skillEntry.isDirectory() && !skillEntry.name.startsWith(".")) {
-              const skillPath = join21(categoryPath, skillEntry.name);
+              const skillPath = join22(categoryPath, skillEntry.name);
               const hash = await SkillsManifestManager.hashDirectory(skillPath);
               skills.push({
                 name: skillEntry.name,
@@ -30376,7 +31146,7 @@ class SkillsManifestManager {
     files.sort();
     for (const file of files) {
       const relativePath = relative6(dirPath, file);
-      const content = await readFile10(file);
+      const content = await readFile12(file);
       hash.update(relativePath);
       hash.update(content);
     }
@@ -30384,9 +31154,9 @@ class SkillsManifestManager {
   }
   static async getAllFiles(dirPath) {
     const files = [];
-    const entries = await readdir7(dirPath, { withFileTypes: true });
+    const entries = await readdir8(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join21(dirPath, entry.name);
+      const fullPath = join22(dirPath, entry.name);
       if (entry.name.startsWith(".") || entry.name === "node_modules") {
         continue;
       }
@@ -30621,7 +31391,7 @@ class SkillsMigrationDetector {
     if (!await import_fs_extra12.pathExists(skillsDir)) {
       return ["flat", []];
     }
-    const entries = await readdir8(skillsDir, { withFileTypes: true });
+    const entries = await readdir9(skillsDir, { withFileTypes: true });
     const dirs = entries.filter((entry) => entry.isDirectory() && entry.name !== "node_modules" && !entry.name.startsWith("."));
     if (dirs.length === 0) {
       return ["flat", []];
@@ -30629,13 +31399,13 @@ class SkillsMigrationDetector {
     let totalSkillLikeCount = 0;
     const allSkills = [];
     for (const dir of dirs) {
-      const dirPath = join22(skillsDir, dir.name);
-      const subEntries = await readdir8(dirPath, { withFileTypes: true });
+      const dirPath = join23(skillsDir, dir.name);
+      const subEntries = await readdir9(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 = join22(dirPath, subdir.name);
-          const subdirFiles = await readdir8(subdirPath, { withFileTypes: true });
+          const subdirPath = join23(dirPath, subdir.name);
+          const subdirFiles = await readdir9(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++;
@@ -30672,21 +31442,21 @@ class SkillsMigrationDetector {
 init_types2();
 init_logger();
 var import_fs_extra15 = __toESM(require_lib(), 1);
-import { copyFile as copyFile2, mkdir as mkdir7, readdir as readdir11, rm as rm2 } from "node:fs/promises";
-import { join as join25 } from "node:path";
+import { copyFile as copyFile2, mkdir as mkdir8, readdir as readdir12, rm as rm2 } from "node:fs/promises";
+import { join as join26 } from "node:path";
 
 // src/lib/skills-backup-manager.ts
 init_types2();
 init_logger();
 var import_fs_extra13 = __toESM(require_lib(), 1);
-import { copyFile, mkdir as mkdir6, readdir as readdir9, rm, stat as stat4 } from "node:fs/promises";
-import { basename as basename2, join as join23, normalize as normalize2 } from "node:path";
+import { copyFile, mkdir as mkdir7, readdir as readdir10, rm, stat as stat4 } from "node:fs/promises";
+import { basename as basename2, join as join24, normalize as normalize4 } from "node:path";
 function validatePath2(path9, paramName) {
   if (!path9 || typeof path9 !== "string") {
     throw new SkillsMigrationError(`${paramName} must be a non-empty string`);
   }
   if (path9.includes("..")) {
-    const normalized = normalize2(path9);
+    const normalized = normalize4(path9);
     if (normalized.startsWith("..")) {
       throw new SkillsMigrationError(`${paramName} contains invalid path traversal: ${path9}`);
     }
@@ -30706,10 +31476,10 @@ 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 ? join23(parentDir, backupDirName) : join23(skillsDir, "..", backupDirName);
+    const backupDir = parentDir ? join24(parentDir, backupDirName) : join24(skillsDir, "..", backupDirName);
     logger.info(`Creating backup at: ${backupDir}`);
     try {
-      await mkdir6(backupDir, { recursive: true });
+      await mkdir7(backupDir, { recursive: true });
       await SkillsBackupManager.copyDirectory(skillsDir, backupDir);
       logger.success("Backup created successfully");
       return backupDir;
@@ -30731,7 +31501,7 @@ class SkillsBackupManager {
       if (await import_fs_extra13.pathExists(targetDir)) {
         await rm(targetDir, { recursive: true, force: true });
       }
-      await mkdir6(targetDir, { recursive: true });
+      await mkdir7(targetDir, { recursive: true });
       await SkillsBackupManager.copyDirectory(backupDir, targetDir);
       logger.success("Backup restored successfully");
     } catch (error) {
@@ -30756,8 +31526,8 @@ class SkillsBackupManager {
       return [];
     }
     try {
-      const entries = await readdir9(parentDir, { withFileTypes: true });
-      const backups = entries.filter((entry) => entry.isDirectory() && entry.name.startsWith(SkillsBackupManager.BACKUP_PREFIX)).map((entry) => join23(parentDir, entry.name));
+      const entries = await readdir10(parentDir, { withFileTypes: true });
+      const backups = entries.filter((entry) => entry.isDirectory() && entry.name.startsWith(SkillsBackupManager.BACKUP_PREFIX)).map((entry) => join24(parentDir, entry.name));
       backups.sort().reverse();
       return backups;
     } catch (error) {
@@ -30783,15 +31553,15 @@ class SkillsBackupManager {
     return await SkillsBackupManager.getDirectorySize(backupDir);
   }
   static async copyDirectory(sourceDir, destDir) {
-    const entries = await readdir9(sourceDir, { withFileTypes: true });
+    const entries = await readdir10(sourceDir, { withFileTypes: true });
     for (const entry of entries) {
-      const sourcePath = join23(sourceDir, entry.name);
-      const destPath = join23(destDir, entry.name);
+      const sourcePath = join24(sourceDir, entry.name);
+      const destPath = join24(destDir, entry.name);
       if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.isSymbolicLink()) {
         continue;
       }
       if (entry.isDirectory()) {
-        await mkdir6(destPath, { recursive: true });
+        await mkdir7(destPath, { recursive: true });
         await SkillsBackupManager.copyDirectory(sourcePath, destPath);
       } else if (entry.isFile()) {
         await copyFile(sourcePath, destPath);
@@ -30800,9 +31570,9 @@ class SkillsBackupManager {
   }
   static async getDirectorySize(dirPath) {
     let size = 0;
-    const entries = await readdir9(dirPath, { withFileTypes: true });
+    const entries = await readdir10(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join23(dirPath, entry.name);
+      const fullPath = join24(dirPath, entry.name);
       if (entry.isSymbolicLink()) {
         continue;
       }
@@ -30832,14 +31602,14 @@ init_logger();
 var import_fs_extra14 = __toESM(require_lib(), 1);
 import { createHash as createHash3 } from "node:crypto";
 import { createReadStream as createReadStream2 } from "node:fs";
-import { readFile as readFile11, readdir as readdir10 } from "node:fs/promises";
-import { join as join24, normalize as normalize3, relative as relative7 } from "node:path";
+import { readFile as readFile13, readdir as readdir11 } from "node:fs/promises";
+import { join as join25, normalize as normalize5, relative as relative7 } from "node:path";
 function validatePath3(path9, paramName) {
   if (!path9 || typeof path9 !== "string") {
     throw new SkillsMigrationError(`${paramName} must be a non-empty string`);
   }
   if (path9.includes("..")) {
-    const normalized = normalize3(path9);
+    const normalized = normalize5(path9);
     if (normalized.startsWith("..")) {
       throw new SkillsMigrationError(`${paramName} contains invalid path traversal: ${path9}`);
     }
@@ -30975,19 +31745,19 @@ class SkillsCustomizationScanner {
     if (!await import_fs_extra14.pathExists(skillsDir)) {
       return ["flat", []];
     }
-    const entries = await readdir10(skillsDir, { withFileTypes: true });
+    const entries = await readdir11(skillsDir, { withFileTypes: true });
     const dirs = entries.filter((entry) => entry.isDirectory() && entry.name !== "node_modules" && !entry.name.startsWith("."));
     if (dirs.length === 0) {
       return ["flat", []];
     }
-    const firstDirPath = join24(skillsDir, dirs[0].name);
-    const subEntries = await readdir10(firstDirPath, { withFileTypes: true });
+    const firstDirPath = join25(skillsDir, dirs[0].name);
+    const subEntries = await readdir11(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 = join24(firstDirPath, subdir.name);
-        const subdirFiles = await readdir10(subdirPath, { withFileTypes: true });
+        const subdirPath = join25(firstDirPath, subdir.name);
+        const subdirFiles = await readdir11(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++;
@@ -30996,8 +31766,8 @@ class SkillsCustomizationScanner {
       if (skillLikeCount > 0) {
         const skills = [];
         for (const dir of dirs) {
-          const categoryPath = join24(skillsDir, dir.name);
-          const skillDirs = await readdir10(categoryPath, { withFileTypes: true });
+          const categoryPath = join25(skillsDir, dir.name);
+          const skillDirs = await readdir11(categoryPath, { withFileTypes: true });
           skills.push(...skillDirs.filter((entry) => entry.isDirectory() && !entry.name.startsWith(".")).map((entry) => entry.name));
         }
         return ["categorized", skills];
@@ -31006,17 +31776,17 @@ class SkillsCustomizationScanner {
     return ["flat", dirs.map((dir) => dir.name)];
   }
   static async findSkillPath(skillsDir, skillName) {
-    const flatPath = join24(skillsDir, skillName);
+    const flatPath = join25(skillsDir, skillName);
     if (await import_fs_extra14.pathExists(flatPath)) {
       return { path: flatPath, category: undefined };
     }
-    const entries = await readdir10(skillsDir, { withFileTypes: true });
+    const entries = await readdir11(skillsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory() || entry.name.startsWith(".") || entry.name === "node_modules") {
         continue;
       }
-      const categoryPath = join24(skillsDir, entry.name);
-      const skillPath = join24(categoryPath, skillName);
+      const categoryPath = join25(skillsDir, entry.name);
+      const skillPath = join25(categoryPath, skillName);
       if (await import_fs_extra14.pathExists(skillPath)) {
         return { path: skillPath, category: entry.name };
       }
@@ -31025,9 +31795,9 @@ class SkillsCustomizationScanner {
   }
   static async getAllFiles(dirPath) {
     const files = [];
-    const entries = await readdir10(dirPath, { withFileTypes: true });
+    const entries = await readdir11(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join24(dirPath, entry.name);
+      const fullPath = join25(dirPath, entry.name);
       if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.isSymbolicLink()) {
         continue;
       }
@@ -31041,12 +31811,12 @@ class SkillsCustomizationScanner {
     return files;
   }
   static async hashFile(filePath) {
-    return new Promise((resolve3, reject) => {
+    return new Promise((resolve4, reject) => {
       const hash = createHash3("sha256");
       const stream = createReadStream2(filePath);
       stream.on("data", (chunk) => hash.update(chunk));
       stream.on("end", () => {
-        resolve3(hash.digest("hex"));
+        resolve4(hash.digest("hex"));
       });
       stream.on("error", (error) => {
         stream.destroy();
@@ -31060,7 +31830,7 @@ class SkillsCustomizationScanner {
     files.sort();
     for (const file of files) {
       const relativePath = relative7(dirPath, file);
-      const content = await readFile11(file);
+      const content = await readFile13(file);
       hash.update(relativePath);
       hash.update(content);
     }
@@ -31270,7 +32040,7 @@ class SkillsMigrator {
         }
       }
       if (options.backup && !options.dryRun) {
-        const claudeDir = join25(currentSkillsDir, "..");
+        const claudeDir = join26(currentSkillsDir, "..");
         result.backupPath = await SkillsBackupManager.createBackup(currentSkillsDir, claudeDir);
         logger.success(`Backup created at: ${result.backupPath}`);
       }
@@ -31322,8 +32092,8 @@ class SkillsMigrator {
     const migrated = [];
     const preserved = [];
     const errors2 = [];
-    const tempDir = join25(currentSkillsDir, "..", ".skills-migration-temp");
-    await mkdir7(tempDir, { recursive: true });
+    const tempDir = join26(currentSkillsDir, "..", ".skills-migration-temp");
+    await mkdir8(tempDir, { recursive: true });
     try {
       for (const mapping of mappings) {
         try {
@@ -31343,9 +32113,9 @@ class SkillsMigrator {
             }
           }
           const category = mapping.category;
-          const targetPath = category ? join25(tempDir, category, skillName) : join25(tempDir, skillName);
+          const targetPath = category ? join26(tempDir, category, skillName) : join26(tempDir, skillName);
           if (category) {
-            await mkdir7(join25(tempDir, category), { recursive: true });
+            await mkdir8(join26(tempDir, category), { recursive: true });
           }
           await SkillsMigrator.copySkillDirectory(currentSkillPath, targetPath);
           migrated.push(skillName);
@@ -31364,7 +32134,7 @@ class SkillsMigrator {
         }
       }
       await rm2(currentSkillsDir, { recursive: true, force: true });
-      await mkdir7(currentSkillsDir, { recursive: true });
+      await mkdir8(currentSkillsDir, { recursive: true });
       await SkillsMigrator.copySkillDirectory(tempDir, currentSkillsDir);
       await rm2(tempDir, { recursive: true, force: true });
       return { migrated, preserved, errors: errors2 };
@@ -31376,11 +32146,11 @@ class SkillsMigrator {
     }
   }
   static async copySkillDirectory(sourceDir, destDir) {
-    await mkdir7(destDir, { recursive: true });
-    const entries = await readdir11(sourceDir, { withFileTypes: true });
+    await mkdir8(destDir, { recursive: true });
+    const entries = await readdir12(sourceDir, { withFileTypes: true });
     for (const entry of entries) {
-      const sourcePath = join25(sourceDir, entry.name);
-      const destPath = join25(destDir, entry.name);
+      const sourcePath = join26(sourceDir, entry.name);
+      const destPath = join26(destDir, entry.name);
       if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.isSymbolicLink()) {
         continue;
       }
@@ -31400,17 +32170,17 @@ init_types2();
 init_types2();
 init_logger();
 import { existsSync as existsSync6 } from "node:fs";
-import { mkdir as mkdir8, readFile as readFile12, rename as rename2, rm as rm3, writeFile as writeFile10 } from "node:fs/promises";
+import { mkdir as mkdir9, readFile as readFile14, rename as rename2, rm as rm3, writeFile as writeFile12 } from "node:fs/promises";
 import { chmod as chmod2 } from "node:fs/promises";
-import { platform as platform8 } from "node:os";
-import { join as join26 } from "node:path";
+import { platform as platform9 } from "node:os";
+import { join as join27 } from "node:path";
 var PROJECT_CONFIG_FILE = ".ck.json";
 
 class ConfigManager {
   static config = null;
   static globalFlag = false;
   static getProjectConfigDir(projectDir, global3) {
-    return global3 ? projectDir : join26(projectDir, ".claude");
+    return global3 ? projectDir : join27(projectDir, ".claude");
   }
   static setGlobalFlag(global3) {
     ConfigManager.globalFlag = global3;
@@ -31426,7 +32196,7 @@ class ConfigManager {
     const configFile = PathResolver.getConfigFile(ConfigManager.globalFlag);
     try {
       if (existsSync6(configFile)) {
-        const content = await readFile12(configFile, "utf-8");
+        const content = await readFile14(configFile, "utf-8");
         const data = JSON.parse(content);
         ConfigManager.config = ConfigSchema.parse(data);
         logger.debug(`Config loaded from ${configFile}`);
@@ -31444,13 +32214,13 @@ class ConfigManager {
       const configDir = PathResolver.getConfigDir(ConfigManager.globalFlag);
       const configFile = PathResolver.getConfigFile(ConfigManager.globalFlag);
       if (!existsSync6(configDir)) {
-        await mkdir8(configDir, { recursive: true });
-        if (platform8() !== "win32") {
+        await mkdir9(configDir, { recursive: true });
+        if (platform9() !== "win32") {
           await chmod2(configDir, 448);
         }
       }
-      await writeFile10(configFile, JSON.stringify(validConfig, null, 2), "utf-8");
-      if (platform8() !== "win32") {
+      await writeFile12(configFile, JSON.stringify(validConfig, null, 2), "utf-8");
+      if (platform9() !== "win32") {
         await chmod2(configFile, 384);
       }
       ConfigManager.config = validConfig;
@@ -31477,10 +32247,10 @@ class ConfigManager {
   }
   static async loadProjectConfig(projectDir, global3 = false) {
     const configDir = ConfigManager.getProjectConfigDir(projectDir, global3);
-    const configPath = join26(configDir, PROJECT_CONFIG_FILE);
+    const configPath = join27(configDir, PROJECT_CONFIG_FILE);
     try {
       if (existsSync6(configPath)) {
-        const content = await readFile12(configPath, "utf-8");
+        const content = await readFile14(configPath, "utf-8");
         const data = JSON.parse(content);
         const folders = FoldersConfigSchema.parse(data.paths || data);
         logger.debug(`Project config loaded from ${configPath}`);
@@ -31493,13 +32263,13 @@ class ConfigManager {
   }
   static async saveProjectConfig(projectDir, folders, global3 = false) {
     const configDir = ConfigManager.getProjectConfigDir(projectDir, global3);
-    const configPath = join26(configDir, PROJECT_CONFIG_FILE);
+    const configPath = join27(configDir, PROJECT_CONFIG_FILE);
     try {
       if (!existsSync6(configDir)) {
-        await mkdir8(configDir, { recursive: true });
+        await mkdir9(configDir, { recursive: true });
       }
       const validFolders = FoldersConfigSchema.parse(folders);
-      await writeFile10(configPath, JSON.stringify({ paths: validFolders }, null, 2), "utf-8");
+      await writeFile12(configPath, JSON.stringify({ paths: validFolders }, null, 2), "utf-8");
       logger.debug(`Project config saved to ${configPath}`);
     } catch (error) {
       throw new Error(`Failed to save project config: ${error instanceof Error ? error.message : "Unknown error"}`);
@@ -31525,11 +32295,11 @@ class ConfigManager {
   }
   static projectConfigExists(projectDir, global3 = false) {
     const configDir = ConfigManager.getProjectConfigDir(projectDir, global3);
-    return existsSync6(join26(configDir, PROJECT_CONFIG_FILE));
+    return existsSync6(join27(configDir, PROJECT_CONFIG_FILE));
   }
   static async migrateNestedConfig(globalDir) {
-    const correctPath = join26(globalDir, PROJECT_CONFIG_FILE);
-    const incorrectPath = join26(globalDir, ".claude", PROJECT_CONFIG_FILE);
+    const correctPath = join27(globalDir, PROJECT_CONFIG_FILE);
+    const incorrectPath = join27(globalDir, ".claude", PROJECT_CONFIG_FILE);
     if (existsSync6(correctPath)) {
       logger.debug("Config already exists at correct location, skipping migration");
       return false;
@@ -31539,7 +32309,7 @@ class ConfigManager {
         logger.info("Migrating .ck.json from nested location to correct location...");
         await rename2(incorrectPath, correctPath);
         logger.success(`Migrated ${PROJECT_CONFIG_FILE} to ${correctPath}`);
-        const nestedClaudeDir = join26(globalDir, ".claude");
+        const nestedClaudeDir = join27(globalDir, ".claude");
         try {
           await rm3(nestedClaudeDir, { recursive: false });
           logger.debug("Removed empty nested .claude directory");
@@ -31562,7 +32332,7 @@ init_environment();
 // src/utils/file-scanner.ts
 init_logger();
 var import_fs_extra16 = __toESM(require_lib(), 1);
-import { join as join27, relative as relative8, resolve as resolve3 } from "node:path";
+import { join as join28, relative as relative8, resolve as resolve4 } from "node:path";
 var SKIP_DIRS2 = [
   "node_modules",
   ".venv",
@@ -31597,7 +32367,7 @@ class FileScanner {
           logger.debug(`Skipping directory: ${entry}`);
           continue;
         }
-        const fullPath = join27(dirPath, entry);
+        const fullPath = join28(dirPath, entry);
         if (!FileScanner.isSafePath(basePath, fullPath)) {
           logger.warning(`Skipping potentially unsafe path: ${entry}`);
           continue;
@@ -31632,8 +32402,8 @@ class FileScanner {
     return files;
   }
   static async findCustomFiles(destDir, sourceDir, subPath) {
-    const destSubDir = join27(destDir, subPath);
-    const sourceSubDir = join27(sourceDir, subPath);
+    const destSubDir = join28(destDir, subPath);
+    const sourceSubDir = join28(sourceDir, subPath);
     logger.debug(`findCustomFiles - destDir: ${destDir}`);
     logger.debug(`findCustomFiles - sourceDir: ${sourceDir}`);
     logger.debug(`findCustomFiles - subPath: "${subPath}"`);
@@ -31661,8 +32431,8 @@ class FileScanner {
     return customFiles;
   }
   static isSafePath(basePath, targetPath) {
-    const resolvedBase = resolve3(basePath);
-    const resolvedTarget = resolve3(targetPath);
+    const resolvedBase = resolve4(basePath);
+    const resolvedTarget = resolve4(targetPath);
     return resolvedTarget.startsWith(resolvedBase);
   }
   static toPosixPath(path9) {
@@ -31688,9 +32458,9 @@ async function initCommand(options) {
     }
     if (validOptions.global) {
       const globalKitDir = PathResolver.getGlobalKitDir();
-      const cwdResolved = resolve4(process.cwd());
-      const isInGlobalDir = cwdResolved === globalKitDir || cwdResolved === resolve4(globalKitDir, "..");
-      const localSettingsPath = join28(process.cwd(), ".claude", "settings.json");
+      const cwdResolved = resolve5(process.cwd());
+      const isInGlobalDir = cwdResolved === globalKitDir || cwdResolved === resolve5(globalKitDir, "..");
+      const localSettingsPath = join29(process.cwd(), ".claude", "settings.json");
       if (!isInGlobalDir && await import_fs_extra17.pathExists(localSettingsPath)) {
         if (isNonInteractive2) {
           logger.warning("Local .claude/settings.json detected. Local settings take precedence over global.");
@@ -31702,7 +32472,7 @@ async function initCommand(options) {
             return;
           }
           if (choice === "remove") {
-            const localClaudeDir = join28(process.cwd(), ".claude");
+            const localClaudeDir = join29(process.cwd(), ".claude");
             try {
               await import_fs_extra17.remove(localClaudeDir);
               logger.success("Removed local .claude/ directory");
@@ -31746,12 +32516,12 @@ async function initCommand(options) {
         }
       }
     }
-    const resolvedDir = resolve4(targetDir);
+    const resolvedDir = resolve5(targetDir);
     logger.info(`Target directory: ${resolvedDir}`);
     if (!await import_fs_extra17.pathExists(resolvedDir)) {
       if (validOptions.global) {
-        const { mkdir: mkdir9 } = await import("node:fs/promises");
-        await mkdir9(resolvedDir, { recursive: true });
+        const { mkdir: mkdir10 } = await import("node:fs/promises");
+        await mkdir10(resolvedDir, { recursive: true });
         logger.info(`Created global directory: ${resolvedDir}`);
       } else {
         logger.error(`Directory does not exist: ${resolvedDir}`);
@@ -31761,7 +32531,7 @@ async function initCommand(options) {
     }
     if (validOptions.fresh) {
       const prefix = PathResolver.getPathPrefix(validOptions.global);
-      const claudeDir2 = prefix ? join28(resolvedDir, prefix) : resolvedDir;
+      const claudeDir2 = prefix ? join29(resolvedDir, prefix) : resolvedDir;
       const canProceed = await handleFreshInstallation(claudeDir2, prompts);
       if (!canProceed) {
         return;
@@ -31898,7 +32668,7 @@ async function initCommand(options) {
       }
     }
     if (!validOptions.fresh) {
-      const newSkillsDir = join28(extractDir, ".claude", "skills");
+      const newSkillsDir = join29(extractDir, ".claude", "skills");
       const currentSkillsDir = PathResolver.buildSkillsPath(resolvedDir, validOptions.global);
       if (await import_fs_extra17.pathExists(newSkillsDir) && await import_fs_extra17.pathExists(currentSkillsDir)) {
         logger.info("Checking for skills directory migration...");
@@ -31923,7 +32693,7 @@ async function initCommand(options) {
     let customClaudeFiles = [];
     if (!validOptions.fresh) {
       logger.info("Scanning for custom .claude files...");
-      const scanSourceDir = validOptions.global ? join28(extractDir, ".claude") : extractDir;
+      const scanSourceDir = validOptions.global ? join29(extractDir, ".claude") : extractDir;
       const scanTargetSubdir = validOptions.global ? "" : ".claude";
       customClaudeFiles = await FileScanner.findCustomFiles(resolvedDir, scanSourceDir, scanTargetSubdir);
     } else {
@@ -31952,7 +32722,7 @@ async function initCommand(options) {
       merger.addIgnorePatterns(validOptions.exclude);
     }
     merger.setGlobalFlag(validOptions.global);
-    const claudeDir = validOptions.global ? resolvedDir : join28(resolvedDir, ".claude");
+    const claudeDir = validOptions.global ? resolvedDir : join29(resolvedDir, ".claude");
     const releaseManifest = await ReleaseManifestLoader.load(extractDir);
     if (!validOptions.fresh && await import_fs_extra17.pathExists(claudeDir)) {
       const legacyDetection = await LegacyMigration.detectLegacy(claudeDir);
@@ -31974,7 +32744,7 @@ async function initCommand(options) {
         return;
       }
     }
-    const sourceDir = validOptions.global ? join28(extractDir, ".claude") : extractDir;
+    const sourceDir = validOptions.global ? join29(extractDir, ".claude") : extractDir;
     await merger.merge(sourceDir, resolvedDir, false);
     const manifestWriter = new ManifestWriter;
     const installedFiles = merger.getAllInstalledFiles();
@@ -31983,7 +32753,7 @@ async function initCommand(options) {
       if (!validOptions.global && !installedPath.startsWith(".claude/"))
         continue;
       const relativePath = validOptions.global ? installedPath : installedPath.replace(/^\.claude\//, "");
-      const filePath = join28(claudeDir, relativePath);
+      const filePath = join29(claudeDir, relativePath);
       const manifestEntry = releaseManifest ? ReleaseManifestLoader.findFile(releaseManifest, installedPath) : null;
       const ownership = manifestEntry ? "ck" : "user";
       filesToTrack.push({
@@ -32004,8 +32774,8 @@ async function initCommand(options) {
     trackingSpinner.succeed(`Tracked ${trackResult.success} files`);
     await manifestWriter.writeManifest(claudeDir, kitConfig.name, release.tag_name, validOptions.global ? "global" : "local");
     if (validOptions.global) {
-      const claudeMdSource = join28(extractDir, "CLAUDE.md");
-      const claudeMdDest = join28(resolvedDir, "CLAUDE.md");
+      const claudeMdSource = join29(extractDir, "CLAUDE.md");
+      const claudeMdDest = join29(resolvedDir, "CLAUDE.md");
       if (await import_fs_extra17.pathExists(claudeMdSource)) {
         if (!await import_fs_extra17.pathExists(claudeMdDest)) {
           await import_fs_extra17.copy(claudeMdSource, claudeMdDest);
@@ -32025,7 +32795,7 @@ async function initCommand(options) {
       await handleSkillsInstallation2(skillsDir);
     }
     if (!validOptions.skipSetup && !isNonInteractive2) {
-      const envPath = join28(claudeDir, ".env");
+      const envPath = join29(claudeDir, ".env");
       if (!await import_fs_extra17.pathExists(envPath)) {
         const shouldSetup = await prompts.confirm("Set up API keys now? (Gemini API key for ai-multimodal skill, optional webhooks)");
         if (shouldSetup) {
@@ -32057,7 +32827,7 @@ Protected files (.env, etc.) were not modified.`;
 
 // src/commands/new.ts
 var import_fs_extra18 = __toESM(require_lib(), 1);
-import { join as join29, resolve as resolve5 } from "node:path";
+import { join as join30, resolve as resolve6 } from "node:path";
 init_types2();
 init_environment();
 init_logger();
@@ -32086,7 +32856,7 @@ async function newCommand(options) {
         targetDir = await prompts.getDirectory(targetDir);
       }
     }
-    const resolvedDir = resolve5(targetDir);
+    const resolvedDir = resolve6(targetDir);
     logger.info(`Target directory: ${resolvedDir}`);
     if (await import_fs_extra18.pathExists(resolvedDir)) {
       const files = await import_fs_extra18.readdir(resolvedDir);
@@ -32228,7 +32998,7 @@ async function newCommand(options) {
       await CommandsPrefix.cleanupCommandsDirectory(resolvedDir, false);
     }
     await merger.merge(extractDir, resolvedDir, true);
-    const claudeDir = join29(resolvedDir, ".claude");
+    const claudeDir = join30(resolvedDir, ".claude");
     const manifestWriter = new ManifestWriter;
     const releaseManifest = await ReleaseManifestLoader.load(extractDir);
     const installedFiles = merger.getAllInstalledFiles();
@@ -32237,7 +33007,7 @@ async function newCommand(options) {
       if (!installedPath.startsWith(".claude/"))
         continue;
       const relativePath = installedPath.replace(/^\.claude\//, "");
-      const filePath = join29(claudeDir, relativePath);
+      const filePath = join30(claudeDir, relativePath);
       const manifestEntry = releaseManifest ? ReleaseManifestLoader.findFile(releaseManifest, installedPath) : null;
       const ownership = manifestEntry ? "ck" : "user";
       filesToTrack.push({
@@ -32293,7 +33063,7 @@ init_dist2();
 var import_fs_extra19 = __toESM(require_lib(), 1);
 var import_picocolors10 = __toESM(require_picocolors(), 1);
 import { readdirSync, rmSync } from "node:fs";
-import { dirname as dirname4, join as join30 } from "node:path";
+import { dirname as dirname5, join as join31 } from "node:path";
 init_types2();
 init_logger();
 async function detectInstallations() {
@@ -32353,7 +33123,7 @@ async function confirmUninstall(scope) {
 }
 async function cleanupEmptyDirectories(filePath, installationRoot) {
   let cleaned = 0;
-  let currentDir = dirname4(filePath);
+  let currentDir = dirname5(filePath);
   while (currentDir !== installationRoot && currentDir.startsWith(installationRoot)) {
     try {
       const entries = readdirSync(currentDir);
@@ -32361,7 +33131,7 @@ async function cleanupEmptyDirectories(filePath, installationRoot) {
         rmSync(currentDir, { recursive: true });
         cleaned++;
         logger.debug(`Removed empty directory: ${currentDir}`);
-        currentDir = dirname4(currentDir);
+        currentDir = dirname5(currentDir);
       } else {
         break;
       }
@@ -32384,7 +33154,7 @@ async function analyzeInstallation(installation, forceOverwrite) {
     return result;
   }
   for (const trackedFile of metadata.files) {
-    const filePath = join30(installation.path, trackedFile.path);
+    const filePath = join31(installation.path, trackedFile.path);
     const ownershipResult = await OwnershipChecker.checkOwnership(filePath, metadata, installation.path);
     if (!ownershipResult.exists)
       continue;
@@ -32442,7 +33212,7 @@ async function removeInstallations(installations, options) {
       let removedCount = 0;
       let cleanedDirs = 0;
       for (const item of analysis.toDelete) {
-        const filePath = join30(installation.path, item.path);
+        const filePath = join31(installation.path, item.path);
         if (await import_fs_extra19.pathExists(filePath)) {
           await import_fs_extra19.remove(filePath);
           removedCount++;
@@ -32544,7 +33314,7 @@ import { promisify as promisify6 } from "node:util";
 // package.json
 var package_default2 = {
   name: "claudekit-cli",
-  version: "3.6.2",
+  version: "3.7.0",
   description: "CLI tool for bootstrapping and updating ClaudeKit projects",
   type: "module",
   repository: {
@@ -32990,14 +33760,14 @@ var import_picocolors12 = __toESM(require_picocolors(), 1);
 // src/lib/version-cache.ts
 init_logger();
 import { existsSync as existsSync7 } from "node:fs";
-import { mkdir as mkdir9, readFile as readFile13, writeFile as writeFile11 } from "node:fs/promises";
-import { join as join31 } from "node:path";
+import { mkdir as mkdir10, readFile as readFile15, writeFile as writeFile13 } from "node:fs/promises";
+import { join as join32 } from "node:path";
 class VersionCacheManager {
   static CACHE_FILENAME = "version-check.json";
   static CACHE_TTL_MS = 7 * 24 * 60 * 60 * 1000;
   static getCacheFile() {
     const cacheDir = PathResolver.getCacheDir(false);
-    return join31(cacheDir, VersionCacheManager.CACHE_FILENAME);
+    return join32(cacheDir, VersionCacheManager.CACHE_FILENAME);
   }
   static async load() {
     const cacheFile = VersionCacheManager.getCacheFile();
@@ -33006,7 +33776,7 @@ class VersionCacheManager {
         logger.debug("Version check cache not found");
         return null;
       }
-      const content = await readFile13(cacheFile, "utf-8");
+      const content = await readFile15(cacheFile, "utf-8");
       const cache2 = JSON.parse(content);
       if (!cache2.lastCheck || !cache2.currentVersion || !cache2.latestVersion) {
         logger.debug("Invalid cache structure, ignoring");
@@ -33024,9 +33794,9 @@ class VersionCacheManager {
     const cacheDir = PathResolver.getCacheDir(false);
     try {
       if (!existsSync7(cacheDir)) {
-        await mkdir9(cacheDir, { recursive: true, mode: 448 });
+        await mkdir10(cacheDir, { recursive: true, mode: 448 });
       }
-      await writeFile11(cacheFile, JSON.stringify(cache2, null, 2), "utf-8");
+      await writeFile13(cacheFile, JSON.stringify(cache2, null, 2), "utf-8");
       logger.debug(`Version check cache saved to ${cacheFile}`);
     } catch (error) {
       logger.debug(`Failed to save version check cache: ${error}`);
@@ -33472,8 +34242,8 @@ class Logger2 {
 var logger2 = new Logger2;
 
 // src/utils/path-resolver.ts
-import { homedir as homedir2, platform as platform9 } from "node:os";
-import { join as join32, normalize as normalize4 } from "node:path";
+import { homedir as homedir4, platform as platform10 } from "node:os";
+import { join as join33, normalize as normalize6 } from "node:path";
 
 class PathResolver2 {
   static getTestHomeDir() {
@@ -33492,7 +34262,7 @@ class PathResolver2 {
         return false;
       }
     }
-    const normalized = normalize4(path9);
+    const normalized = normalize6(path9);
     for (const pattern of dangerousPatterns) {
       if (normalized.includes(pattern)) {
         return false;
@@ -33506,50 +34276,50 @@ class PathResolver2 {
   static getConfigDir(global3 = false) {
     const testHome = PathResolver2.getTestHomeDir();
     if (testHome) {
-      return global3 ? join32(testHome, ".config", "claude") : join32(testHome, ".claudekit");
+      return global3 ? join33(testHome, ".config", "claude") : join33(testHome, ".claudekit");
     }
     if (!global3) {
-      return join32(homedir2(), ".claudekit");
+      return join33(homedir4(), ".claudekit");
     }
-    const os2 = platform9();
+    const os2 = platform10();
     if (os2 === "win32") {
-      const localAppData = process.env.LOCALAPPDATA || join32(homedir2(), "AppData", "Local");
-      return join32(localAppData, "claude");
+      const localAppData = process.env.LOCALAPPDATA || join33(homedir4(), "AppData", "Local");
+      return join33(localAppData, "claude");
     }
     const xdgConfigHome = process.env.XDG_CONFIG_HOME;
     if (xdgConfigHome) {
-      return join32(xdgConfigHome, "claude");
+      return join33(xdgConfigHome, "claude");
     }
-    return join32(homedir2(), ".config", "claude");
+    return join33(homedir4(), ".config", "claude");
   }
   static getConfigFile(global3 = false) {
-    return join32(PathResolver2.getConfigDir(global3), "config.json");
+    return join33(PathResolver2.getConfigDir(global3), "config.json");
   }
   static getCacheDir(global3 = false) {
     const testHome = PathResolver2.getTestHomeDir();
     if (testHome) {
-      return global3 ? join32(testHome, ".cache", "claude") : join32(testHome, ".claudekit", "cache");
+      return global3 ? join33(testHome, ".cache", "claude") : join33(testHome, ".claudekit", "cache");
     }
     if (!global3) {
-      return join32(homedir2(), ".claudekit", "cache");
+      return join33(homedir4(), ".claudekit", "cache");
     }
-    const os2 = platform9();
+    const os2 = platform10();
     if (os2 === "win32") {
-      const localAppData = process.env.LOCALAPPDATA || join32(homedir2(), "AppData", "Local");
-      return join32(localAppData, "claude", "cache");
+      const localAppData = process.env.LOCALAPPDATA || join33(homedir4(), "AppData", "Local");
+      return join33(localAppData, "claude", "cache");
     }
     const xdgCacheHome = process.env.XDG_CACHE_HOME;
     if (xdgCacheHome) {
-      return join32(xdgCacheHome, "claude");
+      return join33(xdgCacheHome, "claude");
     }
-    return join32(homedir2(), ".cache", "claude");
+    return join33(homedir4(), ".cache", "claude");
   }
   static getGlobalKitDir() {
     const testHome = PathResolver2.getTestHomeDir();
     if (testHome) {
-      return join32(testHome, ".claude");
+      return join33(testHome, ".claude");
     }
-    return join32(homedir2(), ".claude");
+    return join33(homedir4(), ".claude");
   }
   static getPathPrefix(global3) {
     return global3 ? "" : ".claude";
@@ -33557,9 +34327,9 @@ class PathResolver2 {
   static buildSkillsPath(baseDir, global3) {
     const prefix = PathResolver2.getPathPrefix(global3);
     if (prefix) {
-      return join32(baseDir, prefix, "skills");
+      return join33(baseDir, prefix, "skills");
     }
-    return join32(baseDir, "skills");
+    return join33(baseDir, "skills");
   }
   static buildComponentPath(baseDir, component, global3) {
     if (!PathResolver2.isPathSafe(component)) {
@@ -33567,9 +34337,9 @@ class PathResolver2 {
     }
     const prefix = PathResolver2.getPathPrefix(global3);
     if (prefix) {
-      return join32(baseDir, prefix, component);
+      return join33(baseDir, prefix, component);
     }
-    return join32(baseDir, component);
+    return join33(baseDir, component);
   }
 }
 
@@ -33587,9 +34357,9 @@ async function displayVersion() {
   let localKitVersion = null;
   let isGlobalOnlyKit = false;
   const globalKitDir = PathResolver2.getGlobalKitDir();
-  const globalMetadataPath = join33(globalKitDir, "metadata.json");
+  const globalMetadataPath = join34(globalKitDir, "metadata.json");
   const prefix = PathResolver2.getPathPrefix(false);
-  const localMetadataPath = prefix ? join33(process.cwd(), prefix, "metadata.json") : join33(process.cwd(), "metadata.json");
+  const localMetadataPath = prefix ? join34(process.cwd(), prefix, "metadata.json") : join34(process.cwd(), "metadata.json");
   const isLocalSameAsGlobal = localMetadataPath === globalMetadataPath;
   if (!isLocalSameAsGlobal && existsSync8(localMetadataPath)) {
     try {
@@ -33689,7 +34459,7 @@ cli.command("update", "Update ClaudeKit CLI to the latest version").option("-r,
 cli.command("versions", "List available versions of ClaudeKit repositories").option("--kit <kit>", "Filter by specific kit (engineer, marketing)").option("--limit <limit>", "Number of releases to show (default: 30)").option("--all", "Show all releases including prereleases").action(async (options) => {
   await versionCommand(options);
 });
-cli.command("doctor", "Comprehensive health check for ClaudeKit").option("--report", "Generate shareable diagnostic report").option("--fix", "Auto-fix all fixable issues").option("--check-only", "CI mode: no prompts, exit 1 on failures").option("--json", "Output JSON format").action(async (options) => {
+cli.command("doctor", "Comprehensive health check for ClaudeKit").option("--report", "Generate shareable diagnostic report").option("--fix", "Auto-fix all fixable issues").option("--check-only", "CI mode: no prompts, exit 1 on failures").option("--json", "Output JSON format").option("--full", "Include extended priority checks (slower)").action(async (options) => {
   await doctorCommand(options);
 });
 cli.command("uninstall", "Remove ClaudeKit installations").option("-y, --yes", "Skip confirmation prompt").option("-l, --local", "Uninstall only local installation (current project)").option("-g, --global", "Uninstall only global installation (~/.claude/)").option("-A, --all", "Uninstall from both local and global locations").option("--dry-run", "Preview what would be removed without deleting").option("--force-overwrite", "Delete even user-modified files (requires confirmation)").action(async (options) => {