claudekit-cli 4.3.1-dev.1 → 4.3.1-dev.3

package/dist/index.js

@@ -12564,6 +12564,16 @@ import { existsSync as existsSync2 } from "node:fs";
 import { mkdir, readFile as readFile2, rename, unlink, writeFile } from "node:fs/promises";
 import { homedir as homedir3 } from "node:os";
 import { dirname, join as join2, resolve } from "node:path";
+function getPortableRegistryPaths() {
+  const home2 = homedir3();
+  const claudekitDir = join2(home2, ".claudekit");
+  return {
+    registryPath: join2(claudekitDir, "portable-registry.json"),
+    registryLockPath: join2(claudekitDir, "portable-registry.lock"),
+    legacyRegistryPath: join2(claudekitDir, "skill-registry.json"),
+    migrationLockPath: join2(claudekitDir, ".migration.lock")
+  };
+}
 function isErrnoCode(error, code) {
   return typeof error === "object" && error !== null && "code" in error && error.code === code;
 }
@@ -12597,8 +12607,9 @@ function getCliVersion() {
   }
 }
 async function migrateLegacyRegistry() {
+  const { legacyRegistryPath } = getPortableRegistryPaths();
   try {
-    const content = await readFile2(LEGACY_REGISTRY_PATH, "utf-8");
+    const content = await readFile2(legacyRegistryPath, "utf-8");
     const data = JSON.parse(content);
     const legacy = LegacyRegistrySchema.parse(data);
     const installations = legacy.installations.map((i) => ({
@@ -12707,9 +12718,10 @@ async function repairStaleRegistryV3(registry) {
 }
 async function persistCurrentStaleRegistryV3Repair(preparedRepair) {
   return withRegistryLock(async () => {
+    const { registryPath } = getPortableRegistryPaths();
     let content;
     try {
-      content = await readFile2(REGISTRY_PATH, "utf-8");
+      content = await readFile2(registryPath, "utf-8");
     } catch (error) {
       if (isErrnoCode(error, "ENOENT")) {
         return readPortableRegistryInternal({ persistStaleV3Repair: false });
@@ -12741,8 +12753,9 @@ async function persistCurrentStaleRegistryV3Repair(preparedRepair) {
   });
 }
 async function isMigrationLocked() {
+  const { migrationLockPath } = getPortableRegistryPaths();
   try {
-    const lockContent = await readFile2(MIGRATION_LOCK_PATH, "utf-8");
+    const lockContent = await readFile2(migrationLockPath, "utf-8");
     const lockTime = Number.parseInt(lockContent, 10);
     if (Number.isNaN(lockTime)) {
       logger.verbose("Migration lock timestamp is invalid, treating lock as active");
@@ -12754,7 +12767,7 @@ async function isMigrationLocked() {
       return true;
     }
     logger.verbose("Removing stale migration lock");
-    await unlink(MIGRATION_LOCK_PATH);
+    await unlink(migrationLockPath);
     return false;
   } catch (error) {
     if (isErrnoCode(error, "ENOENT")) {
@@ -12765,23 +12778,26 @@ async function isMigrationLocked() {
   }
 }
 async function createMigrationLock() {
-  const lockDir = dirname(MIGRATION_LOCK_PATH);
+  const { migrationLockPath } = getPortableRegistryPaths();
+  const lockDir = dirname(migrationLockPath);
   if (!existsSync2(lockDir)) {
     await mkdir(lockDir, { recursive: true });
   }
-  await writeFile(MIGRATION_LOCK_PATH, Date.now().toString(), "utf-8");
+  await writeFile(migrationLockPath, Date.now().toString(), "utf-8");
 }
 async function removeMigrationLock() {
+  const { migrationLockPath } = getPortableRegistryPaths();
   try {
-    await unlink(MIGRATION_LOCK_PATH);
+    await unlink(migrationLockPath);
   } catch {}
 }
 async function readPortableRegistry() {
   return readPortableRegistryInternal({ persistStaleV3Repair: true });
 }
 async function readPortableRegistryInternal(options2) {
+  const { registryPath } = getPortableRegistryPaths();
   try {
-    const content = await readFile2(REGISTRY_PATH, "utf-8");
+    const content = await readFile2(registryPath, "utf-8");
     let data;
     try {
       data = JSON.parse(content);
@@ -12850,15 +12866,16 @@ async function readPortableRegistryWithinRegistryLock() {
   return readPortableRegistryInternal({ persistStaleV3Repair: false });
 }
 async function writePortableRegistry(registry) {
-  const dir = dirname(REGISTRY_PATH);
+  const { registryPath } = getPortableRegistryPaths();
+  const dir = dirname(registryPath);
   if (!existsSync2(dir)) {
     await mkdir(dir, { recursive: true });
   }
   const normalizedRegistry = normalizePortableRegistryChecksums(registry);
-  const tempPath = `${REGISTRY_PATH}.tmp-${process.pid}-${Date.now()}`;
+  const tempPath = `${registryPath}.tmp-${process.pid}-${Date.now()}`;
   try {
     await writeFile(tempPath, JSON.stringify(normalizedRegistry, null, 2), "utf-8");
-    await rename(tempPath, REGISTRY_PATH);
+    await rename(tempPath, registryPath);
   } catch (error) {
     try {
       await unlink(tempPath);
@@ -12867,14 +12884,15 @@ async function writePortableRegistry(registry) {
   }
 }
 async function withRegistryLock(operation) {
-  const lockDir = dirname(REGISTRY_LOCK_PATH);
+  const { registryLockPath } = getPortableRegistryPaths();
+  const lockDir = dirname(registryLockPath);
   if (!existsSync2(lockDir)) {
     await mkdir(lockDir, { recursive: true });
   }
-  if (!existsSync2(REGISTRY_LOCK_PATH)) {
-    await writeFile(REGISTRY_LOCK_PATH, "", "utf-8");
+  if (!existsSync2(registryLockPath)) {
+    await writeFile(registryLockPath, "", "utf-8");
   }
-  const release = await import_proper_lockfile.default.lock(REGISTRY_LOCK_PATH, {
+  const release = await import_proper_lockfile.default.lock(registryLockPath, {
     realpath: false,
     retries: {
       retries: 5,
@@ -12975,17 +12993,12 @@ async function syncPortableRegistry() {
     return { removed };
   });
 }
-var import_proper_lockfile, home2, REGISTRY_PATH, REGISTRY_LOCK_PATH, LEGACY_REGISTRY_PATH, MIGRATION_LOCK_PATH, PortableInstallationSchema, PortableRegistrySchema, PortableInstallationSchemaV3, PortableRegistrySchemaV3, RepairablePortableRegistrySchemaV3, LegacyInstallationSchema, LegacyRegistrySchema;
+var import_proper_lockfile, PortableInstallationSchema, PortableRegistrySchema, PortableInstallationSchemaV3, PortableRegistrySchemaV3, RepairablePortableRegistrySchemaV3, LegacyInstallationSchema, LegacyRegistrySchema;
 var init_portable_registry = __esm(() => {
   init_zod();
   init_logger();
   init_checksum_utils();
   import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
-  home2 = homedir3();
-  REGISTRY_PATH = join2(home2, ".claudekit", "portable-registry.json");
-  REGISTRY_LOCK_PATH = join2(home2, ".claudekit", "portable-registry.lock");
-  LEGACY_REGISTRY_PATH = join2(home2, ".claudekit", "skill-registry.json");
-  MIGRATION_LOCK_PATH = join2(home2, ".claudekit", ".migration.lock");
   PortableInstallationSchema = exports_external.object({
     item: exports_external.string(),
     type: exports_external.enum(["agent", "command", "skill", "config", "rules", "hooks"]),
@@ -13046,6 +13059,12 @@ import { existsSync as existsSync3 } from "node:fs";
 import { mkdir as mkdir2, readFile as readFile3, realpath, unlink as unlink2, writeFile as writeFile2 } from "node:fs/promises";
 import { homedir as homedir4 } from "node:os";
 import { basename, dirname as dirname2, isAbsolute, join as join3, relative, resolve as resolve2 } from "node:path";
+function resolveCodexTomlRegistryDeps(deps) {
+  return {
+    ...defaultCodexTomlRegistryDeps,
+    ...deps
+  };
+}
 async function ensureDir(filePath) {
   const dir = dirname2(filePath);
   if (!existsSync3(dir)) {
@@ -13299,12 +13318,13 @@ async function restoreFileSnapshots(snapshots) {
     await restoreFileSnapshot(snapshots[index]);
   }
 }
-async function rollbackRegistryEntries(entries, portableType, provider, global2) {
+async function rollbackRegistryEntries(entries, portableType, provider, global2, registryDeps) {
   for (let index = entries.length - 1;index >= 0; index -= 1) {
-    await removePortableInstallation(entries[index].itemName, portableType, provider, global2);
+    await registryDeps.removePortableInstallation(entries[index].itemName, portableType, provider, global2);
   }
 }
-async function installCodexToml(items, provider, portableType, options2) {
+async function installCodexToml(items, provider, portableType, options2, deps) {
+  const registryDeps = resolveCodexTomlRegistryDeps(deps);
   const config = providers[provider];
   const pathConfig = config.agents;
   if (!pathConfig) {
@@ -13487,7 +13507,7 @@ async function installCodexToml(items, provider, portableType, options2) {
         }
         await writeFile2(configTomlPath, mergeResult.content, "utf-8");
         for (const install of pendingInstalls) {
-          await addPortableInstallation(install.itemName, portableType, provider, options2.global, install.agentTomlPath, install.sourcePath, {
+          await registryDeps.addPortableInstallation(install.itemName, portableType, provider, options2.global, install.agentTomlPath, install.sourcePath, {
             sourceChecksum: install.sourceChecksum,
             targetChecksum: install.targetChecksum,
             ownedSections: [install.slug],
@@ -13506,7 +13526,7 @@ async function installCodexToml(items, provider, portableType, options2) {
         let message = error instanceof Error ? error.message : "Unknown error";
         if (addedRegistryEntries.length > 0) {
           try {
-            await rollbackRegistryEntries(addedRegistryEntries, portableType, provider, options2.global);
+            await rollbackRegistryEntries(addedRegistryEntries, portableType, provider, options2.global, registryDeps);
           } catch (rollbackRegistryError) {
             const rollbackMessage = rollbackRegistryError instanceof Error ? rollbackRegistryError.message : "Unknown registry rollback error";
             message = `${message}; registry rollback failed: ${rollbackMessage}`;
@@ -13632,7 +13652,7 @@ async function cleanupStaleCodexConfigEntries(options2) {
     return [];
   }
 }
-var import_proper_lockfile2, SENTINEL_START = "# --- ck-managed-agents-start ---", SENTINEL_END = "# --- ck-managed-agents-end ---", MAX_WINDOWS_PATH_LENGTH = 240;
+var import_proper_lockfile2, SENTINEL_START = "# --- ck-managed-agents-start ---", SENTINEL_END = "# --- ck-managed-agents-end ---", MAX_WINDOWS_PATH_LENGTH = 240, defaultCodexTomlRegistryDeps;
 var init_codex_toml_installer = __esm(() => {
   init_logger();
   init_checksum_utils();
@@ -13641,6 +13661,10 @@ var init_codex_toml_installer = __esm(() => {
   init_portable_registry();
   init_provider_registry();
   import_proper_lockfile2 = __toESM(require_proper_lockfile(), 1);
+  defaultCodexTomlRegistryDeps = {
+    addPortableInstallation,
+    removePortableInstallation
+  };
 });
 
 // src/commands/portable/merge-single-sections.ts
@@ -13888,6 +13912,12 @@ function validateStrategyTargetPath(targetPath, options2) {
   }
   return null;
 }
+function resolvePortableInstallerRegistryDeps(deps) {
+  return {
+    ...defaultPortableInstallerRegistryDeps,
+    ...deps
+  };
+}
 function resolvePerFileOutputFilename(filename, pathConfig) {
   if (pathConfig.nestedCommands !== false || !filename.includes("/")) {
     return filename;
@@ -14049,7 +14079,7 @@ function buildPerFileCollisionSkips(items, provider, configDisplayName, basePath
   }
   return skipped;
 }
-async function installPerFileItems(items, provider, portableType, pathConfig, options2) {
+async function installPerFileItems(items, provider, portableType, pathConfig, options2, registryDeps) {
   const config = providers[provider];
   const results = [];
   let aggregateChars = 0;
@@ -14101,7 +14131,7 @@ async function installPerFileItems(items, provider, portableType, pathConfig, op
         continue;
       }
     }
-    const result = await installPerFile(item, provider, portableType, options2);
+    const result = await installPerFile(item, provider, portableType, options2, registryDeps);
     if (totalCharLimit && result.success && !result.skipped) {
       aggregateChars += itemSize;
     }
@@ -14189,7 +14219,7 @@ function parseYamlModesFile(content) {
   }
   return modes;
 }
-async function installPerFile(item, provider, portableType, options2) {
+async function installPerFile(item, provider, portableType, options2, registryDeps) {
   const config = providers[provider];
   const typeKey = getProviderPathKeyForPortableType(portableType);
   const pathConfig = config[typeKey];
@@ -14274,7 +14304,7 @@ async function installPerFile(item, provider, portableType, options2) {
     await writeFile3(targetPath, result.content, "utf-8");
     const sourceChecksum = computeContentChecksum(result.content);
     const targetChecksum = sourceChecksum;
-    await addPortableInstallation(item.name, portableType, provider, options2.global, targetPath, item.sourcePath, {
+    await registryDeps.addPortableInstallation(item.name, portableType, provider, options2.global, targetPath, item.sourcePath, {
       sourceChecksum,
       targetChecksum,
       installSource: "kit"
@@ -14307,7 +14337,7 @@ async function installPerFile(item, provider, portableType, options2) {
     };
   }
 }
-async function installMergeSingle(items, provider, portableType, options2) {
+async function installMergeSingle(items, provider, portableType, options2, registryDeps) {
   const config = providers[provider];
   const typeKey = getProviderPathKeyForPortableType(portableType);
   const pathConfig = config[typeKey];
@@ -14479,7 +14509,7 @@ ${sections.join(`
           const sectionContent = newOwnedSections.get(sectionKey) || "";
           const sourceChecksum = newSourceChecksums.get(sectionKey) ?? computeContentChecksum(item.body);
           const targetChecksum = computeContentChecksum(sectionContent);
-          await addPortableInstallation(item.name, portableType, provider, options2.global, targetPath, item.sourcePath, {
+          await registryDeps.addPortableInstallation(item.name, portableType, provider, options2.global, targetPath, item.sourcePath, {
             sourceChecksum,
             targetChecksum,
             ownedSections: [sectionKey],
@@ -14522,7 +14552,7 @@ ${sections.join(`
     };
   }
 }
-async function installYamlMerge(items, provider, portableType, options2) {
+async function installYamlMerge(items, provider, portableType, options2, registryDeps) {
   const config = providers[provider];
   const typeKey = getProviderPathKeyForPortableType(portableType);
   const pathConfig = config[typeKey];
@@ -14628,7 +14658,7 @@ async function installYamlMerge(items, provider, portableType, options2) {
     for (const item of items) {
       const result = convertItem(item, pathConfig.format, provider, { global: options2.global });
       const sourceChecksum = computeContentChecksum(result.content);
-      await addPortableInstallation(item.name, portableType, provider, options2.global, targetPath, item.sourcePath, {
+      await registryDeps.addPortableInstallation(item.name, portableType, provider, options2.global, targetPath, item.sourcePath, {
         sourceChecksum,
         targetChecksum,
         ownedSections,
@@ -14660,7 +14690,7 @@ async function installYamlMerge(items, provider, portableType, options2) {
     };
   }
 }
-async function installJsonMerge(items, provider, portableType, options2) {
+async function installJsonMerge(items, provider, portableType, options2, registryDeps) {
   const config = providers[provider];
   const typeKey = getProviderPathKeyForPortableType(portableType);
   const pathConfig = config[typeKey];
@@ -14838,7 +14868,7 @@ ${item.body}
     for (const item of items) {
       const result = convertItem(item, pathConfig.format, provider, { global: options2.global });
       const sourceChecksum = computeContentChecksum(result.content);
-      await addPortableInstallation(item.name, portableType, provider, options2.global, modesPath, item.sourcePath, {
+      await registryDeps.addPortableInstallation(item.name, portableType, provider, options2.global, modesPath, item.sourcePath, {
         sourceChecksum,
         targetChecksum,
         ownedSections,
@@ -14870,7 +14900,8 @@ ${item.body}
     };
   }
 }
-async function installPortableItem(items, provider, portableType, options2) {
+async function installPortableItem(items, provider, portableType, options2, deps) {
+  const registryDeps = resolvePortableInstallerRegistryDeps(deps);
   const config = providers[provider];
   const typeKey = getProviderPathKeyForPortableType(portableType);
   const pathConfig = config[typeKey];
@@ -14885,17 +14916,17 @@ async function installPortableItem(items, provider, portableType, options2) {
   }
   switch (pathConfig.writeStrategy) {
     case "merge-single":
-      return installMergeSingle(items, provider, portableType, options2);
+      return installMergeSingle(items, provider, portableType, options2, registryDeps);
     case "yaml-merge":
-      return installYamlMerge(items, provider, portableType, options2);
+      return installYamlMerge(items, provider, portableType, options2, registryDeps);
     case "json-merge":
-      return installJsonMerge(items, provider, portableType, options2);
+      return installJsonMerge(items, provider, portableType, options2, registryDeps);
     case "codex-toml":
-      return installCodexToml(items, provider, portableType, options2);
+      return installCodexToml(items, provider, portableType, options2, registryDeps);
     case "single-file":
-      return installPerFile(items[0], provider, portableType, options2);
+      return installPerFile(items[0], provider, portableType, options2, registryDeps);
     case "codex-hooks":
-      return installPerFile(items[0], provider, portableType, options2);
+      return installPerFile(items[0], provider, portableType, options2, registryDeps);
     case "per-file": {
       const results = [];
       let aggregateChars = 0;
@@ -14943,7 +14974,7 @@ async function installPortableItem(items, provider, portableType, options2) {
             continue;
           }
         }
-        const result = await installPerFile(item, provider, portableType, options2);
+        const result = await installPerFile(item, provider, portableType, options2, registryDeps);
         if (totalCharLimit && result.success && !result.skipped) {
           aggregateChars += itemSize;
         }
@@ -14979,7 +15010,8 @@ async function installPortableItem(items, provider, portableType, options2) {
     }
   }
 }
-async function installPortableItems(items, targetProviders, portableType, options2) {
+async function installPortableItems(items, targetProviders, portableType, options2, deps) {
+  const registryDeps = resolvePortableInstallerRegistryDeps(deps);
   const uniqueProviders = Array.from(new Set(targetProviders));
   const results = [];
   for (const provider of uniqueProviders) {
@@ -14988,14 +15020,14 @@ async function installPortableItems(items, targetProviders, portableType, option
     const pathConfig = config[typeKey];
     const providerOptions = { ...options2 };
     if (pathConfig?.writeStrategy === "per-file") {
-      results.push(...await installPerFileItems(items, provider, portableType, pathConfig, providerOptions));
+      results.push(...await installPerFileItems(items, provider, portableType, pathConfig, providerOptions, registryDeps));
       continue;
     }
-    results.push(await installPortableItem(items, provider, portableType, providerOptions));
+    results.push(await installPortableItem(items, provider, portableType, providerOptions, registryDeps));
   }
   return results;
 }
-var import_proper_lockfile3, ClineCustomModeSchema, ClineCustomModesFileSchema;
+var import_proper_lockfile3, ClineCustomModeSchema, ClineCustomModesFileSchema, defaultPortableInstallerRegistryDeps;
 var init_portable_installer = __esm(() => {
   init_zod();
   init_checksum_utils();
@@ -15018,6 +15050,9 @@ var init_portable_installer = __esm(() => {
   ClineCustomModesFileSchema = exports_external.object({
     customModes: exports_external.array(ClineCustomModeSchema).optional()
   });
+  defaultPortableInstallerRegistryDeps = {
+    addPortableInstallation
+  };
 });
 
 // src/commands/portable/types.ts
@@ -49406,7 +49441,7 @@ function resolveAgentDirs() {
       dirs.push({ path: candidate, label: rel });
     }
   }
-  const globalPath = join28(home3, ".claude", "agents");
+  const globalPath = join28(home2, ".claude", "agents");
   dirs.push({ path: globalPath, label: "~/.claude/agents" });
   const seen = new Set;
   return dirs.filter(({ path: path3 }) => {
@@ -49495,11 +49530,11 @@ function registerAgentsBrowserRoutes(app) {
     res.status(404).json({ error: "Agent not found" });
   });
 }
-var home3;
+var home2;
 var init_agents_routes = __esm(() => {
   init_frontmatter_parser();
   init_kit_layout();
-  home3 = homedir15();
+  home2 = homedir15();
 });
 
 // src/schemas/ck-config.schema.json
@@ -51551,10 +51586,10 @@ function mergeServers(lists) {
 function isSafeProjectPath(projectPath) {
   if (projectPath.includes(".."))
     return false;
-  const home4 = homedir23();
+  const home3 = homedir23();
   try {
     const resolved = resolve14(projectPath);
-    if (!resolved.startsWith(home4))
+    if (!resolved.startsWith(home3))
       return false;
     return existsSync21(resolved);
   } catch {
@@ -51918,9 +51953,9 @@ async function copyHooksCompanionDirs(sourceDir, targetDir) {
 function resolveSourceOrigin(sourcePath) {
   if (!sourcePath)
     return "global";
-  const home4 = homedir24();
+  const home3 = homedir24();
   const cwd2 = process.cwd();
-  if (cwd2 === home4)
+  if (cwd2 === home3)
     return "global";
   const cwdPrefix = cwd2.endsWith(sep6) ? cwd2 : `${cwd2}${sep6}`;
   if (sourcePath === cwd2 || sourcePath.startsWith(cwdPrefix))
@@ -53856,22 +53891,29 @@ async function detectCodexCapabilities() {
   if (process.env.CK_CODEX_COMPAT === "strict") {
     return CODEX_CAPABILITY_TABLE[CODEX_CAPABILITY_TABLE.length - 1];
   }
-  try {
-    const { stdout } = await execFileAsync5("codex", ["--version"], {
-      timeout: 5000,
-      encoding: "utf8"
-    });
-    const raw = stdout.trim();
+  const binaryCandidates = process.platform === "win32" ? ["codex.exe", "codex"] : ["codex"];
+  let rawStdout = null;
+  for (const bin of binaryCandidates) {
+    try {
+      const { stdout } = await execFileAsync5(bin, ["--version"], {
+        timeout: 5000,
+        encoding: "utf8"
+      });
+      rawStdout = stdout;
+      break;
+    } catch {}
+  }
+  if (rawStdout !== null) {
+    const raw = rawStdout.trim();
     const version = raw.replace(/^(codex\s+)?v?/i, "").trim();
     const match = findCapabilitiesForVersion(version);
     if (match)
       return match;
     logger.warning(`[!] Codex version ${version} not found in ck capability table; using most-restrictive baseline. Set CK_CODEX_COMPAT=optimistic to use newest known capabilities instead.`);
     return process.env.CK_CODEX_COMPAT === "optimistic" ? CODEX_CAPABILITY_TABLE[0] : FALLBACK_CAPABILITIES;
-  } catch {
-    logger.warning("[!] Could not detect Codex version; using most-restrictive capability baseline. Set CK_CODEX_COMPAT=optimistic to use newest known capabilities instead.");
-    return process.env.CK_CODEX_COMPAT === "optimistic" ? CODEX_CAPABILITY_TABLE[0] : FALLBACK_CAPABILITIES;
   }
+  logger.warning("[!] Could not detect Codex version; using most-restrictive capability baseline. Set CK_CODEX_COMPAT=optimistic to use newest known capabilities instead.");
+  return process.env.CK_CODEX_COMPAT === "optimistic" ? CODEX_CAPABILITY_TABLE[0] : FALLBACK_CAPABILITIES;
 }
 function findCapabilitiesForVersion(version) {
   const exact = CODEX_CAPABILITY_TABLE.find((entry) => entry.version === version);
@@ -54234,11 +54276,12 @@ function buildWrapperScript(originalPath, capabilities, hookTimeoutMs) {
   const escapedOriginalPath = JSON.stringify(originalPath);
   const scrubRulesJson = JSON.stringify(scrubRules);
   const effectiveTimeout = hookTimeoutMs ?? 30000;
-  return `#!/usr/bin/env node
-// AUTO-GENERATED by claudekit ck migrate — DO NOT EDIT
+  return `// AUTO-GENERATED by claudekit ck migrate — DO NOT EDIT
 // Codex hook compatibility wrapper for:
 //   ${originalPath}
 //
+// INVOCATION: always call as \`node "<this-file>"\` — no shebang (Windows portability).
+// The hooks.json command field must prefix this wrapper with \`node\`.
 // This wrapper spawns the original hook, sanitizes its JSON output
 // to remove fields that Codex does not support, then re-emits to stdout.
 // To regenerate: run \`ck migrate\` again.
@@ -54450,25 +54493,46 @@ function scrubHookEntry(entry, event, capabilities, pathRewrite) {
 }
 function rewriteCommandPath(command, pathRewrite) {
   if (pathRewrite.commandSubstitutions && pathRewrite.commandSubstitutions.size > 0) {
-    const home4 = homedir26();
+    const home3 = homedir26();
+    const homeForward = home3.replace(/\\/g, "/");
+    const normalizeSlashesStr = (s) => s.replace(/\\/g, "/");
     for (const [originalAbsPath, wrapperAbsPath] of pathRewrite.commandSubstitutions) {
-      const candidates = new Set([
-        originalAbsPath,
-        originalAbsPath.replace(home4, "$HOME"),
-        originalAbsPath.replace(home4, "~")
-      ]);
+      const originalAbsForward = normalizeSlashesStr(originalAbsPath);
+      let relFromHome = null;
+      if (originalAbsForward.startsWith(`${homeForward}/`)) {
+        relFromHome = originalAbsForward.slice(homeForward.length + 1);
+      } else if (originalAbsForward === homeForward) {
+        relFromHome = "";
+      }
+      const candidates = [
+        originalAbsForward,
+        originalAbsPath
+      ];
+      if (relFromHome !== null && relFromHome !== "") {
+        candidates.push(`$HOME/${relFromHome}`);
+        candidates.push(`~/${relFromHome}`);
+        candidates.push(`%USERPROFILE%/${relFromHome}`);
+        candidates.push(`\${HOME}/${relFromHome}`);
+      }
+      const commandNorm = normalizeSlashesStr(command);
       for (const candidate of candidates) {
-        if (command.includes(candidate)) {
-          return command.replaceAll(candidate, wrapperAbsPath);
+        const candidateNorm = normalizeSlashesStr(candidate);
+        if (commandNorm.includes(candidateNorm)) {
+          const wrapperForward = normalizeSlashesStr(wrapperAbsPath);
+          return commandNorm.replaceAll(candidateNorm, wrapperForward);
         }
       }
     }
   }
-  const src = pathRewrite.sourceDir.endsWith("/") ? pathRewrite.sourceDir : `${pathRewrite.sourceDir}/`;
-  const tgt = pathRewrite.targetDir.endsWith("/") ? pathRewrite.targetDir : `${pathRewrite.targetDir}/`;
+  const normalizeSlashes = (s) => s.replace(/\\/g, "/");
+  const src = normalizeSlashes(pathRewrite.sourceDir.endsWith("/") || pathRewrite.sourceDir.endsWith("\\") ? pathRewrite.sourceDir : `${pathRewrite.sourceDir}/`);
+  const tgt = normalizeSlashes(pathRewrite.targetDir.endsWith("/") || pathRewrite.targetDir.endsWith("\\") ? pathRewrite.targetDir : `${pathRewrite.targetDir}/`);
   if (src === tgt)
     return command;
-  return command.replaceAll(src, tgt);
+  const normalizedCommand = normalizeSlashes(command);
+  if (!normalizedCommand.includes(src))
+    return command;
+  return normalizedCommand.replaceAll(src, tgt);
 }
 var init_claude_to_codex_hooks = () => {};
 
@@ -54897,17 +54961,6 @@ async function migrateHooksSettingsForCodex(options2) {
     installedHookAbsolutePaths,
     global: isGlobal
   } = options2;
-  if (process.platform === "win32") {
-    return {
-      status: "skipped-windows",
-      success: true,
-      backupPath: null,
-      hooksRegistered: 0,
-      message: "[!] Codex hook installation skipped: Codex CLI hooks are temporarily disabled on Windows.",
-      sourceSettingsPath: null,
-      targetSettingsPath: null
-    };
-  }
   if (installedHookFiles.length === 0) {
     return {
       status: "no-installed-files",
@@ -55432,14 +55485,15 @@ var init_portable_manifest = __esm(() => {
 function shouldBackfillRegistry(action) {
   return action.action === "skip" && action.backfillRegistry === true && typeof action.targetPath === "string" && action.targetPath.length > 0 && typeof action.sourceChecksum === "string" && !isUnknownChecksum(action.sourceChecksum) && typeof action.currentTargetChecksum === "string" && !isUnknownChecksum(action.currentTargetChecksum);
 }
-async function backfillRegistryChecksums(actions, registry) {
+async function backfillRegistryChecksums(actions, registry, deps) {
+  const addInstallation = deps?.addPortableInstallation ?? addPortableInstallation;
   for (const action of actions) {
     if (!shouldBackfillRegistry(action))
       continue;
     const registryEntry = registry.installations.find((entry) => entry.item === action.item && entry.type === action.type && entry.provider === action.provider && entry.global === action.global);
     if (!registryEntry)
       continue;
-    await addPortableInstallation(action.item, action.type, action.provider, action.global, action.targetPath, registryEntry.sourcePath, {
+    await addInstallation(action.item, action.type, action.provider, action.global, action.targetPath, registryEntry.sourcePath, {
       sourceChecksum: action.sourceChecksum,
       targetChecksum: action.currentTargetChecksum,
       ownedSections: registryEntry.ownedSections,
@@ -56728,6 +56782,12 @@ import { existsSync as existsSync30 } from "node:fs";
 import { readFile as readFile26, rm as rm8 } from "node:fs/promises";
 import { homedir as homedir29 } from "node:os";
 import { basename as basename17, join as join46, resolve as resolve23 } from "node:path";
+function resolveRegistryDeps(deps) {
+  return {
+    ...defaultRegistryDeps,
+    ...deps?.registry
+  };
+}
 function isDisallowedControlCode(codePoint) {
   return codePoint >= 0 && codePoint <= 8 || codePoint >= 11 && codePoint <= 31 || codePoint >= 127 && codePoint <= 159;
 }
@@ -56962,7 +57022,7 @@ async function executePlanDeleteAction(action, options2) {
     if (!shouldPreserveTarget && action.targetPath && existsSync30(action.targetPath)) {
       await rm8(action.targetPath, { recursive: true, force: true });
     }
-    await removePortableInstallation(action.item, action.type, action.provider, action.global, action.targetPath ? { path: action.targetPath } : undefined);
+    await (options2?.removePortableInstallation ?? removePortableInstallation)(action.item, action.type, action.provider, action.global, action.targetPath ? { path: action.targetPath } : undefined);
     return {
       provider: action.provider,
       providerDisplayName: providers[action.provider]?.displayName || action.provider,
@@ -57333,7 +57393,8 @@ function getCapabilities(provider) {
     hooks: config.hooks !== null
   };
 }
-function registerMigrationRoutes(app) {
+function registerMigrationRoutes(app, deps) {
+  const registryDeps = resolveRegistryDeps(deps);
   app.get("/api/migrate/providers", async (_req, res) => {
     try {
       const detected = new Set(await detectInstalledProviders());
@@ -57367,12 +57428,12 @@ function registerMigrationRoutes(app) {
       };
       const discovered = await discoverMigrationItems(includeAll);
       const cwd2 = process.cwd();
-      const home4 = homedir29();
+      const home3 = homedir29();
       res.status(200).json({
         cwd: cwd2,
         targetPaths: {
           project: join46(cwd2, ".claude"),
-          global: join46(home4, ".claude")
+          global: join46(home3, ".claude")
         },
         sourcePaths: discovered.sourcePaths,
         sourceOrigins: {
@@ -57541,7 +57602,7 @@ function registerMigrationRoutes(app) {
           warnReadFailure("hook", hook.name, error);
         }
       }
-      const registry = await readPortableRegistry();
+      const registry = await registryDeps.readPortableRegistry();
       const targetStates = await buildTargetStates(registry.installations, {
         onReadFailure: (entryPath, error) => warnReadFailure("registry-target", entryPath, error)
       });
@@ -57650,7 +57711,7 @@ function registerMigrationRoutes(app) {
       }
       const configSource = sourceParsed.value;
       const discovered = await discoverMigrationItems(include, configSource);
-      const registry = await readPortableRegistry();
+      const registry = await registryDeps.readPortableRegistry();
       const candidates = [];
       if (include.agents) {
         addCandidates(discovered.agents.map((a3) => ({
@@ -57903,15 +57964,18 @@ function registerMigrationRoutes(app) {
         const writtenPaths = new Set(allResults.filter((r2) => r2.success && !r2.skipped && r2.path.length > 0).map((r2) => resolve23(r2.path)));
         for (const deleteAction of deleteActions) {
           const deleteResult = await executePlanDeleteAction(deleteAction, {
-            preservePaths: writtenPaths
+            preservePaths: writtenPaths,
+            removePortableInstallation: registryDeps.removePortableInstallation
           });
           deleteResult.portableType = deleteAction.type;
           deleteResult.itemName = deleteAction.item;
           allResults.push(deleteResult);
         }
         try {
-          const registry = await readPortableRegistry();
-          await backfillRegistryChecksums(plan.actions, registry);
+          const registry = await registryDeps.readPortableRegistry();
+          await backfillRegistryChecksums(plan.actions, registry, {
+            addPortableInstallation: registryDeps.addPortableInstallation
+          });
         } catch {}
         for (const provider of allPlanProviders) {
           if (providers[provider]?.agents?.writeStrategy !== "codex-toml")
@@ -57928,7 +57992,7 @@ function registerMigrationRoutes(app) {
             });
             if (staleSlugs.length > 0) {
               const staleSlugSet = new Set(staleSlugs.map((s) => `${s}.toml`));
-              await removeInstallationsByFilter((i) => i.type === "agent" && i.provider === provider && i.global === scope && staleSlugSet.has(basename17(i.path)));
+              await registryDeps.removeInstallationsByFilter((i) => i.type === "agent" && i.provider === provider && i.global === scope && staleSlugSet.has(basename17(i.path)));
             }
           }
         }
@@ -57939,7 +58003,7 @@ function registerMigrationRoutes(app) {
           const kitRoot = (agentSrc ? resolve23(agentSrc, "..") : null) ?? (cmdSrc ? resolve23(cmdSrc, "..") : null) ?? (skillSrc ? resolve23(skillSrc, "..") : null) ?? null;
           const manifest = kitRoot ? await loadPortableManifest(kitRoot) : null;
           if (manifest?.cliVersion) {
-            await updateAppliedManifestVersion(manifest.cliVersion);
+            await registryDeps.updateAppliedManifestVersion(manifest.cliVersion);
           }
         } catch {}
         const responseResults2 = [...allResults, ...hookRegistrationResults2];
@@ -58141,7 +58205,7 @@ function registerMigrationRoutes(app) {
     }
   });
 }
-var MIGRATION_TYPES, MAX_PROVIDER_COUNT = 20, MAX_PLAN_ACTIONS = 5000, ALLOWED_CONFIG_SOURCE_KEYS, CONFLICT_RESOLUTION_SCHEMA, RECONCILE_ACTION_SCHEMA, RECONCILE_BANNER_SCHEMA, RECONCILE_PLAN_SCHEMA, PLAN_EXECUTE_PAYLOAD_SCHEMA, PLURAL_TO_SINGULAR, shellHookWarningShown = false;
+var defaultRegistryDeps, MIGRATION_TYPES, MAX_PROVIDER_COUNT = 20, MAX_PLAN_ACTIONS = 5000, ALLOWED_CONFIG_SOURCE_KEYS, CONFLICT_RESOLUTION_SCHEMA, RECONCILE_ACTION_SCHEMA, RECONCILE_BANNER_SCHEMA, RECONCILE_PLAN_SCHEMA, PLAN_EXECUTE_PAYLOAD_SCHEMA, PLURAL_TO_SINGULAR, shellHookWarningShown = false;
 var init_migration_routes = __esm(() => {
   init_agents_discovery();
   init_commands_discovery();
@@ -58163,6 +58227,13 @@ var init_migration_routes = __esm(() => {
   init_logger();
   init_zod();
   init_migration_result_utils();
+  defaultRegistryDeps = {
+    addPortableInstallation,
+    readPortableRegistry,
+    removeInstallationsByFilter,
+    removePortableInstallation,
+    updateAppliedManifestVersion
+  };
   MIGRATION_TYPES = [
     "agents",
     "commands",
@@ -60998,8 +61069,8 @@ function toDateStr(d3) {
   return `${y3}-${m2}-${day}`;
 }
 async function scanActivityMetrics(periodDays) {
-  const home4 = homedir33();
-  const projectsDir2 = join56(home4, ".claude", "projects");
+  const home3 = homedir33();
+  const projectsDir2 = join56(home3, ".claude", "projects");
   const cutoff = new Date;
   cutoff.setDate(cutoff.getDate() - periodDays);
   const dailyMap = new Map;
@@ -61069,29 +61140,29 @@ async function scanActivityMetrics(periodDays) {
   return { totalSessions, projects: projectActivities, dailyCounts };
 }
 async function resolveSessionDir(projectId) {
-  const home4 = homedir33();
+  const home3 = homedir33();
   if (projectId.startsWith("discovered-")) {
     try {
       const encodedPathB64 = projectId.slice("discovered-".length);
       const projectPath = Buffer.from(encodedPathB64, "base64url").toString("utf-8");
       const claudeEncoded = encodePath(projectPath);
-      return join56(home4, ".claude", "projects", claudeEncoded);
+      return join56(home3, ".claude", "projects", claudeEncoded);
     } catch {
       return null;
     }
   }
   if (projectId === "current") {
     const cwdEncoded = encodePath(process.cwd());
-    return join56(home4, ".claude", "projects", cwdEncoded);
+    return join56(home3, ".claude", "projects", cwdEncoded);
   }
   if (projectId === "global") {
-    const globalEncoded = encodePath(join56(home4, ".claude"));
-    return join56(home4, ".claude", "projects", globalEncoded);
+    const globalEncoded = encodePath(join56(home3, ".claude"));
+    return join56(home3, ".claude", "projects", globalEncoded);
   }
   const registered = await ProjectsRegistryManager.getProject(projectId);
   if (registered) {
     const claudeEncoded = encodePath(registered.path);
-    return join56(home4, ".claude", "projects", claudeEncoded);
+    return join56(home3, ".claude", "projects", claudeEncoded);
   }
   return null;
 }
@@ -61243,8 +61314,8 @@ async function parseSessionDetail(filePath, limit, offset) {
 }
 function registerSessionRoutes(app) {
   app.get("/api/sessions", async (_req, res) => {
-    const home4 = homedir33();
-    const projectsDir2 = join56(home4, ".claude", "projects");
+    const home3 = homedir33();
+    const projectsDir2 = join56(home3, ".claude", "projects");
     if (!existsSync38(projectsDir2)) {
       res.json({ projects: [] });
       return;
@@ -61927,10 +61998,10 @@ function hasOpenCodeInstallSignal2() {
     join59(process.cwd(), "opencode.jsonc"),
     join59(process.cwd(), ".opencode/agents"),
     join59(process.cwd(), ".opencode/commands"),
-    join59(home4, ".config/opencode/AGENTS.md"),
-    join59(home4, ".config/opencode/agents"),
-    join59(home4, ".config/opencode/commands"),
-    join59(home4, ".opencode", "bin", OPENCODE_BINARY_NAME2)
+    join59(home3, ".config/opencode/AGENTS.md"),
+    join59(home3, ".config/opencode/agents"),
+    join59(home3, ".config/opencode/commands"),
+    join59(home3, ".opencode", "bin", OPENCODE_BINARY_NAME2)
   ]);
 }
 async function detectInstalledAgents() {
@@ -61954,108 +62025,108 @@ function isSkillInstalled(skillName, agent, options2) {
   const installPath = getInstallPath(skillName, agent, options2);
   return existsSync39(installPath);
 }
-var home4, OPENCODE_BINARY_NAME2, agents;
+var home3, OPENCODE_BINARY_NAME2, agents;
 var init_agents = __esm(() => {
-  home4 = homedir37();
+  home3 = homedir37();
   OPENCODE_BINARY_NAME2 = platform5() === "win32" ? "opencode.exe" : "opencode";
   agents = {
     "claude-code": {
       name: "claude-code",
       displayName: "Claude Code",
       projectPath: ".claude/skills",
-      globalPath: join59(home4, ".claude/skills"),
-      detect: async () => existsSync39(join59(home4, ".claude"))
+      globalPath: join59(home3, ".claude/skills"),
+      detect: async () => existsSync39(join59(home3, ".claude"))
     },
     cursor: {
       name: "cursor",
       displayName: "Cursor",
       projectPath: ".cursor/skills",
-      globalPath: join59(home4, ".cursor/skills"),
-      detect: async () => existsSync39(join59(home4, ".cursor"))
+      globalPath: join59(home3, ".cursor/skills"),
+      detect: async () => existsSync39(join59(home3, ".cursor"))
     },
     codex: {
       name: "codex",
       displayName: "Codex",
       projectPath: ".codex/skills",
-      globalPath: join59(home4, ".codex/skills"),
-      detect: async () => existsSync39(join59(home4, ".codex"))
+      globalPath: join59(home3, ".codex/skills"),
+      detect: async () => existsSync39(join59(home3, ".codex"))
     },
     opencode: {
       name: "opencode",
       displayName: "OpenCode",
       projectPath: ".claude/skills",
-      globalPath: join59(home4, ".claude/skills"),
+      globalPath: join59(home3, ".claude/skills"),
       detect: async () => hasOpenCodeInstallSignal2()
     },
     goose: {
       name: "goose",
       displayName: "Goose",
       projectPath: ".goose/skills",
-      globalPath: join59(home4, ".config/goose/skills"),
-      detect: async () => existsSync39(join59(home4, ".config/goose"))
+      globalPath: join59(home3, ".config/goose/skills"),
+      detect: async () => existsSync39(join59(home3, ".config/goose"))
     },
     "gemini-cli": {
       name: "gemini-cli",
       displayName: "Gemini CLI",
       projectPath: ".agents/skills",
-      globalPath: join59(home4, ".agents/skills"),
-      detect: async () => existsSync39(join59(home4, ".gemini"))
+      globalPath: join59(home3, ".agents/skills"),
+      detect: async () => existsSync39(join59(home3, ".gemini"))
     },
     antigravity: {
       name: "antigravity",
       displayName: "Antigravity",
       projectPath: ".agent/skills",
-      globalPath: join59(home4, ".gemini/antigravity/skills"),
-      detect: async () => existsSync39(join59(process.cwd(), ".agent")) || existsSync39(join59(home4, ".gemini/antigravity"))
+      globalPath: join59(home3, ".gemini/antigravity/skills"),
+      detect: async () => existsSync39(join59(process.cwd(), ".agent")) || existsSync39(join59(home3, ".gemini/antigravity"))
     },
     "github-copilot": {
       name: "github-copilot",
       displayName: "GitHub Copilot",
       projectPath: ".github/skills",
-      globalPath: join59(home4, ".copilot/skills"),
-      detect: async () => existsSync39(join59(home4, ".copilot"))
+      globalPath: join59(home3, ".copilot/skills"),
+      detect: async () => existsSync39(join59(home3, ".copilot"))
     },
     amp: {
       name: "amp",
       displayName: "Amp",
       projectPath: ".agents/skills",
-      globalPath: join59(home4, ".config/agents/skills"),
-      detect: async () => existsSync39(join59(home4, ".config/amp"))
+      globalPath: join59(home3, ".config/agents/skills"),
+      detect: async () => existsSync39(join59(home3, ".config/amp"))
     },
     kilo: {
       name: "kilo",
       displayName: "Kilo Code",
       projectPath: ".kilocode/skills",
-      globalPath: join59(home4, ".kilocode/skills"),
-      detect: async () => existsSync39(join59(home4, ".kilocode"))
+      globalPath: join59(home3, ".kilocode/skills"),
+      detect: async () => existsSync39(join59(home3, ".kilocode"))
     },
     roo: {
       name: "roo",
       displayName: "Roo Code",
       projectPath: ".roo/skills",
-      globalPath: join59(home4, ".roo/skills"),
-      detect: async () => existsSync39(join59(home4, ".roo"))
+      globalPath: join59(home3, ".roo/skills"),
+      detect: async () => existsSync39(join59(home3, ".roo"))
     },
     windsurf: {
       name: "windsurf",
       displayName: "Windsurf",
       projectPath: ".windsurf/skills",
-      globalPath: join59(home4, ".codeium/windsurf/skills"),
-      detect: async () => existsSync39(join59(home4, ".codeium/windsurf"))
+      globalPath: join59(home3, ".codeium/windsurf/skills"),
+      detect: async () => existsSync39(join59(home3, ".codeium/windsurf"))
     },
     cline: {
       name: "cline",
       displayName: "Cline",
       projectPath: ".cline/skills",
-      globalPath: join59(home4, ".cline/skills"),
-      detect: async () => existsSync39(join59(home4, ".cline"))
+      globalPath: join59(home3, ".cline/skills"),
+      detect: async () => existsSync39(join59(home3, ".cline"))
     },
     openhands: {
       name: "openhands",
       displayName: "OpenHands",
       projectPath: ".openhands/skills",
-      globalPath: join59(home4, ".openhands/skills"),
-      detect: async () => existsSync39(join59(home4, ".openhands"))
+      globalPath: join59(home3, ".openhands/skills"),
+      detect: async () => existsSync39(join59(home3, ".openhands"))
     }
   };
 });
@@ -62096,15 +62167,15 @@ function migrateRegistryPaths(registry) {
 }
 async function readRegistry2() {
   try {
-    if (!existsSync40(REGISTRY_PATH2)) {
+    if (!existsSync40(REGISTRY_PATH)) {
       return { version: "1.0", installations: [] };
     }
-    const content = await readFile31(REGISTRY_PATH2, "utf-8");
+    const content = await readFile31(REGISTRY_PATH, "utf-8");
     const data = JSON.parse(content);
     const registry = SkillRegistrySchema.parse(data);
     if (migrateRegistryPaths(registry)) {
       try {
-        await writeFile15(REGISTRY_PATH2, JSON.stringify(registry, null, 2), "utf-8");
+        await writeFile15(REGISTRY_PATH, JSON.stringify(registry, null, 2), "utf-8");
       } catch {}
     }
     return registry;
@@ -62116,11 +62187,11 @@ async function readRegistry2() {
   }
 }
 async function writeRegistry2(registry) {
-  const dir = dirname25(REGISTRY_PATH2);
+  const dir = dirname25(REGISTRY_PATH);
   if (!existsSync40(dir)) {
     await mkdir15(dir, { recursive: true });
   }
-  await writeFile15(REGISTRY_PATH2, JSON.stringify(registry, null, 2), "utf-8");
+  await writeFile15(REGISTRY_PATH, JSON.stringify(registry, null, 2), "utf-8");
 }
 async function addInstallation(skill, agent, global3, path6, sourcePath) {
   const registry = await readRegistry2();
@@ -62172,11 +62243,11 @@ async function syncRegistry() {
   }
   return { removed };
 }
-var home5, REGISTRY_PATH2, SkillInstallationSchema, SkillRegistrySchema, REGISTRY_PATH_MIGRATIONS;
+var home4, REGISTRY_PATH, SkillInstallationSchema, SkillRegistrySchema, REGISTRY_PATH_MIGRATIONS;
 var init_skills_registry = __esm(() => {
   init_zod();
-  home5 = homedir38();
-  REGISTRY_PATH2 = join60(home5, ".claudekit", "skill-registry.json");
+  home4 = homedir38();
+  REGISTRY_PATH = join60(home4, ".claudekit", "skill-registry.json");
   SkillInstallationSchema = exports_external.object({
     skill: exports_external.string(),
     agent: exports_external.string(),
@@ -63287,7 +63358,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "claudekit-cli",
-    version: "4.3.1-dev.1",
+    version: "4.3.1-dev.3",
     description: "CLI tool for bootstrapping and updating ClaudeKit projects",
     type: "module",
     repository: {
@@ -65804,12 +65875,12 @@ function extractHookReferencePaths(cmd) {
 }
 function resolveHookScriptPath(scriptPath, projectDir) {
   let resolved = scriptPath.replace(/\\/g, "/");
-  const home6 = homedir40();
-  resolved = resolved.replace(/^\$\{?HOME\}?/, home6);
+  const home5 = homedir40();
+  resolved = resolved.replace(/^\$\{?HOME\}?/, home5);
   resolved = resolved.replace(/^\$\{?CLAUDE_PROJECT_DIR\}?/, projectDir);
-  resolved = resolved.replace(/^%USERPROFILE%/, home6);
+  resolved = resolved.replace(/^%USERPROFILE%/, home5);
   resolved = resolved.replace(/^%CLAUDE_PROJECT_DIR%/, projectDir);
-  resolved = resolved.replace(/^~\//, `${home6}/`);
+  resolved = resolved.replace(/^~\//, `${home5}/`);
   if (resolved.startsWith(".claude/") || resolved === ".claude") {
     resolved = join67(projectDir, resolved);
   }
@@ -75826,7 +75897,7 @@ __export(exports_worktree_manager, {
   createWorktree: () => createWorktree,
   cleanupAllWorktrees: () => cleanupAllWorktrees
 });
-import { existsSync as existsSync71 } from "node:fs";
+import { existsSync as existsSync72 } from "node:fs";
 import { readFile as readFile67, writeFile as writeFile38 } from "node:fs/promises";
 import { join as join153 } from "node:path";
 async function createWorktree(projectDir, issueNumber, baseBranch) {
@@ -75892,7 +75963,7 @@ async function cleanupAllWorktrees(projectDir) {
 async function ensureGitignore(projectDir) {
   const gitignorePath = join153(projectDir, ".gitignore");
   try {
-    const content = existsSync71(gitignorePath) ? await readFile67(gitignorePath, "utf-8") : "";
+    const content = existsSync72(gitignorePath) ? await readFile67(gitignorePath, "utf-8") : "";
     if (!content.includes(".worktrees")) {
       const newContent = content.endsWith(`
 `) ? `${content}.worktrees/
@@ -75994,13 +76065,13 @@ var init_content_validator = __esm(() => {
 
 // src/commands/content/phases/context-cache-manager.ts
 import { createHash as createHash9 } from "node:crypto";
-import { existsSync as existsSync77, mkdirSync as mkdirSync5, readFileSync as readFileSync18, readdirSync as readdirSync11, statSync as statSync14 } from "node:fs";
+import { existsSync as existsSync78, mkdirSync as mkdirSync5, readFileSync as readFileSync18, readdirSync as readdirSync12, statSync as statSync14 } from "node:fs";
 import { rename as rename16, writeFile as writeFile40 } from "node:fs/promises";
-import { homedir as homedir54 } from "node:os";
-import { basename as basename33, join as join160 } from "node:path";
+import { homedir as homedir55 } from "node:os";
+import { basename as basename34, join as join160 } from "node:path";
 function getCachedContext(repoPath) {
   const cachePath = getCacheFilePath(repoPath);
-  if (!existsSync77(cachePath))
+  if (!existsSync78(cachePath))
     return null;
   try {
     const raw2 = readFileSync18(cachePath, "utf-8");
@@ -76017,7 +76088,7 @@ function getCachedContext(repoPath) {
   }
 }
 async function saveCachedContext(repoPath, cache5) {
-  if (!existsSync77(CACHE_DIR)) {
+  if (!existsSync78(CACHE_DIR)) {
     mkdirSync5(CACHE_DIR, { recursive: true });
   }
   const cachePath = getCacheFilePath(repoPath);
@@ -76041,9 +76112,9 @@ function computeSourceHash(repoPath) {
 function getDocSourcePaths(repoPath) {
   const paths = [];
   const docsDir = join160(repoPath, "docs");
-  if (existsSync77(docsDir)) {
+  if (existsSync78(docsDir)) {
     try {
-      const files = readdirSync11(docsDir);
+      const files = readdirSync12(docsDir);
       for (const f3 of files) {
         if (f3.endsWith(".md"))
           paths.push(join160(docsDir, f3));
@@ -76051,12 +76122,12 @@ function getDocSourcePaths(repoPath) {
     } catch {}
   }
   const readme = join160(repoPath, "README.md");
-  if (existsSync77(readme))
+  if (existsSync78(readme))
     paths.push(readme);
   const stylesDir = join160(repoPath, "assets", "writing-styles");
-  if (existsSync77(stylesDir)) {
+  if (existsSync78(stylesDir)) {
     try {
-      const files = readdirSync11(stylesDir);
+      const files = readdirSync12(stylesDir);
       for (const f3 of files) {
         paths.push(join160(stylesDir, f3));
       }
@@ -76065,13 +76136,13 @@ function getDocSourcePaths(repoPath) {
   return paths.sort();
 }
 function getCacheFilePath(repoPath) {
-  const repoName = basename33(repoPath).replace(/[^a-zA-Z0-9_-]/g, "_");
+  const repoName = basename34(repoPath).replace(/[^a-zA-Z0-9_-]/g, "_");
   const pathHash = createHash9("sha256").update(repoPath).digest("hex").slice(0, 8);
   return join160(CACHE_DIR, `${repoName}-${pathHash}-context-cache.json`);
 }
 var CACHE_DIR, CACHE_TTL_MS5;
 var init_context_cache_manager = __esm(() => {
-  CACHE_DIR = join160(homedir54(), ".claudekit", "cache");
+  CACHE_DIR = join160(homedir55(), ".claudekit", "cache");
   CACHE_TTL_MS5 = 24 * 60 * 60 * 1000;
 });
 
@@ -76251,7 +76322,7 @@ function extractContentFromResponse(response) {
 
 // src/commands/content/phases/docs-summarizer.ts
 import { execSync as execSync7 } from "node:child_process";
-import { existsSync as existsSync78, readFileSync as readFileSync19, readdirSync as readdirSync12 } from "node:fs";
+import { existsSync as existsSync79, readFileSync as readFileSync19, readdirSync as readdirSync13 } from "node:fs";
 import { join as join161 } from "node:path";
 async function summarizeProjectDocs(repoPath, contentLogger) {
   const rawContent = collectRawDocs(repoPath);
@@ -76296,7 +76367,7 @@ async function summarizeProjectDocs(repoPath, contentLogger) {
 function collectRawDocs(repoPath) {
   let totalChars = 0;
   const readCapped = (filePath, maxChars) => {
-    if (!existsSync78(filePath))
+    if (!existsSync79(filePath))
       return "";
     if (totalChars >= MAX_RAW_CONTENT_CHARS)
       return "";
@@ -76307,9 +76378,9 @@ function collectRawDocs(repoPath) {
   };
   const docsContent = [];
   const docsDir = join161(repoPath, "docs");
-  if (existsSync78(docsDir)) {
+  if (existsSync79(docsDir)) {
     try {
-      const files = readdirSync12(docsDir).filter((f3) => f3.endsWith(".md")).sort();
+      const files = readdirSync13(docsDir).filter((f3) => f3.endsWith(".md")).sort();
       for (const f3 of files) {
         const content = readCapped(join161(docsDir, f3), 5000);
         if (content) {
@@ -76331,9 +76402,9 @@ ${content}`);
   }
   let styles3 = "";
   const stylesDir = join161(repoPath, "assets", "writing-styles");
-  if (existsSync78(stylesDir)) {
+  if (existsSync79(stylesDir)) {
     try {
-      const files = readdirSync12(stylesDir).slice(0, 3);
+      const files = readdirSync13(stylesDir).slice(0, 3);
       styles3 = files.map((f3) => readCapped(join161(stylesDir, f3), 1000)).filter(Boolean).join(`
 
 `);
@@ -76524,12 +76595,12 @@ IMPORTANT: Generate the image and output the path as JSON: {"imagePath": "/path/
 
 // src/commands/content/phases/photo-generator.ts
 import { execSync as execSync8 } from "node:child_process";
-import { existsSync as existsSync79, mkdirSync as mkdirSync6, readdirSync as readdirSync13 } from "node:fs";
-import { homedir as homedir55 } from "node:os";
+import { existsSync as existsSync80, mkdirSync as mkdirSync6, readdirSync as readdirSync14 } from "node:fs";
+import { homedir as homedir56 } from "node:os";
 import { join as join162 } from "node:path";
 async function generatePhoto(_content, context, config, platform18, contentId, contentLogger) {
-  const mediaDir = join162(config.contentDir.replace(/^~/, homedir55()), "media", String(contentId));
-  if (!existsSync79(mediaDir)) {
+  const mediaDir = join162(config.contentDir.replace(/^~/, homedir56()), "media", String(contentId));
+  if (!existsSync80(mediaDir)) {
     mkdirSync6(mediaDir, { recursive: true });
   }
   const prompt = buildPhotoPrompt(context, platform18);
@@ -76545,11 +76616,11 @@ async function generatePhoto(_content, context, config, platform18, contentId, c
     const parsed = parseClaudeJsonOutput(result);
     if (parsed && typeof parsed === "object" && "imagePath" in parsed) {
       const imagePath = String(parsed.imagePath);
-      if (existsSync79(imagePath)) {
+      if (existsSync80(imagePath)) {
         return { path: imagePath, ...dimensions, format: "png" };
       }
     }
-    const files = readdirSync13(mediaDir);
+    const files = readdirSync14(mediaDir);
     const imageFile = files.find((f3) => /\.(png|jpg|jpeg|webp)$/i.test(f3));
     if (imageFile) {
       const ext2 = imageFile.split(".").pop() ?? "png";
@@ -76641,8 +76712,8 @@ var init_content_creator = __esm(() => {
 });
 
 // src/commands/content/phases/content-logger.ts
-import { createWriteStream as createWriteStream4, existsSync as existsSync80, mkdirSync as mkdirSync7, statSync as statSync15 } from "node:fs";
-import { homedir as homedir56 } from "node:os";
+import { createWriteStream as createWriteStream4, existsSync as existsSync81, mkdirSync as mkdirSync7, statSync as statSync15 } from "node:fs";
+import { homedir as homedir57 } from "node:os";
 import { join as join163 } from "node:path";
 
 class ContentLogger {
@@ -76651,11 +76722,11 @@ class ContentLogger {
   logDir;
   maxBytes;
   constructor(maxBytes = 0) {
-    this.logDir = join163(homedir56(), ".claudekit", "logs");
+    this.logDir = join163(homedir57(), ".claudekit", "logs");
     this.maxBytes = maxBytes;
   }
   init() {
-    if (!existsSync80(this.logDir)) {
+    if (!existsSync81(this.logDir)) {
       mkdirSync7(this.logDir, { recursive: true });
     }
     this.rotateIfNeeded();
@@ -76748,8 +76819,8 @@ function openDatabase(dbPath) {
 var init_sqlite_client = () => {};
 
 // src/commands/content/phases/db-manager.ts
-import { existsSync as existsSync81, mkdirSync as mkdirSync8 } from "node:fs";
-import { dirname as dirname49 } from "node:path";
+import { existsSync as existsSync82, mkdirSync as mkdirSync8 } from "node:fs";
+import { dirname as dirname50 } from "node:path";
 function initDatabase(dbPath) {
   ensureParentDir(dbPath);
   const db = openDatabase(dbPath);
@@ -76770,8 +76841,8 @@ function runRetentionCleanup(db, retentionDays = 90) {
   db.prepare("DELETE FROM git_events WHERE processed = 1 AND created_at < ?").run(cutoff);
 }
 function ensureParentDir(dbPath) {
-  const dir = dirname49(dbPath);
-  if (dir && !existsSync81(dir)) {
+  const dir = dirname50(dbPath);
+  if (dir && !existsSync82(dir)) {
     mkdirSync8(dir, { recursive: true });
   }
 }
@@ -76936,7 +77007,7 @@ function isNoiseCommit(title, author) {
 
 // src/commands/content/phases/change-detector.ts
 import { execSync as execSync10, spawnSync as spawnSync9 } from "node:child_process";
-import { existsSync as existsSync82, readFileSync as readFileSync20, readdirSync as readdirSync14, statSync as statSync16 } from "node:fs";
+import { existsSync as existsSync83, readFileSync as readFileSync20, readdirSync as readdirSync15, statSync as statSync16 } from "node:fs";
 import { join as join164 } from "node:path";
 function detectCommits(repo, since) {
   try {
@@ -77047,17 +77118,17 @@ function detectTags(repo, since) {
 }
 function detectCompletedPlans(repo, since) {
   const plansDir = join164(repo.path, "plans");
-  if (!existsSync82(plansDir))
+  if (!existsSync83(plansDir))
     return [];
   const sinceMs = new Date(since).getTime();
   const events = [];
   try {
-    const entries = readdirSync14(plansDir, { withFileTypes: true });
+    const entries = readdirSync15(plansDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
       const planFile = join164(plansDir, entry.name, "plan.md");
-      if (!existsSync82(planFile))
+      if (!existsSync83(planFile))
         continue;
       try {
         const stat26 = statSync16(planFile);
@@ -77133,7 +77204,7 @@ function classifyCommit(event) {
 
 // src/commands/content/phases/repo-discoverer.ts
 import { execSync as execSync11 } from "node:child_process";
-import { readdirSync as readdirSync15 } from "node:fs";
+import { readdirSync as readdirSync16 } from "node:fs";
 import { join as join165 } from "node:path";
 function discoverRepos2(cwd2) {
   const repos = [];
@@ -77143,7 +77214,7 @@ function discoverRepos2(cwd2) {
       repos.push(info);
   }
   try {
-    const entries = readdirSync15(cwd2, { withFileTypes: true });
+    const entries = readdirSync16(cwd2, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory() || entry.name.startsWith("."))
         continue;
@@ -78125,7 +78196,7 @@ var init_platform_setup_x = __esm(() => {
 });
 
 // src/commands/content/phases/setup-wizard.ts
-import { existsSync as existsSync83 } from "node:fs";
+import { existsSync as existsSync84 } from "node:fs";
 import { join as join167 } from "node:path";
 async function runSetupWizard2(cwd2, contentLogger) {
   console.log();
@@ -78194,8 +78265,8 @@ async function showRepoSummary(cwd2) {
 function detectBrandAssets(cwd2, contentLogger) {
   const repos = discoverRepos2(cwd2);
   for (const repo of repos) {
-    const hasGuidelines = existsSync83(join167(repo.path, "docs", "brand-guidelines.md"));
-    const hasStyles = existsSync83(join167(repo.path, "assets", "writing-styles"));
+    const hasGuidelines = existsSync84(join167(repo.path, "docs", "brand-guidelines.md"));
+    const hasStyles = existsSync84(join167(repo.path, "assets", "writing-styles"));
     if (!hasGuidelines) {
       f2.warning(`${repo.name}: No docs/brand-guidelines.md — content will use generic tone.`);
       contentLogger.warn(`${repo.name}: missing docs/brand-guidelines.md`);
@@ -78261,13 +78332,13 @@ var init_setup_wizard = __esm(() => {
 });
 
 // src/commands/content/content-review-commands.ts
-import { existsSync as existsSync84 } from "node:fs";
-import { homedir as homedir57 } from "node:os";
+import { existsSync as existsSync85 } from "node:fs";
+import { homedir as homedir58 } from "node:os";
 async function queueContent() {
   const cwd2 = process.cwd();
   const config = await loadContentConfig(cwd2);
-  const dbPath = config.dbPath.replace(/^~/, homedir57());
-  if (!existsSync84(dbPath)) {
+  const dbPath = config.dbPath.replace(/^~/, homedir58());
+  if (!existsSync85(dbPath)) {
     logger.info("No content database found. Run 'ck content setup' first.");
     return;
   }
@@ -78293,7 +78364,7 @@ async function queueContent() {
 async function approveContentCmd(id) {
   const cwd2 = process.cwd();
   const config = await loadContentConfig(cwd2);
-  const dbPath = config.dbPath.replace(/^~/, homedir57());
+  const dbPath = config.dbPath.replace(/^~/, homedir58());
   const db = initDatabase(dbPath);
   try {
     approveContent(db, Number.parseInt(id, 10));
@@ -78305,7 +78376,7 @@ async function approveContentCmd(id) {
 async function rejectContentCmd(id, reason) {
   const cwd2 = process.cwd();
   const config = await loadContentConfig(cwd2);
-  const dbPath = config.dbPath.replace(/^~/, homedir57());
+  const dbPath = config.dbPath.replace(/^~/, homedir58());
   const db = initDatabase(dbPath);
   try {
     rejectContent(db, Number.parseInt(id, 10), reason);
@@ -78335,12 +78406,12 @@ __export(exports_content_subcommands, {
   logsContent: () => logsContent,
   approveContentCmd: () => approveContentCmd
 });
-import { existsSync as existsSync85, readFileSync as readFileSync21, unlinkSync as unlinkSync6 } from "node:fs";
-import { homedir as homedir58 } from "node:os";
+import { existsSync as existsSync86, readFileSync as readFileSync21, unlinkSync as unlinkSync6 } from "node:fs";
+import { homedir as homedir59 } from "node:os";
 import { join as join168 } from "node:path";
 function isDaemonRunning() {
   const lockFile = join168(LOCK_DIR, `${LOCK_NAME2}.lock`);
-  if (!existsSync85(lockFile))
+  if (!existsSync86(lockFile))
     return { running: false, pid: null };
   try {
     const pidStr = readFileSync21(lockFile, "utf-8").trim();
@@ -78372,7 +78443,7 @@ async function startContent(options2) {
 }
 async function stopContent() {
   const lockFile = join168(LOCK_DIR, `${LOCK_NAME2}.lock`);
-  if (!existsSync85(lockFile)) {
+  if (!existsSync86(lockFile)) {
     logger.info("Content daemon is not running.");
     return;
   }
@@ -78410,10 +78481,10 @@ async function statusContent() {
   } catch {}
 }
 async function logsContent(options2) {
-  const logDir = join168(homedir58(), ".claudekit", "logs");
+  const logDir = join168(homedir59(), ".claudekit", "logs");
   const dateStr = new Date().toISOString().slice(0, 10).replace(/-/g, "");
   const logPath = join168(logDir, `content-${dateStr}.log`);
-  if (!existsSync85(logPath)) {
+  if (!existsSync86(logPath)) {
     logger.info("No content logs found for today.");
     return;
   }
@@ -78444,12 +78515,12 @@ var init_content_subcommands = __esm(() => {
   init_setup_wizard();
   init_state_manager();
   init_content_review_commands();
-  LOCK_DIR = join168(homedir58(), ".claudekit", "locks");
+  LOCK_DIR = join168(homedir59(), ".claudekit", "locks");
 });
 
 // src/commands/content/content-command.ts
-import { existsSync as existsSync86, mkdirSync as mkdirSync9, unlinkSync as unlinkSync7, writeFileSync as writeFileSync7 } from "node:fs";
-import { homedir as homedir59 } from "node:os";
+import { existsSync as existsSync87, mkdirSync as mkdirSync9, unlinkSync as unlinkSync7, writeFileSync as writeFileSync7 } from "node:fs";
+import { homedir as homedir60 } from "node:os";
 import { join as join169 } from "node:path";
 async function contentCommand(options2) {
   const cwd2 = process.cwd();
@@ -78479,10 +78550,10 @@ async function contentCommand(options2) {
       }
       contentLogger.info("Setup complete. Starting daemon...");
     }
-    if (!existsSync86(LOCK_DIR2))
+    if (!existsSync87(LOCK_DIR2))
       mkdirSync9(LOCK_DIR2, { recursive: true });
     writeFileSync7(LOCK_FILE, String(process.pid), "utf-8");
-    const dbPath = config.dbPath.replace(/^~/, homedir59());
+    const dbPath = config.dbPath.replace(/^~/, homedir60());
     const db = initDatabase(dbPath);
     contentLogger.info(`Database initialised at ${dbPath}`);
     const adapters = initializeAdapters(config);
@@ -78628,7 +78699,7 @@ var init_content_command = __esm(() => {
   init_publisher();
   init_review_manager();
   init_state_manager();
-  LOCK_DIR2 = join169(homedir59(), ".claudekit", "locks");
+  LOCK_DIR2 = join169(homedir60(), ".claudekit", "locks");
   LOCK_FILE = join169(LOCK_DIR2, "ck-content.lock");
 });
 
@@ -80168,6 +80239,12 @@ var init_plan_command_help = __esm(() => {
             title: "Scope Options",
             options: [{ flags: "-g, --global", description: "Create plan in global plans scope" }]
           }
+        ],
+        sections: [
+          {
+            title: "Agent Editing Reminder",
+            content: "After creating a plan, Claude Code agents should read `plan.md` and every generated `phase-*.md` before editing. The files already exist; Write/Edit without Read can be rejected after wasting tokens."
+          }
         ]
       },
       {
@@ -84596,6 +84673,16 @@ init_provider_registry();
 import { existsSync as existsSync9 } from "node:fs";
 import { lstat as lstat3, rm as rm2 } from "node:fs/promises";
 import { basename as basename5, dirname as dirname6, join as join17, relative as relative4, resolve as resolve8, sep as sep4 } from "node:path";
+var defaultCommandRegistryDeps = {
+  readPortableRegistry,
+  removePortableInstallation
+};
+function resolveCommandRegistryDeps(deps) {
+  return {
+    ...defaultCommandRegistryDeps,
+    ...deps
+  };
+}
 function isPathWithinBase(targetPath, basePath) {
   const resolvedTarget = resolve8(targetPath);
   const resolvedBase = resolve8(basePath);
@@ -84727,8 +84814,9 @@ async function removeCommandTarget(targetPath, provider, basePath) {
   }
   await rm2(targetPath, { recursive: true, force: true });
 }
-async function uninstallCommandFromProvider(commandName, provider, global3) {
-  const registry = await readPortableRegistry();
+async function uninstallCommandFromProvider(commandName, provider, global3, deps) {
+  const registryDeps = resolveCommandRegistryDeps(deps);
+  const registry = await registryDeps.readPortableRegistry();
   const installations = findPortableInstallations(registry, commandName, "command", provider, global3);
   if (installations.length === 0) {
     return {
@@ -84749,7 +84837,7 @@ async function uninstallCommandFromProvider(commandName, provider, global3) {
     if (fileExists) {
       await removeCommandTarget(installation.path, provider, basePath);
     }
-    await removePortableInstallation(commandName, "command", provider, global3);
+    await registryDeps.removePortableInstallation(commandName, "command", provider, global3);
     return {
       item: commandName,
       provider,
@@ -84771,7 +84859,8 @@ async function uninstallCommandFromProvider(commandName, provider, global3) {
     };
   }
 }
-async function forceUninstallCommandFromProvider(commandName, provider, global3) {
+async function forceUninstallCommandFromProvider(commandName, provider, global3, deps) {
+  const registryDeps = resolveCommandRegistryDeps(deps);
   const config = providers[provider];
   const pathConfig = config.commands;
   if (!pathConfig) {
@@ -84841,7 +84930,7 @@ async function forceUninstallCommandFromProvider(commandName, provider, global3)
   }
   try {
     await removeCommandTarget(targetPath, provider, basePath);
-    await removePortableInstallation(commandName, "command", provider, global3);
+    await registryDeps.removePortableInstallation(commandName, "command", provider, global3);
     return {
       item: commandName,
       provider,
@@ -84862,8 +84951,9 @@ async function forceUninstallCommandFromProvider(commandName, provider, global3)
     };
   }
 }
-async function getInstalledCommands(provider, global3) {
-  const registry = await readPortableRegistry();
+async function getInstalledCommands(provider, global3, deps) {
+  const registryDeps = resolveCommandRegistryDeps(deps);
+  const registry = await registryDeps.readPortableRegistry();
   return registry.installations.filter((i) => {
     if (i.type !== "command")
       return false;
@@ -84876,9 +84966,20 @@ async function getInstalledCommands(provider, global3) {
 }
 
 // src/commands/commands/commands-command.ts
-async function listCommands(showInstalled) {
+var defaultCommandsRegistryDeps = {
+  readPortableRegistry,
+  removePortableInstallation,
+  syncPortableRegistry
+};
+function resolveCommandsRegistryDeps(options2) {
+  return {
+    ...defaultCommandsRegistryDeps,
+    ...options2?.registry
+  };
+}
+async function listCommands(showInstalled, registryDeps) {
   if (showInstalled) {
-    const installations = await getInstalledCommands();
+    const installations = await getInstalledCommands(undefined, undefined, registryDeps);
     if (installations.length === 0) {
       f2.warn("No commands installed via ck commands.");
       return;
@@ -84930,9 +85031,9 @@ async function listCommands(showInstalled) {
   console.log(import_picocolors13.default.dim(`  Source: ${sourcePath}`));
   console.log();
 }
-async function handleUninstall2(options2) {
+async function handleUninstall2(options2, registryDeps) {
   if (!options2.name) {
-    const installations = await getInstalledCommands();
+    const installations = await getInstalledCommands(undefined, undefined, registryDeps);
     if (installations.length === 0) {
       f2.warn("No commands installed via ck commands.");
       return;
@@ -84964,7 +85065,7 @@ async function handleUninstall2(options2) {
     const spinner2 = de();
     spinner2.start("Uninstalling...");
     for (const inst of toUninstall) {
-      await uninstallCommandFromProvider(inst.item, inst.provider, inst.global);
+      await uninstallCommandFromProvider(inst.item, inst.provider, inst.global, registryDeps);
     }
     spinner2.stop("Uninstall complete");
     f2.success(`Removed ${toUninstall.length} command(s)`);
@@ -84990,7 +85091,7 @@ async function handleUninstall2(options2) {
     const spinner2 = de();
     spinner2.start("Force uninstalling...");
     const targets = options2.agent;
-    const results = await Promise.all(targets.map((provider) => forceUninstallCommandFromProvider(trimmedName, provider, options2.global ?? false)));
+    const results = await Promise.all(targets.map((provider) => forceUninstallCommandFromProvider(trimmedName, provider, options2.global ?? false, registryDeps)));
     const successCount2 = results.filter((result) => result.success).length;
     spinner2.stop("Force uninstall complete");
     for (const result of results) {
@@ -85005,7 +85106,7 @@ async function handleUninstall2(options2) {
     }
     return true;
   };
-  const registry = await readPortableRegistry();
+  const registry = await registryDeps.readPortableRegistry();
   const matches = registry.installations.filter((i) => i.type === "command" && i.item.toLowerCase() === trimmedName.toLowerCase());
   if (matches.length === 0) {
     if (options2.force) {
@@ -85048,7 +85149,7 @@ async function handleUninstall2(options2) {
   spinner.start("Uninstalling...");
   let successCount = 0;
   for (const inst of toRemove) {
-    const result = await uninstallCommandFromProvider(inst.item, inst.provider, inst.global);
+    const result = await uninstallCommandFromProvider(inst.item, inst.provider, inst.global, registryDeps);
     if (result.success)
       successCount++;
   }
@@ -85059,11 +85160,12 @@ async function commandsCommand(options2) {
   console.log();
   oe(import_picocolors13.default.bgCyan(import_picocolors13.default.black(" ck commands ")));
   try {
+    const registryDeps = resolveCommandsRegistryDeps(options2);
     const validOptions = PortableCommandOptionsSchema.parse(options2);
     if (validOptions.sync) {
       const spinner2 = de();
       spinner2.start("Syncing registry...");
-      const { removed } = await syncPortableRegistry();
+      const { removed } = await registryDeps.syncPortableRegistry();
       spinner2.stop("Sync complete");
       if (removed.length > 0) {
         const cmdRemoved = removed.filter((r2) => r2.type === "command");
@@ -85075,12 +85177,12 @@ async function commandsCommand(options2) {
       return;
     }
     if (validOptions.uninstall) {
-      await handleUninstall2(validOptions);
+      await handleUninstall2(validOptions, registryDeps);
       $e(import_picocolors13.default.green("Done!"));
       return;
     }
     if (validOptions.list) {
-      await listCommands(validOptions.installed ?? false);
+      await listCommands(validOptions.installed ?? false, registryDeps);
       $e(import_picocolors13.default.dim("Use --name <command> to install a specific command"));
       return;
     }
@@ -87266,16 +87368,16 @@ async function checkPathRefsValid(projectDir) {
       };
     }
     const baseDir = dirname28(claudeMdPath);
-    const home6 = homedir42();
+    const home5 = homedir42();
     const broken = [];
     for (const ref of refs) {
       let refPath;
       if (ref.startsWith("$HOME") || ref.startsWith("${HOME}") || ref.startsWith("%USERPROFILE%")) {
-        refPath = normalize6(ref.replace(/^\$\{?HOME\}?/, home6).replace("%USERPROFILE%", home6));
+        refPath = normalize6(ref.replace(/^\$\{?HOME\}?/, home5).replace("%USERPROFILE%", home5));
       } else if (ref.startsWith("$CLAUDE_PROJECT_DIR") || ref.startsWith("${CLAUDE_PROJECT_DIR}") || ref.startsWith("%CLAUDE_PROJECT_DIR%")) {
         refPath = normalize6(ref.replace(/^\$\{?CLAUDE_PROJECT_DIR\}?/, projectDir).replace("%CLAUDE_PROJECT_DIR%", projectDir));
       } else if (ref.startsWith("~")) {
-        refPath = normalize6(ref.replace(/^~/, home6));
+        refPath = normalize6(ref.replace(/^~/, home5));
       } else if (ref.startsWith("/")) {
         refPath = normalize6(ref);
       } else if (/^[A-Za-z]:/.test(ref)) {
@@ -87284,7 +87386,7 @@ async function checkPathRefsValid(projectDir) {
         refPath = resolve35(baseDir, ref);
       }
       const normalizedPath = normalize6(refPath);
-      const isWithinHome = normalizedPath.startsWith(home6);
+      const isWithinHome = normalizedPath.startsWith(home5);
       const isWithinBase2 = normalizedPath.startsWith(normalize6(baseDir));
       const isAbsoluteAllowed = ref.startsWith("/") || /^[A-Za-z]:/.test(ref);
       if (!isWithinHome && !isWithinBase2 && !isAbsoluteAllowed) {
@@ -89271,8 +89373,8 @@ class ReportGenerator {
     };
   }
   scrubPath(path7) {
-    const home6 = process.env.HOME || process.env.USERPROFILE || "";
-    return home6 ? path7.replace(home6, "~") : path7;
+    const home5 = process.env.HOME || process.env.USERPROFILE || "";
+    return home5 ? path7.replace(home5, "~") : path7;
   }
   getStatusIcon(status) {
     switch (status) {
@@ -89386,8 +89488,8 @@ class DoctorUIRenderer {
     }
   }
   shortenPath(path7) {
-    const home6 = process.env.HOME || process.env.USERPROFILE || "";
-    let shortened = home6 ? path7.replace(home6, "~") : path7;
+    const home5 = process.env.HOME || process.env.USERPROFILE || "";
+    let shortened = home5 ? path7.replace(home5, "~") : path7;
     const maxLen = 50;
     if (shortened.length > maxLen) {
       const start = shortened.slice(0, 20);
@@ -100668,7 +100770,7 @@ init_logger();
 init_types3();
 var import_fs_extra15 = __toESM(require_lib(), 1);
 var import_ignore3 = __toESM(require_ignore(), 1);
-import { dirname as dirname37, join as join110, relative as relative23 } from "node:path";
+import { dirname as dirname38, join as join110, relative as relative23 } from "node:path";
 
 // src/domains/installation/selective-merger.ts
 import { stat as stat18 } from "node:fs/promises";
@@ -102338,8 +102440,8 @@ class FileScanner {
 
 // src/domains/installation/merger/settings-processor.ts
 import { execSync as execSync5 } from "node:child_process";
-import { homedir as homedir45 } from "node:os";
-import { dirname as dirname36, join as join109 } from "node:path";
+import { homedir as homedir46 } from "node:os";
+import { dirname as dirname37, join as join109 } from "node:path";
 
 // src/domains/config/installed-settings-tracker.ts
 init_shared();
@@ -102436,6 +102538,136 @@ class InstalledSettingsTracker {
 
 // src/domains/installation/merger/settings-processor.ts
 init_settings_merger();
+
+// src/domains/installation/merger/zombie-wirings-pruner.ts
+import { existsSync as existsSync65, readdirSync as readdirSync8 } from "node:fs";
+import { homedir as homedir45 } from "node:os";
+import { basename as basename26, dirname as dirname36, isAbsolute as isAbsolute12, resolve as resolve41, sep as sep13 } from "node:path";
+function pruneZombieEngineerWirings(settings, hookDir) {
+  const pruned = [];
+  if (!existsSync65(hookDir)) {
+    return { settings, pruned };
+  }
+  const hookFiles = readdirSync8(hookDir);
+  const hasHookFiles = hookFiles.some((f3) => f3.endsWith(".cjs") || f3.endsWith(".sh"));
+  if (!hasHookFiles) {
+    return { settings, pruned };
+  }
+  if (!settings.hooks) {
+    return { settings, pruned };
+  }
+  const eventKeysToDelete = [];
+  const events = settings.hooks;
+  for (const eventName of Object.keys(events)) {
+    const groups = events[eventName];
+    const keptGroups = [];
+    for (const group of groups) {
+      if (!("hooks" in group) || !Array.isArray(group.hooks)) {
+        const entry = group;
+        if (shouldPruneEntry(entry, hookDir, pruned)) {
+          continue;
+        }
+        keptGroups.push(group);
+        continue;
+      }
+      const keptHooks = group.hooks.filter((h2) => {
+        return !shouldPruneEntry(h2, hookDir, pruned);
+      });
+      if (keptHooks.length > 0) {
+        keptGroups.push({ ...group, hooks: keptHooks });
+      }
+    }
+    if (keptGroups.length > 0) {
+      events[eventName] = keptGroups;
+    } else {
+      eventKeysToDelete.push(eventName);
+    }
+  }
+  for (const key of eventKeysToDelete) {
+    delete events[key];
+  }
+  return { settings, pruned };
+}
+function shouldPruneEntry(entry, hookDir, pruned) {
+  if (entry._origin !== "engineer")
+    return false;
+  const filePath = extractHookFilePath(entry.command, hookDir);
+  if (!filePath)
+    return false;
+  if (existsSync65(filePath))
+    return false;
+  pruned.push(basename26(filePath));
+  return true;
+}
+function extractHookFilePath(command, hookDir) {
+  if (!command)
+    return null;
+  if (/&&|\|\||;|(?<!["|'])\|(?!["|'])/.test(command))
+    return null;
+  const home5 = homedir45().replace(/\\/g, "/");
+  const hookDirNorm = hookDir.replace(/\\/g, "/");
+  function resolveEnvPath(prefix, rest) {
+    const normRest = rest.replace(/\\/g, "/");
+    let resolved;
+    if (prefix === "$HOME" || prefix === "${HOME}" || prefix === "%USERPROFILE%") {
+      resolved = `${home5}/${normRest}`;
+    } else if (prefix === "$CLAUDE_PROJECT_DIR" || prefix === "%CLAUDE_PROJECT_DIR%") {
+      const projectRoot = dirname36(dirname36(hookDirNorm));
+      resolved = `${projectRoot}/${normRest}`;
+    } else {
+      resolved = `${prefix}/${normRest}`;
+    }
+    return resolved;
+  }
+  if (/^bash\s/.test(command)) {
+    const bashMatch = command.match(/^bash\s+["']([^"']+\.sh)["']/);
+    if (bashMatch) {
+      const rawPath = bashMatch[1].replace(/\\/g, "/");
+      const resolved = isAbsolute12(rawPath) || /^[A-Za-z]:[\\/]/.test(rawPath) ? rawPath : resolve41(hookDir, rawPath);
+      return process.platform === "win32" ? resolved.replace(/\//g, sep13) : resolved;
+    }
+    return null;
+  }
+  if (!/(?:^|\s)node\s/.test(command))
+    return null;
+  const varOnlyQuoted = command.match(/(?:^|\s)node\s+["'](\$\w+|\$\{\w+\}|%\w+%)["'][/\\](\.claude[/\\]\S+)/);
+  if (varOnlyQuoted) {
+    const [, envVar, rest] = varOnlyQuoted;
+    const resolved = resolveEnvPath(envVar, rest);
+    return process.platform === "win32" ? resolved.replace(/\//g, sep13) : resolved;
+  }
+  const quotedMatch = command.match(/(?:^|\s)node\s+["']([^"']+)["']/);
+  if (quotedMatch) {
+    const rawArg = quotedMatch[1].trim().replace(/\\/g, "/");
+    const envPrefixMatch = rawArg.match(/^(\$HOME|\$\{HOME\}|%USERPROFILE%|\$CLAUDE_PROJECT_DIR|%CLAUDE_PROJECT_DIR%)[/\\](.*)/);
+    if (envPrefixMatch) {
+      const resolved = resolveEnvPath(envPrefixMatch[1], envPrefixMatch[2]);
+      return process.platform === "win32" ? resolved.replace(/\//g, sep13) : resolved;
+    }
+    const tildeResolved = rawArg.replace(/^~(?=\/)/, home5);
+    if (isAbsolute12(tildeResolved) || /^[A-Za-z]:[\\/]/.test(tildeResolved)) {
+      return process.platform === "win32" ? tildeResolved.replace(/\//g, sep13) : tildeResolved;
+    }
+    return resolve41(hookDir, tildeResolved);
+  }
+  const unquotedMatch = command.match(/(?:^|\s)node\s+(\S+\.(?:cjs|sh|mjs|js))/);
+  if (unquotedMatch) {
+    const rawArg = unquotedMatch[1].replace(/\\/g, "/");
+    const envPrefixMatch = rawArg.match(/^(\$HOME|\$\{HOME\}|%USERPROFILE%|\$CLAUDE_PROJECT_DIR|%CLAUDE_PROJECT_DIR%)[/\\](.*)/);
+    if (envPrefixMatch) {
+      const resolved = resolveEnvPath(envPrefixMatch[1], envPrefixMatch[2]);
+      return process.platform === "win32" ? resolved.replace(/\//g, sep13) : resolved;
+    }
+    const tildeResolved = rawArg.replace(/^~(?=\/)/, home5);
+    if (isAbsolute12(tildeResolved) || /^[A-Za-z]:[\\/]/.test(tildeResolved)) {
+      return process.platform === "win32" ? tildeResolved.replace(/\//g, sep13) : tildeResolved;
+    }
+    return resolve41(hookDir, tildeResolved);
+  }
+  return null;
+}
+
+// src/domains/installation/merger/settings-processor.ts
 init_command_normalizer();
 init_logger();
 init_path_resolver();
@@ -102452,6 +102684,7 @@ class SettingsProcessor {
   installingKit;
   cachedVersion = undefined;
   deletionPatterns = [];
+  zombiePrunerHookDir = null;
   setGlobalFlag(isGlobal) {
     this.isGlobal = isGlobal;
   }
@@ -102472,6 +102705,9 @@ class SettingsProcessor {
   setDeletions(deletions) {
     this.deletionPatterns = deletions;
   }
+  setZombiePrunerHookDir(hookDir) {
+    this.zombiePrunerHookDir = hookDir;
+  }
   initTracker() {
     if (this.projectDir) {
       this.tracker = new InstalledSettingsTracker(this.projectDir, this.isGlobal, this.kitName);
@@ -102582,6 +102818,12 @@ class SettingsProcessor {
     if (hooksPruned > 0) {
       logger.info(`Pruned ${hooksPruned} stale hook(s) referencing deleted files`);
     }
+    if (this.zombiePrunerHookDir) {
+      const { pruned: zombiePruned } = pruneZombieEngineerWirings(mergeResult.merged, this.zombiePrunerHookDir);
+      if (zombiePruned.length > 0) {
+        logger.info(`Pruned ${zombiePruned.length} zombie hook entries: ${zombiePruned.join(", ")}`);
+      }
+    }
     await SettingsMerger.writeSettingsFile(destFile, mergeResult.merged);
     logger.success("Merged settings.json (user customizations preserved)");
     await this.injectTeamHooksIfSupported(destFile, mergeResult.merged);
@@ -102827,7 +103069,7 @@ class SettingsProcessor {
       return false;
     }
     const configuredGlobalDir = PathResolver.getGlobalKitDir().replace(/\\/g, "/").replace(/\/+$/, "");
-    const defaultGlobalDir = join109(homedir45(), ".claude").replace(/\\/g, "/");
+    const defaultGlobalDir = join109(homedir46(), ".claude").replace(/\\/g, "/");
     return configuredGlobalDir !== defaultGlobalDir;
   }
   getClaudeCommandRoot() {
@@ -102847,7 +103089,7 @@ class SettingsProcessor {
     return true;
   }
   async repairSiblingSettingsLocal(destFile) {
-    const settingsLocalPath = join109(dirname36(destFile), "settings.local.json");
+    const settingsLocalPath = join109(dirname37(destFile), "settings.local.json");
     if (settingsLocalPath === destFile || !await import_fs_extra14.pathExists(settingsLocalPath)) {
       return;
     }
@@ -102987,6 +103229,9 @@ class CopyExecutor {
   setKitName(kit) {
     this.settingsProcessor.setKitName(kit);
   }
+  setZombiePrunerHookDir(hookDir) {
+    this.settingsProcessor.setZombiePrunerHookDir(hookDir);
+  }
   setManifest(manifest) {
     this.selectiveMerger = manifest ? new SelectiveMerger(manifest) : null;
     if (manifest && this.selectiveMerger?.hasManifest()) {
@@ -103107,10 +103352,10 @@ class CopyExecutor {
   }
   trackInstalledFile(relativePath) {
     this.installedFiles.add(relativePath);
-    let dir = dirname37(relativePath);
+    let dir = dirname38(relativePath);
     while (dir && dir !== "." && dir !== "/") {
       this.installedDirectories.add(`${dir}/`);
-      dir = dirname37(dir);
+      dir = dirname38(dir);
     }
   }
 }
@@ -103156,6 +103401,9 @@ class FileMerger {
   setDeletions(deletions) {
     this.copyExecutor.setDeletions(deletions);
   }
+  setZombiePrunerHookDir(hookDir) {
+    this.copyExecutor.setZombiePrunerHookDir(hookDir);
+  }
   setManifest(manifest) {
     this.copyExecutor.setManifest(manifest);
   }
@@ -103867,7 +104115,7 @@ function buildConflictSummary(fileConflicts, hookConflicts, mcpConflicts) {
 init_logger();
 init_skip_directories();
 var import_fs_extra19 = __toESM(require_lib(), 1);
-import { join as join115, relative as relative25, resolve as resolve41 } from "node:path";
+import { join as join115, relative as relative25, resolve as resolve43 } from "node:path";
 
 class FileScanner2 {
   static async getFiles(dirPath, relativeTo) {
@@ -103947,8 +104195,8 @@ class FileScanner2 {
     return customFiles;
   }
   static isSafePath(basePath, targetPath) {
-    const resolvedBase = resolve41(basePath);
-    const resolvedTarget = resolve41(targetPath);
+    const resolvedBase = resolve43(basePath);
+    const resolvedTarget = resolve43(targetPath);
     return resolvedTarget.startsWith(resolvedBase);
   }
   static toPosixPath(path16) {
@@ -104469,6 +104717,7 @@ async function handleMerge(ctx) {
   merger.setForceOverwriteSettings(ctx.options.forceOverwriteSettings);
   merger.setProjectDir(ctx.resolvedDir);
   merger.setKitName(ctx.kit.name);
+  merger.setZombiePrunerHookDir(join120(ctx.claudeDir, "hooks"));
   if (ctx.kitType) {
     merger.setMultiKitContext(ctx.claudeDir, ctx.kitType);
   }
@@ -105259,7 +105508,7 @@ init_logger();
 init_types3();
 var import_fs_extra28 = __toESM(require_lib(), 1);
 import { copyFile as copyFile7, mkdir as mkdir34, readdir as readdir36, rm as rm14, stat as stat21 } from "node:fs/promises";
-import { basename as basename26, join as join124, normalize as normalize9 } from "node:path";
+import { basename as basename27, join as join124, normalize as normalize9 } from "node:path";
 function validatePath2(path16, paramName) {
   if (!path16 || typeof path16 !== "string") {
     throw new SkillsMigrationError(`${paramName} must be a non-empty string`);
@@ -105395,7 +105644,7 @@ class SkillsBackupManager {
     return size;
   }
   static extractBackupTimestamp(backupPath) {
-    const dirName = basename26(backupPath);
+    const dirName = basename27(backupPath);
     if (!dirName.startsWith(SkillsBackupManager.BACKUP_PREFIX)) {
       return null;
     }
@@ -105436,12 +105685,12 @@ async function getAllFiles(dirPath) {
   return files;
 }
 async function hashFile(filePath) {
-  return new Promise((resolve43, reject) => {
+  return new Promise((resolve44, reject) => {
     const hash = createHash8("sha256");
     const stream = createReadStream2(filePath);
     stream.on("data", (chunk) => hash.update(chunk));
     stream.on("end", () => {
-      resolve43(hash.digest("hex"));
+      resolve44(hash.digest("hex"));
     });
     stream.on("error", (error) => {
       stream.destroy();
@@ -106090,7 +106339,7 @@ async function handlePostInstall(ctx) {
 init_config_manager();
 init_github_client();
 import { mkdir as mkdir36 } from "node:fs/promises";
-import { join as join134, resolve as resolve46 } from "node:path";
+import { join as join134, resolve as resolve47 } from "node:path";
 
 // src/domains/github/kit-access-checker.ts
 init_error2();
@@ -106259,8 +106508,8 @@ async function runPreflightChecks() {
 
 // src/domains/installation/fresh-installer.ts
 init_metadata_migration();
-import { existsSync as existsSync65, readdirSync as readdirSync8, rmSync as rmSync3, rmdirSync as rmdirSync2, unlinkSync as unlinkSync5 } from "node:fs";
-import { basename as basename27, dirname as dirname38, join as join132, resolve as resolve43 } from "node:path";
+import { existsSync as existsSync66, readdirSync as readdirSync9, rmSync as rmSync3, rmdirSync as rmdirSync2, unlinkSync as unlinkSync5 } from "node:fs";
+import { basename as basename28, dirname as dirname39, join as join132, resolve as resolve45 } from "node:path";
 init_logger();
 init_safe_spinner();
 var import_fs_extra34 = __toESM(require_lib(), 1);
@@ -106312,15 +106561,15 @@ async function analyzeFreshInstallation(claudeDir3) {
   };
 }
 function cleanupEmptyDirectories2(filePath, claudeDir3) {
-  const normalizedClaudeDir = resolve43(claudeDir3);
-  let currentDir = resolve43(dirname38(filePath));
+  const normalizedClaudeDir = resolve45(claudeDir3);
+  let currentDir = resolve45(dirname39(filePath));
   while (currentDir !== normalizedClaudeDir && currentDir.startsWith(normalizedClaudeDir)) {
     try {
-      const entries = readdirSync8(currentDir);
+      const entries = readdirSync9(currentDir);
       if (entries.length === 0) {
         rmdirSync2(currentDir);
         logger.debug(`Removed empty directory: ${currentDir}`);
-        currentDir = resolve43(dirname38(currentDir));
+        currentDir = resolve45(dirname39(currentDir));
       } else {
         break;
       }
@@ -106343,7 +106592,7 @@ async function removeFilesByOwnership(claudeDir3, analysis, includeModified) {
   }
   for (const file of filesToRemove) {
     const fullPath = join132(claudeDir3, file.path);
-    if (!existsSync65(fullPath)) {
+    if (!existsSync66(fullPath)) {
       continue;
     }
     try {
@@ -106401,8 +106650,8 @@ function getFreshBackupTargets(claudeDir3, analysis, includeModified) {
       mutatePaths: filesToRemove.length > 0 ? ["metadata.json"] : []
     };
   }
-  const deletePaths = CLAUDEKIT_SUBDIRECTORIES.filter((subdir) => existsSync65(join132(claudeDir3, subdir)));
-  if (existsSync65(join132(claudeDir3, "metadata.json"))) {
+  const deletePaths = CLAUDEKIT_SUBDIRECTORIES.filter((subdir) => existsSync66(join132(claudeDir3, subdir)));
+  if (existsSync66(join132(claudeDir3, "metadata.json"))) {
     deletePaths.push("metadata.json");
   }
   return {
@@ -106471,7 +106720,7 @@ async function handleFreshInstallation(claudeDir3, prompts) {
           mutatePaths: backupTargets.mutatePaths,
           scope: "claude"
         });
-        await cleanupOldDestructiveOperationBackups(undefined, basename27(backup.backupDir));
+        await cleanupOldDestructiveOperationBackups(undefined, basename28(backup.backupDir));
         backupSpinner.succeed(`Recovery backup saved to ${backup.backupDir}`);
       } catch (error) {
         backupSpinner.fail("Failed to create recovery backup");
@@ -106509,8 +106758,8 @@ async function handleFreshInstallation(claudeDir3, prompts) {
 // src/domains/installation/global-kit-legacy-repair.ts
 var import_fs_extra35 = __toESM(require_lib(), 1);
 import { cp as cp5, mkdir as mkdir35, readdir as readdir41, rename as rename11, rm as rm16, stat as stat22 } from "node:fs/promises";
-import { homedir as homedir46 } from "node:os";
-import { dirname as dirname39, join as join133, normalize as normalize11, resolve as resolve45 } from "node:path";
+import { homedir as homedir47 } from "node:os";
+import { dirname as dirname40, join as join133, normalize as normalize11, resolve as resolve46 } from "node:path";
 var LEGACY_KIT_MARKERS = [
   "metadata.json",
   ".ck.json",
@@ -106536,7 +106785,7 @@ function uniqueNormalizedPaths(paths) {
   const seen = new Set;
   const result = [];
   for (const path16 of paths) {
-    const normalized = normalize11(resolve45(path16));
+    const normalized = normalize11(resolve46(path16));
     if (seen.has(normalized))
       continue;
     seen.add(normalized);
@@ -106544,7 +106793,7 @@ function uniqueNormalizedPaths(paths) {
   }
   return result;
 }
-function getLegacyWindowsGlobalKitDirCandidates(env2 = process.env, homeDir = homedir46()) {
+function getLegacyWindowsGlobalKitDirCandidates(env2 = process.env, homeDir = homedir47()) {
   const candidates = [];
   const localAppData = safeEnvPath(env2.LOCALAPPDATA);
   const appData = safeEnvPath(env2.APPDATA);
@@ -106601,8 +106850,8 @@ async function repairLegacyWindowsGlobalKitDir(options2) {
   if (safeEnvPath(env2.CLAUDE_CONFIG_DIR)) {
     return { status: "skipped", reason: "custom-global-dir", candidateDirs: [] };
   }
-  const targetDir = normalize11(resolve45(options2.targetDir));
-  const candidateDirs = getLegacyWindowsGlobalKitDirCandidates(env2, options2.homeDir).filter((candidate) => normalize11(resolve45(candidate)) !== targetDir);
+  const targetDir = normalize11(resolve46(options2.targetDir));
+  const candidateDirs = getLegacyWindowsGlobalKitDirCandidates(env2, options2.homeDir).filter((candidate) => normalize11(resolve46(candidate)) !== targetDir);
   const legacyDirs = [];
   for (const candidate of candidateDirs) {
     if (await hasKitMarkers(candidate)) {
@@ -106623,7 +106872,7 @@ async function repairLegacyWindowsGlobalKitDir(options2) {
   if (targetExists) {
     await rm16(targetDir, { recursive: true, force: true });
   }
-  await mkdir35(dirname39(targetDir), { recursive: true });
+  await mkdir35(dirname40(targetDir), { recursive: true });
   await moveDirectory(legacyDir, targetDir);
   return { status: "repaired", reason: "repaired", legacyDir, candidateDirs };
 }
@@ -106825,7 +107074,7 @@ async function handleSelection(ctx) {
       }
     }
   }
-  const resolvedDir = resolve46(targetDir);
+  const resolvedDir = resolve47(targetDir);
   if (ctx.options.global) {
     try {
       const repairResult = await repairLegacyWindowsGlobalKitDir({ targetDir: resolvedDir });
@@ -107022,7 +107271,7 @@ async function handleSelection(ctx) {
 }
 // src/commands/init/phases/sync-handler.ts
 import { copyFile as copyFile8, mkdir as mkdir37, open as open5, readFile as readFile59, rename as rename12, stat as stat23, unlink as unlink13, writeFile as writeFile33 } from "node:fs/promises";
-import { dirname as dirname40, join as join135, resolve as resolve47 } from "node:path";
+import { dirname as dirname41, join as join135, resolve as resolve48 } from "node:path";
 init_logger();
 init_path_resolver();
 var import_fs_extra37 = __toESM(require_lib(), 1);
@@ -107031,7 +107280,7 @@ async function handleSync(ctx) {
   if (!ctx.options.sync) {
     return ctx;
   }
-  const resolvedDir = ctx.options.global ? PathResolver.getGlobalKitDir() : resolve47(ctx.options.dir || ".");
+  const resolvedDir = ctx.options.global ? PathResolver.getGlobalKitDir() : resolve48(ctx.options.dir || ".");
   const claudeDir3 = ctx.options.global ? resolvedDir : join135(resolvedDir, ".claude");
   if (!await import_fs_extra37.pathExists(claudeDir3)) {
     logger.error("Cannot sync: no .claude directory found");
@@ -107141,7 +107390,7 @@ async function acquireSyncLock(global3) {
   const lockPath = join135(cacheDir, ".sync-lock");
   const startTime = Date.now();
   const lockTimeout = getLockTimeout();
-  await mkdir37(dirname40(lockPath), { recursive: true });
+  await mkdir37(dirname41(lockPath), { recursive: true });
   while (Date.now() - startTime < lockTimeout) {
     try {
       const handle = await open5(lockPath, "wx");
@@ -107677,7 +107926,7 @@ async function transformFolderPaths(extractDir, folders, options2 = {}) {
 // src/services/transformers/global-path-transformer.ts
 init_logger();
 import { readFile as readFile61, readdir as readdir43, writeFile as writeFile35 } from "node:fs/promises";
-import { homedir as homedir47, platform as platform15 } from "node:os";
+import { homedir as homedir48, platform as platform15 } from "node:os";
 import { extname as extname6, join as join138 } from "node:path";
 var IS_WINDOWS3 = platform15() === "win32";
 var HOME_PREFIX = "$HOME";
@@ -107688,7 +107937,7 @@ function normalizeInstallPath(path16) {
   return path16.replace(/\\/g, "/").replace(/\/+$/, "");
 }
 function getDefaultGlobalClaudeDir() {
-  return normalizeInstallPath(join138(homedir47(), ".claude"));
+  return normalizeInstallPath(join138(homedir48(), ".claude"));
 }
 function getCustomGlobalClaudeDir(targetClaudeDir) {
   if (!targetClaudeDir)
@@ -107808,8 +108057,8 @@ function transformContent(content, options2 = {}) {
 }
 function shouldTransformFile3(filename) {
   const ext2 = extname6(filename).toLowerCase();
-  const basename28 = filename.split("/").pop() || filename;
-  return TRANSFORMABLE_EXTENSIONS3.has(ext2) || ALWAYS_TRANSFORM_FILES.has(basename28);
+  const basename29 = filename.split("/").pop() || filename;
+  return TRANSFORMABLE_EXTENSIONS3.has(ext2) || ALWAYS_TRANSFORM_FILES.has(basename29);
 }
 async function transformPathsForGlobalInstall(directory, options2 = {}) {
   let filesTransformed = 0;
@@ -108087,16 +108336,16 @@ async function initCommand(options2) {
 // src/commands/migrate/migrate-command.ts
 init_dist2();
 var import_picocolors30 = __toESM(require_picocolors(), 1);
-import { existsSync as existsSync66 } from "node:fs";
+import { existsSync as existsSync67 } from "node:fs";
 import { readFile as readFile65, rm as rm18, unlink as unlink14 } from "node:fs/promises";
-import { homedir as homedir52 } from "node:os";
-import { basename as basename29, join as join143, resolve as resolve49 } from "node:path";
+import { homedir as homedir53 } from "node:os";
+import { basename as basename30, join as join143, resolve as resolve50 } from "node:path";
 init_logger();
 
 // src/ui/ck-cli-design/tokens.ts
 var import_picocolors27 = __toESM(require_picocolors(), 1);
-import { homedir as homedir48, platform as platform16 } from "node:os";
-import { resolve as resolve48, win32 as win322 } from "node:path";
+import { homedir as homedir49, platform as platform16 } from "node:os";
+import { resolve as resolve49, win32 as win322 } from "node:path";
 var PANEL_MIN_WIDTH = 60;
 var PANEL_MAX_WIDTH = 72;
 var DEFAULT_WIDTH = PANEL_MAX_WIDTH;
@@ -108253,11 +108502,11 @@ function wrapText(value, width) {
 }
 function formatDisplayPath(value) {
   const normalized = value.replace(/\\/g, "/");
-  const home6 = homedir48().replace(/\\/g, "/");
-  if (normalized === home6)
+  const home5 = homedir49().replace(/\\/g, "/");
+  if (normalized === home5)
     return "~";
-  if (normalized.startsWith(`${home6}/`)) {
-    return normalized.replace(home6, "~");
+  if (normalized.startsWith(`${home5}/`)) {
+    return normalized.replace(home5, "~");
   }
   return normalized;
 }
@@ -108266,7 +108515,7 @@ function formatCdHint(value, currentPlatform = platform16()) {
     const absolutePath2 = win322.resolve(value);
     return `cd /d "${absolutePath2}"`;
   }
-  const absolutePath = resolve48(value);
+  const absolutePath = resolve49(value);
   const displayPath = formatDisplayPath(absolutePath);
   if (displayPath.includes(" ")) {
     return `cd "${displayPath}"`;
@@ -108567,13 +108816,13 @@ init_logger();
 init_dist2();
 init_model_taxonomy();
 import { mkdir as mkdir39, readFile as readFile64, writeFile as writeFile37 } from "node:fs/promises";
-import { homedir as homedir51 } from "node:os";
-import { dirname as dirname41, join as join142 } from "node:path";
+import { homedir as homedir52 } from "node:os";
+import { dirname as dirname42, join as join142 } from "node:path";
 
 // src/commands/portable/models-dev-cache.ts
 init_logger();
 import { mkdir as mkdir38, readFile as readFile62, rename as rename14, writeFile as writeFile36 } from "node:fs/promises";
-import { homedir as homedir49 } from "node:os";
+import { homedir as homedir50 } from "node:os";
 import { join as join140 } from "node:path";
 
 class ModelsDevUnavailableError extends Error {
@@ -108586,7 +108835,7 @@ var MODELS_DEV_URL = "https://models.dev/api.json";
 var CACHE_TTL_MS3 = 24 * 60 * 60 * 1000;
 var FETCH_TIMEOUT_MS = 1e4;
 function defaultCacheDir() {
-  return join140(homedir49(), ".config", "claudekit", "cache");
+  return join140(homedir50(), ".config", "claudekit", "cache");
 }
 function cacheFilePath(cacheDir) {
   return join140(cacheDir, "models-dev.json");
@@ -108666,7 +108915,7 @@ async function getModelsDevCatalog(opts = {}) {
 // src/commands/portable/opencode-model-discovery.ts
 init_logger();
 import { readFile as readFile63 } from "node:fs/promises";
-import { homedir as homedir50, platform as platform17 } from "node:os";
+import { homedir as homedir51, platform as platform17 } from "node:os";
 import { join as join141 } from "node:path";
 function resolveOpenCodeAuthPath(homeDir) {
   if (platform17() === "win32") {
@@ -108712,8 +108961,8 @@ function pickGenericModel(models) {
   return sorted[0] ?? null;
 }
 async function resolveOpenCodeDefaultModel(opts = {}) {
-  const home6 = opts.homeDir ?? homedir50();
-  const authedProviders = await readAuthedProviders(home6);
+  const home5 = opts.homeDir ?? homedir51();
+  const authedProviders = await readAuthedProviders(home5);
   if (authedProviders.length === 0) {
     return { ok: false, reason: "no-auth", authedProviders: [] };
   }
@@ -108776,7 +109025,7 @@ function messageForReason(reason) {
 }
 function getOpenCodeConfigPath(options2) {
   if (options2.global) {
-    return join142(options2.homeDir ?? homedir51(), ".config", "opencode", "opencode.json");
+    return join142(options2.homeDir ?? homedir52(), ".config", "opencode", "opencode.json");
   }
   return join142(options2.cwd ?? process.cwd(), "opencode.json");
 }
@@ -108921,7 +109170,7 @@ async function ensureOpenCodeModel(options2) {
     }
     const chosenModel2 = response2.action === "custom" ? response2.value : suggestion2.model;
     const next2 = { ...existing, model: chosenModel2 };
-    await mkdir39(dirname41(configPath), { recursive: true });
+    await mkdir39(dirname42(configPath), { recursive: true });
     await writeFile37(configPath, `${JSON.stringify(next2, null, 2)}
 `, "utf-8");
     return { path: configPath, action: "added", model: chosenModel2, reason: suggestion2.reason };
@@ -108932,7 +109181,7 @@ async function ensureOpenCodeModel(options2) {
       throw new OpenCodeAuthRequiredError(suggestion.failure);
     }
     const next2 = { ...existing ?? {}, model: suggestion.model };
-    await mkdir39(dirname41(configPath), { recursive: true });
+    await mkdir39(dirname42(configPath), { recursive: true });
     await writeFile37(configPath, `${JSON.stringify(next2, null, 2)}
 `, "utf-8");
     return {
@@ -108954,7 +109203,7 @@ async function ensureOpenCodeModel(options2) {
   }
   const chosenModel = response.action === "custom" ? response.value : suggestion.ok ? suggestion.model : "";
   const next = { ...existing ?? {}, model: chosenModel };
-  await mkdir39(dirname41(configPath), { recursive: true });
+  await mkdir39(dirname42(configPath), { recursive: true });
   await writeFile37(configPath, `${JSON.stringify(next, null, 2)}
 `, "utf-8");
   return {
@@ -108967,7 +109216,7 @@ async function ensureOpenCodeModel(options2) {
 
 // src/commands/portable/plan-display.ts
 var import_picocolors28 = __toESM(require_picocolors(), 1);
-import { basename as basename28, dirname as dirname42, extname as extname7 } from "node:path";
+import { basename as basename29, dirname as dirname43, extname as extname7 } from "node:path";
 var DEFAULT_MAX_PLAN_GROUP_ITEMS = 20;
 var TYPE_ORDER = [
   "agent",
@@ -109193,21 +109442,21 @@ function collectPlannedWhereLines(plan) {
   return destinations.map((destination) => `${formatDisplayPath(destination)} -> ${formatCdHint(resolveCdTarget(destination))}`);
 }
 function resolveCdTarget(destination) {
-  return extname7(destination).length > 0 ? dirname42(destination) : destination;
+  return extname7(destination).length > 0 ? dirname43(destination) : destination;
 }
 function normalizeWhereDestination(path16, portableType) {
   if (portableType === "agent" || portableType === "command" || portableType === "skill") {
-    return dirname42(path16);
+    return dirname43(path16);
   }
   if (portableType === "hooks") {
-    return dirname42(path16);
+    return dirname43(path16);
   }
   if (portableType === "rules") {
-    const fileName = basename28(path16).toLowerCase();
+    const fileName = basename29(path16).toLowerCase();
     if (fileName === "agents.md" || fileName === "gemini.md" || fileName === ".goosehints" || fileName === "custom_modes.yaml" || fileName === "custom_modes.yml") {
       return path16;
     }
-    return dirname42(path16);
+    return dirname43(path16);
   }
   return path16;
 }
@@ -109728,9 +109977,9 @@ function shouldExecuteAction2(action) {
 }
 async function executeDeleteAction(action, options2) {
   const preservePaths = options2?.preservePaths ?? new Set;
-  const shouldPreserveTarget = action.targetPath.length > 0 && preservePaths.has(resolve49(action.targetPath));
+  const shouldPreserveTarget = action.targetPath.length > 0 && preservePaths.has(resolve50(action.targetPath));
   try {
-    if (!shouldPreserveTarget && action.targetPath && existsSync66(action.targetPath)) {
+    if (!shouldPreserveTarget && action.targetPath && existsSync67(action.targetPath)) {
       await rm18(action.targetPath, { recursive: true, force: true });
     }
     await removePortableInstallation(action.item, action.type, action.provider, action.global, action.targetPath ? { path: action.targetPath } : undefined);
@@ -109761,8 +110010,8 @@ async function executeDeleteAction(action, options2) {
 async function processMetadataDeletions(skillSourcePath, installGlobally) {
   if (!skillSourcePath)
     return;
-  const sourceMetadataPath = join143(resolve49(skillSourcePath, ".."), "metadata.json");
-  if (!existsSync66(sourceMetadataPath))
+  const sourceMetadataPath = join143(resolve50(skillSourcePath, ".."), "metadata.json");
+  if (!existsSync67(sourceMetadataPath))
     return;
   let sourceMetadata;
   try {
@@ -109774,8 +110023,8 @@ async function processMetadataDeletions(skillSourcePath, installGlobally) {
   }
   if (!sourceMetadata.deletions || sourceMetadata.deletions.length === 0)
     return;
-  const claudeDir3 = installGlobally ? join143(homedir52(), ".claude") : join143(process.cwd(), ".claude");
-  if (!existsSync66(claudeDir3))
+  const claudeDir3 = installGlobally ? join143(homedir53(), ".claude") : join143(process.cwd(), ".claude");
+  if (!existsSync67(claudeDir3))
     return;
   try {
     const result = await handleDeletions(sourceMetadata, claudeDir3, inferKitTypeFromSourceMetadata(sourceMetadata));
@@ -109903,7 +110152,7 @@ async function migrateCommand(options2) {
     let installGlobally = requestedGlobal;
     if (options2.global === undefined && !options2.yes) {
       const projectTarget = join143(process.cwd(), ".claude");
-      const globalTarget = join143(homedir52(), ".claude");
+      const globalTarget = join143(homedir53(), ".claude");
       const scopeChoice = await ie({
         message: "Installation scope",
         options: [
@@ -109976,7 +110225,7 @@ async function migrateCommand(options2) {
     }).join(`
 `));
     if (sourceGlobalOnly) {
-      f2.info(import_picocolors30.default.dim(`  Scope: global (--global / -g) - reading from ${formatDisplayPath(join143(homedir52(), ".claude"))}`));
+      f2.info(import_picocolors30.default.dim(`  Scope: global (--global / -g) - reading from ${formatDisplayPath(join143(homedir53(), ".claude"))}`));
     } else {
       f2.info(import_picocolors30.default.dim(`  CWD: ${process.cwd()}`));
     }
@@ -110067,7 +110316,7 @@ async function migrateCommand(options2) {
       const interactive = process.stdout.isTTY && !options2.yes;
       const conflictActions = plan.actions.filter((a3) => a3.action === "conflict");
       for (const action of conflictActions) {
-        if (!action.diff && action.targetPath && existsSync66(action.targetPath)) {
+        if (!action.diff && action.targetPath && existsSync67(action.targetPath)) {
           try {
             const targetContent = await readFile65(action.targetPath, "utf-8");
             const sourceItem = effectiveAgents.find((a3) => a3.name === action.item) || effectiveCommands.find((c2) => c2.name === action.item) || (effectiveConfigItem?.name === action.item ? effectiveConfigItem : null) || effectiveRuleItems.find((r2) => r2.name === action.item) || effectiveHookItems.find((h2) => h2.name === action.item);
@@ -110182,18 +110431,18 @@ async function migrateCommand(options2) {
     const recordSuccessfulWrites = (task, taskResults) => {
       for (const result of taskResults.filter((entry) => entry.success && !entry.skipped)) {
         if (result.path.length > 0) {
-          writtenPaths.add(resolve49(result.path));
+          writtenPaths.add(resolve50(result.path));
         }
         if (task.type === "hooks") {
           const existing = successfulHookFiles.get(task.provider) ?? {
             files: [],
             global: task.global
           };
-          existing.files.push(basename29(result.path));
+          existing.files.push(basename30(result.path));
           successfulHookFiles.set(task.provider, existing);
           if (result.path.length > 0) {
             const absExisting = successfulHookAbsPaths.get(task.provider) ?? [];
-            absExisting.push(resolve49(result.path));
+            absExisting.push(resolve50(result.path));
             successfulHookAbsPaths.set(task.provider, absExisting);
           }
         }
@@ -110327,7 +110576,7 @@ async function migrateCommand(options2) {
         });
         if (staleSlugs.length > 0) {
           const staleSlugSet = new Set(staleSlugs.map((s) => `${s}.toml`));
-          const removed = await removeInstallationsByFilter((i) => i.type === "agent" && i.provider === provider && i.global === scope2 && staleSlugSet.has(basename29(i.path)));
+          const removed = await removeInstallationsByFilter((i) => i.type === "agent" && i.provider === provider && i.global === scope2 && staleSlugSet.has(basename30(i.path)));
           for (const entry of removed) {
             logger.verbose(`[migrate] Cleaned stale registry entry: ${entry.item} (${provider})`);
           }
@@ -110335,7 +110584,7 @@ async function migrateCommand(options2) {
       }
     }
     try {
-      const kitRoot = (agentSource ? resolve49(agentSource, "..") : null) ?? (commandSource ? resolve49(commandSource, "..") : null) ?? (skillSource ? resolve49(skillSource, "..") : null) ?? null;
+      const kitRoot = (agentSource ? resolve50(agentSource, "..") : null) ?? (commandSource ? resolve50(commandSource, "..") : null) ?? (skillSource ? resolve50(skillSource, "..") : null) ?? null;
       const manifest = kitRoot ? await loadPortableManifest(kitRoot) : null;
       if (manifest?.cliVersion) {
         await updateAppliedManifestVersion(manifest.cliVersion);
@@ -110383,7 +110632,7 @@ async function migrateCommand(options2) {
 async function rollbackResults(results) {
   const rolledBackPaths = new Set;
   for (const result of results) {
-    if (!result.path || !existsSync66(result.path))
+    if (!result.path || !existsSync67(result.path))
       continue;
     try {
       if (result.overwritten)
@@ -110532,7 +110781,7 @@ var import_picocolors31 = __toESM(require_picocolors(), 1);
 
 // src/commands/new/phases/directory-setup.ts
 init_config_manager();
-import { resolve as resolve50 } from "node:path";
+import { resolve as resolve51 } from "node:path";
 init_logger();
 init_path_resolver();
 init_types3();
@@ -110617,7 +110866,7 @@ async function directorySetup(validOptions, prompts) {
       targetDir = await prompts.getDirectory(targetDir);
     }
   }
-  const resolvedDir = resolve50(targetDir);
+  const resolvedDir = resolve51(targetDir);
   logger.info(`Target directory: ${resolvedDir}`);
   if (PathResolver.isLocalSameAsGlobal(resolvedDir)) {
     logger.warning("You're creating a project at HOME directory.");
@@ -110950,8 +111199,8 @@ Please use only one download method.`);
 }
 // src/commands/plan/plan-command.ts
 init_output_manager();
-import { existsSync as existsSync69, statSync as statSync12 } from "node:fs";
-import { dirname as dirname46, isAbsolute as isAbsolute13, join as join148, parse as parse7, resolve as resolve54 } from "node:path";
+import { existsSync as existsSync70, statSync as statSync12 } from "node:fs";
+import { dirname as dirname47, isAbsolute as isAbsolute14, join as join148, parse as parse7, resolve as resolve55 } from "node:path";
 
 // src/commands/plan/plan-read-handlers.ts
 init_config();
@@ -110960,19 +111209,19 @@ init_plans_registry();
 init_logger();
 init_output_manager();
 var import_picocolors32 = __toESM(require_picocolors(), 1);
-import { existsSync as existsSync68, statSync as statSync11 } from "node:fs";
-import { basename as basename30, dirname as dirname44, join as join147, relative as relative31, resolve as resolve52 } from "node:path";
+import { existsSync as existsSync69, statSync as statSync11 } from "node:fs";
+import { basename as basename31, dirname as dirname45, join as join147, relative as relative31, resolve as resolve53 } from "node:path";
 
 // src/commands/plan/plan-dependencies.ts
 init_config();
 init_plan_parser();
 init_plans_registry();
-import { existsSync as existsSync67 } from "node:fs";
-import { dirname as dirname43, join as join146 } from "node:path";
+import { existsSync as existsSync68 } from "node:fs";
+import { dirname as dirname44, join as join146 } from "node:path";
 async function resolvePlanDependencies(references, currentPlanFile, options2 = {}) {
   if (references.length === 0)
     return [];
-  const currentPlanDir = dirname43(currentPlanFile);
+  const currentPlanDir = dirname44(currentPlanFile);
   const projectRoot = findProjectRoot(currentPlanDir);
   const config = options2.preloadedConfig ?? (await CkConfigManager.loadFull(projectRoot)).config;
   const defaultScope = inferPlanScopeForDir(currentPlanDir, config);
@@ -110990,7 +111239,7 @@ async function resolvePlanDependencies(references, currentPlanFile, options2 = {
     const scopeRoot = resolvePlanDirForScope(scope, projectRoot, config);
     const planFile = join146(scopeRoot, planId, "plan.md");
     const isSelfReference = planFile === currentPlanFile;
-    if (!existsSync67(planFile)) {
+    if (!existsSync68(planFile)) {
       return {
         reference,
         scope,
@@ -111019,14 +111268,14 @@ init_config();
 init_plan_parser();
 init_plan_scope();
 init_plans_registry();
-import { isAbsolute as isAbsolute12, resolve as resolve51 } from "node:path";
+import { isAbsolute as isAbsolute13, resolve as resolve52 } 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 = isAbsolute12(target) ? resolve51(target) : resolve51(baseDir, target);
+  const resolvedTarget = isAbsolute13(target) ? resolve52(target) : resolve52(baseDir, target);
   return isWithinDir(resolvedTarget, baseDir) ? resolvedTarget : null;
 }
 
@@ -111059,7 +111308,7 @@ async function handleParse(target, options2) {
     console.log(JSON.stringify({ file: relative31(process.cwd(), planFile), frontmatter, phases }, null, 2));
     return;
   }
-  const title = typeof frontmatter.title === "string" ? frontmatter.title : basename30(dirname44(planFile));
+  const title = typeof frontmatter.title === "string" ? frontmatter.title : basename31(dirname45(planFile));
   console.log();
   console.log(import_picocolors32.default.bold(`  Plan: ${title}`));
   console.log(`  File: ${planFile}`);
@@ -111129,8 +111378,8 @@ async function handleStatus(target, options2) {
     return;
   }
   const effectiveTarget = !resolvedTarget && globalBaseDir ? globalBaseDir : resolvedTarget;
-  const t = effectiveTarget ? resolve52(effectiveTarget) : null;
-  const plansDir = t && existsSync68(t) && statSync11(t).isDirectory() && !existsSync68(join147(t, "plan.md")) ? t : null;
+  const t = effectiveTarget ? resolve53(effectiveTarget) : null;
+  const plansDir = t && existsSync69(t) && statSync11(t).isDirectory() && !existsSync69(join147(t, "plan.md")) ? t : null;
   if (plansDir) {
     const planFiles = scanPlanDir(plansDir);
     if (planFiles.length === 0) {
@@ -111170,7 +111419,7 @@ async function handleStatus(target, options2) {
         const blockedBy2 = await resolvePlanDependencies(s.blockedBy, pf, { preloadedConfig });
         const blocks2 = await resolvePlanDependencies(s.blocks, pf, { preloadedConfig });
         const bar = progressBar(s.completed, s.totalPhases);
-        const title2 = s.title ?? basename30(dirname44(pf));
+        const title2 = s.title ?? basename31(dirname45(pf));
         console.log(`  ${import_picocolors32.default.bold(title2)}`);
         console.log(`  ${bar}`);
         if (s.inProgress > 0)
@@ -111189,7 +111438,7 @@ async function handleStatus(target, options2) {
         }
         console.log();
       } catch {
-        console.log(`  [X] Failed to read: ${basename30(dirname44(pf))}`);
+        console.log(`  [X] Failed to read: ${basename31(dirname45(pf))}`);
         console.log();
       }
     }
@@ -111216,7 +111465,7 @@ async function handleStatus(target, options2) {
     console.log(JSON.stringify({ ...summary, dependencyStatus: { blockedBy, blocks } }, null, 2));
     return;
   }
-  const title = summary.title ?? basename30(dirname44(planFile));
+  const title = summary.title ?? basename31(dirname45(planFile));
   console.log();
   console.log(import_picocolors32.default.bold(`  ${title}`));
   if (summary.status)
@@ -111279,7 +111528,7 @@ async function handleKanban(target, options2) {
     process.exitCode = 1;
     return;
   }
-  const route = `/plans?dir=${encodeURIComponent(dirname44(dirname44(planFile)))}&view=kanban`;
+  const route = `/plans?dir=${encodeURIComponent(dirname45(dirname45(planFile)))}&view=kanban`;
   const url = `http://localhost:${server.port}${route}`;
   console.log();
   console.log(import_picocolors32.default.bold("  ClaudeKit Dashboard — Plans"));
@@ -111314,7 +111563,18 @@ init_plan_parser();
 init_plans_registry();
 init_output_manager();
 var import_picocolors33 = __toESM(require_picocolors(), 1);
-import { basename as basename31, dirname as dirname45, relative as relative32, resolve as resolve53 } from "node:path";
+import { basename as basename32, dirname as dirname46, relative as relative32, resolve as resolve54 } from "node:path";
+function quoteReadTarget(filePath) {
+  return `"${filePath.replace(/\\/g, "/").replace(/"/g, "\\\"")}"`;
+}
+function buildPlanCreateReadReminder(planFile, phaseFiles, cwd2 = process.cwd()) {
+  const files = [planFile, ...phaseFiles].map((file) => quoteReadTarget(relative32(cwd2, file)));
+  return [
+    "  [i] Claude Code agents: read plan.md and every phase-*.md before editing.",
+    "      These files already exist; Write/Edit without Read may be rejected after wasting tokens.",
+    `      cat ${files.join(" ")}`
+  ];
+}
 async function handleCreate(target, options2) {
   if (!options2.title) {
     output.error("[X] --title is required for create");
@@ -111346,13 +111606,13 @@ async function handleCreate(target, options2) {
     return;
   }
   const globalBaseDir = options2.global ? await getGlobalPlansDirFromCwd() : undefined;
-  const resolvedDir = globalBaseDir ? resolveTargetFromBase(dir, globalBaseDir) : resolve53(dir);
+  const resolvedDir = globalBaseDir ? resolveTargetFromBase(dir, globalBaseDir) : resolve54(dir);
   if (globalBaseDir && !resolvedDir) {
     output.error("[X] Target directory must stay within the configured global plans root");
     process.exitCode = 1;
     return;
   }
-  const safeResolvedDir = resolvedDir ?? resolve53(dir);
+  const safeResolvedDir = resolvedDir ?? resolve54(dir);
   const result = scaffoldPlan({
     title: options2.title,
     phases: phaseNames.map((name2) => ({ name: name2 })),
@@ -111390,7 +111650,10 @@ async function handleCreate(target, options2) {
   console.log(`  Directory: ${safeResolvedDir}`);
   console.log(`  Phases: ${result.phaseFiles.length}`);
   for (const f3 of result.phaseFiles) {
-    console.log(`    [ ] ${basename31(f3)}`);
+    console.log(`    [ ] ${basename32(f3)}`);
+  }
+  for (const line of buildPlanCreateReadReminder(result.planFile, result.phaseFiles)) {
+    console.log(line);
   }
   console.log();
 }
@@ -111414,7 +111677,7 @@ async function handleCheck(target, options2) {
     process.exitCode = 1;
     return;
   }
-  const planDir = dirname45(planFile);
+  const planDir = dirname46(planFile);
   let planStatus = "pending";
   try {
     const projectRoot = findProjectRoot(planDir);
@@ -111463,7 +111726,7 @@ async function handleUncheck(target, options2) {
     process.exitCode = 1;
     return;
   }
-  const planDir = dirname45(planFile);
+  const planDir = dirname46(planFile);
   try {
     const projectRoot = findProjectRoot(planDir);
     const summary = buildPlanSummary(planFile);
@@ -111502,7 +111765,7 @@ async function handleAddPhase(target, options2) {
   try {
     const result = addPhase(planFile, target, options2.after);
     try {
-      const planDir = dirname45(planFile);
+      const planDir = dirname46(planFile);
       const projectRoot = findProjectRoot(planDir);
       updateRegistryAddPhase({
         planDir,
@@ -111528,25 +111791,25 @@ async function handleAddPhase(target, options2) {
 // src/commands/plan/plan-command.ts
 function resolveTargetPath(target, baseDir) {
   if (!baseDir) {
-    return resolve54(target);
+    return resolve55(target);
   }
-  if (isAbsolute13(target)) {
-    return resolve54(target);
+  if (isAbsolute14(target)) {
+    return resolve55(target);
   }
-  const cwdCandidate = resolve54(target);
-  if (existsSync69(cwdCandidate)) {
+  const cwdCandidate = resolve55(target);
+  if (existsSync70(cwdCandidate)) {
     return cwdCandidate;
   }
-  return resolve54(baseDir, target);
+  return resolve55(baseDir, target);
 }
 function resolvePlanFile(target, baseDir) {
-  const t = target ? resolveTargetPath(target, baseDir) : baseDir ? resolve54(baseDir) : process.cwd();
-  if (existsSync69(t)) {
+  const t = target ? resolveTargetPath(target, baseDir) : baseDir ? resolve55(baseDir) : process.cwd();
+  if (existsSync70(t)) {
     const stat24 = statSync12(t);
     if (stat24.isFile())
       return t;
     const candidate = join148(t, "plan.md");
-    if (existsSync69(candidate))
+    if (existsSync70(candidate))
       return candidate;
   }
   if (!target && !baseDir) {
@@ -111554,9 +111817,9 @@ function resolvePlanFile(target, baseDir) {
     const root = parse7(dir).root;
     while (dir !== root) {
       const candidate = join148(dir, "plan.md");
-      if (existsSync69(candidate))
+      if (existsSync70(candidate))
         return candidate;
-      dir = dirname46(dir);
+      dir = dirname47(dir);
     }
   }
   return null;
@@ -111604,7 +111867,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 && existsSync69(resolve54(resolvedAction));
+    const existsOnDisk = !looksLikePath && existsSync70(resolve55(resolvedAction));
     if (looksLikePath || existsOnDisk) {
       resolvedTarget = resolvedAction;
       resolvedAction = undefined;
@@ -111646,13 +111909,13 @@ init_claudekit_data2();
 init_logger();
 init_safe_prompts();
 var import_picocolors34 = __toESM(require_picocolors(), 1);
-import { existsSync as existsSync70 } from "node:fs";
-import { resolve as resolve55 } from "node:path";
+import { existsSync as existsSync71 } from "node:fs";
+import { resolve as resolve56 } from "node:path";
 async function handleAdd(projectPath, options2) {
   logger.debug(`Adding project: ${projectPath}, options: ${JSON.stringify(options2)}`);
   intro("Add Project");
-  const absolutePath = resolve55(projectPath);
-  if (!existsSync70(absolutePath)) {
+  const absolutePath = resolve56(projectPath);
+  if (!existsSync71(absolutePath)) {
     log.error(`Path does not exist: ${absolutePath}`);
     process.exitCode = 1;
     return;
@@ -112075,7 +112338,7 @@ import { readFile as readFile66 } from "node:fs/promises";
 import { join as join150 } from "node:path";
 
 // src/commands/skills/installed-skills-inventory.ts
-import { join as join149, resolve as resolve56 } from "node:path";
+import { join as join149, resolve as resolve57 } from "node:path";
 init_path_resolver();
 var SCOPE_SORT_ORDER = {
   project: 0,
@@ -112083,8 +112346,8 @@ var SCOPE_SORT_ORDER = {
 };
 async function getActiveClaudeSkillInstallations(options2 = {}) {
   const projectDir = options2.projectDir ?? process.cwd();
-  const globalDir = resolve56(options2.globalDir ?? PathResolver.getGlobalKitDir());
-  const projectClaudeDir = resolve56(projectDir, ".claude");
+  const globalDir = resolve57(options2.globalDir ?? PathResolver.getGlobalKitDir());
+  const projectClaudeDir = resolve57(projectDir, ".claude");
   const projectScopeAliasesGlobal = projectClaudeDir === globalDir;
   const [projectSkills, globalSkills] = await Promise.all([
     projectScopeAliasesGlobal ? Promise.resolve([]) : scanSkills2(join149(projectClaudeDir, "skills")),
@@ -112830,8 +113093,8 @@ async function detectInstallations() {
 }
 
 // src/commands/uninstall/removal-handler.ts
-import { readdirSync as readdirSync10, rmSync as rmSync5 } from "node:fs";
-import { basename as basename32, join as join152, resolve as resolve57, sep as sep13 } from "node:path";
+import { readdirSync as readdirSync11, rmSync as rmSync5 } from "node:fs";
+import { basename as basename33, join as join152, resolve as resolve58, sep as sep14 } from "node:path";
 init_logger();
 init_safe_prompts();
 init_safe_spinner();
@@ -112839,8 +113102,8 @@ var import_fs_extra42 = __toESM(require_lib(), 1);
 
 // src/commands/uninstall/analysis-handler.ts
 init_metadata_migration();
-import { readdirSync as readdirSync9, rmSync as rmSync4 } from "node:fs";
-import { dirname as dirname47, join as join151 } from "node:path";
+import { readdirSync as readdirSync10, rmSync as rmSync4 } from "node:fs";
+import { dirname as dirname48, join as join151 } from "node:path";
 init_logger();
 init_safe_prompts();
 var import_fs_extra41 = __toESM(require_lib(), 1);
@@ -112862,15 +113125,15 @@ function classifyFileByOwnership(ownership, forceOverwrite, deleteReason) {
 }
 async function cleanupEmptyDirectories3(filePath, installationRoot) {
   let cleaned = 0;
-  let currentDir = dirname47(filePath);
+  let currentDir = dirname48(filePath);
   while (currentDir !== installationRoot && currentDir.startsWith(installationRoot)) {
     try {
-      const entries = readdirSync9(currentDir);
+      const entries = readdirSync10(currentDir);
       if (entries.length === 0) {
         rmSync4(currentDir, { recursive: true });
         cleaned++;
         logger.debug(`Removed empty directory: ${currentDir}`);
-        currentDir = dirname47(currentDir);
+        currentDir = dirname48(currentDir);
       } else {
         break;
       }
@@ -113015,17 +113278,17 @@ async function restoreUninstallBackup(backup) {
 }
 async function isPathSafeToRemove(filePath, baseDir) {
   try {
-    const resolvedPath = resolve57(filePath);
-    const resolvedBase = resolve57(baseDir);
-    if (!resolvedPath.startsWith(resolvedBase + sep13) && resolvedPath !== resolvedBase) {
+    const resolvedPath = resolve58(filePath);
+    const resolvedBase = resolve58(baseDir);
+    if (!resolvedPath.startsWith(resolvedBase + sep14) && resolvedPath !== resolvedBase) {
       logger.debug(`Path outside installation directory: ${filePath}`);
       return false;
     }
     const stats = await import_fs_extra42.lstat(filePath);
     if (stats.isSymbolicLink()) {
       const realPath = await import_fs_extra42.realpath(filePath);
-      const resolvedReal = resolve57(realPath);
-      if (!resolvedReal.startsWith(resolvedBase + sep13) && resolvedReal !== resolvedBase) {
+      const resolvedReal = resolve58(realPath);
+      if (!resolvedReal.startsWith(resolvedBase + sep14) && resolvedReal !== resolvedBase) {
         logger.debug(`Symlink points outside installation directory: ${filePath} -> ${realPath}`);
         return false;
       }
@@ -113070,7 +113333,7 @@ async function removeInstallations(installations, options2) {
             scope: installation.type,
             kit: options2.kit
           });
-          await cleanupOldDestructiveOperationBackups(undefined, basename32(backup.backupDir));
+          await cleanupOldDestructiveOperationBackups(undefined, basename33(backup.backupDir));
           backupSpinner.succeed(`Recovery backup saved to ${backup.backupDir}`);
         } catch (error) {
           backupSpinner.fail("Failed to create recovery backup");
@@ -113109,7 +113372,7 @@ async function removeInstallations(installations, options2) {
           }
         }
         try {
-          const remaining = readdirSync10(installation.path);
+          const remaining = readdirSync11(installation.path);
           if (remaining.length === 0) {
             rmSync5(installation.path, { recursive: true });
             logger.debug(`Removed empty installation directory: ${installation.path}`);
@@ -113491,7 +113754,7 @@ ${import_picocolors40.default.bold(import_picocolors40.default.cyan(result.kitCo
 
 // src/commands/watch/watch-command.ts
 init_logger();
-import { existsSync as existsSync76 } from "node:fs";
+import { existsSync as existsSync77 } from "node:fs";
 import { rm as rm19 } from "node:fs/promises";
 import { join as join159 } from "node:path";
 var import_picocolors41 = __toESM(require_picocolors(), 1);
@@ -114790,14 +115053,14 @@ function cleanExpiredIssues(state, ttlDays) {
 init_ck_config_manager();
 init_file_io();
 init_logger();
-import { existsSync as existsSync72 } from "node:fs";
+import { existsSync as existsSync73 } from "node:fs";
 import { mkdir as mkdir41, readFile as readFile68 } from "node:fs/promises";
-import { dirname as dirname48 } from "node:path";
+import { dirname as dirname49 } from "node:path";
 var PROCESSED_ISSUES_CAP = 500;
 async function readCkJson(projectDir) {
   const configPath = CkConfigManager.getProjectConfigPath(projectDir);
   try {
-    if (!existsSync72(configPath))
+    if (!existsSync73(configPath))
       return {};
     const content = await readFile68(configPath, "utf-8");
     return JSON.parse(content);
@@ -114822,8 +115085,8 @@ async function loadWatchState(projectDir) {
 }
 async function saveWatchState(projectDir, state) {
   const configPath = CkConfigManager.getProjectConfigPath(projectDir);
-  const configDir = dirname48(configPath);
-  if (!existsSync72(configDir)) {
+  const configDir = dirname49(configPath);
+  if (!existsSync73(configDir)) {
     await mkdir41(configDir, { recursive: true });
   }
   const raw2 = await readCkJson(projectDir);
@@ -114950,7 +115213,7 @@ async function processImplementationQueue(state, config, setup, options2, watchL
 // src/commands/watch/phases/repo-scanner.ts
 init_logger();
 import { spawnSync as spawnSync7 } from "node:child_process";
-import { existsSync as existsSync73 } from "node:fs";
+import { existsSync as existsSync74 } from "node:fs";
 import { readdir as readdir46, stat as stat25 } from "node:fs/promises";
 import { join as join156 } from "node:path";
 async function scanForRepos(parentDir) {
@@ -114964,7 +115227,7 @@ async function scanForRepos(parentDir) {
     if (!entryStat.isDirectory())
       continue;
     const gitDir = join156(fullPath, ".git");
-    if (!existsSync73(gitDir))
+    if (!existsSync74(gitDir))
       continue;
     const result = spawnSync7("gh", ["repo", "view", "--json", "owner,name"], {
       encoding: "utf-8",
@@ -114988,8 +115251,8 @@ async function scanForRepos(parentDir) {
 // src/commands/watch/phases/setup-validator.ts
 init_logger();
 import { spawnSync as spawnSync8 } from "node:child_process";
-import { existsSync as existsSync74 } from "node:fs";
-import { homedir as homedir53 } from "node:os";
+import { existsSync as existsSync75 } from "node:fs";
+import { homedir as homedir54 } from "node:os";
 import { join as join157 } from "node:path";
 async function validateSetup(cwd2) {
   const workDir = cwd2 ?? process.cwd();
@@ -115021,8 +115284,8 @@ Run this command from a directory with a GitHub remote.`);
   } catch {
     throw new Error(`Failed to parse repository info: ${ghRepo.stdout}`);
   }
-  const skillsPath = join157(homedir53(), ".claude", "skills");
-  const skillsAvailable = existsSync74(skillsPath);
+  const skillsPath = join157(homedir54(), ".claude", "skills");
+  const skillsAvailable = existsSync75(skillsPath);
   if (!skillsAvailable) {
     logger.warning(`ClaudeKit Engineer skills not found at ${skillsPath}`);
   }
@@ -115038,7 +115301,7 @@ Run this command from a directory with a GitHub remote.`);
 init_logger();
 init_path_resolver();
 import { createWriteStream as createWriteStream3, statSync as statSync13 } from "node:fs";
-import { existsSync as existsSync75 } from "node:fs";
+import { existsSync as existsSync76 } from "node:fs";
 import { mkdir as mkdir42, rename as rename15 } from "node:fs/promises";
 import { join as join158 } from "node:path";
 
@@ -115053,7 +115316,7 @@ class WatchLogger {
   }
   async init() {
     try {
-      if (!existsSync75(this.logDir)) {
+      if (!existsSync76(this.logDir)) {
         await mkdir42(this.logDir, { recursive: true });
       }
       const dateStr = formatDate(new Date);
@@ -115239,7 +115502,7 @@ async function watchCommand(options2) {
 }
 async function discoverRepos(options2, watchLog) {
   const cwd2 = process.cwd();
-  const isGitRepo = existsSync76(join159(cwd2, ".git"));
+  const isGitRepo = existsSync77(join159(cwd2, ".git"));
   if (options2.force) {
     await forceRemoveLock(watchLog);
   }
@@ -115496,7 +115759,7 @@ function registerCommands(cli) {
 // src/cli/version-display.ts
 init_package();
 init_config_version_checker();
-import { existsSync as existsSync88, readFileSync as readFileSync22 } from "node:fs";
+import { existsSync as existsSync89, readFileSync as readFileSync22 } from "node:fs";
 import { join as join171 } from "node:path";
 
 // src/domains/versioning/version-checker.ts
@@ -115510,7 +115773,7 @@ init_types3();
 // src/domains/versioning/version-cache.ts
 init_logger();
 init_path_resolver();
-import { existsSync as existsSync87 } from "node:fs";
+import { existsSync as existsSync88 } from "node:fs";
 import { mkdir as mkdir43, readFile as readFile70, writeFile as writeFile42 } from "node:fs/promises";
 import { join as join170 } from "node:path";
 
@@ -115524,7 +115787,7 @@ class VersionCacheManager {
   static async load() {
     const cacheFile = VersionCacheManager.getCacheFile();
     try {
-      if (!existsSync87(cacheFile)) {
+      if (!existsSync88(cacheFile)) {
         logger.debug("Version check cache not found");
         return null;
       }
@@ -115545,7 +115808,7 @@ class VersionCacheManager {
     const cacheFile = VersionCacheManager.getCacheFile();
     const cacheDir = PathResolver.getCacheDir(false);
     try {
-      if (!existsSync87(cacheDir)) {
+      if (!existsSync88(cacheDir)) {
         await mkdir43(cacheDir, { recursive: true, mode: 448 });
       }
       await writeFile42(cacheFile, JSON.stringify(cache5, null, 2), "utf-8");
@@ -115567,7 +115830,7 @@ class VersionCacheManager {
   static async clear() {
     const cacheFile = VersionCacheManager.getCacheFile();
     try {
-      if (existsSync87(cacheFile)) {
+      if (existsSync88(cacheFile)) {
         const fs20 = await import("node:fs/promises");
         await fs20.unlink(cacheFile);
         logger.debug("Version check cache cleared");
@@ -115834,7 +116097,7 @@ async function displayVersion() {
   const prefix = PathResolver.getPathPrefix(false);
   const localMetadataPath = prefix ? join171(process.cwd(), prefix, "metadata.json") : join171(process.cwd(), "metadata.json");
   const isLocalSameAsGlobal = localMetadataPath === globalMetadataPath;
-  if (!isLocalSameAsGlobal && existsSync88(localMetadataPath)) {
+  if (!isLocalSameAsGlobal && existsSync89(localMetadataPath)) {
     try {
       const rawMetadata = JSON.parse(readFileSync22(localMetadataPath, "utf-8"));
       const metadata = MetadataSchema.parse(rawMetadata);
@@ -115848,7 +116111,7 @@ async function displayVersion() {
       logger.verbose("Failed to parse local metadata.json", { error });
     }
   }
-  if (existsSync88(globalMetadataPath)) {
+  if (existsSync89(globalMetadataPath)) {
     try {
       const rawMetadata = JSON.parse(readFileSync22(globalMetadataPath, "utf-8"));
       const metadata = MetadataSchema.parse(rawMetadata);