claudekit-cli 3.22.0 → 3.23.0

package/dist/index.js

@@ -12606,7 +12606,7 @@ var require_get_stream = __commonJS((exports, module) => {
     };
     const { maxBuffer } = options;
     let stream;
-    await new Promise((resolve6, reject) => {
+    await new Promise((resolve5, reject) => {
       const rejectPromise = (error) => {
         if (error && stream.getBufferedLength() <= BufferConstants.MAX_LENGTH) {
           error.bufferedData = stream.getBufferedValue();
@@ -12618,7 +12618,7 @@ var require_get_stream = __commonJS((exports, module) => {
           rejectPromise(error);
           return;
         }
-        resolve6();
+        resolve5();
       });
       stream.on("data", () => {
         if (stream.getBufferedLength() > maxBuffer) {
@@ -13979,7 +13979,7 @@ var require_extract_zip = __commonJS((exports, module) => {
       debug("opening", this.zipPath, "with opts", this.opts);
       this.zipfile = await openZip(this.zipPath, { lazyEntries: true });
       this.canceled = false;
-      return new Promise((resolve6, reject) => {
+      return new Promise((resolve5, reject) => {
         this.zipfile.on("error", (err) => {
           this.canceled = true;
           reject(err);
@@ -13988,7 +13988,7 @@ var require_extract_zip = __commonJS((exports, module) => {
         this.zipfile.on("close", () => {
           if (!this.canceled) {
             debug("zip extraction complete");
-            resolve6();
+            resolve5();
           }
         });
         this.zipfile.on("entry", async (entry) => {
@@ -16592,7 +16592,7 @@ function getPagerArgs(pagerCmd) {
   return [];
 }
 async function trySystemPager(content) {
-  return new Promise((resolve11) => {
+  return new Promise((resolve10) => {
     const pagerCmd = process.env.PAGER || "less";
     const pagerArgs = getPagerArgs(pagerCmd);
     try {
@@ -16602,20 +16602,20 @@ async function trySystemPager(content) {
       });
       const timeout = setTimeout(() => {
         pager.kill();
-        resolve11(false);
+        resolve10(false);
       }, 30000);
       pager.stdin.write(content);
       pager.stdin.end();
       pager.on("close", (code2) => {
         clearTimeout(timeout);
-        resolve11(code2 === 0);
+        resolve10(code2 === 0);
       });
       pager.on("error", () => {
         clearTimeout(timeout);
-        resolve11(false);
+        resolve10(false);
       });
     } catch {
-      resolve11(false);
+      resolve10(false);
     }
   });
 }
@@ -16642,16 +16642,16 @@ async function basicPager(content) {
       break;
     }
     const remaining = lines.length - currentLine;
-    await new Promise((resolve11) => {
+    await new Promise((resolve10) => {
       rl.question(`-- More (${remaining} lines) [Enter/q] --`, (answer) => {
         if (answer.toLowerCase() === "q") {
           rl.close();
           process.exitCode = 0;
-          resolve11();
+          resolve10();
           return;
         }
         process.stdout.write("\x1B[1A\x1B[2K");
-        resolve11();
+        resolve10();
       });
     });
   }
@@ -18507,6 +18507,20 @@ class PathResolver {
   static isWSL() {
     return isWSL();
   }
+  static isAtHomeDirectory(cwd) {
+    const currentDir = normalize(cwd || process.cwd());
+    const homeDir = normalize(homedir());
+    return currentDir === homeDir;
+  }
+  static getLocalClaudeDir(baseDir) {
+    const dir = baseDir || process.cwd();
+    return join(dir, ".claude");
+  }
+  static isLocalSameAsGlobal(cwd) {
+    const localPath = normalize(PathResolver.getLocalClaudeDir(cwd));
+    const globalPath = normalize(PathResolver.getGlobalKitDir());
+    return localPath === globalPath;
+  }
 }
 
 // src/shared/skip-directories.ts
@@ -18621,7 +18635,8 @@ async function getClaudeKitSetup(projectDir = process.cwd()) {
     setup.global.components = await scanClaudeKitDirectory(globalDir);
   }
   const projectClaudeDir = join2(projectDir, ".claude");
-  if (await import_fs_extra.pathExists(projectClaudeDir)) {
+  const isLocalSameAsGlobal = projectClaudeDir === globalDir;
+  if (!isLocalSameAsGlobal && await import_fs_extra.pathExists(projectClaudeDir)) {
     setup.project.path = projectClaudeDir;
     setup.project.metadata = await readClaudeKitMetadata(join2(projectClaudeDir, "metadata.json"));
     setup.project.components = await scanClaudeKitDirectory(projectClaudeDir);
@@ -22383,11 +22398,15 @@ function getInstalledKits(metadata) {
     return Object.keys(metadata.kits);
   }
   const nameToCheck = metadata.name || "";
+  const kits = [];
   if (/\bengineer\b/i.test(nameToCheck)) {
-    return ["engineer"];
+    kits.push("engineer");
   }
   if (/\bmarketing\b/i.test(nameToCheck)) {
-    return ["marketing"];
+    kits.push("marketing");
+  }
+  if (kits.length > 0) {
+    return kits;
   }
   if (metadata.version) {
     return ["engineer"];
@@ -24815,6 +24834,28 @@ class PromptsManager {
   async promptDirectorySelection(global2 = false) {
     return promptDirectorySelection(global2);
   }
+  async selectScope() {
+    const options = [
+      {
+        value: "global",
+        label: "Install globally",
+        hint: "Continue installing to ~/.claude/"
+      },
+      {
+        value: "different",
+        label: "Use a different directory",
+        hint: "Cancel and run from a project directory"
+      }
+    ];
+    const selected = await ie({
+      message: "What would you like to do?",
+      options
+    });
+    if (lD(selected)) {
+      return "cancel";
+    }
+    return selected;
+  }
 }
 
 // src/commands/init/init-command.ts
@@ -24864,18 +24905,18 @@ init_types2();
 
 // src/commands/init/phases/conflict-handler.ts
 init_logger();
-import { join as join27, resolve as resolve4 } from "node:path";
+import { join as join27 } from "node:path";
 var import_fs_extra3 = __toESM(require_lib(), 1);
 async function handleConflicts(ctx) {
   if (ctx.cancelled)
     return ctx;
   if (!ctx.options.global)
     return ctx;
-  const globalKitDir = PathResolver.getGlobalKitDir();
-  const cwdResolved = resolve4(process.cwd());
-  const isInGlobalDir = cwdResolved === globalKitDir || cwdResolved === resolve4(globalKitDir, "..");
+  if (PathResolver.isLocalSameAsGlobal()) {
+    return ctx;
+  }
   const localSettingsPath = join27(process.cwd(), ".claude", "settings.json");
-  if (isInGlobalDir || !await import_fs_extra3.pathExists(localSettingsPath)) {
+  if (!await import_fs_extra3.pathExists(localSettingsPath)) {
     return ctx;
   }
   if (ctx.isNonInteractive) {
@@ -26503,11 +26544,11 @@ init_types2();
 
 // src/domains/installation/utils/path-security.ts
 init_types2();
-import { relative as relative3, resolve as resolve5 } from "node:path";
+import { relative as relative3, resolve as resolve4 } from "node:path";
 var MAX_EXTRACTION_SIZE = 500 * 1024 * 1024;
 function isPathSafe(basePath, targetPath) {
-  const resolvedBase = resolve5(basePath);
-  const resolvedTarget = resolve5(targetPath);
+  const resolvedBase = resolve4(basePath);
+  const resolvedTarget = resolve4(targetPath);
   const relativePath = relative3(resolvedBase, resolvedTarget);
   return !relativePath.startsWith("..") && !relativePath.startsWith("/") && resolvedTarget.startsWith(resolvedBase);
 }
@@ -27244,10 +27285,10 @@ class Minipass extends EventEmitter2 {
     return this[ENCODING] ? buf.join("") : Buffer.concat(buf, buf.dataLength);
   }
   async promise() {
-    return new Promise((resolve6, reject) => {
+    return new Promise((resolve5, reject) => {
       this.on(DESTROYED, () => reject(new Error("stream destroyed")));
       this.on("error", (er) => reject(er));
-      this.on("end", () => resolve6());
+      this.on("end", () => resolve5());
     });
   }
   [Symbol.asyncIterator]() {
@@ -27266,7 +27307,7 @@ class Minipass extends EventEmitter2 {
         return Promise.resolve({ done: false, value: res });
       if (this[EOF])
         return stop();
-      let resolve6;
+      let resolve5;
       let reject;
       const onerr = (er) => {
         this.off("data", ondata);
@@ -27280,19 +27321,19 @@ class Minipass extends EventEmitter2 {
         this.off("end", onend);
         this.off(DESTROYED, ondestroy);
         this.pause();
-        resolve6({ value, done: !!this[EOF] });
+        resolve5({ value, done: !!this[EOF] });
       };
       const onend = () => {
         this.off("error", onerr);
         this.off("data", ondata);
         this.off(DESTROYED, ondestroy);
         stop();
-        resolve6({ done: true, value: undefined });
+        resolve5({ done: true, value: undefined });
       };
       const ondestroy = () => onerr(new Error("stream destroyed"));
       return new Promise((res2, rej) => {
         reject = rej;
-        resolve6 = res2;
+        resolve5 = res2;
         this.once(DESTROYED, ondestroy);
         this.once("error", onerr);
         this.once("end", onend);
@@ -28398,10 +28439,10 @@ class Minipass2 extends EventEmitter3 {
     return this[ENCODING2] ? buf.join("") : Buffer.concat(buf, buf.dataLength);
   }
   async promise() {
-    return new Promise((resolve6, reject) => {
+    return new Promise((resolve5, reject) => {
       this.on(DESTROYED2, () => reject(new Error("stream destroyed")));
       this.on("error", (er) => reject(er));
-      this.on("end", () => resolve6());
+      this.on("end", () => resolve5());
     });
   }
   [Symbol.asyncIterator]() {
@@ -28420,7 +28461,7 @@ class Minipass2 extends EventEmitter3 {
         return Promise.resolve({ done: false, value: res });
       if (this[EOF2])
         return stop();
-      let resolve6;
+      let resolve5;
       let reject;
       const onerr = (er) => {
         this.off("data", ondata);
@@ -28434,19 +28475,19 @@ class Minipass2 extends EventEmitter3 {
         this.off("end", onend);
         this.off(DESTROYED2, ondestroy);
         this.pause();
-        resolve6({ value, done: !!this[EOF2] });
+        resolve5({ value, done: !!this[EOF2] });
       };
       const onend = () => {
         this.off("error", onerr);
         this.off("data", ondata);
         this.off(DESTROYED2, ondestroy);
         stop();
-        resolve6({ done: true, value: undefined });
+        resolve5({ done: true, value: undefined });
       };
       const ondestroy = () => onerr(new Error("stream destroyed"));
       return new Promise((res2, rej) => {
         reject = rej;
-        resolve6 = res2;
+        resolve5 = res2;
         this.once(DESTROYED2, ondestroy);
         this.once("error", onerr);
         this.once("end", onend);
@@ -29874,10 +29915,10 @@ class Minipass3 extends EventEmitter4 {
     return this[ENCODING3] ? buf.join("") : Buffer.concat(buf, buf.dataLength);
   }
   async promise() {
-    return new Promise((resolve6, reject) => {
+    return new Promise((resolve5, reject) => {
       this.on(DESTROYED3, () => reject(new Error("stream destroyed")));
       this.on("error", (er) => reject(er));
-      this.on("end", () => resolve6());
+      this.on("end", () => resolve5());
     });
   }
   [Symbol.asyncIterator]() {
@@ -29896,7 +29937,7 @@ class Minipass3 extends EventEmitter4 {
         return Promise.resolve({ done: false, value: res });
       if (this[EOF3])
         return stop();
-      let resolve6;
+      let resolve5;
       let reject;
       const onerr = (er) => {
         this.off("data", ondata);
@@ -29910,19 +29951,19 @@ class Minipass3 extends EventEmitter4 {
         this.off("end", onend);
         this.off(DESTROYED3, ondestroy);
         this.pause();
-        resolve6({ value, done: !!this[EOF3] });
+        resolve5({ value, done: !!this[EOF3] });
       };
       const onend = () => {
         this.off("error", onerr);
         this.off("data", ondata);
         this.off(DESTROYED3, ondestroy);
         stop();
-        resolve6({ done: true, value: undefined });
+        resolve5({ done: true, value: undefined });
       };
       const ondestroy = () => onerr(new Error("stream destroyed"));
       return new Promise((res2, rej) => {
         reject = rej;
-        resolve6 = res2;
+        resolve5 = res2;
         this.once(DESTROYED3, ondestroy);
         this.once("error", onerr);
         this.once("end", onend);
@@ -30693,9 +30734,9 @@ var listFile = (opt, _files) => {
   const parse3 = new Parser(opt);
   const readSize = opt.maxReadSize || 16 * 1024 * 1024;
   const file = opt.file;
-  const p = new Promise((resolve6, reject) => {
+  const p = new Promise((resolve5, reject) => {
     parse3.on("error", reject);
-    parse3.on("end", resolve6);
+    parse3.on("end", resolve5);
     fs4.stat(file, (er, stat3) => {
       if (er) {
         reject(er);
@@ -33275,9 +33316,9 @@ var extractFile = (opt, _3) => {
   const u = new Unpack(opt);
   const readSize = opt.maxReadSize || 16 * 1024 * 1024;
   const file = opt.file;
-  const p = new Promise((resolve6, reject) => {
+  const p = new Promise((resolve5, reject) => {
     u.on("error", reject);
-    u.on("close", resolve6);
+    u.on("close", resolve5);
     fs11.stat(file, (er, stat3) => {
       if (er) {
         reject(er);
@@ -33410,7 +33451,7 @@ var replaceAsync = (opt, files) => {
     };
     fs12.read(fd, headBuf, 0, 512, position, onread);
   };
-  const promise = new Promise((resolve6, reject) => {
+  const promise = new Promise((resolve5, reject) => {
     p.on("error", reject);
     let flag = "r+";
     const onopen = (er, fd) => {
@@ -33435,7 +33476,7 @@ var replaceAsync = (opt, files) => {
           });
           p.pipe(stream);
           stream.on("error", reject);
-          stream.on("close", resolve6);
+          stream.on("close", resolve5);
           addFilesAsync2(p, files);
         });
       });
@@ -33709,20 +33750,20 @@ class ZipExtractor {
     if (!isMacOS()) {
       return false;
     }
-    return new Promise((resolve6) => {
+    return new Promise((resolve5) => {
       mkdir13(destDir, { recursive: true }).then(() => {
         execFile2("unzip", ["-o", "-q", archivePath, "-d", destDir], (error, _stdout, stderr) => {
           if (error) {
             logger.debug(`Native unzip failed: ${stderr || error.message}`);
-            resolve6(false);
+            resolve5(false);
             return;
           }
           logger.debug("Native unzip succeeded");
-          resolve6(true);
+          resolve5(true);
         });
       }).catch((err) => {
         logger.debug(`Failed to create directory for native unzip: ${err.message}`);
-        resolve6(false);
+        resolve5(false);
       });
     });
   }
@@ -34230,7 +34271,7 @@ async function handleDownload(ctx) {
   };
 }
 // src/commands/init/phases/merge-handler.ts
-import { join as join49 } from "node:path";
+import { join as join50 } from "node:path";
 
 // src/domains/installation/file-merger.ts
 init_logger();
@@ -36167,9 +36208,6 @@ class InstalledSettingsTracker {
   }
 }
 
-// src/domains/config/merger/merge-engine.ts
-init_logger();
-
 // src/domains/config/merger/diff-calculator.ts
 function truncateCommand(cmd, maxLen = 50) {
   if (cmd.length <= maxLen)
@@ -36368,12 +36406,61 @@ function mergeHooks(sourceHooks, destHooks, result, options) {
   const merged = { ...destHooks };
   const installedHooks = options?.installedSettings?.hooks ?? [];
   const sourceKit = options?.sourceKit;
+  const sourceCommands = new Set;
+  for (const entries of Object.values(sourceHooks)) {
+    extractCommands(entries, sourceCommands);
+  }
   for (const [eventName, sourceEntries] of Object.entries(sourceHooks)) {
     const destEntries = destHooks[eventName] || [];
     merged[eventName] = mergeHookEntries(sourceEntries, destEntries, eventName, result, installedHooks, sourceKit);
   }
+  if (installedHooks.length > 0) {
+    const deprecatedHooks = installedHooks.filter((hook) => !sourceCommands.has(normalizeCommand(hook)));
+    if (deprecatedHooks.length > 0) {
+      result.removedHooks = result.removedHooks ?? [];
+      for (const [eventName, entries] of Object.entries(merged)) {
+        const filtered = removeDeprecatedFromEntries(entries, deprecatedHooks, result);
+        if (filtered.length > 0) {
+          merged[eventName] = filtered;
+        } else {
+          delete merged[eventName];
+        }
+      }
+    }
+  }
   return merged;
 }
+function removeDeprecatedFromEntries(entries, deprecatedHooks, result) {
+  const deprecatedSet = new Set(deprecatedHooks.map((h2) => normalizeCommand(h2)));
+  const filtered = [];
+  for (const entry of entries) {
+    if ("hooks" in entry && entry.hooks) {
+      const remainingHooks = entry.hooks.filter((h2) => {
+        if (h2.command && deprecatedSet.has(normalizeCommand(h2.command))) {
+          result.hooksRemoved++;
+          result.removedHooks?.push(h2.command);
+          logger.info(`Removed deprecated hook: ${h2.command.slice(0, 60)}...`);
+          return false;
+        }
+        return true;
+      });
+      if (remainingHooks.length > 0) {
+        filtered.push({ ...entry, hooks: remainingHooks });
+      }
+    } else if ("command" in entry) {
+      if (deprecatedSet.has(normalizeCommand(entry.command))) {
+        result.hooksRemoved++;
+        result.removedHooks?.push(entry.command);
+        logger.info(`Removed deprecated hook: ${entry.command.slice(0, 60)}...`);
+      } else {
+        filtered.push(entry);
+      }
+    } else {
+      filtered.push(entry);
+    }
+  }
+  return filtered;
+}
 function mergeMcp(sourceMcp, destMcp, result, options) {
   if (!sourceMcp)
     return destMcp;
@@ -36450,6 +36537,24 @@ function mergeMcp(sourceMcp, destMcp, result, options) {
       }
     }
   }
+  if (installedServers.length > 0 && merged.servers) {
+    const sourceServerNames = new Set(Object.keys(sourceMcp.servers || {}));
+    const deprecatedServers = installedServers.filter((server) => !sourceServerNames.has(server));
+    if (deprecatedServers.length > 0) {
+      result.removedMcpServers = result.removedMcpServers ?? [];
+      for (const serverName of deprecatedServers) {
+        if (serverName in merged.servers) {
+          delete merged.servers[serverName];
+          result.mcpServersRemoved++;
+          result.removedMcpServers.push(serverName);
+          logger.info(`Removed deprecated MCP server: ${serverName}`);
+        }
+      }
+      if (merged.servers && Object.keys(merged.servers).length === 0) {
+        merged.servers = undefined;
+      }
+    }
+  }
   for (const key of Object.keys(sourceMcp)) {
     if (key !== "servers" && !(key in merged)) {
       merged[key] = sourceMcp[key];
@@ -36463,8 +36568,10 @@ function mergeSettings(source, destination, options) {
     hooksAdded: 0,
     hooksPreserved: 0,
     hooksSkipped: 0,
+    hooksRemoved: 0,
     mcpServersPreserved: 0,
     mcpServersSkipped: 0,
+    mcpServersRemoved: 0,
     conflictsDetected: [],
     newlyInstalledHooks: [],
     newlyInstalledServers: [],
@@ -37352,6 +37459,8 @@ class LegacyMigration {
     for (const entry of entries) {
       if (entry === "metadata.json")
         continue;
+      if (SKIP_DIRS_ALL.includes(entry))
+        continue;
       const fullPath = join44(dir, entry);
       let stats;
       try {
@@ -37578,7 +37687,7 @@ function buildConflictSummary(fileConflicts, hookConflicts, mcpConflicts) {
 }
 
 // src/services/file-operations/file-scanner.ts
-import { join as join45, relative as relative8, resolve as resolve7 } from "node:path";
+import { join as join45, relative as relative8, resolve as resolve6 } from "node:path";
 init_logger();
 var import_fs_extra12 = __toESM(require_lib(), 1);
 
@@ -37660,8 +37769,8 @@ class FileScanner2 {
     return customFiles;
   }
   static isSafePath(basePath, targetPath) {
-    const resolvedBase = resolve7(basePath);
-    const resolvedTarget = resolve7(targetPath);
+    const resolvedBase = resolve6(basePath);
+    const resolvedTarget = resolve6(targetPath);
     return resolvedTarget.startsWith(resolvedBase);
   }
   static toPosixPath(path11) {
@@ -37672,8 +37781,113 @@ class FileScanner2 {
 // src/services/transformers/commands-prefix/prefix-applier.ts
 init_logger();
 var import_fs_extra13 = __toESM(require_lib(), 1);
-import { lstat as lstat5, mkdir as mkdir16, readdir as readdir11, stat as stat8 } from "node:fs/promises";
+import { lstat as lstat5, mkdir as mkdir16, readdir as readdir12, stat as stat8 } from "node:fs/promises";
+import { join as join47 } from "node:path";
+
+// src/services/transformers/commands-prefix/content-transformer.ts
+init_logger();
+import { readFile as readFile17, readdir as readdir11, writeFile as writeFile14 } from "node:fs/promises";
 import { join as join46 } from "node:path";
+var TRANSFORMABLE_EXTENSIONS = new Set([
+  ".md",
+  ".txt",
+  ".json",
+  ".yaml",
+  ".yml",
+  ".ts",
+  ".js",
+  ".mjs",
+  ".cjs",
+  ".py"
+]);
+var COMMAND_ROOTS = [
+  "plan",
+  "fix",
+  "code",
+  "review",
+  "cook",
+  "brainstorm",
+  "integrate",
+  "bootstrap",
+  "worktree",
+  "scout",
+  "test",
+  "debug",
+  "preview",
+  "kanban",
+  "journal",
+  "watzup"
+];
+function buildCommandPatterns() {
+  const patterns = [];
+  for (const cmd of COMMAND_ROOTS) {
+    patterns.push({
+      regex: new RegExp(`(?<![\\w:])(\\/)${cmd}(:)`, "g"),
+      replacement: "$1ck:$2".replace("$2", `${cmd}:`)
+    });
+    patterns.push({
+      regex: new RegExp(`(?<![\\w:])(\\/)${cmd}(?=[\\s\`"'\\)\\]}>.,;:!?]|$)`, "g"),
+      replacement: `$1ck:${cmd}`
+    });
+  }
+  return patterns;
+}
+function transformCommandContent(content) {
+  let changes = 0;
+  let transformed = content;
+  const patterns = buildCommandPatterns();
+  for (const { regex: regex2, replacement } of patterns) {
+    regex2.lastIndex = 0;
+    const matches = transformed.match(regex2);
+    if (matches) {
+      changes += matches.length;
+      regex2.lastIndex = 0;
+      transformed = transformed.replace(regex2, replacement);
+    }
+  }
+  return { transformed, changes };
+}
+function shouldTransformFile(filename) {
+  const ext2 = filename.toLowerCase().slice(filename.lastIndexOf("."));
+  return TRANSFORMABLE_EXTENSIONS.has(ext2);
+}
+async function transformCommandReferences(directory, options = {}) {
+  let filesTransformed = 0;
+  let totalReplacements = 0;
+  async function processDirectory(dir) {
+    const entries = await readdir11(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join46(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (entry.name === "node_modules" || entry.name.startsWith(".") && entry.name !== ".claude") {
+          continue;
+        }
+        await processDirectory(fullPath);
+      } else if (entry.isFile() && shouldTransformFile(entry.name)) {
+        try {
+          const content = await readFile17(fullPath, "utf-8");
+          const { transformed, changes } = transformCommandContent(content);
+          if (changes > 0) {
+            if (options.dryRun) {
+              logger.debug(`[dry-run] Would transform ${changes} command ref(s) in ${fullPath}`);
+            } else {
+              await writeFile14(fullPath, transformed, "utf-8");
+              if (options.verbose) {
+                logger.verbose(`Transformed ${changes} command ref(s) in ${fullPath}`);
+              }
+            }
+            filesTransformed++;
+            totalReplacements += changes;
+          }
+        } catch (error) {
+          logger.debug(`Skipped ${fullPath}: ${error instanceof Error ? error.message : "unknown"}`);
+        }
+      }
+    }
+  }
+  await processDirectory(directory);
+  return { filesTransformed, totalReplacements };
+}
 
 // src/services/transformers/commands-prefix/prefix-utils.ts
 init_logger();
@@ -37718,22 +37932,22 @@ function shouldApplyPrefix(options) {
 // src/services/transformers/commands-prefix/prefix-applier.ts
 async function applyPrefix(extractDir) {
   validatePath(extractDir, "extractDir");
-  const commandsDir = join46(extractDir, ".claude", "commands");
+  const commandsDir = join47(extractDir, ".claude", "commands");
   if (!await import_fs_extra13.pathExists(commandsDir)) {
     logger.verbose("No commands directory found, skipping prefix application");
     return;
   }
   logger.info("Applying /ck: prefix to slash commands...");
-  const backupDir = join46(extractDir, ".commands-backup");
-  const tempDir = join46(extractDir, ".commands-prefix-temp");
+  const backupDir = join47(extractDir, ".commands-backup");
+  const tempDir = join47(extractDir, ".commands-prefix-temp");
   try {
-    const entries = await readdir11(commandsDir);
+    const entries = await readdir12(commandsDir);
     if (entries.length === 0) {
       logger.verbose("Commands directory is empty, skipping prefix application");
       return;
     }
     if (entries.length === 1 && entries[0] === "ck") {
-      const ckDir2 = join46(commandsDir, "ck");
+      const ckDir2 = join47(commandsDir, "ck");
       const ckStat = await stat8(ckDir2);
       if (ckStat.isDirectory()) {
         logger.verbose("Commands already have /ck: prefix, skipping");
@@ -37743,17 +37957,17 @@ async function applyPrefix(extractDir) {
     await import_fs_extra13.copy(commandsDir, backupDir);
     logger.verbose("Created backup of commands directory");
     await mkdir16(tempDir, { recursive: true });
-    const ckDir = join46(tempDir, "ck");
+    const ckDir = join47(tempDir, "ck");
     await mkdir16(ckDir, { recursive: true });
     let processedCount = 0;
     for (const entry of entries) {
-      const sourcePath = join46(commandsDir, entry);
+      const sourcePath = join47(commandsDir, entry);
       const stats = await lstat5(sourcePath);
       if (stats.isSymbolicLink()) {
         logger.warning(`Skipping symlink for security: ${entry}`);
         continue;
       }
-      const destPath = join46(ckDir, entry);
+      const destPath = join47(ckDir, entry);
       await import_fs_extra13.copy(sourcePath, destPath, {
         overwrite: false,
         errorOnExist: true
@@ -37770,7 +37984,17 @@ async function applyPrefix(extractDir) {
     await import_fs_extra13.remove(commandsDir);
     await import_fs_extra13.move(tempDir, commandsDir);
     await import_fs_extra13.remove(backupDir);
-    logger.success("Successfully applied /ck: prefix to all commands");
+    logger.success("Successfully reorganized commands to /ck: prefix");
+    const claudeDir = join47(extractDir, ".claude");
+    logger.info("Transforming command references in file contents...");
+    const transformResult = await transformCommandReferences(claudeDir, {
+      verbose: logger.isVerbose()
+    });
+    if (transformResult.totalReplacements > 0) {
+      logger.success(`Transformed ${transformResult.totalReplacements} command ref(s) in ${transformResult.filesTransformed} file(s)`);
+    } else {
+      logger.verbose("No command references needed transformation");
+    }
   } catch (error) {
     if (await import_fs_extra13.pathExists(backupDir)) {
       try {
@@ -37797,21 +38021,21 @@ async function applyPrefix(extractDir) {
 }
 
 // src/services/transformers/commands-prefix/prefix-cleaner.ts
-import { lstat as lstat7, readdir as readdir13 } from "node:fs/promises";
-import { join as join48 } from "node:path";
+import { lstat as lstat7, readdir as readdir14 } from "node:fs/promises";
+import { join as join49 } from "node:path";
 init_logger();
 var import_fs_extra15 = __toESM(require_lib(), 1);
 
 // src/services/transformers/commands-prefix/file-processor.ts
-import { lstat as lstat6, readdir as readdir12 } from "node:fs/promises";
-import { join as join47 } from "node:path";
+import { lstat as lstat6, readdir as readdir13 } from "node:fs/promises";
+import { join as join48 } from "node:path";
 init_logger();
 var import_fs_extra14 = __toESM(require_lib(), 1);
 async function scanDirectoryFiles(dir) {
   const files = [];
-  const entries = await readdir12(dir);
+  const entries = await readdir13(dir);
   for (const entry of entries) {
-    const fullPath = join47(dir, entry);
+    const fullPath = join48(dir, entry);
     const stats = await lstat6(fullPath);
     if (stats.isSymbolicLink()) {
       continue;
@@ -37919,8 +38143,8 @@ function logCleanupSummary(deletedCount, preservedCount, dryRun, results) {
 async function cleanupCommandsDirectory(targetDir, isGlobal, options = {}) {
   const { dryRun = false } = options;
   validatePath(targetDir, "targetDir");
-  const claudeDir = isGlobal ? targetDir : join48(targetDir, ".claude");
-  const commandsDir = join48(claudeDir, "commands");
+  const claudeDir = isGlobal ? targetDir : join49(targetDir, ".claude");
+  const commandsDir = join49(claudeDir, "commands");
   const accumulator = {
     results: [],
     deletedCount: 0,
@@ -37948,13 +38172,13 @@ async function cleanupCommandsDirectory(targetDir, isGlobal, options = {}) {
     logger.verbose("All existing files will be preserved as user-owned");
     return result;
   }
-  const entries = await readdir13(commandsDir);
+  const entries = await readdir14(commandsDir);
   if (entries.length === 0) {
     logger.verbose("Commands directory is empty");
     return result;
   }
   for (const entry of entries) {
-    const entryPath = join48(commandsDir, entry);
+    const entryPath = join49(commandsDir, entry);
     const stats = await lstat7(entryPath);
     if (stats.isSymbolicLink()) {
       addSymlinkSkip(entry, accumulator);
@@ -38006,7 +38230,7 @@ async function handleMerge(ctx) {
   let customClaudeFiles = [];
   if (!ctx.options.fresh) {
     logger.info("Scanning for custom .claude files...");
-    const scanSourceDir = ctx.options.global ? join49(ctx.extractDir, ".claude") : ctx.extractDir;
+    const scanSourceDir = ctx.options.global ? join50(ctx.extractDir, ".claude") : ctx.extractDir;
     const scanTargetSubdir = ctx.options.global ? "" : ".claude";
     customClaudeFiles = await FileScanner2.findCustomFiles(ctx.resolvedDir, scanSourceDir, scanTargetSubdir);
   } else {
@@ -38070,7 +38294,7 @@ async function handleMerge(ctx) {
       return { ...ctx, cancelled: true };
     }
   }
-  const sourceDir = ctx.options.global ? join49(ctx.extractDir, ".claude") : ctx.extractDir;
+  const sourceDir = ctx.options.global ? join50(ctx.extractDir, ".claude") : ctx.extractDir;
   await merger.merge(sourceDir, ctx.resolvedDir, ctx.isNonInteractive);
   const fileConflicts = merger.getFileConflicts();
   if (fileConflicts.length > 0 && !ctx.isNonInteractive) {
@@ -38099,7 +38323,7 @@ async function handleMerge(ctx) {
   };
 }
 // src/commands/init/phases/migration-handler.ts
-import { join as join57 } from "node:path";
+import { join as join58 } from "node:path";
 
 // src/domains/skills/skills-detector.ts
 init_logger();
@@ -38110,11 +38334,11 @@ init_logger();
 
 // src/domains/skills/skills-manifest.ts
 init_logger();
+import { createHash as createHash2 } from "node:crypto";
+import { readFile as readFile18, readdir as readdir15, writeFile as writeFile15 } from "node:fs/promises";
+import { join as join51, relative as relative9 } from "node:path";
 init_types2();
 var import_fs_extra17 = __toESM(require_lib(), 1);
-import { createHash as createHash2 } from "node:crypto";
-import { readFile as readFile17, readdir as readdir14, writeFile as writeFile14 } from "node:fs/promises";
-import { join as join50, relative as relative9 } from "node:path";
 
 class SkillsManifestManager {
   static MANIFEST_FILENAME = ".skills-manifest.json";
@@ -38136,18 +38360,18 @@ class SkillsManifestManager {
     return manifest;
   }
   static async writeManifest(skillsDir, manifest) {
-    const manifestPath = join50(skillsDir, SkillsManifestManager.MANIFEST_FILENAME);
-    await writeFile14(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
+    const manifestPath = join51(skillsDir, SkillsManifestManager.MANIFEST_FILENAME);
+    await writeFile15(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
     logger.debug(`Wrote manifest to: ${manifestPath}`);
   }
   static async readManifest(skillsDir) {
-    const manifestPath = join50(skillsDir, SkillsManifestManager.MANIFEST_FILENAME);
+    const manifestPath = join51(skillsDir, SkillsManifestManager.MANIFEST_FILENAME);
     if (!await import_fs_extra17.pathExists(manifestPath)) {
       logger.debug(`No manifest found at: ${manifestPath}`);
       return null;
     }
     try {
-      const content = await readFile17(manifestPath, "utf-8");
+      const content = await readFile18(manifestPath, "utf-8");
       const data = JSON.parse(content);
       const manifest = SkillsManifestSchema.parse(data);
       logger.debug(`Read manifest from: ${manifestPath}`);
@@ -38158,14 +38382,14 @@ class SkillsManifestManager {
     }
   }
   static async detectStructure(skillsDir) {
-    const entries = await readdir14(skillsDir, { withFileTypes: true });
-    const dirs = entries.filter((entry) => entry.isDirectory() && entry.name !== "node_modules" && !entry.name.startsWith("."));
+    const entries = await readdir15(skillsDir, { withFileTypes: true });
+    const dirs = entries.filter((entry) => entry.isDirectory() && !BUILD_ARTIFACT_DIRS.includes(entry.name) && !entry.name.startsWith("."));
     if (dirs.length === 0) {
       return "flat";
     }
     for (const dir of dirs.slice(0, 3)) {
-      const dirPath = join50(skillsDir, dir.name);
-      const subEntries = await readdir14(dirPath, { withFileTypes: true });
+      const dirPath = join51(skillsDir, dir.name);
+      const subEntries = await readdir15(dirPath, { withFileTypes: true });
       const hasSubdirs = subEntries.some((entry) => entry.isDirectory());
       if (hasSubdirs) {
         return "categorized";
@@ -38180,10 +38404,10 @@ class SkillsManifestManager {
   static async scanSkills(skillsDir, structure) {
     const skills = [];
     if (structure === "flat") {
-      const entries = await readdir14(skillsDir, { withFileTypes: true });
+      const entries = await readdir15(skillsDir, { withFileTypes: true });
       for (const entry of entries) {
-        if (entry.isDirectory() && entry.name !== "node_modules" && !entry.name.startsWith(".")) {
-          const skillPath = join50(skillsDir, entry.name);
+        if (entry.isDirectory() && !BUILD_ARTIFACT_DIRS.includes(entry.name) && !entry.name.startsWith(".")) {
+          const skillPath = join51(skillsDir, entry.name);
           const hash = await SkillsManifestManager.hashDirectory(skillPath);
           skills.push({
             name: entry.name,
@@ -38192,14 +38416,14 @@ class SkillsManifestManager {
         }
       }
     } else {
-      const categories = await readdir14(skillsDir, { withFileTypes: true });
+      const categories = await readdir15(skillsDir, { withFileTypes: true });
       for (const category of categories) {
-        if (category.isDirectory() && category.name !== "node_modules" && !category.name.startsWith(".")) {
-          const categoryPath = join50(skillsDir, category.name);
-          const skillEntries = await readdir14(categoryPath, { withFileTypes: true });
+        if (category.isDirectory() && !BUILD_ARTIFACT_DIRS.includes(category.name) && !category.name.startsWith(".")) {
+          const categoryPath = join51(skillsDir, category.name);
+          const skillEntries = await readdir15(categoryPath, { withFileTypes: true });
           for (const skillEntry of skillEntries) {
             if (skillEntry.isDirectory() && !skillEntry.name.startsWith(".")) {
-              const skillPath = join50(categoryPath, skillEntry.name);
+              const skillPath = join51(categoryPath, skillEntry.name);
               const hash = await SkillsManifestManager.hashDirectory(skillPath);
               skills.push({
                 name: skillEntry.name,
@@ -38219,7 +38443,7 @@ class SkillsManifestManager {
     files.sort();
     for (const file of files) {
       const relativePath = relative9(dirPath, file);
-      const content = await readFile17(file);
+      const content = await readFile18(file);
       hash.update(relativePath);
       hash.update(content);
     }
@@ -38227,10 +38451,10 @@ class SkillsManifestManager {
   }
   static async getAllFiles(dirPath) {
     const files = [];
-    const entries = await readdir14(dirPath, { withFileTypes: true });
+    const entries = await readdir15(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join50(dirPath, entry.name);
-      if (entry.name.startsWith(".") || entry.name === "node_modules") {
+      const fullPath = join51(dirPath, entry.name);
+      if (entry.name.startsWith(".") || BUILD_ARTIFACT_DIRS.includes(entry.name)) {
         continue;
       }
       if (entry.isDirectory()) {
@@ -38350,13 +38574,13 @@ function getPathMapping(skillName, oldBasePath, newBasePath) {
 
 // src/domains/skills/detection/script-detector.ts
 var import_fs_extra18 = __toESM(require_lib(), 1);
-import { readdir as readdir15 } from "node:fs/promises";
-import { join as join51 } from "node:path";
+import { readdir as readdir16 } from "node:fs/promises";
+import { join as join52 } from "node:path";
 async function scanDirectory(skillsDir) {
   if (!await import_fs_extra18.pathExists(skillsDir)) {
     return ["flat", []];
   }
-  const entries = await readdir15(skillsDir, { withFileTypes: true });
+  const entries = await readdir16(skillsDir, { withFileTypes: true });
   const dirs = entries.filter((entry) => entry.isDirectory() && entry.name !== "node_modules" && !entry.name.startsWith("."));
   if (dirs.length === 0) {
     return ["flat", []];
@@ -38364,13 +38588,13 @@ async function scanDirectory(skillsDir) {
   let totalSkillLikeCount = 0;
   const allSkills = [];
   for (const dir of dirs) {
-    const dirPath = join51(skillsDir, dir.name);
-    const subEntries = await readdir15(dirPath, { withFileTypes: true });
+    const dirPath = join52(skillsDir, dir.name);
+    const subEntries = await readdir16(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 = join51(dirPath, subdir.name);
-        const subdirFiles = await readdir15(subdirPath, { withFileTypes: true });
+        const subdirPath = join52(dirPath, subdir.name);
+        const subdirFiles = await readdir16(subdirPath, { withFileTypes: true });
         const hasSkillMarker = subdirFiles.some((file) => file.isFile() && (file.name === "skill.md" || file.name === "README.md" || file.name === "readme.md" || file.name === "config.json" || file.name === "package.json"));
         if (hasSkillMarker) {
           totalSkillLikeCount++;
@@ -38526,12 +38750,12 @@ class SkillsMigrationDetector {
 // src/domains/skills/skills-migrator.ts
 init_logger();
 init_types2();
-import { join as join56 } from "node:path";
+import { join as join57 } from "node:path";
 
 // src/domains/skills/migrator/migration-executor.ts
 init_logger();
-import { copyFile as copyFile4, mkdir as mkdir17, readdir as readdir16, rm as rm3 } from "node:fs/promises";
-import { join as join52 } from "node:path";
+import { copyFile as copyFile4, mkdir as mkdir17, readdir as readdir17, rm as rm3 } from "node:fs/promises";
+import { join as join53 } from "node:path";
 var import_fs_extra20 = __toESM(require_lib(), 1);
 
 // src/domains/skills/skills-migration-prompts.ts
@@ -38694,10 +38918,10 @@ Detected changes:`;
 // src/domains/skills/migrator/migration-executor.ts
 async function copySkillDirectory(sourceDir, destDir) {
   await mkdir17(destDir, { recursive: true });
-  const entries = await readdir16(sourceDir, { withFileTypes: true });
+  const entries = await readdir17(sourceDir, { withFileTypes: true });
   for (const entry of entries) {
-    const sourcePath = join52(sourceDir, entry.name);
-    const destPath = join52(destDir, entry.name);
+    const sourcePath = join53(sourceDir, entry.name);
+    const destPath = join53(destDir, entry.name);
     if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.isSymbolicLink()) {
       continue;
     }
@@ -38712,7 +38936,7 @@ async function executeInternal(mappings, customizations, currentSkillsDir, inter
   const migrated = [];
   const preserved = [];
   const errors2 = [];
-  const tempDir = join52(currentSkillsDir, "..", ".skills-migration-temp");
+  const tempDir = join53(currentSkillsDir, "..", ".skills-migration-temp");
   await mkdir17(tempDir, { recursive: true });
   try {
     for (const mapping of mappings) {
@@ -38733,9 +38957,9 @@ async function executeInternal(mappings, customizations, currentSkillsDir, inter
           }
         }
         const category = mapping.category;
-        const targetPath = category ? join52(tempDir, category, skillName) : join52(tempDir, skillName);
+        const targetPath = category ? join53(tempDir, category, skillName) : join53(tempDir, skillName);
         if (category) {
-          await mkdir17(join52(tempDir, category), { recursive: true });
+          await mkdir17(join53(tempDir, category), { recursive: true });
         }
         await copySkillDirectory(currentSkillPath, targetPath);
         migrated.push(skillName);
@@ -38801,8 +39025,8 @@ function validateMigrationPath(path11, paramName) {
 init_logger();
 init_types2();
 var import_fs_extra21 = __toESM(require_lib(), 1);
-import { copyFile as copyFile5, mkdir as mkdir18, readdir as readdir17, rm as rm4, stat as stat9 } from "node:fs/promises";
-import { basename as basename2, join as join53, normalize as normalize6 } from "node:path";
+import { copyFile as copyFile5, mkdir as mkdir18, readdir as readdir18, rm as rm4, stat as stat9 } from "node:fs/promises";
+import { basename as basename2, join as join54, normalize as normalize6 } from "node:path";
 function validatePath2(path11, paramName) {
   if (!path11 || typeof path11 !== "string") {
     throw new SkillsMigrationError(`${paramName} must be a non-empty string`);
@@ -38828,7 +39052,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 ? join53(parentDir, backupDirName) : join53(skillsDir, "..", backupDirName);
+    const backupDir = parentDir ? join54(parentDir, backupDirName) : join54(skillsDir, "..", backupDirName);
     logger.info(`Creating backup at: ${backupDir}`);
     try {
       await mkdir18(backupDir, { recursive: true });
@@ -38878,8 +39102,8 @@ class SkillsBackupManager {
       return [];
     }
     try {
-      const entries = await readdir17(parentDir, { withFileTypes: true });
-      const backups = entries.filter((entry) => entry.isDirectory() && entry.name.startsWith(SkillsBackupManager.BACKUP_PREFIX)).map((entry) => join53(parentDir, entry.name));
+      const entries = await readdir18(parentDir, { withFileTypes: true });
+      const backups = entries.filter((entry) => entry.isDirectory() && entry.name.startsWith(SkillsBackupManager.BACKUP_PREFIX)).map((entry) => join54(parentDir, entry.name));
       backups.sort().reverse();
       return backups;
     } catch (error) {
@@ -38905,10 +39129,10 @@ class SkillsBackupManager {
     return await SkillsBackupManager.getDirectorySize(backupDir);
   }
   static async copyDirectory(sourceDir, destDir) {
-    const entries = await readdir17(sourceDir, { withFileTypes: true });
+    const entries = await readdir18(sourceDir, { withFileTypes: true });
     for (const entry of entries) {
-      const sourcePath = join53(sourceDir, entry.name);
-      const destPath = join53(destDir, entry.name);
+      const sourcePath = join54(sourceDir, entry.name);
+      const destPath = join54(destDir, entry.name);
       if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.isSymbolicLink()) {
         continue;
       }
@@ -38922,9 +39146,9 @@ class SkillsBackupManager {
   }
   static async getDirectorySize(dirPath) {
     let size = 0;
-    const entries = await readdir17(dirPath, { withFileTypes: true });
+    const entries = await readdir18(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join53(dirPath, entry.name);
+      const fullPath = join54(dirPath, entry.name);
       if (entry.isSymbolicLink()) {
         continue;
       }
@@ -38958,14 +39182,14 @@ import { relative as relative11 } from "node:path";
 // src/domains/skills/customization/hash-calculator.ts
 import { createHash as createHash3 } from "node:crypto";
 import { createReadStream as createReadStream2 } from "node:fs";
-import { readFile as readFile18, readdir as readdir18 } from "node:fs/promises";
-import { join as join54, relative as relative10 } from "node:path";
+import { readFile as readFile19, readdir as readdir19 } from "node:fs/promises";
+import { join as join55, relative as relative10 } from "node:path";
 async function getAllFiles(dirPath) {
   const files = [];
-  const entries = await readdir18(dirPath, { withFileTypes: true });
+  const entries = await readdir19(dirPath, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = join54(dirPath, entry.name);
-    if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.isSymbolicLink()) {
+    const fullPath = join55(dirPath, entry.name);
+    if (entry.name.startsWith(".") || BUILD_ARTIFACT_DIRS.includes(entry.name) || entry.isSymbolicLink()) {
       continue;
     }
     if (entry.isDirectory()) {
@@ -38978,12 +39202,12 @@ async function getAllFiles(dirPath) {
   return files;
 }
 async function hashFile(filePath) {
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve7, reject) => {
     const hash = createHash3("sha256");
     const stream = createReadStream2(filePath);
     stream.on("data", (chunk) => hash.update(chunk));
     stream.on("end", () => {
-      resolve8(hash.digest("hex"));
+      resolve7(hash.digest("hex"));
     });
     stream.on("error", (error) => {
       stream.destroy();
@@ -38997,7 +39221,7 @@ async function hashDirectory(dirPath) {
   files.sort();
   for (const file of files) {
     const relativePath = relative10(dirPath, file);
-    const content = await readFile18(file);
+    const content = await readFile19(file);
     hash.update(relativePath);
     hash.update(content);
   }
@@ -39090,8 +39314,8 @@ async function detectFileChanges(currentSkillPath, baselineSkillPath) {
 // src/domains/skills/customization/scan-reporter.ts
 init_types2();
 var import_fs_extra23 = __toESM(require_lib(), 1);
-import { readdir as readdir19 } from "node:fs/promises";
-import { join as join55, normalize as normalize7 } from "node:path";
+import { readdir as readdir20 } from "node:fs/promises";
+import { join as join56, normalize as normalize7 } from "node:path";
 function validatePath3(path11, paramName) {
   if (!path11 || typeof path11 !== "string") {
     throw new SkillsMigrationError(`${paramName} must be a non-empty string`);
@@ -39107,19 +39331,19 @@ async function scanSkillsDirectory(skillsDir) {
   if (!await import_fs_extra23.pathExists(skillsDir)) {
     return ["flat", []];
   }
-  const entries = await readdir19(skillsDir, { withFileTypes: true });
+  const entries = await readdir20(skillsDir, { withFileTypes: true });
   const dirs = entries.filter((entry) => entry.isDirectory() && entry.name !== "node_modules" && !entry.name.startsWith("."));
   if (dirs.length === 0) {
     return ["flat", []];
   }
-  const firstDirPath = join55(skillsDir, dirs[0].name);
-  const subEntries = await readdir19(firstDirPath, { withFileTypes: true });
+  const firstDirPath = join56(skillsDir, dirs[0].name);
+  const subEntries = await readdir20(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 = join55(firstDirPath, subdir.name);
-      const subdirFiles = await readdir19(subdirPath, { withFileTypes: true });
+      const subdirPath = join56(firstDirPath, subdir.name);
+      const subdirFiles = await readdir20(subdirPath, { withFileTypes: true });
       const hasSkillMarker = subdirFiles.some((file) => file.isFile() && (file.name === "skill.md" || file.name === "README.md" || file.name === "readme.md" || file.name === "config.json" || file.name === "package.json"));
       if (hasSkillMarker) {
         skillLikeCount++;
@@ -39128,8 +39352,8 @@ async function scanSkillsDirectory(skillsDir) {
     if (skillLikeCount > 0) {
       const skills = [];
       for (const dir of dirs) {
-        const categoryPath = join55(skillsDir, dir.name);
-        const skillDirs = await readdir19(categoryPath, { withFileTypes: true });
+        const categoryPath = join56(skillsDir, dir.name);
+        const skillDirs = await readdir20(categoryPath, { withFileTypes: true });
         skills.push(...skillDirs.filter((entry) => entry.isDirectory() && !entry.name.startsWith(".")).map((entry) => entry.name));
       }
       return ["categorized", skills];
@@ -39138,17 +39362,17 @@ async function scanSkillsDirectory(skillsDir) {
   return ["flat", dirs.map((dir) => dir.name)];
 }
 async function findSkillPath(skillsDir, skillName) {
-  const flatPath = join55(skillsDir, skillName);
+  const flatPath = join56(skillsDir, skillName);
   if (await import_fs_extra23.pathExists(flatPath)) {
     return { path: flatPath, category: undefined };
   }
-  const entries = await readdir19(skillsDir, { withFileTypes: true });
+  const entries = await readdir20(skillsDir, { withFileTypes: true });
   for (const entry of entries) {
     if (!entry.isDirectory() || entry.name.startsWith(".") || entry.name === "node_modules") {
       continue;
     }
-    const categoryPath = join55(skillsDir, entry.name);
-    const skillPath = join55(categoryPath, skillName);
+    const categoryPath = join56(skillsDir, entry.name);
+    const skillPath = join56(categoryPath, skillName);
     if (await import_fs_extra23.pathExists(skillPath)) {
       return { path: skillPath, category: entry.name };
     }
@@ -39242,7 +39466,7 @@ class SkillsMigrator {
         }
       }
       if (options.backup && !options.dryRun) {
-        const claudeDir = join56(currentSkillsDir, "..");
+        const claudeDir = join57(currentSkillsDir, "..");
         result.backupPath = await SkillsBackupManager.createBackup(currentSkillsDir, claudeDir);
         logger.success(`Backup created at: ${result.backupPath}`);
       }
@@ -39302,7 +39526,7 @@ async function handleMigration(ctx) {
     logger.debug("Skipping skills migration (fresh installation)");
     return ctx;
   }
-  const newSkillsDir = join57(ctx.extractDir, ".claude", "skills");
+  const newSkillsDir = join58(ctx.extractDir, ".claude", "skills");
   const currentSkillsDir = PathResolver.buildSkillsPath(ctx.resolvedDir, ctx.options.global);
   if (!await import_fs_extra24.pathExists(newSkillsDir) || !await import_fs_extra24.pathExists(currentSkillsDir)) {
     return ctx;
@@ -39327,10 +39551,10 @@ async function handleMigration(ctx) {
 // src/domains/config/config-manager.ts
 init_logger();
 import { existsSync as existsSync18 } from "node:fs";
-import { mkdir as mkdir19, readFile as readFile19, rename as rename2, rm as rm5, writeFile as writeFile15 } from "node:fs/promises";
+import { mkdir as mkdir19, readFile as readFile20, rename as rename2, rm as rm5, writeFile as writeFile16 } from "node:fs/promises";
 import { chmod as chmod2 } from "node:fs/promises";
 import { platform as platform10 } from "node:os";
-import { join as join58 } from "node:path";
+import { join as join59 } from "node:path";
 init_types2();
 var PROJECT_CONFIG_FILE = ".ck.json";
 
@@ -39338,7 +39562,7 @@ class ConfigManager {
   static config = null;
   static globalFlag = false;
   static getProjectConfigDir(projectDir, global3) {
-    return global3 ? projectDir : join58(projectDir, ".claude");
+    return global3 ? projectDir : join59(projectDir, ".claude");
   }
   static setGlobalFlag(global3) {
     ConfigManager.globalFlag = global3;
@@ -39354,7 +39578,7 @@ class ConfigManager {
     const configFile = PathResolver.getConfigFile(ConfigManager.globalFlag);
     try {
       if (existsSync18(configFile)) {
-        const content = await readFile19(configFile, "utf-8");
+        const content = await readFile20(configFile, "utf-8");
         const data = JSON.parse(content);
         ConfigManager.config = ConfigSchema.parse(data);
         logger.debug(`Config loaded from ${configFile}`);
@@ -39377,7 +39601,7 @@ class ConfigManager {
           await chmod2(configDir, 448);
         }
       }
-      await writeFile15(configFile, JSON.stringify(validConfig, null, 2), "utf-8");
+      await writeFile16(configFile, JSON.stringify(validConfig, null, 2), "utf-8");
       if (platform10() !== "win32") {
         await chmod2(configFile, 384);
       }
@@ -39405,10 +39629,10 @@ class ConfigManager {
   }
   static async loadProjectConfig(projectDir, global3 = false) {
     const configDir = ConfigManager.getProjectConfigDir(projectDir, global3);
-    const configPath = join58(configDir, PROJECT_CONFIG_FILE);
+    const configPath = join59(configDir, PROJECT_CONFIG_FILE);
     try {
       if (existsSync18(configPath)) {
-        const content = await readFile19(configPath, "utf-8");
+        const content = await readFile20(configPath, "utf-8");
         const data = JSON.parse(content);
         const folders = FoldersConfigSchema.parse(data.paths || data);
         logger.debug(`Project config loaded from ${configPath}`);
@@ -39421,7 +39645,7 @@ class ConfigManager {
   }
   static async saveProjectConfig(projectDir, folders, global3 = false) {
     const configDir = ConfigManager.getProjectConfigDir(projectDir, global3);
-    const configPath = join58(configDir, PROJECT_CONFIG_FILE);
+    const configPath = join59(configDir, PROJECT_CONFIG_FILE);
     try {
       if (!existsSync18(configDir)) {
         await mkdir19(configDir, { recursive: true });
@@ -39429,7 +39653,7 @@ class ConfigManager {
       let existingConfig = {};
       if (existsSync18(configPath)) {
         try {
-          const content = await readFile19(configPath, "utf-8");
+          const content = await readFile20(configPath, "utf-8");
           existingConfig = JSON.parse(content);
         } catch (error) {
           logger.debug(`Could not parse existing config, starting fresh: ${error instanceof Error ? error.message : "Unknown error"}`);
@@ -39444,7 +39668,7 @@ class ConfigManager {
           ...validFolders
         }
       };
-      await writeFile15(configPath, JSON.stringify(mergedConfig, null, 2), "utf-8");
+      await writeFile16(configPath, JSON.stringify(mergedConfig, null, 2), "utf-8");
       logger.debug(`Project config saved to ${configPath}`);
     } catch (error) {
       throw new Error(`Failed to save project config: ${error instanceof Error ? error.message : "Unknown error"}`);
@@ -39470,11 +39694,11 @@ class ConfigManager {
   }
   static projectConfigExists(projectDir, global3 = false) {
     const configDir = ConfigManager.getProjectConfigDir(projectDir, global3);
-    return existsSync18(join58(configDir, PROJECT_CONFIG_FILE));
+    return existsSync18(join59(configDir, PROJECT_CONFIG_FILE));
   }
   static async migrateNestedConfig(globalDir) {
-    const correctPath = join58(globalDir, PROJECT_CONFIG_FILE);
-    const incorrectPath = join58(globalDir, ".claude", PROJECT_CONFIG_FILE);
+    const correctPath = join59(globalDir, PROJECT_CONFIG_FILE);
+    const incorrectPath = join59(globalDir, ".claude", PROJECT_CONFIG_FILE);
     if (existsSync18(correctPath)) {
       logger.debug("Config already exists at correct location, skipping migration");
       return false;
@@ -39484,7 +39708,7 @@ class ConfigManager {
         logger.info("Migrating .ck.json from nested location to correct location...");
         await rename2(incorrectPath, correctPath);
         logger.success(`Migrated ${PROJECT_CONFIG_FILE} to ${correctPath}`);
-        const nestedClaudeDir = join58(globalDir, ".claude");
+        const nestedClaudeDir = join59(globalDir, ".claude");
         try {
           await rm5(nestedClaudeDir, { recursive: false });
           logger.debug("Removed empty nested .claude directory");
@@ -39575,14 +39799,14 @@ Please use only one download method.`);
   };
 }
 // src/commands/init/phases/post-install-handler.ts
-import { join as join61 } from "node:path";
+import { join as join62 } from "node:path";
 
 // src/domains/installation/setup-wizard.ts
-import { join as join60 } from "node:path";
+import { join as join61 } from "node:path";
 
 // src/domains/config/config-generator.ts
 var import_fs_extra25 = __toESM(require_lib(), 1);
-import { join as join59 } from "node:path";
+import { join as join60 } from "node:path";
 async function generateEnvFile(targetDir, values) {
   const lines = [
     "# Generated by ClaudeKit CLI setup wizard",
@@ -39624,7 +39848,7 @@ async function generateEnvFile(targetDir, values) {
   for (const [key, value] of otherValues) {
     lines.push(`${key}=${value}`);
   }
-  const envPath = join59(targetDir, ".env");
+  const envPath = join60(targetDir, ".env");
   await import_fs_extra25.writeFile(envPath, `${lines.join(`
 `)}
 `, { mode: 384 });
@@ -39698,7 +39922,7 @@ async function parseEnvFile(path11) {
   }
 }
 async function checkGlobalConfig() {
-  const globalEnvPath = join60(PathResolver.getGlobalKitDir(), ".env");
+  const globalEnvPath = join61(PathResolver.getGlobalKitDir(), ".env");
   if (!await import_fs_extra26.pathExists(globalEnvPath))
     return false;
   const env2 = await parseEnvFile(globalEnvPath);
@@ -39714,7 +39938,7 @@ async function runSetupWizard(options) {
   let globalEnv = {};
   const hasGlobalConfig = !isGlobal && await checkGlobalConfig();
   if (!isGlobal) {
-    const globalEnvPath = join60(PathResolver.getGlobalKitDir(), ".env");
+    const globalEnvPath = join61(PathResolver.getGlobalKitDir(), ".env");
     if (await import_fs_extra26.pathExists(globalEnvPath)) {
       globalEnv = await parseEnvFile(globalEnvPath);
     }
@@ -39777,7 +40001,7 @@ async function runSetupWizard(options) {
     }
   }
   await generateEnvFile(targetDir, values);
-  f2.success(`Configuration saved to ${join60(targetDir, ".env")}`);
+  f2.success(`Configuration saved to ${join61(targetDir, ".env")}`);
   return true;
 }
 async function promptForAdditionalGeminiKeys(primaryKey) {
@@ -39833,8 +40057,8 @@ async function handlePostInstall(ctx) {
     return ctx;
   }
   if (ctx.options.global) {
-    const claudeMdSource = join61(ctx.extractDir, "CLAUDE.md");
-    const claudeMdDest = join61(ctx.resolvedDir, "CLAUDE.md");
+    const claudeMdSource = join62(ctx.extractDir, "CLAUDE.md");
+    const claudeMdDest = join62(ctx.resolvedDir, "CLAUDE.md");
     if (await import_fs_extra27.pathExists(claudeMdSource)) {
       if (!await import_fs_extra27.pathExists(claudeMdDest)) {
         await import_fs_extra27.copy(claudeMdSource, claudeMdDest);
@@ -39881,7 +40105,7 @@ async function handlePostInstall(ctx) {
     }
   }
   if (!ctx.options.skipSetup && !ctx.isNonInteractive) {
-    const envPath = join61(ctx.claudeDir, ".env");
+    const envPath = join62(ctx.claudeDir, ".env");
     if (!await import_fs_extra27.pathExists(envPath)) {
       const shouldSetup = await ctx.prompts.confirm("Set up API keys now? (Gemini API key for ai-multimodal skill, optional webhooks)");
       if (shouldSetup) {
@@ -39903,7 +40127,7 @@ Optional: DISCORD_WEBHOOK_URL, TELEGRAM_BOT_TOKEN`, "Configuration skipped");
 }
 // src/commands/init/phases/selection-handler.ts
 import { mkdir as mkdir20 } from "node:fs/promises";
-import { join as join63, resolve as resolve8 } from "node:path";
+import { join as join64, resolve as resolve7 } from "node:path";
 
 // src/domains/github/kit-access-checker.ts
 init_logger();
@@ -39932,7 +40156,7 @@ async function detectAccessibleKits() {
 
 // src/domains/installation/fresh-installer.ts
 init_logger();
-import { join as join62 } from "node:path";
+import { join as join63 } from "node:path";
 var import_fs_extra28 = __toESM(require_lib(), 1);
 var CLAUDEKIT_SUBDIRECTORIES = ["commands", "agents", "skills", "workflows", "hooks"];
 async function handleFreshInstallation(claudeDir, prompts) {
@@ -39951,7 +40175,7 @@ async function handleFreshInstallation(claudeDir, prompts) {
     const { rmSync } = await import("node:fs");
     let removedCount = 0;
     for (const subdir of CLAUDEKIT_SUBDIRECTORIES) {
-      const subdirPath = join62(claudeDir, subdir);
+      const subdirPath = join63(claudeDir, subdir);
       if (await import_fs_extra28.pathExists(subdirPath)) {
         rmSync(subdirPath, { recursive: true, force: true });
         removedCount++;
@@ -40111,8 +40335,28 @@ async function handleSelection(ctx) {
       }
     }
   }
-  const resolvedDir = resolve8(targetDir);
+  const resolvedDir = resolve7(targetDir);
   logger.info(`Target directory: ${resolvedDir}`);
+  if (!ctx.options.global && PathResolver.isLocalSameAsGlobal(resolvedDir)) {
+    logger.warning("You're at HOME directory. Installing here modifies your GLOBAL ClaudeKit.");
+    if (!ctx.isNonInteractive) {
+      const choice = await ctx.prompts.selectScope();
+      if (choice === "cancel") {
+        return { ...ctx, cancelled: true };
+      }
+      if (choice === "global") {
+        logger.info("Proceeding with global installation");
+      }
+      if (choice === "different") {
+        logger.info("Please run 'ck init' from a project directory instead.");
+        return { ...ctx, cancelled: true };
+      }
+    } else {
+      logger.error("Cannot use local installation at HOME directory.");
+      logger.info("Use -g/--global flag or run from a project directory.");
+      return { ...ctx, cancelled: true };
+    }
+  }
   if (!await import_fs_extra29.pathExists(resolvedDir)) {
     if (ctx.options.global) {
       await mkdir20(resolvedDir, { recursive: true });
@@ -40125,7 +40369,7 @@ async function handleSelection(ctx) {
   }
   if (!ctx.options.fresh) {
     const prefix = PathResolver.getPathPrefix(ctx.options.global);
-    const claudeDir = prefix ? join63(resolvedDir, prefix) : resolvedDir;
+    const claudeDir = prefix ? join64(resolvedDir, prefix) : resolvedDir;
     try {
       const existingMetadata = await readManifest(claudeDir);
       if (existingMetadata?.kits) {
@@ -40157,7 +40401,7 @@ async function handleSelection(ctx) {
   }
   if (ctx.options.fresh) {
     const prefix = PathResolver.getPathPrefix(ctx.options.global);
-    const claudeDir = prefix ? join63(resolvedDir, prefix) : resolvedDir;
+    const claudeDir = prefix ? join64(resolvedDir, prefix) : resolvedDir;
     const canProceed = await handleFreshInstallation(claudeDir, ctx.prompts);
     if (!canProceed) {
       return { ...ctx, cancelled: true };
@@ -40175,7 +40419,7 @@ async function handleSelection(ctx) {
     logger.info("Fetching available versions...");
     let currentVersion = null;
     try {
-      const metadataPath = ctx.options.global ? join63(PathResolver.getGlobalKitDir(), "metadata.json") : join63(resolvedDir, ".claude", "metadata.json");
+      const metadataPath = ctx.options.global ? join64(PathResolver.getGlobalKitDir(), "metadata.json") : join64(resolvedDir, ".claude", "metadata.json");
       const metadata = await readClaudeKitMetadata(metadataPath);
       currentVersion = metadata?.version || null;
       if (currentVersion) {
@@ -40243,8 +40487,8 @@ async function handleSelection(ctx) {
   };
 }
 // src/commands/init/phases/sync-handler.ts
-import { copyFile as copyFile6, mkdir as mkdir21, open, rename as rename3, stat as stat10, unlink as unlink7, writeFile as writeFile17 } from "node:fs/promises";
-import { dirname as dirname9, join as join64, resolve as resolve9 } from "node:path";
+import { copyFile as copyFile6, mkdir as mkdir21, open, rename as rename3, stat as stat10, unlink as unlink7, writeFile as writeFile18 } from "node:fs/promises";
+import { dirname as dirname9, join as join65, resolve as resolve8 } from "node:path";
 init_logger();
 var import_fs_extra30 = __toESM(require_lib(), 1);
 var import_picocolors19 = __toESM(require_picocolors(), 1);
@@ -40252,14 +40496,14 @@ async function handleSync(ctx) {
   if (!ctx.options.sync) {
     return ctx;
   }
-  const resolvedDir = ctx.options.global ? PathResolver.getGlobalKitDir() : resolve9(ctx.options.dir || ".");
-  const claudeDir = ctx.options.global ? resolvedDir : join64(resolvedDir, ".claude");
+  const resolvedDir = ctx.options.global ? PathResolver.getGlobalKitDir() : resolve8(ctx.options.dir || ".");
+  const claudeDir = ctx.options.global ? resolvedDir : join65(resolvedDir, ".claude");
   if (!await import_fs_extra30.pathExists(claudeDir)) {
     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 = join64(claudeDir, "metadata.json");
+  const metadataPath = join65(claudeDir, "metadata.json");
   if (!await import_fs_extra30.pathExists(metadataPath)) {
     logger.error("Cannot sync: no metadata.json found");
     ctx.prompts.note(`Your installation may be from an older version.
@@ -40359,7 +40603,7 @@ function getLockTimeout() {
 var STALE_LOCK_THRESHOLD_MS = 5 * 60 * 1000;
 async function acquireSyncLock(global3) {
   const cacheDir = PathResolver.getCacheDir(global3);
-  const lockPath = join64(cacheDir, ".sync-lock");
+  const lockPath = join65(cacheDir, ".sync-lock");
   const startTime = Date.now();
   const lockTimeout = getLockTimeout();
   await mkdir21(dirname9(lockPath), { recursive: true });
@@ -40386,7 +40630,7 @@ async function acquireSyncLock(global3) {
           }
           logger.debug(`Lock stat failed: ${statError}`);
         }
-        await new Promise((resolve10) => setTimeout(resolve10, 100));
+        await new Promise((resolve9) => setTimeout(resolve9, 100));
         continue;
       }
       throw err;
@@ -40405,7 +40649,7 @@ async function executeSyncMerge(ctx) {
   const releaseLock = await acquireSyncLock(ctx.options.global);
   try {
     const trackedFiles = ctx.syncTrackedFiles;
-    const upstreamDir = ctx.options.global ? join64(ctx.extractDir, ".claude") : ctx.extractDir;
+    const upstreamDir = ctx.options.global ? join65(ctx.extractDir, ".claude") : ctx.extractDir;
     logger.info("Analyzing file changes...");
     const plan = await SyncEngine.createSyncPlan(trackedFiles, ctx.claudeDir, upstreamDir);
     displaySyncPlan(plan);
@@ -40424,7 +40668,7 @@ async function executeSyncMerge(ctx) {
         try {
           const sourcePath = await validateSyncPath(upstreamDir, file.path);
           const targetPath = await validateSyncPath(ctx.claudeDir, file.path);
-          const targetDir = join64(targetPath, "..");
+          const targetDir = join65(targetPath, "..");
           try {
             await mkdir21(targetDir, { recursive: true });
           } catch (mkdirError) {
@@ -40505,7 +40749,7 @@ async function executeSyncMerge(ctx) {
         try {
           const tempPath = `${currentPath}.tmp.${Date.now()}`;
           try {
-            await writeFile17(tempPath, result.result, "utf-8");
+            await writeFile18(tempPath, result.result, "utf-8");
             await rename3(tempPath, currentPath);
           } catch (atomicError) {
             await unlink7(tempPath).catch(() => {});
@@ -40595,7 +40839,7 @@ async function createBackup(claudeDir, files, backupDir) {
       const sourcePath = await validateSyncPath(claudeDir, file.path);
       if (await import_fs_extra30.pathExists(sourcePath)) {
         const targetPath = await validateSyncPath(backupDir, file.path);
-        const targetDir = join64(targetPath, "..");
+        const targetDir = join65(targetPath, "..");
         await mkdir21(targetDir, { recursive: true });
         await copyFile6(sourcePath, targetPath);
       }
@@ -40609,7 +40853,7 @@ async function createBackup(claudeDir, files, backupDir) {
   }
 }
 // src/commands/init/phases/transform-handler.ts
-import { join as join68 } from "node:path";
+import { join as join69 } from "node:path";
 
 // src/services/transformers/folder-path-transformer.ts
 init_logger();
@@ -40620,38 +40864,38 @@ init_logger();
 init_types2();
 var import_fs_extra31 = __toESM(require_lib(), 1);
 import { rename as rename4, rm as rm6 } from "node:fs/promises";
-import { join as join65, relative as relative12 } from "node:path";
+import { join as join66, relative as relative12 } from "node:path";
 async function collectDirsToRename(extractDir, folders) {
   const dirsToRename = [];
   if (folders.docs !== DEFAULT_FOLDERS.docs) {
-    const docsPath = join65(extractDir, DEFAULT_FOLDERS.docs);
+    const docsPath = join66(extractDir, DEFAULT_FOLDERS.docs);
     if (await import_fs_extra31.pathExists(docsPath)) {
       dirsToRename.push({
         from: docsPath,
-        to: join65(extractDir, folders.docs)
+        to: join66(extractDir, folders.docs)
       });
     }
-    const claudeDocsPath = join65(extractDir, ".claude", DEFAULT_FOLDERS.docs);
+    const claudeDocsPath = join66(extractDir, ".claude", DEFAULT_FOLDERS.docs);
     if (await import_fs_extra31.pathExists(claudeDocsPath)) {
       dirsToRename.push({
         from: claudeDocsPath,
-        to: join65(extractDir, ".claude", folders.docs)
+        to: join66(extractDir, ".claude", folders.docs)
       });
     }
   }
   if (folders.plans !== DEFAULT_FOLDERS.plans) {
-    const plansPath = join65(extractDir, DEFAULT_FOLDERS.plans);
+    const plansPath = join66(extractDir, DEFAULT_FOLDERS.plans);
     if (await import_fs_extra31.pathExists(plansPath)) {
       dirsToRename.push({
         from: plansPath,
-        to: join65(extractDir, folders.plans)
+        to: join66(extractDir, folders.plans)
       });
     }
-    const claudePlansPath = join65(extractDir, ".claude", DEFAULT_FOLDERS.plans);
+    const claudePlansPath = join66(extractDir, ".claude", DEFAULT_FOLDERS.plans);
     if (await import_fs_extra31.pathExists(claudePlansPath)) {
       dirsToRename.push({
         from: claudePlansPath,
-        to: join65(extractDir, ".claude", folders.plans)
+        to: join66(extractDir, ".claude", folders.plans)
       });
     }
   }
@@ -40691,8 +40935,8 @@ async function renameFolders(dirsToRename, extractDir, options) {
 // src/services/transformers/folder-transform/path-replacer.ts
 init_logger();
 init_types2();
-import { readFile as readFile21, readdir as readdir20, writeFile as writeFile18 } from "node:fs/promises";
-import { join as join66, relative as relative13 } from "node:path";
+import { readFile as readFile22, readdir as readdir21, writeFile as writeFile19 } from "node:fs/promises";
+import { join as join67, relative as relative13 } from "node:path";
 var TRANSFORMABLE_FILE_PATTERNS = [
   ".md",
   ".txt",
@@ -40743,9 +40987,9 @@ function compileReplacements(replacements) {
 async function transformFileContents(dir, compiledReplacements, options) {
   let filesChanged = 0;
   let replacementsCount = 0;
-  const entries = await readdir20(dir, { withFileTypes: true });
+  const entries = await readdir21(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = join66(dir, entry.name);
+    const fullPath = join67(dir, entry.name);
     if (entry.isDirectory()) {
       if (entry.name === "node_modules" || entry.name === ".git") {
         continue;
@@ -40758,7 +41002,7 @@ async function transformFileContents(dir, compiledReplacements, options) {
       if (!shouldTransform)
         continue;
       try {
-        const content = await readFile21(fullPath, "utf-8");
+        const content = await readFile22(fullPath, "utf-8");
         let newContent = content;
         let changeCount = 0;
         for (const { regex: regex2, replacement } of compiledReplacements) {
@@ -40774,7 +41018,7 @@ async function transformFileContents(dir, compiledReplacements, options) {
           if (options.dryRun) {
             logger.debug(`[dry-run] Would update ${relative13(dir, fullPath)}: ${changeCount} replacement(s)`);
           } else {
-            await writeFile18(fullPath, newContent, "utf-8");
+            await writeFile19(fullPath, newContent, "utf-8");
             logger.debug(`Updated ${relative13(dir, fullPath)}: ${changeCount} replacement(s)`);
           }
           filesChanged++;
@@ -40880,15 +41124,15 @@ async function transformFolderPaths(extractDir, folders, options = {}) {
 
 // src/services/transformers/global-path-transformer.ts
 init_logger();
-import { readFile as readFile22, readdir as readdir21, writeFile as writeFile19 } from "node:fs/promises";
+import { readFile as readFile23, readdir as readdir22, writeFile as writeFile20 } from "node:fs/promises";
 import { platform as platform11 } from "node:os";
-import { extname as extname2, join as join67 } from "node:path";
+import { extname as extname2, join as join68 } from "node:path";
 var IS_WINDOWS3 = platform11() === "win32";
 var HOME_PREFIX = IS_WINDOWS3 ? "%USERPROFILE%" : "$HOME";
 function getHomeDirPrefix() {
   return HOME_PREFIX;
 }
-var TRANSFORMABLE_EXTENSIONS = new Set([
+var TRANSFORMABLE_EXTENSIONS2 = new Set([
   ".md",
   ".js",
   ".ts",
@@ -40979,10 +41223,10 @@ function transformContent(content) {
   });
   return { transformed, changes };
 }
-function shouldTransformFile(filename) {
+function shouldTransformFile2(filename) {
   const ext2 = extname2(filename).toLowerCase();
   const basename3 = filename.split("/").pop() || filename;
-  return TRANSFORMABLE_EXTENSIONS.has(ext2) || ALWAYS_TRANSFORM_FILES.has(basename3);
+  return TRANSFORMABLE_EXTENSIONS2.has(ext2) || ALWAYS_TRANSFORM_FILES.has(basename3);
 }
 async function transformPathsForGlobalInstall(directory, options = {}) {
   let filesTransformed = 0;
@@ -40990,20 +41234,20 @@ async function transformPathsForGlobalInstall(directory, options = {}) {
   let filesSkipped = 0;
   const skippedFiles = [];
   async function processDirectory2(dir) {
-    const entries = await readdir21(dir, { withFileTypes: true });
+    const entries = await readdir22(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join67(dir, entry.name);
+      const fullPath = join68(dir, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name.startsWith(".") && entry.name !== ".claude") {
           continue;
         }
         await processDirectory2(fullPath);
-      } else if (entry.isFile() && shouldTransformFile(entry.name)) {
+      } else if (entry.isFile() && shouldTransformFile2(entry.name)) {
         try {
-          const content = await readFile22(fullPath, "utf-8");
+          const content = await readFile23(fullPath, "utf-8");
           const { transformed, changes } = transformContent(content);
           if (changes > 0) {
-            await writeFile19(fullPath, transformed, "utf-8");
+            await writeFile20(fullPath, transformed, "utf-8");
             filesTransformed++;
             totalChanges += changes;
             if (options.verbose) {
@@ -41068,7 +41312,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 claudeDir = ctx.options.global ? ctx.resolvedDir : join68(ctx.resolvedDir, ".claude");
+  const claudeDir = ctx.options.global ? ctx.resolvedDir : join69(ctx.resolvedDir, ".claude");
   return {
     ...ctx,
     foldersConfig,
@@ -41250,7 +41494,7 @@ init_types2();
 var import_picocolors20 = __toESM(require_picocolors(), 1);
 
 // src/commands/new/phases/directory-setup.ts
-import { resolve as resolve10 } from "node:path";
+import { resolve as resolve9 } from "node:path";
 init_logger();
 init_types2();
 var import_fs_extra32 = __toESM(require_lib(), 1);
@@ -41334,8 +41578,24 @@ async function directorySetup(validOptions, prompts) {
       targetDir = await prompts.getDirectory(targetDir);
     }
   }
-  const resolvedDir = resolve10(targetDir);
+  const resolvedDir = resolve9(targetDir);
   logger.info(`Target directory: ${resolvedDir}`);
+  if (PathResolver.isLocalSameAsGlobal(resolvedDir)) {
+    logger.warning("You're creating a project at HOME directory.");
+    logger.warning("This will install to your GLOBAL ~/.claude/ directory.");
+    if (!isNonInteractive2) {
+      const choice = await prompts.selectScope();
+      if (choice === "cancel" || choice === "different") {
+        logger.info("Please run 'ck new' from or specify a different directory.");
+        return null;
+      }
+      logger.info("Proceeding with global installation");
+    } else {
+      logger.error("Cannot create project at HOME directory in non-interactive mode.");
+      logger.info("Specify a different directory with --dir flag.");
+      return null;
+    }
+  }
   if (await import_fs_extra32.pathExists(resolvedDir)) {
     const files = await import_fs_extra32.readdir(resolvedDir);
     const isEmpty = files.length === 0;
@@ -41373,7 +41633,7 @@ async function handleDirectorySetup(ctx) {
   };
 }
 // src/commands/new/phases/project-creation.ts
-import { join as join69 } from "node:path";
+import { join as join70 } from "node:path";
 init_logger();
 init_output_manager();
 init_types2();
@@ -41483,7 +41743,7 @@ async function projectCreation(kit, resolvedDir, validOptions, isNonInteractive2
   output.section("Installing");
   logger.verbose("Installation target", { directory: resolvedDir });
   const merger = new FileMerger;
-  const claudeDir = join69(resolvedDir, ".claude");
+  const claudeDir = join70(resolvedDir, ".claude");
   merger.setMultiKitContext(claudeDir, kit);
   if (validOptions.exclude && validOptions.exclude.length > 0) {
     merger.addIgnorePatterns(validOptions.exclude);
@@ -41624,7 +41884,8 @@ var import_fs_extra33 = __toESM(require_lib(), 1);
 async function detectInstallations() {
   const installations = [];
   const setup = await getClaudeKitSetup(process.cwd());
-  if (setup.project.path && setup.project.metadata) {
+  const isLocalSameAsGlobal = PathResolver.isLocalSameAsGlobal();
+  if (setup.project.path && setup.project.metadata && !isLocalSameAsGlobal) {
     installations.push({
       type: "local",
       path: setup.project.path,
@@ -41643,13 +41904,13 @@ async function detectInstallations() {
 
 // src/commands/uninstall/removal-handler.ts
 import { readdirSync as readdirSync2, rmSync as rmSync2 } from "node:fs";
-import { join as join71 } from "node:path";
+import { join as join72 } from "node:path";
 init_logger();
 var import_fs_extra34 = __toESM(require_lib(), 1);
 
 // src/commands/uninstall/analysis-handler.ts
 import { readdirSync, rmSync } from "node:fs";
-import { dirname as dirname10, join as join70 } from "node:path";
+import { dirname as dirname10, join as join71 } from "node:path";
 init_logger();
 var import_picocolors21 = __toESM(require_picocolors(), 1);
 function classifyFileByOwnership(ownership, forceOverwrite, deleteReason) {
@@ -41696,7 +41957,7 @@ async function analyzeInstallation(installation, forceOverwrite, kit) {
   if (uninstallManifest.isMultiKit && kit && metadata?.kits?.[kit]) {
     const kitFiles = metadata.kits[kit].files || [];
     for (const trackedFile of kitFiles) {
-      const filePath = join70(installation.path, trackedFile.path);
+      const filePath = join71(installation.path, trackedFile.path);
       if (uninstallManifest.filesToPreserve.includes(trackedFile.path)) {
         result.toPreserve.push({ path: trackedFile.path, reason: "shared with other kit" });
         continue;
@@ -41726,7 +41987,7 @@ async function analyzeInstallation(installation, forceOverwrite, kit) {
     return result;
   }
   for (const trackedFile of allTrackedFiles) {
-    const filePath = join70(installation.path, trackedFile.path);
+    const filePath = join71(installation.path, trackedFile.path);
     const ownershipResult = await OwnershipChecker.checkOwnership(filePath, metadata, installation.path);
     if (!ownershipResult.exists)
       continue;
@@ -41786,7 +42047,7 @@ async function removeInstallations(installations, options) {
       let removedCount = 0;
       let cleanedDirs = 0;
       for (const item of analysis.toDelete) {
-        const filePath = join71(installation.path, item.path);
+        const filePath = join72(installation.path, item.path);
         if (await import_fs_extra34.pathExists(filePath)) {
           await import_fs_extra34.remove(filePath);
           removedCount++;
@@ -41883,6 +42144,12 @@ async function uninstallCommand(options) {
         return;
       }
     }
+    const isAtHome = PathResolver.isLocalSameAsGlobal();
+    if (validOptions.local && !validOptions.global && isAtHome) {
+      log.warn(import_picocolors22.default.yellow("Cannot use --local at HOME directory (local path equals global path)."));
+      log.info("Use -g/--global or run from a project directory.");
+      return;
+    }
     let scope;
     if (validOptions.all || validOptions.local && validOptions.global) {
       scope = "all";
@@ -41890,6 +42157,9 @@ async function uninstallCommand(options) {
       scope = "local";
     } else if (validOptions.global) {
       scope = "global";
+    } else if (isAtHome) {
+      log.info(import_picocolors22.default.cyan("Running at HOME directory - targeting global installation"));
+      scope = "global";
     } else {
       const promptedScope = await promptScope(allInstallations);
       if (!promptedScope) {
@@ -42109,14 +42379,14 @@ init_types2();
 // src/domains/versioning/version-cache.ts
 init_logger();
 import { existsSync as existsSync19 } from "node:fs";
-import { mkdir as mkdir22, readFile as readFile23, writeFile as writeFile20 } from "node:fs/promises";
-import { join as join72 } from "node:path";
+import { mkdir as mkdir22, readFile as readFile24, writeFile as writeFile21 } from "node:fs/promises";
+import { join as join73 } from "node:path";
 class VersionCacheManager {
   static CACHE_FILENAME = "version-check.json";
   static CACHE_TTL_MS = 7 * 24 * 60 * 60 * 1000;
   static getCacheFile() {
     const cacheDir = PathResolver.getCacheDir(false);
-    return join72(cacheDir, VersionCacheManager.CACHE_FILENAME);
+    return join73(cacheDir, VersionCacheManager.CACHE_FILENAME);
   }
   static async load() {
     const cacheFile = VersionCacheManager.getCacheFile();
@@ -42125,7 +42395,7 @@ class VersionCacheManager {
         logger.debug("Version check cache not found");
         return null;
       }
-      const content = await readFile23(cacheFile, "utf-8");
+      const content = await readFile24(cacheFile, "utf-8");
       const cache2 = JSON.parse(content);
       if (!cache2.lastCheck || !cache2.currentVersion || !cache2.latestVersion) {
         logger.debug("Invalid cache structure, ignoring");
@@ -42145,7 +42415,7 @@ class VersionCacheManager {
       if (!existsSync19(cacheDir)) {
         await mkdir22(cacheDir, { recursive: true, mode: 448 });
       }
-      await writeFile20(cacheFile, JSON.stringify(cache2, null, 2), "utf-8");
+      await writeFile21(cacheFile, JSON.stringify(cache2, null, 2), "utf-8");
       logger.debug(`Version check cache saved to ${cacheFile}`);
     } catch (error) {
       logger.debug(`Failed to save version check cache: ${error}`);
@@ -42358,7 +42628,7 @@ var import_picocolors24 = __toESM(require_picocolors(), 1);
 // package.json
 var package_default = {
   name: "claudekit-cli",
-  version: "3.22.0",
+  version: "3.23.0",
   description: "CLI tool for bootstrapping and updating ClaudeKit projects",
   type: "module",
   repository: {
@@ -42783,7 +43053,7 @@ function registerCommands(cli) {
 
 // src/cli/version-display.ts
 import { existsSync as existsSync20, readFileSync as readFileSync6 } from "node:fs";
-import { join as join73 } from "node:path";
+import { join as join74 } from "node:path";
 init_logger();
 init_types2();
 var packageVersion = package_default.version;
@@ -42817,9 +43087,9 @@ async function displayVersion() {
   let localKitVersion = null;
   let isGlobalOnlyKit = false;
   const globalKitDir = PathResolver.getGlobalKitDir();
-  const globalMetadataPath = join73(globalKitDir, "metadata.json");
+  const globalMetadataPath = join74(globalKitDir, "metadata.json");
   const prefix = PathResolver.getPathPrefix(false);
-  const localMetadataPath = prefix ? join73(process.cwd(), prefix, "metadata.json") : join73(process.cwd(), "metadata.json");
+  const localMetadataPath = prefix ? join74(process.cwd(), prefix, "metadata.json") : join74(process.cwd(), "metadata.json");
   const isLocalSameAsGlobal = localMetadataPath === globalMetadataPath;
   if (!isLocalSameAsGlobal && existsSync20(localMetadataPath)) {
     try {