claudekit-cli 3.41.4-dev.47 → 3.41.4-dev.49

package/dist/index.js

@@ -12416,6 +12416,50 @@ function normalizeChecksum(checksum) {
 function isUnknownChecksum(checksum) {
   return normalizeChecksum(checksum) === UNKNOWN_CHECKSUM;
 }
+function getReasonCopy(code, _ctx) {
+  switch (code) {
+    case "new-item":
+      return "New — not previously installed";
+    case "new-provider-for-item":
+      return "New provider for existing item";
+    case "target-deleted-source-changed":
+      return "You deleted this, CK has updates — reinstalling";
+    case "target-dir-empty-reinstall":
+      return "Provider directory is empty — reinstalling";
+    case "force-reinstall":
+      return "Force reinstall (target was deleted)";
+    case "force-overwrite":
+      return "Force overwrite (you edited this, --force active)";
+    case "registry-upgrade-reinstall":
+      return "Target deleted — reinstalling after registry upgrade";
+    case "source-changed":
+      return "CK updated, you didn't edit — safe to overwrite";
+    case "registry-upgrade-heal":
+      return "Healing stale target after registry upgrade";
+    case "no-changes":
+      return "Already up to date";
+    case "user-edits-preserved":
+      return "You edited this, CK unchanged — keeping your edits";
+    case "user-deleted-respected":
+      return "You deleted this, CK unchanged — respecting your choice";
+    case "target-up-to-date-backfill":
+      return "Already up to date — registry checksums will be backfilled";
+    case "provider-checksum-unavailable":
+      return "Provider checksum unavailable — cannot verify safely";
+    case "target-state-unknown":
+      return "Target state unavailable, CK unchanged — preserving target";
+    case "source-removed-orphan":
+      return "No longer shipped by CK — will be removed";
+    case "renamed-cleanup":
+      return "Renamed — cleaning up old path";
+    case "path-migrated-cleanup":
+      return "Path migrated — cleaning up old location";
+    case "both-changed":
+      return "Both you and CK changed this — pick one";
+    case "target-state-unknown-source-changed":
+      return "Target state unavailable while CK changed — manual review required";
+  }
+}
 var UNKNOWN_CHECKSUM = "unknown";
 
 // src/commands/portable/portable-registry.ts
@@ -53250,24 +53294,37 @@ async function _ensureFeatureFlagLocked(configTomlPath) {
       };
     }
   }
-  const hasManagedBlock = existing.includes(SENTINEL_START2) && existing.includes(SENTINEL_END2);
-  if (hasManagedBlock) {
-    const replaced = replaceManagedBlock(existing);
-    await atomicWrite(configTomlPath, replaced);
+  const { content: stripped, removed: hadManagedBlock } = stripAllManagedBlocks(existing);
+  let content = stripped;
+  let mutated = hadManagedBlock;
+  const featuresHeaderIdx = findFeaturesSectionStart(content);
+  if (featuresHeaderIdx !== -1) {
+    const { updated, changed } = ensureFlagInFeaturesSection(content, featuresHeaderIdx);
+    content = updated;
+    mutated = mutated || changed;
+    if (!mutated) {
+      return { status: "already-set", configPath: configTomlPath };
+    }
+    try {
+      await atomicWrite(configTomlPath, content);
+    } catch (err) {
+      return {
+        status: "failed",
+        configPath: configTomlPath,
+        error: `Failed to write ${configTomlPath}: ${err instanceof Error ? err.message : String(err)}`
+      };
+    }
     return { status: "updated", configPath: configTomlPath };
   }
-  if (hasRawFeatureFlag(existing)) {
-    return { status: "already-set", configPath: configTomlPath };
-  }
-  const separator = existing.length > 0 && !existing.endsWith(`
+  const separator = content.length === 0 ? "" : content.endsWith(`
 `) ? `
-
 ` : `
+
 `;
-  const updated = `${existing}${separator}${MANAGED_BLOCK}
+  const withBlock = `${content}${separator}${MANAGED_BLOCK}
 `;
   try {
-    await atomicWrite(configTomlPath, updated);
+    await atomicWrite(configTomlPath, withBlock);
   } catch (err) {
     return {
       status: "failed",
@@ -53275,34 +53332,80 @@ async function _ensureFeatureFlagLocked(configTomlPath) {
       error: `Failed to write ${configTomlPath}: ${err instanceof Error ? err.message : String(err)}`
     };
   }
-  return { status: "written", configPath: configTomlPath };
+  return { status: hadManagedBlock ? "updated" : "written", configPath: configTomlPath };
 }
-function hasRawFeatureFlag(content) {
-  const withoutManaged = removeManagedBlock(content);
-  return /^\s*codex_hooks\s*=\s*true(\s*#[^\r\n]*)?\s*$/m.test(withoutManaged);
+function findFeaturesSectionStart(content) {
+  const match = /^[ \t]*\[features\][ \t]*(?:#[^\r\n]*)?$/m.exec(content);
+  return match ? match.index : -1;
 }
-function replaceManagedBlock(content) {
-  const startIdx = content.indexOf(SENTINEL_START2);
-  const endIdx = content.lastIndexOf(SENTINEL_END2);
-  if (startIdx === -1 || endIdx === -1 || endIdx < startIdx) {
-    return content;
+function ensureFlagInFeaturesSection(content, headerStartIdx) {
+  const headerLineEnd = content.indexOf(`
+`, headerStartIdx);
+  const bodyStart = headerLineEnd === -1 ? content.length : headerLineEnd + 1;
+  const rest = content.slice(bodyStart);
+  const nextHeaderMatch = /\n\[[^\]]+\]/.exec(rest);
+  const bodyEnd = nextHeaderMatch ? bodyStart + nextHeaderMatch.index + 1 : content.length;
+  const body = content.slice(bodyStart, bodyEnd);
+  const flagRegex = /^([ \t]*codex_hooks[ \t]*=[ \t]*)(true|false)([ \t]*#[^\r\n]*)?[ \t]*$/m;
+  const flagMatch = flagRegex.exec(body);
+  if (flagMatch) {
+    if (flagMatch[2] === "true") {
+      return { updated: content, changed: false };
+    }
+    const newBody = body.replace(flagRegex, (_m, prefix, _v, trailing) => `${prefix}true${trailing ?? ""}`);
+    return {
+      updated: content.slice(0, bodyStart) + newBody + content.slice(bodyEnd),
+      changed: true
+    };
   }
-  const endOfBlock = endIdx + SENTINEL_END2.length;
-  const afterBlock = content[endOfBlock] === `
-` ? content.slice(endOfBlock + 1) : content.slice(endOfBlock);
-  const before = content.slice(0, startIdx);
-  return `${before}${MANAGED_BLOCK}
-${afterBlock}`;
-}
-function removeManagedBlock(content) {
-  const startIdx = content.indexOf(SENTINEL_START2);
-  const endIdx = content.indexOf(SENTINEL_END2);
-  if (startIdx === -1 || endIdx === -1 || endIdx < startIdx)
-    return content;
-  const endOfBlock = endIdx + SENTINEL_END2.length;
-  const afterBlock = content[endOfBlock] === `
-` ? content.slice(endOfBlock + 1) : content.slice(endOfBlock);
-  return content.slice(0, startIdx) + afterBlock;
+  if (headerLineEnd === -1) {
+    return { updated: `${content}
+codex_hooks = true
+`, changed: true };
+  }
+  let insertAt = bodyEnd;
+  while (insertAt > bodyStart && content[insertAt - 1] === `
+` && content[insertAt - 2] === `
+`) {
+    insertAt -= 1;
+  }
+  const needsLeadingNewline = insertAt > bodyStart && content[insertAt - 1] !== `
+`;
+  const insertion = `${needsLeadingNewline ? `
+` : ""}codex_hooks = true
+`;
+  return {
+    updated: content.slice(0, insertAt) + insertion + content.slice(insertAt),
+    changed: true
+  };
+}
+function stripAllManagedBlocks(content) {
+  let result = content;
+  let removed = false;
+  while (true) {
+    const startIdx = result.indexOf(SENTINEL_START2);
+    if (startIdx === -1)
+      break;
+    const endIdx = result.indexOf(SENTINEL_END2, startIdx);
+    if (endIdx === -1)
+      break;
+    const endOfBlock = endIdx + SENTINEL_END2.length;
+    const afterBlockStart = result[endOfBlock] === `
+` ? endOfBlock + 1 : endOfBlock;
+    let beforeBlockEnd = startIdx;
+    if (beforeBlockEnd >= 1 && result[beforeBlockEnd - 1] === `
+`) {
+      beforeBlockEnd -= 1;
+      if (beforeBlockEnd >= 1 && result[beforeBlockEnd - 1] === `
+`) {
+        beforeBlockEnd -= 1;
+      }
+      beforeBlockEnd += 1;
+    }
+    result = result.slice(0, beforeBlockEnd) + result.slice(afterBlockStart);
+    removed = true;
+  }
+  return { content: result, removed };
 }
 async function atomicWrite(filePath, content) {
   const tempPath = `${filePath}.ck-tmp`;
@@ -54298,7 +54401,7 @@ var init_reconcile_registry_backfill = __esm(() => {
 });
 
 // src/commands/portable/reconcile-state-builders.ts
-import { existsSync as existsSync27 } from "node:fs";
+import { existsSync as existsSync27, readdirSync as readdirSync3, statSync as statSync5 } from "node:fs";
 import { readFile as readFile23 } from "node:fs/promises";
 function getProviderPathKeyForPortableType2(type) {
   switch (type) {
@@ -54394,6 +54497,95 @@ function buildSourceItemState(item, type, selectedProviders, options2) {
     targetChecksums
   };
 }
+function buildTypeDirectoryStates(providerConfigs, types4) {
+  const results = [];
+  for (const { provider, global: isGlobal } of providerConfigs) {
+    const providerConfig = providers[provider];
+    if (!providerConfig)
+      continue;
+    for (const type of types4) {
+      const pathKey = portableTypeToProviderPathKey(type);
+      const pathConfig = providerConfig[pathKey];
+      if (!pathConfig)
+        continue;
+      if (pathConfig.writeStrategy === "merge-single" || pathConfig.writeStrategy === "single-file") {
+        continue;
+      }
+      const dirPath = isGlobal ? pathConfig.globalPath : pathConfig.projectPath;
+      if (!dirPath)
+        continue;
+      const exists = existsSync27(dirPath);
+      if (!exists) {
+        results.push({
+          provider,
+          type,
+          global: isGlobal,
+          path: dirPath,
+          exists: false,
+          isEmpty: true,
+          fileCount: 0
+        });
+        continue;
+      }
+      let stat7 = null;
+      try {
+        stat7 = statSync5(dirPath);
+      } catch {
+        results.push({
+          provider,
+          type,
+          global: isGlobal,
+          path: dirPath,
+          exists: false,
+          isEmpty: true,
+          fileCount: 0
+        });
+        continue;
+      }
+      if (!stat7.isDirectory()) {
+        results.push({
+          provider,
+          type,
+          global: isGlobal,
+          path: dirPath,
+          exists: true,
+          isEmpty: false,
+          fileCount: 1
+        });
+        continue;
+      }
+      const ext = pathConfig.fileExtension ?? "";
+      let entries = [];
+      try {
+        entries = readdirSync3(dirPath);
+      } catch {
+        results.push({
+          provider,
+          type,
+          global: isGlobal,
+          path: dirPath,
+          exists: true,
+          isEmpty: true,
+          fileCount: 0
+        });
+        continue;
+      }
+      const managedFiles = ext === "" ? entries.filter((f3) => {
+        return f3.endsWith(".json") || f3.endsWith(".sh") || f3.endsWith(".js");
+      }) : entries.filter((f3) => f3.endsWith(ext));
+      results.push({
+        provider,
+        type,
+        global: isGlobal,
+        path: dirPath,
+        exists: true,
+        isEmpty: managedFiles.length === 0,
+        fileCount: managedFiles.length
+      });
+    }
+  }
+  return results;
+}
 async function buildTargetStates(entries, options2) {
   const targetStates = new Map;
   const entriesByPath = new Map;
@@ -54422,11 +54614,13 @@ async function buildTargetStates(entries, options2) {
   }
   return targetStates;
 }
+var portableTypeToProviderPathKey;
 var init_reconcile_state_builders = __esm(() => {
   init_checksum_utils();
   init_converters();
   init_merge_single_sections();
   init_provider_registry();
+  portableTypeToProviderPathKey = getProviderPathKeyForPortableType2;
 });
 
 // src/commands/portable/reconciler.ts
@@ -54479,6 +54673,9 @@ function makeItemTypeKey(item, type) {
 function makeRegistryIdentityKey(entry) {
   return JSON.stringify([entry.item, entry.type, entry.provider, entry.global]);
 }
+function makeDirStateKey(provider, type, global3) {
+  return JSON.stringify([provider, type, global3]);
+}
 function dedupeProviderConfigs(providerConfigs) {
   const seen = new Set;
   const unique = [];
@@ -54505,6 +54702,14 @@ function buildTargetStateIndex(targetStates) {
   }
   return index;
 }
+function buildDirStateIndex(dirStates) {
+  const index = new Map;
+  for (const ds of dirStates) {
+    const key = makeDirStateKey(ds.provider, ds.type, ds.global);
+    index.set(key, ds);
+  }
+  return index;
+}
 function lookupTargetState(targetStateIndex, pathValue) {
   return targetStateIndex.get(normalizePortablePath(pathValue));
 }
@@ -54588,6 +54793,66 @@ function suppressOverlappingActions(actions) {
   }
   return filtered;
 }
+function applyEmptyDirOverride(actions, dirStates, respectDeletions) {
+  if (dirStates.length === 0) {
+    return { actions, banners: [] };
+  }
+  const dirIndex = buildDirStateIndex(dirStates);
+  const banners = [];
+  const flippedGroups = new Map;
+  for (const action of actions) {
+    if (action.action !== "skip" || action.reasonCode !== "user-deleted-respected") {
+      continue;
+    }
+    const key = makeDirStateKey(action.provider, action.type, action.global);
+    const dirState = dirIndex.get(key);
+    if (!dirState?.isEmpty)
+      continue;
+    if (respectDeletions) {
+      const existing2 = flippedGroups.get(key);
+      if (existing2) {
+        existing2.count++;
+      } else {
+        flippedGroups.set(key, { dirState, count: 1 });
+      }
+      continue;
+    }
+    action.action = "install";
+    action.reasonCode = "target-dir-empty-reinstall";
+    action.reasonCopy = getReasonCopy("target-dir-empty-reinstall");
+    action.reason = action.reasonCopy;
+    const existing = flippedGroups.get(key);
+    if (existing) {
+      existing.count++;
+    } else {
+      flippedGroups.set(key, { dirState, count: 1 });
+    }
+  }
+  for (const [, { dirState, count }] of flippedGroups) {
+    if (respectDeletions) {
+      banners.push({
+        kind: "empty-dir-respected",
+        provider: dirState.provider,
+        type: dirState.type,
+        global: dirState.global,
+        path: dirState.path,
+        itemCount: count,
+        message: `Detected empty ${dirState.path} — respecting your deletions (${count} items skipped).`
+      });
+    } else {
+      banners.push({
+        kind: "empty-dir",
+        provider: dirState.provider,
+        type: dirState.type,
+        global: dirState.global,
+        path: dirState.path,
+        itemCount: count,
+        message: `Detected empty ${dirState.path} — ${count} item${count === 1 ? "" : "s"} will be reinstalled. Uncheck any to skip.`
+      });
+    }
+  }
+  return { actions, banners };
+}
 function reconcile(input) {
   const actions = [];
   const targetStateIndex = buildTargetStateIndex(input.targetStates);
@@ -54617,7 +54882,10 @@ function reconcile(input) {
   const orphanActions = detectOrphans(input, renamedFromKeys);
   actions.push(...orphanActions);
   const normalizedActions = suppressOverlappingActions(dedupeActions(actions));
-  return buildPlan(normalizedActions);
+  const dirStates = input.typeDirectoryStates ?? [];
+  const respectDeletions = input.respectDeletions ?? false;
+  const { actions: finalActions, banners } = applyEmptyDirOverride(normalizedActions, dirStates, respectDeletions);
+  return buildPlan(finalActions, banners);
 }
 function determineAction(source, providerConfig, input, targetStateIndex, deletedIdentityKeys) {
   let registryEntry = findRegistryEntry(source, providerConfig, input.registry);
@@ -54630,12 +54898,14 @@ function determineAction(source, providerConfig, input, targetStateIndex, delete
   if (registryEntry && deletedIdentityKeys.has(identityKey)) {
     registryEntry = null;
   }
+  const isDirectoryItem = source.type === "skill";
   const common = {
     item: source.item,
     type: source.type,
     provider: providerConfig.provider,
     global: providerConfig.global,
-    targetPath: ""
+    targetPath: "",
+    isDirectoryItem: isDirectoryItem || undefined
   };
   const convertedChecksumRaw = source.convertedChecksums[providerConfig.provider];
   const convertedChecksum = normalizeChecksum(convertedChecksumRaw);
@@ -54643,30 +54913,39 @@ function determineAction(source, providerConfig, input, targetStateIndex, delete
   if (!convertedChecksumRaw || isUnknownChecksum(convertedChecksumRaw)) {
     if (registryEntry) {
       common.targetPath = registryEntry.path;
+      const code3 = "provider-checksum-unavailable";
       return {
         ...common,
         action: "skip",
         reason: "Provider checksum unavailable — cannot verify safely",
+        reasonCode: code3,
+        reasonCopy: getReasonCopy(code3),
         sourceChecksum: UNKNOWN_CHECKSUM,
         registeredSourceChecksum: normalizeChecksum(registryEntry.sourceChecksum),
         registeredTargetChecksum: normalizeChecksum(registryEntry.targetChecksum)
       };
     }
     const itemExistsElsewhere = input.registry.installations.some((i) => i.item === source.item && i.type === source.type);
+    const code2 = itemExistsElsewhere ? "new-provider-for-item" : "new-item";
     return {
       ...common,
       action: "install",
       reason: itemExistsElsewhere ? "New provider for existing item" : "New item, not previously installed",
+      reasonCode: code2,
+      reasonCopy: getReasonCopy(code2),
       sourceChecksum: UNKNOWN_CHECKSUM
     };
   }
   if (!registryEntry) {
     const itemExistsElsewhere = input.registry.installations.some((i) => i.item === source.item && i.type === source.type);
+    const code2 = itemExistsElsewhere ? "new-provider-for-item" : "new-item";
     const reason = itemExistsElsewhere ? "New provider for existing item" : "New item, not previously installed";
     return {
       ...common,
       action: "install",
       reason,
+      reasonCode: code2,
+      reasonCopy: getReasonCopy(code2),
       sourceChecksum: convertedChecksum
     };
   }
@@ -54678,36 +54957,48 @@ function determineAction(source, providerConfig, input, targetStateIndex, delete
   const targetMatchesExpectedOutput = targetState?.exists === true && !isUnknownChecksum(expectedTargetChecksum) && currentTargetChecksum === expectedTargetChecksum;
   if (isUnknownChecksum(registeredSourceChecksum)) {
     if (targetMatchesExpectedOutput) {
+      const code3 = "target-up-to-date-backfill";
       return {
         ...common,
         action: "skip",
         reason: "Target up-to-date after registry upgrade — checksums will be backfilled",
+        reasonCode: code3,
+        reasonCopy: getReasonCopy(code3),
         sourceChecksum: convertedChecksum,
         currentTargetChecksum,
         backfillRegistry: true
       };
     }
     if (!targetState || !targetState.exists) {
+      const code3 = "registry-upgrade-reinstall";
       return {
         ...common,
         action: "install",
         reason: "Target deleted — reinstalling after registry upgrade",
+        reasonCode: code3,
+        reasonCopy: getReasonCopy(code3),
         sourceChecksum: convertedChecksum
       };
     }
+    const code2 = "registry-upgrade-heal";
     return {
       ...common,
       action: "update",
       reason: "Healing stale target after registry upgrade",
+      reasonCode: code2,
+      reasonCopy: getReasonCopy(code2),
       sourceChecksum: convertedChecksum,
       currentTargetChecksum
     };
   }
   if (targetMatchesExpectedOutput && (convertedChecksum !== registeredSourceChecksum || currentTargetChecksum !== registeredTargetChecksum)) {
+    const code2 = "target-up-to-date-backfill";
     return {
       ...common,
       action: "skip",
       reason: "Target up-to-date — registry checksums will be backfilled",
+      reasonCode: code2,
+      reasonCopy: getReasonCopy(code2),
       sourceChecksum: convertedChecksum,
       registeredSourceChecksum,
       currentTargetChecksum,
@@ -54719,19 +55010,49 @@ function determineAction(source, providerConfig, input, targetStateIndex, delete
   const targetChangeState = getTargetChangeState(targetState, registryEntry, registeredTargetChecksum);
   if (targetChangeState === "deleted") {
     const forceReinstall = input.force && !sourceChanged;
+    if (sourceChanged) {
+      const code3 = "target-deleted-source-changed";
+      return {
+        ...common,
+        action: "install",
+        reason: "Target was deleted, CK has updates — reinstalling",
+        reasonCode: code3,
+        reasonCopy: getReasonCopy(code3),
+        sourceChecksum: convertedChecksum,
+        registeredSourceChecksum
+      };
+    }
+    if (forceReinstall) {
+      const code3 = "force-reinstall";
+      return {
+        ...common,
+        action: "install",
+        reason: "Force reinstall (target was deleted)",
+        reasonCode: code3,
+        reasonCopy: getReasonCopy(code3),
+        sourceChecksum: convertedChecksum,
+        registeredSourceChecksum
+      };
+    }
+    const code2 = "user-deleted-respected";
     return {
       ...common,
-      action: sourceChanged || forceReinstall ? "install" : "skip",
-      reason: sourceChanged ? "Target was deleted, CK has updates — reinstalling" : forceReinstall ? "Force reinstall (target was deleted)" : "Target was deleted by user, CK unchanged — respecting deletion",
+      action: "skip",
+      reason: "Target was deleted by user, CK unchanged — respecting deletion",
+      reasonCode: code2,
+      reasonCopy: getReasonCopy(code2),
       sourceChecksum: convertedChecksum,
       registeredSourceChecksum
     };
   }
   if (targetChangeState === "unknown") {
+    const code2 = sourceChanged ? "target-state-unknown-source-changed" : "target-state-unknown";
     return {
       ...common,
       action: sourceChanged ? "conflict" : "skip",
       reason: sourceChanged ? "Target state unavailable while CK changed — manual review required" : "Target state unavailable, CK unchanged — preserving target",
+      reasonCode: code2,
+      reasonCopy: getReasonCopy(code2),
       sourceChecksum: convertedChecksum,
       registeredSourceChecksum,
       currentTargetChecksum,
@@ -54740,19 +55061,38 @@ function determineAction(source, providerConfig, input, targetStateIndex, delete
   }
   const targetChanged = targetChangeState === "changed";
   if (!sourceChanged && !targetChanged) {
+    const code2 = "no-changes";
     return {
       ...common,
       action: "skip",
       reason: "No changes",
+      reasonCode: code2,
+      reasonCopy: getReasonCopy(code2),
       sourceChecksum: convertedChecksum,
       currentTargetChecksum
     };
   }
   if (!sourceChanged && targetChanged) {
+    if (input.force) {
+      return {
+        ...common,
+        action: "install",
+        reason: "Force overwrite (user edits)",
+        reasonCode: "force-overwrite",
+        reasonCopy: getReasonCopy("force-overwrite"),
+        sourceChecksum: convertedChecksum,
+        registeredSourceChecksum,
+        currentTargetChecksum,
+        registeredTargetChecksum
+      };
+    }
+    const code2 = "user-edits-preserved";
     return {
       ...common,
-      action: input.force ? "install" : "skip",
-      reason: input.force ? "Force overwrite (user edits)" : "User edited, CK unchanged — preserving edits",
+      action: "skip",
+      reason: "User edited, CK unchanged — preserving edits",
+      reasonCode: code2,
+      reasonCopy: getReasonCopy(code2),
       sourceChecksum: convertedChecksum,
       registeredSourceChecksum,
       currentTargetChecksum,
@@ -54760,20 +55100,26 @@ function determineAction(source, providerConfig, input, targetStateIndex, delete
     };
   }
   if (sourceChanged && !targetChanged) {
+    const code2 = "source-changed";
     return {
       ...common,
       action: "update",
       reason: "CK updated, no user edits — safe overwrite",
+      reasonCode: code2,
+      reasonCopy: getReasonCopy(code2),
       sourceChecksum: convertedChecksum,
       registeredSourceChecksum,
       currentTargetChecksum,
       registeredTargetChecksum
     };
   }
+  const code = "both-changed";
   return {
     ...common,
     action: "conflict",
     reason: "Both CK and user modified this item",
+    reasonCode: code,
+    reasonCopy: getReasonCopy(code),
     sourceChecksum: convertedChecksum,
     registeredSourceChecksum,
     currentTargetChecksum,
@@ -54809,6 +55155,7 @@ function detectOrphans(input, renamedFromKeys) {
     if (entry.type === "config" && hasConfigSource)
       continue;
     if (!sourceItemKeys.has(sourceItemKey)) {
+      const code = "source-removed-orphan";
       actions.push({
         action: "delete",
         item: entry.item,
@@ -54816,7 +55163,9 @@ function detectOrphans(input, renamedFromKeys) {
         provider: entry.provider,
         global: entry.global,
         targetPath: entry.path,
-        reason: "Item no longer in CK source — orphaned"
+        reason: "Item no longer in CK source — orphaned",
+        reasonCode: code,
+        reasonCopy: getReasonCopy(code)
       });
     }
   }
@@ -54835,6 +55184,7 @@ function detectRenames(input) {
     const normalizedFrom = normalizePortablePath(rename8.from);
     const oldEntries = input.registry.installations.filter((e2) => normalizePortablePath(e2.sourcePath) === normalizedFrom);
     for (const oldEntry of oldEntries) {
+      const code = "renamed-cleanup";
       actions.push({
         deleteAction: {
           action: "delete",
@@ -54844,6 +55194,8 @@ function detectRenames(input) {
           global: oldEntry.global,
           targetPath: oldEntry.path,
           reason: `Renamed: ${rename8.from} -> ${rename8.to}`,
+          reasonCode: code,
+          reasonCopy: getReasonCopy(code),
           previousItem: oldEntry.item
         },
         newItem: oldEntry.item
@@ -54860,6 +55212,7 @@ function detectPathMigrations(input) {
   for (const migration of applicable) {
     const affectedEntries = input.registry.installations.filter((e2) => e2.provider === migration.provider && e2.type === migration.type && pathContainsSegments(e2.path, migration.from));
     for (const entry of affectedEntries) {
+      const code = "path-migrated-cleanup";
       actions.push({
         deleteAction: {
           action: "delete",
@@ -54869,6 +55222,8 @@ function detectPathMigrations(input) {
           global: entry.global,
           targetPath: entry.path,
           reason: `Provider path migrated: ${migration.from} -> ${migration.to}`,
+          reasonCode: code,
+          reasonCopy: getReasonCopy(code),
           previousPath: entry.path
         }
       });
@@ -54879,7 +55234,7 @@ function detectPathMigrations(input) {
 function detectSectionRenames(_input) {
   return [];
 }
-function buildPlan(actions) {
+function buildPlan(actions, banners) {
   const summary = { install: 0, update: 0, skip: 0, conflict: 0, delete: 0 };
   for (const action of actions) {
     summary[action.action]++;
@@ -54887,7 +55242,8 @@ function buildPlan(actions) {
   return {
     actions,
     summary,
-    hasConflicts: summary.conflict > 0
+    hasConflicts: summary.conflict > 0,
+    banners
   };
 }
 var init_reconciler = __esm(() => {
@@ -55910,6 +56266,28 @@ function registerMigrationRoutes(app) {
         return;
       }
       const configSource = sourceParsed.value;
+      const reinstallEmptyDirsParsed = parseBooleanLike(req.query.reinstallEmptyDirs);
+      if (!reinstallEmptyDirsParsed.ok) {
+        res.status(400).json({ error: `reinstallEmptyDirs ${reinstallEmptyDirsParsed.error}` });
+        return;
+      }
+      const reinstallEmptyDirs = reinstallEmptyDirsParsed.value !== false;
+      const respectDeletionsParsed = parseBooleanLike(req.query.respectDeletions);
+      if (!respectDeletionsParsed.ok) {
+        res.status(400).json({ error: `respectDeletions ${respectDeletionsParsed.error}` });
+        return;
+      }
+      const respectDeletions = respectDeletionsParsed.value === true;
+      const modeRaw = req.query.mode;
+      let reconcileMode = "reconcile";
+      if (modeRaw !== undefined) {
+        const modeStr = String(modeRaw).trim().toLowerCase();
+        if (modeStr !== "reconcile" && modeStr !== "install") {
+          res.status(400).json({ error: "mode must be 'reconcile' or 'install'" });
+          return;
+        }
+        reconcileMode = modeStr;
+      }
       const discovered = await discoverMigrationItems(include, configSource);
       const sourceItems = [];
       for (const agent of discovered.agents) {
@@ -55995,20 +56373,33 @@ function registerMigrationRoutes(app) {
         provider,
         global: globalParam
       }));
+      const enabledTypes = ["agent", "command", "skill", "config", "rules", "hooks"].filter((type) => {
+        const key = type === "agent" ? "agents" : type === "command" ? "commands" : type === "skill" ? "skills" : type === "config" ? "config" : type === "rules" ? "rules" : "hooks";
+        return include[key];
+      });
+      const typeDirectoryStates = reinstallEmptyDirs ? buildTypeDirectoryStates(providerConfigs.map((p) => ({
+        provider: p.provider,
+        global: p.global
+      })), enabledTypes) : undefined;
       const input = {
         sourceItems,
         registry,
         targetStates,
         manifest,
-        providerConfigs
+        providerConfigs,
+        typeDirectoryStates,
+        respectDeletions
       };
       const plan = reconcile(input);
+      const hasUnknownChecksum = registry.installations.some((inst) => isUnknownChecksum(inst.sourceChecksum) || isUnknownChecksum(inst.targetChecksum));
+      const suggestedMode = hasUnknownChecksum ? "install" : "reconcile";
       const planWithMeta = {
         ...plan,
         meta: {
           include,
           providers: selectedProviders,
           source: configSource,
+          mode: reconcileMode,
           items: {
             agents: discovered.agents.map((item) => item.name),
             commands: discovered.commands.map((item) => item.name),
@@ -56019,7 +56410,10 @@ function registerMigrationRoutes(app) {
           }
         }
       };
-      res.status(200).json({ plan: planWithMeta });
+      res.status(200).json({
+        plan: planWithMeta,
+        suggestedMode
+      });
     } catch (error) {
       res.status(500).json({
         error: "Failed to compute reconcile plan",
@@ -56027,6 +56421,123 @@ function registerMigrationRoutes(app) {
       });
     }
   });
+  app.get("/api/migrate/install-discovery", async (req, res) => {
+    try {
+      let addCandidates = function(items, type, isDirectoryItem) {
+        for (const item of items) {
+          const sourcePath = item.sourcePath ?? item.path ?? "";
+          for (const provider of selectedProviders) {
+            const registryEntry = registry.installations.find((inst) => inst.item === item.name && inst.type === type && inst.provider === provider && inst.global === globalParam);
+            const alreadyInstalled = registryEntry !== undefined;
+            candidates.push({
+              item: item.name,
+              type,
+              provider,
+              global: globalParam,
+              isDirectoryItem,
+              description: item.description,
+              sourcePath,
+              alreadyInstalled,
+              registryPath: alreadyInstalled ? registryEntry?.path : undefined
+            });
+          }
+        }
+      };
+      const providersParsed = parseProvidersFromQuery(req.query.providers);
+      if (!providersParsed.ok || !providersParsed.value) {
+        res.status(400).json({ error: providersParsed.error || "Invalid providers parameter" });
+        return;
+      }
+      const selectedProviders = providersParsed.value;
+      const includeParsed = parseIncludeOptionsStrict({
+        agents: req.query.agents,
+        commands: req.query.commands,
+        skills: req.query.skills,
+        config: req.query.config,
+        rules: req.query.rules,
+        hooks: req.query.hooks
+      }, "");
+      if (!includeParsed.ok || !includeParsed.value) {
+        res.status(400).json({ error: includeParsed.error || "Invalid include options" });
+        return;
+      }
+      const include = includeParsed.value;
+      const globalParsed = parseBooleanLike(req.query.global);
+      if (!globalParsed.ok) {
+        res.status(400).json({ error: `global ${globalParsed.error}` });
+        return;
+      }
+      const globalParam = globalParsed.value === true;
+      const sourceParsed = parseConfigSource(req.query.source);
+      if (!sourceParsed.ok) {
+        res.status(400).json({ error: sourceParsed.error || "Invalid source value" });
+        return;
+      }
+      const configSource = sourceParsed.value;
+      const discovered = await discoverMigrationItems(include, configSource);
+      const registry = await readPortableRegistry();
+      const candidates = [];
+      if (include.agents) {
+        addCandidates(discovered.agents.map((a3) => ({
+          name: a3.name,
+          description: a3.description,
+          sourcePath: a3.sourcePath ?? ""
+        })), "agent", false);
+      }
+      if (include.commands) {
+        addCandidates(discovered.commands.map((c2) => ({
+          name: c2.name,
+          description: c2.description,
+          sourcePath: c2.sourcePath ?? ""
+        })), "command", false);
+      }
+      if (include.skills) {
+        addCandidates(discovered.skills.map((s) => ({
+          name: s.name,
+          description: s.description,
+          path: s.path
+        })), "skill", true);
+      }
+      if (include.config && discovered.configItem) {
+        addCandidates([
+          {
+            name: discovered.configItem.name,
+            description: undefined,
+            sourcePath: discovered.configItem.sourcePath ?? ""
+          }
+        ], "config", false);
+      }
+      if (include.rules) {
+        addCandidates(discovered.ruleItems.map((r2) => ({
+          name: r2.name,
+          description: undefined,
+          sourcePath: r2.sourcePath ?? ""
+        })), "rules", false);
+      }
+      if (include.hooks) {
+        addCandidates(discovered.hookItems.map((h2) => ({
+          name: h2.name,
+          description: undefined,
+          sourcePath: h2.sourcePath ?? ""
+        })), "hooks", false);
+      }
+      const providerConfigs = selectedProviders.map((provider) => ({
+        provider,
+        global: globalParam
+      }));
+      const enabledTypes = ["agent", "command", "skill", "config", "rules", "hooks"].filter((type) => {
+        const key = type === "agent" ? "agents" : type === "command" ? "commands" : type === "skill" ? "skills" : type === "config" ? "config" : type === "rules" ? "rules" : "hooks";
+        return include[key];
+      });
+      const typeDirectoryStates = buildTypeDirectoryStates(providerConfigs, enabledTypes);
+      res.status(200).json({ candidates, typeDirectoryStates });
+    } catch (error) {
+      res.status(500).json({
+        error: "Failed to discover install candidates",
+        message: sanitizeUntrusted(error, 260)
+      });
+    }
+  });
   app.post("/api/migrate/execute", async (req, res) => {
     try {
       const planBased = req.body?.plan !== undefined;
@@ -56429,7 +56940,7 @@ function registerMigrationRoutes(app) {
     }
   });
 }
-var MIGRATION_TYPES, MAX_PROVIDER_COUNT = 20, MAX_PLAN_ACTIONS = 5000, ALLOWED_CONFIG_SOURCE_KEYS, CONFLICT_RESOLUTION_SCHEMA, RECONCILE_ACTION_SCHEMA, RECONCILE_PLAN_SCHEMA, PLAN_EXECUTE_PAYLOAD_SCHEMA, PLURAL_TO_SINGULAR, shellHookWarningShown = false;
+var MIGRATION_TYPES, MAX_PROVIDER_COUNT = 20, MAX_PLAN_ACTIONS = 5000, ALLOWED_CONFIG_SOURCE_KEYS, CONFLICT_RESOLUTION_SCHEMA, RECONCILE_ACTION_SCHEMA, RECONCILE_BANNER_SCHEMA, RECONCILE_PLAN_SCHEMA, PLAN_EXECUTE_PAYLOAD_SCHEMA, PLURAL_TO_SINGULAR, shellHookWarningShown = false;
 var init_migration_routes = __esm(() => {
   init_agents_discovery();
   init_commands_discovery();
@@ -56481,8 +56992,20 @@ var init_migration_routes = __esm(() => {
     ownedSections: exports_external.array(exports_external.string()).optional(),
     affectedSections: exports_external.array(exports_external.string()).optional(),
     diff: exports_external.string().optional(),
-    resolution: CONFLICT_RESOLUTION_SCHEMA.optional()
+    resolution: CONFLICT_RESOLUTION_SCHEMA.optional(),
+    reasonCode: exports_external.string().optional(),
+    reasonCopy: exports_external.string().optional(),
+    isDirectoryItem: exports_external.boolean().optional()
   }).passthrough();
+  RECONCILE_BANNER_SCHEMA = exports_external.object({
+    kind: exports_external.enum(["empty-dir", "empty-dir-respected"]),
+    provider: exports_external.string(),
+    type: exports_external.string(),
+    global: exports_external.boolean(),
+    path: exports_external.string(),
+    itemCount: exports_external.number().int().nonnegative(),
+    message: exports_external.string()
+  });
   RECONCILE_PLAN_SCHEMA = exports_external.object({
     actions: exports_external.array(RECONCILE_ACTION_SCHEMA).max(MAX_PLAN_ACTIONS),
     summary: exports_external.object({
@@ -56492,11 +57015,13 @@ var init_migration_routes = __esm(() => {
       conflict: exports_external.number().int().nonnegative(),
       delete: exports_external.number().int().nonnegative()
     }),
-    hasConflicts: exports_external.boolean()
+    hasConflicts: exports_external.boolean(),
+    banners: exports_external.array(RECONCILE_BANNER_SCHEMA).optional().default([])
   }).passthrough();
   PLAN_EXECUTE_PAYLOAD_SCHEMA = exports_external.object({
     plan: RECONCILE_PLAN_SCHEMA,
-    resolutions: exports_external.record(CONFLICT_RESOLUTION_SCHEMA).optional().default({})
+    resolutions: exports_external.record(CONFLICT_RESOLUTION_SCHEMA).optional().default({}),
+    mode: exports_external.enum(["reconcile", "install"]).optional()
   }).passthrough();
   PLURAL_TO_SINGULAR = {
     agents: "agent",
@@ -56509,7 +57034,7 @@ var init_migration_routes = __esm(() => {
 });
 
 // src/domains/plan-parser/plan-metadata.ts
-import { readFileSync as readFileSync6, statSync as statSync5 } from "node:fs";
+import { readFileSync as readFileSync6, statSync as statSync6 } from "node:fs";
 function readMatter(filePath) {
   try {
     return import_gray_matter6.default(readFileSync6(filePath, "utf8")).data;
@@ -56586,7 +57111,7 @@ function parseEffortHours(value) {
 }
 function readPlanMetadata(planFile, counts) {
   const frontmatter = readMatter(planFile);
-  const stats = statSync5(planFile);
+  const stats = statSync6(planFile);
   return {
     title: typeof frontmatter.title === "string" ? frontmatter.title : undefined,
     description: typeof frontmatter.description === "string" ? frontmatter.description : undefined,
@@ -56603,7 +57128,7 @@ function readPlanMetadata(planFile, counts) {
 }
 function readPhaseMetadata(phaseFile) {
   const frontmatter = readMatter(phaseFile);
-  const stats = statSync5(phaseFile);
+  const stats = statSync6(phaseFile);
   return {
     title: typeof frontmatter.title === "string" ? frontmatter.title : undefined,
     status: normalizePhaseStatus(frontmatter.status),
@@ -57000,7 +57525,7 @@ var init_plan_table_parser = __esm(() => {
 
 // src/domains/plan-parser/activity-tracker.ts
 import { spawnSync as spawnSync2 } from "node:child_process";
-import { readdirSync as readdirSync3, statSync as statSync6 } from "node:fs";
+import { readdirSync as readdirSync4, statSync as statSync7 } from "node:fs";
 import { join as join42, relative as relative8 } from "node:path";
 function startOfDay(date) {
   const copy = new Date(date);
@@ -57010,7 +57535,7 @@ function startOfDay(date) {
 function enumerateMarkdownFiles(dir, depth = 0) {
   if (depth >= MAX_DEPTH)
     return [];
-  const entries = readdirSync3(dir, { withFileTypes: true });
+  const entries = readdirSync4(dir, { withFileTypes: true });
   return entries.flatMap((entry) => {
     const entryPath = join42(dir, entry.name);
     if (entry.isDirectory())
@@ -57054,7 +57579,7 @@ function getGitSamples(dir, samples) {
 }
 function getMtimeSamples(dir, samples) {
   for (const file of enumerateMarkdownFiles(dir)) {
-    const mtimeKey = startOfDay(statSync6(file).mtime).toISOString();
+    const mtimeKey = startOfDay(statSync7(file).mtime).toISOString();
     const sample = samples.get(mtimeKey);
     if (!sample)
       continue;
@@ -57117,13 +57642,13 @@ var DAY_MS = 86400000, CELL_COUNT = 84, MAX_DEPTH = 10;
 var init_activity_tracker = () => {};
 
 // src/domains/plan-parser/plan-scanner.ts
-import { existsSync as existsSync29, readdirSync as readdirSync4 } from "node:fs";
+import { existsSync as existsSync29, readdirSync as readdirSync5 } from "node:fs";
 import { join as join43 } from "node:path";
 function scanPlanDir(dir) {
   if (!existsSync29(dir))
     return [];
   try {
-    return readdirSync4(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join43(dir, entry.name, "plan.md")).filter(existsSync29);
+    return readdirSync5(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join43(dir, entry.name, "plan.md")).filter(existsSync29);
   } catch {
     return [];
   }
@@ -60169,7 +60694,7 @@ var init_skill_browser_routes = __esm(() => {
 });
 
 // src/commands/skills/agents.ts
-import { existsSync as existsSync37, readdirSync as readdirSync5, statSync as statSync7 } from "node:fs";
+import { existsSync as existsSync37, readdirSync as readdirSync6, statSync as statSync8 } from "node:fs";
 import { homedir as homedir37, platform as platform5 } from "node:os";
 import { join as join54 } from "node:path";
 function hasInstallSignal2(path6) {
@@ -60177,9 +60702,9 @@ function hasInstallSignal2(path6) {
     return false;
   }
   try {
-    const stat10 = statSync7(path6);
+    const stat10 = statSync8(path6);
     if (stat10.isDirectory()) {
-      return readdirSync5(path6).length > 0;
+      return readdirSync6(path6).length > 0;
     }
     if (stat10.isFile()) {
       return true;
@@ -61558,7 +62083,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "claudekit-cli",
-    version: "3.41.4-dev.47",
+    version: "3.41.4-dev.49",
     description: "CLI tool for bootstrapping and updating ClaudeKit projects",
     type: "module",
     repository: {
@@ -61601,6 +62126,8 @@ var init_package = __esm(() => {
       "test:integration": "CK_RUN_CLI_INTEGRATION=1 bun test tests/integration/cli.test.ts",
       "test:watch": "bun test --watch",
       "test:quick": "./scripts/dev-quick-start.sh test",
+      "test:e2e": "playwright test --config=playwright.config.ts",
+      "test:e2e:ui": "playwright test --ui --config=playwright.config.ts",
       lint: "biome check .",
       "lint:fix": "biome check --fix .",
       "lint:fix-unsafe": "biome check --fix --unsafe .",
@@ -61659,6 +62186,7 @@ var init_package = __esm(() => {
     },
     devDependencies: {
       "@biomejs/biome": "^1.9.4",
+      "@playwright/test": "^1.59.1",
       "@semantic-release/changelog": "^6.0.3",
       "@semantic-release/git": "^10.0.1",
       "@tauri-apps/cli": "^2",
@@ -72856,7 +73384,7 @@ var init_content_validator = __esm(() => {
 
 // src/commands/content/phases/context-cache-manager.ts
 import { createHash as createHash9 } from "node:crypto";
-import { existsSync as existsSync75, mkdirSync as mkdirSync5, readFileSync as readFileSync18, readdirSync as readdirSync10, statSync as statSync13 } from "node:fs";
+import { existsSync as existsSync75, mkdirSync as mkdirSync5, readFileSync as readFileSync18, readdirSync as readdirSync11, statSync as statSync14 } from "node:fs";
 import { rename as rename14, writeFile as writeFile38 } from "node:fs/promises";
 import { homedir as homedir52 } from "node:os";
 import { basename as basename30, join as join158 } from "node:path";
@@ -72892,7 +73420,7 @@ function computeSourceHash(repoPath) {
   const paths = getDocSourcePaths(repoPath);
   for (const filePath of paths) {
     try {
-      const stat25 = statSync13(filePath);
+      const stat25 = statSync14(filePath);
       hash.update(`${filePath}:${stat25.mtimeMs}`);
     } catch {
       hash.update(`${filePath}:0`);
@@ -72905,7 +73433,7 @@ function getDocSourcePaths(repoPath) {
   const docsDir = join158(repoPath, "docs");
   if (existsSync75(docsDir)) {
     try {
-      const files = readdirSync10(docsDir);
+      const files = readdirSync11(docsDir);
       for (const f3 of files) {
         if (f3.endsWith(".md"))
           paths.push(join158(docsDir, f3));
@@ -72918,7 +73446,7 @@ function getDocSourcePaths(repoPath) {
   const stylesDir = join158(repoPath, "assets", "writing-styles");
   if (existsSync75(stylesDir)) {
     try {
-      const files = readdirSync10(stylesDir);
+      const files = readdirSync11(stylesDir);
       for (const f3 of files) {
         paths.push(join158(stylesDir, f3));
       }
@@ -73113,7 +73641,7 @@ function extractContentFromResponse(response) {
 
 // src/commands/content/phases/docs-summarizer.ts
 import { execSync as execSync7 } from "node:child_process";
-import { existsSync as existsSync76, readFileSync as readFileSync19, readdirSync as readdirSync11 } from "node:fs";
+import { existsSync as existsSync76, readFileSync as readFileSync19, readdirSync as readdirSync12 } from "node:fs";
 import { join as join159 } from "node:path";
 async function summarizeProjectDocs(repoPath, contentLogger) {
   const rawContent = collectRawDocs(repoPath);
@@ -73171,7 +73699,7 @@ function collectRawDocs(repoPath) {
   const docsDir = join159(repoPath, "docs");
   if (existsSync76(docsDir)) {
     try {
-      const files = readdirSync11(docsDir).filter((f3) => f3.endsWith(".md")).sort();
+      const files = readdirSync12(docsDir).filter((f3) => f3.endsWith(".md")).sort();
       for (const f3 of files) {
         const content = readCapped(join159(docsDir, f3), 5000);
         if (content) {
@@ -73195,7 +73723,7 @@ ${content}`);
   const stylesDir = join159(repoPath, "assets", "writing-styles");
   if (existsSync76(stylesDir)) {
     try {
-      const files = readdirSync11(stylesDir).slice(0, 3);
+      const files = readdirSync12(stylesDir).slice(0, 3);
       styles3 = files.map((f3) => readCapped(join159(stylesDir, f3), 1000)).filter(Boolean).join(`
 
 `);
@@ -73386,7 +73914,7 @@ IMPORTANT: Generate the image and output the path as JSON: {"imagePath": "/path/
 
 // src/commands/content/phases/photo-generator.ts
 import { execSync as execSync8 } from "node:child_process";
-import { existsSync as existsSync77, mkdirSync as mkdirSync6, readdirSync as readdirSync12 } from "node:fs";
+import { existsSync as existsSync77, mkdirSync as mkdirSync6, readdirSync as readdirSync13 } from "node:fs";
 import { homedir as homedir53 } from "node:os";
 import { join as join160 } from "node:path";
 async function generatePhoto(_content, context, config, platform17, contentId, contentLogger) {
@@ -73411,7 +73939,7 @@ async function generatePhoto(_content, context, config, platform17, contentId, c
         return { path: imagePath, ...dimensions, format: "png" };
       }
     }
-    const files = readdirSync12(mediaDir);
+    const files = readdirSync13(mediaDir);
     const imageFile = files.find((f3) => /\.(png|jpg|jpeg|webp)$/i.test(f3));
     if (imageFile) {
       const ext2 = imageFile.split(".").pop() ?? "png";
@@ -73503,7 +74031,7 @@ var init_content_creator = __esm(() => {
 });
 
 // src/commands/content/phases/content-logger.ts
-import { createWriteStream as createWriteStream4, existsSync as existsSync78, mkdirSync as mkdirSync7, statSync as statSync14 } from "node:fs";
+import { createWriteStream as createWriteStream4, existsSync as existsSync78, mkdirSync as mkdirSync7, statSync as statSync15 } from "node:fs";
 import { homedir as homedir54 } from "node:os";
 import { join as join161 } from "node:path";
 
@@ -73569,7 +74097,7 @@ class ContentLogger {
     if (this.maxBytes > 0 && this.stream) {
       const logPath = join161(this.logDir, `content-${this.currentDate}.log`);
       try {
-        const stat25 = statSync14(logPath);
+        const stat25 = statSync15(logPath);
         if (stat25.size >= this.maxBytes) {
           this.close();
           const suffix = Date.now();
@@ -73798,7 +74326,7 @@ function isNoiseCommit(title, author) {
 
 // src/commands/content/phases/change-detector.ts
 import { execSync as execSync10, spawnSync as spawnSync9 } from "node:child_process";
-import { existsSync as existsSync80, readFileSync as readFileSync20, readdirSync as readdirSync13, statSync as statSync15 } from "node:fs";
+import { existsSync as existsSync80, readFileSync as readFileSync20, readdirSync as readdirSync14, statSync as statSync16 } from "node:fs";
 import { join as join162 } from "node:path";
 function detectCommits(repo, since) {
   try {
@@ -73914,7 +74442,7 @@ function detectCompletedPlans(repo, since) {
   const sinceMs = new Date(since).getTime();
   const events = [];
   try {
-    const entries = readdirSync13(plansDir, { withFileTypes: true });
+    const entries = readdirSync14(plansDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
@@ -73922,7 +74450,7 @@ function detectCompletedPlans(repo, since) {
       if (!existsSync80(planFile))
         continue;
       try {
-        const stat25 = statSync15(planFile);
+        const stat25 = statSync16(planFile);
         if (stat25.mtimeMs < sinceMs)
           continue;
         const content = readFileSync20(planFile, "utf-8");
@@ -73995,7 +74523,7 @@ function classifyCommit(event) {
 
 // src/commands/content/phases/repo-discoverer.ts
 import { execSync as execSync11 } from "node:child_process";
-import { readdirSync as readdirSync14 } from "node:fs";
+import { readdirSync as readdirSync15 } from "node:fs";
 import { join as join163 } from "node:path";
 function discoverRepos2(cwd2) {
   const repos = [];
@@ -74005,7 +74533,7 @@ function discoverRepos2(cwd2) {
       repos.push(info);
   }
   try {
-    const entries = readdirSync14(cwd2, { withFileTypes: true });
+    const entries = readdirSync15(cwd2, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory() || entry.name.startsWith("."))
         continue;
@@ -76715,19 +77243,40 @@ var init_migrate_command_help = __esm(() => {
     usage: "ck migrate [options]",
     examples: [
       {
-        command: "ck migrate --agent codex --dry-run",
-        description: "Preview the destination-aware migration plan before writing files"
+        command: "ck migrate --install",
+        description: "Pick items to install interactively (install picker mode)"
       },
       {
-        command: "ck migrate --agent codex -g",
-        description: "Write to Codex global paths such as ~/.codex/ and ~/.agents/skills"
+        command: "ck migrate --agent codex --dry-run",
+        description: "Preview the destination-aware reconcile plan before writing files"
       },
       {
-        command: "CK_FORCE_ASCII=1 ck migrate --agent codex",
-        description: "Force ASCII borders on legacy Windows terminals (cmd.exe, older PowerShell)"
+        command: "ck migrate --respect-deletions",
+        description: "Preserve empty directories — do not auto-reinstall deleted items"
       }
     ],
     optionGroups: [
+      {
+        title: "Mode Options",
+        options: [
+          {
+            flags: "--install",
+            description: "Opt-in install picker mode — interactively select which items to install (default when registry is empty or has unknown checksums)"
+          },
+          {
+            flags: "--reconcile",
+            description: "Force reconcile mode — compute diff vs registry and apply only changes (default when registry is valid)"
+          },
+          {
+            flags: "--reinstall-empty-dirs",
+            description: "Reinstall all items when their type directory is empty or missing (default: true). Use --respect-deletions to disable."
+          },
+          {
+            flags: "--respect-deletions",
+            description: "Preserve deletion even when a type directory is empty — skip reinstall heuristic. Mutually exclusive with --reinstall-empty-dirs."
+          }
+        ]
+      },
       {
         title: "Target Options",
         options: [
@@ -76790,6 +77339,19 @@ var init_migrate_command_help = __esm(() => {
           }
         ]
       }
+    ],
+    sections: [
+      {
+        title: "Gotchas",
+        content: [
+          "  --install and --reconcile are mutually exclusive — pass only one",
+          "  --reinstall-empty-dirs and --respect-deletions are mutually exclusive — pass only one",
+          "  Default mode is smart-detected: no/stale registry → install, valid registry → reconcile",
+          "  --respect-deletions disables the auto-reinstall heuristic for empty directories",
+          "  --force overrides skip decisions per item; --reinstall-empty-dirs is a per-directory heuristic"
+        ].join(`
+`)
+      }
     ]
   };
 });
@@ -84267,7 +84829,7 @@ async function checkCliInstallMethod() {
   };
 }
 // src/domains/health-checks/checkers/claude-md-checker.ts
-import { existsSync as existsSync48, statSync as statSync8 } from "node:fs";
+import { existsSync as existsSync48, statSync as statSync9 } from "node:fs";
 import { join as join76 } from "node:path";
 function checkClaudeMd(setup, projectDir) {
   const results = [];
@@ -84293,7 +84855,7 @@ function checkClaudeMdFile(path6, name, id) {
     };
   }
   try {
-    const stat13 = statSync8(path6);
+    const stat13 = statSync9(path6);
     const sizeKB = (stat13.size / 1024).toFixed(1);
     if (stat13.size === 0) {
       return {
@@ -85304,7 +85866,7 @@ init_command_normalizer();
 init_logger();
 init_path_resolver();
 import { spawnSync as spawnSync3 } from "node:child_process";
-import { existsSync as existsSync55, readFileSync as readFileSync15, statSync as statSync9, writeFileSync as writeFileSync5 } from "node:fs";
+import { existsSync as existsSync55, readFileSync as readFileSync15, statSync as statSync10, writeFileSync as writeFileSync5 } from "node:fs";
 import { readdir as readdir21 } from "node:fs/promises";
 import { homedir as homedir43, tmpdir as tmpdir2 } from "node:os";
 import { join as join86, resolve as resolve30 } from "node:path";
@@ -86152,7 +86714,7 @@ async function checkHookLogs(projectDir) {
     };
   }
   try {
-    const logStats = statSync9(logPath);
+    const logStats = statSync10(logPath);
     if (logStats.size > MAX_LOG_FILE_SIZE_BYTES) {
       return {
         id: "hook-logs",
@@ -98194,7 +98756,7 @@ async function handleDownload(ctx) {
 import { join as join122 } from "node:path";
 
 // src/domains/installation/deletion-handler.ts
-import { existsSync as existsSync61, lstatSync as lstatSync3, readdirSync as readdirSync6, rmSync as rmSync2, rmdirSync, unlinkSync as unlinkSync4 } from "node:fs";
+import { existsSync as existsSync61, lstatSync as lstatSync3, readdirSync as readdirSync7, rmSync as rmSync2, rmdirSync, unlinkSync as unlinkSync4 } from "node:fs";
 import { dirname as dirname35, join as join108, relative as relative17, resolve as resolve34, sep as sep10 } from "node:path";
 
 // src/services/file-operations/manifest/manifest-reader.ts
@@ -98388,7 +98950,7 @@ function collectFilesRecursively(dir, baseDir) {
   if (!existsSync61(dir))
     return results;
   try {
-    const entries = readdirSync6(dir, { withFileTypes: true });
+    const entries = readdirSync7(dir, { withFileTypes: true });
     for (const entry of entries) {
       const fullPath = join108(dir, entry.name);
       const relativePath = relative17(baseDir, fullPath);
@@ -98426,7 +98988,7 @@ function cleanupEmptyDirectories(filePath, claudeDir3) {
   while (currentDir !== normalizedClaudeDir && currentDir.startsWith(normalizedClaudeDir) && iterations < MAX_CLEANUP_ITERATIONS) {
     iterations++;
     try {
-      const entries = readdirSync6(currentDir);
+      const entries = readdirSync7(currentDir);
       if (entries.length === 0) {
         rmdirSync(currentDir);
         logger.debug(`Removed empty directory: ${currentDir}`);
@@ -104104,7 +104666,7 @@ async function runPreflightChecks() {
 
 // src/domains/installation/fresh-installer.ts
 init_metadata_migration();
-import { existsSync as existsSync63, readdirSync as readdirSync7, rmSync as rmSync3, rmdirSync as rmdirSync2, unlinkSync as unlinkSync5 } from "node:fs";
+import { existsSync as existsSync63, readdirSync as readdirSync8, rmSync as rmSync3, rmdirSync as rmdirSync2, unlinkSync as unlinkSync5 } from "node:fs";
 import { basename as basename24, dirname as dirname39, join as join134, resolve as resolve36 } from "node:path";
 init_logger();
 init_safe_spinner();
@@ -104157,7 +104719,7 @@ function cleanupEmptyDirectories2(filePath, claudeDir3) {
   let currentDir = resolve36(dirname39(filePath));
   while (currentDir !== normalizedClaudeDir && currentDir.startsWith(normalizedClaudeDir)) {
     try {
-      const entries = readdirSync7(currentDir);
+      const entries = readdirSync8(currentDir);
       if (entries.length === 0) {
         rmdirSync2(currentDir);
         logger.debug(`Removed empty directory: ${currentDir}`);
@@ -106857,6 +107419,30 @@ function buildProviderScopeSubtitle(selectedProviders, global3) {
   }
   return `${selectedProviders.length} providers -> ${scope}`;
 }
+function renderBannerLines(banner) {
+  const width = 64;
+  const bar = `+${"=".repeat(width)}+`;
+  const homePath = process.env.HOME ?? "";
+  const displayPath = banner.path.replace(homePath, "~");
+  if (banner.kind === "empty-dir") {
+    return [
+      bar,
+      `| [i] Detected empty ${displayPath}`,
+      `|     ${banner.itemCount} item(s) below will be reinstalled.`,
+      "|     Use --respect-deletions to preserve deletion.",
+      bar
+    ];
+  }
+  if (banner.kind === "empty-dir-respected") {
+    return [
+      bar,
+      `| [i] Detected empty ${displayPath}`,
+      `|     ${banner.itemCount} item(s) skipped (--respect-deletions active).`,
+      bar
+    ];
+  }
+  return [];
+}
 function buildSourceSummaryLines(counts, origins) {
   const parts = [];
   if (counts.agents > 0)
@@ -106880,6 +107466,148 @@ function buildSourceSummaryLines(counts, origins) {
 
 // src/commands/migrate/migrate-command.ts
 init_skill_directory_installer();
+function validateMutualExclusion(options2) {
+  if (options2.install && options2.reconcile) {
+    return "Pass either --install or --reconcile, not both.";
+  }
+  if (options2.reinstallEmptyDirs && options2.respectDeletions) {
+    return "Pass either --reinstall-empty-dirs or --respect-deletions, not both.";
+  }
+  return null;
+}
+function resolveMigrationMode(options2, hasUnknownChecksums) {
+  if (options2.install)
+    return "install";
+  if (options2.reconcile)
+    return "reconcile";
+  if (hasUnknownChecksums)
+    return "install";
+  return "reconcile";
+}
+function renderBanners(banners) {
+  if (banners.length === 0)
+    return;
+  for (const banner of banners) {
+    const lines = renderBannerLines(banner);
+    if (lines.length > 0) {
+      console.log();
+      for (const line of lines) {
+        console.log(line);
+      }
+    }
+  }
+}
+async function runInstallMode(options2, discoveredItems, _selectedProviders, _installGlobally) {
+  const interactive = process.stdout.isTTY && !options2.yes;
+  if (!interactive) {
+    return discoveredItems;
+  }
+  const toOption = (item) => ({
+    value: item.name,
+    label: item.name,
+    hint: item.recommended ? "Recommended" : undefined
+  });
+  let selectedAgents = discoveredItems.agents;
+  let selectedCommands = discoveredItems.commands;
+  let selectedSkills = discoveredItems.skills;
+  let selectedConfig = discoveredItems.configItem;
+  let selectedRules = discoveredItems.ruleItems;
+  let selectedHooks = discoveredItems.hookItems;
+  if (discoveredItems.agents.length > 0) {
+    const picked = await ae({
+      message: `Select agents to install (${discoveredItems.agents.length} available)`,
+      options: discoveredItems.agents.map(toOption),
+      initialValues: discoveredItems.agents.map((a3) => a3.name),
+      required: false
+    });
+    if (lD(picked)) {
+      ue("Migrate cancelled");
+      process.exit(0);
+    }
+    const pickedSet = new Set(picked);
+    selectedAgents = discoveredItems.agents.filter((a3) => pickedSet.has(a3.name));
+  }
+  if (discoveredItems.commands.length > 0) {
+    const picked = await ae({
+      message: `Select commands to install (${discoveredItems.commands.length} available)`,
+      options: discoveredItems.commands.map(toOption),
+      initialValues: discoveredItems.commands.map((c2) => c2.name),
+      required: false
+    });
+    if (lD(picked)) {
+      ue("Migrate cancelled");
+      process.exit(0);
+    }
+    const pickedSet = new Set(picked);
+    selectedCommands = discoveredItems.commands.filter((c2) => pickedSet.has(c2.name));
+  }
+  if (discoveredItems.skills.length > 0) {
+    const picked = await ae({
+      message: `Select skills to install (${discoveredItems.skills.length} available, directory-level)`,
+      options: discoveredItems.skills.map((s) => ({
+        value: s.name,
+        label: s.name,
+        hint: "skill directory"
+      })),
+      initialValues: discoveredItems.skills.map((s) => s.name),
+      required: false
+    });
+    if (lD(picked)) {
+      ue("Migrate cancelled");
+      process.exit(0);
+    }
+    const pickedSet = new Set(picked);
+    selectedSkills = discoveredItems.skills.filter((s) => pickedSet.has(s.name));
+  }
+  if (discoveredItems.configItem) {
+    const include = await se({
+      message: "Include CLAUDE.md config?",
+      initialValue: true
+    });
+    if (lD(include)) {
+      ue("Migrate cancelled");
+      process.exit(0);
+    }
+    if (!include)
+      selectedConfig = null;
+  }
+  if (discoveredItems.ruleItems.length > 0) {
+    const picked = await ae({
+      message: `Select rules to install (${discoveredItems.ruleItems.length} available)`,
+      options: discoveredItems.ruleItems.map(toOption),
+      initialValues: discoveredItems.ruleItems.map((r2) => r2.name),
+      required: false
+    });
+    if (lD(picked)) {
+      ue("Migrate cancelled");
+      process.exit(0);
+    }
+    const pickedSet = new Set(picked);
+    selectedRules = discoveredItems.ruleItems.filter((r2) => pickedSet.has(r2.name));
+  }
+  if (discoveredItems.hookItems.length > 0) {
+    const picked = await ae({
+      message: `Select hooks to install (${discoveredItems.hookItems.length} available)`,
+      options: discoveredItems.hookItems.map(toOption),
+      initialValues: discoveredItems.hookItems.map((h2) => h2.name),
+      required: false
+    });
+    if (lD(picked)) {
+      ue("Migrate cancelled");
+      process.exit(0);
+    }
+    const pickedSet = new Set(picked);
+    selectedHooks = discoveredItems.hookItems.filter((h2) => pickedSet.has(h2.name));
+  }
+  return {
+    agents: selectedAgents,
+    commands: selectedCommands,
+    skills: selectedSkills,
+    configItem: selectedConfig,
+    ruleItems: selectedRules,
+    hookItems: selectedHooks
+  };
+}
 function getProviderPathKey(type) {
   switch (type) {
     case "agent":
@@ -106894,8 +107622,6 @@ function getProviderPathKey(type) {
       return "hooks";
     case "skill":
       return "skills";
-    default:
-      return type;
   }
 }
 function shouldExecuteAction2(action) {
@@ -106977,6 +107703,11 @@ function inferKitTypeFromSourceMetadata(sourceMetadata) {
 }
 async function migrateCommand(options2) {
   console.log();
+  const mutexError = validateMutualExclusion(options2);
+  if (mutexError) {
+    f2.error(mutexError);
+    process.exit(1);
+  }
   try {
     const scope = resolveMigrationScope(process.argv.slice(2), options2);
     const spinner = de();
@@ -107170,31 +107901,66 @@ async function migrateCommand(options2) {
     setTaxonomyOverrides(ckConfigResult.config.modelTaxonomy);
     const reconcileSpinner = de();
     reconcileSpinner.start("Computing migration plan...");
+    const registry = await readPortableRegistry();
+    const hasUnknownChecksums = registry.installations.some((entry) => !entry.sourceChecksum || entry.sourceChecksum === "unknown" || !entry.targetChecksum || entry.targetChecksum === "unknown");
+    const migrationMode = resolveMigrationMode(options2, hasUnknownChecksums);
+    let effectiveAgents = agents2;
+    let effectiveCommands = commands;
+    let effectiveSkills = skills;
+    let effectiveConfigItem = configItem;
+    let effectiveRuleItems = ruleItems;
+    let effectiveHookItems = hookItems;
+    if (migrationMode === "install") {
+      reconcileSpinner.stop("Discovery complete");
+      if (!options2.yes && process.stdout.isTTY) {
+        f2.info(`[i] Smart default: ${hasUnknownChecksums ? "unknown checksums detected" : "--install flag"} — entering install picker mode.`);
+      }
+      const picked = await runInstallMode(options2, {
+        agents: agents2,
+        commands,
+        skills,
+        configItem,
+        ruleItems,
+        hookItems
+      }, selectedProviders, installGlobally);
+      effectiveAgents = picked.agents;
+      effectiveCommands = picked.commands;
+      effectiveSkills = picked.skills;
+      effectiveConfigItem = picked.configItem;
+      effectiveRuleItems = picked.ruleItems;
+      effectiveHookItems = picked.hookItems;
+      reconcileSpinner.start("Computing migration plan...");
+    }
     const sourceStates = await computeSourceStates({
-      agents: agents2,
-      commands,
-      config: configItem,
-      rules: ruleItems,
-      hooks: hookItems
+      agents: effectiveAgents,
+      commands: effectiveCommands,
+      config: effectiveConfigItem,
+      rules: effectiveRuleItems,
+      hooks: effectiveHookItems
     }, selectedProviders);
     const targetStates = await computeTargetStates(selectedProviders, installGlobally);
-    const registry = await readPortableRegistry();
     const providerConfigs = selectedProviders.map((provider) => ({
       provider,
       global: installGlobally
     }));
+    const portableTypes = ["agent", "command", "config", "rules", "hooks"];
+    const typeDirectoryStates = buildTypeDirectoryStates(selectedProviders.map((provider) => ({ provider, global: installGlobally })), [...portableTypes]);
+    const reinstallEmptyDirs = options2.respectDeletions ? false : options2.reinstallEmptyDirs ?? true;
     const plan = reconcile({
       sourceItems: sourceStates,
       registry,
       targetStates,
       providerConfigs,
-      force: options2.force
+      force: options2.force,
+      typeDirectoryStates,
+      respectDeletions: !reinstallEmptyDirs
     });
     reconcileSpinner.stop("Plan computed");
     const useColor = process.stdout.isTTY && !process.env.NO_COLOR;
+    renderBanners(plan.banners);
     displayReconcilePlan(plan, { color: useColor });
     if (options2.dryRun) {
-      displayMigrationSummary(plan, buildDryRunFallbackResults(skills, selectedProviders, installGlobally, plan.actions), { color: useColor, dryRun: true });
+      displayMigrationSummary(plan, buildDryRunFallbackResults(effectiveSkills, selectedProviders, installGlobally, plan.actions), { color: useColor, dryRun: true });
       return;
     }
     if (plan.hasConflicts) {
@@ -107204,7 +107970,7 @@ async function migrateCommand(options2) {
         if (!action.diff && action.targetPath && existsSync64(action.targetPath)) {
           try {
             const targetContent = await readFile61(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) || hookItems.find((h2) => h2.name === action.item);
+            const sourceItem = effectiveAgents.find((a3) => a3.name === action.item) || effectiveCommands.find((c2) => c2.name === action.item) || (effectiveConfigItem?.name === action.item ? effectiveConfigItem : null) || effectiveRuleItems.find((r2) => r2.name === action.item) || effectiveHookItems.find((h2) => h2.name === action.item);
             if (sourceItem) {
               const providerConfig = providers[action.provider];
               const pathConfigKey = getProviderPathKey(action.type);
@@ -107242,12 +108008,12 @@ async function migrateCommand(options2) {
     }
     let allResults = [];
     const installOpts = { global: installGlobally };
-    const agentByName = new Map(agents2.map((item) => [item.name, item]));
-    const commandByName = new Map(commands.map((item) => [item.name, item]));
-    const skillByName = new Map(skills.map((item) => [item.name, item]));
-    const configByName = new Map(configItem ? [[configItem.name, configItem]] : []);
-    const ruleByName = new Map(ruleItems.map((item) => [item.name, item]));
-    const hookByName = new Map(hookItems.map((item) => [item.name, item]));
+    const agentByName = new Map(effectiveAgents.map((item) => [item.name, item]));
+    const commandByName = new Map(effectiveCommands.map((item) => [item.name, item]));
+    const skillByName = new Map(effectiveSkills.map((item) => [item.name, item]));
+    const configByName = new Map(effectiveConfigItem ? [[effectiveConfigItem.name, effectiveConfigItem]] : []);
+    const ruleByName = new Map(effectiveRuleItems.map((item) => [item.name, item]));
+    const hookByName = new Map(effectiveHookItems.map((item) => [item.name, item]));
     const successfulHookFiles = new Map;
     const successfulHookAbsPaths = new Map;
     const postProgressWarnings = [];
@@ -107299,10 +108065,10 @@ async function migrateCommand(options2) {
       }
     }
     const plannedSkillActions = plannedExecActions.filter((action) => action.type === "skill").length;
-    if (skills.length > 0 && plannedSkillActions === 0) {
+    if (effectiveSkills.length > 0 && plannedSkillActions === 0) {
       const skillProviders = selectedProviders.filter((pv) => getProvidersSupporting("skills").includes(pv));
       for (const provider of skillProviders) {
-        for (const skill of skills) {
+        for (const skill of effectiveSkills) {
           writeTasks.push({ item: skill, provider, type: "skill" });
         }
       }
@@ -108010,7 +108776,7 @@ Please use only one download method.`);
 }
 // src/commands/plan/plan-command.ts
 init_output_manager();
-import { existsSync as existsSync67, statSync as statSync11 } from "node:fs";
+import { existsSync as existsSync67, statSync as statSync12 } from "node:fs";
 import { dirname as dirname46, isAbsolute as isAbsolute11, join as join147, parse as parse7, resolve as resolve45 } from "node:path";
 
 // src/commands/plan/plan-read-handlers.ts
@@ -108020,7 +108786,7 @@ init_plans_registry();
 init_logger();
 init_output_manager();
 var import_picocolors32 = __toESM(require_picocolors(), 1);
-import { existsSync as existsSync66, statSync as statSync10 } from "node:fs";
+import { existsSync as existsSync66, statSync as statSync11 } from "node:fs";
 import { basename as basename27, dirname as dirname44, join as join146, relative as relative27, resolve as resolve43 } from "node:path";
 
 // src/commands/plan/plan-dependencies.ts
@@ -108190,7 +108956,7 @@ async function handleStatus(target, options2) {
   }
   const effectiveTarget = !resolvedTarget && globalBaseDir ? globalBaseDir : resolvedTarget;
   const t = effectiveTarget ? resolve43(effectiveTarget) : null;
-  const plansDir = t && existsSync66(t) && statSync10(t).isDirectory() && !existsSync66(join146(t, "plan.md")) ? t : null;
+  const plansDir = t && existsSync66(t) && statSync11(t).isDirectory() && !existsSync66(join146(t, "plan.md")) ? t : null;
   if (plansDir) {
     const planFiles = scanPlanDir(plansDir);
     if (planFiles.length === 0) {
@@ -108602,7 +109368,7 @@ function resolveTargetPath(target, baseDir) {
 function resolvePlanFile(target, baseDir) {
   const t = target ? resolveTargetPath(target, baseDir) : baseDir ? resolve45(baseDir) : process.cwd();
   if (existsSync67(t)) {
-    const stat23 = statSync11(t);
+    const stat23 = statSync12(t);
     if (stat23.isFile())
       return t;
     const candidate = join147(t, "plan.md");
@@ -109815,7 +110581,7 @@ async function detectInstallations() {
 }
 
 // src/commands/uninstall/removal-handler.ts
-import { readdirSync as readdirSync9, rmSync as rmSync5 } from "node:fs";
+import { readdirSync as readdirSync10, rmSync as rmSync5 } from "node:fs";
 import { basename as basename29, join as join150, resolve as resolve47, sep as sep12 } from "node:path";
 init_logger();
 init_safe_prompts();
@@ -109824,7 +110590,7 @@ var import_fs_extra44 = __toESM(require_lib3(), 1);
 
 // src/commands/uninstall/analysis-handler.ts
 init_metadata_migration();
-import { readdirSync as readdirSync8, rmSync as rmSync4 } from "node:fs";
+import { readdirSync as readdirSync9, rmSync as rmSync4 } from "node:fs";
 import { dirname as dirname47, join as join149 } from "node:path";
 init_logger();
 init_safe_prompts();
@@ -109850,7 +110616,7 @@ async function cleanupEmptyDirectories3(filePath, installationRoot) {
   let currentDir = dirname47(filePath);
   while (currentDir !== installationRoot && currentDir.startsWith(installationRoot)) {
     try {
-      const entries = readdirSync8(currentDir);
+      const entries = readdirSync9(currentDir);
       if (entries.length === 0) {
         rmSync4(currentDir, { recursive: true });
         cleaned++;
@@ -110091,7 +110857,7 @@ async function removeInstallations(installations, options2) {
           }
         }
         try {
-          const remaining = readdirSync9(installation.path);
+          const remaining = readdirSync10(installation.path);
           if (remaining.length === 0) {
             rmSync5(installation.path, { recursive: true });
             logger.debug(`Removed empty installation directory: ${installation.path}`);
@@ -111944,7 +112710,7 @@ Run this command from a directory with a GitHub remote.`);
 // src/commands/watch/phases/watch-logger.ts
 init_logger();
 init_path_resolver();
-import { createWriteStream as createWriteStream3, statSync as statSync12 } from "node:fs";
+import { createWriteStream as createWriteStream3, statSync as statSync13 } from "node:fs";
 import { existsSync as existsSync73 } from "node:fs";
 import { mkdir as mkdir38, rename as rename13 } from "node:fs/promises";
 import { join as join156 } from "node:path";
@@ -112012,7 +112778,7 @@ class WatchLogger {
       return;
     if (this.maxBytes > 0 && this.logPath) {
       try {
-        const stats = statSync12(this.logPath);
+        const stats = statSync13(this.logPath);
         if (stats.size >= this.maxBytes) {
           this.rotateLog();
         }
@@ -112390,7 +113156,7 @@ function registerCommands(cli) {
   cli.command("api [action] [service] [path]", "Interact with ClaudeKit API and proxy services").option("--method <method>", "HTTP method for proxy requests (default: GET)").option("--body <json>", "Request body as JSON string (proxy only)").option("--query <json>", "Query params as JSON string (proxy only)").option("--key <key>", "API key to use (setup only)").option("--force", "Force re-setup even if key exists (setup only)").option("--json", "Output raw JSON instead of formatted display").option("--locale <locale>", "Locale for vidcap summary/caption (default: en)").option("--max-results <n>", "Max results for vidcap search").option("--second <s>", "Timestamp in seconds for vidcap screenshot").option("--order <order>", "Sort order for vidcap comments (time/relevance)").option("--format <fmt>", "Summary format for reviewweb (bullet/paragraph)").option("--max-length <n>", "Max summary length for reviewweb").option("--instructions <text>", "Extraction instructions for reviewweb extract").option("--template <json>", "JSON template for reviewweb extract").option("--type <type>", "Link type filter for reviewweb links (web/image/file/all)").option("--country <code>", "Country code for reviewweb SEO commands").action(async (action, service, path16, options2) => {
     await apiCommand(action, service, path16, options2);
   });
-  cli.command("migrate", "Migrate agents, commands, skills, config, rules, and hooks to other providers").option("-a, --agent <agents...>", "Target providers (cursor, codex, droid, opencode, etc.)").option("-g, --global", "Install globally instead of project-level").option("--all", "Migrate to all supported providers").option("-y, --yes", "Skip confirmation prompts").option("--config", "Migrate CLAUDE.md config only").option("--rules", "Migrate .claude/rules/ only").option("--hooks", "Migrate .claude/hooks/ only").option("--skip-config", "Skip config migration").option("--skip-rules", "Skip rules migration").option("--skip-hooks", "Skip hooks migration").option("--source <path>", "Custom CLAUDE.md source path (config only, not agents/commands/skills/hooks)").option("--dry-run", "Preview migration targets without writing files").option("-f, --force", "Force reinstall deleted/edited items").action(async (options2) => {
+  cli.command("migrate", "Migrate agents, commands, skills, config, rules, and hooks to other providers").option("-a, --agent <agents...>", "Target providers (cursor, codex, droid, opencode, etc.)").option("-g, --global", "Install globally instead of project-level").option("--all", "Migrate to all supported providers").option("-y, --yes", "Skip confirmation prompts").option("--config", "Migrate CLAUDE.md config only").option("--rules", "Migrate .claude/rules/ only").option("--hooks", "Migrate .claude/hooks/ only").option("--skip-config", "Skip config migration").option("--skip-rules", "Skip rules migration").option("--skip-hooks", "Skip hooks migration").option("--source <path>", "Custom CLAUDE.md source path (config only, not agents/commands/skills/hooks)").option("--dry-run", "Preview migration targets without writing files").option("-f, --force", "Force reinstall deleted/edited items").option("--install", "Opt-in install picker mode (select specific items to install)").option("--reconcile", "Force reconcile mode (current default when registry is valid)").option("--reinstall-empty-dirs", "Reinstall all items when their type directory is empty (default: true)").option("--respect-deletions", "Preserve deletion even when type directory is empty (disables reinstall-empty-dirs)").action(async (options2) => {
     if (options2.agent && !Array.isArray(options2.agent)) {
       options2.agent = [options2.agent];
     }