claudekit-cli 4.5.2-dev.2 → 4.5.2-dev.3

package/cli-manifest.json

@@ -1,6 +1,6 @@
 {
-	"version": "4.5.2-dev.2",
-	"generatedAt": "2026-07-03T23:45:55.887Z",
+	"version": "4.5.2-dev.3",
+	"generatedAt": "2026-07-06T11:49:03.646Z",
 	"commands": {
 		"agents": {
 			"name": "agents",

package/dist/index.js

@@ -15560,6 +15560,128 @@ var init_types2 = __esm(() => {
   });
 });
 
+// node_modules/compare-versions/lib/umd/index.js
+var require_umd = __commonJS((exports, module) => {
+  (function(global2, factory) {
+    typeof exports === "object" && typeof module !== "undefined" ? factory(exports) : typeof define === "function" && define.amd ? define(["exports"], factory) : (global2 = typeof globalThis !== "undefined" ? globalThis : global2 || self, factory(global2.compareVersions = {}));
+  })(exports, function(exports2) {
+    const semver = /^[v^~<>=]*?(\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+))?(?:-([\da-z\-]+(?:\.[\da-z\-]+)*))?(?:\+[\da-z\-]+(?:\.[\da-z\-]+)*)?)?)?$/i;
+    const validateAndParse = (version) => {
+      if (typeof version !== "string") {
+        throw new TypeError("Invalid argument expected string");
+      }
+      const match = version.match(semver);
+      if (!match) {
+        throw new Error(`Invalid argument not valid semver ('${version}' received)`);
+      }
+      match.shift();
+      return match;
+    };
+    const isWildcard = (s) => s === "*" || s === "x" || s === "X";
+    const tryParse = (v2) => {
+      const n = parseInt(v2, 10);
+      return isNaN(n) ? v2 : n;
+    };
+    const forceType = (a3, b3) => typeof a3 !== typeof b3 ? [String(a3), String(b3)] : [a3, b3];
+    const compareStrings = (a3, b3) => {
+      if (isWildcard(a3) || isWildcard(b3))
+        return 0;
+      const [ap, bp] = forceType(tryParse(a3), tryParse(b3));
+      if (ap > bp)
+        return 1;
+      if (ap < bp)
+        return -1;
+      return 0;
+    };
+    const compareSegments = (a3, b3) => {
+      for (let i = 0;i < Math.max(a3.length, b3.length); i++) {
+        const r2 = compareStrings(a3[i] || "0", b3[i] || "0");
+        if (r2 !== 0)
+          return r2;
+      }
+      return 0;
+    };
+    const compareVersions = (v1, v2) => {
+      const n1 = validateAndParse(v1);
+      const n2 = validateAndParse(v2);
+      const p1 = n1.pop();
+      const p2 = n2.pop();
+      const r2 = compareSegments(n1, n2);
+      if (r2 !== 0)
+        return r2;
+      if (p1 && p2) {
+        return compareSegments(p1.split("."), p2.split("."));
+      } else if (p1 || p2) {
+        return p1 ? -1 : 1;
+      }
+      return 0;
+    };
+    const compare = (v1, v2, operator) => {
+      assertValidOperator(operator);
+      const res = compareVersions(v1, v2);
+      return operatorResMap[operator].includes(res);
+    };
+    const operatorResMap = {
+      ">": [1],
+      ">=": [0, 1],
+      "=": [0],
+      "<=": [-1, 0],
+      "<": [-1],
+      "!=": [-1, 1]
+    };
+    const allowedOperators = Object.keys(operatorResMap);
+    const assertValidOperator = (op) => {
+      if (typeof op !== "string") {
+        throw new TypeError(`Invalid operator type, expected string but got ${typeof op}`);
+      }
+      if (allowedOperators.indexOf(op) === -1) {
+        throw new Error(`Invalid operator, expected one of ${allowedOperators.join("|")}`);
+      }
+    };
+    const satisfies = (version, range) => {
+      range = range.replace(/([><=]+)\s+/g, "$1");
+      if (range.includes("||")) {
+        return range.split("||").some((r5) => satisfies(version, r5));
+      } else if (range.includes(" - ")) {
+        const [a3, b3] = range.split(" - ", 2);
+        return satisfies(version, `>=${a3} <=${b3}`);
+      } else if (range.includes(" ")) {
+        return range.trim().replace(/\s{2,}/g, " ").split(" ").every((r5) => satisfies(version, r5));
+      }
+      const m2 = range.match(/^([<>=~^]+)/);
+      const op = m2 ? m2[1] : "=";
+      if (op !== "^" && op !== "~")
+        return compare(version, range, op);
+      const [v1, v2, v3, , vp] = validateAndParse(version);
+      const [r1, r2, r3, , rp] = validateAndParse(range);
+      const v4 = [v1, v2, v3];
+      const r4 = [r1, r2 !== null && r2 !== undefined ? r2 : "x", r3 !== null && r3 !== undefined ? r3 : "x"];
+      if (rp) {
+        if (!vp)
+          return false;
+        if (compareSegments(v4, r4) !== 0)
+          return false;
+        if (compareSegments(vp.split("."), rp.split(".")) === -1)
+          return false;
+      }
+      const nonZero = r4.findIndex((v5) => v5 !== "0") + 1;
+      const i = op === "~" ? 2 : nonZero > 1 ? nonZero : 1;
+      if (compareSegments(v4.slice(0, i), r4.slice(0, i)) !== 0)
+        return false;
+      if (compareSegments(v4.slice(i), r4.slice(i)) === -1)
+        return false;
+      return true;
+    };
+    const validate = (version) => typeof version === "string" && /^[v\d]/.test(version) && semver.test(version);
+    const validateStrict = (version) => typeof version === "string" && /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/.test(version);
+    exports2.compare = compare;
+    exports2.compareVersions = compareVersions;
+    exports2.satisfies = satisfies;
+    exports2.validate = validate;
+    exports2.validateStrict = validateStrict;
+  });
+});
+
 // src/domains/installation/plugin/install-mode-detector.ts
 import { createHash as createHash4 } from "node:crypto";
 import { existsSync as existsSync6, readFileSync as readFileSync3, readdirSync as readdirSync2, statSync as statSync2 } from "node:fs";
@@ -15605,7 +15727,7 @@ function detectPluginState(claudeDir) {
         state.marketplace = state.marketplace ?? marketplace;
         const versions = safeReaddir(ckDir).filter((v2) => isDir(join6(ckDir, v2)));
         if (versions.length > 0 && state.version === null) {
-          state.version = versions.map((v2) => ({ v: v2, mtime: statMtime(join6(ckDir, v2)) })).sort((a3, b3) => b3.mtime - a3.mtime)[0].v;
+          state.version = selectPluginCacheVersion(versions, ckDir);
         }
         if (!state.installed)
           state.staleCache = true;
@@ -15615,6 +15737,24 @@ function detectPluginState(claudeDir) {
   }
   return state;
 }
+function selectPluginCacheVersion(versions, ckDir) {
+  const comparable = versions.filter(isComparableSemver);
+  if (comparable.length > 0) {
+    return comparable.sort((a3, b3) => import_compare_versions.compareVersions(normalizeVersion(b3), normalizeVersion(a3)))[0];
+  }
+  return versions.map((v2) => ({ v: v2, mtime: statMtime(join6(ckDir, v2)) })).sort((a3, b3) => b3.mtime - a3.mtime)[0].v;
+}
+function isComparableSemver(version) {
+  try {
+    import_compare_versions.compareVersions(normalizeVersion(version), normalizeVersion(version));
+    return true;
+  } catch {
+    return false;
+  }
+}
+function normalizeVersion(version) {
+  return version.replace(/^v/, "");
+}
 function detectLegacyState(claudeDir) {
   const metadata = readJsonSafe(join6(claudeDir, "metadata.json"));
   if (!isRecord(metadata))
@@ -15773,9 +15913,10 @@ function statMtime(p) {
     return 0;
   }
 }
-var CK_PLUGIN_NAME = "ck", CK_MARKETPLACE_NAME = "claudekit", ENGINEER_KIT_KEY = "engineer", PLUGIN_SUPPLIED_LEGACY_PREFIXES;
+var import_compare_versions, CK_PLUGIN_NAME = "ck", CK_MARKETPLACE_NAME = "claudekit", ENGINEER_KIT_KEY = "engineer", PLUGIN_SUPPLIED_LEGACY_PREFIXES;
 var init_install_mode_detector = __esm(() => {
   init_path_resolver();
+  import_compare_versions = __toESM(require_umd(), 1);
   PLUGIN_SUPPLIED_LEGACY_PREFIXES = ["agents/", "skills/"];
 });
 
@@ -64591,7 +64732,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "claudekit-cli",
-    version: "4.5.2-dev.2",
+    version: "4.5.2-dev.3",
     description: "CLI tool for bootstrapping and updating ClaudeKit projects",
     type: "module",
     repository: {
@@ -64713,142 +64854,20 @@ var init_package = __esm(() => {
   };
 });
 
-// node_modules/compare-versions/lib/umd/index.js
-var require_umd = __commonJS((exports, module) => {
-  (function(global3, factory) {
-    typeof exports === "object" && typeof module !== "undefined" ? factory(exports) : typeof define === "function" && define.amd ? define(["exports"], factory) : (global3 = typeof globalThis !== "undefined" ? globalThis : global3 || self, factory(global3.compareVersions = {}));
-  })(exports, function(exports2) {
-    const semver3 = /^[v^~<>=]*?(\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+))?(?:-([\da-z\-]+(?:\.[\da-z\-]+)*))?(?:\+[\da-z\-]+(?:\.[\da-z\-]+)*)?)?)?$/i;
-    const validateAndParse = (version) => {
-      if (typeof version !== "string") {
-        throw new TypeError("Invalid argument expected string");
-      }
-      const match = version.match(semver3);
-      if (!match) {
-        throw new Error(`Invalid argument not valid semver ('${version}' received)`);
-      }
-      match.shift();
-      return match;
-    };
-    const isWildcard = (s) => s === "*" || s === "x" || s === "X";
-    const tryParse = (v2) => {
-      const n = parseInt(v2, 10);
-      return isNaN(n) ? v2 : n;
-    };
-    const forceType = (a3, b3) => typeof a3 !== typeof b3 ? [String(a3), String(b3)] : [a3, b3];
-    const compareStrings = (a3, b3) => {
-      if (isWildcard(a3) || isWildcard(b3))
-        return 0;
-      const [ap, bp] = forceType(tryParse(a3), tryParse(b3));
-      if (ap > bp)
-        return 1;
-      if (ap < bp)
-        return -1;
-      return 0;
-    };
-    const compareSegments = (a3, b3) => {
-      for (let i = 0;i < Math.max(a3.length, b3.length); i++) {
-        const r2 = compareStrings(a3[i] || "0", b3[i] || "0");
-        if (r2 !== 0)
-          return r2;
-      }
-      return 0;
-    };
-    const compareVersions = (v1, v2) => {
-      const n1 = validateAndParse(v1);
-      const n2 = validateAndParse(v2);
-      const p1 = n1.pop();
-      const p2 = n2.pop();
-      const r2 = compareSegments(n1, n2);
-      if (r2 !== 0)
-        return r2;
-      if (p1 && p2) {
-        return compareSegments(p1.split("."), p2.split("."));
-      } else if (p1 || p2) {
-        return p1 ? -1 : 1;
-      }
-      return 0;
-    };
-    const compare = (v1, v2, operator) => {
-      assertValidOperator(operator);
-      const res = compareVersions(v1, v2);
-      return operatorResMap[operator].includes(res);
-    };
-    const operatorResMap = {
-      ">": [1],
-      ">=": [0, 1],
-      "=": [0],
-      "<=": [-1, 0],
-      "<": [-1],
-      "!=": [-1, 1]
-    };
-    const allowedOperators = Object.keys(operatorResMap);
-    const assertValidOperator = (op) => {
-      if (typeof op !== "string") {
-        throw new TypeError(`Invalid operator type, expected string but got ${typeof op}`);
-      }
-      if (allowedOperators.indexOf(op) === -1) {
-        throw new Error(`Invalid operator, expected one of ${allowedOperators.join("|")}`);
-      }
-    };
-    const satisfies = (version, range) => {
-      range = range.replace(/([><=]+)\s+/g, "$1");
-      if (range.includes("||")) {
-        return range.split("||").some((r5) => satisfies(version, r5));
-      } else if (range.includes(" - ")) {
-        const [a3, b3] = range.split(" - ", 2);
-        return satisfies(version, `>=${a3} <=${b3}`);
-      } else if (range.includes(" ")) {
-        return range.trim().replace(/\s{2,}/g, " ").split(" ").every((r5) => satisfies(version, r5));
-      }
-      const m2 = range.match(/^([<>=~^]+)/);
-      const op = m2 ? m2[1] : "=";
-      if (op !== "^" && op !== "~")
-        return compare(version, range, op);
-      const [v1, v2, v3, , vp] = validateAndParse(version);
-      const [r1, r2, r3, , rp] = validateAndParse(range);
-      const v4 = [v1, v2, v3];
-      const r4 = [r1, r2 !== null && r2 !== undefined ? r2 : "x", r3 !== null && r3 !== undefined ? r3 : "x"];
-      if (rp) {
-        if (!vp)
-          return false;
-        if (compareSegments(v4, r4) !== 0)
-          return false;
-        if (compareSegments(vp.split("."), rp.split(".")) === -1)
-          return false;
-      }
-      const nonZero = r4.findIndex((v5) => v5 !== "0") + 1;
-      const i = op === "~" ? 2 : nonZero > 1 ? nonZero : 1;
-      if (compareSegments(v4.slice(0, i), r4.slice(0, i)) !== 0)
-        return false;
-      if (compareSegments(v4.slice(i), r4.slice(i)) === -1)
-        return false;
-      return true;
-    };
-    const validate2 = (version) => typeof version === "string" && /^[v\d]/.test(version) && semver3.test(version);
-    const validateStrict = (version) => typeof version === "string" && /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/.test(version);
-    exports2.compare = compare;
-    exports2.compareVersions = compareVersions;
-    exports2.satisfies = satisfies;
-    exports2.validate = validate2;
-    exports2.validateStrict = validateStrict;
-  });
-});
-
 // src/domains/versioning/checking/version-utils.ts
 function isUpdateCheckDisabled() {
   return process.env.NO_UPDATE_NOTIFIER === "1" || process.env.NO_UPDATE_NOTIFIER === "true" || !process.stdout.isTTY;
 }
-function normalizeVersion(version) {
+function normalizeVersion2(version) {
   return version.replace(/^v/i, "");
 }
 function isPrereleaseVersion(version) {
   if (!version)
     return false;
-  return /-(beta|alpha|rc|dev)[.\d]/i.test(normalizeVersion(version));
+  return /-(beta|alpha|rc|dev)[.\d]/i.test(normalizeVersion2(version));
 }
 function parseVersionParts(version) {
-  const normalized = normalizeVersion(version);
+  const normalized = normalizeVersion2(version);
   const [base, ...prereleaseParts] = normalized.split("-");
   return {
     base,
@@ -64865,23 +64884,23 @@ function isPrereleaseOfSameBase(currentVersion, latestVersion) {
   return current.base === latest.base;
 }
 function versionsMatch(installed, latest) {
-  return normalizeVersion(installed) === normalizeVersion(latest);
+  return normalizeVersion2(installed) === normalizeVersion2(latest);
 }
 function isNewerVersion(currentVersion, latestVersion) {
   try {
-    const current = normalizeVersion(currentVersion);
-    const latest = normalizeVersion(latestVersion);
+    const current = normalizeVersion2(currentVersion);
+    const latest = normalizeVersion2(latestVersion);
     if (isPrereleaseOfSameBase(current, latest)) {
       return false;
     }
-    return import_compare_versions.compareVersions(latest, current) > 0;
+    return import_compare_versions2.compareVersions(latest, current) > 0;
   } catch {
     return false;
   }
 }
-var import_compare_versions;
+var import_compare_versions2;
 var init_version_utils = __esm(() => {
-  import_compare_versions = __toESM(require_umd(), 1);
+  import_compare_versions2 = __toESM(require_umd(), 1);
 });
 
 // src/commands/update/error.ts
@@ -64965,7 +64984,7 @@ var init_registry_client = __esm(() => {
 
 // src/commands/update/version-comparator.ts
 function compareCliVersions(currentVersion, targetVersion, opts) {
-  const comparison = import_compare_versions2.compareVersions(currentVersion, targetVersion);
+  const comparison = import_compare_versions3.compareVersions(currentVersion, targetVersion);
   if (comparison === 0) {
     return { status: "up-to-date" };
   }
@@ -64987,10 +65006,10 @@ function parseCliVersionFromOutput(output2) {
   const match = output2.match(/CLI Version:\s*(\S+)/);
   return match ? match[1] : null;
 }
-var import_compare_versions2;
+var import_compare_versions3;
 var init_version_comparator = __esm(() => {
   init_version_utils();
-  import_compare_versions2 = __toESM(require_umd(), 1);
+  import_compare_versions3 = __toESM(require_umd(), 1);
 });
 
 // src/commands/update/package-manager-runner.ts
@@ -68254,7 +68273,7 @@ class VersionFormatter {
   static compare(v1, v2) {
     const normV1 = VersionFormatter.normalize(v1);
     const normV2 = VersionFormatter.normalize(v2);
-    return import_compare_versions3.compareVersions(normV1, normV2);
+    return import_compare_versions4.compareVersions(normV1, normV2);
   }
   static formatRelativeTime(dateString) {
     if (!dateString)
@@ -68342,20 +68361,20 @@ class VersionFormatter {
       const majorA = Number.parseInt(normA.split(".")[0], 10);
       const majorB = Number.parseInt(normB.split(".")[0], 10);
       if (majorA === 0 && majorB === 0) {
-        return import_compare_versions3.compareVersions(normB, normA);
+        return import_compare_versions4.compareVersions(normB, normA);
       }
       if (majorA === 0)
         return 1;
       if (majorB === 0)
         return -1;
-      return import_compare_versions3.compareVersions(normB, normA);
+      return import_compare_versions4.compareVersions(normB, normA);
     });
   }
 }
-var import_compare_versions3;
+var import_compare_versions4;
 var init_version_formatter = __esm(() => {
   init_logger();
-  import_compare_versions3 = __toESM(require_umd(), 1);
+  import_compare_versions4 = __toESM(require_umd(), 1);
 });
 
 // src/domains/versioning/release-filter.ts
@@ -69700,7 +69719,7 @@ class ConfigVersionChecker {
     return isPrereleaseVersion(currentVersion) ? "beta" : "stable";
   }
   static isValidSemverCore(version) {
-    const [coreVersion] = normalizeVersion(version).split(/[-+]/, 1);
+    const [coreVersion] = normalizeVersion2(version).split(/[-+]/, 1);
     const coreParts = coreVersion?.split(".") ?? [];
     return coreParts.length === 3 && coreParts.every((part) => /^\d+$/.test(part));
   }
@@ -69711,12 +69730,12 @@ class ConfigVersionChecker {
       if (!tagName || tagName.length > 256) {
         continue;
       }
-      const normalizedVersion = normalizeVersion(tagName);
+      const normalizedVersion = normalizeVersion2(tagName);
       if (!ConfigVersionChecker.isValidSemverCore(normalizedVersion)) {
         logger.debug(`Invalid version format from GitHub: ${tagName}`);
         continue;
       }
-      if (!highestVersion || import_compare_versions4.compareVersions(normalizedVersion, highestVersion) > 0) {
+      if (!highestVersion || import_compare_versions5.compareVersions(normalizedVersion, highestVersion) > 0) {
         highestVersion = normalizedVersion;
       }
     }
@@ -69829,7 +69848,7 @@ class ConfigVersionChecker {
     return null;
   }
   static async checkForUpdates(kitType, currentVersion, global3 = false, channel) {
-    const normalizedCurrent = normalizeVersion(currentVersion);
+    const normalizedCurrent = normalizeVersion2(currentVersion);
     const resolvedChannel = ConfigVersionChecker.resolveChannel(normalizedCurrent, channel);
     const cache3 = await ConfigVersionChecker.loadCache(kitType, global3, resolvedChannel);
     const now = Date.now();
@@ -69904,13 +69923,13 @@ class ConfigVersionChecker {
     }
   }
 }
-var import_compare_versions4, CACHE_TTL_HOURS = 24, DEFAULT_CACHE_TTL_MS, MIN_CACHE_TTL_MS, MAX_CACHE_TTL_MS, CACHE_TTL_MS, GITHUB_API_TIMEOUT_MS = 1e4, CACHE_FILENAME = "config-update-cache.json", RELEASES_PER_PAGE = 100, KIT_REPOS;
+var import_compare_versions5, CACHE_TTL_HOURS = 24, DEFAULT_CACHE_TTL_MS, MIN_CACHE_TTL_MS, MAX_CACHE_TTL_MS, CACHE_TTL_MS, GITHUB_API_TIMEOUT_MS = 1e4, CACHE_FILENAME = "config-update-cache.json", RELEASES_PER_PAGE = 100, KIT_REPOS;
 var init_config_version_checker = __esm(() => {
   init_version_utils();
   init_claudekit_constants();
   init_logger();
   init_path_resolver();
-  import_compare_versions4 = __toESM(require_umd(), 1);
+  import_compare_versions5 = __toESM(require_umd(), 1);
   DEFAULT_CACHE_TTL_MS = CACHE_TTL_HOURS * 60 * 60 * 1000;
   MIN_CACHE_TTL_MS = 60 * 1000;
   MAX_CACHE_TTL_MS = 7 * 24 * 60 * 60 * 1000;
@@ -69958,7 +69977,7 @@ function hasCliUpdate(currentVersion, latestVersion) {
     return false;
   }
   try {
-    return import_compare_versions5.compareVersions(normalizeVersion(latestVersion), normalizeVersion(currentVersion)) > 0;
+    return import_compare_versions6.compareVersions(normalizeVersion2(latestVersion), normalizeVersion2(currentVersion)) > 0;
   } catch (error) {
     logger.debug(`Version comparison failed for "${currentVersion}" vs "${latestVersion}": ${error}`);
     return latestVersion !== currentVersion;
@@ -70229,7 +70248,7 @@ async function getKitMetadata2(kitName) {
     return null;
   }
 }
-var import_compare_versions5, versionCache, CACHE_TTL_MS2;
+var import_compare_versions6, versionCache, CACHE_TTL_MS2;
 var init_system_routes = __esm(() => {
   init_update_cli();
   init_github_client();
@@ -70242,7 +70261,7 @@ var init_system_routes = __esm(() => {
   init_path_resolver();
   init_kit();
   init_package();
-  import_compare_versions5 = __toESM(require_umd(), 1);
+  import_compare_versions6 = __toESM(require_umd(), 1);
   versionCache = new Map;
   CACHE_TTL_MS2 = 5 * 60 * 1000;
 });
@@ -88639,7 +88658,7 @@ init_logger();
 import { readFileSync as readFileSync17 } from "node:fs";
 var MIN_GH_CLI_VERSION = "2.20.0";
 var GH_COMMAND_TIMEOUT_MS = 1e4;
-function compareVersions6(a3, b3) {
+function compareVersions7(a3, b3) {
   const partsA = a3.split(".").map(Number);
   const partsB = b3.split(".").map(Number);
   const maxLen = Math.max(partsA.length, partsB.length);
@@ -88860,7 +88879,7 @@ async function getCommandVersion(command, versionFlag, versionRegex) {
     return null;
   }
 }
-function compareVersions7(current, required) {
+function compareVersions8(current, required) {
   const parseCurrent = current.split(".").map((n) => Number.parseInt(n, 10));
   const parseRequired = required.split(".").map((n) => Number.parseInt(n, 10));
   for (let i = 0;i < 3; i++) {
@@ -88884,7 +88903,7 @@ async function checkDependency(config) {
       let meetsRequirements = true;
       let message;
       if (config.minVersion && version) {
-        meetsRequirements = compareVersions7(version, config.minVersion);
+        meetsRequirements = compareVersions8(version, config.minVersion);
         if (!meetsRequirements) {
           message = `Version ${version} is below minimum ${config.minVersion}`;
         }
@@ -89279,7 +89298,7 @@ class SystemChecker {
       const { stdout } = await execAsync6("gh --version");
       const match = stdout.match(/(\d+\.\d+\.\d+)/);
       const version = match?.[1];
-      if (version && compareVersions6(version, MIN_GH_CLI_VERSION) < 0) {
+      if (version && compareVersions7(version, MIN_GH_CLI_VERSION) < 0) {
         return {
           id: "gh-cli-version",
           name: "GitHub CLI",
@@ -109710,6 +109729,7 @@ async function migrateLegacyToPlugin(opts) {
   const ts = opts.now ?? new Date().toISOString();
   const before = detectInstallMode(claudeDir3);
   if (before.mode === "plugin") {
+    prunePluginSuppliedLegacyFilesFromMetadata(claudeDir3);
     return base("noop-already-plugin", before.mode, before.plugin.enabled);
   }
   if (!await installer.isClaudeAvailable() || !await installer.isPluginSupported()) {
@@ -109735,6 +109755,7 @@ async function migrateLegacyToPlugin(opts) {
     backupDir = join137(claudeDir3, "backups", `ck-legacy-${ts.replace(/[:.]/g, "-")}`);
     mkdirSync5(backupDir, { recursive: true });
     removedPaths = removeLegacy(claudeDir3, backupDir);
+    prunePluginSuppliedLegacyFilesFromMetadata(claudeDir3, removedPaths);
   }
   const installedVersion = detectPluginState(claudeDir3).version;
   const receiptPath = writeReceipt(claudeDir3, {
@@ -109958,6 +109979,45 @@ function collectTrackedFiles2(meta) {
   }
   return out;
 }
+function prunePluginSuppliedLegacyFilesFromMetadata(claudeDir3, removedPaths) {
+  const metadataPath = join137(claudeDir3, "metadata.json");
+  const meta = readJsonSafe3(metadataPath);
+  if (!isRecord5(meta))
+    return;
+  const removed = removedPaths ? new Set(removedPaths.map(normalizeComparableLegacyPath).filter(Boolean)) : null;
+  let changed = false;
+  const pruneFiles = (files) => {
+    if (!Array.isArray(files))
+      return files;
+    const pruned = files.filter((file) => {
+      if (!isRecord5(file) || typeof file.path !== "string")
+        return true;
+      const normalizedPath = normalizeComparableLegacyPath(file.path);
+      const resolvedPath = resolveSafePluginSuppliedLegacyPath2(claudeDir3, normalizedPath);
+      const shouldPrune = removed ? removed.has(normalizedPath) || resolvedPath !== null && !existsSync69(resolvedPath.absolutePath) : isPluginSuppliedLegacyPath2(normalizedPath);
+      return !shouldPrune;
+    });
+    if (pruned.length !== files.length)
+      changed = true;
+    return pruned;
+  };
+  if (isRecord5(meta.kits)) {
+    const engineer = meta.kits[ENGINEER_KIT_KEY];
+    if (isRecord5(engineer)) {
+      engineer.files = pruneFiles(engineer.files);
+    }
+  } else {
+    meta.files = pruneFiles(meta.files);
+    meta.installedFiles = pruneFiles(meta.installedFiles);
+  }
+  if (changed) {
+    writeFileSync7(metadataPath, `${JSON.stringify(meta, null, 2)}
+`, "utf-8");
+  }
+}
+function normalizeComparableLegacyPath(pathValue) {
+  return normalizeLegacyPath2(pathValue).replace(/^\.\/+/, "").replace(/^\.claude\//, "");
+}
 function writeReceipt(claudeDir3, receipt) {
   const receiptPath = join137(claudeDir3, ".ck-migration-log.json");
   const existing = readJsonSafe3(receiptPath);
@@ -110401,7 +110461,7 @@ async function runPreflightChecks() {
     return result;
   }
   if (result.ghVersion) {
-    const comparison = compareVersions6(result.ghVersion, MIN_GH_CLI_VERSION);
+    const comparison = compareVersions7(result.ghVersion, MIN_GH_CLI_VERSION);
     result.ghVersionOk = comparison >= 0;
     if (!result.ghVersionOk) {
       logger.debug(`GitHub CLI version ${result.ghVersion} is below minimum ${MIN_GH_CLI_VERSION}`);
@@ -119968,7 +120028,7 @@ init_npm_registry();
 init_claudekit_constants();
 init_logger();
 init_version_utils();
-var import_compare_versions6 = __toESM(require_umd(), 1);
+var import_compare_versions7 = __toESM(require_umd(), 1);
 
 class CliVersionChecker {
   static async check(currentVersion) {
@@ -119982,13 +120042,13 @@ class CliVersionChecker {
         logger.debug("Failed to fetch latest CLI version from npm");
         return null;
       }
-      const current = normalizeVersion(currentVersion);
-      const latest = normalizeVersion(latestVersion);
+      const current = normalizeVersion2(currentVersion);
+      const latest = normalizeVersion2(latestVersion);
       if (isPrereleaseOfSameBase(current, latest)) {
         logger.debug(`CLI version check: skipping update - prerelease (${current}) is same base as stable (${latest})`);
         return null;
       }
-      const updateAvailable = import_compare_versions6.compareVersions(latest, current) > 0;
+      const updateAvailable = import_compare_versions7.compareVersions(latest, current) > 0;
       logger.debug(`CLI version check: current=${current}, latest=${latest}, updateAvailable=${updateAvailable}`);
       return {
         currentVersion: current,
@@ -120026,8 +120086,8 @@ function displayKitNotification(result, options2 = {}) {
     return;
   const { currentVersion, latestVersion } = result;
   const { isGlobal = false, kitName } = options2;
-  const displayCurrent = normalizeVersion(currentVersion);
-  const displayLatest = normalizeVersion(latestVersion);
+  const displayCurrent = normalizeVersion2(currentVersion);
+  const displayLatest = normalizeVersion2(latestVersion);
   const boxWidth = 52;
   const { topBorder, bottomBorder, emptyLine, padLine } = createNotificationBox2(import_picocolors44.default.cyan, boxWidth);
   const headerText = import_picocolors44.default.bold(import_picocolors44.default.yellow("⬆ Kit Update Available"));

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "claudekit-cli",
-	"version": "4.5.2-dev.2",
+	"version": "4.5.2-dev.3",
 	"description": "CLI tool for bootstrapping and updating ClaudeKit projects",
 	"type": "module",
 	"repository": {