claudekit-cli 3.37.0-dev.4 → 3.37.0-dev.6

package/dist/index.js

@@ -12977,7 +12977,7 @@ async function installCodexToml(items, provider, portableType, options2) {
             slug,
             agentTomlPath,
             sourcePath: item.sourcePath,
-            sourceChecksum: await computeContentChecksum(item.body),
+            sourceChecksum: await computeContentChecksum(result.content),
             targetChecksum: await computeContentChecksum(result.content)
           });
         }
@@ -13157,6 +13157,204 @@ var init_codex_toml_installer = __esm(() => {
   import_proper_lockfile2 = __toESM(require_proper_lockfile(), 1);
 });
 
+// src/commands/portable/merge-single-sections.ts
+function isManagedHeadingLine(line) {
+  return Object.values(SECTION_HEADING_PATTERNS).some((regex) => regex.test(line));
+}
+function findNextNonBlankLineIndex(lines, startIndex) {
+  for (let index = startIndex;index < lines.length; index += 1) {
+    if (lines[index].trim().length > 0) {
+      return index;
+    }
+  }
+  return -1;
+}
+function hasLaterManagedHeading(lines, startIndex) {
+  let inFence = false;
+  for (let index = startIndex;index < lines.length; index += 1) {
+    const trimmedLine = lines[index].trim();
+    if (trimmedLine.startsWith("```") || trimmedLine.startsWith("~~~")) {
+      inFence = !inFence;
+      continue;
+    }
+    if (!inFence && isManagedHeadingLine(trimmedLine)) {
+      return true;
+    }
+  }
+  return false;
+}
+function splitManagedContent(content) {
+  const lines = content.split(/\r?\n/);
+  const lineOffsets = [];
+  let offset = 0;
+  for (const line of lines) {
+    lineOffsets.push(offset);
+    offset += line.length + 1;
+  }
+  let inFence = false;
+  let firstManagedIndex = -1;
+  const separatorIndices = [];
+  for (let lineIndex = 0;lineIndex < lines.length; lineIndex += 1) {
+    const trimmedLine = lines[lineIndex].trim();
+    if (trimmedLine.startsWith("```") || trimmedLine.startsWith("~~~")) {
+      inFence = !inFence;
+    }
+    if (!inFence) {
+      if (isManagedHeadingLine(trimmedLine) && firstManagedIndex === -1) {
+        firstManagedIndex = lineOffsets[lineIndex];
+      }
+      if (/^[ \t]*---[ \t]*$/.test(trimmedLine)) {
+        const nextNonBlankLineIndex = findNextNonBlankLineIndex(lines, lineIndex + 1);
+        if (nextNonBlankLineIndex === -1) {
+          separatorIndices.push(lineOffsets[lineIndex]);
+          continue;
+        }
+        const nextNonBlankLine = lines[nextNonBlankLineIndex].trim();
+        if (isManagedHeadingLine(nextNonBlankLine) || !hasLaterManagedHeading(lines, nextNonBlankLineIndex)) {
+          separatorIndices.push(lineOffsets[lineIndex]);
+        }
+      }
+    }
+  }
+  if (firstManagedIndex === -1) {
+    return { preambleEnd: content.length, parts: [] };
+  }
+  const managedContent = content.slice(firstManagedIndex);
+  const managedStart = firstManagedIndex;
+  const parts = [];
+  let lastSplitPos = 0;
+  for (const separatorIndex of separatorIndices) {
+    if (separatorIndex < managedStart)
+      continue;
+    const relativeIndex = separatorIndex - managedStart;
+    if (relativeIndex > lastSplitPos) {
+      const part = managedContent.slice(lastSplitPos, relativeIndex).trim();
+      if (part)
+        parts.push(part);
+    }
+    const separatorLineEnd = managedContent.indexOf(`
+`, relativeIndex);
+    lastSplitPos = separatorLineEnd >= 0 ? separatorLineEnd + 1 : managedContent.length;
+  }
+  const finalPart = managedContent.slice(lastSplitPos).trim();
+  if (finalPart)
+    parts.push(finalPart);
+  return { preambleEnd: firstManagedIndex, parts };
+}
+function parseSectionMetadata(content) {
+  const agentMatch = content.match(SECTION_HEADING_PATTERNS.agent);
+  if (agentMatch) {
+    return { kind: "agent", key: agentMatch[1].trim() };
+  }
+  const ruleMatch = content.match(SECTION_HEADING_PATTERNS.rule);
+  if (ruleMatch) {
+    return { kind: "rule", key: ruleMatch[1].trim() };
+  }
+  if (SECTION_HEADING_PATTERNS.config.test(content)) {
+    return { kind: "config", key: "config" };
+  }
+  return null;
+}
+function parseMergedSections(content) {
+  const sections = [];
+  const warnings = [];
+  const { preambleEnd, parts } = splitManagedContent(content);
+  if (parts.length === 0) {
+    return {
+      sections,
+      preamble: content.trim(),
+      warnings
+    };
+  }
+  let unknownIndex = 0;
+  const seenKeys = new Map;
+  for (const part of parts) {
+    const trimmed = part.trim();
+    if (!trimmed)
+      continue;
+    const metadata = parseSectionMetadata(trimmed);
+    if (metadata) {
+      const compositeKey = `${metadata.kind}:${metadata.key}`;
+      const existingIndex = seenKeys.get(compositeKey);
+      if (existingIndex !== undefined) {
+        warnings.push(`Duplicate ${metadata.kind} section "${metadata.key}" in existing file; keeping last occurrence`);
+        sections.splice(existingIndex, 1);
+        for (const [key, index] of seenKeys) {
+          if (index > existingIndex) {
+            seenKeys.set(key, index - 1);
+          }
+        }
+      }
+      const nextIndex = sections.length;
+      sections.push({
+        kind: metadata.kind,
+        key: metadata.key,
+        content: trimmed
+      });
+      seenKeys.set(compositeKey, nextIndex);
+      continue;
+    }
+    unknownIndex += 1;
+    sections.push({
+      kind: "unknown",
+      key: `unknown-${unknownIndex}`,
+      content: trimmed
+    });
+  }
+  let preamble = content.slice(0, preambleEnd).trimEnd();
+  preamble = preamble.replace(/^# Agents\r?\n\r?\n> Ported from Claude Code agents via ClaudeKit CLI \(ck agents\)\r?\n> Target: .*\r?\n+/is, "").replace(/^# Rules\r?\n\r?\n> Ported from Claude Code rules via ClaudeKit CLI \(ck migrate --rules\)\r?\n> Target: .*\r?\n+/is, "").replace(/^# Config\r?\n\r?\n> Ported from Claude Code config via ClaudeKit CLI.*\r?\n+/is, "").trimEnd();
+  return {
+    sections,
+    preamble: preamble.trim(),
+    warnings
+  };
+}
+function getMergeSectionKey(kind, item) {
+  if (kind === "config")
+    return "config";
+  if (kind === "agent")
+    return item.frontmatter.name || item.name;
+  return item.name;
+}
+function buildMergeSectionContent(kind, sectionKey, convertedContent) {
+  if (kind === "config") {
+    return `## Config
+
+${convertedContent.trim()}
+`;
+  }
+  if (kind === "rule") {
+    return `## Rule: ${sectionKey}
+
+${convertedContent.trim()}
+`;
+  }
+  return convertedContent.trimEnd();
+}
+function getManagedSectionChecksumKey(kind, key) {
+  return `${kind}:${key}`;
+}
+function computeManagedSectionChecksums(content) {
+  const checksums = {};
+  for (const section of parseMergedSections(content).sections) {
+    if (section.kind === "unknown")
+      continue;
+    const normalizedContent = section.kind === "agent" ? section.content.trimEnd() : `${section.content.trimEnd()}
+`;
+    checksums[getManagedSectionChecksumKey(section.kind, section.key)] = computeContentChecksum(normalizedContent);
+  }
+  return checksums;
+}
+var SECTION_HEADING_PATTERNS;
+var init_merge_single_sections = __esm(() => {
+  init_checksum_utils();
+  SECTION_HEADING_PATTERNS = {
+    agent: /^##\s*agent\s*:\s*(.+?)\s*$/im,
+    rule: /^##\s*rule\s*:\s*(.+?)\s*$/im,
+    config: /^##\s*config\s*$/im
+  };
+});
+
 // src/commands/portable/portable-installer.ts
 import { existsSync as existsSync4 } from "node:fs";
 import { mkdir as mkdir3, readFile as readFile4, unlink as unlink3, writeFile as writeFile3 } from "node:fs/promises";
@@ -13315,146 +13513,6 @@ async function restoreFileSnapshots2(snapshots) {
     await restoreFileSnapshot2(snapshots[index]);
   }
 }
-function splitManagedContent(content) {
-  const lines = content.split(/\r?\n/);
-  let inFence = false;
-  let firstManagedIndex = -1;
-  const separatorIndices = [];
-  let currentLineIndex = 0;
-  for (let i = 0;i < lines.length; i++) {
-    const line = lines[i];
-    const trimmedLine = line.trim();
-    if (trimmedLine.startsWith("```") || trimmedLine.startsWith("~~~")) {
-      inFence = !inFence;
-    }
-    if (!inFence) {
-      const isManagedHeading = Object.values(SECTION_HEADING_PATTERNS).some((regex) => regex.test(trimmedLine));
-      if (isManagedHeading) {
-        if (firstManagedIndex === -1) {
-          firstManagedIndex = currentLineIndex;
-        }
-      }
-      if (/^[ \t]*---[ \t]*$/.test(trimmedLine)) {
-        separatorIndices.push(currentLineIndex);
-      }
-    }
-    currentLineIndex += line.length + 1;
-  }
-  if (firstManagedIndex === -1) {
-    return { preambleEnd: content.length, parts: [] };
-  }
-  const managedContent = content.slice(firstManagedIndex);
-  const managedStart = firstManagedIndex;
-  const parts = [];
-  let lastSplitPos = 0;
-  for (const sepIdx of separatorIndices) {
-    if (sepIdx >= managedStart) {
-      const relativeIdx = sepIdx - managedStart;
-      if (relativeIdx > lastSplitPos) {
-        const part = managedContent.slice(lastSplitPos, relativeIdx).trim();
-        if (part)
-          parts.push(part);
-      }
-      const sepLineEnd = managedContent.indexOf(`
-`, relativeIdx);
-      lastSplitPos = sepLineEnd >= 0 ? sepLineEnd + 1 : managedContent.length;
-    }
-  }
-  const finalPart = managedContent.slice(lastSplitPos).trim();
-  if (finalPart)
-    parts.push(finalPart);
-  return { preambleEnd: firstManagedIndex, parts };
-}
-function parseSectionMetadata(content) {
-  const agentMatch = content.match(SECTION_HEADING_PATTERNS.agent);
-  if (agentMatch) {
-    return { kind: "agent", key: agentMatch[1].trim() };
-  }
-  const ruleMatch = content.match(SECTION_HEADING_PATTERNS.rule);
-  if (ruleMatch) {
-    return { kind: "rule", key: ruleMatch[1].trim() };
-  }
-  if (SECTION_HEADING_PATTERNS.config.test(content)) {
-    return { kind: "config", key: "config" };
-  }
-  return null;
-}
-function parseMergedSections(content) {
-  const sections = [];
-  const warnings = [];
-  const { preambleEnd, parts } = splitManagedContent(content);
-  if (parts.length === 0) {
-    return {
-      sections,
-      preamble: content.trim(),
-      warnings
-    };
-  }
-  let unknownIndex = 0;
-  const seenKeys = new Map;
-  for (const part of parts) {
-    const trimmed = part.trim();
-    if (!trimmed)
-      continue;
-    const metadata = parseSectionMetadata(trimmed);
-    if (metadata) {
-      const compositeKey = `${metadata.kind}:${metadata.key}`;
-      const existingIndex = seenKeys.get(compositeKey);
-      if (existingIndex !== undefined) {
-        warnings.push(`Duplicate ${metadata.kind} section "${metadata.key}" in existing file; keeping last occurrence`);
-        sections.splice(existingIndex, 1);
-        for (const [key, idx] of seenKeys) {
-          if (idx > existingIndex) {
-            seenKeys.set(key, idx - 1);
-          }
-        }
-      }
-      const newIndex = sections.length;
-      sections.push({
-        kind: metadata.kind,
-        key: metadata.key,
-        content: trimmed
-      });
-      seenKeys.set(compositeKey, newIndex);
-      continue;
-    }
-    unknownIndex += 1;
-    sections.push({
-      kind: "unknown",
-      key: `unknown-${unknownIndex}`,
-      content: trimmed
-    });
-  }
-  let preamble = content.slice(0, preambleEnd).trimEnd();
-  preamble = preamble.replace(/^# Agents\r?\n\r?\n> Ported from Claude Code agents via ClaudeKit CLI \(ck agents\)\r?\n> Target: .*\r?\n+/is, "").replace(/^# Rules\r?\n\r?\n> Ported from Claude Code rules via ClaudeKit CLI \(ck migrate --rules\)\r?\n> Target: .*\r?\n+/is, "").replace(/^# Config\r?\n\r?\n> Ported from Claude Code config via ClaudeKit CLI.*\r?\n+/is, "").trimEnd();
-  return {
-    sections,
-    preamble: preamble.trim(),
-    warnings
-  };
-}
-function getMergeSectionKey(kind, item) {
-  if (kind === "config")
-    return "config";
-  if (kind === "agent")
-    return item.frontmatter.name || item.name;
-  return item.name;
-}
-function buildMergeSectionContent(kind, sectionKey, convertedContent) {
-  if (kind === "config") {
-    return `## Config
-
-${convertedContent.trim()}
-`;
-  }
-  if (kind === "rule") {
-    return `## Rule: ${sectionKey}
-
-${convertedContent.trim()}
-`;
-  }
-  return convertedContent.trimEnd();
-}
 function parseYamlModesFile(content) {
   const modes = new Map;
   const match = content.match(/customModes:\s*\n/);
@@ -14223,7 +14281,7 @@ async function installPortableItems(items, targetProviders, portableType, option
   }
   return results;
 }
-var import_proper_lockfile3, ClineCustomModeSchema, ClineCustomModesFileSchema, SECTION_HEADING_PATTERNS;
+var import_proper_lockfile3, ClineCustomModeSchema, ClineCustomModesFileSchema;
 var init_portable_installer = __esm(() => {
   init_zod();
   init_checksum_utils();
@@ -14231,6 +14289,7 @@ var init_portable_installer = __esm(() => {
   init_fm_to_json();
   init_fm_to_yaml();
   init_converters();
+  init_merge_single_sections();
   init_portable_registry();
   init_provider_registry();
   import_proper_lockfile3 = __toESM(require_proper_lockfile(), 1);
@@ -14244,11 +14303,6 @@ var init_portable_installer = __esm(() => {
   ClineCustomModesFileSchema = exports_external.object({
     customModes: exports_external.array(ClineCustomModeSchema).optional()
   });
-  SECTION_HEADING_PATTERNS = {
-    agent: /^##\s*agent\s*:\s*(.+?)\s*$/im,
-    rule: /^##\s*rule\s*:\s*(.+?)\s*$/im,
-    config: /^##\s*config\s*$/im
-  };
 });
 
 // src/commands/portable/types.ts
@@ -52006,6 +52060,161 @@ var init_portable_manifest = __esm(() => {
   }).passthrough();
 });
 
+// src/commands/portable/reconcile-registry-backfill.ts
+function shouldBackfillRegistry(action) {
+  return action.action === "skip" && action.backfillRegistry === true && typeof action.targetPath === "string" && action.targetPath.length > 0 && typeof action.sourceChecksum === "string" && !isUnknownChecksum(action.sourceChecksum) && typeof action.currentTargetChecksum === "string" && !isUnknownChecksum(action.currentTargetChecksum);
+}
+async function backfillRegistryChecksums(actions, registry) {
+  for (const action of actions) {
+    if (!shouldBackfillRegistry(action))
+      continue;
+    const registryEntry = registry.installations.find((entry) => entry.item === action.item && entry.type === action.type && entry.provider === action.provider && entry.global === action.global);
+    if (!registryEntry)
+      continue;
+    await addPortableInstallation(action.item, action.type, action.provider, action.global, action.targetPath, registryEntry.sourcePath, {
+      sourceChecksum: action.sourceChecksum,
+      targetChecksum: action.currentTargetChecksum,
+      ownedSections: registryEntry.ownedSections,
+      installSource: registryEntry.installSource === "manual" ? "manual" : "kit"
+    });
+  }
+}
+var init_reconcile_registry_backfill = __esm(() => {
+  init_portable_registry();
+});
+
+// src/commands/portable/reconcile-state-builders.ts
+import { existsSync as existsSync24 } from "node:fs";
+import { readFile as readFile18 } from "node:fs/promises";
+function getProviderPathKeyForPortableType2(type) {
+  switch (type) {
+    case "agent":
+      return "agents";
+    case "command":
+      return "commands";
+    case "skill":
+      return "skills";
+    case "config":
+      return "config";
+    case "rules":
+      return "rules";
+    case "hooks":
+      return "hooks";
+  }
+}
+function getProviderPathConfig(provider, type) {
+  return providers[provider]?.[getProviderPathKeyForPortableType2(type)] ?? null;
+}
+function usesMergeSingleChecksums(entry) {
+  const pathConfig = getProviderPathConfig(entry.provider, entry.type);
+  return pathConfig?.writeStrategy === "merge-single";
+}
+function buildTargetChecksum(item, type, provider, convertedContent) {
+  const pathConfig = getProviderPathConfig(provider, type);
+  if (!pathConfig) {
+    return computeContentChecksum(item.body);
+  }
+  if (pathConfig.writeStrategy === "yaml-merge" || pathConfig.writeStrategy === "json-merge") {
+    return;
+  }
+  if (pathConfig.writeStrategy !== "merge-single") {
+    return computeContentChecksum(convertedContent);
+  }
+  const sectionKind = type === "config" ? "config" : type === "rules" ? "rule" : type === "agent" ? "agent" : null;
+  if (!sectionKind) {
+    return;
+  }
+  const sectionKey = getMergeSectionKey(sectionKind, item);
+  return computeContentChecksum(buildMergeSectionContent(sectionKind, sectionKey, convertedContent));
+}
+function buildConvertedChecksums(item, type, selectedProviders, options2) {
+  const rawChecksum = computeContentChecksum(item.body);
+  const convertedChecksums = {};
+  for (const provider of selectedProviders) {
+    const pathConfig = getProviderPathConfig(provider, type);
+    if (!pathConfig) {
+      convertedChecksums[provider] = rawChecksum;
+      continue;
+    }
+    const result = convertItem(item, pathConfig.format, provider);
+    if (result.error) {
+      options2?.onConversionFallback?.({
+        item: item.name,
+        type,
+        provider,
+        format: pathConfig.format,
+        error: result.error
+      });
+      convertedChecksums[provider] = rawChecksum;
+      continue;
+    }
+    convertedChecksums[provider] = computeContentChecksum(result.content);
+  }
+  return convertedChecksums;
+}
+function buildSourceItemState(item, type, selectedProviders, options2) {
+  const rawChecksum = computeContentChecksum(item.body);
+  const convertedChecksums = buildConvertedChecksums(item, type, selectedProviders, options2);
+  const targetChecksums = {};
+  for (const provider of selectedProviders) {
+    const pathConfig = getProviderPathConfig(provider, type);
+    if (!pathConfig) {
+      targetChecksums[provider] = rawChecksum;
+      continue;
+    }
+    const result = convertItem(item, pathConfig.format, provider);
+    if (result.error) {
+      targetChecksums[provider] = rawChecksum;
+      continue;
+    }
+    const targetChecksum = buildTargetChecksum(item, type, provider, result.content);
+    if (targetChecksum) {
+      targetChecksums[provider] = targetChecksum;
+    }
+  }
+  return {
+    item: item.name,
+    type,
+    sourceChecksum: rawChecksum,
+    convertedChecksums,
+    targetChecksums
+  };
+}
+async function buildTargetStates(entries, options2) {
+  const targetStates = new Map;
+  const entriesByPath = new Map;
+  for (const entry of entries) {
+    if (entry.type === "skill")
+      continue;
+    const group = entriesByPath.get(entry.path) ?? [];
+    group.push(entry);
+    entriesByPath.set(entry.path, group);
+  }
+  for (const [entryPath, groupedEntries] of entriesByPath) {
+    const exists = existsSync24(entryPath);
+    const state = { path: entryPath, exists };
+    if (exists) {
+      try {
+        const content = await readFile18(entryPath, "utf-8");
+        state.currentChecksum = computeContentChecksum(content);
+        if (groupedEntries.some((entry) => usesMergeSingleChecksums(entry))) {
+          state.sectionChecksums = computeManagedSectionChecksums(content);
+        }
+      } catch (error) {
+        options2?.onReadFailure?.(entryPath, error);
+      }
+    }
+    targetStates.set(entryPath, state);
+  }
+  return targetStates;
+}
+var init_reconcile_state_builders = __esm(() => {
+  init_checksum_utils();
+  init_converters();
+  init_merge_single_sections();
+  init_provider_registry();
+});
+
 // src/commands/portable/reconciler.ts
 import path3 from "node:path";
 function normalizePortablePath(value) {
@@ -52085,12 +52294,39 @@ function buildTargetStateIndex(targetStates) {
 function lookupTargetState(targetStateIndex, pathValue) {
   return targetStateIndex.get(normalizePortablePath(pathValue));
 }
-function getTargetChangeState(targetState, registeredTargetChecksum) {
+function getManagedSectionKind(type) {
+  if (type === "agent")
+    return "agent";
+  if (type === "rules")
+    return "rule";
+  if (type === "config")
+    return "config";
+  return null;
+}
+function getExpectedTargetChecksum(source, provider) {
+  return normalizeChecksum(source.targetChecksums?.[provider] ?? source.convertedChecksums[provider]);
+}
+function getCurrentTargetChecksum(targetState, registryEntry) {
+  if (!targetState)
+    return UNKNOWN_CHECKSUM;
+  if (!targetState.exists)
+    return UNKNOWN_CHECKSUM;
+  if (targetState.sectionChecksums && registryEntry.ownedSections?.length) {
+    const sectionKind = getManagedSectionKind(registryEntry.type);
+    const sectionName = registryEntry.ownedSections[0];
+    if (sectionKind && sectionName) {
+      return normalizeChecksum(targetState.sectionChecksums[`${sectionKind}:${sectionName}`]);
+    }
+    return UNKNOWN_CHECKSUM;
+  }
+  return normalizeChecksum(targetState.currentChecksum);
+}
+function getTargetChangeState(targetState, registryEntry, registeredTargetChecksum) {
   if (!targetState)
     return "unknown";
   if (!targetState.exists)
     return "deleted";
-  const currentTargetChecksum = normalizeChecksum(targetState.currentChecksum);
+  const currentTargetChecksum = getCurrentTargetChecksum(targetState, registryEntry);
   if (isUnknownChecksum(currentTargetChecksum) || isUnknownChecksum(registeredTargetChecksum)) {
     return "unknown";
   }
@@ -52189,6 +52425,7 @@ function determineAction(source, providerConfig, input, targetStateIndex, delete
   };
   const convertedChecksumRaw = source.convertedChecksums[providerConfig.provider];
   const convertedChecksum = normalizeChecksum(convertedChecksumRaw);
+  const expectedTargetChecksum = getExpectedTargetChecksum(source, providerConfig.provider);
   if (!convertedChecksumRaw || isUnknownChecksum(convertedChecksumRaw)) {
     if (registryEntry) {
       common.targetPath = registryEntry.path;
@@ -52222,19 +52459,21 @@ function determineAction(source, providerConfig, input, targetStateIndex, delete
   common.targetPath = registryEntry.path;
   const registeredSourceChecksum = normalizeChecksum(registryEntry.sourceChecksum);
   const registeredTargetChecksum = normalizeChecksum(registryEntry.targetChecksum);
+  const targetState = lookupTargetState(targetStateIndex, registryEntry.path);
+  const currentTargetChecksum = getCurrentTargetChecksum(targetState, registryEntry);
+  const targetMatchesExpectedOutput = targetState?.exists === true && !isUnknownChecksum(expectedTargetChecksum) && currentTargetChecksum === expectedTargetChecksum;
   if (isUnknownChecksum(registeredSourceChecksum)) {
-    const targetState2 = lookupTargetState(targetStateIndex, registryEntry.path);
-    const currentTargetChecksum = normalizeChecksum(targetState2?.currentChecksum);
-    if (currentTargetChecksum === convertedChecksum) {
+    if (targetMatchesExpectedOutput) {
       return {
         ...common,
         action: "skip",
         reason: "Target up-to-date after registry upgrade — checksums will be backfilled",
         sourceChecksum: convertedChecksum,
-        currentTargetChecksum
+        currentTargetChecksum,
+        backfillRegistry: true
       };
     }
-    if (!targetState2 || !targetState2.exists) {
+    if (!targetState || !targetState.exists) {
       return {
         ...common,
         action: "install",
@@ -52250,9 +52489,20 @@ function determineAction(source, providerConfig, input, targetStateIndex, delete
       currentTargetChecksum
     };
   }
+  if (targetMatchesExpectedOutput && (convertedChecksum !== registeredSourceChecksum || currentTargetChecksum !== registeredTargetChecksum)) {
+    return {
+      ...common,
+      action: "skip",
+      reason: "Target up-to-date — registry checksums will be backfilled",
+      sourceChecksum: convertedChecksum,
+      registeredSourceChecksum,
+      currentTargetChecksum,
+      registeredTargetChecksum,
+      backfillRegistry: true
+    };
+  }
   const sourceChanged = convertedChecksum !== registeredSourceChecksum;
-  const targetState = lookupTargetState(targetStateIndex, registryEntry.path);
-  const targetChangeState = getTargetChangeState(targetState, registeredTargetChecksum);
+  const targetChangeState = getTargetChangeState(targetState, registryEntry, registeredTargetChecksum);
   if (targetChangeState === "deleted") {
     const forceReinstall = input.force && !sourceChanged;
     return {
@@ -52270,7 +52520,7 @@ function determineAction(source, providerConfig, input, targetStateIndex, delete
       reason: sourceChanged ? "Target state unavailable while CK changed — manual review required" : "Target state unavailable, CK unchanged — preserving target",
       sourceChecksum: convertedChecksum,
       registeredSourceChecksum,
-      currentTargetChecksum: normalizeChecksum(targetState?.currentChecksum),
+      currentTargetChecksum,
       registeredTargetChecksum
     };
   }
@@ -52281,7 +52531,7 @@ function determineAction(source, providerConfig, input, targetStateIndex, delete
       action: "skip",
       reason: "No changes",
       sourceChecksum: convertedChecksum,
-      currentTargetChecksum: normalizeChecksum(targetState?.currentChecksum)
+      currentTargetChecksum
     };
   }
   if (!sourceChanged && targetChanged) {
@@ -52291,7 +52541,7 @@ function determineAction(source, providerConfig, input, targetStateIndex, delete
       reason: input.force ? "Force overwrite (user edits)" : "User edited, CK unchanged — preserving edits",
       sourceChecksum: convertedChecksum,
       registeredSourceChecksum,
-      currentTargetChecksum: normalizeChecksum(targetState?.currentChecksum),
+      currentTargetChecksum,
       registeredTargetChecksum
     };
   }
@@ -52302,7 +52552,7 @@ function determineAction(source, providerConfig, input, targetStateIndex, delete
       reason: "CK updated, no user edits — safe overwrite",
       sourceChecksum: convertedChecksum,
       registeredSourceChecksum,
-      currentTargetChecksum: normalizeChecksum(targetState?.currentChecksum),
+      currentTargetChecksum,
       registeredTargetChecksum
     };
   }
@@ -52312,7 +52562,7 @@ function determineAction(source, providerConfig, input, targetStateIndex, delete
     reason: "Both CK and user modified this item",
     sourceChecksum: convertedChecksum,
     registeredSourceChecksum,
-    currentTargetChecksum: normalizeChecksum(targetState?.currentChecksum),
+    currentTargetChecksum,
     registeredTargetChecksum
   };
 }
@@ -52431,8 +52681,8 @@ var init_reconciler = __esm(() => {
 });
 
 // src/commands/skills/skills-discovery.ts
-import { existsSync as existsSync24 } from "node:fs";
-import { readFile as readFile18, readdir as readdir8, stat as stat6 } from "node:fs/promises";
+import { existsSync as existsSync25 } from "node:fs";
+import { readFile as readFile19, readdir as readdir8, stat as stat6 } from "node:fs/promises";
 import { homedir as homedir20 } from "node:os";
 import { dirname as dirname10, join as join33 } from "node:path";
 function getSkillSourcePath() {
@@ -52441,12 +52691,12 @@ function getSkillSourcePath() {
     join33(process.cwd(), ".claude/skills")
   ];
   for (const path4 of bundledPaths) {
-    if (existsSync24(path4)) {
+    if (existsSync25(path4)) {
       return path4;
     }
   }
   const globalSkillsPath = join33(home5, ".claude/skills");
-  if (existsSync24(globalSkillsPath)) {
+  if (existsSync25(globalSkillsPath)) {
     return globalSkillsPath;
   }
   return null;
@@ -52462,7 +52712,7 @@ async function hasSkillMd(dir) {
 }
 async function parseSkillMd(skillMdPath) {
   try {
-    const content = await readFile18(skillMdPath, "utf-8");
+    const content = await readFile19(skillMdPath, "utf-8");
     const { data } = import_gray_matter5.default(content);
     const skillDir = dirname10(skillMdPath);
     const dirName = skillDir.split(/[/\\]/).pop() || "";
@@ -52622,8 +52872,8 @@ var init_migration_result_utils = __esm(() => {
 });
 
 // src/domains/web-server/routes/migration-routes.ts
-import { existsSync as existsSync25 } from "node:fs";
-import { readFile as readFile19, rm as rm6 } from "node:fs/promises";
+import { existsSync as existsSync26 } from "node:fs";
+import { readFile as readFile20, rm as rm6 } from "node:fs/promises";
 import { homedir as homedir21 } from "node:os";
 import { basename as basename9, join as join34, resolve as resolve8 } from "node:path";
 function isDisallowedControlCode(codePoint) {
@@ -52857,7 +53107,7 @@ async function executePlanDeleteAction(action, options2) {
   const preservePaths = options2?.preservePaths ?? new Set;
   const shouldPreserveTarget = action.targetPath.length > 0 && preservePaths.has(resolve8(action.targetPath));
   try {
-    if (!shouldPreserveTarget && action.targetPath && existsSync25(action.targetPath)) {
+    if (!shouldPreserveTarget && action.targetPath && existsSync26(action.targetPath)) {
       await rm6(action.targetPath, { recursive: true, force: true });
     }
     await removePortableInstallation(action.item, action.type, action.provider, action.global);
@@ -53106,6 +53356,9 @@ function recordHookRegistrationOutcome(provider, mergeResult, warnings, feedback
     feedbackResults.push(feedback);
   }
 }
+function warnConversionFallback(warning) {
+  console.warn(`[migrate] Falling back to raw checksum for ${sanitizeUntrusted(warning.provider)} ${sanitizeUntrusted(warning.type)} "${sanitizeUntrusted(warning.item, 80)}" because ${sanitizeUntrusted(warning.format)} conversion failed: ${sanitizeUntrusted(warning.error, 260)}`);
+}
 async function discoverMigrationItems(include, configSource) {
   const agentsSource = include.agents ? getAgentSourcePath() : null;
   const commandsSource = include.commands ? getCommandSourcePath() : null;
@@ -53263,36 +53516,18 @@ function registerMigrationRoutes(app) {
       const sourceItems = [];
       for (const agent of discovered.agents) {
         try {
-          const content = await readFile19(agent.sourcePath, "utf-8");
-          const sourceChecksum = computeContentChecksum(content);
-          const convertedChecksums = {};
-          for (const provider of selectedProviders) {
-            convertedChecksums[provider] = sourceChecksum;
-          }
-          sourceItems.push({
-            item: agent.name,
-            type: "agent",
-            sourceChecksum,
-            convertedChecksums
-          });
+          sourceItems.push(buildSourceItemState(agent, "agent", selectedProviders, {
+            onConversionFallback: warnConversionFallback
+          }));
         } catch (error) {
           warnReadFailure("agent", agent.name, error);
         }
       }
       for (const command of discovered.commands) {
         try {
-          const content = await readFile19(command.sourcePath, "utf-8");
-          const sourceChecksum = computeContentChecksum(content);
-          const convertedChecksums = {};
-          for (const provider of selectedProviders) {
-            convertedChecksums[provider] = sourceChecksum;
-          }
-          sourceItems.push({
-            item: command.name,
-            type: "command",
-            sourceChecksum,
-            convertedChecksums
-          });
+          sourceItems.push(buildSourceItemState(command, "command", selectedProviders, {
+            onConversionFallback: warnConversionFallback
+          }));
         } catch (error) {
           warnReadFailure("command", command.name, error);
         }
@@ -53302,24 +53537,25 @@ function registerMigrationRoutes(app) {
           const skillMdPath = `${skill.path}/SKILL.md`;
           const readmePath = `${skill.path}/README.md`;
           let content;
-          if (existsSync25(skillMdPath)) {
-            content = await readFile19(skillMdPath, "utf-8");
-          } else if (existsSync25(readmePath)) {
-            content = await readFile19(readmePath, "utf-8");
+          if (existsSync26(skillMdPath)) {
+            content = await readFile20(skillMdPath, "utf-8");
+          } else if (existsSync26(readmePath)) {
+            content = await readFile20(readmePath, "utf-8");
           } else {
             console.warn(`[migrate] Skill "${sanitizeUntrusted(skill.name, 80)}" has neither SKILL.md nor README.md, skipping`);
             continue;
           }
-          const sourceChecksum = computeContentChecksum(content);
-          const convertedChecksums = {};
-          for (const provider of selectedProviders) {
-            convertedChecksums[provider] = sourceChecksum;
-          }
           sourceItems.push({
-            item: skill.name,
-            type: "skill",
-            sourceChecksum,
-            convertedChecksums
+            ...buildSourceItemState({
+              name: skill.name,
+              description: skill.description,
+              type: "skill",
+              sourcePath: skill.path,
+              frontmatter: {},
+              body: content
+            }, "skill", selectedProviders, {
+              onConversionFallback: warnConversionFallback
+            })
           });
         } catch (error) {
           warnReadFailure("skill", skill.name, error);
@@ -53327,75 +53563,35 @@ function registerMigrationRoutes(app) {
       }
       if (discovered.configItem) {
         try {
-          const content = await readFile19(discovered.configItem.sourcePath, "utf-8");
-          const sourceChecksum = computeContentChecksum(content);
-          const convertedChecksums = {};
-          for (const provider of selectedProviders) {
-            convertedChecksums[provider] = sourceChecksum;
-          }
-          sourceItems.push({
-            item: discovered.configItem.name,
-            type: "config",
-            sourceChecksum,
-            convertedChecksums
-          });
+          sourceItems.push(buildSourceItemState(discovered.configItem, "config", selectedProviders, {
+            onConversionFallback: warnConversionFallback
+          }));
         } catch (error) {
           warnReadFailure("config", "CLAUDE.md", error);
         }
       }
       for (const rule of discovered.ruleItems) {
         try {
-          const content = await readFile19(rule.sourcePath, "utf-8");
-          const sourceChecksum = computeContentChecksum(content);
-          const convertedChecksums = {};
-          for (const provider of selectedProviders) {
-            convertedChecksums[provider] = sourceChecksum;
-          }
-          sourceItems.push({
-            item: rule.name,
-            type: "rules",
-            sourceChecksum,
-            convertedChecksums
-          });
+          sourceItems.push(buildSourceItemState(rule, "rules", selectedProviders, {
+            onConversionFallback: warnConversionFallback
+          }));
         } catch (error) {
           warnReadFailure("rule", rule.name, error);
         }
       }
       for (const hook of discovered.hookItems) {
         try {
-          const content = await readFile19(hook.sourcePath, "utf-8");
-          const sourceChecksum = computeContentChecksum(content);
-          const convertedChecksums = {};
-          for (const provider of selectedProviders) {
-            convertedChecksums[provider] = sourceChecksum;
-          }
-          sourceItems.push({
-            item: hook.name,
-            type: "hooks",
-            sourceChecksum,
-            convertedChecksums
-          });
+          sourceItems.push(buildSourceItemState(hook, "hooks", selectedProviders, {
+            onConversionFallback: warnConversionFallback
+          }));
         } catch (error) {
           warnReadFailure("hook", hook.name, error);
         }
       }
       const registry = await readPortableRegistry();
-      const targetStates = new Map;
-      for (const entry of registry.installations) {
-        if (entry.type === "skill")
-          continue;
-        const exists = existsSync25(entry.path);
-        const state = { path: entry.path, exists };
-        if (exists) {
-          try {
-            const content = await readFile19(entry.path, "utf-8");
-            state.currentChecksum = computeContentChecksum(content);
-          } catch (error) {
-            warnReadFailure("registry-target", entry.path, error);
-          }
-        }
-        targetStates.set(entry.path, state);
-      }
+      const targetStates = await buildTargetStates(registry.installations, {
+        onReadFailure: (entryPath, error) => warnReadFailure("registry-target", entryPath, error)
+      });
       const manifest = discovered.sourcePaths.agents ? await loadPortableManifest(discovered.sourcePaths.agents) : null;
       const providerConfigs = selectedProviders.map((provider) => ({
         provider,
@@ -53597,6 +53793,10 @@ function registerMigrationRoutes(app) {
           deleteResult.itemName = deleteAction.item;
           allResults.push(deleteResult);
         }
+        try {
+          const registry = await readPortableRegistry();
+          await backfillRegistryChecksums(plan.actions, registry);
+        } catch {}
         for (const provider of allPlanProviders) {
           if (providers[provider]?.agents?.writeStrategy !== "codex-toml")
             continue;
@@ -53822,7 +54022,6 @@ var init_migration_routes = __esm(() => {
   init_agents_discovery();
   init_commands_discovery();
   init_skill_directory_installer();
-  init_checksum_utils();
   init_codex_toml_installer();
   init_config_discovery();
   init_hooks_settings_merger();
@@ -53830,6 +54029,8 @@ var init_migration_routes = __esm(() => {
   init_portable_manifest();
   init_portable_registry();
   init_provider_registry();
+  init_reconcile_registry_backfill();
+  init_reconcile_state_builders();
   init_reconciler();
   init_types2();
   init_skills_discovery();
@@ -54274,13 +54475,13 @@ var init_plan_table_parser = __esm(() => {
 });
 
 // src/domains/plan-parser/plan-scanner.ts
-import { existsSync as existsSync26, readdirSync as readdirSync3 } from "node:fs";
+import { existsSync as existsSync27, readdirSync as readdirSync3 } from "node:fs";
 import { join as join35 } from "node:path";
 function scanPlanDir(dir) {
-  if (!existsSync26(dir))
+  if (!existsSync27(dir))
     return [];
   try {
-    return readdirSync3(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join35(dir, entry.name, "plan.md")).filter(existsSync26);
+    return readdirSync3(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join35(dir, entry.name, "plan.md")).filter(existsSync27);
   } catch {
     return [];
   }
@@ -54288,7 +54489,7 @@ function scanPlanDir(dir) {
 var init_plan_scanner = () => {};
 
 // src/domains/plan-parser/plan-validator.ts
-import { existsSync as existsSync27, readFileSync as readFileSync6 } from "node:fs";
+import { existsSync as existsSync28, readFileSync as readFileSync6 } from "node:fs";
 import { basename as basename10, dirname as dirname12 } from "node:path";
 function validatePlanFile(filePath, strict = false) {
   const content = readFileSync6(filePath, "utf8");
@@ -54328,7 +54529,7 @@ function validatePlanFile(filePath, strict = false) {
     });
   }
   for (const phase of phases) {
-    if (phase.file && !existsSync27(phase.file)) {
+    if (phase.file && !existsSync28(phase.file)) {
       const fileBasename = basename10(phase.file);
       const refLine = lines.findIndex((l2) => l2.includes(fileBasename));
       issues.push({
@@ -54354,7 +54555,7 @@ var init_plan_validator = __esm(() => {
 
 // src/domains/plan-parser/plan-writer.ts
 import { mkdirSync as mkdirSync2, readFileSync as readFileSync7, writeFileSync as writeFileSync3 } from "node:fs";
-import { existsSync as existsSync28 } from "node:fs";
+import { existsSync as existsSync29 } from "node:fs";
 import { basename as basename11, dirname as dirname13, join as join36 } from "node:path";
 function phaseNameToFilename(id, name) {
   const numMatch = /^(\d+)([a-z]*)$/i.exec(id);
@@ -54536,7 +54737,7 @@ function updatePhaseStatus(planFile, phaseId, newStatus) {
   writeFileSync3(planFile, updatedContent, "utf8");
   const planDir = dirname13(planFile);
   const phaseFilename = phaseNameFilenameFromTableRow(updatedBody, phaseId, planDir);
-  if (phaseFilename && existsSync28(phaseFilename)) {
+  if (phaseFilename && existsSync29(phaseFilename)) {
     updatePhaseFileFrontmatter(phaseFilename, newStatus);
   }
 }
@@ -54667,7 +54868,7 @@ var init_plan_parser = __esm(() => {
 });
 
 // src/domains/web-server/routes/plan-routes.ts
-import { existsSync as existsSync29, realpathSync } from "node:fs";
+import { existsSync as existsSync30, realpathSync } from "node:fs";
 import { basename as basename12, dirname as dirname15, relative as relative6, resolve as resolve10, sep as sep4 } from "node:path";
 function isWithinCwd(filePath) {
   const cwd2 = process.cwd();
@@ -54675,7 +54876,7 @@ function isWithinCwd(filePath) {
   const cwdPrefix = cwd2.endsWith(sep4) ? cwd2 : `${cwd2}${sep4}`;
   if (!resolved.startsWith(cwdPrefix) && resolved !== cwd2)
     return false;
-  if (existsSync29(resolved)) {
+  if (existsSync30(resolved)) {
     try {
       const real = realpathSync(resolved);
       return real.startsWith(cwdPrefix) || real === cwd2;
@@ -54706,7 +54907,7 @@ function registerPlanRoutes(app) {
       res.status(403).json({ error: "Path must be within current working directory" });
       return;
     }
-    if (!existsSync29(file)) {
+    if (!existsSync30(file)) {
       res.status(404).json({ error: "File not found" });
       return;
     }
@@ -54728,7 +54929,7 @@ function registerPlanRoutes(app) {
       res.status(403).json({ error: "Path must be within current working directory" });
       return;
     }
-    if (!existsSync29(file)) {
+    if (!existsSync30(file)) {
       res.status(404).json({ error: "File not found" });
       return;
     }
@@ -54749,7 +54950,7 @@ function registerPlanRoutes(app) {
       res.status(403).json({ error: "Path must be within current working directory" });
       return;
     }
-    if (!existsSync29(dir)) {
+    if (!existsSync30(dir)) {
       res.status(404).json({ error: "Directory not found" });
       return;
     }
@@ -54774,7 +54975,7 @@ function registerPlanRoutes(app) {
       res.status(403).json({ error: "Path must be within current working directory" });
       return;
     }
-    if (!existsSync29(file)) {
+    if (!existsSync30(file)) {
       res.status(404).json({ error: "File not found" });
       return;
     }
@@ -54791,8 +54992,8 @@ var init_plan_routes = __esm(() => {
 });
 
 // src/domains/web-server/routes/project-routes.ts
-import { existsSync as existsSync30 } from "node:fs";
-import { readFile as readFile20 } from "node:fs/promises";
+import { existsSync as existsSync31 } from "node:fs";
+import { readFile as readFile21 } from "node:fs/promises";
 import { homedir as homedir22 } from "node:os";
 import { basename as basename13, join as join37, resolve as resolve11 } from "node:path";
 function registerProjectRoutes(app) {
@@ -54911,7 +55112,7 @@ function registerProjectRoutes(app) {
         res.status(400).json({ error: "Invalid path after expansion" });
         return;
       }
-      if (!existsSync30(projectPath)) {
+      if (!existsSync31(projectPath)) {
         res.status(400).json({ error: `Directory does not exist: ${projectPath}` });
         return;
       }
@@ -55027,14 +55228,14 @@ function registerProjectRoutes(app) {
 async function buildProjectInfoFromRegistry(registered) {
   const claudeDir2 = join37(registered.path, ".claude");
   const metadataPath = join37(claudeDir2, "metadata.json");
-  if (!existsSync30(registered.path)) {
+  if (!existsSync31(registered.path)) {
     return null;
   }
-  const hasClaudeDir = existsSync30(claudeDir2);
+  const hasClaudeDir = existsSync31(claudeDir2);
   let metadata = {};
   try {
-    if (hasClaudeDir && existsSync30(metadataPath)) {
-      const content = await readFile20(metadataPath, "utf-8");
+    if (hasClaudeDir && existsSync31(metadataPath)) {
+      const content = await readFile21(metadataPath, "utf-8");
       try {
         metadata = JSON.parse(content);
       } catch {}
@@ -55044,7 +55245,7 @@ async function buildProjectInfoFromRegistry(registered) {
   const settings = await readSettings();
   const skills = await scanSkills();
   const settingsPath = join37(homedir22(), ".claude", "settings.json");
-  const health = existsSync30(settingsPath) ? "healthy" : "warning";
+  const health = existsSync31(settingsPath) ? "healthy" : "warning";
   const model = getCurrentModel() || settings?.model || "claude-sonnet-4";
   return {
     id: registered.id,
@@ -55068,15 +55269,15 @@ async function buildProjectInfoFromRegistry(registered) {
 async function detectAndBuildProjectInfo(path4, id) {
   const claudeDir2 = id === "global" ? path4 : join37(path4, ".claude");
   const metadataPath = join37(claudeDir2, "metadata.json");
-  if (!existsSync30(metadataPath)) {
-    if (!existsSync30(claudeDir2)) {
+  if (!existsSync31(metadataPath)) {
+    if (!existsSync31(claudeDir2)) {
       return null;
     }
   }
   let metadata = {};
   try {
-    if (existsSync30(metadataPath)) {
-      const content = await readFile20(metadataPath, "utf-8");
+    if (existsSync31(metadataPath)) {
+      const content = await readFile21(metadataPath, "utf-8");
       try {
         metadata = JSON.parse(content);
       } catch {}
@@ -55086,7 +55287,7 @@ async function detectAndBuildProjectInfo(path4, id) {
   const settings = await readSettings();
   const skills = await scanSkills();
   const settingsPath = join37(homedir22(), ".claude", "settings.json");
-  const health = existsSync30(settingsPath) ? "healthy" : "warning";
+  const health = existsSync31(settingsPath) ? "healthy" : "warning";
   const model = getCurrentModel() || settings?.model || "claude-sonnet-4";
   return {
     id,
@@ -55279,7 +55480,7 @@ var init_settings_routes = __esm(() => {
 });
 
 // src/commands/skills/agents.ts
-import { existsSync as existsSync31 } from "node:fs";
+import { existsSync as existsSync32 } from "node:fs";
 import { homedir as homedir25 } from "node:os";
 import { join as join39 } from "node:path";
 async function detectInstalledAgents() {
@@ -55301,7 +55502,7 @@ function getInstallPath(skillName, agent, options2) {
 }
 function isSkillInstalled(skillName, agent, options2) {
   const installPath = getInstallPath(skillName, agent, options2);
-  return existsSync31(installPath);
+  return existsSync32(installPath);
 }
 var home6, agents;
 var init_agents = __esm(() => {
@@ -55312,105 +55513,105 @@ var init_agents = __esm(() => {
       displayName: "Claude Code",
       projectPath: ".claude/skills",
       globalPath: join39(home6, ".claude/skills"),
-      detect: async () => existsSync31(join39(home6, ".claude"))
+      detect: async () => existsSync32(join39(home6, ".claude"))
     },
     cursor: {
       name: "cursor",
       displayName: "Cursor",
       projectPath: ".cursor/skills",
       globalPath: join39(home6, ".cursor/skills"),
-      detect: async () => existsSync31(join39(home6, ".cursor"))
+      detect: async () => existsSync32(join39(home6, ".cursor"))
     },
     codex: {
       name: "codex",
       displayName: "Codex",
       projectPath: ".codex/skills",
       globalPath: join39(home6, ".codex/skills"),
-      detect: async () => existsSync31(join39(home6, ".codex"))
+      detect: async () => existsSync32(join39(home6, ".codex"))
     },
     opencode: {
       name: "opencode",
       displayName: "OpenCode",
       projectPath: ".opencode/skills",
       globalPath: join39(home6, ".config/opencode/skills"),
-      detect: async () => existsSync31(join39(home6, ".config/opencode"))
+      detect: async () => existsSync32(join39(home6, ".config/opencode"))
     },
     goose: {
       name: "goose",
       displayName: "Goose",
       projectPath: ".goose/skills",
       globalPath: join39(home6, ".config/goose/skills"),
-      detect: async () => existsSync31(join39(home6, ".config/goose"))
+      detect: async () => existsSync32(join39(home6, ".config/goose"))
     },
     "gemini-cli": {
       name: "gemini-cli",
       displayName: "Gemini CLI",
       projectPath: ".gemini/skills",
       globalPath: join39(home6, ".gemini/skills"),
-      detect: async () => existsSync31(join39(home6, ".gemini"))
+      detect: async () => existsSync32(join39(home6, ".gemini"))
     },
     antigravity: {
       name: "antigravity",
       displayName: "Antigravity",
       projectPath: ".agent/skills",
       globalPath: join39(home6, ".gemini/antigravity/skills"),
-      detect: async () => existsSync31(join39(process.cwd(), ".agent")) || existsSync31(join39(home6, ".gemini/antigravity"))
+      detect: async () => existsSync32(join39(process.cwd(), ".agent")) || existsSync32(join39(home6, ".gemini/antigravity"))
     },
     "github-copilot": {
       name: "github-copilot",
       displayName: "GitHub Copilot",
       projectPath: ".github/skills",
       globalPath: join39(home6, ".copilot/skills"),
-      detect: async () => existsSync31(join39(home6, ".copilot"))
+      detect: async () => existsSync32(join39(home6, ".copilot"))
     },
     amp: {
       name: "amp",
       displayName: "Amp",
       projectPath: ".agents/skills",
       globalPath: join39(home6, ".config/agents/skills"),
-      detect: async () => existsSync31(join39(home6, ".config/amp"))
+      detect: async () => existsSync32(join39(home6, ".config/amp"))
     },
     kilo: {
       name: "kilo",
       displayName: "Kilo Code",
       projectPath: ".kilocode/skills",
       globalPath: join39(home6, ".kilocode/skills"),
-      detect: async () => existsSync31(join39(home6, ".kilocode"))
+      detect: async () => existsSync32(join39(home6, ".kilocode"))
     },
     roo: {
       name: "roo",
       displayName: "Roo Code",
       projectPath: ".roo/skills",
       globalPath: join39(home6, ".roo/skills"),
-      detect: async () => existsSync31(join39(home6, ".roo"))
+      detect: async () => existsSync32(join39(home6, ".roo"))
     },
     windsurf: {
       name: "windsurf",
       displayName: "Windsurf",
       projectPath: ".windsurf/skills",
       globalPath: join39(home6, ".codeium/windsurf/skills"),
-      detect: async () => existsSync31(join39(home6, ".codeium/windsurf"))
+      detect: async () => existsSync32(join39(home6, ".codeium/windsurf"))
     },
     cline: {
       name: "cline",
       displayName: "Cline",
       projectPath: ".cline/skills",
       globalPath: join39(home6, ".cline/skills"),
-      detect: async () => existsSync31(join39(home6, ".cline"))
+      detect: async () => existsSync32(join39(home6, ".cline"))
     },
     openhands: {
       name: "openhands",
       displayName: "OpenHands",
       projectPath: ".openhands/skills",
       globalPath: join39(home6, ".openhands/skills"),
-      detect: async () => existsSync31(join39(home6, ".openhands"))
+      detect: async () => existsSync32(join39(home6, ".openhands"))
     }
   };
 });
 
 // src/commands/skills/skills-registry.ts
-import { existsSync as existsSync32 } from "node:fs";
-import { mkdir as mkdir9, readFile as readFile21, writeFile as writeFile11 } from "node:fs/promises";
+import { existsSync as existsSync33 } from "node:fs";
+import { mkdir as mkdir9, readFile as readFile22, writeFile as writeFile11 } from "node:fs/promises";
 import { homedir as homedir26 } from "node:os";
 import { dirname as dirname16, join as join40 } from "node:path";
 function getCliVersion3() {
@@ -55431,10 +55632,10 @@ function getCliVersion3() {
 }
 async function readRegistry() {
   try {
-    if (!existsSync32(REGISTRY_PATH2)) {
+    if (!existsSync33(REGISTRY_PATH2)) {
       return { version: "1.0", installations: [] };
     }
-    const content = await readFile21(REGISTRY_PATH2, "utf-8");
+    const content = await readFile22(REGISTRY_PATH2, "utf-8");
     const data = JSON.parse(content);
     return SkillRegistrySchema.parse(data);
   } catch (error) {
@@ -55446,7 +55647,7 @@ async function readRegistry() {
 }
 async function writeRegistry(registry) {
   const dir = dirname16(REGISTRY_PATH2);
-  if (!existsSync32(dir)) {
+  if (!existsSync33(dir)) {
     await mkdir9(dir, { recursive: true });
   }
   await writeFile11(REGISTRY_PATH2, JSON.stringify(registry, null, 2), "utf-8");
@@ -55490,7 +55691,7 @@ async function syncRegistry() {
   const registry = await readRegistry();
   const removed = [];
   registry.installations = registry.installations.filter((i) => {
-    if (!existsSync32(i.path)) {
+    if (!existsSync33(i.path)) {
       removed.push(i);
       return false;
     }
@@ -55522,7 +55723,7 @@ var init_skills_registry = __esm(() => {
 });
 
 // src/commands/skills/skills-installer.ts
-import { existsSync as existsSync33 } from "node:fs";
+import { existsSync as existsSync34 } from "node:fs";
 import { cp as cp2, mkdir as mkdir10, stat as stat7 } from "node:fs/promises";
 import { dirname as dirname17, resolve as resolve12 } from "node:path";
 function isSamePath2(path1, path22) {
@@ -55567,10 +55768,10 @@ async function installSkillForAgent(skill, agent, options2) {
   }
   try {
     const parentDir = dirname17(targetPath);
-    if (!existsSync33(parentDir)) {
+    if (!existsSync34(parentDir)) {
       await mkdir10(parentDir, { recursive: true });
     }
-    if (existsSync33(targetPath)) {
+    if (existsSync34(targetPath)) {
       const stats = await stat7(targetPath);
       if (stats.isFile()) {
         return {
@@ -55626,7 +55827,7 @@ var init_skills_installer = __esm(() => {
 });
 
 // src/commands/skills/skills-uninstaller.ts
-import { existsSync as existsSync34 } from "node:fs";
+import { existsSync as existsSync35 } from "node:fs";
 import { rm as rm7 } from "node:fs/promises";
 import { join as join41 } from "node:path";
 async function uninstallSkillFromAgent(skill, agent, global3) {
@@ -55646,7 +55847,7 @@ async function uninstallSkillFromAgent(skill, agent, global3) {
   }
   const installation = installations[0];
   const path4 = installation.path;
-  const fileExists = existsSync34(path4);
+  const fileExists = existsSync35(path4);
   try {
     if (fileExists) {
       await rm7(path4, { recursive: true, force: true });
@@ -55677,7 +55878,7 @@ async function forceUninstallSkill(skill, agent, global3) {
   const agentConfig = agents[agent];
   const basePath = global3 ? agentConfig.globalPath : agentConfig.projectPath;
   const path4 = join41(basePath, skill);
-  if (!existsSync34(path4)) {
+  if (!existsSync35(path4)) {
     return {
       skill,
       agent,
@@ -56217,8 +56418,8 @@ var init_pnpm_detector = __esm(() => {
 });
 
 // src/domains/installation/package-managers/detection-core.ts
-import { existsSync as existsSync35, realpathSync as realpathSync2 } from "node:fs";
-import { chmod as chmod2, mkdir as mkdir11, readFile as readFile22, writeFile as writeFile12 } from "node:fs/promises";
+import { existsSync as existsSync36, realpathSync as realpathSync2 } from "node:fs";
+import { chmod as chmod2, mkdir as mkdir11, readFile as readFile23, writeFile as writeFile12 } from "node:fs/promises";
 import { platform as platform4 } from "node:os";
 import { join as join42 } from "node:path";
 function detectFromBinaryPath() {
@@ -56298,10 +56499,10 @@ function detectFromEnv() {
 async function readCachedPm() {
   try {
     const cacheFile = join42(PathResolver.getConfigDir(false), CACHE_FILE);
-    if (!existsSync35(cacheFile)) {
+    if (!existsSync36(cacheFile)) {
       return null;
     }
-    const content = await readFile22(cacheFile, "utf-8");
+    const content = await readFile23(cacheFile, "utf-8");
     const data = JSON.parse(content);
     if (!data.packageManager || !data.detectedAt) {
       logger.debug("Invalid cache structure, ignoring");
@@ -56329,7 +56530,7 @@ async function saveCachedPm(pm, getVersion) {
   try {
     const configDir = PathResolver.getConfigDir(false);
     const cacheFile = join42(configDir, CACHE_FILE);
-    if (!existsSync35(configDir)) {
+    if (!existsSync36(configDir)) {
       await mkdir11(configDir, { recursive: true });
       if (platform4() !== "win32") {
         await chmod2(configDir, 448);
@@ -56392,7 +56593,7 @@ async function clearCache() {
   try {
     const { unlink: unlink6 } = await import("node:fs/promises");
     const cacheFile = join42(PathResolver.getConfigDir(false), CACHE_FILE);
-    if (existsSync35(cacheFile)) {
+    if (existsSync36(cacheFile)) {
       await unlink6(cacheFile);
       logger.debug("Package manager cache cleared");
     }
@@ -56991,7 +57192,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "claudekit-cli",
-    version: "3.37.0-dev.4",
+    version: "3.37.0-dev.6",
     description: "CLI tool for bootstrapping and updating ClaudeKit projects",
     type: "module",
     repository: {
@@ -57551,8 +57752,8 @@ var init_error_handler2 = __esm(() => {
 });
 
 // src/domains/versioning/release-cache.ts
-import { existsSync as existsSync36 } from "node:fs";
-import { mkdir as mkdir12, readFile as readFile25, unlink as unlink6, writeFile as writeFile14 } from "node:fs/promises";
+import { existsSync as existsSync37 } from "node:fs";
+import { mkdir as mkdir12, readFile as readFile26, unlink as unlink6, writeFile as writeFile14 } from "node:fs/promises";
 import { join as join45 } from "node:path";
 var ReleaseCacheEntrySchema, ReleaseCache;
 var init_release_cache = __esm(() => {
@@ -57573,11 +57774,11 @@ var init_release_cache = __esm(() => {
     async get(key) {
       const cacheFile = this.getCachePath(key);
       try {
-        if (!existsSync36(cacheFile)) {
+        if (!existsSync37(cacheFile)) {
           logger.debug(`Release cache not found for key: ${key}`);
           return null;
         }
-        const content = await readFile25(cacheFile, "utf-8");
+        const content = await readFile26(cacheFile, "utf-8");
         const parsed = JSON.parse(content);
         const cacheEntry = ReleaseCacheEntrySchema.parse(parsed);
         if (this.isExpired(cacheEntry.timestamp)) {
@@ -57613,7 +57814,7 @@ var init_release_cache = __esm(() => {
       if (key) {
         const cacheFile = this.getCachePath(key);
         try {
-          if (existsSync36(cacheFile)) {
+          if (existsSync37(cacheFile)) {
             await unlink6(cacheFile);
             logger.debug(`Release cache cleared for key: ${key}`);
           }
@@ -58674,8 +58875,8 @@ var init_update_cli = __esm(() => {
 });
 
 // src/domains/versioning/version-cache.ts
-import { existsSync as existsSync37 } from "node:fs";
-import { mkdir as mkdir13, readFile as readFile27, writeFile as writeFile15 } from "node:fs/promises";
+import { existsSync as existsSync38 } from "node:fs";
+import { mkdir as mkdir13, readFile as readFile28, writeFile as writeFile15 } from "node:fs/promises";
 import { join as join47 } from "node:path";
 var VersionCacheManager;
 var init_version_cache = __esm(() => {
@@ -58691,11 +58892,11 @@ var init_version_cache = __esm(() => {
     static async load() {
       const cacheFile = VersionCacheManager.getCacheFile();
       try {
-        if (!existsSync37(cacheFile)) {
+        if (!existsSync38(cacheFile)) {
           logger.debug("Version check cache not found");
           return null;
         }
-        const content = await readFile27(cacheFile, "utf-8");
+        const content = await readFile28(cacheFile, "utf-8");
         const cache3 = JSON.parse(content);
         if (!cache3.lastCheck || !cache3.currentVersion || !cache3.latestVersion) {
           logger.debug("Invalid cache structure, ignoring");
@@ -58712,7 +58913,7 @@ var init_version_cache = __esm(() => {
       const cacheFile = VersionCacheManager.getCacheFile();
       const cacheDir = PathResolver.getCacheDir(false);
       try {
-        if (!existsSync37(cacheDir)) {
+        if (!existsSync38(cacheDir)) {
           await mkdir13(cacheDir, { recursive: true, mode: 448 });
         }
         await writeFile15(cacheFile, JSON.stringify(cache3, null, 2), "utf-8");
@@ -58734,7 +58935,7 @@ var init_version_cache = __esm(() => {
     static async clear() {
       const cacheFile = VersionCacheManager.getCacheFile();
       try {
-        if (existsSync37(cacheFile)) {
+        if (existsSync38(cacheFile)) {
           const fs6 = await import("node:fs/promises");
           await fs6.unlink(cacheFile);
           logger.debug("Version check cache cleared");
@@ -58953,8 +59154,8 @@ var init_version_checker = __esm(() => {
 
 // src/domains/web-server/routes/system-routes.ts
 import { spawn as spawn2 } from "node:child_process";
-import { existsSync as existsSync38 } from "node:fs";
-import { readFile as readFile28 } from "node:fs/promises";
+import { existsSync as existsSync39 } from "node:fs";
+import { readFile as readFile29 } from "node:fs/promises";
 import { join as join48 } from "node:path";
 function hasCliUpdate(currentVersion, latestVersion) {
   if (!latestVersion) {
@@ -59199,9 +59400,9 @@ async function getPackageJson() {
 async function getKitMetadata2(kitName) {
   try {
     const metadataPath = join48(PathResolver.getGlobalKitDir(), "metadata.json");
-    if (!existsSync38(metadataPath))
+    if (!existsSync39(metadataPath))
       return null;
-    const content = await readFile28(metadataPath, "utf-8");
+    const content = await readFile29(metadataPath, "utf-8");
     const metadata = JSON.parse(content);
     if (metadata.kits?.[kitName]) {
       return { version: metadata.kits[kitName].version };
@@ -59344,8 +59545,8 @@ var init_routes = __esm(() => {
 });
 
 // src/domains/web-server/static-server.ts
-import { existsSync as existsSync39 } from "node:fs";
-import { dirname as dirname18, extname as extname4, join as join49 } from "node:path";
+import { existsSync as existsSync40 } from "node:fs";
+import { dirname as dirname18, extname as extname4, join as join49, resolve as resolve13 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 function tryServeFromEmbedded(app) {
   if (typeof globalThis.Bun === "undefined" || !globalThis.Bun.embeddedFiles?.length) {
@@ -59404,25 +59605,38 @@ function tryServeFromEmbedded(app) {
   });
   return true;
 }
+function addRuntimeUiCandidate(candidates, runtimePath) {
+  if (!runtimePath) {
+    return;
+  }
+  const looksLikePath = runtimePath.includes("/") || runtimePath.includes("\\") || existsSync40(runtimePath);
+  if (!looksLikePath) {
+    return;
+  }
+  const entryDir = dirname18(resolve13(runtimePath));
+  candidates.add(join49(entryDir, "ui"));
+  candidates.add(join49(entryDir, "..", "dist", "ui"));
+}
 function resolveUiDistPath() {
-  const candidates = [
-    join49(__dirname3, "ui"),
-    join49(process.cwd(), "dist", "ui"),
-    join49(process.cwd(), "src", "ui", "dist")
-  ];
+  const candidates = new Set;
+  addRuntimeUiCandidate(candidates, process.execPath);
+  addRuntimeUiCandidate(candidates, process.argv[1]);
+  candidates.add(join49(__dirname3, "ui"));
+  candidates.add(join49(process.cwd(), "dist", "ui"));
+  candidates.add(join49(process.cwd(), "src", "ui", "dist"));
   for (const path4 of candidates) {
-    if (existsSync39(join49(path4, "index.html"))) {
+    if (existsSync40(join49(path4, "index.html"))) {
       return path4;
     }
   }
-  return candidates[0];
+  return Array.from(candidates)[0] ?? join49(process.cwd(), "dist", "ui");
 }
 function serveStatic(app) {
   if (tryServeFromEmbedded(app)) {
     return;
   }
   const uiDistPath = resolveUiDistPath();
-  if (!existsSync39(uiDistPath)) {
+  if (!existsSync40(uiDistPath)) {
     logger.warning(`UI dist not found at ${uiDistPath}. Run 'bun run ui:build' first.`);
     app.use((req, res, next) => {
       if (req.path.startsWith("/api/")) {
@@ -62444,10 +62658,10 @@ async function createAppServer(options2 = {}) {
     wsManager = new WebSocketManager(server);
     fileWatcher = new FileWatcher({ wsManager });
     fileWatcher.start();
-    await new Promise((resolve13, reject) => {
+    await new Promise((resolve14, reject) => {
       const onListening = () => {
         server.off("error", onError);
-        resolve13();
+        resolve14();
       };
       const onError = (error) => {
         server.off("listening", onListening);
@@ -62484,16 +62698,16 @@ async function createAppServer(options2 = {}) {
   };
 }
 async function closeHttpServer(server) {
-  await new Promise((resolve13) => {
+  await new Promise((resolve14) => {
     if (!server.listening) {
-      resolve13();
+      resolve14();
       return;
     }
     server.close((err) => {
       if (err) {
         logger.debug(`Server close error: ${err.message}`);
       }
-      resolve13();
+      resolve14();
     });
   });
 }
@@ -64229,7 +64443,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((resolve15, reject) => {
+  return new Promise((resolve16, reject) => {
     const child = spawn3(command, args, {
       stdio: ["ignore", "inherit", "inherit"],
       cwd: options2?.cwd,
@@ -64250,7 +64464,7 @@ function executeInteractiveScript(command, args, options2) {
       } else if (code !== 0) {
         reject(new Error(`Command exited with code ${code}`));
       } else {
-        resolve15();
+        resolve16();
       }
     });
     child.on("error", (error) => {
@@ -64271,7 +64485,7 @@ var init_process_executor = __esm(() => {
 });
 
 // src/services/package-installer/validators.ts
-import { resolve as resolve15 } from "node:path";
+import { resolve as resolve16 } from "node:path";
 function validatePackageName(packageName) {
   if (!packageName || typeof packageName !== "string") {
     throw new Error("Package name must be a non-empty string");
@@ -64284,8 +64498,8 @@ function validatePackageName(packageName) {
   }
 }
 function validateScriptPath(skillsDir2, scriptPath) {
-  const skillsDirResolved = resolve15(skillsDir2);
-  const scriptPathResolved = resolve15(scriptPath);
+  const skillsDirResolved = resolve16(skillsDir2);
+  const scriptPathResolved = resolve16(scriptPath);
   const skillsDirNormalized = isWindows() ? skillsDirResolved.toLowerCase() : skillsDirResolved;
   const scriptPathNormalized = isWindows() ? scriptPathResolved.toLowerCase() : scriptPathResolved;
   if (!scriptPathNormalized.startsWith(skillsDirNormalized)) {
@@ -64546,7 +64760,7 @@ var init_opencode_installer = __esm(() => {
 var PARTIAL_INSTALL_VERSION = "partial", EXIT_CODE_CRITICAL_FAILURE = 1, EXIT_CODE_PARTIAL_SUCCESS = 2;
 
 // src/services/package-installer/install-error-handler.ts
-import { existsSync as existsSync50, readFileSync as readFileSync13, unlinkSync as unlinkSync2 } from "node:fs";
+import { existsSync as existsSync51, readFileSync as readFileSync13, unlinkSync as unlinkSync2 } from "node:fs";
 import { join as join68 } from "node:path";
 function parseNameReason(str2) {
   const colonIndex = str2.indexOf(":");
@@ -64557,7 +64771,7 @@ function parseNameReason(str2) {
 }
 function displayInstallErrors(skillsDir2) {
   const summaryPath = join68(skillsDir2, ".install-error-summary.json");
-  if (!existsSync50(summaryPath)) {
+  if (!existsSync51(summaryPath)) {
     logger.error("Skills installation failed. Run with --verbose for details.");
     return;
   }
@@ -64648,7 +64862,7 @@ async function checkNeedsSudoPackages() {
 }
 function hasInstallState(skillsDir2) {
   const stateFilePath = join68(skillsDir2, ".install-state.json");
-  return existsSync50(stateFilePath);
+  return existsSync51(stateFilePath);
 }
 var WHICH_COMMAND_TIMEOUT_MS = 5000;
 var init_install_error_handler = __esm(() => {
@@ -64678,7 +64892,7 @@ async function installSkillsDependencies(skillsDir2, options2 = {}) {
     };
   }
   try {
-    const { existsSync: existsSync51 } = await import("node:fs");
+    const { existsSync: existsSync52 } = await import("node:fs");
     const clack = await Promise.resolve().then(() => (init_dist2(), exports_dist));
     const platform7 = process.platform;
     const scriptName = platform7 === "win32" ? "install.ps1" : "install.sh";
@@ -64694,7 +64908,7 @@ async function installSkillsDependencies(skillsDir2, options2 = {}) {
         error: `Path validation failed: ${errorMessage}`
       };
     }
-    if (!existsSync51(scriptPath)) {
+    if (!existsSync52(scriptPath)) {
       logger.warning(`Skills installation script not found: ${scriptPath}`);
       logger.info("");
       logger.info("\uD83D\uDCD6 Manual Installation Instructions:");
@@ -64714,8 +64928,8 @@ async function installSkillsDependencies(skillsDir2, options2 = {}) {
     logger.info(`  Platform: ${platform7 === "win32" ? "Windows (PowerShell)" : "Unix (bash)"}`);
     if (logger.isVerbose()) {
       try {
-        const { readFile: readFile35 } = await import("node:fs/promises");
-        const scriptContent = await readFile35(scriptPath, "utf-8");
+        const { readFile: readFile36 } = await import("node:fs/promises");
+        const scriptContent = await readFile36(scriptPath, "utf-8");
         const previewLines = scriptContent.split(`
 `).slice(0, 20);
         logger.verbose("Script preview (first 20 lines):");
@@ -64910,12 +65124,12 @@ var init_skills_installer2 = __esm(() => {
 });
 
 // src/services/package-installer/gemini-mcp/config-manager.ts
-import { existsSync as existsSync51 } from "node:fs";
-import { mkdir as mkdir17, readFile as readFile35, writeFile as writeFile20 } from "node:fs/promises";
+import { existsSync as existsSync52 } from "node:fs";
+import { mkdir as mkdir17, readFile as readFile36, writeFile as writeFile20 } from "node:fs/promises";
 import { dirname as dirname21, join as join70 } from "node:path";
 async function readJsonFile(filePath) {
   try {
-    const content = await readFile35(filePath, "utf-8");
+    const content = await readFile36(filePath, "utf-8");
     return JSON.parse(content);
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : "Unknown error";
@@ -64928,8 +65142,8 @@ async function addGeminiToGitignore(projectDir) {
   const geminiPattern = ".gemini/";
   try {
     let content = "";
-    if (existsSync51(gitignorePath)) {
-      content = await readFile35(gitignorePath, "utf-8");
+    if (existsSync52(gitignorePath)) {
+      content = await readFile36(gitignorePath, "utf-8");
       const lines = content.split(`
 `).map((line) => line.trim()).filter((line) => !line.startsWith("#"));
       const geminiPatterns = [".gemini/", ".gemini", "/.gemini/", "/.gemini"];
@@ -64953,7 +65167,7 @@ ${geminiPattern}
 }
 async function createNewSettingsWithMerge(geminiSettingsPath, mcpConfigPath) {
   const linkDir = dirname21(geminiSettingsPath);
-  if (!existsSync51(linkDir)) {
+  if (!existsSync52(linkDir)) {
     await mkdir17(linkDir, { recursive: true });
     logger.debug(`Created directory: ${linkDir}`);
   }
@@ -65014,7 +65228,7 @@ var init_config_manager2 = __esm(() => {
 });
 
 // src/services/package-installer/gemini-mcp/validation.ts
-import { existsSync as existsSync52, lstatSync, readlinkSync } from "node:fs";
+import { existsSync as existsSync53, lstatSync, readlinkSync } from "node:fs";
 import { homedir as homedir29 } from "node:os";
 import { join as join71 } from "node:path";
 function getGlobalMcpConfigPath() {
@@ -65025,12 +65239,12 @@ function getLocalMcpConfigPath(projectDir) {
 }
 function findMcpConfigPath(projectDir) {
   const localPath = getLocalMcpConfigPath(projectDir);
-  if (existsSync52(localPath)) {
+  if (existsSync53(localPath)) {
     logger.debug(`Found local MCP config: ${localPath}`);
     return localPath;
   }
   const globalPath = getGlobalMcpConfigPath();
-  if (existsSync52(globalPath)) {
+  if (existsSync53(globalPath)) {
     logger.debug(`Found global MCP config: ${globalPath}`);
     return globalPath;
   }
@@ -65045,7 +65259,7 @@ function getGeminiSettingsPath(projectDir, isGlobal) {
 }
 function checkExistingGeminiConfig(projectDir, isGlobal = false) {
   const geminiSettingsPath = getGeminiSettingsPath(projectDir, isGlobal);
-  if (!existsSync52(geminiSettingsPath)) {
+  if (!existsSync53(geminiSettingsPath)) {
     return { exists: false, isSymlink: false, settingsPath: geminiSettingsPath };
   }
   try {
@@ -65069,12 +65283,12 @@ var init_validation = __esm(() => {
 });
 
 // src/services/package-installer/gemini-mcp/linker-core.ts
-import { existsSync as existsSync53 } from "node:fs";
+import { existsSync as existsSync54 } from "node:fs";
 import { mkdir as mkdir18, symlink as symlink2 } from "node:fs/promises";
 import { dirname as dirname22, join as join72 } from "node:path";
 async function createSymlink(targetPath, linkPath, projectDir, isGlobal) {
   const linkDir = dirname22(linkPath);
-  if (!existsSync53(linkDir)) {
+  if (!existsSync54(linkDir)) {
     await mkdir18(linkDir, { recursive: true });
     logger.debug(`Created directory: ${linkDir}`);
   }
@@ -65115,10 +65329,10 @@ __export(exports_gemini_mcp_linker, {
   checkExistingGeminiConfig: () => checkExistingGeminiConfig,
   addGeminiToGitignore: () => addGeminiToGitignore
 });
-import { resolve as resolve16 } from "node:path";
+import { resolve as resolve17 } from "node:path";
 async function linkGeminiMcpConfig(projectDir, options2 = {}) {
   const { skipGitignore = false, isGlobal = false } = options2;
-  const resolvedProjectDir = resolve16(projectDir);
+  const resolvedProjectDir = resolve17(projectDir);
   const geminiSettingsPath = getGeminiSettingsPath(resolvedProjectDir, isGlobal);
   const mcpConfigPath = findMcpConfigPath(resolvedProjectDir);
   if (!mcpConfigPath) {
@@ -65766,7 +65980,7 @@ var require_get_stream = __commonJS((exports, module) => {
     };
     const { maxBuffer } = options2;
     let stream;
-    await new Promise((resolve18, reject) => {
+    await new Promise((resolve19, reject) => {
       const rejectPromise = (error) => {
         if (error && stream.getBufferedLength() <= BufferConstants.MAX_LENGTH) {
           error.bufferedData = stream.getBufferedValue();
@@ -65778,7 +65992,7 @@ var require_get_stream = __commonJS((exports, module) => {
           rejectPromise(error);
           return;
         }
-        resolve18();
+        resolve19();
       });
       stream.on("data", () => {
         if (stream.getBufferedLength() > maxBuffer) {
@@ -67139,7 +67353,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((resolve18, reject) => {
+      return new Promise((resolve19, reject) => {
         this.zipfile.on("error", (err) => {
           this.canceled = true;
           reject(err);
@@ -67148,7 +67362,7 @@ var require_extract_zip = __commonJS((exports, module) => {
         this.zipfile.on("close", () => {
           if (!this.canceled) {
             debug("zip extraction complete");
-            resolve18();
+            resolve19();
           }
         });
         this.zipfile.on("entry", async (entry) => {
@@ -67467,7 +67681,7 @@ async function restoreOriginalBranch(branchName, cwd2, issueNumber) {
   }
 }
 function spawnAndCollect(command, args, cwd2) {
-  return new Promise((resolve31, reject) => {
+  return new Promise((resolve32, reject) => {
     const child = spawn4(command, args, { ...cwd2 && { cwd: cwd2 }, stdio: ["ignore", "pipe", "pipe"] });
     const chunks = [];
     const stderrChunks = [];
@@ -67480,7 +67694,7 @@ function spawnAndCollect(command, args, cwd2) {
         reject(new Error(`${command} ${args[0] ?? ""} exited with code ${code2}: ${stderr}`));
         return;
       }
-      resolve31(Buffer.concat(chunks).toString("utf-8"));
+      resolve32(Buffer.concat(chunks).toString("utf-8"));
     });
   });
 }
@@ -67497,8 +67711,8 @@ __export(exports_worktree_manager, {
   createWorktree: () => createWorktree,
   cleanupAllWorktrees: () => cleanupAllWorktrees
 });
-import { existsSync as existsSync61 } from "node:fs";
-import { readFile as readFile52, writeFile as writeFile33 } from "node:fs/promises";
+import { existsSync as existsSync62 } from "node:fs";
+import { readFile as readFile53, writeFile as writeFile33 } from "node:fs/promises";
 import { join as join123 } from "node:path";
 async function createWorktree(projectDir, issueNumber, baseBranch) {
   const worktreePath = join123(projectDir, WORKTREE_DIR, `issue-${issueNumber}`);
@@ -67563,7 +67777,7 @@ async function cleanupAllWorktrees(projectDir) {
 async function ensureGitignore(projectDir) {
   const gitignorePath = join123(projectDir, ".gitignore");
   try {
-    const content = existsSync61(gitignorePath) ? await readFile52(gitignorePath, "utf-8") : "";
+    const content = existsSync62(gitignorePath) ? await readFile53(gitignorePath, "utf-8") : "";
     if (!content.includes(".worktrees")) {
       const newContent = content.endsWith(`
 `) ? `${content}.worktrees/
@@ -67665,13 +67879,13 @@ var init_content_validator = __esm(() => {
 
 // src/commands/content/phases/context-cache-manager.ts
 import { createHash as createHash6 } from "node:crypto";
-import { existsSync as existsSync67, mkdirSync as mkdirSync4, readFileSync as readFileSync14, readdirSync as readdirSync8, statSync as statSync10 } from "node:fs";
+import { existsSync as existsSync68, mkdirSync as mkdirSync4, readFileSync as readFileSync14, readdirSync as readdirSync8, statSync as statSync10 } from "node:fs";
 import { rename as rename9, writeFile as writeFile35 } from "node:fs/promises";
 import { homedir as homedir33 } from "node:os";
 import { basename as basename19, join as join130 } from "node:path";
 function getCachedContext(repoPath) {
   const cachePath = getCacheFilePath(repoPath);
-  if (!existsSync67(cachePath))
+  if (!existsSync68(cachePath))
     return null;
   try {
     const raw2 = readFileSync14(cachePath, "utf-8");
@@ -67688,7 +67902,7 @@ function getCachedContext(repoPath) {
   }
 }
 async function saveCachedContext(repoPath, cache5) {
-  if (!existsSync67(CACHE_DIR)) {
+  if (!existsSync68(CACHE_DIR)) {
     mkdirSync4(CACHE_DIR, { recursive: true });
   }
   const cachePath = getCacheFilePath(repoPath);
@@ -67712,7 +67926,7 @@ function computeSourceHash(repoPath) {
 function getDocSourcePaths(repoPath) {
   const paths = [];
   const docsDir = join130(repoPath, "docs");
-  if (existsSync67(docsDir)) {
+  if (existsSync68(docsDir)) {
     try {
       const files = readdirSync8(docsDir);
       for (const f3 of files) {
@@ -67722,10 +67936,10 @@ function getDocSourcePaths(repoPath) {
     } catch {}
   }
   const readme = join130(repoPath, "README.md");
-  if (existsSync67(readme))
+  if (existsSync68(readme))
     paths.push(readme);
   const stylesDir = join130(repoPath, "assets", "writing-styles");
-  if (existsSync67(stylesDir)) {
+  if (existsSync68(stylesDir)) {
     try {
       const files = readdirSync8(stylesDir);
       for (const f3 of files) {
@@ -67922,7 +68136,7 @@ function extractContentFromResponse(response) {
 
 // src/commands/content/phases/docs-summarizer.ts
 import { execSync as execSync6 } from "node:child_process";
-import { existsSync as existsSync68, readFileSync as readFileSync15, readdirSync as readdirSync9 } from "node:fs";
+import { existsSync as existsSync69, readFileSync as readFileSync15, readdirSync as readdirSync9 } from "node:fs";
 import { join as join131 } from "node:path";
 async function summarizeProjectDocs(repoPath, contentLogger) {
   const rawContent = collectRawDocs(repoPath);
@@ -67967,7 +68181,7 @@ async function summarizeProjectDocs(repoPath, contentLogger) {
 function collectRawDocs(repoPath) {
   let totalChars = 0;
   const readCapped = (filePath, maxChars) => {
-    if (!existsSync68(filePath))
+    if (!existsSync69(filePath))
       return "";
     if (totalChars >= MAX_RAW_CONTENT_CHARS)
       return "";
@@ -67978,7 +68192,7 @@ function collectRawDocs(repoPath) {
   };
   const docsContent = [];
   const docsDir = join131(repoPath, "docs");
-  if (existsSync68(docsDir)) {
+  if (existsSync69(docsDir)) {
     try {
       const files = readdirSync9(docsDir).filter((f3) => f3.endsWith(".md")).sort();
       for (const f3 of files) {
@@ -68002,7 +68216,7 @@ ${content}`);
   }
   let styles3 = "";
   const stylesDir = join131(repoPath, "assets", "writing-styles");
-  if (existsSync68(stylesDir)) {
+  if (existsSync69(stylesDir)) {
     try {
       const files = readdirSync9(stylesDir).slice(0, 3);
       styles3 = files.map((f3) => readCapped(join131(stylesDir, f3), 1000)).filter(Boolean).join(`
@@ -68195,12 +68409,12 @@ IMPORTANT: Generate the image and output the path as JSON: {"imagePath": "/path/
 
 // src/commands/content/phases/photo-generator.ts
 import { execSync as execSync7 } from "node:child_process";
-import { existsSync as existsSync69, mkdirSync as mkdirSync5, readdirSync as readdirSync10 } from "node:fs";
+import { existsSync as existsSync70, mkdirSync as mkdirSync5, readdirSync as readdirSync10 } from "node:fs";
 import { homedir as homedir34 } from "node:os";
 import { join as join132 } from "node:path";
 async function generatePhoto(_content, context, config, platform14, contentId, contentLogger) {
   const mediaDir = join132(config.contentDir.replace(/^~/, homedir34()), "media", String(contentId));
-  if (!existsSync69(mediaDir)) {
+  if (!existsSync70(mediaDir)) {
     mkdirSync5(mediaDir, { recursive: true });
   }
   const prompt = buildPhotoPrompt(context, platform14);
@@ -68216,7 +68430,7 @@ async function generatePhoto(_content, context, config, platform14, contentId, c
     const parsed = parseClaudeJsonOutput(result);
     if (parsed && typeof parsed === "object" && "imagePath" in parsed) {
       const imagePath = String(parsed.imagePath);
-      if (existsSync69(imagePath)) {
+      if (existsSync70(imagePath)) {
         return { path: imagePath, ...dimensions, format: "png" };
       }
     }
@@ -68312,7 +68526,7 @@ var init_content_creator = __esm(() => {
 });
 
 // src/commands/content/phases/content-logger.ts
-import { createWriteStream as createWriteStream4, existsSync as existsSync70, mkdirSync as mkdirSync6, statSync as statSync11 } from "node:fs";
+import { createWriteStream as createWriteStream4, existsSync as existsSync71, mkdirSync as mkdirSync6, statSync as statSync11 } from "node:fs";
 import { homedir as homedir35 } from "node:os";
 import { join as join133 } from "node:path";
 
@@ -68326,7 +68540,7 @@ class ContentLogger {
     this.maxBytes = maxBytes;
   }
   init() {
-    if (!existsSync70(this.logDir)) {
+    if (!existsSync71(this.logDir)) {
       mkdirSync6(this.logDir, { recursive: true });
     }
     this.rotateIfNeeded();
@@ -68413,7 +68627,7 @@ var init_content_logger = __esm(() => {
 
 // src/commands/content/phases/db-manager.ts
 import { Database } from "bun:sqlite";
-import { existsSync as existsSync71, mkdirSync as mkdirSync7 } from "node:fs";
+import { existsSync as existsSync72, mkdirSync as mkdirSync7 } from "node:fs";
 import { dirname as dirname33 } from "node:path";
 function initDatabase(dbPath) {
   ensureParentDir(dbPath);
@@ -68436,7 +68650,7 @@ function runRetentionCleanup(db, retentionDays = 90) {
 }
 function ensureParentDir(dbPath) {
   const dir = dirname33(dbPath);
-  if (dir && !existsSync71(dir)) {
+  if (dir && !existsSync72(dir)) {
     mkdirSync7(dir, { recursive: true });
   }
 }
@@ -68599,7 +68813,7 @@ function isNoiseCommit(title, author) {
 
 // src/commands/content/phases/change-detector.ts
 import { execSync as execSync9 } from "node:child_process";
-import { existsSync as existsSync72, readFileSync as readFileSync16, readdirSync as readdirSync11, statSync as statSync12 } from "node:fs";
+import { existsSync as existsSync73, readFileSync as readFileSync16, readdirSync as readdirSync11, statSync as statSync12 } from "node:fs";
 import { join as join134 } from "node:path";
 function detectCommits(repo, since) {
   try {
@@ -68699,7 +68913,7 @@ function detectTags(repo, since) {
 }
 function detectCompletedPlans(repo, since) {
   const plansDir = join134(repo.path, "plans");
-  if (!existsSync72(plansDir))
+  if (!existsSync73(plansDir))
     return [];
   const sinceMs = new Date(since).getTime();
   const events = [];
@@ -68709,7 +68923,7 @@ function detectCompletedPlans(repo, since) {
       if (!entry.isDirectory())
         continue;
       const planFile = join134(plansDir, entry.name, "plan.md");
-      if (!existsSync72(planFile))
+      if (!existsSync73(planFile))
         continue;
       try {
         const stat20 = statSync12(planFile);
@@ -69465,12 +69679,12 @@ var init_types6 = __esm(() => {
 });
 
 // src/commands/content/phases/state-manager.ts
-import { readFile as readFile54, rename as rename10, writeFile as writeFile36 } from "node:fs/promises";
+import { readFile as readFile55, rename as rename10, writeFile as writeFile36 } from "node:fs/promises";
 import { join as join136 } from "node:path";
 async function loadContentConfig(projectDir) {
   const configPath = join136(projectDir, CK_CONFIG_FILE2);
   try {
-    const raw2 = await readFile54(configPath, "utf-8");
+    const raw2 = await readFile55(configPath, "utf-8");
     const json = JSON.parse(raw2);
     return ContentConfigSchema.parse(json.content ?? {});
   } catch {
@@ -69486,7 +69700,7 @@ async function saveContentConfig(projectDir, config) {
 async function loadContentState(projectDir) {
   const configPath = join136(projectDir, CK_CONFIG_FILE2);
   try {
-    const raw2 = await readFile54(configPath, "utf-8");
+    const raw2 = await readFile55(configPath, "utf-8");
     const json = JSON.parse(raw2);
     const contentBlock = json.content ?? {};
     return ContentStateSchema.parse(contentBlock.state ?? {});
@@ -69513,7 +69727,7 @@ async function saveContentState(projectDir, state) {
 }
 async function readJsonSafe(filePath) {
   try {
-    const raw2 = await readFile54(filePath, "utf-8");
+    const raw2 = await readFile55(filePath, "utf-8");
     return JSON.parse(raw2);
   } catch {
     return {};
@@ -69776,7 +69990,7 @@ var init_platform_setup_x = __esm(() => {
 });
 
 // src/commands/content/phases/setup-wizard.ts
-import { existsSync as existsSync73 } from "node:fs";
+import { existsSync as existsSync74 } from "node:fs";
 import { join as join137 } from "node:path";
 async function runSetupWizard2(cwd2, contentLogger) {
   console.log();
@@ -69845,8 +70059,8 @@ async function showRepoSummary(cwd2) {
 function detectBrandAssets(cwd2, contentLogger) {
   const repos = discoverRepos2(cwd2);
   for (const repo of repos) {
-    const hasGuidelines = existsSync73(join137(repo.path, "docs", "brand-guidelines.md"));
-    const hasStyles = existsSync73(join137(repo.path, "assets", "writing-styles"));
+    const hasGuidelines = existsSync74(join137(repo.path, "docs", "brand-guidelines.md"));
+    const hasStyles = existsSync74(join137(repo.path, "assets", "writing-styles"));
     if (!hasGuidelines) {
       f2.warning(`${repo.name}: No docs/brand-guidelines.md — content will use generic tone.`);
       contentLogger.warn(`${repo.name}: missing docs/brand-guidelines.md`);
@@ -69912,13 +70126,13 @@ var init_setup_wizard = __esm(() => {
 });
 
 // src/commands/content/content-review-commands.ts
-import { existsSync as existsSync74 } from "node:fs";
+import { existsSync as existsSync75 } from "node:fs";
 import { homedir as homedir36 } from "node:os";
 async function queueContent() {
   const cwd2 = process.cwd();
   const config = await loadContentConfig(cwd2);
   const dbPath = config.dbPath.replace(/^~/, homedir36());
-  if (!existsSync74(dbPath)) {
+  if (!existsSync75(dbPath)) {
     logger.info("No content database found. Run 'ck content setup' first.");
     return;
   }
@@ -69986,12 +70200,12 @@ __export(exports_content_subcommands, {
   logsContent: () => logsContent,
   approveContentCmd: () => approveContentCmd
 });
-import { existsSync as existsSync75, readFileSync as readFileSync17, unlinkSync as unlinkSync5 } from "node:fs";
+import { existsSync as existsSync76, readFileSync as readFileSync17, unlinkSync as unlinkSync5 } from "node:fs";
 import { homedir as homedir37 } from "node:os";
 import { join as join138 } from "node:path";
 function isDaemonRunning() {
   const lockFile = join138(LOCK_DIR, `${LOCK_NAME2}.lock`);
-  if (!existsSync75(lockFile))
+  if (!existsSync76(lockFile))
     return { running: false, pid: null };
   try {
     const pidStr = readFileSync17(lockFile, "utf-8").trim();
@@ -70023,7 +70237,7 @@ async function startContent(options2) {
 }
 async function stopContent() {
   const lockFile = join138(LOCK_DIR, `${LOCK_NAME2}.lock`);
-  if (!existsSync75(lockFile)) {
+  if (!existsSync76(lockFile)) {
     logger.info("Content daemon is not running.");
     return;
   }
@@ -70064,7 +70278,7 @@ async function logsContent(options2) {
   const logDir = join138(homedir37(), ".claudekit", "logs");
   const dateStr = new Date().toISOString().slice(0, 10).replace(/-/g, "");
   const logPath = join138(logDir, `content-${dateStr}.log`);
-  if (!existsSync75(logPath)) {
+  if (!existsSync76(logPath)) {
     logger.info("No content logs found for today.");
     return;
   }
@@ -70099,7 +70313,7 @@ var init_content_subcommands = __esm(() => {
 });
 
 // src/commands/content/content-command.ts
-import { existsSync as existsSync76, mkdirSync as mkdirSync8, unlinkSync as unlinkSync6, writeFileSync as writeFileSync6 } from "node:fs";
+import { existsSync as existsSync77, mkdirSync as mkdirSync8, unlinkSync as unlinkSync6, writeFileSync as writeFileSync6 } from "node:fs";
 import { homedir as homedir38 } from "node:os";
 import { join as join139 } from "node:path";
 async function contentCommand(options2) {
@@ -70130,7 +70344,7 @@ async function contentCommand(options2) {
       }
       contentLogger.info("Setup complete. Starting daemon...");
     }
-    if (!existsSync76(LOCK_DIR2))
+    if (!existsSync77(LOCK_DIR2))
       mkdirSync8(LOCK_DIR2, { recursive: true });
     writeFileSync6(LOCK_FILE, String(process.pid), "utf-8");
     const dbPath = config.dbPath.replace(/^~/, homedir38());
@@ -70262,8 +70476,8 @@ function shouldRunCleanup(lastAt) {
   return Date.now() - new Date(lastAt).getTime() >= 86400000;
 }
 function sleep2(ms) {
-  return new Promise((resolve31) => {
-    setTimeout(resolve31, ms);
+  return new Promise((resolve32) => {
+    setTimeout(resolve32, ms);
   });
 }
 var LOCK_DIR2, LOCK_FILE, MAX_CREATION_RETRIES = 3, MAX_PUBLISH_RETRIES_PER_CYCLE = 3, PUBLISH_RETRY_WINDOW_HOURS = 24;
@@ -71580,7 +71794,7 @@ function getPagerArgs(pagerCmd) {
   return [];
 }
 async function trySystemPager(content) {
-  return new Promise((resolve31) => {
+  return new Promise((resolve32) => {
     const pagerCmd = process.env.PAGER || "less";
     const pagerArgs = getPagerArgs(pagerCmd);
     try {
@@ -71590,20 +71804,20 @@ async function trySystemPager(content) {
       });
       const timeout2 = setTimeout(() => {
         pager.kill();
-        resolve31(false);
+        resolve32(false);
       }, 30000);
       pager.stdin.write(content);
       pager.stdin.end();
       pager.on("close", (code2) => {
         clearTimeout(timeout2);
-        resolve31(code2 === 0);
+        resolve32(code2 === 0);
       });
       pager.on("error", () => {
         clearTimeout(timeout2);
-        resolve31(false);
+        resolve32(false);
       });
     } catch {
-      resolve31(false);
+      resolve32(false);
     }
   });
 }
@@ -71630,16 +71844,16 @@ async function basicPager(content) {
       break;
     }
     const remaining = lines.length - currentLine;
-    await new Promise((resolve31) => {
+    await new Promise((resolve32) => {
       rl.question(`-- More (${remaining} lines) [Enter/q] --`, (answer) => {
         if (answer.toLowerCase() === "q") {
           rl.close();
           process.exitCode = 0;
-          resolve31();
+          resolve32();
           return;
         }
         process.stdout.write("\x1B[1A\x1B[2K");
-        resolve31();
+        resolve32();
       });
     });
   }
@@ -75040,12 +75254,12 @@ async function configUICommand(options2 = {}) {
     console.log();
     console.log(import_picocolors14.default.dim("  Press Ctrl+C to stop"));
     console.log();
-    await new Promise((resolve13) => {
+    await new Promise((resolve14) => {
       const shutdown = async () => {
         console.log();
         logger.info("Shutting down...");
         await server.close();
-        resolve13();
+        resolve14();
       };
       process.on("SIGINT", shutdown);
       process.on("SIGTERM", shutdown);
@@ -75066,12 +75280,12 @@ async function configUICommand(options2 = {}) {
 }
 async function checkPort(port, host) {
   const { createServer: createServer2 } = await import("node:net");
-  return new Promise((resolve13) => {
+  return new Promise((resolve14) => {
     const server = createServer2();
-    server.once("error", () => resolve13(false));
+    server.once("error", () => resolve14(false));
     server.once("listening", () => {
       server.close();
-      resolve13(true);
+      resolve14(true);
     });
     server.listen(port, host);
   });
@@ -75272,9 +75486,11 @@ async function configCommand(action, keyOrOptions, valueOrOptions, options2) {
     return;
   }
   const rawOpts = options2 || (typeof keyOrOptions === "object" ? keyOrOptions : {});
+  const openOption = rawOpts.open;
+  const noOpen = rawOpts.noOpen === true || openOption === false ? true : undefined;
   const uiOpts = {
     port: rawOpts.port,
-    noOpen: rawOpts.noOpen,
+    noOpen,
     dev: rawOpts.dev,
     host: rawOpts.host
   };
@@ -76231,7 +76447,7 @@ async function checkCliInstallMethod() {
   };
 }
 // src/domains/health-checks/checkers/claude-md-checker.ts
-import { existsSync as existsSync41, statSync as statSync5 } from "node:fs";
+import { existsSync as existsSync42, statSync as statSync5 } from "node:fs";
 import { join as join50 } from "node:path";
 function checkClaudeMd(setup, projectDir) {
   const results = [];
@@ -76244,7 +76460,7 @@ function checkClaudeMd(setup, projectDir) {
   return results;
 }
 function checkClaudeMdFile(path4, name, id) {
-  if (!existsSync41(path4)) {
+  if (!existsSync42(path4)) {
     return {
       id,
       name,
@@ -76297,11 +76513,11 @@ function checkClaudeMdFile(path4, name, id) {
   }
 }
 // src/domains/health-checks/checkers/active-plan-checker.ts
-import { existsSync as existsSync42, readFileSync as readFileSync10 } from "node:fs";
+import { existsSync as existsSync43, readFileSync as readFileSync10 } from "node:fs";
 import { join as join51 } from "node:path";
 function checkActivePlan(projectDir) {
   const activePlanPath = join51(projectDir, ".claude", "active-plan");
-  if (!existsSync42(activePlanPath)) {
+  if (!existsSync43(activePlanPath)) {
     return {
       id: "ck-active-plan",
       name: "Active Plan",
@@ -76315,7 +76531,7 @@ function checkActivePlan(projectDir) {
   try {
     const targetPath = readFileSync10(activePlanPath, "utf-8").trim();
     const fullPath = join51(projectDir, targetPath);
-    if (!existsSync42(fullPath)) {
+    if (!existsSync43(fullPath)) {
       return {
         id: "ck-active-plan",
         name: "Active Plan",
@@ -76351,7 +76567,7 @@ function checkActivePlan(projectDir) {
   }
 }
 // src/domains/health-checks/checkers/skills-checker.ts
-import { existsSync as existsSync43 } from "node:fs";
+import { existsSync as existsSync44 } from "node:fs";
 import { join as join52 } from "node:path";
 function checkSkillsScripts(setup) {
   const results = [];
@@ -76359,7 +76575,7 @@ function checkSkillsScripts(setup) {
   const scriptName = platform5 === "win32" ? "install.ps1" : "install.sh";
   if (setup.global.path) {
     const globalScriptPath = join52(setup.global.path, "skills", scriptName);
-    const hasGlobalScript = existsSync43(globalScriptPath);
+    const hasGlobalScript = existsSync44(globalScriptPath);
     results.push({
       id: "ck-global-skills-script",
       name: "Global Skills Script",
@@ -76374,7 +76590,7 @@ function checkSkillsScripts(setup) {
   }
   if (setup.project.metadata) {
     const projectScriptPath = join52(setup.project.path, "skills", scriptName);
-    const hasProjectScript = existsSync43(projectScriptPath);
+    const hasProjectScript = existsSync44(projectScriptPath);
     results.push({
       id: "ck-project-skills-script",
       name: "Project Skills Script",
@@ -76512,7 +76728,7 @@ async function checkGlobalDirWritable() {
 }
 // src/domains/health-checks/checkers/hooks-checker.ts
 init_path_resolver();
-import { existsSync as existsSync44 } from "node:fs";
+import { existsSync as existsSync45 } from "node:fs";
 import { readdir as readdir10 } from "node:fs/promises";
 import { join as join54 } from "node:path";
 
@@ -76528,8 +76744,8 @@ function normalizePath2(filePath) {
 async function checkHooksExist(projectDir) {
   const globalHooksDir = join54(PathResolver.getGlobalKitDir(), "hooks");
   const projectHooksDir = join54(projectDir, ".claude", "hooks");
-  const globalExists = existsSync44(globalHooksDir);
-  const projectExists = existsSync44(projectHooksDir);
+  const globalExists = existsSync45(globalHooksDir);
+  const projectExists = existsSync45(projectHooksDir);
   let hookCount = 0;
   const checkedFiles = new Set;
   if (globalExists) {
@@ -76576,13 +76792,13 @@ async function checkHooksExist(projectDir) {
 // src/domains/health-checks/checkers/settings-checker.ts
 init_logger();
 init_path_resolver();
-import { existsSync as existsSync45 } from "node:fs";
-import { readFile as readFile29 } from "node:fs/promises";
+import { existsSync as existsSync46 } from "node:fs";
+import { readFile as readFile30 } from "node:fs/promises";
 import { join as join55 } from "node:path";
 async function checkSettingsValid(projectDir) {
   const globalSettings = join55(PathResolver.getGlobalKitDir(), "settings.json");
   const projectSettings = join55(projectDir, ".claude", "settings.json");
-  const settingsPath = existsSync45(globalSettings) ? globalSettings : existsSync45(projectSettings) ? projectSettings : null;
+  const settingsPath = existsSync46(globalSettings) ? globalSettings : existsSync46(projectSettings) ? projectSettings : null;
   if (!settingsPath) {
     return {
       id: "ck-settings-valid",
@@ -76595,7 +76811,7 @@ async function checkSettingsValid(projectDir) {
     };
   }
   try {
-    const content = await readFile29(settingsPath, "utf-8");
+    const content = await readFile30(settingsPath, "utf-8");
     JSON.parse(content);
     return {
       id: "ck-settings-valid",
@@ -76651,14 +76867,14 @@ async function checkSettingsValid(projectDir) {
 // src/domains/health-checks/checkers/path-refs-checker.ts
 init_logger();
 init_path_resolver();
-import { existsSync as existsSync46 } from "node:fs";
-import { readFile as readFile30 } from "node:fs/promises";
+import { existsSync as existsSync47 } from "node:fs";
+import { readFile as readFile31 } from "node:fs/promises";
 import { homedir as homedir27 } from "node:os";
-import { dirname as dirname19, join as join56, normalize as normalize5, resolve as resolve13 } from "node:path";
+import { dirname as dirname19, join as join56, normalize as normalize5, resolve as resolve14 } from "node:path";
 async function checkPathRefsValid(projectDir) {
   const globalClaudeMd = join56(PathResolver.getGlobalKitDir(), "CLAUDE.md");
   const projectClaudeMd = join56(projectDir, ".claude", "CLAUDE.md");
-  const claudeMdPath = existsSync46(globalClaudeMd) ? globalClaudeMd : existsSync46(projectClaudeMd) ? projectClaudeMd : null;
+  const claudeMdPath = existsSync47(globalClaudeMd) ? globalClaudeMd : existsSync47(projectClaudeMd) ? projectClaudeMd : null;
   if (!claudeMdPath) {
     return {
       id: "ck-path-refs-valid",
@@ -76671,7 +76887,7 @@ async function checkPathRefsValid(projectDir) {
     };
   }
   try {
-    const content = await readFile30(claudeMdPath, "utf-8");
+    const content = await readFile31(claudeMdPath, "utf-8");
     const refPattern = /@([^\s\)]+)/g;
     const refs = [...content.matchAll(refPattern)].map((m2) => m2[1]);
     if (refs.length === 0) {
@@ -76701,7 +76917,7 @@ async function checkPathRefsValid(projectDir) {
       } else if (/^[A-Za-z]:/.test(ref)) {
         refPath = normalize5(ref);
       } else {
-        refPath = resolve13(baseDir, ref);
+        refPath = resolve14(baseDir, ref);
       }
       const normalizedPath = normalize5(refPath);
       const isWithinHome = normalizedPath.startsWith(home8);
@@ -76711,7 +76927,7 @@ async function checkPathRefsValid(projectDir) {
         logger.verbose("Skipping potentially unsafe path reference", { ref, refPath });
         continue;
       }
-      if (!existsSync46(normalizedPath)) {
+      if (!existsSync47(normalizedPath)) {
         broken.push(ref);
       }
     }
@@ -76750,7 +76966,7 @@ async function checkPathRefsValid(projectDir) {
   }
 }
 // src/domains/health-checks/checkers/config-completeness-checker.ts
-import { existsSync as existsSync47 } from "node:fs";
+import { existsSync as existsSync48 } from "node:fs";
 import { readdir as readdir11 } from "node:fs/promises";
 import { join as join57 } from "node:path";
 async function checkProjectConfigCompleteness(setup, projectDir) {
@@ -76770,11 +76986,11 @@ async function checkProjectConfigCompleteness(setup, projectDir) {
   const missingDirs = [];
   for (const dir of requiredDirs) {
     const dirPath = join57(projectClaudeDir, dir);
-    if (!existsSync47(dirPath)) {
+    if (!existsSync48(dirPath)) {
       missingDirs.push(dir);
     }
   }
-  const hasRulesOrWorkflows = existsSync47(join57(projectClaudeDir, "rules")) || existsSync47(join57(projectClaudeDir, "workflows"));
+  const hasRulesOrWorkflows = existsSync48(join57(projectClaudeDir, "rules")) || existsSync48(join57(projectClaudeDir, "workflows"));
   if (!hasRulesOrWorkflows) {
     missingDirs.push("rules");
   }
@@ -77123,24 +77339,24 @@ init_claudekit_constants();
 init_logger();
 init_path_resolver();
 import { spawnSync as spawnSync2 } from "node:child_process";
-import { existsSync as existsSync48, readFileSync as readFileSync11, statSync as statSync6, writeFileSync as writeFileSync4 } from "node:fs";
+import { existsSync as existsSync49, readFileSync as readFileSync11, statSync as statSync6, writeFileSync as writeFileSync4 } from "node:fs";
 import { readdir as readdir12 } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { join as join60, resolve as resolve14 } from "node:path";
+import { join as join60, resolve as resolve15 } from "node:path";
 var HOOK_CHECK_TIMEOUT_MS = 5000;
 var PYTHON_CHECK_TIMEOUT_MS = 3000;
 var MAX_LOG_FILE_SIZE_BYTES = 10 * 1024 * 1024;
 function getHooksDir(projectDir) {
-  const projectHooksDir = resolve14(projectDir, ".claude", "hooks");
-  const globalHooksDir = resolve14(PathResolver.getGlobalKitDir(), "hooks");
-  if (existsSync48(projectHooksDir))
+  const projectHooksDir = resolve15(projectDir, ".claude", "hooks");
+  const globalHooksDir = resolve15(PathResolver.getGlobalKitDir(), "hooks");
+  if (existsSync49(projectHooksDir))
     return projectHooksDir;
-  if (existsSync48(globalHooksDir))
+  if (existsSync49(globalHooksDir))
     return globalHooksDir;
   return null;
 }
 function isPathWithin(filePath, parentDir) {
-  return resolve14(filePath).startsWith(resolve14(parentDir));
+  return resolve15(filePath).startsWith(resolve15(parentDir));
 }
 async function checkHookSyntax(projectDir) {
   const hooksDir = getHooksDir(projectDir);
@@ -77270,7 +77486,7 @@ async function checkHookDeps(projectDir) {
           const resolvedPath = join60(hooksDir, depPath);
           const extensions = [".js", ".cjs", ".mjs", ".json"];
           const indexFiles = ["index.js", "index.cjs", "index.mjs"];
-          const exists = existsSync48(resolvedPath) || extensions.some((ext) => existsSync48(resolvedPath + ext)) || indexFiles.some((idx) => existsSync48(join60(resolvedPath, idx)));
+          const exists = existsSync49(resolvedPath) || extensions.some((ext) => existsSync49(resolvedPath + ext)) || indexFiles.some((idx) => existsSync49(join60(resolvedPath, idx)));
           if (!exists) {
             missingDeps.push(`${file}: ${depPath}`);
           }
@@ -77455,7 +77671,7 @@ async function checkHookRuntime(projectDir) {
 async function checkHookConfig(projectDir) {
   const projectConfigPath = join60(projectDir, ".claude", ".ck.json");
   const globalConfigPath = join60(PathResolver.getGlobalKitDir(), ".ck.json");
-  const configPath = existsSync48(projectConfigPath) ? projectConfigPath : existsSync48(globalConfigPath) ? globalConfigPath : null;
+  const configPath = existsSync49(projectConfigPath) ? projectConfigPath : existsSync49(globalConfigPath) ? globalConfigPath : null;
   if (!configPath) {
     return {
       id: "hook-config",
@@ -77579,7 +77795,7 @@ async function checkHookLogs(projectDir) {
     };
   }
   const logPath = join60(hooksDir, ".logs", "hook-log.jsonl");
-  if (!existsSync48(logPath)) {
+  if (!existsSync49(logPath)) {
     return {
       id: "hook-logs",
       name: "Hook Crash Logs",
@@ -77836,7 +78052,7 @@ async function checkPythonVenv(projectDir) {
   const venvBin = isWindows3 ? join60("Scripts", "python.exe") : join60("bin", "python3");
   const projectVenvPath = join60(projectDir, ".claude", "skills", ".venv", venvBin);
   const globalVenvPath = join60(PathResolver.getGlobalKitDir(), "skills", ".venv", venvBin);
-  const venvPath = existsSync48(projectVenvPath) ? projectVenvPath : existsSync48(globalVenvPath) ? globalVenvPath : null;
+  const venvPath = existsSync49(projectVenvPath) ? projectVenvPath : existsSync49(globalVenvPath) ? globalVenvPath : null;
   if (!venvPath) {
     return {
       id: "python-venv",
@@ -78314,7 +78530,7 @@ import { platform as platform6 } from "node:os";
 // src/domains/health-checks/platform/environment-checker.ts
 init_environment();
 init_path_resolver();
-import { constants as constants3, access as access3, mkdir as mkdir14, readFile as readFile32, unlink as unlink8, writeFile as writeFile17 } from "node:fs/promises";
+import { constants as constants3, access as access3, mkdir as mkdir14, readFile as readFile33, unlink as unlink8, writeFile as writeFile17 } from "node:fs/promises";
 import { arch as arch2, homedir as homedir28, platform as platform5 } from "node:os";
 import { join as join62, normalize as normalize6 } from "node:path";
 function shouldSkipExpensiveOperations4() {
@@ -78411,7 +78627,7 @@ async function checkGlobalDirAccess() {
   try {
     await mkdir14(globalDir, { recursive: true });
     await writeFile17(testFile, "test", "utf-8");
-    const content = await readFile32(testFile, "utf-8");
+    const content = await readFile33(testFile, "utf-8");
     await unlink8(testFile);
     if (content !== "test")
       throw new Error("Read mismatch");
@@ -79304,7 +79520,7 @@ init_claudekit_constants();
 init_logger();
 init_path_resolver();
 var import_compare_versions6 = __toESM(require_umd(), 1);
-import { mkdir as mkdir16, readFile as readFile33, unlink as unlink10, writeFile as writeFile19 } from "node:fs/promises";
+import { mkdir as mkdir16, readFile as readFile34, unlink as unlink10, writeFile as writeFile19 } from "node:fs/promises";
 import { join as join65 } from "node:path";
 var CACHE_TTL_HOURS = 24;
 var DEFAULT_CACHE_TTL_MS = CACHE_TTL_HOURS * 60 * 60 * 1000;
@@ -79347,7 +79563,7 @@ class ConfigVersionChecker {
   static async loadCache(kitType, global3) {
     try {
       const cachePath = ConfigVersionChecker.getCacheFilePath(kitType, global3);
-      const data = await readFile33(cachePath, "utf8");
+      const data = await readFile34(cachePath, "utf8");
       const parsed = JSON.parse(data);
       if (typeof parsed !== "object" || parsed === null || typeof parsed.lastCheck !== "number" || typeof parsed.latestVersion !== "string" || !parsed.latestVersion || parsed.lastCheck < 0 || parsed.lastCheck > Date.now() + 7 * 24 * 60 * 60 * 1000) {
         logger.debug("Invalid cache structure, ignoring");
@@ -79429,7 +79645,7 @@ class ConfigVersionChecker {
           return null;
         }
         const delay = baseBackoff * 2 ** attempt;
-        await new Promise((resolve15) => setTimeout(resolve15, delay));
+        await new Promise((resolve16) => setTimeout(resolve16, delay));
       }
     }
     return null;
@@ -79504,7 +79720,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 { lstat as lstat3, readFile as readFile35, readlink, realpath as realpath3, stat as stat9 } from "node:fs/promises";
 import { isAbsolute as isAbsolute3, join as join66, normalize as normalize7, relative as relative8 } from "node:path";
 
 // src/services/file-operations/ownership-checker.ts
@@ -79596,24 +79812,24 @@ function pLimit(concurrency) {
     activeCount--;
     resumeNext();
   };
-  const run = async (function_, resolve15, arguments_) => {
+  const run = async (function_, resolve16, arguments_) => {
     const result = (async () => function_(...arguments_))();
-    resolve15(result);
+    resolve16(result);
     try {
       await result;
     } catch {}
     next();
   };
-  const enqueue = (function_, resolve15, arguments_) => {
+  const enqueue = (function_, resolve16, arguments_) => {
     new Promise((internalResolve) => {
       queue.enqueue(internalResolve);
-    }).then(run.bind(undefined, function_, resolve15, arguments_));
+    }).then(run.bind(undefined, function_, resolve16, arguments_));
     if (activeCount < concurrency) {
       resumeNext();
     }
   };
-  const generator = (function_, ...arguments_) => new Promise((resolve15) => {
-    enqueue(function_, resolve15, arguments_);
+  const generator = (function_, ...arguments_) => new Promise((resolve16) => {
+    enqueue(function_, resolve16, arguments_);
   });
   Object.defineProperties(generator, {
     activeCount: {
@@ -79664,12 +79880,12 @@ async function mapWithLimit(items, fn, concurrency = DEFAULT_CONCURRENCY) {
 // src/services/file-operations/ownership-checker.ts
 class OwnershipChecker {
   static async calculateChecksum(filePath) {
-    return new Promise((resolve15, reject) => {
+    return new Promise((resolve16, reject) => {
       const hash = createHash3("sha256");
       const stream = createReadStream2(filePath);
       stream.on("data", (chunk) => hash.update(chunk));
       stream.on("end", () => {
-        resolve15(hash.digest("hex"));
+        resolve16(hash.digest("hex"));
       });
       stream.on("error", (err) => {
         stream.destroy();
@@ -81088,7 +81304,7 @@ class SyncEngine {
       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)`);
       }
-      const buffer = await readFile34(filePath);
+      const buffer = await readFile35(filePath);
       if (buffer.includes(0)) {
         return { content: "", isBinary: true };
       }
@@ -82472,10 +82688,10 @@ init_types3();
 // src/domains/installation/utils/path-security.ts
 init_types3();
 import { lstatSync as lstatSync2, realpathSync as realpathSync3 } from "node:fs";
-import { relative as relative9, resolve as resolve17 } from "node:path";
+import { relative as relative9, resolve as resolve18 } from "node:path";
 var MAX_EXTRACTION_SIZE = 500 * 1024 * 1024;
 function isPathSafe(basePath, targetPath) {
-  const resolvedBase = resolve17(basePath);
+  const resolvedBase = resolve18(basePath);
   try {
     const stat10 = lstatSync2(targetPath);
     if (stat10.isSymbolicLink()) {
@@ -82485,7 +82701,7 @@ function isPathSafe(basePath, targetPath) {
       }
     }
   } catch {}
-  const resolvedTarget = resolve17(targetPath);
+  const resolvedTarget = resolve18(targetPath);
   const relativePath = relative9(resolvedBase, resolvedTarget);
   return !relativePath.startsWith("..") && !relativePath.startsWith("/") && resolvedTarget.startsWith(resolvedBase);
 }
@@ -82573,7 +82789,7 @@ class FileDownloader {
         }
         if (downloadedSize !== totalSize) {
           fileStream.end();
-          await new Promise((resolve18) => fileStream.once("close", resolve18));
+          await new Promise((resolve19) => fileStream.once("close", resolve19));
           try {
             rmSync2(destPath, { force: true });
           } catch (cleanupError) {
@@ -82587,7 +82803,7 @@ class FileDownloader {
         return destPath;
       } catch (error) {
         fileStream.end();
-        await new Promise((resolve18) => fileStream.once("close", resolve18));
+        await new Promise((resolve19) => fileStream.once("close", resolve19));
         try {
           rmSync2(destPath, { force: true });
         } catch (cleanupError) {
@@ -82653,7 +82869,7 @@ class FileDownloader {
       const expectedSize = Number(response.headers.get("content-length"));
       if (expectedSize > 0 && downloadedSize !== expectedSize) {
         fileStream.end();
-        await new Promise((resolve18) => fileStream.once("close", resolve18));
+        await new Promise((resolve19) => fileStream.once("close", resolve19));
         try {
           rmSync2(destPath, { force: true });
         } catch (cleanupError) {
@@ -82671,7 +82887,7 @@ class FileDownloader {
       return destPath;
     } catch (error) {
       fileStream.end();
-      await new Promise((resolve18) => fileStream.once("close", resolve18));
+      await new Promise((resolve19) => fileStream.once("close", resolve19));
       try {
         rmSync2(destPath, { force: true });
       } catch (cleanupError) {
@@ -83270,10 +83486,10 @@ class Minipass extends EventEmitter3 {
     return this[ENCODING] ? buf.join("") : Buffer.concat(buf, buf.dataLength);
   }
   async promise() {
-    return new Promise((resolve18, reject) => {
+    return new Promise((resolve19, reject) => {
       this.on(DESTROYED, () => reject(new Error("stream destroyed")));
       this.on("error", (er) => reject(er));
-      this.on("end", () => resolve18());
+      this.on("end", () => resolve19());
     });
   }
   [Symbol.asyncIterator]() {
@@ -83292,7 +83508,7 @@ class Minipass extends EventEmitter3 {
         return Promise.resolve({ done: false, value: res });
       if (this[EOF])
         return stop();
-      let resolve18;
+      let resolve19;
       let reject;
       const onerr = (er) => {
         this.off("data", ondata);
@@ -83306,19 +83522,19 @@ class Minipass extends EventEmitter3 {
         this.off("end", onend);
         this.off(DESTROYED, ondestroy);
         this.pause();
-        resolve18({ value, done: !!this[EOF] });
+        resolve19({ value, done: !!this[EOF] });
       };
       const onend = () => {
         this.off("error", onerr);
         this.off("data", ondata);
         this.off(DESTROYED, ondestroy);
         stop();
-        resolve18({ done: true, value: undefined });
+        resolve19({ done: true, value: undefined });
       };
       const ondestroy = () => onerr(new Error("stream destroyed"));
       return new Promise((res2, rej) => {
         reject = rej;
-        resolve18 = res2;
+        resolve19 = res2;
         this.once(DESTROYED, ondestroy);
         this.once("error", onerr);
         this.once("end", onend);
@@ -84424,10 +84640,10 @@ class Minipass2 extends EventEmitter4 {
     return this[ENCODING2] ? buf.join("") : Buffer.concat(buf, buf.dataLength);
   }
   async promise() {
-    return new Promise((resolve18, reject) => {
+    return new Promise((resolve19, reject) => {
       this.on(DESTROYED2, () => reject(new Error("stream destroyed")));
       this.on("error", (er) => reject(er));
-      this.on("end", () => resolve18());
+      this.on("end", () => resolve19());
     });
   }
   [Symbol.asyncIterator]() {
@@ -84446,7 +84662,7 @@ class Minipass2 extends EventEmitter4 {
         return Promise.resolve({ done: false, value: res });
       if (this[EOF2])
         return stop();
-      let resolve18;
+      let resolve19;
       let reject;
       const onerr = (er) => {
         this.off("data", ondata);
@@ -84460,19 +84676,19 @@ class Minipass2 extends EventEmitter4 {
         this.off("end", onend);
         this.off(DESTROYED2, ondestroy);
         this.pause();
-        resolve18({ value, done: !!this[EOF2] });
+        resolve19({ value, done: !!this[EOF2] });
       };
       const onend = () => {
         this.off("error", onerr);
         this.off("data", ondata);
         this.off(DESTROYED2, ondestroy);
         stop();
-        resolve18({ done: true, value: undefined });
+        resolve19({ done: true, value: undefined });
       };
       const ondestroy = () => onerr(new Error("stream destroyed"));
       return new Promise((res2, rej) => {
         reject = rej;
-        resolve18 = res2;
+        resolve19 = res2;
         this.once(DESTROYED2, ondestroy);
         this.once("error", onerr);
         this.once("end", onend);
@@ -85900,10 +86116,10 @@ class Minipass3 extends EventEmitter5 {
     return this[ENCODING3] ? buf.join("") : Buffer.concat(buf, buf.dataLength);
   }
   async promise() {
-    return new Promise((resolve18, reject) => {
+    return new Promise((resolve19, reject) => {
       this.on(DESTROYED3, () => reject(new Error("stream destroyed")));
       this.on("error", (er) => reject(er));
-      this.on("end", () => resolve18());
+      this.on("end", () => resolve19());
     });
   }
   [Symbol.asyncIterator]() {
@@ -85922,7 +86138,7 @@ class Minipass3 extends EventEmitter5 {
         return Promise.resolve({ done: false, value: res });
       if (this[EOF3])
         return stop();
-      let resolve18;
+      let resolve19;
       let reject;
       const onerr = (er) => {
         this.off("data", ondata);
@@ -85936,19 +86152,19 @@ class Minipass3 extends EventEmitter5 {
         this.off("end", onend);
         this.off(DESTROYED3, ondestroy);
         this.pause();
-        resolve18({ value, done: !!this[EOF3] });
+        resolve19({ value, done: !!this[EOF3] });
       };
       const onend = () => {
         this.off("error", onerr);
         this.off("data", ondata);
         this.off(DESTROYED3, ondestroy);
         stop();
-        resolve18({ done: true, value: undefined });
+        resolve19({ done: true, value: undefined });
       };
       const ondestroy = () => onerr(new Error("stream destroyed"));
       return new Promise((res2, rej) => {
         reject = rej;
-        resolve18 = res2;
+        resolve19 = res2;
         this.once(DESTROYED3, ondestroy);
         this.once("error", onerr);
         this.once("end", onend);
@@ -86719,9 +86935,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((resolve18, reject) => {
+  const p = new Promise((resolve19, reject) => {
     parse4.on("error", reject);
-    parse4.on("end", resolve18);
+    parse4.on("end", resolve19);
     fs9.stat(file, (er, stat10) => {
       if (er) {
         reject(er);
@@ -89301,9 +89517,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((resolve18, reject) => {
+  const p = new Promise((resolve19, reject) => {
     u.on("error", reject);
-    u.on("close", resolve18);
+    u.on("close", resolve19);
     fs16.stat(file, (er, stat10) => {
       if (er) {
         reject(er);
@@ -89436,7 +89652,7 @@ var replaceAsync = (opt, files) => {
     };
     fs17.read(fd, headBuf, 0, 512, position, onread);
   };
-  const promise = new Promise((resolve18, reject) => {
+  const promise = new Promise((resolve19, reject) => {
     p.on("error", reject);
     let flag = "r+";
     const onopen = (er, fd) => {
@@ -89461,7 +89677,7 @@ var replaceAsync = (opt, files) => {
           });
           p.pipe(stream);
           stream.on("error", reject);
-          stream.on("close", resolve18);
+          stream.on("close", resolve19);
           addFilesAsync2(p, files);
         });
       });
@@ -89735,20 +89951,20 @@ class ZipExtractor {
     if (!isMacOS()) {
       return false;
     }
-    return new Promise((resolve18) => {
+    return new Promise((resolve19) => {
       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}`);
-            resolve18(false);
+            resolve19(false);
             return;
           }
           logger.debug("Native unzip succeeded");
-          resolve18(true);
+          resolve19(true);
         });
       }).catch((err) => {
         logger.debug(`Failed to create directory for native unzip: ${err.message}`);
-        resolve18(false);
+        resolve19(false);
       });
     });
   }
@@ -90261,8 +90477,8 @@ async function handleDownload(ctx) {
 import { join as join97 } from "node:path";
 
 // src/domains/installation/deletion-handler.ts
-import { existsSync as existsSync54, lstatSync as lstatSync3, readdirSync as readdirSync4, rmSync as rmSync3, rmdirSync, unlinkSync as unlinkSync3 } from "node:fs";
-import { dirname as dirname24, join as join84, relative as relative11, resolve as resolve19, sep as sep5 } from "node:path";
+import { existsSync as existsSync55, lstatSync as lstatSync3, readdirSync as readdirSync4, rmSync as rmSync3, rmdirSync, unlinkSync as unlinkSync3 } from "node:fs";
+import { dirname as dirname24, join as join84, relative as relative11, resolve as resolve20, sep as sep5 } from "node:path";
 
 // src/services/file-operations/manifest/manifest-reader.ts
 init_metadata_migration();
@@ -90444,7 +90660,7 @@ function shouldDeletePath(path13, metadata) {
 }
 function collectFilesRecursively(dir, baseDir) {
   const results = [];
-  if (!existsSync54(dir))
+  if (!existsSync55(dir))
     return results;
   try {
     const entries = readdirSync4(dir, { withFileTypes: true });
@@ -90479,8 +90695,8 @@ function expandGlobPatterns(patterns, claudeDir2) {
 }
 var MAX_CLEANUP_ITERATIONS = 50;
 function cleanupEmptyDirectories(filePath, claudeDir2) {
-  const normalizedClaudeDir = resolve19(claudeDir2);
-  let currentDir = resolve19(dirname24(filePath));
+  const normalizedClaudeDir = resolve20(claudeDir2);
+  let currentDir = resolve20(dirname24(filePath));
   let iterations = 0;
   while (currentDir !== normalizedClaudeDir && currentDir.startsWith(normalizedClaudeDir) && iterations < MAX_CLEANUP_ITERATIONS) {
     iterations++;
@@ -90489,7 +90705,7 @@ function cleanupEmptyDirectories(filePath, claudeDir2) {
       if (entries.length === 0) {
         rmdirSync(currentDir);
         logger.debug(`Removed empty directory: ${currentDir}`);
-        currentDir = resolve19(dirname24(currentDir));
+        currentDir = resolve20(dirname24(currentDir));
       } else {
         break;
       }
@@ -90499,8 +90715,8 @@ function cleanupEmptyDirectories(filePath, claudeDir2) {
   }
 }
 function deletePath(fullPath, claudeDir2) {
-  const normalizedPath = resolve19(fullPath);
-  const normalizedClaudeDir = resolve19(claudeDir2);
+  const normalizedPath = resolve20(fullPath);
+  const normalizedClaudeDir = resolve20(claudeDir2);
   if (!normalizedPath.startsWith(`${normalizedClaudeDir}${sep5}`) && normalizedPath !== normalizedClaudeDir) {
     throw new Error(`Path traversal detected: ${fullPath}`);
   }
@@ -90573,8 +90789,8 @@ async function handleDeletions(sourceMetadata, claudeDir2) {
   const result = { deletedPaths: [], preservedPaths: [], errors: [] };
   for (const path13 of deletions) {
     const fullPath = join84(claudeDir2, path13);
-    const normalizedPath = resolve19(fullPath);
-    const normalizedClaudeDir = resolve19(claudeDir2);
+    const normalizedPath = resolve20(fullPath);
+    const normalizedClaudeDir = resolve20(claudeDir2);
     if (!normalizedPath.startsWith(`${normalizedClaudeDir}${sep5}`)) {
       logger.warning(`Skipping invalid path: ${path13}`);
       result.errors.push(path13);
@@ -90585,7 +90801,7 @@ async function handleDeletions(sourceMetadata, claudeDir2) {
       logger.verbose(`Preserved user file: ${path13}`);
       continue;
     }
-    if (existsSync54(fullPath)) {
+    if (existsSync55(fullPath)) {
       try {
         deletePath(fullPath, claudeDir2);
         result.deletedPaths.push(path13);
@@ -92285,8 +92501,8 @@ import { execSync as execSync4 } from "node:child_process";
 
 // src/domains/config/installed-settings-tracker.ts
 init_shared();
-import { existsSync as existsSync55 } from "node:fs";
-import { mkdir as mkdir26, readFile as readFile38, writeFile as writeFile22 } from "node:fs/promises";
+import { existsSync as existsSync56 } from "node:fs";
+import { mkdir as mkdir26, readFile as readFile39, writeFile as writeFile22 } from "node:fs/promises";
 import { dirname as dirname25, join as join86 } from "node:path";
 var CK_JSON_FILE = ".ck.json";
 
@@ -92307,11 +92523,11 @@ class InstalledSettingsTracker {
   }
   async loadInstalledSettings() {
     const ckJsonPath = this.getCkJsonPath();
-    if (!existsSync55(ckJsonPath)) {
+    if (!existsSync56(ckJsonPath)) {
       return { hooks: [], mcpServers: [] };
     }
     try {
-      const content = await readFile38(ckJsonPath, "utf-8");
+      const content = await readFile39(ckJsonPath, "utf-8");
       const data = JSON.parse(content);
       const installed = data.kits?.[this.kitName]?.installedSettings;
       if (installed) {
@@ -92327,8 +92543,8 @@ class InstalledSettingsTracker {
     const ckJsonPath = this.getCkJsonPath();
     try {
       let data = {};
-      if (existsSync55(ckJsonPath)) {
-        const content = await readFile38(ckJsonPath, "utf-8");
+      if (existsSync56(ckJsonPath)) {
+        const content = await readFile39(ckJsonPath, "utf-8");
         data = JSON.parse(content);
       }
       if (!data.kits) {
@@ -93688,7 +93904,7 @@ function buildConflictSummary(fileConflicts, hookConflicts, mcpConflicts) {
 init_logger();
 init_skip_directories();
 var import_fs_extra16 = __toESM(require_lib3(), 1);
-import { join as join92, relative as relative15, resolve as resolve20 } from "node:path";
+import { join as join92, relative as relative15, resolve as resolve21 } from "node:path";
 
 class FileScanner2 {
   static async getFiles(dirPath, relativeTo) {
@@ -93768,8 +93984,8 @@ class FileScanner2 {
     return customFiles;
   }
   static isSafePath(basePath, targetPath) {
-    const resolvedBase = resolve20(basePath);
-    const resolvedTarget = resolve20(targetPath);
+    const resolvedBase = resolve21(basePath);
+    const resolvedTarget = resolve21(targetPath);
     return resolvedTarget.startsWith(resolvedBase);
   }
   static toPosixPath(path14) {
@@ -93785,7 +94001,7 @@ import { join as join94 } 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 { readFile as readFile43, readdir as readdir20, writeFile as writeFile26 } from "node:fs/promises";
 import { join as join93 } from "node:path";
 var TRANSFORMABLE_EXTENSIONS = new Set([
   ".md",
@@ -93855,7 +94071,7 @@ async function transformCommandReferences(directory, options2 = {}) {
         await processDirectory(fullPath);
       } else if (entry.isFile() && shouldTransformFile(entry.name)) {
         try {
-          const content = await readFile42(fullPath, "utf-8");
+          const content = await readFile43(fullPath, "utf-8");
           const { transformed, changes } = transformCommandContent(content);
           if (changes > 0) {
             if (options2.dryRun) {
@@ -94392,7 +94608,7 @@ init_skip_directories();
 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 { readFile as readFile45, readdir as readdir24, writeFile as writeFile27 } from "node:fs/promises";
 import { join as join98, relative as relative16 } from "node:path";
 
 class SkillsManifestManager {
@@ -94426,7 +94642,7 @@ class SkillsManifestManager {
       return null;
     }
     try {
-      const content = await readFile44(manifestPath, "utf-8");
+      const content = await readFile45(manifestPath, "utf-8");
       const data = JSON.parse(content);
       const manifest = SkillsManifestSchema.parse(data);
       logger.debug(`Read manifest from: ${manifestPath}`);
@@ -94498,7 +94714,7 @@ class SkillsManifestManager {
     files.sort();
     for (const file of files) {
       const relativePath = relative16(dirPath, file);
-      const content = await readFile44(file);
+      const content = await readFile45(file);
       hash.update(relativePath);
       hash.update(content);
     }
@@ -95238,7 +95454,7 @@ import { relative as relative18 } from "node:path";
 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 { readFile as readFile46, readdir as readdir28 } from "node:fs/promises";
 import { join as join102, relative as relative17 } from "node:path";
 async function getAllFiles(dirPath) {
   const files = [];
@@ -95258,12 +95474,12 @@ async function getAllFiles(dirPath) {
   return files;
 }
 async function hashFile(filePath) {
-  return new Promise((resolve21, reject) => {
+  return new Promise((resolve22, reject) => {
     const hash = createHash5("sha256");
     const stream = createReadStream3(filePath);
     stream.on("data", (chunk) => hash.update(chunk));
     stream.on("end", () => {
-      resolve21(hash.digest("hex"));
+      resolve22(hash.digest("hex"));
     });
     stream.on("error", (error) => {
       stream.destroy();
@@ -95277,7 +95493,7 @@ async function hashDirectory(dirPath) {
   files.sort();
   for (const file of files) {
     const relativePath = relative17(dirPath, file);
-    const content = await readFile45(file);
+    const content = await readFile46(file);
     hash.update(relativePath);
     hash.update(content);
   }
@@ -95611,7 +95827,7 @@ import { join as join107 } 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 { readFile as readFile47, readdir as readdir30, writeFile as writeFile28 } from "node:fs/promises";
 import { platform as platform12 } from "node:os";
 import { extname as extname6, join as join106 } from "node:path";
 var IS_WINDOWS2 = platform12() === "win32";
@@ -95682,7 +95898,7 @@ async function transformPathsForGlobalOpenCode(directory, options2 = {}) {
         await processDirectory2(fullPath);
       } else if (entry.isFile() && shouldTransformFile2(entry.name)) {
         try {
-          const content = await readFile46(fullPath, "utf-8");
+          const content = await readFile47(fullPath, "utf-8");
           const { transformed, changes } = transformOpenCodeContent(content);
           if (changes > 0) {
             await writeFile28(fullPath, transformed, "utf-8");
@@ -96022,7 +96238,7 @@ async function handlePostInstall(ctx) {
 init_config_manager();
 init_github_client();
 import { mkdir as mkdir30 } from "node:fs/promises";
-import { join as join110, resolve as resolve22 } from "node:path";
+import { join as join110, resolve as resolve23 } from "node:path";
 
 // src/domains/github/kit-access-checker.ts
 init_logger();
@@ -96152,8 +96368,8 @@ async function runPreflightChecks() {
 
 // src/domains/installation/fresh-installer.ts
 init_metadata_migration();
-import { existsSync as existsSync56, readdirSync as readdirSync5, rmSync as rmSync4, rmdirSync as rmdirSync2, unlinkSync as unlinkSync4 } from "node:fs";
-import { dirname as dirname27, join as join109, resolve as resolve21 } from "node:path";
+import { existsSync as existsSync57, readdirSync as readdirSync5, rmSync as rmSync4, rmdirSync as rmdirSync2, unlinkSync as unlinkSync4 } from "node:fs";
+import { dirname as dirname27, join as join109, resolve as resolve22 } from "node:path";
 init_logger();
 init_safe_spinner();
 var import_fs_extra31 = __toESM(require_lib3(), 1);
@@ -96201,15 +96417,15 @@ async function analyzeFreshInstallation(claudeDir2) {
   };
 }
 function cleanupEmptyDirectories2(filePath, claudeDir2) {
-  const normalizedClaudeDir = resolve21(claudeDir2);
-  let currentDir = resolve21(dirname27(filePath));
+  const normalizedClaudeDir = resolve22(claudeDir2);
+  let currentDir = resolve22(dirname27(filePath));
   while (currentDir !== normalizedClaudeDir && currentDir.startsWith(normalizedClaudeDir)) {
     try {
       const entries = readdirSync5(currentDir);
       if (entries.length === 0) {
         rmdirSync2(currentDir);
         logger.debug(`Removed empty directory: ${currentDir}`);
-        currentDir = resolve21(dirname27(currentDir));
+        currentDir = resolve22(dirname27(currentDir));
       } else {
         break;
       }
@@ -96228,7 +96444,7 @@ async function removeFilesByOwnership(claudeDir2, analysis, includeModified) {
   for (const file of filesToRemove) {
     const fullPath = join109(claudeDir2, file.path);
     try {
-      if (existsSync56(fullPath)) {
+      if (existsSync57(fullPath)) {
         unlinkSync4(fullPath);
         removedFiles.push(file.path);
         logger.debug(`Removed: ${file.path}`);
@@ -96521,7 +96737,7 @@ async function handleSelection(ctx) {
       }
     }
   }
-  const resolvedDir = resolve22(targetDir);
+  const resolvedDir = resolve23(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.");
@@ -96695,8 +96911,8 @@ async function handleSelection(ctx) {
   };
 }
 // src/commands/init/phases/sync-handler.ts
-import { copyFile as copyFile8, mkdir as mkdir31, open as open5, readFile as readFile48, rename as rename6, stat as stat17, unlink as unlink11, writeFile as writeFile30 } from "node:fs/promises";
-import { dirname as dirname28, join as join111, resolve as resolve23 } from "node:path";
+import { copyFile as copyFile8, mkdir as mkdir31, open as open5, readFile as readFile49, rename as rename6, stat as stat17, unlink as unlink11, writeFile as writeFile30 } from "node:fs/promises";
+import { dirname as dirname28, join as join111, resolve as resolve24 } from "node:path";
 init_logger();
 init_path_resolver();
 var import_fs_extra33 = __toESM(require_lib3(), 1);
@@ -96705,7 +96921,7 @@ async function handleSync(ctx) {
   if (!ctx.options.sync) {
     return ctx;
   }
-  const resolvedDir = ctx.options.global ? PathResolver.getGlobalKitDir() : resolve23(ctx.options.dir || ".");
+  const resolvedDir = ctx.options.global ? PathResolver.getGlobalKitDir() : resolve24(ctx.options.dir || ".");
   const claudeDir2 = ctx.options.global ? resolvedDir : join111(resolvedDir, ".claude");
   if (!await import_fs_extra33.pathExists(claudeDir2)) {
     logger.error("Cannot sync: no .claude directory found");
@@ -96839,7 +97055,7 @@ async function acquireSyncLock(global3) {
           }
           logger.debug(`Lock stat failed: ${statError}`);
         }
-        await new Promise((resolve24) => setTimeout(resolve24, 100));
+        await new Promise((resolve25) => setTimeout(resolve25, 100));
         continue;
       }
       throw err;
@@ -96863,7 +97079,7 @@ async function executeSyncMerge(ctx) {
     try {
       const sourceMetadataPath = join111(upstreamDir, "metadata.json");
       if (await import_fs_extra33.pathExists(sourceMetadataPath)) {
-        const content = await readFile48(sourceMetadataPath, "utf-8");
+        const content = await readFile49(sourceMetadataPath, "utf-8");
         const sourceMetadata = JSON.parse(content);
         deletions = sourceMetadata.deletions || [];
       }
@@ -97161,7 +97377,7 @@ 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 { readFile as readFile50, readdir as readdir32, writeFile as writeFile31 } from "node:fs/promises";
 import { join as join113, relative as relative20 } from "node:path";
 var TRANSFORMABLE_FILE_PATTERNS = [
   ".md",
@@ -97228,7 +97444,7 @@ async function transformFileContents(dir, compiledReplacements, options2) {
       if (!shouldTransform)
         continue;
       try {
-        const content = await readFile49(fullPath, "utf-8");
+        const content = await readFile50(fullPath, "utf-8");
         let newContent = content;
         let changeCount = 0;
         for (const { regex: regex2, replacement } of compiledReplacements) {
@@ -97350,7 +97566,7 @@ 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 readFile51, readdir as readdir33, writeFile as writeFile32 } from "node:fs/promises";
 import { platform as platform13 } from "node:os";
 import { extname as extname7, join as join114 } from "node:path";
 var IS_WINDOWS3 = platform13() === "win32";
@@ -97470,7 +97686,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 readFile51(fullPath, "utf-8");
           const { transformed, changes } = transformContent(content);
           if (changes > 0) {
             await writeFile32(fullPath, transformed, "utf-8");
@@ -97726,14 +97942,13 @@ async function initCommand(options2) {
 // src/commands/migrate/migrate-command.ts
 init_dist2();
 var import_picocolors28 = __toESM(require_picocolors(), 1);
-import { existsSync as existsSync57 } from "node:fs";
-import { readFile as readFile51, rm as rm14, unlink as unlink12 } from "node:fs/promises";
+import { existsSync as existsSync58 } from "node:fs";
+import { readFile as readFile52, rm as rm14, unlink as unlink12 } from "node:fs/promises";
 import { homedir as homedir30 } from "node:os";
-import { basename as basename16, join as join116, resolve as resolve24 } from "node:path";
+import { basename as basename16, join as join116, resolve as resolve25 } from "node:path";
 init_logger();
 init_agents_discovery();
 init_commands_discovery();
-init_checksum_utils();
 init_codex_toml_installer();
 init_config_discovery();
 
@@ -98060,6 +98275,8 @@ init_portable_installer();
 init_portable_manifest();
 init_portable_registry();
 init_provider_registry();
+init_reconcile_registry_backfill();
+init_reconcile_state_builders();
 init_reconciler();
 init_skills_discovery();
 
@@ -98126,9 +98343,9 @@ function shouldExecuteAction2(action) {
 }
 async function executeDeleteAction(action, options2) {
   const preservePaths = options2?.preservePaths ?? new Set;
-  const shouldPreserveTarget = action.targetPath.length > 0 && preservePaths.has(resolve24(action.targetPath));
+  const shouldPreserveTarget = action.targetPath.length > 0 && preservePaths.has(resolve25(action.targetPath));
   try {
-    if (!shouldPreserveTarget && action.targetPath && existsSync57(action.targetPath)) {
+    if (!shouldPreserveTarget && action.targetPath && existsSync58(action.targetPath)) {
       await rm14(action.targetPath, { recursive: true, force: true });
     }
     await removePortableInstallation(action.item, action.type, action.provider, action.global);
@@ -98153,12 +98370,12 @@ async function executeDeleteAction(action, options2) {
 async function processMetadataDeletions(skillSourcePath, installGlobally) {
   if (!skillSourcePath)
     return;
-  const sourceMetadataPath = join116(resolve24(skillSourcePath, ".."), "metadata.json");
-  if (!existsSync57(sourceMetadataPath))
+  const sourceMetadataPath = join116(resolve25(skillSourcePath, ".."), "metadata.json");
+  if (!existsSync58(sourceMetadataPath))
     return;
   let sourceMetadata;
   try {
-    const content = await readFile51(sourceMetadataPath, "utf-8");
+    const content = await readFile52(sourceMetadataPath, "utf-8");
     sourceMetadata = JSON.parse(content);
   } catch (error) {
     logger.debug(`[migrate] Failed to parse source metadata.json: ${error}`);
@@ -98167,7 +98384,7 @@ async function processMetadataDeletions(skillSourcePath, installGlobally) {
   if (!sourceMetadata.deletions || sourceMetadata.deletions.length === 0)
     return;
   const claudeDir2 = installGlobally ? join116(homedir30(), ".claude") : join116(process.cwd(), ".claude");
-  if (!existsSync57(claudeDir2))
+  if (!existsSync58(claudeDir2))
     return;
   try {
     const result = await handleDeletions(sourceMetadata, claudeDir2);
@@ -98416,9 +98633,9 @@ async function migrateCommand(options2) {
       const interactive = process.stdout.isTTY && !options2.yes;
       const conflictActions = plan.actions.filter((a3) => a3.action === "conflict");
       for (const action of conflictActions) {
-        if (!action.diff && action.targetPath && existsSync57(action.targetPath)) {
+        if (!action.diff && action.targetPath && existsSync58(action.targetPath)) {
           try {
-            const targetContent = await readFile51(action.targetPath, "utf-8");
+            const targetContent = await readFile52(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);
             if (sourceItem) {
               const providerConfig = providers[action.provider];
@@ -98544,26 +98761,16 @@ async function migrateCommand(options2) {
       }
     }
     await processMetadataDeletions(skillSource, installGlobally);
-    const writtenPaths = new Set(allResults.filter((result) => result.success && !result.skipped && result.path.length > 0).map((result) => resolve24(result.path)));
+    const writtenPaths = new Set(allResults.filter((result) => result.success && !result.skipped && result.path.length > 0).map((result) => resolve25(result.path)));
     for (const deleteAction of plannedDeleteActions) {
       allResults.push(await executeDeleteAction(deleteAction, {
         preservePaths: writtenPaths
       }));
     }
-    const skipActionsToPopulate = plan.actions.filter((a3) => a3.action === "skip" && a3.sourceChecksum && !isUnknownChecksum(a3.sourceChecksum) && a3.targetPath);
-    for (const action of skipActionsToPopulate) {
-      const registryEntry = registry.installations.find((i) => i.item === action.item && i.type === action.type && i.provider === action.provider && i.global === action.global);
-      if (registryEntry && isUnknownChecksum(registryEntry.sourceChecksum)) {
-        try {
-          await addPortableInstallation(action.item, action.type, action.provider, action.global, action.targetPath, registryEntry.sourcePath, {
-            sourceChecksum: action.sourceChecksum,
-            targetChecksum: action.currentTargetChecksum,
-            installSource: registryEntry.installSource === "manual" ? "manual" : "kit"
-          });
-        } catch {
-          logger.debug(`Failed to populate checksums for ${action.item} — will retry on next run`);
-        }
-      }
+    try {
+      await backfillRegistryChecksums(plan.actions, registry);
+    } catch {
+      logger.debug("Failed to backfill reconcile registry checksums — will retry on next run");
     }
     for (const provider of selectedProviders) {
       const providerConfig = providers[provider];
@@ -98582,7 +98789,7 @@ async function migrateCommand(options2) {
       }
     }
     try {
-      const kitRoot = (agentSource ? resolve24(agentSource, "..") : null) ?? (commandSource ? resolve24(commandSource, "..") : null) ?? (skillSource ? resolve24(skillSource, "..") : null) ?? null;
+      const kitRoot = (agentSource ? resolve25(agentSource, "..") : null) ?? (commandSource ? resolve25(commandSource, "..") : null) ?? (skillSource ? resolve25(skillSource, "..") : null) ?? null;
       const manifest = kitRoot ? await loadPortableManifest(kitRoot) : null;
       if (manifest?.cliVersion) {
         await updateAppliedManifestVersion(manifest.cliVersion);
@@ -98631,7 +98838,7 @@ async function migrateCommand(options2) {
 }
 async function rollbackResults(results) {
   for (const result of results) {
-    if (!result.path || !existsSync57(result.path))
+    if (!result.path || !existsSync58(result.path))
       continue;
     try {
       if (result.overwritten)
@@ -98645,29 +98852,16 @@ async function rollbackResults(results) {
     } catch {}
   }
 }
+function warnConversionFallback2(warning) {
+  logger.warning(logger.sanitize(`[migrate] Falling back to raw checksum for ${warning.provider} ${warning.type} "${warning.item}" because ${warning.format} conversion failed: ${warning.error}`));
+}
 async function computeSourceStates(items, selectedProviders) {
   const states = [];
   const processItems = async (itemList, type) => {
     for (const item of itemList) {
-      const sourceChecksum = computeContentChecksum(item.body);
-      const convertedChecksums = {};
-      for (const provider of selectedProviders) {
-        const providerConfig = providers[provider];
-        const pathConfigKey = getProviderPathKey(type);
-        const pathConfig = providerConfig[pathConfigKey];
-        if (pathConfig && typeof pathConfig === "object" && "format" in pathConfig) {
-          const converted = convertItem(item, pathConfig.format, provider);
-          if (converted.content) {
-            convertedChecksums[provider] = computeContentChecksum(converted.content);
-          }
-        }
-      }
-      states.push({
-        item: item.name,
-        type,
-        sourceChecksum,
-        convertedChecksums
-      });
+      states.push(buildSourceItemState(item, type, selectedProviders, {
+        onConversionFallback: warnConversionFallback2
+      }));
     }
   };
   await processItems(items.agents, "agent");
@@ -98681,35 +98875,18 @@ async function computeSourceStates(items, selectedProviders) {
 }
 async function computeTargetStates(selectedProviders, global3) {
   const registry = await readPortableRegistry();
-  const states = new Map;
-  for (const entry of registry.installations) {
+  const relevantEntries = registry.installations.filter((entry) => {
     if (!selectedProviders.includes(entry.provider))
-      continue;
+      return false;
     if (entry.global !== global3)
-      continue;
-    if (entry.type === "skill")
-      continue;
-    const exists = existsSync57(entry.path);
-    if (!exists) {
-      states.set(entry.path, {
-        path: entry.path,
-        exists: false
-      });
-      continue;
-    }
-    const state = {
-      path: entry.path,
-      exists: true
-    };
-    try {
-      const content = await readFile51(entry.path, "utf-8");
-      state.currentChecksum = computeContentChecksum(content);
-    } catch (error) {
-      logger.debug(`[migrate] Failed to read target for checksum: ${entry.path} (${String(error)})`);
+      return false;
+    return entry.type !== "skill";
+  });
+  return buildTargetStates(relevantEntries, {
+    onReadFailure: (entryPath, error) => {
+      logger.debug(`[migrate] Failed to read target for checksum: ${entryPath} (${String(error)})`);
     }
-    states.set(entry.path, state);
-  }
-  return states;
+  });
 }
 function displayResults3(results) {
   console.log();
@@ -98761,7 +98938,7 @@ var import_picocolors29 = __toESM(require_picocolors(), 1);
 
 // src/commands/new/phases/directory-setup.ts
 init_config_manager();
-import { resolve as resolve25 } from "node:path";
+import { resolve as resolve26 } from "node:path";
 init_logger();
 init_path_resolver();
 init_types3();
@@ -98846,7 +99023,7 @@ async function directorySetup(validOptions, prompts) {
       targetDir = await prompts.getDirectory(targetDir);
     }
   }
-  const resolvedDir = resolve25(targetDir);
+  const resolvedDir = resolve26(targetDir);
   logger.info(`Target directory: ${resolvedDir}`);
   if (PathResolver.isLocalSameAsGlobal(resolvedDir)) {
     logger.warning("You're creating a project at HOME directory.");
@@ -99179,16 +99356,16 @@ Please use only one download method.`);
 }
 // src/commands/plan/plan-command.ts
 init_output_manager();
-import { existsSync as existsSync59, statSync as statSync8 } from "node:fs";
-import { dirname as dirname30, join as join120, parse as parse6, resolve as resolve28 } from "node:path";
+import { existsSync as existsSync60, statSync as statSync8 } from "node:fs";
+import { dirname as dirname30, join as join120, parse as parse6, resolve as resolve29 } from "node:path";
 
 // src/commands/plan/plan-read-handlers.ts
 init_plan_parser();
 init_logger();
 init_output_manager();
 var import_picocolors30 = __toESM(require_picocolors(), 1);
-import { existsSync as existsSync58, statSync as statSync7 } from "node:fs";
-import { basename as basename17, dirname as dirname29, join as join119, relative as relative21, resolve as resolve26 } from "node:path";
+import { existsSync as existsSync59, statSync as statSync7 } from "node:fs";
+import { basename as basename17, dirname as dirname29, join as join119, relative as relative21, resolve as resolve27 } from "node:path";
 async function handleParse(target, options2) {
   const planFile = resolvePlanFile(target);
   if (!planFile) {
@@ -99263,8 +99440,8 @@ async function handleValidate(target, options2) {
     process.exitCode = 1;
 }
 async function handleStatus(target, options2) {
-  const t = target ? resolve26(target) : null;
-  const plansDir = t && existsSync58(t) && statSync7(t).isDirectory() && !existsSync58(join119(t, "plan.md")) ? t : null;
+  const t = target ? resolve27(target) : null;
+  const plansDir = t && existsSync59(t) && statSync7(t).isDirectory() && !existsSync59(join119(t, "plan.md")) ? t : null;
   if (plansDir) {
     const planFiles = scanPlanDir(plansDir);
     if (planFiles.length === 0) {
@@ -99385,7 +99562,7 @@ async function handleKanban(target, options2) {
 init_plan_parser();
 init_output_manager();
 var import_picocolors31 = __toESM(require_picocolors(), 1);
-import { basename as basename18, relative as relative22, resolve as resolve27 } from "node:path";
+import { basename as basename18, relative as relative22, resolve as resolve28 } from "node:path";
 async function handleCreate(target, options2) {
   if (!options2.title) {
     output.error("[X] --title is required for create");
@@ -99419,7 +99596,7 @@ async function handleCreate(target, options2) {
   const result = scaffoldPlan({
     title: options2.title,
     phases: phaseNames.map((name2) => ({ name: name2 })),
-    dir: resolve27(dir),
+    dir: resolve28(dir),
     priority,
     issue: options2.issue ? Number(options2.issue) : undefined
   });
@@ -99433,7 +99610,7 @@ async function handleCreate(target, options2) {
   }
   console.log();
   console.log(import_picocolors31.default.bold(`  [OK] Plan created: ${options2.title}`));
-  console.log(`  Directory: ${resolve27(dir)}`);
+  console.log(`  Directory: ${resolve28(dir)}`);
   console.log(`  Phases: ${result.phaseFiles.length}`);
   for (const f3 of result.phaseFiles) {
     console.log(`    [ ] ${basename18(f3)}`);
@@ -99531,13 +99708,13 @@ async function handleAddPhase(target, options2) {
 
 // src/commands/plan/plan-command.ts
 function resolvePlanFile(target) {
-  const t = target ? resolve28(target) : process.cwd();
-  if (existsSync59(t)) {
+  const t = target ? resolve29(target) : process.cwd();
+  if (existsSync60(t)) {
     const stat18 = statSync8(t);
     if (stat18.isFile())
       return t;
     const candidate = join120(t, "plan.md");
-    if (existsSync59(candidate))
+    if (existsSync60(candidate))
       return candidate;
   }
   if (!target) {
@@ -99545,7 +99722,7 @@ function resolvePlanFile(target) {
     const root = parse6(dir).root;
     while (dir !== root) {
       const candidate = join120(dir, "plan.md");
-      if (existsSync59(candidate))
+      if (existsSync60(candidate))
         return candidate;
       dir = dirname30(dir);
     }
@@ -99595,7 +99772,7 @@ async function planCommand(action, target, options2) {
   let resolvedTarget = target;
   if (resolvedAction && !knownActions.has(resolvedAction)) {
     const looksLikePath = resolvedAction.includes("/") || resolvedAction.includes("\\") || resolvedAction.endsWith(".md") || resolvedAction === "." || resolvedAction === "..";
-    const existsOnDisk = !looksLikePath && existsSync59(resolve28(resolvedAction));
+    const existsOnDisk = !looksLikePath && existsSync60(resolve29(resolvedAction));
     if (looksLikePath || existsOnDisk) {
       resolvedTarget = resolvedAction;
       resolvedAction = undefined;
@@ -99637,13 +99814,13 @@ init_claudekit_data2();
 init_logger();
 init_safe_prompts();
 var import_picocolors32 = __toESM(require_picocolors(), 1);
-import { existsSync as existsSync60 } from "node:fs";
-import { resolve as resolve29 } from "node:path";
+import { existsSync as existsSync61 } from "node:fs";
+import { resolve as resolve30 } from "node:path";
 async function handleAdd(projectPath, options2) {
   logger.debug(`Adding project: ${projectPath}, options: ${JSON.stringify(options2)}`);
   intro("Add Project");
-  const absolutePath = resolve29(projectPath);
-  if (!existsSync60(absolutePath)) {
+  const absolutePath = resolve30(projectPath);
+  if (!existsSync61(absolutePath)) {
     log.error(`Path does not exist: ${absolutePath}`);
     process.exitCode = 1;
     return;
@@ -100571,7 +100748,7 @@ async function detectInstallations() {
 
 // src/commands/uninstall/removal-handler.ts
 import { readdirSync as readdirSync7, rmSync as rmSync6 } from "node:fs";
-import { join as join122, resolve as resolve30, sep as sep7 } from "node:path";
+import { join as join122, resolve as resolve31, sep as sep7 } from "node:path";
 init_logger();
 init_safe_prompts();
 init_safe_spinner();
@@ -100712,8 +100889,8 @@ async function isDirectory(filePath) {
 }
 async function isPathSafeToRemove(filePath, baseDir) {
   try {
-    const resolvedPath = resolve30(filePath);
-    const resolvedBase = resolve30(baseDir);
+    const resolvedPath = resolve31(filePath);
+    const resolvedBase = resolve31(baseDir);
     if (!resolvedPath.startsWith(resolvedBase + sep7) && resolvedPath !== resolvedBase) {
       logger.debug(`Path outside installation directory: ${filePath}`);
       return false;
@@ -100721,7 +100898,7 @@ async function isPathSafeToRemove(filePath, baseDir) {
     const stats = await import_fs_extra37.lstat(filePath);
     if (stats.isSymbolicLink()) {
       const realPath = await import_fs_extra37.realpath(filePath);
-      const resolvedReal = resolve30(realPath);
+      const resolvedReal = resolve31(realPath);
       if (!resolvedReal.startsWith(resolvedBase + sep7) && resolvedReal !== resolvedBase) {
         logger.debug(`Symlink points outside installation directory: ${filePath} -> ${realPath}`);
         return false;
@@ -101056,7 +101233,7 @@ ${import_picocolors38.default.bold(import_picocolors38.default.cyan(result.kitCo
 
 // src/commands/watch/watch-command.ts
 init_logger();
-import { existsSync as existsSync66 } from "node:fs";
+import { existsSync as existsSync67 } from "node:fs";
 import { rm as rm15 } from "node:fs/promises";
 import { homedir as homedir32 } from "node:os";
 import { join as join129 } from "node:path";
@@ -101128,7 +101305,7 @@ function getDisclaimerMarker() {
   return AI_DISCLAIMER;
 }
 function spawnAndCollect2(command, args) {
-  return new Promise((resolve31, reject) => {
+  return new Promise((resolve32, reject) => {
     const child = spawn5(command, args, { stdio: ["ignore", "pipe", "pipe"] });
     const chunks = [];
     const stderrChunks = [];
@@ -101141,7 +101318,7 @@ function spawnAndCollect2(command, args) {
         reject(new Error(`${command} exited with code ${code2}: ${stderr}`));
         return;
       }
-      resolve31(Buffer.concat(chunks).toString("utf-8"));
+      resolve32(Buffer.concat(chunks).toString("utf-8"));
     });
   });
 }
@@ -101249,7 +101426,7 @@ function formatResponse(content, showBranding) {
   return disclaimer + formatted + branding;
 }
 async function postViaGh(owner, repo, issueNumber, body) {
-  return new Promise((resolve31, reject) => {
+  return new Promise((resolve32, reject) => {
     const args = [
       "issue",
       "comment",
@@ -101271,7 +101448,7 @@ async function postViaGh(owner, repo, issueNumber, body) {
         reject(new Error(`gh exited with code ${code2}: ${stderr}`));
         return;
       }
-      resolve31();
+      resolve32();
     });
   });
 }
@@ -101389,7 +101566,7 @@ After completing the implementation:
     "--allowedTools",
     tools
   ];
-  await new Promise((resolve31, reject) => {
+  await new Promise((resolve32, reject) => {
     const child = spawn7("claude", args, { cwd: cwd2, stdio: ["pipe", "pipe", "pipe"], detached: false });
     child.stdin.write(prompt);
     child.stdin.end();
@@ -101414,7 +101591,7 @@ After completing the implementation:
         reject(new Error(`Claude exited ${code2}: ${stderr.slice(0, 500)}`));
         return;
       }
-      resolve31();
+      resolve32();
     });
   });
 }
@@ -101558,7 +101735,7 @@ function checkRateLimit2(processedThisHour, maxPerHour) {
   return processedThisHour < maxPerHour;
 }
 function spawnAndCollect3(command, args) {
-  return new Promise((resolve31, reject) => {
+  return new Promise((resolve32, reject) => {
     const child = spawn8(command, args, { stdio: ["ignore", "pipe", "pipe"] });
     const chunks = [];
     const stderrChunks = [];
@@ -101571,7 +101748,7 @@ function spawnAndCollect3(command, args) {
         reject(new Error(`${command} exited with code ${code2}: ${stderr}`));
         return;
       }
-      resolve31(Buffer.concat(chunks).toString("utf-8"));
+      resolve32(Buffer.concat(chunks).toString("utf-8"));
     });
   });
 }
@@ -101620,7 +101797,7 @@ async function invokeClaude(options2) {
   return collectClaudeOutput(child, options2.timeoutSec, verbose);
 }
 function collectClaudeOutput(child, timeoutSec, verbose = false) {
-  return new Promise((resolve31, reject) => {
+  return new Promise((resolve32, reject) => {
     const chunks = [];
     const stderrChunks = [];
     child.stdout?.on("data", (chunk) => {
@@ -101650,7 +101827,7 @@ function collectClaudeOutput(child, timeoutSec, verbose = false) {
         reject(new Error(`Claude exited with code ${code2}: ${stderr}`));
         return;
       }
-      resolve31(verbose ? parseStreamJsonOutput(stdout2) : parseClaudeOutput(stdout2));
+      resolve32(verbose ? parseStreamJsonOutput(stdout2) : parseClaudeOutput(stdout2));
     });
   });
 }
@@ -102353,16 +102530,16 @@ function cleanExpiredIssues(state, ttlDays) {
 init_ck_config_manager();
 init_file_io();
 init_logger();
-import { existsSync as existsSync62 } from "node:fs";
-import { mkdir as mkdir33, readFile as readFile53 } from "node:fs/promises";
+import { existsSync as existsSync63 } from "node:fs";
+import { mkdir as mkdir33, readFile as readFile54 } from "node:fs/promises";
 import { dirname as dirname32 } from "node:path";
 var PROCESSED_ISSUES_CAP = 500;
 async function readCkJson(projectDir) {
   const configPath = CkConfigManager.getProjectConfigPath(projectDir);
   try {
-    if (!existsSync62(configPath))
+    if (!existsSync63(configPath))
       return {};
-    const content = await readFile53(configPath, "utf-8");
+    const content = await readFile54(configPath, "utf-8");
     return JSON.parse(content);
   } catch (error) {
     logger.warning(`Failed to parse .ck.json: ${error instanceof Error ? error.message : "Unknown"}`);
@@ -102386,7 +102563,7 @@ async function loadWatchState(projectDir) {
 async function saveWatchState(projectDir, state) {
   const configPath = CkConfigManager.getProjectConfigPath(projectDir);
   const configDir = dirname32(configPath);
-  if (!existsSync62(configDir)) {
+  if (!existsSync63(configDir)) {
     await mkdir33(configDir, { recursive: true });
   }
   const raw2 = await readCkJson(projectDir);
@@ -102513,7 +102690,7 @@ async function processImplementationQueue(state, config, setup, options2, watchL
 // src/commands/watch/phases/repo-scanner.ts
 init_logger();
 import { spawnSync as spawnSync6 } from "node:child_process";
-import { existsSync as existsSync63 } from "node:fs";
+import { existsSync as existsSync64 } from "node:fs";
 import { readdir as readdir36, stat as stat19 } from "node:fs/promises";
 import { join as join126 } from "node:path";
 async function scanForRepos(parentDir) {
@@ -102527,7 +102704,7 @@ async function scanForRepos(parentDir) {
     if (!entryStat.isDirectory())
       continue;
     const gitDir = join126(fullPath, ".git");
-    if (!existsSync63(gitDir))
+    if (!existsSync64(gitDir))
       continue;
     const result = spawnSync6("gh", ["repo", "view", "--json", "owner,name"], {
       encoding: "utf-8",
@@ -102551,7 +102728,7 @@ async function scanForRepos(parentDir) {
 // src/commands/watch/phases/setup-validator.ts
 init_logger();
 import { spawnSync as spawnSync7 } from "node:child_process";
-import { existsSync as existsSync64 } from "node:fs";
+import { existsSync as existsSync65 } from "node:fs";
 import { homedir as homedir31 } from "node:os";
 import { join as join127 } from "node:path";
 async function validateSetup(cwd2) {
@@ -102585,7 +102762,7 @@ Run this command from a directory with a GitHub remote.`);
     throw new Error(`Failed to parse repository info: ${ghRepo.stdout}`);
   }
   const skillsPath = join127(homedir31(), ".claude", "skills");
-  const skillsAvailable = existsSync64(skillsPath);
+  const skillsAvailable = existsSync65(skillsPath);
   if (!skillsAvailable) {
     logger.warning(`ClaudeKit Engineer skills not found at ${skillsPath}`);
   }
@@ -102601,7 +102778,7 @@ Run this command from a directory with a GitHub remote.`);
 init_logger();
 init_path_resolver();
 import { createWriteStream as createWriteStream3, statSync as statSync9 } from "node:fs";
-import { existsSync as existsSync65 } from "node:fs";
+import { existsSync as existsSync66 } from "node:fs";
 import { mkdir as mkdir34, rename as rename8 } from "node:fs/promises";
 import { join as join128 } from "node:path";
 
@@ -102616,7 +102793,7 @@ class WatchLogger {
   }
   async init() {
     try {
-      if (!existsSync65(this.logDir)) {
+      if (!existsSync66(this.logDir)) {
         await mkdir34(this.logDir, { recursive: true });
       }
       const dateStr = formatDate(new Date);
@@ -102800,7 +102977,7 @@ async function watchCommand(options2) {
 }
 async function discoverRepos(options2, watchLog) {
   const cwd2 = process.cwd();
-  const isGitRepo = existsSync66(join129(cwd2, ".git"));
+  const isGitRepo = existsSync67(join129(cwd2, ".git"));
   if (options2.force) {
     await forceRemoveLock(watchLog);
   }
@@ -102909,7 +103086,7 @@ function formatQueueInfo(state) {
   return "idle";
 }
 function sleep(ms) {
-  return new Promise((resolve31) => setTimeout(resolve31, ms));
+  return new Promise((resolve32) => setTimeout(resolve32, ms));
 }
 // src/cli/command-registry.ts
 init_logger();
@@ -103053,7 +103230,7 @@ init_version_checker();
 init_logger();
 init_path_resolver();
 init_types3();
-import { existsSync as existsSync77, readFileSync as readFileSync18 } from "node:fs";
+import { existsSync as existsSync78, readFileSync as readFileSync18 } from "node:fs";
 import { join as join140 } from "node:path";
 var packageVersion = package_default.version;
 function formatInstalledKits(metadata) {
@@ -103090,7 +103267,7 @@ async function displayVersion() {
   const prefix = PathResolver.getPathPrefix(false);
   const localMetadataPath = prefix ? join140(process.cwd(), prefix, "metadata.json") : join140(process.cwd(), "metadata.json");
   const isLocalSameAsGlobal = localMetadataPath === globalMetadataPath;
-  if (!isLocalSameAsGlobal && existsSync77(localMetadataPath)) {
+  if (!isLocalSameAsGlobal && existsSync78(localMetadataPath)) {
     try {
       const rawMetadata = JSON.parse(readFileSync18(localMetadataPath, "utf-8"));
       const metadata = MetadataSchema.parse(rawMetadata);
@@ -103104,7 +103281,7 @@ async function displayVersion() {
       logger.verbose("Failed to parse local metadata.json", { error });
     }
   }
-  if (existsSync77(globalMetadataPath)) {
+  if (existsSync78(globalMetadataPath)) {
     try {
       const rawMetadata = JSON.parse(readFileSync18(globalMetadataPath, "utf-8"));
       const metadata = MetadataSchema.parse(rawMetadata);