claudekit-cli 3.41.3 → 3.41.4

package/dist/index.js

@@ -43451,10 +43451,69 @@ function notFoundError(type, name, hint) {
 }
 
 // src/shared/command-normalizer.ts
+import { homedir as homedir12 } from "node:os";
+import { join as join16 } from "node:path";
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function normalizeCommandRoot(root) {
+  return root.replace(/\\/g, "/").replace(/\/+$/, "");
+}
+function formatCanonicalClaudeCommand(nodePrefix, root, relativePath, suffix = "") {
+  const normalizedRoot = normalizeCommandRoot(root);
+  let normalizedRelativePath = relativePath.replace(/\\/g, "/").replace(/^\/+/, "");
+  if (normalizedRoot !== "$HOME" && normalizedRoot !== "$CLAUDE_PROJECT_DIR") {
+    normalizedRelativePath = normalizedRelativePath.replace(/^\.claude\//, "");
+  }
+  return normalizedRoot === "$CLAUDE_PROJECT_DIR" ? `${nodePrefix}"${normalizedRoot}"/${normalizedRelativePath}${suffix}` : `${nodePrefix}"${normalizedRoot}/${normalizedRelativePath}"${suffix}`;
+}
+function isNodeClaudeCommand(cmd) {
+  if (!cmd)
+    return false;
+  return /^\s*node\s+/.test(cmd) && (cmd.includes(".claude/") || cmd.includes(".claude\\"));
+}
+function repairClaudeNodeCommandPath(cmd, root) {
+  if (!cmd || !isNodeClaudeCommand(cmd)) {
+    return { command: cmd ?? "", changed: false, issue: null };
+  }
+  const bareRelativeMatch = cmd.match(/^(node\s+)(?:\.\/)?(\.claude[/\\][^\s"]+)(.*)$/);
+  if (bareRelativeMatch) {
+    const [, nodePrefix, relativePath, suffix] = bareRelativeMatch;
+    const command = formatCanonicalClaudeCommand(nodePrefix, root, relativePath, suffix);
+    return { command, changed: command !== cmd, issue: "raw-relative" };
+  }
+  const embeddedQuotedMatch = cmd.match(/^(node\s+)"(?:\$HOME|\$CLAUDE_PROJECT_DIR|%USERPROFILE%|%CLAUDE_PROJECT_DIR%)[/\\](\.claude[/\\][^"]+)"(.*)$/);
+  if (embeddedQuotedMatch) {
+    const [, nodePrefix, relativePath, suffix] = embeddedQuotedMatch;
+    const command = formatCanonicalClaudeCommand(nodePrefix, root, relativePath, suffix);
+    return { command, changed: command !== cmd, issue: "invalid-format" };
+  }
+  const varOnlyQuotedMatch = cmd.match(/^(node\s+)"(?:\$HOME|\$CLAUDE_PROJECT_DIR|%USERPROFILE%|%CLAUDE_PROJECT_DIR%)"[/\\](\.claude[/\\][^\s"]+)(.*)$/);
+  if (varOnlyQuotedMatch) {
+    const [, nodePrefix, relativePath, suffix] = varOnlyQuotedMatch;
+    const command = formatCanonicalClaudeCommand(nodePrefix, root, relativePath, suffix);
+    return { command, changed: command !== cmd, issue: "invalid-format" };
+  }
+  const tildeMatch = cmd.match(/^(node\s+)~[/\\](\.claude[/\\][^\s"]+)(.*)$/);
+  if (tildeMatch) {
+    const [, nodePrefix, relativePath, suffix] = tildeMatch;
+    const command = formatCanonicalClaudeCommand(nodePrefix, root, relativePath, suffix);
+    return { command, changed: command !== cmd, issue: "invalid-format" };
+  }
+  const unquotedMatch = cmd.match(/^(node\s+)(?:\$HOME|\$CLAUDE_PROJECT_DIR|%USERPROFILE%|%CLAUDE_PROJECT_DIR%)[/\\](\.claude[/\\][^\s"]+)(.*)$/);
+  if (unquotedMatch) {
+    const [, nodePrefix, relativePath, suffix] = unquotedMatch;
+    const command = formatCanonicalClaudeCommand(nodePrefix, root, relativePath, suffix);
+    return { command, changed: command !== cmd, issue: "invalid-format" };
+  }
+  return { command: cmd, changed: false, issue: null };
+}
 function normalizeCommand(cmd) {
   if (!cmd)
     return "";
   let normalized = cmd;
+  const globalKitDir = PathResolver.getGlobalKitDir().replace(/\\/g, "/").replace(/\/+$/, "");
+  const defaultGlobalKitDir = join16(homedir12(), ".claude").replace(/\\/g, "/");
   normalized = normalized.replace(/"/g, "");
   normalized = normalized.replace(/~\//g, "$HOME/");
   normalized = normalized.replace(/\$CLAUDE_PROJECT_DIR/g, "$HOME");
@@ -43463,9 +43522,17 @@ function normalizeCommand(cmd) {
   normalized = normalized.replace(/%CLAUDE_PROJECT_DIR%/g, "$HOME");
   normalized = normalized.replace(/(^|\s)(?:\.\/)?\.claude\//g, "$1$HOME/.claude/");
   normalized = normalized.replace(/\\/g, "/");
+  const globalPaths = [...new Set([globalKitDir, defaultGlobalKitDir].filter(Boolean))];
+  for (const absoluteGlobalPath of globalPaths) {
+    const absoluteGlobalPathPattern = new RegExp(escapeRegex(absoluteGlobalPath), "g");
+    normalized = normalized.replace(absoluteGlobalPathPattern, "$HOME/.claude");
+  }
   normalized = normalized.replace(/\s+/g, " ").trim();
   return normalized;
 }
+var init_command_normalizer = __esm(() => {
+  init_path_resolver();
+});
 
 // src/shared/parse-timeout.ts
 function parseTimeoutMs(rawValue, fallback2, min = 500, max = 60000) {
@@ -43495,6 +43562,7 @@ var init_shared = __esm(() => {
   init_safe_spinner();
   init_safe_prompts();
   init_skip_directories();
+  init_command_normalizer();
 });
 
 // src/domains/config/merger/diff-calculator.ts
@@ -45202,7 +45270,7 @@ var require_lib3 = __commonJS((exports, module) => {
 
 // src/domains/config/merger/file-io.ts
 import { randomUUID } from "node:crypto";
-import { dirname as dirname5, join as join16 } from "node:path";
+import { dirname as dirname5, join as join17 } from "node:path";
 function stripBOM(content) {
   return content.charCodeAt(0) === 65279 ? content.slice(1) : content;
 }
@@ -45226,7 +45294,7 @@ async function readSettingsFile(filePath) {
 }
 async function atomicWriteFile(filePath, content) {
   const dir = dirname5(filePath);
-  const tempPath = join16(dir, `.settings-${randomUUID()}.tmp`);
+  const tempPath = join17(dir, `.settings-${randomUUID()}.tmp`);
   try {
     await import_fs_extra.writeFile(tempPath, content, "utf-8");
     await import_fs_extra.rename(tempPath, filePath);
@@ -45277,7 +45345,7 @@ var init_settings_merger = __esm(() => {
 });
 
 // src/domains/config/config-generator.ts
-import { join as join17 } from "node:path";
+import { join as join18 } from "node:path";
 async function generateEnvFile(targetDir, values) {
   const lines = [
     "# Generated by ClaudeKit CLI setup wizard",
@@ -45319,7 +45387,7 @@ async function generateEnvFile(targetDir, values) {
   for (const [key, value] of otherValues) {
     lines.push(`${key}=${value}`);
   }
-  const envPath = join17(targetDir, ".env");
+  const envPath = join18(targetDir, ".env");
   await import_fs_extra2.writeFile(envPath, `${lines.join(`
 `)}
 `, { mode: 384 });
@@ -46943,8 +47011,8 @@ var init_chokidar = __esm(() => {
 });
 
 // src/domains/web-server/file-watcher.ts
-import { homedir as homedir12 } from "node:os";
-import { join as join20 } from "node:path";
+import { homedir as homedir13 } from "node:os";
+import { join as join21 } from "node:path";
 
 class FileWatcher {
   watcher = null;
@@ -46966,16 +47034,16 @@ class FileWatcher {
   }
   getWatchPaths() {
     const paths = [];
-    const globalDir = join20(homedir12(), ".claudekit");
-    paths.push(join20(globalDir, "config.json"));
-    const globalKitDir = join20(homedir12(), ".claude");
-    paths.push(join20(globalKitDir, ".ck.json"));
-    paths.push(join20(globalKitDir, "settings.json"));
-    paths.push(join20(globalKitDir, "settings.local.json"));
+    const globalDir = join21(homedir13(), ".claudekit");
+    paths.push(join21(globalDir, "config.json"));
+    const globalKitDir = join21(homedir13(), ".claude");
+    paths.push(join21(globalKitDir, ".ck.json"));
+    paths.push(join21(globalKitDir, "settings.json"));
+    paths.push(join21(globalKitDir, "settings.local.json"));
     const cwd2 = process.cwd();
-    paths.push(join20(cwd2, ".claude", ".ck.json"));
-    paths.push(join20(cwd2, ".claude", "settings.json"));
-    paths.push(join20(cwd2, ".claude", "settings.local.json"));
+    paths.push(join21(cwd2, ".claude", ".ck.json"));
+    paths.push(join21(cwd2, ".claude", "settings.json"));
+    paths.push(join21(cwd2, ".claude", "settings.local.json"));
     return paths;
   }
   handleFileChange(path3, type) {
@@ -47018,8 +47086,8 @@ class FileWatcher {
     return path3.endsWith("config.json") || path3.endsWith(".ck.json") || path3.endsWith("settings.json") || path3.endsWith("settings.local.json");
   }
   getConfigScope(path3) {
-    const globalDir = join20(homedir12(), ".claudekit");
-    const globalKitDir = join20(homedir12(), ".claude");
+    const globalDir = join21(homedir13(), ".claudekit");
+    const globalKitDir = join21(homedir13(), ".claude");
     return path3.startsWith(globalDir) || path3.startsWith(globalKitDir) ? "global" : "local";
   }
   stop() {
@@ -47412,14 +47480,14 @@ var init_projects_registry = __esm(() => {
 
 // src/domains/claudekit-data/claude-projects-scanner.ts
 import { existsSync as existsSync13, readFileSync as readFileSync5, readdirSync as readdirSync2, statSync as statSync3 } from "node:fs";
-import { join as join21 } from "node:path";
+import { join as join22 } from "node:path";
 function extractProjectPath(claudeProjectDir) {
   try {
     const files = readdirSync2(claudeProjectDir);
     const jsonlFile = files.find((f3) => f3.endsWith(".jsonl"));
     if (!jsonlFile)
       return null;
-    const filePath = join21(claudeProjectDir, jsonlFile);
+    const filePath = join22(claudeProjectDir, jsonlFile);
     const content = readFileSync5(filePath, "utf-8");
     const lines = content.split(`
 `).slice(0, 10);
@@ -47439,7 +47507,7 @@ function extractProjectPath(claudeProjectDir) {
   }
 }
 function scanClaudeProjects() {
-  const claudeProjectsDir = join21(PathResolver.getGlobalKitDir(), "projects");
+  const claudeProjectsDir = join22(PathResolver.getGlobalKitDir(), "projects");
   const now = Date.now();
   if (cachedDiscoveredProjects && cachedDiscoveredProjects.expiresAt > now) {
     return cachedDiscoveredProjects.projects;
@@ -47456,7 +47524,7 @@ function scanClaudeProjects() {
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
-      const projectDirPath = join21(claudeProjectsDir, entry.name);
+      const projectDirPath = join22(claudeProjectsDir, entry.name);
       const projectPath = extractProjectPath(projectDirPath);
       if (!projectPath) {
         logger.debug(`Could not extract path from: ${entry.name}`);
@@ -47510,15 +47578,15 @@ var init_claudekit_data2 = __esm(() => {
 // src/domains/web-server/routes/action-routes.ts
 import { spawn, spawnSync } from "node:child_process";
 import { existsSync as existsSync14 } from "node:fs";
-import { homedir as homedir13 } from "node:os";
-import { join as join22, resolve as resolve6, sep as sep2 } from "node:path";
+import { homedir as homedir14 } from "node:os";
+import { join as join23, resolve as resolve6, sep as sep2 } from "node:path";
 function getWindowsPaths(...relativePaths) {
   const roots = [
     WINDOWS_PATHS.localAppData,
     WINDOWS_PATHS.programFiles,
     WINDOWS_PATHS.programFilesX86
   ];
-  return roots.flatMap((root) => relativePaths.map((rel) => join22(root, rel)));
+  return roots.flatMap((root) => relativePaths.map((rel) => join23(root, rel)));
 }
 function isCommandAvailable(command) {
   const checkCommand = isWindows() ? "where" : "which";
@@ -47790,7 +47858,7 @@ async function isActionPathAllowed(dirPath, projectId) {
   if (isPathInsideBase(dirPath, process.cwd())) {
     return true;
   }
-  return isPathInsideBase(dirPath, homedir13());
+  return isPathInsideBase(dirPath, homedir14());
 }
 function buildSystemTerminalCommand(dirPath) {
   if (isMacOS()) {
@@ -48129,7 +48197,7 @@ var init_action_routes = __esm(() => {
     projectId: exports_external.string().min(1).max(256).optional()
   }).strict();
   WINDOWS_PATHS = {
-    localAppData: process.env.LOCALAPPDATA || join22(homedir13(), "AppData", "Local"),
+    localAppData: process.env.LOCALAPPDATA || join23(homedir14(), "AppData", "Local"),
     programFiles: process.env.ProgramFiles || "C:\\Program Files",
     programFilesX86: process.env["ProgramFiles(x86)"] || "C:\\Program Files (x86)"
   };
@@ -48150,7 +48218,7 @@ var init_action_routes = __esm(() => {
       openMode: "open-directory",
       capabilities: ["open-directory", "run-command"],
       macAppName: "iTerm",
-      macAppPaths: ["/Applications/iTerm.app", join22(homedir13(), "Applications", "iTerm.app")]
+      macAppPaths: ["/Applications/iTerm.app", join23(homedir14(), "Applications", "iTerm.app")]
     },
     {
       id: "warp",
@@ -48161,7 +48229,7 @@ var init_action_routes = __esm(() => {
       capabilities: ["open-directory", "uri-scheme"],
       commands: ["warp"],
       macAppName: "Warp",
-      macAppPaths: ["/Applications/Warp.app", join22(homedir13(), "Applications", "Warp.app")],
+      macAppPaths: ["/Applications/Warp.app", join23(homedir14(), "Applications", "Warp.app")],
       windowsAppPaths: getWindowsPaths("Warp\\Warp.exe"),
       linuxAppPaths: ["/usr/bin/warp", "/usr/local/bin/warp"]
     },
@@ -48173,7 +48241,7 @@ var init_action_routes = __esm(() => {
       openMode: "open-directory",
       capabilities: ["open-directory", "run-command"],
       commands: ["wt"],
-      windowsAppPaths: [join22(WINDOWS_PATHS.localAppData, "Microsoft", "WindowsApps", "wt.exe")]
+      windowsAppPaths: [join23(WINDOWS_PATHS.localAppData, "Microsoft", "WindowsApps", "wt.exe")]
     },
     {
       id: "wezterm",
@@ -48184,7 +48252,7 @@ var init_action_routes = __esm(() => {
       capabilities: ["open-directory"],
       commands: ["wezterm"],
       macAppName: "WezTerm",
-      macAppPaths: ["/Applications/WezTerm.app", join22(homedir13(), "Applications", "WezTerm.app")],
+      macAppPaths: ["/Applications/WezTerm.app", join23(homedir14(), "Applications", "WezTerm.app")],
       windowsAppPaths: getWindowsPaths("WezTerm\\wezterm-gui.exe", "WezTerm\\wezterm.exe"),
       linuxAppPaths: ["/usr/bin/wezterm", "/usr/local/bin/wezterm"]
     },
@@ -48197,7 +48265,7 @@ var init_action_routes = __esm(() => {
       capabilities: ["open-directory"],
       commands: ["kitty"],
       macAppName: "kitty",
-      macAppPaths: ["/Applications/kitty.app", join22(homedir13(), "Applications", "kitty.app")],
+      macAppPaths: ["/Applications/kitty.app", join23(homedir14(), "Applications", "kitty.app")],
       windowsAppPaths: getWindowsPaths("kitty\\kitty.exe"),
       linuxAppPaths: ["/usr/bin/kitty", "/usr/local/bin/kitty"]
     },
@@ -48210,7 +48278,7 @@ var init_action_routes = __esm(() => {
       capabilities: ["open-directory"],
       commands: ["alacritty"],
       macAppName: "Alacritty",
-      macAppPaths: ["/Applications/Alacritty.app", join22(homedir13(), "Applications", "Alacritty.app")],
+      macAppPaths: ["/Applications/Alacritty.app", join23(homedir14(), "Applications", "Alacritty.app")],
       windowsAppPaths: getWindowsPaths("Alacritty\\alacritty.exe"),
       linuxAppPaths: ["/usr/bin/alacritty", "/usr/local/bin/alacritty"]
     },
@@ -48283,7 +48351,7 @@ var init_action_routes = __esm(() => {
       capabilities: ["open-app"],
       commands: ["termius"],
       macAppName: "Termius",
-      macAppPaths: ["/Applications/Termius.app", join22(homedir13(), "Applications", "Termius.app")],
+      macAppPaths: ["/Applications/Termius.app", join23(homedir14(), "Applications", "Termius.app")],
       windowsAppPaths: getWindowsPaths("Termius\\Termius.exe"),
       linuxAppPaths: ["/usr/bin/termius"]
     },
@@ -48306,7 +48374,7 @@ var init_action_routes = __esm(() => {
       macAppName: "Visual Studio Code",
       macAppPaths: [
         "/Applications/Visual Studio Code.app",
-        join22(homedir13(), "Applications", "Visual Studio Code.app")
+        join23(homedir14(), "Applications", "Visual Studio Code.app")
       ],
       windowsAppPaths: getWindowsPaths("Programs\\Microsoft VS Code\\Code.exe", "Microsoft VS Code\\Code.exe"),
       linuxAppPaths: ["/usr/bin/code", "/snap/bin/code"]
@@ -48320,7 +48388,7 @@ var init_action_routes = __esm(() => {
       capabilities: ["open-directory"],
       commands: ["cursor"],
       macAppName: "Cursor",
-      macAppPaths: ["/Applications/Cursor.app", join22(homedir13(), "Applications", "Cursor.app")],
+      macAppPaths: ["/Applications/Cursor.app", join23(homedir14(), "Applications", "Cursor.app")],
       windowsAppPaths: getWindowsPaths("Programs\\Cursor\\Cursor.exe", "Cursor\\Cursor.exe"),
       linuxAppPaths: ["/usr/bin/cursor"]
     },
@@ -48333,7 +48401,7 @@ var init_action_routes = __esm(() => {
       capabilities: ["open-directory"],
       commands: ["windsurf"],
       macAppName: "Windsurf",
-      macAppPaths: ["/Applications/Windsurf.app", join22(homedir13(), "Applications", "Windsurf.app")],
+      macAppPaths: ["/Applications/Windsurf.app", join23(homedir14(), "Applications", "Windsurf.app")],
       windowsAppPaths: getWindowsPaths("Programs\\Windsurf\\Windsurf.exe", "Windsurf\\Windsurf.exe"),
       linuxAppPaths: ["/usr/bin/windsurf"]
     },
@@ -48348,11 +48416,11 @@ var init_action_routes = __esm(() => {
       macAppName: "Antigravity",
       macAppPaths: [
         "/Applications/Antigravity.app",
-        join22(homedir13(), "Applications", "Antigravity.app")
+        join23(homedir14(), "Applications", "Antigravity.app")
       ],
       windowsAppPaths: getWindowsPaths("Programs\\Antigravity\\Antigravity.exe"),
       linuxAppPaths: ["/usr/bin/antigravity"],
-      fallbackDetectionPaths: [join22(homedir13(), ".gemini", "antigravity")]
+      fallbackDetectionPaths: [join23(homedir14(), ".gemini", "antigravity")]
     },
     {
       id: "zed",
@@ -48363,7 +48431,7 @@ var init_action_routes = __esm(() => {
       capabilities: ["open-directory"],
       commands: ["zed"],
       macAppName: "Zed",
-      macAppPaths: ["/Applications/Zed.app", join22(homedir13(), "Applications", "Zed.app")],
+      macAppPaths: ["/Applications/Zed.app", join23(homedir14(), "Applications", "Zed.app")],
       windowsAppPaths: getWindowsPaths("Zed\\Zed.exe"),
       linuxAppPaths: ["/usr/bin/zed", "/usr/local/bin/zed"]
     },
@@ -48378,7 +48446,7 @@ var init_action_routes = __esm(() => {
       macAppName: "Sublime Text",
       macAppPaths: [
         "/Applications/Sublime Text.app",
-        join22(homedir13(), "Applications", "Sublime Text.app")
+        join23(homedir14(), "Applications", "Sublime Text.app")
       ],
       windowsAppPaths: getWindowsPaths("Sublime Text\\sublime_text.exe"),
       linuxAppPaths: ["/usr/bin/subl", "/snap/bin/subl"]
@@ -49001,7 +49069,7 @@ var init_ck_config_schema = __esm(() => {
 // src/domains/web-server/routes/ck-config-routes.ts
 import { existsSync as existsSync15 } from "node:fs";
 import { readFile as readFile11 } from "node:fs/promises";
-import { join as join23 } from "node:path";
+import { join as join24 } from "node:path";
 async function resolveProjectDir(projectId) {
   if (!projectId)
     return null;
@@ -49143,7 +49211,7 @@ function registerCkConfigRoutes(app) {
   });
   app.get("/api/metadata/global", async (_req, res) => {
     try {
-      const metadataPath = join23(PathResolver.getGlobalKitDir(), "metadata.json");
+      const metadataPath = join24(PathResolver.getGlobalKitDir(), "metadata.json");
       let metadata = {};
       if (existsSync15(metadataPath)) {
         const content = await readFile11(metadataPath, "utf-8");
@@ -49223,11 +49291,11 @@ var init_types5 = __esm(() => {
 
 // src/services/claude-data/history-parser.ts
 import { createReadStream, statSync as statSync4 } from "node:fs";
-import { homedir as homedir14 } from "node:os";
-import { join as join24 } from "node:path";
+import { homedir as homedir15 } from "node:os";
+import { join as join25 } from "node:path";
 import { createInterface as createInterface2 } from "node:readline";
 function getHistoryPath() {
-  return process.env.CLAUDE_HISTORY_PATH ?? join24(homedir14(), ".claude", "history.jsonl");
+  return process.env.CLAUDE_HISTORY_PATH ?? join25(homedir15(), ".claude", "history.jsonl");
 }
 function emptyResult(parseTimeMs, error) {
   return { projects: [], totalEntries: 0, errorCount: 0, parseTimeMs, error };
@@ -49311,7 +49379,7 @@ var init_history_parser = __esm(() => {
 // src/services/claude-data/session-parser.ts
 import { existsSync as existsSync16 } from "node:fs";
 import { readFile as readFile12, readdir as readdir5, stat as stat4 } from "node:fs/promises";
-import { join as join25 } from "node:path";
+import { join as join26 } from "node:path";
 function formatTimestamp(date) {
   const now = new Date;
   const isToday = date.toDateString() === now.toDateString();
@@ -49408,7 +49476,7 @@ async function getProjectSessions(projectDir, limit = 10) {
     const files = await readdir5(projectDir);
     const jsonlFiles = files.filter((f3) => f3.endsWith(".jsonl"));
     const fileStats = await Promise.all(jsonlFiles.map(async (file) => {
-      const filePath = join25(projectDir, file);
+      const filePath = join26(projectDir, file);
       const fileStat = await stat4(filePath).catch(() => null);
       return { file, filePath, mtime: fileStat?.mtime || new Date(0) };
     }));
@@ -49425,10 +49493,10 @@ var init_session_parser = () => {};
 // src/services/claude-data/skill-scanner.ts
 import { existsSync as existsSync17 } from "node:fs";
 import { readFile as readFile13, readdir as readdir6 } from "node:fs/promises";
-import { homedir as homedir15 } from "node:os";
-import { join as join26 } from "node:path";
+import { homedir as homedir16 } from "node:os";
+import { join as join27 } from "node:path";
 async function getCkSkillMetadata(scope) {
-  const metaPath = scope === "global" ? join26(homedir15(), ".claude", "metadata.json") : join26(process.cwd(), ".claude", "metadata.json");
+  const metaPath = scope === "global" ? join27(homedir16(), ".claude", "metadata.json") : join27(process.cwd(), ".claude", "metadata.json");
   if (!existsSync17(metaPath))
     return null;
   const result = new Map;
@@ -49464,7 +49532,7 @@ async function getCkSkillMetadata(scope) {
   return result.size > 0 ? result : null;
 }
 async function getSkillMetadata(skillPath) {
-  const skillMdPath = join26(skillPath, "SKILL.md");
+  const skillMdPath = join27(skillPath, "SKILL.md");
   if (!existsSync17(skillMdPath))
     return null;
   try {
@@ -49513,8 +49581,8 @@ async function scanSkills() {
         continue;
       if (ckMeta && !ckMeta.has(entry))
         continue;
-      const entryPath = join26(skillsDir, entry);
-      const skillMdPath = join26(entryPath, "SKILL.md");
+      const entryPath = join27(skillsDir, entry);
+      const skillMdPath = join27(entryPath, "SKILL.md");
       if (!existsSync17(skillMdPath))
         continue;
       const frontmatter = await getSkillMetadata(entryPath);
@@ -49559,17 +49627,17 @@ async function scanSkills() {
 var import_gray_matter4, skillsDir, SKIP_DIRS2;
 var init_skill_scanner = __esm(() => {
   import_gray_matter4 = __toESM(require_gray_matter(), 1);
-  skillsDir = join26(homedir15(), ".claude", "skills");
+  skillsDir = join27(homedir16(), ".claude", "skills");
   SKIP_DIRS2 = [".venv", "scripts", "__pycache__", "node_modules", ".git", "common"];
 });
 
 // src/services/claude-data/settings-reader.ts
 import { existsSync as existsSync18 } from "node:fs";
 import { copyFile as copyFile2, mkdir as mkdir7, readFile as readFile14, rename as rename4, rm as rm4, writeFile as writeFile10 } from "node:fs/promises";
-import { homedir as homedir16 } from "node:os";
-import { join as join27 } from "node:path";
+import { homedir as homedir17 } from "node:os";
+import { join as join28 } from "node:path";
 function getSettingsPath() {
-  return join27(claudeDir, settingsFilename);
+  return join28(claudeDir, settingsFilename);
 }
 async function readSettings() {
   const settingsPath = getSettingsPath();
@@ -49591,7 +49659,7 @@ async function backupAndSaveSettings(settings) {
   let backupPath = null;
   if (existsSync18(settingsPath)) {
     await mkdir7(settingsBackupDir, { recursive: true });
-    backupPath = join27(settingsBackupDir, `${getBackupTimestamp()}-${settingsFilename}`);
+    backupPath = join28(settingsBackupDir, `${getBackupTimestamp()}-${settingsFilename}`);
     await copyFile2(settingsPath, backupPath);
   }
   const tempPath = `${settingsPath}.tmp-${Date.now()}`;
@@ -49628,13 +49696,13 @@ function countMcpServers(settings) {
 }
 var claudeDir, settingsFilename = "settings.json", settingsBackupDir;
 var init_settings_reader = __esm(() => {
-  claudeDir = join27(homedir16(), ".claude");
-  settingsBackupDir = join27(claudeDir, ".ck-backups", "settings");
+  claudeDir = join28(homedir17(), ".claude");
+  settingsBackupDir = join28(claudeDir, ".ck-backups", "settings");
 });
 
 // src/services/claude-data/hook-log-reader.ts
 import { open as open4 } from "node:fs/promises";
-import { join as join28 } from "node:path";
+import { join as join29 } from "node:path";
 function createEmptySummary() {
   return {
     total: 0,
@@ -49682,9 +49750,9 @@ async function resolveProjectPath(projectId) {
 }
 function getHookLogPath(scope, basePath) {
   if (scope === "global") {
-    return join28(basePath, "hooks", ".logs", "hook-log.jsonl");
+    return join29(basePath, "hooks", ".logs", "hook-log.jsonl");
   }
-  return join28(basePath, ".claude", "hooks", ".logs", "hook-log.jsonl");
+  return join29(basePath, ".claude", "hooks", ".logs", "hook-log.jsonl");
 }
 function parseEntry(line) {
   try {
@@ -49796,14 +49864,14 @@ var init_hook_log_reader = __esm(() => {
 });
 
 // src/services/claude-data/project-scanner.ts
-import { homedir as homedir17 } from "node:os";
-import { basename as basename6, join as join29, normalize as normalize3 } from "node:path";
+import { homedir as homedir18 } from "node:os";
+import { basename as basename6, join as join30, normalize as normalize3 } from "node:path";
 function encodePath(path3) {
   return path3.replace(/\//g, "-").replace(/^-/, "-");
 }
 var projectsDir;
 var init_project_scanner = __esm(() => {
-  projectsDir = join29(homedir17(), ".claude", "projects");
+  projectsDir = join30(homedir18(), ".claude", "projects");
 });
 
 // src/services/claude-data/project-discovery.ts
@@ -49898,10 +49966,10 @@ var init_project_discovery = __esm(() => {
 
 // src/services/claude-data/user-preferences.ts
 import { readFile as readFile15, stat as stat5 } from "node:fs/promises";
-import { homedir as homedir18 } from "node:os";
-import { join as join30 } from "node:path";
+import { homedir as homedir19 } from "node:os";
+import { join as join31 } from "node:path";
 function getPreferencesPath() {
-  return join30(homedir18(), ".claude.json");
+  return join31(homedir19(), ".claude.json");
 }
 async function readUserPreferences(filePath) {
   const path3 = filePath ?? getPreferencesPath();
@@ -50035,7 +50103,7 @@ var init_hook_log_routes = __esm(() => {
 // src/commands/migrate/skill-directory-installer.ts
 import { existsSync as existsSync19 } from "node:fs";
 import { cp, mkdir as mkdir8, rename as rename5, rm as rm5 } from "node:fs/promises";
-import { join as join31, resolve as resolve7 } from "node:path";
+import { join as join32, resolve as resolve7 } from "node:path";
 async function installSkillDirectories(skills, targetProviders, options2) {
   const results = [];
   for (const provider of targetProviders) {
@@ -50063,7 +50131,7 @@ async function installSkillDirectories(skills, targetProviders, options2) {
       continue;
     }
     for (const skill of skills) {
-      const targetDir = join31(basePath, skill.name);
+      const targetDir = join32(basePath, skill.name);
       if (resolve7(skill.path) === resolve7(targetDir)) {
         results.push({
           provider,
@@ -50139,12 +50207,12 @@ var init_skill_directory_installer = __esm(() => {
 // src/commands/portable/config-discovery.ts
 import { existsSync as existsSync20 } from "node:fs";
 import { readFile as readFile16, readdir as readdir7 } from "node:fs/promises";
-import { homedir as homedir19 } from "node:os";
-import { extname as extname3, join as join32, relative as relative5, sep as sep3 } from "node:path";
+import { homedir as homedir20 } from "node:os";
+import { extname as extname3, join as join33, relative as relative5, sep as sep3 } from "node:path";
 function resolveSourceOrigin(sourcePath) {
   if (!sourcePath)
     return "global";
-  const home5 = homedir19();
+  const home5 = homedir20();
   const cwd2 = process.cwd();
   if (cwd2 === home5)
     return "global";
@@ -50157,13 +50225,13 @@ function getConfigSourcePath() {
   return findExistingProjectConfigPath(process.cwd()) ?? getGlobalConfigSourcePath();
 }
 function getGlobalConfigSourcePath() {
-  return join32(homedir19(), ".claude", "CLAUDE.md");
+  return join33(homedir20(), ".claude", "CLAUDE.md");
 }
 function getRulesSourcePath() {
-  return findExistingProjectLayoutPath(process.cwd(), "rules") ?? join32(homedir19(), ".claude", "rules");
+  return findExistingProjectLayoutPath(process.cwd(), "rules") ?? join33(homedir20(), ".claude", "rules");
 }
 function getHooksSourcePath() {
-  return findExistingProjectLayoutPath(process.cwd(), "hooks") ?? join32(homedir19(), ".claude", "hooks");
+  return findExistingProjectLayoutPath(process.cwd(), "hooks") ?? join33(homedir20(), ".claude", "hooks");
 }
 async function discoverConfig(sourcePath) {
   const path3 = sourcePath ?? getConfigSourcePath();
@@ -50215,7 +50283,7 @@ async function discoverHooks(sourcePath) {
     }
     if (!HOOK_EXTENSIONS.has(ext))
       continue;
-    const fullPath = join32(path3, entry.name);
+    const fullPath = join33(path3, entry.name);
     try {
       const content = await readFile16(fullPath, "utf-8");
       items.push({
@@ -50241,7 +50309,7 @@ async function discoverPortableFiles(dir, baseDir, options2) {
   for (const entry of entries) {
     if (entry.name.startsWith("."))
       continue;
-    const fullPath = join32(dir, entry.name);
+    const fullPath = join33(dir, entry.name);
     if (entry.isSymbolicLink()) {
       continue;
     }
@@ -50285,7 +50353,7 @@ var init_config_discovery = __esm(() => {
 // src/commands/portable/hooks-settings-merger.ts
 import { existsSync as existsSync21, mkdirSync, renameSync, rmSync, writeFileSync as writeFileSync2 } from "node:fs";
 import { readFile as readFile17 } from "node:fs/promises";
-import { basename as basename8, dirname as dirname9, join as join33 } from "node:path";
+import { basename as basename8, dirname as dirname9, join as join34 } from "node:path";
 async function inspectHooksSettings(settingsPath) {
   try {
     if (!existsSync21(settingsPath)) {
@@ -50466,8 +50534,8 @@ async function migrateHooksSettings(options2) {
       targetSettingsPath: null
     };
   }
-  const resolvedSourcePath = isGlobal ? sourceSettingsPath : join33(process.cwd(), sourceSettingsPath);
-  const resolvedTargetPath = isGlobal ? targetSettingsPath : join33(process.cwd(), targetSettingsPath);
+  const resolvedSourcePath = isGlobal ? sourceSettingsPath : join34(process.cwd(), sourceSettingsPath);
+  const resolvedTargetPath = isGlobal ? targetSettingsPath : join34(process.cwd(), targetSettingsPath);
   const sourceHooksResult = await inspectHooksSettings(resolvedSourcePath);
   if (sourceHooksResult.status === "missing-file") {
     return {
@@ -53063,20 +53131,20 @@ var init_reconciler = __esm(() => {
 
 // src/commands/skills/skills-discovery.ts
 import { readFile as readFile20, readdir as readdir8, stat as stat6 } from "node:fs/promises";
-import { homedir as homedir20 } from "node:os";
-import { dirname as dirname10, join as join34 } from "node:path";
+import { homedir as homedir21 } from "node:os";
+import { dirname as dirname10, join as join35 } from "node:path";
 function getSkillSourcePath() {
-  const bundledRoot = join34(process.cwd(), "node_modules", "claudekit-engineer");
+  const bundledRoot = join35(process.cwd(), "node_modules", "claudekit-engineer");
   return findFirstExistingPath([
-    join34(bundledRoot, "skills"),
+    join35(bundledRoot, "skills"),
     ...getProjectLayoutCandidates(bundledRoot, "skills"),
     ...getProjectLayoutCandidates(process.cwd(), "skills"),
-    join34(home5, ".claude/skills")
+    join35(home5, ".claude/skills")
   ]);
 }
 async function hasSkillMd(dir) {
   try {
-    const skillPath = join34(dir, "SKILL.md");
+    const skillPath = join35(dir, "SKILL.md");
     const stats = await stat6(skillPath);
     return stats.isFile();
   } catch {
@@ -53124,9 +53192,9 @@ async function discoverSkills(sourcePath) {
       if (!entry.isDirectory() || SKIP_DIRS3.includes(entry.name)) {
         continue;
       }
-      const skillDir = join34(searchPath, entry.name);
+      const skillDir = join35(searchPath, entry.name);
       if (await hasSkillMd(skillDir)) {
-        const skill = await parseSkillMd(join34(skillDir, "SKILL.md"));
+        const skill = await parseSkillMd(join35(skillDir, "SKILL.md"));
         if (skill && !seenNames.has(skill.name)) {
           skills.push(skill);
           seenNames.add(skill.name);
@@ -53145,7 +53213,7 @@ var init_skills_discovery = __esm(() => {
   init_kit_layout();
   init_logger();
   import_gray_matter5 = __toESM(require_gray_matter(), 1);
-  home5 = homedir20();
+  home5 = homedir21();
   SKIP_DIRS3 = ["node_modules", ".git", "dist", "build", ".venv", "__pycache__", "common"];
 });
 
@@ -53248,8 +53316,8 @@ var init_migration_result_utils = __esm(() => {
 // src/domains/web-server/routes/migration-routes.ts
 import { existsSync as existsSync24 } from "node:fs";
 import { readFile as readFile21, rm as rm6 } from "node:fs/promises";
-import { homedir as homedir21 } from "node:os";
-import { basename as basename9, join as join35, resolve as resolve8 } from "node:path";
+import { homedir as homedir22 } from "node:os";
+import { basename as basename9, join as join36, resolve as resolve8 } from "node:path";
 function isDisallowedControlCode(codePoint) {
   return codePoint >= 0 && codePoint <= 8 || codePoint >= 11 && codePoint <= 31 || codePoint >= 127 && codePoint <= 159;
 }
@@ -53816,12 +53884,12 @@ function registerMigrationRoutes(app) {
       };
       const discovered = await discoverMigrationItems(includeAll);
       const cwd2 = process.cwd();
-      const home6 = homedir21();
+      const home6 = homedir22();
       res.status(200).json({
         cwd: cwd2,
         targetPaths: {
-          project: join35(cwd2, ".claude"),
-          global: join35(home6, ".claude")
+          project: join36(cwd2, ".claude"),
+          global: join36(home6, ".claude")
         },
         sourcePaths: discovered.sourcePaths,
         sourceOrigins: {
@@ -54850,12 +54918,12 @@ var init_plan_table_parser = __esm(() => {
 
 // src/domains/plan-parser/plan-scanner.ts
 import { existsSync as existsSync25, readdirSync as readdirSync3 } from "node:fs";
-import { join as join36 } from "node:path";
+import { join as join37 } from "node:path";
 function scanPlanDir(dir) {
   if (!existsSync25(dir))
     return [];
   try {
-    return readdirSync3(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join36(dir, entry.name, "plan.md")).filter(existsSync25);
+    return readdirSync3(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join37(dir, entry.name, "plan.md")).filter(existsSync25);
   } catch {
     return [];
   }
@@ -54930,7 +54998,7 @@ var init_plan_validator = __esm(() => {
 // src/domains/plan-parser/plan-writer.ts
 import { mkdirSync as mkdirSync2, readFileSync as readFileSync8, writeFileSync as writeFileSync3 } from "node:fs";
 import { existsSync as existsSync27 } from "node:fs";
-import { basename as basename11, dirname as dirname13, join as join37 } from "node:path";
+import { basename as basename11, dirname as dirname13, join as join38 } from "node:path";
 function phaseNameToFilename(id, name) {
   const numMatch = /^(\d+)([a-z]*)$/i.exec(id);
   const num = numMatch ? numMatch[1] : id;
@@ -55038,12 +55106,12 @@ function scaffoldPlan(options2) {
   mkdirSync2(dir, { recursive: true });
   const resolvedPhases = resolvePhaseIds(options2.phases);
   const optionsWithResolved = { ...options2, phases: resolvedPhases };
-  const planFile = join37(dir, "plan.md");
+  const planFile = join38(dir, "plan.md");
   writeFileSync3(planFile, generatePlanMd(optionsWithResolved), "utf8");
   const phaseFiles = [];
   for (const phase of resolvedPhases) {
     const filename = phaseNameToFilename(phase.id, phase.name);
-    const phaseFile = join37(dir, filename);
+    const phaseFile = join38(dir, filename);
     writeFileSync3(phaseFile, generatePhaseTemplate(phase), "utf8");
     phaseFiles.push(phaseFile);
   }
@@ -55123,7 +55191,7 @@ function phaseNameFilenameFromTableRow(body, phaseId, planDir) {
       continue;
     const linkMatch = /\[([^\]]+)\]\(\.\/([^)]+)\)/.exec(row);
     if (linkMatch)
-      return join37(planDir, linkMatch[2]);
+      return join38(planDir, linkMatch[2]);
   }
   return null;
 }
@@ -55204,7 +55272,7 @@ function addPhase(planFile, name, afterId) {
 `);
   }
   writeFileSync3(planFile, import_gray_matter8.default.stringify(updatedBody, frontmatter), "utf8");
-  const phaseFilePath = join37(planDir, filename);
+  const phaseFilePath = join38(planDir, filename);
   writeFileSync3(phaseFilePath, generatePhaseTemplate({ id: phaseId, name }), "utf8");
   return { phaseId, phaseFile: phaseFilePath };
 }
@@ -55368,8 +55436,8 @@ var init_plan_routes = __esm(() => {
 // src/domains/web-server/routes/project-routes.ts
 import { existsSync as existsSync29 } from "node:fs";
 import { readFile as readFile22 } from "node:fs/promises";
-import { homedir as homedir22 } from "node:os";
-import { basename as basename13, join as join38, resolve as resolve11 } from "node:path";
+import { homedir as homedir23 } from "node:os";
+import { basename as basename13, join as join39, resolve as resolve11 } from "node:path";
 function registerProjectRoutes(app) {
   app.get("/api/projects", async (req, res) => {
     try {
@@ -55388,7 +55456,7 @@ function registerProjectRoutes(app) {
       for (const discovered of discoveredProjects) {
         if (registeredPaths.has(discovered.path))
           continue;
-        if (discovered.path === join38(homedir22(), ".claude"))
+        if (discovered.path === join39(homedir23(), ".claude"))
           continue;
         const projectInfo = await detectAndBuildProjectInfo(discovered.path, `discovered-${discovered.path}`);
         if (projectInfo) {
@@ -55404,7 +55472,7 @@ function registerProjectRoutes(app) {
         if (cwdProject) {
           projects.push(cwdProject);
         }
-        const globalDir = join38(homedir22(), ".claude");
+        const globalDir = join39(homedir23(), ".claude");
         const globalProject = await detectAndBuildProjectInfo(globalDir, "global");
         if (globalProject) {
           projects.push(globalProject);
@@ -55476,12 +55544,12 @@ function registerProjectRoutes(app) {
       const body = validation.data;
       let projectPath = body.path;
       if (projectPath.startsWith("~/") || projectPath === "~") {
-        projectPath = join38(homedir22(), projectPath.slice(1));
+        projectPath = join39(homedir23(), projectPath.slice(1));
       } else if (projectPath.startsWith("~\\")) {
-        projectPath = join38(homedir22(), projectPath.slice(1));
+        projectPath = join39(homedir23(), projectPath.slice(1));
       }
       projectPath = resolve11(projectPath);
-      const homeDir = homedir22();
+      const homeDir = homedir23();
       if (projectPath.includes("..") || !projectPath.startsWith(homeDir)) {
         res.status(400).json({ error: "Invalid path after expansion" });
         return;
@@ -55538,7 +55606,7 @@ function registerProjectRoutes(app) {
       if (id === "current") {
         projectPath = process.cwd();
       } else if (id === "global") {
-        projectPath = join38(homedir22(), ".claude");
+        projectPath = join39(homedir23(), ".claude");
       } else {
         res.status(404).json({ error: "Project not found" });
         return;
@@ -55600,8 +55668,8 @@ function registerProjectRoutes(app) {
   });
 }
 async function buildProjectInfoFromRegistry(registered) {
-  const claudeDir2 = join38(registered.path, ".claude");
-  const metadataPath = join38(claudeDir2, "metadata.json");
+  const claudeDir2 = join39(registered.path, ".claude");
+  const metadataPath = join39(claudeDir2, "metadata.json");
   if (!existsSync29(registered.path)) {
     return null;
   }
@@ -55618,7 +55686,7 @@ async function buildProjectInfoFromRegistry(registered) {
   const hasLocalConfig = hasClaudeDir && CkConfigManager.projectConfigExists(registered.path, false);
   const settings = await readSettings();
   const skills = await scanSkills();
-  const settingsPath = join38(homedir22(), ".claude", "settings.json");
+  const settingsPath = join39(homedir23(), ".claude", "settings.json");
   const health = existsSync29(settingsPath) ? "healthy" : "warning";
   const model = getCurrentModel() || settings?.model || "claude-sonnet-4";
   return {
@@ -55641,8 +55709,8 @@ async function buildProjectInfoFromRegistry(registered) {
   };
 }
 async function detectAndBuildProjectInfo(path5, id) {
-  const claudeDir2 = id === "global" ? path5 : join38(path5, ".claude");
-  const metadataPath = join38(claudeDir2, "metadata.json");
+  const claudeDir2 = id === "global" ? path5 : join39(path5, ".claude");
+  const metadataPath = join39(claudeDir2, "metadata.json");
   if (!existsSync29(metadataPath)) {
     if (!existsSync29(claudeDir2)) {
       return null;
@@ -55660,7 +55728,7 @@ async function detectAndBuildProjectInfo(path5, id) {
   const hasLocalConfig = CkConfigManager.projectConfigExists(path5, id === "global");
   const settings = await readSettings();
   const skills = await scanSkills();
-  const settingsPath = join38(homedir22(), ".claude", "settings.json");
+  const settingsPath = join39(homedir23(), ".claude", "settings.json");
   const health = existsSync29(settingsPath) ? "healthy" : "warning";
   const model = getCurrentModel() || settings?.model || "claude-sonnet-4";
   return {
@@ -55701,32 +55769,32 @@ var init_project_routes = __esm(() => {
 });
 
 // src/domains/web-server/routes/session-routes.ts
-import { homedir as homedir23 } from "node:os";
-import { join as join39 } from "node:path";
+import { homedir as homedir24 } from "node:os";
+import { join as join40 } from "node:path";
 async function resolveSessionDir(projectId) {
-  const home6 = homedir23();
+  const home6 = homedir24();
   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 join39(home6, ".claude", "projects", claudeEncoded);
+      return join40(home6, ".claude", "projects", claudeEncoded);
     } catch {
       return null;
     }
   }
   if (projectId === "current") {
     const cwdEncoded = encodePath(process.cwd());
-    return join39(home6, ".claude", "projects", cwdEncoded);
+    return join40(home6, ".claude", "projects", cwdEncoded);
   }
   if (projectId === "global") {
-    const globalEncoded = encodePath(join39(home6, ".claude"));
-    return join39(home6, ".claude", "projects", globalEncoded);
+    const globalEncoded = encodePath(join40(home6, ".claude"));
+    return join40(home6, ".claude", "projects", globalEncoded);
   }
   const registered = await ProjectsRegistryManager.getProject(projectId);
   if (registered) {
     const claudeEncoded = encodePath(registered.path);
-    return join39(home6, ".claude", "projects", claudeEncoded);
+    return join40(home6, ".claude", "projects", claudeEncoded);
   }
   return null;
 }
@@ -55743,7 +55811,7 @@ function registerSessionRoutes(app) {
       res.status(404).json({ error: "Project not found" });
       return;
     }
-    const allowedBase = join39(homedir23(), ".claude", "projects");
+    const allowedBase = join40(homedir24(), ".claude", "projects");
     if (!projectDir.startsWith(allowedBase)) {
       res.status(403).json({ error: "Access denied" });
       return;
@@ -55765,7 +55833,7 @@ var init_session_routes = __esm(() => {
 });
 
 // src/domains/web-server/routes/settings-routes.ts
-import { homedir as homedir24 } from "node:os";
+import { homedir as homedir25 } from "node:os";
 function registerSettingsRoutes(app) {
   app.get("/api/settings", async (_req, res) => {
     try {
@@ -55821,7 +55889,7 @@ function registerSettingsRoutes(app) {
       res.json({
         success: true,
         path: "~/.claude/settings.json",
-        backupPath: saveResult.backupPath ? saveResult.backupPath.replace(homedir24(), "~") : null,
+        backupPath: saveResult.backupPath ? saveResult.backupPath.replace(homedir25(), "~") : null,
         absolutePath: getSettingsPath()
       });
     } catch (error) {
@@ -55855,8 +55923,8 @@ var init_settings_routes = __esm(() => {
 
 // src/commands/skills/agents.ts
 import { existsSync as existsSync30 } from "node:fs";
-import { homedir as homedir25 } from "node:os";
-import { join as join40 } from "node:path";
+import { homedir as homedir26 } from "node:os";
+import { join as join41 } from "node:path";
 async function detectInstalledAgents() {
   const installed = [];
   for (const [type, config] of Object.entries(agents)) {
@@ -55872,7 +55940,7 @@ function getAgentConfig(type) {
 function getInstallPath(skillName, agent, options2) {
   const config = agents[agent];
   const basePath = options2.global ? config.globalPath : config.projectPath;
-  return join40(basePath, skillName);
+  return join41(basePath, skillName);
 }
 function isSkillInstalled(skillName, agent, options2) {
   const installPath = getInstallPath(skillName, agent, options2);
@@ -55880,105 +55948,105 @@ function isSkillInstalled(skillName, agent, options2) {
 }
 var home6, agents;
 var init_agents = __esm(() => {
-  home6 = homedir25();
+  home6 = homedir26();
   agents = {
     "claude-code": {
       name: "claude-code",
       displayName: "Claude Code",
       projectPath: ".claude/skills",
-      globalPath: join40(home6, ".claude/skills"),
-      detect: async () => existsSync30(join40(home6, ".claude"))
+      globalPath: join41(home6, ".claude/skills"),
+      detect: async () => existsSync30(join41(home6, ".claude"))
     },
     cursor: {
       name: "cursor",
       displayName: "Cursor",
       projectPath: ".cursor/skills",
-      globalPath: join40(home6, ".cursor/skills"),
-      detect: async () => existsSync30(join40(home6, ".cursor"))
+      globalPath: join41(home6, ".cursor/skills"),
+      detect: async () => existsSync30(join41(home6, ".cursor"))
     },
     codex: {
       name: "codex",
       displayName: "Codex",
       projectPath: ".codex/skills",
-      globalPath: join40(home6, ".codex/skills"),
-      detect: async () => existsSync30(join40(home6, ".codex"))
+      globalPath: join41(home6, ".codex/skills"),
+      detect: async () => existsSync30(join41(home6, ".codex"))
     },
     opencode: {
       name: "opencode",
       displayName: "OpenCode",
       projectPath: ".opencode/skills",
-      globalPath: join40(home6, ".config/opencode/skills"),
-      detect: async () => existsSync30(join40(home6, ".config/opencode"))
+      globalPath: join41(home6, ".config/opencode/skills"),
+      detect: async () => existsSync30(join41(home6, ".config/opencode"))
     },
     goose: {
       name: "goose",
       displayName: "Goose",
       projectPath: ".goose/skills",
-      globalPath: join40(home6, ".config/goose/skills"),
-      detect: async () => existsSync30(join40(home6, ".config/goose"))
+      globalPath: join41(home6, ".config/goose/skills"),
+      detect: async () => existsSync30(join41(home6, ".config/goose"))
     },
     "gemini-cli": {
       name: "gemini-cli",
       displayName: "Gemini CLI",
       projectPath: ".agents/skills",
-      globalPath: join40(home6, ".agents/skills"),
-      detect: async () => existsSync30(join40(home6, ".gemini"))
+      globalPath: join41(home6, ".agents/skills"),
+      detect: async () => existsSync30(join41(home6, ".gemini"))
     },
     antigravity: {
       name: "antigravity",
       displayName: "Antigravity",
       projectPath: ".agent/skills",
-      globalPath: join40(home6, ".gemini/antigravity/skills"),
-      detect: async () => existsSync30(join40(process.cwd(), ".agent")) || existsSync30(join40(home6, ".gemini/antigravity"))
+      globalPath: join41(home6, ".gemini/antigravity/skills"),
+      detect: async () => existsSync30(join41(process.cwd(), ".agent")) || existsSync30(join41(home6, ".gemini/antigravity"))
     },
     "github-copilot": {
       name: "github-copilot",
       displayName: "GitHub Copilot",
       projectPath: ".github/skills",
-      globalPath: join40(home6, ".copilot/skills"),
-      detect: async () => existsSync30(join40(home6, ".copilot"))
+      globalPath: join41(home6, ".copilot/skills"),
+      detect: async () => existsSync30(join41(home6, ".copilot"))
     },
     amp: {
       name: "amp",
       displayName: "Amp",
       projectPath: ".agents/skills",
-      globalPath: join40(home6, ".config/agents/skills"),
-      detect: async () => existsSync30(join40(home6, ".config/amp"))
+      globalPath: join41(home6, ".config/agents/skills"),
+      detect: async () => existsSync30(join41(home6, ".config/amp"))
     },
     kilo: {
       name: "kilo",
       displayName: "Kilo Code",
       projectPath: ".kilocode/skills",
-      globalPath: join40(home6, ".kilocode/skills"),
-      detect: async () => existsSync30(join40(home6, ".kilocode"))
+      globalPath: join41(home6, ".kilocode/skills"),
+      detect: async () => existsSync30(join41(home6, ".kilocode"))
     },
     roo: {
       name: "roo",
       displayName: "Roo Code",
       projectPath: ".roo/skills",
-      globalPath: join40(home6, ".roo/skills"),
-      detect: async () => existsSync30(join40(home6, ".roo"))
+      globalPath: join41(home6, ".roo/skills"),
+      detect: async () => existsSync30(join41(home6, ".roo"))
     },
     windsurf: {
       name: "windsurf",
       displayName: "Windsurf",
       projectPath: ".windsurf/skills",
-      globalPath: join40(home6, ".codeium/windsurf/skills"),
-      detect: async () => existsSync30(join40(home6, ".codeium/windsurf"))
+      globalPath: join41(home6, ".codeium/windsurf/skills"),
+      detect: async () => existsSync30(join41(home6, ".codeium/windsurf"))
     },
     cline: {
       name: "cline",
       displayName: "Cline",
       projectPath: ".cline/skills",
-      globalPath: join40(home6, ".cline/skills"),
-      detect: async () => existsSync30(join40(home6, ".cline"))
+      globalPath: join41(home6, ".cline/skills"),
+      detect: async () => existsSync30(join41(home6, ".cline"))
     },
     openhands: {
       name: "openhands",
       displayName: "OpenHands",
       projectPath: ".openhands/skills",
-      globalPath: join40(home6, ".openhands/skills"),
-      detect: async () => existsSync30(join40(home6, ".openhands"))
+      globalPath: join41(home6, ".openhands/skills"),
+      detect: async () => existsSync30(join41(home6, ".openhands"))
     }
   };
 });
@@ -55986,8 +56054,8 @@ var init_agents = __esm(() => {
 // src/commands/skills/skills-registry.ts
 import { existsSync as existsSync31 } from "node:fs";
 import { mkdir as mkdir9, readFile as readFile23, writeFile as writeFile11 } from "node:fs/promises";
-import { homedir as homedir26 } from "node:os";
-import { dirname as dirname16, join as join41, sep as sep5 } from "node:path";
+import { homedir as homedir27 } from "node:os";
+import { dirname as dirname16, join as join42, sep as sep5 } from "node:path";
 function getCliVersion3() {
   try {
     if (process.env.npm_package_version) {
@@ -56098,8 +56166,8 @@ async function syncRegistry() {
 var home7, REGISTRY_PATH2, SkillInstallationSchema, SkillRegistrySchema, REGISTRY_PATH_MIGRATIONS;
 var init_skills_registry = __esm(() => {
   init_zod();
-  home7 = homedir26();
-  REGISTRY_PATH2 = join41(home7, ".claudekit", "skill-registry.json");
+  home7 = homedir27();
+  REGISTRY_PATH2 = join42(home7, ".claudekit", "skill-registry.json");
   SkillInstallationSchema = exports_external.object({
     skill: exports_external.string(),
     agent: exports_external.string(),
@@ -56130,8 +56198,8 @@ var init_skills_registry = __esm(() => {
 // src/commands/skills/skills-installer.ts
 import { existsSync as existsSync32 } from "node:fs";
 import { cp as cp2, mkdir as mkdir10, rm as rm7, stat as stat7 } from "node:fs/promises";
-import { homedir as homedir27 } from "node:os";
-import { dirname as dirname17, join as join42, resolve as resolve12 } from "node:path";
+import { homedir as homedir28 } from "node:os";
+import { dirname as dirname17, join as join43, resolve as resolve12 } from "node:path";
 function isSamePath2(path1, path22) {
   try {
     return resolve12(path1) === resolve12(path22);
@@ -56163,7 +56231,7 @@ async function cleanupLegacySkillPath(skillName, agent, global3) {
   if (!legacy)
     return;
   const legacyBase = global3 ? legacy.global : legacy.project;
-  const legacyPath = join42(legacyBase, skillName);
+  const legacyPath = join43(legacyBase, skillName);
   if (!existsSync32(legacyPath))
     return;
   await rm7(legacyPath, { recursive: true, force: true });
@@ -56173,7 +56241,7 @@ async function cleanupLegacySkillPath(skillName, agent, global3) {
     if (entry.skill === skillName && entry.agent === agent && entry.global === global3) {
       if (entry.path === legacyPath) {
         const newBase = global3 ? agents[agent].globalPath : agents[agent].projectPath;
-        entry.path = join42(newBase, skillName);
+        entry.path = join43(newBase, skillName);
         changed = true;
       }
     }
@@ -56261,7 +56329,7 @@ var init_skills_installer = __esm(() => {
   LEGACY_SKILL_PATHS = {
     "gemini-cli": {
       project: ".gemini/skills",
-      global: join42(homedir27(), ".gemini/skills")
+      global: join43(homedir28(), ".gemini/skills")
     }
   };
 });
@@ -56269,7 +56337,7 @@ var init_skills_installer = __esm(() => {
 // src/commands/skills/skills-uninstaller.ts
 import { existsSync as existsSync33 } from "node:fs";
 import { rm as rm8 } from "node:fs/promises";
-import { join as join43 } from "node:path";
+import { join as join44 } from "node:path";
 async function uninstallSkillFromAgent(skill, agent, global3) {
   const agentConfig = agents[agent];
   const registry = await readRegistry();
@@ -56317,7 +56385,7 @@ async function uninstallSkillFromAgent(skill, agent, global3) {
 async function forceUninstallSkill(skill, agent, global3) {
   const agentConfig = agents[agent];
   const basePath = global3 ? agentConfig.globalPath : agentConfig.projectPath;
-  const path5 = join43(basePath, skill);
+  const path5 = join44(basePath, skill);
   if (!existsSync33(path5)) {
     return {
       skill,
@@ -56861,7 +56929,7 @@ var init_pnpm_detector = __esm(() => {
 import { existsSync as existsSync34, realpathSync as realpathSync2 } from "node:fs";
 import { chmod as chmod2, mkdir as mkdir11, readFile as readFile24, writeFile as writeFile12 } from "node:fs/promises";
 import { platform as platform4 } from "node:os";
-import { join as join44 } from "node:path";
+import { join as join45 } from "node:path";
 function detectFromBinaryPath() {
   const normalizePath2 = (pathValue) => pathValue.replace(/\\/g, "/").toLowerCase();
   const detectFromNormalizedPath = (normalized) => {
@@ -56938,7 +57006,7 @@ function detectFromEnv() {
 }
 async function readCachedPm() {
   try {
-    const cacheFile = join44(PathResolver.getConfigDir(false), CACHE_FILE);
+    const cacheFile = join45(PathResolver.getConfigDir(false), CACHE_FILE);
     if (!existsSync34(cacheFile)) {
       return null;
     }
@@ -56969,7 +57037,7 @@ async function saveCachedPm(pm, getVersion) {
     return;
   try {
     const configDir = PathResolver.getConfigDir(false);
-    const cacheFile = join44(configDir, CACHE_FILE);
+    const cacheFile = join45(configDir, CACHE_FILE);
     if (!existsSync34(configDir)) {
       await mkdir11(configDir, { recursive: true });
       if (platform4() !== "win32") {
@@ -57032,7 +57100,7 @@ async function findOwningPm() {
 async function clearCache() {
   try {
     const { unlink: unlink6 } = await import("node:fs/promises");
-    const cacheFile = join44(PathResolver.getConfigDir(false), CACHE_FILE);
+    const cacheFile = join45(PathResolver.getConfigDir(false), CACHE_FILE);
     if (existsSync34(cacheFile)) {
       await unlink6(cacheFile);
       logger.debug("Package manager cache cleared");
@@ -57189,9 +57257,9 @@ var init_package_manager_detector = __esm(() => {
 });
 
 // src/domains/migration/metadata-migration.ts
-import { join as join45 } from "node:path";
+import { join as join46 } from "node:path";
 async function detectMetadataFormat(claudeDir2) {
-  const metadataPath = join45(claudeDir2, "metadata.json");
+  const metadataPath = join46(claudeDir2, "metadata.json");
   if (!await import_fs_extra3.pathExists(metadataPath)) {
     return { format: "none", metadata: null, detectedKit: null };
   }
@@ -57243,7 +57311,7 @@ async function migrateToMultiKit(claudeDir2) {
       toFormat: "multi-kit"
     };
   }
-  const metadataPath = join45(claudeDir2, "metadata.json");
+  const metadataPath = join46(claudeDir2, "metadata.json");
   const legacy = detection.metadata;
   if (!legacy) {
     return {
@@ -57526,7 +57594,7 @@ var init_version_utils = __esm(() => {
 });
 
 // src/services/file-operations/claudekit-scanner.ts
-import { join as join46 } from "node:path";
+import { join as join47 } from "node:path";
 async function scanClaudeKitDirectory(directoryPath) {
   const counts = {
     agents: 0,
@@ -57540,33 +57608,33 @@ async function scanClaudeKitDirectory(directoryPath) {
     }
     const items = await import_fs_extra4.readdir(directoryPath);
     if (items.includes("agents")) {
-      const agentsPath = join46(directoryPath, "agents");
+      const agentsPath = join47(directoryPath, "agents");
       const agentFiles = await import_fs_extra4.readdir(agentsPath);
       counts.agents = agentFiles.filter((file) => file.endsWith(".md")).length;
     }
     if (items.includes("commands")) {
-      const commandsPath = join46(directoryPath, "commands");
+      const commandsPath = join47(directoryPath, "commands");
       const commandFiles = await import_fs_extra4.readdir(commandsPath);
       counts.commands = commandFiles.filter((file) => file.endsWith(".md")).length;
     }
     if (items.includes("rules")) {
-      const rulesPath = join46(directoryPath, "rules");
+      const rulesPath = join47(directoryPath, "rules");
       const ruleFiles = await import_fs_extra4.readdir(rulesPath);
       counts.rules = ruleFiles.filter((file) => file.endsWith(".md")).length;
     } else if (items.includes("workflows")) {
-      const workflowsPath = join46(directoryPath, "workflows");
+      const workflowsPath = join47(directoryPath, "workflows");
       const workflowFiles = await import_fs_extra4.readdir(workflowsPath);
       counts.rules = workflowFiles.filter((file) => file.endsWith(".md")).length;
     }
     if (items.includes("skills")) {
-      const skillsPath = join46(directoryPath, "skills");
+      const skillsPath = join47(directoryPath, "skills");
       const skillItems = await import_fs_extra4.readdir(skillsPath);
       let skillCount = 0;
       for (const item of skillItems) {
         if (SKIP_DIRS_CLAUDE_INTERNAL.includes(item)) {
           continue;
         }
-        const itemPath = join46(skillsPath, item);
+        const itemPath = join47(skillsPath, item);
         const stat8 = await import_fs_extra4.readdir(itemPath).catch(() => null);
         if (stat8?.includes("SKILL.md")) {
           skillCount++;
@@ -57608,14 +57676,14 @@ async function getClaudeKitSetup(projectDir = process.cwd()) {
   const globalDir = getGlobalInstallDir();
   if (await import_fs_extra4.pathExists(globalDir)) {
     setup.global.path = globalDir;
-    setup.global.metadata = await readClaudeKitMetadata(join46(globalDir, "metadata.json"));
+    setup.global.metadata = await readClaudeKitMetadata(join47(globalDir, "metadata.json"));
     setup.global.components = await scanClaudeKitDirectory(globalDir);
   }
-  const projectClaudeDir = join46(projectDir, ".claude");
+  const projectClaudeDir = join47(projectDir, ".claude");
   const isLocalSameAsGlobal = projectClaudeDir === globalDir;
   if (!isLocalSameAsGlobal && await import_fs_extra4.pathExists(projectClaudeDir)) {
     setup.project.path = projectClaudeDir;
-    setup.project.metadata = await readClaudeKitMetadata(join46(projectClaudeDir, "metadata.json"));
+    setup.project.metadata = await readClaudeKitMetadata(join47(projectClaudeDir, "metadata.json"));
     setup.project.components = await scanClaudeKitDirectory(projectClaudeDir);
   }
   return setup;
@@ -57632,7 +57700,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "claudekit-cli",
-    version: "3.41.3",
+    version: "3.41.4",
     description: "CLI tool for bootstrapping and updating ClaudeKit projects",
     type: "module",
     repository: {
@@ -58184,7 +58252,7 @@ var init_error_handler2 = __esm(() => {
 // src/domains/versioning/release-cache.ts
 import { existsSync as existsSync35 } from "node:fs";
 import { mkdir as mkdir12, readFile as readFile27, unlink as unlink6, writeFile as writeFile14 } from "node:fs/promises";
-import { join as join47 } from "node:path";
+import { join as join48 } from "node:path";
 var ReleaseCacheEntrySchema, ReleaseCache;
 var init_release_cache = __esm(() => {
   init_logger();
@@ -58199,7 +58267,7 @@ var init_release_cache = __esm(() => {
     static CACHE_TTL_SECONDS = Number(process.env.CK_CACHE_TTL) || 3600;
     cacheDir;
     constructor() {
-      this.cacheDir = join47(PathResolver.getCacheDir(false), ReleaseCache.CACHE_DIR);
+      this.cacheDir = join48(PathResolver.getCacheDir(false), ReleaseCache.CACHE_DIR);
     }
     async get(key) {
       const cacheFile = this.getCachePath(key);
@@ -58257,7 +58325,7 @@ var init_release_cache = __esm(() => {
           const files = await readdir10(this.cacheDir);
           for (const file of files) {
             if (file.endsWith(".json")) {
-              await unlink6(join47(this.cacheDir, file));
+              await unlink6(join48(this.cacheDir, file));
             }
           }
           logger.debug("All release cache cleared");
@@ -58268,7 +58336,7 @@ var init_release_cache = __esm(() => {
     }
     getCachePath(key) {
       const safeKey = key.replace(/[^a-zA-Z0-9_-]/g, "_");
-      return join47(this.cacheDir, `${safeKey}.json`);
+      return join48(this.cacheDir, `${safeKey}.json`);
     }
     isExpired(timestamp) {
       const now = Date.now();
@@ -58909,7 +58977,7 @@ var init_github_client = __esm(() => {
 
 // src/commands/update-cli.ts
 import { exec as exec2, spawn as spawn2 } from "node:child_process";
-import { join as join48 } from "node:path";
+import { join as join49 } from "node:path";
 import { promisify as promisify8 } from "node:util";
 function getDefaultUpdateCliCommandDeps() {
   return {
@@ -58989,7 +59057,7 @@ function selectKitForUpdate(params) {
   };
 }
 async function readMetadataFile(claudeDir2) {
-  const metadataPath = join48(claudeDir2, "metadata.json");
+  const metadataPath = join49(claudeDir2, "metadata.json");
   try {
     if (!await import_fs_extra5.pathExists(metadataPath)) {
       return null;
@@ -59411,7 +59479,7 @@ var init_update_cli = __esm(() => {
 // src/domains/versioning/version-cache.ts
 import { existsSync as existsSync36 } from "node:fs";
 import { mkdir as mkdir13, readFile as readFile29, writeFile as writeFile15 } from "node:fs/promises";
-import { join as join49 } from "node:path";
+import { join as join50 } from "node:path";
 var VersionCacheManager;
 var init_version_cache = __esm(() => {
   init_logger();
@@ -59421,7 +59489,7 @@ var init_version_cache = __esm(() => {
     static CACHE_TTL_MS = 7 * 24 * 60 * 60 * 1000;
     static getCacheFile() {
       const cacheDir = PathResolver.getCacheDir(false);
-      return join49(cacheDir, VersionCacheManager.CACHE_FILENAME);
+      return join50(cacheDir, VersionCacheManager.CACHE_FILENAME);
     }
     static async load() {
       const cacheFile = VersionCacheManager.getCacheFile();
@@ -59690,7 +59758,7 @@ var init_version_checker = __esm(() => {
 import { spawn as spawn3 } from "node:child_process";
 import { existsSync as existsSync37 } from "node:fs";
 import { readFile as readFile30 } from "node:fs/promises";
-import { join as join50 } from "node:path";
+import { join as join51 } from "node:path";
 function hasCliUpdate(currentVersion, latestVersion) {
   if (!latestVersion) {
     return false;
@@ -59933,7 +60001,7 @@ async function getPackageJson() {
 }
 async function getKitMetadata2(kitName) {
   try {
-    const metadataPath = join50(PathResolver.getGlobalKitDir(), "metadata.json");
+    const metadataPath = join51(PathResolver.getGlobalKitDir(), "metadata.json");
     if (!existsSync37(metadataPath))
       return null;
     const content = await readFile30(metadataPath, "utf-8");
@@ -60080,7 +60148,7 @@ var init_routes = __esm(() => {
 
 // src/domains/web-server/static-server.ts
 import { existsSync as existsSync38 } from "node:fs";
-import { dirname as dirname18, join as join51, resolve as resolve13 } from "node:path";
+import { dirname as dirname18, join as join52, resolve as resolve13 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 function addRuntimeUiCandidate(candidates, runtimePath) {
   if (!runtimePath) {
@@ -60091,21 +60159,21 @@ function addRuntimeUiCandidate(candidates, runtimePath) {
     return;
   }
   const entryDir = dirname18(resolve13(runtimePath));
-  candidates.add(join51(entryDir, "ui"));
-  candidates.add(join51(entryDir, "..", "dist", "ui"));
+  candidates.add(join52(entryDir, "ui"));
+  candidates.add(join52(entryDir, "..", "dist", "ui"));
 }
 function resolveUiDistPath() {
   const candidates = new Set;
   addRuntimeUiCandidate(candidates, process.argv[1]);
-  candidates.add(join51(__dirname3, "ui"));
-  candidates.add(join51(process.cwd(), "dist", "ui"));
-  candidates.add(join51(process.cwd(), "src", "ui", "dist"));
+  candidates.add(join52(__dirname3, "ui"));
+  candidates.add(join52(process.cwd(), "dist", "ui"));
+  candidates.add(join52(process.cwd(), "src", "ui", "dist"));
   for (const path5 of candidates) {
-    if (existsSync38(join51(path5, "index.html"))) {
+    if (existsSync38(join52(path5, "index.html"))) {
       return path5;
     }
   }
-  return Array.from(candidates)[0] ?? join51(process.cwd(), "dist", "ui");
+  return Array.from(candidates)[0] ?? join52(process.cwd(), "dist", "ui");
 }
 function serveStatic(app) {
   const uiDistPath = resolveUiDistPath();
@@ -60141,7 +60209,7 @@ function serveStatic(app) {
     if (req.path.startsWith("/assets/") || req.path.match(/\.(js|css|ico|png|jpg|svg|woff2?)$/)) {
       return next();
     }
-    res.sendFile(join51(uiDistPath, "index.html"), { dotfiles: "allow" });
+    res.sendFile(join52(uiDistPath, "index.html"), { dotfiles: "allow" });
   });
   logger.debug(`Serving static files from ${uiDistPath}`);
 }
@@ -64990,7 +65058,7 @@ function getNpmLookupTimeoutMs() {
 function getNpmInstallTimeoutMs() {
   return parseTimeoutMs(process.env.CK_NPM_INSTALL_TIMEOUT_MS, DEFAULT_NPM_INSTALL_TIMEOUT_MS, MIN_NPM_TIMEOUT_MS, MAX_NPM_TIMEOUT_MS);
 }
-function escapeRegex(value) {
+function escapeRegex2(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 async function isPackageInstalled(packageName) {
@@ -65022,7 +65090,7 @@ async function isPackageInstalled(packageName) {
       const { stdout: stdout2 } = await execAsync7(`${getNpmCommand()} list -g ${packageName} --depth=0`, {
         timeout: getNpmLookupTimeoutMs()
       });
-      const exactPattern = new RegExp(`(?:^|\\s|[├└│─]+)${escapeRegex(packageName)}@([^\\s\\n]+)(?:\\s|$)`, "m");
+      const exactPattern = new RegExp(`(?:^|\\s|[├└│─]+)${escapeRegex2(packageName)}@([^\\s\\n]+)(?:\\s|$)`, "m");
       return exactPattern.test(stdout2);
     } catch {
       return false;
@@ -65068,8 +65136,8 @@ async function getPackageVersion(packageName) {
       timeout: getNpmLookupTimeoutMs()
     });
     const patterns = [
-      new RegExp(`${escapeRegex(packageName)}@([^\\s\\n]+)`),
-      new RegExp(`${escapeRegex(packageName)}@([0-9]+\\.[0-9]+\\.[0-9]+(?:-[\\w.-]+)?)`)
+      new RegExp(`${escapeRegex2(packageName)}@([^\\s\\n]+)`),
+      new RegExp(`${escapeRegex2(packageName)}@([0-9]+\\.[0-9]+\\.[0-9]+(?:-[\\w.-]+)?)`)
     ];
     for (const pattern of patterns) {
       const match = stdout2.match(pattern);
@@ -65148,7 +65216,7 @@ var init_gemini_installer = __esm(() => {
 });
 
 // src/services/package-installer/opencode-installer.ts
-import { join as join69 } from "node:path";
+import { join as join70 } from "node:path";
 async function isOpenCodeInstalled() {
   try {
     await execAsync7("opencode --version", { timeout: 5000 });
@@ -65171,7 +65239,7 @@ async function installOpenCode() {
     logger.info(`Installing ${displayName}...`);
     const { unlink: unlink11 } = await import("node:fs/promises");
     const { tmpdir: tmpdir4 } = await import("node:os");
-    const tempScriptPath = join69(tmpdir4(), "opencode-install.sh");
+    const tempScriptPath = join70(tmpdir4(), "opencode-install.sh");
     try {
       logger.info("Downloading OpenCode installation script...");
       await execFileAsync5("curl", ["-fsSL", "https://opencode.ai/install", "-o", tempScriptPath], {
@@ -65223,7 +65291,7 @@ var PARTIAL_INSTALL_VERSION = "partial", EXIT_CODE_CRITICAL_FAILURE = 1, EXIT_CO
 
 // src/services/package-installer/install-error-handler.ts
 import { existsSync as existsSync49, readFileSync as readFileSync14, unlinkSync as unlinkSync2 } from "node:fs";
-import { join as join70 } from "node:path";
+import { join as join71 } from "node:path";
 function parseNameReason(str2) {
   const colonIndex = str2.indexOf(":");
   if (colonIndex === -1) {
@@ -65232,7 +65300,7 @@ function parseNameReason(str2) {
   return [str2.slice(0, colonIndex).trim(), str2.slice(colonIndex + 1).trim()];
 }
 function displayInstallErrors(skillsDir2) {
-  const summaryPath = join70(skillsDir2, ".install-error-summary.json");
+  const summaryPath = join71(skillsDir2, ".install-error-summary.json");
   if (!existsSync49(summaryPath)) {
     logger.error("Skills installation failed. Run with --verbose for details.");
     return;
@@ -65323,7 +65391,7 @@ async function checkNeedsSudoPackages() {
   }
 }
 function hasInstallState(skillsDir2) {
-  const stateFilePath = join70(skillsDir2, ".install-state.json");
+  const stateFilePath = join71(skillsDir2, ".install-state.json");
   return existsSync49(stateFilePath);
 }
 var WHICH_COMMAND_TIMEOUT_MS = 5000;
@@ -65332,7 +65400,7 @@ var init_install_error_handler = __esm(() => {
 });
 
 // src/services/package-installer/skills-installer.ts
-import { join as join71 } from "node:path";
+import { join as join72 } from "node:path";
 async function installSkillsDependencies(skillsDir2, options2 = {}) {
   const { skipConfirm = false, withSudo = false } = options2;
   const displayName = "Skills Dependencies";
@@ -65358,7 +65426,7 @@ async function installSkillsDependencies(skillsDir2, options2 = {}) {
     const clack = await Promise.resolve().then(() => (init_dist2(), exports_dist));
     const platform7 = process.platform;
     const scriptName = platform7 === "win32" ? "install.ps1" : "install.sh";
-    const scriptPath = join71(skillsDir2, scriptName);
+    const scriptPath = join72(skillsDir2, scriptName);
     try {
       validateScriptPath(skillsDir2, scriptPath);
     } catch (error) {
@@ -65374,7 +65442,7 @@ async function installSkillsDependencies(skillsDir2, options2 = {}) {
       logger.warning(`Skills installation script not found: ${scriptPath}`);
       logger.info("");
       logger.info("\uD83D\uDCD6 Manual Installation Instructions:");
-      logger.info(`  See: ${join71(skillsDir2, "INSTALLATION.md")}`);
+      logger.info(`  See: ${join72(skillsDir2, "INSTALLATION.md")}`);
       logger.info("");
       logger.info("Quick start:");
       logger.info("  cd .claude/skills/ai-multimodal/scripts");
@@ -65421,7 +65489,7 @@ async function installSkillsDependencies(skillsDir2, options2 = {}) {
       logger.info(`  ${platform7 === "win32" ? `powershell -File "${scriptPath}"` : `bash ${scriptPath}`}`);
       logger.info("");
       logger.info("Or see complete guide:");
-      logger.info(`  ${join71(skillsDir2, "INSTALLATION.md")}`);
+      logger.info(`  ${join72(skillsDir2, "INSTALLATION.md")}`);
       return {
         success: false,
         package: displayName,
@@ -65542,7 +65610,7 @@ async function installSkillsDependencies(skillsDir2, options2 = {}) {
     logger.info("\uD83D\uDCD6 Manual Installation Instructions:");
     logger.info("");
     logger.info("See complete guide:");
-    logger.info(`  cat ${join71(skillsDir2, "INSTALLATION.md")}`);
+    logger.info(`  cat ${join72(skillsDir2, "INSTALLATION.md")}`);
     logger.info("");
     logger.info("Quick start:");
     logger.info("  cd .claude/skills/ai-multimodal/scripts");
@@ -65588,7 +65656,7 @@ var init_skills_installer2 = __esm(() => {
 // src/services/package-installer/gemini-mcp/config-manager.ts
 import { existsSync as existsSync50 } from "node:fs";
 import { mkdir as mkdir17, readFile as readFile37, writeFile as writeFile20 } from "node:fs/promises";
-import { dirname as dirname21, join as join72 } from "node:path";
+import { dirname as dirname21, join as join73 } from "node:path";
 async function readJsonFile(filePath) {
   try {
     const content = await readFile37(filePath, "utf-8");
@@ -65600,7 +65668,7 @@ async function readJsonFile(filePath) {
   }
 }
 async function addGeminiToGitignore(projectDir) {
-  const gitignorePath = join72(projectDir, ".gitignore");
+  const gitignorePath = join73(projectDir, ".gitignore");
   const geminiPattern = ".gemini/";
   try {
     let content = "";
@@ -65691,13 +65759,13 @@ var init_config_manager2 = __esm(() => {
 
 // src/services/package-installer/gemini-mcp/validation.ts
 import { existsSync as existsSync51, lstatSync, readlinkSync } from "node:fs";
-import { homedir as homedir30 } from "node:os";
-import { join as join73 } from "node:path";
+import { homedir as homedir32 } from "node:os";
+import { join as join74 } from "node:path";
 function getGlobalMcpConfigPath() {
-  return join73(homedir30(), ".claude", ".mcp.json");
+  return join74(homedir32(), ".claude", ".mcp.json");
 }
 function getLocalMcpConfigPath(projectDir) {
-  return join73(projectDir, ".mcp.json");
+  return join74(projectDir, ".mcp.json");
 }
 function findMcpConfigPath(projectDir) {
   const localPath = getLocalMcpConfigPath(projectDir);
@@ -65715,9 +65783,9 @@ function findMcpConfigPath(projectDir) {
 }
 function getGeminiSettingsPath(projectDir, isGlobal) {
   if (isGlobal) {
-    return join73(homedir30(), ".gemini", "settings.json");
+    return join74(homedir32(), ".gemini", "settings.json");
   }
-  return join73(projectDir, ".gemini", "settings.json");
+  return join74(projectDir, ".gemini", "settings.json");
 }
 function checkExistingGeminiConfig(projectDir, isGlobal = false) {
   const geminiSettingsPath = getGeminiSettingsPath(projectDir, isGlobal);
@@ -65747,7 +65815,7 @@ var init_validation = __esm(() => {
 // src/services/package-installer/gemini-mcp/linker-core.ts
 import { existsSync as existsSync52 } from "node:fs";
 import { mkdir as mkdir18, symlink as symlink2 } from "node:fs/promises";
-import { dirname as dirname22, join as join74 } from "node:path";
+import { dirname as dirname22, join as join75 } from "node:path";
 async function createSymlink(targetPath, linkPath, projectDir, isGlobal) {
   const linkDir = dirname22(linkPath);
   if (!existsSync52(linkDir)) {
@@ -65758,7 +65826,7 @@ async function createSymlink(targetPath, linkPath, projectDir, isGlobal) {
   if (isGlobal) {
     symlinkTarget = getGlobalMcpConfigPath();
   } else {
-    const localMcpPath = join74(projectDir, ".mcp.json");
+    const localMcpPath = join75(projectDir, ".mcp.json");
     const isLocalConfig = targetPath === localMcpPath;
     symlinkTarget = isLocalConfig ? "../.mcp.json" : targetPath;
   }
@@ -68175,9 +68243,9 @@ __export(exports_worktree_manager, {
 });
 import { existsSync as existsSync60 } from "node:fs";
 import { readFile as readFile54, writeFile as writeFile33 } from "node:fs/promises";
-import { join as join125 } from "node:path";
+import { join as join127 } from "node:path";
 async function createWorktree(projectDir, issueNumber, baseBranch) {
-  const worktreePath = join125(projectDir, WORKTREE_DIR, `issue-${issueNumber}`);
+  const worktreePath = join127(projectDir, WORKTREE_DIR, `issue-${issueNumber}`);
   const branchName = `ck-watch/issue-${issueNumber}`;
   await spawnAndCollect("git", ["fetch", "origin", baseBranch], projectDir).catch(() => {
     logger.warning(`[worktree] Could not fetch origin/${baseBranch}, using local`);
@@ -68195,7 +68263,7 @@ async function createWorktree(projectDir, issueNumber, baseBranch) {
   return worktreePath;
 }
 async function removeWorktree(projectDir, issueNumber) {
-  const worktreePath = join125(projectDir, WORKTREE_DIR, `issue-${issueNumber}`);
+  const worktreePath = join127(projectDir, WORKTREE_DIR, `issue-${issueNumber}`);
   const branchName = `ck-watch/issue-${issueNumber}`;
   try {
     await spawnAndCollect("git", ["worktree", "remove", worktreePath, "--force"], projectDir);
@@ -68209,7 +68277,7 @@ async function listActiveWorktrees(projectDir) {
   try {
     const output2 = await spawnAndCollect("git", ["worktree", "list", "--porcelain"], projectDir);
     const issueNumbers = [];
-    const worktreePrefix = join125(projectDir, WORKTREE_DIR, "issue-").replace(/\\/g, "/");
+    const worktreePrefix = join127(projectDir, WORKTREE_DIR, "issue-").replace(/\\/g, "/");
     for (const line of output2.split(`
 `)) {
       if (line.startsWith("worktree ")) {
@@ -68237,7 +68305,7 @@ async function cleanupAllWorktrees(projectDir) {
   await spawnAndCollect("git", ["worktree", "prune"], projectDir).catch(() => {});
 }
 async function ensureGitignore(projectDir) {
-  const gitignorePath = join125(projectDir, ".gitignore");
+  const gitignorePath = join127(projectDir, ".gitignore");
   try {
     const content = existsSync60(gitignorePath) ? await readFile54(gitignorePath, "utf-8") : "";
     if (!content.includes(".worktrees")) {
@@ -68343,8 +68411,8 @@ var init_content_validator = __esm(() => {
 import { createHash as createHash6 } from "node:crypto";
 import { existsSync as existsSync66, mkdirSync as mkdirSync4, readFileSync as readFileSync15, readdirSync as readdirSync8, statSync as statSync10 } from "node:fs";
 import { rename as rename9, writeFile as writeFile35 } from "node:fs/promises";
-import { homedir as homedir34 } from "node:os";
-import { basename as basename19, join as join132 } from "node:path";
+import { homedir as homedir37 } from "node:os";
+import { basename as basename19, join as join134 } from "node:path";
 function getCachedContext(repoPath) {
   const cachePath = getCacheFilePath(repoPath);
   if (!existsSync66(cachePath))
@@ -68387,25 +68455,25 @@ function computeSourceHash(repoPath) {
 }
 function getDocSourcePaths(repoPath) {
   const paths = [];
-  const docsDir = join132(repoPath, "docs");
+  const docsDir = join134(repoPath, "docs");
   if (existsSync66(docsDir)) {
     try {
       const files = readdirSync8(docsDir);
       for (const f3 of files) {
         if (f3.endsWith(".md"))
-          paths.push(join132(docsDir, f3));
+          paths.push(join134(docsDir, f3));
       }
     } catch {}
   }
-  const readme = join132(repoPath, "README.md");
+  const readme = join134(repoPath, "README.md");
   if (existsSync66(readme))
     paths.push(readme);
-  const stylesDir = join132(repoPath, "assets", "writing-styles");
+  const stylesDir = join134(repoPath, "assets", "writing-styles");
   if (existsSync66(stylesDir)) {
     try {
       const files = readdirSync8(stylesDir);
       for (const f3 of files) {
-        paths.push(join132(stylesDir, f3));
+        paths.push(join134(stylesDir, f3));
       }
     } catch {}
   }
@@ -68414,11 +68482,11 @@ function getDocSourcePaths(repoPath) {
 function getCacheFilePath(repoPath) {
   const repoName = basename19(repoPath).replace(/[^a-zA-Z0-9_-]/g, "_");
   const pathHash = createHash6("sha256").update(repoPath).digest("hex").slice(0, 8);
-  return join132(CACHE_DIR, `${repoName}-${pathHash}-context-cache.json`);
+  return join134(CACHE_DIR, `${repoName}-${pathHash}-context-cache.json`);
 }
 var CACHE_DIR, CACHE_TTL_MS4;
 var init_context_cache_manager = __esm(() => {
-  CACHE_DIR = join132(homedir34(), ".claudekit", "cache");
+  CACHE_DIR = join134(homedir37(), ".claudekit", "cache");
   CACHE_TTL_MS4 = 24 * 60 * 60 * 1000;
 });
 
@@ -68599,7 +68667,7 @@ function extractContentFromResponse(response) {
 // src/commands/content/phases/docs-summarizer.ts
 import { execSync as execSync6 } from "node:child_process";
 import { existsSync as existsSync67, readFileSync as readFileSync16, readdirSync as readdirSync9 } from "node:fs";
-import { join as join133 } from "node:path";
+import { join as join135 } from "node:path";
 async function summarizeProjectDocs(repoPath, contentLogger) {
   const rawContent = collectRawDocs(repoPath);
   if (rawContent.total.length < 200) {
@@ -68653,12 +68721,12 @@ function collectRawDocs(repoPath) {
     return capped;
   };
   const docsContent = [];
-  const docsDir = join133(repoPath, "docs");
+  const docsDir = join135(repoPath, "docs");
   if (existsSync67(docsDir)) {
     try {
       const files = readdirSync9(docsDir).filter((f3) => f3.endsWith(".md")).sort();
       for (const f3 of files) {
-        const content = readCapped(join133(docsDir, f3), 5000);
+        const content = readCapped(join135(docsDir, f3), 5000);
         if (content) {
           docsContent.push(`### ${f3}
 ${content}`);
@@ -68672,21 +68740,21 @@ ${content}`);
   let brand = "";
   const brandCandidates = ["docs/brand-guidelines.md", "docs/design-guidelines.md"];
   for (const p of brandCandidates) {
-    brand = readCapped(join133(repoPath, p), 3000);
+    brand = readCapped(join135(repoPath, p), 3000);
     if (brand)
       break;
   }
   let styles3 = "";
-  const stylesDir = join133(repoPath, "assets", "writing-styles");
+  const stylesDir = join135(repoPath, "assets", "writing-styles");
   if (existsSync67(stylesDir)) {
     try {
       const files = readdirSync9(stylesDir).slice(0, 3);
-      styles3 = files.map((f3) => readCapped(join133(stylesDir, f3), 1000)).filter(Boolean).join(`
+      styles3 = files.map((f3) => readCapped(join135(stylesDir, f3), 1000)).filter(Boolean).join(`
 
 `);
     } catch {}
   }
-  const readme = readCapped(join133(repoPath, "README.md"), 3000);
+  const readme = readCapped(join135(repoPath, "README.md"), 3000);
   const total = [docs, brand, styles3, readme].join(`
 `);
   return { docs, brand, styles: styles3, readme, total };
@@ -68872,10 +68940,10 @@ IMPORTANT: Generate the image and output the path as JSON: {"imagePath": "/path/
 // src/commands/content/phases/photo-generator.ts
 import { execSync as execSync7 } from "node:child_process";
 import { existsSync as existsSync68, mkdirSync as mkdirSync5, readdirSync as readdirSync10 } from "node:fs";
-import { homedir as homedir35 } from "node:os";
-import { join as join134 } from "node:path";
+import { homedir as homedir38 } from "node:os";
+import { join as join136 } from "node:path";
 async function generatePhoto(_content, context, config, platform14, contentId, contentLogger) {
-  const mediaDir = join134(config.contentDir.replace(/^~/, homedir35()), "media", String(contentId));
+  const mediaDir = join136(config.contentDir.replace(/^~/, homedir38()), "media", String(contentId));
   if (!existsSync68(mediaDir)) {
     mkdirSync5(mediaDir, { recursive: true });
   }
@@ -68900,7 +68968,7 @@ async function generatePhoto(_content, context, config, platform14, contentId, c
     const imageFile = files.find((f3) => /\.(png|jpg|jpeg|webp)$/i.test(f3));
     if (imageFile) {
       const ext2 = imageFile.split(".").pop() ?? "png";
-      return { path: join134(mediaDir, imageFile), ...dimensions, format: ext2 };
+      return { path: join136(mediaDir, imageFile), ...dimensions, format: ext2 };
     }
     contentLogger.warn(`Photo generation produced no image for content ${contentId}`);
     return null;
@@ -68989,8 +69057,8 @@ var init_content_creator = __esm(() => {
 
 // src/commands/content/phases/content-logger.ts
 import { createWriteStream as createWriteStream4, existsSync as existsSync69, mkdirSync as mkdirSync6, statSync as statSync11 } from "node:fs";
-import { homedir as homedir36 } from "node:os";
-import { join as join135 } from "node:path";
+import { homedir as homedir39 } from "node:os";
+import { join as join137 } from "node:path";
 
 class ContentLogger {
   stream = null;
@@ -68998,7 +69066,7 @@ class ContentLogger {
   logDir;
   maxBytes;
   constructor(maxBytes = 0) {
-    this.logDir = join135(homedir36(), ".claudekit", "logs");
+    this.logDir = join137(homedir39(), ".claudekit", "logs");
     this.maxBytes = maxBytes;
   }
   init() {
@@ -69030,7 +69098,7 @@ class ContentLogger {
     }
   }
   getLogPath() {
-    return join135(this.logDir, `content-${this.getDateStr()}.log`);
+    return join137(this.logDir, `content-${this.getDateStr()}.log`);
   }
   write(level, message) {
     this.rotateIfNeeded();
@@ -69047,18 +69115,18 @@ class ContentLogger {
     if (dateStr !== this.currentDate) {
       this.close();
       this.currentDate = dateStr;
-      const logPath = join135(this.logDir, `content-${dateStr}.log`);
+      const logPath = join137(this.logDir, `content-${dateStr}.log`);
       this.stream = createWriteStream4(logPath, { flags: "a", mode: 384 });
       return;
     }
     if (this.maxBytes > 0 && this.stream) {
-      const logPath = join135(this.logDir, `content-${this.currentDate}.log`);
+      const logPath = join137(this.logDir, `content-${this.currentDate}.log`);
       try {
         const stat20 = statSync11(logPath);
         if (stat20.size >= this.maxBytes) {
           this.close();
           const suffix = Date.now();
-          const rotatedPath = join135(this.logDir, `content-${this.currentDate}-${suffix}.log`);
+          const rotatedPath = join137(this.logDir, `content-${this.currentDate}-${suffix}.log`);
           import("node:fs/promises").then(({ rename: rename10 }) => rename10(logPath, rotatedPath).catch(() => {}));
           this.stream = createWriteStream4(logPath, { flags: "w", mode: 384 });
         }
@@ -69096,7 +69164,7 @@ var init_sqlite_client = () => {};
 
 // src/commands/content/phases/db-manager.ts
 import { existsSync as existsSync70, mkdirSync as mkdirSync7 } from "node:fs";
-import { dirname as dirname34 } from "node:path";
+import { dirname as dirname35 } from "node:path";
 function initDatabase(dbPath) {
   ensureParentDir(dbPath);
   const db = openDatabase(dbPath);
@@ -69117,7 +69185,7 @@ function runRetentionCleanup(db, retentionDays = 90) {
   db.prepare("DELETE FROM git_events WHERE processed = 1 AND created_at < ?").run(cutoff);
 }
 function ensureParentDir(dbPath) {
-  const dir = dirname34(dbPath);
+  const dir = dirname35(dbPath);
   if (dir && !existsSync70(dir)) {
     mkdirSync7(dir, { recursive: true });
   }
@@ -69284,7 +69352,7 @@ function isNoiseCommit(title, author) {
 // src/commands/content/phases/change-detector.ts
 import { execSync as execSync9 } from "node:child_process";
 import { existsSync as existsSync71, readFileSync as readFileSync17, readdirSync as readdirSync11, statSync as statSync12 } from "node:fs";
-import { join as join136 } from "node:path";
+import { join as join138 } from "node:path";
 function detectCommits(repo, since) {
   try {
     const fetchUrl = sshToHttps(repo.remoteUrl);
@@ -69382,7 +69450,7 @@ function detectTags(repo, since) {
   }
 }
 function detectCompletedPlans(repo, since) {
-  const plansDir = join136(repo.path, "plans");
+  const plansDir = join138(repo.path, "plans");
   if (!existsSync71(plansDir))
     return [];
   const sinceMs = new Date(since).getTime();
@@ -69392,7 +69460,7 @@ function detectCompletedPlans(repo, since) {
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
-      const planFile = join136(plansDir, entry.name, "plan.md");
+      const planFile = join138(plansDir, entry.name, "plan.md");
       if (!existsSync71(planFile))
         continue;
       try {
@@ -69470,7 +69538,7 @@ function classifyCommit(event) {
 // src/commands/content/phases/repo-discoverer.ts
 import { execSync as execSync10 } from "node:child_process";
 import { readdirSync as readdirSync12 } from "node:fs";
-import { join as join137 } from "node:path";
+import { join as join139 } from "node:path";
 function discoverRepos2(cwd2) {
   const repos = [];
   if (isGitRepoRoot(cwd2)) {
@@ -69483,7 +69551,7 @@ function discoverRepos2(cwd2) {
     for (const entry of entries) {
       if (!entry.isDirectory() || entry.name.startsWith("."))
         continue;
-      const dirPath = join137(cwd2, entry.name);
+      const dirPath = join139(cwd2, entry.name);
       if (isGitRepoRoot(dirPath)) {
         const info = getRepoInfo(dirPath);
         if (info)
@@ -70150,9 +70218,9 @@ var init_types6 = __esm(() => {
 
 // src/commands/content/phases/state-manager.ts
 import { readFile as readFile56, rename as rename10, writeFile as writeFile36 } from "node:fs/promises";
-import { join as join138 } from "node:path";
+import { join as join140 } from "node:path";
 async function loadContentConfig(projectDir) {
-  const configPath = join138(projectDir, CK_CONFIG_FILE2);
+  const configPath = join140(projectDir, CK_CONFIG_FILE2);
   try {
     const raw2 = await readFile56(configPath, "utf-8");
     const json = JSON.parse(raw2);
@@ -70162,13 +70230,13 @@ async function loadContentConfig(projectDir) {
   }
 }
 async function saveContentConfig(projectDir, config) {
-  const configPath = join138(projectDir, CK_CONFIG_FILE2);
+  const configPath = join140(projectDir, CK_CONFIG_FILE2);
   const json = await readJsonSafe(configPath);
   json.content = { ...json.content, ...config };
   await atomicWrite(configPath, json);
 }
 async function loadContentState(projectDir) {
-  const configPath = join138(projectDir, CK_CONFIG_FILE2);
+  const configPath = join140(projectDir, CK_CONFIG_FILE2);
   try {
     const raw2 = await readFile56(configPath, "utf-8");
     const json = JSON.parse(raw2);
@@ -70179,7 +70247,7 @@ async function loadContentState(projectDir) {
   }
 }
 async function saveContentState(projectDir, state) {
-  const configPath = join138(projectDir, CK_CONFIG_FILE2);
+  const configPath = join140(projectDir, CK_CONFIG_FILE2);
   const sevenDaysAgo = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString().slice(0, 10);
   for (const key of Object.keys(state.dailyPostCounts)) {
     const dateStr = key.slice(-10);
@@ -70461,7 +70529,7 @@ var init_platform_setup_x = __esm(() => {
 
 // src/commands/content/phases/setup-wizard.ts
 import { existsSync as existsSync72 } from "node:fs";
-import { join as join139 } from "node:path";
+import { join as join141 } from "node:path";
 async function runSetupWizard2(cwd2, contentLogger) {
   console.log();
   oe(import_picocolors41.default.bgCyan(import_picocolors41.default.white(" CK Content — Multi-Channel Content Engine ")));
@@ -70529,8 +70597,8 @@ async function showRepoSummary(cwd2) {
 function detectBrandAssets(cwd2, contentLogger) {
   const repos = discoverRepos2(cwd2);
   for (const repo of repos) {
-    const hasGuidelines = existsSync72(join139(repo.path, "docs", "brand-guidelines.md"));
-    const hasStyles = existsSync72(join139(repo.path, "assets", "writing-styles"));
+    const hasGuidelines = existsSync72(join141(repo.path, "docs", "brand-guidelines.md"));
+    const hasStyles = existsSync72(join141(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`);
@@ -70597,11 +70665,11 @@ var init_setup_wizard = __esm(() => {
 
 // src/commands/content/content-review-commands.ts
 import { existsSync as existsSync73 } from "node:fs";
-import { homedir as homedir37 } from "node:os";
+import { homedir as homedir40 } from "node:os";
 async function queueContent() {
   const cwd2 = process.cwd();
   const config = await loadContentConfig(cwd2);
-  const dbPath = config.dbPath.replace(/^~/, homedir37());
+  const dbPath = config.dbPath.replace(/^~/, homedir40());
   if (!existsSync73(dbPath)) {
     logger.info("No content database found. Run 'ck content setup' first.");
     return;
@@ -70628,7 +70696,7 @@ async function queueContent() {
 async function approveContentCmd(id) {
   const cwd2 = process.cwd();
   const config = await loadContentConfig(cwd2);
-  const dbPath = config.dbPath.replace(/^~/, homedir37());
+  const dbPath = config.dbPath.replace(/^~/, homedir40());
   const db = initDatabase(dbPath);
   try {
     approveContent(db, Number.parseInt(id, 10));
@@ -70640,7 +70708,7 @@ async function approveContentCmd(id) {
 async function rejectContentCmd(id, reason) {
   const cwd2 = process.cwd();
   const config = await loadContentConfig(cwd2);
-  const dbPath = config.dbPath.replace(/^~/, homedir37());
+  const dbPath = config.dbPath.replace(/^~/, homedir40());
   const db = initDatabase(dbPath);
   try {
     rejectContent(db, Number.parseInt(id, 10), reason);
@@ -70671,10 +70739,10 @@ __export(exports_content_subcommands, {
   approveContentCmd: () => approveContentCmd
 });
 import { existsSync as existsSync74, readFileSync as readFileSync18, unlinkSync as unlinkSync5 } from "node:fs";
-import { homedir as homedir38 } from "node:os";
-import { join as join140 } from "node:path";
+import { homedir as homedir41 } from "node:os";
+import { join as join142 } from "node:path";
 function isDaemonRunning() {
-  const lockFile = join140(LOCK_DIR, `${LOCK_NAME2}.lock`);
+  const lockFile = join142(LOCK_DIR, `${LOCK_NAME2}.lock`);
   if (!existsSync74(lockFile))
     return { running: false, pid: null };
   try {
@@ -70706,7 +70774,7 @@ async function startContent(options2) {
   await contentCommand(options2);
 }
 async function stopContent() {
-  const lockFile = join140(LOCK_DIR, `${LOCK_NAME2}.lock`);
+  const lockFile = join142(LOCK_DIR, `${LOCK_NAME2}.lock`);
   if (!existsSync74(lockFile)) {
     logger.info("Content daemon is not running.");
     return;
@@ -70745,9 +70813,9 @@ async function statusContent() {
   } catch {}
 }
 async function logsContent(options2) {
-  const logDir = join140(homedir38(), ".claudekit", "logs");
+  const logDir = join142(homedir41(), ".claudekit", "logs");
   const dateStr = new Date().toISOString().slice(0, 10).replace(/-/g, "");
-  const logPath = join140(logDir, `content-${dateStr}.log`);
+  const logPath = join142(logDir, `content-${dateStr}.log`);
   if (!existsSync74(logPath)) {
     logger.info("No content logs found for today.");
     return;
@@ -70779,13 +70847,13 @@ var init_content_subcommands = __esm(() => {
   init_setup_wizard();
   init_state_manager();
   init_content_review_commands();
-  LOCK_DIR = join140(homedir38(), ".claudekit", "locks");
+  LOCK_DIR = join142(homedir41(), ".claudekit", "locks");
 });
 
 // src/commands/content/content-command.ts
 import { existsSync as existsSync75, mkdirSync as mkdirSync8, unlinkSync as unlinkSync6, writeFileSync as writeFileSync6 } from "node:fs";
-import { homedir as homedir39 } from "node:os";
-import { join as join141 } from "node:path";
+import { homedir as homedir42 } from "node:os";
+import { join as join143 } from "node:path";
 async function contentCommand(options2) {
   const cwd2 = process.cwd();
   const contentLogger = new ContentLogger;
@@ -70817,7 +70885,7 @@ async function contentCommand(options2) {
     if (!existsSync75(LOCK_DIR2))
       mkdirSync8(LOCK_DIR2, { recursive: true });
     writeFileSync6(LOCK_FILE, String(process.pid), "utf-8");
-    const dbPath = config.dbPath.replace(/^~/, homedir39());
+    const dbPath = config.dbPath.replace(/^~/, homedir42());
     const db = initDatabase(dbPath);
     contentLogger.info(`Database initialised at ${dbPath}`);
     const adapters = initializeAdapters(config);
@@ -70963,8 +71031,8 @@ var init_content_command = __esm(() => {
   init_publisher();
   init_review_manager();
   init_state_manager();
-  LOCK_DIR2 = join141(homedir39(), ".claudekit", "locks");
-  LOCK_FILE = join141(LOCK_DIR2, "ck-content.lock");
+  LOCK_DIR2 = join143(homedir42(), ".claudekit", "locks");
+  LOCK_FILE = join143(LOCK_DIR2, "ck-content.lock");
 });
 
 // src/commands/content/index.ts
@@ -76924,14 +76992,14 @@ async function checkCliInstallMethod() {
 }
 // src/domains/health-checks/checkers/claude-md-checker.ts
 import { existsSync as existsSync40, statSync as statSync5 } from "node:fs";
-import { join as join52 } from "node:path";
+import { join as join53 } from "node:path";
 function checkClaudeMd(setup, projectDir) {
   const results = [];
   if (setup.global.path) {
-    const globalClaudeMd = join52(setup.global.path, "CLAUDE.md");
+    const globalClaudeMd = join53(setup.global.path, "CLAUDE.md");
     results.push(checkClaudeMdFile(globalClaudeMd, "Global CLAUDE.md", "ck-global-claude-md"));
   }
-  const projectClaudeMd = join52(projectDir, ".claude", "CLAUDE.md");
+  const projectClaudeMd = join53(projectDir, ".claude", "CLAUDE.md");
   results.push(checkClaudeMdFile(projectClaudeMd, "Project CLAUDE.md", "ck-project-claude-md"));
   return results;
 }
@@ -76990,9 +77058,9 @@ function checkClaudeMdFile(path5, name, id) {
 }
 // src/domains/health-checks/checkers/active-plan-checker.ts
 import { existsSync as existsSync41, readFileSync as readFileSync11 } from "node:fs";
-import { join as join53 } from "node:path";
+import { join as join54 } from "node:path";
 function checkActivePlan(projectDir) {
-  const activePlanPath = join53(projectDir, ".claude", "active-plan");
+  const activePlanPath = join54(projectDir, ".claude", "active-plan");
   if (!existsSync41(activePlanPath)) {
     return {
       id: "ck-active-plan",
@@ -77006,7 +77074,7 @@ function checkActivePlan(projectDir) {
   }
   try {
     const targetPath = readFileSync11(activePlanPath, "utf-8").trim();
-    const fullPath = join53(projectDir, targetPath);
+    const fullPath = join54(projectDir, targetPath);
     if (!existsSync41(fullPath)) {
       return {
         id: "ck-active-plan",
@@ -77044,13 +77112,13 @@ function checkActivePlan(projectDir) {
 }
 // src/domains/health-checks/checkers/skills-checker.ts
 import { existsSync as existsSync42 } from "node:fs";
-import { join as join54 } from "node:path";
+import { join as join55 } from "node:path";
 function checkSkillsScripts(setup) {
   const results = [];
   const platform5 = process.platform;
   const scriptName = platform5 === "win32" ? "install.ps1" : "install.sh";
   if (setup.global.path) {
-    const globalScriptPath = join54(setup.global.path, "skills", scriptName);
+    const globalScriptPath = join55(setup.global.path, "skills", scriptName);
     const hasGlobalScript = existsSync42(globalScriptPath);
     results.push({
       id: "ck-global-skills-script",
@@ -77065,7 +77133,7 @@ function checkSkillsScripts(setup) {
     });
   }
   if (setup.project.metadata) {
-    const projectScriptPath = join54(setup.project.path, "skills", scriptName);
+    const projectScriptPath = join55(setup.project.path, "skills", scriptName);
     const hasProjectScript = existsSync42(projectScriptPath);
     results.push({
       id: "ck-project-skills-script",
@@ -77104,7 +77172,7 @@ function checkComponentCounts(setup) {
 init_logger();
 init_path_resolver();
 import { constants as constants2, access as access2, unlink as unlink7, writeFile as writeFile16 } from "node:fs/promises";
-import { join as join55 } from "node:path";
+import { join as join56 } from "node:path";
 
 // src/domains/health-checks/checkers/shared.ts
 init_environment();
@@ -77170,7 +77238,7 @@ async function checkGlobalDirWritable() {
   }
   const timestamp = Date.now();
   const random = Math.random().toString(36).substring(2);
-  const testFile = join55(globalDir, `.ck-write-test-${timestamp}-${random}`);
+  const testFile = join56(globalDir, `.ck-write-test-${timestamp}-${random}`);
   try {
     await writeFile16(testFile, "test", { encoding: "utf-8", flag: "wx" });
   } catch (error) {
@@ -77206,7 +77274,7 @@ async function checkGlobalDirWritable() {
 init_path_resolver();
 import { existsSync as existsSync43 } from "node:fs";
 import { readdir as readdir10 } from "node:fs/promises";
-import { join as join56 } from "node:path";
+import { join as join57 } from "node:path";
 
 // src/domains/health-checks/utils/path-normalizer.ts
 import { normalize as normalize4 } from "node:path";
@@ -77218,8 +77286,8 @@ function normalizePath2(filePath) {
 
 // src/domains/health-checks/checkers/hooks-checker.ts
 async function checkHooksExist(projectDir) {
-  const globalHooksDir = join56(PathResolver.getGlobalKitDir(), "hooks");
-  const projectHooksDir = join56(projectDir, ".claude", "hooks");
+  const globalHooksDir = join57(PathResolver.getGlobalKitDir(), "hooks");
+  const projectHooksDir = join57(projectDir, ".claude", "hooks");
   const globalExists = existsSync43(globalHooksDir);
   const projectExists = existsSync43(projectHooksDir);
   let hookCount = 0;
@@ -77228,7 +77296,7 @@ async function checkHooksExist(projectDir) {
     const files = await readdir10(globalHooksDir, { withFileTypes: false });
     const hooks = files.filter((f3) => HOOK_EXTENSIONS2.some((ext) => f3.endsWith(ext)));
     hooks.forEach((hook) => {
-      const fullPath = join56(globalHooksDir, hook);
+      const fullPath = join57(globalHooksDir, hook);
       checkedFiles.add(normalizePath2(fullPath));
     });
   }
@@ -77238,7 +77306,7 @@ async function checkHooksExist(projectDir) {
     const files = await readdir10(projectHooksDir, { withFileTypes: false });
     const hooks = files.filter((f3) => HOOK_EXTENSIONS2.some((ext) => f3.endsWith(ext)));
     hooks.forEach((hook) => {
-      const fullPath = join56(projectHooksDir, hook);
+      const fullPath = join57(projectHooksDir, hook);
       checkedFiles.add(normalizePath2(fullPath));
     });
   }
@@ -77270,10 +77338,10 @@ init_logger();
 init_path_resolver();
 import { existsSync as existsSync44 } from "node:fs";
 import { readFile as readFile31 } from "node:fs/promises";
-import { join as join57 } from "node:path";
+import { join as join58 } from "node:path";
 async function checkSettingsValid(projectDir) {
-  const globalSettings = join57(PathResolver.getGlobalKitDir(), "settings.json");
-  const projectSettings = join57(projectDir, ".claude", "settings.json");
+  const globalSettings = join58(PathResolver.getGlobalKitDir(), "settings.json");
+  const projectSettings = join58(projectDir, ".claude", "settings.json");
   const settingsPath = existsSync44(globalSettings) ? globalSettings : existsSync44(projectSettings) ? projectSettings : null;
   if (!settingsPath) {
     return {
@@ -77345,11 +77413,11 @@ init_logger();
 init_path_resolver();
 import { existsSync as existsSync45 } from "node:fs";
 import { readFile as readFile32 } from "node:fs/promises";
-import { homedir as homedir28 } from "node:os";
-import { dirname as dirname19, join as join58, normalize as normalize5, resolve as resolve14 } from "node:path";
+import { homedir as homedir29 } from "node:os";
+import { dirname as dirname19, join as join59, normalize as normalize5, resolve as resolve14 } from "node:path";
 async function checkPathRefsValid(projectDir) {
-  const globalClaudeMd = join58(PathResolver.getGlobalKitDir(), "CLAUDE.md");
-  const projectClaudeMd = join58(projectDir, ".claude", "CLAUDE.md");
+  const globalClaudeMd = join59(PathResolver.getGlobalKitDir(), "CLAUDE.md");
+  const projectClaudeMd = join59(projectDir, ".claude", "CLAUDE.md");
   const claudeMdPath = existsSync45(globalClaudeMd) ? globalClaudeMd : existsSync45(projectClaudeMd) ? projectClaudeMd : null;
   if (!claudeMdPath) {
     return {
@@ -77378,7 +77446,7 @@ async function checkPathRefsValid(projectDir) {
       };
     }
     const baseDir = dirname19(claudeMdPath);
-    const home8 = homedir28();
+    const home8 = homedir29();
     const broken = [];
     for (const ref of refs) {
       let refPath;
@@ -77444,7 +77512,7 @@ async function checkPathRefsValid(projectDir) {
 // src/domains/health-checks/checkers/config-completeness-checker.ts
 import { existsSync as existsSync46 } from "node:fs";
 import { readdir as readdir11 } from "node:fs/promises";
-import { join as join59 } from "node:path";
+import { join as join60 } from "node:path";
 async function checkProjectConfigCompleteness(setup, projectDir) {
   if (setup.project.path === setup.global.path) {
     return {
@@ -77457,16 +77525,16 @@ async function checkProjectConfigCompleteness(setup, projectDir) {
       autoFixable: false
     };
   }
-  const projectClaudeDir = join59(projectDir, ".claude");
+  const projectClaudeDir = join60(projectDir, ".claude");
   const requiredDirs = ["agents", "commands", "skills"];
   const missingDirs = [];
   for (const dir of requiredDirs) {
-    const dirPath = join59(projectClaudeDir, dir);
+    const dirPath = join60(projectClaudeDir, dir);
     if (!existsSync46(dirPath)) {
       missingDirs.push(dir);
     }
   }
-  const hasRulesOrWorkflows = existsSync46(join59(projectClaudeDir, "rules")) || existsSync46(join59(projectClaudeDir, "workflows"));
+  const hasRulesOrWorkflows = existsSync46(join60(projectClaudeDir, "rules")) || existsSync46(join60(projectClaudeDir, "workflows"));
   if (!hasRulesOrWorkflows) {
     missingDirs.push("rules");
   }
@@ -77511,7 +77579,7 @@ async function checkProjectConfigCompleteness(setup, projectDir) {
   };
 }
 // src/domains/health-checks/checkers/env-keys-checker.ts
-import { join as join61 } from "node:path";
+import { join as join62 } from "node:path";
 
 // src/domains/installation/setup-wizard.ts
 init_config_generator();
@@ -77520,7 +77588,7 @@ init_logger();
 init_path_resolver();
 init_dist2();
 var import_fs_extra6 = __toESM(require_lib3(), 1);
-import { join as join60 } from "node:path";
+import { join as join61 } from "node:path";
 var REQUIRED_ENV_KEYS = [
   { key: "GEMINI_API_KEY", label: "Gemini API Key" }
 ];
@@ -77597,7 +77665,7 @@ async function parseEnvFile(path5) {
   }
 }
 async function checkGlobalConfig() {
-  const globalEnvPath = join60(PathResolver.getGlobalKitDir(), ".env");
+  const globalEnvPath = join61(PathResolver.getGlobalKitDir(), ".env");
   if (!await import_fs_extra6.pathExists(globalEnvPath))
     return false;
   const env2 = await parseEnvFile(globalEnvPath);
@@ -77613,7 +77681,7 @@ async function runSetupWizard(options2) {
   let globalEnv = {};
   const hasGlobalConfig = !isGlobal && await checkGlobalConfig();
   if (!isGlobal) {
-    const globalEnvPath = join60(PathResolver.getGlobalKitDir(), ".env");
+    const globalEnvPath = join61(PathResolver.getGlobalKitDir(), ".env");
     if (await import_fs_extra6.pathExists(globalEnvPath)) {
       globalEnv = await parseEnvFile(globalEnvPath);
     }
@@ -77676,7 +77744,7 @@ async function runSetupWizard(options2) {
     }
   }
   await generateEnvFile(targetDir, values);
-  f2.success(`Configuration saved to ${join60(targetDir, ".env")}`);
+  f2.success(`Configuration saved to ${join61(targetDir, ".env")}`);
   return true;
 }
 async function promptForAdditionalGeminiKeys(primaryKey) {
@@ -77751,7 +77819,7 @@ Optional: DISCORD_WEBHOOK_URL, TELEGRAM_BOT_TOKEN`, "Configuration skipped");
 async function checkEnvKeys(setup) {
   const results = [];
   if (setup.global.path) {
-    const globalEnvPath = join61(setup.global.path, ".env");
+    const globalEnvPath = join62(setup.global.path, ".env");
     const globalCheck = await checkRequiredKeysExist(globalEnvPath);
     if (!globalCheck.allPresent) {
       const missingKeys = globalCheck.missing.map((m2) => m2.label).join(", ");
@@ -77780,7 +77848,7 @@ async function checkEnvKeys(setup) {
     }
   }
   if (setup.project.metadata) {
-    const projectEnvPath = join61(setup.project.path, ".env");
+    const projectEnvPath = join62(setup.project.path, ".env");
     const projectCheck = await checkRequiredKeysExist(projectEnvPath);
     if (!projectCheck.allPresent) {
       const missingKeys = projectCheck.missing.map((m2) => m2.label).join(", ");
@@ -77811,14 +77879,16 @@ async function checkEnvKeys(setup) {
   return results;
 }
 // src/domains/health-checks/checkers/hook-health-checker.ts
+init_settings_merger();
 init_claudekit_constants();
+init_command_normalizer();
 init_logger();
 init_path_resolver();
 import { spawnSync as spawnSync2 } from "node:child_process";
 import { existsSync as existsSync47, readFileSync as readFileSync12, statSync as statSync6, writeFileSync as writeFileSync4 } from "node:fs";
 import { readdir as readdir12 } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join as join62, resolve as resolve15 } from "node:path";
+import { homedir as homedir30, tmpdir } from "node:os";
+import { join as join63, resolve as resolve15 } from "node:path";
 var HOOK_CHECK_TIMEOUT_MS = 5000;
 var PYTHON_CHECK_TIMEOUT_MS = 3000;
 var MAX_LOG_FILE_SIZE_BYTES = 10 * 1024 * 1024;
@@ -77834,6 +77904,117 @@ function getHooksDir(projectDir) {
 function isPathWithin(filePath, parentDir) {
   return resolve15(filePath).startsWith(resolve15(parentDir));
 }
+function getCanonicalGlobalCommandRoot() {
+  const configuredGlobalDir = PathResolver.getGlobalKitDir().replace(/\\/g, "/").replace(/\/+$/, "");
+  const defaultGlobalDir = join63(homedir30(), ".claude").replace(/\\/g, "/");
+  return configuredGlobalDir === defaultGlobalDir ? "$HOME" : configuredGlobalDir;
+}
+function getClaudeSettingsFiles(projectDir) {
+  const globalClaudeDir = PathResolver.getGlobalKitDir();
+  const candidates = [
+    {
+      path: resolve15(projectDir, ".claude", "settings.json"),
+      label: "project settings.json",
+      root: "$CLAUDE_PROJECT_DIR"
+    },
+    {
+      path: resolve15(projectDir, ".claude", "settings.local.json"),
+      label: "project settings.local.json",
+      root: "$CLAUDE_PROJECT_DIR"
+    },
+    {
+      path: resolve15(globalClaudeDir, "settings.json"),
+      label: "global settings.json",
+      root: getCanonicalGlobalCommandRoot()
+    },
+    {
+      path: resolve15(globalClaudeDir, "settings.local.json"),
+      label: "global settings.local.json",
+      root: getCanonicalGlobalCommandRoot()
+    }
+  ];
+  return candidates.filter((candidate) => existsSync47(candidate.path));
+}
+function collectHookCommandFindings(settings, settingsFile) {
+  if (!settings.hooks) {
+    return [];
+  }
+  const findings = [];
+  for (const [eventName, entries] of Object.entries(settings.hooks)) {
+    for (const entry of entries) {
+      if ("command" in entry && typeof entry.command === "string") {
+        const repair = repairClaudeNodeCommandPath(entry.command, settingsFile.root);
+        if (repair.changed && repair.issue) {
+          findings.push({
+            path: settingsFile.path,
+            label: settingsFile.label,
+            eventName,
+            command: entry.command,
+            expected: repair.command,
+            issue: repair.issue
+          });
+        }
+      }
+      if (!("hooks" in entry) || !entry.hooks) {
+        continue;
+      }
+      for (const hook of entry.hooks) {
+        if (!hook.command) {
+          continue;
+        }
+        const repair = repairClaudeNodeCommandPath(hook.command, settingsFile.root);
+        if (!repair.changed || !repair.issue) {
+          continue;
+        }
+        findings.push({
+          path: settingsFile.path,
+          label: settingsFile.label,
+          eventName,
+          matcher: "matcher" in entry ? entry.matcher : undefined,
+          command: hook.command,
+          expected: repair.command,
+          issue: repair.issue
+        });
+      }
+    }
+  }
+  return findings;
+}
+async function repairHookCommandsInSettingsFile(settingsFile) {
+  const settings = await SettingsMerger.readSettingsFile(settingsFile.path);
+  if (!settings?.hooks) {
+    return 0;
+  }
+  let repaired = 0;
+  for (const entries of Object.values(settings.hooks)) {
+    for (const entry of entries) {
+      if ("command" in entry && typeof entry.command === "string") {
+        const repair = repairClaudeNodeCommandPath(entry.command, settingsFile.root);
+        if (repair.changed) {
+          entry.command = repair.command;
+          repaired++;
+        }
+      }
+      if (!("hooks" in entry) || !entry.hooks) {
+        continue;
+      }
+      for (const hook of entry.hooks) {
+        if (!hook.command) {
+          continue;
+        }
+        const repair = repairClaudeNodeCommandPath(hook.command, settingsFile.root);
+        if (repair.changed) {
+          hook.command = repair.command;
+          repaired++;
+        }
+      }
+    }
+  }
+  if (repaired > 0) {
+    await SettingsMerger.writeSettingsFile(settingsFile.path, settings);
+  }
+  return repaired;
+}
 async function checkHookSyntax(projectDir) {
   const hooksDir = getHooksDir(projectDir);
   if (!hooksDir) {
@@ -77863,7 +78044,7 @@ async function checkHookSyntax(projectDir) {
     }
     const errors2 = [];
     for (const file of cjsFiles) {
-      const filePath = join62(hooksDir, file);
+      const filePath = join63(hooksDir, file);
       if (!isPathWithin(filePath, hooksDir))
         continue;
       const result = spawnSync2("node", ["--check", filePath], {
@@ -77949,7 +78130,7 @@ async function checkHookDeps(projectDir) {
     const missingDeps = [];
     const requireRegex = /require\(['"]([^'"]+)['"]\)/g;
     for (const file of cjsFiles) {
-      const filePath = join62(hooksDir, file);
+      const filePath = join63(hooksDir, file);
       if (!isPathWithin(filePath, hooksDir))
         continue;
       const content = readFileSync12(filePath, "utf-8");
@@ -77959,10 +78140,10 @@ async function checkHookDeps(projectDir) {
           continue;
         }
         if (depPath.startsWith(".")) {
-          const resolvedPath = join62(hooksDir, depPath);
+          const resolvedPath = join63(hooksDir, depPath);
           const extensions = [".js", ".cjs", ".mjs", ".json"];
           const indexFiles = ["index.js", "index.cjs", "index.mjs"];
-          const exists = existsSync47(resolvedPath) || extensions.some((ext) => existsSync47(resolvedPath + ext)) || indexFiles.some((idx) => existsSync47(join62(resolvedPath, idx)));
+          const exists = existsSync47(resolvedPath) || extensions.some((ext) => existsSync47(resolvedPath + ext)) || indexFiles.some((idx) => existsSync47(join63(resolvedPath, idx)));
           if (!exists) {
             missingDeps.push(`${file}: ${depPath}`);
           }
@@ -78079,11 +78260,11 @@ async function checkHookRuntime(projectDir) {
     }
     const syntheticPayload = JSON.stringify({
       tool_name: "Read",
-      tool_input: { file_path: join62(tmpdir(), "ck-doctor-test.txt") }
+      tool_input: { file_path: join63(tmpdir(), "ck-doctor-test.txt") }
     });
     const failures = [];
     for (const file of cjsFiles) {
-      const filePath = join62(hooksDir, file);
+      const filePath = join63(hooksDir, file);
       if (!isPathWithin(filePath, hooksDir))
         continue;
       const result = spawnSync2("node", [filePath], {
@@ -78144,9 +78325,85 @@ async function checkHookRuntime(projectDir) {
     };
   }
 }
+async function checkHookCommandPaths(projectDir) {
+  const settingsFiles = getClaudeSettingsFiles(projectDir);
+  if (settingsFiles.length === 0) {
+    return {
+      id: "hook-command-paths",
+      name: "Hook Command Paths",
+      group: "claudekit",
+      priority: "standard",
+      status: "info",
+      message: "No Claude settings files",
+      autoFixable: false
+    };
+  }
+  const findings = [];
+  for (const settingsFile of settingsFiles) {
+    const settings = await SettingsMerger.readSettingsFile(settingsFile.path);
+    if (!settings) {
+      continue;
+    }
+    findings.push(...collectHookCommandFindings(settings, settingsFile));
+  }
+  if (findings.length === 0) {
+    return {
+      id: "hook-command-paths",
+      name: "Hook Command Paths",
+      group: "claudekit",
+      priority: "standard",
+      status: "pass",
+      message: `${settingsFiles.length} settings file(s) canonical`,
+      autoFixable: false
+    };
+  }
+  const details = findings.slice(0, 5).map((finding) => {
+    const matcher = finding.matcher ? ` [${finding.matcher}]` : "";
+    return `${finding.label} :: ${finding.eventName}${matcher} :: ${finding.issue} :: ${finding.command}`;
+  }).join(`
+`);
+  return {
+    id: "hook-command-paths",
+    name: "Hook Command Paths",
+    group: "claudekit",
+    priority: "standard",
+    status: "fail",
+    message: `${findings.length} stale hook command path(s)`,
+    details,
+    suggestion: "Run: ck doctor --fix",
+    autoFixable: true,
+    fix: {
+      id: "fix-hook-command-paths",
+      description: "Canonicalize stale .claude hook command paths in settings files",
+      execute: async () => {
+        try {
+          let repaired = 0;
+          for (const settingsFile of settingsFiles) {
+            repaired += await repairHookCommandsInSettingsFile(settingsFile);
+          }
+          if (repaired === 0) {
+            return {
+              success: true,
+              message: "No stale hook command paths needed repair"
+            };
+          }
+          return {
+            success: true,
+            message: `Repaired ${repaired} stale hook command path(s)`
+          };
+        } catch (error) {
+          return {
+            success: false,
+            message: `Failed to repair hook command paths: ${error}`
+          };
+        }
+      }
+    }
+  };
+}
 async function checkHookConfig(projectDir) {
-  const projectConfigPath = join62(projectDir, ".claude", ".ck.json");
-  const globalConfigPath = join62(PathResolver.getGlobalKitDir(), ".ck.json");
+  const projectConfigPath = join63(projectDir, ".claude", ".ck.json");
+  const globalConfigPath = join63(PathResolver.getGlobalKitDir(), ".ck.json");
   const configPath = existsSync47(projectConfigPath) ? projectConfigPath : existsSync47(globalConfigPath) ? globalConfigPath : null;
   if (!configPath) {
     return {
@@ -78270,7 +78527,7 @@ async function checkHookLogs(projectDir) {
       autoFixable: false
     };
   }
-  const logPath = join62(hooksDir, ".logs", "hook-log.jsonl");
+  const logPath = join63(hooksDir, ".logs", "hook-log.jsonl");
   if (!existsSync47(logPath)) {
     return {
       id: "hook-logs",
@@ -78525,9 +78782,9 @@ async function checkCliVersion() {
 }
 async function checkPythonVenv(projectDir) {
   const isWindows3 = process.platform === "win32";
-  const venvBin = isWindows3 ? join62("Scripts", "python.exe") : join62("bin", "python3");
-  const projectVenvPath = join62(projectDir, ".claude", "skills", ".venv", venvBin);
-  const globalVenvPath = join62(PathResolver.getGlobalKitDir(), "skills", ".venv", venvBin);
+  const venvBin = isWindows3 ? join63("Scripts", "python.exe") : join63("bin", "python3");
+  const projectVenvPath = join63(projectDir, ".claude", "skills", ".venv", venvBin);
+  const globalVenvPath = join63(PathResolver.getGlobalKitDir(), "skills", ".venv", venvBin);
   const venvPath = existsSync47(projectVenvPath) ? projectVenvPath : existsSync47(globalVenvPath) ? globalVenvPath : null;
   if (!venvPath) {
     return {
@@ -78643,6 +78900,8 @@ class ClaudekitChecker {
     results.push(await checkHookDeps(this.projectDir));
     logger.verbose("ClaudekitChecker: Checking hook runtime");
     results.push(await checkHookRuntime(this.projectDir));
+    logger.verbose("ClaudekitChecker: Checking hook command paths");
+    results.push(await checkHookCommandPaths(this.projectDir));
     logger.verbose("ClaudekitChecker: Checking hook config");
     results.push(await checkHookConfig(this.projectDir));
     logger.verbose("ClaudekitChecker: Checking hook crash logs");
@@ -79007,8 +79266,8 @@ import { platform as platform6 } from "node:os";
 init_environment();
 init_path_resolver();
 import { constants as constants3, access as access3, mkdir as mkdir14, readFile as readFile34, unlink as unlink8, writeFile as writeFile17 } from "node:fs/promises";
-import { arch as arch2, homedir as homedir29, platform as platform5 } from "node:os";
-import { join as join64, normalize as normalize6 } from "node:path";
+import { arch as arch2, homedir as homedir31, platform as platform5 } from "node:os";
+import { join as join65, normalize as normalize6 } from "node:path";
 function shouldSkipExpensiveOperations4() {
   return shouldSkipExpensiveOperations();
 }
@@ -79030,7 +79289,7 @@ async function checkPlatformDetect() {
   };
 }
 async function checkHomeDirResolution() {
-  const nodeHome = normalize6(homedir29());
+  const nodeHome = normalize6(homedir31());
   const rawEnvHome = getHomeDirectoryFromEnv(platform5());
   const envHome = rawEnvHome ? normalize6(rawEnvHome) : "";
   const match = nodeHome === envHome && envHome !== "";
@@ -79099,7 +79358,7 @@ async function checkGlobalDirAccess() {
       autoFixable: false
     };
   }
-  const testFile = join64(globalDir, ".ck-doctor-access-test");
+  const testFile = join65(globalDir, ".ck-doctor-access-test");
   try {
     await mkdir14(globalDir, { recursive: true });
     await writeFile17(testFile, "test", "utf-8");
@@ -79177,7 +79436,7 @@ async function checkWSLBoundary() {
 // src/domains/health-checks/platform/windows-checker.ts
 init_path_resolver();
 import { mkdir as mkdir15, symlink, unlink as unlink9, writeFile as writeFile18 } from "node:fs/promises";
-import { join as join65 } from "node:path";
+import { join as join66 } from "node:path";
 async function checkLongPathSupport() {
   if (shouldSkipExpensiveOperations4()) {
     return {
@@ -79229,8 +79488,8 @@ async function checkSymlinkSupport() {
     };
   }
   const testDir = PathResolver.getGlobalKitDir();
-  const target = join65(testDir, ".ck-symlink-test-target");
-  const link = join65(testDir, ".ck-symlink-test-link");
+  const target = join66(testDir, ".ck-symlink-test-target");
+  const link = join66(testDir, ".ck-symlink-test-link");
   try {
     await mkdir15(testDir, { recursive: true });
     await writeFile18(target, "test", "utf-8");
@@ -79524,7 +79783,7 @@ class AutoHealer {
 import { execSync as execSync3, spawnSync as spawnSync5 } from "node:child_process";
 import { readFileSync as readFileSync13, unlinkSync, writeFileSync as writeFileSync5 } from "node:fs";
 import { tmpdir as tmpdir3 } from "node:os";
-import { dirname as dirname20, join as join66 } from "node:path";
+import { dirname as dirname20, join as join67 } from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 init_environment();
 init_logger();
@@ -79532,7 +79791,7 @@ init_dist2();
 function getCliVersion4() {
   try {
     const __dirname4 = dirname20(fileURLToPath4(import.meta.url));
-    const pkgPath = join66(__dirname4, "../../../package.json");
+    const pkgPath = join67(__dirname4, "../../../package.json");
     const pkg = JSON.parse(readFileSync13(pkgPath, "utf-8"));
     return pkg.version || "unknown";
   } catch (err) {
@@ -79671,7 +79930,7 @@ class ReportGenerator {
         return null;
       }
     }
-    const tmpFile = join66(tmpdir3(), `ck-report-${Date.now()}.txt`);
+    const tmpFile = join67(tmpdir3(), `ck-report-${Date.now()}.txt`);
     writeFileSync5(tmpFile, report);
     try {
       const result = spawnSync5("gh", ["gist", "create", tmpFile, "--desc", "ClaudeKit Diagnostic Report"], {
@@ -79997,7 +80256,7 @@ init_claudekit_constants();
 init_logger();
 init_path_resolver();
 import { mkdir as mkdir16, readFile as readFile35, unlink as unlink10, writeFile as writeFile19 } from "node:fs/promises";
-import { join as join67 } from "node:path";
+import { join as join68 } from "node:path";
 var CACHE_TTL_HOURS = 24;
 var DEFAULT_CACHE_TTL_MS = CACHE_TTL_HOURS * 60 * 60 * 1000;
 var MIN_CACHE_TTL_MS = 60 * 1000;
@@ -80034,7 +80293,7 @@ var KIT_REPOS = {
 class ConfigVersionChecker {
   static getCacheFilePath(kitType, global3) {
     const cacheDir = PathResolver.getCacheDir(global3);
-    return join67(cacheDir, `${kitType}-${CACHE_FILENAME}`);
+    return join68(cacheDir, `${kitType}-${CACHE_FILENAME}`);
   }
   static async loadCache(kitType, global3) {
     try {
@@ -80197,7 +80456,7 @@ class ConfigVersionChecker {
 }
 // src/domains/sync/sync-engine.ts
 import { lstat as lstat3, readFile as readFile36, readlink, realpath as realpath3, stat as stat9 } from "node:fs/promises";
-import { isAbsolute as isAbsolute3, join as join68, normalize as normalize7, relative as relative8 } from "node:path";
+import { isAbsolute as isAbsolute3, join as join69, normalize as normalize7, relative as relative8 } from "node:path";
 
 // src/services/file-operations/ownership-checker.ts
 init_metadata_migration();
@@ -81558,7 +81817,7 @@ async function validateSymlinkChain(path6, basePath, maxDepth = MAX_SYMLINK_DEPT
       if (!stats.isSymbolicLink())
         break;
       const target = await readlink(current);
-      const resolvedTarget = isAbsolute3(target) ? target : join68(current, "..", target);
+      const resolvedTarget = isAbsolute3(target) ? target : join69(current, "..", target);
       const normalizedTarget = normalize7(resolvedTarget);
       const rel = relative8(basePath, normalizedTarget);
       if (rel.startsWith("..") || isAbsolute3(rel)) {
@@ -81594,7 +81853,7 @@ async function validateSyncPath(basePath, filePath) {
   if (normalized.startsWith("..") || normalized.includes("/../")) {
     throw new Error(`Path traversal not allowed: ${filePath}`);
   }
-  const fullPath = join68(basePath, normalized);
+  const fullPath = join69(basePath, normalized);
   const rel = relative8(basePath, fullPath);
   if (rel.startsWith("..") || isAbsolute3(rel)) {
     throw new Error(`Path escapes base directory: ${filePath}`);
@@ -81609,7 +81868,7 @@ async function validateSyncPath(basePath, filePath) {
     }
   } catch (error) {
     if (error.code === "ENOENT") {
-      const parentPath = join68(fullPath, "..");
+      const parentPath = join69(fullPath, "..");
       try {
         const resolvedBase = await realpath3(basePath);
         const resolvedParent = await realpath3(parentPath);
@@ -82828,7 +83087,7 @@ init_logger();
 var import_proper_lockfile4 = __toESM(require_proper_lockfile(), 1);
 import { mkdir as mkdir19 } from "node:fs/promises";
 import os5 from "node:os";
-import { join as join75 } from "node:path";
+import { join as join76 } from "node:path";
 var LOCK_CONFIG = {
   stale: 60000,
   retries: 0
@@ -82836,12 +83095,12 @@ var LOCK_CONFIG = {
 var activeLocks = new Set;
 var cleanupRegistered = false;
 function getLocksDir() {
-  return join75(os5.homedir(), ".claudekit", "locks");
+  return join76(os5.homedir(), ".claudekit", "locks");
 }
 function cleanupLocks() {
   for (const name of activeLocks) {
     try {
-      const lockPath = join75(getLocksDir(), `${name}.lock`);
+      const lockPath = join76(getLocksDir(), `${name}.lock`);
       import_proper_lockfile4.default.unlockSync(lockPath, { realpath: false });
     } catch {
       try {
@@ -82864,7 +83123,7 @@ async function ensureLocksDir() {
 async function withProcessLock(lockName, fn) {
   registerCleanupHandlers();
   await ensureLocksDir();
-  const lockPath = join75(getLocksDir(), `${lockName}.lock`);
+  const lockPath = join76(getLocksDir(), `${lockName}.lock`);
   let release;
   try {
     release = await import_proper_lockfile4.default.lock(lockPath, { ...LOCK_CONFIG, realpath: false });
@@ -82896,7 +83155,7 @@ init_logger();
 init_logger();
 init_path_resolver();
 var import_fs_extra7 = __toESM(require_lib3(), 1);
-import { join as join76 } from "node:path";
+import { join as join77 } from "node:path";
 async function handleConflicts(ctx) {
   if (ctx.cancelled)
     return ctx;
@@ -82905,7 +83164,7 @@ async function handleConflicts(ctx) {
   if (PathResolver.isLocalSameAsGlobal()) {
     return ctx;
   }
-  const localSettingsPath = join76(process.cwd(), ".claude", "settings.json");
+  const localSettingsPath = join77(process.cwd(), ".claude", "settings.json");
   if (!await import_fs_extra7.pathExists(localSettingsPath)) {
     return ctx;
   }
@@ -82920,7 +83179,7 @@ async function handleConflicts(ctx) {
     return { ...ctx, cancelled: true };
   }
   if (choice === "remove") {
-    const localClaudeDir = join76(process.cwd(), ".claude");
+    const localClaudeDir = join77(process.cwd(), ".claude");
     try {
       await import_fs_extra7.remove(localClaudeDir);
       logger.success("Removed local .claude/ directory");
@@ -83017,7 +83276,7 @@ init_logger();
 init_safe_spinner();
 import { mkdir as mkdir25, stat as stat12 } from "node:fs/promises";
 import { tmpdir as tmpdir4 } from "node:os";
-import { join as join83 } from "node:path";
+import { join as join84 } from "node:path";
 
 // src/shared/temp-cleanup.ts
 init_logger();
@@ -83036,7 +83295,7 @@ init_logger();
 init_output_manager();
 import { createWriteStream as createWriteStream2, rmSync as rmSync2 } from "node:fs";
 import { mkdir as mkdir20 } from "node:fs/promises";
-import { join as join77 } from "node:path";
+import { join as join78 } from "node:path";
 
 // src/shared/progress-bar.ts
 init_output_manager();
@@ -83246,7 +83505,7 @@ var MAX_DOWNLOAD_SIZE = 500 * 1024 * 1024;
 class FileDownloader {
   async downloadAsset(asset, destDir) {
     try {
-      const destPath = join77(destDir, asset.name);
+      const destPath = join78(destDir, asset.name);
       await mkdir20(destDir, { recursive: true });
       output.info(`Downloading ${asset.name} (${formatBytes(asset.size)})...`);
       logger.verbose("Download details", {
@@ -83331,7 +83590,7 @@ class FileDownloader {
   }
   async downloadFile(params) {
     const { url, name, size, destDir, token } = params;
-    const destPath = join77(destDir, name);
+    const destPath = join78(destDir, name);
     await mkdir20(destDir, { recursive: true });
     output.info(`Downloading ${name}${size ? ` (${formatBytes(size)})` : ""}...`);
     const headers = {};
@@ -83417,7 +83676,7 @@ init_logger();
 init_types3();
 import { constants as constants4 } from "node:fs";
 import { access as access4, readdir as readdir13 } from "node:fs/promises";
-import { join as join78 } from "node:path";
+import { join as join79 } from "node:path";
 async function validateExtraction(extractDir) {
   try {
     const entries = await readdir13(extractDir, { encoding: "utf8" });
@@ -83429,7 +83688,7 @@ async function validateExtraction(extractDir) {
     const missingPaths = [];
     for (const path6 of criticalPaths) {
       try {
-        await access4(join78(extractDir, path6), constants4.F_OK);
+        await access4(join79(extractDir, path6), constants4.F_OK);
         logger.debug(`Found: ${path6}`);
       } catch {
         logger.warning(`Expected path not found: ${path6}`);
@@ -83451,7 +83710,7 @@ async function validateExtraction(extractDir) {
 // src/domains/installation/extraction/tar-extractor.ts
 init_logger();
 import { copyFile as copyFile4, mkdir as mkdir23, readdir as readdir15, rm as rm9, stat as stat10 } from "node:fs/promises";
-import { join as join81 } from "node:path";
+import { join as join82 } from "node:path";
 
 // node_modules/@isaacs/fs-minipass/dist/esm/index.js
 import EE from "events";
@@ -89213,7 +89472,7 @@ var mkdirSync3 = (dir, opt) => {
 };
 
 // node_modules/tar/dist/esm/path-reservations.js
-import { join as join79 } from "node:path";
+import { join as join80 } from "node:path";
 
 // node_modules/tar/dist/esm/normalize-unicode.js
 var normalizeCache = Object.create(null);
@@ -89246,7 +89505,7 @@ var getDirs = (path11) => {
   const dirs = path11.split("/").slice(0, -1).reduce((set, path12) => {
     const s = set[set.length - 1];
     if (s !== undefined) {
-      path12 = join79(s, path12);
+      path12 = join80(s, path12);
     }
     set.push(path12 || "/");
     return set;
@@ -89260,7 +89519,7 @@ class PathReservations {
   #running = new Set;
   reserve(paths, fn) {
     paths = isWindows4 ? ["win32 parallelization disabled"] : paths.map((p) => {
-      return stripTrailingSlashes(join79(normalizeUnicode(p))).toLowerCase();
+      return stripTrailingSlashes(join80(normalizeUnicode(p))).toLowerCase();
     });
     const dirs = new Set(paths.map((path11) => getDirs(path11)).reduce((a3, b3) => a3.concat(b3)));
     this.#reservations.set(fn, { dirs, paths });
@@ -90320,7 +90579,7 @@ function decodeFilePath(path13) {
 init_logger();
 init_types3();
 import { copyFile as copyFile3, lstat as lstat4, mkdir as mkdir22, readdir as readdir14 } from "node:fs/promises";
-import { join as join80, relative as relative10 } from "node:path";
+import { join as join81, relative as relative10 } from "node:path";
 async function withRetry(fn, retries = 3) {
   for (let i = 0;i < retries; i++) {
     try {
@@ -90342,8 +90601,8 @@ async function moveDirectoryContents(sourceDir, destDir, shouldExclude, sizeTrac
   await mkdir22(destDir, { recursive: true });
   const entries = await readdir14(sourceDir, { encoding: "utf8" });
   for (const entry of entries) {
-    const sourcePath = join80(sourceDir, entry);
-    const destPath = join80(destDir, entry);
+    const sourcePath = join81(sourceDir, entry);
+    const destPath = join81(destDir, entry);
     const relativePath = relative10(sourceDir, sourcePath);
     if (!isPathSafe(destDir, destPath)) {
       logger.warning(`Skipping unsafe path: ${relativePath}`);
@@ -90370,8 +90629,8 @@ async function copyDirectory(sourceDir, destDir, shouldExclude, sizeTracker) {
   await mkdir22(destDir, { recursive: true });
   const entries = await readdir14(sourceDir, { encoding: "utf8" });
   for (const entry of entries) {
-    const sourcePath = join80(sourceDir, entry);
-    const destPath = join80(destDir, entry);
+    const sourcePath = join81(sourceDir, entry);
+    const destPath = join81(destDir, entry);
     const relativePath = relative10(sourceDir, sourcePath);
     if (!isPathSafe(destDir, destPath)) {
       logger.warning(`Skipping unsafe path: ${relativePath}`);
@@ -90419,7 +90678,7 @@ class TarExtractor {
       logger.debug(`Root entries: ${entries.join(", ")}`);
       if (entries.length === 1) {
         const rootEntry = entries[0];
-        const rootPath = join81(tempExtractDir, rootEntry);
+        const rootPath = join82(tempExtractDir, rootEntry);
         const rootStat = await stat10(rootPath);
         if (rootStat.isDirectory()) {
           const rootContents = await readdir15(rootPath, { encoding: "utf8" });
@@ -90435,7 +90694,7 @@ class TarExtractor {
           }
         } else {
           await mkdir23(destDir, { recursive: true });
-          await copyFile4(rootPath, join81(destDir, rootEntry));
+          await copyFile4(rootPath, join82(destDir, rootEntry));
         }
       } else {
         logger.debug("Multiple root entries - moving all");
@@ -90458,7 +90717,7 @@ init_logger();
 var import_extract_zip = __toESM(require_extract_zip(), 1);
 import { execFile as execFile8 } from "node:child_process";
 import { copyFile as copyFile5, mkdir as mkdir24, readdir as readdir16, rm as rm10, stat as stat11 } from "node:fs/promises";
-import { join as join82 } from "node:path";
+import { join as join83 } from "node:path";
 class ZipExtractor {
   async tryNativeUnzip(archivePath, destDir) {
     if (!isMacOS()) {
@@ -90506,7 +90765,7 @@ class ZipExtractor {
       logger.debug(`Root entries: ${entries.join(", ")}`);
       if (entries.length === 1) {
         const rootEntry = entries[0];
-        const rootPath = join82(tempExtractDir, rootEntry);
+        const rootPath = join83(tempExtractDir, rootEntry);
         const rootStat = await stat11(rootPath);
         if (rootStat.isDirectory()) {
           const rootContents = await readdir16(rootPath, { encoding: "utf8" });
@@ -90522,7 +90781,7 @@ class ZipExtractor {
           }
         } else {
           await mkdir24(destDir, { recursive: true });
-          await copyFile5(rootPath, join82(destDir, rootEntry));
+          await copyFile5(rootPath, join83(destDir, rootEntry));
         }
       } else {
         logger.debug("Multiple root entries - moving all");
@@ -90621,7 +90880,7 @@ class DownloadManager {
   async createTempDir() {
     const timestamp = Date.now();
     const counter = DownloadManager.tempDirCounter++;
-    const primaryTempDir = join83(tmpdir4(), `claudekit-${timestamp}-${counter}`);
+    const primaryTempDir = join84(tmpdir4(), `claudekit-${timestamp}-${counter}`);
     try {
       await mkdir25(primaryTempDir, { recursive: true });
       logger.debug(`Created temp directory: ${primaryTempDir}`);
@@ -90638,7 +90897,7 @@ Solutions:
   2. Set HOME environment variable
   3. Try running from a different directory`);
       }
-      const fallbackTempDir = join83(homeDir, ".claudekit", "tmp", `claudekit-${timestamp}-${counter}`);
+      const fallbackTempDir = join84(homeDir, ".claudekit", "tmp", `claudekit-${timestamp}-${counter}`);
       try {
         await mkdir25(fallbackTempDir, { recursive: true });
         logger.debug(`Created temp directory (fallback): ${fallbackTempDir}`);
@@ -91058,20 +91317,20 @@ async function handleDownload(ctx) {
   };
 }
 // src/commands/init/phases/merge-handler.ts
-import { join as join99 } from "node:path";
+import { join as join101 } from "node:path";
 
 // src/domains/installation/deletion-handler.ts
 import { existsSync as existsSync53, lstatSync as lstatSync3, readdirSync as readdirSync4, rmSync as rmSync3, rmdirSync, unlinkSync as unlinkSync3 } from "node:fs";
-import { dirname as dirname25, join as join86, relative as relative11, resolve as resolve20, sep as sep6 } from "node:path";
+import { dirname as dirname25, join as join87, relative as relative11, resolve as resolve20, sep as sep6 } from "node:path";
 
 // src/services/file-operations/manifest/manifest-reader.ts
 init_metadata_migration();
 init_logger();
 init_types3();
 var import_fs_extra8 = __toESM(require_lib3(), 1);
-import { join as join85 } from "node:path";
+import { join as join86 } from "node:path";
 async function readManifest(claudeDir2) {
-  const metadataPath = join85(claudeDir2, "metadata.json");
+  const metadataPath = join86(claudeDir2, "metadata.json");
   if (!await import_fs_extra8.pathExists(metadataPath)) {
     return null;
   }
@@ -91257,7 +91516,7 @@ function collectFilesRecursively(dir, baseDir) {
   try {
     const entries = readdirSync4(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join86(dir, entry.name);
+      const fullPath = join87(dir, entry.name);
       const relativePath = relative11(baseDir, fullPath);
       if (entry.isDirectory()) {
         results.push(...collectFilesRecursively(fullPath, baseDir));
@@ -91325,7 +91584,7 @@ function deletePath(fullPath, claudeDir2) {
   }
 }
 async function updateMetadataAfterDeletion(claudeDir2, deletedPaths) {
-  const metadataPath = join86(claudeDir2, "metadata.json");
+  const metadataPath = join87(claudeDir2, "metadata.json");
   if (!await import_fs_extra9.pathExists(metadataPath)) {
     return;
   }
@@ -91380,7 +91639,7 @@ async function handleDeletions(sourceMetadata, claudeDir2, kitType) {
   const userMetadata = await readManifest(claudeDir2);
   const result = { deletedPaths: [], preservedPaths: [], errors: [] };
   for (const path14 of deletions) {
-    const fullPath = join86(claudeDir2, path14);
+    const fullPath = join87(claudeDir2, path14);
     const normalizedPath = resolve20(fullPath);
     const normalizedClaudeDir = resolve20(claudeDir2);
     if (!normalizedPath.startsWith(`${normalizedClaudeDir}${sep6}`)) {
@@ -91420,7 +91679,7 @@ init_logger();
 init_types3();
 var import_fs_extra12 = __toESM(require_lib3(), 1);
 var import_ignore3 = __toESM(require_ignore(), 1);
-import { dirname as dirname27, join as join89, relative as relative13 } from "node:path";
+import { dirname as dirname28, join as join91, relative as relative13 } from "node:path";
 
 // src/domains/installation/selective-merger.ts
 import { stat as stat13 } from "node:fs/promises";
@@ -91599,7 +91858,7 @@ init_logger();
 var import_fs_extra10 = __toESM(require_lib3(), 1);
 var import_ignore2 = __toESM(require_ignore(), 1);
 import { relative as relative12 } from "node:path";
-import { join as join87 } from "node:path";
+import { join as join88 } from "node:path";
 
 // node_modules/@isaacs/balanced-match/dist/esm/index.js
 var balanced = (a3, b3, str2) => {
@@ -93055,7 +93314,7 @@ class FileScanner {
     const files = [];
     const entries = await import_fs_extra10.readdir(dir, { encoding: "utf8" });
     for (const entry of entries) {
-      const fullPath = join87(dir, entry);
+      const fullPath = join88(dir, entry);
       const relativePath = relative12(baseDir, fullPath);
       const normalizedRelativePath = relativePath.replace(/\\/g, "/");
       const stats = await import_fs_extra10.lstat(fullPath);
@@ -93090,12 +93349,14 @@ class FileScanner {
 
 // src/domains/installation/merger/settings-processor.ts
 import { execSync as execSync4 } from "node:child_process";
+import { homedir as homedir33 } from "node:os";
+import { dirname as dirname27, join as join90 } from "node:path";
 
 // src/domains/config/installed-settings-tracker.ts
 init_shared();
 import { existsSync as existsSync54 } from "node:fs";
 import { mkdir as mkdir26, readFile as readFile40, writeFile as writeFile22 } from "node:fs/promises";
-import { dirname as dirname26, join as join88 } from "node:path";
+import { dirname as dirname26, join as join89 } from "node:path";
 var CK_JSON_FILE = ".ck.json";
 
 class InstalledSettingsTracker {
@@ -93109,9 +93370,9 @@ class InstalledSettingsTracker {
   }
   getCkJsonPath() {
     if (this.isGlobal) {
-      return join88(this.projectDir, CK_JSON_FILE);
+      return join89(this.projectDir, CK_JSON_FILE);
     }
-    return join88(this.projectDir, ".claude", CK_JSON_FILE);
+    return join89(this.projectDir, ".claude", CK_JSON_FILE);
   }
   async loadInstalledSettings() {
     const ckJsonPath = this.getCkJsonPath();
@@ -93186,7 +93447,9 @@ class InstalledSettingsTracker {
 
 // src/domains/installation/merger/settings-processor.ts
 init_settings_merger();
+init_command_normalizer();
 init_logger();
+init_path_resolver();
 var import_fs_extra11 = __toESM(require_lib3(), 1);
 var import_semver3 = __toESM(require_semver2(), 1);
 
@@ -93230,16 +93493,15 @@ class SettingsProcessor {
       const sourceContent = await import_fs_extra11.readFile(sourceFile, "utf-8");
       let transformedSource = sourceContent;
       if (this.isGlobal) {
-        const homeVar = '"$HOME"';
-        transformedSource = this.transformClaudePaths(sourceContent, homeVar);
+        const globalRoot = this.getCanonicalGlobalCommandRoot();
+        transformedSource = this.transformClaudePaths(sourceContent, globalRoot);
         if (transformedSource !== sourceContent) {
-          logger.debug(`Transformed .claude/ paths to ${homeVar}/.claude/ in settings.json for global installation`);
+          logger.debug(`Transformed .claude/ paths to ${globalRoot} in settings.json for global installation`);
         }
       } else {
-        const projectDirVar = '"$CLAUDE_PROJECT_DIR"';
-        transformedSource = this.transformClaudePaths(sourceContent, projectDirVar);
+        transformedSource = this.transformClaudePaths(sourceContent, "$CLAUDE_PROJECT_DIR");
         if (transformedSource !== sourceContent) {
-          logger.debug(`Transformed .claude/ paths to ${projectDirVar}/.claude/ in settings.json for local installation`);
+          logger.debug('Transformed .claude/ paths to "$CLAUDE_PROJECT_DIR"/.claude/ in settings.json for local installation');
         }
       }
       const destExists = await import_fs_extra11.pathExists(destFile);
@@ -93267,6 +93529,7 @@ class SettingsProcessor {
         }
         await this.injectTeamHooksIfSupported(destFile);
       }
+      await this.repairSiblingSettingsLocal(destFile);
     } catch (error) {
       logger.error(`Failed to process settings.json: ${error}`);
       await import_fs_extra11.copy(sourceFile, destFile, { overwrite: true });
@@ -93471,36 +93734,27 @@ class SettingsProcessor {
       const content = await import_fs_extra11.readFile(destFile, "utf-8");
       if (!content.trim())
         return null;
-      const homeVar = "$HOME";
-      let normalized = content;
-      normalized = normalized.replace(/"\$CLAUDE_PROJECT_DIR"/g, `"${homeVar}"`);
-      normalized = normalized.replace(/\$CLAUDE_PROJECT_DIR/g, homeVar);
-      normalized = normalized.replace(/"%CLAUDE_PROJECT_DIR%"/g, `"${homeVar}"`);
-      normalized = normalized.replace(/%CLAUDE_PROJECT_DIR%/g, homeVar);
-      normalized = normalized.replace(/"%USERPROFILE%"/g, `"${homeVar}"`);
-      normalized = normalized.replace(/%USERPROFILE%/g, homeVar);
-      if (normalized !== content) {
-        logger.debug("Normalized $CLAUDE_PROJECT_DIR paths to $HOME in existing global settings");
-      }
-      return JSON.parse(normalized);
+      const parsedSettings = JSON.parse(content);
+      this.fixHookCommandPaths(parsedSettings);
+      return parsedSettings;
     } catch {
       return null;
     }
   }
-  transformClaudePaths(content, prefix) {
+  transformClaudePaths(content, root) {
     if (/\.claude\/[^\s"']*[;`$&|><]/.test(content)) {
       logger.warning("Potentially unsafe characters detected in .claude/ paths");
       throw new Error("Settings file contains potentially unsafe path characters");
     }
     let transformed = content;
-    const rawPrefix = prefix.replace(/"/g, "");
     transformed = transformed.replace(/(node\s+)(?:\.\/)?(\.claude\/[^\s"\\]+)([^"\\]*)/g, (_match, nodePrefix, relativePath, suffix) => {
-      const normalizedRelativePath = relativePath.replace(/\\/g, "/");
-      return rawPrefix === "$CLAUDE_PROJECT_DIR" ? `${nodePrefix}\\"${rawPrefix}\\"/${normalizedRelativePath}${suffix}` : `${nodePrefix}\\"${rawPrefix}/${normalizedRelativePath}\\"${suffix}`;
+      return this.formatCommandPath(nodePrefix, root, relativePath, suffix).replace(/"/g, "\\\"");
     });
-    if (rawPrefix.includes("HOME") || rawPrefix.includes("USERPROFILE")) {
-      transformed = transformed.replace(/\$CLAUDE_PROJECT_DIR/g, rawPrefix);
-      transformed = transformed.replace(/%CLAUDE_PROJECT_DIR%/g, rawPrefix);
+    if (this.isGlobal) {
+      transformed = transformed.replace(/"\$CLAUDE_PROJECT_DIR"/g, `"${root}"`);
+      transformed = transformed.replace(/\$CLAUDE_PROJECT_DIR/g, root);
+      transformed = transformed.replace(/"%CLAUDE_PROJECT_DIR%"/g, `"${root}"`);
+      transformed = transformed.replace(/%CLAUDE_PROJECT_DIR%/g, root);
     }
     return transformed;
   }
@@ -93541,48 +93795,71 @@ class SettingsProcessor {
     return fixed;
   }
   fixSingleCommandPath(cmd) {
-    if (!cmd.includes(".claude/") && !cmd.includes(".claude\\"))
-      return cmd;
-    const bareRelativeMatch = cmd.match(/^(node\s+)(?:\.\/)?(\.claude[/\\][^\s"]+)(.*)$/);
-    if (bareRelativeMatch) {
-      const [, nodePrefix, relativePath, suffix] = bareRelativeMatch;
-      return this.formatCommandPath(nodePrefix, this.isGlobal ? "$HOME" : "$CLAUDE_PROJECT_DIR", relativePath, suffix);
-    }
-    const embeddedQuotedMatch = cmd.match(/^(node\s+)"(\$HOME|\$CLAUDE_PROJECT_DIR|%USERPROFILE%|%CLAUDE_PROJECT_DIR%)[/\\](\.claude[/\\][^"]+)"(.*)$/);
-    if (embeddedQuotedMatch) {
-      const [, nodePrefix, capturedVar, relativePath, suffix] = embeddedQuotedMatch;
-      return this.formatCommandPath(nodePrefix, capturedVar, relativePath, suffix);
-    }
-    const varOnlyQuotedMatch = cmd.match(/^(node\s+)"(\$HOME|\$CLAUDE_PROJECT_DIR|%USERPROFILE%|%CLAUDE_PROJECT_DIR%)"[/\\](\.claude[/\\][^\s"]+)(.*)$/);
-    if (varOnlyQuotedMatch) {
-      const [, nodePrefix, capturedVar, relativePath, suffix] = varOnlyQuotedMatch;
-      return this.formatCommandPath(nodePrefix, capturedVar, relativePath, suffix);
-    }
-    const tildeMatch = cmd.match(/^(node\s+)~[/\\](\.claude[/\\][^\s"]+)(.*)$/);
-    if (tildeMatch) {
-      const [, nodePrefix, relativePath, suffix] = tildeMatch;
-      return this.formatCommandPath(nodePrefix, "$HOME", relativePath, suffix);
-    }
-    const unquotedMatch = cmd.match(/^(node\s+)(\$HOME|\$CLAUDE_PROJECT_DIR|%USERPROFILE%|%CLAUDE_PROJECT_DIR%)[/\\](\.claude[/\\][^\s"]+)(.*)$/);
-    if (unquotedMatch) {
-      const [, nodePrefix, capturedVar, relativePath, suffix] = unquotedMatch;
-      return this.formatCommandPath(nodePrefix, capturedVar, relativePath, suffix);
-    }
-    return cmd;
+    return repairClaudeNodeCommandPath(cmd, this.getClaudeCommandRoot()).command;
   }
   formatCommandPath(nodePrefix, capturedVar, relativePath, suffix = "") {
-    const canonicalVar = this.canonicalizePathVar(capturedVar);
-    const normalizedRelativePath = relativePath.replace(/\\/g, "/").replace(/^\/+/, "");
-    return canonicalVar === "$CLAUDE_PROJECT_DIR" ? `${nodePrefix}"${canonicalVar}"/${normalizedRelativePath}${suffix}` : `${nodePrefix}"${canonicalVar}/${normalizedRelativePath}"${suffix}`;
+    const canonicalRoot = this.canonicalizePathRoot(capturedVar);
+    const normalizedRelativePath = this.normalizeRelativePath(canonicalRoot, relativePath);
+    return canonicalRoot === "$CLAUDE_PROJECT_DIR" ? `${nodePrefix}"${canonicalRoot}"/${normalizedRelativePath}${suffix}` : `${nodePrefix}"${canonicalRoot}/${normalizedRelativePath}"${suffix}`;
   }
-  canonicalizePathVar(capturedVar) {
+  canonicalizePathRoot(capturedVar) {
     switch (capturedVar) {
       case "%USERPROFILE%":
-        return "$HOME";
+      case "$HOME":
+        return this.isGlobal ? this.getCanonicalGlobalCommandRoot() : "$HOME";
       case "%CLAUDE_PROJECT_DIR%":
-        return "$CLAUDE_PROJECT_DIR";
+      case "$CLAUDE_PROJECT_DIR":
+        return this.isGlobal ? this.getCanonicalGlobalCommandRoot() : "$CLAUDE_PROJECT_DIR";
       default:
-        return capturedVar;
+        return capturedVar.replace(/\\/g, "/").replace(/\/+$/, "");
+    }
+  }
+  normalizeRelativePath(root, relativePath) {
+    const normalizedRelativePath = relativePath.replace(/\\/g, "/").replace(/^\/+/, "");
+    if (root !== "$CLAUDE_PROJECT_DIR" && this.usesCustomGlobalInstallPath()) {
+      return normalizedRelativePath.replace(/^\.claude\//, "");
+    }
+    return normalizedRelativePath;
+  }
+  getCanonicalGlobalCommandRoot() {
+    if (this.usesCustomGlobalInstallPath()) {
+      return PathResolver.getGlobalKitDir().replace(/\\/g, "/").replace(/\/+$/, "");
+    }
+    return "$HOME";
+  }
+  usesCustomGlobalInstallPath() {
+    if (!this.isGlobal || !this.projectDir) {
+      if (this.isGlobal && !this.projectDir) {
+        logger.debug("usesCustomGlobalInstallPath: global mode but projectDir not set — defaulting to $HOME");
+      }
+      return false;
+    }
+    const configuredGlobalDir = PathResolver.getGlobalKitDir().replace(/\\/g, "/").replace(/\/+$/, "");
+    const defaultGlobalDir = join90(homedir33(), ".claude").replace(/\\/g, "/");
+    return configuredGlobalDir !== defaultGlobalDir;
+  }
+  getClaudeCommandRoot() {
+    return this.isGlobal ? this.getCanonicalGlobalCommandRoot() : "$CLAUDE_PROJECT_DIR";
+  }
+  async repairSettingsFile(filePath) {
+    const settings = await SettingsMerger.readSettingsFile(filePath);
+    if (!settings) {
+      return false;
+    }
+    const pathsFixed = this.fixHookCommandPaths(settings);
+    if (!pathsFixed) {
+      return false;
+    }
+    await SettingsMerger.writeSettingsFile(filePath, settings);
+    return true;
+  }
+  async repairSiblingSettingsLocal(destFile) {
+    const settingsLocalPath = join90(dirname27(destFile), "settings.local.json");
+    if (settingsLocalPath === destFile || !await import_fs_extra11.pathExists(settingsLocalPath)) {
+      return;
+    }
+    if (await this.repairSettingsFile(settingsLocalPath)) {
+      logger.info(`Repaired stale .claude command paths in ${settingsLocalPath}`);
     }
   }
   detectClaudeCodeVersion() {
@@ -93633,7 +93910,7 @@ class SettingsProcessor {
       { event: "TeammateIdle", handler: "teammate-idle-handler.cjs" }
     ];
     for (const { event, handler } of teamHooks) {
-      const hookCommand = this.formatCommandPath("node ", this.isGlobal ? "$HOME" : "$CLAUDE_PROJECT_DIR", `.claude/hooks/${handler}`);
+      const hookCommand = this.formatCommandPath("node ", this.isGlobal ? this.getCanonicalGlobalCommandRoot() : "$CLAUDE_PROJECT_DIR", `.claude/hooks/${handler}`);
       const eventHooks = settings.hooks[event];
       if (eventHooks && eventHooks.length > 0)
         continue;
@@ -93740,7 +94017,7 @@ class CopyExecutor {
     for (const file of files) {
       const relativePath = relative13(sourceDir, file);
       const normalizedRelativePath = relativePath.replace(/\\/g, "/");
-      const destPath = join89(destDir, relativePath);
+      const destPath = join91(destDir, relativePath);
       if (await import_fs_extra12.pathExists(destPath)) {
         if (this.fileScanner.shouldNeverCopy(normalizedRelativePath)) {
           logger.debug(`Security-sensitive file exists but won't be overwritten: ${normalizedRelativePath}`);
@@ -93762,7 +94039,7 @@ class CopyExecutor {
     for (const file of files) {
       const relativePath = relative13(sourceDir, file);
       const normalizedRelativePath = relativePath.replace(/\\/g, "/");
-      const destPath = join89(destDir, relativePath);
+      const destPath = join91(destDir, relativePath);
       if (this.fileScanner.shouldNeverCopy(normalizedRelativePath)) {
         logger.debug(`Skipping security-sensitive file: ${normalizedRelativePath}`);
         skippedCount++;
@@ -93839,10 +94116,10 @@ class CopyExecutor {
   }
   trackInstalledFile(relativePath) {
     this.installedFiles.add(relativePath);
-    let dir = dirname27(relativePath);
+    let dir = dirname28(relativePath);
     while (dir && dir !== "." && dir !== "/") {
       this.installedDirectories.add(`${dir}/`);
-      dir = dirname27(dir);
+      dir = dirname28(dir);
     }
   }
 }
@@ -93935,15 +94212,15 @@ class FileMerger {
 
 // src/domains/migration/legacy-migration.ts
 import { readdir as readdir18, stat as stat14 } from "node:fs/promises";
-import { join as join93, relative as relative14 } from "node:path";
+import { join as join95, relative as relative14 } from "node:path";
 // src/services/file-operations/manifest/manifest-tracker.ts
-import { join as join92 } from "node:path";
+import { join as join94 } from "node:path";
 
 // src/domains/migration/release-manifest.ts
 init_logger();
 init_zod();
 var import_fs_extra13 = __toESM(require_lib3(), 1);
-import { join as join90 } from "node:path";
+import { join as join92 } from "node:path";
 var ReleaseManifestFileSchema = exports_external.object({
   path: exports_external.string(),
   checksum: exports_external.string().regex(/^[a-f0-9]{64}$/),
@@ -93958,7 +94235,7 @@ var ReleaseManifestSchema = exports_external.object({
 
 class ReleaseManifestLoader {
   static async load(extractDir) {
-    const manifestPath = join90(extractDir, "release-manifest.json");
+    const manifestPath = join92(extractDir, "release-manifest.json");
     try {
       const content = await import_fs_extra13.readFile(manifestPath, "utf-8");
       const parsed = JSON.parse(content);
@@ -93984,9 +94261,9 @@ init_logger();
 init_types3();
 var import_fs_extra14 = __toESM(require_lib3(), 1);
 var import_proper_lockfile5 = __toESM(require_proper_lockfile(), 1);
-import { join as join91 } from "node:path";
+import { join as join93 } from "node:path";
 async function writeManifest(claudeDir2, kitName, version, scope, kitType, trackedFiles, userConfigFiles) {
-  const metadataPath = join91(claudeDir2, "metadata.json");
+  const metadataPath = join93(claudeDir2, "metadata.json");
   const kit = kitType || (/\bmarketing\b/i.test(kitName) ? "marketing" : "engineer");
   await import_fs_extra14.ensureFile(metadataPath);
   let release = null;
@@ -94042,7 +94319,7 @@ async function writeManifest(claudeDir2, kitName, version, scope, kitType, track
   }
 }
 async function removeKitFromManifest(claudeDir2, kit) {
-  const metadataPath = join91(claudeDir2, "metadata.json");
+  const metadataPath = join93(claudeDir2, "metadata.json");
   if (!await import_fs_extra14.pathExists(metadataPath))
     return false;
   let release = null;
@@ -94075,7 +94352,7 @@ async function removeKitFromManifest(claudeDir2, kit) {
   }
 }
 async function retainTrackedFilesInManifest(claudeDir2, retainedPaths, options2) {
-  const metadataPath = join91(claudeDir2, "metadata.json");
+  const metadataPath = join93(claudeDir2, "metadata.json");
   if (!await import_fs_extra14.pathExists(metadataPath))
     return false;
   const normalizedPaths = new Set(retainedPaths.map((path15) => path15.replace(/\\/g, "/")));
@@ -94258,7 +94535,7 @@ function buildFileTrackingList(options2) {
     if (!isGlobal && !installedPath.startsWith(".claude/"))
       continue;
     const relativePath = isGlobal ? installedPath : installedPath.replace(/^\.claude\//, "");
-    const filePath = join92(claudeDir2, relativePath);
+    const filePath = join94(claudeDir2, relativePath);
     const manifestEntry = releaseManifest ? ReleaseManifestLoader.findFile(releaseManifest, installedPath) : null;
     const ownership = manifestEntry ? "ck" : "user";
     filesToTrack.push({
@@ -94368,7 +94645,7 @@ class LegacyMigration {
         continue;
       if (SKIP_DIRS_ALL.includes(entry))
         continue;
-      const fullPath = join93(dir, entry);
+      const fullPath = join95(dir, entry);
       let stats;
       try {
         stats = await stat14(fullPath);
@@ -94470,7 +94747,7 @@ User-created files (sample):`);
     ];
     if (filesToChecksum.length > 0) {
       const checksumResults = await mapWithLimit(filesToChecksum, async ({ relativePath, ownership }) => {
-        const fullPath = join93(claudeDir2, relativePath);
+        const fullPath = join95(claudeDir2, relativePath);
         const checksum = await OwnershipChecker.calculateChecksum(fullPath);
         return { relativePath, checksum, ownership };
       });
@@ -94491,7 +94768,7 @@ User-created files (sample):`);
       installedAt: new Date().toISOString(),
       files: trackedFiles
     };
-    const metadataPath = join93(claudeDir2, "metadata.json");
+    const metadataPath = join95(claudeDir2, "metadata.json");
     await import_fs_extra15.writeFile(metadataPath, JSON.stringify(updatedMetadata, null, 2));
     logger.success(`Migration complete: tracked ${trackedFiles.length} files`);
     return true;
@@ -94597,7 +94874,7 @@ function buildConflictSummary(fileConflicts, hookConflicts, mcpConflicts) {
 init_logger();
 init_skip_directories();
 var import_fs_extra16 = __toESM(require_lib3(), 1);
-import { join as join94, relative as relative15, resolve as resolve21 } from "node:path";
+import { join as join96, relative as relative15, resolve as resolve21 } from "node:path";
 
 class FileScanner2 {
   static async getFiles(dirPath, relativeTo) {
@@ -94613,7 +94890,7 @@ class FileScanner2 {
           logger.debug(`Skipping directory: ${entry}`);
           continue;
         }
-        const fullPath = join94(dirPath, entry);
+        const fullPath = join96(dirPath, entry);
         if (!FileScanner2.isSafePath(basePath, fullPath)) {
           logger.warning(`Skipping potentially unsafe path: ${entry}`);
           continue;
@@ -94648,8 +94925,8 @@ class FileScanner2 {
     return files;
   }
   static async findCustomFiles(destDir, sourceDir, subPath) {
-    const destSubDir = join94(destDir, subPath);
-    const sourceSubDir = join94(sourceDir, subPath);
+    const destSubDir = join96(destDir, subPath);
+    const sourceSubDir = join96(sourceDir, subPath);
     logger.debug(`findCustomFiles - destDir: ${destDir}`);
     logger.debug(`findCustomFiles - sourceDir: ${sourceDir}`);
     logger.debug(`findCustomFiles - subPath: "${subPath}"`);
@@ -94690,12 +94967,12 @@ class FileScanner2 {
 init_logger();
 var import_fs_extra17 = __toESM(require_lib3(), 1);
 import { lstat as lstat7, mkdir as mkdir27, readdir as readdir21, stat as stat15 } from "node:fs/promises";
-import { join as join96 } from "node:path";
+import { join as join98 } from "node:path";
 
 // src/services/transformers/commands-prefix/content-transformer.ts
 init_logger();
 import { readFile as readFile44, readdir as readdir20, writeFile as writeFile26 } from "node:fs/promises";
-import { join as join95 } from "node:path";
+import { join as join97 } from "node:path";
 var TRANSFORMABLE_EXTENSIONS = new Set([
   ".md",
   ".txt",
@@ -94756,7 +95033,7 @@ async function transformCommandReferences(directory, options2 = {}) {
   async function processDirectory(dir) {
     const entries = await readdir20(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join95(dir, entry.name);
+      const fullPath = join97(dir, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name.startsWith(".") && entry.name !== ".claude") {
           continue;
@@ -94831,14 +95108,14 @@ function shouldApplyPrefix(options2) {
 // src/services/transformers/commands-prefix/prefix-applier.ts
 async function applyPrefix(extractDir) {
   validatePath(extractDir, "extractDir");
-  const commandsDir = join96(extractDir, ".claude", "commands");
+  const commandsDir = join98(extractDir, ".claude", "commands");
   if (!await import_fs_extra17.pathExists(commandsDir)) {
     logger.verbose("No commands directory found, skipping prefix application");
     return;
   }
   logger.info("Applying /ck: prefix to slash commands...");
-  const backupDir = join96(extractDir, ".commands-backup");
-  const tempDir = join96(extractDir, ".commands-prefix-temp");
+  const backupDir = join98(extractDir, ".commands-backup");
+  const tempDir = join98(extractDir, ".commands-prefix-temp");
   try {
     const entries = await readdir21(commandsDir);
     if (entries.length === 0) {
@@ -94846,7 +95123,7 @@ async function applyPrefix(extractDir) {
       return;
     }
     if (entries.length === 1 && entries[0] === "ck") {
-      const ckDir2 = join96(commandsDir, "ck");
+      const ckDir2 = join98(commandsDir, "ck");
       const ckStat = await stat15(ckDir2);
       if (ckStat.isDirectory()) {
         logger.verbose("Commands already have /ck: prefix, skipping");
@@ -94856,17 +95133,17 @@ async function applyPrefix(extractDir) {
     await import_fs_extra17.copy(commandsDir, backupDir);
     logger.verbose("Created backup of commands directory");
     await mkdir27(tempDir, { recursive: true });
-    const ckDir = join96(tempDir, "ck");
+    const ckDir = join98(tempDir, "ck");
     await mkdir27(ckDir, { recursive: true });
     let processedCount = 0;
     for (const entry of entries) {
-      const sourcePath = join96(commandsDir, entry);
+      const sourcePath = join98(commandsDir, entry);
       const stats = await lstat7(sourcePath);
       if (stats.isSymbolicLink()) {
         logger.warning(`Skipping symlink for security: ${entry}`);
         continue;
       }
-      const destPath = join96(ckDir, entry);
+      const destPath = join98(ckDir, entry);
       await import_fs_extra17.copy(sourcePath, destPath, {
         overwrite: false,
         errorOnExist: true
@@ -94884,7 +95161,7 @@ async function applyPrefix(extractDir) {
     await import_fs_extra17.move(tempDir, commandsDir);
     await import_fs_extra17.remove(backupDir);
     logger.success("Successfully reorganized commands to /ck: prefix");
-    const claudeDir2 = join96(extractDir, ".claude");
+    const claudeDir2 = join98(extractDir, ".claude");
     logger.info("Transforming command references in file contents...");
     const transformResult = await transformCommandReferences(claudeDir2, {
       verbose: logger.isVerbose()
@@ -94922,20 +95199,20 @@ async function applyPrefix(extractDir) {
 // src/services/transformers/commands-prefix/prefix-cleaner.ts
 init_metadata_migration();
 import { lstat as lstat9, readdir as readdir23 } from "node:fs/promises";
-import { join as join98 } from "node:path";
+import { join as join100 } from "node:path";
 init_logger();
 var import_fs_extra19 = __toESM(require_lib3(), 1);
 
 // src/services/transformers/commands-prefix/file-processor.ts
 import { lstat as lstat8, readdir as readdir22 } from "node:fs/promises";
-import { join as join97 } from "node:path";
+import { join as join99 } from "node:path";
 init_logger();
 var import_fs_extra18 = __toESM(require_lib3(), 1);
 async function scanDirectoryFiles(dir) {
   const files = [];
   const entries = await readdir22(dir);
   for (const entry of entries) {
-    const fullPath = join97(dir, entry);
+    const fullPath = join99(dir, entry);
     const stats = await lstat8(fullPath);
     if (stats.isSymbolicLink()) {
       continue;
@@ -95063,8 +95340,8 @@ function isDifferentKitDirectory(dirName, currentKit) {
 async function cleanupCommandsDirectory(targetDir, isGlobal, options2 = {}) {
   const { dryRun = false } = options2;
   validatePath(targetDir, "targetDir");
-  const claudeDir2 = isGlobal ? targetDir : join98(targetDir, ".claude");
-  const commandsDir = join98(claudeDir2, "commands");
+  const claudeDir2 = isGlobal ? targetDir : join100(targetDir, ".claude");
+  const commandsDir = join100(claudeDir2, "commands");
   const accumulator = {
     results: [],
     deletedCount: 0,
@@ -95106,7 +95383,7 @@ async function cleanupCommandsDirectory(targetDir, isGlobal, options2 = {}) {
   }
   const metadataForChecks = options2.kitType ? createKitSpecificMetadata(metadata, options2.kitType) : metadata;
   for (const entry of entries) {
-    const entryPath = join98(commandsDir, entry);
+    const entryPath = join100(commandsDir, entry);
     const stats = await lstat9(entryPath);
     if (stats.isSymbolicLink()) {
       addSymlinkSkip(entry, accumulator);
@@ -95163,7 +95440,7 @@ async function handleMerge(ctx) {
   let customClaudeFiles = [];
   if (!ctx.options.fresh) {
     logger.info("Scanning for custom .claude files...");
-    const scanSourceDir = ctx.options.global ? join99(ctx.extractDir, ".claude") : ctx.extractDir;
+    const scanSourceDir = ctx.options.global ? join101(ctx.extractDir, ".claude") : ctx.extractDir;
     const scanTargetSubdir = ctx.options.global ? "" : ".claude";
     customClaudeFiles = await FileScanner2.findCustomFiles(ctx.resolvedDir, scanSourceDir, scanTargetSubdir);
   } else {
@@ -95228,8 +95505,8 @@ async function handleMerge(ctx) {
       return { ...ctx, cancelled: true };
     }
   }
-  const sourceDir = ctx.options.global ? join99(ctx.extractDir, ".claude") : ctx.extractDir;
-  const sourceMetadataPath = ctx.options.global ? join99(sourceDir, "metadata.json") : join99(sourceDir, ".claude", "metadata.json");
+  const sourceDir = ctx.options.global ? join101(ctx.extractDir, ".claude") : ctx.extractDir;
+  const sourceMetadataPath = ctx.options.global ? join101(sourceDir, "metadata.json") : join101(sourceDir, ".claude", "metadata.json");
   let sourceMetadata = null;
   try {
     if (await import_fs_extra20.pathExists(sourceMetadataPath)) {
@@ -95286,7 +95563,7 @@ async function handleMerge(ctx) {
   };
 }
 // src/commands/init/phases/migration-handler.ts
-import { join as join107 } from "node:path";
+import { join as join109 } from "node:path";
 
 // src/domains/skills/skills-detector.ts
 init_logger();
@@ -95302,7 +95579,7 @@ init_types3();
 var import_fs_extra21 = __toESM(require_lib3(), 1);
 import { createHash as createHash4 } from "node:crypto";
 import { readFile as readFile46, readdir as readdir24, writeFile as writeFile27 } from "node:fs/promises";
-import { join as join100, relative as relative16 } from "node:path";
+import { join as join102, relative as relative16 } from "node:path";
 
 class SkillsManifestManager {
   static MANIFEST_FILENAME = ".skills-manifest.json";
@@ -95324,12 +95601,12 @@ class SkillsManifestManager {
     return manifest;
   }
   static async writeManifest(skillsDir2, manifest) {
-    const manifestPath = join100(skillsDir2, SkillsManifestManager.MANIFEST_FILENAME);
+    const manifestPath = join102(skillsDir2, SkillsManifestManager.MANIFEST_FILENAME);
     await writeFile27(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
     logger.debug(`Wrote manifest to: ${manifestPath}`);
   }
   static async readManifest(skillsDir2) {
-    const manifestPath = join100(skillsDir2, SkillsManifestManager.MANIFEST_FILENAME);
+    const manifestPath = join102(skillsDir2, SkillsManifestManager.MANIFEST_FILENAME);
     if (!await import_fs_extra21.pathExists(manifestPath)) {
       logger.debug(`No manifest found at: ${manifestPath}`);
       return null;
@@ -95352,7 +95629,7 @@ class SkillsManifestManager {
       return "flat";
     }
     for (const dir of dirs.slice(0, 3)) {
-      const dirPath = join100(skillsDir2, dir.name);
+      const dirPath = join102(skillsDir2, dir.name);
       const subEntries = await readdir24(dirPath, { withFileTypes: true });
       const hasSubdirs = subEntries.some((entry) => entry.isDirectory());
       if (hasSubdirs) {
@@ -95371,7 +95648,7 @@ class SkillsManifestManager {
       const entries = await readdir24(skillsDir2, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isDirectory() && !BUILD_ARTIFACT_DIRS.includes(entry.name) && !entry.name.startsWith(".")) {
-          const skillPath = join100(skillsDir2, entry.name);
+          const skillPath = join102(skillsDir2, entry.name);
           const hash = await SkillsManifestManager.hashDirectory(skillPath);
           skills.push({
             name: entry.name,
@@ -95383,11 +95660,11 @@ class SkillsManifestManager {
       const categories = await readdir24(skillsDir2, { withFileTypes: true });
       for (const category of categories) {
         if (category.isDirectory() && !BUILD_ARTIFACT_DIRS.includes(category.name) && !category.name.startsWith(".")) {
-          const categoryPath = join100(skillsDir2, category.name);
+          const categoryPath = join102(skillsDir2, category.name);
           const skillEntries = await readdir24(categoryPath, { withFileTypes: true });
           for (const skillEntry of skillEntries) {
             if (skillEntry.isDirectory() && !skillEntry.name.startsWith(".")) {
-              const skillPath = join100(categoryPath, skillEntry.name);
+              const skillPath = join102(categoryPath, skillEntry.name);
               const hash = await SkillsManifestManager.hashDirectory(skillPath);
               skills.push({
                 name: skillEntry.name,
@@ -95417,7 +95694,7 @@ class SkillsManifestManager {
     const files = [];
     const entries = await readdir24(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join100(dirPath, entry.name);
+      const fullPath = join102(dirPath, entry.name);
       if (entry.name.startsWith(".") || BUILD_ARTIFACT_DIRS.includes(entry.name)) {
         continue;
       }
@@ -95539,7 +95816,7 @@ function getPathMapping(skillName, oldBasePath, newBasePath) {
 // src/domains/skills/detection/script-detector.ts
 var import_fs_extra22 = __toESM(require_lib3(), 1);
 import { readdir as readdir25 } from "node:fs/promises";
-import { join as join101 } from "node:path";
+import { join as join103 } from "node:path";
 async function scanDirectory(skillsDir2) {
   if (!await import_fs_extra22.pathExists(skillsDir2)) {
     return ["flat", []];
@@ -95552,12 +95829,12 @@ async function scanDirectory(skillsDir2) {
   let totalSkillLikeCount = 0;
   const allSkills = [];
   for (const dir of dirs) {
-    const dirPath = join101(skillsDir2, dir.name);
+    const dirPath = join103(skillsDir2, dir.name);
     const subEntries = await readdir25(dirPath, { withFileTypes: true });
     const subdirs = subEntries.filter((entry) => entry.isDirectory() && !entry.name.startsWith("."));
     if (subdirs.length > 0) {
       for (const subdir of subdirs.slice(0, 3)) {
-        const subdirPath = join101(dirPath, subdir.name);
+        const subdirPath = join103(dirPath, subdir.name);
         const subdirFiles = await readdir25(subdirPath, { withFileTypes: true });
         const hasSkillMarker = subdirFiles.some((file) => file.isFile() && (file.name === "skill.md" || file.name === "README.md" || file.name === "readme.md" || file.name === "config.json" || file.name === "package.json"));
         if (hasSkillMarker) {
@@ -95714,12 +95991,12 @@ class SkillsMigrationDetector {
 // src/domains/skills/skills-migrator.ts
 init_logger();
 init_types3();
-import { join as join106 } from "node:path";
+import { join as join108 } from "node:path";
 
 // src/domains/skills/migrator/migration-executor.ts
 init_logger();
 import { copyFile as copyFile6, mkdir as mkdir28, readdir as readdir26, rm as rm11 } from "node:fs/promises";
-import { join as join102 } from "node:path";
+import { join as join104 } from "node:path";
 var import_fs_extra24 = __toESM(require_lib3(), 1);
 
 // src/domains/skills/skills-migration-prompts.ts
@@ -95884,8 +96161,8 @@ async function copySkillDirectory(sourceDir, destDir) {
   await mkdir28(destDir, { recursive: true });
   const entries = await readdir26(sourceDir, { withFileTypes: true });
   for (const entry of entries) {
-    const sourcePath = join102(sourceDir, entry.name);
-    const destPath = join102(destDir, entry.name);
+    const sourcePath = join104(sourceDir, entry.name);
+    const destPath = join104(destDir, entry.name);
     if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.isSymbolicLink()) {
       continue;
     }
@@ -95900,7 +96177,7 @@ async function executeInternal(mappings, customizations, currentSkillsDir, inter
   const migrated = [];
   const preserved = [];
   const errors2 = [];
-  const tempDir = join102(currentSkillsDir, "..", ".skills-migration-temp");
+  const tempDir = join104(currentSkillsDir, "..", ".skills-migration-temp");
   await mkdir28(tempDir, { recursive: true });
   try {
     for (const mapping of mappings) {
@@ -95921,9 +96198,9 @@ async function executeInternal(mappings, customizations, currentSkillsDir, inter
           }
         }
         const category = mapping.category;
-        const targetPath = category ? join102(tempDir, category, skillName) : join102(tempDir, skillName);
+        const targetPath = category ? join104(tempDir, category, skillName) : join104(tempDir, skillName);
         if (category) {
-          await mkdir28(join102(tempDir, category), { recursive: true });
+          await mkdir28(join104(tempDir, category), { recursive: true });
         }
         await copySkillDirectory(currentSkillPath, targetPath);
         migrated.push(skillName);
@@ -95990,7 +96267,7 @@ init_logger();
 init_types3();
 var import_fs_extra25 = __toESM(require_lib3(), 1);
 import { copyFile as copyFile7, mkdir as mkdir29, readdir as readdir27, rm as rm12, stat as stat16 } from "node:fs/promises";
-import { basename as basename15, join as join103, normalize as normalize8 } from "node:path";
+import { basename as basename15, join as join105, normalize as normalize8 } from "node:path";
 function validatePath2(path15, paramName) {
   if (!path15 || typeof path15 !== "string") {
     throw new SkillsMigrationError(`${paramName} must be a non-empty string`);
@@ -96016,7 +96293,7 @@ class SkillsBackupManager {
     const timestamp = Date.now();
     const randomSuffix = Math.random().toString(36).substring(2, 8);
     const backupDirName = `${SkillsBackupManager.BACKUP_PREFIX}${timestamp}-${randomSuffix}`;
-    const backupDir = parentDir ? join103(parentDir, backupDirName) : join103(skillsDir2, "..", backupDirName);
+    const backupDir = parentDir ? join105(parentDir, backupDirName) : join105(skillsDir2, "..", backupDirName);
     logger.info(`Creating backup at: ${backupDir}`);
     try {
       await mkdir29(backupDir, { recursive: true });
@@ -96067,7 +96344,7 @@ class SkillsBackupManager {
     }
     try {
       const entries = await readdir27(parentDir, { withFileTypes: true });
-      const backups = entries.filter((entry) => entry.isDirectory() && entry.name.startsWith(SkillsBackupManager.BACKUP_PREFIX)).map((entry) => join103(parentDir, entry.name));
+      const backups = entries.filter((entry) => entry.isDirectory() && entry.name.startsWith(SkillsBackupManager.BACKUP_PREFIX)).map((entry) => join105(parentDir, entry.name));
       backups.sort().reverse();
       return backups;
     } catch (error) {
@@ -96095,8 +96372,8 @@ class SkillsBackupManager {
   static async copyDirectory(sourceDir, destDir) {
     const entries = await readdir27(sourceDir, { withFileTypes: true });
     for (const entry of entries) {
-      const sourcePath = join103(sourceDir, entry.name);
-      const destPath = join103(destDir, entry.name);
+      const sourcePath = join105(sourceDir, entry.name);
+      const destPath = join105(destDir, entry.name);
       if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.isSymbolicLink()) {
         continue;
       }
@@ -96112,7 +96389,7 @@ class SkillsBackupManager {
     let size = 0;
     const entries = await readdir27(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join103(dirPath, entry.name);
+      const fullPath = join105(dirPath, entry.name);
       if (entry.isSymbolicLink()) {
         continue;
       }
@@ -96148,12 +96425,12 @@ init_skip_directories();
 import { createHash as createHash5 } from "node:crypto";
 import { createReadStream as createReadStream3 } from "node:fs";
 import { readFile as readFile47, readdir as readdir28 } from "node:fs/promises";
-import { join as join104, relative as relative17 } from "node:path";
+import { join as join106, relative as relative17 } from "node:path";
 async function getAllFiles(dirPath) {
   const files = [];
   const entries = await readdir28(dirPath, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = join104(dirPath, entry.name);
+    const fullPath = join106(dirPath, entry.name);
     if (entry.name.startsWith(".") || BUILD_ARTIFACT_DIRS.includes(entry.name) || entry.isSymbolicLink()) {
       continue;
     }
@@ -96280,7 +96557,7 @@ async function detectFileChanges(currentSkillPath, baselineSkillPath) {
 init_types3();
 var import_fs_extra27 = __toESM(require_lib3(), 1);
 import { readdir as readdir29 } from "node:fs/promises";
-import { join as join105, normalize as normalize9 } from "node:path";
+import { join as join107, normalize as normalize9 } from "node:path";
 function validatePath3(path15, paramName) {
   if (!path15 || typeof path15 !== "string") {
     throw new SkillsMigrationError(`${paramName} must be a non-empty string`);
@@ -96301,13 +96578,13 @@ async function scanSkillsDirectory(skillsDir2) {
   if (dirs.length === 0) {
     return ["flat", []];
   }
-  const firstDirPath = join105(skillsDir2, dirs[0].name);
+  const firstDirPath = join107(skillsDir2, dirs[0].name);
   const subEntries = await readdir29(firstDirPath, { withFileTypes: true });
   const subdirs = subEntries.filter((entry) => entry.isDirectory() && !entry.name.startsWith("."));
   if (subdirs.length > 0) {
     let skillLikeCount = 0;
     for (const subdir of subdirs.slice(0, 3)) {
-      const subdirPath = join105(firstDirPath, subdir.name);
+      const subdirPath = join107(firstDirPath, subdir.name);
       const subdirFiles = await readdir29(subdirPath, { withFileTypes: true });
       const hasSkillMarker = subdirFiles.some((file) => file.isFile() && (file.name === "skill.md" || file.name === "README.md" || file.name === "readme.md" || file.name === "config.json" || file.name === "package.json"));
       if (hasSkillMarker) {
@@ -96317,7 +96594,7 @@ async function scanSkillsDirectory(skillsDir2) {
     if (skillLikeCount > 0) {
       const skills = [];
       for (const dir of dirs) {
-        const categoryPath = join105(skillsDir2, dir.name);
+        const categoryPath = join107(skillsDir2, dir.name);
         const skillDirs = await readdir29(categoryPath, { withFileTypes: true });
         skills.push(...skillDirs.filter((entry) => entry.isDirectory() && !entry.name.startsWith(".")).map((entry) => entry.name));
       }
@@ -96327,7 +96604,7 @@ async function scanSkillsDirectory(skillsDir2) {
   return ["flat", dirs.map((dir) => dir.name)];
 }
 async function findSkillPath(skillsDir2, skillName) {
-  const flatPath = join105(skillsDir2, skillName);
+  const flatPath = join107(skillsDir2, skillName);
   if (await import_fs_extra27.pathExists(flatPath)) {
     return { path: flatPath, category: undefined };
   }
@@ -96336,8 +96613,8 @@ async function findSkillPath(skillsDir2, skillName) {
     if (!entry.isDirectory() || entry.name.startsWith(".") || entry.name === "node_modules") {
       continue;
     }
-    const categoryPath = join105(skillsDir2, entry.name);
-    const skillPath = join105(categoryPath, skillName);
+    const categoryPath = join107(skillsDir2, entry.name);
+    const skillPath = join107(categoryPath, skillName);
     if (await import_fs_extra27.pathExists(skillPath)) {
       return { path: skillPath, category: entry.name };
     }
@@ -96431,7 +96708,7 @@ class SkillsMigrator {
         }
       }
       if (options2.backup && !options2.dryRun) {
-        const claudeDir2 = join106(currentSkillsDir, "..");
+        const claudeDir2 = join108(currentSkillsDir, "..");
         result.backupPath = await SkillsBackupManager.createBackup(currentSkillsDir, claudeDir2);
         logger.success(`Backup created at: ${result.backupPath}`);
       }
@@ -96492,7 +96769,7 @@ async function handleMigration(ctx) {
     logger.debug("Skipping skills migration (fresh installation)");
     return ctx;
   }
-  const newSkillsDir = join107(ctx.extractDir, ".claude", "skills");
+  const newSkillsDir = join109(ctx.extractDir, ".claude", "skills");
   const currentSkillsDir = PathResolver.buildSkillsPath(ctx.resolvedDir, ctx.options.global);
   if (!await import_fs_extra28.pathExists(newSkillsDir) || !await import_fs_extra28.pathExists(currentSkillsDir)) {
     return ctx;
@@ -96516,13 +96793,13 @@ async function handleMigration(ctx) {
 }
 // src/commands/init/phases/opencode-handler.ts
 import { cp as cp3, readdir as readdir31, rm as rm13 } from "node:fs/promises";
-import { join as join109 } from "node:path";
+import { join as join111 } from "node:path";
 
 // src/services/transformers/opencode-path-transformer.ts
 init_logger();
 import { readFile as readFile48, readdir as readdir30, writeFile as writeFile28 } from "node:fs/promises";
 import { platform as platform12 } from "node:os";
-import { extname as extname5, join as join108 } from "node:path";
+import { extname as extname5, join as join110 } from "node:path";
 var IS_WINDOWS2 = platform12() === "win32";
 function getOpenCodeGlobalPath() {
   return "$HOME/.config/opencode/";
@@ -96583,7 +96860,7 @@ async function transformPathsForGlobalOpenCode(directory, options2 = {}) {
   async function processDirectory2(dir) {
     const entries = await readdir30(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join108(dir, entry.name);
+      const fullPath = join110(dir, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name.startsWith(".")) {
           continue;
@@ -96622,7 +96899,7 @@ async function handleOpenCode(ctx) {
   if (ctx.cancelled || !ctx.extractDir || !ctx.resolvedDir) {
     return ctx;
   }
-  const openCodeSource = join109(ctx.extractDir, ".opencode");
+  const openCodeSource = join111(ctx.extractDir, ".opencode");
   if (!await import_fs_extra29.pathExists(openCodeSource)) {
     logger.debug("No .opencode directory in archive, skipping");
     return ctx;
@@ -96640,8 +96917,8 @@ async function handleOpenCode(ctx) {
     await import_fs_extra29.ensureDir(targetDir);
     const entries = await readdir31(openCodeSource, { withFileTypes: true });
     for (const entry of entries) {
-      const sourcePath = join109(openCodeSource, entry.name);
-      const targetPath = join109(targetDir, entry.name);
+      const sourcePath = join111(openCodeSource, entry.name);
+      const targetPath = join111(targetDir, entry.name);
       if (await import_fs_extra29.pathExists(targetPath)) {
         if (!ctx.options.forceOverwrite) {
           logger.verbose(`Skipping existing: ${entry.name}`);
@@ -96739,7 +97016,7 @@ Please use only one download method.`);
 }
 // src/commands/init/phases/post-install-handler.ts
 init_projects_registry();
-import { join as join110 } from "node:path";
+import { join as join112 } from "node:path";
 init_logger();
 init_path_resolver();
 var import_fs_extra30 = __toESM(require_lib3(), 1);
@@ -96748,8 +97025,8 @@ async function handlePostInstall(ctx) {
     return ctx;
   }
   if (ctx.options.global) {
-    const claudeMdSource = join110(ctx.extractDir, "CLAUDE.md");
-    const claudeMdDest = join110(ctx.resolvedDir, "CLAUDE.md");
+    const claudeMdSource = join112(ctx.extractDir, "CLAUDE.md");
+    const claudeMdDest = join112(ctx.resolvedDir, "CLAUDE.md");
     if (await import_fs_extra30.pathExists(claudeMdSource)) {
       if (ctx.options.fresh || !await import_fs_extra30.pathExists(claudeMdDest)) {
         await import_fs_extra30.copy(claudeMdSource, claudeMdDest);
@@ -96797,7 +97074,7 @@ async function handlePostInstall(ctx) {
   }
   if (!ctx.options.skipSetup) {
     await promptSetupWizardIfNeeded({
-      envPath: join110(ctx.claudeDir, ".env"),
+      envPath: join112(ctx.claudeDir, ".env"),
       claudeDir: ctx.claudeDir,
       isGlobal: ctx.options.global,
       isNonInteractive: ctx.isNonInteractive,
@@ -96821,7 +97098,7 @@ async function handlePostInstall(ctx) {
 init_config_manager();
 init_github_client();
 import { mkdir as mkdir30 } from "node:fs/promises";
-import { join as join112, resolve as resolve23 } from "node:path";
+import { join as join114, resolve as resolve23 } from "node:path";
 
 // src/domains/github/kit-access-checker.ts
 init_logger();
@@ -96952,7 +97229,7 @@ async function runPreflightChecks() {
 // src/domains/installation/fresh-installer.ts
 init_metadata_migration();
 import { existsSync as existsSync55, readdirSync as readdirSync5, rmSync as rmSync4, rmdirSync as rmdirSync2, unlinkSync as unlinkSync4 } from "node:fs";
-import { dirname as dirname28, join as join111, resolve as resolve22 } from "node:path";
+import { dirname as dirname29, join as join113, resolve as resolve22 } from "node:path";
 init_logger();
 init_safe_spinner();
 var import_fs_extra31 = __toESM(require_lib3(), 1);
@@ -97001,14 +97278,14 @@ async function analyzeFreshInstallation(claudeDir2) {
 }
 function cleanupEmptyDirectories2(filePath, claudeDir2) {
   const normalizedClaudeDir = resolve22(claudeDir2);
-  let currentDir = resolve22(dirname28(filePath));
+  let currentDir = resolve22(dirname29(filePath));
   while (currentDir !== normalizedClaudeDir && currentDir.startsWith(normalizedClaudeDir)) {
     try {
       const entries = readdirSync5(currentDir);
       if (entries.length === 0) {
         rmdirSync2(currentDir);
         logger.debug(`Removed empty directory: ${currentDir}`);
-        currentDir = resolve22(dirname28(currentDir));
+        currentDir = resolve22(dirname29(currentDir));
       } else {
         break;
       }
@@ -97025,7 +97302,7 @@ async function removeFilesByOwnership(claudeDir2, analysis, includeModified) {
   const filesToRemove = includeModified ? [...analysis.ckFiles, ...analysis.ckModifiedFiles] : analysis.ckFiles;
   const filesToPreserve = includeModified ? analysis.userFiles : [...analysis.ckModifiedFiles, ...analysis.userFiles];
   for (const file of filesToRemove) {
-    const fullPath = join111(claudeDir2, file.path);
+    const fullPath = join113(claudeDir2, file.path);
     try {
       if (existsSync55(fullPath)) {
         unlinkSync4(fullPath);
@@ -97050,7 +97327,7 @@ async function removeFilesByOwnership(claudeDir2, analysis, includeModified) {
   };
 }
 async function updateMetadataAfterFresh(claudeDir2, removedFiles) {
-  const metadataPath = join111(claudeDir2, "metadata.json");
+  const metadataPath = join113(claudeDir2, "metadata.json");
   if (!await import_fs_extra31.pathExists(metadataPath)) {
     return;
   }
@@ -97093,7 +97370,7 @@ async function removeSubdirectoriesFallback(claudeDir2) {
   const removedFiles = [];
   let removedDirCount = 0;
   for (const subdir of CLAUDEKIT_SUBDIRECTORIES) {
-    const subdirPath = join111(claudeDir2, subdir);
+    const subdirPath = join113(claudeDir2, subdir);
     if (await import_fs_extra31.pathExists(subdirPath)) {
       rmSync4(subdirPath, { recursive: true, force: true });
       removedDirCount++;
@@ -97101,7 +97378,7 @@ async function removeSubdirectoriesFallback(claudeDir2) {
       logger.debug(`Removed subdirectory: ${subdir}/`);
     }
   }
-  const metadataPath = join111(claudeDir2, "metadata.json");
+  const metadataPath = join113(claudeDir2, "metadata.json");
   if (await import_fs_extra31.pathExists(metadataPath)) {
     unlinkSync4(metadataPath);
     removedFiles.push("metadata.json");
@@ -97353,7 +97630,7 @@ async function handleSelection(ctx) {
   }
   if (!ctx.options.fresh) {
     const prefix = PathResolver.getPathPrefix(ctx.options.global);
-    const claudeDir2 = prefix ? join112(resolvedDir, prefix) : resolvedDir;
+    const claudeDir2 = prefix ? join114(resolvedDir, prefix) : resolvedDir;
     try {
       const existingMetadata = await readManifest(claudeDir2);
       if (existingMetadata?.kits) {
@@ -97385,7 +97662,7 @@ async function handleSelection(ctx) {
   }
   if (ctx.options.fresh) {
     const prefix = PathResolver.getPathPrefix(ctx.options.global);
-    const claudeDir2 = prefix ? join112(resolvedDir, prefix) : resolvedDir;
+    const claudeDir2 = prefix ? join114(resolvedDir, prefix) : resolvedDir;
     const canProceed = await handleFreshInstallation(claudeDir2, ctx.prompts);
     if (!canProceed) {
       return { ...ctx, cancelled: true };
@@ -97405,7 +97682,7 @@ async function handleSelection(ctx) {
     let currentVersion = null;
     try {
       const prefix = PathResolver.getPathPrefix(ctx.options.global);
-      const claudeDir2 = prefix ? join112(resolvedDir, prefix) : resolvedDir;
+      const claudeDir2 = prefix ? join114(resolvedDir, prefix) : resolvedDir;
       const existingMetadata = await readManifest(claudeDir2);
       currentVersion = existingMetadata?.kits?.[kitType]?.version || null;
       if (currentVersion) {
@@ -97474,7 +97751,7 @@ async function handleSelection(ctx) {
   if (ctx.options.yes && !ctx.options.fresh && !ctx.options.force && releaseTag && !isOfflineMode && !pendingKits?.length) {
     try {
       const prefix = PathResolver.getPathPrefix(ctx.options.global);
-      const claudeDir2 = prefix ? join112(resolvedDir, prefix) : resolvedDir;
+      const claudeDir2 = prefix ? join114(resolvedDir, prefix) : resolvedDir;
       const existingMetadata = await readManifest(claudeDir2);
       const installedKitVersion = existingMetadata?.kits?.[kitType]?.version;
       if (installedKitVersion && versionsMatch(installedKitVersion, releaseTag)) {
@@ -97498,7 +97775,7 @@ async function handleSelection(ctx) {
 }
 // src/commands/init/phases/sync-handler.ts
 import { copyFile as copyFile8, mkdir as mkdir31, open as open5, readFile as readFile50, rename as rename6, stat as stat17, unlink as unlink11, writeFile as writeFile30 } from "node:fs/promises";
-import { dirname as dirname29, join as join113, resolve as resolve24 } from "node:path";
+import { dirname as dirname30, join as join115, resolve as resolve24 } from "node:path";
 init_logger();
 init_path_resolver();
 var import_fs_extra33 = __toESM(require_lib3(), 1);
@@ -97508,13 +97785,13 @@ async function handleSync(ctx) {
     return ctx;
   }
   const resolvedDir = ctx.options.global ? PathResolver.getGlobalKitDir() : resolve24(ctx.options.dir || ".");
-  const claudeDir2 = ctx.options.global ? resolvedDir : join113(resolvedDir, ".claude");
+  const claudeDir2 = ctx.options.global ? resolvedDir : join115(resolvedDir, ".claude");
   if (!await import_fs_extra33.pathExists(claudeDir2)) {
     logger.error("Cannot sync: no .claude directory found");
     ctx.prompts.note("Run 'ck init' without --sync to install first.", "No Installation Found");
     return { ...ctx, cancelled: true };
   }
-  const metadataPath = join113(claudeDir2, "metadata.json");
+  const metadataPath = join115(claudeDir2, "metadata.json");
   if (!await import_fs_extra33.pathExists(metadataPath)) {
     logger.error("Cannot sync: no metadata.json found");
     ctx.prompts.note(`Your installation may be from an older version.
@@ -97614,10 +97891,10 @@ function getLockTimeout() {
 var STALE_LOCK_THRESHOLD_MS = 5 * 60 * 1000;
 async function acquireSyncLock(global3) {
   const cacheDir = PathResolver.getCacheDir(global3);
-  const lockPath = join113(cacheDir, ".sync-lock");
+  const lockPath = join115(cacheDir, ".sync-lock");
   const startTime = Date.now();
   const lockTimeout = getLockTimeout();
-  await mkdir31(dirname29(lockPath), { recursive: true });
+  await mkdir31(dirname30(lockPath), { recursive: true });
   while (Date.now() - startTime < lockTimeout) {
     try {
       const handle = await open5(lockPath, "wx");
@@ -97660,10 +97937,10 @@ async function executeSyncMerge(ctx) {
   const releaseLock = await acquireSyncLock(ctx.options.global);
   try {
     const trackedFiles = ctx.syncTrackedFiles;
-    const upstreamDir = ctx.options.global ? join113(ctx.extractDir, ".claude") : ctx.extractDir;
+    const upstreamDir = ctx.options.global ? join115(ctx.extractDir, ".claude") : ctx.extractDir;
     let deletions = [];
     try {
-      const sourceMetadataPath = join113(upstreamDir, "metadata.json");
+      const sourceMetadataPath = join115(upstreamDir, "metadata.json");
       if (await import_fs_extra33.pathExists(sourceMetadataPath)) {
         const content = await readFile50(sourceMetadataPath, "utf-8");
         const sourceMetadata = JSON.parse(content);
@@ -97695,7 +97972,7 @@ async function executeSyncMerge(ctx) {
         try {
           const sourcePath = await validateSyncPath(upstreamDir, file.path);
           const targetPath = await validateSyncPath(ctx.claudeDir, file.path);
-          const targetDir = join113(targetPath, "..");
+          const targetDir = join115(targetPath, "..");
           try {
             await mkdir31(targetDir, { recursive: true });
           } catch (mkdirError) {
@@ -97866,7 +98143,7 @@ async function createBackup(claudeDir2, files, backupDir) {
       const sourcePath = await validateSyncPath(claudeDir2, file.path);
       if (await import_fs_extra33.pathExists(sourcePath)) {
         const targetPath = await validateSyncPath(backupDir, file.path);
-        const targetDir = join113(targetPath, "..");
+        const targetDir = join115(targetPath, "..");
         await mkdir31(targetDir, { recursive: true });
         await copyFile8(sourcePath, targetPath);
       }
@@ -97881,7 +98158,7 @@ async function createBackup(claudeDir2, files, backupDir) {
 }
 // src/commands/init/phases/transform-handler.ts
 init_config_manager();
-import { join as join117 } from "node:path";
+import { join as join119 } from "node:path";
 
 // src/services/transformers/folder-path-transformer.ts
 init_logger();
@@ -97892,38 +98169,38 @@ init_logger();
 init_types3();
 var import_fs_extra34 = __toESM(require_lib3(), 1);
 import { rename as rename7, rm as rm14 } from "node:fs/promises";
-import { join as join114, relative as relative19 } from "node:path";
+import { join as join116, relative as relative19 } from "node:path";
 async function collectDirsToRename(extractDir, folders) {
   const dirsToRename = [];
   if (folders.docs !== DEFAULT_FOLDERS.docs) {
-    const docsPath = join114(extractDir, DEFAULT_FOLDERS.docs);
+    const docsPath = join116(extractDir, DEFAULT_FOLDERS.docs);
     if (await import_fs_extra34.pathExists(docsPath)) {
       dirsToRename.push({
         from: docsPath,
-        to: join114(extractDir, folders.docs)
+        to: join116(extractDir, folders.docs)
       });
     }
-    const claudeDocsPath = join114(extractDir, ".claude", DEFAULT_FOLDERS.docs);
+    const claudeDocsPath = join116(extractDir, ".claude", DEFAULT_FOLDERS.docs);
     if (await import_fs_extra34.pathExists(claudeDocsPath)) {
       dirsToRename.push({
         from: claudeDocsPath,
-        to: join114(extractDir, ".claude", folders.docs)
+        to: join116(extractDir, ".claude", folders.docs)
       });
     }
   }
   if (folders.plans !== DEFAULT_FOLDERS.plans) {
-    const plansPath = join114(extractDir, DEFAULT_FOLDERS.plans);
+    const plansPath = join116(extractDir, DEFAULT_FOLDERS.plans);
     if (await import_fs_extra34.pathExists(plansPath)) {
       dirsToRename.push({
         from: plansPath,
-        to: join114(extractDir, folders.plans)
+        to: join116(extractDir, folders.plans)
       });
     }
-    const claudePlansPath = join114(extractDir, ".claude", DEFAULT_FOLDERS.plans);
+    const claudePlansPath = join116(extractDir, ".claude", DEFAULT_FOLDERS.plans);
     if (await import_fs_extra34.pathExists(claudePlansPath)) {
       dirsToRename.push({
         from: claudePlansPath,
-        to: join114(extractDir, ".claude", folders.plans)
+        to: join116(extractDir, ".claude", folders.plans)
       });
     }
   }
@@ -97964,7 +98241,7 @@ async function renameFolders(dirsToRename, extractDir, options2) {
 init_logger();
 init_types3();
 import { readFile as readFile51, readdir as readdir32, writeFile as writeFile31 } from "node:fs/promises";
-import { join as join115, relative as relative20 } from "node:path";
+import { join as join117, relative as relative20 } from "node:path";
 var TRANSFORMABLE_FILE_PATTERNS = [
   ".md",
   ".txt",
@@ -98017,7 +98294,7 @@ async function transformFileContents(dir, compiledReplacements, options2) {
   let replacementsCount = 0;
   const entries = await readdir32(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = join115(dir, entry.name);
+    const fullPath = join117(dir, entry.name);
     if (entry.isDirectory()) {
       if (entry.name === "node_modules" || entry.name === ".git") {
         continue;
@@ -98154,7 +98431,7 @@ async function transformFolderPaths(extractDir, folders, options2 = {}) {
 init_logger();
 import { readFile as readFile52, readdir as readdir33, writeFile as writeFile32 } from "node:fs/promises";
 import { platform as platform13 } from "node:os";
-import { extname as extname6, join as join116 } from "node:path";
+import { extname as extname6, join as join118 } from "node:path";
 var IS_WINDOWS3 = platform13() === "win32";
 var HOME_PREFIX = IS_WINDOWS3 ? "%USERPROFILE%" : "$HOME";
 function getHomeDirPrefix() {
@@ -98266,7 +98543,7 @@ async function transformPathsForGlobalInstall(directory, options2 = {}) {
   async function processDirectory2(dir) {
     const entries = await readdir33(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join116(dir, entry.name);
+      const fullPath = join118(dir, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name.startsWith(".") && entry.name !== ".claude") {
           continue;
@@ -98342,7 +98619,7 @@ async function handleTransforms(ctx) {
       logger.debug(ctx.options.global ? "Saved folder configuration to ~/.claude/.ck.json" : "Saved folder configuration to .claude/.ck.json");
     }
   }
-  const claudeDir2 = ctx.options.global ? ctx.resolvedDir : join117(ctx.resolvedDir, ".claude");
+  const claudeDir2 = ctx.options.global ? ctx.resolvedDir : join119(ctx.resolvedDir, ".claude");
   return {
     ...ctx,
     foldersConfig,
@@ -98533,8 +98810,8 @@ init_dist2();
 var import_picocolors28 = __toESM(require_picocolors(), 1);
 import { existsSync as existsSync56 } from "node:fs";
 import { readFile as readFile53, rm as rm15, unlink as unlink12 } from "node:fs/promises";
-import { homedir as homedir31 } from "node:os";
-import { basename as basename16, join as join118, resolve as resolve25 } from "node:path";
+import { homedir as homedir34 } from "node:os";
+import { basename as basename16, join as join120, resolve as resolve25 } from "node:path";
 init_logger();
 init_agents_discovery();
 init_commands_discovery();
@@ -98959,7 +99236,7 @@ async function executeDeleteAction(action, options2) {
 async function processMetadataDeletions(skillSourcePath, installGlobally) {
   if (!skillSourcePath)
     return;
-  const sourceMetadataPath = join118(resolve25(skillSourcePath, ".."), "metadata.json");
+  const sourceMetadataPath = join120(resolve25(skillSourcePath, ".."), "metadata.json");
   if (!existsSync56(sourceMetadataPath))
     return;
   let sourceMetadata;
@@ -98972,7 +99249,7 @@ async function processMetadataDeletions(skillSourcePath, installGlobally) {
   }
   if (!sourceMetadata.deletions || sourceMetadata.deletions.length === 0)
     return;
-  const claudeDir2 = installGlobally ? join118(homedir31(), ".claude") : join118(process.cwd(), ".claude");
+  const claudeDir2 = installGlobally ? join120(homedir34(), ".claude") : join120(process.cwd(), ".claude");
   if (!existsSync56(claudeDir2))
     return;
   try {
@@ -99127,8 +99404,8 @@ async function migrateCommand(options2) {
     selectedProviders = Array.from(new Set(selectedProviders));
     let installGlobally = options2.global ?? false;
     if (options2.global === undefined && !options2.yes) {
-      const projectTarget = join118(process.cwd(), ".claude");
-      const globalTarget = join118(homedir31(), ".claude");
+      const projectTarget = join120(process.cwd(), ".claude");
+      const globalTarget = join120(homedir34(), ".claude");
       const scopeChoice = await ie({
         message: "Installation scope",
         options: [
@@ -99180,7 +99457,7 @@ async function migrateCommand(options2) {
     }
     const providerNames = selectedProviders.map((prov) => import_picocolors28.default.cyan(providers[prov].displayName)).join(", ");
     f2.message(`  Providers: ${providerNames}`);
-    const targetDir = installGlobally ? join118(homedir31(), ".claude") : join118(process.cwd(), ".claude");
+    const targetDir = installGlobally ? join120(homedir34(), ".claude") : join120(process.cwd(), ".claude");
     f2.message(`  Scope: ${installGlobally ? "Global" : "Project"} ${import_picocolors28.default.dim(`-> ${targetDir}`)}`);
     const cmdProviders = getProvidersSupporting("commands");
     const unsupportedCmd = selectedProviders.filter((pv) => !cmdProviders.includes(pv));
@@ -99676,7 +99953,7 @@ async function handleDirectorySetup(ctx) {
 // src/commands/new/phases/project-creation.ts
 init_config_manager();
 init_github_client();
-import { join as join119 } from "node:path";
+import { join as join121 } from "node:path";
 init_logger();
 init_output_manager();
 init_types3();
@@ -99802,7 +100079,7 @@ async function projectCreation(kit, resolvedDir, validOptions, isNonInteractive2
   output.section("Installing");
   logger.verbose("Installation target", { directory: resolvedDir });
   const merger = new FileMerger;
-  const claudeDir2 = join119(resolvedDir, ".claude");
+  const claudeDir2 = join121(resolvedDir, ".claude");
   merger.setMultiKitContext(claudeDir2, kit);
   if (validOptions.exclude && validOptions.exclude.length > 0) {
     merger.addIgnorePatterns(validOptions.exclude);
@@ -99849,7 +100126,7 @@ async function handleProjectCreation(ctx) {
 }
 // src/commands/new/phases/post-setup.ts
 init_projects_registry();
-import { join as join120 } from "node:path";
+import { join as join122 } from "node:path";
 init_package_installer();
 init_logger();
 init_path_resolver();
@@ -99881,9 +100158,9 @@ async function postSetup(resolvedDir, validOptions, isNonInteractive2, prompts)
       withSudo: validOptions.withSudo
     });
   }
-  const claudeDir2 = join120(resolvedDir, ".claude");
+  const claudeDir2 = join122(resolvedDir, ".claude");
   await promptSetupWizardIfNeeded({
-    envPath: join120(claudeDir2, ".env"),
+    envPath: join122(claudeDir2, ".env"),
     claudeDir: claudeDir2,
     isGlobal: false,
     isNonInteractive: isNonInteractive2,
@@ -99953,7 +100230,7 @@ Please use only one download method.`);
 // src/commands/plan/plan-command.ts
 init_output_manager();
 import { existsSync as existsSync58, statSync as statSync8 } from "node:fs";
-import { dirname as dirname31, join as join122, parse as parse6, resolve as resolve29 } from "node:path";
+import { dirname as dirname32, join as join124, parse as parse6, resolve as resolve29 } from "node:path";
 
 // src/commands/plan/plan-read-handlers.ts
 init_plan_parser();
@@ -99961,7 +100238,7 @@ init_logger();
 init_output_manager();
 var import_picocolors30 = __toESM(require_picocolors(), 1);
 import { existsSync as existsSync57, statSync as statSync7 } from "node:fs";
-import { basename as basename17, dirname as dirname30, join as join121, relative as relative21, resolve as resolve27 } from "node:path";
+import { basename as basename17, dirname as dirname31, join as join123, relative as relative21, resolve as resolve27 } from "node:path";
 async function handleParse(target, options2) {
   const planFile = resolvePlanFile(target);
   if (!planFile) {
@@ -99982,7 +100259,7 @@ async function handleParse(target, options2) {
     console.log(JSON.stringify({ file: relative21(process.cwd(), planFile), frontmatter, phases }, null, 2));
     return;
   }
-  const title = typeof frontmatter.title === "string" ? frontmatter.title : basename17(dirname30(planFile));
+  const title = typeof frontmatter.title === "string" ? frontmatter.title : basename17(dirname31(planFile));
   console.log();
   console.log(import_picocolors30.default.bold(`  Plan: ${title}`));
   console.log(`  File: ${planFile}`);
@@ -100037,7 +100314,7 @@ async function handleValidate(target, options2) {
 }
 async function handleStatus(target, options2) {
   const t = target ? resolve27(target) : null;
-  const plansDir = t && existsSync57(t) && statSync7(t).isDirectory() && !existsSync57(join121(t, "plan.md")) ? t : null;
+  const plansDir = t && existsSync57(t) && statSync7(t).isDirectory() && !existsSync57(join123(t, "plan.md")) ? t : null;
   if (plansDir) {
     const planFiles = scanPlanDir(plansDir);
     if (planFiles.length === 0) {
@@ -100062,14 +100339,14 @@ async function handleStatus(target, options2) {
       try {
         const s = buildPlanSummary(pf);
         const bar = progressBar(s.completed, s.totalPhases);
-        const title2 = s.title ?? basename17(dirname30(pf));
+        const title2 = s.title ?? basename17(dirname31(pf));
         console.log(`  ${import_picocolors30.default.bold(title2)}`);
         console.log(`  ${bar}`);
         if (s.inProgress > 0)
           console.log(`  [~] ${s.inProgress} in progress`);
         console.log();
       } catch {
-        console.log(`  [X] Failed to read: ${basename17(dirname30(pf))}`);
+        console.log(`  [X] Failed to read: ${basename17(dirname31(pf))}`);
         console.log();
       }
     }
@@ -100093,7 +100370,7 @@ async function handleStatus(target, options2) {
     console.log(JSON.stringify(summary, null, 2));
     return;
   }
-  const title = summary.title ?? basename17(dirname30(planFile));
+  const title = summary.title ?? basename17(dirname31(planFile));
   console.log();
   console.log(import_picocolors30.default.bold(`  ${title}`));
   if (summary.status)
@@ -100309,7 +100586,7 @@ function resolvePlanFile(target) {
     const stat18 = statSync8(t);
     if (stat18.isFile())
       return t;
-    const candidate = join122(t, "plan.md");
+    const candidate = join124(t, "plan.md");
     if (existsSync58(candidate))
       return candidate;
   }
@@ -100317,10 +100594,10 @@ function resolvePlanFile(target) {
     let dir = process.cwd();
     const root = parse6(dir).root;
     while (dir !== root) {
-      const candidate = join122(dir, "plan.md");
+      const candidate = join124(dir, "plan.md");
       if (existsSync58(candidate))
         return candidate;
-      dir = dirname31(dir);
+      dir = dirname32(dir);
     }
   }
   return null;
@@ -101345,7 +101622,7 @@ async function detectInstallations() {
 
 // src/commands/uninstall/removal-handler.ts
 import { readdirSync as readdirSync7, rmSync as rmSync6 } from "node:fs";
-import { join as join124, resolve as resolve31, sep as sep8 } from "node:path";
+import { join as join126, resolve as resolve31, sep as sep8 } from "node:path";
 init_logger();
 init_safe_prompts();
 init_safe_spinner();
@@ -101354,7 +101631,7 @@ var import_fs_extra38 = __toESM(require_lib3(), 1);
 // src/commands/uninstall/analysis-handler.ts
 init_metadata_migration();
 import { readdirSync as readdirSync6, rmSync as rmSync5 } from "node:fs";
-import { dirname as dirname32, join as join123 } from "node:path";
+import { dirname as dirname33, join as join125 } from "node:path";
 init_logger();
 init_safe_prompts();
 var import_fs_extra37 = __toESM(require_lib3(), 1);
@@ -101376,7 +101653,7 @@ function classifyFileByOwnership(ownership, forceOverwrite, deleteReason) {
 }
 async function cleanupEmptyDirectories3(filePath, installationRoot) {
   let cleaned = 0;
-  let currentDir = dirname32(filePath);
+  let currentDir = dirname33(filePath);
   while (currentDir !== installationRoot && currentDir.startsWith(installationRoot)) {
     try {
       const entries = readdirSync6(currentDir);
@@ -101384,7 +101661,7 @@ async function cleanupEmptyDirectories3(filePath, installationRoot) {
         rmSync5(currentDir, { recursive: true });
         cleaned++;
         logger.debug(`Removed empty directory: ${currentDir}`);
-        currentDir = dirname32(currentDir);
+        currentDir = dirname33(currentDir);
       } else {
         break;
       }
@@ -101411,7 +101688,7 @@ async function analyzeInstallation(installation, forceOverwrite, kit) {
       const remainingFiles = metadata.kits?.[remainingKit]?.files || [];
       for (const file of remainingFiles) {
         const relativePath = normalizeTrackedPath(file.path);
-        if (await import_fs_extra37.pathExists(join123(installation.path, relativePath))) {
+        if (await import_fs_extra37.pathExists(join125(installation.path, relativePath))) {
           result.retainedManifestPaths.push(relativePath);
         }
       }
@@ -101419,7 +101696,7 @@ async function analyzeInstallation(installation, forceOverwrite, kit) {
     const kitFiles = metadata.kits[kit].files || [];
     for (const trackedFile of kitFiles) {
       const relativePath = normalizeTrackedPath(trackedFile.path);
-      const filePath = join123(installation.path, relativePath);
+      const filePath = join125(installation.path, relativePath);
       if (preservedPaths.has(relativePath)) {
         result.toPreserve.push({ path: relativePath, reason: "shared with other kit" });
         continue;
@@ -101452,7 +101729,7 @@ async function analyzeInstallation(installation, forceOverwrite, kit) {
   }
   for (const trackedFile of allTrackedFiles) {
     const relativePath = normalizeTrackedPath(trackedFile.path);
-    const filePath = join123(installation.path, relativePath);
+    const filePath = join125(installation.path, relativePath);
     const ownershipResult = await OwnershipChecker.checkOwnership(filePath, metadata, installation.path);
     if (!ownershipResult.exists)
       continue;
@@ -101554,7 +101831,7 @@ async function removeInstallations(installations, options2) {
       let removedCount = 0;
       let cleanedDirs = 0;
       for (const item of analysis.toDelete) {
-        const filePath = join124(installation.path, item.path);
+        const filePath = join126(installation.path, item.path);
         if (!await import_fs_extra38.pathExists(filePath))
           continue;
         if (!await isPathSafeToRemove(filePath, installation.path)) {
@@ -101875,8 +102152,8 @@ ${import_picocolors38.default.bold(import_picocolors38.default.cyan(result.kitCo
 init_logger();
 import { existsSync as existsSync65 } from "node:fs";
 import { rm as rm16 } from "node:fs/promises";
-import { homedir as homedir33 } from "node:os";
-import { join as join131 } from "node:path";
+import { homedir as homedir36 } from "node:os";
+import { join as join133 } from "node:path";
 var import_picocolors39 = __toESM(require_picocolors(), 1);
 
 // src/commands/watch/phases/implementation-runner.ts
@@ -102395,7 +102672,7 @@ function spawnAndCollect3(command, args) {
 
 // src/commands/watch/phases/issue-processor.ts
 import { mkdir as mkdir32, writeFile as writeFile34 } from "node:fs/promises";
-import { join as join127 } from "node:path";
+import { join as join129 } from "node:path";
 
 // src/commands/watch/phases/approval-detector.ts
 init_logger();
@@ -102770,9 +103047,9 @@ async function checkAwaitingApproval(state, setup, options2, watchLog, projectDi
 
 // src/commands/watch/phases/plan-dir-finder.ts
 import { readdir as readdir35, stat as stat18 } from "node:fs/promises";
-import { join as join126 } from "node:path";
+import { join as join128 } from "node:path";
 async function findRecentPlanDir(cwd2, issueNumber, watchLog) {
-  const plansRoot = join126(cwd2, "plans");
+  const plansRoot = join128(cwd2, "plans");
   try {
     const entries = await readdir35(plansRoot);
     const tenMinAgo = Date.now() - 10 * 60 * 1000;
@@ -102781,14 +103058,14 @@ async function findRecentPlanDir(cwd2, issueNumber, watchLog) {
     for (const entry of entries) {
       if (entry === "watch" || entry === "reports" || entry === "visuals")
         continue;
-      const dirPath = join126(plansRoot, entry);
+      const dirPath = join128(plansRoot, entry);
       const dirStat = await stat18(dirPath);
       if (!dirStat.isDirectory())
         continue;
       if (dirStat.mtimeMs < tenMinAgo)
         continue;
       try {
-        await stat18(join126(dirPath, "plan.md"));
+        await stat18(join128(dirPath, "plan.md"));
       } catch {
         continue;
       }
@@ -103019,13 +103296,13 @@ async function handlePlanGeneration(issue, state, config, setup, options2, watch
     stats.plansCreated++;
     const detectedPlanDir = await findRecentPlanDir(projectDir, issue.number, watchLog);
     if (detectedPlanDir) {
-      state.activeIssues[numStr].planPath = join127(detectedPlanDir, "plan.md");
+      state.activeIssues[numStr].planPath = join129(detectedPlanDir, "plan.md");
       watchLog.info(`Plan directory detected: ${detectedPlanDir}`);
     } else {
       try {
-        const planDir = join127(projectDir, "plans", "watch");
+        const planDir = join129(projectDir, "plans", "watch");
         await mkdir32(planDir, { recursive: true });
-        const planFilePath = join127(planDir, `issue-${issue.number}-plan.md`);
+        const planFilePath = join129(planDir, `issue-${issue.number}-plan.md`);
         await writeFile34(planFilePath, planResult.planText, "utf-8");
         state.activeIssues[numStr].planPath = planFilePath;
         watchLog.info(`Plan saved (fallback) to ${planFilePath}`);
@@ -103172,7 +103449,7 @@ init_file_io();
 init_logger();
 import { existsSync as existsSync61 } from "node:fs";
 import { mkdir as mkdir33, readFile as readFile55 } from "node:fs/promises";
-import { dirname as dirname33 } from "node:path";
+import { dirname as dirname34 } from "node:path";
 var PROCESSED_ISSUES_CAP = 500;
 async function readCkJson(projectDir) {
   const configPath = CkConfigManager.getProjectConfigPath(projectDir);
@@ -103202,7 +103479,7 @@ async function loadWatchState(projectDir) {
 }
 async function saveWatchState(projectDir, state) {
   const configPath = CkConfigManager.getProjectConfigPath(projectDir);
-  const configDir = dirname33(configPath);
+  const configDir = dirname34(configPath);
   if (!existsSync61(configDir)) {
     await mkdir33(configDir, { recursive: true });
   }
@@ -103332,18 +103609,18 @@ init_logger();
 import { spawnSync as spawnSync6 } from "node:child_process";
 import { existsSync as existsSync62 } from "node:fs";
 import { readdir as readdir36, stat as stat19 } from "node:fs/promises";
-import { join as join128 } from "node:path";
+import { join as join130 } from "node:path";
 async function scanForRepos(parentDir) {
   const repos = [];
   const entries = await readdir36(parentDir);
   for (const entry of entries) {
     if (entry.startsWith("."))
       continue;
-    const fullPath = join128(parentDir, entry);
+    const fullPath = join130(parentDir, entry);
     const entryStat = await stat19(fullPath);
     if (!entryStat.isDirectory())
       continue;
-    const gitDir = join128(fullPath, ".git");
+    const gitDir = join130(fullPath, ".git");
     if (!existsSync62(gitDir))
       continue;
     const result = spawnSync6("gh", ["repo", "view", "--json", "owner,name"], {
@@ -103369,8 +103646,8 @@ async function scanForRepos(parentDir) {
 init_logger();
 import { spawnSync as spawnSync7 } from "node:child_process";
 import { existsSync as existsSync63 } from "node:fs";
-import { homedir as homedir32 } from "node:os";
-import { join as join129 } from "node:path";
+import { homedir as homedir35 } from "node:os";
+import { join as join131 } from "node:path";
 async function validateSetup(cwd2) {
   const workDir = cwd2 ?? process.cwd();
   const ghVersion = spawnSync7("gh", ["--version"], { encoding: "utf-8", timeout: 1e4 });
@@ -103401,7 +103678,7 @@ Run this command from a directory with a GitHub remote.`);
   } catch {
     throw new Error(`Failed to parse repository info: ${ghRepo.stdout}`);
   }
-  const skillsPath = join129(homedir32(), ".claude", "skills");
+  const skillsPath = join131(homedir35(), ".claude", "skills");
   const skillsAvailable = existsSync63(skillsPath);
   if (!skillsAvailable) {
     logger.warning(`ClaudeKit Engineer skills not found at ${skillsPath}`);
@@ -103420,7 +103697,7 @@ init_path_resolver();
 import { createWriteStream as createWriteStream3, statSync as statSync9 } from "node:fs";
 import { existsSync as existsSync64 } from "node:fs";
 import { mkdir as mkdir34, rename as rename8 } from "node:fs/promises";
-import { join as join130 } from "node:path";
+import { join as join132 } from "node:path";
 
 class WatchLogger {
   logStream = null;
@@ -103428,7 +103705,7 @@ class WatchLogger {
   logPath = null;
   maxBytes;
   constructor(logDir, maxBytes = 0) {
-    this.logDir = logDir ?? join130(PathResolver.getClaudeKitDir(), "logs");
+    this.logDir = logDir ?? join132(PathResolver.getClaudeKitDir(), "logs");
     this.maxBytes = maxBytes;
   }
   async init() {
@@ -103437,7 +103714,7 @@ class WatchLogger {
         await mkdir34(this.logDir, { recursive: true });
       }
       const dateStr = formatDate(new Date);
-      this.logPath = join130(this.logDir, `watch-${dateStr}.log`);
+      this.logPath = join132(this.logDir, `watch-${dateStr}.log`);
       this.logStream = createWriteStream3(this.logPath, { flags: "a", mode: 384 });
     } catch (error) {
       logger.warning(`Cannot create watch log file: ${error instanceof Error ? error.message : "Unknown"}`);
@@ -103617,7 +103894,7 @@ async function watchCommand(options2) {
 }
 async function discoverRepos(options2, watchLog) {
   const cwd2 = process.cwd();
-  const isGitRepo = existsSync65(join131(cwd2, ".git"));
+  const isGitRepo = existsSync65(join133(cwd2, ".git"));
   if (options2.force) {
     await forceRemoveLock(watchLog);
   }
@@ -103687,7 +103964,7 @@ async function resetState(state, projectDir, watchLog) {
   watchLog.info(`Watch state reset (--force) for ${projectDir}`);
 }
 async function forceRemoveLock(watchLog) {
-  const lockPath = join131(homedir33(), ".claudekit", "locks", `${LOCK_NAME}.lock`);
+  const lockPath = join133(homedir36(), ".claudekit", "locks", `${LOCK_NAME}.lock`);
   try {
     await rm16(lockPath, { recursive: true, force: true });
     watchLog.info("Removed existing lock file (--force)");
@@ -103871,7 +104148,7 @@ init_logger();
 init_path_resolver();
 init_types3();
 import { existsSync as existsSync76, readFileSync as readFileSync19 } from "node:fs";
-import { join as join142 } from "node:path";
+import { join as join144 } from "node:path";
 var packageVersion = package_default.version;
 function formatInstalledKits(metadata) {
   if (!metadata.kits || Object.keys(metadata.kits).length === 0) {
@@ -103903,9 +104180,9 @@ async function displayVersion() {
   let localKitVersion = null;
   let isGlobalOnlyKit = false;
   const globalKitDir = PathResolver.getGlobalKitDir();
-  const globalMetadataPath = join142(globalKitDir, "metadata.json");
+  const globalMetadataPath = join144(globalKitDir, "metadata.json");
   const prefix = PathResolver.getPathPrefix(false);
-  const localMetadataPath = prefix ? join142(process.cwd(), prefix, "metadata.json") : join142(process.cwd(), "metadata.json");
+  const localMetadataPath = prefix ? join144(process.cwd(), prefix, "metadata.json") : join144(process.cwd(), "metadata.json");
   const isLocalSameAsGlobal = localMetadataPath === globalMetadataPath;
   if (!isLocalSameAsGlobal && existsSync76(localMetadataPath)) {
     try {