claudekit-cli 3.35.1-dev.1 → 3.36.0-dev.2

package/dist/index.js

@@ -38479,7 +38479,10 @@ var init_metadata = __esm(() => {
     files: exports_external.array(TrackedFileSchema).optional(),
     lastUpdateCheck: exports_external.string().optional(),
     dismissedVersion: exports_external.string().optional(),
-    installedSettings: InstalledSettingsSchema.optional()
+    installedSettings: InstalledSettingsSchema.optional(),
+    pluginInstalled: exports_external.boolean().optional(),
+    pluginInstalledAt: exports_external.string().optional(),
+    pluginVersion: exports_external.string().optional()
   });
   MultiKitMetadataSchema = exports_external.object({
     kits: exports_external.record(KitType, KitMetadataSchema).optional(),
@@ -53920,6 +53923,17 @@ var init_package_manager_detector = __esm(() => {
 });
 
 // src/domains/migration/metadata-migration.ts
+var exports_metadata_migration = {};
+__export(exports_metadata_migration, {
+  updateKitPluginState: () => updateKitPluginState,
+  needsMigration: () => needsMigration,
+  migrateToMultiKit: () => migrateToMultiKit,
+  getTrackedFilesForKit: () => getTrackedFilesForKit,
+  getKitMetadata: () => getKitMetadata,
+  getInstalledKits: () => getInstalledKits,
+  getAllTrackedFiles: () => getAllTrackedFiles,
+  detectMetadataFormat: () => detectMetadataFormat
+});
 import { join as join35 } from "node:path";
 async function detectMetadataFormat(claudeDir2) {
   const metadataPath = join35(claudeDir2, "metadata.json");
@@ -53956,6 +53970,9 @@ async function detectMetadataFormat(claudeDir2) {
     return { format: "none", metadata: null, detectedKit: null };
   }
 }
+function needsMigration(detection) {
+  return detection.format === "legacy";
+}
 async function migrateToMultiKit(claudeDir2) {
   const detection = await detectMetadataFormat(claudeDir2);
   if (detection.format === "multi-kit") {
@@ -54079,6 +54096,41 @@ function getInstalledKits(metadata) {
   }
   return [];
 }
+async function updateKitPluginState(claudeDir2, kit, state) {
+  const metadataPath = join35(claudeDir2, "metadata.json");
+  if (!await import_fs_extra3.pathExists(metadataPath)) {
+    logger.debug("No metadata.json found — skipping plugin state update");
+    return;
+  }
+  try {
+    let metadata = {};
+    try {
+      const raw = await import_fs_extra3.readFile(metadataPath, "utf-8");
+      const parsed = JSON.parse(raw);
+      if (parsed && typeof parsed === "object") {
+        metadata = parsed;
+      } else {
+        logger.warning("metadata.json is not an object; rebuilding minimal plugin metadata structure");
+      }
+    } catch (error) {
+      logger.warning(`metadata.json unreadable during plugin state update; rebuilding: ${error}`);
+    }
+    if (!metadata.kits || typeof metadata.kits !== "object") {
+      metadata.kits = {};
+    }
+    const existingKitState = metadata.kits[kit];
+    metadata.kits[kit] = {
+      ...existingKitState || {},
+      version: existingKitState?.version ?? "",
+      installedAt: existingKitState?.installedAt ?? state.pluginInstalledAt,
+      ...state
+    };
+    await import_fs_extra3.writeFile(metadataPath, JSON.stringify(metadata, null, 2));
+    logger.debug(`Plugin state saved: ${state.pluginInstalled ? "installed" : "failed"}`);
+  } catch (error) {
+    logger.debug(`Failed to update plugin state: ${error}`);
+  }
+}
 var import_fs_extra3;
 var init_metadata_migration = __esm(() => {
   init_logger();
@@ -54314,7 +54366,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "claudekit-cli",
-    version: "3.35.1-dev.1",
+    version: "3.36.0-dev.2",
     description: "CLI tool for bootstrapping and updating ClaudeKit projects",
     type: "module",
     repository: {
@@ -61503,7 +61555,7 @@ var require_picomatch2 = __commonJS((exports, module) => {
 import { exec as exec7, execFile as execFile7, spawn as spawn3 } from "node:child_process";
 import { promisify as promisify13 } from "node:util";
 function executeInteractiveScript(command, args, options2) {
-  return new Promise((resolve13, reject) => {
+  return new Promise((resolve14, reject) => {
     const child = spawn3(command, args, {
       stdio: ["ignore", "inherit", "inherit"],
       cwd: options2?.cwd,
@@ -61524,7 +61576,7 @@ function executeInteractiveScript(command, args, options2) {
       } else if (code !== 0) {
         reject(new Error(`Command exited with code ${code}`));
       } else {
-        resolve13();
+        resolve14();
       }
     });
     child.on("error", (error) => {
@@ -61545,7 +61597,7 @@ var init_process_executor = __esm(() => {
 });
 
 // src/services/package-installer/validators.ts
-import { resolve as resolve13 } from "node:path";
+import { resolve as resolve14 } from "node:path";
 function validatePackageName(packageName) {
   if (!packageName || typeof packageName !== "string") {
     throw new Error("Package name must be a non-empty string");
@@ -61558,8 +61610,8 @@ function validatePackageName(packageName) {
   }
 }
 function validateScriptPath(skillsDir2, scriptPath) {
-  const skillsDirResolved = resolve13(skillsDir2);
-  const scriptPathResolved = resolve13(scriptPath);
+  const skillsDirResolved = resolve14(skillsDir2);
+  const scriptPathResolved = resolve14(scriptPath);
   const skillsDirNormalized = isWindows() ? skillsDirResolved.toLowerCase() : skillsDirResolved;
   const scriptPathNormalized = isWindows() ? scriptPathResolved.toLowerCase() : scriptPathResolved;
   if (!scriptPathNormalized.startsWith(skillsDirNormalized)) {
@@ -61746,7 +61798,7 @@ var init_gemini_installer = __esm(() => {
 });
 
 // src/services/package-installer/opencode-installer.ts
-import { join as join59 } from "node:path";
+import { join as join58 } from "node:path";
 async function isOpenCodeInstalled() {
   try {
     await execAsync7("opencode --version", { timeout: 5000 });
@@ -61769,7 +61821,7 @@ async function installOpenCode() {
     logger.info(`Installing ${displayName}...`);
     const { unlink: unlink11 } = await import("node:fs/promises");
     const { tmpdir: tmpdir4 } = await import("node:os");
-    const tempScriptPath = join59(tmpdir4(), "opencode-install.sh");
+    const tempScriptPath = join58(tmpdir4(), "opencode-install.sh");
     try {
       logger.info("Downloading OpenCode installation script...");
       await execFileAsync5("curl", ["-fsSL", "https://opencode.ai/install", "-o", tempScriptPath], {
@@ -61821,7 +61873,7 @@ var PARTIAL_INSTALL_VERSION = "partial", EXIT_CODE_CRITICAL_FAILURE = 1, EXIT_CO
 
 // src/services/package-installer/install-error-handler.ts
 import { existsSync as existsSync44, readFileSync as readFileSync9, unlinkSync as unlinkSync2 } from "node:fs";
-import { join as join60 } from "node:path";
+import { join as join59 } from "node:path";
 function parseNameReason(str2) {
   const colonIndex = str2.indexOf(":");
   if (colonIndex === -1) {
@@ -61830,7 +61882,7 @@ function parseNameReason(str2) {
   return [str2.slice(0, colonIndex).trim(), str2.slice(colonIndex + 1).trim()];
 }
 function displayInstallErrors(skillsDir2) {
-  const summaryPath = join60(skillsDir2, ".install-error-summary.json");
+  const summaryPath = join59(skillsDir2, ".install-error-summary.json");
   if (!existsSync44(summaryPath)) {
     logger.error("Skills installation failed. Run with --verbose for details.");
     return;
@@ -61921,7 +61973,7 @@ async function checkNeedsSudoPackages() {
   }
 }
 function hasInstallState(skillsDir2) {
-  const stateFilePath = join60(skillsDir2, ".install-state.json");
+  const stateFilePath = join59(skillsDir2, ".install-state.json");
   return existsSync44(stateFilePath);
 }
 var WHICH_COMMAND_TIMEOUT_MS = 5000;
@@ -61930,7 +61982,7 @@ var init_install_error_handler = __esm(() => {
 });
 
 // src/services/package-installer/skills-installer.ts
-import { join as join61 } from "node:path";
+import { join as join60 } from "node:path";
 async function installSkillsDependencies(skillsDir2, options2 = {}) {
   const { skipConfirm = false, withSudo = false } = options2;
   const displayName = "Skills Dependencies";
@@ -61956,7 +62008,7 @@ async function installSkillsDependencies(skillsDir2, options2 = {}) {
     const clack = await Promise.resolve().then(() => (init_dist2(), exports_dist));
     const platform7 = process.platform;
     const scriptName = platform7 === "win32" ? "install.ps1" : "install.sh";
-    const scriptPath = join61(skillsDir2, scriptName);
+    const scriptPath = join60(skillsDir2, scriptName);
     try {
       validateScriptPath(skillsDir2, scriptPath);
     } catch (error) {
@@ -61972,7 +62024,7 @@ async function installSkillsDependencies(skillsDir2, options2 = {}) {
       logger.warning(`Skills installation script not found: ${scriptPath}`);
       logger.info("");
       logger.info("\uD83D\uDCD6 Manual Installation Instructions:");
-      logger.info(`  See: ${join61(skillsDir2, "INSTALLATION.md")}`);
+      logger.info(`  See: ${join60(skillsDir2, "INSTALLATION.md")}`);
       logger.info("");
       logger.info("Quick start:");
       logger.info("  cd .claude/skills/ai-multimodal/scripts");
@@ -62019,7 +62071,7 @@ async function installSkillsDependencies(skillsDir2, options2 = {}) {
       logger.info(`  ${platform7 === "win32" ? `powershell -File "${scriptPath}"` : `bash ${scriptPath}`}`);
       logger.info("");
       logger.info("Or see complete guide:");
-      logger.info(`  ${join61(skillsDir2, "INSTALLATION.md")}`);
+      logger.info(`  ${join60(skillsDir2, "INSTALLATION.md")}`);
       return {
         success: false,
         package: displayName,
@@ -62140,7 +62192,7 @@ async function installSkillsDependencies(skillsDir2, options2 = {}) {
     logger.info("\uD83D\uDCD6 Manual Installation Instructions:");
     logger.info("");
     logger.info("See complete guide:");
-    logger.info(`  cat ${join61(skillsDir2, "INSTALLATION.md")}`);
+    logger.info(`  cat ${join60(skillsDir2, "INSTALLATION.md")}`);
     logger.info("");
     logger.info("Quick start:");
     logger.info("  cd .claude/skills/ai-multimodal/scripts");
@@ -62186,7 +62238,7 @@ var init_skills_installer2 = __esm(() => {
 // src/services/package-installer/gemini-mcp/config-manager.ts
 import { existsSync as existsSync45 } from "node:fs";
 import { mkdir as mkdir17, readFile as readFile35, writeFile as writeFile20 } from "node:fs/promises";
-import { dirname as dirname15, join as join62 } from "node:path";
+import { dirname as dirname16, join as join61 } from "node:path";
 async function readJsonFile(filePath) {
   try {
     const content = await readFile35(filePath, "utf-8");
@@ -62198,7 +62250,7 @@ async function readJsonFile(filePath) {
   }
 }
 async function addGeminiToGitignore(projectDir) {
-  const gitignorePath = join62(projectDir, ".gitignore");
+  const gitignorePath = join61(projectDir, ".gitignore");
   const geminiPattern = ".gemini/";
   try {
     let content = "";
@@ -62226,7 +62278,7 @@ ${geminiPattern}
   }
 }
 async function createNewSettingsWithMerge(geminiSettingsPath, mcpConfigPath) {
-  const linkDir = dirname15(geminiSettingsPath);
+  const linkDir = dirname16(geminiSettingsPath);
   if (!existsSync45(linkDir)) {
     await mkdir17(linkDir, { recursive: true });
     logger.debug(`Created directory: ${linkDir}`);
@@ -62290,12 +62342,12 @@ var init_config_manager2 = __esm(() => {
 // src/services/package-installer/gemini-mcp/validation.ts
 import { existsSync as existsSync46, lstatSync, readlinkSync } from "node:fs";
 import { homedir as homedir27 } from "node:os";
-import { join as join63 } from "node:path";
+import { join as join62 } from "node:path";
 function getGlobalMcpConfigPath() {
-  return join63(homedir27(), ".claude", ".mcp.json");
+  return join62(homedir27(), ".claude", ".mcp.json");
 }
 function getLocalMcpConfigPath(projectDir) {
-  return join63(projectDir, ".mcp.json");
+  return join62(projectDir, ".mcp.json");
 }
 function findMcpConfigPath(projectDir) {
   const localPath = getLocalMcpConfigPath(projectDir);
@@ -62313,9 +62365,9 @@ function findMcpConfigPath(projectDir) {
 }
 function getGeminiSettingsPath(projectDir, isGlobal) {
   if (isGlobal) {
-    return join63(homedir27(), ".gemini", "settings.json");
+    return join62(homedir27(), ".gemini", "settings.json");
   }
-  return join63(projectDir, ".gemini", "settings.json");
+  return join62(projectDir, ".gemini", "settings.json");
 }
 function checkExistingGeminiConfig(projectDir, isGlobal = false) {
   const geminiSettingsPath = getGeminiSettingsPath(projectDir, isGlobal);
@@ -62345,9 +62397,9 @@ var init_validation = __esm(() => {
 // src/services/package-installer/gemini-mcp/linker-core.ts
 import { existsSync as existsSync47 } from "node:fs";
 import { mkdir as mkdir18, symlink as symlink2 } from "node:fs/promises";
-import { dirname as dirname16, join as join64 } from "node:path";
+import { dirname as dirname17, join as join63 } from "node:path";
 async function createSymlink(targetPath, linkPath, projectDir, isGlobal) {
-  const linkDir = dirname16(linkPath);
+  const linkDir = dirname17(linkPath);
   if (!existsSync47(linkDir)) {
     await mkdir18(linkDir, { recursive: true });
     logger.debug(`Created directory: ${linkDir}`);
@@ -62356,7 +62408,7 @@ async function createSymlink(targetPath, linkPath, projectDir, isGlobal) {
   if (isGlobal) {
     symlinkTarget = getGlobalMcpConfigPath();
   } else {
-    const localMcpPath = join64(projectDir, ".mcp.json");
+    const localMcpPath = join63(projectDir, ".mcp.json");
     const isLocalConfig = targetPath === localMcpPath;
     symlinkTarget = isLocalConfig ? "../.mcp.json" : targetPath;
   }
@@ -62389,10 +62441,10 @@ __export(exports_gemini_mcp_linker, {
   checkExistingGeminiConfig: () => checkExistingGeminiConfig,
   addGeminiToGitignore: () => addGeminiToGitignore
 });
-import { resolve as resolve14 } from "node:path";
+import { resolve as resolve15 } from "node:path";
 async function linkGeminiMcpConfig(projectDir, options2 = {}) {
   const { skipGitignore = false, isGlobal = false } = options2;
-  const resolvedProjectDir = resolve14(projectDir);
+  const resolvedProjectDir = resolve15(projectDir);
   const geminiSettingsPath = getGeminiSettingsPath(resolvedProjectDir, isGlobal);
   const mcpConfigPath = findMcpConfigPath(resolvedProjectDir);
   if (!mcpConfigPath) {
@@ -63040,7 +63092,7 @@ var require_get_stream = __commonJS((exports, module) => {
     };
     const { maxBuffer } = options2;
     let stream;
-    await new Promise((resolve16, reject) => {
+    await new Promise((resolve17, reject) => {
       const rejectPromise = (error) => {
         if (error && stream.getBufferedLength() <= BufferConstants.MAX_LENGTH) {
           error.bufferedData = stream.getBufferedValue();
@@ -63052,7 +63104,7 @@ var require_get_stream = __commonJS((exports, module) => {
           rejectPromise(error);
           return;
         }
-        resolve16();
+        resolve17();
       });
       stream.on("data", () => {
         if (stream.getBufferedLength() > maxBuffer) {
@@ -64413,7 +64465,7 @@ var require_extract_zip = __commonJS((exports, module) => {
       debug("opening", this.zipPath, "with opts", this.opts);
       this.zipfile = await openZip(this.zipPath, { lazyEntries: true });
       this.canceled = false;
-      return new Promise((resolve16, reject) => {
+      return new Promise((resolve17, reject) => {
         this.zipfile.on("error", (err) => {
           this.canceled = true;
           reject(err);
@@ -64422,7 +64474,7 @@ var require_extract_zip = __commonJS((exports, module) => {
         this.zipfile.on("close", () => {
           if (!this.canceled) {
             debug("zip extraction complete");
-            resolve16();
+            resolve17();
           }
         });
         this.zipfile.on("entry", async (entry) => {
@@ -64529,6 +64581,412 @@ var require_extract_zip = __commonJS((exports, module) => {
   };
 });
 
+// src/services/file-operations/manifest/manifest-reader.ts
+import { join as join74 } from "node:path";
+async function readManifest(claudeDir2) {
+  const metadataPath = join74(claudeDir2, "metadata.json");
+  if (!await import_fs_extra8.pathExists(metadataPath)) {
+    return null;
+  }
+  try {
+    const content = await import_fs_extra8.readFile(metadataPath, "utf-8");
+    const parsed = JSON.parse(content);
+    return MetadataSchema.parse(parsed);
+  } catch (error) {
+    logger.debug(`Failed to read manifest: ${error}`);
+    return null;
+  }
+}
+async function readKitManifest(claudeDir2, kit) {
+  const metadata = await readManifest(claudeDir2);
+  if (!metadata)
+    return null;
+  return getKitMetadata(metadata, kit);
+}
+async function findFileInInstalledKits(claudeDir2, relativePath, excludeKit) {
+  const metadata = await readManifest(claudeDir2);
+  if (!metadata?.kits) {
+    return {
+      exists: false,
+      ownerKit: null,
+      checksum: null,
+      version: null,
+      sourceTimestamp: null,
+      installedAt: null
+    };
+  }
+  for (const [kitName, kitMeta] of Object.entries(metadata.kits)) {
+    const kit = kitName;
+    if (kit === excludeKit)
+      continue;
+    if (!kitMeta.files)
+      continue;
+    const file = kitMeta.files.find((f3) => f3.path === relativePath);
+    if (file) {
+      return {
+        exists: true,
+        ownerKit: kit,
+        checksum: file.checksum,
+        version: kitMeta.version,
+        sourceTimestamp: file.sourceTimestamp ?? null,
+        installedAt: file.installedAt ?? null
+      };
+    }
+  }
+  return {
+    exists: false,
+    ownerKit: null,
+    checksum: null,
+    version: null,
+    sourceTimestamp: null,
+    installedAt: null
+  };
+}
+async function getUninstallManifest(claudeDir2, kit) {
+  const detection = await detectMetadataFormat(claudeDir2);
+  if (detection.format === "multi-kit" && detection.metadata?.kits) {
+    const installedKits = Object.keys(detection.metadata.kits);
+    if (kit) {
+      const kitMeta = detection.metadata.kits[kit];
+      if (!kitMeta?.files) {
+        return {
+          filesToRemove: [],
+          filesToPreserve: USER_CONFIG_PATTERNS,
+          hasManifest: true,
+          isMultiKit: true,
+          remainingKits: installedKits.filter((k2) => k2 !== kit)
+        };
+      }
+      const kitFiles = kitMeta.files.map((f3) => f3.path);
+      const sharedFiles = new Set;
+      for (const otherKit of installedKits) {
+        if (otherKit !== kit) {
+          const otherMeta = detection.metadata.kits[otherKit];
+          if (otherMeta?.files) {
+            for (const f3 of otherMeta.files) {
+              sharedFiles.add(f3.path);
+            }
+          }
+        }
+      }
+      const filesToRemove = kitFiles.filter((f3) => !sharedFiles.has(f3));
+      const filesToPreserve = [
+        ...USER_CONFIG_PATTERNS,
+        ...kitFiles.filter((f3) => sharedFiles.has(f3))
+      ];
+      return {
+        filesToRemove,
+        filesToPreserve,
+        hasManifest: true,
+        isMultiKit: true,
+        remainingKits: installedKits.filter((k2) => k2 !== kit)
+      };
+    }
+    const allFiles = getAllTrackedFiles(detection.metadata);
+    return {
+      filesToRemove: allFiles.map((f3) => f3.path),
+      filesToPreserve: USER_CONFIG_PATTERNS,
+      hasManifest: true,
+      isMultiKit: true,
+      remainingKits: []
+    };
+  }
+  if (detection.format === "legacy" && detection.metadata) {
+    const legacyFiles2 = detection.metadata.files?.map((f3) => f3.path) || [];
+    const installedFiles = detection.metadata.installedFiles || [];
+    const hasFiles = legacyFiles2.length > 0 || installedFiles.length > 0;
+    if (!hasFiles) {
+      const legacyDirs2 = ["commands", "agents", "skills", "rules", "workflows", "hooks", "scripts"];
+      const legacyFileList = ["metadata.json"];
+      return {
+        filesToRemove: [...legacyDirs2, ...legacyFileList],
+        filesToPreserve: USER_CONFIG_PATTERNS,
+        hasManifest: false,
+        isMultiKit: false,
+        remainingKits: []
+      };
+    }
+    return {
+      filesToRemove: legacyFiles2.length > 0 ? legacyFiles2 : installedFiles,
+      filesToPreserve: detection.metadata.userConfigFiles || USER_CONFIG_PATTERNS,
+      hasManifest: true,
+      isMultiKit: false,
+      remainingKits: []
+    };
+  }
+  const legacyDirs = ["commands", "agents", "skills", "rules", "workflows", "hooks", "scripts"];
+  const legacyFiles = ["metadata.json"];
+  return {
+    filesToRemove: [...legacyDirs, ...legacyFiles],
+    filesToPreserve: USER_CONFIG_PATTERNS,
+    hasManifest: false,
+    isMultiKit: false,
+    remainingKits: []
+  };
+}
+var import_fs_extra8;
+var init_manifest_reader = __esm(() => {
+  init_metadata_migration();
+  init_logger();
+  init_types3();
+  import_fs_extra8 = __toESM(require_lib3(), 1);
+});
+
+// src/domains/installation/deletion-handler.ts
+var exports_deletion_handler = {};
+__export(exports_deletion_handler, {
+  handleDeletions: () => handleDeletions,
+  categorizeDeletions: () => categorizeDeletions
+});
+import {
+  existsSync as existsSync48,
+  lstatSync as lstatSync3,
+  readdirSync as readdirSync3,
+  realpathSync as realpathSync3,
+  rmSync as rmSync2,
+  rmdirSync,
+  unlinkSync as unlinkSync3
+} from "node:fs";
+import { dirname as dirname19, join as join75, relative as relative10, resolve as resolve18, sep as sep3 } from "node:path";
+function findFileInMetadata(metadata, path13) {
+  if (!metadata)
+    return null;
+  const normalizedPath = normalizeRelativePath(path13);
+  if (metadata.kits) {
+    for (const kitMeta of Object.values(metadata.kits)) {
+      if (kitMeta?.files) {
+        const found = kitMeta.files.find((f3) => normalizeRelativePath(f3.path) === normalizedPath);
+        if (found)
+          return found;
+      }
+    }
+  }
+  if (metadata.files) {
+    const found = metadata.files.find((f3) => normalizeRelativePath(f3.path) === normalizedPath);
+    if (found)
+      return found;
+  }
+  return null;
+}
+function shouldDeletePath(path13, metadata) {
+  const tracked = findFileInMetadata(metadata, path13);
+  if (!tracked)
+    return true;
+  return tracked.ownership !== "user";
+}
+function collectFilesRecursively(dir, baseDir) {
+  const results = [];
+  if (!existsSync48(dir))
+    return results;
+  try {
+    const entries = readdirSync3(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join75(dir, entry.name);
+      const relativePath = relative10(baseDir, fullPath);
+      if (entry.isDirectory()) {
+        results.push(...collectFilesRecursively(fullPath, baseDir));
+      } else {
+        results.push(normalizeRelativePath(relativePath));
+      }
+    }
+  } catch {}
+  return results;
+}
+function expandGlobPatterns(patterns, claudeDir2) {
+  const expanded = [];
+  const allFiles = collectFilesRecursively(claudeDir2, claudeDir2);
+  for (const pattern of patterns) {
+    const normalizedPattern = normalizeRelativePath(pattern);
+    if (PathResolver.isGlobPattern(normalizedPattern)) {
+      const matcher = import_picomatch2.default(normalizedPattern);
+      const matches = allFiles.filter((file) => matcher(file));
+      expanded.push(...matches);
+      if (matches.length > 0) {
+        logger.debug(`Pattern "${normalizedPattern}" matched ${matches.length} files`);
+      }
+    } else {
+      expanded.push(normalizedPattern);
+    }
+  }
+  return [...new Set(expanded)];
+}
+function cleanupEmptyDirectories(filePath, claudeDir2) {
+  const normalizedClaudeDir = resolve18(claudeDir2);
+  let currentDir = resolve18(dirname19(filePath));
+  let iterations = 0;
+  while (currentDir !== normalizedClaudeDir && currentDir.startsWith(normalizedClaudeDir) && iterations < MAX_CLEANUP_ITERATIONS) {
+    iterations++;
+    try {
+      const entries = readdirSync3(currentDir);
+      if (entries.length === 0) {
+        rmdirSync(currentDir);
+        logger.debug(`Removed empty directory: ${currentDir}`);
+        currentDir = resolve18(dirname19(currentDir));
+      } else {
+        break;
+      }
+    } catch {
+      break;
+    }
+  }
+}
+function normalizeRelativePath(path13) {
+  return path13.replace(/\\/g, "/").replace(/^\.\/+/, "").replace(/\/+/g, "/");
+}
+function isWithinBase(candidatePath, basePath) {
+  return candidatePath === basePath || candidatePath.startsWith(`${basePath}${sep3}`);
+}
+function validateExistingDeletionTarget(fullPath, claudeDir2) {
+  const normalizedPath = resolve18(fullPath);
+  const normalizedClaudeDir = resolve18(claudeDir2);
+  if (!isWithinBase(normalizedPath, normalizedClaudeDir)) {
+    throw new Error(`Path traversal detected: ${fullPath}`);
+  }
+  let realBase = normalizedClaudeDir;
+  try {
+    realBase = realpathSync3(normalizedClaudeDir);
+  } catch {}
+  try {
+    const realParent = realpathSync3(dirname19(fullPath));
+    if (!isWithinBase(realParent, realBase)) {
+      throw new Error(`Path escapes base via symlink parent: ${fullPath}`);
+    }
+  } catch (error) {
+    throw new Error(`Failed to validate deletion parent for ${fullPath}: ${String(error)}`);
+  }
+  try {
+    const stat13 = lstatSync3(fullPath);
+    if (!stat13.isSymbolicLink()) {
+      const realTarget = realpathSync3(fullPath);
+      if (!isWithinBase(realTarget, realBase)) {
+        throw new Error(`Path escapes base via symlink target: ${fullPath}`);
+      }
+    }
+  } catch (error) {
+    throw new Error(`Failed to validate deletion target ${fullPath}: ${String(error)}`);
+  }
+}
+function deletePath(fullPath, claudeDir2) {
+  validateExistingDeletionTarget(fullPath, claudeDir2);
+  try {
+    const stat13 = lstatSync3(fullPath);
+    if (stat13.isDirectory()) {
+      rmSync2(fullPath, { recursive: true, force: true });
+    } else {
+      unlinkSync3(fullPath);
+      cleanupEmptyDirectories(fullPath, claudeDir2);
+    }
+  } catch (error) {
+    throw new Error(`Failed to delete ${fullPath}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+async function updateMetadataAfterDeletion(claudeDir2, deletedPaths) {
+  const metadataPath = join75(claudeDir2, "metadata.json");
+  if (!await import_fs_extra9.pathExists(metadataPath)) {
+    return;
+  }
+  let content;
+  try {
+    content = await import_fs_extra9.readFile(metadataPath, "utf-8");
+  } catch {
+    logger.debug("Failed to read metadata.json for cleanup");
+    return;
+  }
+  let metadata;
+  try {
+    metadata = JSON.parse(content);
+  } catch {
+    logger.debug("Failed to parse metadata.json for cleanup");
+    return;
+  }
+  const deletedSet = new Set(deletedPaths);
+  const isDeletedOrInDeletedDir = (path13) => {
+    if (deletedSet.has(path13))
+      return true;
+    for (const deleted of deletedPaths) {
+      if (path13.startsWith(`${deleted}/`))
+        return true;
+    }
+    return false;
+  };
+  if (metadata.kits) {
+    for (const kitName of Object.keys(metadata.kits)) {
+      const kit = metadata.kits[kitName];
+      if (kit?.files) {
+        kit.files = kit.files.filter((f3) => !isDeletedOrInDeletedDir(f3.path));
+      }
+    }
+  }
+  if (metadata.files) {
+    metadata.files = metadata.files.filter((f3) => !isDeletedOrInDeletedDir(f3.path));
+  }
+  try {
+    await import_fs_extra9.writeFile(metadataPath, JSON.stringify(metadata, null, 2));
+    logger.debug(`Updated metadata.json, removed ${deletedPaths.length} entries`);
+  } catch {
+    logger.debug("Failed to write updated metadata.json");
+  }
+}
+function categorizeDeletions(deletions) {
+  const immediate = [];
+  const deferred = [];
+  for (const path13 of deletions) {
+    if (path13.startsWith("skills/") || path13.startsWith("skills\\")) {
+      deferred.push(path13);
+    } else {
+      immediate.push(path13);
+    }
+  }
+  return { immediate, deferred };
+}
+async function handleDeletions(sourceMetadata, claudeDir2) {
+  const deletionPatterns = sourceMetadata.deletions || [];
+  if (deletionPatterns.length === 0) {
+    return { deletedPaths: [], preservedPaths: [], errors: [] };
+  }
+  const deletions = expandGlobPatterns(deletionPatterns, claudeDir2);
+  const userMetadata = await readManifest(claudeDir2);
+  const result = { deletedPaths: [], preservedPaths: [], errors: [] };
+  for (const path13 of deletions) {
+    const normalizedRelativePath = normalizeRelativePath(path13);
+    const fullPath = join75(claudeDir2, normalizedRelativePath);
+    const normalizedResolvedPath = resolve18(fullPath);
+    const normalizedClaudeDir = resolve18(claudeDir2);
+    if (!isWithinBase(normalizedResolvedPath, normalizedClaudeDir)) {
+      logger.warning(`Skipping invalid path: ${normalizedRelativePath}`);
+      result.errors.push(normalizedRelativePath);
+      continue;
+    }
+    if (!shouldDeletePath(normalizedRelativePath, userMetadata)) {
+      result.preservedPaths.push(normalizedRelativePath);
+      logger.verbose(`Preserved user file: ${normalizedRelativePath}`);
+      continue;
+    }
+    if (existsSync48(fullPath)) {
+      try {
+        deletePath(fullPath, claudeDir2);
+        result.deletedPaths.push(normalizedRelativePath);
+        logger.verbose(`Deleted: ${normalizedRelativePath}`);
+      } catch (error) {
+        result.errors.push(normalizedRelativePath);
+        logger.debug(`Failed to delete ${normalizedRelativePath}: ${error}`);
+      }
+    }
+  }
+  if (result.deletedPaths.length > 0) {
+    await updateMetadataAfterDeletion(claudeDir2, result.deletedPaths);
+  }
+  return result;
+}
+var import_fs_extra9, import_picomatch2, MAX_CLEANUP_ITERATIONS = 50;
+var init_deletion_handler = __esm(() => {
+  init_manifest_reader();
+  init_logger();
+  init_path_resolver();
+  import_fs_extra9 = __toESM(require_lib3(), 1);
+  import_picomatch2 = __toESM(require_picomatch2(), 1);
+});
+
 // src/domains/ui/ownership-display.ts
 var exports_ownership_display = {};
 __export(exports_ownership_display, {
@@ -64665,6 +65123,596 @@ var init_ownership_display = __esm(() => {
   import_picocolors22 = __toESM(require_picocolors(), 1);
 });
 
+// src/shared/claude-exec-options.ts
+function buildExecOptions(timeout2) {
+  const env2 = { ...process.env };
+  for (const key of Object.keys(env2)) {
+    if (key.startsWith("CLAUDE") && key !== "CLAUDE_CONFIG_DIR") {
+      delete env2[key];
+    }
+  }
+  return {
+    timeout: timeout2,
+    env: env2,
+    shell: process.platform === "win32"
+  };
+}
+
+// src/services/cc-version-checker.ts
+var exports_cc_version_checker = {};
+__export(exports_cc_version_checker, {
+  requireCCPluginSupport: () => requireCCPluginSupport,
+  parseVersion: () => parseVersion,
+  isCCPluginSupportError: () => isCCPluginSupportError,
+  getCCVersion: () => getCCVersion,
+  compareVersions: () => compareVersions9,
+  MIN_PLUGIN_VERSION: () => MIN_PLUGIN_VERSION,
+  CCPluginSupportError: () => CCPluginSupportError
+});
+import { execFile as execFile9 } from "node:child_process";
+import { promisify as promisify14 } from "node:util";
+function parseVersion(version) {
+  const match2 = version.match(/^(\d+)\.(\d+)\.(\d+)/);
+  if (!match2)
+    return null;
+  return [Number(match2[1]), Number(match2[2]), Number(match2[3])];
+}
+function compareVersions9(a3, b3) {
+  const parsedA = parseVersion(a3);
+  const parsedB = parseVersion(b3);
+  if (!parsedA || !parsedB)
+    return -1;
+  for (let i = 0;i < 3; i++) {
+    if (parsedA[i] !== parsedB[i])
+      return parsedA[i] - parsedB[i];
+  }
+  return 0;
+}
+async function getCCVersionResult() {
+  try {
+    const { stdout: stdout2, stderr } = await execFileAsync6("claude", ["--version"], buildExecOptions(5000));
+    const output2 = stdout2.trim();
+    const match2 = output2.match(/(\d+\.\d+\.\d+)/);
+    if (!match2) {
+      return {
+        version: null,
+        error: new CCPluginSupportError("cc_version_unparseable", "Failed to parse Claude Code version output", output2 || stderr?.trim() || "empty output")
+      };
+    }
+    return { version: match2[1] };
+  } catch (error) {
+    const err = error;
+    if (err.code === "ENOENT") {
+      return {
+        version: null,
+        error: new CCPluginSupportError("cc_not_found", "Claude Code CLI not found on PATH")
+      };
+    }
+    return {
+      version: null,
+      error: new CCPluginSupportError("cc_exec_failed", "Failed to run 'claude --version'", (err.stderr ?? err.message ?? "Unknown error").trim())
+    };
+  }
+}
+async function getCCVersion() {
+  const result = await getCCVersionResult();
+  return result.version;
+}
+async function requireCCPluginSupport() {
+  const result = await getCCVersionResult();
+  const version = result.version;
+  if (!version) {
+    throw result.error ?? new CCPluginSupportError("cc_exec_failed", "Failed to determine Claude Code version");
+  }
+  if (compareVersions9(version, MIN_PLUGIN_VERSION) < 0) {
+    throw new CCPluginSupportError("cc_version_too_old", `Claude Code ${version} does not support plugins (requires >= ${MIN_PLUGIN_VERSION})`);
+  }
+  logger.debug(`CC version ${version} supports plugins (>= ${MIN_PLUGIN_VERSION})`);
+}
+function isCCPluginSupportError(error) {
+  return error instanceof CCPluginSupportError;
+}
+var execFileAsync6, MIN_PLUGIN_VERSION = "1.0.33", CCPluginSupportError;
+var init_cc_version_checker = __esm(() => {
+  init_logger();
+  execFileAsync6 = promisify14(execFile9);
+  CCPluginSupportError = class CCPluginSupportError extends Error {
+    code;
+    details;
+    constructor(code2, message, details) {
+      super(message);
+      this.code = code2;
+      this.details = details;
+      this.name = "CCPluginSupportError";
+    }
+  };
+});
+
+// src/services/plugin-installer.ts
+var exports_plugin_installer = {};
+__export(exports_plugin_installer, {
+  handlePluginUninstall: () => handlePluginUninstall,
+  handlePluginInstall: () => handlePluginInstall
+});
+import { execFile as execFile10 } from "node:child_process";
+import { rename as rename6 } from "node:fs/promises";
+import { join as join99 } from "node:path";
+import { promisify as promisify15 } from "node:util";
+function getMarketplacePath() {
+  const dataDir = PathResolver.getClaudeKitDir();
+  return join99(dataDir, MARKETPLACE_DIR_NAME);
+}
+function escapeRegex2(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function outputContainsToken(output2, token) {
+  const tokenPattern = new RegExp(`(^|\\s)${escapeRegex2(token)}(?=\\s|$)`, "i");
+  return output2.split(/\r?\n/).map((line) => line.trim()).some((line) => tokenPattern.test(line));
+}
+async function runClaudePlugin(args) {
+  try {
+    const { stdout: stdout2, stderr } = await execFileAsync7("claude", ["plugin", ...args], buildExecOptions(30000));
+    return { success: true, stdout: stdout2.trim(), stderr: stderr.trim() };
+  } catch (error) {
+    const err = error;
+    return {
+      success: false,
+      stdout: (err.stdout ?? "").trim(),
+      stderr: (err.stderr ?? err.message ?? "Unknown error").trim()
+    };
+  }
+}
+async function isClaudeAvailable() {
+  try {
+    await execFileAsync7("claude", ["--version"], buildExecOptions(5000));
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function copyPluginToMarketplace(extractDir) {
+  const marketplacePath = getMarketplacePath();
+  const sourceMarketplaceJson = join99(extractDir, ".claude-plugin", "marketplace.json");
+  const sourcePluginDir = join99(extractDir, "plugins", PLUGIN_NAME);
+  if (!await import_fs_extra30.pathExists(sourceMarketplaceJson) || !await import_fs_extra30.pathExists(sourcePluginDir)) {
+    logger.debug("Kit release does not contain plugin structure — skipping plugin install");
+    return false;
+  }
+  await import_fs_extra30.ensureDir(join99(marketplacePath, ".claude-plugin"));
+  await import_fs_extra30.ensureDir(join99(marketplacePath, "plugins"));
+  const suffix = `${process.pid}-${Date.now()}`;
+  const destMarketplaceJson = join99(marketplacePath, ".claude-plugin", "marketplace.json");
+  const destPluginDir = join99(marketplacePath, "plugins", PLUGIN_NAME);
+  const tempMarketplaceJson = `${destMarketplaceJson}.tmp-${suffix}`;
+  const tempPluginDir = `${destPluginDir}.tmp-${suffix}`;
+  const backupMarketplaceJson = `${destMarketplaceJson}.bak-${suffix}`;
+  const backupPluginDir = `${destPluginDir}.bak-${suffix}`;
+  await import_fs_extra30.remove(tempMarketplaceJson).catch(() => {});
+  await import_fs_extra30.remove(tempPluginDir).catch(() => {});
+  await import_fs_extra30.remove(backupMarketplaceJson).catch(() => {});
+  await import_fs_extra30.remove(backupPluginDir).catch(() => {});
+  await import_fs_extra30.copy(sourceMarketplaceJson, tempMarketplaceJson, { overwrite: true });
+  await import_fs_extra30.copy(sourcePluginDir, tempPluginDir, { overwrite: true });
+  let backupMarketplaceCreated = false;
+  let backupPluginCreated = false;
+  let marketplaceReplaced = false;
+  let pluginReplaced = false;
+  try {
+    if (await import_fs_extra30.pathExists(destMarketplaceJson)) {
+      await rename6(destMarketplaceJson, backupMarketplaceJson);
+      backupMarketplaceCreated = true;
+    }
+    await rename6(tempMarketplaceJson, destMarketplaceJson);
+    marketplaceReplaced = true;
+    if (await import_fs_extra30.pathExists(destPluginDir)) {
+      await rename6(destPluginDir, backupPluginDir);
+      backupPluginCreated = true;
+    }
+    await rename6(tempPluginDir, destPluginDir);
+    pluginReplaced = true;
+  } catch (error) {
+    if (marketplaceReplaced) {
+      await import_fs_extra30.remove(destMarketplaceJson).catch(() => {});
+    }
+    if (pluginReplaced) {
+      await import_fs_extra30.remove(destPluginDir).catch(() => {});
+    }
+    if (backupMarketplaceCreated) {
+      await rename6(backupMarketplaceJson, destMarketplaceJson).catch(() => {});
+    }
+    if (backupPluginCreated) {
+      await rename6(backupPluginDir, destPluginDir).catch(() => {});
+    }
+    await import_fs_extra30.remove(tempMarketplaceJson).catch(() => {});
+    await import_fs_extra30.remove(tempPluginDir).catch(() => {});
+    throw error;
+  }
+  await import_fs_extra30.remove(backupMarketplaceJson).catch(() => {});
+  await import_fs_extra30.remove(backupPluginDir).catch(() => {});
+  await import_fs_extra30.remove(tempMarketplaceJson).catch(() => {});
+  await import_fs_extra30.remove(tempPluginDir).catch(() => {});
+  logger.debug("Plugin copied to marketplace");
+  return true;
+}
+async function registerMarketplace() {
+  const marketplacePath = getMarketplacePath();
+  const listResult = await runClaudePlugin(["marketplace", "list"]);
+  const alreadyRegistered = listResult.success && outputContainsToken(listResult.stdout, MARKETPLACE_NAME);
+  if (alreadyRegistered) {
+    const addResult = await runClaudePlugin(["marketplace", "add", marketplacePath]);
+    if (addResult.success) {
+      logger.debug("Marketplace re-registered successfully");
+      return true;
+    }
+    logger.debug("Marketplace add failed while registered; removing stale entry and retrying");
+    const removeResult = await runClaudePlugin(["marketplace", "remove", MARKETPLACE_NAME]);
+    if (!removeResult.success) {
+      logger.debug(`Marketplace remove failed: ${removeResult.stderr}`);
+      return false;
+    }
+    const retryResult = await runClaudePlugin(["marketplace", "add", marketplacePath]);
+    if (!retryResult.success) {
+      logger.warning(`Marketplace remove succeeded but retry-add failed: ${retryResult.stderr}`);
+      return false;
+    }
+    logger.debug("Marketplace re-registered after remove+retry");
+    return true;
+  }
+  const result = await runClaudePlugin(["marketplace", "add", marketplacePath]);
+  if (!result.success) {
+    logger.debug(`Marketplace registration failed: ${result.stderr}`);
+    return false;
+  }
+  logger.debug("Marketplace registered successfully");
+  return true;
+}
+async function installOrUpdatePlugin() {
+  const pluginRef = `${PLUGIN_NAME}@${MARKETPLACE_NAME}`;
+  const listResult = await runClaudePlugin(["list"]);
+  const isInstalled = listResult.success && outputContainsToken(listResult.stdout, pluginRef);
+  if (isInstalled) {
+    const result2 = await runClaudePlugin(["update", pluginRef]);
+    if (result2.success) {
+      logger.debug("Plugin updated successfully");
+      return true;
+    }
+    logger.debug(`Plugin update failed (${result2.stderr}); re-verifying install state`);
+    const stillInstalled = await verifyPluginInstalled();
+    if (stillInstalled) {
+      logger.debug("Plugin update failed but plugin is still installed — treating as success");
+      return true;
+    }
+    logger.debug("Plugin update failed and plugin is no longer listed");
+    return false;
+  }
+  const result = await runClaudePlugin(["install", pluginRef]);
+  if (!result.success) {
+    logger.debug(`Plugin install failed: ${result.stderr}`);
+    return false;
+  }
+  logger.debug("Plugin installed successfully");
+  return true;
+}
+async function verifyPluginInstalled() {
+  const pluginRef = `${PLUGIN_NAME}@${MARKETPLACE_NAME}`;
+  const result = await runClaudePlugin(["list"]);
+  if (!result.success)
+    return false;
+  return outputContainsToken(result.stdout, pluginRef);
+}
+async function handlePluginInstall(extractDir) {
+  if (!await isClaudeAvailable()) {
+    return {
+      installed: false,
+      marketplaceRegistered: false,
+      verified: false,
+      error: "Claude Code CLI not found on PATH"
+    };
+  }
+  logger.debug("Registering CK plugin with Claude Code...");
+  let copied = false;
+  try {
+    copied = await copyPluginToMarketplace(extractDir);
+  } catch (error) {
+    return {
+      installed: false,
+      marketplaceRegistered: false,
+      verified: false,
+      error: `Plugin copy failed: ${error instanceof Error ? error.message : "Unknown error"}`
+    };
+  }
+  if (!copied) {
+    return {
+      installed: false,
+      marketplaceRegistered: false,
+      verified: false,
+      error: "No plugin found in kit release"
+    };
+  }
+  const registered = await registerMarketplace();
+  if (!registered) {
+    return {
+      installed: false,
+      marketplaceRegistered: false,
+      verified: false,
+      error: "Marketplace registration failed"
+    };
+  }
+  const installOk = await installOrUpdatePlugin();
+  if (!installOk) {
+    return {
+      installed: false,
+      marketplaceRegistered: true,
+      verified: false,
+      error: "Plugin install/update failed"
+    };
+  }
+  const verified = await verifyPluginInstalled();
+  if (verified) {
+    logger.success("CK plugin installed — skills available as /ck:* commands");
+  } else {
+    logger.warning("Plugin installed but verification failed — skills may not be available");
+  }
+  return {
+    installed: true,
+    marketplaceRegistered: true,
+    verified,
+    error: verified ? undefined : "Post-install verification failed"
+  };
+}
+async function handlePluginUninstall() {
+  if (!await isClaudeAvailable()) {
+    logger.debug("Claude Code CLI not found — skipping plugin cleanup");
+    return;
+  }
+  const isInstalled = await verifyPluginInstalled();
+  if (isInstalled) {
+    const pluginRef = `${PLUGIN_NAME}@${MARKETPLACE_NAME}`;
+    const uninstallResult = await runClaudePlugin(["uninstall", pluginRef]);
+    if (uninstallResult.success) {
+      logger.debug("CK plugin uninstalled from Claude Code");
+    } else {
+      logger.debug(`Plugin uninstall failed: ${uninstallResult.stderr}`);
+    }
+  }
+  const marketplaceRemoveResult = await runClaudePlugin([
+    "marketplace",
+    "remove",
+    MARKETPLACE_NAME
+  ]);
+  if (!marketplaceRemoveResult.success) {
+    logger.debug(`Marketplace remove failed: ${marketplaceRemoveResult.stderr}`);
+  }
+  const marketplacePath = getMarketplacePath();
+  if (await import_fs_extra30.pathExists(marketplacePath)) {
+    try {
+      await import_fs_extra30.remove(marketplacePath);
+      logger.debug("Marketplace directory cleaned up");
+    } catch (error) {
+      logger.warning(`Failed to clean marketplace directory: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+}
+var import_fs_extra30, execFileAsync7, MARKETPLACE_DIR_NAME = "marketplace", PLUGIN_NAME = "ck", MARKETPLACE_NAME = "claudekit";
+var init_plugin_installer = __esm(() => {
+  init_logger();
+  init_path_resolver();
+  import_fs_extra30 = __toESM(require_lib3(), 1);
+  execFileAsync7 = promisify15(execFile10);
+});
+
+// src/services/skill-migration-merger.ts
+var exports_skill_migration_merger = {};
+__export(exports_skill_migration_merger, {
+  migrateUserSkills: () => migrateUserSkills
+});
+import { readFile as readFile47 } from "node:fs/promises";
+import { join as join100 } from "node:path";
+async function migrateUserSkills(claudeDir2, pluginVerified) {
+  const result = {
+    preserved: [],
+    deleted: [],
+    userOwned: [],
+    canDelete: false
+  };
+  if (!pluginVerified) {
+    return result;
+  }
+  const metadataPath = join100(claudeDir2, "metadata.json");
+  if (!await import_fs_extra31.pathExists(metadataPath)) {
+    return result;
+  }
+  let trackedFiles;
+  try {
+    const content = await readFile47(metadataPath, "utf-8");
+    const metadata = JSON.parse(content);
+    trackedFiles = extractTrackedSkillFiles(metadata);
+  } catch {
+    logger.debug("Could not read metadata for skill migration");
+    return result;
+  }
+  if (trackedFiles.length === 0) {
+    return result;
+  }
+  result.canDelete = true;
+  const preservedSet = new Set;
+  const deletedSet = new Set;
+  const userOwnedSet = new Set;
+  for (const file of trackedFiles) {
+    const skillDir = extractSkillDir(file.path);
+    if (!skillDir)
+      continue;
+    switch (file.ownership) {
+      case "user":
+        userOwnedSet.add(skillDir);
+        break;
+      case "ck-modified":
+        preservedSet.add(skillDir);
+        break;
+      case "ck":
+        deletedSet.add(skillDir);
+        break;
+    }
+  }
+  for (const dir of preservedSet) {
+    deletedSet.delete(dir);
+  }
+  result.preserved = [...preservedSet];
+  result.deleted = [...deletedSet];
+  result.userOwned = [...userOwnedSet];
+  for (const dir of result.preserved) {
+    const skillName = dir.split("/")[1];
+    logger.info(`Preserved customizations: /${skillName} (standalone alongside /ck:${skillName})`);
+  }
+  return result;
+}
+function extractTrackedSkillFiles(metadata) {
+  const files = [];
+  if (metadata.kits && typeof metadata.kits === "object") {
+    for (const kit of Object.values(metadata.kits)) {
+      if (kit.files) {
+        files.push(...kit.files.filter((f3) => isSkillPath(f3.path)));
+      }
+    }
+  }
+  if (Array.isArray(metadata.files)) {
+    files.push(...metadata.files.filter((f3) => isSkillPath(f3.path)));
+  }
+  return files;
+}
+function isSkillPath(path14) {
+  const normalized = path14.replace(/\\/g, "/");
+  return normalized.startsWith("skills/");
+}
+function extractSkillDir(path14) {
+  const normalized = path14.replace(/\\/g, "/");
+  const parts = normalized.split("/").filter(Boolean);
+  if (parts.length < 2 || parts[0] !== "skills") {
+    return null;
+  }
+  return `skills/${parts[1]}`;
+}
+var import_fs_extra31;
+var init_skill_migration_merger = __esm(() => {
+  init_logger();
+  import_fs_extra31 = __toESM(require_lib3(), 1);
+});
+
+// src/services/standalone-skill-cleanup.ts
+var exports_standalone_skill_cleanup = {};
+__export(exports_standalone_skill_cleanup, {
+  cleanupOverlappingStandaloneSkills: () => cleanupOverlappingStandaloneSkills
+});
+import { readFile as readFile48, readdir as readdir32 } from "node:fs/promises";
+import { join as join101 } from "node:path";
+async function listSkillDirs(dir) {
+  if (!await import_fs_extra32.pathExists(dir))
+    return new Set;
+  try {
+    const entries = await readdir32(dir, { withFileTypes: true });
+    const dirs = entries.filter((e2) => e2.isDirectory());
+    const results = await Promise.all(dirs.map(async (e2) => {
+      const exists = await import_fs_extra32.pathExists(join101(dir, e2.name, "SKILL.md"));
+      return exists ? e2.name : null;
+    }));
+    return new Set(results.filter(Boolean));
+  } catch {
+    return new Set;
+  }
+}
+async function getSkillOwnershipMap(claudeDir2) {
+  const ownershipMap = new Map;
+  const metadataPath = join101(claudeDir2, "metadata.json");
+  if (!await import_fs_extra32.pathExists(metadataPath))
+    return ownershipMap;
+  let trackedFiles;
+  try {
+    const content = await readFile48(metadataPath, "utf-8");
+    const metadata = JSON.parse(content);
+    trackedFiles = extractTrackedSkillFiles2(metadata);
+  } catch {
+    logger.debug("standalone-skill-cleanup: could not read metadata");
+    return ownershipMap;
+  }
+  for (const file of trackedFiles) {
+    const skillDirName = extractSkillDirName(file.path);
+    if (!skillDirName)
+      continue;
+    const existing = ownershipMap.get(skillDirName);
+    if (file.ownership === "user" || file.ownership === "ck-modified") {
+      ownershipMap.set(skillDirName, "user");
+    } else if (!existing) {
+      ownershipMap.set(skillDirName, "ck");
+    }
+  }
+  return ownershipMap;
+}
+function extractTrackedSkillFiles2(metadata) {
+  const files = [];
+  if (metadata.kits && typeof metadata.kits === "object") {
+    for (const kit of Object.values(metadata.kits)) {
+      if (kit.files) {
+        files.push(...kit.files.filter((f3) => f3.path?.startsWith("skills/")));
+      }
+    }
+  }
+  if (Array.isArray(metadata.files)) {
+    files.push(...metadata.files.filter((f3) => f3.path?.startsWith("skills/")));
+  }
+  return files;
+}
+function extractSkillDirName(filePath) {
+  const normalized = filePath.replace(/\\/g, "/");
+  const parts = normalized.split("/").filter(Boolean);
+  if (parts.length < 2 || parts[0] !== "skills")
+    return null;
+  return parts[1];
+}
+async function cleanupOverlappingStandaloneSkills(claudeDir2, pluginSkillsDir) {
+  const standaloneSkillsDir = join101(claudeDir2, "skills");
+  const result = {
+    removed: [],
+    preserved: [],
+    pluginSkillsDir
+  };
+  const [pluginSkills, standaloneSkills] = await Promise.all([
+    listSkillDirs(pluginSkillsDir),
+    listSkillDirs(standaloneSkillsDir)
+  ]);
+  if (pluginSkills.size === 0 || standaloneSkills.size === 0) {
+    logger.debug(`standalone-skill-cleanup: nothing to clean (plugin=${pluginSkills.size}, standalone=${standaloneSkills.size})`);
+    return result;
+  }
+  const overlaps = [...standaloneSkills].filter((name2) => pluginSkills.has(name2));
+  if (overlaps.length === 0)
+    return result;
+  const ownershipMap = await getSkillOwnershipMap(claudeDir2);
+  for (const skillName of overlaps) {
+    const ownership = ownershipMap.get(skillName);
+    const skillPath = join101(standaloneSkillsDir, skillName);
+    if (ownership === "user" || ownership === undefined) {
+      result.preserved.push(skillName);
+      const reason = ownership === "user" ? "user-owned/modified" : "untracked";
+      logger.debug(`standalone-skill-cleanup: preserved ${skillName} (${reason})`);
+      continue;
+    }
+    try {
+      await import_fs_extra32.remove(skillPath);
+      result.removed.push(skillName);
+      logger.debug(`standalone-skill-cleanup: removed standalone ${skillName} (plugin has it)`);
+    } catch (error) {
+      result.preserved.push(skillName);
+      logger.debug(`standalone-skill-cleanup: could not remove ${skillName}: ${error}`);
+    }
+  }
+  return result;
+}
+var import_fs_extra32;
+var init_standalone_skill_cleanup = __esm(() => {
+  init_logger();
+  import_fs_extra32 = __toESM(require_lib3(), 1);
+});
+
 // src/domains/help/commands/common-options.ts
 var filterOptionsGroup, folderOptionsGroup;
 var init_common_options = __esm(() => {
@@ -65782,7 +66830,7 @@ function getPagerArgs(pagerCmd) {
   return [];
 }
 async function trySystemPager(content) {
-  return new Promise((resolve26) => {
+  return new Promise((resolve27) => {
     const pagerCmd = process.env.PAGER || "less";
     const pagerArgs = getPagerArgs(pagerCmd);
     try {
@@ -65792,20 +66840,20 @@ async function trySystemPager(content) {
       });
       const timeout2 = setTimeout(() => {
         pager.kill();
-        resolve26(false);
+        resolve27(false);
       }, 30000);
       pager.stdin.write(content);
       pager.stdin.end();
       pager.on("close", (code2) => {
         clearTimeout(timeout2);
-        resolve26(code2 === 0);
+        resolve27(code2 === 0);
       });
       pager.on("error", () => {
         clearTimeout(timeout2);
-        resolve26(false);
+        resolve27(false);
       });
     } catch {
-      resolve26(false);
+      resolve27(false);
     }
   });
 }
@@ -65832,16 +66880,16 @@ async function basicPager(content) {
       break;
     }
     const remaining = lines.length - currentLine;
-    await new Promise((resolve26) => {
+    await new Promise((resolve27) => {
       rl.question(`-- More (${remaining} lines) [Enter/q] --`, (answer) => {
         if (answer.toLowerCase() === "q") {
           rl.close();
           process.exitCode = 0;
-          resolve26();
+          resolve27();
           return;
         }
         process.stdout.write("\x1B[1A\x1B[2K");
-        resolve26();
+        resolve27();
       });
     });
   }
@@ -72514,7 +73562,7 @@ class ConfigVersionChecker {
 }
 // src/domains/sync/sync-engine.ts
 import { lstat as lstat3, readFile as readFile34, readlink, realpath as realpath3, stat as stat9 } from "node:fs/promises";
-import { isAbsolute as isAbsolute3, join as join58, normalize as normalize7, relative as relative7 } from "node:path";
+import { dirname as dirname15, isAbsolute as isAbsolute3, normalize as normalize7, relative as relative7, resolve as resolve13 } from "node:path";
 
 // src/services/file-operations/ownership-checker.ts
 init_metadata_migration();
@@ -73875,7 +74923,7 @@ async function validateSymlinkChain(path5, basePath, maxDepth = MAX_SYMLINK_DEPT
       if (!stats.isSymbolicLink())
         break;
       const target = await readlink(current);
-      const resolvedTarget = isAbsolute3(target) ? target : join58(current, "..", target);
+      const resolvedTarget = isAbsolute3(target) ? target : resolve13(dirname15(current), target);
       const normalizedTarget = normalize7(resolvedTarget);
       const rel = relative7(basePath, normalizedTarget);
       if (rel.startsWith("..") || isAbsolute3(rel)) {
@@ -73894,6 +74942,10 @@ async function validateSymlinkChain(path5, basePath, maxDepth = MAX_SYMLINK_DEPT
     throw new Error(`Symlink chain too deep (>${maxDepth}): ${path5}`);
   }
 }
+function isOutsideBase(candidatePath, basePath) {
+  const rel = relative7(basePath, candidatePath);
+  return rel.startsWith("..") || isAbsolute3(rel);
+}
 async function validateSyncPath(basePath, filePath) {
   if (!filePath || filePath.trim() === "") {
     throw new Error("Empty file path not allowed");
@@ -73908,37 +74960,44 @@ async function validateSyncPath(basePath, filePath) {
   if (isAbsolute3(normalized)) {
     throw new Error(`Absolute paths not allowed: ${filePath}`);
   }
-  if (normalized.startsWith("..") || normalized.includes("/../")) {
+  const pathParts = normalized.split(/[\\/]+/).filter(Boolean);
+  if (pathParts.includes("..")) {
     throw new Error(`Path traversal not allowed: ${filePath}`);
   }
-  const fullPath = join58(basePath, normalized);
-  const rel = relative7(basePath, fullPath);
-  if (rel.startsWith("..") || isAbsolute3(rel)) {
+  const lexicalBase = resolve13(basePath);
+  const fullPath = resolve13(basePath, normalized);
+  const resolvedBase = await realpath3(basePath).catch(() => lexicalBase);
+  if (isOutsideBase(fullPath, lexicalBase)) {
     throw new Error(`Path escapes base directory: ${filePath}`);
   }
-  await validateSymlinkChain(fullPath, basePath);
+  await validateSymlinkChain(fullPath, resolvedBase);
   try {
-    const resolvedBase = await realpath3(basePath);
     const resolvedFull = await realpath3(fullPath);
-    const resolvedRel = relative7(resolvedBase, resolvedFull);
-    if (resolvedRel.startsWith("..") || isAbsolute3(resolvedRel)) {
+    if (isOutsideBase(resolvedFull, resolvedBase)) {
       throw new Error(`Symlink escapes base directory: ${filePath}`);
     }
   } catch (error) {
     if (error.code === "ENOENT") {
-      const parentPath = join58(fullPath, "..");
-      try {
-        const resolvedBase = await realpath3(basePath);
-        const resolvedParent = await realpath3(parentPath);
-        const resolvedRel = relative7(resolvedBase, resolvedParent);
-        if (resolvedRel.startsWith("..") || isAbsolute3(resolvedRel)) {
-          throw new Error(`Parent symlink escapes base directory: ${filePath}`);
-        }
-      } catch (parentError) {
-        if (parentError.code !== "ENOENT") {
-          throw parentError;
+      let ancestor = dirname15(fullPath);
+      while (ancestor !== lexicalBase) {
+        try {
+          await lstat3(ancestor);
+          break;
+        } catch (ancestorError) {
+          if (ancestorError.code !== "ENOENT") {
+            throw ancestorError;
+          }
+          const nextAncestor = dirname15(ancestor);
+          if (nextAncestor === ancestor) {
+            break;
+          }
+          ancestor = nextAncestor;
         }
       }
+      const resolvedAncestor = await realpath3(ancestor).catch(() => null);
+      if (!resolvedAncestor || isOutsideBase(resolvedAncestor, resolvedBase)) {
+        throw new Error(`Parent symlink escapes base directory: ${filePath}`);
+      }
     } else {
       throw error;
     }
@@ -74090,14 +75149,24 @@ class SyncEngine {
   }
   static async loadFileContent(filePath) {
     try {
-      const lstats = await lstat3(filePath);
-      if (lstats.isSymbolicLink()) {
+      const beforeStats = await lstat3(filePath);
+      if (beforeStats.isSymbolicLink()) {
         throw new Error(`Symlink not allowed for sync: ${filePath}`);
       }
-      if (lstats.size > MAX_SYNC_FILE_SIZE) {
-        throw new Error(`File too large for sync (${Math.round(lstats.size / 1024 / 1024)}MB > ${MAX_SYNC_FILE_SIZE / 1024 / 1024}MB limit)`);
+      if (beforeStats.size > MAX_SYNC_FILE_SIZE) {
+        throw new Error(`File too large for sync (${Math.round(beforeStats.size / 1024 / 1024)}MB > ${MAX_SYNC_FILE_SIZE / 1024 / 1024}MB limit)`);
       }
       const buffer = await readFile34(filePath);
+      const afterStats = await lstat3(filePath);
+      if (afterStats.isSymbolicLink()) {
+        throw new Error(`File became symlink during read: ${filePath}`);
+      }
+      if (beforeStats.dev !== afterStats.dev || beforeStats.ino !== afterStats.ino) {
+        throw new Error(`File changed identity during read: ${filePath}`);
+      }
+      if (beforeStats.mtimeMs !== afterStats.mtimeMs || beforeStats.size !== afterStats.size) {
+        throw new Error(`File changed during read: ${filePath}`);
+      }
       if (buffer.includes(0)) {
         return { content: "", isBinary: true };
       }
@@ -75108,7 +76177,7 @@ init_logger();
 var import_proper_lockfile4 = __toESM(require_proper_lockfile(), 1);
 import { mkdir as mkdir19 } from "node:fs/promises";
 import os5 from "node:os";
-import { join as join65 } from "node:path";
+import { join as join64 } from "node:path";
 var LOCK_CONFIG = {
   stale: 60000,
   retries: 0
@@ -75116,12 +76185,12 @@ var LOCK_CONFIG = {
 var activeLocks = new Set;
 var cleanupRegistered = false;
 function getLocksDir() {
-  return join65(os5.homedir(), ".claudekit", "locks");
+  return join64(os5.homedir(), ".claudekit", "locks");
 }
 function cleanupLocks() {
   for (const name of activeLocks) {
     try {
-      const lockPath = join65(getLocksDir(), `${name}.lock`);
+      const lockPath = join64(getLocksDir(), `${name}.lock`);
       import_proper_lockfile4.default.unlockSync(lockPath, { realpath: false });
     } catch {
       try {
@@ -75144,7 +76213,7 @@ async function ensureLocksDir() {
 async function withProcessLock(lockName, fn) {
   registerCleanupHandlers();
   await ensureLocksDir();
-  const lockPath = join65(getLocksDir(), `${lockName}.lock`);
+  const lockPath = join64(getLocksDir(), `${lockName}.lock`);
   let release;
   try {
     release = await import_proper_lockfile4.default.lock(lockPath, { ...LOCK_CONFIG, realpath: false });
@@ -75175,7 +76244,7 @@ init_logger();
 init_logger();
 init_path_resolver();
 var import_fs_extra7 = __toESM(require_lib3(), 1);
-import { join as join66 } from "node:path";
+import { join as join65 } from "node:path";
 async function handleConflicts(ctx) {
   if (ctx.cancelled)
     return ctx;
@@ -75184,7 +76253,7 @@ async function handleConflicts(ctx) {
   if (PathResolver.isLocalSameAsGlobal()) {
     return ctx;
   }
-  const localSettingsPath = join66(process.cwd(), ".claude", "settings.json");
+  const localSettingsPath = join65(process.cwd(), ".claude", "settings.json");
   if (!await import_fs_extra7.pathExists(localSettingsPath)) {
     return ctx;
   }
@@ -75199,7 +76268,7 @@ async function handleConflicts(ctx) {
     return { ...ctx, cancelled: true };
   }
   if (choice === "remove") {
-    const localClaudeDir = join66(process.cwd(), ".claude");
+    const localClaudeDir = join65(process.cwd(), ".claude");
     try {
       await import_fs_extra7.remove(localClaudeDir);
       logger.success("Removed local .claude/ directory");
@@ -75296,7 +76365,7 @@ init_logger();
 init_safe_spinner();
 import { mkdir as mkdir25, stat as stat12 } from "node:fs/promises";
 import { tmpdir as tmpdir4 } from "node:os";
-import { join as join73 } from "node:path";
+import { join as join72 } from "node:path";
 
 // src/shared/temp-cleanup.ts
 init_logger();
@@ -75315,7 +76384,7 @@ init_logger();
 init_output_manager();
 import { createWriteStream as createWriteStream2, rmSync } from "node:fs";
 import { mkdir as mkdir20 } from "node:fs/promises";
-import { join as join67 } from "node:path";
+import { join as join66 } from "node:path";
 
 // src/shared/progress-bar.ts
 init_output_manager();
@@ -75480,10 +76549,10 @@ init_types3();
 // src/domains/installation/utils/path-security.ts
 init_types3();
 import { lstatSync as lstatSync2, realpathSync as realpathSync2 } from "node:fs";
-import { relative as relative8, resolve as resolve15 } from "node:path";
+import { relative as relative8, resolve as resolve16 } from "node:path";
 var MAX_EXTRACTION_SIZE = 500 * 1024 * 1024;
 function isPathSafe(basePath, targetPath) {
-  const resolvedBase = resolve15(basePath);
+  const resolvedBase = resolve16(basePath);
   try {
     const stat10 = lstatSync2(targetPath);
     if (stat10.isSymbolicLink()) {
@@ -75493,7 +76562,7 @@ function isPathSafe(basePath, targetPath) {
       }
     }
   } catch {}
-  const resolvedTarget = resolve15(targetPath);
+  const resolvedTarget = resolve16(targetPath);
   const relativePath = relative8(resolvedBase, resolvedTarget);
   return !relativePath.startsWith("..") && !relativePath.startsWith("/") && resolvedTarget.startsWith(resolvedBase);
 }
@@ -75525,7 +76594,7 @@ var MAX_DOWNLOAD_SIZE = 500 * 1024 * 1024;
 class FileDownloader {
   async downloadAsset(asset, destDir) {
     try {
-      const destPath = join67(destDir, asset.name);
+      const destPath = join66(destDir, asset.name);
       await mkdir20(destDir, { recursive: true });
       output.info(`Downloading ${asset.name} (${formatBytes(asset.size)})...`);
       logger.verbose("Download details", {
@@ -75581,7 +76650,7 @@ class FileDownloader {
         }
         if (downloadedSize !== totalSize) {
           fileStream.end();
-          await new Promise((resolve16) => fileStream.once("close", resolve16));
+          await new Promise((resolve17) => fileStream.once("close", resolve17));
           try {
             rmSync(destPath, { force: true });
           } catch (cleanupError) {
@@ -75595,7 +76664,7 @@ class FileDownloader {
         return destPath;
       } catch (error) {
         fileStream.end();
-        await new Promise((resolve16) => fileStream.once("close", resolve16));
+        await new Promise((resolve17) => fileStream.once("close", resolve17));
         try {
           rmSync(destPath, { force: true });
         } catch (cleanupError) {
@@ -75610,7 +76679,7 @@ class FileDownloader {
   }
   async downloadFile(params) {
     const { url, name, size, destDir, token } = params;
-    const destPath = join67(destDir, name);
+    const destPath = join66(destDir, name);
     await mkdir20(destDir, { recursive: true });
     output.info(`Downloading ${name}${size ? ` (${formatBytes(size)})` : ""}...`);
     const headers = {};
@@ -75661,7 +76730,7 @@ class FileDownloader {
       const expectedSize = Number(response.headers.get("content-length"));
       if (expectedSize > 0 && downloadedSize !== expectedSize) {
         fileStream.end();
-        await new Promise((resolve16) => fileStream.once("close", resolve16));
+        await new Promise((resolve17) => fileStream.once("close", resolve17));
         try {
           rmSync(destPath, { force: true });
         } catch (cleanupError) {
@@ -75679,7 +76748,7 @@ class FileDownloader {
       return destPath;
     } catch (error) {
       fileStream.end();
-      await new Promise((resolve16) => fileStream.once("close", resolve16));
+      await new Promise((resolve17) => fileStream.once("close", resolve17));
       try {
         rmSync(destPath, { force: true });
       } catch (cleanupError) {
@@ -75696,7 +76765,7 @@ init_logger();
 init_types3();
 import { constants as constants4 } from "node:fs";
 import { access as access4, readdir as readdir13 } from "node:fs/promises";
-import { join as join68 } from "node:path";
+import { join as join67 } from "node:path";
 async function validateExtraction(extractDir) {
   try {
     const entries = await readdir13(extractDir, { encoding: "utf8" });
@@ -75708,7 +76777,7 @@ async function validateExtraction(extractDir) {
     const missingPaths = [];
     for (const path5 of criticalPaths) {
       try {
-        await access4(join68(extractDir, path5), constants4.F_OK);
+        await access4(join67(extractDir, path5), constants4.F_OK);
         logger.debug(`Found: ${path5}`);
       } catch {
         logger.warning(`Expected path not found: ${path5}`);
@@ -75730,7 +76799,7 @@ async function validateExtraction(extractDir) {
 // src/domains/installation/extraction/tar-extractor.ts
 init_logger();
 import { copyFile as copyFile4, mkdir as mkdir23, readdir as readdir15, rm as rm8, stat as stat10 } from "node:fs/promises";
-import { join as join71 } from "node:path";
+import { join as join70 } from "node:path";
 
 // node_modules/@isaacs/fs-minipass/dist/esm/index.js
 import EE from "events";
@@ -76278,10 +77347,10 @@ class Minipass extends EventEmitter3 {
     return this[ENCODING] ? buf.join("") : Buffer.concat(buf, buf.dataLength);
   }
   async promise() {
-    return new Promise((resolve16, reject) => {
+    return new Promise((resolve17, reject) => {
       this.on(DESTROYED, () => reject(new Error("stream destroyed")));
       this.on("error", (er) => reject(er));
-      this.on("end", () => resolve16());
+      this.on("end", () => resolve17());
     });
   }
   [Symbol.asyncIterator]() {
@@ -76300,7 +77369,7 @@ class Minipass extends EventEmitter3 {
         return Promise.resolve({ done: false, value: res });
       if (this[EOF])
         return stop();
-      let resolve16;
+      let resolve17;
       let reject;
       const onerr = (er) => {
         this.off("data", ondata);
@@ -76314,19 +77383,19 @@ class Minipass extends EventEmitter3 {
         this.off("end", onend);
         this.off(DESTROYED, ondestroy);
         this.pause();
-        resolve16({ value, done: !!this[EOF] });
+        resolve17({ value, done: !!this[EOF] });
       };
       const onend = () => {
         this.off("error", onerr);
         this.off("data", ondata);
         this.off(DESTROYED, ondestroy);
         stop();
-        resolve16({ done: true, value: undefined });
+        resolve17({ done: true, value: undefined });
       };
       const ondestroy = () => onerr(new Error("stream destroyed"));
       return new Promise((res2, rej) => {
         reject = rej;
-        resolve16 = res2;
+        resolve17 = res2;
         this.once(DESTROYED, ondestroy);
         this.once("error", onerr);
         this.once("end", onend);
@@ -76783,7 +77852,7 @@ import path7 from "node:path";
 
 // node_modules/tar/dist/esm/list.js
 import fs9 from "node:fs";
-import { dirname as dirname17, parse as parse3 } from "path";
+import { dirname as dirname18, parse as parse3 } from "path";
 
 // node_modules/tar/dist/esm/options.js
 var argmap = new Map([
@@ -77432,10 +78501,10 @@ class Minipass2 extends EventEmitter4 {
     return this[ENCODING2] ? buf.join("") : Buffer.concat(buf, buf.dataLength);
   }
   async promise() {
-    return new Promise((resolve16, reject) => {
+    return new Promise((resolve17, reject) => {
       this.on(DESTROYED2, () => reject(new Error("stream destroyed")));
       this.on("error", (er) => reject(er));
-      this.on("end", () => resolve16());
+      this.on("end", () => resolve17());
     });
   }
   [Symbol.asyncIterator]() {
@@ -77454,7 +78523,7 @@ class Minipass2 extends EventEmitter4 {
         return Promise.resolve({ done: false, value: res });
       if (this[EOF2])
         return stop();
-      let resolve16;
+      let resolve17;
       let reject;
       const onerr = (er) => {
         this.off("data", ondata);
@@ -77468,19 +78537,19 @@ class Minipass2 extends EventEmitter4 {
         this.off("end", onend);
         this.off(DESTROYED2, ondestroy);
         this.pause();
-        resolve16({ value, done: !!this[EOF2] });
+        resolve17({ value, done: !!this[EOF2] });
       };
       const onend = () => {
         this.off("error", onerr);
         this.off("data", ondata);
         this.off(DESTROYED2, ondestroy);
         stop();
-        resolve16({ done: true, value: undefined });
+        resolve17({ done: true, value: undefined });
       };
       const ondestroy = () => onerr(new Error("stream destroyed"));
       return new Promise((res2, rej) => {
         reject = rej;
-        resolve16 = res2;
+        resolve17 = res2;
         this.once(DESTROYED2, ondestroy);
         this.once("error", onerr);
         this.once("end", onend);
@@ -78908,10 +79977,10 @@ class Minipass3 extends EventEmitter5 {
     return this[ENCODING3] ? buf.join("") : Buffer.concat(buf, buf.dataLength);
   }
   async promise() {
-    return new Promise((resolve16, reject) => {
+    return new Promise((resolve17, reject) => {
       this.on(DESTROYED3, () => reject(new Error("stream destroyed")));
       this.on("error", (er) => reject(er));
-      this.on("end", () => resolve16());
+      this.on("end", () => resolve17());
     });
   }
   [Symbol.asyncIterator]() {
@@ -78930,7 +79999,7 @@ class Minipass3 extends EventEmitter5 {
         return Promise.resolve({ done: false, value: res });
       if (this[EOF3])
         return stop();
-      let resolve16;
+      let resolve17;
       let reject;
       const onerr = (er) => {
         this.off("data", ondata);
@@ -78944,19 +80013,19 @@ class Minipass3 extends EventEmitter5 {
         this.off("end", onend);
         this.off(DESTROYED3, ondestroy);
         this.pause();
-        resolve16({ value, done: !!this[EOF3] });
+        resolve17({ value, done: !!this[EOF3] });
       };
       const onend = () => {
         this.off("error", onerr);
         this.off("data", ondata);
         this.off(DESTROYED3, ondestroy);
         stop();
-        resolve16({ done: true, value: undefined });
+        resolve17({ done: true, value: undefined });
       };
       const ondestroy = () => onerr(new Error("stream destroyed"));
       return new Promise((res2, rej) => {
         reject = rej;
-        resolve16 = res2;
+        resolve17 = res2;
         this.once(DESTROYED3, ondestroy);
         this.once("error", onerr);
         this.once("end", onend);
@@ -79683,7 +80752,7 @@ var filesFilter = (opt, files) => {
       if (m2 !== undefined) {
         ret = m2;
       } else {
-        ret = mapHas(dirname17(file), root);
+        ret = mapHas(dirname18(file), root);
       }
     }
     map.set(file, ret);
@@ -79727,9 +80796,9 @@ var listFile = (opt, _files) => {
   const parse4 = new Parser(opt);
   const readSize = opt.maxReadSize || 16 * 1024 * 1024;
   const file = opt.file;
-  const p = new Promise((resolve16, reject) => {
+  const p = new Promise((resolve17, reject) => {
     parse4.on("error", reject);
-    parse4.on("end", resolve16);
+    parse4.on("end", resolve17);
     fs9.stat(file, (er, stat10) => {
       if (er) {
         reject(er);
@@ -81492,7 +82561,7 @@ var mkdirSync = (dir, opt) => {
 };
 
 // node_modules/tar/dist/esm/path-reservations.js
-import { join as join69 } from "node:path";
+import { join as join68 } from "node:path";
 
 // node_modules/tar/dist/esm/normalize-unicode.js
 var normalizeCache = Object.create(null);
@@ -81525,7 +82594,7 @@ var getDirs = (path10) => {
   const dirs = path10.split("/").slice(0, -1).reduce((set, path11) => {
     const s = set[set.length - 1];
     if (s !== undefined) {
-      path11 = join69(s, path11);
+      path11 = join68(s, path11);
     }
     set.push(path11 || "/");
     return set;
@@ -81539,7 +82608,7 @@ class PathReservations {
   #running = new Set;
   reserve(paths, fn) {
     paths = isWindows4 ? ["win32 parallelization disabled"] : paths.map((p) => {
-      return stripTrailingSlashes(join69(normalizeUnicode(p))).toLowerCase();
+      return stripTrailingSlashes(join68(normalizeUnicode(p))).toLowerCase();
     });
     const dirs = new Set(paths.map((path10) => getDirs(path10)).reduce((a3, b3) => a3.concat(b3)));
     this.#reservations.set(fn, { dirs, paths });
@@ -82309,9 +83378,9 @@ var extractFile = (opt, _3) => {
   const u = new Unpack(opt);
   const readSize = opt.maxReadSize || 16 * 1024 * 1024;
   const file = opt.file;
-  const p = new Promise((resolve16, reject) => {
+  const p = new Promise((resolve17, reject) => {
     u.on("error", reject);
-    u.on("close", resolve16);
+    u.on("close", resolve17);
     fs16.stat(file, (er, stat10) => {
       if (er) {
         reject(er);
@@ -82444,7 +83513,7 @@ var replaceAsync = (opt, files) => {
     };
     fs17.read(fd, headBuf, 0, 512, position, onread);
   };
-  const promise = new Promise((resolve16, reject) => {
+  const promise = new Promise((resolve17, reject) => {
     p.on("error", reject);
     let flag = "r+";
     const onopen = (er, fd) => {
@@ -82469,7 +83538,7 @@ var replaceAsync = (opt, files) => {
           });
           p.pipe(stream);
           stream.on("error", reject);
-          stream.on("close", resolve16);
+          stream.on("close", resolve17);
           addFilesAsync2(p, files);
         });
       });
@@ -82599,7 +83668,7 @@ function decodeFilePath(path12) {
 init_logger();
 init_types3();
 import { copyFile as copyFile3, lstat as lstat4, mkdir as mkdir22, readdir as readdir14 } from "node:fs/promises";
-import { join as join70, relative as relative9 } from "node:path";
+import { join as join69, relative as relative9 } from "node:path";
 async function withRetry(fn, retries = 3) {
   for (let i = 0;i < retries; i++) {
     try {
@@ -82621,8 +83690,8 @@ async function moveDirectoryContents(sourceDir, destDir, shouldExclude, sizeTrac
   await mkdir22(destDir, { recursive: true });
   const entries = await readdir14(sourceDir, { encoding: "utf8" });
   for (const entry of entries) {
-    const sourcePath = join70(sourceDir, entry);
-    const destPath = join70(destDir, entry);
+    const sourcePath = join69(sourceDir, entry);
+    const destPath = join69(destDir, entry);
     const relativePath = relative9(sourceDir, sourcePath);
     if (!isPathSafe(destDir, destPath)) {
       logger.warning(`Skipping unsafe path: ${relativePath}`);
@@ -82649,8 +83718,8 @@ async function copyDirectory(sourceDir, destDir, shouldExclude, sizeTracker) {
   await mkdir22(destDir, { recursive: true });
   const entries = await readdir14(sourceDir, { encoding: "utf8" });
   for (const entry of entries) {
-    const sourcePath = join70(sourceDir, entry);
-    const destPath = join70(destDir, entry);
+    const sourcePath = join69(sourceDir, entry);
+    const destPath = join69(destDir, entry);
     const relativePath = relative9(sourceDir, sourcePath);
     if (!isPathSafe(destDir, destPath)) {
       logger.warning(`Skipping unsafe path: ${relativePath}`);
@@ -82698,7 +83767,7 @@ class TarExtractor {
       logger.debug(`Root entries: ${entries.join(", ")}`);
       if (entries.length === 1) {
         const rootEntry = entries[0];
-        const rootPath = join71(tempExtractDir, rootEntry);
+        const rootPath = join70(tempExtractDir, rootEntry);
         const rootStat = await stat10(rootPath);
         if (rootStat.isDirectory()) {
           const rootContents = await readdir15(rootPath, { encoding: "utf8" });
@@ -82714,7 +83783,7 @@ class TarExtractor {
           }
         } else {
           await mkdir23(destDir, { recursive: true });
-          await copyFile4(rootPath, join71(destDir, rootEntry));
+          await copyFile4(rootPath, join70(destDir, rootEntry));
         }
       } else {
         logger.debug("Multiple root entries - moving all");
@@ -82737,26 +83806,26 @@ init_logger();
 var import_extract_zip = __toESM(require_extract_zip(), 1);
 import { execFile as execFile8 } from "node:child_process";
 import { copyFile as copyFile5, mkdir as mkdir24, readdir as readdir16, rm as rm9, stat as stat11 } from "node:fs/promises";
-import { join as join72 } from "node:path";
+import { join as join71 } from "node:path";
 class ZipExtractor {
   async tryNativeUnzip(archivePath, destDir) {
     if (!isMacOS()) {
       return false;
     }
-    return new Promise((resolve16) => {
+    return new Promise((resolve17) => {
       mkdir24(destDir, { recursive: true }).then(() => {
         execFile8("unzip", ["-o", "-q", archivePath, "-d", destDir], (error, _stdout, stderr) => {
           if (error) {
             logger.debug(`Native unzip failed: ${stderr || error.message}`);
-            resolve16(false);
+            resolve17(false);
             return;
           }
           logger.debug("Native unzip succeeded");
-          resolve16(true);
+          resolve17(true);
         });
       }).catch((err) => {
         logger.debug(`Failed to create directory for native unzip: ${err.message}`);
-        resolve16(false);
+        resolve17(false);
       });
     });
   }
@@ -82785,7 +83854,7 @@ class ZipExtractor {
       logger.debug(`Root entries: ${entries.join(", ")}`);
       if (entries.length === 1) {
         const rootEntry = entries[0];
-        const rootPath = join72(tempExtractDir, rootEntry);
+        const rootPath = join71(tempExtractDir, rootEntry);
         const rootStat = await stat11(rootPath);
         if (rootStat.isDirectory()) {
           const rootContents = await readdir16(rootPath, { encoding: "utf8" });
@@ -82801,7 +83870,7 @@ class ZipExtractor {
           }
         } else {
           await mkdir24(destDir, { recursive: true });
-          await copyFile5(rootPath, join72(destDir, rootEntry));
+          await copyFile5(rootPath, join71(destDir, rootEntry));
         }
       } else {
         logger.debug("Multiple root entries - moving all");
@@ -82900,7 +83969,7 @@ class DownloadManager {
   async createTempDir() {
     const timestamp = Date.now();
     const counter = DownloadManager.tempDirCounter++;
-    const primaryTempDir = join73(tmpdir4(), `claudekit-${timestamp}-${counter}`);
+    const primaryTempDir = join72(tmpdir4(), `claudekit-${timestamp}-${counter}`);
     try {
       await mkdir25(primaryTempDir, { recursive: true });
       logger.debug(`Created temp directory: ${primaryTempDir}`);
@@ -82917,7 +83986,7 @@ Solutions:
   2. Set HOME environment variable
   3. Try running from a different directory`);
       }
-      const fallbackTempDir = join73(homeDir, ".claudekit", "tmp", `claudekit-${timestamp}-${counter}`);
+      const fallbackTempDir = join72(homeDir, ".claudekit", "tmp", `claudekit-${timestamp}-${counter}`);
       try {
         await mkdir25(fallbackTempDir, { recursive: true });
         logger.debug(`Created temp directory (fallback): ${fallbackTempDir}`);
@@ -83266,349 +84335,8 @@ async function handleDownload(ctx) {
   };
 }
 // src/commands/init/phases/merge-handler.ts
-import { join as join89 } from "node:path";
-
-// src/domains/installation/deletion-handler.ts
-import { existsSync as existsSync48, lstatSync as lstatSync3, readdirSync as readdirSync3, rmSync as rmSync2, rmdirSync, unlinkSync as unlinkSync3 } from "node:fs";
-import { dirname as dirname18, join as join76, relative as relative10, resolve as resolve17, sep as sep3 } from "node:path";
-
-// src/services/file-operations/manifest/manifest-reader.ts
-init_metadata_migration();
-init_logger();
-init_types3();
-var import_fs_extra8 = __toESM(require_lib3(), 1);
-import { join as join75 } from "node:path";
-async function readManifest(claudeDir2) {
-  const metadataPath = join75(claudeDir2, "metadata.json");
-  if (!await import_fs_extra8.pathExists(metadataPath)) {
-    return null;
-  }
-  try {
-    const content = await import_fs_extra8.readFile(metadataPath, "utf-8");
-    const parsed = JSON.parse(content);
-    return MetadataSchema.parse(parsed);
-  } catch (error) {
-    logger.debug(`Failed to read manifest: ${error}`);
-    return null;
-  }
-}
-async function readKitManifest(claudeDir2, kit) {
-  const metadata = await readManifest(claudeDir2);
-  if (!metadata)
-    return null;
-  return getKitMetadata(metadata, kit);
-}
-async function findFileInInstalledKits(claudeDir2, relativePath, excludeKit) {
-  const metadata = await readManifest(claudeDir2);
-  if (!metadata?.kits) {
-    return {
-      exists: false,
-      ownerKit: null,
-      checksum: null,
-      version: null,
-      sourceTimestamp: null,
-      installedAt: null
-    };
-  }
-  for (const [kitName, kitMeta] of Object.entries(metadata.kits)) {
-    const kit = kitName;
-    if (kit === excludeKit)
-      continue;
-    if (!kitMeta.files)
-      continue;
-    const file = kitMeta.files.find((f3) => f3.path === relativePath);
-    if (file) {
-      return {
-        exists: true,
-        ownerKit: kit,
-        checksum: file.checksum,
-        version: kitMeta.version,
-        sourceTimestamp: file.sourceTimestamp ?? null,
-        installedAt: file.installedAt ?? null
-      };
-    }
-  }
-  return {
-    exists: false,
-    ownerKit: null,
-    checksum: null,
-    version: null,
-    sourceTimestamp: null,
-    installedAt: null
-  };
-}
-async function getUninstallManifest(claudeDir2, kit) {
-  const detection = await detectMetadataFormat(claudeDir2);
-  if (detection.format === "multi-kit" && detection.metadata?.kits) {
-    const installedKits = Object.keys(detection.metadata.kits);
-    if (kit) {
-      const kitMeta = detection.metadata.kits[kit];
-      if (!kitMeta?.files) {
-        return {
-          filesToRemove: [],
-          filesToPreserve: USER_CONFIG_PATTERNS,
-          hasManifest: true,
-          isMultiKit: true,
-          remainingKits: installedKits.filter((k2) => k2 !== kit)
-        };
-      }
-      const kitFiles = kitMeta.files.map((f3) => f3.path);
-      const sharedFiles = new Set;
-      for (const otherKit of installedKits) {
-        if (otherKit !== kit) {
-          const otherMeta = detection.metadata.kits[otherKit];
-          if (otherMeta?.files) {
-            for (const f3 of otherMeta.files) {
-              sharedFiles.add(f3.path);
-            }
-          }
-        }
-      }
-      const filesToRemove = kitFiles.filter((f3) => !sharedFiles.has(f3));
-      const filesToPreserve = [
-        ...USER_CONFIG_PATTERNS,
-        ...kitFiles.filter((f3) => sharedFiles.has(f3))
-      ];
-      return {
-        filesToRemove,
-        filesToPreserve,
-        hasManifest: true,
-        isMultiKit: true,
-        remainingKits: installedKits.filter((k2) => k2 !== kit)
-      };
-    }
-    const allFiles = getAllTrackedFiles(detection.metadata);
-    return {
-      filesToRemove: allFiles.map((f3) => f3.path),
-      filesToPreserve: USER_CONFIG_PATTERNS,
-      hasManifest: true,
-      isMultiKit: true,
-      remainingKits: []
-    };
-  }
-  if (detection.format === "legacy" && detection.metadata) {
-    const legacyFiles2 = detection.metadata.files?.map((f3) => f3.path) || [];
-    const installedFiles = detection.metadata.installedFiles || [];
-    const hasFiles = legacyFiles2.length > 0 || installedFiles.length > 0;
-    if (!hasFiles) {
-      const legacyDirs2 = ["commands", "agents", "skills", "rules", "workflows", "hooks", "scripts"];
-      const legacyFileList = ["metadata.json"];
-      return {
-        filesToRemove: [...legacyDirs2, ...legacyFileList],
-        filesToPreserve: USER_CONFIG_PATTERNS,
-        hasManifest: false,
-        isMultiKit: false,
-        remainingKits: []
-      };
-    }
-    return {
-      filesToRemove: legacyFiles2.length > 0 ? legacyFiles2 : installedFiles,
-      filesToPreserve: detection.metadata.userConfigFiles || USER_CONFIG_PATTERNS,
-      hasManifest: true,
-      isMultiKit: false,
-      remainingKits: []
-    };
-  }
-  const legacyDirs = ["commands", "agents", "skills", "rules", "workflows", "hooks", "scripts"];
-  const legacyFiles = ["metadata.json"];
-  return {
-    filesToRemove: [...legacyDirs, ...legacyFiles],
-    filesToPreserve: USER_CONFIG_PATTERNS,
-    hasManifest: false,
-    isMultiKit: false,
-    remainingKits: []
-  };
-}
-
-// src/domains/installation/deletion-handler.ts
-init_logger();
-init_path_resolver();
-var import_fs_extra9 = __toESM(require_lib3(), 1);
-var import_picomatch2 = __toESM(require_picomatch2(), 1);
-function findFileInMetadata(metadata, path13) {
-  if (!metadata)
-    return null;
-  if (metadata.kits) {
-    for (const kitMeta of Object.values(metadata.kits)) {
-      if (kitMeta?.files) {
-        const found = kitMeta.files.find((f3) => f3.path === path13);
-        if (found)
-          return found;
-      }
-    }
-  }
-  if (metadata.files) {
-    const found = metadata.files.find((f3) => f3.path === path13);
-    if (found)
-      return found;
-  }
-  return null;
-}
-function shouldDeletePath(path13, metadata) {
-  const tracked = findFileInMetadata(metadata, path13);
-  if (!tracked)
-    return true;
-  return tracked.ownership !== "user";
-}
-function collectFilesRecursively(dir, baseDir) {
-  const results = [];
-  if (!existsSync48(dir))
-    return results;
-  try {
-    const entries = readdirSync3(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = join76(dir, entry.name);
-      const relativePath = relative10(baseDir, fullPath);
-      if (entry.isDirectory()) {
-        results.push(...collectFilesRecursively(fullPath, baseDir));
-      } else {
-        results.push(relativePath);
-      }
-    }
-  } catch {}
-  return results;
-}
-function expandGlobPatterns(patterns, claudeDir2) {
-  const expanded = [];
-  const allFiles = collectFilesRecursively(claudeDir2, claudeDir2);
-  for (const pattern of patterns) {
-    if (PathResolver.isGlobPattern(pattern)) {
-      const matcher = import_picomatch2.default(pattern);
-      const matches = allFiles.filter((file) => matcher(file));
-      expanded.push(...matches);
-      if (matches.length > 0) {
-        logger.debug(`Pattern "${pattern}" matched ${matches.length} files`);
-      }
-    } else {
-      expanded.push(pattern);
-    }
-  }
-  return [...new Set(expanded)];
-}
-var MAX_CLEANUP_ITERATIONS = 50;
-function cleanupEmptyDirectories(filePath, claudeDir2) {
-  const normalizedClaudeDir = resolve17(claudeDir2);
-  let currentDir = resolve17(dirname18(filePath));
-  let iterations = 0;
-  while (currentDir !== normalizedClaudeDir && currentDir.startsWith(normalizedClaudeDir) && iterations < MAX_CLEANUP_ITERATIONS) {
-    iterations++;
-    try {
-      const entries = readdirSync3(currentDir);
-      if (entries.length === 0) {
-        rmdirSync(currentDir);
-        logger.debug(`Removed empty directory: ${currentDir}`);
-        currentDir = resolve17(dirname18(currentDir));
-      } else {
-        break;
-      }
-    } catch {
-      break;
-    }
-  }
-}
-function deletePath(fullPath, claudeDir2) {
-  const normalizedPath = resolve17(fullPath);
-  const normalizedClaudeDir = resolve17(claudeDir2);
-  if (!normalizedPath.startsWith(`${normalizedClaudeDir}${sep3}`) && normalizedPath !== normalizedClaudeDir) {
-    throw new Error(`Path traversal detected: ${fullPath}`);
-  }
-  try {
-    const stat13 = lstatSync3(fullPath);
-    if (stat13.isDirectory()) {
-      rmSync2(fullPath, { recursive: true, force: true });
-    } else {
-      unlinkSync3(fullPath);
-      cleanupEmptyDirectories(fullPath, claudeDir2);
-    }
-  } catch (error) {
-    throw new Error(`Failed to delete ${fullPath}: ${error instanceof Error ? error.message : String(error)}`);
-  }
-}
-async function updateMetadataAfterDeletion(claudeDir2, deletedPaths) {
-  const metadataPath = join76(claudeDir2, "metadata.json");
-  if (!await import_fs_extra9.pathExists(metadataPath)) {
-    return;
-  }
-  let content;
-  try {
-    content = await import_fs_extra9.readFile(metadataPath, "utf-8");
-  } catch {
-    logger.debug("Failed to read metadata.json for cleanup");
-    return;
-  }
-  let metadata;
-  try {
-    metadata = JSON.parse(content);
-  } catch {
-    logger.debug("Failed to parse metadata.json for cleanup");
-    return;
-  }
-  const deletedSet = new Set(deletedPaths);
-  const isDeletedOrInDeletedDir = (path13) => {
-    if (deletedSet.has(path13))
-      return true;
-    for (const deleted of deletedPaths) {
-      if (path13.startsWith(`${deleted}/`))
-        return true;
-    }
-    return false;
-  };
-  if (metadata.kits) {
-    for (const kitName of Object.keys(metadata.kits)) {
-      const kit = metadata.kits[kitName];
-      if (kit?.files) {
-        kit.files = kit.files.filter((f3) => !isDeletedOrInDeletedDir(f3.path));
-      }
-    }
-  }
-  if (metadata.files) {
-    metadata.files = metadata.files.filter((f3) => !isDeletedOrInDeletedDir(f3.path));
-  }
-  try {
-    await import_fs_extra9.writeFile(metadataPath, JSON.stringify(metadata, null, 2));
-    logger.debug(`Updated metadata.json, removed ${deletedPaths.length} entries`);
-  } catch {
-    logger.debug("Failed to write updated metadata.json");
-  }
-}
-async function handleDeletions(sourceMetadata, claudeDir2) {
-  const deletionPatterns = sourceMetadata.deletions || [];
-  if (deletionPatterns.length === 0) {
-    return { deletedPaths: [], preservedPaths: [], errors: [] };
-  }
-  const deletions = expandGlobPatterns(deletionPatterns, claudeDir2);
-  const userMetadata = await readManifest(claudeDir2);
-  const result = { deletedPaths: [], preservedPaths: [], errors: [] };
-  for (const path13 of deletions) {
-    const fullPath = join76(claudeDir2, path13);
-    const normalizedPath = resolve17(fullPath);
-    const normalizedClaudeDir = resolve17(claudeDir2);
-    if (!normalizedPath.startsWith(`${normalizedClaudeDir}${sep3}`)) {
-      logger.warning(`Skipping invalid path: ${path13}`);
-      result.errors.push(path13);
-      continue;
-    }
-    if (!shouldDeletePath(path13, userMetadata)) {
-      result.preservedPaths.push(path13);
-      logger.verbose(`Preserved user file: ${path13}`);
-      continue;
-    }
-    if (existsSync48(fullPath)) {
-      try {
-        deletePath(fullPath, claudeDir2);
-        result.deletedPaths.push(path13);
-        logger.verbose(`Deleted: ${path13}`);
-      } catch (error) {
-        result.errors.push(path13);
-        logger.debug(`Failed to delete ${path13}: ${error}`);
-      }
-    }
-  }
-  if (result.deletedPaths.length > 0) {
-    await updateMetadataAfterDeletion(claudeDir2, result.deletedPaths);
-  }
-  return result;
-}
+init_deletion_handler();
+import { join as join88 } from "node:path";
 
 // src/domains/installation/file-merger.ts
 init_logger();
@@ -83620,9 +84348,10 @@ init_logger();
 init_types3();
 var import_fs_extra12 = __toESM(require_lib3(), 1);
 var import_ignore3 = __toESM(require_ignore(), 1);
-import { dirname as dirname20, join as join79, relative as relative12 } from "node:path";
+import { dirname as dirname21, join as join78, relative as relative12 } from "node:path";
 
 // src/domains/installation/selective-merger.ts
+init_manifest_reader();
 import { stat as stat13 } from "node:fs/promises";
 init_logger();
 var import_semver2 = __toESM(require_semver2(), 1);
@@ -83799,7 +84528,7 @@ init_logger();
 var import_fs_extra10 = __toESM(require_lib3(), 1);
 var import_ignore2 = __toESM(require_ignore(), 1);
 import { relative as relative11 } from "node:path";
-import { join as join77 } from "node:path";
+import { join as join76 } from "node:path";
 
 // node_modules/@isaacs/balanced-match/dist/esm/index.js
 var balanced = (a3, b3, str2) => {
@@ -85255,7 +85984,7 @@ class FileScanner {
     const files = [];
     const entries = await import_fs_extra10.readdir(dir, { encoding: "utf8" });
     for (const entry of entries) {
-      const fullPath = join77(dir, entry);
+      const fullPath = join76(dir, entry);
       const relativePath = relative11(baseDir, fullPath);
       const normalizedRelativePath = relativePath.replace(/\\/g, "/");
       const stats = await import_fs_extra10.lstat(fullPath);
@@ -85295,7 +86024,7 @@ import { execSync as execSync4 } from "node:child_process";
 init_shared();
 import { existsSync as existsSync49 } from "node:fs";
 import { mkdir as mkdir26, readFile as readFile38, writeFile as writeFile22 } from "node:fs/promises";
-import { dirname as dirname19, join as join78 } from "node:path";
+import { dirname as dirname20, join as join77 } from "node:path";
 var CK_JSON_FILE = ".ck.json";
 
 class InstalledSettingsTracker {
@@ -85309,9 +86038,9 @@ class InstalledSettingsTracker {
   }
   getCkJsonPath() {
     if (this.isGlobal) {
-      return join78(this.projectDir, CK_JSON_FILE);
+      return join77(this.projectDir, CK_JSON_FILE);
     }
-    return join78(this.projectDir, ".claude", CK_JSON_FILE);
+    return join77(this.projectDir, ".claude", CK_JSON_FILE);
   }
   async loadInstalledSettings() {
     const ckJsonPath = this.getCkJsonPath();
@@ -85346,7 +86075,7 @@ class InstalledSettingsTracker {
         data.kits[this.kitName] = {};
       }
       data.kits[this.kitName].installedSettings = settings;
-      await mkdir26(dirname19(ckJsonPath), { recursive: true });
+      await mkdir26(dirname20(ckJsonPath), { recursive: true });
       await writeFile22(ckJsonPath, JSON.stringify(data, null, 2), "utf-8");
       logger.debug(`Saved installed settings to ${ckJsonPath}`);
     } catch (error) {
@@ -85864,7 +86593,7 @@ class CopyExecutor {
     for (const file of files) {
       const relativePath = relative12(sourceDir, file);
       const normalizedRelativePath = relativePath.replace(/\\/g, "/");
-      const destPath = join79(destDir, relativePath);
+      const destPath = join78(destDir, relativePath);
       if (await import_fs_extra12.pathExists(destPath)) {
         if (this.fileScanner.shouldNeverCopy(normalizedRelativePath)) {
           logger.debug(`Security-sensitive file exists but won't be overwritten: ${normalizedRelativePath}`);
@@ -85886,7 +86615,7 @@ class CopyExecutor {
     for (const file of files) {
       const relativePath = relative12(sourceDir, file);
       const normalizedRelativePath = relativePath.replace(/\\/g, "/");
-      const destPath = join79(destDir, relativePath);
+      const destPath = join78(destDir, relativePath);
       if (this.fileScanner.shouldNeverCopy(normalizedRelativePath)) {
         logger.debug(`Skipping security-sensitive file: ${normalizedRelativePath}`);
         skippedCount++;
@@ -85963,10 +86692,10 @@ class CopyExecutor {
   }
   trackInstalledFile(relativePath) {
     this.installedFiles.add(relativePath);
-    let dir = dirname20(relativePath);
+    let dir = dirname21(relativePath);
     while (dir && dir !== "." && dir !== "/") {
       this.installedDirectories.add(`${dir}/`);
-      dir = dirname20(dir);
+      dir = dirname21(dir);
     }
   }
 }
@@ -86056,15 +86785,19 @@ class FileMerger {
 
 // src/domains/migration/legacy-migration.ts
 import { readdir as readdir18, stat as stat14 } from "node:fs/promises";
-import { join as join83, relative as relative13 } from "node:path";
+import { join as join82, relative as relative13 } from "node:path";
+
+// src/services/file-operations/manifest/index.ts
+init_manifest_reader();
+
 // src/services/file-operations/manifest/manifest-tracker.ts
-import { join as join82 } from "node:path";
+import { join as join81 } from "node:path";
 
 // src/domains/migration/release-manifest.ts
 init_logger();
 init_zod();
 var import_fs_extra13 = __toESM(require_lib3(), 1);
-import { join as join80 } from "node:path";
+import { join as join79 } from "node:path";
 var ReleaseManifestFileSchema = exports_external.object({
   path: exports_external.string(),
   checksum: exports_external.string().regex(/^[a-f0-9]{64}$/),
@@ -86079,7 +86812,7 @@ var ReleaseManifestSchema = exports_external.object({
 
 class ReleaseManifestLoader {
   static async load(extractDir) {
-    const manifestPath = join80(extractDir, "release-manifest.json");
+    const manifestPath = join79(extractDir, "release-manifest.json");
     try {
       const content = await import_fs_extra13.readFile(manifestPath, "utf-8");
       const parsed = JSON.parse(content);
@@ -86103,11 +86836,12 @@ init_safe_spinner();
 init_metadata_migration();
 init_logger();
 init_types3();
+init_manifest_reader();
 var import_fs_extra14 = __toESM(require_lib3(), 1);
 var import_proper_lockfile5 = __toESM(require_proper_lockfile(), 1);
-import { join as join81 } from "node:path";
+import { join as join80 } from "node:path";
 async function writeManifest(claudeDir2, kitName, version, scope, kitType, trackedFiles, userConfigFiles) {
-  const metadataPath = join81(claudeDir2, "metadata.json");
+  const metadataPath = join80(claudeDir2, "metadata.json");
   const kit = kitType || (/\bmarketing\b/i.test(kitName) ? "marketing" : "engineer");
   await import_fs_extra14.ensureFile(metadataPath);
   let release = null;
@@ -86127,20 +86861,54 @@ async function writeManifest(claudeDir2, kitName, version, scope, kitType, track
         const content = await import_fs_extra14.readFile(metadataPath, "utf-8");
         const parsed = JSON.parse(content);
         if (parsed && typeof parsed === "object" && Object.keys(parsed).length > 0) {
-          existingMetadata = parsed;
+          const validatedExisting = MetadataSchema.safeParse(parsed);
+          if (validatedExisting.success) {
+            existingMetadata = validatedExisting.data;
+          } else {
+            logger.warning("Existing metadata.json is invalid; preserving recoverable fields and rebuilding the rest");
+            const raw2 = parsed;
+            const recoveredKits = {};
+            if (raw2.kits && typeof raw2.kits === "object") {
+              for (const [rawKitName, rawKitValue] of Object.entries(raw2.kits)) {
+                if ((rawKitName === "engineer" || rawKitName === "marketing") && rawKitValue && typeof rawKitValue === "object") {
+                  const recoveredKit = rawKitValue;
+                  if (typeof recoveredKit.version === "string" && typeof recoveredKit.installedAt === "string") {
+                    recoveredKits[rawKitName] = recoveredKit;
+                  }
+                }
+              }
+            }
+            existingMetadata = {
+              kits: recoveredKits,
+              scope: raw2.scope === "local" || raw2.scope === "global" ? raw2.scope : undefined,
+              name: typeof raw2.name === "string" ? raw2.name : undefined,
+              version: typeof raw2.version === "string" ? raw2.version : undefined,
+              installedAt: typeof raw2.installedAt === "string" ? raw2.installedAt : undefined,
+              userConfigFiles: Array.isArray(raw2.userConfigFiles) ? raw2.userConfigFiles.filter((entry) => typeof entry === "string") : undefined
+            };
+          }
         }
       } catch (error) {
         logger.debug(`Could not read existing metadata: ${error}`);
       }
     }
     const installedAt = new Date().toISOString();
+    const existingKits = existingMetadata.kits || {};
+    const existingKitMetadata = existingKits[kit];
     const kitMetadata = {
+      ...existingKitMetadata,
       version,
       installedAt,
       files: trackedFiles.length > 0 ? trackedFiles : undefined
     };
-    const existingKits = existingMetadata.kits || {};
     const otherKitsExist = Object.keys(existingKits).some((k2) => k2 !== kit);
+    const mergedUserConfigFiles = [
+      ...new Set([
+        ...existingMetadata.userConfigFiles || [],
+        ...USER_CONFIG_PATTERNS,
+        ...userConfigFiles
+      ])
+    ];
     const metadata = {
       kits: {
         ...existingKits,
@@ -86150,7 +86918,7 @@ async function writeManifest(claudeDir2, kitName, version, scope, kitType, track
       name: otherKitsExist ? existingMetadata.name ?? kitName : kitName,
       version: otherKitsExist ? existingMetadata.version ?? version : version,
       installedAt: otherKitsExist ? existingMetadata.installedAt ?? installedAt : installedAt,
-      userConfigFiles: [...USER_CONFIG_PATTERNS, ...userConfigFiles]
+      userConfigFiles: mergedUserConfigFiles
     };
     const validated = MetadataSchema.parse(metadata);
     await import_fs_extra14.writeFile(metadataPath, JSON.stringify(validated, null, 2), "utf-8");
@@ -86163,7 +86931,7 @@ async function writeManifest(claudeDir2, kitName, version, scope, kitType, track
   }
 }
 async function removeKitFromManifest(claudeDir2, kit) {
-  const metadataPath = join81(claudeDir2, "metadata.json");
+  const metadataPath = join80(claudeDir2, "metadata.json");
   if (!await import_fs_extra14.pathExists(metadataPath))
     return false;
   let release = null;
@@ -86293,7 +87061,7 @@ function buildFileTrackingList(options2) {
     if (!isGlobal && !installedPath.startsWith(".claude/"))
       continue;
     const relativePath = isGlobal ? installedPath : installedPath.replace(/^\.claude\//, "");
-    const filePath = join82(claudeDir2, relativePath);
+    const filePath = join81(claudeDir2, relativePath);
     const manifestEntry = releaseManifest ? ReleaseManifestLoader.findFile(releaseManifest, installedPath) : null;
     const ownership = manifestEntry ? "ck" : "user";
     filesToTrack.push({
@@ -86400,7 +87168,7 @@ class LegacyMigration {
         continue;
       if (SKIP_DIRS_ALL.includes(entry))
         continue;
-      const fullPath = join83(dir, entry);
+      const fullPath = join82(dir, entry);
       let stats;
       try {
         stats = await stat14(fullPath);
@@ -86502,7 +87270,7 @@ User-created files (sample):`);
     ];
     if (filesToChecksum.length > 0) {
       const checksumResults = await mapWithLimit(filesToChecksum, async ({ relativePath, ownership }) => {
-        const fullPath = join83(claudeDir2, relativePath);
+        const fullPath = join82(claudeDir2, relativePath);
         const checksum = await OwnershipChecker.calculateChecksum(fullPath);
         return { relativePath, checksum, ownership };
       });
@@ -86523,7 +87291,7 @@ User-created files (sample):`);
       installedAt: new Date().toISOString(),
       files: trackedFiles
     };
-    const metadataPath = join83(claudeDir2, "metadata.json");
+    const metadataPath = join82(claudeDir2, "metadata.json");
     await import_fs_extra15.writeFile(metadataPath, JSON.stringify(updatedMetadata, null, 2));
     logger.success(`Migration complete: tracked ${trackedFiles.length} files`);
     return true;
@@ -86629,7 +87397,7 @@ function buildConflictSummary(fileConflicts, hookConflicts, mcpConflicts) {
 init_logger();
 init_skip_directories();
 var import_fs_extra16 = __toESM(require_lib3(), 1);
-import { join as join84, relative as relative14, resolve as resolve18 } from "node:path";
+import { join as join83, relative as relative14, resolve as resolve19 } from "node:path";
 
 class FileScanner2 {
   static async getFiles(dirPath, relativeTo) {
@@ -86645,7 +87413,7 @@ class FileScanner2 {
           logger.debug(`Skipping directory: ${entry}`);
           continue;
         }
-        const fullPath = join84(dirPath, entry);
+        const fullPath = join83(dirPath, entry);
         if (!FileScanner2.isSafePath(basePath, fullPath)) {
           logger.warning(`Skipping potentially unsafe path: ${entry}`);
           continue;
@@ -86680,8 +87448,8 @@ class FileScanner2 {
     return files;
   }
   static async findCustomFiles(destDir, sourceDir, subPath) {
-    const destSubDir = join84(destDir, subPath);
-    const sourceSubDir = join84(sourceDir, subPath);
+    const destSubDir = join83(destDir, subPath);
+    const sourceSubDir = join83(sourceDir, subPath);
     logger.debug(`findCustomFiles - destDir: ${destDir}`);
     logger.debug(`findCustomFiles - sourceDir: ${sourceDir}`);
     logger.debug(`findCustomFiles - subPath: "${subPath}"`);
@@ -86709,8 +87477,8 @@ class FileScanner2 {
     return customFiles;
   }
   static isSafePath(basePath, targetPath) {
-    const resolvedBase = resolve18(basePath);
-    const resolvedTarget = resolve18(targetPath);
+    const resolvedBase = resolve19(basePath);
+    const resolvedTarget = resolve19(targetPath);
     return resolvedTarget.startsWith(resolvedBase);
   }
   static toPosixPath(path14) {
@@ -86722,12 +87490,12 @@ class FileScanner2 {
 init_logger();
 var import_fs_extra17 = __toESM(require_lib3(), 1);
 import { lstat as lstat7, mkdir as mkdir27, readdir as readdir21, stat as stat15 } from "node:fs/promises";
-import { join as join86 } from "node:path";
+import { join as join85 } from "node:path";
 
 // src/services/transformers/commands-prefix/content-transformer.ts
 init_logger();
 import { readFile as readFile42, readdir as readdir20, writeFile as writeFile26 } from "node:fs/promises";
-import { join as join85 } from "node:path";
+import { join as join84 } from "node:path";
 var TRANSFORMABLE_EXTENSIONS = new Set([
   ".md",
   ".txt",
@@ -86788,7 +87556,7 @@ async function transformCommandReferences(directory, options2 = {}) {
   async function processDirectory(dir) {
     const entries = await readdir20(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join85(dir, entry.name);
+      const fullPath = join84(dir, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name.startsWith(".") && entry.name !== ".claude") {
           continue;
@@ -86863,14 +87631,14 @@ function shouldApplyPrefix(options2) {
 // src/services/transformers/commands-prefix/prefix-applier.ts
 async function applyPrefix(extractDir) {
   validatePath(extractDir, "extractDir");
-  const commandsDir = join86(extractDir, ".claude", "commands");
+  const commandsDir = join85(extractDir, ".claude", "commands");
   if (!await import_fs_extra17.pathExists(commandsDir)) {
     logger.verbose("No commands directory found, skipping prefix application");
     return;
   }
   logger.info("Applying /ck: prefix to slash commands...");
-  const backupDir = join86(extractDir, ".commands-backup");
-  const tempDir = join86(extractDir, ".commands-prefix-temp");
+  const backupDir = join85(extractDir, ".commands-backup");
+  const tempDir = join85(extractDir, ".commands-prefix-temp");
   try {
     const entries = await readdir21(commandsDir);
     if (entries.length === 0) {
@@ -86878,7 +87646,7 @@ async function applyPrefix(extractDir) {
       return;
     }
     if (entries.length === 1 && entries[0] === "ck") {
-      const ckDir2 = join86(commandsDir, "ck");
+      const ckDir2 = join85(commandsDir, "ck");
       const ckStat = await stat15(ckDir2);
       if (ckStat.isDirectory()) {
         logger.verbose("Commands already have /ck: prefix, skipping");
@@ -86888,17 +87656,17 @@ async function applyPrefix(extractDir) {
     await import_fs_extra17.copy(commandsDir, backupDir);
     logger.verbose("Created backup of commands directory");
     await mkdir27(tempDir, { recursive: true });
-    const ckDir = join86(tempDir, "ck");
+    const ckDir = join85(tempDir, "ck");
     await mkdir27(ckDir, { recursive: true });
     let processedCount = 0;
     for (const entry of entries) {
-      const sourcePath = join86(commandsDir, entry);
+      const sourcePath = join85(commandsDir, entry);
       const stats = await lstat7(sourcePath);
       if (stats.isSymbolicLink()) {
         logger.warning(`Skipping symlink for security: ${entry}`);
         continue;
       }
-      const destPath = join86(ckDir, entry);
+      const destPath = join85(ckDir, entry);
       await import_fs_extra17.copy(sourcePath, destPath, {
         overwrite: false,
         errorOnExist: true
@@ -86916,7 +87684,7 @@ async function applyPrefix(extractDir) {
     await import_fs_extra17.move(tempDir, commandsDir);
     await import_fs_extra17.remove(backupDir);
     logger.success("Successfully reorganized commands to /ck: prefix");
-    const claudeDir2 = join86(extractDir, ".claude");
+    const claudeDir2 = join85(extractDir, ".claude");
     logger.info("Transforming command references in file contents...");
     const transformResult = await transformCommandReferences(claudeDir2, {
       verbose: logger.isVerbose()
@@ -86954,20 +87722,20 @@ async function applyPrefix(extractDir) {
 // src/services/transformers/commands-prefix/prefix-cleaner.ts
 init_metadata_migration();
 import { lstat as lstat9, readdir as readdir23 } from "node:fs/promises";
-import { join as join88 } from "node:path";
+import { join as join87 } from "node:path";
 init_logger();
 var import_fs_extra19 = __toESM(require_lib3(), 1);
 
 // src/services/transformers/commands-prefix/file-processor.ts
 import { lstat as lstat8, readdir as readdir22 } from "node:fs/promises";
-import { join as join87 } from "node:path";
+import { join as join86 } from "node:path";
 init_logger();
 var import_fs_extra18 = __toESM(require_lib3(), 1);
 async function scanDirectoryFiles(dir) {
   const files = [];
   const entries = await readdir22(dir);
   for (const entry of entries) {
-    const fullPath = join87(dir, entry);
+    const fullPath = join86(dir, entry);
     const stats = await lstat8(fullPath);
     if (stats.isSymbolicLink()) {
       continue;
@@ -87095,8 +87863,8 @@ function isDifferentKitDirectory(dirName, currentKit) {
 async function cleanupCommandsDirectory(targetDir, isGlobal, options2 = {}) {
   const { dryRun = false } = options2;
   validatePath(targetDir, "targetDir");
-  const claudeDir2 = isGlobal ? targetDir : join88(targetDir, ".claude");
-  const commandsDir = join88(claudeDir2, "commands");
+  const claudeDir2 = isGlobal ? targetDir : join87(targetDir, ".claude");
+  const commandsDir = join87(claudeDir2, "commands");
   const accumulator = {
     results: [],
     deletedCount: 0,
@@ -87138,7 +87906,7 @@ async function cleanupCommandsDirectory(targetDir, isGlobal, options2 = {}) {
   }
   const metadataForChecks = options2.kitType ? createKitSpecificMetadata(metadata, options2.kitType) : metadata;
   for (const entry of entries) {
-    const entryPath = join88(commandsDir, entry);
+    const entryPath = join87(commandsDir, entry);
     const stats = await lstat9(entryPath);
     if (stats.isSymbolicLink()) {
       addSymlinkSkip(entry, accumulator);
@@ -87195,7 +87963,7 @@ async function handleMerge(ctx) {
   let customClaudeFiles = [];
   if (!ctx.options.fresh) {
     logger.info("Scanning for custom .claude files...");
-    const scanSourceDir = ctx.options.global ? join89(ctx.extractDir, ".claude") : ctx.extractDir;
+    const scanSourceDir = ctx.options.global ? join88(ctx.extractDir, ".claude") : ctx.extractDir;
     const scanTargetSubdir = ctx.options.global ? "" : ".claude";
     customClaudeFiles = await FileScanner2.findCustomFiles(ctx.resolvedDir, scanSourceDir, scanTargetSubdir);
   } else {
@@ -87260,28 +88028,38 @@ async function handleMerge(ctx) {
       return { ...ctx, cancelled: true };
     }
   }
-  const sourceDir = ctx.options.global ? join89(ctx.extractDir, ".claude") : ctx.extractDir;
+  const sourceDir = ctx.options.global ? join88(ctx.extractDir, ".claude") : ctx.extractDir;
   await merger.merge(sourceDir, ctx.resolvedDir, ctx.isNonInteractive);
   const fileConflicts = merger.getFileConflicts();
   if (fileConflicts.length > 0 && !ctx.isNonInteractive) {
     const summary = buildConflictSummary(fileConflicts, [], []);
     displayConflictSummary(summary);
   }
+  let deferredDeletions = [];
   try {
-    const sourceMetadataPath = ctx.options.global ? join89(sourceDir, "metadata.json") : join89(sourceDir, ".claude", "metadata.json");
+    const sourceMetadataPath = ctx.options.global ? join88(sourceDir, "metadata.json") : join88(sourceDir, ".claude", "metadata.json");
     if (await import_fs_extra20.pathExists(sourceMetadataPath)) {
       const metadataContent = await import_fs_extra20.readFile(sourceMetadataPath, "utf-8");
       const sourceMetadata = JSON.parse(metadataContent);
       if (sourceMetadata.deletions && sourceMetadata.deletions.length > 0) {
-        const deletionResult = await handleDeletions(sourceMetadata, ctx.claudeDir);
-        if (deletionResult.deletedPaths.length > 0) {
-          logger.info(`Removed ${deletionResult.deletedPaths.length} deprecated file(s)`);
-          for (const path14 of deletionResult.deletedPaths) {
-            logger.verbose(`  - ${path14}`);
+        const { categorizeDeletions: categorizeDeletions2 } = await Promise.resolve().then(() => (init_deletion_handler(), exports_deletion_handler));
+        const categorized = categorizeDeletions2(sourceMetadata.deletions);
+        if (categorized.immediate.length > 0) {
+          const immediateMetadata = { ...sourceMetadata, deletions: categorized.immediate };
+          const deletionResult = await handleDeletions(immediateMetadata, ctx.claudeDir);
+          if (deletionResult.deletedPaths.length > 0) {
+            logger.info(`Removed ${deletionResult.deletedPaths.length} deprecated file(s)`);
+            for (const path14 of deletionResult.deletedPaths) {
+              logger.verbose(`  - ${path14}`);
+            }
+          }
+          if (deletionResult.preservedPaths.length > 0) {
+            logger.verbose(`Preserved ${deletionResult.preservedPaths.length} user-owned file(s)`);
           }
         }
-        if (deletionResult.preservedPaths.length > 0) {
-          logger.verbose(`Preserved ${deletionResult.preservedPaths.length} user-owned file(s)`);
+        if (categorized.deferred.length > 0) {
+          deferredDeletions = categorized.deferred;
+          logger.debug(`Deferred ${categorized.deferred.length} skill deletion(s) to post-install phase`);
         }
       }
     } else {
@@ -87308,11 +88086,12 @@ async function handleMerge(ctx) {
   return {
     ...ctx,
     customClaudeFiles,
-    includePatterns
+    includePatterns,
+    deferredDeletions
   };
 }
 // src/commands/init/phases/migration-handler.ts
-import { join as join97 } from "node:path";
+import { join as join96 } from "node:path";
 
 // src/domains/skills/skills-detector.ts
 init_logger();
@@ -87328,7 +88107,7 @@ init_types3();
 var import_fs_extra21 = __toESM(require_lib3(), 1);
 import { createHash as createHash4 } from "node:crypto";
 import { readFile as readFile44, readdir as readdir24, writeFile as writeFile27 } from "node:fs/promises";
-import { join as join90, relative as relative15 } from "node:path";
+import { join as join89, relative as relative15 } from "node:path";
 
 class SkillsManifestManager {
   static MANIFEST_FILENAME = ".skills-manifest.json";
@@ -87350,12 +88129,12 @@ class SkillsManifestManager {
     return manifest;
   }
   static async writeManifest(skillsDir2, manifest) {
-    const manifestPath = join90(skillsDir2, SkillsManifestManager.MANIFEST_FILENAME);
+    const manifestPath = join89(skillsDir2, SkillsManifestManager.MANIFEST_FILENAME);
     await writeFile27(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
     logger.debug(`Wrote manifest to: ${manifestPath}`);
   }
   static async readManifest(skillsDir2) {
-    const manifestPath = join90(skillsDir2, SkillsManifestManager.MANIFEST_FILENAME);
+    const manifestPath = join89(skillsDir2, SkillsManifestManager.MANIFEST_FILENAME);
     if (!await import_fs_extra21.pathExists(manifestPath)) {
       logger.debug(`No manifest found at: ${manifestPath}`);
       return null;
@@ -87378,7 +88157,7 @@ class SkillsManifestManager {
       return "flat";
     }
     for (const dir of dirs.slice(0, 3)) {
-      const dirPath = join90(skillsDir2, dir.name);
+      const dirPath = join89(skillsDir2, dir.name);
       const subEntries = await readdir24(dirPath, { withFileTypes: true });
       const hasSubdirs = subEntries.some((entry) => entry.isDirectory());
       if (hasSubdirs) {
@@ -87397,7 +88176,7 @@ class SkillsManifestManager {
       const entries = await readdir24(skillsDir2, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isDirectory() && !BUILD_ARTIFACT_DIRS.includes(entry.name) && !entry.name.startsWith(".")) {
-          const skillPath = join90(skillsDir2, entry.name);
+          const skillPath = join89(skillsDir2, entry.name);
           const hash = await SkillsManifestManager.hashDirectory(skillPath);
           skills.push({
             name: entry.name,
@@ -87409,11 +88188,11 @@ class SkillsManifestManager {
       const categories = await readdir24(skillsDir2, { withFileTypes: true });
       for (const category of categories) {
         if (category.isDirectory() && !BUILD_ARTIFACT_DIRS.includes(category.name) && !category.name.startsWith(".")) {
-          const categoryPath = join90(skillsDir2, category.name);
+          const categoryPath = join89(skillsDir2, category.name);
           const skillEntries = await readdir24(categoryPath, { withFileTypes: true });
           for (const skillEntry of skillEntries) {
             if (skillEntry.isDirectory() && !skillEntry.name.startsWith(".")) {
-              const skillPath = join90(categoryPath, skillEntry.name);
+              const skillPath = join89(categoryPath, skillEntry.name);
               const hash = await SkillsManifestManager.hashDirectory(skillPath);
               skills.push({
                 name: skillEntry.name,
@@ -87443,7 +88222,7 @@ class SkillsManifestManager {
     const files = [];
     const entries = await readdir24(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join90(dirPath, entry.name);
+      const fullPath = join89(dirPath, entry.name);
       if (entry.name.startsWith(".") || BUILD_ARTIFACT_DIRS.includes(entry.name)) {
         continue;
       }
@@ -87565,7 +88344,7 @@ function getPathMapping(skillName, oldBasePath, newBasePath) {
 // src/domains/skills/detection/script-detector.ts
 var import_fs_extra22 = __toESM(require_lib3(), 1);
 import { readdir as readdir25 } from "node:fs/promises";
-import { join as join91 } from "node:path";
+import { join as join90 } from "node:path";
 async function scanDirectory(skillsDir2) {
   if (!await import_fs_extra22.pathExists(skillsDir2)) {
     return ["flat", []];
@@ -87578,12 +88357,12 @@ async function scanDirectory(skillsDir2) {
   let totalSkillLikeCount = 0;
   const allSkills = [];
   for (const dir of dirs) {
-    const dirPath = join91(skillsDir2, dir.name);
+    const dirPath = join90(skillsDir2, dir.name);
     const subEntries = await readdir25(dirPath, { withFileTypes: true });
     const subdirs = subEntries.filter((entry) => entry.isDirectory() && !entry.name.startsWith("."));
     if (subdirs.length > 0) {
       for (const subdir of subdirs.slice(0, 3)) {
-        const subdirPath = join91(dirPath, subdir.name);
+        const subdirPath = join90(dirPath, subdir.name);
         const subdirFiles = await readdir25(subdirPath, { withFileTypes: true });
         const hasSkillMarker = subdirFiles.some((file) => file.isFile() && (file.name === "skill.md" || file.name === "README.md" || file.name === "readme.md" || file.name === "config.json" || file.name === "package.json"));
         if (hasSkillMarker) {
@@ -87740,12 +88519,12 @@ class SkillsMigrationDetector {
 // src/domains/skills/skills-migrator.ts
 init_logger();
 init_types3();
-import { join as join96 } from "node:path";
+import { join as join95 } from "node:path";
 
 // src/domains/skills/migrator/migration-executor.ts
 init_logger();
 import { copyFile as copyFile6, mkdir as mkdir28, readdir as readdir26, rm as rm10 } from "node:fs/promises";
-import { join as join92 } from "node:path";
+import { join as join91 } from "node:path";
 var import_fs_extra24 = __toESM(require_lib3(), 1);
 
 // src/domains/skills/skills-migration-prompts.ts
@@ -87910,8 +88689,8 @@ async function copySkillDirectory(sourceDir, destDir) {
   await mkdir28(destDir, { recursive: true });
   const entries = await readdir26(sourceDir, { withFileTypes: true });
   for (const entry of entries) {
-    const sourcePath = join92(sourceDir, entry.name);
-    const destPath = join92(destDir, entry.name);
+    const sourcePath = join91(sourceDir, entry.name);
+    const destPath = join91(destDir, entry.name);
     if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.isSymbolicLink()) {
       continue;
     }
@@ -87926,7 +88705,7 @@ async function executeInternal(mappings, customizations, currentSkillsDir, inter
   const migrated = [];
   const preserved = [];
   const errors2 = [];
-  const tempDir = join92(currentSkillsDir, "..", ".skills-migration-temp");
+  const tempDir = join91(currentSkillsDir, "..", ".skills-migration-temp");
   await mkdir28(tempDir, { recursive: true });
   try {
     for (const mapping of mappings) {
@@ -87947,9 +88726,9 @@ async function executeInternal(mappings, customizations, currentSkillsDir, inter
           }
         }
         const category = mapping.category;
-        const targetPath = category ? join92(tempDir, category, skillName) : join92(tempDir, skillName);
+        const targetPath = category ? join91(tempDir, category, skillName) : join91(tempDir, skillName);
         if (category) {
-          await mkdir28(join92(tempDir, category), { recursive: true });
+          await mkdir28(join91(tempDir, category), { recursive: true });
         }
         await copySkillDirectory(currentSkillPath, targetPath);
         migrated.push(skillName);
@@ -88016,7 +88795,7 @@ init_logger();
 init_types3();
 var import_fs_extra25 = __toESM(require_lib3(), 1);
 import { copyFile as copyFile7, mkdir as mkdir29, readdir as readdir27, rm as rm11, stat as stat16 } from "node:fs/promises";
-import { basename as basename10, join as join93, normalize as normalize8 } from "node:path";
+import { basename as basename10, join as join92, normalize as normalize8 } from "node:path";
 function validatePath2(path14, paramName) {
   if (!path14 || typeof path14 !== "string") {
     throw new SkillsMigrationError(`${paramName} must be a non-empty string`);
@@ -88042,7 +88821,7 @@ class SkillsBackupManager {
     const timestamp = Date.now();
     const randomSuffix = Math.random().toString(36).substring(2, 8);
     const backupDirName = `${SkillsBackupManager.BACKUP_PREFIX}${timestamp}-${randomSuffix}`;
-    const backupDir = parentDir ? join93(parentDir, backupDirName) : join93(skillsDir2, "..", backupDirName);
+    const backupDir = parentDir ? join92(parentDir, backupDirName) : join92(skillsDir2, "..", backupDirName);
     logger.info(`Creating backup at: ${backupDir}`);
     try {
       await mkdir29(backupDir, { recursive: true });
@@ -88093,7 +88872,7 @@ class SkillsBackupManager {
     }
     try {
       const entries = await readdir27(parentDir, { withFileTypes: true });
-      const backups = entries.filter((entry) => entry.isDirectory() && entry.name.startsWith(SkillsBackupManager.BACKUP_PREFIX)).map((entry) => join93(parentDir, entry.name));
+      const backups = entries.filter((entry) => entry.isDirectory() && entry.name.startsWith(SkillsBackupManager.BACKUP_PREFIX)).map((entry) => join92(parentDir, entry.name));
       backups.sort().reverse();
       return backups;
     } catch (error) {
@@ -88121,8 +88900,8 @@ class SkillsBackupManager {
   static async copyDirectory(sourceDir, destDir) {
     const entries = await readdir27(sourceDir, { withFileTypes: true });
     for (const entry of entries) {
-      const sourcePath = join93(sourceDir, entry.name);
-      const destPath = join93(destDir, entry.name);
+      const sourcePath = join92(sourceDir, entry.name);
+      const destPath = join92(destDir, entry.name);
       if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.isSymbolicLink()) {
         continue;
       }
@@ -88138,7 +88917,7 @@ class SkillsBackupManager {
     let size = 0;
     const entries = await readdir27(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join93(dirPath, entry.name);
+      const fullPath = join92(dirPath, entry.name);
       if (entry.isSymbolicLink()) {
         continue;
       }
@@ -88174,12 +88953,12 @@ init_skip_directories();
 import { createHash as createHash5 } from "node:crypto";
 import { createReadStream as createReadStream3 } from "node:fs";
 import { readFile as readFile45, readdir as readdir28 } from "node:fs/promises";
-import { join as join94, relative as relative16 } from "node:path";
+import { join as join93, relative as relative16 } from "node:path";
 async function getAllFiles(dirPath) {
   const files = [];
   const entries = await readdir28(dirPath, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = join94(dirPath, entry.name);
+    const fullPath = join93(dirPath, entry.name);
     if (entry.name.startsWith(".") || BUILD_ARTIFACT_DIRS.includes(entry.name) || entry.isSymbolicLink()) {
       continue;
     }
@@ -88193,12 +88972,12 @@ async function getAllFiles(dirPath) {
   return files;
 }
 async function hashFile(filePath) {
-  return new Promise((resolve19, reject) => {
+  return new Promise((resolve20, reject) => {
     const hash = createHash5("sha256");
     const stream = createReadStream3(filePath);
     stream.on("data", (chunk) => hash.update(chunk));
     stream.on("end", () => {
-      resolve19(hash.digest("hex"));
+      resolve20(hash.digest("hex"));
     });
     stream.on("error", (error) => {
       stream.destroy();
@@ -88306,7 +89085,7 @@ async function detectFileChanges(currentSkillPath, baselineSkillPath) {
 init_types3();
 var import_fs_extra27 = __toESM(require_lib3(), 1);
 import { readdir as readdir29 } from "node:fs/promises";
-import { join as join95, normalize as normalize9 } from "node:path";
+import { join as join94, normalize as normalize9 } from "node:path";
 function validatePath3(path14, paramName) {
   if (!path14 || typeof path14 !== "string") {
     throw new SkillsMigrationError(`${paramName} must be a non-empty string`);
@@ -88327,13 +89106,13 @@ async function scanSkillsDirectory(skillsDir2) {
   if (dirs.length === 0) {
     return ["flat", []];
   }
-  const firstDirPath = join95(skillsDir2, dirs[0].name);
+  const firstDirPath = join94(skillsDir2, dirs[0].name);
   const subEntries = await readdir29(firstDirPath, { withFileTypes: true });
   const subdirs = subEntries.filter((entry) => entry.isDirectory() && !entry.name.startsWith("."));
   if (subdirs.length > 0) {
     let skillLikeCount = 0;
     for (const subdir of subdirs.slice(0, 3)) {
-      const subdirPath = join95(firstDirPath, subdir.name);
+      const subdirPath = join94(firstDirPath, subdir.name);
       const subdirFiles = await readdir29(subdirPath, { withFileTypes: true });
       const hasSkillMarker = subdirFiles.some((file) => file.isFile() && (file.name === "skill.md" || file.name === "README.md" || file.name === "readme.md" || file.name === "config.json" || file.name === "package.json"));
       if (hasSkillMarker) {
@@ -88343,7 +89122,7 @@ async function scanSkillsDirectory(skillsDir2) {
     if (skillLikeCount > 0) {
       const skills = [];
       for (const dir of dirs) {
-        const categoryPath = join95(skillsDir2, dir.name);
+        const categoryPath = join94(skillsDir2, dir.name);
         const skillDirs = await readdir29(categoryPath, { withFileTypes: true });
         skills.push(...skillDirs.filter((entry) => entry.isDirectory() && !entry.name.startsWith(".")).map((entry) => entry.name));
       }
@@ -88353,7 +89132,7 @@ async function scanSkillsDirectory(skillsDir2) {
   return ["flat", dirs.map((dir) => dir.name)];
 }
 async function findSkillPath(skillsDir2, skillName) {
-  const flatPath = join95(skillsDir2, skillName);
+  const flatPath = join94(skillsDir2, skillName);
   if (await import_fs_extra27.pathExists(flatPath)) {
     return { path: flatPath, category: undefined };
   }
@@ -88362,8 +89141,8 @@ async function findSkillPath(skillsDir2, skillName) {
     if (!entry.isDirectory() || entry.name.startsWith(".") || entry.name === "node_modules") {
       continue;
     }
-    const categoryPath = join95(skillsDir2, entry.name);
-    const skillPath = join95(categoryPath, skillName);
+    const categoryPath = join94(skillsDir2, entry.name);
+    const skillPath = join94(categoryPath, skillName);
     if (await import_fs_extra27.pathExists(skillPath)) {
       return { path: skillPath, category: entry.name };
     }
@@ -88457,7 +89236,7 @@ class SkillsMigrator {
         }
       }
       if (options2.backup && !options2.dryRun) {
-        const claudeDir2 = join96(currentSkillsDir, "..");
+        const claudeDir2 = join95(currentSkillsDir, "..");
         result.backupPath = await SkillsBackupManager.createBackup(currentSkillsDir, claudeDir2);
         logger.success(`Backup created at: ${result.backupPath}`);
       }
@@ -88518,7 +89297,7 @@ async function handleMigration(ctx) {
     logger.debug("Skipping skills migration (fresh installation)");
     return ctx;
   }
-  const newSkillsDir = join97(ctx.extractDir, ".claude", "skills");
+  const newSkillsDir = join96(ctx.extractDir, ".claude", "skills");
   const currentSkillsDir = PathResolver.buildSkillsPath(ctx.resolvedDir, ctx.options.global);
   if (!await import_fs_extra28.pathExists(newSkillsDir) || !await import_fs_extra28.pathExists(currentSkillsDir)) {
     return ctx;
@@ -88542,13 +89321,13 @@ async function handleMigration(ctx) {
 }
 // src/commands/init/phases/opencode-handler.ts
 import { cp as cp3, readdir as readdir31, rm as rm12 } from "node:fs/promises";
-import { join as join99 } from "node:path";
+import { join as join98 } from "node:path";
 
 // src/services/transformers/opencode-path-transformer.ts
 init_logger();
 import { readFile as readFile46, readdir as readdir30, writeFile as writeFile28 } from "node:fs/promises";
 import { platform as platform12 } from "node:os";
-import { extname as extname5, join as join98 } from "node:path";
+import { extname as extname5, join as join97 } from "node:path";
 var IS_WINDOWS2 = platform12() === "win32";
 function getOpenCodeGlobalPath() {
   return "$HOME/.config/opencode/";
@@ -88609,7 +89388,7 @@ async function transformPathsForGlobalOpenCode(directory, options2 = {}) {
   async function processDirectory2(dir) {
     const entries = await readdir30(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join98(dir, entry.name);
+      const fullPath = join97(dir, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name.startsWith(".")) {
           continue;
@@ -88648,7 +89427,7 @@ async function handleOpenCode(ctx) {
   if (ctx.cancelled || !ctx.extractDir || !ctx.resolvedDir) {
     return ctx;
   }
-  const openCodeSource = join99(ctx.extractDir, ".opencode");
+  const openCodeSource = join98(ctx.extractDir, ".opencode");
   if (!await import_fs_extra29.pathExists(openCodeSource)) {
     logger.debug("No .opencode directory in archive, skipping");
     return ctx;
@@ -88666,8 +89445,8 @@ async function handleOpenCode(ctx) {
     await import_fs_extra29.ensureDir(targetDir);
     const entries = await readdir31(openCodeSource, { withFileTypes: true });
     for (const entry of entries) {
-      const sourcePath = join99(openCodeSource, entry.name);
-      const targetPath = join99(targetDir, entry.name);
+      const sourcePath = join98(openCodeSource, entry.name);
+      const targetPath = join98(targetDir, entry.name);
       if (await import_fs_extra29.pathExists(targetPath)) {
         if (!ctx.options.forceOverwrite) {
           logger.verbose(`Skipping existing: ${entry.name}`);
@@ -88764,20 +89543,21 @@ Please use only one download method.`);
 }
 // src/commands/init/phases/post-install-handler.ts
 init_projects_registry();
-import { join as join100 } from "node:path";
+import { join as join102 } from "node:path";
+init_cc_version_checker();
 init_logger();
 init_path_resolver();
-var import_fs_extra30 = __toESM(require_lib3(), 1);
+var import_fs_extra33 = __toESM(require_lib3(), 1);
 async function handlePostInstall(ctx) {
   if (ctx.cancelled || !ctx.extractDir || !ctx.resolvedDir || !ctx.claudeDir) {
     return ctx;
   }
   if (ctx.options.global) {
-    const claudeMdSource = join100(ctx.extractDir, "CLAUDE.md");
-    const claudeMdDest = join100(ctx.resolvedDir, "CLAUDE.md");
-    if (await import_fs_extra30.pathExists(claudeMdSource)) {
-      if (ctx.options.fresh || !await import_fs_extra30.pathExists(claudeMdDest)) {
-        await import_fs_extra30.copy(claudeMdSource, claudeMdDest);
+    const claudeMdSource = join102(ctx.extractDir, "CLAUDE.md");
+    const claudeMdDest = join102(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);
         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)");
@@ -88796,6 +89576,90 @@ async function handlePostInstall(ctx) {
       withSudo: ctx.options.withSudo
     });
   }
+  let pluginSupported = false;
+  try {
+    const { requireCCPluginSupport: requireCCPluginSupport2 } = await Promise.resolve().then(() => (init_cc_version_checker(), exports_cc_version_checker));
+    await requireCCPluginSupport2();
+    pluginSupported = true;
+  } catch (error) {
+    if (error instanceof CCPluginSupportError) {
+      logger.info(`Plugin install skipped: ${error.message}`);
+      if (error.code === "cc_version_too_old") {
+        logger.info("Upgrade: brew upgrade claude-code (or npm i -g @anthropic-ai/claude-code)");
+      }
+      if (error.code === "cc_not_found") {
+        logger.info("Install Claude Code CLI, then re-run ck init to enable /ck:* plugin skills");
+      }
+    } else {
+      logger.info(`Plugin install skipped: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  let pluginVerified = false;
+  if (pluginSupported) {
+    try {
+      const { handlePluginInstall: handlePluginInstall2 } = await Promise.resolve().then(() => (init_plugin_installer(), exports_plugin_installer));
+      const pluginResult = await handlePluginInstall2(ctx.extractDir);
+      pluginVerified = pluginResult.verified;
+      if (pluginResult.error) {
+        logger.info(`Plugin install issue: ${pluginResult.error}`);
+      }
+    } catch (error) {
+      logger.debug(`Plugin install skipped: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  if (ctx.claudeDir && ctx.kitType) {
+    try {
+      const { updateKitPluginState: updateKitPluginState2 } = await Promise.resolve().then(() => (init_metadata_migration(), exports_metadata_migration));
+      await updateKitPluginState2(ctx.claudeDir, ctx.kitType, {
+        pluginInstalled: pluginVerified,
+        pluginInstalledAt: new Date().toISOString(),
+        pluginVersion: ctx.selectedVersion || "unknown"
+      });
+    } catch {}
+  }
+  if (ctx.deferredDeletions?.length && ctx.claudeDir) {
+    try {
+      const { migrateUserSkills: migrateUserSkills2 } = await Promise.resolve().then(() => (init_skill_migration_merger(), exports_skill_migration_merger));
+      const migration = await migrateUserSkills2(ctx.claudeDir, pluginVerified);
+      if (pluginVerified) {
+        if (!migration.canDelete) {
+          logger.warning("Skill migration metadata unavailable — preserving existing skills (fail-safe)");
+          return { ...ctx, installSkills, pluginSupported };
+        }
+        const preservedDirs = new Set(migration.preserved.map(normalizeSkillDir));
+        const safeDeletions = ctx.deferredDeletions.filter((d3) => {
+          const dirPath = extractSkillDirFromDeletionPath(d3);
+          if (!dirPath)
+            return true;
+          return !preservedDirs.has(normalizeSkillDir(dirPath));
+        });
+        if (safeDeletions.length > 0) {
+          const { handleDeletions: handleDeletions2 } = await Promise.resolve().then(() => (init_deletion_handler(), exports_deletion_handler));
+          const deferredResult = await handleDeletions2({ deletions: safeDeletions }, ctx.claudeDir);
+          if (deferredResult.deletedPaths.length > 0) {
+            logger.info(`Removed ${deferredResult.deletedPaths.length} old skill file(s) (replaced by plugin)`);
+          }
+        }
+      } else {
+        logger.info("Plugin not verified — keeping existing skills as fallback");
+      }
+    } catch (error) {
+      logger.debug(`Deferred skill deletion failed: ${error}`);
+    }
+  }
+  if (pluginVerified) {
+    try {
+      const { cleanupOverlappingStandaloneSkills: cleanupOverlappingStandaloneSkills2 } = await Promise.resolve().then(() => (init_standalone_skill_cleanup(), exports_standalone_skill_cleanup));
+      const globalClaudeDir = PathResolver.getGlobalKitDir();
+      const pluginSkillsDir = join102(PathResolver.getClaudeKitDir(), "marketplace", "plugins", "ck", "skills");
+      const overlap = await cleanupOverlappingStandaloneSkills2(globalClaudeDir, pluginSkillsDir);
+      if (overlap.removed.length > 0) {
+        logger.info(`Cleaned up ${overlap.removed.length} standalone skill(s) now provided by /ck:* plugin`);
+      }
+    } catch (error) {
+      logger.info(`Standalone skill cleanup failed: ${error}`);
+    }
+  }
   if (!ctx.isNonInteractive) {
     const { isGeminiInstalled: isGeminiInstalled2 } = await Promise.resolve().then(() => (init_package_installer(), exports_package_installer));
     const { checkExistingGeminiConfig: checkExistingGeminiConfig2, findMcpConfigPath: findMcpConfigPath2, processGeminiMcpLinking: processGeminiMcpLinking2 } = await Promise.resolve().then(() => (init_gemini_mcp_linker(), exports_gemini_mcp_linker));
@@ -88822,7 +89686,7 @@ async function handlePostInstall(ctx) {
   }
   if (!ctx.options.skipSetup) {
     await promptSetupWizardIfNeeded({
-      envPath: join100(ctx.claudeDir, ".env"),
+      envPath: join102(ctx.claudeDir, ".env"),
       claudeDir: ctx.claudeDir,
       isGlobal: ctx.options.global,
       isNonInteractive: ctx.isNonInteractive,
@@ -88839,14 +89703,26 @@ async function handlePostInstall(ctx) {
   }
   return {
     ...ctx,
-    installSkills
+    installSkills,
+    pluginSupported
   };
 }
+function normalizeSkillDir(path14) {
+  return path14.replace(/\\/g, "/").replace(/\/+/g, "/");
+}
+function extractSkillDirFromDeletionPath(path14) {
+  const normalized = normalizeSkillDir(path14);
+  const parts = normalized.split("/").filter(Boolean);
+  if (parts.length < 2 || parts[0] !== "skills") {
+    return null;
+  }
+  return `skills/${parts[1]}`;
+}
 // src/commands/init/phases/selection-handler.ts
 init_config_manager();
 init_github_client();
 import { mkdir as mkdir30 } from "node:fs/promises";
-import { join as join102, resolve as resolve20 } from "node:path";
+import { join as join104, resolve as resolve21 } from "node:path";
 
 // src/domains/github/kit-access-checker.ts
 init_logger();
@@ -88878,8 +89754,8 @@ async function detectAccessibleKits() {
 // src/domains/github/preflight-checker.ts
 init_logger();
 import { exec as exec8 } from "node:child_process";
-import { promisify as promisify14 } from "node:util";
-var execAsync8 = promisify14(exec8);
+import { promisify as promisify16 } from "node:util";
+var execAsync8 = promisify16(exec8);
 function createSuccessfulPreflightResult() {
   return {
     success: true,
@@ -88976,11 +89852,12 @@ async function runPreflightChecks() {
 
 // src/domains/installation/fresh-installer.ts
 init_metadata_migration();
-import { existsSync as existsSync50, readdirSync as readdirSync4, rmSync as rmSync3, rmdirSync as rmdirSync2, unlinkSync as unlinkSync4 } from "node:fs";
-import { dirname as dirname21, join as join101, resolve as resolve19 } from "node:path";
+init_manifest_reader();
 init_logger();
 init_safe_spinner();
-var import_fs_extra31 = __toESM(require_lib3(), 1);
+var import_fs_extra34 = __toESM(require_lib3(), 1);
+import { existsSync as existsSync50, readdirSync as readdirSync4, rmSync as rmSync3, rmdirSync as rmdirSync2, unlinkSync as unlinkSync4 } from "node:fs";
+import { dirname as dirname22, join as join103, resolve as resolve20 } from "node:path";
 var CLAUDEKIT_SUBDIRECTORIES = ["commands", "agents", "skills", "rules", "hooks"];
 async function analyzeFreshInstallation(claudeDir2) {
   const metadata = await readManifest(claudeDir2);
@@ -89025,15 +89902,15 @@ async function analyzeFreshInstallation(claudeDir2) {
   };
 }
 function cleanupEmptyDirectories2(filePath, claudeDir2) {
-  const normalizedClaudeDir = resolve19(claudeDir2);
-  let currentDir = resolve19(dirname21(filePath));
+  const normalizedClaudeDir = resolve20(claudeDir2);
+  let currentDir = resolve20(dirname22(filePath));
   while (currentDir !== normalizedClaudeDir && currentDir.startsWith(normalizedClaudeDir)) {
     try {
       const entries = readdirSync4(currentDir);
       if (entries.length === 0) {
         rmdirSync2(currentDir);
         logger.debug(`Removed empty directory: ${currentDir}`);
-        currentDir = resolve19(dirname21(currentDir));
+        currentDir = resolve20(dirname22(currentDir));
       } else {
         break;
       }
@@ -89050,7 +89927,7 @@ async function removeFilesByOwnership(claudeDir2, analysis, includeModified) {
   const filesToRemove = includeModified ? [...analysis.ckFiles, ...analysis.ckModifiedFiles] : analysis.ckFiles;
   const filesToPreserve = includeModified ? analysis.userFiles : [...analysis.ckModifiedFiles, ...analysis.userFiles];
   for (const file of filesToRemove) {
-    const fullPath = join101(claudeDir2, file.path);
+    const fullPath = join103(claudeDir2, file.path);
     try {
       if (existsSync50(fullPath)) {
         unlinkSync4(fullPath);
@@ -89075,13 +89952,13 @@ async function removeFilesByOwnership(claudeDir2, analysis, includeModified) {
   };
 }
 async function updateMetadataAfterFresh(claudeDir2, removedFiles) {
-  const metadataPath = join101(claudeDir2, "metadata.json");
-  if (!await import_fs_extra31.pathExists(metadataPath)) {
+  const metadataPath = join103(claudeDir2, "metadata.json");
+  if (!await import_fs_extra34.pathExists(metadataPath)) {
     return;
   }
   let content;
   try {
-    content = await import_fs_extra31.readFile(metadataPath, "utf-8");
+    content = await import_fs_extra34.readFile(metadataPath, "utf-8");
   } catch (readError) {
     logger.warning(`Failed to read metadata.json: ${readError instanceof Error ? readError.message : String(readError)}`);
     return;
@@ -89107,7 +89984,7 @@ async function updateMetadataAfterFresh(claudeDir2, removedFiles) {
     metadata.files = metadata.files.filter((f3) => !removedSet.has(f3.path));
   }
   try {
-    await import_fs_extra31.writeFile(metadataPath, JSON.stringify(metadata, null, 2));
+    await import_fs_extra34.writeFile(metadataPath, JSON.stringify(metadata, null, 2));
     logger.debug(`Updated metadata.json, removed ${removedFiles.length} file entries`);
   } catch (writeError) {
     logger.warning(`Failed to write metadata.json: ${writeError instanceof Error ? writeError.message : String(writeError)}`);
@@ -89118,16 +89995,16 @@ async function removeSubdirectoriesFallback(claudeDir2) {
   const removedFiles = [];
   let removedDirCount = 0;
   for (const subdir of CLAUDEKIT_SUBDIRECTORIES) {
-    const subdirPath = join101(claudeDir2, subdir);
-    if (await import_fs_extra31.pathExists(subdirPath)) {
+    const subdirPath = join103(claudeDir2, subdir);
+    if (await import_fs_extra34.pathExists(subdirPath)) {
       rmSync3(subdirPath, { recursive: true, force: true });
       removedDirCount++;
       removedFiles.push(`${subdir}/ (entire directory)`);
       logger.debug(`Removed subdirectory: ${subdir}/`);
     }
   }
-  const metadataPath = join101(claudeDir2, "metadata.json");
-  if (await import_fs_extra31.pathExists(metadataPath)) {
+  const metadataPath = join103(claudeDir2, "metadata.json");
+  if (await import_fs_extra34.pathExists(metadataPath)) {
     unlinkSync4(metadataPath);
     removedFiles.push("metadata.json");
   }
@@ -89140,7 +90017,7 @@ async function removeSubdirectoriesFallback(claudeDir2) {
   };
 }
 async function handleFreshInstallation(claudeDir2, prompts) {
-  if (!await import_fs_extra31.pathExists(claudeDir2)) {
+  if (!await import_fs_extra34.pathExists(claudeDir2)) {
     logger.info(".claude directory does not exist, proceeding with fresh installation");
     return true;
   }
@@ -89172,10 +90049,11 @@ async function handleFreshInstallation(claudeDir2, prompts) {
 
 // src/commands/init/phases/selection-handler.ts
 init_claudekit_scanner();
+init_manifest_reader();
 init_logger();
 init_path_resolver();
 init_types3();
-var import_fs_extra32 = __toESM(require_lib3(), 1);
+var import_fs_extra35 = __toESM(require_lib3(), 1);
 
 // src/commands/init/types.ts
 function isSyncContext(ctx) {
@@ -89344,7 +90222,7 @@ async function handleSelection(ctx) {
       }
     }
   }
-  const resolvedDir = resolve20(targetDir);
+  const resolvedDir = resolve21(targetDir);
   logger.info(`Target directory: ${resolvedDir}`);
   if (!ctx.options.global && PathResolver.isLocalSameAsGlobal(resolvedDir)) {
     logger.warning("You're at HOME directory. Installing here modifies your GLOBAL ClaudeKit.");
@@ -89366,7 +90244,7 @@ async function handleSelection(ctx) {
       return { ...ctx, cancelled: true };
     }
   }
-  if (!await import_fs_extra32.pathExists(resolvedDir)) {
+  if (!await import_fs_extra35.pathExists(resolvedDir)) {
     if (ctx.options.global) {
       await mkdir30(resolvedDir, { recursive: true });
       logger.info(`Created global directory: ${resolvedDir}`);
@@ -89378,7 +90256,7 @@ async function handleSelection(ctx) {
   }
   if (!ctx.options.fresh) {
     const prefix = PathResolver.getPathPrefix(ctx.options.global);
-    const claudeDir2 = prefix ? join102(resolvedDir, prefix) : resolvedDir;
+    const claudeDir2 = prefix ? join104(resolvedDir, prefix) : resolvedDir;
     try {
       const existingMetadata = await readManifest(claudeDir2);
       if (existingMetadata?.kits) {
@@ -89410,7 +90288,7 @@ async function handleSelection(ctx) {
   }
   if (ctx.options.fresh) {
     const prefix = PathResolver.getPathPrefix(ctx.options.global);
-    const claudeDir2 = prefix ? join102(resolvedDir, prefix) : resolvedDir;
+    const claudeDir2 = prefix ? join104(resolvedDir, prefix) : resolvedDir;
     const canProceed = await handleFreshInstallation(claudeDir2, ctx.prompts);
     if (!canProceed) {
       return { ...ctx, cancelled: true };
@@ -89429,7 +90307,7 @@ async function handleSelection(ctx) {
     logger.info("Fetching available versions...");
     let currentVersion = null;
     try {
-      const metadataPath = ctx.options.global ? join102(PathResolver.getGlobalKitDir(), "metadata.json") : join102(resolvedDir, ".claude", "metadata.json");
+      const metadataPath = ctx.options.global ? join104(PathResolver.getGlobalKitDir(), "metadata.json") : join104(resolvedDir, ".claude", "metadata.json");
       const metadata = await readClaudeKitMetadata(metadataPath);
       currentVersion = metadata?.version || null;
       if (currentVersion) {
@@ -89503,25 +90381,27 @@ async function handleSelection(ctx) {
   };
 }
 // src/commands/init/phases/sync-handler.ts
-import { copyFile as copyFile8, mkdir as mkdir31, open as open4, readFile as readFile48, rename as rename6, stat as stat17, unlink as unlink11, writeFile as writeFile30 } from "node:fs/promises";
-import { dirname as dirname22, join as join103, resolve as resolve21 } from "node:path";
+import { copyFile as copyFile8, mkdir as mkdir31, open as open4, readFile as readFile50, rename as rename7, stat as stat17, unlink as unlink11, writeFile as writeFile30 } from "node:fs/promises";
+import { dirname as dirname23, join as join105, resolve as resolve22 } from "node:path";
+init_cc_version_checker();
+init_manifest_reader();
 init_logger();
 init_path_resolver();
-var import_fs_extra33 = __toESM(require_lib3(), 1);
+var import_fs_extra36 = __toESM(require_lib3(), 1);
 var import_picocolors23 = __toESM(require_picocolors(), 1);
 async function handleSync(ctx) {
   if (!ctx.options.sync) {
     return ctx;
   }
-  const resolvedDir = ctx.options.global ? PathResolver.getGlobalKitDir() : resolve21(ctx.options.dir || ".");
-  const claudeDir2 = ctx.options.global ? resolvedDir : join103(resolvedDir, ".claude");
-  if (!await import_fs_extra33.pathExists(claudeDir2)) {
+  const resolvedDir = ctx.options.global ? PathResolver.getGlobalKitDir() : resolve22(ctx.options.dir || ".");
+  const claudeDir2 = ctx.options.global ? resolvedDir : join105(resolvedDir, ".claude");
+  if (!await import_fs_extra36.pathExists(claudeDir2)) {
     logger.error("Cannot sync: no .claude directory found");
     ctx.prompts.note("Run 'ck init' without --sync to install first.", "No Installation Found");
     return { ...ctx, cancelled: true };
   }
-  const metadataPath = join103(claudeDir2, "metadata.json");
-  if (!await import_fs_extra33.pathExists(metadataPath)) {
+  const metadataPath = join105(claudeDir2, "metadata.json");
+  if (!await import_fs_extra36.pathExists(metadataPath)) {
     logger.error("Cannot sync: no metadata.json found");
     ctx.prompts.note(`Your installation may be from an older version.
 Run 'ck init' to update.`, "Legacy Installation");
@@ -89618,17 +90498,42 @@ function getLockTimeout() {
   return timeoutMs;
 }
 var STALE_LOCK_THRESHOLD_MS = 5 * 60 * 1000;
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    const code2 = error.code;
+    return code2 === "EPERM";
+  }
+}
+async function readLockPayload(lockPath) {
+  try {
+    const raw2 = await readFile50(lockPath, "utf-8");
+    const parsed = JSON.parse(raw2);
+    if (typeof parsed.pid === "number" && Number.isInteger(parsed.pid) && parsed.pid > 0) {
+      return {
+        pid: parsed.pid,
+        startedAt: typeof parsed.startedAt === "string" && parsed.startedAt.length > 0 ? parsed.startedAt : "unknown"
+      };
+    }
+  } catch {}
+  return null;
+}
 async function acquireSyncLock(global3) {
   const cacheDir = PathResolver.getCacheDir(global3);
-  const lockPath = join103(cacheDir, ".sync-lock");
+  const lockPath = join105(cacheDir, ".sync-lock");
   const startTime = Date.now();
   const lockTimeout = getLockTimeout();
-  await mkdir31(dirname22(lockPath), { recursive: true });
+  await mkdir31(dirname23(lockPath), { recursive: true });
   while (Date.now() - startTime < lockTimeout) {
     try {
       const handle = await open4(lockPath, "wx");
+      await handle.writeFile(JSON.stringify({ pid: process.pid, startedAt: new Date().toISOString() }), "utf-8");
       return async () => {
-        await handle.close();
+        try {
+          await handle.close();
+        } catch {}
         await unlink11(lockPath).catch(() => {});
       };
     } catch (err) {
@@ -89636,18 +90541,29 @@ async function acquireSyncLock(global3) {
         try {
           const lockStat = await stat17(lockPath);
           const lockAge = Math.abs(Date.now() - lockStat.mtimeMs);
-          if (lockAge > STALE_LOCK_THRESHOLD_MS) {
-            logger.warning(`Removing stale sync lock (age: ${Math.round(lockAge / 1000)}s)`);
+          const lockOwner = await readLockPayload(lockPath);
+          if (lockOwner?.pid === process.pid) {
+            throw new Error("Sync lock is already held by current process");
+          }
+          const ownerAlive = lockOwner?.pid ? isProcessAlive(lockOwner.pid) : null;
+          if (lockAge > STALE_LOCK_THRESHOLD_MS && ownerAlive !== true) {
+            logger.warning(`Removing stale sync lock (age: ${Math.round(lockAge / 1000)}s${lockOwner?.pid ? `, pid=${lockOwner.pid}` : ""})`);
             await unlink11(lockPath).catch(() => {});
             continue;
           }
+          if (lockAge > STALE_LOCK_THRESHOLD_MS && ownerAlive === true) {
+            logger.debug(`Sync lock older than threshold but owner pid=${lockOwner?.pid} still alive; waiting`);
+          }
         } catch (statError) {
+          if (statError instanceof Error && statError.message.includes("already held by current process")) {
+            throw statError;
+          }
           if (statError.code === "ENOENT") {
             continue;
           }
           logger.debug(`Lock stat failed: ${statError}`);
         }
-        await new Promise((resolve22) => setTimeout(resolve22, 100));
+        await new Promise((resolve23) => setTimeout(resolve23, 100));
         continue;
       }
       throw err;
@@ -89666,18 +90582,20 @@ async function executeSyncMerge(ctx) {
   const releaseLock = await acquireSyncLock(ctx.options.global);
   try {
     const trackedFiles = ctx.syncTrackedFiles;
-    const upstreamDir = ctx.options.global ? join103(ctx.extractDir, ".claude") : ctx.extractDir;
+    const upstreamDir = ctx.options.global ? join105(ctx.extractDir, ".claude") : ctx.extractDir;
     let deletions = [];
     try {
-      const sourceMetadataPath = join103(upstreamDir, "metadata.json");
-      if (await import_fs_extra33.pathExists(sourceMetadataPath)) {
-        const content = await readFile48(sourceMetadataPath, "utf-8");
+      const sourceMetadataPath = join105(upstreamDir, "metadata.json");
+      if (await import_fs_extra36.pathExists(sourceMetadataPath)) {
+        const content = await readFile50(sourceMetadataPath, "utf-8");
         const sourceMetadata = JSON.parse(content);
         deletions = sourceMetadata.deletions || [];
       }
     } catch (error) {
       logger.debug(`Failed to load source metadata for deletion filtering: ${error}`);
     }
+    const { categorizeDeletions: categorizeDeletions2, handleDeletions: handleDeletions2 } = await Promise.resolve().then(() => (init_deletion_handler(), exports_deletion_handler));
+    const categorizedDeletions = categorizeDeletions2(deletions);
     const filteredTrackedFiles = filterDeletionPaths(trackedFiles, deletions);
     if (deletions.length > 0) {
       const filtered = trackedFiles.length - filteredTrackedFiles.length;
@@ -89685,23 +90603,44 @@ async function executeSyncMerge(ctx) {
     }
     logger.info("Analyzing file changes...");
     const plan = await SyncEngine.createSyncPlan(filteredTrackedFiles, ctx.claudeDir, upstreamDir);
+    const forceOverwriteNonInteractive = ctx.isNonInteractive && ctx.options.forceOverwrite;
+    const autoUpdateQueue = forceOverwriteNonInteractive ? dedupeTrackedFiles([...plan.autoUpdate, ...plan.needsReview]) : plan.autoUpdate;
+    const reviewQueue = forceOverwriteNonInteractive ? [] : plan.needsReview;
     displaySyncPlan(plan);
-    if (plan.autoUpdate.length === 0 && plan.needsReview.length === 0) {
+    if (autoUpdateQueue.length === 0 && reviewQueue.length === 0 && categorizedDeletions.immediate.length === 0 && categorizedDeletions.deferred.length === 0) {
       ctx.prompts.note("All files are up to date or user-owned.", "No Changes Needed");
+    }
+    if (reviewQueue.length > 0 && ctx.isNonInteractive) {
+      logger.error(`Cannot complete sync: ${reviewQueue.length} file(s) require interactive review`);
+      ctx.prompts.note(`The following files have local modifications:
+${reviewQueue.slice(0, 5).map((f3) => `  • ${f3.path}`).join(`
+`)}${reviewQueue.length > 5 ? `
+  ... and ${reviewQueue.length - 5} more` : ""}
+
+Options:
+  1. Run 'ck init --sync' without --yes for interactive merge
+  2. Use --force-overwrite to accept all upstream changes
+  3. Manually resolve conflicts before syncing`, "Sync Blocked");
       return { ...ctx, cancelled: true };
     }
-    const backupDir = PathResolver.getBackupDir();
-    await createBackup(ctx.claudeDir, trackedFiles, backupDir);
-    logger.success(`Backup created at ${import_picocolors23.default.dim(backupDir)}`);
-    if (plan.autoUpdate.length > 0) {
-      logger.info(`Auto-updating ${plan.autoUpdate.length} file(s)...`);
+    if (forceOverwriteNonInteractive && plan.needsReview.length > 0) {
+      logger.info(`--force-overwrite enabled: auto-updating ${plan.needsReview.length} locally modified file(s)`);
+    }
+    const willModifyFiles = autoUpdateQueue.length > 0 || reviewQueue.length > 0 || categorizedDeletions.immediate.length > 0 || categorizedDeletions.deferred.length > 0;
+    if (willModifyFiles) {
+      const backupDir = PathResolver.getBackupDir();
+      await createBackup(ctx.claudeDir, trackedFiles, backupDir);
+      logger.success(`Backup created at ${import_picocolors23.default.dim(backupDir)}`);
+    }
+    if (autoUpdateQueue.length > 0) {
+      logger.info(`Auto-updating ${autoUpdateQueue.length} file(s)...`);
       let updateSuccess = 0;
       let updateFailed = 0;
-      for (const file of plan.autoUpdate) {
+      for (const file of autoUpdateQueue) {
         try {
           const sourcePath = await validateSyncPath(upstreamDir, file.path);
           const targetPath = await validateSyncPath(ctx.claudeDir, file.path);
-          const targetDir = join103(targetPath, "..");
+          const targetDir = dirname23(targetPath);
           try {
             await mkdir31(targetDir, { recursive: true });
           } catch (mkdirError) {
@@ -89711,7 +90650,7 @@ async function executeSyncMerge(ctx) {
               ctx.prompts.note("Your disk is full. Free up space and try again.", "Sync Failed");
               return { ...ctx, cancelled: true };
             }
-            if (errCode === "EROFS" || errCode === "EACCES") {
+            if (errCode === "EROFS" || errCode === "EACCES" || errCode === "EPERM") {
               logger.warning(`Cannot create directory ${file.path}: ${errCode}`);
               updateFailed++;
               continue;
@@ -89729,7 +90668,7 @@ async function executeSyncMerge(ctx) {
             ctx.prompts.note("Your disk is full. Free up space and try again.", "Sync Failed");
             return { ...ctx, cancelled: true };
           }
-          if (errCode === "EACCES" || errCode === "EPERM") {
+          if (errCode === "EACCES" || errCode === "EPERM" || errCode === "EROFS") {
             logger.warning(`Permission denied: ${file.path} - check file permissions`);
             updateFailed++;
           } else if (errMsg.includes("Symlink") || errMsg.includes("Path")) {
@@ -89744,19 +90683,22 @@ async function executeSyncMerge(ctx) {
       if (updateSuccess > 0) {
         logger.success(`Auto-updated ${updateSuccess} file(s)${updateFailed > 0 ? ` (${updateFailed} failed)` : ""}`);
       }
+      if (updateSuccess === 0 && updateFailed > 0) {
+        logger.warning("No files were updated due to write errors");
+      }
     }
-    if (plan.needsReview.length > 0 && !ctx.isNonInteractive) {
-      logger.info(`${plan.needsReview.length} file(s) need interactive review...`);
+    if (reviewQueue.length > 0 && !ctx.isNonInteractive) {
+      logger.info(`${reviewQueue.length} file(s) need interactive review...`);
       let totalApplied = 0;
       let totalRejected = 0;
       let skippedFiles = 0;
-      for (const file of plan.needsReview) {
+      for (const file of reviewQueue) {
         let currentPath;
         let upstreamPath;
         try {
           currentPath = await validateSyncPath(ctx.claudeDir, file.path);
           upstreamPath = await validateSyncPath(upstreamDir, file.path);
-        } catch (error) {
+        } catch {
           logger.warning(`Skipping invalid path during review: ${file.path}`);
           skippedFiles++;
           continue;
@@ -89783,7 +90725,7 @@ async function executeSyncMerge(ctx) {
           const tempPath = `${currentPath}.tmp.${Date.now()}`;
           try {
             await writeFile30(tempPath, result.result, "utf-8");
-            await rename6(tempPath, currentPath);
+            await rename7(tempPath, currentPath);
           } catch (atomicError) {
             await unlink11(tempPath).catch(() => {});
             throw atomicError;
@@ -89804,8 +90746,8 @@ async function executeSyncMerge(ctx) {
       console.log("");
       console.log(import_picocolors23.default.bold("Sync Summary:"));
       console.log(import_picocolors23.default.dim("─".repeat(40)));
-      if (plan.autoUpdate.length > 0) {
-        console.log(import_picocolors23.default.green(`  ✓ ${plan.autoUpdate.length} file(s) auto-updated`));
+      if (autoUpdateQueue.length > 0) {
+        console.log(import_picocolors23.default.green(`  ✓ ${autoUpdateQueue.length} file(s) auto-updated`));
       }
       if (totalApplied > 0) {
         console.log(import_picocolors23.default.green(`  ✓ ${totalApplied} hunk(s) applied`));
@@ -89819,23 +90761,96 @@ async function executeSyncMerge(ctx) {
       if (plan.skipped.length > 0) {
         console.log(import_picocolors23.default.dim(`  ─ ${plan.skipped.length} user-owned file(s) unchanged`));
       }
-    } else if (plan.needsReview.length > 0 && ctx.isNonInteractive) {
-      logger.error(`Cannot complete sync: ${plan.needsReview.length} file(s) require interactive review`);
-      ctx.prompts.note(`The following files have local modifications:
-${plan.needsReview.slice(0, 5).map((f3) => `  • ${f3.path}`).join(`
-`)}${plan.needsReview.length > 5 ? `
-  ... and ${plan.needsReview.length - 5} more` : ""}
-
-Options:
-  1. Run 'ck init --sync' without --yes for interactive merge
-  2. Use --force-overwrite to accept all upstream changes
-  3. Manually resolve conflicts before syncing`, "Sync Blocked");
-      return { ...ctx, cancelled: true };
+    }
+    if (categorizedDeletions.immediate.length > 0) {
+      try {
+        const deletionResult = await handleDeletions2({ deletions: categorizedDeletions.immediate }, ctx.claudeDir);
+        if (deletionResult.deletedPaths.length > 0) {
+          logger.info(`Removed ${deletionResult.deletedPaths.length} deprecated file(s)`);
+        }
+        if (deletionResult.preservedPaths.length > 0) {
+          logger.verbose(`Preserved ${deletionResult.preservedPaths.length} user-owned file(s)`);
+        }
+      } catch (error) {
+        logger.debug(`Immediate deletion cleanup failed during sync: ${error}`);
+      }
+    }
+    let pluginSupported = false;
+    let pluginVerified = false;
+    try {
+      const { requireCCPluginSupport: requireCCPluginSupport2 } = await Promise.resolve().then(() => (init_cc_version_checker(), exports_cc_version_checker));
+      await requireCCPluginSupport2();
+      pluginSupported = true;
+    } catch (error) {
+      if (error instanceof CCPluginSupportError) {
+        logger.info(`Plugin install skipped during sync: ${error.message}`);
+        if (error.code === "cc_version_too_old") {
+          logger.info("Upgrade Claude Code, then re-run: ck init --sync (plugin migration requires >= 1.0.33)");
+        }
+        if (error.code === "cc_not_found") {
+          logger.info("Install Claude Code CLI to enable /ck:* plugin skills");
+        }
+      } else {
+        logger.debug(`Plugin version check failed during sync: ${error instanceof Error ? error.message : "Unknown error"}`);
+      }
+    }
+    if (pluginSupported && ctx.extractDir) {
+      try {
+        const { handlePluginInstall: handlePluginInstall2 } = await Promise.resolve().then(() => (init_plugin_installer(), exports_plugin_installer));
+        const pluginResult = await handlePluginInstall2(ctx.extractDir);
+        pluginVerified = pluginResult.verified;
+        if (pluginResult.error) {
+          logger.debug(`Plugin install issue: ${pluginResult.error}`);
+        }
+      } catch (error) {
+        logger.debug(`Plugin install skipped: ${error instanceof Error ? error.message : "Unknown error"}`);
+      }
+    }
+    if (ctx.claudeDir && ctx.kitType) {
+      try {
+        const { updateKitPluginState: updateKitPluginState2 } = await Promise.resolve().then(() => (init_metadata_migration(), exports_metadata_migration));
+        await updateKitPluginState2(ctx.claudeDir, ctx.kitType, {
+          pluginInstalled: pluginVerified,
+          pluginInstalledAt: new Date().toISOString(),
+          pluginVersion: ctx.selectedVersion || ctx.syncLatestVersion || "unknown"
+        });
+      } catch {}
+    }
+    if (categorizedDeletions.deferred.length > 0) {
+      if (pluginVerified) {
+        try {
+          const { migrateUserSkills: migrateUserSkills2 } = await Promise.resolve().then(() => (init_skill_migration_merger(), exports_skill_migration_merger));
+          const migration = await migrateUserSkills2(ctx.claudeDir, pluginVerified);
+          if (!migration.canDelete) {
+            logger.warning("Skill migration metadata unavailable during sync — preserving existing skills");
+          } else {
+            const preservedDirs = new Set(migration.preserved.map(normalizeSkillDir2));
+            const safeDeletions = categorizedDeletions.deferred.filter((path14) => {
+              const skillDir = extractSkillDirFromDeletionPath2(path14);
+              return !skillDir || !preservedDirs.has(normalizeSkillDir2(skillDir));
+            });
+            if (safeDeletions.length > 0) {
+              const deferredResult = await handleDeletions2({ deletions: safeDeletions }, ctx.claudeDir);
+              if (deferredResult.deletedPaths.length > 0) {
+                logger.info(`Removed ${deferredResult.deletedPaths.length} old skill file(s) during sync`);
+              }
+            }
+          }
+        } catch (error) {
+          logger.debug(`Deferred skill cleanup failed during sync: ${error}`);
+        }
+      } else {
+        logger.info("Plugin not verified during sync — keeping existing skills as fallback");
+      }
     }
     ctx.prompts.outro("Config sync completed successfully");
     return { ...ctx, cancelled: true };
   } finally {
-    await releaseLock();
+    try {
+      await releaseLock();
+    } catch (error) {
+      logger.debug(`Failed to release sync lock: ${error}`);
+    }
   }
 }
 function displaySyncPlan(plan) {
@@ -89870,9 +90885,9 @@ async function createBackup(claudeDir2, files, backupDir) {
   for (const file of files) {
     try {
       const sourcePath = await validateSyncPath(claudeDir2, file.path);
-      if (await import_fs_extra33.pathExists(sourcePath)) {
+      if (await import_fs_extra36.pathExists(sourcePath)) {
         const targetPath = await validateSyncPath(backupDir, file.path);
-        const targetDir = join103(targetPath, "..");
+        const targetDir = dirname23(targetPath);
         await mkdir31(targetDir, { recursive: true });
         await copyFile8(sourcePath, targetPath);
       }
@@ -89885,9 +90900,27 @@ async function createBackup(claudeDir2, files, backupDir) {
     }
   }
 }
+function dedupeTrackedFiles(files) {
+  const deduped = new Map;
+  for (const file of files) {
+    deduped.set(file.path, file);
+  }
+  return [...deduped.values()];
+}
+function normalizeSkillDir2(path14) {
+  return path14.replace(/\\/g, "/").replace(/\/+/g, "/");
+}
+function extractSkillDirFromDeletionPath2(path14) {
+  const normalized = normalizeSkillDir2(path14);
+  const parts = normalized.split("/").filter(Boolean);
+  if (parts.length < 2 || parts[0] !== "skills") {
+    return null;
+  }
+  return `skills/${parts[1]}`;
+}
 // src/commands/init/phases/transform-handler.ts
 init_config_manager();
-import { join as join107 } from "node:path";
+import { join as join109 } from "node:path";
 
 // src/services/transformers/folder-path-transformer.ts
 init_logger();
@@ -89896,40 +90929,40 @@ init_types3();
 // src/services/transformers/folder-transform/folder-renamer.ts
 init_logger();
 init_types3();
-var import_fs_extra34 = __toESM(require_lib3(), 1);
-import { rename as rename7, rm as rm13 } from "node:fs/promises";
-import { join as join104, relative as relative18 } from "node:path";
+var import_fs_extra37 = __toESM(require_lib3(), 1);
+import { rename as rename8, rm as rm13 } from "node:fs/promises";
+import { join as join106, relative as relative18 } from "node:path";
 async function collectDirsToRename(extractDir, folders) {
   const dirsToRename = [];
   if (folders.docs !== DEFAULT_FOLDERS.docs) {
-    const docsPath = join104(extractDir, DEFAULT_FOLDERS.docs);
-    if (await import_fs_extra34.pathExists(docsPath)) {
+    const docsPath = join106(extractDir, DEFAULT_FOLDERS.docs);
+    if (await import_fs_extra37.pathExists(docsPath)) {
       dirsToRename.push({
         from: docsPath,
-        to: join104(extractDir, folders.docs)
+        to: join106(extractDir, folders.docs)
       });
     }
-    const claudeDocsPath = join104(extractDir, ".claude", DEFAULT_FOLDERS.docs);
-    if (await import_fs_extra34.pathExists(claudeDocsPath)) {
+    const claudeDocsPath = join106(extractDir, ".claude", DEFAULT_FOLDERS.docs);
+    if (await import_fs_extra37.pathExists(claudeDocsPath)) {
       dirsToRename.push({
         from: claudeDocsPath,
-        to: join104(extractDir, ".claude", folders.docs)
+        to: join106(extractDir, ".claude", folders.docs)
       });
     }
   }
   if (folders.plans !== DEFAULT_FOLDERS.plans) {
-    const plansPath = join104(extractDir, DEFAULT_FOLDERS.plans);
-    if (await import_fs_extra34.pathExists(plansPath)) {
+    const plansPath = join106(extractDir, DEFAULT_FOLDERS.plans);
+    if (await import_fs_extra37.pathExists(plansPath)) {
       dirsToRename.push({
         from: plansPath,
-        to: join104(extractDir, folders.plans)
+        to: join106(extractDir, folders.plans)
       });
     }
-    const claudePlansPath = join104(extractDir, ".claude", DEFAULT_FOLDERS.plans);
-    if (await import_fs_extra34.pathExists(claudePlansPath)) {
+    const claudePlansPath = join106(extractDir, ".claude", DEFAULT_FOLDERS.plans);
+    if (await import_fs_extra37.pathExists(claudePlansPath)) {
       dirsToRename.push({
         from: claudePlansPath,
-        to: join104(extractDir, ".claude", folders.plans)
+        to: join106(extractDir, ".claude", folders.plans)
       });
     }
   }
@@ -89937,11 +90970,11 @@ async function collectDirsToRename(extractDir, folders) {
 }
 async function moveAcrossDevices(src, dest) {
   try {
-    await rename7(src, dest);
+    await rename8(src, dest);
   } catch (e2) {
     if (e2.code === "EXDEV") {
       logger.debug(`Cross-device move detected, using copy+delete: ${src} -> ${dest}`);
-      await import_fs_extra34.copy(src, dest, { overwrite: true });
+      await import_fs_extra37.copy(src, dest, { overwrite: true });
       await rm13(src, { recursive: true, force: true });
     } else {
       throw e2;
@@ -89969,8 +91002,8 @@ async function renameFolders(dirsToRename, extractDir, options2) {
 // src/services/transformers/folder-transform/path-replacer.ts
 init_logger();
 init_types3();
-import { readFile as readFile49, readdir as readdir32, writeFile as writeFile31 } from "node:fs/promises";
-import { join as join105, relative as relative19 } from "node:path";
+import { readFile as readFile51, readdir as readdir33, writeFile as writeFile31 } from "node:fs/promises";
+import { join as join107, relative as relative19 } from "node:path";
 var TRANSFORMABLE_FILE_PATTERNS = [
   ".md",
   ".txt",
@@ -90021,9 +91054,9 @@ function compileReplacements(replacements) {
 async function transformFileContents(dir, compiledReplacements, options2) {
   let filesChanged = 0;
   let replacementsCount = 0;
-  const entries = await readdir32(dir, { withFileTypes: true });
+  const entries = await readdir33(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = join105(dir, entry.name);
+    const fullPath = join107(dir, entry.name);
     if (entry.isDirectory()) {
       if (entry.name === "node_modules" || entry.name === ".git") {
         continue;
@@ -90036,7 +91069,7 @@ async function transformFileContents(dir, compiledReplacements, options2) {
       if (!shouldTransform)
         continue;
       try {
-        const content = await readFile49(fullPath, "utf-8");
+        const content = await readFile51(fullPath, "utf-8");
         let newContent = content;
         let changeCount = 0;
         for (const { regex: regex2, replacement } of compiledReplacements) {
@@ -90158,9 +91191,9 @@ async function transformFolderPaths(extractDir, folders, options2 = {}) {
 
 // src/services/transformers/global-path-transformer.ts
 init_logger();
-import { readFile as readFile50, readdir as readdir33, writeFile as writeFile32 } from "node:fs/promises";
+import { readFile as readFile52, readdir as readdir34, writeFile as writeFile32 } from "node:fs/promises";
 import { platform as platform13 } from "node:os";
-import { extname as extname6, join as join106 } from "node:path";
+import { extname as extname6, join as join108 } from "node:path";
 var IS_WINDOWS3 = platform13() === "win32";
 var HOME_PREFIX = IS_WINDOWS3 ? "%USERPROFILE%" : "$HOME";
 function getHomeDirPrefix() {
@@ -90268,9 +91301,9 @@ async function transformPathsForGlobalInstall(directory, options2 = {}) {
   let filesSkipped = 0;
   const skippedFiles = [];
   async function processDirectory2(dir) {
-    const entries = await readdir33(dir, { withFileTypes: true });
+    const entries = await readdir34(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join106(dir, entry.name);
+      const fullPath = join108(dir, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name.startsWith(".") && entry.name !== ".claude") {
           continue;
@@ -90278,7 +91311,7 @@ async function transformPathsForGlobalInstall(directory, options2 = {}) {
         await processDirectory2(fullPath);
       } else if (entry.isFile() && shouldTransformFile3(entry.name)) {
         try {
-          const content = await readFile50(fullPath, "utf-8");
+          const content = await readFile52(fullPath, "utf-8");
           const { transformed, changes } = transformContent(content);
           if (changes > 0) {
             await writeFile32(fullPath, transformed, "utf-8");
@@ -90346,7 +91379,7 @@ async function handleTransforms(ctx) {
       logger.debug(ctx.options.global ? "Saved folder configuration to ~/.claude/.ck.json" : "Saved folder configuration to .claude/.ck.json");
     }
   }
-  const claudeDir2 = ctx.options.global ? ctx.resolvedDir : join107(ctx.resolvedDir, ".claude");
+  const claudeDir2 = ctx.options.global ? ctx.resolvedDir : join109(ctx.resolvedDir, ".claude");
   return {
     ...ctx,
     foldersConfig,
@@ -90540,8 +91573,8 @@ init_checksum_utils();
 init_config_discovery();
 var import_picocolors25 = __toESM(require_picocolors(), 1);
 import { existsSync as existsSync51 } from "node:fs";
-import { readFile as readFile51, rm as rm14, unlink as unlink12 } from "node:fs/promises";
-import { resolve as resolve22 } from "node:path";
+import { readFile as readFile53, rm as rm14, unlink as unlink12 } from "node:fs/promises";
+import { resolve as resolve23 } from "node:path";
 
 // src/commands/portable/conflict-resolver.ts
 init_dist2();
@@ -90888,7 +91921,7 @@ function shouldExecuteAction2(action) {
 }
 async function executeDeleteAction(action, options2) {
   const preservePaths = options2?.preservePaths ?? new Set;
-  const shouldPreserveTarget = action.targetPath.length > 0 && preservePaths.has(resolve22(action.targetPath));
+  const shouldPreserveTarget = action.targetPath.length > 0 && preservePaths.has(resolve23(action.targetPath));
   try {
     if (!shouldPreserveTarget && action.targetPath && existsSync51(action.targetPath)) {
       await rm14(action.targetPath, { recursive: true, force: true });
@@ -91113,7 +92146,7 @@ async function migrateCommand(options2) {
       for (const action of conflictActions) {
         if (!action.diff && action.targetPath && existsSync51(action.targetPath)) {
           try {
-            const targetContent = await readFile51(action.targetPath, "utf-8");
+            const targetContent = await readFile53(action.targetPath, "utf-8");
             const sourceItem = agents2.find((a3) => a3.name === action.item) || commands.find((c2) => c2.name === action.item) || (configItem?.name === action.item ? configItem : null) || ruleItems.find((r2) => r2.name === action.item);
             if (sourceItem) {
               const providerConfig = providers[action.provider];
@@ -91204,7 +92237,7 @@ async function migrateCommand(options2) {
         allResults.push(...await installSkillDirectories(skills, skillProviders, installOpts));
       }
     }
-    const writtenPaths = new Set(allResults.filter((result) => result.success && !result.skipped && result.path.length > 0).map((result) => resolve22(result.path)));
+    const writtenPaths = new Set(allResults.filter((result) => result.success && !result.skipped && result.path.length > 0).map((result) => resolve23(result.path)));
     for (const deleteAction of plannedDeleteActions) {
       allResults.push(await executeDeleteAction(deleteAction, {
         preservePaths: writtenPaths
@@ -91320,7 +92353,7 @@ async function computeTargetStates(selectedProviders, global3) {
       exists: true
     };
     try {
-      const content = await readFile51(entry.path, "utf-8");
+      const content = await readFile53(entry.path, "utf-8");
       state.currentChecksum = computeContentChecksum(content);
     } catch (error) {
       logger.debug(`[migrate] Failed to read target for checksum: ${entry.path} (${String(error)})`);
@@ -91379,11 +92412,11 @@ var import_picocolors26 = __toESM(require_picocolors(), 1);
 
 // src/commands/new/phases/directory-setup.ts
 init_config_manager();
-import { resolve as resolve23 } from "node:path";
+import { resolve as resolve24 } from "node:path";
 init_logger();
 init_path_resolver();
 init_types3();
-var import_fs_extra35 = __toESM(require_lib3(), 1);
+var import_fs_extra38 = __toESM(require_lib3(), 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();
@@ -91464,7 +92497,7 @@ async function directorySetup(validOptions, prompts) {
       targetDir = await prompts.getDirectory(targetDir);
     }
   }
-  const resolvedDir = resolve23(targetDir);
+  const resolvedDir = resolve24(targetDir);
   logger.info(`Target directory: ${resolvedDir}`);
   if (PathResolver.isLocalSameAsGlobal(resolvedDir)) {
     logger.warning("You're creating a project at HOME directory.");
@@ -91482,8 +92515,8 @@ async function directorySetup(validOptions, prompts) {
       return null;
     }
   }
-  if (await import_fs_extra35.pathExists(resolvedDir)) {
-    const files = await import_fs_extra35.readdir(resolvedDir);
+  if (await import_fs_extra38.pathExists(resolvedDir)) {
+    const files = await import_fs_extra38.readdir(resolvedDir);
     const isEmpty = files.length === 0;
     if (!isEmpty) {
       if (isNonInteractive2) {
@@ -91521,7 +92554,7 @@ async function handleDirectorySetup(ctx) {
 // src/commands/new/phases/project-creation.ts
 init_config_manager();
 init_github_client();
-import { join as join108 } from "node:path";
+import { join as join110 } from "node:path";
 init_logger();
 init_output_manager();
 init_types3();
@@ -91647,7 +92680,7 @@ async function projectCreation(kit, resolvedDir, validOptions, isNonInteractive2
   output.section("Installing");
   logger.verbose("Installation target", { directory: resolvedDir });
   const merger = new FileMerger;
-  const claudeDir2 = join108(resolvedDir, ".claude");
+  const claudeDir2 = join110(resolvedDir, ".claude");
   merger.setMultiKitContext(claudeDir2, kit);
   if (validOptions.exclude && validOptions.exclude.length > 0) {
     merger.addIgnorePatterns(validOptions.exclude);
@@ -91694,7 +92727,7 @@ async function handleProjectCreation(ctx) {
 }
 // src/commands/new/phases/post-setup.ts
 init_projects_registry();
-import { join as join109 } from "node:path";
+import { join as join111 } from "node:path";
 init_package_installer();
 init_logger();
 init_path_resolver();
@@ -91726,9 +92759,9 @@ async function postSetup(resolvedDir, validOptions, isNonInteractive2, prompts)
       withSudo: validOptions.withSudo
     });
   }
-  const claudeDir2 = join109(resolvedDir, ".claude");
+  const claudeDir2 = join111(resolvedDir, ".claude");
   await promptSetupWizardIfNeeded({
-    envPath: join109(claudeDir2, ".env"),
+    envPath: join111(claudeDir2, ".env"),
     claudeDir: claudeDir2,
     isGlobal: false,
     isNonInteractive: isNonInteractive2,
@@ -91801,11 +92834,11 @@ init_logger();
 init_safe_prompts();
 var import_picocolors27 = __toESM(require_picocolors(), 1);
 import { existsSync as existsSync52 } from "node:fs";
-import { resolve as resolve24 } from "node:path";
+import { resolve as resolve25 } from "node:path";
 async function handleAdd(projectPath, options2) {
   logger.debug(`Adding project: ${projectPath}, options: ${JSON.stringify(options2)}`);
   intro("Add Project");
-  const absolutePath = resolve24(projectPath);
+  const absolutePath = resolve25(projectPath);
   if (!existsSync52(absolutePath)) {
     log.error(`Path does not exist: ${absolutePath}`);
     process.exitCode = 1;
@@ -92695,7 +93728,7 @@ var import_picocolors32 = __toESM(require_picocolors(), 1);
 // src/commands/uninstall/installation-detector.ts
 init_claudekit_scanner();
 init_path_resolver();
-var import_fs_extra36 = __toESM(require_lib3(), 1);
+var import_fs_extra39 = __toESM(require_lib3(), 1);
 function hasClaudeKitComponents(components) {
   return components.agents > 0 || components.commands > 0 || components.rules > 0 || components.skills > 0;
 }
@@ -92710,7 +93743,7 @@ async function detectInstallations() {
       installations.push({
         type: "local",
         path: setup.project.path,
-        exists: await import_fs_extra36.pathExists(setup.project.path),
+        exists: await import_fs_extra39.pathExists(setup.project.path),
         hasMetadata,
         components: setup.project.components
       });
@@ -92723,7 +93756,7 @@ async function detectInstallations() {
       installations.push({
         type: "global",
         path: setup.global.path,
-        exists: await import_fs_extra36.pathExists(setup.global.path),
+        exists: await import_fs_extra39.pathExists(setup.global.path),
         hasMetadata,
         components: setup.global.components
       });
@@ -92734,16 +93767,16 @@ async function detectInstallations() {
 
 // src/commands/uninstall/removal-handler.ts
 import { readdirSync as readdirSync6, rmSync as rmSync5 } from "node:fs";
-import { join as join111, resolve as resolve25, sep as sep5 } from "node:path";
+import { join as join113, resolve as resolve26, sep as sep5 } from "node:path";
 init_logger();
 init_safe_prompts();
 init_safe_spinner();
-var import_fs_extra37 = __toESM(require_lib3(), 1);
+var import_fs_extra40 = __toESM(require_lib3(), 1);
 
 // src/commands/uninstall/analysis-handler.ts
 init_metadata_migration();
 import { readdirSync as readdirSync5, rmSync as rmSync4 } from "node:fs";
-import { dirname as dirname23, join as join110 } from "node:path";
+import { dirname as dirname24, join as join112 } from "node:path";
 init_logger();
 init_safe_prompts();
 var import_picocolors31 = __toESM(require_picocolors(), 1);
@@ -92761,7 +93794,7 @@ function classifyFileByOwnership(ownership, forceOverwrite, deleteReason) {
 }
 async function cleanupEmptyDirectories3(filePath, installationRoot) {
   let cleaned = 0;
-  let currentDir = dirname23(filePath);
+  let currentDir = dirname24(filePath);
   while (currentDir !== installationRoot && currentDir.startsWith(installationRoot)) {
     try {
       const entries = readdirSync5(currentDir);
@@ -92769,7 +93802,7 @@ async function cleanupEmptyDirectories3(filePath, installationRoot) {
         rmSync4(currentDir, { recursive: true });
         cleaned++;
         logger.debug(`Removed empty directory: ${currentDir}`);
-        currentDir = dirname23(currentDir);
+        currentDir = dirname24(currentDir);
       } else {
         break;
       }
@@ -92791,7 +93824,7 @@ async function analyzeInstallation(installation, forceOverwrite, kit) {
   if (uninstallManifest.isMultiKit && kit && metadata?.kits?.[kit]) {
     const kitFiles = metadata.kits[kit].files || [];
     for (const trackedFile of kitFiles) {
-      const filePath = join110(installation.path, trackedFile.path);
+      const filePath = join112(installation.path, trackedFile.path);
       if (uninstallManifest.filesToPreserve.includes(trackedFile.path)) {
         result.toPreserve.push({ path: trackedFile.path, reason: "shared with other kit" });
         continue;
@@ -92821,7 +93854,7 @@ async function analyzeInstallation(installation, forceOverwrite, kit) {
     return result;
   }
   for (const trackedFile of allTrackedFiles) {
-    const filePath = join110(installation.path, trackedFile.path);
+    const filePath = join112(installation.path, trackedFile.path);
     const ownershipResult = await OwnershipChecker.checkOwnership(filePath, metadata, installation.path);
     if (!ownershipResult.exists)
       continue;
@@ -92866,7 +93899,7 @@ function displayDryRunPreview(analysis, installationType) {
 // src/commands/uninstall/removal-handler.ts
 async function isDirectory(filePath) {
   try {
-    const stats = await import_fs_extra37.lstat(filePath);
+    const stats = await import_fs_extra40.lstat(filePath);
     return stats.isDirectory();
   } catch {
     logger.debug(`Failed to check if path is directory: ${filePath}`);
@@ -92875,16 +93908,16 @@ async function isDirectory(filePath) {
 }
 async function isPathSafeToRemove(filePath, baseDir) {
   try {
-    const resolvedPath = resolve25(filePath);
-    const resolvedBase = resolve25(baseDir);
+    const resolvedPath = resolve26(filePath);
+    const resolvedBase = resolve26(baseDir);
     if (!resolvedPath.startsWith(resolvedBase + sep5) && resolvedPath !== resolvedBase) {
       logger.debug(`Path outside installation directory: ${filePath}`);
       return false;
     }
-    const stats = await import_fs_extra37.lstat(filePath);
+    const stats = await import_fs_extra40.lstat(filePath);
     if (stats.isSymbolicLink()) {
-      const realPath = await import_fs_extra37.realpath(filePath);
-      const resolvedReal = resolve25(realPath);
+      const realPath = await import_fs_extra40.realpath(filePath);
+      const resolvedReal = resolve26(realPath);
       if (!resolvedReal.startsWith(resolvedBase + sep5) && resolvedReal !== resolvedBase) {
         logger.debug(`Symlink points outside installation directory: ${filePath} -> ${realPath}`);
         return false;
@@ -92918,15 +93951,15 @@ async function removeInstallations(installations, options2) {
       let removedCount = 0;
       let cleanedDirs = 0;
       for (const item of analysis.toDelete) {
-        const filePath = join111(installation.path, item.path);
-        if (!await import_fs_extra37.pathExists(filePath))
+        const filePath = join113(installation.path, item.path);
+        if (!await import_fs_extra40.pathExists(filePath))
           continue;
         if (!await isPathSafeToRemove(filePath, installation.path)) {
           logger.debug(`Skipping unsafe path: ${item.path}`);
           continue;
         }
         const isDir = await isDirectory(filePath);
-        await import_fs_extra37.remove(filePath);
+        await import_fs_extra40.remove(filePath);
         removedCount++;
         logger.debug(`Removed ${isDir ? "directory" : "file"}: ${item.path}`);
         if (!isDir) {
@@ -93110,6 +94143,12 @@ ${import_picocolors32.default.yellow("User modifications will be permanently del
       forceOverwrite: validOptions.forceOverwrite,
       kit: validOptions.kit
     });
+    if (!validOptions.kit || validOptions.kit === "engineer") {
+      try {
+        const { handlePluginUninstall: handlePluginUninstall2 } = await Promise.resolve().then(() => (init_plugin_installer(), exports_plugin_installer));
+        await handlePluginUninstall2();
+      } catch {}
+    }
     const kitMsg = validOptions.kit ? ` (${validOptions.kit} kit)` : "";
     prompts.outro(`ClaudeKit${kitMsg} uninstalled successfully!`);
   } catch (error) {
@@ -93311,7 +94350,7 @@ init_logger();
 init_path_resolver();
 init_types3();
 import { existsSync as existsSync53, readFileSync as readFileSync10 } from "node:fs";
-import { join as join112 } from "node:path";
+import { join as join114 } from "node:path";
 var packageVersion = package_default.version;
 function formatInstalledKits(metadata) {
   if (!metadata.kits || Object.keys(metadata.kits).length === 0) {
@@ -93343,9 +94382,9 @@ async function displayVersion() {
   let localKitVersion = null;
   let isGlobalOnlyKit = false;
   const globalKitDir = PathResolver.getGlobalKitDir();
-  const globalMetadataPath = join112(globalKitDir, "metadata.json");
+  const globalMetadataPath = join114(globalKitDir, "metadata.json");
   const prefix = PathResolver.getPathPrefix(false);
-  const localMetadataPath = prefix ? join112(process.cwd(), prefix, "metadata.json") : join112(process.cwd(), "metadata.json");
+  const localMetadataPath = prefix ? join114(process.cwd(), prefix, "metadata.json") : join114(process.cwd(), "metadata.json");
   const isLocalSameAsGlobal = localMetadataPath === globalMetadataPath;
   if (!isLocalSameAsGlobal && existsSync53(localMetadataPath)) {
     try {
@@ -93738,7 +94777,7 @@ var output2 = new OutputManager2;
 
 // src/shared/temp-cleanup.ts
 init_logger();
-var import_fs_extra38 = __toESM(require_lib3(), 1);
+var import_fs_extra41 = __toESM(require_lib3(), 1);
 import { rmSync as rmSync6 } from "node:fs";
 var tempDirs2 = new Set;
 async function cleanup() {
@@ -93747,7 +94786,7 @@ async function cleanup() {
   logger.debug(`Cleaning up ${tempDirs2.size} temporary director(ies)...`);
   for (const dir of tempDirs2) {
     try {
-      await import_fs_extra38.remove(dir);
+      await import_fs_extra41.remove(dir);
       logger.debug(`Cleaned up temp directory: ${dir}`);
     } catch (error) {
       logger.debug(`Failed to clean temp directory ${dir}: ${error}`);