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

package/dist/index.js

@@ -44763,10 +44763,69 @@ function notFoundError(type, name, hint) {
 }
 
 // src/shared/command-normalizer.ts
+import { homedir as homedir12 } from "node:os";
+import { join as join20 } 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 = join20(homedir12(), ".claude").replace(/\\/g, "/");
   normalized = normalized.replace(/"/g, "");
   normalized = normalized.replace(/~\//g, "$HOME/");
   normalized = normalized.replace(/\$CLAUDE_PROJECT_DIR/g, "$HOME");
@@ -44775,9 +44834,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) {
@@ -44807,6 +44874,7 @@ var init_shared = __esm(() => {
   init_safe_spinner();
   init_safe_prompts();
   init_skip_directories();
+  init_command_normalizer();
 });
 
 // src/domains/config/merger/diff-calculator.ts
@@ -45206,7 +45274,7 @@ var init_merge_engine = __esm(() => {
 
 // src/domains/config/merger/file-io.ts
 import { randomUUID } from "node:crypto";
-import { dirname as dirname6, join as join20 } from "node:path";
+import { dirname as dirname6, join as join21 } from "node:path";
 function stripBOM(content) {
   return content.charCodeAt(0) === 65279 ? content.slice(1) : content;
 }
@@ -45230,7 +45298,7 @@ async function readSettingsFile(filePath) {
 }
 async function atomicWriteFile(filePath, content) {
   const dir = dirname6(filePath);
-  const tempPath = join20(dir, `.settings-${randomUUID()}.tmp`);
+  const tempPath = join21(dir, `.settings-${randomUUID()}.tmp`);
   try {
     await import_fs_extra4.writeFile(tempPath, content, "utf-8");
     await import_fs_extra4.rename(tempPath, filePath);
@@ -45281,7 +45349,7 @@ var init_settings_merger = __esm(() => {
 });
 
 // src/domains/config/config-generator.ts
-import { join as join21 } from "node:path";
+import { join as join22 } from "node:path";
 async function generateEnvFile(targetDir, values) {
   const lines = [
     "# Generated by ClaudeKit CLI setup wizard",
@@ -45323,7 +45391,7 @@ async function generateEnvFile(targetDir, values) {
   for (const [key, value] of otherValues) {
     lines.push(`${key}=${value}`);
   }
-  const envPath = join21(targetDir, ".env");
+  const envPath = join22(targetDir, ".env");
   await import_fs_extra5.writeFile(envPath, `${lines.join(`
 `)}
 `, { mode: 384 });
@@ -46947,8 +47015,8 @@ var init_chokidar = __esm(() => {
 });
 
 // src/domains/web-server/file-watcher.ts
-import { homedir as homedir12 } from "node:os";
-import { join as join24 } from "node:path";
+import { homedir as homedir13 } from "node:os";
+import { join as join25 } from "node:path";
 
 class FileWatcher {
   watcher = null;
@@ -46970,16 +47038,16 @@ class FileWatcher {
   }
   getWatchPaths() {
     const paths = [];
-    const globalDir = join24(homedir12(), ".claudekit");
-    paths.push(join24(globalDir, "config.json"));
-    const globalKitDir = join24(homedir12(), ".claude");
-    paths.push(join24(globalKitDir, ".ck.json"));
-    paths.push(join24(globalKitDir, "settings.json"));
-    paths.push(join24(globalKitDir, "settings.local.json"));
+    const globalDir = join25(homedir13(), ".claudekit");
+    paths.push(join25(globalDir, "config.json"));
+    const globalKitDir = join25(homedir13(), ".claude");
+    paths.push(join25(globalKitDir, ".ck.json"));
+    paths.push(join25(globalKitDir, "settings.json"));
+    paths.push(join25(globalKitDir, "settings.local.json"));
     const cwd2 = process.cwd();
-    paths.push(join24(cwd2, ".claude", ".ck.json"));
-    paths.push(join24(cwd2, ".claude", "settings.json"));
-    paths.push(join24(cwd2, ".claude", "settings.local.json"));
+    paths.push(join25(cwd2, ".claude", ".ck.json"));
+    paths.push(join25(cwd2, ".claude", "settings.json"));
+    paths.push(join25(cwd2, ".claude", "settings.local.json"));
     return paths;
   }
   handleFileChange(path3, type) {
@@ -47022,8 +47090,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 = join24(homedir12(), ".claudekit");
-    const globalKitDir = join24(homedir12(), ".claude");
+    const globalDir = join25(homedir13(), ".claudekit");
+    const globalKitDir = join25(homedir13(), ".claude");
     return path3.startsWith(globalDir) || path3.startsWith(globalKitDir) ? "global" : "local";
   }
   stop() {
@@ -47416,14 +47484,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 join25 } from "node:path";
+import { join as join26 } 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 = join25(claudeProjectDir, jsonlFile);
+    const filePath = join26(claudeProjectDir, jsonlFile);
     const content = readFileSync5(filePath, "utf-8");
     const lines = content.split(`
 `).slice(0, 10);
@@ -47443,7 +47511,7 @@ function extractProjectPath(claudeProjectDir) {
   }
 }
 function scanClaudeProjects() {
-  const claudeProjectsDir = join25(PathResolver.getGlobalKitDir(), "projects");
+  const claudeProjectsDir = join26(PathResolver.getGlobalKitDir(), "projects");
   const now = Date.now();
   if (cachedDiscoveredProjects && cachedDiscoveredProjects.expiresAt > now) {
     return cachedDiscoveredProjects.projects;
@@ -47460,7 +47528,7 @@ function scanClaudeProjects() {
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
-      const projectDirPath = join25(claudeProjectsDir, entry.name);
+      const projectDirPath = join26(claudeProjectsDir, entry.name);
       const projectPath = extractProjectPath(projectDirPath);
       if (!projectPath) {
         logger.debug(`Could not extract path from: ${entry.name}`);
@@ -47514,15 +47582,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 join26, resolve as resolve9, sep as sep4 } from "node:path";
+import { homedir as homedir14 } from "node:os";
+import { join as join27, resolve as resolve9, sep as sep4 } from "node:path";
 function getWindowsPaths(...relativePaths) {
   const roots = [
     WINDOWS_PATHS.localAppData,
     WINDOWS_PATHS.programFiles,
     WINDOWS_PATHS.programFilesX86
   ];
-  return roots.flatMap((root) => relativePaths.map((rel) => join26(root, rel)));
+  return roots.flatMap((root) => relativePaths.map((rel) => join27(root, rel)));
 }
 function isCommandAvailable(command) {
   const checkCommand = isWindows() ? "where" : "which";
@@ -47802,7 +47870,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()) {
@@ -48141,7 +48209,7 @@ var init_action_routes = __esm(() => {
     projectId: exports_external.string().min(1).max(256).optional()
   }).strict();
   WINDOWS_PATHS = {
-    localAppData: process.env.LOCALAPPDATA || join26(homedir13(), "AppData", "Local"),
+    localAppData: process.env.LOCALAPPDATA || join27(homedir14(), "AppData", "Local"),
     programFiles: process.env.ProgramFiles || "C:\\Program Files",
     programFilesX86: process.env["ProgramFiles(x86)"] || "C:\\Program Files (x86)"
   };
@@ -48162,7 +48230,7 @@ var init_action_routes = __esm(() => {
       openMode: "open-directory",
       capabilities: ["open-directory", "run-command"],
       macAppName: "iTerm",
-      macAppPaths: ["/Applications/iTerm.app", join26(homedir13(), "Applications", "iTerm.app")]
+      macAppPaths: ["/Applications/iTerm.app", join27(homedir14(), "Applications", "iTerm.app")]
     },
     {
       id: "warp",
@@ -48173,7 +48241,7 @@ var init_action_routes = __esm(() => {
       capabilities: ["open-directory", "uri-scheme"],
       commands: ["warp"],
       macAppName: "Warp",
-      macAppPaths: ["/Applications/Warp.app", join26(homedir13(), "Applications", "Warp.app")],
+      macAppPaths: ["/Applications/Warp.app", join27(homedir14(), "Applications", "Warp.app")],
       windowsAppPaths: getWindowsPaths("Warp\\Warp.exe"),
       linuxAppPaths: ["/usr/bin/warp", "/usr/local/bin/warp"]
     },
@@ -48185,7 +48253,7 @@ var init_action_routes = __esm(() => {
       openMode: "open-directory",
       capabilities: ["open-directory", "run-command"],
       commands: ["wt"],
-      windowsAppPaths: [join26(WINDOWS_PATHS.localAppData, "Microsoft", "WindowsApps", "wt.exe")]
+      windowsAppPaths: [join27(WINDOWS_PATHS.localAppData, "Microsoft", "WindowsApps", "wt.exe")]
     },
     {
       id: "wezterm",
@@ -48196,7 +48264,7 @@ var init_action_routes = __esm(() => {
       capabilities: ["open-directory"],
       commands: ["wezterm"],
       macAppName: "WezTerm",
-      macAppPaths: ["/Applications/WezTerm.app", join26(homedir13(), "Applications", "WezTerm.app")],
+      macAppPaths: ["/Applications/WezTerm.app", join27(homedir14(), "Applications", "WezTerm.app")],
       windowsAppPaths: getWindowsPaths("WezTerm\\wezterm-gui.exe", "WezTerm\\wezterm.exe"),
       linuxAppPaths: ["/usr/bin/wezterm", "/usr/local/bin/wezterm"]
     },
@@ -48209,7 +48277,7 @@ var init_action_routes = __esm(() => {
       capabilities: ["open-directory"],
       commands: ["kitty"],
       macAppName: "kitty",
-      macAppPaths: ["/Applications/kitty.app", join26(homedir13(), "Applications", "kitty.app")],
+      macAppPaths: ["/Applications/kitty.app", join27(homedir14(), "Applications", "kitty.app")],
       windowsAppPaths: getWindowsPaths("kitty\\kitty.exe"),
       linuxAppPaths: ["/usr/bin/kitty", "/usr/local/bin/kitty"]
     },
@@ -48222,7 +48290,7 @@ var init_action_routes = __esm(() => {
       capabilities: ["open-directory"],
       commands: ["alacritty"],
       macAppName: "Alacritty",
-      macAppPaths: ["/Applications/Alacritty.app", join26(homedir13(), "Applications", "Alacritty.app")],
+      macAppPaths: ["/Applications/Alacritty.app", join27(homedir14(), "Applications", "Alacritty.app")],
       windowsAppPaths: getWindowsPaths("Alacritty\\alacritty.exe"),
       linuxAppPaths: ["/usr/bin/alacritty", "/usr/local/bin/alacritty"]
     },
@@ -48295,7 +48363,7 @@ var init_action_routes = __esm(() => {
       capabilities: ["open-app"],
       commands: ["termius"],
       macAppName: "Termius",
-      macAppPaths: ["/Applications/Termius.app", join26(homedir13(), "Applications", "Termius.app")],
+      macAppPaths: ["/Applications/Termius.app", join27(homedir14(), "Applications", "Termius.app")],
       windowsAppPaths: getWindowsPaths("Termius\\Termius.exe"),
       linuxAppPaths: ["/usr/bin/termius"]
     },
@@ -48318,7 +48386,7 @@ var init_action_routes = __esm(() => {
       macAppName: "Visual Studio Code",
       macAppPaths: [
         "/Applications/Visual Studio Code.app",
-        join26(homedir13(), "Applications", "Visual Studio Code.app")
+        join27(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"]
@@ -48332,7 +48400,7 @@ var init_action_routes = __esm(() => {
       capabilities: ["open-directory"],
       commands: ["cursor"],
       macAppName: "Cursor",
-      macAppPaths: ["/Applications/Cursor.app", join26(homedir13(), "Applications", "Cursor.app")],
+      macAppPaths: ["/Applications/Cursor.app", join27(homedir14(), "Applications", "Cursor.app")],
       windowsAppPaths: getWindowsPaths("Programs\\Cursor\\Cursor.exe", "Cursor\\Cursor.exe"),
       linuxAppPaths: ["/usr/bin/cursor"]
     },
@@ -48345,7 +48413,7 @@ var init_action_routes = __esm(() => {
       capabilities: ["open-directory"],
       commands: ["windsurf"],
       macAppName: "Windsurf",
-      macAppPaths: ["/Applications/Windsurf.app", join26(homedir13(), "Applications", "Windsurf.app")],
+      macAppPaths: ["/Applications/Windsurf.app", join27(homedir14(), "Applications", "Windsurf.app")],
       windowsAppPaths: getWindowsPaths("Programs\\Windsurf\\Windsurf.exe", "Windsurf\\Windsurf.exe"),
       linuxAppPaths: ["/usr/bin/windsurf"]
     },
@@ -48360,11 +48428,11 @@ var init_action_routes = __esm(() => {
       macAppName: "Antigravity",
       macAppPaths: [
         "/Applications/Antigravity.app",
-        join26(homedir13(), "Applications", "Antigravity.app")
+        join27(homedir14(), "Applications", "Antigravity.app")
       ],
       windowsAppPaths: getWindowsPaths("Programs\\Antigravity\\Antigravity.exe"),
       linuxAppPaths: ["/usr/bin/antigravity"],
-      fallbackDetectionPaths: [join26(homedir13(), ".gemini", "antigravity")]
+      fallbackDetectionPaths: [join27(homedir14(), ".gemini", "antigravity")]
     },
     {
       id: "zed",
@@ -48375,7 +48443,7 @@ var init_action_routes = __esm(() => {
       capabilities: ["open-directory"],
       commands: ["zed"],
       macAppName: "Zed",
-      macAppPaths: ["/Applications/Zed.app", join26(homedir13(), "Applications", "Zed.app")],
+      macAppPaths: ["/Applications/Zed.app", join27(homedir14(), "Applications", "Zed.app")],
       windowsAppPaths: getWindowsPaths("Zed\\Zed.exe"),
       linuxAppPaths: ["/usr/bin/zed", "/usr/local/bin/zed"]
     },
@@ -48390,7 +48458,7 @@ var init_action_routes = __esm(() => {
       macAppName: "Sublime Text",
       macAppPaths: [
         "/Applications/Sublime Text.app",
-        join26(homedir13(), "Applications", "Sublime Text.app")
+        join27(homedir14(), "Applications", "Sublime Text.app")
       ],
       windowsAppPaths: getWindowsPaths("Sublime Text\\sublime_text.exe"),
       linuxAppPaths: ["/usr/bin/subl", "/snap/bin/subl"]
@@ -49013,7 +49081,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 join27 } from "node:path";
+import { join as join28 } from "node:path";
 async function resolveProjectDir(projectId) {
   if (!projectId)
     return null;
@@ -49155,7 +49223,7 @@ function registerCkConfigRoutes(app) {
   });
   app.get("/api/metadata/global", async (_req, res) => {
     try {
-      const metadataPath = join27(PathResolver.getGlobalKitDir(), "metadata.json");
+      const metadataPath = join28(PathResolver.getGlobalKitDir(), "metadata.json");
       let metadata = {};
       if (existsSync15(metadataPath)) {
         const content = await readFile11(metadataPath, "utf-8");
@@ -49235,11 +49303,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 join28 } from "node:path";
+import { homedir as homedir15 } from "node:os";
+import { join as join29 } from "node:path";
 import { createInterface as createInterface2 } from "node:readline";
 function getHistoryPath() {
-  return process.env.CLAUDE_HISTORY_PATH ?? join28(homedir14(), ".claude", "history.jsonl");
+  return process.env.CLAUDE_HISTORY_PATH ?? join29(homedir15(), ".claude", "history.jsonl");
 }
 function emptyResult(parseTimeMs, error) {
   return { projects: [], totalEntries: 0, errorCount: 0, parseTimeMs, error };
@@ -49323,7 +49391,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 readdir7, stat as stat5 } from "node:fs/promises";
-import { join as join29 } from "node:path";
+import { join as join30 } from "node:path";
 function formatTimestamp(date) {
   const now = new Date;
   const isToday = date.toDateString() === now.toDateString();
@@ -49420,7 +49488,7 @@ async function getProjectSessions(projectDir, limit = 10) {
     const files = await readdir7(projectDir);
     const jsonlFiles = files.filter((f3) => f3.endsWith(".jsonl"));
     const fileStats = await Promise.all(jsonlFiles.map(async (file) => {
-      const filePath = join29(projectDir, file);
+      const filePath = join30(projectDir, file);
       const fileStat = await stat5(filePath).catch(() => null);
       return { file, filePath, mtime: fileStat?.mtime || new Date(0) };
     }));
@@ -49437,10 +49505,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 readdir8 } from "node:fs/promises";
-import { homedir as homedir15 } from "node:os";
-import { join as join30 } from "node:path";
+import { homedir as homedir16 } from "node:os";
+import { join as join31 } from "node:path";
 async function getCkSkillMetadata(scope) {
-  const metaPath = scope === "global" ? join30(homedir15(), ".claude", "metadata.json") : join30(process.cwd(), ".claude", "metadata.json");
+  const metaPath = scope === "global" ? join31(homedir16(), ".claude", "metadata.json") : join31(process.cwd(), ".claude", "metadata.json");
   if (!existsSync17(metaPath))
     return null;
   const result = new Map;
@@ -49476,7 +49544,7 @@ async function getCkSkillMetadata(scope) {
   return result.size > 0 ? result : null;
 }
 async function getSkillMetadata(skillPath) {
-  const skillMdPath = join30(skillPath, "SKILL.md");
+  const skillMdPath = join31(skillPath, "SKILL.md");
   if (!existsSync17(skillMdPath))
     return null;
   try {
@@ -49525,8 +49593,8 @@ async function scanSkills() {
         continue;
       if (ckMeta && !ckMeta.has(entry))
         continue;
-      const entryPath = join30(skillsDir, entry);
-      const skillMdPath = join30(entryPath, "SKILL.md");
+      const entryPath = join31(skillsDir, entry);
+      const skillMdPath = join31(entryPath, "SKILL.md");
       if (!existsSync17(skillMdPath))
         continue;
       const frontmatter = await getSkillMetadata(entryPath);
@@ -49571,17 +49639,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 = join30(homedir15(), ".claude", "skills");
+  skillsDir = join31(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 mkdir9, readFile as readFile14, rename as rename5, rm as rm4, writeFile as writeFile10 } from "node:fs/promises";
-import { homedir as homedir16 } from "node:os";
-import { join as join31 } from "node:path";
+import { homedir as homedir17 } from "node:os";
+import { join as join32 } from "node:path";
 function getSettingsPath() {
-  return join31(claudeDir, settingsFilename);
+  return join32(claudeDir, settingsFilename);
 }
 async function readSettings() {
   const settingsPath = getSettingsPath();
@@ -49603,7 +49671,7 @@ async function backupAndSaveSettings(settings) {
   let backupPath = null;
   if (existsSync18(settingsPath)) {
     await mkdir9(settingsBackupDir, { recursive: true });
-    backupPath = join31(settingsBackupDir, `${getBackupTimestamp()}-${settingsFilename}`);
+    backupPath = join32(settingsBackupDir, `${getBackupTimestamp()}-${settingsFilename}`);
     await copyFile2(settingsPath, backupPath);
   }
   const tempPath = `${settingsPath}.tmp-${Date.now()}`;
@@ -49640,13 +49708,13 @@ function countMcpServers(settings) {
 }
 var claudeDir, settingsFilename = "settings.json", settingsBackupDir;
 var init_settings_reader = __esm(() => {
-  claudeDir = join31(homedir16(), ".claude");
-  settingsBackupDir = join31(claudeDir, ".ck-backups", "settings");
+  claudeDir = join32(homedir17(), ".claude");
+  settingsBackupDir = join32(claudeDir, ".ck-backups", "settings");
 });
 
 // src/services/claude-data/hook-log-reader.ts
 import { open as open4 } from "node:fs/promises";
-import { join as join32 } from "node:path";
+import { join as join33 } from "node:path";
 function createEmptySummary() {
   return {
     total: 0,
@@ -49694,9 +49762,9 @@ async function resolveProjectPath(projectId) {
 }
 function getHookLogPath(scope, basePath) {
   if (scope === "global") {
-    return join32(basePath, "hooks", ".logs", "hook-log.jsonl");
+    return join33(basePath, "hooks", ".logs", "hook-log.jsonl");
   }
-  return join32(basePath, ".claude", "hooks", ".logs", "hook-log.jsonl");
+  return join33(basePath, ".claude", "hooks", ".logs", "hook-log.jsonl");
 }
 function parseEntry(line) {
   try {
@@ -49808,14 +49876,14 @@ var init_hook_log_reader = __esm(() => {
 });
 
 // src/services/claude-data/project-scanner.ts
-import { homedir as homedir17 } from "node:os";
-import { basename as basename8, join as join33, normalize as normalize4 } from "node:path";
+import { homedir as homedir18 } from "node:os";
+import { basename as basename8, join as join34, normalize as normalize4 } from "node:path";
 function encodePath(path3) {
   return path3.replace(/\//g, "-").replace(/^-/, "-");
 }
 var projectsDir;
 var init_project_scanner = __esm(() => {
-  projectsDir = join33(homedir17(), ".claude", "projects");
+  projectsDir = join34(homedir18(), ".claude", "projects");
 });
 
 // src/services/claude-data/project-discovery.ts
@@ -49910,10 +49978,10 @@ var init_project_discovery = __esm(() => {
 
 // src/services/claude-data/user-preferences.ts
 import { readFile as readFile15, stat as stat6 } from "node:fs/promises";
-import { homedir as homedir18 } from "node:os";
-import { join as join34 } from "node:path";
+import { homedir as homedir19 } from "node:os";
+import { join as join35 } from "node:path";
 function getPreferencesPath() {
-  return join34(homedir18(), ".claude.json");
+  return join35(homedir19(), ".claude.json");
 }
 async function readUserPreferences(filePath) {
   const path3 = filePath ?? getPreferencesPath();
@@ -50047,7 +50115,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 mkdir10, rename as rename6, rm as rm5 } from "node:fs/promises";
-import { join as join35, resolve as resolve10 } from "node:path";
+import { join as join36, resolve as resolve10 } from "node:path";
 async function installSkillDirectories(skills, targetProviders, options2) {
   const results = [];
   for (const provider of targetProviders) {
@@ -50075,7 +50143,7 @@ async function installSkillDirectories(skills, targetProviders, options2) {
       continue;
     }
     for (const skill of skills) {
-      const targetDir = join35(basePath, skill.name);
+      const targetDir = join36(basePath, skill.name);
       if (resolve10(skill.path) === resolve10(targetDir)) {
         results.push({
           provider,
@@ -50151,12 +50219,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 readdir9 } from "node:fs/promises";
-import { homedir as homedir19 } from "node:os";
-import { extname as extname3, join as join36, relative as relative5, sep as sep5 } from "node:path";
+import { homedir as homedir20 } from "node:os";
+import { extname as extname3, join as join37, relative as relative5, sep as sep5 } 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";
@@ -50169,13 +50237,13 @@ function getConfigSourcePath() {
   return findExistingProjectConfigPath(process.cwd()) ?? getGlobalConfigSourcePath();
 }
 function getGlobalConfigSourcePath() {
-  return join36(homedir19(), ".claude", "CLAUDE.md");
+  return join37(homedir20(), ".claude", "CLAUDE.md");
 }
 function getRulesSourcePath() {
-  return findExistingProjectLayoutPath(process.cwd(), "rules") ?? join36(homedir19(), ".claude", "rules");
+  return findExistingProjectLayoutPath(process.cwd(), "rules") ?? join37(homedir20(), ".claude", "rules");
 }
 function getHooksSourcePath() {
-  return findExistingProjectLayoutPath(process.cwd(), "hooks") ?? join36(homedir19(), ".claude", "hooks");
+  return findExistingProjectLayoutPath(process.cwd(), "hooks") ?? join37(homedir20(), ".claude", "hooks");
 }
 async function discoverConfig(sourcePath) {
   const path3 = sourcePath ?? getConfigSourcePath();
@@ -50227,7 +50295,7 @@ async function discoverHooks(sourcePath) {
     }
     if (!HOOK_EXTENSIONS.has(ext))
       continue;
-    const fullPath = join36(path3, entry.name);
+    const fullPath = join37(path3, entry.name);
     try {
       const content = await readFile16(fullPath, "utf-8");
       items.push({
@@ -50253,7 +50321,7 @@ async function discoverPortableFiles(dir, baseDir, options2) {
   for (const entry of entries) {
     if (entry.name.startsWith("."))
       continue;
-    const fullPath = join36(dir, entry.name);
+    const fullPath = join37(dir, entry.name);
     if (entry.isSymbolicLink()) {
       continue;
     }
@@ -50297,7 +50365,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 basename10, dirname as dirname10, join as join37 } from "node:path";
+import { basename as basename10, dirname as dirname10, join as join38 } from "node:path";
 async function inspectHooksSettings(settingsPath) {
   try {
     if (!existsSync21(settingsPath)) {
@@ -50478,8 +50546,8 @@ async function migrateHooksSettings(options2) {
       targetSettingsPath: null
     };
   }
-  const resolvedSourcePath = isGlobal ? sourceSettingsPath : join37(process.cwd(), sourceSettingsPath);
-  const resolvedTargetPath = isGlobal ? targetSettingsPath : join37(process.cwd(), targetSettingsPath);
+  const resolvedSourcePath = isGlobal ? sourceSettingsPath : join38(process.cwd(), sourceSettingsPath);
+  const resolvedTargetPath = isGlobal ? targetSettingsPath : join38(process.cwd(), targetSettingsPath);
   const sourceHooksResult = await inspectHooksSettings(resolvedSourcePath);
   if (sourceHooksResult.status === "missing-file") {
     return {
@@ -53075,20 +53143,20 @@ var init_reconciler = __esm(() => {
 
 // src/commands/skills/skills-discovery.ts
 import { readFile as readFile20, readdir as readdir10, stat as stat7 } from "node:fs/promises";
-import { homedir as homedir20 } from "node:os";
-import { dirname as dirname11, join as join38 } from "node:path";
+import { homedir as homedir21 } from "node:os";
+import { dirname as dirname11, join as join39 } from "node:path";
 function getSkillSourcePath() {
-  const bundledRoot = join38(process.cwd(), "node_modules", "claudekit-engineer");
+  const bundledRoot = join39(process.cwd(), "node_modules", "claudekit-engineer");
   return findFirstExistingPath([
-    join38(bundledRoot, "skills"),
+    join39(bundledRoot, "skills"),
     ...getProjectLayoutCandidates(bundledRoot, "skills"),
     ...getProjectLayoutCandidates(process.cwd(), "skills"),
-    join38(home5, ".claude/skills")
+    join39(home5, ".claude/skills")
   ]);
 }
 async function hasSkillMd(dir) {
   try {
-    const skillPath = join38(dir, "SKILL.md");
+    const skillPath = join39(dir, "SKILL.md");
     const stats = await stat7(skillPath);
     return stats.isFile();
   } catch {
@@ -53136,9 +53204,9 @@ async function discoverSkills(sourcePath) {
       if (!entry.isDirectory() || SKIP_DIRS3.includes(entry.name)) {
         continue;
       }
-      const skillDir = join38(searchPath, entry.name);
+      const skillDir = join39(searchPath, entry.name);
       if (await hasSkillMd(skillDir)) {
-        const skill = await parseSkillMd(join38(skillDir, "SKILL.md"));
+        const skill = await parseSkillMd(join39(skillDir, "SKILL.md"));
         if (skill && !seenNames.has(skill.name)) {
           skills.push(skill);
           seenNames.add(skill.name);
@@ -53157,7 +53225,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"];
 });
 
@@ -53260,8 +53328,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 basename11, join as join39, resolve as resolve11 } from "node:path";
+import { homedir as homedir22 } from "node:os";
+import { basename as basename11, join as join40, resolve as resolve11 } from "node:path";
 function isDisallowedControlCode(codePoint) {
   return codePoint >= 0 && codePoint <= 8 || codePoint >= 11 && codePoint <= 31 || codePoint >= 127 && codePoint <= 159;
 }
@@ -53828,12 +53896,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: join39(cwd2, ".claude"),
-          global: join39(home6, ".claude")
+          project: join40(cwd2, ".claude"),
+          global: join40(home6, ".claude")
         },
         sourcePaths: discovered.sourcePaths,
         sourceOrigins: {
@@ -54862,12 +54930,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 join40 } from "node:path";
+import { join as join41 } from "node:path";
 function scanPlanDir(dir) {
   if (!existsSync25(dir))
     return [];
   try {
-    return readdirSync3(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join40(dir, entry.name, "plan.md")).filter(existsSync25);
+    return readdirSync3(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join41(dir, entry.name, "plan.md")).filter(existsSync25);
   } catch {
     return [];
   }
@@ -54942,7 +55010,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 basename13, dirname as dirname14, join as join41 } from "node:path";
+import { basename as basename13, dirname as dirname14, join as join42 } from "node:path";
 function phaseNameToFilename(id, name) {
   const numMatch = /^(\d+)([a-z]*)$/i.exec(id);
   const num = numMatch ? numMatch[1] : id;
@@ -55050,12 +55118,12 @@ function scaffoldPlan(options2) {
   mkdirSync2(dir, { recursive: true });
   const resolvedPhases = resolvePhaseIds(options2.phases);
   const optionsWithResolved = { ...options2, phases: resolvedPhases };
-  const planFile = join41(dir, "plan.md");
+  const planFile = join42(dir, "plan.md");
   writeFileSync3(planFile, generatePlanMd(optionsWithResolved), "utf8");
   const phaseFiles = [];
   for (const phase of resolvedPhases) {
     const filename = phaseNameToFilename(phase.id, phase.name);
-    const phaseFile = join41(dir, filename);
+    const phaseFile = join42(dir, filename);
     writeFileSync3(phaseFile, generatePhaseTemplate(phase), "utf8");
     phaseFiles.push(phaseFile);
   }
@@ -55135,7 +55203,7 @@ function phaseNameFilenameFromTableRow(body, phaseId, planDir) {
       continue;
     const linkMatch = /\[([^\]]+)\]\(\.\/([^)]+)\)/.exec(row);
     if (linkMatch)
-      return join41(planDir, linkMatch[2]);
+      return join42(planDir, linkMatch[2]);
   }
   return null;
 }
@@ -55216,7 +55284,7 @@ function addPhase(planFile, name, afterId) {
 `);
   }
   writeFileSync3(planFile, import_gray_matter8.default.stringify(updatedBody, frontmatter), "utf8");
-  const phaseFilePath = join41(planDir, filename);
+  const phaseFilePath = join42(planDir, filename);
   writeFileSync3(phaseFilePath, generatePhaseTemplate({ id: phaseId, name }), "utf8");
   return { phaseId, phaseFile: phaseFilePath };
 }
@@ -55380,8 +55448,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 basename15, join as join42, resolve as resolve14 } from "node:path";
+import { homedir as homedir23 } from "node:os";
+import { basename as basename15, join as join43, resolve as resolve14 } from "node:path";
 function registerProjectRoutes(app) {
   app.get("/api/projects", async (req, res) => {
     try {
@@ -55400,7 +55468,7 @@ function registerProjectRoutes(app) {
       for (const discovered of discoveredProjects) {
         if (registeredPaths.has(discovered.path))
           continue;
-        if (discovered.path === join42(homedir22(), ".claude"))
+        if (discovered.path === join43(homedir23(), ".claude"))
           continue;
         const projectInfo = await detectAndBuildProjectInfo(discovered.path, `discovered-${discovered.path}`);
         if (projectInfo) {
@@ -55416,7 +55484,7 @@ function registerProjectRoutes(app) {
         if (cwdProject) {
           projects.push(cwdProject);
         }
-        const globalDir = join42(homedir22(), ".claude");
+        const globalDir = join43(homedir23(), ".claude");
         const globalProject = await detectAndBuildProjectInfo(globalDir, "global");
         if (globalProject) {
           projects.push(globalProject);
@@ -55488,12 +55556,12 @@ function registerProjectRoutes(app) {
       const body = validation.data;
       let projectPath = body.path;
       if (projectPath.startsWith("~/") || projectPath === "~") {
-        projectPath = join42(homedir22(), projectPath.slice(1));
+        projectPath = join43(homedir23(), projectPath.slice(1));
       } else if (projectPath.startsWith("~\\")) {
-        projectPath = join42(homedir22(), projectPath.slice(1));
+        projectPath = join43(homedir23(), projectPath.slice(1));
       }
       projectPath = resolve14(projectPath);
-      const homeDir = homedir22();
+      const homeDir = homedir23();
       if (projectPath.includes("..") || !projectPath.startsWith(homeDir)) {
         res.status(400).json({ error: "Invalid path after expansion" });
         return;
@@ -55550,7 +55618,7 @@ function registerProjectRoutes(app) {
       if (id === "current") {
         projectPath = process.cwd();
       } else if (id === "global") {
-        projectPath = join42(homedir22(), ".claude");
+        projectPath = join43(homedir23(), ".claude");
       } else {
         res.status(404).json({ error: "Project not found" });
         return;
@@ -55612,8 +55680,8 @@ function registerProjectRoutes(app) {
   });
 }
 async function buildProjectInfoFromRegistry(registered) {
-  const claudeDir2 = join42(registered.path, ".claude");
-  const metadataPath = join42(claudeDir2, "metadata.json");
+  const claudeDir2 = join43(registered.path, ".claude");
+  const metadataPath = join43(claudeDir2, "metadata.json");
   if (!existsSync29(registered.path)) {
     return null;
   }
@@ -55630,7 +55698,7 @@ async function buildProjectInfoFromRegistry(registered) {
   const hasLocalConfig = hasClaudeDir && CkConfigManager.projectConfigExists(registered.path, false);
   const settings = await readSettings();
   const skills = await scanSkills();
-  const settingsPath = join42(homedir22(), ".claude", "settings.json");
+  const settingsPath = join43(homedir23(), ".claude", "settings.json");
   const health = existsSync29(settingsPath) ? "healthy" : "warning";
   const model = getCurrentModel() || settings?.model || "claude-sonnet-4";
   return {
@@ -55653,8 +55721,8 @@ async function buildProjectInfoFromRegistry(registered) {
   };
 }
 async function detectAndBuildProjectInfo(path5, id) {
-  const claudeDir2 = id === "global" ? path5 : join42(path5, ".claude");
-  const metadataPath = join42(claudeDir2, "metadata.json");
+  const claudeDir2 = id === "global" ? path5 : join43(path5, ".claude");
+  const metadataPath = join43(claudeDir2, "metadata.json");
   if (!existsSync29(metadataPath)) {
     if (!existsSync29(claudeDir2)) {
       return null;
@@ -55672,7 +55740,7 @@ async function detectAndBuildProjectInfo(path5, id) {
   const hasLocalConfig = CkConfigManager.projectConfigExists(path5, id === "global");
   const settings = await readSettings();
   const skills = await scanSkills();
-  const settingsPath = join42(homedir22(), ".claude", "settings.json");
+  const settingsPath = join43(homedir23(), ".claude", "settings.json");
   const health = existsSync29(settingsPath) ? "healthy" : "warning";
   const model = getCurrentModel() || settings?.model || "claude-sonnet-4";
   return {
@@ -55713,32 +55781,32 @@ var init_project_routes = __esm(() => {
 });
 
 // src/domains/web-server/routes/session-routes.ts
-import { homedir as homedir23 } from "node:os";
-import { join as join43 } from "node:path";
+import { homedir as homedir24 } from "node:os";
+import { join as join44 } 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 join43(home6, ".claude", "projects", claudeEncoded);
+      return join44(home6, ".claude", "projects", claudeEncoded);
     } catch {
       return null;
     }
   }
   if (projectId === "current") {
     const cwdEncoded = encodePath(process.cwd());
-    return join43(home6, ".claude", "projects", cwdEncoded);
+    return join44(home6, ".claude", "projects", cwdEncoded);
   }
   if (projectId === "global") {
-    const globalEncoded = encodePath(join43(home6, ".claude"));
-    return join43(home6, ".claude", "projects", globalEncoded);
+    const globalEncoded = encodePath(join44(home6, ".claude"));
+    return join44(home6, ".claude", "projects", globalEncoded);
   }
   const registered = await ProjectsRegistryManager.getProject(projectId);
   if (registered) {
     const claudeEncoded = encodePath(registered.path);
-    return join43(home6, ".claude", "projects", claudeEncoded);
+    return join44(home6, ".claude", "projects", claudeEncoded);
   }
   return null;
 }
@@ -55755,7 +55823,7 @@ function registerSessionRoutes(app) {
       res.status(404).json({ error: "Project not found" });
       return;
     }
-    const allowedBase = join43(homedir23(), ".claude", "projects");
+    const allowedBase = join44(homedir24(), ".claude", "projects");
     if (!projectDir.startsWith(allowedBase)) {
       res.status(403).json({ error: "Access denied" });
       return;
@@ -55777,7 +55845,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 {
@@ -55833,7 +55901,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) {
@@ -55867,8 +55935,8 @@ var init_settings_routes = __esm(() => {
 
 // src/commands/skills/agents.ts
 import { existsSync as existsSync30, readdirSync as readdirSync4, statSync as statSync5 } from "node:fs";
-import { homedir as homedir25, platform as platform5 } from "node:os";
-import { join as join44 } from "node:path";
+import { homedir as homedir26, platform as platform5 } from "node:os";
+import { join as join45 } from "node:path";
 function hasInstallSignal2(path5) {
   if (!path5 || !existsSync30(path5)) {
     return false;
@@ -55891,14 +55959,14 @@ function hasAnyInstallSignal2(paths) {
 }
 function hasOpenCodeInstallSignal2() {
   return hasAnyInstallSignal2([
-    join44(process.cwd(), "opencode.json"),
-    join44(process.cwd(), "opencode.jsonc"),
-    join44(process.cwd(), ".opencode/agents"),
-    join44(process.cwd(), ".opencode/commands"),
-    join44(home6, ".config/opencode/AGENTS.md"),
-    join44(home6, ".config/opencode/agents"),
-    join44(home6, ".config/opencode/commands"),
-    join44(home6, ".opencode", "bin", OPENCODE_BINARY_NAME2)
+    join45(process.cwd(), "opencode.json"),
+    join45(process.cwd(), "opencode.jsonc"),
+    join45(process.cwd(), ".opencode/agents"),
+    join45(process.cwd(), ".opencode/commands"),
+    join45(home6, ".config/opencode/AGENTS.md"),
+    join45(home6, ".config/opencode/agents"),
+    join45(home6, ".config/opencode/commands"),
+    join45(home6, ".opencode", "bin", OPENCODE_BINARY_NAME2)
   ]);
 }
 async function detectInstalledAgents() {
@@ -55916,7 +55984,7 @@ function getAgentConfig(type) {
 function getInstallPath(skillName, agent, options2) {
   const config = agents[agent];
   const basePath = options2.global ? config.globalPath : config.projectPath;
-  return join44(basePath, skillName);
+  return join45(basePath, skillName);
 }
 function isSkillInstalled(skillName, agent, options2) {
   const installPath = getInstallPath(skillName, agent, options2);
@@ -55924,106 +55992,106 @@ function isSkillInstalled(skillName, agent, options2) {
 }
 var home6, OPENCODE_BINARY_NAME2, agents;
 var init_agents = __esm(() => {
-  home6 = homedir25();
+  home6 = homedir26();
   OPENCODE_BINARY_NAME2 = platform5() === "win32" ? "opencode.exe" : "opencode";
   agents = {
     "claude-code": {
       name: "claude-code",
       displayName: "Claude Code",
       projectPath: ".claude/skills",
-      globalPath: join44(home6, ".claude/skills"),
-      detect: async () => existsSync30(join44(home6, ".claude"))
+      globalPath: join45(home6, ".claude/skills"),
+      detect: async () => existsSync30(join45(home6, ".claude"))
     },
     cursor: {
       name: "cursor",
       displayName: "Cursor",
       projectPath: ".cursor/skills",
-      globalPath: join44(home6, ".cursor/skills"),
-      detect: async () => existsSync30(join44(home6, ".cursor"))
+      globalPath: join45(home6, ".cursor/skills"),
+      detect: async () => existsSync30(join45(home6, ".cursor"))
     },
     codex: {
       name: "codex",
       displayName: "Codex",
       projectPath: ".codex/skills",
-      globalPath: join44(home6, ".codex/skills"),
-      detect: async () => existsSync30(join44(home6, ".codex"))
+      globalPath: join45(home6, ".codex/skills"),
+      detect: async () => existsSync30(join45(home6, ".codex"))
     },
     opencode: {
       name: "opencode",
       displayName: "OpenCode",
       projectPath: ".claude/skills",
-      globalPath: join44(home6, ".claude/skills"),
+      globalPath: join45(home6, ".claude/skills"),
       detect: async () => hasOpenCodeInstallSignal2()
     },
     goose: {
       name: "goose",
       displayName: "Goose",
       projectPath: ".goose/skills",
-      globalPath: join44(home6, ".config/goose/skills"),
-      detect: async () => existsSync30(join44(home6, ".config/goose"))
+      globalPath: join45(home6, ".config/goose/skills"),
+      detect: async () => existsSync30(join45(home6, ".config/goose"))
     },
     "gemini-cli": {
       name: "gemini-cli",
       displayName: "Gemini CLI",
       projectPath: ".agents/skills",
-      globalPath: join44(home6, ".agents/skills"),
-      detect: async () => existsSync30(join44(home6, ".gemini"))
+      globalPath: join45(home6, ".agents/skills"),
+      detect: async () => existsSync30(join45(home6, ".gemini"))
     },
     antigravity: {
       name: "antigravity",
       displayName: "Antigravity",
       projectPath: ".agent/skills",
-      globalPath: join44(home6, ".gemini/antigravity/skills"),
-      detect: async () => existsSync30(join44(process.cwd(), ".agent")) || existsSync30(join44(home6, ".gemini/antigravity"))
+      globalPath: join45(home6, ".gemini/antigravity/skills"),
+      detect: async () => existsSync30(join45(process.cwd(), ".agent")) || existsSync30(join45(home6, ".gemini/antigravity"))
     },
     "github-copilot": {
       name: "github-copilot",
       displayName: "GitHub Copilot",
       projectPath: ".github/skills",
-      globalPath: join44(home6, ".copilot/skills"),
-      detect: async () => existsSync30(join44(home6, ".copilot"))
+      globalPath: join45(home6, ".copilot/skills"),
+      detect: async () => existsSync30(join45(home6, ".copilot"))
     },
     amp: {
       name: "amp",
       displayName: "Amp",
       projectPath: ".agents/skills",
-      globalPath: join44(home6, ".config/agents/skills"),
-      detect: async () => existsSync30(join44(home6, ".config/amp"))
+      globalPath: join45(home6, ".config/agents/skills"),
+      detect: async () => existsSync30(join45(home6, ".config/amp"))
     },
     kilo: {
       name: "kilo",
       displayName: "Kilo Code",
       projectPath: ".kilocode/skills",
-      globalPath: join44(home6, ".kilocode/skills"),
-      detect: async () => existsSync30(join44(home6, ".kilocode"))
+      globalPath: join45(home6, ".kilocode/skills"),
+      detect: async () => existsSync30(join45(home6, ".kilocode"))
     },
     roo: {
       name: "roo",
       displayName: "Roo Code",
       projectPath: ".roo/skills",
-      globalPath: join44(home6, ".roo/skills"),
-      detect: async () => existsSync30(join44(home6, ".roo"))
+      globalPath: join45(home6, ".roo/skills"),
+      detect: async () => existsSync30(join45(home6, ".roo"))
     },
     windsurf: {
       name: "windsurf",
       displayName: "Windsurf",
       projectPath: ".windsurf/skills",
-      globalPath: join44(home6, ".codeium/windsurf/skills"),
-      detect: async () => existsSync30(join44(home6, ".codeium/windsurf"))
+      globalPath: join45(home6, ".codeium/windsurf/skills"),
+      detect: async () => existsSync30(join45(home6, ".codeium/windsurf"))
     },
     cline: {
       name: "cline",
       displayName: "Cline",
       projectPath: ".cline/skills",
-      globalPath: join44(home6, ".cline/skills"),
-      detect: async () => existsSync30(join44(home6, ".cline"))
+      globalPath: join45(home6, ".cline/skills"),
+      detect: async () => existsSync30(join45(home6, ".cline"))
     },
     openhands: {
       name: "openhands",
       displayName: "OpenHands",
       projectPath: ".openhands/skills",
-      globalPath: join44(home6, ".openhands/skills"),
-      detect: async () => existsSync30(join44(home6, ".openhands"))
+      globalPath: join45(home6, ".openhands/skills"),
+      detect: async () => existsSync30(join45(home6, ".openhands"))
     }
   };
 });
@@ -56031,8 +56099,8 @@ var init_agents = __esm(() => {
 // src/commands/skills/skills-registry.ts
 import { existsSync as existsSync31 } from "node:fs";
 import { mkdir as mkdir11, readFile as readFile23, writeFile as writeFile11 } from "node:fs/promises";
-import { homedir as homedir26 } from "node:os";
-import { dirname as dirname17, join as join45, sep as sep7 } from "node:path";
+import { homedir as homedir27 } from "node:os";
+import { dirname as dirname17, join as join46, sep as sep7 } from "node:path";
 function getCliVersion3() {
   try {
     if (process.env.npm_package_version) {
@@ -56143,8 +56211,8 @@ async function syncRegistry() {
 var home7, REGISTRY_PATH2, SkillInstallationSchema, SkillRegistrySchema, REGISTRY_PATH_MIGRATIONS;
 var init_skills_registry = __esm(() => {
   init_zod();
-  home7 = homedir26();
-  REGISTRY_PATH2 = join45(home7, ".claudekit", "skill-registry.json");
+  home7 = homedir27();
+  REGISTRY_PATH2 = join46(home7, ".claudekit", "skill-registry.json");
   SkillInstallationSchema = exports_external.object({
     skill: exports_external.string(),
     agent: exports_external.string(),
@@ -56175,8 +56243,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 mkdir12, rm as rm7, stat as stat8 } from "node:fs/promises";
-import { homedir as homedir27 } from "node:os";
-import { dirname as dirname18, join as join46, resolve as resolve15 } from "node:path";
+import { homedir as homedir28 } from "node:os";
+import { dirname as dirname18, join as join47, resolve as resolve15 } from "node:path";
 function isSamePath2(path1, path22) {
   try {
     return resolve15(path1) === resolve15(path22);
@@ -56208,7 +56276,7 @@ async function cleanupLegacySkillPath(skillName, agent, global3) {
   if (!legacy)
     return;
   const legacyBase = global3 ? legacy.global : legacy.project;
-  const legacyPath = join46(legacyBase, skillName);
+  const legacyPath = join47(legacyBase, skillName);
   if (!existsSync32(legacyPath))
     return;
   await rm7(legacyPath, { recursive: true, force: true });
@@ -56218,7 +56286,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 = join46(newBase, skillName);
+        entry.path = join47(newBase, skillName);
         changed = true;
       }
     }
@@ -56306,7 +56374,7 @@ var init_skills_installer = __esm(() => {
   LEGACY_SKILL_PATHS = {
     "gemini-cli": {
       project: ".gemini/skills",
-      global: join46(homedir27(), ".gemini/skills")
+      global: join47(homedir28(), ".gemini/skills")
     }
   };
 });
@@ -56314,7 +56382,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 join47, resolve as resolve16 } from "node:path";
+import { join as join48, resolve as resolve16 } from "node:path";
 function isSamePath3(path1, path22) {
   try {
     return resolve16(path1) === resolve16(path22);
@@ -56370,7 +56438,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 = join47(basePath, skill);
+  const path5 = join48(basePath, skill);
   const registry = await readRegistry();
   if (!existsSync33(path5)) {
     return {
@@ -56923,7 +56991,7 @@ var init_pnpm_detector = __esm(() => {
 import { existsSync as existsSync34, realpathSync as realpathSync2 } from "node:fs";
 import { chmod as chmod2, mkdir as mkdir13, readFile as readFile24, writeFile as writeFile12 } from "node:fs/promises";
 import { platform as platform6 } from "node:os";
-import { join as join48 } from "node:path";
+import { join as join49 } from "node:path";
 function detectFromBinaryPath() {
   const normalizePath2 = (pathValue) => pathValue.replace(/\\/g, "/").toLowerCase();
   const detectFromNormalizedPath = (normalized) => {
@@ -57000,7 +57068,7 @@ function detectFromEnv() {
 }
 async function readCachedPm() {
   try {
-    const cacheFile = join48(PathResolver.getConfigDir(false), CACHE_FILE);
+    const cacheFile = join49(PathResolver.getConfigDir(false), CACHE_FILE);
     if (!existsSync34(cacheFile)) {
       return null;
     }
@@ -57031,7 +57099,7 @@ async function saveCachedPm(pm, getVersion) {
     return;
   try {
     const configDir = PathResolver.getConfigDir(false);
-    const cacheFile = join48(configDir, CACHE_FILE);
+    const cacheFile = join49(configDir, CACHE_FILE);
     if (!existsSync34(configDir)) {
       await mkdir13(configDir, { recursive: true });
       if (platform6() !== "win32") {
@@ -57094,7 +57162,7 @@ async function findOwningPm() {
 async function clearCache() {
   try {
     const { unlink: unlink6 } = await import("node:fs/promises");
-    const cacheFile = join48(PathResolver.getConfigDir(false), CACHE_FILE);
+    const cacheFile = join49(PathResolver.getConfigDir(false), CACHE_FILE);
     if (existsSync34(cacheFile)) {
       await unlink6(cacheFile);
       logger.debug("Package manager cache cleared");
@@ -57255,7 +57323,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "claudekit-cli",
-    version: "3.41.3-dev.1",
+    version: "3.41.3-dev.3",
     description: "CLI tool for bootstrapping and updating ClaudeKit projects",
     type: "module",
     repository: {
@@ -57728,9 +57796,9 @@ var init_package_manager_runner = __esm(() => {
 });
 
 // src/domains/migration/metadata-migration.ts
-import { join as join49 } from "node:path";
+import { join as join50 } from "node:path";
 async function detectMetadataFormat(claudeDir2) {
-  const metadataPath = join49(claudeDir2, "metadata.json");
+  const metadataPath = join50(claudeDir2, "metadata.json");
   if (!await import_fs_extra6.pathExists(metadataPath)) {
     return { format: "none", metadata: null, detectedKit: null };
   }
@@ -57782,7 +57850,7 @@ async function migrateToMultiKit(claudeDir2) {
       toFormat: "multi-kit"
     };
   }
-  const metadataPath = join49(claudeDir2, "metadata.json");
+  const metadataPath = join50(claudeDir2, "metadata.json");
   const legacy = detection.metadata;
   if (!legacy) {
     return {
@@ -57894,7 +57962,7 @@ var init_metadata_migration = __esm(() => {
 });
 
 // src/services/file-operations/claudekit-scanner.ts
-import { join as join50 } from "node:path";
+import { join as join51 } from "node:path";
 async function scanClaudeKitDirectory(directoryPath) {
   const counts = {
     agents: 0,
@@ -57908,33 +57976,33 @@ async function scanClaudeKitDirectory(directoryPath) {
     }
     const items = await import_fs_extra7.readdir(directoryPath);
     if (items.includes("agents")) {
-      const agentsPath = join50(directoryPath, "agents");
+      const agentsPath = join51(directoryPath, "agents");
       const agentFiles = await import_fs_extra7.readdir(agentsPath);
       counts.agents = agentFiles.filter((file) => file.endsWith(".md")).length;
     }
     if (items.includes("commands")) {
-      const commandsPath = join50(directoryPath, "commands");
+      const commandsPath = join51(directoryPath, "commands");
       const commandFiles = await import_fs_extra7.readdir(commandsPath);
       counts.commands = commandFiles.filter((file) => file.endsWith(".md")).length;
     }
     if (items.includes("rules")) {
-      const rulesPath = join50(directoryPath, "rules");
+      const rulesPath = join51(directoryPath, "rules");
       const ruleFiles = await import_fs_extra7.readdir(rulesPath);
       counts.rules = ruleFiles.filter((file) => file.endsWith(".md")).length;
     } else if (items.includes("workflows")) {
-      const workflowsPath = join50(directoryPath, "workflows");
+      const workflowsPath = join51(directoryPath, "workflows");
       const workflowFiles = await import_fs_extra7.readdir(workflowsPath);
       counts.rules = workflowFiles.filter((file) => file.endsWith(".md")).length;
     }
     if (items.includes("skills")) {
-      const skillsPath = join50(directoryPath, "skills");
+      const skillsPath = join51(directoryPath, "skills");
       const skillItems = await import_fs_extra7.readdir(skillsPath);
       let skillCount = 0;
       for (const item of skillItems) {
         if (SKIP_DIRS_CLAUDE_INTERNAL.includes(item)) {
           continue;
         }
-        const itemPath = join50(skillsPath, item);
+        const itemPath = join51(skillsPath, item);
         const stat9 = await import_fs_extra7.readdir(itemPath).catch(() => null);
         if (stat9?.includes("SKILL.md")) {
           skillCount++;
@@ -57976,14 +58044,14 @@ async function getClaudeKitSetup(projectDir = process.cwd()) {
   const globalDir = getGlobalInstallDir();
   if (await import_fs_extra7.pathExists(globalDir)) {
     setup.global.path = globalDir;
-    setup.global.metadata = await readClaudeKitMetadata(join50(globalDir, "metadata.json"));
+    setup.global.metadata = await readClaudeKitMetadata(join51(globalDir, "metadata.json"));
     setup.global.components = await scanClaudeKitDirectory(globalDir);
   }
-  const projectClaudeDir = join50(projectDir, ".claude");
+  const projectClaudeDir = join51(projectDir, ".claude");
   const isLocalSameAsGlobal = projectClaudeDir === globalDir;
   if (!isLocalSameAsGlobal && await import_fs_extra7.pathExists(projectClaudeDir)) {
     setup.project.path = projectClaudeDir;
-    setup.project.metadata = await readClaudeKitMetadata(join50(projectClaudeDir, "metadata.json"));
+    setup.project.metadata = await readClaudeKitMetadata(join51(projectClaudeDir, "metadata.json"));
     setup.project.components = await scanClaudeKitDirectory(projectClaudeDir);
   }
   return setup;
@@ -58441,7 +58509,7 @@ var init_error_handler2 = __esm(() => {
 // src/domains/versioning/release-cache.ts
 import { existsSync as existsSync35 } from "node:fs";
 import { mkdir as mkdir14, readFile as readFile27, unlink as unlink6, writeFile as writeFile14 } from "node:fs/promises";
-import { join as join51 } from "node:path";
+import { join as join52 } from "node:path";
 var ReleaseCacheEntrySchema, ReleaseCache;
 var init_release_cache = __esm(() => {
   init_logger();
@@ -58456,7 +58524,7 @@ var init_release_cache = __esm(() => {
     static CACHE_TTL_SECONDS = Number(process.env.CK_CACHE_TTL) || 3600;
     cacheDir;
     constructor() {
-      this.cacheDir = join51(PathResolver.getCacheDir(false), ReleaseCache.CACHE_DIR);
+      this.cacheDir = join52(PathResolver.getCacheDir(false), ReleaseCache.CACHE_DIR);
     }
     async get(key) {
       const cacheFile = this.getCachePath(key);
@@ -58514,7 +58582,7 @@ var init_release_cache = __esm(() => {
           const files = await readdir12(this.cacheDir);
           for (const file of files) {
             if (file.endsWith(".json")) {
-              await unlink6(join51(this.cacheDir, file));
+              await unlink6(join52(this.cacheDir, file));
             }
           }
           logger.debug("All release cache cleared");
@@ -58525,7 +58593,7 @@ var init_release_cache = __esm(() => {
     }
     getCachePath(key) {
       const safeKey = key.replace(/[^a-zA-Z0-9_-]/g, "_");
-      return join51(this.cacheDir, `${safeKey}.json`);
+      return join52(this.cacheDir, `${safeKey}.json`);
     }
     isExpired(timestamp) {
       const now = Date.now();
@@ -59166,7 +59234,7 @@ var init_github_client = __esm(() => {
 
 // src/commands/update/post-update-handler.ts
 import { exec as exec2, spawn as spawn2 } from "node:child_process";
-import { join as join52 } from "node:path";
+import { join as join53 } from "node:path";
 import { promisify as promisify8 } from "node:util";
 function selectKitForUpdate(params) {
   const { hasLocal, hasGlobal, localKits, globalKits } = params;
@@ -59198,7 +59266,7 @@ function selectKitForUpdate(params) {
   };
 }
 async function readMetadataFile(claudeDir2) {
-  const metadataPath = join52(claudeDir2, "metadata.json");
+  const metadataPath = join53(claudeDir2, "metadata.json");
   try {
     if (!await import_fs_extra8.pathExists(metadataPath))
       return null;
@@ -59569,7 +59637,7 @@ var init_update_cli = __esm(() => {
 // src/domains/versioning/version-cache.ts
 import { existsSync as existsSync36 } from "node:fs";
 import { mkdir as mkdir15, readFile as readFile29, writeFile as writeFile15 } from "node:fs/promises";
-import { join as join53 } from "node:path";
+import { join as join54 } from "node:path";
 var VersionCacheManager;
 var init_version_cache = __esm(() => {
   init_logger();
@@ -59579,7 +59647,7 @@ var init_version_cache = __esm(() => {
     static CACHE_TTL_MS = 7 * 24 * 60 * 60 * 1000;
     static getCacheFile() {
       const cacheDir = PathResolver.getCacheDir(false);
-      return join53(cacheDir, VersionCacheManager.CACHE_FILENAME);
+      return join54(cacheDir, VersionCacheManager.CACHE_FILENAME);
     }
     static async load() {
       const cacheFile = VersionCacheManager.getCacheFile();
@@ -59848,7 +59916,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 join54 } from "node:path";
+import { join as join55 } from "node:path";
 function hasCliUpdate(currentVersion, latestVersion) {
   if (!latestVersion) {
     return false;
@@ -60091,7 +60159,7 @@ async function getPackageJson() {
 }
 async function getKitMetadata2(kitName) {
   try {
-    const metadataPath = join54(PathResolver.getGlobalKitDir(), "metadata.json");
+    const metadataPath = join55(PathResolver.getGlobalKitDir(), "metadata.json");
     if (!existsSync37(metadataPath))
       return null;
     const content = await readFile30(metadataPath, "utf-8");
@@ -60238,7 +60306,7 @@ var init_routes = __esm(() => {
 
 // src/domains/web-server/static-server.ts
 import { existsSync as existsSync38 } from "node:fs";
-import { dirname as dirname19, join as join55, resolve as resolve17 } from "node:path";
+import { dirname as dirname19, join as join56, resolve as resolve17 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 function addRuntimeUiCandidate(candidates, runtimePath) {
   if (!runtimePath) {
@@ -60249,21 +60317,21 @@ function addRuntimeUiCandidate(candidates, runtimePath) {
     return;
   }
   const entryDir = dirname19(resolve17(runtimePath));
-  candidates.add(join55(entryDir, "ui"));
-  candidates.add(join55(entryDir, "..", "dist", "ui"));
+  candidates.add(join56(entryDir, "ui"));
+  candidates.add(join56(entryDir, "..", "dist", "ui"));
 }
 function resolveUiDistPath() {
   const candidates = new Set;
   addRuntimeUiCandidate(candidates, process.argv[1]);
-  candidates.add(join55(__dirname3, "ui"));
-  candidates.add(join55(process.cwd(), "dist", "ui"));
-  candidates.add(join55(process.cwd(), "src", "ui", "dist"));
+  candidates.add(join56(__dirname3, "ui"));
+  candidates.add(join56(process.cwd(), "dist", "ui"));
+  candidates.add(join56(process.cwd(), "src", "ui", "dist"));
   for (const path5 of candidates) {
-    if (existsSync38(join55(path5, "index.html"))) {
+    if (existsSync38(join56(path5, "index.html"))) {
       return path5;
     }
   }
-  return Array.from(candidates)[0] ?? join55(process.cwd(), "dist", "ui");
+  return Array.from(candidates)[0] ?? join56(process.cwd(), "dist", "ui");
 }
 function serveStatic(app) {
   const uiDistPath = resolveUiDistPath();
@@ -60299,7 +60367,7 @@ function serveStatic(app) {
     if (req.path.startsWith("/assets/") || req.path.match(/\.(js|css|ico|png|jpg|svg|woff2?)$/)) {
       return next();
     }
-    res.sendFile(join55(uiDistPath, "index.html"), { dotfiles: "allow" });
+    res.sendFile(join56(uiDistPath, "index.html"), { dotfiles: "allow" });
   });
   logger.debug(`Serving static files from ${uiDistPath}`);
 }
@@ -65148,7 +65216,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) {
@@ -65180,7 +65248,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;
@@ -65226,8 +65294,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);
@@ -65306,7 +65374,7 @@ var init_gemini_installer = __esm(() => {
 });
 
 // src/services/package-installer/opencode-installer.ts
-import { join as join73 } from "node:path";
+import { join as join74 } from "node:path";
 async function isOpenCodeInstalled() {
   try {
     await execAsync7("opencode --version", { timeout: 5000 });
@@ -65329,7 +65397,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 = join73(tmpdir4(), "opencode-install.sh");
+    const tempScriptPath = join74(tmpdir4(), "opencode-install.sh");
     try {
       logger.info("Downloading OpenCode installation script...");
       await execFileAsync5("curl", ["-fsSL", "https://opencode.ai/install", "-o", tempScriptPath], {
@@ -65381,7 +65449,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 join74 } from "node:path";
+import { join as join75 } from "node:path";
 function parseNameReason(str2) {
   const colonIndex = str2.indexOf(":");
   if (colonIndex === -1) {
@@ -65390,7 +65458,7 @@ function parseNameReason(str2) {
   return [str2.slice(0, colonIndex).trim(), str2.slice(colonIndex + 1).trim()];
 }
 function displayInstallErrors(skillsDir2) {
-  const summaryPath = join74(skillsDir2, ".install-error-summary.json");
+  const summaryPath = join75(skillsDir2, ".install-error-summary.json");
   if (!existsSync49(summaryPath)) {
     logger.error("Skills installation failed. Run with --verbose for details.");
     return;
@@ -65481,7 +65549,7 @@ async function checkNeedsSudoPackages() {
   }
 }
 function hasInstallState(skillsDir2) {
-  const stateFilePath = join74(skillsDir2, ".install-state.json");
+  const stateFilePath = join75(skillsDir2, ".install-state.json");
   return existsSync49(stateFilePath);
 }
 var WHICH_COMMAND_TIMEOUT_MS = 5000;
@@ -65490,7 +65558,7 @@ var init_install_error_handler = __esm(() => {
 });
 
 // src/services/package-installer/skills-installer.ts
-import { join as join75 } from "node:path";
+import { join as join76 } from "node:path";
 async function installSkillsDependencies(skillsDir2, options2 = {}) {
   const { skipConfirm = false, withSudo = false } = options2;
   const displayName = "Skills Dependencies";
@@ -65516,7 +65584,7 @@ async function installSkillsDependencies(skillsDir2, options2 = {}) {
     const clack = await Promise.resolve().then(() => (init_dist2(), exports_dist));
     const platform9 = process.platform;
     const scriptName = platform9 === "win32" ? "install.ps1" : "install.sh";
-    const scriptPath = join75(skillsDir2, scriptName);
+    const scriptPath = join76(skillsDir2, scriptName);
     try {
       validateScriptPath(skillsDir2, scriptPath);
     } catch (error) {
@@ -65532,7 +65600,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: ${join75(skillsDir2, "INSTALLATION.md")}`);
+      logger.info(`  See: ${join76(skillsDir2, "INSTALLATION.md")}`);
       logger.info("");
       logger.info("Quick start:");
       logger.info("  cd .claude/skills/ai-multimodal/scripts");
@@ -65579,7 +65647,7 @@ async function installSkillsDependencies(skillsDir2, options2 = {}) {
       logger.info(`  ${platform9 === "win32" ? `powershell -File "${scriptPath}"` : `bash ${scriptPath}`}`);
       logger.info("");
       logger.info("Or see complete guide:");
-      logger.info(`  ${join75(skillsDir2, "INSTALLATION.md")}`);
+      logger.info(`  ${join76(skillsDir2, "INSTALLATION.md")}`);
       return {
         success: false,
         package: displayName,
@@ -65700,7 +65768,7 @@ async function installSkillsDependencies(skillsDir2, options2 = {}) {
     logger.info("\uD83D\uDCD6 Manual Installation Instructions:");
     logger.info("");
     logger.info("See complete guide:");
-    logger.info(`  cat ${join75(skillsDir2, "INSTALLATION.md")}`);
+    logger.info(`  cat ${join76(skillsDir2, "INSTALLATION.md")}`);
     logger.info("");
     logger.info("Quick start:");
     logger.info("  cd .claude/skills/ai-multimodal/scripts");
@@ -65746,7 +65814,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 mkdir19, readFile as readFile37, writeFile as writeFile20 } from "node:fs/promises";
-import { dirname as dirname22, join as join76 } from "node:path";
+import { dirname as dirname22, join as join77 } from "node:path";
 async function readJsonFile(filePath) {
   try {
     const content = await readFile37(filePath, "utf-8");
@@ -65758,7 +65826,7 @@ async function readJsonFile(filePath) {
   }
 }
 async function addGeminiToGitignore(projectDir) {
-  const gitignorePath = join76(projectDir, ".gitignore");
+  const gitignorePath = join77(projectDir, ".gitignore");
   const geminiPattern = ".gemini/";
   try {
     let content = "";
@@ -65849,13 +65917,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 join77 } from "node:path";
+import { homedir as homedir32 } from "node:os";
+import { join as join78 } from "node:path";
 function getGlobalMcpConfigPath() {
-  return join77(homedir30(), ".claude", ".mcp.json");
+  return join78(homedir32(), ".claude", ".mcp.json");
 }
 function getLocalMcpConfigPath(projectDir) {
-  return join77(projectDir, ".mcp.json");
+  return join78(projectDir, ".mcp.json");
 }
 function findMcpConfigPath(projectDir) {
   const localPath = getLocalMcpConfigPath(projectDir);
@@ -65873,9 +65941,9 @@ function findMcpConfigPath(projectDir) {
 }
 function getGeminiSettingsPath(projectDir, isGlobal) {
   if (isGlobal) {
-    return join77(homedir30(), ".gemini", "settings.json");
+    return join78(homedir32(), ".gemini", "settings.json");
   }
-  return join77(projectDir, ".gemini", "settings.json");
+  return join78(projectDir, ".gemini", "settings.json");
 }
 function checkExistingGeminiConfig(projectDir, isGlobal = false) {
   const geminiSettingsPath = getGeminiSettingsPath(projectDir, isGlobal);
@@ -65905,7 +65973,7 @@ var init_validation = __esm(() => {
 // src/services/package-installer/gemini-mcp/linker-core.ts
 import { existsSync as existsSync52 } from "node:fs";
 import { mkdir as mkdir20, symlink as symlink3 } from "node:fs/promises";
-import { dirname as dirname23, join as join78 } from "node:path";
+import { dirname as dirname23, join as join79 } from "node:path";
 async function createSymlink(targetPath, linkPath, projectDir, isGlobal) {
   const linkDir = dirname23(linkPath);
   if (!existsSync52(linkDir)) {
@@ -65916,7 +65984,7 @@ async function createSymlink(targetPath, linkPath, projectDir, isGlobal) {
   if (isGlobal) {
     symlinkTarget = getGlobalMcpConfigPath();
   } else {
-    const localMcpPath = join78(projectDir, ".mcp.json");
+    const localMcpPath = join79(projectDir, ".mcp.json");
     const isLocalConfig = targetPath === localMcpPath;
     symlinkTarget = isLocalConfig ? "../.mcp.json" : targetPath;
   }
@@ -68333,9 +68401,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 join129 } from "node:path";
+import { join as join131 } from "node:path";
 async function createWorktree(projectDir, issueNumber, baseBranch) {
-  const worktreePath = join129(projectDir, WORKTREE_DIR, `issue-${issueNumber}`);
+  const worktreePath = join131(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`);
@@ -68353,7 +68421,7 @@ async function createWorktree(projectDir, issueNumber, baseBranch) {
   return worktreePath;
 }
 async function removeWorktree(projectDir, issueNumber) {
-  const worktreePath = join129(projectDir, WORKTREE_DIR, `issue-${issueNumber}`);
+  const worktreePath = join131(projectDir, WORKTREE_DIR, `issue-${issueNumber}`);
   const branchName = `ck-watch/issue-${issueNumber}`;
   try {
     await spawnAndCollect("git", ["worktree", "remove", worktreePath, "--force"], projectDir);
@@ -68367,7 +68435,7 @@ async function listActiveWorktrees(projectDir) {
   try {
     const output2 = await spawnAndCollect("git", ["worktree", "list", "--porcelain"], projectDir);
     const issueNumbers = [];
-    const worktreePrefix = join129(projectDir, WORKTREE_DIR, "issue-").replace(/\\/g, "/");
+    const worktreePrefix = join131(projectDir, WORKTREE_DIR, "issue-").replace(/\\/g, "/");
     for (const line of output2.split(`
 `)) {
       if (line.startsWith("worktree ")) {
@@ -68395,7 +68463,7 @@ async function cleanupAllWorktrees(projectDir) {
   await spawnAndCollect("git", ["worktree", "prune"], projectDir).catch(() => {});
 }
 async function ensureGitignore(projectDir) {
-  const gitignorePath = join129(projectDir, ".gitignore");
+  const gitignorePath = join131(projectDir, ".gitignore");
   try {
     const content = existsSync60(gitignorePath) ? await readFile54(gitignorePath, "utf-8") : "";
     if (!content.includes(".worktrees")) {
@@ -68501,8 +68569,8 @@ var init_content_validator = __esm(() => {
 import { createHash as createHash7 } from "node:crypto";
 import { existsSync as existsSync66, mkdirSync as mkdirSync4, readFileSync as readFileSync15, readdirSync as readdirSync9, statSync as statSync11 } from "node:fs";
 import { rename as rename10, writeFile as writeFile35 } from "node:fs/promises";
-import { homedir as homedir33 } from "node:os";
-import { basename as basename23, join as join136 } from "node:path";
+import { homedir as homedir37 } from "node:os";
+import { basename as basename23, join as join138 } from "node:path";
 function getCachedContext(repoPath) {
   const cachePath = getCacheFilePath(repoPath);
   if (!existsSync66(cachePath))
@@ -68545,25 +68613,25 @@ function computeSourceHash(repoPath) {
 }
 function getDocSourcePaths(repoPath) {
   const paths = [];
-  const docsDir = join136(repoPath, "docs");
+  const docsDir = join138(repoPath, "docs");
   if (existsSync66(docsDir)) {
     try {
       const files = readdirSync9(docsDir);
       for (const f3 of files) {
         if (f3.endsWith(".md"))
-          paths.push(join136(docsDir, f3));
+          paths.push(join138(docsDir, f3));
       }
     } catch {}
   }
-  const readme = join136(repoPath, "README.md");
+  const readme = join138(repoPath, "README.md");
   if (existsSync66(readme))
     paths.push(readme);
-  const stylesDir = join136(repoPath, "assets", "writing-styles");
+  const stylesDir = join138(repoPath, "assets", "writing-styles");
   if (existsSync66(stylesDir)) {
     try {
       const files = readdirSync9(stylesDir);
       for (const f3 of files) {
-        paths.push(join136(stylesDir, f3));
+        paths.push(join138(stylesDir, f3));
       }
     } catch {}
   }
@@ -68572,11 +68640,11 @@ function getDocSourcePaths(repoPath) {
 function getCacheFilePath(repoPath) {
   const repoName = basename23(repoPath).replace(/[^a-zA-Z0-9_-]/g, "_");
   const pathHash = createHash7("sha256").update(repoPath).digest("hex").slice(0, 8);
-  return join136(CACHE_DIR, `${repoName}-${pathHash}-context-cache.json`);
+  return join138(CACHE_DIR, `${repoName}-${pathHash}-context-cache.json`);
 }
 var CACHE_DIR, CACHE_TTL_MS4;
 var init_context_cache_manager = __esm(() => {
-  CACHE_DIR = join136(homedir33(), ".claudekit", "cache");
+  CACHE_DIR = join138(homedir37(), ".claudekit", "cache");
   CACHE_TTL_MS4 = 24 * 60 * 60 * 1000;
 });
 
@@ -68757,7 +68825,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 readdirSync10 } from "node:fs";
-import { join as join137 } from "node:path";
+import { join as join139 } from "node:path";
 async function summarizeProjectDocs(repoPath, contentLogger) {
   const rawContent = collectRawDocs(repoPath);
   if (rawContent.total.length < 200) {
@@ -68811,12 +68879,12 @@ function collectRawDocs(repoPath) {
     return capped;
   };
   const docsContent = [];
-  const docsDir = join137(repoPath, "docs");
+  const docsDir = join139(repoPath, "docs");
   if (existsSync67(docsDir)) {
     try {
       const files = readdirSync10(docsDir).filter((f3) => f3.endsWith(".md")).sort();
       for (const f3 of files) {
-        const content = readCapped(join137(docsDir, f3), 5000);
+        const content = readCapped(join139(docsDir, f3), 5000);
         if (content) {
           docsContent.push(`### ${f3}
 ${content}`);
@@ -68830,21 +68898,21 @@ ${content}`);
   let brand = "";
   const brandCandidates = ["docs/brand-guidelines.md", "docs/design-guidelines.md"];
   for (const p of brandCandidates) {
-    brand = readCapped(join137(repoPath, p), 3000);
+    brand = readCapped(join139(repoPath, p), 3000);
     if (brand)
       break;
   }
   let styles3 = "";
-  const stylesDir = join137(repoPath, "assets", "writing-styles");
+  const stylesDir = join139(repoPath, "assets", "writing-styles");
   if (existsSync67(stylesDir)) {
     try {
       const files = readdirSync10(stylesDir).slice(0, 3);
-      styles3 = files.map((f3) => readCapped(join137(stylesDir, f3), 1000)).filter(Boolean).join(`
+      styles3 = files.map((f3) => readCapped(join139(stylesDir, f3), 1000)).filter(Boolean).join(`
 
 `);
     } catch {}
   }
-  const readme = readCapped(join137(repoPath, "README.md"), 3000);
+  const readme = readCapped(join139(repoPath, "README.md"), 3000);
   const total = [docs, brand, styles3, readme].join(`
 `);
   return { docs, brand, styles: styles3, readme, total };
@@ -69030,10 +69098,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 readdirSync11 } from "node:fs";
-import { homedir as homedir34 } from "node:os";
-import { join as join138 } from "node:path";
+import { homedir as homedir38 } from "node:os";
+import { join as join140 } from "node:path";
 async function generatePhoto(_content, context, config, platform16, contentId, contentLogger) {
-  const mediaDir = join138(config.contentDir.replace(/^~/, homedir34()), "media", String(contentId));
+  const mediaDir = join140(config.contentDir.replace(/^~/, homedir38()), "media", String(contentId));
   if (!existsSync68(mediaDir)) {
     mkdirSync5(mediaDir, { recursive: true });
   }
@@ -69058,7 +69126,7 @@ async function generatePhoto(_content, context, config, platform16, contentId, c
     const imageFile = files.find((f3) => /\.(png|jpg|jpeg|webp)$/i.test(f3));
     if (imageFile) {
       const ext2 = imageFile.split(".").pop() ?? "png";
-      return { path: join138(mediaDir, imageFile), ...dimensions, format: ext2 };
+      return { path: join140(mediaDir, imageFile), ...dimensions, format: ext2 };
     }
     contentLogger.warn(`Photo generation produced no image for content ${contentId}`);
     return null;
@@ -69147,8 +69215,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 statSync12 } from "node:fs";
-import { homedir as homedir35 } from "node:os";
-import { join as join139 } from "node:path";
+import { homedir as homedir39 } from "node:os";
+import { join as join141 } from "node:path";
 
 class ContentLogger {
   stream = null;
@@ -69156,7 +69224,7 @@ class ContentLogger {
   logDir;
   maxBytes;
   constructor(maxBytes = 0) {
-    this.logDir = join139(homedir35(), ".claudekit", "logs");
+    this.logDir = join141(homedir39(), ".claudekit", "logs");
     this.maxBytes = maxBytes;
   }
   init() {
@@ -69188,7 +69256,7 @@ class ContentLogger {
     }
   }
   getLogPath() {
-    return join139(this.logDir, `content-${this.getDateStr()}.log`);
+    return join141(this.logDir, `content-${this.getDateStr()}.log`);
   }
   write(level, message) {
     this.rotateIfNeeded();
@@ -69205,18 +69273,18 @@ class ContentLogger {
     if (dateStr !== this.currentDate) {
       this.close();
       this.currentDate = dateStr;
-      const logPath = join139(this.logDir, `content-${dateStr}.log`);
+      const logPath = join141(this.logDir, `content-${dateStr}.log`);
       this.stream = createWriteStream4(logPath, { flags: "a", mode: 384 });
       return;
     }
     if (this.maxBytes > 0 && this.stream) {
-      const logPath = join139(this.logDir, `content-${this.currentDate}.log`);
+      const logPath = join141(this.logDir, `content-${this.currentDate}.log`);
       try {
         const stat21 = statSync12(logPath);
         if (stat21.size >= this.maxBytes) {
           this.close();
           const suffix = Date.now();
-          const rotatedPath = join139(this.logDir, `content-${this.currentDate}-${suffix}.log`);
+          const rotatedPath = join141(this.logDir, `content-${this.currentDate}-${suffix}.log`);
           import("node:fs/promises").then(({ rename: rename11 }) => rename11(logPath, rotatedPath).catch(() => {}));
           this.stream = createWriteStream4(logPath, { flags: "w", mode: 384 });
         }
@@ -69254,7 +69322,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 dirname35 } from "node:path";
+import { dirname as dirname36 } from "node:path";
 function initDatabase(dbPath) {
   ensureParentDir(dbPath);
   const db = openDatabase(dbPath);
@@ -69275,7 +69343,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 = dirname35(dbPath);
+  const dir = dirname36(dbPath);
   if (dir && !existsSync70(dir)) {
     mkdirSync7(dir, { recursive: true });
   }
@@ -69442,7 +69510,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 readdirSync12, statSync as statSync13 } from "node:fs";
-import { join as join140 } from "node:path";
+import { join as join142 } from "node:path";
 function detectCommits(repo, since) {
   try {
     const fetchUrl = sshToHttps(repo.remoteUrl);
@@ -69540,7 +69608,7 @@ function detectTags(repo, since) {
   }
 }
 function detectCompletedPlans(repo, since) {
-  const plansDir = join140(repo.path, "plans");
+  const plansDir = join142(repo.path, "plans");
   if (!existsSync71(plansDir))
     return [];
   const sinceMs = new Date(since).getTime();
@@ -69550,7 +69618,7 @@ function detectCompletedPlans(repo, since) {
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
-      const planFile = join140(plansDir, entry.name, "plan.md");
+      const planFile = join142(plansDir, entry.name, "plan.md");
       if (!existsSync71(planFile))
         continue;
       try {
@@ -69628,7 +69696,7 @@ function classifyCommit(event) {
 // src/commands/content/phases/repo-discoverer.ts
 import { execSync as execSync10 } from "node:child_process";
 import { readdirSync as readdirSync13 } from "node:fs";
-import { join as join141 } from "node:path";
+import { join as join143 } from "node:path";
 function discoverRepos2(cwd2) {
   const repos = [];
   if (isGitRepoRoot(cwd2)) {
@@ -69641,7 +69709,7 @@ function discoverRepos2(cwd2) {
     for (const entry of entries) {
       if (!entry.isDirectory() || entry.name.startsWith("."))
         continue;
-      const dirPath = join141(cwd2, entry.name);
+      const dirPath = join143(cwd2, entry.name);
       if (isGitRepoRoot(dirPath)) {
         const info = getRepoInfo(dirPath);
         if (info)
@@ -70308,9 +70376,9 @@ var init_types6 = __esm(() => {
 
 // src/commands/content/phases/state-manager.ts
 import { readFile as readFile56, rename as rename11, writeFile as writeFile36 } from "node:fs/promises";
-import { join as join142 } from "node:path";
+import { join as join144 } from "node:path";
 async function loadContentConfig(projectDir) {
-  const configPath = join142(projectDir, CK_CONFIG_FILE2);
+  const configPath = join144(projectDir, CK_CONFIG_FILE2);
   try {
     const raw2 = await readFile56(configPath, "utf-8");
     const json = JSON.parse(raw2);
@@ -70320,13 +70388,13 @@ async function loadContentConfig(projectDir) {
   }
 }
 async function saveContentConfig(projectDir, config) {
-  const configPath = join142(projectDir, CK_CONFIG_FILE2);
+  const configPath = join144(projectDir, CK_CONFIG_FILE2);
   const json = await readJsonSafe(configPath);
   json.content = { ...json.content, ...config };
   await atomicWrite(configPath, json);
 }
 async function loadContentState(projectDir) {
-  const configPath = join142(projectDir, CK_CONFIG_FILE2);
+  const configPath = join144(projectDir, CK_CONFIG_FILE2);
   try {
     const raw2 = await readFile56(configPath, "utf-8");
     const json = JSON.parse(raw2);
@@ -70337,7 +70405,7 @@ async function loadContentState(projectDir) {
   }
 }
 async function saveContentState(projectDir, state) {
-  const configPath = join142(projectDir, CK_CONFIG_FILE2);
+  const configPath = join144(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);
@@ -70619,7 +70687,7 @@ var init_platform_setup_x = __esm(() => {
 
 // src/commands/content/phases/setup-wizard.ts
 import { existsSync as existsSync72 } from "node:fs";
-import { join as join143 } from "node:path";
+import { join as join145 } from "node:path";
 async function runSetupWizard2(cwd2, contentLogger) {
   console.log();
   oe(import_picocolors42.default.bgCyan(import_picocolors42.default.white(" CK Content — Multi-Channel Content Engine ")));
@@ -70687,8 +70755,8 @@ async function showRepoSummary(cwd2) {
 function detectBrandAssets(cwd2, contentLogger) {
   const repos = discoverRepos2(cwd2);
   for (const repo of repos) {
-    const hasGuidelines = existsSync72(join143(repo.path, "docs", "brand-guidelines.md"));
-    const hasStyles = existsSync72(join143(repo.path, "assets", "writing-styles"));
+    const hasGuidelines = existsSync72(join145(repo.path, "docs", "brand-guidelines.md"));
+    const hasStyles = existsSync72(join145(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`);
@@ -70755,11 +70823,11 @@ var init_setup_wizard = __esm(() => {
 
 // src/commands/content/content-review-commands.ts
 import { existsSync as existsSync73 } from "node:fs";
-import { homedir as homedir36 } 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(/^~/, homedir36());
+  const dbPath = config.dbPath.replace(/^~/, homedir40());
   if (!existsSync73(dbPath)) {
     logger.info("No content database found. Run 'ck content setup' first.");
     return;
@@ -70786,7 +70854,7 @@ async function queueContent() {
 async function approveContentCmd(id) {
   const cwd2 = process.cwd();
   const config = await loadContentConfig(cwd2);
-  const dbPath = config.dbPath.replace(/^~/, homedir36());
+  const dbPath = config.dbPath.replace(/^~/, homedir40());
   const db = initDatabase(dbPath);
   try {
     approveContent(db, Number.parseInt(id, 10));
@@ -70798,7 +70866,7 @@ async function approveContentCmd(id) {
 async function rejectContentCmd(id, reason) {
   const cwd2 = process.cwd();
   const config = await loadContentConfig(cwd2);
-  const dbPath = config.dbPath.replace(/^~/, homedir36());
+  const dbPath = config.dbPath.replace(/^~/, homedir40());
   const db = initDatabase(dbPath);
   try {
     rejectContent(db, Number.parseInt(id, 10), reason);
@@ -70829,10 +70897,10 @@ __export(exports_content_subcommands, {
   approveContentCmd: () => approveContentCmd
 });
 import { existsSync as existsSync74, readFileSync as readFileSync18, unlinkSync as unlinkSync5 } from "node:fs";
-import { homedir as homedir37 } from "node:os";
-import { join as join144 } from "node:path";
+import { homedir as homedir41 } from "node:os";
+import { join as join146 } from "node:path";
 function isDaemonRunning() {
-  const lockFile = join144(LOCK_DIR, `${LOCK_NAME2}.lock`);
+  const lockFile = join146(LOCK_DIR, `${LOCK_NAME2}.lock`);
   if (!existsSync74(lockFile))
     return { running: false, pid: null };
   try {
@@ -70864,7 +70932,7 @@ async function startContent(options2) {
   await contentCommand(options2);
 }
 async function stopContent() {
-  const lockFile = join144(LOCK_DIR, `${LOCK_NAME2}.lock`);
+  const lockFile = join146(LOCK_DIR, `${LOCK_NAME2}.lock`);
   if (!existsSync74(lockFile)) {
     logger.info("Content daemon is not running.");
     return;
@@ -70903,9 +70971,9 @@ async function statusContent() {
   } catch {}
 }
 async function logsContent(options2) {
-  const logDir = join144(homedir37(), ".claudekit", "logs");
+  const logDir = join146(homedir41(), ".claudekit", "logs");
   const dateStr = new Date().toISOString().slice(0, 10).replace(/-/g, "");
-  const logPath = join144(logDir, `content-${dateStr}.log`);
+  const logPath = join146(logDir, `content-${dateStr}.log`);
   if (!existsSync74(logPath)) {
     logger.info("No content logs found for today.");
     return;
@@ -70937,13 +71005,13 @@ var init_content_subcommands = __esm(() => {
   init_setup_wizard();
   init_state_manager();
   init_content_review_commands();
-  LOCK_DIR = join144(homedir37(), ".claudekit", "locks");
+  LOCK_DIR = join146(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 homedir38 } from "node:os";
-import { join as join145 } from "node:path";
+import { homedir as homedir42 } from "node:os";
+import { join as join147 } from "node:path";
 async function contentCommand(options2) {
   const cwd2 = process.cwd();
   const contentLogger = new ContentLogger;
@@ -70975,7 +71043,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(/^~/, homedir38());
+    const dbPath = config.dbPath.replace(/^~/, homedir42());
     const db = initDatabase(dbPath);
     contentLogger.info(`Database initialised at ${dbPath}`);
     const adapters = initializeAdapters(config);
@@ -71121,8 +71189,8 @@ var init_content_command = __esm(() => {
   init_publisher();
   init_review_manager();
   init_state_manager();
-  LOCK_DIR2 = join145(homedir38(), ".claudekit", "locks");
-  LOCK_FILE = join145(LOCK_DIR2, "ck-content.lock");
+  LOCK_DIR2 = join147(homedir42(), ".claudekit", "locks");
+  LOCK_FILE = join147(LOCK_DIR2, "ck-content.lock");
 });
 
 // src/commands/content/index.ts
@@ -77985,14 +78053,14 @@ async function checkCliInstallMethod() {
 }
 // src/domains/health-checks/checkers/claude-md-checker.ts
 import { existsSync as existsSync40, statSync as statSync6 } from "node:fs";
-import { join as join56 } from "node:path";
+import { join as join57 } from "node:path";
 function checkClaudeMd(setup, projectDir) {
   const results = [];
   if (setup.global.path) {
-    const globalClaudeMd = join56(setup.global.path, "CLAUDE.md");
+    const globalClaudeMd = join57(setup.global.path, "CLAUDE.md");
     results.push(checkClaudeMdFile(globalClaudeMd, "Global CLAUDE.md", "ck-global-claude-md"));
   }
-  const projectClaudeMd = join56(projectDir, ".claude", "CLAUDE.md");
+  const projectClaudeMd = join57(projectDir, ".claude", "CLAUDE.md");
   results.push(checkClaudeMdFile(projectClaudeMd, "Project CLAUDE.md", "ck-project-claude-md"));
   return results;
 }
@@ -78051,9 +78119,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 join57 } from "node:path";
+import { join as join58 } from "node:path";
 function checkActivePlan(projectDir) {
-  const activePlanPath = join57(projectDir, ".claude", "active-plan");
+  const activePlanPath = join58(projectDir, ".claude", "active-plan");
   if (!existsSync41(activePlanPath)) {
     return {
       id: "ck-active-plan",
@@ -78067,7 +78135,7 @@ function checkActivePlan(projectDir) {
   }
   try {
     const targetPath = readFileSync11(activePlanPath, "utf-8").trim();
-    const fullPath = join57(projectDir, targetPath);
+    const fullPath = join58(projectDir, targetPath);
     if (!existsSync41(fullPath)) {
       return {
         id: "ck-active-plan",
@@ -78105,13 +78173,13 @@ function checkActivePlan(projectDir) {
 }
 // src/domains/health-checks/checkers/skills-checker.ts
 import { existsSync as existsSync42 } from "node:fs";
-import { join as join58 } from "node:path";
+import { join as join59 } from "node:path";
 function checkSkillsScripts(setup) {
   const results = [];
   const platform7 = process.platform;
   const scriptName = platform7 === "win32" ? "install.ps1" : "install.sh";
   if (setup.global.path) {
-    const globalScriptPath = join58(setup.global.path, "skills", scriptName);
+    const globalScriptPath = join59(setup.global.path, "skills", scriptName);
     const hasGlobalScript = existsSync42(globalScriptPath);
     results.push({
       id: "ck-global-skills-script",
@@ -78126,7 +78194,7 @@ function checkSkillsScripts(setup) {
     });
   }
   if (setup.project.metadata) {
-    const projectScriptPath = join58(setup.project.path, "skills", scriptName);
+    const projectScriptPath = join59(setup.project.path, "skills", scriptName);
     const hasProjectScript = existsSync42(projectScriptPath);
     results.push({
       id: "ck-project-skills-script",
@@ -78165,7 +78233,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 join59 } from "node:path";
+import { join as join60 } from "node:path";
 
 // src/domains/health-checks/checkers/shared.ts
 init_environment();
@@ -78231,7 +78299,7 @@ async function checkGlobalDirWritable() {
   }
   const timestamp = Date.now();
   const random = Math.random().toString(36).substring(2);
-  const testFile = join59(globalDir, `.ck-write-test-${timestamp}-${random}`);
+  const testFile = join60(globalDir, `.ck-write-test-${timestamp}-${random}`);
   try {
     await writeFile16(testFile, "test", { encoding: "utf-8", flag: "wx" });
   } catch (error) {
@@ -78267,7 +78335,7 @@ async function checkGlobalDirWritable() {
 init_path_resolver();
 import { existsSync as existsSync43 } from "node:fs";
 import { readdir as readdir12 } from "node:fs/promises";
-import { join as join60 } from "node:path";
+import { join as join61 } from "node:path";
 
 // src/domains/health-checks/utils/path-normalizer.ts
 import { normalize as normalize5 } from "node:path";
@@ -78279,8 +78347,8 @@ function normalizePath2(filePath) {
 
 // src/domains/health-checks/checkers/hooks-checker.ts
 async function checkHooksExist(projectDir) {
-  const globalHooksDir = join60(PathResolver.getGlobalKitDir(), "hooks");
-  const projectHooksDir = join60(projectDir, ".claude", "hooks");
+  const globalHooksDir = join61(PathResolver.getGlobalKitDir(), "hooks");
+  const projectHooksDir = join61(projectDir, ".claude", "hooks");
   const globalExists = existsSync43(globalHooksDir);
   const projectExists = existsSync43(projectHooksDir);
   let hookCount = 0;
@@ -78289,7 +78357,7 @@ async function checkHooksExist(projectDir) {
     const files = await readdir12(globalHooksDir, { withFileTypes: false });
     const hooks = files.filter((f3) => HOOK_EXTENSIONS2.some((ext) => f3.endsWith(ext)));
     hooks.forEach((hook) => {
-      const fullPath = join60(globalHooksDir, hook);
+      const fullPath = join61(globalHooksDir, hook);
       checkedFiles.add(normalizePath2(fullPath));
     });
   }
@@ -78299,7 +78367,7 @@ async function checkHooksExist(projectDir) {
     const files = await readdir12(projectHooksDir, { withFileTypes: false });
     const hooks = files.filter((f3) => HOOK_EXTENSIONS2.some((ext) => f3.endsWith(ext)));
     hooks.forEach((hook) => {
-      const fullPath = join60(projectHooksDir, hook);
+      const fullPath = join61(projectHooksDir, hook);
       checkedFiles.add(normalizePath2(fullPath));
     });
   }
@@ -78331,10 +78399,10 @@ init_logger();
 init_path_resolver();
 import { existsSync as existsSync44 } from "node:fs";
 import { readFile as readFile31 } from "node:fs/promises";
-import { join as join61 } from "node:path";
+import { join as join62 } from "node:path";
 async function checkSettingsValid(projectDir) {
-  const globalSettings = join61(PathResolver.getGlobalKitDir(), "settings.json");
-  const projectSettings = join61(projectDir, ".claude", "settings.json");
+  const globalSettings = join62(PathResolver.getGlobalKitDir(), "settings.json");
+  const projectSettings = join62(projectDir, ".claude", "settings.json");
   const settingsPath = existsSync44(globalSettings) ? globalSettings : existsSync44(projectSettings) ? projectSettings : null;
   if (!settingsPath) {
     return {
@@ -78406,11 +78474,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 dirname20, join as join62, normalize as normalize6, resolve as resolve18 } from "node:path";
+import { homedir as homedir29 } from "node:os";
+import { dirname as dirname20, join as join63, normalize as normalize6, resolve as resolve18 } from "node:path";
 async function checkPathRefsValid(projectDir) {
-  const globalClaudeMd = join62(PathResolver.getGlobalKitDir(), "CLAUDE.md");
-  const projectClaudeMd = join62(projectDir, ".claude", "CLAUDE.md");
+  const globalClaudeMd = join63(PathResolver.getGlobalKitDir(), "CLAUDE.md");
+  const projectClaudeMd = join63(projectDir, ".claude", "CLAUDE.md");
   const claudeMdPath = existsSync45(globalClaudeMd) ? globalClaudeMd : existsSync45(projectClaudeMd) ? projectClaudeMd : null;
   if (!claudeMdPath) {
     return {
@@ -78439,7 +78507,7 @@ async function checkPathRefsValid(projectDir) {
       };
     }
     const baseDir = dirname20(claudeMdPath);
-    const home8 = homedir28();
+    const home8 = homedir29();
     const broken = [];
     for (const ref of refs) {
       let refPath;
@@ -78505,7 +78573,7 @@ async function checkPathRefsValid(projectDir) {
 // src/domains/health-checks/checkers/config-completeness-checker.ts
 import { existsSync as existsSync46 } from "node:fs";
 import { readdir as readdir13 } from "node:fs/promises";
-import { join as join63 } from "node:path";
+import { join as join64 } from "node:path";
 async function checkProjectConfigCompleteness(setup, projectDir) {
   if (setup.project.path === setup.global.path) {
     return {
@@ -78518,16 +78586,16 @@ async function checkProjectConfigCompleteness(setup, projectDir) {
       autoFixable: false
     };
   }
-  const projectClaudeDir = join63(projectDir, ".claude");
+  const projectClaudeDir = join64(projectDir, ".claude");
   const requiredDirs = ["agents", "commands", "skills"];
   const missingDirs = [];
   for (const dir of requiredDirs) {
-    const dirPath = join63(projectClaudeDir, dir);
+    const dirPath = join64(projectClaudeDir, dir);
     if (!existsSync46(dirPath)) {
       missingDirs.push(dir);
     }
   }
-  const hasRulesOrWorkflows = existsSync46(join63(projectClaudeDir, "rules")) || existsSync46(join63(projectClaudeDir, "workflows"));
+  const hasRulesOrWorkflows = existsSync46(join64(projectClaudeDir, "rules")) || existsSync46(join64(projectClaudeDir, "workflows"));
   if (!hasRulesOrWorkflows) {
     missingDirs.push("rules");
   }
@@ -78572,7 +78640,7 @@ async function checkProjectConfigCompleteness(setup, projectDir) {
   };
 }
 // src/domains/health-checks/checkers/env-keys-checker.ts
-import { join as join65 } from "node:path";
+import { join as join66 } from "node:path";
 
 // src/domains/installation/setup-wizard.ts
 init_config_generator();
@@ -78581,7 +78649,7 @@ init_logger();
 init_path_resolver();
 init_dist2();
 var import_fs_extra9 = __toESM(require_lib(), 1);
-import { join as join64 } from "node:path";
+import { join as join65 } from "node:path";
 var REQUIRED_ENV_KEYS = [
   { key: "GEMINI_API_KEY", label: "Gemini API Key" }
 ];
@@ -78658,7 +78726,7 @@ async function parseEnvFile(path5) {
   }
 }
 async function checkGlobalConfig() {
-  const globalEnvPath = join64(PathResolver.getGlobalKitDir(), ".env");
+  const globalEnvPath = join65(PathResolver.getGlobalKitDir(), ".env");
   if (!await import_fs_extra9.pathExists(globalEnvPath))
     return false;
   const env2 = await parseEnvFile(globalEnvPath);
@@ -78674,7 +78742,7 @@ async function runSetupWizard(options2) {
   let globalEnv = {};
   const hasGlobalConfig = !isGlobal && await checkGlobalConfig();
   if (!isGlobal) {
-    const globalEnvPath = join64(PathResolver.getGlobalKitDir(), ".env");
+    const globalEnvPath = join65(PathResolver.getGlobalKitDir(), ".env");
     if (await import_fs_extra9.pathExists(globalEnvPath)) {
       globalEnv = await parseEnvFile(globalEnvPath);
     }
@@ -78737,7 +78805,7 @@ async function runSetupWizard(options2) {
     }
   }
   await generateEnvFile(targetDir, values);
-  f2.success(`Configuration saved to ${join64(targetDir, ".env")}`);
+  f2.success(`Configuration saved to ${join65(targetDir, ".env")}`);
   return true;
 }
 async function promptForAdditionalGeminiKeys(primaryKey) {
@@ -78812,7 +78880,7 @@ Optional: DISCORD_WEBHOOK_URL, TELEGRAM_BOT_TOKEN`, "Configuration skipped");
 async function checkEnvKeys(setup) {
   const results = [];
   if (setup.global.path) {
-    const globalEnvPath = join65(setup.global.path, ".env");
+    const globalEnvPath = join66(setup.global.path, ".env");
     const globalCheck = await checkRequiredKeysExist(globalEnvPath);
     if (!globalCheck.allPresent) {
       const missingKeys = globalCheck.missing.map((m2) => m2.label).join(", ");
@@ -78841,7 +78909,7 @@ async function checkEnvKeys(setup) {
     }
   }
   if (setup.project.metadata) {
-    const projectEnvPath = join65(setup.project.path, ".env");
+    const projectEnvPath = join66(setup.project.path, ".env");
     const projectCheck = await checkRequiredKeysExist(projectEnvPath);
     if (!projectCheck.allPresent) {
       const missingKeys = projectCheck.missing.map((m2) => m2.label).join(", ");
@@ -78872,14 +78940,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 statSync7, writeFileSync as writeFileSync4 } from "node:fs";
 import { readdir as readdir14 } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join as join66, resolve as resolve19 } from "node:path";
+import { homedir as homedir30, tmpdir } from "node:os";
+import { join as join67, resolve as resolve19 } from "node:path";
 var HOOK_CHECK_TIMEOUT_MS = 5000;
 var PYTHON_CHECK_TIMEOUT_MS = 3000;
 var MAX_LOG_FILE_SIZE_BYTES = 10 * 1024 * 1024;
@@ -78895,6 +78965,117 @@ function getHooksDir(projectDir) {
 function isPathWithin(filePath, parentDir) {
   return resolve19(filePath).startsWith(resolve19(parentDir));
 }
+function getCanonicalGlobalCommandRoot() {
+  const configuredGlobalDir = PathResolver.getGlobalKitDir().replace(/\\/g, "/").replace(/\/+$/, "");
+  const defaultGlobalDir = join67(homedir30(), ".claude").replace(/\\/g, "/");
+  return configuredGlobalDir === defaultGlobalDir ? "$HOME" : configuredGlobalDir;
+}
+function getClaudeSettingsFiles(projectDir) {
+  const globalClaudeDir = PathResolver.getGlobalKitDir();
+  const candidates = [
+    {
+      path: resolve19(projectDir, ".claude", "settings.json"),
+      label: "project settings.json",
+      root: "$CLAUDE_PROJECT_DIR"
+    },
+    {
+      path: resolve19(projectDir, ".claude", "settings.local.json"),
+      label: "project settings.local.json",
+      root: "$CLAUDE_PROJECT_DIR"
+    },
+    {
+      path: resolve19(globalClaudeDir, "settings.json"),
+      label: "global settings.json",
+      root: getCanonicalGlobalCommandRoot()
+    },
+    {
+      path: resolve19(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) {
@@ -78924,7 +79105,7 @@ async function checkHookSyntax(projectDir) {
     }
     const errors2 = [];
     for (const file of cjsFiles) {
-      const filePath = join66(hooksDir, file);
+      const filePath = join67(hooksDir, file);
       if (!isPathWithin(filePath, hooksDir))
         continue;
       const result = spawnSync2("node", ["--check", filePath], {
@@ -79010,7 +79191,7 @@ async function checkHookDeps(projectDir) {
     const missingDeps = [];
     const requireRegex = /require\(['"]([^'"]+)['"]\)/g;
     for (const file of cjsFiles) {
-      const filePath = join66(hooksDir, file);
+      const filePath = join67(hooksDir, file);
       if (!isPathWithin(filePath, hooksDir))
         continue;
       const content = readFileSync12(filePath, "utf-8");
@@ -79020,10 +79201,10 @@ async function checkHookDeps(projectDir) {
           continue;
         }
         if (depPath.startsWith(".")) {
-          const resolvedPath = join66(hooksDir, depPath);
+          const resolvedPath = join67(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(join66(resolvedPath, idx)));
+          const exists = existsSync47(resolvedPath) || extensions.some((ext) => existsSync47(resolvedPath + ext)) || indexFiles.some((idx) => existsSync47(join67(resolvedPath, idx)));
           if (!exists) {
             missingDeps.push(`${file}: ${depPath}`);
           }
@@ -79140,11 +79321,11 @@ async function checkHookRuntime(projectDir) {
     }
     const syntheticPayload = JSON.stringify({
       tool_name: "Read",
-      tool_input: { file_path: join66(tmpdir(), "ck-doctor-test.txt") }
+      tool_input: { file_path: join67(tmpdir(), "ck-doctor-test.txt") }
     });
     const failures = [];
     for (const file of cjsFiles) {
-      const filePath = join66(hooksDir, file);
+      const filePath = join67(hooksDir, file);
       if (!isPathWithin(filePath, hooksDir))
         continue;
       const result = spawnSync2("node", [filePath], {
@@ -79205,9 +79386,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 = join66(projectDir, ".claude", ".ck.json");
-  const globalConfigPath = join66(PathResolver.getGlobalKitDir(), ".ck.json");
+  const projectConfigPath = join67(projectDir, ".claude", ".ck.json");
+  const globalConfigPath = join67(PathResolver.getGlobalKitDir(), ".ck.json");
   const configPath = existsSync47(projectConfigPath) ? projectConfigPath : existsSync47(globalConfigPath) ? globalConfigPath : null;
   if (!configPath) {
     return {
@@ -79331,7 +79588,7 @@ async function checkHookLogs(projectDir) {
       autoFixable: false
     };
   }
-  const logPath = join66(hooksDir, ".logs", "hook-log.jsonl");
+  const logPath = join67(hooksDir, ".logs", "hook-log.jsonl");
   if (!existsSync47(logPath)) {
     return {
       id: "hook-logs",
@@ -79586,9 +79843,9 @@ async function checkCliVersion() {
 }
 async function checkPythonVenv(projectDir) {
   const isWindows3 = process.platform === "win32";
-  const venvBin = isWindows3 ? join66("Scripts", "python.exe") : join66("bin", "python3");
-  const projectVenvPath = join66(projectDir, ".claude", "skills", ".venv", venvBin);
-  const globalVenvPath = join66(PathResolver.getGlobalKitDir(), "skills", ".venv", venvBin);
+  const venvBin = isWindows3 ? join67("Scripts", "python.exe") : join67("bin", "python3");
+  const projectVenvPath = join67(projectDir, ".claude", "skills", ".venv", venvBin);
+  const globalVenvPath = join67(PathResolver.getGlobalKitDir(), "skills", ".venv", venvBin);
   const venvPath = existsSync47(projectVenvPath) ? projectVenvPath : existsSync47(globalVenvPath) ? globalVenvPath : null;
   if (!venvPath) {
     return {
@@ -79704,6 +79961,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");
@@ -80068,8 +80327,8 @@ import { platform as platform8 } from "node:os";
 init_environment();
 init_path_resolver();
 import { constants as constants3, access as access3, mkdir as mkdir16, readFile as readFile34, unlink as unlink8, writeFile as writeFile17 } from "node:fs/promises";
-import { arch as arch2, homedir as homedir29, platform as platform7 } from "node:os";
-import { join as join68, normalize as normalize7 } from "node:path";
+import { arch as arch2, homedir as homedir31, platform as platform7 } from "node:os";
+import { join as join69, normalize as normalize7 } from "node:path";
 function shouldSkipExpensiveOperations4() {
   return shouldSkipExpensiveOperations();
 }
@@ -80091,7 +80350,7 @@ async function checkPlatformDetect() {
   };
 }
 async function checkHomeDirResolution() {
-  const nodeHome = normalize7(homedir29());
+  const nodeHome = normalize7(homedir31());
   const rawEnvHome = getHomeDirectoryFromEnv(platform7());
   const envHome = rawEnvHome ? normalize7(rawEnvHome) : "";
   const match = nodeHome === envHome && envHome !== "";
@@ -80160,7 +80419,7 @@ async function checkGlobalDirAccess() {
       autoFixable: false
     };
   }
-  const testFile = join68(globalDir, ".ck-doctor-access-test");
+  const testFile = join69(globalDir, ".ck-doctor-access-test");
   try {
     await mkdir16(globalDir, { recursive: true });
     await writeFile17(testFile, "test", "utf-8");
@@ -80238,7 +80497,7 @@ async function checkWSLBoundary() {
 // src/domains/health-checks/platform/windows-checker.ts
 init_path_resolver();
 import { mkdir as mkdir17, symlink as symlink2, unlink as unlink9, writeFile as writeFile18 } from "node:fs/promises";
-import { join as join69 } from "node:path";
+import { join as join70 } from "node:path";
 async function checkLongPathSupport() {
   if (shouldSkipExpensiveOperations4()) {
     return {
@@ -80290,8 +80549,8 @@ async function checkSymlinkSupport() {
     };
   }
   const testDir = PathResolver.getGlobalKitDir();
-  const target = join69(testDir, ".ck-symlink-test-target");
-  const link = join69(testDir, ".ck-symlink-test-link");
+  const target = join70(testDir, ".ck-symlink-test-target");
+  const link = join70(testDir, ".ck-symlink-test-link");
   try {
     await mkdir17(testDir, { recursive: true });
     await writeFile18(target, "test", "utf-8");
@@ -80585,7 +80844,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 dirname21, join as join70 } from "node:path";
+import { dirname as dirname21, join as join71 } from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 init_environment();
 init_logger();
@@ -80593,7 +80852,7 @@ init_dist2();
 function getCliVersion4() {
   try {
     const __dirname4 = dirname21(fileURLToPath4(import.meta.url));
-    const pkgPath = join70(__dirname4, "../../../package.json");
+    const pkgPath = join71(__dirname4, "../../../package.json");
     const pkg = JSON.parse(readFileSync13(pkgPath, "utf-8"));
     return pkg.version || "unknown";
   } catch (err) {
@@ -80732,7 +80991,7 @@ class ReportGenerator {
         return null;
       }
     }
-    const tmpFile = join70(tmpdir3(), `ck-report-${Date.now()}.txt`);
+    const tmpFile = join71(tmpdir3(), `ck-report-${Date.now()}.txt`);
     writeFileSync5(tmpFile, report);
     try {
       const result = spawnSync5("gh", ["gist", "create", tmpFile, "--desc", "ClaudeKit Diagnostic Report"], {
@@ -81058,7 +81317,7 @@ init_claudekit_constants();
 init_logger();
 init_path_resolver();
 import { mkdir as mkdir18, readFile as readFile35, unlink as unlink10, writeFile as writeFile19 } from "node:fs/promises";
-import { join as join71 } from "node:path";
+import { join as join72 } 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;
@@ -81095,7 +81354,7 @@ var KIT_REPOS = {
 class ConfigVersionChecker {
   static getCacheFilePath(kitType, global3) {
     const cacheDir = PathResolver.getCacheDir(global3);
-    return join71(cacheDir, `${kitType}-${CACHE_FILENAME}`);
+    return join72(cacheDir, `${kitType}-${CACHE_FILENAME}`);
   }
   static async loadCache(kitType, global3) {
     try {
@@ -81258,7 +81517,7 @@ class ConfigVersionChecker {
 }
 // src/domains/sync/sync-engine.ts
 import { lstat as lstat4, readFile as readFile36, readlink as readlink2, realpath as realpath5, stat as stat10 } from "node:fs/promises";
-import { isAbsolute as isAbsolute4, join as join72, normalize as normalize8, relative as relative8 } from "node:path";
+import { isAbsolute as isAbsolute4, join as join73, normalize as normalize8, relative as relative8 } from "node:path";
 
 // src/services/file-operations/ownership-checker.ts
 init_metadata_migration();
@@ -82619,7 +82878,7 @@ async function validateSymlinkChain(path6, basePath, maxDepth = MAX_SYMLINK_DEPT
       if (!stats.isSymbolicLink())
         break;
       const target = await readlink2(current);
-      const resolvedTarget = isAbsolute4(target) ? target : join72(current, "..", target);
+      const resolvedTarget = isAbsolute4(target) ? target : join73(current, "..", target);
       const normalizedTarget = normalize8(resolvedTarget);
       const rel = relative8(basePath, normalizedTarget);
       if (rel.startsWith("..") || isAbsolute4(rel)) {
@@ -82655,7 +82914,7 @@ async function validateSyncPath(basePath, filePath) {
   if (normalized.startsWith("..") || normalized.includes("/../")) {
     throw new Error(`Path traversal not allowed: ${filePath}`);
   }
-  const fullPath = join72(basePath, normalized);
+  const fullPath = join73(basePath, normalized);
   const rel = relative8(basePath, fullPath);
   if (rel.startsWith("..") || isAbsolute4(rel)) {
     throw new Error(`Path escapes base directory: ${filePath}`);
@@ -82670,7 +82929,7 @@ async function validateSyncPath(basePath, filePath) {
     }
   } catch (error) {
     if (error.code === "ENOENT") {
-      const parentPath = join72(fullPath, "..");
+      const parentPath = join73(fullPath, "..");
       try {
         const resolvedBase = await realpath5(basePath);
         const resolvedParent = await realpath5(parentPath);
@@ -83578,7 +83837,7 @@ async function getLatestVersion(kit, includePrereleases = false) {
 init_logger();
 init_path_resolver();
 init_safe_prompts();
-import { join as join79 } from "node:path";
+import { join as join80 } from "node:path";
 async function promptUpdateMode() {
   const updateEverything = await se({
     message: "Do you want to update everything?"
@@ -83620,7 +83879,7 @@ async function promptDirectorySelection(global3 = false) {
   return selectedCategories;
 }
 async function promptFreshConfirmation(targetPath, analysis) {
-  const backupRoot = join79(PathResolver.getConfigDir(false), "backups");
+  const backupRoot = join80(PathResolver.getConfigDir(false), "backups");
   logger.warning("[!] Fresh installation will remove ClaudeKit files:");
   logger.info(`Path: ${targetPath}`);
   logger.info(`Recovery backup: ${backupRoot}`);
@@ -83894,7 +84153,7 @@ init_logger();
 init_logger();
 init_path_resolver();
 var import_fs_extra10 = __toESM(require_lib(), 1);
-import { join as join80 } from "node:path";
+import { join as join81 } from "node:path";
 async function handleConflicts(ctx) {
   if (ctx.cancelled)
     return ctx;
@@ -83903,7 +84162,7 @@ async function handleConflicts(ctx) {
   if (PathResolver.isLocalSameAsGlobal()) {
     return ctx;
   }
-  const localSettingsPath = join80(process.cwd(), ".claude", "settings.json");
+  const localSettingsPath = join81(process.cwd(), ".claude", "settings.json");
   if (!await import_fs_extra10.pathExists(localSettingsPath)) {
     return ctx;
   }
@@ -83918,7 +84177,7 @@ async function handleConflicts(ctx) {
     return { ...ctx, cancelled: true };
   }
   if (choice === "remove") {
-    const localClaudeDir = join80(process.cwd(), ".claude");
+    const localClaudeDir = join81(process.cwd(), ".claude");
     try {
       await import_fs_extra10.remove(localClaudeDir);
       logger.success("Removed local .claude/ directory");
@@ -84015,7 +84274,7 @@ init_logger();
 init_safe_spinner();
 import { mkdir as mkdir26, stat as stat13 } from "node:fs/promises";
 import { tmpdir as tmpdir4 } from "node:os";
-import { join as join87 } from "node:path";
+import { join as join88 } from "node:path";
 
 // src/shared/temp-cleanup.ts
 init_logger();
@@ -84034,7 +84293,7 @@ init_logger();
 init_output_manager();
 import { createWriteStream as createWriteStream2, rmSync as rmSync2 } from "node:fs";
 import { mkdir as mkdir21 } from "node:fs/promises";
-import { join as join81 } from "node:path";
+import { join as join82 } from "node:path";
 
 // src/shared/progress-bar.ts
 init_output_manager();
@@ -84244,7 +84503,7 @@ var MAX_DOWNLOAD_SIZE = 500 * 1024 * 1024;
 class FileDownloader {
   async downloadAsset(asset, destDir) {
     try {
-      const destPath = join81(destDir, asset.name);
+      const destPath = join82(destDir, asset.name);
       await mkdir21(destDir, { recursive: true });
       output.info(`Downloading ${asset.name} (${formatBytes2(asset.size)})...`);
       logger.verbose("Download details", {
@@ -84329,7 +84588,7 @@ class FileDownloader {
   }
   async downloadFile(params) {
     const { url, name, size, destDir, token } = params;
-    const destPath = join81(destDir, name);
+    const destPath = join82(destDir, name);
     await mkdir21(destDir, { recursive: true });
     output.info(`Downloading ${name}${size ? ` (${formatBytes2(size)})` : ""}...`);
     const headers = {};
@@ -84415,7 +84674,7 @@ init_logger();
 init_types3();
 import { constants as constants4 } from "node:fs";
 import { access as access4, readdir as readdir15 } from "node:fs/promises";
-import { join as join82 } from "node:path";
+import { join as join83 } from "node:path";
 async function validateExtraction(extractDir) {
   try {
     const entries = await readdir15(extractDir, { encoding: "utf8" });
@@ -84427,7 +84686,7 @@ async function validateExtraction(extractDir) {
     const missingPaths = [];
     for (const path6 of criticalPaths) {
       try {
-        await access4(join82(extractDir, path6), constants4.F_OK);
+        await access4(join83(extractDir, path6), constants4.F_OK);
         logger.debug(`Found: ${path6}`);
       } catch {
         logger.warning(`Expected path not found: ${path6}`);
@@ -84449,7 +84708,7 @@ async function validateExtraction(extractDir) {
 // src/domains/installation/extraction/tar-extractor.ts
 init_logger();
 import { copyFile as copyFile4, mkdir as mkdir24, readdir as readdir17, rm as rm9, stat as stat11 } from "node:fs/promises";
-import { join as join85 } from "node:path";
+import { join as join86 } from "node:path";
 
 // node_modules/@isaacs/fs-minipass/dist/esm/index.js
 import EE from "events";
@@ -90211,7 +90470,7 @@ var mkdirSync3 = (dir, opt) => {
 };
 
 // node_modules/tar/dist/esm/path-reservations.js
-import { join as join83 } from "node:path";
+import { join as join84 } from "node:path";
 
 // node_modules/tar/dist/esm/normalize-unicode.js
 var normalizeCache = Object.create(null);
@@ -90244,7 +90503,7 @@ var getDirs = (path11) => {
   const dirs = path11.split("/").slice(0, -1).reduce((set, path12) => {
     const s = set[set.length - 1];
     if (s !== undefined) {
-      path12 = join83(s, path12);
+      path12 = join84(s, path12);
     }
     set.push(path12 || "/");
     return set;
@@ -90258,7 +90517,7 @@ class PathReservations {
   #running = new Set;
   reserve(paths, fn) {
     paths = isWindows4 ? ["win32 parallelization disabled"] : paths.map((p) => {
-      return stripTrailingSlashes(join83(normalizeUnicode(p))).toLowerCase();
+      return stripTrailingSlashes(join84(normalizeUnicode(p))).toLowerCase();
     });
     const dirs = new Set(paths.map((path11) => getDirs(path11)).reduce((a3, b3) => a3.concat(b3)));
     this.#reservations.set(fn, { dirs, paths });
@@ -91318,7 +91577,7 @@ function decodeFilePath(path13) {
 init_logger();
 init_types3();
 import { copyFile as copyFile3, lstat as lstat5, mkdir as mkdir23, readdir as readdir16 } from "node:fs/promises";
-import { join as join84, relative as relative10 } from "node:path";
+import { join as join85, relative as relative10 } from "node:path";
 async function withRetry(fn, retries = 3) {
   for (let i = 0;i < retries; i++) {
     try {
@@ -91340,8 +91599,8 @@ async function moveDirectoryContents(sourceDir, destDir, shouldExclude, sizeTrac
   await mkdir23(destDir, { recursive: true });
   const entries = await readdir16(sourceDir, { encoding: "utf8" });
   for (const entry of entries) {
-    const sourcePath = join84(sourceDir, entry);
-    const destPath = join84(destDir, entry);
+    const sourcePath = join85(sourceDir, entry);
+    const destPath = join85(destDir, entry);
     const relativePath = relative10(sourceDir, sourcePath);
     if (!isPathSafe(destDir, destPath)) {
       logger.warning(`Skipping unsafe path: ${relativePath}`);
@@ -91368,8 +91627,8 @@ async function copyDirectory(sourceDir, destDir, shouldExclude, sizeTracker) {
   await mkdir23(destDir, { recursive: true });
   const entries = await readdir16(sourceDir, { encoding: "utf8" });
   for (const entry of entries) {
-    const sourcePath = join84(sourceDir, entry);
-    const destPath = join84(destDir, entry);
+    const sourcePath = join85(sourceDir, entry);
+    const destPath = join85(destDir, entry);
     const relativePath = relative10(sourceDir, sourcePath);
     if (!isPathSafe(destDir, destPath)) {
       logger.warning(`Skipping unsafe path: ${relativePath}`);
@@ -91417,7 +91676,7 @@ class TarExtractor {
       logger.debug(`Root entries: ${entries.join(", ")}`);
       if (entries.length === 1) {
         const rootEntry = entries[0];
-        const rootPath = join85(tempExtractDir, rootEntry);
+        const rootPath = join86(tempExtractDir, rootEntry);
         const rootStat = await stat11(rootPath);
         if (rootStat.isDirectory()) {
           const rootContents = await readdir17(rootPath, { encoding: "utf8" });
@@ -91433,7 +91692,7 @@ class TarExtractor {
           }
         } else {
           await mkdir24(destDir, { recursive: true });
-          await copyFile4(rootPath, join85(destDir, rootEntry));
+          await copyFile4(rootPath, join86(destDir, rootEntry));
         }
       } else {
         logger.debug("Multiple root entries - moving all");
@@ -91456,7 +91715,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 mkdir25, readdir as readdir18, rm as rm10, stat as stat12 } from "node:fs/promises";
-import { join as join86 } from "node:path";
+import { join as join87 } from "node:path";
 class ZipExtractor {
   async tryNativeUnzip(archivePath, destDir) {
     if (!isMacOS()) {
@@ -91504,7 +91763,7 @@ class ZipExtractor {
       logger.debug(`Root entries: ${entries.join(", ")}`);
       if (entries.length === 1) {
         const rootEntry = entries[0];
-        const rootPath = join86(tempExtractDir, rootEntry);
+        const rootPath = join87(tempExtractDir, rootEntry);
         const rootStat = await stat12(rootPath);
         if (rootStat.isDirectory()) {
           const rootContents = await readdir18(rootPath, { encoding: "utf8" });
@@ -91520,7 +91779,7 @@ class ZipExtractor {
           }
         } else {
           await mkdir25(destDir, { recursive: true });
-          await copyFile5(rootPath, join86(destDir, rootEntry));
+          await copyFile5(rootPath, join87(destDir, rootEntry));
         }
       } else {
         logger.debug("Multiple root entries - moving all");
@@ -91619,7 +91878,7 @@ class DownloadManager {
   async createTempDir() {
     const timestamp = Date.now();
     const counter = DownloadManager.tempDirCounter++;
-    const primaryTempDir = join87(tmpdir4(), `claudekit-${timestamp}-${counter}`);
+    const primaryTempDir = join88(tmpdir4(), `claudekit-${timestamp}-${counter}`);
     try {
       await mkdir26(primaryTempDir, { recursive: true });
       logger.debug(`Created temp directory: ${primaryTempDir}`);
@@ -91636,7 +91895,7 @@ Solutions:
   2. Set HOME environment variable
   3. Try running from a different directory`);
       }
-      const fallbackTempDir = join87(homeDir, ".claudekit", "tmp", `claudekit-${timestamp}-${counter}`);
+      const fallbackTempDir = join88(homeDir, ".claudekit", "tmp", `claudekit-${timestamp}-${counter}`);
       try {
         await mkdir26(fallbackTempDir, { recursive: true });
         logger.debug(`Created temp directory (fallback): ${fallbackTempDir}`);
@@ -92056,20 +92315,20 @@ async function handleDownload(ctx) {
   };
 }
 // src/commands/init/phases/merge-handler.ts
-import { join as join103 } from "node:path";
+import { join as join105 } from "node:path";
 
 // src/domains/installation/deletion-handler.ts
 import { existsSync as existsSync53, lstatSync as lstatSync3, readdirSync as readdirSync5, rmSync as rmSync3, rmdirSync, unlinkSync as unlinkSync3 } from "node:fs";
-import { dirname as dirname26, join as join90, relative as relative11, resolve as resolve24, sep as sep8 } from "node:path";
+import { dirname as dirname26, join as join91, relative as relative11, resolve as resolve24, sep as sep8 } from "node:path";
 
 // src/services/file-operations/manifest/manifest-reader.ts
 init_metadata_migration();
 init_logger();
 init_types3();
 var import_fs_extra11 = __toESM(require_lib(), 1);
-import { join as join89 } from "node:path";
+import { join as join90 } from "node:path";
 async function readManifest(claudeDir2) {
-  const metadataPath = join89(claudeDir2, "metadata.json");
+  const metadataPath = join90(claudeDir2, "metadata.json");
   if (!await import_fs_extra11.pathExists(metadataPath)) {
     return null;
   }
@@ -92255,7 +92514,7 @@ function collectFilesRecursively(dir, baseDir) {
   try {
     const entries = readdirSync5(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join90(dir, entry.name);
+      const fullPath = join91(dir, entry.name);
       const relativePath = relative11(baseDir, fullPath);
       if (entry.isDirectory()) {
         results.push(...collectFilesRecursively(fullPath, baseDir));
@@ -92323,7 +92582,7 @@ function deletePath(fullPath, claudeDir2) {
   }
 }
 async function updateMetadataAfterDeletion(claudeDir2, deletedPaths) {
-  const metadataPath = join90(claudeDir2, "metadata.json");
+  const metadataPath = join91(claudeDir2, "metadata.json");
   if (!await import_fs_extra12.pathExists(metadataPath)) {
     return;
   }
@@ -92378,7 +92637,7 @@ async function handleDeletions(sourceMetadata, claudeDir2, kitType) {
   const userMetadata = await readManifest(claudeDir2);
   const result = { deletedPaths: [], preservedPaths: [], errors: [] };
   for (const path14 of deletions) {
-    const fullPath = join90(claudeDir2, path14);
+    const fullPath = join91(claudeDir2, path14);
     const normalizedPath = resolve24(fullPath);
     const normalizedClaudeDir = resolve24(claudeDir2);
     if (!normalizedPath.startsWith(`${normalizedClaudeDir}${sep8}`)) {
@@ -92418,7 +92677,7 @@ init_logger();
 init_types3();
 var import_fs_extra15 = __toESM(require_lib(), 1);
 var import_ignore3 = __toESM(require_ignore(), 1);
-import { dirname as dirname28, join as join93, relative as relative13 } from "node:path";
+import { dirname as dirname29, join as join95, relative as relative13 } from "node:path";
 
 // src/domains/installation/selective-merger.ts
 import { stat as stat14 } from "node:fs/promises";
@@ -92597,7 +92856,7 @@ init_logger();
 var import_fs_extra13 = __toESM(require_lib(), 1);
 var import_ignore2 = __toESM(require_ignore(), 1);
 import { relative as relative12 } from "node:path";
-import { join as join91 } from "node:path";
+import { join as join92 } from "node:path";
 
 // node_modules/@isaacs/balanced-match/dist/esm/index.js
 var balanced = (a3, b3, str2) => {
@@ -94053,7 +94312,7 @@ class FileScanner {
     const files = [];
     const entries = await import_fs_extra13.readdir(dir, { encoding: "utf8" });
     for (const entry of entries) {
-      const fullPath = join91(dir, entry);
+      const fullPath = join92(dir, entry);
       const relativePath = relative12(baseDir, fullPath);
       const normalizedRelativePath = relativePath.replace(/\\/g, "/");
       const stats = await import_fs_extra13.lstat(fullPath);
@@ -94088,12 +94347,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 dirname28, join as join94 } from "node:path";
 
 // src/domains/config/installed-settings-tracker.ts
 init_shared();
 import { existsSync as existsSync54 } from "node:fs";
 import { mkdir as mkdir27, readFile as readFile40, writeFile as writeFile22 } from "node:fs/promises";
-import { dirname as dirname27, join as join92 } from "node:path";
+import { dirname as dirname27, join as join93 } from "node:path";
 var CK_JSON_FILE = ".ck.json";
 
 class InstalledSettingsTracker {
@@ -94107,9 +94368,9 @@ class InstalledSettingsTracker {
   }
   getCkJsonPath() {
     if (this.isGlobal) {
-      return join92(this.projectDir, CK_JSON_FILE);
+      return join93(this.projectDir, CK_JSON_FILE);
     }
-    return join92(this.projectDir, ".claude", CK_JSON_FILE);
+    return join93(this.projectDir, ".claude", CK_JSON_FILE);
   }
   async loadInstalledSettings() {
     const ckJsonPath = this.getCkJsonPath();
@@ -94184,7 +94445,9 @@ class InstalledSettingsTracker {
 
 // src/domains/installation/merger/settings-processor.ts
 init_settings_merger();
+init_command_normalizer();
 init_logger();
+init_path_resolver();
 var import_fs_extra14 = __toESM(require_lib(), 1);
 var import_semver3 = __toESM(require_semver2(), 1);
 
@@ -94228,16 +94491,15 @@ class SettingsProcessor {
       const sourceContent = await import_fs_extra14.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_extra14.pathExists(destFile);
@@ -94265,6 +94527,7 @@ class SettingsProcessor {
         }
         await this.injectTeamHooksIfSupported(destFile);
       }
+      await this.repairSiblingSettingsLocal(destFile);
     } catch (error) {
       logger.error(`Failed to process settings.json: ${error}`);
       await import_fs_extra14.copy(sourceFile, destFile, { overwrite: true });
@@ -94469,36 +94732,27 @@ class SettingsProcessor {
       const content = await import_fs_extra14.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;
   }
@@ -94539,48 +94793,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 = join94(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 = join94(dirname28(destFile), "settings.local.json");
+    if (settingsLocalPath === destFile || !await import_fs_extra14.pathExists(settingsLocalPath)) {
+      return;
+    }
+    if (await this.repairSettingsFile(settingsLocalPath)) {
+      logger.info(`Repaired stale .claude command paths in ${settingsLocalPath}`);
     }
   }
   detectClaudeCodeVersion() {
@@ -94631,7 +94908,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;
@@ -94738,7 +95015,7 @@ class CopyExecutor {
     for (const file of files) {
       const relativePath = relative13(sourceDir, file);
       const normalizedRelativePath = relativePath.replace(/\\/g, "/");
-      const destPath = join93(destDir, relativePath);
+      const destPath = join95(destDir, relativePath);
       if (await import_fs_extra15.pathExists(destPath)) {
         if (this.fileScanner.shouldNeverCopy(normalizedRelativePath)) {
           logger.debug(`Security-sensitive file exists but won't be overwritten: ${normalizedRelativePath}`);
@@ -94760,7 +95037,7 @@ class CopyExecutor {
     for (const file of files) {
       const relativePath = relative13(sourceDir, file);
       const normalizedRelativePath = relativePath.replace(/\\/g, "/");
-      const destPath = join93(destDir, relativePath);
+      const destPath = join95(destDir, relativePath);
       if (this.fileScanner.shouldNeverCopy(normalizedRelativePath)) {
         logger.debug(`Skipping security-sensitive file: ${normalizedRelativePath}`);
         skippedCount++;
@@ -94837,10 +95114,10 @@ class CopyExecutor {
   }
   trackInstalledFile(relativePath) {
     this.installedFiles.add(relativePath);
-    let dir = dirname28(relativePath);
+    let dir = dirname29(relativePath);
     while (dir && dir !== "." && dir !== "/") {
       this.installedDirectories.add(`${dir}/`);
-      dir = dirname28(dir);
+      dir = dirname29(dir);
     }
   }
 }
@@ -94933,15 +95210,15 @@ class FileMerger {
 
 // src/domains/migration/legacy-migration.ts
 import { readdir as readdir20, stat as stat15 } from "node:fs/promises";
-import { join as join97, relative as relative14 } from "node:path";
+import { join as join99, relative as relative14 } from "node:path";
 // src/services/file-operations/manifest/manifest-tracker.ts
-import { join as join96 } from "node:path";
+import { join as join98 } from "node:path";
 
 // src/domains/migration/release-manifest.ts
 init_logger();
 init_zod();
 var import_fs_extra16 = __toESM(require_lib(), 1);
-import { join as join94 } from "node:path";
+import { join as join96 } from "node:path";
 var ReleaseManifestFileSchema = exports_external.object({
   path: exports_external.string(),
   checksum: exports_external.string().regex(/^[a-f0-9]{64}$/),
@@ -94956,7 +95233,7 @@ var ReleaseManifestSchema = exports_external.object({
 
 class ReleaseManifestLoader {
   static async load(extractDir) {
-    const manifestPath = join94(extractDir, "release-manifest.json");
+    const manifestPath = join96(extractDir, "release-manifest.json");
     try {
       const content = await import_fs_extra16.readFile(manifestPath, "utf-8");
       const parsed = JSON.parse(content);
@@ -94978,12 +95255,12 @@ init_safe_spinner();
 
 // src/services/file-operations/manifest/manifest-updater.ts
 init_metadata_migration();
-import { join as join95 } from "node:path";
+import { join as join97 } from "node:path";
 init_logger();
 init_types3();
 var import_fs_extra17 = __toESM(require_lib(), 1);
 async function writeManifest(claudeDir2, kitName, version, scope, kitType, trackedFiles, userConfigFiles) {
-  const metadataPath = join95(claudeDir2, "metadata.json");
+  const metadataPath = join97(claudeDir2, "metadata.json");
   const kit = kitType || (/\bmarketing\b/i.test(kitName) ? "marketing" : "engineer");
   await import_fs_extra17.ensureFile(metadataPath);
   let release = null;
@@ -95035,7 +95312,7 @@ async function writeManifest(claudeDir2, kitName, version, scope, kitType, track
   }
 }
 async function removeKitFromManifest(claudeDir2, kit, options2) {
-  const metadataPath = join95(claudeDir2, "metadata.json");
+  const metadataPath = join97(claudeDir2, "metadata.json");
   if (!await import_fs_extra17.pathExists(metadataPath))
     return false;
   let release = null;
@@ -95067,7 +95344,7 @@ async function removeKitFromManifest(claudeDir2, kit, options2) {
   }
 }
 async function retainTrackedFilesInManifest(claudeDir2, retainedPaths, options2) {
-  const metadataPath = join95(claudeDir2, "metadata.json");
+  const metadataPath = join97(claudeDir2, "metadata.json");
   if (!await import_fs_extra17.pathExists(metadataPath))
     return false;
   const normalizedPaths = new Set(retainedPaths.map((path15) => path15.replace(/\\/g, "/")));
@@ -95248,7 +95525,7 @@ function buildFileTrackingList(options2) {
     if (!isGlobal && !installedPath.startsWith(".claude/"))
       continue;
     const relativePath = isGlobal ? installedPath : installedPath.replace(/^\.claude\//, "");
-    const filePath = join96(claudeDir2, relativePath);
+    const filePath = join98(claudeDir2, relativePath);
     const manifestEntry = releaseManifest ? ReleaseManifestLoader.findFile(releaseManifest, installedPath) : null;
     const ownership = manifestEntry ? "ck" : "user";
     filesToTrack.push({
@@ -95358,7 +95635,7 @@ class LegacyMigration {
         continue;
       if (SKIP_DIRS_ALL.includes(entry))
         continue;
-      const fullPath = join97(dir, entry);
+      const fullPath = join99(dir, entry);
       let stats;
       try {
         stats = await stat15(fullPath);
@@ -95460,7 +95737,7 @@ User-created files (sample):`);
     ];
     if (filesToChecksum.length > 0) {
       const checksumResults = await mapWithLimit(filesToChecksum, async ({ relativePath, ownership }) => {
-        const fullPath = join97(claudeDir2, relativePath);
+        const fullPath = join99(claudeDir2, relativePath);
         const checksum = await OwnershipChecker.calculateChecksum(fullPath);
         return { relativePath, checksum, ownership };
       });
@@ -95481,7 +95758,7 @@ User-created files (sample):`);
       installedAt: new Date().toISOString(),
       files: trackedFiles
     };
-    const metadataPath = join97(claudeDir2, "metadata.json");
+    const metadataPath = join99(claudeDir2, "metadata.json");
     await import_fs_extra18.writeFile(metadataPath, JSON.stringify(updatedMetadata, null, 2));
     logger.success(`Migration complete: tracked ${trackedFiles.length} files`);
     return true;
@@ -95587,7 +95864,7 @@ function buildConflictSummary(fileConflicts, hookConflicts, mcpConflicts) {
 init_logger();
 init_skip_directories();
 var import_fs_extra19 = __toESM(require_lib(), 1);
-import { join as join98, relative as relative15, resolve as resolve25 } from "node:path";
+import { join as join100, relative as relative15, resolve as resolve25 } from "node:path";
 
 class FileScanner2 {
   static async getFiles(dirPath, relativeTo) {
@@ -95603,7 +95880,7 @@ class FileScanner2 {
           logger.debug(`Skipping directory: ${entry}`);
           continue;
         }
-        const fullPath = join98(dirPath, entry);
+        const fullPath = join100(dirPath, entry);
         if (!FileScanner2.isSafePath(basePath, fullPath)) {
           logger.warning(`Skipping potentially unsafe path: ${entry}`);
           continue;
@@ -95638,8 +95915,8 @@ class FileScanner2 {
     return files;
   }
   static async findCustomFiles(destDir, sourceDir, subPath) {
-    const destSubDir = join98(destDir, subPath);
-    const sourceSubDir = join98(sourceDir, subPath);
+    const destSubDir = join100(destDir, subPath);
+    const sourceSubDir = join100(sourceDir, subPath);
     logger.debug(`findCustomFiles - destDir: ${destDir}`);
     logger.debug(`findCustomFiles - sourceDir: ${sourceDir}`);
     logger.debug(`findCustomFiles - subPath: "${subPath}"`);
@@ -95680,12 +95957,12 @@ class FileScanner2 {
 init_logger();
 var import_fs_extra20 = __toESM(require_lib(), 1);
 import { lstat as lstat8, mkdir as mkdir28, readdir as readdir23, stat as stat16 } from "node:fs/promises";
-import { join as join100 } from "node:path";
+import { join as join102 } from "node:path";
 
 // src/services/transformers/commands-prefix/content-transformer.ts
 init_logger();
 import { readFile as readFile44, readdir as readdir22, writeFile as writeFile26 } from "node:fs/promises";
-import { join as join99 } from "node:path";
+import { join as join101 } from "node:path";
 var TRANSFORMABLE_EXTENSIONS = new Set([
   ".md",
   ".txt",
@@ -95746,7 +96023,7 @@ async function transformCommandReferences(directory, options2 = {}) {
   async function processDirectory(dir) {
     const entries = await readdir22(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join99(dir, entry.name);
+      const fullPath = join101(dir, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name.startsWith(".") && entry.name !== ".claude") {
           continue;
@@ -95821,14 +96098,14 @@ function shouldApplyPrefix(options2) {
 // src/services/transformers/commands-prefix/prefix-applier.ts
 async function applyPrefix(extractDir) {
   validatePath(extractDir, "extractDir");
-  const commandsDir = join100(extractDir, ".claude", "commands");
+  const commandsDir = join102(extractDir, ".claude", "commands");
   if (!await import_fs_extra20.pathExists(commandsDir)) {
     logger.verbose("No commands directory found, skipping prefix application");
     return;
   }
   logger.info("Applying /ck: prefix to slash commands...");
-  const backupDir = join100(extractDir, ".commands-backup");
-  const tempDir = join100(extractDir, ".commands-prefix-temp");
+  const backupDir = join102(extractDir, ".commands-backup");
+  const tempDir = join102(extractDir, ".commands-prefix-temp");
   try {
     const entries = await readdir23(commandsDir);
     if (entries.length === 0) {
@@ -95836,7 +96113,7 @@ async function applyPrefix(extractDir) {
       return;
     }
     if (entries.length === 1 && entries[0] === "ck") {
-      const ckDir2 = join100(commandsDir, "ck");
+      const ckDir2 = join102(commandsDir, "ck");
       const ckStat = await stat16(ckDir2);
       if (ckStat.isDirectory()) {
         logger.verbose("Commands already have /ck: prefix, skipping");
@@ -95846,17 +96123,17 @@ async function applyPrefix(extractDir) {
     await import_fs_extra20.copy(commandsDir, backupDir);
     logger.verbose("Created backup of commands directory");
     await mkdir28(tempDir, { recursive: true });
-    const ckDir = join100(tempDir, "ck");
+    const ckDir = join102(tempDir, "ck");
     await mkdir28(ckDir, { recursive: true });
     let processedCount = 0;
     for (const entry of entries) {
-      const sourcePath = join100(commandsDir, entry);
+      const sourcePath = join102(commandsDir, entry);
       const stats = await lstat8(sourcePath);
       if (stats.isSymbolicLink()) {
         logger.warning(`Skipping symlink for security: ${entry}`);
         continue;
       }
-      const destPath = join100(ckDir, entry);
+      const destPath = join102(ckDir, entry);
       await import_fs_extra20.copy(sourcePath, destPath, {
         overwrite: false,
         errorOnExist: true
@@ -95874,7 +96151,7 @@ async function applyPrefix(extractDir) {
     await import_fs_extra20.move(tempDir, commandsDir);
     await import_fs_extra20.remove(backupDir);
     logger.success("Successfully reorganized commands to /ck: prefix");
-    const claudeDir2 = join100(extractDir, ".claude");
+    const claudeDir2 = join102(extractDir, ".claude");
     logger.info("Transforming command references in file contents...");
     const transformResult = await transformCommandReferences(claudeDir2, {
       verbose: logger.isVerbose()
@@ -95912,20 +96189,20 @@ async function applyPrefix(extractDir) {
 // src/services/transformers/commands-prefix/prefix-cleaner.ts
 init_metadata_migration();
 import { lstat as lstat10, readdir as readdir25 } from "node:fs/promises";
-import { join as join102 } from "node:path";
+import { join as join104 } from "node:path";
 init_logger();
 var import_fs_extra22 = __toESM(require_lib(), 1);
 
 // src/services/transformers/commands-prefix/file-processor.ts
 import { lstat as lstat9, readdir as readdir24 } from "node:fs/promises";
-import { join as join101 } from "node:path";
+import { join as join103 } from "node:path";
 init_logger();
 var import_fs_extra21 = __toESM(require_lib(), 1);
 async function scanDirectoryFiles(dir) {
   const files = [];
   const entries = await readdir24(dir);
   for (const entry of entries) {
-    const fullPath = join101(dir, entry);
+    const fullPath = join103(dir, entry);
     const stats = await lstat9(fullPath);
     if (stats.isSymbolicLink()) {
       continue;
@@ -96053,8 +96330,8 @@ function isDifferentKitDirectory(dirName, currentKit) {
 async function cleanupCommandsDirectory(targetDir, isGlobal, options2 = {}) {
   const { dryRun = false } = options2;
   validatePath(targetDir, "targetDir");
-  const claudeDir2 = isGlobal ? targetDir : join102(targetDir, ".claude");
-  const commandsDir = join102(claudeDir2, "commands");
+  const claudeDir2 = isGlobal ? targetDir : join104(targetDir, ".claude");
+  const commandsDir = join104(claudeDir2, "commands");
   const accumulator = {
     results: [],
     deletedCount: 0,
@@ -96096,7 +96373,7 @@ async function cleanupCommandsDirectory(targetDir, isGlobal, options2 = {}) {
   }
   const metadataForChecks = options2.kitType ? createKitSpecificMetadata(metadata, options2.kitType) : metadata;
   for (const entry of entries) {
-    const entryPath = join102(commandsDir, entry);
+    const entryPath = join104(commandsDir, entry);
     const stats = await lstat10(entryPath);
     if (stats.isSymbolicLink()) {
       addSymlinkSkip(entry, accumulator);
@@ -96153,7 +96430,7 @@ async function handleMerge(ctx) {
   let customClaudeFiles = [];
   if (!ctx.options.fresh) {
     logger.info("Scanning for custom .claude files...");
-    const scanSourceDir = ctx.options.global ? join103(ctx.extractDir, ".claude") : ctx.extractDir;
+    const scanSourceDir = ctx.options.global ? join105(ctx.extractDir, ".claude") : ctx.extractDir;
     const scanTargetSubdir = ctx.options.global ? "" : ".claude";
     customClaudeFiles = await FileScanner2.findCustomFiles(ctx.resolvedDir, scanSourceDir, scanTargetSubdir);
   } else {
@@ -96218,8 +96495,8 @@ async function handleMerge(ctx) {
       return { ...ctx, cancelled: true };
     }
   }
-  const sourceDir = ctx.options.global ? join103(ctx.extractDir, ".claude") : ctx.extractDir;
-  const sourceMetadataPath = ctx.options.global ? join103(sourceDir, "metadata.json") : join103(sourceDir, ".claude", "metadata.json");
+  const sourceDir = ctx.options.global ? join105(ctx.extractDir, ".claude") : ctx.extractDir;
+  const sourceMetadataPath = ctx.options.global ? join105(sourceDir, "metadata.json") : join105(sourceDir, ".claude", "metadata.json");
   let sourceMetadata = null;
   try {
     if (await import_fs_extra23.pathExists(sourceMetadataPath)) {
@@ -96276,7 +96553,7 @@ async function handleMerge(ctx) {
   };
 }
 // src/commands/init/phases/migration-handler.ts
-import { join as join111 } from "node:path";
+import { join as join113 } from "node:path";
 
 // src/domains/skills/skills-detector.ts
 init_logger();
@@ -96292,7 +96569,7 @@ init_types3();
 var import_fs_extra24 = __toESM(require_lib(), 1);
 import { createHash as createHash5 } from "node:crypto";
 import { readFile as readFile46, readdir as readdir26, writeFile as writeFile27 } from "node:fs/promises";
-import { join as join104, relative as relative16 } from "node:path";
+import { join as join106, relative as relative16 } from "node:path";
 
 class SkillsManifestManager {
   static MANIFEST_FILENAME = ".skills-manifest.json";
@@ -96314,12 +96591,12 @@ class SkillsManifestManager {
     return manifest;
   }
   static async writeManifest(skillsDir2, manifest) {
-    const manifestPath = join104(skillsDir2, SkillsManifestManager.MANIFEST_FILENAME);
+    const manifestPath = join106(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 = join104(skillsDir2, SkillsManifestManager.MANIFEST_FILENAME);
+    const manifestPath = join106(skillsDir2, SkillsManifestManager.MANIFEST_FILENAME);
     if (!await import_fs_extra24.pathExists(manifestPath)) {
       logger.debug(`No manifest found at: ${manifestPath}`);
       return null;
@@ -96342,7 +96619,7 @@ class SkillsManifestManager {
       return "flat";
     }
     for (const dir of dirs.slice(0, 3)) {
-      const dirPath = join104(skillsDir2, dir.name);
+      const dirPath = join106(skillsDir2, dir.name);
       const subEntries = await readdir26(dirPath, { withFileTypes: true });
       const hasSubdirs = subEntries.some((entry) => entry.isDirectory());
       if (hasSubdirs) {
@@ -96361,7 +96638,7 @@ class SkillsManifestManager {
       const entries = await readdir26(skillsDir2, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isDirectory() && !BUILD_ARTIFACT_DIRS.includes(entry.name) && !entry.name.startsWith(".")) {
-          const skillPath = join104(skillsDir2, entry.name);
+          const skillPath = join106(skillsDir2, entry.name);
           const hash = await SkillsManifestManager.hashDirectory(skillPath);
           skills.push({
             name: entry.name,
@@ -96373,11 +96650,11 @@ class SkillsManifestManager {
       const categories = await readdir26(skillsDir2, { withFileTypes: true });
       for (const category of categories) {
         if (category.isDirectory() && !BUILD_ARTIFACT_DIRS.includes(category.name) && !category.name.startsWith(".")) {
-          const categoryPath = join104(skillsDir2, category.name);
+          const categoryPath = join106(skillsDir2, category.name);
           const skillEntries = await readdir26(categoryPath, { withFileTypes: true });
           for (const skillEntry of skillEntries) {
             if (skillEntry.isDirectory() && !skillEntry.name.startsWith(".")) {
-              const skillPath = join104(categoryPath, skillEntry.name);
+              const skillPath = join106(categoryPath, skillEntry.name);
               const hash = await SkillsManifestManager.hashDirectory(skillPath);
               skills.push({
                 name: skillEntry.name,
@@ -96407,7 +96684,7 @@ class SkillsManifestManager {
     const files = [];
     const entries = await readdir26(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)) {
         continue;
       }
@@ -96529,7 +96806,7 @@ function getPathMapping(skillName, oldBasePath, newBasePath) {
 // src/domains/skills/detection/script-detector.ts
 var import_fs_extra25 = __toESM(require_lib(), 1);
 import { readdir as readdir27 } from "node:fs/promises";
-import { join as join105 } from "node:path";
+import { join as join107 } from "node:path";
 async function scanDirectory(skillsDir2) {
   if (!await import_fs_extra25.pathExists(skillsDir2)) {
     return ["flat", []];
@@ -96542,12 +96819,12 @@ async function scanDirectory(skillsDir2) {
   let totalSkillLikeCount = 0;
   const allSkills = [];
   for (const dir of dirs) {
-    const dirPath = join105(skillsDir2, dir.name);
+    const dirPath = join107(skillsDir2, dir.name);
     const subEntries = await readdir27(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 = join105(dirPath, subdir.name);
+        const subdirPath = join107(dirPath, subdir.name);
         const subdirFiles = await readdir27(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) {
@@ -96704,12 +96981,12 @@ class SkillsMigrationDetector {
 // src/domains/skills/skills-migrator.ts
 init_logger();
 init_types3();
-import { join as join110 } from "node:path";
+import { join as join112 } from "node:path";
 
 // src/domains/skills/migrator/migration-executor.ts
 init_logger();
 import { copyFile as copyFile6, mkdir as mkdir29, readdir as readdir28, rm as rm11 } from "node:fs/promises";
-import { join as join106 } from "node:path";
+import { join as join108 } from "node:path";
 var import_fs_extra27 = __toESM(require_lib(), 1);
 
 // src/domains/skills/skills-migration-prompts.ts
@@ -96874,8 +97151,8 @@ async function copySkillDirectory(sourceDir, destDir) {
   await mkdir29(destDir, { recursive: true });
   const entries = await readdir28(sourceDir, { withFileTypes: true });
   for (const entry of entries) {
-    const sourcePath = join106(sourceDir, entry.name);
-    const destPath = join106(destDir, entry.name);
+    const sourcePath = join108(sourceDir, entry.name);
+    const destPath = join108(destDir, entry.name);
     if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.isSymbolicLink()) {
       continue;
     }
@@ -96890,7 +97167,7 @@ async function executeInternal(mappings, customizations, currentSkillsDir, inter
   const migrated = [];
   const preserved = [];
   const errors2 = [];
-  const tempDir = join106(currentSkillsDir, "..", ".skills-migration-temp");
+  const tempDir = join108(currentSkillsDir, "..", ".skills-migration-temp");
   await mkdir29(tempDir, { recursive: true });
   try {
     for (const mapping of mappings) {
@@ -96911,9 +97188,9 @@ async function executeInternal(mappings, customizations, currentSkillsDir, inter
           }
         }
         const category = mapping.category;
-        const targetPath = category ? join106(tempDir, category, skillName) : join106(tempDir, skillName);
+        const targetPath = category ? join108(tempDir, category, skillName) : join108(tempDir, skillName);
         if (category) {
-          await mkdir29(join106(tempDir, category), { recursive: true });
+          await mkdir29(join108(tempDir, category), { recursive: true });
         }
         await copySkillDirectory(currentSkillPath, targetPath);
         migrated.push(skillName);
@@ -96980,7 +97257,7 @@ init_logger();
 init_types3();
 var import_fs_extra28 = __toESM(require_lib(), 1);
 import { copyFile as copyFile7, mkdir as mkdir30, readdir as readdir29, rm as rm12, stat as stat17 } from "node:fs/promises";
-import { basename as basename17, join as join107, normalize as normalize9 } from "node:path";
+import { basename as basename17, join as join109, normalize as normalize9 } from "node:path";
 function validatePath2(path15, paramName) {
   if (!path15 || typeof path15 !== "string") {
     throw new SkillsMigrationError(`${paramName} must be a non-empty string`);
@@ -97006,7 +97283,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 ? join107(parentDir, backupDirName) : join107(skillsDir2, "..", backupDirName);
+    const backupDir = parentDir ? join109(parentDir, backupDirName) : join109(skillsDir2, "..", backupDirName);
     logger.info(`Creating backup at: ${backupDir}`);
     try {
       await mkdir30(backupDir, { recursive: true });
@@ -97057,7 +97334,7 @@ class SkillsBackupManager {
     }
     try {
       const entries = await readdir29(parentDir, { withFileTypes: true });
-      const backups = entries.filter((entry) => entry.isDirectory() && entry.name.startsWith(SkillsBackupManager.BACKUP_PREFIX)).map((entry) => join107(parentDir, entry.name));
+      const backups = entries.filter((entry) => entry.isDirectory() && entry.name.startsWith(SkillsBackupManager.BACKUP_PREFIX)).map((entry) => join109(parentDir, entry.name));
       backups.sort().reverse();
       return backups;
     } catch (error) {
@@ -97085,8 +97362,8 @@ class SkillsBackupManager {
   static async copyDirectory(sourceDir, destDir) {
     const entries = await readdir29(sourceDir, { withFileTypes: true });
     for (const entry of entries) {
-      const sourcePath = join107(sourceDir, entry.name);
-      const destPath = join107(destDir, entry.name);
+      const sourcePath = join109(sourceDir, entry.name);
+      const destPath = join109(destDir, entry.name);
       if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.isSymbolicLink()) {
         continue;
       }
@@ -97102,7 +97379,7 @@ class SkillsBackupManager {
     let size = 0;
     const entries = await readdir29(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join107(dirPath, entry.name);
+      const fullPath = join109(dirPath, entry.name);
       if (entry.isSymbolicLink()) {
         continue;
       }
@@ -97138,12 +97415,12 @@ init_skip_directories();
 import { createHash as createHash6 } from "node:crypto";
 import { createReadStream as createReadStream3 } from "node:fs";
 import { readFile as readFile47, readdir as readdir30 } from "node:fs/promises";
-import { join as join108, relative as relative17 } from "node:path";
+import { join as join110, relative as relative17 } from "node:path";
 async function getAllFiles(dirPath) {
   const files = [];
   const entries = await readdir30(dirPath, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = join108(dirPath, entry.name);
+    const fullPath = join110(dirPath, entry.name);
     if (entry.name.startsWith(".") || BUILD_ARTIFACT_DIRS.includes(entry.name) || entry.isSymbolicLink()) {
       continue;
     }
@@ -97270,7 +97547,7 @@ async function detectFileChanges(currentSkillPath, baselineSkillPath) {
 init_types3();
 var import_fs_extra30 = __toESM(require_lib(), 1);
 import { readdir as readdir31 } from "node:fs/promises";
-import { join as join109, normalize as normalize10 } from "node:path";
+import { join as join111, normalize as normalize10 } from "node:path";
 function validatePath3(path15, paramName) {
   if (!path15 || typeof path15 !== "string") {
     throw new SkillsMigrationError(`${paramName} must be a non-empty string`);
@@ -97291,13 +97568,13 @@ async function scanSkillsDirectory(skillsDir2) {
   if (dirs.length === 0) {
     return ["flat", []];
   }
-  const firstDirPath = join109(skillsDir2, dirs[0].name);
+  const firstDirPath = join111(skillsDir2, dirs[0].name);
   const subEntries = await readdir31(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 = join109(firstDirPath, subdir.name);
+      const subdirPath = join111(firstDirPath, subdir.name);
       const subdirFiles = await readdir31(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) {
@@ -97307,7 +97584,7 @@ async function scanSkillsDirectory(skillsDir2) {
     if (skillLikeCount > 0) {
       const skills = [];
       for (const dir of dirs) {
-        const categoryPath = join109(skillsDir2, dir.name);
+        const categoryPath = join111(skillsDir2, dir.name);
         const skillDirs = await readdir31(categoryPath, { withFileTypes: true });
         skills.push(...skillDirs.filter((entry) => entry.isDirectory() && !entry.name.startsWith(".")).map((entry) => entry.name));
       }
@@ -97317,7 +97594,7 @@ async function scanSkillsDirectory(skillsDir2) {
   return ["flat", dirs.map((dir) => dir.name)];
 }
 async function findSkillPath(skillsDir2, skillName) {
-  const flatPath = join109(skillsDir2, skillName);
+  const flatPath = join111(skillsDir2, skillName);
   if (await import_fs_extra30.pathExists(flatPath)) {
     return { path: flatPath, category: undefined };
   }
@@ -97326,8 +97603,8 @@ async function findSkillPath(skillsDir2, skillName) {
     if (!entry.isDirectory() || entry.name.startsWith(".") || entry.name === "node_modules") {
       continue;
     }
-    const categoryPath = join109(skillsDir2, entry.name);
-    const skillPath = join109(categoryPath, skillName);
+    const categoryPath = join111(skillsDir2, entry.name);
+    const skillPath = join111(categoryPath, skillName);
     if (await import_fs_extra30.pathExists(skillPath)) {
       return { path: skillPath, category: entry.name };
     }
@@ -97421,7 +97698,7 @@ class SkillsMigrator {
         }
       }
       if (options2.backup && !options2.dryRun) {
-        const claudeDir2 = join110(currentSkillsDir, "..");
+        const claudeDir2 = join112(currentSkillsDir, "..");
         result.backupPath = await SkillsBackupManager.createBackup(currentSkillsDir, claudeDir2);
         logger.success(`Backup created at: ${result.backupPath}`);
       }
@@ -97482,7 +97759,7 @@ async function handleMigration(ctx) {
     logger.debug("Skipping skills migration (fresh installation)");
     return ctx;
   }
-  const newSkillsDir = join111(ctx.extractDir, ".claude", "skills");
+  const newSkillsDir = join113(ctx.extractDir, ".claude", "skills");
   const currentSkillsDir = PathResolver.buildSkillsPath(ctx.resolvedDir, ctx.options.global);
   if (!await import_fs_extra31.pathExists(newSkillsDir) || !await import_fs_extra31.pathExists(currentSkillsDir)) {
     return ctx;
@@ -97506,13 +97783,13 @@ async function handleMigration(ctx) {
 }
 // src/commands/init/phases/opencode-handler.ts
 import { cp as cp3, readdir as readdir33, rm as rm13 } from "node:fs/promises";
-import { join as join113 } from "node:path";
+import { join as join115 } from "node:path";
 
 // src/services/transformers/opencode-path-transformer.ts
 init_logger();
 import { readFile as readFile48, readdir as readdir32, writeFile as writeFile28 } from "node:fs/promises";
 import { platform as platform14 } from "node:os";
-import { extname as extname5, join as join112 } from "node:path";
+import { extname as extname5, join as join114 } from "node:path";
 var IS_WINDOWS2 = platform14() === "win32";
 function getOpenCodeGlobalPath() {
   return "$HOME/.config/opencode/";
@@ -97573,7 +97850,7 @@ async function transformPathsForGlobalOpenCode(directory, options2 = {}) {
   async function processDirectory2(dir) {
     const entries = await readdir32(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join112(dir, entry.name);
+      const fullPath = join114(dir, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name.startsWith(".")) {
           continue;
@@ -97612,7 +97889,7 @@ async function handleOpenCode(ctx) {
   if (ctx.cancelled || !ctx.extractDir || !ctx.resolvedDir) {
     return ctx;
   }
-  const openCodeSource = join113(ctx.extractDir, ".opencode");
+  const openCodeSource = join115(ctx.extractDir, ".opencode");
   if (!await import_fs_extra32.pathExists(openCodeSource)) {
     logger.debug("No .opencode directory in archive, skipping");
     return ctx;
@@ -97630,8 +97907,8 @@ async function handleOpenCode(ctx) {
     await import_fs_extra32.ensureDir(targetDir);
     const entries = await readdir33(openCodeSource, { withFileTypes: true });
     for (const entry of entries) {
-      const sourcePath = join113(openCodeSource, entry.name);
-      const targetPath = join113(targetDir, entry.name);
+      const sourcePath = join115(openCodeSource, entry.name);
+      const targetPath = join115(targetDir, entry.name);
       if (await import_fs_extra32.pathExists(targetPath)) {
         if (!ctx.options.forceOverwrite) {
           logger.verbose(`Skipping existing: ${entry.name}`);
@@ -97729,7 +98006,7 @@ Please use only one download method.`);
 }
 // src/commands/init/phases/post-install-handler.ts
 init_projects_registry();
-import { join as join114 } from "node:path";
+import { join as join116 } from "node:path";
 init_logger();
 init_path_resolver();
 var import_fs_extra33 = __toESM(require_lib(), 1);
@@ -97738,8 +98015,8 @@ async function handlePostInstall(ctx) {
     return ctx;
   }
   if (ctx.options.global) {
-    const claudeMdSource = join114(ctx.extractDir, "CLAUDE.md");
-    const claudeMdDest = join114(ctx.resolvedDir, "CLAUDE.md");
+    const claudeMdSource = join116(ctx.extractDir, "CLAUDE.md");
+    const claudeMdDest = join116(ctx.resolvedDir, "CLAUDE.md");
     if (await import_fs_extra33.pathExists(claudeMdSource)) {
       if (ctx.options.fresh || !await import_fs_extra33.pathExists(claudeMdDest)) {
         await import_fs_extra33.copy(claudeMdSource, claudeMdDest);
@@ -97787,7 +98064,7 @@ async function handlePostInstall(ctx) {
   }
   if (!ctx.options.skipSetup) {
     await promptSetupWizardIfNeeded({
-      envPath: join114(ctx.claudeDir, ".env"),
+      envPath: join116(ctx.claudeDir, ".env"),
       claudeDir: ctx.claudeDir,
       isGlobal: ctx.options.global,
       isNonInteractive: ctx.isNonInteractive,
@@ -97811,7 +98088,7 @@ async function handlePostInstall(ctx) {
 init_config_manager();
 init_github_client();
 import { mkdir as mkdir31 } from "node:fs/promises";
-import { join as join116, resolve as resolve27 } from "node:path";
+import { join as join118, resolve as resolve27 } from "node:path";
 
 // src/domains/github/kit-access-checker.ts
 init_logger();
@@ -97942,7 +98219,7 @@ async function runPreflightChecks() {
 // src/domains/installation/fresh-installer.ts
 init_metadata_migration();
 import { existsSync as existsSync55, readdirSync as readdirSync6, rmSync as rmSync4, rmdirSync as rmdirSync2, unlinkSync as unlinkSync4 } from "node:fs";
-import { basename as basename18, dirname as dirname29, join as join115, resolve as resolve26 } from "node:path";
+import { basename as basename18, dirname as dirname30, join as join117, resolve as resolve26 } from "node:path";
 init_logger();
 init_safe_spinner();
 var import_fs_extra34 = __toESM(require_lib(), 1);
@@ -97991,14 +98268,14 @@ async function analyzeFreshInstallation(claudeDir2) {
 }
 function cleanupEmptyDirectories2(filePath, claudeDir2) {
   const normalizedClaudeDir = resolve26(claudeDir2);
-  let currentDir = resolve26(dirname29(filePath));
+  let currentDir = resolve26(dirname30(filePath));
   while (currentDir !== normalizedClaudeDir && currentDir.startsWith(normalizedClaudeDir)) {
     try {
       const entries = readdirSync6(currentDir);
       if (entries.length === 0) {
         rmdirSync2(currentDir);
         logger.debug(`Removed empty directory: ${currentDir}`);
-        currentDir = resolve26(dirname29(currentDir));
+        currentDir = resolve26(dirname30(currentDir));
       } else {
         break;
       }
@@ -98015,7 +98292,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 = join115(claudeDir2, file.path);
+    const fullPath = join117(claudeDir2, file.path);
     if (!existsSync55(fullPath)) {
       continue;
     }
@@ -98043,7 +98320,7 @@ async function removeFilesByOwnership(claudeDir2, analysis, includeModified) {
   };
 }
 async function updateMetadataAfterFresh(claudeDir2, removedFiles) {
-  const metadataPath = join115(claudeDir2, "metadata.json");
+  const metadataPath = join117(claudeDir2, "metadata.json");
   if (!await import_fs_extra34.pathExists(metadataPath)) {
     throw new Error("metadata.json is missing during fresh install cleanup");
   }
@@ -98086,8 +98363,8 @@ function getFreshBackupTargets(claudeDir2, analysis, includeModified) {
       mutatePaths: filesToRemove.length > 0 ? ["metadata.json"] : []
     };
   }
-  const deletePaths = CLAUDEKIT_SUBDIRECTORIES.filter((subdir) => existsSync55(join115(claudeDir2, subdir)));
-  if (existsSync55(join115(claudeDir2, "metadata.json"))) {
+  const deletePaths = CLAUDEKIT_SUBDIRECTORIES.filter((subdir) => existsSync55(join117(claudeDir2, subdir)));
+  if (existsSync55(join117(claudeDir2, "metadata.json"))) {
     deletePaths.push("metadata.json");
   }
   return {
@@ -98109,7 +98386,7 @@ async function removeSubdirectoriesFallback(claudeDir2) {
   const removedFiles = [];
   let removedDirCount = 0;
   for (const subdir of CLAUDEKIT_SUBDIRECTORIES) {
-    const subdirPath = join115(claudeDir2, subdir);
+    const subdirPath = join117(claudeDir2, subdir);
     if (await import_fs_extra34.pathExists(subdirPath)) {
       rmSync4(subdirPath, { recursive: true, force: true });
       removedDirCount++;
@@ -98117,7 +98394,7 @@ async function removeSubdirectoriesFallback(claudeDir2) {
       logger.debug(`Removed subdirectory: ${subdir}/`);
     }
   }
-  const metadataPath = join115(claudeDir2, "metadata.json");
+  const metadataPath = join117(claudeDir2, "metadata.json");
   if (await import_fs_extra34.pathExists(metadataPath)) {
     unlinkSync4(metadataPath);
     removedFiles.push("metadata.json");
@@ -98399,7 +98676,7 @@ async function handleSelection(ctx) {
   }
   if (!ctx.options.fresh) {
     const prefix = PathResolver.getPathPrefix(ctx.options.global);
-    const claudeDir2 = prefix ? join116(resolvedDir, prefix) : resolvedDir;
+    const claudeDir2 = prefix ? join118(resolvedDir, prefix) : resolvedDir;
     try {
       const existingMetadata = await readManifest(claudeDir2);
       if (existingMetadata?.kits) {
@@ -98431,7 +98708,7 @@ async function handleSelection(ctx) {
   }
   if (ctx.options.fresh) {
     const prefix = PathResolver.getPathPrefix(ctx.options.global);
-    const claudeDir2 = prefix ? join116(resolvedDir, prefix) : resolvedDir;
+    const claudeDir2 = prefix ? join118(resolvedDir, prefix) : resolvedDir;
     const canProceed = await handleFreshInstallation(claudeDir2, ctx.prompts);
     if (!canProceed) {
       return { ...ctx, cancelled: true };
@@ -98451,7 +98728,7 @@ async function handleSelection(ctx) {
     let currentVersion = null;
     try {
       const prefix = PathResolver.getPathPrefix(ctx.options.global);
-      const claudeDir2 = prefix ? join116(resolvedDir, prefix) : resolvedDir;
+      const claudeDir2 = prefix ? join118(resolvedDir, prefix) : resolvedDir;
       const existingMetadata = await readManifest(claudeDir2);
       currentVersion = existingMetadata?.kits?.[kitType]?.version || null;
       if (currentVersion) {
@@ -98520,7 +98797,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 ? join116(resolvedDir, prefix) : resolvedDir;
+      const claudeDir2 = prefix ? join118(resolvedDir, prefix) : resolvedDir;
       const existingMetadata = await readManifest(claudeDir2);
       const installedKitVersion = existingMetadata?.kits?.[kitType]?.version;
       if (installedKitVersion && versionsMatch(installedKitVersion, releaseTag)) {
@@ -98544,7 +98821,7 @@ async function handleSelection(ctx) {
 }
 // src/commands/init/phases/sync-handler.ts
 import { copyFile as copyFile8, mkdir as mkdir32, open as open5, readFile as readFile50, rename as rename7, stat as stat18, unlink as unlink11, writeFile as writeFile30 } from "node:fs/promises";
-import { dirname as dirname30, join as join117, resolve as resolve28 } from "node:path";
+import { dirname as dirname31, join as join119, resolve as resolve28 } from "node:path";
 init_logger();
 init_path_resolver();
 var import_fs_extra36 = __toESM(require_lib(), 1);
@@ -98554,13 +98831,13 @@ async function handleSync(ctx) {
     return ctx;
   }
   const resolvedDir = ctx.options.global ? PathResolver.getGlobalKitDir() : resolve28(ctx.options.dir || ".");
-  const claudeDir2 = ctx.options.global ? resolvedDir : join117(resolvedDir, ".claude");
+  const claudeDir2 = ctx.options.global ? resolvedDir : join119(resolvedDir, ".claude");
   if (!await import_fs_extra36.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 = join117(claudeDir2, "metadata.json");
+  const metadataPath = join119(claudeDir2, "metadata.json");
   if (!await import_fs_extra36.pathExists(metadataPath)) {
     logger.error("Cannot sync: no metadata.json found");
     ctx.prompts.note(`Your installation may be from an older version.
@@ -98660,10 +98937,10 @@ function getLockTimeout() {
 var STALE_LOCK_THRESHOLD_MS = 5 * 60 * 1000;
 async function acquireSyncLock(global3) {
   const cacheDir = PathResolver.getCacheDir(global3);
-  const lockPath = join117(cacheDir, ".sync-lock");
+  const lockPath = join119(cacheDir, ".sync-lock");
   const startTime = Date.now();
   const lockTimeout = getLockTimeout();
-  await mkdir32(dirname30(lockPath), { recursive: true });
+  await mkdir32(dirname31(lockPath), { recursive: true });
   while (Date.now() - startTime < lockTimeout) {
     try {
       const handle = await open5(lockPath, "wx");
@@ -98706,10 +98983,10 @@ async function executeSyncMerge(ctx) {
   const releaseLock = await acquireSyncLock(ctx.options.global);
   try {
     const trackedFiles = ctx.syncTrackedFiles;
-    const upstreamDir = ctx.options.global ? join117(ctx.extractDir, ".claude") : ctx.extractDir;
+    const upstreamDir = ctx.options.global ? join119(ctx.extractDir, ".claude") : ctx.extractDir;
     let deletions = [];
     try {
-      const sourceMetadataPath = join117(upstreamDir, "metadata.json");
+      const sourceMetadataPath = join119(upstreamDir, "metadata.json");
       if (await import_fs_extra36.pathExists(sourceMetadataPath)) {
         const content = await readFile50(sourceMetadataPath, "utf-8");
         const sourceMetadata = JSON.parse(content);
@@ -98741,7 +99018,7 @@ async function executeSyncMerge(ctx) {
         try {
           const sourcePath = await validateSyncPath(upstreamDir, file.path);
           const targetPath = await validateSyncPath(ctx.claudeDir, file.path);
-          const targetDir = join117(targetPath, "..");
+          const targetDir = join119(targetPath, "..");
           try {
             await mkdir32(targetDir, { recursive: true });
           } catch (mkdirError) {
@@ -98912,7 +99189,7 @@ async function createBackup(claudeDir2, files, backupDir) {
       const sourcePath = await validateSyncPath(claudeDir2, file.path);
       if (await import_fs_extra36.pathExists(sourcePath)) {
         const targetPath = await validateSyncPath(backupDir, file.path);
-        const targetDir = join117(targetPath, "..");
+        const targetDir = join119(targetPath, "..");
         await mkdir32(targetDir, { recursive: true });
         await copyFile8(sourcePath, targetPath);
       }
@@ -98927,7 +99204,7 @@ async function createBackup(claudeDir2, files, backupDir) {
 }
 // src/commands/init/phases/transform-handler.ts
 init_config_manager();
-import { join as join121 } from "node:path";
+import { join as join123 } from "node:path";
 
 // src/services/transformers/folder-path-transformer.ts
 init_logger();
@@ -98938,38 +99215,38 @@ init_logger();
 init_types3();
 var import_fs_extra37 = __toESM(require_lib(), 1);
 import { rename as rename8, rm as rm14 } from "node:fs/promises";
-import { join as join118, relative as relative19 } from "node:path";
+import { join as join120, relative as relative19 } from "node:path";
 async function collectDirsToRename(extractDir, folders) {
   const dirsToRename = [];
   if (folders.docs !== DEFAULT_FOLDERS.docs) {
-    const docsPath = join118(extractDir, DEFAULT_FOLDERS.docs);
+    const docsPath = join120(extractDir, DEFAULT_FOLDERS.docs);
     if (await import_fs_extra37.pathExists(docsPath)) {
       dirsToRename.push({
         from: docsPath,
-        to: join118(extractDir, folders.docs)
+        to: join120(extractDir, folders.docs)
       });
     }
-    const claudeDocsPath = join118(extractDir, ".claude", DEFAULT_FOLDERS.docs);
+    const claudeDocsPath = join120(extractDir, ".claude", DEFAULT_FOLDERS.docs);
     if (await import_fs_extra37.pathExists(claudeDocsPath)) {
       dirsToRename.push({
         from: claudeDocsPath,
-        to: join118(extractDir, ".claude", folders.docs)
+        to: join120(extractDir, ".claude", folders.docs)
       });
     }
   }
   if (folders.plans !== DEFAULT_FOLDERS.plans) {
-    const plansPath = join118(extractDir, DEFAULT_FOLDERS.plans);
+    const plansPath = join120(extractDir, DEFAULT_FOLDERS.plans);
     if (await import_fs_extra37.pathExists(plansPath)) {
       dirsToRename.push({
         from: plansPath,
-        to: join118(extractDir, folders.plans)
+        to: join120(extractDir, folders.plans)
       });
     }
-    const claudePlansPath = join118(extractDir, ".claude", DEFAULT_FOLDERS.plans);
+    const claudePlansPath = join120(extractDir, ".claude", DEFAULT_FOLDERS.plans);
     if (await import_fs_extra37.pathExists(claudePlansPath)) {
       dirsToRename.push({
         from: claudePlansPath,
-        to: join118(extractDir, ".claude", folders.plans)
+        to: join120(extractDir, ".claude", folders.plans)
       });
     }
   }
@@ -99010,7 +99287,7 @@ async function renameFolders(dirsToRename, extractDir, options2) {
 init_logger();
 init_types3();
 import { readFile as readFile51, readdir as readdir34, writeFile as writeFile31 } from "node:fs/promises";
-import { join as join119, relative as relative20 } from "node:path";
+import { join as join121, relative as relative20 } from "node:path";
 var TRANSFORMABLE_FILE_PATTERNS = [
   ".md",
   ".txt",
@@ -99063,7 +99340,7 @@ async function transformFileContents(dir, compiledReplacements, options2) {
   let replacementsCount = 0;
   const entries = await readdir34(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = join119(dir, entry.name);
+    const fullPath = join121(dir, entry.name);
     if (entry.isDirectory()) {
       if (entry.name === "node_modules" || entry.name === ".git") {
         continue;
@@ -99199,19 +99476,47 @@ async function transformFolderPaths(extractDir, folders, options2 = {}) {
 // src/services/transformers/global-path-transformer.ts
 init_logger();
 import { readFile as readFile52, readdir as readdir35, writeFile as writeFile32 } from "node:fs/promises";
-import { platform as platform15 } from "node:os";
-import { extname as extname6, join as join120 } from "node:path";
+import { homedir as homedir34, platform as platform15 } from "node:os";
+import { extname as extname6, join as join122 } from "node:path";
 var IS_WINDOWS3 = platform15() === "win32";
 var HOME_PREFIX = IS_WINDOWS3 ? "%USERPROFILE%" : "$HOME";
 function getHomeDirPrefix() {
   return HOME_PREFIX;
 }
+function normalizeInstallPath(path15) {
+  return path15.replace(/\\/g, "/").replace(/\/+$/, "");
+}
+function getDefaultGlobalClaudeDir() {
+  return normalizeInstallPath(join122(homedir34(), ".claude"));
+}
+function getCustomGlobalClaudeDir(targetClaudeDir) {
+  if (!targetClaudeDir)
+    return null;
+  const normalizedTargetDir = normalizeInstallPath(targetClaudeDir);
+  return normalizedTargetDir === getDefaultGlobalClaudeDir() ? null : normalizedTargetDir;
+}
+function getGlobalClaudePath(targetClaudeDir) {
+  const customGlobalClaudeDir = getCustomGlobalClaudeDir(targetClaudeDir);
+  if (customGlobalClaudeDir) {
+    return `${customGlobalClaudeDir}/`;
+  }
+  return `${getHomeDirPrefix()}/.claude/`;
+}
+function replaceTracked(content, pattern, replacement) {
+  let changes = 0;
+  const updated = content.replace(pattern, () => {
+    changes++;
+    return replacement;
+  });
+  return { content: updated, changes };
+}
 var TRANSFORMABLE_EXTENSIONS3 = new Set([
   ".md",
   ".js",
   ".cjs",
   ".mjs",
   ".ts",
+  ".py",
   ".json",
   ".sh",
   ".ps1",
@@ -99220,83 +99525,94 @@ var TRANSFORMABLE_EXTENSIONS3 = new Set([
   ".toml"
 ]);
 var ALWAYS_TRANSFORM_FILES = new Set(["CLAUDE.md", "claude.md"]);
-function transformContent(content) {
+function transformContent(content, options2 = {}) {
   let changes = 0;
   let transformed = content;
   const homePrefix = getHomeDirPrefix();
-  const claudePath = `${homePrefix}/.claude/`;
+  const customGlobalClaudeDir = getCustomGlobalClaudeDir(options2.targetClaudeDir);
+  const claudePath = getGlobalClaudePath(options2.targetClaudeDir);
   if (IS_WINDOWS3) {
-    transformed = transformed.replace(/\$HOME\/\.claude\//g, () => {
-      changes++;
-      return claudePath;
-    });
-    transformed = transformed.replace(/\$\{HOME\}\/\.claude\//g, () => {
-      changes++;
-      return claudePath;
-    });
-    transformed = transformed.replace(/\$HOME(?=\/|\\)/g, () => {
-      changes++;
-      return homePrefix;
-    });
-    transformed = transformed.replace(/\$\{HOME\}(?=\/|\\)/g, () => {
-      changes++;
-      return homePrefix;
-    });
-  }
-  transformed = transformed.replace(/\$CLAUDE_PROJECT_DIR\/\.claude\//g, () => {
-    changes++;
-    return claudePath;
-  });
-  transformed = transformed.replace(/"\$CLAUDE_PROJECT_DIR"\/\.claude\//g, () => {
-    changes++;
-    return `"${homePrefix}"/.claude/`;
-  });
-  transformed = transformed.replace(/\$\{CLAUDE_PROJECT_DIR\}\/\.claude\//g, () => {
-    changes++;
-    return claudePath;
-  });
+    const homePathResult = replaceTracked(transformed, /\$HOME\/\.claude\//g, claudePath);
+    transformed = homePathResult.content;
+    changes += homePathResult.changes;
+    const braceHomePathResult = replaceTracked(transformed, /\$\{HOME\}\/\.claude\//g, claudePath);
+    transformed = braceHomePathResult.content;
+    changes += braceHomePathResult.changes;
+    const homePrefixResult = replaceTracked(transformed, /\$HOME(?=\/|\\)/g, homePrefix);
+    transformed = homePrefixResult.content;
+    changes += homePrefixResult.changes;
+    const braceHomePrefixResult = replaceTracked(transformed, /\$\{HOME\}(?=\/|\\)/g, homePrefix);
+    transformed = braceHomePrefixResult.content;
+    changes += braceHomePrefixResult.changes;
+  }
+  const projectDirPathResult = replaceTracked(transformed, /\$CLAUDE_PROJECT_DIR\/\.claude\//g, claudePath);
+  transformed = projectDirPathResult.content;
+  changes += projectDirPathResult.changes;
+  const quotedProjectDirPath = customGlobalClaudeDir ? `${customGlobalClaudeDir}/` : `"${homePrefix}"/.claude/`;
+  const quotedProjectDirPathResult = replaceTracked(transformed, /"\$CLAUDE_PROJECT_DIR"\/\.claude\//g, quotedProjectDirPath);
+  transformed = quotedProjectDirPathResult.content;
+  changes += quotedProjectDirPathResult.changes;
+  const braceProjectDirPathResult = replaceTracked(transformed, /\$\{CLAUDE_PROJECT_DIR\}\/\.claude\//g, claudePath);
+  transformed = braceProjectDirPathResult.content;
+  changes += braceProjectDirPathResult.changes;
   if (IS_WINDOWS3) {
-    transformed = transformed.replace(/%CLAUDE_PROJECT_DIR%\/\.claude\//g, () => {
-      changes++;
-      return claudePath;
-    });
-  }
-  transformed = transformed.replace(/\.\/\.claude\//g, () => {
-    changes++;
-    return claudePath;
-  });
-  transformed = transformed.replace(/@\.\/\.claude\//g, () => {
-    changes++;
-    return `@${claudePath}`;
-  });
-  transformed = transformed.replace(/@\.claude\//g, () => {
-    changes++;
-    return `@${claudePath}`;
-  });
+    const windowsProjectDirPathResult = replaceTracked(transformed, /%CLAUDE_PROJECT_DIR%\/\.claude\//g, claudePath);
+    transformed = windowsProjectDirPathResult.content;
+    changes += windowsProjectDirPathResult.changes;
+  }
+  const relativeClaudePathResult = replaceTracked(transformed, /\.\/\.claude\//g, claudePath);
+  transformed = relativeClaudePathResult.content;
+  changes += relativeClaudePathResult.changes;
+  const atRelativeClaudePathResult = replaceTracked(transformed, /@\.\/\.claude\//g, `@${claudePath}`);
+  transformed = atRelativeClaudePathResult.content;
+  changes += atRelativeClaudePathResult.changes;
+  const atClaudePathResult = replaceTracked(transformed, /@\.claude\//g, `@${claudePath}`);
+  transformed = atClaudePathResult.content;
+  changes += atClaudePathResult.changes;
   transformed = transformed.replace(/(["'`])\.claude\//g, (_match, quote) => {
     changes++;
     return `${quote}${claudePath}`;
   });
-  transformed = transformed.replace(/\(\.claude\//g, () => {
-    changes++;
-    return `(${claudePath}`;
-  });
-  transformed = transformed.replace(/ \.claude\//g, () => {
-    changes++;
-    return ` ${claudePath}`;
-  });
-  transformed = transformed.replace(/^\.claude\//gm, () => {
-    changes++;
-    return claudePath;
-  });
-  transformed = transformed.replace(/: \.claude\//g, () => {
-    changes++;
-    return `: ${claudePath}`;
-  });
-  transformed = transformed.replace(/:\.claude\//g, () => {
-    changes++;
-    return `:${claudePath}`;
-  });
+  const markdownClaudePathResult = replaceTracked(transformed, /\(\.claude\//g, `(${claudePath}`);
+  transformed = markdownClaudePathResult.content;
+  changes += markdownClaudePathResult.changes;
+  const spacedClaudePathResult = replaceTracked(transformed, / \.claude\//g, ` ${claudePath}`);
+  transformed = spacedClaudePathResult.content;
+  changes += spacedClaudePathResult.changes;
+  const lineStartClaudePathResult = replaceTracked(transformed, /^\.claude\//gm, claudePath);
+  transformed = lineStartClaudePathResult.content;
+  changes += lineStartClaudePathResult.changes;
+  const colonClaudePathResult = replaceTracked(transformed, /: \.claude\//g, `: ${claudePath}`);
+  transformed = colonClaudePathResult.content;
+  changes += colonClaudePathResult.changes;
+  const compactColonClaudePathResult = replaceTracked(transformed, /:\.claude\//g, `:${claudePath}`);
+  transformed = compactColonClaudePathResult.content;
+  changes += compactColonClaudePathResult.changes;
+  if (customGlobalClaudeDir) {
+    const customPatterns = [
+      { pattern: /~\/\.claude\//g, replacement: `${customGlobalClaudeDir}/` },
+      { pattern: /~\/\.claude\b/g, replacement: customGlobalClaudeDir },
+      { pattern: /\$HOME\/\.claude\//g, replacement: `${customGlobalClaudeDir}/` },
+      { pattern: /\$HOME\/\.claude\b/g, replacement: customGlobalClaudeDir },
+      { pattern: /\$\{HOME\}\/\.claude\//g, replacement: `${customGlobalClaudeDir}/` },
+      { pattern: /\$\{HOME\}\/\.claude\b/g, replacement: customGlobalClaudeDir },
+      { pattern: /%USERPROFILE%[\\/]\.claude[\\/]/g, replacement: `${customGlobalClaudeDir}/` },
+      { pattern: /%USERPROFILE%[\\/]\.claude\b/g, replacement: customGlobalClaudeDir },
+      {
+        pattern: /(?:os\.)?homedir\(\)\s*,\s*(["'])\.claude\1/g,
+        replacement: `"${customGlobalClaudeDir}"`
+      },
+      {
+        pattern: /\b(?:homeDir|homedir)\b\s*,\s*(["'])\.claude\1/g,
+        replacement: `"${customGlobalClaudeDir}"`
+      }
+    ];
+    for (const { pattern, replacement } of customPatterns) {
+      const customPatternResult = replaceTracked(transformed, pattern, replacement);
+      transformed = customPatternResult.content;
+      changes += customPatternResult.changes;
+    }
+  }
   return { transformed, changes };
 }
 function shouldTransformFile3(filename) {
@@ -99312,7 +99628,7 @@ async function transformPathsForGlobalInstall(directory, options2 = {}) {
   async function processDirectory2(dir) {
     const entries = await readdir35(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join120(dir, entry.name);
+      const fullPath = join122(dir, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name.startsWith(".") && entry.name !== ".claude") {
           continue;
@@ -99321,7 +99637,9 @@ async function transformPathsForGlobalInstall(directory, options2 = {}) {
       } else if (entry.isFile() && shouldTransformFile3(entry.name)) {
         try {
           const content = await readFile52(fullPath, "utf-8");
-          const { transformed, changes } = transformContent(content);
+          const { transformed, changes } = transformContent(content, {
+            targetClaudeDir: options2.targetClaudeDir
+          });
           if (changes > 0) {
             await writeFile32(fullPath, transformed, "utf-8");
             filesTransformed++;
@@ -99361,6 +99679,7 @@ async function handleTransforms(ctx) {
   if (ctx.options.global) {
     logger.info("Transforming paths for global installation...");
     const transformResult = await transformPathsForGlobalInstall(ctx.extractDir, {
+      targetClaudeDir: ctx.resolvedDir,
       verbose: logger.isVerbose()
     });
     logger.success(`Transformed ${transformResult.totalChanges} path(s) in ${transformResult.filesTransformed} file(s)`);
@@ -99388,7 +99707,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 : join121(ctx.resolvedDir, ".claude");
+  const claudeDir2 = ctx.options.global ? ctx.resolvedDir : join123(ctx.resolvedDir, ".claude");
   return {
     ...ctx,
     foldersConfig,
@@ -99579,8 +99898,8 @@ init_dist2();
 var import_picocolors29 = __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 basename19, join as join122, resolve as resolve29 } from "node:path";
+import { homedir as homedir35 } from "node:os";
+import { basename as basename19, join as join124, resolve as resolve29 } from "node:path";
 init_logger();
 init_agents_discovery();
 init_commands_discovery();
@@ -100005,7 +100324,7 @@ async function executeDeleteAction(action, options2) {
 async function processMetadataDeletions(skillSourcePath, installGlobally) {
   if (!skillSourcePath)
     return;
-  const sourceMetadataPath = join122(resolve29(skillSourcePath, ".."), "metadata.json");
+  const sourceMetadataPath = join124(resolve29(skillSourcePath, ".."), "metadata.json");
   if (!existsSync56(sourceMetadataPath))
     return;
   let sourceMetadata;
@@ -100018,7 +100337,7 @@ async function processMetadataDeletions(skillSourcePath, installGlobally) {
   }
   if (!sourceMetadata.deletions || sourceMetadata.deletions.length === 0)
     return;
-  const claudeDir2 = installGlobally ? join122(homedir31(), ".claude") : join122(process.cwd(), ".claude");
+  const claudeDir2 = installGlobally ? join124(homedir35(), ".claude") : join124(process.cwd(), ".claude");
   if (!existsSync56(claudeDir2))
     return;
   try {
@@ -100173,8 +100492,8 @@ async function migrateCommand(options2) {
     selectedProviders = Array.from(new Set(selectedProviders));
     let installGlobally = options2.global ?? false;
     if (options2.global === undefined && !options2.yes) {
-      const projectTarget = join122(process.cwd(), ".claude");
-      const globalTarget = join122(homedir31(), ".claude");
+      const projectTarget = join124(process.cwd(), ".claude");
+      const globalTarget = join124(homedir35(), ".claude");
       const scopeChoice = await ie({
         message: "Installation scope",
         options: [
@@ -100226,7 +100545,7 @@ async function migrateCommand(options2) {
     }
     const providerNames = selectedProviders.map((prov) => import_picocolors29.default.cyan(providers[prov].displayName)).join(", ");
     f2.message(`  Providers: ${providerNames}`);
-    const targetDir = installGlobally ? join122(homedir31(), ".claude") : join122(process.cwd(), ".claude");
+    const targetDir = installGlobally ? join124(homedir35(), ".claude") : join124(process.cwd(), ".claude");
     f2.message(`  Scope: ${installGlobally ? "Global" : "Project"} ${import_picocolors29.default.dim(`-> ${targetDir}`)}`);
     const cmdProviders = getProvidersSupporting("commands");
     const unsupportedCmd = selectedProviders.filter((pv) => !cmdProviders.includes(pv));
@@ -100722,7 +101041,7 @@ async function handleDirectorySetup(ctx) {
 // src/commands/new/phases/project-creation.ts
 init_config_manager();
 init_github_client();
-import { join as join123 } from "node:path";
+import { join as join125 } from "node:path";
 init_logger();
 init_output_manager();
 init_types3();
@@ -100848,7 +101167,7 @@ async function projectCreation(kit, resolvedDir, validOptions, isNonInteractive2
   output.section("Installing");
   logger.verbose("Installation target", { directory: resolvedDir });
   const merger = new FileMerger;
-  const claudeDir2 = join123(resolvedDir, ".claude");
+  const claudeDir2 = join125(resolvedDir, ".claude");
   merger.setMultiKitContext(claudeDir2, kit);
   if (validOptions.exclude && validOptions.exclude.length > 0) {
     merger.addIgnorePatterns(validOptions.exclude);
@@ -100895,7 +101214,7 @@ async function handleProjectCreation(ctx) {
 }
 // src/commands/new/phases/post-setup.ts
 init_projects_registry();
-import { join as join124 } from "node:path";
+import { join as join126 } from "node:path";
 init_package_installer();
 init_logger();
 init_path_resolver();
@@ -100927,9 +101246,9 @@ async function postSetup(resolvedDir, validOptions, isNonInteractive2, prompts)
       withSudo: validOptions.withSudo
     });
   }
-  const claudeDir2 = join124(resolvedDir, ".claude");
+  const claudeDir2 = join126(resolvedDir, ".claude");
   await promptSetupWizardIfNeeded({
-    envPath: join124(claudeDir2, ".env"),
+    envPath: join126(claudeDir2, ".env"),
     claudeDir: claudeDir2,
     isGlobal: false,
     isNonInteractive: isNonInteractive2,
@@ -100999,7 +101318,7 @@ Please use only one download method.`);
 // src/commands/plan/plan-command.ts
 init_output_manager();
 import { existsSync as existsSync58, statSync as statSync9 } from "node:fs";
-import { dirname as dirname32, join as join126, parse as parse6, resolve as resolve33 } from "node:path";
+import { dirname as dirname33, join as join128, parse as parse6, resolve as resolve33 } from "node:path";
 
 // src/commands/plan/plan-read-handlers.ts
 init_plan_parser();
@@ -101007,7 +101326,7 @@ init_logger();
 init_output_manager();
 var import_picocolors31 = __toESM(require_picocolors(), 1);
 import { existsSync as existsSync57, statSync as statSync8 } from "node:fs";
-import { basename as basename20, dirname as dirname31, join as join125, relative as relative21, resolve as resolve31 } from "node:path";
+import { basename as basename20, dirname as dirname32, join as join127, relative as relative21, resolve as resolve31 } from "node:path";
 async function handleParse(target, options2) {
   const planFile = resolvePlanFile(target);
   if (!planFile) {
@@ -101028,7 +101347,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 : basename20(dirname31(planFile));
+  const title = typeof frontmatter.title === "string" ? frontmatter.title : basename20(dirname32(planFile));
   console.log();
   console.log(import_picocolors31.default.bold(`  Plan: ${title}`));
   console.log(`  File: ${planFile}`);
@@ -101083,7 +101402,7 @@ async function handleValidate(target, options2) {
 }
 async function handleStatus(target, options2) {
   const t = target ? resolve31(target) : null;
-  const plansDir = t && existsSync57(t) && statSync8(t).isDirectory() && !existsSync57(join125(t, "plan.md")) ? t : null;
+  const plansDir = t && existsSync57(t) && statSync8(t).isDirectory() && !existsSync57(join127(t, "plan.md")) ? t : null;
   if (plansDir) {
     const planFiles = scanPlanDir(plansDir);
     if (planFiles.length === 0) {
@@ -101108,14 +101427,14 @@ async function handleStatus(target, options2) {
       try {
         const s = buildPlanSummary(pf);
         const bar = progressBar(s.completed, s.totalPhases);
-        const title2 = s.title ?? basename20(dirname31(pf));
+        const title2 = s.title ?? basename20(dirname32(pf));
         console.log(`  ${import_picocolors31.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: ${basename20(dirname31(pf))}`);
+        console.log(`  [X] Failed to read: ${basename20(dirname32(pf))}`);
         console.log();
       }
     }
@@ -101139,7 +101458,7 @@ async function handleStatus(target, options2) {
     console.log(JSON.stringify(summary, null, 2));
     return;
   }
-  const title = summary.title ?? basename20(dirname31(planFile));
+  const title = summary.title ?? basename20(dirname32(planFile));
   console.log();
   console.log(import_picocolors31.default.bold(`  ${title}`));
   if (summary.status)
@@ -101355,7 +101674,7 @@ function resolvePlanFile(target) {
     const stat19 = statSync9(t);
     if (stat19.isFile())
       return t;
-    const candidate = join126(t, "plan.md");
+    const candidate = join128(t, "plan.md");
     if (existsSync58(candidate))
       return candidate;
   }
@@ -101363,10 +101682,10 @@ function resolvePlanFile(target) {
     let dir = process.cwd();
     const root = parse6(dir).root;
     while (dir !== root) {
-      const candidate = join126(dir, "plan.md");
+      const candidate = join128(dir, "plan.md");
       if (existsSync58(candidate))
         return candidate;
-      dir = dirname32(dir);
+      dir = dirname33(dir);
     }
   }
   return null;
@@ -102391,7 +102710,7 @@ async function detectInstallations() {
 
 // src/commands/uninstall/removal-handler.ts
 import { readdirSync as readdirSync8, rmSync as rmSync6 } from "node:fs";
-import { basename as basename22, join as join128, resolve as resolve35, sep as sep10 } from "node:path";
+import { basename as basename22, join as join130, resolve as resolve35, sep as sep10 } from "node:path";
 init_logger();
 init_safe_prompts();
 init_safe_spinner();
@@ -102400,7 +102719,7 @@ var import_fs_extra41 = __toESM(require_lib(), 1);
 // src/commands/uninstall/analysis-handler.ts
 init_metadata_migration();
 import { readdirSync as readdirSync7, rmSync as rmSync5 } from "node:fs";
-import { dirname as dirname33, join as join127 } from "node:path";
+import { dirname as dirname34, join as join129 } from "node:path";
 init_logger();
 init_safe_prompts();
 var import_fs_extra40 = __toESM(require_lib(), 1);
@@ -102422,7 +102741,7 @@ function classifyFileByOwnership(ownership, forceOverwrite, deleteReason) {
 }
 async function cleanupEmptyDirectories3(filePath, installationRoot) {
   let cleaned = 0;
-  let currentDir = dirname33(filePath);
+  let currentDir = dirname34(filePath);
   while (currentDir !== installationRoot && currentDir.startsWith(installationRoot)) {
     try {
       const entries = readdirSync7(currentDir);
@@ -102430,7 +102749,7 @@ async function cleanupEmptyDirectories3(filePath, installationRoot) {
         rmSync5(currentDir, { recursive: true });
         cleaned++;
         logger.debug(`Removed empty directory: ${currentDir}`);
-        currentDir = dirname33(currentDir);
+        currentDir = dirname34(currentDir);
       } else {
         break;
       }
@@ -102457,7 +102776,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_extra40.pathExists(join127(installation.path, relativePath))) {
+        if (await import_fs_extra40.pathExists(join129(installation.path, relativePath))) {
           result.retainedManifestPaths.push(relativePath);
         }
       }
@@ -102465,7 +102784,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 = join127(installation.path, relativePath);
+      const filePath = join129(installation.path, relativePath);
       if (preservedPaths.has(relativePath)) {
         result.toPreserve.push({ path: relativePath, reason: "shared with other kit" });
         continue;
@@ -102498,7 +102817,7 @@ async function analyzeInstallation(installation, forceOverwrite, kit) {
   }
   for (const trackedFile of allTrackedFiles) {
     const relativePath = normalizeTrackedPath(trackedFile.path);
-    const filePath = join127(installation.path, relativePath);
+    const filePath = join129(installation.path, relativePath);
     const ownershipResult = await OwnershipChecker.checkOwnership(filePath, metadata, installation.path);
     if (!ownershipResult.exists)
       continue;
@@ -102641,7 +102960,7 @@ async function removeInstallations(installations, options2) {
         let removedCount = 0;
         let cleanedDirs = 0;
         for (const item of analysis.toDelete) {
-          const filePath = join128(installation.path, item.path);
+          const filePath = join130(installation.path, item.path);
           if (!await import_fs_extra41.pathExists(filePath))
             continue;
           if (!await isPathSafeToRemove(filePath, installation.path)) {
@@ -102975,7 +103294,7 @@ ${import_picocolors39.default.bold(import_picocolors39.default.cyan(result.kitCo
 init_logger();
 import { existsSync as existsSync65 } from "node:fs";
 import { rm as rm16 } from "node:fs/promises";
-import { join as join135 } from "node:path";
+import { join as join137 } from "node:path";
 var import_picocolors40 = __toESM(require_picocolors(), 1);
 
 // src/commands/watch/phases/implementation-runner.ts
@@ -103494,7 +103813,7 @@ function spawnAndCollect3(command, args) {
 
 // src/commands/watch/phases/issue-processor.ts
 import { mkdir as mkdir33, writeFile as writeFile34 } from "node:fs/promises";
-import { join as join131 } from "node:path";
+import { join as join133 } from "node:path";
 
 // src/commands/watch/phases/approval-detector.ts
 init_logger();
@@ -103872,9 +104191,9 @@ async function checkAwaitingApproval(state, setup, options2, watchLog, projectDi
 
 // src/commands/watch/phases/plan-dir-finder.ts
 import { readdir as readdir37, stat as stat19 } from "node:fs/promises";
-import { join as join130 } from "node:path";
+import { join as join132 } from "node:path";
 async function findRecentPlanDir(cwd2, issueNumber, watchLog) {
-  const plansRoot = join130(cwd2, "plans");
+  const plansRoot = join132(cwd2, "plans");
   try {
     const entries = await readdir37(plansRoot);
     const tenMinAgo = Date.now() - 10 * 60 * 1000;
@@ -103883,14 +104202,14 @@ async function findRecentPlanDir(cwd2, issueNumber, watchLog) {
     for (const entry of entries) {
       if (entry === "watch" || entry === "reports" || entry === "visuals")
         continue;
-      const dirPath = join130(plansRoot, entry);
+      const dirPath = join132(plansRoot, entry);
       const dirStat = await stat19(dirPath);
       if (!dirStat.isDirectory())
         continue;
       if (dirStat.mtimeMs < tenMinAgo)
         continue;
       try {
-        await stat19(join130(dirPath, "plan.md"));
+        await stat19(join132(dirPath, "plan.md"));
       } catch {
         continue;
       }
@@ -104121,13 +104440,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 = join131(detectedPlanDir, "plan.md");
+      state.activeIssues[numStr].planPath = join133(detectedPlanDir, "plan.md");
       watchLog.info(`Plan directory detected: ${detectedPlanDir}`);
     } else {
       try {
-        const planDir = join131(projectDir, "plans", "watch");
+        const planDir = join133(projectDir, "plans", "watch");
         await mkdir33(planDir, { recursive: true });
-        const planFilePath = join131(planDir, `issue-${issue.number}-plan.md`);
+        const planFilePath = join133(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}`);
@@ -104274,7 +104593,7 @@ init_file_io();
 init_logger();
 import { existsSync as existsSync61 } from "node:fs";
 import { mkdir as mkdir34, readFile as readFile55 } from "node:fs/promises";
-import { dirname as dirname34 } from "node:path";
+import { dirname as dirname35 } from "node:path";
 var PROCESSED_ISSUES_CAP = 500;
 async function readCkJson(projectDir) {
   const configPath = CkConfigManager.getProjectConfigPath(projectDir);
@@ -104304,7 +104623,7 @@ async function loadWatchState(projectDir) {
 }
 async function saveWatchState(projectDir, state) {
   const configPath = CkConfigManager.getProjectConfigPath(projectDir);
-  const configDir = dirname34(configPath);
+  const configDir = dirname35(configPath);
   if (!existsSync61(configDir)) {
     await mkdir34(configDir, { recursive: true });
   }
@@ -104434,18 +104753,18 @@ init_logger();
 import { spawnSync as spawnSync6 } from "node:child_process";
 import { existsSync as existsSync62 } from "node:fs";
 import { readdir as readdir38, stat as stat20 } from "node:fs/promises";
-import { join as join132 } from "node:path";
+import { join as join134 } from "node:path";
 async function scanForRepos(parentDir) {
   const repos = [];
   const entries = await readdir38(parentDir);
   for (const entry of entries) {
     if (entry.startsWith("."))
       continue;
-    const fullPath = join132(parentDir, entry);
+    const fullPath = join134(parentDir, entry);
     const entryStat = await stat20(fullPath);
     if (!entryStat.isDirectory())
       continue;
-    const gitDir = join132(fullPath, ".git");
+    const gitDir = join134(fullPath, ".git");
     if (!existsSync62(gitDir))
       continue;
     const result = spawnSync6("gh", ["repo", "view", "--json", "owner,name"], {
@@ -104471,8 +104790,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 join133 } from "node:path";
+import { homedir as homedir36 } from "node:os";
+import { join as join135 } from "node:path";
 async function validateSetup(cwd2) {
   const workDir = cwd2 ?? process.cwd();
   const ghVersion = spawnSync7("gh", ["--version"], { encoding: "utf-8", timeout: 1e4 });
@@ -104503,7 +104822,7 @@ Run this command from a directory with a GitHub remote.`);
   } catch {
     throw new Error(`Failed to parse repository info: ${ghRepo.stdout}`);
   }
-  const skillsPath = join133(homedir32(), ".claude", "skills");
+  const skillsPath = join135(homedir36(), ".claude", "skills");
   const skillsAvailable = existsSync63(skillsPath);
   if (!skillsAvailable) {
     logger.warning(`ClaudeKit Engineer skills not found at ${skillsPath}`);
@@ -104522,7 +104841,7 @@ init_path_resolver();
 import { createWriteStream as createWriteStream3, statSync as statSync10 } from "node:fs";
 import { existsSync as existsSync64 } from "node:fs";
 import { mkdir as mkdir35, rename as rename9 } from "node:fs/promises";
-import { join as join134 } from "node:path";
+import { join as join136 } from "node:path";
 
 class WatchLogger {
   logStream = null;
@@ -104530,7 +104849,7 @@ class WatchLogger {
   logPath = null;
   maxBytes;
   constructor(logDir, maxBytes = 0) {
-    this.logDir = logDir ?? join134(PathResolver.getClaudeKitDir(), "logs");
+    this.logDir = logDir ?? join136(PathResolver.getClaudeKitDir(), "logs");
     this.maxBytes = maxBytes;
   }
   async init() {
@@ -104539,7 +104858,7 @@ class WatchLogger {
         await mkdir35(this.logDir, { recursive: true });
       }
       const dateStr = formatDate(new Date);
-      this.logPath = join134(this.logDir, `watch-${dateStr}.log`);
+      this.logPath = join136(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"}`);
@@ -104721,7 +105040,7 @@ async function watchCommand(options2) {
 }
 async function discoverRepos(options2, watchLog) {
   const cwd2 = process.cwd();
-  const isGitRepo = existsSync65(join135(cwd2, ".git"));
+  const isGitRepo = existsSync65(join137(cwd2, ".git"));
   if (options2.force) {
     await forceRemoveLock(watchLog);
   }
@@ -104979,7 +105298,7 @@ init_logger();
 init_path_resolver();
 init_types3();
 import { existsSync as existsSync76, readFileSync as readFileSync19 } from "node:fs";
-import { join as join146 } from "node:path";
+import { join as join148 } from "node:path";
 var packageVersion = package_default.version;
 function formatInstalledKits(metadata) {
   if (!metadata.kits || Object.keys(metadata.kits).length === 0) {
@@ -105011,9 +105330,9 @@ async function displayVersion() {
   let localKitVersion = null;
   let isGlobalOnlyKit = false;
   const globalKitDir = PathResolver.getGlobalKitDir();
-  const globalMetadataPath = join146(globalKitDir, "metadata.json");
+  const globalMetadataPath = join148(globalKitDir, "metadata.json");
   const prefix = PathResolver.getPathPrefix(false);
-  const localMetadataPath = prefix ? join146(process.cwd(), prefix, "metadata.json") : join146(process.cwd(), "metadata.json");
+  const localMetadataPath = prefix ? join148(process.cwd(), prefix, "metadata.json") : join148(process.cwd(), "metadata.json");
   const isLocalSameAsGlobal = localMetadataPath === globalMetadataPath;
   if (!isLocalSameAsGlobal && existsSync76(localMetadataPath)) {
     try {