claudekit-cli 3.42.2-dev.6 → 3.42.2-dev.8

package/cli-manifest.json

@@ -1,6 +1,6 @@
 {
-	"version": "3.42.2-dev.6",
-	"generatedAt": "2026-05-04T15:17:33.645Z",
+	"version": "3.42.2-dev.8",
+	"generatedAt": "2026-05-04T15:35:18.530Z",
 	"commands": {
 		"agents": {
 			"name": "agents",

package/dist/index.js

@@ -62389,7 +62389,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "claudekit-cli",
-    version: "3.42.2-dev.6",
+    version: "3.42.2-dev.8",
     description: "CLI tool for bootstrapping and updating ClaudeKit projects",
     type: "module",
     repository: {
@@ -63356,6 +63356,9 @@ async function invalidateAuth() {
   cachedOctokit = null;
   logger.debug("Invalidated cached authentication due to 401 error");
 }
+function resetClient() {
+  cachedOctokit = null;
+}
 var cachedOctokit = null;
 var init_auth_api = __esm(() => {
   init_claudekit_constants();
@@ -64268,6 +64271,16 @@ var init_asset_utils = __esm(() => {
 });
 
 // src/domains/github/client/index.ts
+var exports_client = {};
+__export(exports_client, {
+  resetClient: () => resetClient,
+  invalidateAuth: () => invalidateAuth,
+  handleHttpError: () => handleHttpError,
+  getDownloadableAsset: () => getDownloadableAsset,
+  getAuthenticatedClient: () => getAuthenticatedClient,
+  RepoApi: () => RepoApi,
+  ReleasesApi: () => ReleasesApi
+});
 var init_client = __esm(() => {
   init_auth_api();
   init_error_handler2();
@@ -73512,7 +73525,7 @@ async function restoreOriginalBranch(branchName, cwd2, issueNumber) {
   }
 }
 function spawnAndCollect(command, args, cwd2) {
-  return new Promise((resolve49, reject) => {
+  return new Promise((resolve44, reject) => {
     const child = spawn6(command, args, { ...cwd2 && { cwd: cwd2 }, stdio: ["ignore", "pipe", "pipe"] });
     const chunks = [];
     const stderrChunks = [];
@@ -73525,7 +73538,7 @@ function spawnAndCollect(command, args, cwd2) {
         reject(new Error(`${command} ${args[0] ?? ""} exited with code ${code2}: ${stderr}`));
         return;
       }
-      resolve49(Buffer.concat(chunks).toString("utf-8"));
+      resolve44(Buffer.concat(chunks).toString("utf-8"));
     });
   });
 }
@@ -76327,8 +76340,8 @@ function shouldRunCleanup(lastAt) {
   return Date.now() - new Date(lastAt).getTime() >= 86400000;
 }
 function sleep2(ms) {
-  return new Promise((resolve49) => {
-    setTimeout(resolve49, ms);
+  return new Promise((resolve44) => {
+    setTimeout(resolve44, ms);
   });
 }
 var LOCK_DIR2, LOCK_FILE, MAX_CREATION_RETRIES = 3, MAX_PUBLISH_RETRIES_PER_CYCLE = 3, PUBLISH_RETRY_WINDOW_HOURS = 24;
@@ -78611,7 +78624,7 @@ function getPagerArgs(pagerCmd) {
   return [];
 }
 async function trySystemPager(content) {
-  return new Promise((resolve49) => {
+  return new Promise((resolve44) => {
     const pagerCmd = process.env.PAGER || "less";
     const pagerArgs = getPagerArgs(pagerCmd);
     try {
@@ -78621,20 +78634,20 @@ async function trySystemPager(content) {
       });
       const timeout2 = setTimeout(() => {
         pager.kill();
-        resolve49(false);
+        resolve44(false);
       }, 30000);
       pager.stdin.write(content);
       pager.stdin.end();
       pager.on("close", (code2) => {
         clearTimeout(timeout2);
-        resolve49(code2 === 0);
+        resolve44(code2 === 0);
       });
       pager.on("error", () => {
         clearTimeout(timeout2);
-        resolve49(false);
+        resolve44(false);
       });
     } catch {
-      resolve49(false);
+      resolve44(false);
     }
   });
 }
@@ -78661,16 +78674,16 @@ async function basicPager(content) {
       break;
     }
     const remaining = lines.length - currentLine;
-    await new Promise((resolve49) => {
+    await new Promise((resolve44) => {
       rl.question(`-- More (${remaining} lines) [Enter/q] --`, (answer) => {
         if (answer.toLowerCase() === "q") {
           rl.close();
           process.exitCode = 0;
-          resolve49();
+          resolve44();
           return;
         }
         process.stdout.write("\x1B[1A\x1B[2K");
-        resolve49();
+        resolve44();
       });
     });
   }
@@ -86223,6 +86236,20 @@ import { join as join86, resolve as resolve31 } from "node:path";
 var HOOK_CHECK_TIMEOUT_MS = 5000;
 var PYTHON_CHECK_TIMEOUT_MS = 3000;
 var MAX_LOG_FILE_SIZE_BYTES = 10 * 1024 * 1024;
+
+class FixerDidNotConvergeError extends Error {
+  unresolved;
+  constructor(unresolved) {
+    const lines = unresolved.map((f3) => `  ${f3.label} :: ${f3.eventName} :: ${f3.command}`).join(`
+`);
+    super(`ck doctor --fix: fixer did not converge — ${unresolved.length} stale hook command path(s) remain after repair:
+${lines}
+
+This is a bug. Please open an issue at https://github.com/mrgoonie/claudekit-cli`);
+    this.name = "FixerDidNotConvergeError";
+    this.unresolved = unresolved;
+  }
+}
 function getHooksDir(projectDir) {
   const projectHooksDir = resolve31(projectDir, ".claude", "hooks");
   const globalHooksDir = resolve31(PathResolver.getGlobalKitDir(), "hooks");
@@ -86316,13 +86343,18 @@ async function repairHookCommandsInSettingsFile(settingsFile) {
   if (!settings?.hooks) {
     return 0;
   }
+  const findings = collectHookCommandFindings(settings, settingsFile);
+  if (findings.length === 0) {
+    return 0;
+  }
+  const repairMap = new Map(findings.map((f3) => [f3.command, f3.expected]));
   let repaired = 0;
   for (const entries of Object.values(settings.hooks)) {
     for (const entry of entries) {
       if ("command" in entry && typeof entry.command === "string") {
-        const repair = repairClaudeNodeCommandPath(entry.command, settingsFile.root);
-        if (repair.changed) {
-          entry.command = repair.command;
+        const fixed = repairMap.get(entry.command);
+        if (fixed !== undefined) {
+          entry.command = fixed;
           repaired++;
         }
       }
@@ -86333,9 +86365,9 @@ async function repairHookCommandsInSettingsFile(settingsFile) {
         if (!hook.command) {
           continue;
         }
-        const repair = repairClaudeNodeCommandPath(hook.command, settingsFile.root);
-        if (repair.changed) {
-          hook.command = repair.command;
+        const fixed = repairMap.get(hook.command);
+        if (fixed !== undefined) {
+          hook.command = fixed;
           repaired++;
         }
       }
@@ -86344,6 +86376,10 @@ async function repairHookCommandsInSettingsFile(settingsFile) {
   if (repaired > 0) {
     await SettingsMerger.writeSettingsFile(settingsFile.path, settings);
   }
+  const remaining = collectHookCommandFindings(settings, settingsFile);
+  if (remaining.length > 0) {
+    throw new FixerDidNotConvergeError(remaining);
+  }
   return repaired;
 }
 async function checkHookSyntax(projectDir) {
@@ -88231,6 +88267,313 @@ class NetworkChecker {
     }
   }
 }
+// src/domains/health-checks/checkers/github-reachability-checker.ts
+init_environment();
+init_logger();
+init_types3();
+import * as dnsPromises from "node:dns/promises";
+import * as https from "node:https";
+import * as net2 from "node:net";
+var DNS_TIMEOUT_MS = (() => {
+  const envVal = Number.parseInt(process.env.CLAUDEKIT_DNS_TIMEOUT ?? "", 10);
+  return Number.isFinite(envVal) && envVal > 0 ? envVal : 500;
+})();
+var TCP_TIMEOUT_MS = 1000;
+var TLS_TIMEOUT_MS = 3000;
+var AUTH_TIMEOUT_MS = 5000;
+var API_HOST = "api.github.com";
+var ZEN_URL = `https://${API_HOST}/zen`;
+var PROBE_KIT = "engineer";
+function createDefaultDeps() {
+  return {
+    dns: createDefaultDns(),
+    tcp: createDefaultTcp(),
+    tls: createDefaultTls(),
+    auth: createDefaultAuth()
+  };
+}
+function createDefaultDns() {
+  return {
+    resolve4: (host) => dnsPromises.resolve4(host),
+    resolve6: (host) => dnsPromises.resolve6(host)
+  };
+}
+function createDefaultTcp() {
+  return {
+    connect: ({ host, port, timeoutMs }) => new Promise((resolve32) => {
+      const start = Date.now();
+      const socket = net2.createConnection({ host, port });
+      const timer = setTimeout(() => {
+        socket.destroy();
+        resolve32({ ok: false, layer: "tcp", detail: "timeout", latencyMs: Date.now() - start });
+      }, timeoutMs);
+      socket.on("connect", () => {
+        clearTimeout(timer);
+        socket.destroy();
+        resolve32({
+          ok: true,
+          layer: "tcp",
+          detail: "connected",
+          latencyMs: Date.now() - start
+        });
+      });
+      socket.on("error", (err) => {
+        clearTimeout(timer);
+        resolve32({
+          ok: false,
+          layer: "tcp",
+          detail: err.message,
+          latencyMs: Date.now() - start
+        });
+      });
+    })
+  };
+}
+function createDefaultTls() {
+  return {
+    get: (url, timeoutMs) => new Promise((resolve32) => {
+      const start = Date.now();
+      const timer = setTimeout(() => {
+        req.destroy();
+        resolve32({ ok: false, layer: "tls", detail: "timeout", latencyMs: Date.now() - start });
+      }, timeoutMs);
+      const req = https.get(url, {
+        headers: {
+          "User-Agent": "claudekit-cli-doctor/1.0"
+        }
+      }, (res) => {
+        res.resume();
+        clearTimeout(timer);
+        const status = res.statusCode ?? 0;
+        const latencyMs = Date.now() - start;
+        if (status === 200) {
+          resolve32({ ok: true, layer: "tls", detail: `HTTP ${status}`, latencyMs });
+        } else {
+          resolve32({ ok: false, layer: "tls", detail: `HTTP ${status}`, latencyMs });
+        }
+      });
+      req.on("error", (err) => {
+        clearTimeout(timer);
+        resolve32({
+          ok: false,
+          layer: "tls",
+          detail: err.message,
+          latencyMs: Date.now() - start
+        });
+      });
+    })
+  };
+}
+function createDefaultAuth() {
+  return {
+    checkKitAccess: async () => {
+      const start = Date.now();
+      const { getAuthenticatedClient: getAuthenticatedClient2 } = await Promise.resolve().then(() => (init_client(), exports_client));
+      const kit = AVAILABLE_KITS[PROBE_KIT];
+      try {
+        const client = await getAuthenticatedClient2();
+        await client.repos.get({ owner: kit.owner, repo: kit.repo });
+        return {
+          ok: true,
+          layer: "auth",
+          detail: "200 OK",
+          latencyMs: Date.now() - start,
+          statusCode: 200
+        };
+      } catch (err) {
+        const latencyMs = Date.now() - start;
+        const status = err?.status ?? err?.statusCode;
+        const message = err instanceof Error ? err.message : String(err);
+        if (status === 401) {
+          return {
+            ok: false,
+            layer: "auth",
+            detail: `401 Unauthorized — token invalid or missing. ${message}`,
+            latencyMs,
+            statusCode: 401
+          };
+        }
+        if (status === 404) {
+          return {
+            ok: false,
+            layer: "auth",
+            detail: `404 — no repository access (invitation pending). ${message}`,
+            latencyMs,
+            statusCode: 404
+          };
+        }
+        return {
+          ok: false,
+          layer: "auth",
+          detail: `${status ?? "?"} — ${message}`,
+          latencyMs,
+          statusCode: status
+        };
+      }
+    }
+  };
+}
+async function checkGitHubReachability(deps) {
+  const dnsStart = Date.now();
+  let dnsResult;
+  try {
+    const [r4, r6] = await Promise.allSettled([
+      raceTimeout(deps.dns.resolve4(API_HOST), DNS_TIMEOUT_MS),
+      raceTimeout(deps.dns.resolve6(API_HOST), DNS_TIMEOUT_MS)
+    ]);
+    const ok = r4.status === "fulfilled" || r6.status === "fulfilled";
+    let detail;
+    if (ok) {
+      if (r4.status === "fulfilled") {
+        detail = `resolved: ${r4.value[0]}`;
+      } else {
+        const r6Value = r6.value;
+        detail = `resolved (IPv6): ${r6Value[0]}`;
+      }
+    } else {
+      detail = "NXDOMAIN / timeout";
+    }
+    dnsResult = { ok, layer: "dns", detail, latencyMs: Date.now() - dnsStart };
+  } catch {
+    dnsResult = {
+      ok: false,
+      layer: "dns",
+      detail: "DNS resolution failed",
+      latencyMs: Date.now() - dnsStart
+    };
+  }
+  if (!dnsResult.ok) {
+    return { ok: false, failedLayer: "dns", layers: { dns: dnsResult } };
+  }
+  const tcpResult = await deps.tcp.connect({
+    host: API_HOST,
+    port: 443,
+    timeoutMs: TCP_TIMEOUT_MS
+  });
+  if (!tcpResult.ok) {
+    return { ok: false, failedLayer: "tcp", layers: { dns: dnsResult, tcp: tcpResult } };
+  }
+  const tlsResult = await deps.tls.get(ZEN_URL, TLS_TIMEOUT_MS);
+  if (!tlsResult.ok) {
+    return {
+      ok: false,
+      failedLayer: "tls",
+      layers: { dns: dnsResult, tcp: tcpResult, tls: tlsResult }
+    };
+  }
+  const authResult = await deps.auth.checkKitAccess();
+  if (!authResult.ok) {
+    return {
+      ok: false,
+      failedLayer: "auth",
+      layers: { dns: dnsResult, tcp: tcpResult, tls: tlsResult, auth: authResult }
+    };
+  }
+  return {
+    ok: true,
+    layers: { dns: dnsResult, tcp: tcpResult, tls: tlsResult, auth: authResult }
+  };
+}
+function raceTimeout(promise, ms) {
+  return new Promise((resolve32, reject) => {
+    const timer = setTimeout(() => reject(new Error(`timeout after ${ms}ms`)), ms);
+    promise.then((v2) => {
+      clearTimeout(timer);
+      resolve32(v2);
+    }, (e2) => {
+      clearTimeout(timer);
+      reject(e2);
+    });
+  });
+}
+
+class GitHubReachabilityChecker {
+  group = "network";
+  deps;
+  usingRealDeps;
+  constructor(options2 = {}) {
+    this.usingRealDeps = options2.deps === undefined;
+    this.deps = options2.deps ?? createDefaultDeps();
+  }
+  async run() {
+    if (this.usingRealDeps && (isCIEnvironment() || isTestEnvironment())) {
+      return [
+        {
+          id: "github-reachability",
+          name: "GitHub Reachability",
+          group: "network",
+          priority: "standard",
+          status: "info",
+          message: "Skipped in CI/test environment",
+          autoFixable: false
+        }
+      ];
+    }
+    logger.verbose("GitHubReachabilityChecker: running layered probe");
+    let result;
+    try {
+      result = await raceTimeout(checkGitHubReachability(this.deps), AUTH_TIMEOUT_MS + TLS_TIMEOUT_MS + TCP_TIMEOUT_MS + DNS_TIMEOUT_MS + 500);
+    } catch (err) {
+      return [
+        {
+          id: "github-reachability",
+          name: "GitHub Reachability",
+          group: "network",
+          priority: "standard",
+          status: "fail",
+          message: "Probe timed out",
+          details: err instanceof Error ? err.message : String(err),
+          suggestion: "Check internet connection and proxy settings",
+          autoFixable: false
+        }
+      ];
+    }
+    logger.verbose("GitHubReachabilityChecker: probe complete", { result });
+    return [buildCheckResult(result)];
+  }
+}
+function buildCheckResult(result) {
+  if (result.ok) {
+    const { dns, tcp, tls, auth } = result.layers;
+    const details = [
+      `DNS: ${dns.latencyMs}ms`,
+      tcp ? `TCP: ${tcp.latencyMs}ms` : null,
+      tls ? `TLS/GET: ${tls.latencyMs}ms` : null,
+      auth ? `Auth: ${auth.latencyMs}ms` : null
+    ].filter(Boolean).join(", ");
+    return {
+      id: "github-reachability",
+      name: "GitHub Reachability",
+      group: "network",
+      priority: "standard",
+      status: "pass",
+      message: "All layers reachable",
+      details,
+      autoFixable: false
+    };
+  }
+  const { failedLayer, layers } = result;
+  const failedProbe = layers[failedLayer];
+  const detail = failedProbe?.detail ?? "unknown";
+  const authSuggestion = failedProbe?.statusCode === 401 ? "GitHub token invalid or missing — run: gh auth login" : "No repository access — check GitHub invitation email or purchase at https://claudekit.cc";
+  const suggestions = {
+    dns: "DNS resolution failed — check /etc/resolv.conf or system DNS settings",
+    tcp: "TCP connect to api.github.com:443 failed — check firewall or proxy blocking port 443",
+    tls: "HTTPS GET /zen returned unexpected status — possible TLS interception or GitHub outage. Check https://githubstatus.com",
+    auth: authSuggestion
+  };
+  return {
+    id: "github-reachability",
+    name: "GitHub Reachability",
+    group: "network",
+    priority: "standard",
+    status: "fail",
+    message: `GitHub unreachable at ${failedLayer?.toUpperCase()} layer`,
+    details: detail,
+    suggestion: suggestions[failedLayer ?? ""] ?? "Run: ck doctor for full diagnostics",
+    autoFixable: false
+  };
+}
 // src/domains/health-checks/auto-healer.ts
 class AutoHealer {
   timeout;
@@ -88657,6 +89000,7 @@ async function doctorCommand(options2 = {}) {
   runner.registerChecker(new AuthChecker);
   runner.registerChecker(new PlatformChecker);
   runner.registerChecker(new NetworkChecker);
+  runner.registerChecker(new GitHubReachabilityChecker);
   const summary = await runner.run();
   if (json) {
     const generator = new ReportGenerator;
@@ -105359,7 +105703,15 @@ async function handleSelection(ctx) {
       logger.info("Full diagnostics: ck doctor");
       return { ...ctx, cancelled: true };
     }
-    accessibleKits = await detectAccessibleKits();
+    try {
+      accessibleKits = await detectAccessibleKits();
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      logger.error(`Failed to check repository access: ${message}`);
+      logger.info("");
+      logger.info("Run: ck doctor");
+      return { ...ctx, cancelled: true };
+    }
     if (accessibleKits.length === 0) {
       logger.error("No ClaudeKit repository access found.");
       logger.info("Check email for GitHub invitation, or purchase at https://claudekit.cc");
@@ -108812,7 +109164,7 @@ var import_picocolors31 = __toESM(require_picocolors(), 1);
 
 // src/commands/new/phases/directory-setup.ts
 init_config_manager();
-import { resolve as resolve42 } from "node:path";
+import { resolve as resolve43 } from "node:path";
 init_logger();
 init_path_resolver();
 init_types3();
@@ -108897,7 +109249,7 @@ async function directorySetup(validOptions, prompts) {
       targetDir = await prompts.getDirectory(targetDir);
     }
   }
-  const resolvedDir = resolve42(targetDir);
+  const resolvedDir = resolve43(targetDir);
   logger.info(`Target directory: ${resolvedDir}`);
   if (PathResolver.isLocalSameAsGlobal(resolvedDir)) {
     logger.warning("You're creating a project at HOME directory.");
@@ -109231,7 +109583,7 @@ Please use only one download method.`);
 // src/commands/plan/plan-command.ts
 init_output_manager();
 import { existsSync as existsSync67, statSync as statSync12 } from "node:fs";
-import { dirname as dirname46, isAbsolute as isAbsolute11, join as join147, parse as parse7, resolve as resolve46 } from "node:path";
+import { dirname as dirname46, isAbsolute as isAbsolute11, join as join147, parse as parse7, resolve as resolve48 } from "node:path";
 
 // src/commands/plan/plan-read-handlers.ts
 init_config();
@@ -109241,7 +109593,7 @@ init_logger();
 init_output_manager();
 var import_picocolors32 = __toESM(require_picocolors(), 1);
 import { existsSync as existsSync66, statSync as statSync11 } from "node:fs";
-import { basename as basename28, dirname as dirname44, join as join146, relative as relative27, resolve as resolve44 } from "node:path";
+import { basename as basename28, dirname as dirname44, join as join146, relative as relative27, resolve as resolve46 } from "node:path";
 
 // src/commands/plan/plan-dependencies.ts
 init_config();
@@ -109299,14 +109651,14 @@ init_config();
 init_plan_parser();
 init_plan_scope();
 init_plans_registry();
-import { isAbsolute as isAbsolute10, resolve as resolve43 } from "node:path";
+import { isAbsolute as isAbsolute10, resolve as resolve45 } from "node:path";
 async function getGlobalPlansDirFromCwd() {
   const projectRoot = findProjectRoot(process.cwd());
   const { config } = await CkConfigManager.loadFull(projectRoot);
   return resolveGlobalPlansDir(config);
 }
 function resolveTargetFromBase(target, baseDir) {
-  const resolvedTarget = isAbsolute10(target) ? resolve43(target) : resolve43(baseDir, target);
+  const resolvedTarget = isAbsolute10(target) ? resolve45(target) : resolve45(baseDir, target);
   return isWithinDir(resolvedTarget, baseDir) ? resolvedTarget : null;
 }
 
@@ -109409,7 +109761,7 @@ async function handleStatus(target, options2) {
     return;
   }
   const effectiveTarget = !resolvedTarget && globalBaseDir ? globalBaseDir : resolvedTarget;
-  const t = effectiveTarget ? resolve44(effectiveTarget) : null;
+  const t = effectiveTarget ? resolve46(effectiveTarget) : null;
   const plansDir = t && existsSync66(t) && statSync11(t).isDirectory() && !existsSync66(join146(t, "plan.md")) ? t : null;
   if (plansDir) {
     const planFiles = scanPlanDir(plansDir);
@@ -109594,7 +109946,7 @@ init_plan_parser();
 init_plans_registry();
 init_output_manager();
 var import_picocolors33 = __toESM(require_picocolors(), 1);
-import { basename as basename29, dirname as dirname45, relative as relative28, resolve as resolve45 } from "node:path";
+import { basename as basename29, dirname as dirname45, relative as relative28, resolve as resolve47 } from "node:path";
 async function handleCreate(target, options2) {
   if (!options2.title) {
     output.error("[X] --title is required for create");
@@ -109626,13 +109978,13 @@ async function handleCreate(target, options2) {
     return;
   }
   const globalBaseDir = options2.global ? await getGlobalPlansDirFromCwd() : undefined;
-  const resolvedDir = globalBaseDir ? resolveTargetFromBase(dir, globalBaseDir) : resolve45(dir);
+  const resolvedDir = globalBaseDir ? resolveTargetFromBase(dir, globalBaseDir) : resolve47(dir);
   if (globalBaseDir && !resolvedDir) {
     output.error("[X] Target directory must stay within the configured global plans root");
     process.exitCode = 1;
     return;
   }
-  const safeResolvedDir = resolvedDir ?? resolve45(dir);
+  const safeResolvedDir = resolvedDir ?? resolve47(dir);
   const result = scaffoldPlan({
     title: options2.title,
     phases: phaseNames.map((name2) => ({ name: name2 })),
@@ -109808,19 +110160,19 @@ async function handleAddPhase(target, options2) {
 // src/commands/plan/plan-command.ts
 function resolveTargetPath(target, baseDir) {
   if (!baseDir) {
-    return resolve46(target);
+    return resolve48(target);
   }
   if (isAbsolute11(target)) {
-    return resolve46(target);
+    return resolve48(target);
   }
-  const cwdCandidate = resolve46(target);
+  const cwdCandidate = resolve48(target);
   if (existsSync67(cwdCandidate)) {
     return cwdCandidate;
   }
-  return resolve46(baseDir, target);
+  return resolve48(baseDir, target);
 }
 function resolvePlanFile(target, baseDir) {
-  const t = target ? resolveTargetPath(target, baseDir) : baseDir ? resolve46(baseDir) : process.cwd();
+  const t = target ? resolveTargetPath(target, baseDir) : baseDir ? resolve48(baseDir) : process.cwd();
   if (existsSync67(t)) {
     const stat24 = statSync12(t);
     if (stat24.isFile())
@@ -109884,7 +110236,7 @@ async function planCommand(action, target, options2) {
   let resolvedTarget = target;
   if (resolvedAction && !knownActions.has(resolvedAction)) {
     const looksLikePath = resolvedAction.includes("/") || resolvedAction.includes("\\") || resolvedAction.endsWith(".md") || resolvedAction === "." || resolvedAction === "..";
-    const existsOnDisk = !looksLikePath && existsSync67(resolve46(resolvedAction));
+    const existsOnDisk = !looksLikePath && existsSync67(resolve48(resolvedAction));
     if (looksLikePath || existsOnDisk) {
       resolvedTarget = resolvedAction;
       resolvedAction = undefined;
@@ -109927,11 +110279,11 @@ init_logger();
 init_safe_prompts();
 var import_picocolors34 = __toESM(require_picocolors(), 1);
 import { existsSync as existsSync68 } from "node:fs";
-import { resolve as resolve47 } from "node:path";
+import { resolve as resolve49 } from "node:path";
 async function handleAdd(projectPath, options2) {
   logger.debug(`Adding project: ${projectPath}, options: ${JSON.stringify(options2)}`);
   intro("Add Project");
-  const absolutePath = resolve47(projectPath);
+  const absolutePath = resolve49(projectPath);
   if (!existsSync68(absolutePath)) {
     log.error(`Path does not exist: ${absolutePath}`);
     process.exitCode = 1;
@@ -111036,7 +111388,7 @@ async function detectInstallations() {
 
 // src/commands/uninstall/removal-handler.ts
 import { readdirSync as readdirSync10, rmSync as rmSync5 } from "node:fs";
-import { basename as basename30, join as join150, resolve as resolve48, sep as sep12 } from "node:path";
+import { basename as basename30, join as join150, resolve as resolve50, sep as sep12 } from "node:path";
 init_logger();
 init_safe_prompts();
 init_safe_spinner();
@@ -111217,8 +111569,8 @@ async function restoreUninstallBackup(backup) {
 }
 async function isPathSafeToRemove(filePath, baseDir) {
   try {
-    const resolvedPath = resolve48(filePath);
-    const resolvedBase = resolve48(baseDir);
+    const resolvedPath = resolve50(filePath);
+    const resolvedBase = resolve50(baseDir);
     if (!resolvedPath.startsWith(resolvedBase + sep12) && resolvedPath !== resolvedBase) {
       logger.debug(`Path outside installation directory: ${filePath}`);
       return false;
@@ -111226,7 +111578,7 @@ async function isPathSafeToRemove(filePath, baseDir) {
     const stats = await import_fs_extra44.lstat(filePath);
     if (stats.isSymbolicLink()) {
       const realPath = await import_fs_extra44.realpath(filePath);
-      const resolvedReal = resolve48(realPath);
+      const resolvedReal = resolve50(realPath);
       if (!resolvedReal.startsWith(resolvedBase + sep12) && resolvedReal !== resolvedBase) {
         logger.debug(`Symlink points outside installation directory: ${filePath} -> ${realPath}`);
         return false;
@@ -111689,7 +112041,7 @@ function getDisclaimerMarker() {
   return AI_DISCLAIMER;
 }
 function spawnAndCollect2(command, args) {
-  return new Promise((resolve49, reject) => {
+  return new Promise((resolve44, reject) => {
     const child = spawn7(command, args, { stdio: ["ignore", "pipe", "pipe"] });
     const chunks = [];
     const stderrChunks = [];
@@ -111702,7 +112054,7 @@ function spawnAndCollect2(command, args) {
         reject(new Error(`${command} exited with code ${code2}: ${stderr}`));
         return;
       }
-      resolve49(Buffer.concat(chunks).toString("utf-8"));
+      resolve44(Buffer.concat(chunks).toString("utf-8"));
     });
   });
 }
@@ -111810,7 +112162,7 @@ function formatResponse(content, showBranding) {
   return disclaimer + formatted + branding;
 }
 async function postViaGh(owner, repo, issueNumber, body) {
-  return new Promise((resolve49, reject) => {
+  return new Promise((resolve44, reject) => {
     const args = [
       "issue",
       "comment",
@@ -111832,7 +112184,7 @@ async function postViaGh(owner, repo, issueNumber, body) {
         reject(new Error(`gh exited with code ${code2}: ${stderr}`));
         return;
       }
-      resolve49();
+      resolve44();
     });
   });
 }
@@ -111950,7 +112302,7 @@ After completing the implementation:
     "--allowedTools",
     tools
   ];
-  await new Promise((resolve49, reject) => {
+  await new Promise((resolve44, reject) => {
     const child = spawn9("claude", args, { cwd: cwd2, stdio: ["pipe", "pipe", "pipe"], detached: false });
     child.stdin.write(prompt);
     child.stdin.end();
@@ -111975,7 +112327,7 @@ After completing the implementation:
         reject(new Error(`Claude exited ${code2}: ${stderr.slice(0, 500)}`));
         return;
       }
-      resolve49();
+      resolve44();
     });
   });
 }
@@ -112119,7 +112471,7 @@ function checkRateLimit2(processedThisHour, maxPerHour) {
   return processedThisHour < maxPerHour;
 }
 function spawnAndCollect3(command, args) {
-  return new Promise((resolve49, reject) => {
+  return new Promise((resolve44, reject) => {
     const child = spawn10(command, args, { stdio: ["ignore", "pipe", "pipe"] });
     const chunks = [];
     const stderrChunks = [];
@@ -112132,7 +112484,7 @@ function spawnAndCollect3(command, args) {
         reject(new Error(`${command} exited with code ${code2}: ${stderr}`));
         return;
       }
-      resolve49(Buffer.concat(chunks).toString("utf-8"));
+      resolve44(Buffer.concat(chunks).toString("utf-8"));
     });
   });
 }
@@ -112184,7 +112536,7 @@ async function invokeClaude(options2) {
   return collectClaudeOutput(child, options2.timeoutSec, verbose);
 }
 function collectClaudeOutput(child, timeoutSec, verbose = false) {
-  return new Promise((resolve49, reject) => {
+  return new Promise((resolve44, reject) => {
     const chunks = [];
     const stderrChunks = [];
     child.stdout?.on("data", (chunk) => {
@@ -112214,7 +112566,7 @@ function collectClaudeOutput(child, timeoutSec, verbose = false) {
         reject(new Error(`Claude exited with code ${code2}: ${stderr}`));
         return;
       }
-      resolve49(verbose ? parseStreamJsonOutput(stdout2) : parseClaudeOutput(stdout2));
+      resolve44(verbose ? parseStreamJsonOutput(stdout2) : parseClaudeOutput(stdout2));
     });
   });
 }
@@ -113478,7 +113830,7 @@ function formatQueueInfo(state) {
   return "idle";
 }
 function sleep(ms) {
-  return new Promise((resolve49) => setTimeout(resolve49, ms));
+  return new Promise((resolve44) => setTimeout(resolve44, ms));
 }
 // src/cli/command-registry.ts
 init_logger();

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "claudekit-cli",
-	"version": "3.42.2-dev.6",
+	"version": "3.42.2-dev.8",
 	"description": "CLI tool for bootstrapping and updating ClaudeKit projects",
 	"type": "module",
 	"repository": {