claudekit-cli 4.4.0-dev.2 → 4.4.0-dev.4

package/dist/index.js

@@ -15655,6 +15655,7 @@ var init_metadata = __esm(() => {
     version: exports_external.string(),
     installedAt: exports_external.string(),
     files: exports_external.array(TrackedFileSchema).optional(),
+    ignoredSkills: exports_external.array(exports_external.string()).optional(),
     lastUpdateCheck: exports_external.string().optional(),
     dismissedVersion: exports_external.string().optional(),
     installedSettings: InstalledSettingsSchema.optional()
@@ -63852,7 +63853,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "claudekit-cli",
-    version: "4.4.0-dev.2",
+    version: "4.4.0-dev.4",
     description: "CLI tool for bootstrapping and updating ClaudeKit projects",
     type: "module",
     repository: {
@@ -68483,17 +68484,18 @@ function registerSystemRoutes(app) {
   });
   app.get("/api/system/info", async (_req, res) => {
     try {
-      const [packageJson, installLocation, gitVersion, ghVersion] = await Promise.all([
+      const [packageJson, installLocation, gitVersion, ghVersion, bunVersion] = await Promise.all([
         getPackageJson(),
         runCommand("which", ["ck"], "not found"),
         runCommand("git", ["--version"], "unknown"),
         runCommand("gh", ["--version"], "unknown").then((out) => out.split(`
-`)[0] ?? "unknown")
+`)[0] ?? "unknown"),
+        runCommand("bun", ["--version"], "").then((out) => out || null)
       ]);
       const response = {
         configPath: PathResolver.getGlobalKitDir(),
         nodeVersion: process.version,
-        bunVersion: typeof Bun !== "undefined" ? Bun.version : null,
+        bunVersion,
         os: `${process.platform} ${process.arch}`,
         cliVersion: packageJson?.version ?? "unknown",
         packageManager: detectPackageManager(),
@@ -76947,9 +76949,9 @@ __export(exports_worktree_manager, {
 });
 import { existsSync as existsSync73 } from "node:fs";
 import { readFile as readFile67, writeFile as writeFile38 } from "node:fs/promises";
-import { join as join153 } from "node:path";
+import { join as join154 } from "node:path";
 async function createWorktree(projectDir, issueNumber, baseBranch) {
-  const worktreePath = join153(projectDir, WORKTREE_DIR, `issue-${issueNumber}`);
+  const worktreePath = join154(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`);
@@ -76967,7 +76969,7 @@ async function createWorktree(projectDir, issueNumber, baseBranch) {
   return worktreePath;
 }
 async function removeWorktree(projectDir, issueNumber) {
-  const worktreePath = join153(projectDir, WORKTREE_DIR, `issue-${issueNumber}`);
+  const worktreePath = join154(projectDir, WORKTREE_DIR, `issue-${issueNumber}`);
   const branchName = `ck-watch/issue-${issueNumber}`;
   try {
     await spawnAndCollect("git", ["worktree", "remove", worktreePath, "--force"], projectDir);
@@ -76981,7 +76983,7 @@ async function listActiveWorktrees(projectDir) {
   try {
     const output2 = await spawnAndCollect("git", ["worktree", "list", "--porcelain"], projectDir);
     const issueNumbers = [];
-    const worktreePrefix = join153(projectDir, WORKTREE_DIR, "issue-").replace(/\\/g, "/");
+    const worktreePrefix = join154(projectDir, WORKTREE_DIR, "issue-").replace(/\\/g, "/");
     for (const line of output2.split(`
 `)) {
       if (line.startsWith("worktree ")) {
@@ -77009,7 +77011,7 @@ async function cleanupAllWorktrees(projectDir) {
   await spawnAndCollect("git", ["worktree", "prune"], projectDir).catch(() => {});
 }
 async function ensureGitignore(projectDir) {
-  const gitignorePath = join153(projectDir, ".gitignore");
+  const gitignorePath = join154(projectDir, ".gitignore");
   try {
     const content = existsSync73(gitignorePath) ? await readFile67(gitignorePath, "utf-8") : "";
     if (!content.includes(".worktrees")) {
@@ -77116,7 +77118,7 @@ import { createHash as createHash9 } from "node:crypto";
 import { existsSync as existsSync79, mkdirSync as mkdirSync5, readFileSync as readFileSync19, readdirSync as readdirSync13, statSync as statSync14 } from "node:fs";
 import { rename as rename16, writeFile as writeFile40 } from "node:fs/promises";
 import { homedir as homedir54 } from "node:os";
-import { basename as basename34, join as join160 } from "node:path";
+import { basename as basename34, join as join161 } from "node:path";
 function getCachedContext(repoPath) {
   const cachePath = getCacheFilePath(repoPath);
   if (!existsSync79(cachePath))
@@ -77159,25 +77161,25 @@ function computeSourceHash(repoPath) {
 }
 function getDocSourcePaths(repoPath) {
   const paths = [];
-  const docsDir = join160(repoPath, "docs");
+  const docsDir = join161(repoPath, "docs");
   if (existsSync79(docsDir)) {
     try {
       const files = readdirSync13(docsDir);
       for (const f3 of files) {
         if (f3.endsWith(".md"))
-          paths.push(join160(docsDir, f3));
+          paths.push(join161(docsDir, f3));
       }
     } catch {}
   }
-  const readme = join160(repoPath, "README.md");
+  const readme = join161(repoPath, "README.md");
   if (existsSync79(readme))
     paths.push(readme);
-  const stylesDir = join160(repoPath, "assets", "writing-styles");
+  const stylesDir = join161(repoPath, "assets", "writing-styles");
   if (existsSync79(stylesDir)) {
     try {
       const files = readdirSync13(stylesDir);
       for (const f3 of files) {
-        paths.push(join160(stylesDir, f3));
+        paths.push(join161(stylesDir, f3));
       }
     } catch {}
   }
@@ -77186,11 +77188,11 @@ function getDocSourcePaths(repoPath) {
 function getCacheFilePath(repoPath) {
   const repoName = basename34(repoPath).replace(/[^a-zA-Z0-9_-]/g, "_");
   const pathHash = createHash9("sha256").update(repoPath).digest("hex").slice(0, 8);
-  return join160(CACHE_DIR, `${repoName}-${pathHash}-context-cache.json`);
+  return join161(CACHE_DIR, `${repoName}-${pathHash}-context-cache.json`);
 }
 var CACHE_DIR, CACHE_TTL_MS5;
 var init_context_cache_manager = __esm(() => {
-  CACHE_DIR = join160(homedir54(), ".claudekit", "cache");
+  CACHE_DIR = join161(homedir54(), ".claudekit", "cache");
   CACHE_TTL_MS5 = 24 * 60 * 60 * 1000;
 });
 
@@ -77371,7 +77373,7 @@ function extractContentFromResponse(response) {
 // src/commands/content/phases/docs-summarizer.ts
 import { execSync as execSync7 } from "node:child_process";
 import { existsSync as existsSync80, readFileSync as readFileSync20, readdirSync as readdirSync14 } from "node:fs";
-import { join as join161 } from "node:path";
+import { join as join162 } from "node:path";
 async function summarizeProjectDocs(repoPath, contentLogger) {
   const rawContent = collectRawDocs(repoPath);
   if (rawContent.total.length < 200) {
@@ -77425,12 +77427,12 @@ function collectRawDocs(repoPath) {
     return capped;
   };
   const docsContent = [];
-  const docsDir = join161(repoPath, "docs");
+  const docsDir = join162(repoPath, "docs");
   if (existsSync80(docsDir)) {
     try {
       const files = readdirSync14(docsDir).filter((f3) => f3.endsWith(".md")).sort();
       for (const f3 of files) {
-        const content = readCapped(join161(docsDir, f3), 5000);
+        const content = readCapped(join162(docsDir, f3), 5000);
         if (content) {
           docsContent.push(`### ${f3}
 ${content}`);
@@ -77444,21 +77446,21 @@ ${content}`);
   let brand = "";
   const brandCandidates = ["docs/brand-guidelines.md", "docs/design-guidelines.md"];
   for (const p of brandCandidates) {
-    brand = readCapped(join161(repoPath, p), 3000);
+    brand = readCapped(join162(repoPath, p), 3000);
     if (brand)
       break;
   }
   let styles3 = "";
-  const stylesDir = join161(repoPath, "assets", "writing-styles");
+  const stylesDir = join162(repoPath, "assets", "writing-styles");
   if (existsSync80(stylesDir)) {
     try {
       const files = readdirSync14(stylesDir).slice(0, 3);
-      styles3 = files.map((f3) => readCapped(join161(stylesDir, f3), 1000)).filter(Boolean).join(`
+      styles3 = files.map((f3) => readCapped(join162(stylesDir, f3), 1000)).filter(Boolean).join(`
 
 `);
     } catch {}
   }
-  const readme = readCapped(join161(repoPath, "README.md"), 3000);
+  const readme = readCapped(join162(repoPath, "README.md"), 3000);
   const total = [docs, brand, styles3, readme].join(`
 `);
   return { docs, brand, styles: styles3, readme, total };
@@ -77645,9 +77647,9 @@ IMPORTANT: Generate the image and output the path as JSON: {"imagePath": "/path/
 import { execSync as execSync8 } from "node:child_process";
 import { existsSync as existsSync81, mkdirSync as mkdirSync6, readdirSync as readdirSync15 } from "node:fs";
 import { homedir as homedir55 } from "node:os";
-import { join as join162 } from "node:path";
+import { join as join163 } from "node:path";
 async function generatePhoto(_content, context, config, platform18, contentId, contentLogger) {
-  const mediaDir = join162(config.contentDir.replace(/^~/, homedir55()), "media", String(contentId));
+  const mediaDir = join163(config.contentDir.replace(/^~/, homedir55()), "media", String(contentId));
   if (!existsSync81(mediaDir)) {
     mkdirSync6(mediaDir, { recursive: true });
   }
@@ -77672,7 +77674,7 @@ async function generatePhoto(_content, context, config, platform18, contentId, c
     const imageFile = files.find((f3) => /\.(png|jpg|jpeg|webp)$/i.test(f3));
     if (imageFile) {
       const ext2 = imageFile.split(".").pop() ?? "png";
-      return { path: join162(mediaDir, imageFile), ...dimensions, format: ext2 };
+      return { path: join163(mediaDir, imageFile), ...dimensions, format: ext2 };
     }
     contentLogger.warn(`Photo generation produced no image for content ${contentId}`);
     return null;
@@ -77762,7 +77764,7 @@ var init_content_creator = __esm(() => {
 // src/commands/content/phases/content-logger.ts
 import { createWriteStream as createWriteStream4, existsSync as existsSync82, mkdirSync as mkdirSync7, statSync as statSync15 } from "node:fs";
 import { homedir as homedir56 } from "node:os";
-import { join as join163 } from "node:path";
+import { join as join164 } from "node:path";
 
 class ContentLogger {
   stream = null;
@@ -77770,7 +77772,7 @@ class ContentLogger {
   logDir;
   maxBytes;
   constructor(maxBytes = 0) {
-    this.logDir = join163(homedir56(), ".claudekit", "logs");
+    this.logDir = join164(homedir56(), ".claudekit", "logs");
     this.maxBytes = maxBytes;
   }
   init() {
@@ -77802,7 +77804,7 @@ class ContentLogger {
     }
   }
   getLogPath() {
-    return join163(this.logDir, `content-${this.getDateStr()}.log`);
+    return join164(this.logDir, `content-${this.getDateStr()}.log`);
   }
   write(level, message) {
     this.rotateIfNeeded();
@@ -77819,18 +77821,18 @@ class ContentLogger {
     if (dateStr !== this.currentDate) {
       this.close();
       this.currentDate = dateStr;
-      const logPath = join163(this.logDir, `content-${dateStr}.log`);
+      const logPath = join164(this.logDir, `content-${dateStr}.log`);
       this.stream = createWriteStream4(logPath, { flags: "a", mode: 384 });
       return;
     }
     if (this.maxBytes > 0 && this.stream) {
-      const logPath = join163(this.logDir, `content-${this.currentDate}.log`);
+      const logPath = join164(this.logDir, `content-${this.currentDate}.log`);
       try {
         const stat26 = statSync15(logPath);
         if (stat26.size >= this.maxBytes) {
           this.close();
           const suffix = Date.now();
-          const rotatedPath = join163(this.logDir, `content-${this.currentDate}-${suffix}.log`);
+          const rotatedPath = join164(this.logDir, `content-${this.currentDate}-${suffix}.log`);
           import("node:fs/promises").then(({ rename: rename17 }) => rename17(logPath, rotatedPath).catch(() => {}));
           this.stream = createWriteStream4(logPath, { flags: "w", mode: 384 });
         }
@@ -77913,7 +77915,7 @@ var init_sqlite_client = __esm(() => {
 
 // src/commands/content/phases/db-manager.ts
 import { existsSync as existsSync83, mkdirSync as mkdirSync8 } from "node:fs";
-import { dirname as dirname52 } from "node:path";
+import { dirname as dirname53 } from "node:path";
 function initDatabase(dbPath) {
   ensureParentDir(dbPath);
   const db = openDatabase(dbPath);
@@ -77934,7 +77936,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 = dirname52(dbPath);
+  const dir = dirname53(dbPath);
   if (dir && !existsSync83(dir)) {
     mkdirSync8(dir, { recursive: true });
   }
@@ -78101,7 +78103,7 @@ function isNoiseCommit(title, author) {
 // src/commands/content/phases/change-detector.ts
 import { execSync as execSync10, spawnSync as spawnSync9 } from "node:child_process";
 import { existsSync as existsSync84, readFileSync as readFileSync21, readdirSync as readdirSync16, statSync as statSync16 } from "node:fs";
-import { join as join164 } from "node:path";
+import { join as join165 } from "node:path";
 function detectCommits(repo, since) {
   try {
     const fetchUrl = sshToHttps(repo.remoteUrl);
@@ -78210,7 +78212,7 @@ function detectTags(repo, since) {
   }
 }
 function detectCompletedPlans(repo, since) {
-  const plansDir = join164(repo.path, "plans");
+  const plansDir = join165(repo.path, "plans");
   if (!existsSync84(plansDir))
     return [];
   const sinceMs = new Date(since).getTime();
@@ -78220,7 +78222,7 @@ function detectCompletedPlans(repo, since) {
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
-      const planFile = join164(plansDir, entry.name, "plan.md");
+      const planFile = join165(plansDir, entry.name, "plan.md");
       if (!existsSync84(planFile))
         continue;
       try {
@@ -78298,7 +78300,7 @@ function classifyCommit(event) {
 // src/commands/content/phases/repo-discoverer.ts
 import { execSync as execSync11 } from "node:child_process";
 import { readdirSync as readdirSync17 } from "node:fs";
-import { join as join165 } from "node:path";
+import { join as join166 } from "node:path";
 function discoverRepos2(cwd2) {
   const repos = [];
   if (isGitRepoRoot(cwd2)) {
@@ -78311,7 +78313,7 @@ function discoverRepos2(cwd2) {
     for (const entry of entries) {
       if (!entry.isDirectory() || entry.name.startsWith("."))
         continue;
-      const dirPath = join165(cwd2, entry.name);
+      const dirPath = join166(cwd2, entry.name);
       if (isGitRepoRoot(dirPath)) {
         const info = getRepoInfo(dirPath);
         if (info)
@@ -78979,9 +78981,9 @@ var init_types6 = __esm(() => {
 
 // src/commands/content/phases/state-manager.ts
 import { readFile as readFile69, rename as rename17, writeFile as writeFile41 } from "node:fs/promises";
-import { join as join166 } from "node:path";
+import { join as join167 } from "node:path";
 async function loadContentConfig(projectDir) {
-  const configPath = join166(projectDir, CK_CONFIG_FILE2);
+  const configPath = join167(projectDir, CK_CONFIG_FILE2);
   try {
     const raw2 = await readFile69(configPath, "utf-8");
     const json = JSON.parse(raw2);
@@ -78991,13 +78993,13 @@ async function loadContentConfig(projectDir) {
   }
 }
 async function saveContentConfig(projectDir, config) {
-  const configPath = join166(projectDir, CK_CONFIG_FILE2);
+  const configPath = join167(projectDir, CK_CONFIG_FILE2);
   const json = await readJsonSafe(configPath);
   json.content = { ...json.content, ...config };
   await atomicWrite3(configPath, json);
 }
 async function loadContentState(projectDir) {
-  const configPath = join166(projectDir, CK_CONFIG_FILE2);
+  const configPath = join167(projectDir, CK_CONFIG_FILE2);
   try {
     const raw2 = await readFile69(configPath, "utf-8");
     const json = JSON.parse(raw2);
@@ -79008,7 +79010,7 @@ async function loadContentState(projectDir) {
   }
 }
 async function saveContentState(projectDir, state) {
-  const configPath = join166(projectDir, CK_CONFIG_FILE2);
+  const configPath = join167(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);
@@ -79290,7 +79292,7 @@ var init_platform_setup_x = __esm(() => {
 
 // src/commands/content/phases/setup-wizard.ts
 import { existsSync as existsSync85 } from "node:fs";
-import { join as join167 } from "node:path";
+import { join as join168 } from "node:path";
 async function runSetupWizard2(cwd2, contentLogger) {
   console.log();
   oe(import_picocolors43.default.bgCyan(import_picocolors43.default.white(" CK Content — Multi-Channel Content Engine ")));
@@ -79358,8 +79360,8 @@ async function showRepoSummary(cwd2) {
 function detectBrandAssets(cwd2, contentLogger) {
   const repos = discoverRepos2(cwd2);
   for (const repo of repos) {
-    const hasGuidelines = existsSync85(join167(repo.path, "docs", "brand-guidelines.md"));
-    const hasStyles = existsSync85(join167(repo.path, "assets", "writing-styles"));
+    const hasGuidelines = existsSync85(join168(repo.path, "docs", "brand-guidelines.md"));
+    const hasStyles = existsSync85(join168(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`);
@@ -79501,9 +79503,9 @@ __export(exports_content_subcommands, {
 });
 import { existsSync as existsSync87, readFileSync as readFileSync22, unlinkSync as unlinkSync6 } from "node:fs";
 import { homedir as homedir58 } from "node:os";
-import { join as join168 } from "node:path";
+import { join as join169 } from "node:path";
 function isDaemonRunning() {
-  const lockFile = join168(LOCK_DIR, `${LOCK_NAME2}.lock`);
+  const lockFile = join169(LOCK_DIR, `${LOCK_NAME2}.lock`);
   if (!existsSync87(lockFile))
     return { running: false, pid: null };
   try {
@@ -79535,7 +79537,7 @@ async function startContent(options2) {
   await contentCommand(options2);
 }
 async function stopContent() {
-  const lockFile = join168(LOCK_DIR, `${LOCK_NAME2}.lock`);
+  const lockFile = join169(LOCK_DIR, `${LOCK_NAME2}.lock`);
   if (!existsSync87(lockFile)) {
     logger.info("Content daemon is not running.");
     return;
@@ -79574,9 +79576,9 @@ async function statusContent() {
   } catch {}
 }
 async function logsContent(options2) {
-  const logDir = join168(homedir58(), ".claudekit", "logs");
+  const logDir = join169(homedir58(), ".claudekit", "logs");
   const dateStr = new Date().toISOString().slice(0, 10).replace(/-/g, "");
-  const logPath = join168(logDir, `content-${dateStr}.log`);
+  const logPath = join169(logDir, `content-${dateStr}.log`);
   if (!existsSync87(logPath)) {
     logger.info("No content logs found for today.");
     return;
@@ -79608,13 +79610,13 @@ var init_content_subcommands = __esm(() => {
   init_setup_wizard();
   init_state_manager();
   init_content_review_commands();
-  LOCK_DIR = join168(homedir58(), ".claudekit", "locks");
+  LOCK_DIR = join169(homedir58(), ".claudekit", "locks");
 });
 
 // src/commands/content/content-command.ts
 import { existsSync as existsSync88, mkdirSync as mkdirSync9, unlinkSync as unlinkSync7, writeFileSync as writeFileSync7 } from "node:fs";
 import { homedir as homedir59 } from "node:os";
-import { join as join169 } from "node:path";
+import { join as join170 } from "node:path";
 async function contentCommand(options2) {
   const cwd2 = process.cwd();
   const contentLogger = new ContentLogger;
@@ -79792,8 +79794,8 @@ var init_content_command = __esm(() => {
   init_publisher();
   init_review_manager();
   init_state_manager();
-  LOCK_DIR2 = join169(homedir59(), ".claudekit", "locks");
-  LOCK_FILE = join169(LOCK_DIR2, "ck-content.lock");
+  LOCK_DIR2 = join170(homedir59(), ".claudekit", "locks");
+  LOCK_FILE = join170(LOCK_DIR2, "ck-content.lock");
 });
 
 // src/commands/content/index.ts
@@ -101545,7 +101547,7 @@ async function handleDownload(ctx) {
   };
 }
 // src/commands/init/phases/merge-handler.ts
-import { join as join120 } from "node:path";
+import { join as join121 } from "node:path";
 
 // src/domains/installation/deletion-handler.ts
 import { existsSync as existsSync65, lstatSync as lstatSync3, readdirSync as readdirSync9, rmSync as rmSync2, rmdirSync, unlinkSync as unlinkSync4 } from "node:fs";
@@ -101905,9 +101907,9 @@ init_dist2();
 // src/domains/installation/merger/copy-executor.ts
 init_logger();
 init_types3();
-var import_fs_extra15 = __toESM(require_lib(), 1);
+var import_fs_extra16 = __toESM(require_lib(), 1);
 var import_ignore3 = __toESM(require_ignore(), 1);
-import { dirname as dirname40, join as join110, relative as relative23 } from "node:path";
+import { dirname as dirname41, join as join111, relative as relative24 } from "node:path";
 
 // src/domains/installation/selective-merger.ts
 import { stat as stat18 } from "node:fs/promises";
@@ -102081,12 +102083,87 @@ class SelectiveMerger {
   }
 }
 
+// src/domains/installation/merger/deleted-skill-preservation.ts
+init_metadata_migration();
+import { dirname as dirname38, join as join107, relative as relative22 } from "node:path";
+var import_fs_extra13 = __toESM(require_lib(), 1);
+async function findIgnoredSkillDirectories({
+  files,
+  sourceDir,
+  destDir,
+  claudeDir: claudeDir3,
+  installingKit
+}) {
+  const sourceSkillRoots = findSourceSkillRoots(files, sourceDir);
+  const ignoredSkillDirectories = new Set;
+  if (sourceSkillRoots.size === 0)
+    return ignoredSkillDirectories;
+  const metadata = await readManifest(claudeDir3);
+  const kitMetadata = metadata ? getKitMetadata(metadata, installingKit) : null;
+  if (!kitMetadata)
+    return ignoredSkillDirectories;
+  const previouslyTrackedRoots = new Set;
+  for (const file of kitMetadata.files ?? []) {
+    const skillRoot = findSkillRoot(file.path, sourceSkillRoots.keys());
+    if (skillRoot)
+      previouslyTrackedRoots.add(skillRoot);
+  }
+  const existingIgnoredRoots = new Set((kitMetadata.ignoredSkills ?? []).flatMap((path16) => {
+    const root = normalizeSkillRoot(path16);
+    return root ? [root] : [];
+  }));
+  for (const [metadataRoot, sourceRoot] of sourceSkillRoots) {
+    const destSkillRoot = join107(destDir, ...sourceRoot.split("/"));
+    const skillExists = await import_fs_extra13.pathExists(destSkillRoot);
+    if (existingIgnoredRoots.has(metadataRoot) || !skillExists && previouslyTrackedRoots.has(metadataRoot)) {
+      ignoredSkillDirectories.add(metadataRoot);
+    }
+  }
+  return ignoredSkillDirectories;
+}
+function shouldSkipIgnoredSkill(normalizedRelativePath, ignoredSkillDirectories) {
+  const metadataPath = toMetadataPath(normalizedRelativePath);
+  if (!metadataPath)
+    return false;
+  return findSkillRoot(metadataPath, ignoredSkillDirectories) !== null;
+}
+function findSourceSkillRoots(files, sourceDir) {
+  const sourceSkillRoots = new Map;
+  for (const file of files) {
+    const normalizedPath = relative22(sourceDir, file).replace(/\\/g, "/");
+    const metadataPath = toMetadataPath(normalizedPath);
+    if (!metadataPath?.endsWith("/SKILL.md"))
+      continue;
+    const metadataRoot = dirname38(metadataPath).replace(/\\/g, "/");
+    const sourceRoot = dirname38(normalizedPath).replace(/\\/g, "/");
+    sourceSkillRoots.set(metadataRoot, sourceRoot);
+  }
+  return sourceSkillRoots;
+}
+function toMetadataPath(normalizedRelativePath) {
+  const path16 = normalizedRelativePath.replace(/^\.claude\//, "");
+  return path16.startsWith("skills/") ? path16 : null;
+}
+function normalizeSkillRoot(path16) {
+  const normalized = path16.replace(/\\/g, "/").replace(/^\.claude\//, "").replace(/\/+$/, "");
+  return normalized.startsWith("skills/") && normalized.split("/").length >= 2 ? normalized : null;
+}
+function findSkillRoot(path16, skillRoots) {
+  const normalizedPath = path16.replace(/\\/g, "/").replace(/^\.claude\//, "");
+  for (const root of skillRoots) {
+    if (normalizedPath === `${root}/SKILL.md` || normalizedPath.startsWith(`${root}/`)) {
+      return root;
+    }
+  }
+  return null;
+}
+
 // src/domains/installation/merger/file-scanner.ts
 init_logger();
-var import_fs_extra13 = __toESM(require_lib(), 1);
+var import_fs_extra14 = __toESM(require_lib(), 1);
 var import_ignore2 = __toESM(require_ignore(), 1);
-import { relative as relative22 } from "node:path";
-import { join as join107 } from "node:path";
+import { relative as relative23 } from "node:path";
+import { join as join108 } from "node:path";
 
 // node_modules/@isaacs/balanced-match/dist/esm/index.js
 var balanced = (a3, b3, str2) => {
@@ -103540,12 +103617,12 @@ class FileScanner {
   }
   async getFiles(dir, baseDir = dir) {
     const files = [];
-    const entries = await import_fs_extra13.readdir(dir, { encoding: "utf8" });
+    const entries = await import_fs_extra14.readdir(dir, { encoding: "utf8" });
     for (const entry of entries) {
-      const fullPath = join107(dir, entry);
-      const relativePath = relative22(baseDir, fullPath);
+      const fullPath = join108(dir, entry);
+      const relativePath = relative23(baseDir, fullPath);
       const normalizedRelativePath = relativePath.replace(/\\/g, "/");
-      const stats = await import_fs_extra13.lstat(fullPath);
+      const stats = await import_fs_extra14.lstat(fullPath);
       if (stats.isSymbolicLink()) {
         logger.warning(`Skipping symbolic link: ${normalizedRelativePath}`);
         continue;
@@ -103578,13 +103655,13 @@ class FileScanner {
 // src/domains/installation/merger/settings-processor.ts
 import { execSync as execSync5 } from "node:child_process";
 import { homedir as homedir45 } from "node:os";
-import { dirname as dirname39, join as join109 } from "node:path";
+import { dirname as dirname40, join as join110 } from "node:path";
 
 // src/domains/config/installed-settings-tracker.ts
 init_shared();
 import { existsSync as existsSync66 } from "node:fs";
 import { mkdir as mkdir31, readFile as readFile50, writeFile as writeFile25 } from "node:fs/promises";
-import { dirname as dirname38, join as join108 } from "node:path";
+import { dirname as dirname39, join as join109 } from "node:path";
 var CK_JSON_FILE = ".ck.json";
 
 class InstalledSettingsTracker {
@@ -103598,9 +103675,9 @@ class InstalledSettingsTracker {
   }
   getCkJsonPath() {
     if (this.isGlobal) {
-      return join108(this.projectDir, CK_JSON_FILE);
+      return join109(this.projectDir, CK_JSON_FILE);
     }
-    return join108(this.projectDir, ".claude", CK_JSON_FILE);
+    return join109(this.projectDir, ".claude", CK_JSON_FILE);
   }
   async loadInstalledSettings() {
     const ckJsonPath = this.getCkJsonPath();
@@ -103635,7 +103712,7 @@ class InstalledSettingsTracker {
         data.kits[this.kitName] = {};
       }
       data.kits[this.kitName].installedSettings = settings;
-      await mkdir31(dirname38(ckJsonPath), { recursive: true });
+      await mkdir31(dirname39(ckJsonPath), { recursive: true });
       await writeFile25(ckJsonPath, JSON.stringify(data, null, 2), "utf-8");
       logger.debug(`Saved installed settings to ${ckJsonPath}`);
     } catch (error) {
@@ -103679,7 +103756,7 @@ init_zombie_wirings_pruner();
 init_command_normalizer();
 init_logger();
 init_path_resolver();
-var import_fs_extra14 = __toESM(require_lib(), 1);
+var import_fs_extra15 = __toESM(require_lib(), 1);
 var import_semver4 = __toESM(require_semver2(), 1);
 
 class SettingsProcessor {
@@ -103727,7 +103804,7 @@ class SettingsProcessor {
   }
   async processSettingsJson(sourceFile, destFile) {
     try {
-      const sourceContent = await import_fs_extra14.readFile(sourceFile, "utf-8");
+      const sourceContent = await import_fs_extra15.readFile(sourceFile, "utf-8");
       let transformedSource = sourceContent;
       if (this.isGlobal) {
         const globalRoot = this.getCanonicalGlobalCommandRoot();
@@ -103741,7 +103818,7 @@ class SettingsProcessor {
           logger.debug('Transformed .claude/ paths to "$CLAUDE_PROJECT_DIR"/.claude/ in settings.json for local installation');
         }
       }
-      const destExists = await import_fs_extra14.pathExists(destFile);
+      const destExists = await import_fs_extra15.pathExists(destFile);
       if (destExists && !this.forceOverwriteSettings) {
         await this.selectiveMergeSettings(transformedSource, destFile);
       } else {
@@ -103763,14 +103840,14 @@ class SettingsProcessor {
           }
         } catch {
           const formattedContent = this.formatJsonContent(transformedSource);
-          await import_fs_extra14.writeFile(destFile, formattedContent, "utf-8");
+          await import_fs_extra15.writeFile(destFile, formattedContent, "utf-8");
         }
         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 });
+      await import_fs_extra15.copy(sourceFile, destFile, { overwrite: true });
     }
   }
   async selectiveMergeSettings(transformedSourceContent, destFile) {
@@ -103781,7 +103858,7 @@ class SettingsProcessor {
     } catch {
       logger.warning("Failed to parse source settings.json, falling back to overwrite");
       const formattedContent = this.formatJsonContent(transformedSourceContent);
-      await import_fs_extra14.writeFile(destFile, formattedContent, "utf-8");
+      await import_fs_extra15.writeFile(destFile, formattedContent, "utf-8");
       return;
     }
     let destSettings;
@@ -103863,10 +103940,10 @@ class SettingsProcessor {
     };
     try {
       if (this.isGlobal) {
-        await addFromConfig(join109(this.projectDir, ".ck.json"));
+        await addFromConfig(join110(this.projectDir, ".ck.json"));
       } else {
-        await addFromConfig(join109(PathResolver.getGlobalKitDir(), ".ck.json"));
-        await addFromConfig(join109(this.projectDir, ".claude", ".ck.json"));
+        await addFromConfig(join110(PathResolver.getGlobalKitDir(), ".ck.json"));
+        await addFromConfig(join110(this.projectDir, ".claude", ".ck.json"));
       }
     } catch (error) {
       logger.debug(`Failed to load .ck.json hook preferences: ${error instanceof Error ? error.message : "unknown"}`);
@@ -103874,9 +103951,9 @@ class SettingsProcessor {
     return disabled;
   }
   async readDisabledHookNamesFromConfig(configPath) {
-    if (!await import_fs_extra14.pathExists(configPath))
+    if (!await import_fs_extra15.pathExists(configPath))
       return new Set;
-    const raw2 = parseJsonContent(await import_fs_extra14.readFile(configPath, "utf-8"));
+    const raw2 = parseJsonContent(await import_fs_extra15.readFile(configPath, "utf-8"));
     const hooks = raw2.hooks;
     if (!hooks || typeof hooks !== "object")
       return new Set;
@@ -104113,7 +104190,7 @@ class SettingsProcessor {
   }
   async readAndNormalizeGlobalSettings(destFile) {
     try {
-      const content = await import_fs_extra14.readFile(destFile, "utf-8");
+      const content = await import_fs_extra15.readFile(destFile, "utf-8");
       if (!content.trim())
         return null;
       const parsedSettings = JSON.parse(content);
@@ -104223,7 +104300,7 @@ class SettingsProcessor {
       return false;
     }
     const configuredGlobalDir = PathResolver.getGlobalKitDir().replace(/\\/g, "/").replace(/\/+$/, "");
-    const defaultGlobalDir = join109(homedir45(), ".claude").replace(/\\/g, "/");
+    const defaultGlobalDir = join110(homedir45(), ".claude").replace(/\\/g, "/");
     return configuredGlobalDir !== defaultGlobalDir;
   }
   getClaudeCommandRoot() {
@@ -104243,8 +104320,8 @@ class SettingsProcessor {
     return true;
   }
   async repairSiblingSettingsLocal(destFile) {
-    const settingsLocalPath = join109(dirname39(destFile), "settings.local.json");
-    if (settingsLocalPath === destFile || !await import_fs_extra14.pathExists(settingsLocalPath)) {
+    const settingsLocalPath = join110(dirname40(destFile), "settings.local.json");
+    if (settingsLocalPath === destFile || !await import_fs_extra15.pathExists(settingsLocalPath)) {
       return;
     }
     await this.repairSettingsFile(settingsLocalPath);
@@ -104355,6 +104432,8 @@ class CopyExecutor {
   fileConflicts = [];
   claudeDir = null;
   installingKit = null;
+  ignoredSkillDirectories = new Set;
+  preserveDeletedSkills = true;
   constructor(neverCopyPatterns) {
     this.userConfigChecker = import_ignore3.default().add(USER_CONFIG_PATTERNS);
     this.fileScanner = new FileScanner(neverCopyPatterns);
@@ -104374,6 +104453,9 @@ class CopyExecutor {
   setForceOverwriteSettings(force) {
     this.settingsProcessor.setForceOverwriteSettings(force);
   }
+  setPreserveDeletedSkills(preserve) {
+    this.preserveDeletedSkills = preserve;
+  }
   setRestoreCkHooks(restore) {
     this.settingsProcessor.setRestoreCkHooks(restore);
   }
@@ -104408,10 +104490,10 @@ class CopyExecutor {
     const conflicts = [];
     const files = await this.fileScanner.getFiles(sourceDir, sourceDir);
     for (const file of files) {
-      const relativePath = relative23(sourceDir, file);
+      const relativePath = relative24(sourceDir, file);
       const normalizedRelativePath = relativePath.replace(/\\/g, "/");
-      const destPath = join110(destDir, relativePath);
-      if (await import_fs_extra15.pathExists(destPath)) {
+      const destPath = join111(destDir, relativePath);
+      if (await import_fs_extra16.pathExists(destPath)) {
         if (this.fileScanner.shouldNeverCopy(normalizedRelativePath)) {
           logger.debug(`Security-sensitive file exists but won't be overwritten: ${normalizedRelativePath}`);
           continue;
@@ -104427,19 +104509,26 @@ class CopyExecutor {
   }
   async copyFiles(sourceDir, destDir) {
     const files = await this.fileScanner.getFiles(sourceDir, sourceDir);
+    await this.loadIgnoredSkillDirectories(files, sourceDir, destDir);
     let copiedCount = 0;
     let skippedCount = 0;
+    let ignoredSkillSkipped = 0;
     for (const file of files) {
-      const relativePath = relative23(sourceDir, file);
+      const relativePath = relative24(sourceDir, file);
       const normalizedRelativePath = relativePath.replace(/\\/g, "/");
-      const destPath = join110(destDir, relativePath);
+      const destPath = join111(destDir, relativePath);
       if (this.fileScanner.shouldNeverCopy(normalizedRelativePath)) {
         logger.debug(`Skipping security-sensitive file: ${normalizedRelativePath}`);
         skippedCount++;
         continue;
       }
+      if (this.shouldSkipIgnoredSkill(normalizedRelativePath)) {
+        logger.debug(`Preserving ignored skill file: ${normalizedRelativePath}`);
+        ignoredSkillSkipped++;
+        continue;
+      }
       if (this.userConfigChecker.ignores(normalizedRelativePath)) {
-        const fileExists = await import_fs_extra15.pathExists(destPath);
+        const fileExists = await import_fs_extra16.pathExists(destPath);
         if (fileExists) {
           logger.debug(`Preserving user config: ${normalizedRelativePath}`);
           skippedCount++;
@@ -104470,7 +104559,7 @@ class CopyExecutor {
           continue;
         }
       }
-      await withRetry2(() => import_fs_extra15.copy(file, destPath, { overwrite: true }));
+      await withRetry2(() => import_fs_extra16.copy(file, destPath, { overwrite: true }));
       this.trackInstalledFile(normalizedRelativePath);
       copiedCount++;
     }
@@ -104481,6 +104570,8 @@ class CopyExecutor {
       parts.push(`skipped ${this.unchangedSkipped} unchanged`);
     if (this.sharedSkipped > 0)
       parts.push(`preserved ${this.sharedSkipped} shared`);
+    if (ignoredSkillSkipped > 0)
+      parts.push(`preserved ${ignoredSkillSkipped} ignored skill file(s)`);
     if (skippedCount > 0)
       parts.push(`skipped ${skippedCount} protected`);
     if (parts.length > 0) {
@@ -104507,14 +104598,34 @@ class CopyExecutor {
   getFileConflicts() {
     return this.fileConflicts;
   }
+  getIgnoredSkillDirectories() {
+    return Array.from(this.ignoredSkillDirectories).sort();
+  }
   trackInstalledFile(relativePath) {
     this.installedFiles.add(relativePath);
-    let dir = dirname40(relativePath);
+    let dir = dirname41(relativePath);
     while (dir && dir !== "." && dir !== "/") {
       this.installedDirectories.add(`${dir}/`);
-      dir = dirname40(dir);
+      dir = dirname41(dir);
     }
   }
+  async loadIgnoredSkillDirectories(files, sourceDir, destDir) {
+    this.ignoredSkillDirectories.clear();
+    if (!this.preserveDeletedSkills)
+      return;
+    if (!this.claudeDir || !this.installingKit)
+      return;
+    this.ignoredSkillDirectories = await findIgnoredSkillDirectories({
+      files,
+      sourceDir,
+      destDir,
+      claudeDir: this.claudeDir,
+      installingKit: this.installingKit
+    });
+  }
+  shouldSkipIgnoredSkill(normalizedRelativePath) {
+    return shouldSkipIgnoredSkill(normalizedRelativePath, this.ignoredSkillDirectories);
+  }
 }
 
 // src/domains/installation/file-merger.ts
@@ -104549,6 +104660,9 @@ class FileMerger {
   setForceOverwriteSettings(force) {
     this.copyExecutor.setForceOverwriteSettings(force);
   }
+  setPreserveDeletedSkills(preserve) {
+    this.copyExecutor.setPreserveDeletedSkills(preserve);
+  }
   setRestoreCkHooks(restore) {
     this.copyExecutor.setRestoreCkHooks(restore);
   }
@@ -104607,19 +104721,22 @@ class FileMerger {
   getFileConflicts() {
     return this.copyExecutor.getFileConflicts();
   }
+  getIgnoredSkillDirectories() {
+    return this.copyExecutor.getIgnoredSkillDirectories();
+  }
 }
 
 // src/domains/migration/legacy-migration.ts
 import { readdir as readdir28, stat as stat19 } from "node:fs/promises";
-import { join as join114, relative as relative24 } from "node:path";
+import { join as join115, relative as relative25 } from "node:path";
 // src/services/file-operations/manifest/manifest-tracker.ts
-import { join as join113 } from "node:path";
+import { join as join114 } from "node:path";
 
 // src/domains/migration/release-manifest.ts
 init_logger();
 init_zod();
-var import_fs_extra16 = __toESM(require_lib(), 1);
-import { join as join111 } from "node:path";
+var import_fs_extra17 = __toESM(require_lib(), 1);
+import { join as join112 } from "node:path";
 var ReleaseManifestFileSchema = exports_external.object({
   path: exports_external.string(),
   checksum: exports_external.string().regex(/^[a-f0-9]{64}$/),
@@ -104634,9 +104751,9 @@ var ReleaseManifestSchema = exports_external.object({
 
 class ReleaseManifestLoader {
   static async load(extractDir) {
-    const manifestPath = join111(extractDir, "release-manifest.json");
+    const manifestPath = join112(extractDir, "release-manifest.json");
     try {
-      const content = await import_fs_extra16.readFile(manifestPath, "utf-8");
+      const content = await import_fs_extra17.readFile(manifestPath, "utf-8");
       const parsed = JSON.parse(content);
       return ReleaseManifestSchema.parse(parsed);
     } catch (error) {
@@ -104657,14 +104774,14 @@ init_p_limit();
 
 // src/services/file-operations/manifest/manifest-updater.ts
 init_metadata_migration();
-import { join as join112 } from "node:path";
+import { join as join113 } from "node:path";
 init_logger();
 init_types3();
-var import_fs_extra17 = __toESM(require_lib(), 1);
-async function writeManifest(claudeDir3, kitName, version, scope, kitType, trackedFiles, userConfigFiles) {
-  const metadataPath = join112(claudeDir3, "metadata.json");
+var import_fs_extra18 = __toESM(require_lib(), 1);
+async function writeManifest(claudeDir3, kitName, version, scope, kitType, trackedFiles, userConfigFiles, ignoredSkills = []) {
+  const metadataPath = join113(claudeDir3, "metadata.json");
   const kit = kitType || (/\bmarketing\b/i.test(kitName) ? "marketing" : "engineer");
-  await import_fs_extra17.ensureFile(metadataPath);
+  await import_fs_extra18.ensureFile(metadataPath);
   let release = null;
   try {
     release = await acquireInstallationStateLock(claudeDir3);
@@ -104673,9 +104790,9 @@ async function writeManifest(claudeDir3, kitName, version, scope, kitType, track
       logger.warning(`Metadata migration warning: ${migrationResult.error}`);
     }
     let existingMetadata = { kits: {} };
-    if (await import_fs_extra17.pathExists(metadataPath)) {
+    if (await import_fs_extra18.pathExists(metadataPath)) {
       try {
-        const content = await import_fs_extra17.readFile(metadataPath, "utf-8");
+        const content = await import_fs_extra18.readFile(metadataPath, "utf-8");
         const parsed = JSON.parse(content);
         if (parsed && typeof parsed === "object" && Object.keys(parsed).length > 0) {
           existingMetadata = parsed;
@@ -104684,13 +104801,20 @@ async function writeManifest(claudeDir3, kitName, version, scope, kitType, track
         logger.debug(`Could not read existing metadata: ${error}`);
       }
     }
+    const existingKits = existingMetadata.kits || {};
+    const normalizedTrackedPaths = trackedFiles.map((file) => normalizeMetadataPath(file.path));
+    const existingIgnoredSkills = existingKits[kit]?.ignoredSkills ?? [];
+    const mergedIgnoredSkills = uniqueNormalizedSkillRoots([
+      ...existingIgnoredSkills,
+      ...ignoredSkills
+    ]).filter((skillRoot) => !normalizedTrackedPaths.some((path17) => path17 === `${skillRoot}/SKILL.md` || path17.startsWith(`${skillRoot}/`)));
     const installedAt = new Date().toISOString();
     const kitMetadata = {
       version,
       installedAt,
-      files: trackedFiles.length > 0 ? trackedFiles : undefined
+      files: trackedFiles.length > 0 ? trackedFiles : undefined,
+      ignoredSkills: mergedIgnoredSkills.length > 0 ? mergedIgnoredSkills : undefined
     };
-    const existingKits = existingMetadata.kits || {};
     const otherKitsExist = Object.keys(existingKits).some((k2) => k2 !== kit);
     const metadata = {
       kits: {
@@ -104704,7 +104828,7 @@ async function writeManifest(claudeDir3, kitName, version, scope, kitType, track
       userConfigFiles: [...USER_CONFIG_PATTERNS, ...userConfigFiles]
     };
     const validated = MetadataSchema.parse(metadata);
-    await import_fs_extra17.writeFile(metadataPath, JSON.stringify(validated, null, 2), "utf-8");
+    await import_fs_extra18.writeFile(metadataPath, JSON.stringify(validated, null, 2), "utf-8");
     logger.debug(`Wrote manifest for kit "${kit}" with ${trackedFiles.length} tracked files`);
   } finally {
     if (release) {
@@ -104713,9 +104837,22 @@ async function writeManifest(claudeDir3, kitName, version, scope, kitType, track
     }
   }
 }
+function normalizeMetadataPath(path17) {
+  return path17.replace(/\\/g, "/").replace(/^\.claude\//, "").replace(/\/+$/, "");
+}
+function normalizeSkillRoot2(path17) {
+  const normalized = normalizeMetadataPath(path17);
+  return normalized.startsWith("skills/") && normalized.split("/").length >= 2 ? normalized : null;
+}
+function uniqueNormalizedSkillRoots(paths) {
+  return Array.from(new Set(paths.flatMap((path17) => {
+    const root = normalizeSkillRoot2(path17);
+    return root ? [root] : [];
+  }))).sort();
+}
 async function removeKitFromManifest(claudeDir3, kit, options2) {
-  const metadataPath = join112(claudeDir3, "metadata.json");
-  if (!await import_fs_extra17.pathExists(metadataPath))
+  const metadataPath = join113(claudeDir3, "metadata.json");
+  if (!await import_fs_extra18.pathExists(metadataPath))
     return false;
   let release = null;
   try {
@@ -104727,7 +104864,7 @@ async function removeKitFromManifest(claudeDir3, kit, options2) {
       return false;
     const { [kit]: _removed, ...remainingKits } = metadata.kits;
     if (Object.keys(remainingKits).length === 0) {
-      await import_fs_extra17.remove(metadataPath);
+      await import_fs_extra18.remove(metadataPath);
       logger.debug("No kits remaining, removed metadata.json");
       return true;
     }
@@ -104735,7 +104872,7 @@ async function removeKitFromManifest(claudeDir3, kit, options2) {
       ...metadata,
       kits: remainingKits
     };
-    await import_fs_extra17.writeFile(metadataPath, JSON.stringify(updated, null, 2), "utf-8");
+    await import_fs_extra18.writeFile(metadataPath, JSON.stringify(updated, null, 2), "utf-8");
     logger.debug(`Removed kit "${kit}" from metadata, ${Object.keys(remainingKits).length} kit(s) remaining`);
     return true;
   } finally {
@@ -104746,8 +104883,8 @@ async function removeKitFromManifest(claudeDir3, kit, options2) {
   }
 }
 async function retainTrackedFilesInManifest(claudeDir3, retainedPaths, options2) {
-  const metadataPath = join112(claudeDir3, "metadata.json");
-  if (!await import_fs_extra17.pathExists(metadataPath))
+  const metadataPath = join113(claudeDir3, "metadata.json");
+  if (!await import_fs_extra18.pathExists(metadataPath))
     return false;
   const normalizedPaths = new Set(retainedPaths.map((path17) => path17.replace(/\\/g, "/")));
   if (normalizedPaths.size === 0)
@@ -104796,7 +104933,7 @@ async function retainTrackedFilesInManifest(claudeDir3, retainedPaths, options2)
         files: retainedFiles2.length > 0 ? retainedFiles2 : undefined,
         installedFiles: retainedInstalledFiles2.length > 0 ? retainedInstalledFiles2 : undefined
       });
-      await import_fs_extra17.writeFile(metadataPath, JSON.stringify(updated2, null, 2), "utf-8");
+      await import_fs_extra18.writeFile(metadataPath, JSON.stringify(updated2, null, 2), "utf-8");
       return true;
     }
     const retainedFiles = (metadata.files || []).flatMap((file) => {
@@ -104820,7 +104957,7 @@ async function retainTrackedFilesInManifest(claudeDir3, retainedPaths, options2)
       files: retainedFiles.length > 0 ? retainedFiles : undefined,
       installedFiles: retainedInstalledFiles.length > 0 ? retainedInstalledFiles : undefined
     });
-    await import_fs_extra17.writeFile(metadataPath, JSON.stringify(updated, null, 2), "utf-8");
+    await import_fs_extra18.writeFile(metadataPath, JSON.stringify(updated, null, 2), "utf-8");
     return true;
   } finally {
     if (release) {
@@ -104927,7 +105064,7 @@ function buildFileTrackingList(options2) {
     if (!isGlobal && !installedPath.startsWith(".claude/"))
       continue;
     const relativePath = isGlobal ? installedPath : installedPath.replace(/^\.claude\//, "");
-    const filePath = join113(claudeDir3, relativePath);
+    const filePath = join114(claudeDir3, relativePath);
     const manifestEntry = releaseManifest ? ReleaseManifestLoader.findFile(releaseManifest, installedPath) : null;
     const ownership = manifestEntry ? "ck" : "user";
     filesToTrack.push({
@@ -104951,7 +105088,7 @@ async function trackFilesWithProgress(filesToTrack, manifestOptions) {
     }
   });
   trackingSpinner.succeed(`Tracked ${trackResult.success} files`);
-  await writeManifest(manifestOptions.claudeDir, manifestOptions.kitName, manifestOptions.releaseTag, manifestOptions.mode, manifestOptions.kitType, tracker.getTrackedFiles(), tracker.getUserConfigFiles());
+  await writeManifest(manifestOptions.claudeDir, manifestOptions.kitName, manifestOptions.releaseTag, manifestOptions.mode, manifestOptions.kitType, tracker.getTrackedFiles(), tracker.getUserConfigFiles(), manifestOptions.ignoredSkills);
   return trackResult;
 }
 // src/services/file-operations/manifest-writer.ts
@@ -104981,8 +105118,8 @@ class ManifestWriter {
   getTrackedFiles() {
     return this.tracker.getTrackedFiles();
   }
-  async writeManifest(claudeDir3, kitName, version, scope, kitType) {
-    return writeManifest(claudeDir3, kitName, version, scope, kitType, this.getTrackedFiles(), this.getUserConfigFiles());
+  async writeManifest(claudeDir3, kitName, version, scope, kitType, ignoredSkills) {
+    return writeManifest(claudeDir3, kitName, version, scope, kitType, this.getTrackedFiles(), this.getUserConfigFiles(), ignoredSkills);
   }
   static async readManifest(claudeDir3) {
     return readManifest(claudeDir3);
@@ -105005,7 +105142,7 @@ class ManifestWriter {
 init_environment();
 init_logger();
 init_skip_directories();
-var import_fs_extra18 = __toESM(require_lib(), 1);
+var import_fs_extra19 = __toESM(require_lib(), 1);
 class LegacyMigration {
   static async detectLegacy(claudeDir3) {
     const metadata = await ManifestWriter.readManifest(claudeDir3);
@@ -105038,7 +105175,7 @@ class LegacyMigration {
         continue;
       if (SKIP_DIRS_ALL.includes(entry))
         continue;
-      const fullPath = join114(dir, entry);
+      const fullPath = join115(dir, entry);
       let stats;
       try {
         stats = await stat19(fullPath);
@@ -105064,7 +105201,7 @@ class LegacyMigration {
   static async classifyFiles(claudeDir3, manifest) {
     const files = await LegacyMigration.scanFiles(claudeDir3);
     const relevantFiles = files.filter((file) => {
-      const relativePath = relative24(claudeDir3, file);
+      const relativePath = relative25(claudeDir3, file);
       return !hasSkippedDirectorySegment(relativePath);
     });
     const skippedRuntimeArtifacts = files.length - relevantFiles.length;
@@ -105079,7 +105216,7 @@ class LegacyMigration {
     };
     const filesInManifest = [];
     for (const file of relevantFiles) {
-      const relativePath = relative24(claudeDir3, file).replace(/\\/g, "/");
+      const relativePath = relative25(claudeDir3, file).replace(/\\/g, "/");
       const manifestEntry = ReleaseManifestLoader.findFile(manifest, relativePath);
       if (!manifestEntry) {
         preview.userCreated.push(relativePath);
@@ -105148,7 +105285,7 @@ User-created files (sample):`);
     ];
     if (filesToChecksum.length > 0) {
       const checksumResults = await mapWithLimit(filesToChecksum, async ({ relativePath, ownership }) => {
-        const fullPath = join114(claudeDir3, relativePath);
+        const fullPath = join115(claudeDir3, relativePath);
         const checksum = await OwnershipChecker.calculateChecksum(fullPath);
         return { relativePath, checksum, ownership };
       }, getOptimalConcurrency());
@@ -105169,8 +105306,8 @@ User-created files (sample):`);
       installedAt: new Date().toISOString(),
       files: trackedFiles
     };
-    const metadataPath = join114(claudeDir3, "metadata.json");
-    await import_fs_extra18.writeFile(metadataPath, JSON.stringify(updatedMetadata, null, 2));
+    const metadataPath = join115(claudeDir3, "metadata.json");
+    await import_fs_extra19.writeFile(metadataPath, JSON.stringify(updatedMetadata, null, 2));
     logger.success(`Migration complete: tracked ${trackedFiles.length} files`);
     return true;
   }
@@ -105274,31 +105411,31 @@ function buildConflictSummary(fileConflicts, hookConflicts, mcpConflicts) {
 // src/services/file-operations/file-scanner.ts
 init_logger();
 init_skip_directories();
-var import_fs_extra19 = __toESM(require_lib(), 1);
-import { join as join115, relative as relative25, resolve as resolve43 } from "node:path";
+var import_fs_extra20 = __toESM(require_lib(), 1);
+import { join as join116, relative as relative26, resolve as resolve43 } from "node:path";
 
 class FileScanner2 {
   static async getFiles(dirPath, relativeTo) {
     const basePath = relativeTo || dirPath;
     const files = [];
-    if (!await import_fs_extra19.pathExists(dirPath)) {
+    if (!await import_fs_extra20.pathExists(dirPath)) {
       return files;
     }
     try {
-      const entries = await import_fs_extra19.readdir(dirPath, { encoding: "utf8" });
+      const entries = await import_fs_extra20.readdir(dirPath, { encoding: "utf8" });
       for (const entry of entries) {
         if (SKIP_DIRS_ALL.includes(entry)) {
           logger.debug(`Skipping directory: ${entry}`);
           continue;
         }
-        const fullPath = join115(dirPath, entry);
+        const fullPath = join116(dirPath, entry);
         if (!FileScanner2.isSafePath(basePath, fullPath)) {
           logger.warning(`Skipping potentially unsafe path: ${entry}`);
           continue;
         }
         let stats;
         try {
-          stats = await import_fs_extra19.lstat(fullPath);
+          stats = await import_fs_extra20.lstat(fullPath);
         } catch (error) {
           if (error instanceof Error && "code" in error && (error.code === "EACCES" || error.code === "EPERM")) {
             logger.warning(`Skipping inaccessible path: ${entry}`);
@@ -105314,7 +105451,7 @@ class FileScanner2 {
           const subFiles = await FileScanner2.getFiles(fullPath, basePath);
           files.push(...subFiles);
         } else if (stats.isFile()) {
-          const relativePath = relative25(basePath, fullPath);
+          const relativePath = relative26(basePath, fullPath);
           files.push(FileScanner2.toPosixPath(relativePath));
         }
       }
@@ -105326,8 +105463,8 @@ class FileScanner2 {
     return files;
   }
   static async findCustomFiles(destDir, sourceDir, subPath) {
-    const destSubDir = join115(destDir, subPath);
-    const sourceSubDir = join115(sourceDir, subPath);
+    const destSubDir = join116(destDir, subPath);
+    const sourceSubDir = join116(sourceDir, subPath);
     logger.debug(`findCustomFiles - destDir: ${destDir}`);
     logger.debug(`findCustomFiles - sourceDir: ${sourceDir}`);
     logger.debug(`findCustomFiles - subPath: "${subPath}"`);
@@ -105337,7 +105474,7 @@ class FileScanner2 {
     const sourceFiles = await FileScanner2.getFiles(sourceSubDir, sourceDir);
     logger.debug(`findCustomFiles - destFiles count: ${destFiles.length}`);
     logger.debug(`findCustomFiles - sourceFiles count: ${sourceFiles.length}`);
-    const sourceExists = await import_fs_extra19.pathExists(sourceSubDir);
+    const sourceExists = await import_fs_extra20.pathExists(sourceSubDir);
     if (sourceExists && sourceFiles.length === 0 && destFiles.length > 100) {
       logger.warning(`Source directory exists but is empty while destination has ${destFiles.length} files. This may indicate an extraction issue. Skipping custom file detection.`);
       return [];
@@ -105366,14 +105503,14 @@ class FileScanner2 {
 
 // src/services/transformers/commands-prefix/prefix-applier.ts
 init_logger();
-var import_fs_extra20 = __toESM(require_lib(), 1);
+var import_fs_extra21 = __toESM(require_lib(), 1);
 import { lstat as lstat10, mkdir as mkdir32, readdir as readdir31, stat as stat20 } from "node:fs/promises";
-import { join as join117 } from "node:path";
+import { join as join118 } from "node:path";
 
 // src/services/transformers/commands-prefix/content-transformer.ts
 init_logger();
 import { readFile as readFile54, readdir as readdir30, writeFile as writeFile29 } from "node:fs/promises";
-import { join as join116 } from "node:path";
+import { join as join117 } from "node:path";
 var TRANSFORMABLE_EXTENSIONS = new Set([
   ".md",
   ".txt",
@@ -105433,7 +105570,7 @@ async function transformCommandReferences(directory, options2 = {}) {
   async function processDirectory(dir) {
     const entries = await readdir30(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join116(dir, entry.name);
+      const fullPath = join117(dir, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name.startsWith(".") && entry.name !== ".claude") {
           continue;
@@ -105508,14 +105645,14 @@ function shouldApplyPrefix(options2) {
 // src/services/transformers/commands-prefix/prefix-applier.ts
 async function applyPrefix(extractDir) {
   validatePath(extractDir, "extractDir");
-  const commandsDir = join117(extractDir, ".claude", "commands");
-  if (!await import_fs_extra20.pathExists(commandsDir)) {
+  const commandsDir = join118(extractDir, ".claude", "commands");
+  if (!await import_fs_extra21.pathExists(commandsDir)) {
     logger.verbose("No commands directory found, skipping prefix application");
     return;
   }
   logger.info("Applying /ck: prefix to slash commands...");
-  const backupDir = join117(extractDir, ".commands-backup");
-  const tempDir = join117(extractDir, ".commands-prefix-temp");
+  const backupDir = join118(extractDir, ".commands-backup");
+  const tempDir = join118(extractDir, ".commands-prefix-temp");
   try {
     const entries = await readdir31(commandsDir);
     if (entries.length === 0) {
@@ -105523,28 +105660,28 @@ async function applyPrefix(extractDir) {
       return;
     }
     if (entries.length === 1 && entries[0] === "ck") {
-      const ckDir2 = join117(commandsDir, "ck");
+      const ckDir2 = join118(commandsDir, "ck");
       const ckStat = await stat20(ckDir2);
       if (ckStat.isDirectory()) {
         logger.verbose("Commands already have /ck: prefix, skipping");
         return;
       }
     }
-    await import_fs_extra20.copy(commandsDir, backupDir);
+    await import_fs_extra21.copy(commandsDir, backupDir);
     logger.verbose("Created backup of commands directory");
     await mkdir32(tempDir, { recursive: true });
-    const ckDir = join117(tempDir, "ck");
+    const ckDir = join118(tempDir, "ck");
     await mkdir32(ckDir, { recursive: true });
     let processedCount = 0;
     for (const entry of entries) {
-      const sourcePath = join117(commandsDir, entry);
+      const sourcePath = join118(commandsDir, entry);
       const stats = await lstat10(sourcePath);
       if (stats.isSymbolicLink()) {
         logger.warning(`Skipping symlink for security: ${entry}`);
         continue;
       }
-      const destPath = join117(ckDir, entry);
-      await import_fs_extra20.copy(sourcePath, destPath, {
+      const destPath = join118(ckDir, entry);
+      await import_fs_extra21.copy(sourcePath, destPath, {
         overwrite: false,
         errorOnExist: true
       });
@@ -105553,15 +105690,15 @@ async function applyPrefix(extractDir) {
     }
     if (processedCount === 0) {
       logger.warning("No files to move (all were symlinks or invalid)");
-      await import_fs_extra20.remove(backupDir);
-      await import_fs_extra20.remove(tempDir);
+      await import_fs_extra21.remove(backupDir);
+      await import_fs_extra21.remove(tempDir);
       return;
     }
-    await import_fs_extra20.remove(commandsDir);
-    await import_fs_extra20.move(tempDir, commandsDir);
-    await import_fs_extra20.remove(backupDir);
+    await import_fs_extra21.remove(commandsDir);
+    await import_fs_extra21.move(tempDir, commandsDir);
+    await import_fs_extra21.remove(backupDir);
     logger.success("Successfully reorganized commands to /ck: prefix");
-    const claudeDir3 = join117(extractDir, ".claude");
+    const claudeDir3 = join118(extractDir, ".claude");
     logger.info("Transforming command references in file contents...");
     const transformResult = await transformCommandReferences(claudeDir3, {
       verbose: logger.isVerbose()
@@ -105572,26 +105709,26 @@ async function applyPrefix(extractDir) {
       logger.verbose("No command references needed transformation");
     }
   } catch (error) {
-    if (await import_fs_extra20.pathExists(backupDir)) {
+    if (await import_fs_extra21.pathExists(backupDir)) {
       try {
-        await import_fs_extra20.remove(commandsDir).catch(() => {});
-        await import_fs_extra20.move(backupDir, commandsDir);
+        await import_fs_extra21.remove(commandsDir).catch(() => {});
+        await import_fs_extra21.move(backupDir, commandsDir);
         logger.info("Restored original commands directory from backup");
       } catch (rollbackError) {
         logger.error(`Rollback failed: ${rollbackError}`);
       }
     }
-    if (await import_fs_extra20.pathExists(tempDir)) {
-      await import_fs_extra20.remove(tempDir).catch(() => {});
+    if (await import_fs_extra21.pathExists(tempDir)) {
+      await import_fs_extra21.remove(tempDir).catch(() => {});
     }
     logger.error("Failed to apply /ck: prefix to commands");
     throw error;
   } finally {
-    if (await import_fs_extra20.pathExists(backupDir)) {
-      await import_fs_extra20.remove(backupDir).catch(() => {});
+    if (await import_fs_extra21.pathExists(backupDir)) {
+      await import_fs_extra21.remove(backupDir).catch(() => {});
     }
-    if (await import_fs_extra20.pathExists(tempDir)) {
-      await import_fs_extra20.remove(tempDir).catch(() => {});
+    if (await import_fs_extra21.pathExists(tempDir)) {
+      await import_fs_extra21.remove(tempDir).catch(() => {});
     }
   }
 }
@@ -105599,20 +105736,20 @@ async function applyPrefix(extractDir) {
 // src/services/transformers/commands-prefix/prefix-cleaner.ts
 init_metadata_migration();
 import { lstat as lstat12, readdir as readdir33 } from "node:fs/promises";
-import { join as join119 } from "node:path";
+import { join as join120 } from "node:path";
 init_logger();
-var import_fs_extra22 = __toESM(require_lib(), 1);
+var import_fs_extra23 = __toESM(require_lib(), 1);
 
 // src/services/transformers/commands-prefix/file-processor.ts
 import { lstat as lstat11, readdir as readdir32 } from "node:fs/promises";
-import { join as join118 } from "node:path";
+import { join as join119 } from "node:path";
 init_logger();
-var import_fs_extra21 = __toESM(require_lib(), 1);
+var import_fs_extra22 = __toESM(require_lib(), 1);
 async function scanDirectoryFiles(dir) {
   const files = [];
   const entries = await readdir32(dir);
   for (const entry of entries) {
-    const fullPath = join118(dir, entry);
+    const fullPath = join119(dir, entry);
     const stats = await lstat11(fullPath);
     if (stats.isSymbolicLink()) {
       continue;
@@ -105635,7 +105772,7 @@ async function processFileOwnership(file, relativePath, metadata, claudeDir3, op
       action: "delete"
     });
     if (!dryRun) {
-      await import_fs_extra21.remove(file);
+      await import_fs_extra22.remove(file);
       logger.verbose(`Deleted CK file: ${relativePath}`);
     }
     accumulator.deletedCount++;
@@ -105650,7 +105787,7 @@ async function processFileOwnership(file, relativePath, metadata, claudeDir3, op
         reason: "force overwrite"
       });
       if (!dryRun) {
-        await import_fs_extra21.remove(file);
+        await import_fs_extra22.remove(file);
         logger.verbose(`Force-deleted modified file: ${relativePath}`);
       }
       accumulator.deletedCount++;
@@ -105674,7 +105811,7 @@ async function processFileOwnership(file, relativePath, metadata, claudeDir3, op
       reason: "force overwrite"
     });
     if (!dryRun) {
-      await import_fs_extra21.remove(file);
+      await import_fs_extra22.remove(file);
       logger.verbose(`Force-deleted user file: ${relativePath}`);
     }
     accumulator.deletedCount++;
@@ -105740,8 +105877,8 @@ function isDifferentKitDirectory(dirName, currentKit) {
 async function cleanupCommandsDirectory(targetDir, isGlobal, options2 = {}) {
   const { dryRun = false } = options2;
   validatePath(targetDir, "targetDir");
-  const claudeDir3 = isGlobal ? targetDir : join119(targetDir, ".claude");
-  const commandsDir = join119(claudeDir3, "commands");
+  const claudeDir3 = isGlobal ? targetDir : join120(targetDir, ".claude");
+  const commandsDir = join120(claudeDir3, "commands");
   const accumulator = {
     results: [],
     deletedCount: 0,
@@ -105753,7 +105890,7 @@ async function cleanupCommandsDirectory(targetDir, isGlobal, options2 = {}) {
     preservedCount: 0,
     wasDryRun: dryRun
   };
-  if (!await import_fs_extra22.pathExists(commandsDir)) {
+  if (!await import_fs_extra23.pathExists(commandsDir)) {
     logger.verbose(`Commands directory does not exist: ${commandsDir}`);
     return result;
   }
@@ -105783,7 +105920,7 @@ async function cleanupCommandsDirectory(targetDir, isGlobal, options2 = {}) {
   }
   const metadataForChecks = options2.kitType ? createKitSpecificMetadata(metadata, options2.kitType) : metadata;
   for (const entry of entries) {
-    const entryPath = join119(commandsDir, entry);
+    const entryPath = join120(commandsDir, entry);
     const stats = await lstat12(entryPath);
     if (stats.isSymbolicLink()) {
       addSymlinkSkip(entry, accumulator);
@@ -105816,7 +105953,7 @@ async function processDirectory(entryPath, entry, claudeDir3, metadata, options2
     }
   }
   if (canDeleteDir && !dryRun) {
-    await import_fs_extra22.remove(entryPath);
+    await import_fs_extra23.remove(entryPath);
     logger.verbose(`Removed directory: ${entry}`);
   }
 }
@@ -105831,7 +105968,7 @@ class CommandsPrefix {
 // src/commands/init/phases/merge-handler.ts
 init_logger();
 init_output_manager();
-var import_fs_extra23 = __toESM(require_lib(), 1);
+var import_fs_extra24 = __toESM(require_lib(), 1);
 async function handleMerge(ctx) {
   if (ctx.cancelled || !ctx.extractDir || !ctx.resolvedDir || !ctx.claudeDir || !ctx.kit || !ctx.kitType) {
     return ctx;
@@ -105840,7 +105977,7 @@ async function handleMerge(ctx) {
   let customClaudeFiles = [];
   if (!ctx.options.fresh) {
     logger.info("Scanning for custom .claude files...");
-    const scanSourceDir = ctx.options.global ? join120(ctx.extractDir, ".claude") : ctx.extractDir;
+    const scanSourceDir = ctx.options.global ? join121(ctx.extractDir, ".claude") : ctx.extractDir;
     const scanTargetSubdir = ctx.options.global ? "" : ".claude";
     customClaudeFiles = await FileScanner2.findCustomFiles(ctx.resolvedDir, scanSourceDir, scanTargetSubdir);
   } else {
@@ -105875,10 +106012,11 @@ async function handleMerge(ctx) {
   }
   merger.setGlobalFlag(ctx.options.global);
   merger.setForceOverwriteSettings(ctx.options.forceOverwriteSettings);
+  merger.setPreserveDeletedSkills(!ctx.options.forceOverwrite && !ctx.options.fresh);
   merger.setRestoreCkHooks(ctx.options.restoreCkHooks);
   merger.setProjectDir(ctx.resolvedDir);
   merger.setKitName(ctx.kit.name);
-  merger.setZombiePrunerHookDir(join120(ctx.claudeDir, "hooks"));
+  merger.setZombiePrunerHookDir(join121(ctx.claudeDir, "hooks"));
   if (ctx.kitType) {
     merger.setMultiKitContext(ctx.claudeDir, ctx.kitType);
   }
@@ -105886,7 +106024,7 @@ async function handleMerge(ctx) {
   if (releaseManifest) {
     merger.setManifest(releaseManifest);
   }
-  if (!ctx.options.fresh && await import_fs_extra23.pathExists(ctx.claudeDir)) {
+  if (!ctx.options.fresh && await import_fs_extra24.pathExists(ctx.claudeDir)) {
     const legacyDetection = await LegacyMigration.detectLegacy(ctx.claudeDir);
     if (legacyDetection.isLegacy && releaseManifest) {
       logger.info("Legacy installation detected - migrating to ownership tracking...");
@@ -105907,12 +106045,12 @@ async function handleMerge(ctx) {
       return { ...ctx, cancelled: true };
     }
   }
-  const sourceDir = ctx.options.global ? join120(ctx.extractDir, ".claude") : ctx.extractDir;
-  const sourceMetadataPath = ctx.options.global ? join120(sourceDir, "metadata.json") : join120(sourceDir, ".claude", "metadata.json");
+  const sourceDir = ctx.options.global ? join121(ctx.extractDir, ".claude") : ctx.extractDir;
+  const sourceMetadataPath = ctx.options.global ? join121(sourceDir, "metadata.json") : join121(sourceDir, ".claude", "metadata.json");
   let sourceMetadata = null;
   try {
-    if (await import_fs_extra23.pathExists(sourceMetadataPath)) {
-      const metadataContent = await import_fs_extra23.readFile(sourceMetadataPath, "utf-8");
+    if (await import_fs_extra24.pathExists(sourceMetadataPath)) {
+      const metadataContent = await import_fs_extra24.readFile(sourceMetadataPath, "utf-8");
       sourceMetadata = JSON.parse(metadataContent);
     }
   } catch (error) {
@@ -105956,7 +106094,8 @@ async function handleMerge(ctx) {
     kitName: ctx.kit.name,
     releaseTag: installedVersion,
     mode: ctx.options.global ? "global" : "local",
-    kitType: ctx.kitType
+    kitType: ctx.kitType,
+    ignoredSkills: merger.getIgnoredSkillDirectories()
   });
   return {
     ...ctx,
@@ -105965,11 +106104,11 @@ async function handleMerge(ctx) {
   };
 }
 // src/commands/init/phases/migration-handler.ts
-import { join as join128 } from "node:path";
+import { join as join129 } from "node:path";
 
 // src/domains/skills/skills-detector.ts
 init_logger();
-var import_fs_extra26 = __toESM(require_lib(), 1);
+var import_fs_extra27 = __toESM(require_lib(), 1);
 
 // src/domains/skills/detection/config-detector.ts
 init_logger();
@@ -105978,17 +106117,17 @@ init_logger();
 init_logger();
 init_skip_directories();
 init_types3();
-var import_fs_extra24 = __toESM(require_lib(), 1);
+var import_fs_extra25 = __toESM(require_lib(), 1);
 import { createHash as createHash7 } from "node:crypto";
 import { readFile as readFile56, readdir as readdir34, writeFile as writeFile30 } from "node:fs/promises";
-import { join as join121, relative as relative26 } from "node:path";
+import { join as join122, relative as relative27 } from "node:path";
 
 class SkillsManifestManager {
   static MANIFEST_FILENAME = ".skills-manifest.json";
   static MANIFEST_VERSION = "1.0.0";
   static async generateManifest(skillsDir2) {
     logger.debug(`Generating manifest for: ${skillsDir2}`);
-    if (!await import_fs_extra24.pathExists(skillsDir2)) {
+    if (!await import_fs_extra25.pathExists(skillsDir2)) {
       throw new SkillsMigrationError(`Skills directory does not exist: ${skillsDir2}`);
     }
     const structure = await SkillsManifestManager.detectStructure(skillsDir2);
@@ -106003,13 +106142,13 @@ class SkillsManifestManager {
     return manifest;
   }
   static async writeManifest(skillsDir2, manifest) {
-    const manifestPath = join121(skillsDir2, SkillsManifestManager.MANIFEST_FILENAME);
+    const manifestPath = join122(skillsDir2, SkillsManifestManager.MANIFEST_FILENAME);
     await writeFile30(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
     logger.debug(`Wrote manifest to: ${manifestPath}`);
   }
   static async readManifest(skillsDir2) {
-    const manifestPath = join121(skillsDir2, SkillsManifestManager.MANIFEST_FILENAME);
-    if (!await import_fs_extra24.pathExists(manifestPath)) {
+    const manifestPath = join122(skillsDir2, SkillsManifestManager.MANIFEST_FILENAME);
+    if (!await import_fs_extra25.pathExists(manifestPath)) {
       logger.debug(`No manifest found at: ${manifestPath}`);
       return null;
     }
@@ -106031,7 +106170,7 @@ class SkillsManifestManager {
       return "flat";
     }
     for (const dir of dirs.slice(0, 3)) {
-      const dirPath = join121(skillsDir2, dir.name);
+      const dirPath = join122(skillsDir2, dir.name);
       const subEntries = await readdir34(dirPath, { withFileTypes: true });
       const hasSubdirs = subEntries.some((entry) => entry.isDirectory());
       if (hasSubdirs) {
@@ -106050,7 +106189,7 @@ class SkillsManifestManager {
       const entries = await readdir34(skillsDir2, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isDirectory() && !BUILD_ARTIFACT_DIRS.includes(entry.name) && !entry.name.startsWith(".")) {
-          const skillPath = join121(skillsDir2, entry.name);
+          const skillPath = join122(skillsDir2, entry.name);
           const hash = await SkillsManifestManager.hashDirectory(skillPath);
           skills.push({
             name: entry.name,
@@ -106062,11 +106201,11 @@ class SkillsManifestManager {
       const categories = await readdir34(skillsDir2, { withFileTypes: true });
       for (const category of categories) {
         if (category.isDirectory() && !BUILD_ARTIFACT_DIRS.includes(category.name) && !category.name.startsWith(".")) {
-          const categoryPath = join121(skillsDir2, category.name);
+          const categoryPath = join122(skillsDir2, category.name);
           const skillEntries = await readdir34(categoryPath, { withFileTypes: true });
           for (const skillEntry of skillEntries) {
             if (skillEntry.isDirectory() && !skillEntry.name.startsWith(".")) {
-              const skillPath = join121(categoryPath, skillEntry.name);
+              const skillPath = join122(categoryPath, skillEntry.name);
               const hash = await SkillsManifestManager.hashDirectory(skillPath);
               skills.push({
                 name: skillEntry.name,
@@ -106085,7 +106224,7 @@ class SkillsManifestManager {
     const files = await SkillsManifestManager.getAllFiles(dirPath);
     files.sort();
     for (const file of files) {
-      const relativePath = relative26(dirPath, file);
+      const relativePath = relative27(dirPath, file);
       const content = await readFile56(file);
       hash.update(relativePath);
       hash.update(content);
@@ -106096,7 +106235,7 @@ class SkillsManifestManager {
     const files = [];
     const entries = await readdir34(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join121(dirPath, entry.name);
+      const fullPath = join122(dirPath, entry.name);
       if (entry.name.startsWith(".") || BUILD_ARTIFACT_DIRS.includes(entry.name)) {
         continue;
       }
@@ -106216,11 +106355,11 @@ function getPathMapping(skillName, oldBasePath, newBasePath) {
 }
 
 // src/domains/skills/detection/script-detector.ts
-var import_fs_extra25 = __toESM(require_lib(), 1);
+var import_fs_extra26 = __toESM(require_lib(), 1);
 import { readdir as readdir35 } from "node:fs/promises";
-import { join as join122 } from "node:path";
+import { join as join123 } from "node:path";
 async function scanDirectory(skillsDir2) {
-  if (!await import_fs_extra25.pathExists(skillsDir2)) {
+  if (!await import_fs_extra26.pathExists(skillsDir2)) {
     return ["flat", []];
   }
   const entries = await readdir35(skillsDir2, { withFileTypes: true });
@@ -106231,12 +106370,12 @@ async function scanDirectory(skillsDir2) {
   let totalSkillLikeCount = 0;
   const allSkills = [];
   for (const dir of dirs) {
-    const dirPath = join122(skillsDir2, dir.name);
+    const dirPath = join123(skillsDir2, dir.name);
     const subEntries = await readdir35(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 = join122(dirPath, subdir.name);
+        const subdirPath = join123(dirPath, subdir.name);
         const subdirFiles = await readdir35(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) {
@@ -106358,8 +106497,8 @@ async function detectViaManifest(oldSkillsDir, currentSkillsDir) {
 class SkillsMigrationDetector {
   static async detectMigration(oldSkillsDir, currentSkillsDir) {
     logger.debug("Detecting skills migration need...");
-    const oldExists = await import_fs_extra26.pathExists(oldSkillsDir);
-    const currentExists = await import_fs_extra26.pathExists(currentSkillsDir);
+    const oldExists = await import_fs_extra27.pathExists(oldSkillsDir);
+    const currentExists = await import_fs_extra27.pathExists(currentSkillsDir);
     if (!oldExists && !currentExists) {
       logger.debug("No skills directories found, migration not needed");
       return {
@@ -106393,13 +106532,13 @@ class SkillsMigrationDetector {
 // src/domains/skills/skills-migrator.ts
 init_logger();
 init_types3();
-import { join as join127 } from "node:path";
+import { join as join128 } from "node:path";
 
 // src/domains/skills/migrator/migration-executor.ts
 init_logger();
 import { copyFile as copyFile6, mkdir as mkdir33, readdir as readdir36, rm as rm13 } from "node:fs/promises";
-import { join as join123 } from "node:path";
-var import_fs_extra27 = __toESM(require_lib(), 1);
+import { join as join124 } from "node:path";
+var import_fs_extra28 = __toESM(require_lib(), 1);
 
 // src/domains/skills/skills-migration-prompts.ts
 init_environment();
@@ -106563,8 +106702,8 @@ async function copySkillDirectory(sourceDir, destDir) {
   await mkdir33(destDir, { recursive: true });
   const entries = await readdir36(sourceDir, { withFileTypes: true });
   for (const entry of entries) {
-    const sourcePath = join123(sourceDir, entry.name);
-    const destPath = join123(destDir, entry.name);
+    const sourcePath = join124(sourceDir, entry.name);
+    const destPath = join124(destDir, entry.name);
     if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.isSymbolicLink()) {
       continue;
     }
@@ -106579,14 +106718,14 @@ async function executeInternal(mappings, customizations, currentSkillsDir, inter
   const migrated = [];
   const preserved = [];
   const errors2 = [];
-  const tempDir = join123(currentSkillsDir, "..", ".skills-migration-temp");
+  const tempDir = join124(currentSkillsDir, "..", ".skills-migration-temp");
   await mkdir33(tempDir, { recursive: true });
   try {
     for (const mapping of mappings) {
       try {
         const skillName = mapping.skillName;
         const currentSkillPath = mapping.oldPath;
-        if (!await import_fs_extra27.pathExists(currentSkillPath)) {
+        if (!await import_fs_extra28.pathExists(currentSkillPath)) {
           logger.warning(`Skill not found, skipping: ${skillName}`);
           continue;
         }
@@ -106600,9 +106739,9 @@ async function executeInternal(mappings, customizations, currentSkillsDir, inter
           }
         }
         const category = mapping.category;
-        const targetPath = category ? join123(tempDir, category, skillName) : join123(tempDir, skillName);
+        const targetPath = category ? join124(tempDir, category, skillName) : join124(tempDir, skillName);
         if (category) {
-          await mkdir33(join123(tempDir, category), { recursive: true });
+          await mkdir33(join124(tempDir, category), { recursive: true });
         }
         await copySkillDirectory(currentSkillPath, targetPath);
         migrated.push(skillName);
@@ -106667,9 +106806,9 @@ function validateMigrationPath(path17, paramName) {
 // src/domains/skills/skills-backup-manager.ts
 init_logger();
 init_types3();
-var import_fs_extra28 = __toESM(require_lib(), 1);
+var import_fs_extra29 = __toESM(require_lib(), 1);
 import { copyFile as copyFile7, mkdir as mkdir34, readdir as readdir37, rm as rm14, stat as stat21 } from "node:fs/promises";
-import { basename as basename27, join as join124, normalize as normalize9 } from "node:path";
+import { basename as basename27, join as join125, normalize as normalize9 } from "node:path";
 function validatePath2(path17, paramName) {
   if (!path17 || typeof path17 !== "string") {
     throw new SkillsMigrationError(`${paramName} must be a non-empty string`);
@@ -106689,13 +106828,13 @@ class SkillsBackupManager {
     if (parentDir) {
       validatePath2(parentDir, "parentDir");
     }
-    if (!await import_fs_extra28.pathExists(skillsDir2)) {
+    if (!await import_fs_extra29.pathExists(skillsDir2)) {
       throw new SkillsMigrationError(`Cannot create backup: Skills directory does not exist: ${skillsDir2}`);
     }
     const timestamp = Date.now();
     const randomSuffix = Math.random().toString(36).substring(2, 8);
     const backupDirName = `${SkillsBackupManager.BACKUP_PREFIX}${timestamp}-${randomSuffix}`;
-    const backupDir = parentDir ? join124(parentDir, backupDirName) : join124(skillsDir2, "..", backupDirName);
+    const backupDir = parentDir ? join125(parentDir, backupDirName) : join125(skillsDir2, "..", backupDirName);
     logger.info(`Creating backup at: ${backupDir}`);
     try {
       await mkdir34(backupDir, { recursive: true });
@@ -106712,12 +106851,12 @@ class SkillsBackupManager {
   static async restoreBackup(backupDir, targetDir) {
     validatePath2(backupDir, "backupDir");
     validatePath2(targetDir, "targetDir");
-    if (!await import_fs_extra28.pathExists(backupDir)) {
+    if (!await import_fs_extra29.pathExists(backupDir)) {
       throw new SkillsMigrationError(`Cannot restore: Backup directory does not exist: ${backupDir}`);
     }
     logger.info(`Restoring from backup: ${backupDir}`);
     try {
-      if (await import_fs_extra28.pathExists(targetDir)) {
+      if (await import_fs_extra29.pathExists(targetDir)) {
         await rm14(targetDir, { recursive: true, force: true });
       }
       await mkdir34(targetDir, { recursive: true });
@@ -106728,7 +106867,7 @@ class SkillsBackupManager {
     }
   }
   static async deleteBackup(backupDir) {
-    if (!await import_fs_extra28.pathExists(backupDir)) {
+    if (!await import_fs_extra29.pathExists(backupDir)) {
       logger.warning(`Backup directory does not exist: ${backupDir}`);
       return;
     }
@@ -106741,12 +106880,12 @@ class SkillsBackupManager {
     }
   }
   static async listBackups(parentDir) {
-    if (!await import_fs_extra28.pathExists(parentDir)) {
+    if (!await import_fs_extra29.pathExists(parentDir)) {
       return [];
     }
     try {
       const entries = await readdir37(parentDir, { withFileTypes: true });
-      const backups = entries.filter((entry) => entry.isDirectory() && entry.name.startsWith(SkillsBackupManager.BACKUP_PREFIX)).map((entry) => join124(parentDir, entry.name));
+      const backups = entries.filter((entry) => entry.isDirectory() && entry.name.startsWith(SkillsBackupManager.BACKUP_PREFIX)).map((entry) => join125(parentDir, entry.name));
       backups.sort().reverse();
       return backups;
     } catch (error) {
@@ -106766,7 +106905,7 @@ class SkillsBackupManager {
     }
   }
   static async getBackupSize(backupDir) {
-    if (!await import_fs_extra28.pathExists(backupDir)) {
+    if (!await import_fs_extra29.pathExists(backupDir)) {
       return 0;
     }
     return await SkillsBackupManager.getDirectorySize(backupDir);
@@ -106774,8 +106913,8 @@ class SkillsBackupManager {
   static async copyDirectory(sourceDir, destDir) {
     const entries = await readdir37(sourceDir, { withFileTypes: true });
     for (const entry of entries) {
-      const sourcePath = join124(sourceDir, entry.name);
-      const destPath = join124(destDir, entry.name);
+      const sourcePath = join125(sourceDir, entry.name);
+      const destPath = join125(destDir, entry.name);
       if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.isSymbolicLink()) {
         continue;
       }
@@ -106791,7 +106930,7 @@ class SkillsBackupManager {
     let size = 0;
     const entries = await readdir37(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join124(dirPath, entry.name);
+      const fullPath = join125(dirPath, entry.name);
       if (entry.isSymbolicLink()) {
         continue;
       }
@@ -106819,20 +106958,20 @@ class SkillsBackupManager {
 init_logger();
 
 // src/domains/skills/customization/comparison-engine.ts
-var import_fs_extra29 = __toESM(require_lib(), 1);
-import { relative as relative28 } from "node:path";
+var import_fs_extra30 = __toESM(require_lib(), 1);
+import { relative as relative29 } from "node:path";
 
 // src/domains/skills/customization/hash-calculator.ts
 init_skip_directories();
 import { createHash as createHash8 } from "node:crypto";
 import { createReadStream as createReadStream2 } from "node:fs";
 import { readFile as readFile57, readdir as readdir38 } from "node:fs/promises";
-import { join as join125, relative as relative27 } from "node:path";
+import { join as join126, relative as relative28 } from "node:path";
 async function getAllFiles(dirPath) {
   const files = [];
   const entries = await readdir38(dirPath, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = join125(dirPath, entry.name);
+    const fullPath = join126(dirPath, entry.name);
     if (entry.name.startsWith(".") || BUILD_ARTIFACT_DIRS.includes(entry.name) || entry.isSymbolicLink()) {
       continue;
     }
@@ -106864,7 +107003,7 @@ async function hashDirectory(dirPath) {
   const files = await getAllFiles(dirPath);
   files.sort();
   for (const file of files) {
-    const relativePath = relative27(dirPath, file);
+    const relativePath = relative28(dirPath, file);
     const content = await readFile57(file);
     hash.update(relativePath);
     hash.update(content);
@@ -106898,8 +107037,8 @@ async function compareDirectories(dir1, dir2) {
   if (files1.length !== files2.length) {
     return true;
   }
-  const relFiles1 = files1.map((f3) => relative28(dir1, f3)).sort();
-  const relFiles2 = files2.map((f3) => relative28(dir2, f3)).sort();
+  const relFiles1 = files1.map((f3) => relative29(dir1, f3)).sort();
+  const relFiles2 = files2.map((f3) => relative29(dir2, f3)).sort();
   if (JSON.stringify(relFiles1) !== JSON.stringify(relFiles2)) {
     return true;
   }
@@ -106915,14 +107054,14 @@ async function compareDirectories(dir1, dir2) {
 async function detectFileChanges(currentSkillPath, baselineSkillPath) {
   const changes = [];
   const currentFiles = await getAllFiles(currentSkillPath);
-  const baselineFiles = await import_fs_extra29.pathExists(baselineSkillPath) ? await getAllFiles(baselineSkillPath) : [];
+  const baselineFiles = await import_fs_extra30.pathExists(baselineSkillPath) ? await getAllFiles(baselineSkillPath) : [];
   const currentFileMap = new Map(await Promise.all(currentFiles.map(async (f3) => {
-    const relPath = relative28(currentSkillPath, f3);
+    const relPath = relative29(currentSkillPath, f3);
     const hash = await hashFile(f3);
     return [relPath, hash];
   })));
   const baselineFileMap = new Map(await Promise.all(baselineFiles.map(async (f3) => {
-    const relPath = relative28(baselineSkillPath, f3);
+    const relPath = relative29(baselineSkillPath, f3);
     const hash = await hashFile(f3);
     return [relPath, hash];
   })));
@@ -106957,9 +107096,9 @@ async function detectFileChanges(currentSkillPath, baselineSkillPath) {
 
 // src/domains/skills/customization/scan-reporter.ts
 init_types3();
-var import_fs_extra30 = __toESM(require_lib(), 1);
+var import_fs_extra31 = __toESM(require_lib(), 1);
 import { readdir as readdir39 } from "node:fs/promises";
-import { join as join126, normalize as normalize10 } from "node:path";
+import { join as join127, normalize as normalize10 } from "node:path";
 function validatePath3(path17, paramName) {
   if (!path17 || typeof path17 !== "string") {
     throw new SkillsMigrationError(`${paramName} must be a non-empty string`);
@@ -106972,7 +107111,7 @@ function validatePath3(path17, paramName) {
   }
 }
 async function scanSkillsDirectory(skillsDir2) {
-  if (!await import_fs_extra30.pathExists(skillsDir2)) {
+  if (!await import_fs_extra31.pathExists(skillsDir2)) {
     return ["flat", []];
   }
   const entries = await readdir39(skillsDir2, { withFileTypes: true });
@@ -106980,13 +107119,13 @@ async function scanSkillsDirectory(skillsDir2) {
   if (dirs.length === 0) {
     return ["flat", []];
   }
-  const firstDirPath = join126(skillsDir2, dirs[0].name);
+  const firstDirPath = join127(skillsDir2, dirs[0].name);
   const subEntries = await readdir39(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 = join126(firstDirPath, subdir.name);
+      const subdirPath = join127(firstDirPath, subdir.name);
       const subdirFiles = await readdir39(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) {
@@ -106996,7 +107135,7 @@ async function scanSkillsDirectory(skillsDir2) {
     if (skillLikeCount > 0) {
       const skills = [];
       for (const dir of dirs) {
-        const categoryPath = join126(skillsDir2, dir.name);
+        const categoryPath = join127(skillsDir2, dir.name);
         const skillDirs = await readdir39(categoryPath, { withFileTypes: true });
         skills.push(...skillDirs.filter((entry) => entry.isDirectory() && !entry.name.startsWith(".")).map((entry) => entry.name));
       }
@@ -107006,8 +107145,8 @@ async function scanSkillsDirectory(skillsDir2) {
   return ["flat", dirs.map((dir) => dir.name)];
 }
 async function findSkillPath(skillsDir2, skillName) {
-  const flatPath = join126(skillsDir2, skillName);
-  if (await import_fs_extra30.pathExists(flatPath)) {
+  const flatPath = join127(skillsDir2, skillName);
+  if (await import_fs_extra31.pathExists(flatPath)) {
     return { path: flatPath, category: undefined };
   }
   const entries = await readdir39(skillsDir2, { withFileTypes: true });
@@ -107015,9 +107154,9 @@ async function findSkillPath(skillsDir2, skillName) {
     if (!entry.isDirectory() || entry.name.startsWith(".") || entry.name === "node_modules") {
       continue;
     }
-    const categoryPath = join126(skillsDir2, entry.name);
-    const skillPath = join126(categoryPath, skillName);
-    if (await import_fs_extra30.pathExists(skillPath)) {
+    const categoryPath = join127(skillsDir2, entry.name);
+    const skillPath = join127(categoryPath, skillName);
+    if (await import_fs_extra31.pathExists(skillPath)) {
       return { path: skillPath, category: entry.name };
     }
   }
@@ -107110,7 +107249,7 @@ class SkillsMigrator {
         }
       }
       if (options2.backup && !options2.dryRun) {
-        const claudeDir3 = join127(currentSkillsDir, "..");
+        const claudeDir3 = join128(currentSkillsDir, "..");
         result.backupPath = await SkillsBackupManager.createBackup(currentSkillsDir, claudeDir3);
         logger.success(`Backup created at: ${result.backupPath}`);
       }
@@ -107163,7 +107302,7 @@ class SkillsMigrator {
 // src/commands/init/phases/migration-handler.ts
 init_logger();
 init_path_resolver();
-var import_fs_extra31 = __toESM(require_lib(), 1);
+var import_fs_extra32 = __toESM(require_lib(), 1);
 async function handleMigration(ctx) {
   if (ctx.cancelled || !ctx.extractDir || !ctx.resolvedDir)
     return ctx;
@@ -107171,9 +107310,9 @@ async function handleMigration(ctx) {
     logger.debug("Skipping skills migration (fresh installation)");
     return ctx;
   }
-  const newSkillsDir = join128(ctx.extractDir, ".claude", "skills");
+  const newSkillsDir = join129(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)) {
+  if (!await import_fs_extra32.pathExists(newSkillsDir) || !await import_fs_extra32.pathExists(currentSkillsDir)) {
     return ctx;
   }
   logger.info("Checking for skills directory migration...");
@@ -107195,13 +107334,13 @@ async function handleMigration(ctx) {
 }
 // src/commands/init/phases/opencode-handler.ts
 import { cp as cp4, readdir as readdir41, rm as rm15 } from "node:fs/promises";
-import { join as join130 } from "node:path";
+import { join as join131 } from "node:path";
 
 // src/services/transformers/opencode-path-transformer.ts
 init_logger();
 import { readFile as readFile58, readdir as readdir40, writeFile as writeFile31 } from "node:fs/promises";
 import { platform as platform14 } from "node:os";
-import { extname as extname6, join as join129 } from "node:path";
+import { extname as extname6, join as join130 } from "node:path";
 var IS_WINDOWS2 = platform14() === "win32";
 function getOpenCodeGlobalPath() {
   return "$HOME/.config/opencode/";
@@ -107262,7 +107401,7 @@ async function transformPathsForGlobalOpenCode(directory, options2 = {}) {
   async function processDirectory2(dir) {
     const entries = await readdir40(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join129(dir, entry.name);
+      const fullPath = join130(dir, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name.startsWith(".")) {
           continue;
@@ -107296,13 +107435,13 @@ async function transformPathsForGlobalOpenCode(directory, options2 = {}) {
 // src/commands/init/phases/opencode-handler.ts
 init_logger();
 init_path_resolver();
-var import_fs_extra32 = __toESM(require_lib(), 1);
+var import_fs_extra33 = __toESM(require_lib(), 1);
 async function handleOpenCode(ctx) {
   if (ctx.cancelled || !ctx.extractDir || !ctx.resolvedDir) {
     return ctx;
   }
-  const openCodeSource = join130(ctx.extractDir, ".opencode");
-  if (!await import_fs_extra32.pathExists(openCodeSource)) {
+  const openCodeSource = join131(ctx.extractDir, ".opencode");
+  if (!await import_fs_extra33.pathExists(openCodeSource)) {
     logger.debug("No .opencode directory in archive, skipping");
     return ctx;
   }
@@ -107316,12 +107455,12 @@ async function handleOpenCode(ctx) {
     if (transformResult.totalChanges > 0) {
       logger.success(`Transformed ${transformResult.totalChanges} OpenCode path(s) in ${transformResult.filesTransformed} file(s)`);
     }
-    await import_fs_extra32.ensureDir(targetDir);
+    await import_fs_extra33.ensureDir(targetDir);
     const entries = await readdir41(openCodeSource, { withFileTypes: true });
     for (const entry of entries) {
-      const sourcePath = join130(openCodeSource, entry.name);
-      const targetPath = join130(targetDir, entry.name);
-      if (await import_fs_extra32.pathExists(targetPath)) {
+      const sourcePath = join131(openCodeSource, entry.name);
+      const targetPath = join131(targetDir, entry.name);
+      if (await import_fs_extra33.pathExists(targetPath)) {
         if (!ctx.options.forceOverwrite) {
           logger.verbose(`Skipping existing: ${entry.name}`);
           continue;
@@ -107419,20 +107558,20 @@ Please use only one download method.`);
 }
 // src/commands/init/phases/post-install-handler.ts
 init_projects_registry();
-import { join as join131 } from "node:path";
+import { join as join132 } from "node:path";
 init_logger();
 init_path_resolver();
-var import_fs_extra33 = __toESM(require_lib(), 1);
+var import_fs_extra34 = __toESM(require_lib(), 1);
 async function handlePostInstall(ctx) {
   if (ctx.cancelled || !ctx.extractDir || !ctx.resolvedDir || !ctx.claudeDir) {
     return ctx;
   }
   if (ctx.options.global) {
-    const claudeMdSource = join131(ctx.extractDir, "CLAUDE.md");
-    const claudeMdDest = join131(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);
+    const claudeMdSource = join132(ctx.extractDir, "CLAUDE.md");
+    const claudeMdDest = join132(ctx.resolvedDir, "CLAUDE.md");
+    if (await import_fs_extra34.pathExists(claudeMdSource)) {
+      if (ctx.options.fresh || !await import_fs_extra34.pathExists(claudeMdDest)) {
+        await import_fs_extra34.copy(claudeMdSource, claudeMdDest);
         logger.success(ctx.options.fresh ? "Replaced CLAUDE.md in global directory (fresh install)" : "Copied CLAUDE.md to global directory");
       } else {
         logger.debug("CLAUDE.md already exists in global directory (preserved)");
@@ -107477,7 +107616,7 @@ async function handlePostInstall(ctx) {
   }
   if (!ctx.options.skipSetup) {
     await promptSetupWizardIfNeeded({
-      envPath: join131(ctx.claudeDir, ".env"),
+      envPath: join132(ctx.claudeDir, ".env"),
       claudeDir: ctx.claudeDir,
       isGlobal: ctx.options.global,
       isNonInteractive: ctx.isNonInteractive,
@@ -107501,7 +107640,7 @@ async function handlePostInstall(ctx) {
 init_config_manager();
 init_github_client();
 import { mkdir as mkdir36 } from "node:fs/promises";
-import { join as join134, resolve as resolve47 } from "node:path";
+import { join as join135, resolve as resolve47 } from "node:path";
 
 // src/domains/github/kit-access-checker.ts
 init_error2();
@@ -107671,10 +107810,10 @@ async function runPreflightChecks() {
 // src/domains/installation/fresh-installer.ts
 init_metadata_migration();
 import { existsSync as existsSync67, readdirSync as readdirSync10, rmSync as rmSync3, rmdirSync as rmdirSync2, unlinkSync as unlinkSync5 } from "node:fs";
-import { basename as basename28, dirname as dirname41, join as join132, resolve as resolve45 } from "node:path";
+import { basename as basename28, dirname as dirname42, join as join133, resolve as resolve45 } from "node:path";
 init_logger();
 init_safe_spinner();
-var import_fs_extra34 = __toESM(require_lib(), 1);
+var import_fs_extra35 = __toESM(require_lib(), 1);
 var KIT_MANIFEST_FILE = "metadata.json";
 var CLAUDEKIT_SUBDIRECTORIES = ["commands", "agents", "skills", "rules", "hooks"];
 async function analyzeFreshInstallation(claudeDir3) {
@@ -107724,14 +107863,14 @@ async function analyzeFreshInstallation(claudeDir3) {
 }
 function cleanupEmptyDirectories2(filePath, claudeDir3) {
   const normalizedClaudeDir = resolve45(claudeDir3);
-  let currentDir = resolve45(dirname41(filePath));
+  let currentDir = resolve45(dirname42(filePath));
   while (currentDir !== normalizedClaudeDir && currentDir.startsWith(normalizedClaudeDir)) {
     try {
       const entries = readdirSync10(currentDir);
       if (entries.length === 0) {
         rmdirSync2(currentDir);
         logger.debug(`Removed empty directory: ${currentDir}`);
-        currentDir = resolve45(dirname41(currentDir));
+        currentDir = resolve45(dirname42(currentDir));
       } else {
         break;
       }
@@ -107753,7 +107892,7 @@ async function removeFilesByOwnership(claudeDir3, analysis, includeModified) {
     logger.debug(`${KIT_MANIFEST_FILE} was self-tracked; skipping from delete loop — will be rewritten by updateMetadataAfterFresh`);
   }
   for (const file of filesToRemove) {
-    const fullPath = join132(claudeDir3, file.path);
+    const fullPath = join133(claudeDir3, file.path);
     if (!existsSync67(fullPath)) {
       continue;
     }
@@ -107781,7 +107920,7 @@ async function removeFilesByOwnership(claudeDir3, analysis, includeModified) {
   };
 }
 async function updateMetadataAfterFresh(claudeDir3, removedFiles, metadata) {
-  const metadataPath = join132(claudeDir3, KIT_MANIFEST_FILE);
+  const metadataPath = join133(claudeDir3, KIT_MANIFEST_FILE);
   const removedSet = new Set(removedFiles);
   if (metadata.kits) {
     for (const kitName of Object.keys(metadata.kits)) {
@@ -107794,11 +107933,11 @@ async function updateMetadataAfterFresh(claudeDir3, removedFiles, metadata) {
   if (metadata.files) {
     metadata.files = metadata.files.filter((f3) => !removedSet.has(f3.path));
   }
-  if (!await import_fs_extra34.pathExists(metadataPath)) {
+  if (!await import_fs_extra35.pathExists(metadataPath)) {
     logger.warning(`${KIT_MANIFEST_FILE} was absent at write time (self-tracked or race condition) — recreating from in-memory snapshot`);
   }
   try {
-    await import_fs_extra34.writeFile(metadataPath, JSON.stringify(metadata, null, 2));
+    await import_fs_extra35.writeFile(metadataPath, JSON.stringify(metadata, null, 2));
     logger.debug(`Updated ${KIT_MANIFEST_FILE}, removed ${removedFiles.length} file entries`);
   } catch (writeError) {
     throw new Error(`Failed to write ${KIT_MANIFEST_FILE}: ${writeError instanceof Error ? writeError.message : String(writeError)}`);
@@ -107812,8 +107951,8 @@ function getFreshBackupTargets(claudeDir3, analysis, includeModified) {
       mutatePaths: filesToRemove.length > 0 ? ["metadata.json"] : []
     };
   }
-  const deletePaths = CLAUDEKIT_SUBDIRECTORIES.filter((subdir) => existsSync67(join132(claudeDir3, subdir)));
-  if (existsSync67(join132(claudeDir3, "metadata.json"))) {
+  const deletePaths = CLAUDEKIT_SUBDIRECTORIES.filter((subdir) => existsSync67(join133(claudeDir3, subdir)));
+  if (existsSync67(join133(claudeDir3, "metadata.json"))) {
     deletePaths.push("metadata.json");
   }
   return {
@@ -107835,16 +107974,16 @@ async function removeSubdirectoriesFallback(claudeDir3) {
   const removedFiles = [];
   let removedDirCount = 0;
   for (const subdir of CLAUDEKIT_SUBDIRECTORIES) {
-    const subdirPath = join132(claudeDir3, subdir);
-    if (await import_fs_extra34.pathExists(subdirPath)) {
+    const subdirPath = join133(claudeDir3, subdir);
+    if (await import_fs_extra35.pathExists(subdirPath)) {
       rmSync3(subdirPath, { recursive: true, force: true });
       removedDirCount++;
       removedFiles.push(`${subdir}/ (entire directory)`);
       logger.debug(`Removed subdirectory: ${subdir}/`);
     }
   }
-  const metadataPath = join132(claudeDir3, "metadata.json");
-  if (await import_fs_extra34.pathExists(metadataPath)) {
+  const metadataPath = join133(claudeDir3, "metadata.json");
+  if (await import_fs_extra35.pathExists(metadataPath)) {
     unlinkSync5(metadataPath);
     removedFiles.push("metadata.json");
   }
@@ -107857,7 +107996,7 @@ async function removeSubdirectoriesFallback(claudeDir3) {
   };
 }
 async function handleFreshInstallation(claudeDir3, prompts) {
-  if (!await import_fs_extra34.pathExists(claudeDir3)) {
+  if (!await import_fs_extra35.pathExists(claudeDir3)) {
     logger.info(".claude directory does not exist, proceeding with fresh installation");
     return true;
   }
@@ -107918,10 +108057,10 @@ async function handleFreshInstallation(claudeDir3, prompts) {
 }
 
 // src/domains/installation/global-kit-legacy-repair.ts
-var import_fs_extra35 = __toESM(require_lib(), 1);
+var import_fs_extra36 = __toESM(require_lib(), 1);
 import { cp as cp5, mkdir as mkdir35, readdir as readdir42, rename as rename11, rm as rm16, stat as stat22 } from "node:fs/promises";
 import { homedir as homedir46 } from "node:os";
-import { dirname as dirname42, join as join133, normalize as normalize11, resolve as resolve46 } from "node:path";
+import { dirname as dirname43, join as join134, normalize as normalize11, resolve as resolve46 } from "node:path";
 var LEGACY_KIT_MARKERS = [
   "metadata.json",
   ".ck.json",
@@ -107960,10 +108099,10 @@ function getLegacyWindowsGlobalKitDirCandidates(env2 = process.env, homeDir = ho
   const localAppData = safeEnvPath(env2.LOCALAPPDATA);
   const appData = safeEnvPath(env2.APPDATA);
   if (localAppData) {
-    candidates.push(join133(localAppData, ".claude"));
+    candidates.push(join134(localAppData, ".claude"));
   }
   if (appData) {
-    candidates.push(join133(appData, ".claude"));
+    candidates.push(join134(appData, ".claude"));
   }
   if (homeDir) {
     candidates.push(`${withoutTrailingSeparators(homeDir)}.claude`);
@@ -107981,7 +108120,7 @@ async function hasKitMarkers(dir) {
   if (!await isDirectory(dir))
     return false;
   for (const marker of LEGACY_KIT_MARKERS) {
-    if (await import_fs_extra35.pathExists(join133(dir, marker))) {
+    if (await import_fs_extra36.pathExists(join134(dir, marker))) {
       return true;
     }
   }
@@ -108027,14 +108166,14 @@ async function repairLegacyWindowsGlobalKitDir(options2) {
     return { status: "skipped", reason: "ambiguous-legacy-dirs", candidateDirs };
   }
   const [legacyDir] = legacyDirs;
-  const targetExists = await import_fs_extra35.pathExists(targetDir);
+  const targetExists = await import_fs_extra36.pathExists(targetDir);
   if (targetExists && !await isEmptyDirectory(targetDir)) {
     return { status: "skipped", reason: "target-exists", legacyDir, candidateDirs };
   }
   if (targetExists) {
     await rm16(targetDir, { recursive: true, force: true });
   }
-  await mkdir35(dirname42(targetDir), { recursive: true });
+  await mkdir35(dirname43(targetDir), { recursive: true });
   await moveDirectory(legacyDir, targetDir);
   return { status: "repaired", reason: "repaired", legacyDir, candidateDirs };
 }
@@ -108044,7 +108183,7 @@ init_version_utils();
 init_logger();
 init_path_resolver();
 init_types3();
-var import_fs_extra36 = __toESM(require_lib(), 1);
+var import_fs_extra37 = __toESM(require_lib(), 1);
 
 // src/commands/init/types.ts
 function isSyncContext(ctx) {
@@ -108271,7 +108410,7 @@ async function handleSelection(ctx) {
       return { ...ctx, cancelled: true };
     }
   }
-  if (!await import_fs_extra36.pathExists(resolvedDir)) {
+  if (!await import_fs_extra37.pathExists(resolvedDir)) {
     if (ctx.options.global) {
       await mkdir36(resolvedDir, { recursive: true });
       logger.info(`Created global directory: ${resolvedDir}`);
@@ -108283,7 +108422,7 @@ async function handleSelection(ctx) {
   }
   if (!ctx.options.fresh) {
     const prefix = PathResolver.getPathPrefix(ctx.options.global);
-    const claudeDir3 = prefix ? join134(resolvedDir, prefix) : resolvedDir;
+    const claudeDir3 = prefix ? join135(resolvedDir, prefix) : resolvedDir;
     try {
       const existingMetadata = await readManifest(claudeDir3);
       if (existingMetadata?.kits) {
@@ -108320,7 +108459,7 @@ async function handleSelection(ctx) {
   }
   if (ctx.options.fresh) {
     const prefix = PathResolver.getPathPrefix(ctx.options.global);
-    const claudeDir3 = prefix ? join134(resolvedDir, prefix) : resolvedDir;
+    const claudeDir3 = prefix ? join135(resolvedDir, prefix) : resolvedDir;
     const canProceed = await handleFreshInstallation(claudeDir3, ctx.prompts);
     if (!canProceed) {
       return { ...ctx, cancelled: true };
@@ -108340,7 +108479,7 @@ async function handleSelection(ctx) {
     let currentVersion = null;
     try {
       const prefix = PathResolver.getPathPrefix(ctx.options.global);
-      const claudeDir3 = prefix ? join134(resolvedDir, prefix) : resolvedDir;
+      const claudeDir3 = prefix ? join135(resolvedDir, prefix) : resolvedDir;
       const existingMetadata = await readManifest(claudeDir3);
       currentVersion = existingMetadata?.kits?.[kitType]?.version || null;
       if (currentVersion) {
@@ -108409,7 +108548,7 @@ async function handleSelection(ctx) {
   if (ctx.options.yes && !ctx.options.fresh && !ctx.options.force && !ctx.options.restoreCkHooks && releaseTag && !isOfflineMode && !pendingKits?.length) {
     try {
       const prefix = PathResolver.getPathPrefix(ctx.options.global);
-      const claudeDir3 = prefix ? join134(resolvedDir, prefix) : resolvedDir;
+      const claudeDir3 = prefix ? join135(resolvedDir, prefix) : resolvedDir;
       const existingMetadata = await readManifest(claudeDir3);
       const installedKitVersion = existingMetadata?.kits?.[kitType]?.version;
       if (installedKitVersion && versionsMatch(installedKitVersion, releaseTag)) {
@@ -108433,24 +108572,24 @@ async function handleSelection(ctx) {
 }
 // src/commands/init/phases/sync-handler.ts
 import { copyFile as copyFile8, mkdir as mkdir37, open as open5, readFile as readFile59, rename as rename12, stat as stat23, unlink as unlink13, writeFile as writeFile33 } from "node:fs/promises";
-import { dirname as dirname43, join as join135, resolve as resolve48 } from "node:path";
+import { dirname as dirname44, join as join136, resolve as resolve48 } from "node:path";
 init_logger();
 init_path_resolver();
-var import_fs_extra37 = __toESM(require_lib(), 1);
+var import_fs_extra38 = __toESM(require_lib(), 1);
 var import_picocolors26 = __toESM(require_picocolors(), 1);
 async function handleSync(ctx) {
   if (!ctx.options.sync) {
     return ctx;
   }
   const resolvedDir = ctx.options.global ? PathResolver.getGlobalKitDir() : resolve48(ctx.options.dir || ".");
-  const claudeDir3 = ctx.options.global ? resolvedDir : join135(resolvedDir, ".claude");
-  if (!await import_fs_extra37.pathExists(claudeDir3)) {
+  const claudeDir3 = ctx.options.global ? resolvedDir : join136(resolvedDir, ".claude");
+  if (!await import_fs_extra38.pathExists(claudeDir3)) {
     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 = join135(claudeDir3, "metadata.json");
-  if (!await import_fs_extra37.pathExists(metadataPath)) {
+  const metadataPath = join136(claudeDir3, "metadata.json");
+  if (!await import_fs_extra38.pathExists(metadataPath)) {
     logger.error("Cannot sync: no metadata.json found");
     ctx.prompts.note(`Your installation may be from an older version.
 Run 'ck init' to update.`, "Legacy Installation");
@@ -108549,10 +108688,10 @@ function getLockTimeout() {
 var STALE_LOCK_THRESHOLD_MS = 5 * 60 * 1000;
 async function acquireSyncLock(global3) {
   const cacheDir = PathResolver.getCacheDir(global3);
-  const lockPath = join135(cacheDir, ".sync-lock");
+  const lockPath = join136(cacheDir, ".sync-lock");
   const startTime = Date.now();
   const lockTimeout = getLockTimeout();
-  await mkdir37(dirname43(lockPath), { recursive: true });
+  await mkdir37(dirname44(lockPath), { recursive: true });
   while (Date.now() - startTime < lockTimeout) {
     try {
       const handle = await open5(lockPath, "wx");
@@ -108595,11 +108734,11 @@ async function executeSyncMerge(ctx) {
   const releaseLock = await acquireSyncLock(ctx.options.global);
   try {
     const trackedFiles = ctx.syncTrackedFiles;
-    const upstreamDir = ctx.options.global ? join135(ctx.extractDir, ".claude") : ctx.extractDir;
+    const upstreamDir = ctx.options.global ? join136(ctx.extractDir, ".claude") : ctx.extractDir;
     let deletions = [];
     try {
-      const sourceMetadataPath = join135(upstreamDir, "metadata.json");
-      if (await import_fs_extra37.pathExists(sourceMetadataPath)) {
+      const sourceMetadataPath = join136(upstreamDir, "metadata.json");
+      if (await import_fs_extra38.pathExists(sourceMetadataPath)) {
         const content = await readFile59(sourceMetadataPath, "utf-8");
         const sourceMetadata = JSON.parse(content);
         deletions = sourceMetadata.deletions || [];
@@ -108630,7 +108769,7 @@ async function executeSyncMerge(ctx) {
         try {
           const sourcePath = await validateSyncPath(upstreamDir, file.path);
           const targetPath = await validateSyncPath(ctx.claudeDir, file.path);
-          const targetDir = join135(targetPath, "..");
+          const targetDir = join136(targetPath, "..");
           try {
             await mkdir37(targetDir, { recursive: true });
           } catch (mkdirError) {
@@ -108799,9 +108938,9 @@ async function createBackup(claudeDir3, files, backupDir) {
   for (const file of files) {
     try {
       const sourcePath = await validateSyncPath(claudeDir3, file.path);
-      if (await import_fs_extra37.pathExists(sourcePath)) {
+      if (await import_fs_extra38.pathExists(sourcePath)) {
         const targetPath = await validateSyncPath(backupDir, file.path);
-        const targetDir = join135(targetPath, "..");
+        const targetDir = join136(targetPath, "..");
         await mkdir37(targetDir, { recursive: true });
         await copyFile8(sourcePath, targetPath);
       }
@@ -108816,7 +108955,7 @@ async function createBackup(claudeDir3, files, backupDir) {
 }
 // src/commands/init/phases/transform-handler.ts
 init_config_manager();
-import { join as join139 } from "node:path";
+import { join as join140 } from "node:path";
 
 // src/services/transformers/folder-path-transformer.ts
 init_logger();
@@ -108825,40 +108964,40 @@ init_types3();
 // src/services/transformers/folder-transform/folder-renamer.ts
 init_logger();
 init_types3();
-var import_fs_extra38 = __toESM(require_lib(), 1);
+var import_fs_extra39 = __toESM(require_lib(), 1);
 import { rename as rename13, rm as rm17 } from "node:fs/promises";
-import { join as join136, relative as relative29 } from "node:path";
+import { join as join137, relative as relative30 } from "node:path";
 async function collectDirsToRename(extractDir, folders) {
   const dirsToRename = [];
   if (folders.docs !== DEFAULT_FOLDERS.docs) {
-    const docsPath = join136(extractDir, DEFAULT_FOLDERS.docs);
-    if (await import_fs_extra38.pathExists(docsPath)) {
+    const docsPath = join137(extractDir, DEFAULT_FOLDERS.docs);
+    if (await import_fs_extra39.pathExists(docsPath)) {
       dirsToRename.push({
         from: docsPath,
-        to: join136(extractDir, folders.docs)
+        to: join137(extractDir, folders.docs)
       });
     }
-    const claudeDocsPath = join136(extractDir, ".claude", DEFAULT_FOLDERS.docs);
-    if (await import_fs_extra38.pathExists(claudeDocsPath)) {
+    const claudeDocsPath = join137(extractDir, ".claude", DEFAULT_FOLDERS.docs);
+    if (await import_fs_extra39.pathExists(claudeDocsPath)) {
       dirsToRename.push({
         from: claudeDocsPath,
-        to: join136(extractDir, ".claude", folders.docs)
+        to: join137(extractDir, ".claude", folders.docs)
       });
     }
   }
   if (folders.plans !== DEFAULT_FOLDERS.plans) {
-    const plansPath = join136(extractDir, DEFAULT_FOLDERS.plans);
-    if (await import_fs_extra38.pathExists(plansPath)) {
+    const plansPath = join137(extractDir, DEFAULT_FOLDERS.plans);
+    if (await import_fs_extra39.pathExists(plansPath)) {
       dirsToRename.push({
         from: plansPath,
-        to: join136(extractDir, folders.plans)
+        to: join137(extractDir, folders.plans)
       });
     }
-    const claudePlansPath = join136(extractDir, ".claude", DEFAULT_FOLDERS.plans);
-    if (await import_fs_extra38.pathExists(claudePlansPath)) {
+    const claudePlansPath = join137(extractDir, ".claude", DEFAULT_FOLDERS.plans);
+    if (await import_fs_extra39.pathExists(claudePlansPath)) {
       dirsToRename.push({
         from: claudePlansPath,
-        to: join136(extractDir, ".claude", folders.plans)
+        to: join137(extractDir, ".claude", folders.plans)
       });
     }
   }
@@ -108870,7 +109009,7 @@ async function moveAcrossDevices(src, dest) {
   } catch (e2) {
     if (e2.code === "EXDEV") {
       logger.debug(`Cross-device move detected, using copy+delete: ${src} -> ${dest}`);
-      await import_fs_extra38.copy(src, dest, { overwrite: true });
+      await import_fs_extra39.copy(src, dest, { overwrite: true });
       await rm17(src, { recursive: true, force: true });
     } else {
       throw e2;
@@ -108881,11 +109020,11 @@ async function renameFolders(dirsToRename, extractDir, options2) {
   let foldersRenamed = 0;
   for (const { from, to } of dirsToRename) {
     if (options2.dryRun) {
-      logger.info(`[dry-run] Would rename: ${relative29(extractDir, from)} -> ${relative29(extractDir, to)}`);
+      logger.info(`[dry-run] Would rename: ${relative30(extractDir, from)} -> ${relative30(extractDir, to)}`);
     } else {
       try {
         await moveAcrossDevices(from, to);
-        logger.debug(`Renamed: ${relative29(extractDir, from)} -> ${relative29(extractDir, to)}`);
+        logger.debug(`Renamed: ${relative30(extractDir, from)} -> ${relative30(extractDir, to)}`);
         foldersRenamed++;
       } catch (error) {
         logger.warning(`Failed to rename ${from}: ${error instanceof Error ? error.message : "Unknown error"}`);
@@ -108899,7 +109038,7 @@ async function renameFolders(dirsToRename, extractDir, options2) {
 init_logger();
 init_types3();
 import { readFile as readFile60, readdir as readdir43, writeFile as writeFile34 } from "node:fs/promises";
-import { join as join137, relative as relative30 } from "node:path";
+import { join as join138, relative as relative31 } from "node:path";
 var TRANSFORMABLE_FILE_PATTERNS = [
   ".md",
   ".txt",
@@ -108952,7 +109091,7 @@ async function transformFileContents(dir, compiledReplacements, options2) {
   let replacementsCount = 0;
   const entries = await readdir43(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = join137(dir, entry.name);
+    const fullPath = join138(dir, entry.name);
     if (entry.isDirectory()) {
       if (entry.name === "node_modules" || entry.name === ".git") {
         continue;
@@ -108979,10 +109118,10 @@ async function transformFileContents(dir, compiledReplacements, options2) {
         }
         if (changeCount > 0) {
           if (options2.dryRun) {
-            logger.debug(`[dry-run] Would update ${relative30(dir, fullPath)}: ${changeCount} replacement(s)`);
+            logger.debug(`[dry-run] Would update ${relative31(dir, fullPath)}: ${changeCount} replacement(s)`);
           } else {
             await writeFile34(fullPath, newContent, "utf-8");
-            logger.debug(`Updated ${relative30(dir, fullPath)}: ${changeCount} replacement(s)`);
+            logger.debug(`Updated ${relative31(dir, fullPath)}: ${changeCount} replacement(s)`);
           }
           filesChanged++;
           replacementsCount += changeCount;
@@ -109089,7 +109228,7 @@ async function transformFolderPaths(extractDir, folders, options2 = {}) {
 init_logger();
 import { readFile as readFile61, readdir as readdir44, writeFile as writeFile35 } from "node:fs/promises";
 import { homedir as homedir47, platform as platform15 } from "node:os";
-import { extname as extname7, join as join138 } from "node:path";
+import { extname as extname7, join as join139 } from "node:path";
 var IS_WINDOWS3 = platform15() === "win32";
 var HOME_PREFIX = "$HOME";
 function getHomeDirPrefix() {
@@ -109099,7 +109238,7 @@ function normalizeInstallPath(path17) {
   return path17.replace(/\\/g, "/").replace(/\/+$/, "");
 }
 function getDefaultGlobalClaudeDir() {
-  return normalizeInstallPath(join138(homedir47(), ".claude"));
+  return normalizeInstallPath(join139(homedir47(), ".claude"));
 }
 function getCustomGlobalClaudeDir(targetClaudeDir) {
   if (!targetClaudeDir)
@@ -109230,7 +109369,7 @@ async function transformPathsForGlobalInstall(directory, options2 = {}) {
   async function processDirectory2(dir) {
     const entries = await readdir44(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join138(dir, entry.name);
+      const fullPath = join139(dir, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name.startsWith(".") && entry.name !== ".claude") {
           continue;
@@ -109309,7 +109448,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 claudeDir3 = ctx.options.global ? ctx.resolvedDir : join139(ctx.resolvedDir, ".claude");
+  const claudeDir3 = ctx.options.global ? ctx.resolvedDir : join140(ctx.resolvedDir, ".claude");
   return {
     ...ctx,
     foldersConfig,
@@ -109532,7 +109671,7 @@ var import_picocolors30 = __toESM(require_picocolors(), 1);
 import { existsSync as existsSync68 } from "node:fs";
 import { readFile as readFile65, rm as rm18, unlink as unlink14 } from "node:fs/promises";
 import { homedir as homedir52 } from "node:os";
-import { basename as basename30, join as join143, resolve as resolve50 } from "node:path";
+import { basename as basename30, join as join144, resolve as resolve50 } from "node:path";
 init_logger();
 
 // src/ui/ck-cli-design/tokens.ts
@@ -110010,13 +110149,13 @@ init_dist2();
 init_model_taxonomy();
 import { mkdir as mkdir39, readFile as readFile64, writeFile as writeFile37 } from "node:fs/promises";
 import { homedir as homedir51 } from "node:os";
-import { dirname as dirname44, join as join142 } from "node:path";
+import { dirname as dirname45, join as join143 } from "node:path";
 
 // src/commands/portable/models-dev-cache.ts
 init_logger();
 import { mkdir as mkdir38, readFile as readFile62, rename as rename14, writeFile as writeFile36 } from "node:fs/promises";
 import { homedir as homedir49 } from "node:os";
-import { join as join140 } from "node:path";
+import { join as join141 } from "node:path";
 
 class ModelsDevUnavailableError extends Error {
   constructor(message, cause) {
@@ -110028,13 +110167,13 @@ var MODELS_DEV_URL = "https://models.dev/api.json";
 var CACHE_TTL_MS3 = 24 * 60 * 60 * 1000;
 var FETCH_TIMEOUT_MS = 1e4;
 function defaultCacheDir() {
-  return join140(homedir49(), ".config", "claudekit", "cache");
+  return join141(homedir49(), ".config", "claudekit", "cache");
 }
 function cacheFilePath(cacheDir) {
-  return join140(cacheDir, "models-dev.json");
+  return join141(cacheDir, "models-dev.json");
 }
 function tmpFilePath(cacheDir) {
-  return join140(cacheDir, "models-dev.json.tmp");
+  return join141(cacheDir, "models-dev.json.tmp");
 }
 async function readCacheEntry(cacheDir) {
   const filePath = cacheFilePath(cacheDir);
@@ -110109,14 +110248,14 @@ async function getModelsDevCatalog(opts = {}) {
 init_logger();
 import { readFile as readFile63 } from "node:fs/promises";
 import { homedir as homedir50, platform as platform17 } from "node:os";
-import { join as join141 } from "node:path";
+import { join as join142 } from "node:path";
 function resolveOpenCodeAuthPath(homeDir) {
   if (platform17() === "win32") {
-    const dataRoot2 = process.env.LOCALAPPDATA ?? join141(homeDir, "AppData", "Local");
-    return join141(dataRoot2, "opencode", "auth.json");
+    const dataRoot2 = process.env.LOCALAPPDATA ?? join142(homeDir, "AppData", "Local");
+    return join142(dataRoot2, "opencode", "auth.json");
   }
-  const dataRoot = process.env.XDG_DATA_HOME ?? join141(homeDir, ".local", "share");
-  return join141(dataRoot, "opencode", "auth.json");
+  const dataRoot = process.env.XDG_DATA_HOME ?? join142(homeDir, ".local", "share");
+  return join142(dataRoot, "opencode", "auth.json");
 }
 async function readAuthedProviders(homeDir) {
   const authPath = resolveOpenCodeAuthPath(homeDir);
@@ -110218,9 +110357,9 @@ function messageForReason(reason) {
 }
 function getOpenCodeConfigPath(options2) {
   if (options2.global) {
-    return join142(options2.homeDir ?? homedir51(), ".config", "opencode", "opencode.json");
+    return join143(options2.homeDir ?? homedir51(), ".config", "opencode", "opencode.json");
   }
-  return join142(options2.cwd ?? process.cwd(), "opencode.json");
+  return join143(options2.cwd ?? process.cwd(), "opencode.json");
 }
 function makeCatalogOpts(options2) {
   return {
@@ -110363,7 +110502,7 @@ async function ensureOpenCodeModel(options2) {
     }
     const chosenModel2 = response2.action === "custom" ? response2.value : suggestion2.model;
     const next2 = { ...existing, model: chosenModel2 };
-    await mkdir39(dirname44(configPath), { recursive: true });
+    await mkdir39(dirname45(configPath), { recursive: true });
     await writeFile37(configPath, `${JSON.stringify(next2, null, 2)}
 `, "utf-8");
     return { path: configPath, action: "added", model: chosenModel2, reason: suggestion2.reason };
@@ -110374,7 +110513,7 @@ async function ensureOpenCodeModel(options2) {
       throw new OpenCodeAuthRequiredError(suggestion.failure);
     }
     const next2 = { ...existing ?? {}, model: suggestion.model };
-    await mkdir39(dirname44(configPath), { recursive: true });
+    await mkdir39(dirname45(configPath), { recursive: true });
     await writeFile37(configPath, `${JSON.stringify(next2, null, 2)}
 `, "utf-8");
     return {
@@ -110396,7 +110535,7 @@ async function ensureOpenCodeModel(options2) {
   }
   const chosenModel = response.action === "custom" ? response.value : suggestion.ok ? suggestion.model : "";
   const next = { ...existing ?? {}, model: chosenModel };
-  await mkdir39(dirname44(configPath), { recursive: true });
+  await mkdir39(dirname45(configPath), { recursive: true });
   await writeFile37(configPath, `${JSON.stringify(next, null, 2)}
 `, "utf-8");
   return {
@@ -110409,7 +110548,7 @@ async function ensureOpenCodeModel(options2) {
 
 // src/commands/portable/plan-display.ts
 var import_picocolors28 = __toESM(require_picocolors(), 1);
-import { basename as basename29, dirname as dirname45, extname as extname8 } from "node:path";
+import { basename as basename29, dirname as dirname46, extname as extname8 } from "node:path";
 var DEFAULT_MAX_PLAN_GROUP_ITEMS = 20;
 var TYPE_ORDER = [
   "agent",
@@ -110635,21 +110774,21 @@ function collectPlannedWhereLines(plan) {
   return destinations.map((destination) => `${formatDisplayPath(destination)} -> ${formatCdHint(resolveCdTarget(destination))}`);
 }
 function resolveCdTarget(destination) {
-  return extname8(destination).length > 0 ? dirname45(destination) : destination;
+  return extname8(destination).length > 0 ? dirname46(destination) : destination;
 }
 function normalizeWhereDestination(path17, portableType) {
   if (portableType === "agent" || portableType === "command" || portableType === "skill") {
-    return dirname45(path17);
+    return dirname46(path17);
   }
   if (portableType === "hooks") {
-    return dirname45(path17);
+    return dirname46(path17);
   }
   if (portableType === "rules") {
     const fileName = basename29(path17).toLowerCase();
     if (fileName === "agents.md" || fileName === "gemini.md" || fileName === ".goosehints" || fileName === "custom_modes.yaml" || fileName === "custom_modes.yml") {
       return path17;
     }
-    return dirname45(path17);
+    return dirname46(path17);
   }
   return path17;
 }
@@ -111212,7 +111351,7 @@ async function executeDeleteAction(action, options2) {
 async function processMetadataDeletions(skillSourcePath, installGlobally) {
   if (!skillSourcePath)
     return;
-  const sourceMetadataPath = join143(resolve50(skillSourcePath, ".."), "metadata.json");
+  const sourceMetadataPath = join144(resolve50(skillSourcePath, ".."), "metadata.json");
   if (!existsSync68(sourceMetadataPath))
     return;
   let sourceMetadata;
@@ -111225,7 +111364,7 @@ async function processMetadataDeletions(skillSourcePath, installGlobally) {
   }
   if (!sourceMetadata.deletions || sourceMetadata.deletions.length === 0)
     return;
-  const claudeDir3 = installGlobally ? join143(homedir52(), ".claude") : join143(process.cwd(), ".claude");
+  const claudeDir3 = installGlobally ? join144(homedir52(), ".claude") : join144(process.cwd(), ".claude");
   if (!existsSync68(claudeDir3))
     return;
   try {
@@ -111353,8 +111492,8 @@ async function migrateCommand(options2) {
     let requestedGlobal = options2.global ?? false;
     let installGlobally = requestedGlobal;
     if (options2.global === undefined && !options2.yes) {
-      const projectTarget = join143(process.cwd(), ".claude");
-      const globalTarget = join143(homedir52(), ".claude");
+      const projectTarget = join144(process.cwd(), ".claude");
+      const globalTarget = join144(homedir52(), ".claude");
       const scopeChoice = await ie({
         message: "Installation scope",
         options: [
@@ -111427,7 +111566,7 @@ async function migrateCommand(options2) {
     }).join(`
 `));
     if (sourceGlobalOnly) {
-      f2.info(import_picocolors30.default.dim(`  Scope: global (--global / -g) - reading from ${formatDisplayPath(join143(homedir52(), ".claude"))}`));
+      f2.info(import_picocolors30.default.dim(`  Scope: global (--global / -g) - reading from ${formatDisplayPath(join144(homedir52(), ".claude"))}`));
     } else {
       f2.info(import_picocolors30.default.dim(`  CWD: ${process.cwd()}`));
     }
@@ -111966,7 +112105,7 @@ function buildDryRunFallbackResults(skills, selectedProviders, installGlobally,
       results.push({
         itemName: skill.name,
         operation: "apply",
-        path: join143(basePath, skill.name),
+        path: join144(basePath, skill.name),
         portableType: "skill",
         provider,
         providerDisplayName: providers[provider].displayName,
@@ -111988,7 +112127,7 @@ import { resolve as resolve51 } from "node:path";
 init_logger();
 init_path_resolver();
 init_types3();
-var import_fs_extra39 = __toESM(require_lib(), 1);
+var import_fs_extra40 = __toESM(require_lib(), 1);
 async function directorySetup(validOptions, prompts) {
   const isNonInteractive2 = !process.stdin.isTTY || process.env.CI === "true" || process.env.NON_INTERACTIVE === "true";
   const config = await ConfigManager.get();
@@ -112087,8 +112226,8 @@ async function directorySetup(validOptions, prompts) {
       return null;
     }
   }
-  if (await import_fs_extra39.pathExists(resolvedDir)) {
-    const files = await import_fs_extra39.readdir(resolvedDir);
+  if (await import_fs_extra40.pathExists(resolvedDir)) {
+    const files = await import_fs_extra40.readdir(resolvedDir);
     const isEmpty = files.length === 0;
     if (!isEmpty) {
       if (isNonInteractive2) {
@@ -112126,7 +112265,7 @@ async function handleDirectorySetup(ctx) {
 // src/commands/new/phases/project-creation.ts
 init_config_manager();
 init_github_client();
-import { join as join144 } from "node:path";
+import { join as join145 } from "node:path";
 init_logger();
 init_output_manager();
 init_types3();
@@ -112252,7 +112391,7 @@ async function projectCreation(kit, resolvedDir, validOptions, isNonInteractive2
   output.section("Installing");
   logger.verbose("Installation target", { directory: resolvedDir });
   const merger = new FileMerger;
-  const claudeDir3 = join144(resolvedDir, ".claude");
+  const claudeDir3 = join145(resolvedDir, ".claude");
   merger.setMultiKitContext(claudeDir3, kit);
   if (validOptions.exclude && validOptions.exclude.length > 0) {
     merger.addIgnorePatterns(validOptions.exclude);
@@ -112299,7 +112438,7 @@ async function handleProjectCreation(ctx) {
 }
 // src/commands/new/phases/post-setup.ts
 init_projects_registry();
-import { join as join145 } from "node:path";
+import { join as join146 } from "node:path";
 init_package_installer();
 init_logger();
 init_path_resolver();
@@ -112331,9 +112470,9 @@ async function postSetup(resolvedDir, validOptions, isNonInteractive2, prompts)
       withSudo: validOptions.withSudo
     });
   }
-  const claudeDir3 = join145(resolvedDir, ".claude");
+  const claudeDir3 = join146(resolvedDir, ".claude");
   await promptSetupWizardIfNeeded({
-    envPath: join145(claudeDir3, ".env"),
+    envPath: join146(claudeDir3, ".env"),
     claudeDir: claudeDir3,
     isGlobal: false,
     isNonInteractive: isNonInteractive2,
@@ -112403,7 +112542,7 @@ Please use only one download method.`);
 // src/commands/plan/plan-command.ts
 init_output_manager();
 import { existsSync as existsSync71, statSync as statSync12 } from "node:fs";
-import { dirname as dirname49, isAbsolute as isAbsolute14, join as join148, parse as parse7, resolve as resolve55 } from "node:path";
+import { dirname as dirname50, isAbsolute as isAbsolute14, join as join149, parse as parse7, resolve as resolve55 } from "node:path";
 
 // src/commands/plan/plan-read-handlers.ts
 init_config();
@@ -112413,18 +112552,18 @@ init_logger();
 init_output_manager();
 var import_picocolors32 = __toESM(require_picocolors(), 1);
 import { existsSync as existsSync70, statSync as statSync11 } from "node:fs";
-import { basename as basename31, dirname as dirname47, join as join147, relative as relative31, resolve as resolve53 } from "node:path";
+import { basename as basename31, dirname as dirname48, join as join148, relative as relative32, resolve as resolve53 } from "node:path";
 
 // src/commands/plan/plan-dependencies.ts
 init_config();
 init_plan_parser();
 init_plans_registry();
 import { existsSync as existsSync69 } from "node:fs";
-import { dirname as dirname46, join as join146 } from "node:path";
+import { dirname as dirname47, join as join147 } from "node:path";
 async function resolvePlanDependencies(references, currentPlanFile, options2 = {}) {
   if (references.length === 0)
     return [];
-  const currentPlanDir = dirname46(currentPlanFile);
+  const currentPlanDir = dirname47(currentPlanFile);
   const projectRoot = findProjectRoot(currentPlanDir);
   const config = options2.preloadedConfig ?? (await CkConfigManager.loadFull(projectRoot)).config;
   const defaultScope = inferPlanScopeForDir(currentPlanDir, config);
@@ -112440,7 +112579,7 @@ async function resolvePlanDependencies(references, currentPlanFile, options2 = {
       };
     }
     const scopeRoot = resolvePlanDirForScope(scope, projectRoot, config);
-    const planFile = join146(scopeRoot, planId, "plan.md");
+    const planFile = join147(scopeRoot, planId, "plan.md");
     const isSelfReference = planFile === currentPlanFile;
     if (!existsSync69(planFile)) {
       return {
@@ -112508,10 +112647,10 @@ async function handleParse(target, options2) {
     return;
   }
   if (isJsonOutput(options2)) {
-    console.log(JSON.stringify({ file: relative31(process.cwd(), planFile), frontmatter, phases }, null, 2));
+    console.log(JSON.stringify({ file: relative32(process.cwd(), planFile), frontmatter, phases }, null, 2));
     return;
   }
-  const title = typeof frontmatter.title === "string" ? frontmatter.title : basename31(dirname47(planFile));
+  const title = typeof frontmatter.title === "string" ? frontmatter.title : basename31(dirname48(planFile));
   console.log();
   console.log(import_picocolors32.default.bold(`  Plan: ${title}`));
   console.log(`  File: ${planFile}`);
@@ -112582,7 +112721,7 @@ async function handleStatus(target, options2) {
   }
   const effectiveTarget = !resolvedTarget && globalBaseDir ? globalBaseDir : resolvedTarget;
   const t = effectiveTarget ? resolve53(effectiveTarget) : null;
-  const plansDir = t && existsSync70(t) && statSync11(t).isDirectory() && !existsSync70(join147(t, "plan.md")) ? t : null;
+  const plansDir = t && existsSync70(t) && statSync11(t).isDirectory() && !existsSync70(join148(t, "plan.md")) ? t : null;
   if (plansDir) {
     const planFiles = scanPlanDir(plansDir);
     if (planFiles.length === 0) {
@@ -112622,7 +112761,7 @@ async function handleStatus(target, options2) {
         const blockedBy2 = await resolvePlanDependencies(s.blockedBy, pf, { preloadedConfig });
         const blocks2 = await resolvePlanDependencies(s.blocks, pf, { preloadedConfig });
         const bar = progressBar(s.completed, s.totalPhases);
-        const title2 = s.title ?? basename31(dirname47(pf));
+        const title2 = s.title ?? basename31(dirname48(pf));
         console.log(`  ${import_picocolors32.default.bold(title2)}`);
         console.log(`  ${bar}`);
         if (s.inProgress > 0)
@@ -112641,7 +112780,7 @@ async function handleStatus(target, options2) {
         }
         console.log();
       } catch {
-        console.log(`  [X] Failed to read: ${basename31(dirname47(pf))}`);
+        console.log(`  [X] Failed to read: ${basename31(dirname48(pf))}`);
         console.log();
       }
     }
@@ -112668,7 +112807,7 @@ async function handleStatus(target, options2) {
     console.log(JSON.stringify({ ...summary, dependencyStatus: { blockedBy, blocks } }, null, 2));
     return;
   }
-  const title = summary.title ?? basename31(dirname47(planFile));
+  const title = summary.title ?? basename31(dirname48(planFile));
   console.log();
   console.log(import_picocolors32.default.bold(`  ${title}`));
   if (summary.status)
@@ -112731,7 +112870,7 @@ async function handleKanban(target, options2) {
     process.exitCode = 1;
     return;
   }
-  const route = `/plans?dir=${encodeURIComponent(dirname47(dirname47(planFile)))}&view=kanban`;
+  const route = `/plans?dir=${encodeURIComponent(dirname48(dirname48(planFile)))}&view=kanban`;
   const url = `http://localhost:${server.port}${route}`;
   console.log();
   console.log(import_picocolors32.default.bold("  ClaudeKit Dashboard — Plans"));
@@ -112766,12 +112905,12 @@ init_plan_parser();
 init_plans_registry();
 init_output_manager();
 var import_picocolors33 = __toESM(require_picocolors(), 1);
-import { basename as basename32, dirname as dirname48, relative as relative32, resolve as resolve54 } from "node:path";
+import { basename as basename32, dirname as dirname49, relative as relative33, resolve as resolve54 } from "node:path";
 function quoteReadTarget(filePath) {
   return `"${filePath.replace(/\\/g, "/").replace(/"/g, "\\\"")}"`;
 }
 function buildPlanCreateReadReminder(planFile, phaseFiles, cwd2 = process.cwd()) {
-  const files = [planFile, ...phaseFiles].map((file) => quoteReadTarget(relative32(cwd2, file)));
+  const files = [planFile, ...phaseFiles].map((file) => quoteReadTarget(relative33(cwd2, file)));
   return [
     "  [i] Claude Code agents: read plan.md and every phase-*.md before editing.",
     "      These files already exist; Write/Edit without Read may be rejected after wasting tokens.",
@@ -112843,8 +112982,8 @@ async function handleCreate(target, options2) {
   if (isJsonOutput(options2)) {
     const cwd2 = process.cwd();
     console.log(JSON.stringify({
-      planFile: relative32(cwd2, result.planFile),
-      phaseFiles: result.phaseFiles.map((f3) => relative32(cwd2, f3))
+      planFile: relative33(cwd2, result.planFile),
+      phaseFiles: result.phaseFiles.map((f3) => relative33(cwd2, f3))
     }, null, 2));
     return;
   }
@@ -112880,7 +113019,7 @@ async function handleCheck(target, options2) {
     process.exitCode = 1;
     return;
   }
-  const planDir = dirname48(planFile);
+  const planDir = dirname49(planFile);
   let planStatus = "pending";
   try {
     const projectRoot = findProjectRoot(planDir);
@@ -112903,7 +113042,7 @@ async function handleCheck(target, options2) {
     console.log(JSON.stringify({
       phaseId: target,
       status: newStatus,
-      planFile: relative32(process.cwd(), planFile)
+      planFile: relative33(process.cwd(), planFile)
     }));
     return;
   }
@@ -112929,7 +113068,7 @@ async function handleUncheck(target, options2) {
     process.exitCode = 1;
     return;
   }
-  const planDir = dirname48(planFile);
+  const planDir = dirname49(planFile);
   try {
     const projectRoot = findProjectRoot(planDir);
     const summary = buildPlanSummary(planFile);
@@ -112947,7 +113086,7 @@ async function handleUncheck(target, options2) {
     console.log(JSON.stringify({
       phaseId: target,
       status: "pending",
-      planFile: relative32(process.cwd(), planFile)
+      planFile: relative33(process.cwd(), planFile)
     }));
     return;
   }
@@ -112968,7 +113107,7 @@ async function handleAddPhase(target, options2) {
   try {
     const result = addPhase(planFile, target, options2.after);
     try {
-      const planDir = dirname48(planFile);
+      const planDir = dirname49(planFile);
       const projectRoot = findProjectRoot(planDir);
       updateRegistryAddPhase({
         planDir,
@@ -112979,7 +113118,7 @@ async function handleAddPhase(target, options2) {
     if (isJsonOutput(options2)) {
       console.log(JSON.stringify({
         phaseId: result.phaseId,
-        phaseFile: relative32(process.cwd(), result.phaseFile)
+        phaseFile: relative33(process.cwd(), result.phaseFile)
       }));
       return;
     }
@@ -113011,7 +113150,7 @@ function resolvePlanFile(target, baseDir) {
     const stat24 = statSync12(t);
     if (stat24.isFile())
       return t;
-    const candidate = join148(t, "plan.md");
+    const candidate = join149(t, "plan.md");
     if (existsSync71(candidate))
       return candidate;
   }
@@ -113019,10 +113158,10 @@ function resolvePlanFile(target, baseDir) {
     let dir = process.cwd();
     const root = parse7(dir).root;
     while (dir !== root) {
-      const candidate = join148(dir, "plan.md");
+      const candidate = join149(dir, "plan.md");
       if (existsSync71(candidate))
         return candidate;
-      dir = dirname49(dir);
+      dir = dirname50(dir);
     }
   }
   return null;
@@ -113539,10 +113678,10 @@ init_agents();
 var import_gray_matter12 = __toESM(require_gray_matter(), 1);
 var import_picocolors37 = __toESM(require_picocolors(), 1);
 import { readFile as readFile66 } from "node:fs/promises";
-import { join as join150 } from "node:path";
+import { join as join151 } from "node:path";
 
 // src/commands/skills/installed-skills-inventory.ts
-import { join as join149, resolve as resolve57 } from "node:path";
+import { join as join150, resolve as resolve57 } from "node:path";
 init_path_resolver();
 var SCOPE_SORT_ORDER = {
   project: 0,
@@ -113554,8 +113693,8 @@ async function getActiveClaudeSkillInstallations(options2 = {}) {
   const projectClaudeDir = resolve57(projectDir, ".claude");
   const projectScopeAliasesGlobal = projectClaudeDir === globalDir;
   const [projectSkills, globalSkills] = await Promise.all([
-    projectScopeAliasesGlobal ? Promise.resolve([]) : scanSkills2(join149(projectClaudeDir, "skills")),
-    scanSkills2(join149(globalDir, "skills"))
+    projectScopeAliasesGlobal ? Promise.resolve([]) : scanSkills2(join150(projectClaudeDir, "skills")),
+    scanSkills2(join150(globalDir, "skills"))
   ]);
   const projectIds = new Set(projectSkills.map((skill) => skill.id));
   const globalIds = new Set(globalSkills.map((skill) => skill.id));
@@ -113715,7 +113854,7 @@ async function handleValidate2(sourcePath) {
   spinner.stop(`Checked ${skills.length} skill(s)`);
   let hasIssues = false;
   for (const skill of skills) {
-    const skillMdPath = join150(skill.path, "SKILL.md");
+    const skillMdPath = join151(skill.path, "SKILL.md");
     try {
       const content = await readFile66(skillMdPath, "utf-8");
       const { data } = import_gray_matter12.default(content, {
@@ -114259,7 +114398,7 @@ var import_picocolors39 = __toESM(require_picocolors(), 1);
 // src/commands/uninstall/installation-detector.ts
 init_claudekit_scanner();
 init_path_resolver();
-var import_fs_extra40 = __toESM(require_lib(), 1);
+var import_fs_extra41 = __toESM(require_lib(), 1);
 function hasClaudeKitComponents(components) {
   return components.agents > 0 || components.commands > 0 || components.rules > 0 || components.skills > 0;
 }
@@ -114274,7 +114413,7 @@ async function detectInstallations() {
       installations.push({
         type: "local",
         path: setup.project.path,
-        exists: await import_fs_extra40.pathExists(setup.project.path),
+        exists: await import_fs_extra41.pathExists(setup.project.path),
         hasMetadata,
         components: setup.project.components
       });
@@ -114287,7 +114426,7 @@ async function detectInstallations() {
       installations.push({
         type: "global",
         path: setup.global.path,
-        exists: await import_fs_extra40.pathExists(setup.global.path),
+        exists: await import_fs_extra41.pathExists(setup.global.path),
         hasMetadata,
         components: setup.global.components
       });
@@ -114298,19 +114437,19 @@ async function detectInstallations() {
 
 // src/commands/uninstall/removal-handler.ts
 import { readdirSync as readdirSync12, rmSync as rmSync5 } from "node:fs";
-import { basename as basename33, join as join152, resolve as resolve58, sep as sep14 } from "node:path";
+import { basename as basename33, join as join153, resolve as resolve58, sep as sep14 } from "node:path";
 init_logger();
 init_safe_prompts();
 init_safe_spinner();
-var import_fs_extra42 = __toESM(require_lib(), 1);
+var import_fs_extra43 = __toESM(require_lib(), 1);
 
 // src/commands/uninstall/analysis-handler.ts
 init_metadata_migration();
 import { readdirSync as readdirSync11, rmSync as rmSync4 } from "node:fs";
-import { dirname as dirname50, join as join151 } from "node:path";
+import { dirname as dirname51, join as join152 } from "node:path";
 init_logger();
 init_safe_prompts();
-var import_fs_extra41 = __toESM(require_lib(), 1);
+var import_fs_extra42 = __toESM(require_lib(), 1);
 var import_picocolors38 = __toESM(require_picocolors(), 1);
 function normalizeTrackedPath(relativePath) {
   return relativePath.replace(/\\/g, "/");
@@ -114329,7 +114468,7 @@ function classifyFileByOwnership(ownership, forceOverwrite, deleteReason) {
 }
 async function cleanupEmptyDirectories3(filePath, installationRoot) {
   let cleaned = 0;
-  let currentDir = dirname50(filePath);
+  let currentDir = dirname51(filePath);
   while (currentDir !== installationRoot && currentDir.startsWith(installationRoot)) {
     try {
       const entries = readdirSync11(currentDir);
@@ -114337,7 +114476,7 @@ async function cleanupEmptyDirectories3(filePath, installationRoot) {
         rmSync4(currentDir, { recursive: true });
         cleaned++;
         logger.debug(`Removed empty directory: ${currentDir}`);
-        currentDir = dirname50(currentDir);
+        currentDir = dirname51(currentDir);
       } else {
         break;
       }
@@ -114367,7 +114506,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_extra41.pathExists(join151(installation.path, relativePath))) {
+        if (await import_fs_extra42.pathExists(join152(installation.path, relativePath))) {
           result.retainedManifestPaths.push(relativePath);
         }
       }
@@ -114375,7 +114514,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 = join151(installation.path, relativePath);
+      const filePath = join152(installation.path, relativePath);
       if (preservedPaths.has(relativePath)) {
         result.toPreserve.push({ path: relativePath, reason: "shared with other kit" });
         continue;
@@ -114408,7 +114547,7 @@ async function analyzeInstallation(installation, forceOverwrite, kit) {
   }
   for (const trackedFile of allTrackedFiles) {
     const relativePath = normalizeTrackedPath(trackedFile.path);
-    const filePath = join151(installation.path, relativePath);
+    const filePath = join152(installation.path, relativePath);
     const ownershipResult = await OwnershipChecker.checkOwnership(filePath, metadata, installation.path);
     if (!ownershipResult.exists)
       continue;
@@ -114457,7 +114596,7 @@ function displayDryRunPreview(analysis, installationType) {
 // src/commands/uninstall/removal-handler.ts
 async function isDirectory2(filePath) {
   try {
-    const stats = await import_fs_extra42.lstat(filePath);
+    const stats = await import_fs_extra43.lstat(filePath);
     return stats.isDirectory();
   } catch {
     logger.debug(`Failed to check if path is directory: ${filePath}`);
@@ -114488,9 +114627,9 @@ async function isPathSafeToRemove(filePath, baseDir) {
       logger.debug(`Path outside installation directory: ${filePath}`);
       return false;
     }
-    const stats = await import_fs_extra42.lstat(filePath);
+    const stats = await import_fs_extra43.lstat(filePath);
     if (stats.isSymbolicLink()) {
-      const realPath = await import_fs_extra42.realpath(filePath);
+      const realPath = await import_fs_extra43.realpath(filePath);
       const resolvedReal = resolve58(realPath);
       if (!resolvedReal.startsWith(resolvedBase + sep14) && resolvedReal !== resolvedBase) {
         logger.debug(`Symlink points outside installation directory: ${filePath} -> ${realPath}`);
@@ -114551,15 +114690,15 @@ async function removeInstallations(installations, options2) {
         let removedCount = 0;
         let cleanedDirs = 0;
         for (const item of analysis.toDelete) {
-          const filePath = join152(installation.path, item.path);
-          if (!await import_fs_extra42.pathExists(filePath))
+          const filePath = join153(installation.path, item.path);
+          if (!await import_fs_extra43.pathExists(filePath))
             continue;
           if (!await isPathSafeToRemove(filePath, installation.path)) {
             logger.debug(`Skipping unsafe path: ${item.path}`);
             continue;
           }
           const isDir = await isDirectory2(filePath);
-          await import_fs_extra42.remove(filePath);
+          await import_fs_extra43.remove(filePath);
           removedCount++;
           logger.debug(`Removed ${isDir ? "directory" : "file"}: ${item.path}`);
           if (!isDir) {
@@ -114960,7 +115099,7 @@ ${import_picocolors40.default.bold(import_picocolors40.default.cyan(result.kitCo
 init_logger();
 import { existsSync as existsSync78 } from "node:fs";
 import { rm as rm19 } from "node:fs/promises";
-import { join as join159 } from "node:path";
+import { join as join160 } from "node:path";
 var import_picocolors41 = __toESM(require_picocolors(), 1);
 
 // src/commands/watch/phases/implementation-runner.ts
@@ -115479,7 +115618,7 @@ function spawnAndCollect3(command, args) {
 
 // src/commands/watch/phases/issue-processor.ts
 import { mkdir as mkdir40, writeFile as writeFile39 } from "node:fs/promises";
-import { join as join155 } from "node:path";
+import { join as join156 } from "node:path";
 
 // src/commands/watch/phases/approval-detector.ts
 init_logger();
@@ -115857,9 +115996,9 @@ async function checkAwaitingApproval(state, setup, options2, watchLog, projectDi
 
 // src/commands/watch/phases/plan-dir-finder.ts
 import { readdir as readdir46, stat as stat24 } from "node:fs/promises";
-import { join as join154 } from "node:path";
+import { join as join155 } from "node:path";
 async function findRecentPlanDir(cwd2, issueNumber, watchLog) {
-  const plansRoot = join154(cwd2, "plans");
+  const plansRoot = join155(cwd2, "plans");
   try {
     const entries = await readdir46(plansRoot);
     const tenMinAgo = Date.now() - 10 * 60 * 1000;
@@ -115868,14 +116007,14 @@ async function findRecentPlanDir(cwd2, issueNumber, watchLog) {
     for (const entry of entries) {
       if (entry === "watch" || entry === "reports" || entry === "visuals")
         continue;
-      const dirPath = join154(plansRoot, entry);
+      const dirPath = join155(plansRoot, entry);
       const dirStat = await stat24(dirPath);
       if (!dirStat.isDirectory())
         continue;
       if (dirStat.mtimeMs < tenMinAgo)
         continue;
       try {
-        await stat24(join154(dirPath, "plan.md"));
+        await stat24(join155(dirPath, "plan.md"));
       } catch {
         continue;
       }
@@ -116106,13 +116245,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 = join155(detectedPlanDir, "plan.md");
+      state.activeIssues[numStr].planPath = join156(detectedPlanDir, "plan.md");
       watchLog.info(`Plan directory detected: ${detectedPlanDir}`);
     } else {
       try {
-        const planDir = join155(projectDir, "plans", "watch");
+        const planDir = join156(projectDir, "plans", "watch");
         await mkdir40(planDir, { recursive: true });
-        const planFilePath = join155(planDir, `issue-${issue.number}-plan.md`);
+        const planFilePath = join156(planDir, `issue-${issue.number}-plan.md`);
         await writeFile39(planFilePath, planResult.planText, "utf-8");
         state.activeIssues[numStr].planPath = planFilePath;
         watchLog.info(`Plan saved (fallback) to ${planFilePath}`);
@@ -116259,7 +116398,7 @@ init_file_io();
 init_logger();
 import { existsSync as existsSync74 } from "node:fs";
 import { mkdir as mkdir41, readFile as readFile68 } from "node:fs/promises";
-import { dirname as dirname51 } from "node:path";
+import { dirname as dirname52 } from "node:path";
 var PROCESSED_ISSUES_CAP = 500;
 async function readCkJson(projectDir) {
   const configPath = CkConfigManager.getProjectConfigPath(projectDir);
@@ -116289,7 +116428,7 @@ async function loadWatchState(projectDir) {
 }
 async function saveWatchState(projectDir, state) {
   const configPath = CkConfigManager.getProjectConfigPath(projectDir);
-  const configDir = dirname51(configPath);
+  const configDir = dirname52(configPath);
   if (!existsSync74(configDir)) {
     await mkdir41(configDir, { recursive: true });
   }
@@ -116419,18 +116558,18 @@ init_logger();
 import { spawnSync as spawnSync7 } from "node:child_process";
 import { existsSync as existsSync75 } from "node:fs";
 import { readdir as readdir47, stat as stat25 } from "node:fs/promises";
-import { join as join156 } from "node:path";
+import { join as join157 } from "node:path";
 async function scanForRepos(parentDir) {
   const repos = [];
   const entries = await readdir47(parentDir);
   for (const entry of entries) {
     if (entry.startsWith("."))
       continue;
-    const fullPath = join156(parentDir, entry);
+    const fullPath = join157(parentDir, entry);
     const entryStat = await stat25(fullPath);
     if (!entryStat.isDirectory())
       continue;
-    const gitDir = join156(fullPath, ".git");
+    const gitDir = join157(fullPath, ".git");
     if (!existsSync75(gitDir))
       continue;
     const result = spawnSync7("gh", ["repo", "view", "--json", "owner,name"], {
@@ -116457,7 +116596,7 @@ init_logger();
 import { spawnSync as spawnSync8 } from "node:child_process";
 import { existsSync as existsSync76 } from "node:fs";
 import { homedir as homedir53 } from "node:os";
-import { join as join157 } from "node:path";
+import { join as join158 } from "node:path";
 async function validateSetup(cwd2) {
   const workDir = cwd2 ?? process.cwd();
   const ghVersion = spawnSync8("gh", ["--version"], { encoding: "utf-8", timeout: 1e4 });
@@ -116488,7 +116627,7 @@ Run this command from a directory with a GitHub remote.`);
   } catch {
     throw new Error(`Failed to parse repository info: ${ghRepo.stdout}`);
   }
-  const skillsPath = join157(homedir53(), ".claude", "skills");
+  const skillsPath = join158(homedir53(), ".claude", "skills");
   const skillsAvailable = existsSync76(skillsPath);
   if (!skillsAvailable) {
     logger.warning(`ClaudeKit Engineer skills not found at ${skillsPath}`);
@@ -116507,7 +116646,7 @@ init_path_resolver();
 import { createWriteStream as createWriteStream3, statSync as statSync13 } from "node:fs";
 import { existsSync as existsSync77 } from "node:fs";
 import { mkdir as mkdir42, rename as rename15 } from "node:fs/promises";
-import { join as join158 } from "node:path";
+import { join as join159 } from "node:path";
 
 class WatchLogger {
   logStream = null;
@@ -116515,7 +116654,7 @@ class WatchLogger {
   logPath = null;
   maxBytes;
   constructor(logDir, maxBytes = 0) {
-    this.logDir = logDir ?? join158(PathResolver.getClaudeKitDir(), "logs");
+    this.logDir = logDir ?? join159(PathResolver.getClaudeKitDir(), "logs");
     this.maxBytes = maxBytes;
   }
   async init() {
@@ -116524,7 +116663,7 @@ class WatchLogger {
         await mkdir42(this.logDir, { recursive: true });
       }
       const dateStr = formatDate(new Date);
-      this.logPath = join158(this.logDir, `watch-${dateStr}.log`);
+      this.logPath = join159(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"}`);
@@ -116706,7 +116845,7 @@ async function watchCommand(options2) {
 }
 async function discoverRepos(options2, watchLog) {
   const cwd2 = process.cwd();
-  const isGitRepo = existsSync78(join159(cwd2, ".git"));
+  const isGitRepo = existsSync78(join160(cwd2, ".git"));
   if (options2.force) {
     await forceRemoveLock(watchLog);
   }
@@ -116964,7 +117103,7 @@ function registerCommands(cli) {
 init_package();
 init_config_version_checker();
 import { existsSync as existsSync90, readFileSync as readFileSync23 } from "node:fs";
-import { join as join171 } from "node:path";
+import { join as join172 } from "node:path";
 
 // src/domains/versioning/version-checker.ts
 init_version_utils();
@@ -116979,14 +117118,14 @@ init_logger();
 init_path_resolver();
 import { existsSync as existsSync89 } from "node:fs";
 import { mkdir as mkdir43, readFile as readFile70, writeFile as writeFile42 } from "node:fs/promises";
-import { join as join170 } from "node:path";
+import { join as join171 } 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 join170(cacheDir, VersionCacheManager.CACHE_FILENAME);
+    return join171(cacheDir, VersionCacheManager.CACHE_FILENAME);
   }
   static async load() {
     const cacheFile = VersionCacheManager.getCacheFile();
@@ -117297,9 +117436,9 @@ async function displayVersion() {
   let localInstalledKits = [];
   let globalInstalledKits = [];
   const globalKitDir = PathResolver.getGlobalKitDir();
-  const globalMetadataPath = join171(globalKitDir, "metadata.json");
+  const globalMetadataPath = join172(globalKitDir, "metadata.json");
   const prefix = PathResolver.getPathPrefix(false);
-  const localMetadataPath = prefix ? join171(process.cwd(), prefix, "metadata.json") : join171(process.cwd(), "metadata.json");
+  const localMetadataPath = prefix ? join172(process.cwd(), prefix, "metadata.json") : join172(process.cwd(), "metadata.json");
   const isLocalSameAsGlobal = localMetadataPath === globalMetadataPath;
   if (!isLocalSameAsGlobal && existsSync90(localMetadataPath)) {
     try {
@@ -117687,7 +117826,7 @@ var output2 = new OutputManager2;
 
 // src/shared/temp-cleanup.ts
 init_logger();
-var import_fs_extra43 = __toESM(require_lib(), 1);
+var import_fs_extra44 = __toESM(require_lib(), 1);
 import { rmSync as rmSync6 } from "node:fs";
 var tempDirs2 = new Set;
 async function cleanup() {
@@ -117696,7 +117835,7 @@ async function cleanup() {
   logger.debug(`Cleaning up ${tempDirs2.size} temporary director(ies)...`);
   for (const dir of tempDirs2) {
     try {
-      await import_fs_extra43.remove(dir);
+      await import_fs_extra44.remove(dir);
       logger.debug(`Cleaned up temp directory: ${dir}`);
     } catch (error) {
       logger.debug(`Failed to clean temp directory ${dir}: ${error}`);