claudekit-cli 3.16.0 → 3.18.0

package/dist/index.js

@@ -6589,7 +6589,7 @@ var init_kit = __esm(() => {
       name: "ClaudeKit Marketing",
       repo: "claudekit-marketing",
       owner: "claudekit",
-      description: "[Coming Soon] Marketing toolkit"
+      description: "Marketing automation toolkit for Claude"
     }
   };
   NEVER_COPY_PATTERNS = [
@@ -6740,11 +6740,15 @@ var init_metadata = __esm(() => {
     checksum: exports_external.string().regex(/^[a-f0-9]{64}$/, "Invalid SHA-256 checksum"),
     ownership: exports_external.enum(["ck", "user", "ck-modified"]),
     installedVersion: exports_external.string(),
-    baseChecksum: exports_external.string().regex(/^[a-f0-9]{64}$/, "Invalid SHA-256 checksum").optional()
+    baseChecksum: exports_external.string().regex(/^[a-f0-9]{64}$/, "Invalid SHA-256 checksum").optional(),
+    sourceTimestamp: exports_external.string().datetime({ offset: true }).optional(),
+    installedAt: exports_external.string().datetime({ offset: true }).optional()
   });
   InstalledSettingsSchema = exports_external.object({
     hooks: exports_external.array(exports_external.string()).optional(),
-    mcpServers: exports_external.array(exports_external.string()).optional()
+    mcpServers: exports_external.array(exports_external.string()).optional(),
+    hookTimestamps: exports_external.record(exports_external.string()).optional(),
+    mcpServerTimestamps: exports_external.record(exports_external.string()).optional()
   });
   KitMetadataSchema = exports_external.object({
     version: exports_external.string(),
@@ -13341,6 +13345,1789 @@ var require_extract_zip = __commonJS((exports, module) => {
   };
 });
 
+// node_modules/semver/internal/constants.js
+var require_constants = __commonJS((exports, module) => {
+  var SEMVER_SPEC_VERSION = "2.0.0";
+  var MAX_LENGTH = 256;
+  var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || 9007199254740991;
+  var MAX_SAFE_COMPONENT_LENGTH = 16;
+  var MAX_SAFE_BUILD_LENGTH = MAX_LENGTH - 6;
+  var RELEASE_TYPES = [
+    "major",
+    "premajor",
+    "minor",
+    "preminor",
+    "patch",
+    "prepatch",
+    "prerelease"
+  ];
+  module.exports = {
+    MAX_LENGTH,
+    MAX_SAFE_COMPONENT_LENGTH,
+    MAX_SAFE_BUILD_LENGTH,
+    MAX_SAFE_INTEGER,
+    RELEASE_TYPES,
+    SEMVER_SPEC_VERSION,
+    FLAG_INCLUDE_PRERELEASE: 1,
+    FLAG_LOOSE: 2
+  };
+});
+
+// node_modules/semver/internal/debug.js
+var require_debug = __commonJS((exports, module) => {
+  var debug = typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...args) => console.error("SEMVER", ...args) : () => {};
+  module.exports = debug;
+});
+
+// node_modules/semver/internal/re.js
+var require_re = __commonJS((exports, module) => {
+  var {
+    MAX_SAFE_COMPONENT_LENGTH,
+    MAX_SAFE_BUILD_LENGTH,
+    MAX_LENGTH
+  } = require_constants();
+  var debug = require_debug();
+  exports = module.exports = {};
+  var re2 = exports.re = [];
+  var safeRe = exports.safeRe = [];
+  var src = exports.src = [];
+  var safeSrc = exports.safeSrc = [];
+  var t = exports.t = {};
+  var R3 = 0;
+  var LETTERDASHNUMBER = "[a-zA-Z0-9-]";
+  var safeRegexReplacements = [
+    ["\\s", 1],
+    ["\\d", MAX_LENGTH],
+    [LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH]
+  ];
+  var makeSafeRegex = (value) => {
+    for (const [token, max] of safeRegexReplacements) {
+      value = value.split(`${token}*`).join(`${token}{0,${max}}`).split(`${token}+`).join(`${token}{1,${max}}`);
+    }
+    return value;
+  };
+  var createToken = (name2, value, isGlobal) => {
+    const safe = makeSafeRegex(value);
+    const index = R3++;
+    debug(name2, index, value);
+    t[name2] = index;
+    src[index] = value;
+    safeSrc[index] = safe;
+    re2[index] = new RegExp(value, isGlobal ? "g" : undefined);
+    safeRe[index] = new RegExp(safe, isGlobal ? "g" : undefined);
+  };
+  createToken("NUMERICIDENTIFIER", "0|[1-9]\\d*");
+  createToken("NUMERICIDENTIFIERLOOSE", "\\d+");
+  createToken("NONNUMERICIDENTIFIER", `\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`);
+  createToken("MAINVERSION", `(${src[t.NUMERICIDENTIFIER]})\\.` + `(${src[t.NUMERICIDENTIFIER]})\\.` + `(${src[t.NUMERICIDENTIFIER]})`);
+  createToken("MAINVERSIONLOOSE", `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.` + `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.` + `(${src[t.NUMERICIDENTIFIERLOOSE]})`);
+  createToken("PRERELEASEIDENTIFIER", `(?:${src[t.NONNUMERICIDENTIFIER]}|${src[t.NUMERICIDENTIFIER]})`);
+  createToken("PRERELEASEIDENTIFIERLOOSE", `(?:${src[t.NONNUMERICIDENTIFIER]}|${src[t.NUMERICIDENTIFIERLOOSE]})`);
+  createToken("PRERELEASE", `(?:-(${src[t.PRERELEASEIDENTIFIER]}(?:\\.${src[t.PRERELEASEIDENTIFIER]})*))`);
+  createToken("PRERELEASELOOSE", `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`);
+  createToken("BUILDIDENTIFIER", `${LETTERDASHNUMBER}+`);
+  createToken("BUILD", `(?:\\+(${src[t.BUILDIDENTIFIER]}(?:\\.${src[t.BUILDIDENTIFIER]})*))`);
+  createToken("FULLPLAIN", `v?${src[t.MAINVERSION]}${src[t.PRERELEASE]}?${src[t.BUILD]}?`);
+  createToken("FULL", `^${src[t.FULLPLAIN]}$`);
+  createToken("LOOSEPLAIN", `[v=\\s]*${src[t.MAINVERSIONLOOSE]}${src[t.PRERELEASELOOSE]}?${src[t.BUILD]}?`);
+  createToken("LOOSE", `^${src[t.LOOSEPLAIN]}$`);
+  createToken("GTLT", "((?:<|>)?=?)");
+  createToken("XRANGEIDENTIFIERLOOSE", `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
+  createToken("XRANGEIDENTIFIER", `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`);
+  createToken("XRANGEPLAIN", `[v=\\s]*(${src[t.XRANGEIDENTIFIER]})` + `(?:\\.(${src[t.XRANGEIDENTIFIER]})` + `(?:\\.(${src[t.XRANGEIDENTIFIER]})` + `(?:${src[t.PRERELEASE]})?${src[t.BUILD]}?` + `)?)?`);
+  createToken("XRANGEPLAINLOOSE", `[v=\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})` + `(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` + `(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` + `(?:${src[t.PRERELEASELOOSE]})?${src[t.BUILD]}?` + `)?)?`);
+  createToken("XRANGE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAIN]}$`);
+  createToken("XRANGELOOSE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAINLOOSE]}$`);
+  createToken("COERCEPLAIN", `${"(^|[^\\d])" + "(\\d{1,"}${MAX_SAFE_COMPONENT_LENGTH}})` + `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` + `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?`);
+  createToken("COERCE", `${src[t.COERCEPLAIN]}(?:$|[^\\d])`);
+  createToken("COERCEFULL", src[t.COERCEPLAIN] + `(?:${src[t.PRERELEASE]})?` + `(?:${src[t.BUILD]})?` + `(?:$|[^\\d])`);
+  createToken("COERCERTL", src[t.COERCE], true);
+  createToken("COERCERTLFULL", src[t.COERCEFULL], true);
+  createToken("LONETILDE", "(?:~>?)");
+  createToken("TILDETRIM", `(\\s*)${src[t.LONETILDE]}\\s+`, true);
+  exports.tildeTrimReplace = "$1~";
+  createToken("TILDE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`);
+  createToken("TILDELOOSE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`);
+  createToken("LONECARET", "(?:\\^)");
+  createToken("CARETTRIM", `(\\s*)${src[t.LONECARET]}\\s+`, true);
+  exports.caretTrimReplace = "$1^";
+  createToken("CARET", `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`);
+  createToken("CARETLOOSE", `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`);
+  createToken("COMPARATORLOOSE", `^${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]})$|^$`);
+  createToken("COMPARATOR", `^${src[t.GTLT]}\\s*(${src[t.FULLPLAIN]})$|^$`);
+  createToken("COMPARATORTRIM", `(\\s*)${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true);
+  exports.comparatorTrimReplace = "$1$2$3";
+  createToken("HYPHENRANGE", `^\\s*(${src[t.XRANGEPLAIN]})` + `\\s+-\\s+` + `(${src[t.XRANGEPLAIN]})` + `\\s*$`);
+  createToken("HYPHENRANGELOOSE", `^\\s*(${src[t.XRANGEPLAINLOOSE]})` + `\\s+-\\s+` + `(${src[t.XRANGEPLAINLOOSE]})` + `\\s*$`);
+  createToken("STAR", "(<|>)?=?\\s*\\*");
+  createToken("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$");
+  createToken("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$");
+});
+
+// node_modules/semver/internal/parse-options.js
+var require_parse_options = __commonJS((exports, module) => {
+  var looseOption = Object.freeze({ loose: true });
+  var emptyOpts = Object.freeze({});
+  var parseOptions = (options) => {
+    if (!options) {
+      return emptyOpts;
+    }
+    if (typeof options !== "object") {
+      return looseOption;
+    }
+    return options;
+  };
+  module.exports = parseOptions;
+});
+
+// node_modules/semver/internal/identifiers.js
+var require_identifiers = __commonJS((exports, module) => {
+  var numeric = /^[0-9]+$/;
+  var compareIdentifiers = (a3, b3) => {
+    if (typeof a3 === "number" && typeof b3 === "number") {
+      return a3 === b3 ? 0 : a3 < b3 ? -1 : 1;
+    }
+    const anum = numeric.test(a3);
+    const bnum = numeric.test(b3);
+    if (anum && bnum) {
+      a3 = +a3;
+      b3 = +b3;
+    }
+    return a3 === b3 ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a3 < b3 ? -1 : 1;
+  };
+  var rcompareIdentifiers = (a3, b3) => compareIdentifiers(b3, a3);
+  module.exports = {
+    compareIdentifiers,
+    rcompareIdentifiers
+  };
+});
+
+// node_modules/semver/classes/semver.js
+var require_semver = __commonJS((exports, module) => {
+  var debug = require_debug();
+  var { MAX_LENGTH, MAX_SAFE_INTEGER } = require_constants();
+  var { safeRe: re2, t } = require_re();
+  var parseOptions = require_parse_options();
+  var { compareIdentifiers } = require_identifiers();
+
+  class SemVer {
+    constructor(version, options) {
+      options = parseOptions(options);
+      if (version instanceof SemVer) {
+        if (version.loose === !!options.loose && version.includePrerelease === !!options.includePrerelease) {
+          return version;
+        } else {
+          version = version.version;
+        }
+      } else if (typeof version !== "string") {
+        throw new TypeError(`Invalid version. Must be a string. Got type "${typeof version}".`);
+      }
+      if (version.length > MAX_LENGTH) {
+        throw new TypeError(`version is longer than ${MAX_LENGTH} characters`);
+      }
+      debug("SemVer", version, options);
+      this.options = options;
+      this.loose = !!options.loose;
+      this.includePrerelease = !!options.includePrerelease;
+      const m2 = version.trim().match(options.loose ? re2[t.LOOSE] : re2[t.FULL]);
+      if (!m2) {
+        throw new TypeError(`Invalid Version: ${version}`);
+      }
+      this.raw = version;
+      this.major = +m2[1];
+      this.minor = +m2[2];
+      this.patch = +m2[3];
+      if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
+        throw new TypeError("Invalid major version");
+      }
+      if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
+        throw new TypeError("Invalid minor version");
+      }
+      if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
+        throw new TypeError("Invalid patch version");
+      }
+      if (!m2[4]) {
+        this.prerelease = [];
+      } else {
+        this.prerelease = m2[4].split(".").map((id) => {
+          if (/^[0-9]+$/.test(id)) {
+            const num = +id;
+            if (num >= 0 && num < MAX_SAFE_INTEGER) {
+              return num;
+            }
+          }
+          return id;
+        });
+      }
+      this.build = m2[5] ? m2[5].split(".") : [];
+      this.format();
+    }
+    format() {
+      this.version = `${this.major}.${this.minor}.${this.patch}`;
+      if (this.prerelease.length) {
+        this.version += `-${this.prerelease.join(".")}`;
+      }
+      return this.version;
+    }
+    toString() {
+      return this.version;
+    }
+    compare(other) {
+      debug("SemVer.compare", this.version, this.options, other);
+      if (!(other instanceof SemVer)) {
+        if (typeof other === "string" && other === this.version) {
+          return 0;
+        }
+        other = new SemVer(other, this.options);
+      }
+      if (other.version === this.version) {
+        return 0;
+      }
+      return this.compareMain(other) || this.comparePre(other);
+    }
+    compareMain(other) {
+      if (!(other instanceof SemVer)) {
+        other = new SemVer(other, this.options);
+      }
+      if (this.major < other.major) {
+        return -1;
+      }
+      if (this.major > other.major) {
+        return 1;
+      }
+      if (this.minor < other.minor) {
+        return -1;
+      }
+      if (this.minor > other.minor) {
+        return 1;
+      }
+      if (this.patch < other.patch) {
+        return -1;
+      }
+      if (this.patch > other.patch) {
+        return 1;
+      }
+      return 0;
+    }
+    comparePre(other) {
+      if (!(other instanceof SemVer)) {
+        other = new SemVer(other, this.options);
+      }
+      if (this.prerelease.length && !other.prerelease.length) {
+        return -1;
+      } else if (!this.prerelease.length && other.prerelease.length) {
+        return 1;
+      } else if (!this.prerelease.length && !other.prerelease.length) {
+        return 0;
+      }
+      let i = 0;
+      do {
+        const a3 = this.prerelease[i];
+        const b3 = other.prerelease[i];
+        debug("prerelease compare", i, a3, b3);
+        if (a3 === undefined && b3 === undefined) {
+          return 0;
+        } else if (b3 === undefined) {
+          return 1;
+        } else if (a3 === undefined) {
+          return -1;
+        } else if (a3 === b3) {
+          continue;
+        } else {
+          return compareIdentifiers(a3, b3);
+        }
+      } while (++i);
+    }
+    compareBuild(other) {
+      if (!(other instanceof SemVer)) {
+        other = new SemVer(other, this.options);
+      }
+      let i = 0;
+      do {
+        const a3 = this.build[i];
+        const b3 = other.build[i];
+        debug("build compare", i, a3, b3);
+        if (a3 === undefined && b3 === undefined) {
+          return 0;
+        } else if (b3 === undefined) {
+          return 1;
+        } else if (a3 === undefined) {
+          return -1;
+        } else if (a3 === b3) {
+          continue;
+        } else {
+          return compareIdentifiers(a3, b3);
+        }
+      } while (++i);
+    }
+    inc(release, identifier, identifierBase) {
+      if (release.startsWith("pre")) {
+        if (!identifier && identifierBase === false) {
+          throw new Error("invalid increment argument: identifier is empty");
+        }
+        if (identifier) {
+          const match = `-${identifier}`.match(this.options.loose ? re2[t.PRERELEASELOOSE] : re2[t.PRERELEASE]);
+          if (!match || match[1] !== identifier) {
+            throw new Error(`invalid identifier: ${identifier}`);
+          }
+        }
+      }
+      switch (release) {
+        case "premajor":
+          this.prerelease.length = 0;
+          this.patch = 0;
+          this.minor = 0;
+          this.major++;
+          this.inc("pre", identifier, identifierBase);
+          break;
+        case "preminor":
+          this.prerelease.length = 0;
+          this.patch = 0;
+          this.minor++;
+          this.inc("pre", identifier, identifierBase);
+          break;
+        case "prepatch":
+          this.prerelease.length = 0;
+          this.inc("patch", identifier, identifierBase);
+          this.inc("pre", identifier, identifierBase);
+          break;
+        case "prerelease":
+          if (this.prerelease.length === 0) {
+            this.inc("patch", identifier, identifierBase);
+          }
+          this.inc("pre", identifier, identifierBase);
+          break;
+        case "release":
+          if (this.prerelease.length === 0) {
+            throw new Error(`version ${this.raw} is not a prerelease`);
+          }
+          this.prerelease.length = 0;
+          break;
+        case "major":
+          if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) {
+            this.major++;
+          }
+          this.minor = 0;
+          this.patch = 0;
+          this.prerelease = [];
+          break;
+        case "minor":
+          if (this.patch !== 0 || this.prerelease.length === 0) {
+            this.minor++;
+          }
+          this.patch = 0;
+          this.prerelease = [];
+          break;
+        case "patch":
+          if (this.prerelease.length === 0) {
+            this.patch++;
+          }
+          this.prerelease = [];
+          break;
+        case "pre": {
+          const base = Number(identifierBase) ? 1 : 0;
+          if (this.prerelease.length === 0) {
+            this.prerelease = [base];
+          } else {
+            let i = this.prerelease.length;
+            while (--i >= 0) {
+              if (typeof this.prerelease[i] === "number") {
+                this.prerelease[i]++;
+                i = -2;
+              }
+            }
+            if (i === -1) {
+              if (identifier === this.prerelease.join(".") && identifierBase === false) {
+                throw new Error("invalid increment argument: identifier already exists");
+              }
+              this.prerelease.push(base);
+            }
+          }
+          if (identifier) {
+            let prerelease = [identifier, base];
+            if (identifierBase === false) {
+              prerelease = [identifier];
+            }
+            if (compareIdentifiers(this.prerelease[0], identifier) === 0) {
+              if (isNaN(this.prerelease[1])) {
+                this.prerelease = prerelease;
+              }
+            } else {
+              this.prerelease = prerelease;
+            }
+          }
+          break;
+        }
+        default:
+          throw new Error(`invalid increment argument: ${release}`);
+      }
+      this.raw = this.format();
+      if (this.build.length) {
+        this.raw += `+${this.build.join(".")}`;
+      }
+      return this;
+    }
+  }
+  module.exports = SemVer;
+});
+
+// node_modules/semver/functions/parse.js
+var require_parse = __commonJS((exports, module) => {
+  var SemVer = require_semver();
+  var parse5 = (version, options, throwErrors = false) => {
+    if (version instanceof SemVer) {
+      return version;
+    }
+    try {
+      return new SemVer(version, options);
+    } catch (er) {
+      if (!throwErrors) {
+        return null;
+      }
+      throw er;
+    }
+  };
+  module.exports = parse5;
+});
+
+// node_modules/semver/functions/valid.js
+var require_valid = __commonJS((exports, module) => {
+  var parse5 = require_parse();
+  var valid = (version, options) => {
+    const v2 = parse5(version, options);
+    return v2 ? v2.version : null;
+  };
+  module.exports = valid;
+});
+
+// node_modules/semver/functions/clean.js
+var require_clean = __commonJS((exports, module) => {
+  var parse5 = require_parse();
+  var clean = (version, options) => {
+    const s = parse5(version.trim().replace(/^[=v]+/, ""), options);
+    return s ? s.version : null;
+  };
+  module.exports = clean;
+});
+
+// node_modules/semver/functions/inc.js
+var require_inc = __commonJS((exports, module) => {
+  var SemVer = require_semver();
+  var inc = (version, release, options, identifier, identifierBase) => {
+    if (typeof options === "string") {
+      identifierBase = identifier;
+      identifier = options;
+      options = undefined;
+    }
+    try {
+      return new SemVer(version instanceof SemVer ? version.version : version, options).inc(release, identifier, identifierBase).version;
+    } catch (er) {
+      return null;
+    }
+  };
+  module.exports = inc;
+});
+
+// node_modules/semver/functions/diff.js
+var require_diff = __commonJS((exports, module) => {
+  var parse5 = require_parse();
+  var diff = (version1, version2) => {
+    const v1 = parse5(version1, null, true);
+    const v2 = parse5(version2, null, true);
+    const comparison = v1.compare(v2);
+    if (comparison === 0) {
+      return null;
+    }
+    const v1Higher = comparison > 0;
+    const highVersion = v1Higher ? v1 : v2;
+    const lowVersion = v1Higher ? v2 : v1;
+    const highHasPre = !!highVersion.prerelease.length;
+    const lowHasPre = !!lowVersion.prerelease.length;
+    if (lowHasPre && !highHasPre) {
+      if (!lowVersion.patch && !lowVersion.minor) {
+        return "major";
+      }
+      if (lowVersion.compareMain(highVersion) === 0) {
+        if (lowVersion.minor && !lowVersion.patch) {
+          return "minor";
+        }
+        return "patch";
+      }
+    }
+    const prefix = highHasPre ? "pre" : "";
+    if (v1.major !== v2.major) {
+      return prefix + "major";
+    }
+    if (v1.minor !== v2.minor) {
+      return prefix + "minor";
+    }
+    if (v1.patch !== v2.patch) {
+      return prefix + "patch";
+    }
+    return "prerelease";
+  };
+  module.exports = diff;
+});
+
+// node_modules/semver/functions/major.js
+var require_major = __commonJS((exports, module) => {
+  var SemVer = require_semver();
+  var major = (a3, loose) => new SemVer(a3, loose).major;
+  module.exports = major;
+});
+
+// node_modules/semver/functions/minor.js
+var require_minor = __commonJS((exports, module) => {
+  var SemVer = require_semver();
+  var minor = (a3, loose) => new SemVer(a3, loose).minor;
+  module.exports = minor;
+});
+
+// node_modules/semver/functions/patch.js
+var require_patch = __commonJS((exports, module) => {
+  var SemVer = require_semver();
+  var patch = (a3, loose) => new SemVer(a3, loose).patch;
+  module.exports = patch;
+});
+
+// node_modules/semver/functions/prerelease.js
+var require_prerelease = __commonJS((exports, module) => {
+  var parse5 = require_parse();
+  var prerelease = (version, options) => {
+    const parsed = parse5(version, options);
+    return parsed && parsed.prerelease.length ? parsed.prerelease : null;
+  };
+  module.exports = prerelease;
+});
+
+// node_modules/semver/functions/compare.js
+var require_compare = __commonJS((exports, module) => {
+  var SemVer = require_semver();
+  var compare = (a3, b3, loose) => new SemVer(a3, loose).compare(new SemVer(b3, loose));
+  module.exports = compare;
+});
+
+// node_modules/semver/functions/rcompare.js
+var require_rcompare = __commonJS((exports, module) => {
+  var compare = require_compare();
+  var rcompare = (a3, b3, loose) => compare(b3, a3, loose);
+  module.exports = rcompare;
+});
+
+// node_modules/semver/functions/compare-loose.js
+var require_compare_loose = __commonJS((exports, module) => {
+  var compare = require_compare();
+  var compareLoose = (a3, b3) => compare(a3, b3, true);
+  module.exports = compareLoose;
+});
+
+// node_modules/semver/functions/compare-build.js
+var require_compare_build = __commonJS((exports, module) => {
+  var SemVer = require_semver();
+  var compareBuild = (a3, b3, loose) => {
+    const versionA = new SemVer(a3, loose);
+    const versionB = new SemVer(b3, loose);
+    return versionA.compare(versionB) || versionA.compareBuild(versionB);
+  };
+  module.exports = compareBuild;
+});
+
+// node_modules/semver/functions/sort.js
+var require_sort = __commonJS((exports, module) => {
+  var compareBuild = require_compare_build();
+  var sort = (list3, loose) => list3.sort((a3, b3) => compareBuild(a3, b3, loose));
+  module.exports = sort;
+});
+
+// node_modules/semver/functions/rsort.js
+var require_rsort = __commonJS((exports, module) => {
+  var compareBuild = require_compare_build();
+  var rsort = (list3, loose) => list3.sort((a3, b3) => compareBuild(b3, a3, loose));
+  module.exports = rsort;
+});
+
+// node_modules/semver/functions/gt.js
+var require_gt = __commonJS((exports, module) => {
+  var compare = require_compare();
+  var gt = (a3, b3, loose) => compare(a3, b3, loose) > 0;
+  module.exports = gt;
+});
+
+// node_modules/semver/functions/lt.js
+var require_lt = __commonJS((exports, module) => {
+  var compare = require_compare();
+  var lt = (a3, b3, loose) => compare(a3, b3, loose) < 0;
+  module.exports = lt;
+});
+
+// node_modules/semver/functions/eq.js
+var require_eq = __commonJS((exports, module) => {
+  var compare = require_compare();
+  var eq = (a3, b3, loose) => compare(a3, b3, loose) === 0;
+  module.exports = eq;
+});
+
+// node_modules/semver/functions/neq.js
+var require_neq = __commonJS((exports, module) => {
+  var compare = require_compare();
+  var neq = (a3, b3, loose) => compare(a3, b3, loose) !== 0;
+  module.exports = neq;
+});
+
+// node_modules/semver/functions/gte.js
+var require_gte = __commonJS((exports, module) => {
+  var compare = require_compare();
+  var gte = (a3, b3, loose) => compare(a3, b3, loose) >= 0;
+  module.exports = gte;
+});
+
+// node_modules/semver/functions/lte.js
+var require_lte = __commonJS((exports, module) => {
+  var compare = require_compare();
+  var lte = (a3, b3, loose) => compare(a3, b3, loose) <= 0;
+  module.exports = lte;
+});
+
+// node_modules/semver/functions/cmp.js
+var require_cmp = __commonJS((exports, module) => {
+  var eq = require_eq();
+  var neq = require_neq();
+  var gt = require_gt();
+  var gte = require_gte();
+  var lt = require_lt();
+  var lte = require_lte();
+  var cmp = (a3, op, b3, loose) => {
+    switch (op) {
+      case "===":
+        if (typeof a3 === "object") {
+          a3 = a3.version;
+        }
+        if (typeof b3 === "object") {
+          b3 = b3.version;
+        }
+        return a3 === b3;
+      case "!==":
+        if (typeof a3 === "object") {
+          a3 = a3.version;
+        }
+        if (typeof b3 === "object") {
+          b3 = b3.version;
+        }
+        return a3 !== b3;
+      case "":
+      case "=":
+      case "==":
+        return eq(a3, b3, loose);
+      case "!=":
+        return neq(a3, b3, loose);
+      case ">":
+        return gt(a3, b3, loose);
+      case ">=":
+        return gte(a3, b3, loose);
+      case "<":
+        return lt(a3, b3, loose);
+      case "<=":
+        return lte(a3, b3, loose);
+      default:
+        throw new TypeError(`Invalid operator: ${op}`);
+    }
+  };
+  module.exports = cmp;
+});
+
+// node_modules/semver/functions/coerce.js
+var require_coerce = __commonJS((exports, module) => {
+  var SemVer = require_semver();
+  var parse5 = require_parse();
+  var { safeRe: re2, t } = require_re();
+  var coerce2 = (version, options) => {
+    if (version instanceof SemVer) {
+      return version;
+    }
+    if (typeof version === "number") {
+      version = String(version);
+    }
+    if (typeof version !== "string") {
+      return null;
+    }
+    options = options || {};
+    let match = null;
+    if (!options.rtl) {
+      match = version.match(options.includePrerelease ? re2[t.COERCEFULL] : re2[t.COERCE]);
+    } else {
+      const coerceRtlRegex = options.includePrerelease ? re2[t.COERCERTLFULL] : re2[t.COERCERTL];
+      let next;
+      while ((next = coerceRtlRegex.exec(version)) && (!match || match.index + match[0].length !== version.length)) {
+        if (!match || next.index + next[0].length !== match.index + match[0].length) {
+          match = next;
+        }
+        coerceRtlRegex.lastIndex = next.index + next[1].length + next[2].length;
+      }
+      coerceRtlRegex.lastIndex = -1;
+    }
+    if (match === null) {
+      return null;
+    }
+    const major = match[2];
+    const minor = match[3] || "0";
+    const patch = match[4] || "0";
+    const prerelease = options.includePrerelease && match[5] ? `-${match[5]}` : "";
+    const build = options.includePrerelease && match[6] ? `+${match[6]}` : "";
+    return parse5(`${major}.${minor}.${patch}${prerelease}${build}`, options);
+  };
+  module.exports = coerce2;
+});
+
+// node_modules/semver/internal/lrucache.js
+var require_lrucache = __commonJS((exports, module) => {
+  class LRUCache {
+    constructor() {
+      this.max = 1000;
+      this.map = new Map;
+    }
+    get(key) {
+      const value = this.map.get(key);
+      if (value === undefined) {
+        return;
+      } else {
+        this.map.delete(key);
+        this.map.set(key, value);
+        return value;
+      }
+    }
+    delete(key) {
+      return this.map.delete(key);
+    }
+    set(key, value) {
+      const deleted = this.delete(key);
+      if (!deleted && value !== undefined) {
+        if (this.map.size >= this.max) {
+          const firstKey = this.map.keys().next().value;
+          this.delete(firstKey);
+        }
+        this.map.set(key, value);
+      }
+      return this;
+    }
+  }
+  module.exports = LRUCache;
+});
+
+// node_modules/semver/classes/range.js
+var require_range = __commonJS((exports, module) => {
+  var SPACE_CHARACTERS = /\s+/g;
+
+  class Range {
+    constructor(range, options) {
+      options = parseOptions(options);
+      if (range instanceof Range) {
+        if (range.loose === !!options.loose && range.includePrerelease === !!options.includePrerelease) {
+          return range;
+        } else {
+          return new Range(range.raw, options);
+        }
+      }
+      if (range instanceof Comparator) {
+        this.raw = range.value;
+        this.set = [[range]];
+        this.formatted = undefined;
+        return this;
+      }
+      this.options = options;
+      this.loose = !!options.loose;
+      this.includePrerelease = !!options.includePrerelease;
+      this.raw = range.trim().replace(SPACE_CHARACTERS, " ");
+      this.set = this.raw.split("||").map((r2) => this.parseRange(r2.trim())).filter((c2) => c2.length);
+      if (!this.set.length) {
+        throw new TypeError(`Invalid SemVer Range: ${this.raw}`);
+      }
+      if (this.set.length > 1) {
+        const first = this.set[0];
+        this.set = this.set.filter((c2) => !isNullSet(c2[0]));
+        if (this.set.length === 0) {
+          this.set = [first];
+        } else if (this.set.length > 1) {
+          for (const c2 of this.set) {
+            if (c2.length === 1 && isAny(c2[0])) {
+              this.set = [c2];
+              break;
+            }
+          }
+        }
+      }
+      this.formatted = undefined;
+    }
+    get range() {
+      if (this.formatted === undefined) {
+        this.formatted = "";
+        for (let i = 0;i < this.set.length; i++) {
+          if (i > 0) {
+            this.formatted += "||";
+          }
+          const comps = this.set[i];
+          for (let k2 = 0;k2 < comps.length; k2++) {
+            if (k2 > 0) {
+              this.formatted += " ";
+            }
+            this.formatted += comps[k2].toString().trim();
+          }
+        }
+      }
+      return this.formatted;
+    }
+    format() {
+      return this.range;
+    }
+    toString() {
+      return this.range;
+    }
+    parseRange(range) {
+      const memoOpts = (this.options.includePrerelease && FLAG_INCLUDE_PRERELEASE) | (this.options.loose && FLAG_LOOSE);
+      const memoKey = memoOpts + ":" + range;
+      const cached = cache2.get(memoKey);
+      if (cached) {
+        return cached;
+      }
+      const loose = this.options.loose;
+      const hr = loose ? re2[t.HYPHENRANGELOOSE] : re2[t.HYPHENRANGE];
+      range = range.replace(hr, hyphenReplace(this.options.includePrerelease));
+      debug("hyphen replace", range);
+      range = range.replace(re2[t.COMPARATORTRIM], comparatorTrimReplace);
+      debug("comparator trim", range);
+      range = range.replace(re2[t.TILDETRIM], tildeTrimReplace);
+      debug("tilde trim", range);
+      range = range.replace(re2[t.CARETTRIM], caretTrimReplace);
+      debug("caret trim", range);
+      let rangeList = range.split(" ").map((comp) => parseComparator(comp, this.options)).join(" ").split(/\s+/).map((comp) => replaceGTE0(comp, this.options));
+      if (loose) {
+        rangeList = rangeList.filter((comp) => {
+          debug("loose invalid filter", comp, this.options);
+          return !!comp.match(re2[t.COMPARATORLOOSE]);
+        });
+      }
+      debug("range list", rangeList);
+      const rangeMap = new Map;
+      const comparators = rangeList.map((comp) => new Comparator(comp, this.options));
+      for (const comp of comparators) {
+        if (isNullSet(comp)) {
+          return [comp];
+        }
+        rangeMap.set(comp.value, comp);
+      }
+      if (rangeMap.size > 1 && rangeMap.has("")) {
+        rangeMap.delete("");
+      }
+      const result = [...rangeMap.values()];
+      cache2.set(memoKey, result);
+      return result;
+    }
+    intersects(range, options) {
+      if (!(range instanceof Range)) {
+        throw new TypeError("a Range is required");
+      }
+      return this.set.some((thisComparators) => {
+        return isSatisfiable(thisComparators, options) && range.set.some((rangeComparators) => {
+          return isSatisfiable(rangeComparators, options) && thisComparators.every((thisComparator) => {
+            return rangeComparators.every((rangeComparator) => {
+              return thisComparator.intersects(rangeComparator, options);
+            });
+          });
+        });
+      });
+    }
+    test(version) {
+      if (!version) {
+        return false;
+      }
+      if (typeof version === "string") {
+        try {
+          version = new SemVer(version, this.options);
+        } catch (er) {
+          return false;
+        }
+      }
+      for (let i = 0;i < this.set.length; i++) {
+        if (testSet(this.set[i], version, this.options)) {
+          return true;
+        }
+      }
+      return false;
+    }
+  }
+  module.exports = Range;
+  var LRU = require_lrucache();
+  var cache2 = new LRU;
+  var parseOptions = require_parse_options();
+  var Comparator = require_comparator();
+  var debug = require_debug();
+  var SemVer = require_semver();
+  var {
+    safeRe: re2,
+    t,
+    comparatorTrimReplace,
+    tildeTrimReplace,
+    caretTrimReplace
+  } = require_re();
+  var { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = require_constants();
+  var isNullSet = (c2) => c2.value === "<0.0.0-0";
+  var isAny = (c2) => c2.value === "";
+  var isSatisfiable = (comparators, options) => {
+    let result = true;
+    const remainingComparators = comparators.slice();
+    let testComparator = remainingComparators.pop();
+    while (result && remainingComparators.length) {
+      result = remainingComparators.every((otherComparator) => {
+        return testComparator.intersects(otherComparator, options);
+      });
+      testComparator = remainingComparators.pop();
+    }
+    return result;
+  };
+  var parseComparator = (comp, options) => {
+    comp = comp.replace(re2[t.BUILD], "");
+    debug("comp", comp, options);
+    comp = replaceCarets(comp, options);
+    debug("caret", comp);
+    comp = replaceTildes(comp, options);
+    debug("tildes", comp);
+    comp = replaceXRanges(comp, options);
+    debug("xrange", comp);
+    comp = replaceStars(comp, options);
+    debug("stars", comp);
+    return comp;
+  };
+  var isX = (id) => !id || id.toLowerCase() === "x" || id === "*";
+  var replaceTildes = (comp, options) => {
+    return comp.trim().split(/\s+/).map((c2) => replaceTilde(c2, options)).join(" ");
+  };
+  var replaceTilde = (comp, options) => {
+    const r2 = options.loose ? re2[t.TILDELOOSE] : re2[t.TILDE];
+    return comp.replace(r2, (_3, M3, m2, p, pr) => {
+      debug("tilde", comp, _3, M3, m2, p, pr);
+      let ret;
+      if (isX(M3)) {
+        ret = "";
+      } else if (isX(m2)) {
+        ret = `>=${M3}.0.0 <${+M3 + 1}.0.0-0`;
+      } else if (isX(p)) {
+        ret = `>=${M3}.${m2}.0 <${M3}.${+m2 + 1}.0-0`;
+      } else if (pr) {
+        debug("replaceTilde pr", pr);
+        ret = `>=${M3}.${m2}.${p}-${pr} <${M3}.${+m2 + 1}.0-0`;
+      } else {
+        ret = `>=${M3}.${m2}.${p} <${M3}.${+m2 + 1}.0-0`;
+      }
+      debug("tilde return", ret);
+      return ret;
+    });
+  };
+  var replaceCarets = (comp, options) => {
+    return comp.trim().split(/\s+/).map((c2) => replaceCaret(c2, options)).join(" ");
+  };
+  var replaceCaret = (comp, options) => {
+    debug("caret", comp, options);
+    const r2 = options.loose ? re2[t.CARETLOOSE] : re2[t.CARET];
+    const z3 = options.includePrerelease ? "-0" : "";
+    return comp.replace(r2, (_3, M3, m2, p, pr) => {
+      debug("caret", comp, _3, M3, m2, p, pr);
+      let ret;
+      if (isX(M3)) {
+        ret = "";
+      } else if (isX(m2)) {
+        ret = `>=${M3}.0.0${z3} <${+M3 + 1}.0.0-0`;
+      } else if (isX(p)) {
+        if (M3 === "0") {
+          ret = `>=${M3}.${m2}.0${z3} <${M3}.${+m2 + 1}.0-0`;
+        } else {
+          ret = `>=${M3}.${m2}.0${z3} <${+M3 + 1}.0.0-0`;
+        }
+      } else if (pr) {
+        debug("replaceCaret pr", pr);
+        if (M3 === "0") {
+          if (m2 === "0") {
+            ret = `>=${M3}.${m2}.${p}-${pr} <${M3}.${m2}.${+p + 1}-0`;
+          } else {
+            ret = `>=${M3}.${m2}.${p}-${pr} <${M3}.${+m2 + 1}.0-0`;
+          }
+        } else {
+          ret = `>=${M3}.${m2}.${p}-${pr} <${+M3 + 1}.0.0-0`;
+        }
+      } else {
+        debug("no pr");
+        if (M3 === "0") {
+          if (m2 === "0") {
+            ret = `>=${M3}.${m2}.${p}${z3} <${M3}.${m2}.${+p + 1}-0`;
+          } else {
+            ret = `>=${M3}.${m2}.${p}${z3} <${M3}.${+m2 + 1}.0-0`;
+          }
+        } else {
+          ret = `>=${M3}.${m2}.${p} <${+M3 + 1}.0.0-0`;
+        }
+      }
+      debug("caret return", ret);
+      return ret;
+    });
+  };
+  var replaceXRanges = (comp, options) => {
+    debug("replaceXRanges", comp, options);
+    return comp.split(/\s+/).map((c2) => replaceXRange(c2, options)).join(" ");
+  };
+  var replaceXRange = (comp, options) => {
+    comp = comp.trim();
+    const r2 = options.loose ? re2[t.XRANGELOOSE] : re2[t.XRANGE];
+    return comp.replace(r2, (ret, gtlt, M3, m2, p, pr) => {
+      debug("xRange", comp, ret, gtlt, M3, m2, p, pr);
+      const xM = isX(M3);
+      const xm = xM || isX(m2);
+      const xp = xm || isX(p);
+      const anyX = xp;
+      if (gtlt === "=" && anyX) {
+        gtlt = "";
+      }
+      pr = options.includePrerelease ? "-0" : "";
+      if (xM) {
+        if (gtlt === ">" || gtlt === "<") {
+          ret = "<0.0.0-0";
+        } else {
+          ret = "*";
+        }
+      } else if (gtlt && anyX) {
+        if (xm) {
+          m2 = 0;
+        }
+        p = 0;
+        if (gtlt === ">") {
+          gtlt = ">=";
+          if (xm) {
+            M3 = +M3 + 1;
+            m2 = 0;
+            p = 0;
+          } else {
+            m2 = +m2 + 1;
+            p = 0;
+          }
+        } else if (gtlt === "<=") {
+          gtlt = "<";
+          if (xm) {
+            M3 = +M3 + 1;
+          } else {
+            m2 = +m2 + 1;
+          }
+        }
+        if (gtlt === "<") {
+          pr = "-0";
+        }
+        ret = `${gtlt + M3}.${m2}.${p}${pr}`;
+      } else if (xm) {
+        ret = `>=${M3}.0.0${pr} <${+M3 + 1}.0.0-0`;
+      } else if (xp) {
+        ret = `>=${M3}.${m2}.0${pr} <${M3}.${+m2 + 1}.0-0`;
+      }
+      debug("xRange return", ret);
+      return ret;
+    });
+  };
+  var replaceStars = (comp, options) => {
+    debug("replaceStars", comp, options);
+    return comp.trim().replace(re2[t.STAR], "");
+  };
+  var replaceGTE0 = (comp, options) => {
+    debug("replaceGTE0", comp, options);
+    return comp.trim().replace(re2[options.includePrerelease ? t.GTE0PRE : t.GTE0], "");
+  };
+  var hyphenReplace = (incPr) => ($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr) => {
+    if (isX(fM)) {
+      from = "";
+    } else if (isX(fm)) {
+      from = `>=${fM}.0.0${incPr ? "-0" : ""}`;
+    } else if (isX(fp)) {
+      from = `>=${fM}.${fm}.0${incPr ? "-0" : ""}`;
+    } else if (fpr) {
+      from = `>=${from}`;
+    } else {
+      from = `>=${from}${incPr ? "-0" : ""}`;
+    }
+    if (isX(tM)) {
+      to = "";
+    } else if (isX(tm)) {
+      to = `<${+tM + 1}.0.0-0`;
+    } else if (isX(tp)) {
+      to = `<${tM}.${+tm + 1}.0-0`;
+    } else if (tpr) {
+      to = `<=${tM}.${tm}.${tp}-${tpr}`;
+    } else if (incPr) {
+      to = `<${tM}.${tm}.${+tp + 1}-0`;
+    } else {
+      to = `<=${to}`;
+    }
+    return `${from} ${to}`.trim();
+  };
+  var testSet = (set, version, options) => {
+    for (let i = 0;i < set.length; i++) {
+      if (!set[i].test(version)) {
+        return false;
+      }
+    }
+    if (version.prerelease.length && !options.includePrerelease) {
+      for (let i = 0;i < set.length; i++) {
+        debug(set[i].semver);
+        if (set[i].semver === Comparator.ANY) {
+          continue;
+        }
+        if (set[i].semver.prerelease.length > 0) {
+          const allowed = set[i].semver;
+          if (allowed.major === version.major && allowed.minor === version.minor && allowed.patch === version.patch) {
+            return true;
+          }
+        }
+      }
+      return false;
+    }
+    return true;
+  };
+});
+
+// node_modules/semver/classes/comparator.js
+var require_comparator = __commonJS((exports, module) => {
+  var ANY = Symbol("SemVer ANY");
+
+  class Comparator {
+    static get ANY() {
+      return ANY;
+    }
+    constructor(comp, options) {
+      options = parseOptions(options);
+      if (comp instanceof Comparator) {
+        if (comp.loose === !!options.loose) {
+          return comp;
+        } else {
+          comp = comp.value;
+        }
+      }
+      comp = comp.trim().split(/\s+/).join(" ");
+      debug("comparator", comp, options);
+      this.options = options;
+      this.loose = !!options.loose;
+      this.parse(comp);
+      if (this.semver === ANY) {
+        this.value = "";
+      } else {
+        this.value = this.operator + this.semver.version;
+      }
+      debug("comp", this);
+    }
+    parse(comp) {
+      const r2 = this.options.loose ? re2[t.COMPARATORLOOSE] : re2[t.COMPARATOR];
+      const m2 = comp.match(r2);
+      if (!m2) {
+        throw new TypeError(`Invalid comparator: ${comp}`);
+      }
+      this.operator = m2[1] !== undefined ? m2[1] : "";
+      if (this.operator === "=") {
+        this.operator = "";
+      }
+      if (!m2[2]) {
+        this.semver = ANY;
+      } else {
+        this.semver = new SemVer(m2[2], this.options.loose);
+      }
+    }
+    toString() {
+      return this.value;
+    }
+    test(version) {
+      debug("Comparator.test", version, this.options.loose);
+      if (this.semver === ANY || version === ANY) {
+        return true;
+      }
+      if (typeof version === "string") {
+        try {
+          version = new SemVer(version, this.options);
+        } catch (er) {
+          return false;
+        }
+      }
+      return cmp(version, this.operator, this.semver, this.options);
+    }
+    intersects(comp, options) {
+      if (!(comp instanceof Comparator)) {
+        throw new TypeError("a Comparator is required");
+      }
+      if (this.operator === "") {
+        if (this.value === "") {
+          return true;
+        }
+        return new Range(comp.value, options).test(this.value);
+      } else if (comp.operator === "") {
+        if (comp.value === "") {
+          return true;
+        }
+        return new Range(this.value, options).test(comp.semver);
+      }
+      options = parseOptions(options);
+      if (options.includePrerelease && (this.value === "<0.0.0-0" || comp.value === "<0.0.0-0")) {
+        return false;
+      }
+      if (!options.includePrerelease && (this.value.startsWith("<0.0.0") || comp.value.startsWith("<0.0.0"))) {
+        return false;
+      }
+      if (this.operator.startsWith(">") && comp.operator.startsWith(">")) {
+        return true;
+      }
+      if (this.operator.startsWith("<") && comp.operator.startsWith("<")) {
+        return true;
+      }
+      if (this.semver.version === comp.semver.version && this.operator.includes("=") && comp.operator.includes("=")) {
+        return true;
+      }
+      if (cmp(this.semver, "<", comp.semver, options) && this.operator.startsWith(">") && comp.operator.startsWith("<")) {
+        return true;
+      }
+      if (cmp(this.semver, ">", comp.semver, options) && this.operator.startsWith("<") && comp.operator.startsWith(">")) {
+        return true;
+      }
+      return false;
+    }
+  }
+  module.exports = Comparator;
+  var parseOptions = require_parse_options();
+  var { safeRe: re2, t } = require_re();
+  var cmp = require_cmp();
+  var debug = require_debug();
+  var SemVer = require_semver();
+  var Range = require_range();
+});
+
+// node_modules/semver/functions/satisfies.js
+var require_satisfies = __commonJS((exports, module) => {
+  var Range = require_range();
+  var satisfies = (version, range, options) => {
+    try {
+      range = new Range(range, options);
+    } catch (er) {
+      return false;
+    }
+    return range.test(version);
+  };
+  module.exports = satisfies;
+});
+
+// node_modules/semver/ranges/to-comparators.js
+var require_to_comparators = __commonJS((exports, module) => {
+  var Range = require_range();
+  var toComparators = (range, options) => new Range(range, options).set.map((comp) => comp.map((c2) => c2.value).join(" ").trim().split(" "));
+  module.exports = toComparators;
+});
+
+// node_modules/semver/ranges/max-satisfying.js
+var require_max_satisfying = __commonJS((exports, module) => {
+  var SemVer = require_semver();
+  var Range = require_range();
+  var maxSatisfying = (versions, range, options) => {
+    let max = null;
+    let maxSV = null;
+    let rangeObj = null;
+    try {
+      rangeObj = new Range(range, options);
+    } catch (er) {
+      return null;
+    }
+    versions.forEach((v2) => {
+      if (rangeObj.test(v2)) {
+        if (!max || maxSV.compare(v2) === -1) {
+          max = v2;
+          maxSV = new SemVer(max, options);
+        }
+      }
+    });
+    return max;
+  };
+  module.exports = maxSatisfying;
+});
+
+// node_modules/semver/ranges/min-satisfying.js
+var require_min_satisfying = __commonJS((exports, module) => {
+  var SemVer = require_semver();
+  var Range = require_range();
+  var minSatisfying = (versions, range, options) => {
+    let min = null;
+    let minSV = null;
+    let rangeObj = null;
+    try {
+      rangeObj = new Range(range, options);
+    } catch (er) {
+      return null;
+    }
+    versions.forEach((v2) => {
+      if (rangeObj.test(v2)) {
+        if (!min || minSV.compare(v2) === 1) {
+          min = v2;
+          minSV = new SemVer(min, options);
+        }
+      }
+    });
+    return min;
+  };
+  module.exports = minSatisfying;
+});
+
+// node_modules/semver/ranges/min-version.js
+var require_min_version = __commonJS((exports, module) => {
+  var SemVer = require_semver();
+  var Range = require_range();
+  var gt = require_gt();
+  var minVersion = (range, loose) => {
+    range = new Range(range, loose);
+    let minver = new SemVer("0.0.0");
+    if (range.test(minver)) {
+      return minver;
+    }
+    minver = new SemVer("0.0.0-0");
+    if (range.test(minver)) {
+      return minver;
+    }
+    minver = null;
+    for (let i = 0;i < range.set.length; ++i) {
+      const comparators = range.set[i];
+      let setMin = null;
+      comparators.forEach((comparator) => {
+        const compver = new SemVer(comparator.semver.version);
+        switch (comparator.operator) {
+          case ">":
+            if (compver.prerelease.length === 0) {
+              compver.patch++;
+            } else {
+              compver.prerelease.push(0);
+            }
+            compver.raw = compver.format();
+          case "":
+          case ">=":
+            if (!setMin || gt(compver, setMin)) {
+              setMin = compver;
+            }
+            break;
+          case "<":
+          case "<=":
+            break;
+          default:
+            throw new Error(`Unexpected operation: ${comparator.operator}`);
+        }
+      });
+      if (setMin && (!minver || gt(minver, setMin))) {
+        minver = setMin;
+      }
+    }
+    if (minver && range.test(minver)) {
+      return minver;
+    }
+    return null;
+  };
+  module.exports = minVersion;
+});
+
+// node_modules/semver/ranges/valid.js
+var require_valid2 = __commonJS((exports, module) => {
+  var Range = require_range();
+  var validRange = (range, options) => {
+    try {
+      return new Range(range, options).range || "*";
+    } catch (er) {
+      return null;
+    }
+  };
+  module.exports = validRange;
+});
+
+// node_modules/semver/ranges/outside.js
+var require_outside = __commonJS((exports, module) => {
+  var SemVer = require_semver();
+  var Comparator = require_comparator();
+  var { ANY } = Comparator;
+  var Range = require_range();
+  var satisfies = require_satisfies();
+  var gt = require_gt();
+  var lt = require_lt();
+  var lte = require_lte();
+  var gte = require_gte();
+  var outside = (version, range, hilo, options) => {
+    version = new SemVer(version, options);
+    range = new Range(range, options);
+    let gtfn, ltefn, ltfn, comp, ecomp;
+    switch (hilo) {
+      case ">":
+        gtfn = gt;
+        ltefn = lte;
+        ltfn = lt;
+        comp = ">";
+        ecomp = ">=";
+        break;
+      case "<":
+        gtfn = lt;
+        ltefn = gte;
+        ltfn = gt;
+        comp = "<";
+        ecomp = "<=";
+        break;
+      default:
+        throw new TypeError('Must provide a hilo val of "<" or ">"');
+    }
+    if (satisfies(version, range, options)) {
+      return false;
+    }
+    for (let i = 0;i < range.set.length; ++i) {
+      const comparators = range.set[i];
+      let high = null;
+      let low = null;
+      comparators.forEach((comparator) => {
+        if (comparator.semver === ANY) {
+          comparator = new Comparator(">=0.0.0");
+        }
+        high = high || comparator;
+        low = low || comparator;
+        if (gtfn(comparator.semver, high.semver, options)) {
+          high = comparator;
+        } else if (ltfn(comparator.semver, low.semver, options)) {
+          low = comparator;
+        }
+      });
+      if (high.operator === comp || high.operator === ecomp) {
+        return false;
+      }
+      if ((!low.operator || low.operator === comp) && ltefn(version, low.semver)) {
+        return false;
+      } else if (low.operator === ecomp && ltfn(version, low.semver)) {
+        return false;
+      }
+    }
+    return true;
+  };
+  module.exports = outside;
+});
+
+// node_modules/semver/ranges/gtr.js
+var require_gtr = __commonJS((exports, module) => {
+  var outside = require_outside();
+  var gtr = (version, range, options) => outside(version, range, ">", options);
+  module.exports = gtr;
+});
+
+// node_modules/semver/ranges/ltr.js
+var require_ltr = __commonJS((exports, module) => {
+  var outside = require_outside();
+  var ltr = (version, range, options) => outside(version, range, "<", options);
+  module.exports = ltr;
+});
+
+// node_modules/semver/ranges/intersects.js
+var require_intersects = __commonJS((exports, module) => {
+  var Range = require_range();
+  var intersects = (r1, r2, options) => {
+    r1 = new Range(r1, options);
+    r2 = new Range(r2, options);
+    return r1.intersects(r2, options);
+  };
+  module.exports = intersects;
+});
+
+// node_modules/semver/ranges/simplify.js
+var require_simplify = __commonJS((exports, module) => {
+  var satisfies = require_satisfies();
+  var compare = require_compare();
+  module.exports = (versions, range, options) => {
+    const set = [];
+    let first = null;
+    let prev = null;
+    const v2 = versions.sort((a3, b3) => compare(a3, b3, options));
+    for (const version of v2) {
+      const included = satisfies(version, range, options);
+      if (included) {
+        prev = version;
+        if (!first) {
+          first = version;
+        }
+      } else {
+        if (prev) {
+          set.push([first, prev]);
+        }
+        prev = null;
+        first = null;
+      }
+    }
+    if (first) {
+      set.push([first, null]);
+    }
+    const ranges = [];
+    for (const [min, max] of set) {
+      if (min === max) {
+        ranges.push(min);
+      } else if (!max && min === v2[0]) {
+        ranges.push("*");
+      } else if (!max) {
+        ranges.push(`>=${min}`);
+      } else if (min === v2[0]) {
+        ranges.push(`<=${max}`);
+      } else {
+        ranges.push(`${min} - ${max}`);
+      }
+    }
+    const simplified = ranges.join(" || ");
+    const original = typeof range.raw === "string" ? range.raw : String(range);
+    return simplified.length < original.length ? simplified : range;
+  };
+});
+
+// node_modules/semver/ranges/subset.js
+var require_subset = __commonJS((exports, module) => {
+  var Range = require_range();
+  var Comparator = require_comparator();
+  var { ANY } = Comparator;
+  var satisfies = require_satisfies();
+  var compare = require_compare();
+  var subset = (sub, dom, options = {}) => {
+    if (sub === dom) {
+      return true;
+    }
+    sub = new Range(sub, options);
+    dom = new Range(dom, options);
+    let sawNonNull = false;
+    OUTER:
+      for (const simpleSub of sub.set) {
+        for (const simpleDom of dom.set) {
+          const isSub = simpleSubset(simpleSub, simpleDom, options);
+          sawNonNull = sawNonNull || isSub !== null;
+          if (isSub) {
+            continue OUTER;
+          }
+        }
+        if (sawNonNull) {
+          return false;
+        }
+      }
+    return true;
+  };
+  var minimumVersionWithPreRelease = [new Comparator(">=0.0.0-0")];
+  var minimumVersion = [new Comparator(">=0.0.0")];
+  var simpleSubset = (sub, dom, options) => {
+    if (sub === dom) {
+      return true;
+    }
+    if (sub.length === 1 && sub[0].semver === ANY) {
+      if (dom.length === 1 && dom[0].semver === ANY) {
+        return true;
+      } else if (options.includePrerelease) {
+        sub = minimumVersionWithPreRelease;
+      } else {
+        sub = minimumVersion;
+      }
+    }
+    if (dom.length === 1 && dom[0].semver === ANY) {
+      if (options.includePrerelease) {
+        return true;
+      } else {
+        dom = minimumVersion;
+      }
+    }
+    const eqSet = new Set;
+    let gt, lt;
+    for (const c2 of sub) {
+      if (c2.operator === ">" || c2.operator === ">=") {
+        gt = higherGT(gt, c2, options);
+      } else if (c2.operator === "<" || c2.operator === "<=") {
+        lt = lowerLT(lt, c2, options);
+      } else {
+        eqSet.add(c2.semver);
+      }
+    }
+    if (eqSet.size > 1) {
+      return null;
+    }
+    let gtltComp;
+    if (gt && lt) {
+      gtltComp = compare(gt.semver, lt.semver, options);
+      if (gtltComp > 0) {
+        return null;
+      } else if (gtltComp === 0 && (gt.operator !== ">=" || lt.operator !== "<=")) {
+        return null;
+      }
+    }
+    for (const eq of eqSet) {
+      if (gt && !satisfies(eq, String(gt), options)) {
+        return null;
+      }
+      if (lt && !satisfies(eq, String(lt), options)) {
+        return null;
+      }
+      for (const c2 of dom) {
+        if (!satisfies(eq, String(c2), options)) {
+          return false;
+        }
+      }
+      return true;
+    }
+    let higher, lower;
+    let hasDomLT, hasDomGT;
+    let needDomLTPre = lt && !options.includePrerelease && lt.semver.prerelease.length ? lt.semver : false;
+    let needDomGTPre = gt && !options.includePrerelease && gt.semver.prerelease.length ? gt.semver : false;
+    if (needDomLTPre && needDomLTPre.prerelease.length === 1 && lt.operator === "<" && needDomLTPre.prerelease[0] === 0) {
+      needDomLTPre = false;
+    }
+    for (const c2 of dom) {
+      hasDomGT = hasDomGT || c2.operator === ">" || c2.operator === ">=";
+      hasDomLT = hasDomLT || c2.operator === "<" || c2.operator === "<=";
+      if (gt) {
+        if (needDomGTPre) {
+          if (c2.semver.prerelease && c2.semver.prerelease.length && c2.semver.major === needDomGTPre.major && c2.semver.minor === needDomGTPre.minor && c2.semver.patch === needDomGTPre.patch) {
+            needDomGTPre = false;
+          }
+        }
+        if (c2.operator === ">" || c2.operator === ">=") {
+          higher = higherGT(gt, c2, options);
+          if (higher === c2 && higher !== gt) {
+            return false;
+          }
+        } else if (gt.operator === ">=" && !satisfies(gt.semver, String(c2), options)) {
+          return false;
+        }
+      }
+      if (lt) {
+        if (needDomLTPre) {
+          if (c2.semver.prerelease && c2.semver.prerelease.length && c2.semver.major === needDomLTPre.major && c2.semver.minor === needDomLTPre.minor && c2.semver.patch === needDomLTPre.patch) {
+            needDomLTPre = false;
+          }
+        }
+        if (c2.operator === "<" || c2.operator === "<=") {
+          lower = lowerLT(lt, c2, options);
+          if (lower === c2 && lower !== lt) {
+            return false;
+          }
+        } else if (lt.operator === "<=" && !satisfies(lt.semver, String(c2), options)) {
+          return false;
+        }
+      }
+      if (!c2.operator && (lt || gt) && gtltComp !== 0) {
+        return false;
+      }
+    }
+    if (gt && hasDomLT && !lt && gtltComp !== 0) {
+      return false;
+    }
+    if (lt && hasDomGT && !gt && gtltComp !== 0) {
+      return false;
+    }
+    if (needDomGTPre || needDomLTPre) {
+      return false;
+    }
+    return true;
+  };
+  var higherGT = (a3, b3, options) => {
+    if (!a3) {
+      return b3;
+    }
+    const comp = compare(a3.semver, b3.semver, options);
+    return comp > 0 ? a3 : comp < 0 ? b3 : b3.operator === ">" && a3.operator === ">=" ? b3 : a3;
+  };
+  var lowerLT = (a3, b3, options) => {
+    if (!a3) {
+      return b3;
+    }
+    const comp = compare(a3.semver, b3.semver, options);
+    return comp < 0 ? a3 : comp > 0 ? b3 : b3.operator === "<" && a3.operator === "<=" ? b3 : a3;
+  };
+  module.exports = subset;
+});
+
+// node_modules/semver/index.js
+var require_semver2 = __commonJS((exports, module) => {
+  var internalRe = require_re();
+  var constants5 = require_constants();
+  var SemVer = require_semver();
+  var identifiers = require_identifiers();
+  var parse5 = require_parse();
+  var valid = require_valid();
+  var clean = require_clean();
+  var inc = require_inc();
+  var diff = require_diff();
+  var major = require_major();
+  var minor = require_minor();
+  var patch = require_patch();
+  var prerelease = require_prerelease();
+  var compare = require_compare();
+  var rcompare = require_rcompare();
+  var compareLoose = require_compare_loose();
+  var compareBuild = require_compare_build();
+  var sort = require_sort();
+  var rsort = require_rsort();
+  var gt = require_gt();
+  var lt = require_lt();
+  var eq = require_eq();
+  var neq = require_neq();
+  var gte = require_gte();
+  var lte = require_lte();
+  var cmp = require_cmp();
+  var coerce2 = require_coerce();
+  var Comparator = require_comparator();
+  var Range = require_range();
+  var satisfies = require_satisfies();
+  var toComparators = require_to_comparators();
+  var maxSatisfying = require_max_satisfying();
+  var minSatisfying = require_min_satisfying();
+  var minVersion = require_min_version();
+  var validRange = require_valid2();
+  var outside = require_outside();
+  var gtr = require_gtr();
+  var ltr = require_ltr();
+  var intersects = require_intersects();
+  var simplifyRange = require_simplify();
+  var subset = require_subset();
+  module.exports = {
+    parse: parse5,
+    valid,
+    clean,
+    inc,
+    diff,
+    major,
+    minor,
+    patch,
+    prerelease,
+    compare,
+    rcompare,
+    compareLoose,
+    compareBuild,
+    sort,
+    rsort,
+    gt,
+    lt,
+    eq,
+    neq,
+    gte,
+    lte,
+    cmp,
+    coerce: coerce2,
+    Comparator,
+    Range,
+    satisfies,
+    toComparators,
+    maxSatisfying,
+    minSatisfying,
+    minVersion,
+    validRange,
+    outside,
+    gtr,
+    ltr,
+    intersects,
+    simplifyRange,
+    subset,
+    SemVer,
+    re: internalRe.re,
+    src: internalRe.src,
+    tokens: internalRe.t,
+    SEMVER_SPEC_VERSION: constants5.SEMVER_SPEC_VERSION,
+    RELEASE_TYPES: constants5.RELEASE_TYPES,
+    compareIdentifiers: identifiers.compareIdentifiers,
+    rcompareIdentifiers: identifiers.rcompareIdentifiers
+  };
+});
+
 // node_modules/retry/lib/retry_operation.js
 var require_retry_operation = __commonJS((exports, module) => {
   function RetryOperation(timeouts, options) {
@@ -14093,25 +15880,25 @@ class OwnershipDisplay {
   static formatOwnership(ownership) {
     switch (ownership) {
       case "ck":
-        return import_picocolors17.default.blue("CK-owned");
+        return import_picocolors18.default.blue("CK-owned");
       case "user":
-        return import_picocolors17.default.green("User-created");
+        return import_picocolors18.default.green("User-created");
       case "ck-modified":
-        return import_picocolors17.default.yellow("CK-modified");
+        return import_picocolors18.default.yellow("CK-modified");
       default:
-        return import_picocolors17.default.gray("Unknown");
+        return import_picocolors18.default.gray("Unknown");
     }
   }
   static formatAction(action) {
     switch (action) {
       case "delete":
-        return import_picocolors17.default.red("✖ DELETE");
+        return import_picocolors18.default.red("✖ DELETE");
       case "preserve":
-        return import_picocolors17.default.green("✓ PRESERVE");
+        return import_picocolors18.default.green("✓ PRESERVE");
       case "skip":
-        return import_picocolors17.default.gray("○ SKIP");
+        return import_picocolors18.default.gray("○ SKIP");
       default:
-        return import_picocolors17.default.gray("? UNKNOWN");
+        return import_picocolors18.default.gray("? UNKNOWN");
     }
   }
   static calculateSummary(results) {
@@ -14145,78 +15932,78 @@ class OwnershipDisplay {
   }
   static displaySummary(summary, title = "Ownership Summary") {
     const lines = [
-      `Total files: ${import_picocolors17.default.bold(String(summary.totalFiles))}`,
+      `Total files: ${import_picocolors18.default.bold(String(summary.totalFiles))}`,
       "",
       "By ownership:",
-      `  ${import_picocolors17.default.blue("●")} CK-owned:     ${summary.ckOwned}`,
-      `  ${import_picocolors17.default.green("●")} User-created: ${summary.userCreated}`,
-      `  ${import_picocolors17.default.yellow("●")} CK-modified:  ${summary.ckModified}`,
+      `  ${import_picocolors18.default.blue("●")} CK-owned:     ${summary.ckOwned}`,
+      `  ${import_picocolors18.default.green("●")} User-created: ${summary.userCreated}`,
+      `  ${import_picocolors18.default.yellow("●")} CK-modified:  ${summary.ckModified}`,
       "",
       "Actions:",
-      `  ${import_picocolors17.default.red("✖")} To delete:   ${summary.toDelete}`,
-      `  ${import_picocolors17.default.green("✓")} To preserve: ${summary.toPreserve}`
+      `  ${import_picocolors18.default.red("✖")} To delete:   ${summary.toDelete}`,
+      `  ${import_picocolors18.default.green("✓")} To preserve: ${summary.toPreserve}`
     ];
     le(lines.join(`
 `), title);
   }
   static displayOperationPreview(results, maxItems = 10) {
     const summary = OwnershipDisplay.calculateSummary(results);
-    f2.info(import_picocolors17.default.bold("DRY RUN - Preview of changes:"));
+    f2.info(import_picocolors18.default.bold("DRY RUN - Preview of changes:"));
     console.log("");
     const toDelete = results.filter((r2) => r2.action === "delete");
     const toPreserve = results.filter((r2) => r2.action === "preserve");
     if (toDelete.length > 0) {
-      console.log(import_picocolors17.default.red(import_picocolors17.default.bold(`Files to DELETE (${toDelete.length}):`)));
+      console.log(import_picocolors18.default.red(import_picocolors18.default.bold(`Files to DELETE (${toDelete.length}):`)));
       const showDelete = toDelete.slice(0, maxItems);
       for (const result of showDelete) {
-        console.log(`  ${import_picocolors17.default.red("✖")} ${result.path}`);
+        console.log(`  ${import_picocolors18.default.red("✖")} ${result.path}`);
       }
       if (toDelete.length > maxItems) {
-        console.log(import_picocolors17.default.gray(`  ... and ${toDelete.length - maxItems} more`));
+        console.log(import_picocolors18.default.gray(`  ... and ${toDelete.length - maxItems} more`));
       }
       console.log("");
     }
     if (toPreserve.length > 0) {
-      console.log(import_picocolors17.default.green(import_picocolors17.default.bold(`Files to PRESERVE (${toPreserve.length}):`)));
+      console.log(import_picocolors18.default.green(import_picocolors18.default.bold(`Files to PRESERVE (${toPreserve.length}):`)));
       const showPreserve = toPreserve.slice(0, maxItems);
       for (const result of showPreserve) {
-        const reason = result.reason ? import_picocolors17.default.gray(` (${result.reason})`) : "";
-        console.log(`  ${import_picocolors17.default.green("✓")} ${result.path}${reason}`);
+        const reason = result.reason ? import_picocolors18.default.gray(` (${result.reason})`) : "";
+        console.log(`  ${import_picocolors18.default.green("✓")} ${result.path}${reason}`);
       }
       if (toPreserve.length > maxItems) {
-        console.log(import_picocolors17.default.gray(`  ... and ${toPreserve.length - maxItems} more`));
+        console.log(import_picocolors18.default.gray(`  ... and ${toPreserve.length - maxItems} more`));
       }
       console.log("");
     }
     OwnershipDisplay.displaySummary(summary, "Preview Summary");
-    f2.warn(import_picocolors17.default.yellow("No changes were made. Run without --dry-run to apply changes."));
+    f2.warn(import_picocolors18.default.yellow("No changes were made. Run without --dry-run to apply changes."));
   }
   static displayFile(path11, ownership, action, reason) {
     const ownershipStr = OwnershipDisplay.formatOwnership(ownership);
     const actionStr = OwnershipDisplay.formatAction(action);
-    const reasonStr = reason ? import_picocolors17.default.gray(` - ${reason}`) : "";
+    const reasonStr = reason ? import_picocolors18.default.gray(` - ${reason}`) : "";
     console.log(`  ${actionStr} ${path11} [${ownershipStr}]${reasonStr}`);
   }
   static displayForceWarning() {
-    f2.warn(`${import_picocolors17.default.yellow(import_picocolors17.default.bold("FORCE MODE ENABLED"))}
-${import_picocolors17.default.yellow("User modifications will be overwritten!")}
-${import_picocolors17.default.gray("Use --dry-run first to preview changes.")}`);
+    f2.warn(`${import_picocolors18.default.yellow(import_picocolors18.default.bold("FORCE MODE ENABLED"))}
+${import_picocolors18.default.yellow("User modifications will be overwritten!")}
+${import_picocolors18.default.gray("Use --dry-run first to preview changes.")}`);
   }
   static displayLegacyWarning() {
-    f2.warn(`${import_picocolors17.default.yellow(import_picocolors17.default.bold("Legacy Installation Detected"))}
-${import_picocolors17.default.yellow("No ownership metadata found.")}
-${import_picocolors17.default.gray("Running migration to enable ownership tracking...")}`);
+    f2.warn(`${import_picocolors18.default.yellow(import_picocolors18.default.bold("Legacy Installation Detected"))}
+${import_picocolors18.default.yellow("No ownership metadata found.")}
+${import_picocolors18.default.gray("Running migration to enable ownership tracking...")}`);
   }
   static displayCompletionSummary(deleted, preserved) {
-    const message = `${import_picocolors17.default.green(`✓ Deleted ${deleted} CK-owned file(s)`)}
-${import_picocolors17.default.blue(`✓ Preserved ${preserved} user/modified file(s)`)}`;
+    const message = `${import_picocolors18.default.green(`✓ Deleted ${deleted} CK-owned file(s)`)}
+${import_picocolors18.default.blue(`✓ Preserved ${preserved} user/modified file(s)`)}`;
     f2.success(message);
   }
 }
-var import_picocolors17;
+var import_picocolors18;
 var init_ownership_display = __esm(() => {
   init_dist2();
-  import_picocolors17 = __toESM(require_picocolors(), 1);
+  import_picocolors18 = __toESM(require_picocolors(), 1);
 });
 
 // src/domains/help/commands/common-options.ts
@@ -14734,22 +16521,22 @@ function padEnd(text, width) {
   const padding = Math.max(0, width - visibleLength);
   return text + " ".repeat(padding);
 }
-var import_picocolors27, NO_COLOR, isColorSupported, identity = (text) => text, colors, defaultTheme;
+var import_picocolors28, NO_COLOR, isColorSupported, identity = (text) => text, colors, defaultTheme;
 var init_help_colors = __esm(() => {
-  import_picocolors27 = __toESM(require_picocolors(), 1);
+  import_picocolors28 = __toESM(require_picocolors(), 1);
   NO_COLOR = process.env.NO_COLOR !== undefined;
   isColorSupported = !NO_COLOR && Boolean(process.stdout.isTTY);
   colors = {
-    banner: isColorSupported ? import_picocolors27.default.cyan : identity,
-    command: isColorSupported ? import_picocolors27.default.bold : identity,
-    heading: isColorSupported ? import_picocolors27.default.yellow : identity,
-    flag: isColorSupported ? import_picocolors27.default.green : identity,
-    description: isColorSupported ? import_picocolors27.default.gray : identity,
-    example: isColorSupported ? import_picocolors27.default.blue : identity,
-    warning: isColorSupported ? import_picocolors27.default.yellow : identity,
-    error: isColorSupported ? import_picocolors27.default.red : identity,
-    muted: isColorSupported ? import_picocolors27.default.dim : identity,
-    success: isColorSupported ? import_picocolors27.default.green : identity
+    banner: isColorSupported ? import_picocolors28.default.cyan : identity,
+    command: isColorSupported ? import_picocolors28.default.bold : identity,
+    heading: isColorSupported ? import_picocolors28.default.yellow : identity,
+    flag: isColorSupported ? import_picocolors28.default.green : identity,
+    description: isColorSupported ? import_picocolors28.default.gray : identity,
+    example: isColorSupported ? import_picocolors28.default.blue : identity,
+    warning: isColorSupported ? import_picocolors28.default.yellow : identity,
+    error: isColorSupported ? import_picocolors28.default.red : identity,
+    muted: isColorSupported ? import_picocolors28.default.dim : identity,
+    success: isColorSupported ? import_picocolors28.default.green : identity
   };
   defaultTheme = {
     banner: colors.banner,
@@ -17707,11 +19494,15 @@ async function checkPathRefsValid(projectDir) {
     const broken = [];
     for (const ref of refs) {
       let refPath;
-      if (ref.startsWith("$HOME") || ref.startsWith("%USERPROFILE%")) {
-        refPath = normalize3(ref.replace("$HOME", home).replace("%USERPROFILE%", home));
+      if (ref.startsWith("$HOME") || ref.startsWith("${HOME}") || ref.startsWith("%USERPROFILE%")) {
+        refPath = normalize3(ref.replace(/^\$\{?HOME\}?/, home).replace("%USERPROFILE%", home));
+      } else if (ref.startsWith("$CLAUDE_PROJECT_DIR") || ref.startsWith("${CLAUDE_PROJECT_DIR}") || ref.startsWith("%CLAUDE_PROJECT_DIR%")) {
+        refPath = normalize3(ref.replace(/^\$\{?CLAUDE_PROJECT_DIR\}?/, projectDir).replace("%CLAUDE_PROJECT_DIR%", projectDir));
+      } else if (ref.startsWith("~")) {
+        refPath = normalize3(ref.replace(/^~/, home));
       } else if (ref.startsWith("/")) {
         refPath = normalize3(ref);
-      } else if (ref.includes(":") && ref.startsWith("\\")) {
+      } else if (/^[A-Za-z]:/.test(ref)) {
         refPath = normalize3(ref);
       } else {
         refPath = resolve(baseDir, ref);
@@ -17719,7 +19510,7 @@ async function checkPathRefsValid(projectDir) {
       const normalizedPath = normalize3(refPath);
       const isWithinHome = normalizedPath.startsWith(home);
       const isWithinBase = normalizedPath.startsWith(normalize3(baseDir));
-      const isAbsoluteAllowed = ref.startsWith("/") || ref.includes(":") && ref.startsWith("\\");
+      const isAbsoluteAllowed = ref.startsWith("/") || /^[A-Za-z]:/.test(ref);
       if (!isWithinHome && !isWithinBase && !isAbsoluteAllowed) {
         logger.verbose("Skipping potentially unsafe path reference", { ref, refPath });
         continue;
@@ -22114,13 +23905,14 @@ init_logger();
 
 // src/domains/ui/prompts/kit-prompts.ts
 init_types2();
-async function selectKit(defaultKit) {
+async function selectKit(defaultKit, accessibleKits) {
+  const kits = accessibleKits ?? Object.keys(AVAILABLE_KITS);
   const kit = await ie({
     message: "Select a ClaudeKit:",
-    options: Object.entries(AVAILABLE_KITS).map(([key, config]) => ({
+    options: kits.map((key) => ({
       value: key,
-      label: config.name,
-      hint: config.description
+      label: AVAILABLE_KITS[key].name,
+      hint: AVAILABLE_KITS[key].description
     })),
     initialValue: defaultKit
   });
@@ -22652,8 +24444,8 @@ async function promptSkillsInstallation() {
 }
 // src/domains/ui/prompts.ts
 class PromptsManager {
-  async selectKit(defaultKit) {
-    return selectKit(defaultKit);
+  async selectKit(defaultKit, accessibleKits) {
+    return selectKit(defaultKit, accessibleKits);
   }
   async selectVersion(versions, defaultVersion) {
     return selectVersion(versions, defaultVersion);
@@ -31987,17 +33779,169 @@ init_dist2();
 // src/domains/installation/merger/copy-executor.ts
 init_logger();
 init_types2();
-var import_fs_extra7 = __toESM(require_lib(), 1);
+var import_fs_extra8 = __toESM(require_lib(), 1);
 var import_ignore3 = __toESM(require_ignore(), 1);
-import { dirname as dirname8, join as join38, relative as relative6 } from "node:path";
+import { dirname as dirname8, join as join39, relative as relative6 } from "node:path";
 
 // src/domains/installation/selective-merger.ts
 import { stat as stat6 } from "node:fs/promises";
+
+// src/services/file-operations/manifest/manifest-reader.ts
+import { join as join35 } from "node:path";
+init_logger();
+init_types2();
+var import_fs_extra4 = __toESM(require_lib(), 1);
+async function readManifest(claudeDir) {
+  const metadataPath = join35(claudeDir, "metadata.json");
+  if (!await import_fs_extra4.pathExists(metadataPath)) {
+    return null;
+  }
+  try {
+    const content = await import_fs_extra4.readFile(metadataPath, "utf-8");
+    const parsed = JSON.parse(content);
+    return MetadataSchema.parse(parsed);
+  } catch (error) {
+    logger.debug(`Failed to read manifest: ${error}`);
+    return null;
+  }
+}
+async function readKitManifest(claudeDir, kit) {
+  const metadata = await readManifest(claudeDir);
+  if (!metadata)
+    return null;
+  return getKitMetadata(metadata, kit);
+}
+async function findFileInInstalledKits(claudeDir, relativePath, excludeKit) {
+  const metadata = await readManifest(claudeDir);
+  if (!metadata?.kits) {
+    return {
+      exists: false,
+      ownerKit: null,
+      checksum: null,
+      version: null,
+      sourceTimestamp: null,
+      installedAt: null
+    };
+  }
+  for (const [kitName, kitMeta] of Object.entries(metadata.kits)) {
+    const kit = kitName;
+    if (kit === excludeKit)
+      continue;
+    if (!kitMeta.files)
+      continue;
+    const file = kitMeta.files.find((f3) => f3.path === relativePath);
+    if (file) {
+      return {
+        exists: true,
+        ownerKit: kit,
+        checksum: file.checksum,
+        version: kitMeta.version,
+        sourceTimestamp: file.sourceTimestamp ?? null,
+        installedAt: file.installedAt ?? null
+      };
+    }
+  }
+  return {
+    exists: false,
+    ownerKit: null,
+    checksum: null,
+    version: null,
+    sourceTimestamp: null,
+    installedAt: null
+  };
+}
+async function getUninstallManifest(claudeDir, kit) {
+  const detection = await detectMetadataFormat(claudeDir);
+  if (detection.format === "multi-kit" && detection.metadata?.kits) {
+    const installedKits = Object.keys(detection.metadata.kits);
+    if (kit) {
+      const kitMeta = detection.metadata.kits[kit];
+      if (!kitMeta?.files) {
+        return {
+          filesToRemove: [],
+          filesToPreserve: USER_CONFIG_PATTERNS,
+          hasManifest: true,
+          isMultiKit: true,
+          remainingKits: installedKits.filter((k2) => k2 !== kit)
+        };
+      }
+      const kitFiles = kitMeta.files.map((f3) => f3.path);
+      const sharedFiles = new Set;
+      for (const otherKit of installedKits) {
+        if (otherKit !== kit) {
+          const otherMeta = detection.metadata.kits[otherKit];
+          if (otherMeta?.files) {
+            for (const f3 of otherMeta.files) {
+              sharedFiles.add(f3.path);
+            }
+          }
+        }
+      }
+      const filesToRemove = kitFiles.filter((f3) => !sharedFiles.has(f3));
+      const filesToPreserve = [
+        ...USER_CONFIG_PATTERNS,
+        ...kitFiles.filter((f3) => sharedFiles.has(f3))
+      ];
+      return {
+        filesToRemove,
+        filesToPreserve,
+        hasManifest: true,
+        isMultiKit: true,
+        remainingKits: installedKits.filter((k2) => k2 !== kit)
+      };
+    }
+    const allFiles = getAllTrackedFiles(detection.metadata);
+    return {
+      filesToRemove: allFiles.map((f3) => f3.path),
+      filesToPreserve: USER_CONFIG_PATTERNS,
+      hasManifest: true,
+      isMultiKit: true,
+      remainingKits: []
+    };
+  }
+  if (detection.format === "legacy" && detection.metadata) {
+    const legacyFiles2 = detection.metadata.files?.map((f3) => f3.path) || [];
+    const installedFiles = detection.metadata.installedFiles || [];
+    const hasFiles = legacyFiles2.length > 0 || installedFiles.length > 0;
+    if (!hasFiles) {
+      const legacyDirs2 = ["commands", "agents", "skills", "workflows", "hooks", "scripts"];
+      const legacyFileList = ["metadata.json"];
+      return {
+        filesToRemove: [...legacyDirs2, ...legacyFileList],
+        filesToPreserve: USER_CONFIG_PATTERNS,
+        hasManifest: false,
+        isMultiKit: false,
+        remainingKits: []
+      };
+    }
+    return {
+      filesToRemove: legacyFiles2.length > 0 ? legacyFiles2 : installedFiles,
+      filesToPreserve: detection.metadata.userConfigFiles || USER_CONFIG_PATTERNS,
+      hasManifest: true,
+      isMultiKit: false,
+      remainingKits: []
+    };
+  }
+  const legacyDirs = ["commands", "agents", "skills", "workflows", "hooks", "scripts"];
+  const legacyFiles = ["metadata.json"];
+  return {
+    filesToRemove: [...legacyDirs, ...legacyFiles],
+    filesToPreserve: USER_CONFIG_PATTERNS,
+    hasManifest: false,
+    isMultiKit: false,
+    remainingKits: []
+  };
+}
+
+// src/domains/installation/selective-merger.ts
 init_logger();
+var import_semver = __toESM(require_semver2(), 1);
 
 class SelectiveMerger {
   manifest;
   manifestMap;
+  claudeDir = null;
+  installingKit = null;
   constructor(manifest) {
     this.manifest = manifest;
     this.manifestMap = new Map;
@@ -32007,11 +33951,21 @@ class SelectiveMerger {
       }
     }
   }
+  setMultiKitContext(claudeDir, installingKit) {
+    this.claudeDir = claudeDir;
+    this.installingKit = installingKit;
+  }
   async shouldCopyFile(destPath, relativePath) {
     let destStat;
     try {
       destStat = await stat6(destPath);
     } catch {
+      if (this.claudeDir && this.installingKit) {
+        const installed = await findFileInInstalledKits(this.claudeDir, relativePath, this.installingKit);
+        if (installed.exists) {
+          logger.debug(`File ${relativePath} tracked by ${installed.ownerKit} but missing on disk`);
+        }
+      }
       return { changed: true, reason: "new" };
     }
     const manifestEntry = this.manifestMap.get(relativePath);
@@ -32019,6 +33973,94 @@ class SelectiveMerger {
       logger.debug(`No manifest entry for ${relativePath}, will copy`);
       return { changed: true, reason: "new" };
     }
+    if (this.claudeDir && this.installingKit) {
+      const installed = await findFileInInstalledKits(this.claudeDir, relativePath, this.installingKit);
+      if (installed.exists && installed.checksum && installed.ownerKit) {
+        if (installed.checksum === manifestEntry.checksum) {
+          logger.debug(`Shared identical: ${relativePath} (owned by ${installed.ownerKit})`);
+          return {
+            changed: false,
+            reason: "shared-identical",
+            sourceChecksum: manifestEntry.checksum,
+            destChecksum: installed.checksum,
+            sharedWithKit: installed.ownerKit
+          };
+        }
+        const incomingTimestamp = manifestEntry.lastModified ?? null;
+        const existingTimestamp = installed.sourceTimestamp;
+        const conflictBase = {
+          relativePath,
+          incomingKit: this.installingKit,
+          existingKit: installed.ownerKit,
+          incomingTimestamp,
+          existingTimestamp
+        };
+        if (incomingTimestamp && existingTimestamp) {
+          const incomingTime = new Date(incomingTimestamp).getTime();
+          const existingTime = new Date(existingTimestamp).getTime();
+          if (Number.isNaN(incomingTime) || Number.isNaN(existingTime)) {
+            logger.debug(`Invalid timestamp for ${relativePath}, falling back to version`);
+          } else if (incomingTime > existingTime) {
+            logger.debug(`Shared newer: ${relativePath} - incoming ${incomingTimestamp} > existing ${existingTimestamp}`);
+            return {
+              changed: true,
+              reason: "shared-newer",
+              sourceChecksum: manifestEntry.checksum,
+              destChecksum: installed.checksum,
+              sharedWithKit: installed.ownerKit,
+              conflictInfo: { ...conflictBase, winner: "incoming", reason: "newer" }
+            };
+          } else if (incomingTime < existingTime) {
+            logger.debug(`Shared older: ${relativePath} - incoming ${incomingTimestamp} < existing ${existingTimestamp}`);
+            return {
+              changed: false,
+              reason: "shared-older",
+              sourceChecksum: manifestEntry.checksum,
+              destChecksum: installed.checksum,
+              sharedWithKit: installed.ownerKit,
+              conflictInfo: { ...conflictBase, winner: "existing", reason: "existing-newer" }
+            };
+          } else {
+            logger.debug(`Shared tie: ${relativePath} - same timestamp, keeping existing`);
+            return {
+              changed: false,
+              reason: "shared-older",
+              sourceChecksum: manifestEntry.checksum,
+              destChecksum: installed.checksum,
+              sharedWithKit: installed.ownerKit,
+              conflictInfo: { ...conflictBase, winner: "existing", reason: "tie" }
+            };
+          }
+        } else if (installed.version) {
+          const incomingVersion = this.manifest?.version || "0.0.0";
+          const installedVersion = installed.version;
+          const incomingSemver = import_semver.default.coerce(incomingVersion);
+          const installedSemver = import_semver.default.coerce(installedVersion);
+          if (incomingSemver && installedSemver) {
+            if (import_semver.default.lte(incomingSemver, installedSemver)) {
+              logger.debug(`Shared older (version fallback): ${relativePath} - incoming ${incomingVersion} <= installed ${installedVersion}`);
+              return {
+                changed: false,
+                reason: "shared-older",
+                sourceChecksum: manifestEntry.checksum,
+                destChecksum: installed.checksum,
+                sharedWithKit: installed.ownerKit,
+                conflictInfo: { ...conflictBase, winner: "existing", reason: "no-timestamps" }
+              };
+            }
+          }
+          logger.debug(`Updating shared file (version fallback): ${relativePath} - incoming ${incomingVersion} > installed ${installedVersion}`);
+          return {
+            changed: true,
+            reason: "shared-newer",
+            sourceChecksum: manifestEntry.checksum,
+            destChecksum: installed.checksum,
+            sharedWithKit: installed.ownerKit,
+            conflictInfo: { ...conflictBase, winner: "incoming", reason: "no-timestamps" }
+          };
+        }
+      }
+    }
     if (destStat.size !== manifestEntry.size) {
       logger.debug(`Size differs for ${relativePath}: ${destStat.size} vs ${manifestEntry.size}`);
       return {
@@ -32055,10 +34097,10 @@ class SelectiveMerger {
 
 // src/domains/installation/merger/file-scanner.ts
 init_logger();
-var import_fs_extra4 = __toESM(require_lib(), 1);
+var import_fs_extra5 = __toESM(require_lib(), 1);
 var import_ignore2 = __toESM(require_ignore(), 1);
 import { relative as relative5 } from "node:path";
-import { join as join35 } from "node:path";
+import { join as join36 } from "node:path";
 
 // node_modules/@isaacs/balanced-match/dist/esm/index.js
 var balanced = (a3, b3, str) => {
@@ -33512,12 +35554,12 @@ class FileScanner {
   }
   async getFiles(dir, baseDir = dir) {
     const files = [];
-    const entries = await import_fs_extra4.readdir(dir, { encoding: "utf8" });
+    const entries = await import_fs_extra5.readdir(dir, { encoding: "utf8" });
     for (const entry of entries) {
-      const fullPath = join35(dir, entry);
+      const fullPath = join36(dir, entry);
       const relativePath = relative5(baseDir, fullPath);
       const normalizedRelativePath = relativePath.replace(/\\/g, "/");
-      const stats = await import_fs_extra4.lstat(fullPath);
+      const stats = await import_fs_extra5.lstat(fullPath);
       if (stats.isSymbolicLink()) {
         logger.warning(`Skipping symbolic link: ${normalizedRelativePath}`);
         continue;
@@ -33548,10 +35590,34 @@ class FileScanner {
 }
 
 // src/domains/config/installed-settings-tracker.ts
-init_logger();
 import { existsSync as existsSync16 } from "node:fs";
-import { mkdir as mkdir14, readFile as readFile11, writeFile as writeFile9 } from "node:fs/promises";
-import { dirname as dirname6, join as join36 } from "node:path";
+import { mkdir as mkdir14, readFile as readFile12, writeFile as writeFile9 } from "node:fs/promises";
+import { dirname as dirname6, join as join37 } from "node:path";
+
+// src/shared/index.ts
+init_logger();
+init_environment();
+init_terminal_utils();
+
+// src/shared/command-normalizer.ts
+function normalizeCommand(cmd) {
+  if (!cmd)
+    return "";
+  let normalized = cmd;
+  normalized = normalized.replace(/"\$HOME"/g, "$HOME");
+  normalized = normalized.replace(/"\$CLAUDE_PROJECT_DIR"/g, "$HOME");
+  normalized = normalized.replace(/"\$\{HOME\}"/g, "$HOME");
+  normalized = normalized.replace(/\$CLAUDE_PROJECT_DIR/g, "$HOME");
+  normalized = normalized.replace(/\$\{HOME\}/g, "$HOME");
+  normalized = normalized.replace(/"%USERPROFILE%"/g, "$HOME");
+  normalized = normalized.replace(/%USERPROFILE%/g, "$HOME");
+  normalized = normalized.replace(/"%CLAUDE_PROJECT_DIR%"/g, "$HOME");
+  normalized = normalized.replace(/%CLAUDE_PROJECT_DIR%/g, "$HOME");
+  normalized = normalized.replace(/\\/g, "/");
+  normalized = normalized.replace(/\s+/g, " ").trim();
+  return normalized;
+}
+// src/domains/config/installed-settings-tracker.ts
 var CK_JSON_FILE = ".ck.json";
 
 class InstalledSettingsTracker {
@@ -33565,9 +35631,9 @@ class InstalledSettingsTracker {
   }
   getCkJsonPath() {
     if (this.isGlobal) {
-      return join36(this.projectDir, CK_JSON_FILE);
+      return join37(this.projectDir, CK_JSON_FILE);
     }
-    return join36(this.projectDir, ".claude", CK_JSON_FILE);
+    return join37(this.projectDir, ".claude", CK_JSON_FILE);
   }
   async loadInstalledSettings() {
     const ckJsonPath = this.getCkJsonPath();
@@ -33575,7 +35641,7 @@ class InstalledSettingsTracker {
       return { hooks: [], mcpServers: [] };
     }
     try {
-      const content = await readFile11(ckJsonPath, "utf-8");
+      const content = await readFile12(ckJsonPath, "utf-8");
       const data = JSON.parse(content);
       const installed = data.kits?.[this.kitName]?.installedSettings;
       if (installed) {
@@ -33592,7 +35658,7 @@ class InstalledSettingsTracker {
     try {
       let data = {};
       if (existsSync16(ckJsonPath)) {
-        const content = await readFile11(ckJsonPath, "utf-8");
+        const content = await readFile12(ckJsonPath, "utf-8");
         data = JSON.parse(content);
       }
       if (!data.kits) {
@@ -33610,7 +35676,8 @@ class InstalledSettingsTracker {
     }
   }
   wasHookInstalled(command, installed) {
-    return installed.hooks?.includes(command) ?? false;
+    const normalizedCommand = normalizeCommand(command);
+    return installed.hooks?.some((hook) => normalizeCommand(hook) === normalizedCommand) ?? false;
   }
   wasMcpServerInstalled(serverName, installed) {
     return installed.mcpServers?.includes(serverName) ?? false;
@@ -33619,8 +35686,10 @@ class InstalledSettingsTracker {
     if (!settings.hooks) {
       settings.hooks = [];
     }
-    if (!settings.hooks.includes(command)) {
-      settings.hooks.push(command);
+    const normalizedCommand = normalizeCommand(command);
+    const alreadyTracked = settings.hooks.some((hook) => normalizeCommand(hook) === normalizedCommand);
+    if (!alreadyTracked) {
+      settings.hooks.push(normalizedCommand);
     }
   }
   trackMcpServer(serverName, settings) {
@@ -33640,9 +35709,6 @@ class InstalledSettingsTracker {
 // src/domains/config/merger/merge-engine.ts
 init_logger();
 
-// src/domains/config/merger/conflict-resolver.ts
-init_logger();
-
 // src/domains/config/merger/diff-calculator.ts
 function truncateCommand(cmd, maxLen = 50) {
   if (cmd.length <= maxLen)
@@ -33661,12 +35727,12 @@ function deepCopyEntry(entry) {
 function extractCommands(entries, commands) {
   for (const entry of entries) {
     if ("command" in entry && entry.command) {
-      commands.add(entry.command);
+      commands.add(normalizeCommand(entry.command));
     }
     if ("hooks" in entry && entry.hooks) {
       for (const hook of entry.hooks) {
         if (hook.command) {
-          commands.add(hook.command);
+          commands.add(normalizeCommand(hook.command));
         }
       }
     }
@@ -33695,13 +35761,46 @@ function logDuplicates(duplicateCommands, eventName, result) {
 
 // src/domains/config/merger/conflict-resolver.ts
 function wasCommandInstalled(command, installedHooks) {
-  return installedHooks.includes(command);
+  const normalizedCommand = normalizeCommand(command);
+  return installedHooks.some((hook) => normalizeCommand(hook) === normalizedCommand);
 }
-function mergeHookEntries(sourceEntries, destEntries, eventName, result, installedHooks = []) {
-  if (destEntries.length > 0) {
-    result.hooksPreserved += destEntries.length;
+function dedupeDestinationEntries(entries) {
+  const seenCommands = new Set;
+  const deduped = [];
+  let removedCount = 0;
+  for (const entry of entries) {
+    const commands = getEntryCommands(entry);
+    if (commands.length === 0) {
+      deduped.push(deepCopyEntry(entry));
+      continue;
+    }
+    const uniqueCommands = commands.filter((cmd) => !seenCommands.has(normalizeCommand(cmd)));
+    if (uniqueCommands.length === 0) {
+      removedCount++;
+      logger.verbose(`Removing duplicate hook entry: ${commands[0]?.slice(0, 50)}...`);
+      continue;
+    }
+    if ("hooks" in entry && entry.hooks && uniqueCommands.length < commands.length) {
+      const filteredHooks = entry.hooks.filter((h2) => !h2.command || !seenCommands.has(normalizeCommand(h2.command)));
+      deduped.push({ ...entry, hooks: filteredHooks });
+    } else {
+      deduped.push(deepCopyEntry(entry));
+    }
+    for (const cmd of commands) {
+      seenCommands.add(normalizeCommand(cmd));
+    }
+  }
+  return { deduped, removedCount };
+}
+function mergeHookEntries(sourceEntries, destEntries, eventName, result, installedHooks = [], sourceKit) {
+  const { deduped: dedupedDest, removedCount } = dedupeDestinationEntries(destEntries);
+  if (removedCount > 0) {
+    logger.info(`Cleaned up ${removedCount} duplicate hook(s) from existing settings`);
   }
-  const merged = destEntries.map((entry) => deepCopyEntry(entry));
+  if (dedupedDest.length > 0) {
+    result.hooksPreserved += dedupedDest.length;
+  }
+  const merged = dedupedDest;
   const matcherIndex = new Map;
   for (let i = 0;i < merged.length; i++) {
     const entry = merged[i];
@@ -33710,11 +35809,11 @@ function mergeHookEntries(sourceEntries, destEntries, eventName, result, install
     }
   }
   const existingCommands = new Set;
-  extractCommands(destEntries, existingCommands);
+  extractCommands(dedupedDest, existingCommands);
   for (const entry of sourceEntries) {
     const sourceMatcher = "matcher" in entry ? entry.matcher : undefined;
     const commands = getEntryCommands(entry);
-    const userRemovedCommands = commands.filter((cmd) => !existingCommands.has(cmd) && wasCommandInstalled(cmd, installedHooks));
+    const userRemovedCommands = commands.filter((cmd) => !existingCommands.has(normalizeCommand(cmd)) && wasCommandInstalled(cmd, installedHooks));
     if (userRemovedCommands.length > 0) {
       result.hooksSkipped += userRemovedCommands.length;
       for (const cmd of userRemovedCommands) {
@@ -33729,27 +35828,31 @@ function mergeHookEntries(sourceEntries, destEntries, eventName, result, install
       if (existingIdx === undefined)
         continue;
       const existingEntry = merged[existingIdx];
-      const newCommands = commands.filter((cmd) => !existingCommands.has(cmd) && !wasCommandInstalled(cmd, installedHooks));
-      const duplicateCommands = commands.filter((cmd) => existingCommands.has(cmd));
+      const newCommands = commands.filter((cmd) => !existingCommands.has(normalizeCommand(cmd)) && !wasCommandInstalled(cmd, installedHooks));
+      const duplicateCommands = commands.filter((cmd) => existingCommands.has(normalizeCommand(cmd)));
       logDuplicates(duplicateCommands, eventName, result);
       if (newCommands.length > 0 && "hooks" in entry && entry.hooks) {
         if (!existingEntry.hooks) {
           existingEntry.hooks = [];
         }
         for (const hook of entry.hooks) {
-          if (hook.command && !existingCommands.has(hook.command) && !wasCommandInstalled(hook.command, installedHooks)) {
-            existingEntry.hooks.push(hook);
-            existingCommands.add(hook.command);
+          if (hook.command && !existingCommands.has(normalizeCommand(hook.command)) && !wasCommandInstalled(hook.command, installedHooks)) {
+            const taggedHook = sourceKit ? { ...hook, _origin: sourceKit } : hook;
+            existingEntry.hooks.push(taggedHook);
+            existingCommands.add(normalizeCommand(hook.command));
             result.newlyInstalledHooks.push(hook.command);
+            if (sourceKit) {
+              trackHookOrigin(result, sourceKit, hook.command);
+            }
           }
         }
         result.hooksAdded++;
       }
     } else {
-      const isFullyDuplicated = commands.length > 0 && commands.every((cmd) => existingCommands.has(cmd));
-      const duplicateCommands = commands.filter((cmd) => existingCommands.has(cmd));
+      const isFullyDuplicated = commands.length > 0 && commands.every((cmd) => existingCommands.has(normalizeCommand(cmd)));
+      const duplicateCommands = commands.filter((cmd) => existingCommands.has(normalizeCommand(cmd)));
       logDuplicates(duplicateCommands, eventName, result);
-      const hasNonRemovedCommands = commands.length === 0 || commands.some((cmd) => !existingCommands.has(cmd) && !wasCommandInstalled(cmd, installedHooks));
+      const hasNonRemovedCommands = commands.length === 0 || commands.some((cmd) => !existingCommands.has(normalizeCommand(cmd)) && !wasCommandInstalled(cmd, installedHooks));
       if (!isFullyDuplicated && hasNonRemovedCommands) {
         let filteredEntry = entry;
         if ("hooks" in entry && entry.hooks && userRemovedCommands.length > 0) {
@@ -33758,17 +35861,22 @@ function mergeHookEntries(sourceEntries, destEntries, eventName, result, install
         } else if ("command" in entry && wasCommandInstalled(entry.command, installedHooks)) {
           continue;
         }
-        merged.push(filteredEntry);
+        const taggedEntry = sourceKit ? tagHooksWithOrigin(filteredEntry, sourceKit) : filteredEntry;
+        merged.push(taggedEntry);
         result.hooksAdded++;
         if (sourceMatcher) {
           matcherIndex.set(sourceMatcher, merged.length - 1);
         }
         for (const cmd of commands) {
-          if (!existingCommands.has(cmd) && !wasCommandInstalled(cmd, installedHooks)) {
-            existingCommands.add(cmd);
+          const normalizedCmd = normalizeCommand(cmd);
+          if (!existingCommands.has(normalizedCmd) && !wasCommandInstalled(cmd, installedHooks)) {
+            existingCommands.add(normalizedCmd);
             result.newlyInstalledHooks.push(cmd);
-          } else if (!existingCommands.has(cmd)) {
-            existingCommands.add(cmd);
+            if (sourceKit) {
+              trackHookOrigin(result, sourceKit, cmd);
+            }
+          } else if (!existingCommands.has(normalizedCmd)) {
+            existingCommands.add(normalizedCmd);
           }
         }
       }
@@ -33776,14 +35884,32 @@ function mergeHookEntries(sourceEntries, destEntries, eventName, result, install
   }
   return merged;
 }
+function tagHooksWithOrigin(entry, kit) {
+  if ("hooks" in entry && entry.hooks) {
+    return {
+      ...entry,
+      hooks: entry.hooks.map((h2) => ({ ...h2, _origin: kit }))
+    };
+  }
+  if ("command" in entry) {
+    return { ...entry, _origin: kit };
+  }
+  return entry;
+}
+function trackHookOrigin(result, kit, command) {
+  const existing = result.hooksByOrigin.get(kit) || [];
+  existing.push(command);
+  result.hooksByOrigin.set(kit, existing);
+}
 
 // src/domains/config/merger/merge-engine.ts
 function mergeHooks(sourceHooks, destHooks, result, options) {
   const merged = { ...destHooks };
   const installedHooks = options?.installedSettings?.hooks ?? [];
+  const sourceKit = options?.sourceKit;
   for (const [eventName, sourceEntries] of Object.entries(sourceHooks)) {
     const destEntries = destHooks[eventName] || [];
-    merged[eventName] = mergeHookEntries(sourceEntries, destEntries, eventName, result, installedHooks);
+    merged[eventName] = mergeHookEntries(sourceEntries, destEntries, eventName, result, installedHooks, sourceKit);
   }
   return merged;
 }
@@ -33797,8 +35923,54 @@ function mergeMcp(sourceMcp, destMcp, result, options) {
   if (sourceMcp.servers) {
     const destServers = destMcp.servers || {};
     merged.servers = { ...destServers };
+    const sourceTimestamps = options?.sourceTimestamps?.mcpServers ?? {};
+    const destTimestamps = options?.installedSettings?.mcpServerTimestamps ?? {};
     for (const [serverName, serverConfig] of Object.entries(sourceMcp.servers)) {
       if (serverName in destServers) {
+        const sourceTs = sourceTimestamps[serverName];
+        const destTs = destTimestamps[serverName];
+        if (sourceTs && destTs) {
+          const sourceTime = new Date(sourceTs).getTime();
+          const destTime = new Date(destTs).getTime();
+          if (sourceTime > destTime) {
+            merged.servers[serverName] = serverConfig;
+            result.mcpServersOverwritten = (result.mcpServersOverwritten ?? 0) + 1;
+            result.mcpConflicts = result.mcpConflicts ?? [];
+            result.mcpConflicts.push({
+              serverName,
+              incomingKit: options?.sourceKit ?? "unknown",
+              existingKit: "existing",
+              winner: options?.sourceKit ?? "incoming",
+              reason: "newer"
+            });
+            logger.debug(`Overwrote MCP server (newer): ${serverName}`);
+            continue;
+          }
+          if (sourceTime < destTime) {
+            result.mcpServersPreserved++;
+            result.mcpConflicts = result.mcpConflicts ?? [];
+            result.mcpConflicts.push({
+              serverName,
+              incomingKit: options?.sourceKit ?? "unknown",
+              existingKit: "existing",
+              winner: "existing",
+              reason: "existing-newer"
+            });
+            logger.debug(`Preserved MCP server (existing newer): ${serverName}`);
+            continue;
+          }
+          result.mcpServersPreserved++;
+          result.mcpConflicts = result.mcpConflicts ?? [];
+          result.mcpConflicts.push({
+            serverName,
+            incomingKit: options?.sourceKit ?? "unknown",
+            existingKit: "existing",
+            winner: "existing",
+            reason: "tie"
+          });
+          logger.debug(`Preserved MCP server (tie): ${serverName}`);
+          continue;
+        }
         const userModified = JSON.stringify(serverConfig) !== JSON.stringify(destServers[serverName]);
         if (userModified) {
           result.mcpServersPreserved++;
@@ -33834,7 +36006,8 @@ function mergeSettings(source, destination, options) {
     mcpServersSkipped: 0,
     conflictsDetected: [],
     newlyInstalledHooks: [],
-    newlyInstalledServers: []
+    newlyInstalledServers: [],
+    hooksByOrigin: new Map
   };
   if (source.hooks) {
     result.merged.hooks = mergeHooks(source.hooks, destination.hooks || {}, result, options);
@@ -33851,15 +36024,15 @@ function mergeSettings(source, destination, options) {
 }
 // src/domains/config/merger/file-io.ts
 init_logger();
-var import_fs_extra5 = __toESM(require_lib(), 1);
+var import_fs_extra6 = __toESM(require_lib(), 1);
 import { randomUUID } from "node:crypto";
-import { dirname as dirname7, join as join37 } from "node:path";
+import { dirname as dirname7, join as join38 } from "node:path";
 async function readSettingsFile(filePath) {
   try {
-    if (!await import_fs_extra5.pathExists(filePath)) {
+    if (!await import_fs_extra6.pathExists(filePath)) {
       return null;
     }
-    const content = await import_fs_extra5.readFile(filePath, "utf-8");
+    const content = await import_fs_extra6.readFile(filePath, "utf-8");
     const parsed = JSON.parse(content);
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
       logger.warning(`Invalid settings file format (expected object): ${filePath}`);
@@ -33873,14 +36046,14 @@ async function readSettingsFile(filePath) {
 }
 async function atomicWriteFile(filePath, content) {
   const dir = dirname7(filePath);
-  const tempPath = join37(dir, `.settings-${randomUUID()}.tmp`);
+  const tempPath = join38(dir, `.settings-${randomUUID()}.tmp`);
   try {
-    await import_fs_extra5.writeFile(tempPath, content, "utf-8");
-    await import_fs_extra5.rename(tempPath, filePath);
+    await import_fs_extra6.writeFile(tempPath, content, "utf-8");
+    await import_fs_extra6.rename(tempPath, filePath);
   } catch (error) {
     try {
-      if (await import_fs_extra5.pathExists(tempPath)) {
-        await import_fs_extra5.unlink(tempPath);
+      if (await import_fs_extra6.pathExists(tempPath)) {
+        await import_fs_extra6.unlink(tempPath);
       }
     } catch {}
     throw error;
@@ -33909,7 +36082,7 @@ class SettingsMerger {
 // src/domains/installation/merger/settings-processor.ts
 init_environment();
 init_logger();
-var import_fs_extra6 = __toESM(require_lib(), 1);
+var import_fs_extra7 = __toESM(require_lib(), 1);
 
 class SettingsProcessor {
   isGlobal = false;
@@ -33917,6 +36090,7 @@ class SettingsProcessor {
   projectDir = "";
   kitName = "engineer";
   tracker = null;
+  installingKit;
   setGlobalFlag(isGlobal) {
     this.isGlobal = isGlobal;
   }
@@ -33931,6 +36105,9 @@ class SettingsProcessor {
     this.kitName = kit;
     this.initTracker();
   }
+  setInstallingKit(kit) {
+    this.installingKit = kit;
+  }
   initTracker() {
     if (this.projectDir) {
       this.tracker = new InstalledSettingsTracker(this.projectDir, this.isGlobal, this.kitName);
@@ -33938,7 +36115,7 @@ class SettingsProcessor {
   }
   async processSettingsJson(sourceFile, destFile) {
     try {
-      const sourceContent = await import_fs_extra6.readFile(sourceFile, "utf-8");
+      const sourceContent = await import_fs_extra7.readFile(sourceFile, "utf-8");
       let transformedSource = sourceContent;
       if (this.isGlobal) {
         const homeVar = isWindows() ? '"%USERPROFILE%"' : '"$HOME"';
@@ -33953,12 +36130,12 @@ class SettingsProcessor {
           logger.debug(`Transformed .claude/ paths to ${projectDirVar}/.claude/ in settings.json for local installation`);
         }
       }
-      const destExists = await import_fs_extra6.pathExists(destFile);
+      const destExists = await import_fs_extra7.pathExists(destFile);
       if (destExists && !this.forceOverwriteSettings) {
         await this.selectiveMergeSettings(transformedSource, destFile);
       } else {
         const formattedContent = this.formatJsonContent(transformedSource);
-        await import_fs_extra6.writeFile(destFile, formattedContent, "utf-8");
+        await import_fs_extra7.writeFile(destFile, formattedContent, "utf-8");
         try {
           const parsedSettings = JSON.parse(formattedContent);
           if (this.forceOverwriteSettings && destExists) {
@@ -33972,7 +36149,7 @@ class SettingsProcessor {
       }
     } catch (error) {
       logger.error(`Failed to process settings.json: ${error}`);
-      await import_fs_extra6.copy(sourceFile, destFile, { overwrite: true });
+      await import_fs_extra7.copy(sourceFile, destFile, { overwrite: true });
     }
   }
   async selectiveMergeSettings(transformedSourceContent, destFile) {
@@ -33982,10 +36159,15 @@ class SettingsProcessor {
     } catch {
       logger.warning("Failed to parse source settings.json, falling back to overwrite");
       const formattedContent = this.formatJsonContent(transformedSourceContent);
-      await import_fs_extra6.writeFile(destFile, formattedContent, "utf-8");
+      await import_fs_extra7.writeFile(destFile, formattedContent, "utf-8");
       return;
     }
-    const destSettings = await SettingsMerger.readSettingsFile(destFile);
+    let destSettings;
+    if (this.isGlobal) {
+      destSettings = await this.readAndNormalizeGlobalSettings(destFile);
+    } else {
+      destSettings = await SettingsMerger.readSettingsFile(destFile);
+    }
     if (!destSettings) {
       await SettingsMerger.writeSettingsFile(destFile, sourceSettings);
       await this.trackInstalledSettings(sourceSettings);
@@ -33996,7 +36178,8 @@ class SettingsProcessor {
       installedSettings = await this.tracker.loadInstalledSettings();
     }
     const mergeResult = SettingsMerger.merge(sourceSettings, destSettings, {
-      installedSettings
+      installedSettings,
+      sourceKit: this.installingKit
     });
     logger.verbose("Settings merge details", {
       hooksAdded: mergeResult.hooksAdded,
@@ -34060,6 +36243,25 @@ class SettingsProcessor {
       return content;
     }
   }
+  async readAndNormalizeGlobalSettings(destFile) {
+    try {
+      const content = await import_fs_extra7.readFile(destFile, "utf-8");
+      if (!content.trim())
+        return null;
+      const homeVar = isWindows() ? "%USERPROFILE%" : "$HOME";
+      let normalized = content;
+      normalized = normalized.replace(/"\$CLAUDE_PROJECT_DIR"/g, `"${homeVar}"`);
+      normalized = normalized.replace(/\$CLAUDE_PROJECT_DIR/g, homeVar);
+      normalized = normalized.replace(/"%CLAUDE_PROJECT_DIR%"/g, `"${homeVar}"`);
+      normalized = normalized.replace(/%CLAUDE_PROJECT_DIR%/g, homeVar);
+      if (normalized !== content) {
+        logger.debug("Normalized $CLAUDE_PROJECT_DIR paths to $HOME in existing global settings");
+      }
+      return JSON.parse(normalized);
+    } catch {
+      return null;
+    }
+  }
   transformClaudePaths(content, prefix) {
     if (/\.claude\/[^\s"']*[;`$&|><]/.test(content)) {
       logger.warning("Potentially unsafe characters detected in .claude/ paths");
@@ -34084,13 +36286,22 @@ class CopyExecutor {
   settingsProcessor;
   selectiveMerger = null;
   unchangedSkipped = 0;
+  sharedSkipped = 0;
   installedFiles = new Set;
   installedDirectories = new Set;
+  fileConflicts = [];
+  claudeDir = null;
+  installingKit = null;
   constructor(neverCopyPatterns) {
     this.userConfigChecker = import_ignore3.default().add(USER_CONFIG_PATTERNS);
     this.fileScanner = new FileScanner(neverCopyPatterns);
     this.settingsProcessor = new SettingsProcessor;
   }
+  setMultiKitContext(claudeDir, installingKit) {
+    this.claudeDir = claudeDir;
+    this.installingKit = installingKit;
+    this.settingsProcessor.setInstallingKit(installingKit);
+  }
   setIncludePatterns(patterns) {
     this.fileScanner.setIncludePatterns(patterns);
   }
@@ -34109,6 +36320,9 @@ class CopyExecutor {
   setManifest(manifest) {
     this.selectiveMerger = manifest ? new SelectiveMerger(manifest) : null;
     if (manifest && this.selectiveMerger?.hasManifest()) {
+      if (this.claudeDir && this.installingKit) {
+        this.selectiveMerger.setMultiKitContext(this.claudeDir, this.installingKit);
+      }
       logger.debug(`Selective merge enabled with ${this.selectiveMerger.getManifestFileCount()} tracked files`);
     }
   }
@@ -34124,8 +36338,8 @@ class CopyExecutor {
     for (const file of files) {
       const relativePath = relative6(sourceDir, file);
       const normalizedRelativePath = relativePath.replace(/\\/g, "/");
-      const destPath = join38(destDir, relativePath);
-      if (await import_fs_extra7.pathExists(destPath)) {
+      const destPath = join39(destDir, relativePath);
+      if (await import_fs_extra8.pathExists(destPath)) {
         if (this.fileScanner.shouldNeverCopy(normalizedRelativePath)) {
           logger.debug(`Security-sensitive file exists but won't be overwritten: ${normalizedRelativePath}`);
           continue;
@@ -34146,14 +36360,14 @@ class CopyExecutor {
     for (const file of files) {
       const relativePath = relative6(sourceDir, file);
       const normalizedRelativePath = relativePath.replace(/\\/g, "/");
-      const destPath = join38(destDir, relativePath);
+      const destPath = join39(destDir, relativePath);
       if (this.fileScanner.shouldNeverCopy(normalizedRelativePath)) {
         logger.debug(`Skipping security-sensitive file: ${normalizedRelativePath}`);
         skippedCount++;
         continue;
       }
       if (this.userConfigChecker.ignores(normalizedRelativePath)) {
-        const fileExists = await import_fs_extra7.pathExists(destPath);
+        const fileExists = await import_fs_extra8.pathExists(destPath);
         if (fileExists) {
           logger.debug(`Preserving user config: ${normalizedRelativePath}`);
           skippedCount++;
@@ -34169,19 +36383,36 @@ class CopyExecutor {
       }
       if (this.selectiveMerger?.hasManifest()) {
         const compareResult = await this.selectiveMerger.shouldCopyFile(destPath, normalizedRelativePath);
+        if (compareResult.conflictInfo) {
+          this.fileConflicts.push(compareResult.conflictInfo);
+        }
         if (!compareResult.changed) {
-          logger.debug(`Skipping unchanged: ${normalizedRelativePath}`);
-          this.unchangedSkipped++;
+          if (compareResult.reason === "shared-identical" || compareResult.reason === "shared-older") {
+            logger.debug(`Preserving shared file: ${normalizedRelativePath} (${compareResult.reason})`);
+            this.sharedSkipped++;
+          } else {
+            logger.debug(`Skipping unchanged: ${normalizedRelativePath}`);
+            this.unchangedSkipped++;
+          }
           this.trackInstalledFile(normalizedRelativePath);
           continue;
         }
       }
-      await import_fs_extra7.copy(file, destPath, { overwrite: true });
+      await import_fs_extra8.copy(file, destPath, { overwrite: true });
       this.trackInstalledFile(normalizedRelativePath);
       copiedCount++;
     }
-    if (this.unchangedSkipped > 0) {
-      logger.success(`Updated ${copiedCount} file(s), skipped ${this.unchangedSkipped} unchanged, skipped ${skippedCount} protected`);
+    const parts = [];
+    if (copiedCount > 0)
+      parts.push(`Updated ${copiedCount} file(s)`);
+    if (this.unchangedSkipped > 0)
+      parts.push(`skipped ${this.unchangedSkipped} unchanged`);
+    if (this.sharedSkipped > 0)
+      parts.push(`preserved ${this.sharedSkipped} shared`);
+    if (skippedCount > 0)
+      parts.push(`skipped ${skippedCount} protected`);
+    if (parts.length > 0) {
+      logger.success(parts.join(", "));
     } else {
       logger.success(`Copied ${copiedCount} file(s), skipped ${skippedCount} protected file(s)`);
     }
@@ -34201,6 +36432,9 @@ class CopyExecutor {
   getAllInstalledFiles() {
     return Array.from(this.installedFiles).sort();
   }
+  getFileConflicts() {
+    return this.fileConflicts;
+  }
   trackInstalledFile(relativePath) {
     this.installedFiles.add(relativePath);
     let dir = dirname8(relativePath);
@@ -34235,6 +36469,9 @@ class FileMerger {
   setManifest(manifest) {
     this.copyExecutor.setManifest(manifest);
   }
+  setMultiKitContext(claudeDir, installingKit) {
+    this.copyExecutor.setMultiKitContext(claudeDir, installingKit);
+  }
   async merge(sourceDir, destDir, skipConfirmation = false) {
     const conflicts = await this.copyExecutor.detectConflicts(sourceDir, destDir);
     if (conflicts.length > 0 && !skipConfirmation) {
@@ -34261,119 +36498,14 @@ class FileMerger {
   getAllInstalledFiles() {
     return this.copyExecutor.getAllInstalledFiles();
   }
+  getFileConflicts() {
+    return this.copyExecutor.getFileConflicts();
+  }
 }
 
 // src/domains/migration/legacy-migration.ts
 import { readdir as readdir9, stat as stat7 } from "node:fs/promises";
 import { join as join43, relative as relative7 } from "node:path";
-
-// src/services/file-operations/manifest/manifest-reader.ts
-import { join as join39 } from "node:path";
-init_logger();
-init_types2();
-var import_fs_extra8 = __toESM(require_lib(), 1);
-async function readManifest(claudeDir) {
-  const metadataPath = join39(claudeDir, "metadata.json");
-  if (!await import_fs_extra8.pathExists(metadataPath)) {
-    return null;
-  }
-  try {
-    const content = await import_fs_extra8.readFile(metadataPath, "utf-8");
-    const parsed = JSON.parse(content);
-    return MetadataSchema.parse(parsed);
-  } catch (error) {
-    logger.debug(`Failed to read manifest: ${error}`);
-    return null;
-  }
-}
-async function readKitManifest(claudeDir, kit) {
-  const metadata = await readManifest(claudeDir);
-  if (!metadata)
-    return null;
-  return getKitMetadata(metadata, kit);
-}
-async function getUninstallManifest(claudeDir, kit) {
-  const detection = await detectMetadataFormat(claudeDir);
-  if (detection.format === "multi-kit" && detection.metadata?.kits) {
-    const installedKits = Object.keys(detection.metadata.kits);
-    if (kit) {
-      const kitMeta = detection.metadata.kits[kit];
-      if (!kitMeta?.files) {
-        return {
-          filesToRemove: [],
-          filesToPreserve: USER_CONFIG_PATTERNS,
-          hasManifest: true,
-          isMultiKit: true,
-          remainingKits: installedKits.filter((k2) => k2 !== kit)
-        };
-      }
-      const kitFiles = kitMeta.files.map((f3) => f3.path);
-      const sharedFiles = new Set;
-      for (const otherKit of installedKits) {
-        if (otherKit !== kit) {
-          const otherMeta = detection.metadata.kits[otherKit];
-          if (otherMeta?.files) {
-            for (const f3 of otherMeta.files) {
-              sharedFiles.add(f3.path);
-            }
-          }
-        }
-      }
-      const filesToRemove = kitFiles.filter((f3) => !sharedFiles.has(f3));
-      const filesToPreserve = [
-        ...USER_CONFIG_PATTERNS,
-        ...kitFiles.filter((f3) => sharedFiles.has(f3))
-      ];
-      return {
-        filesToRemove,
-        filesToPreserve,
-        hasManifest: true,
-        isMultiKit: true,
-        remainingKits: installedKits.filter((k2) => k2 !== kit)
-      };
-    }
-    const allFiles = getAllTrackedFiles(detection.metadata);
-    return {
-      filesToRemove: allFiles.map((f3) => f3.path),
-      filesToPreserve: USER_CONFIG_PATTERNS,
-      hasManifest: true,
-      isMultiKit: true,
-      remainingKits: []
-    };
-  }
-  if (detection.format === "legacy" && detection.metadata) {
-    const legacyFiles2 = detection.metadata.files?.map((f3) => f3.path) || [];
-    const installedFiles = detection.metadata.installedFiles || [];
-    const hasFiles = legacyFiles2.length > 0 || installedFiles.length > 0;
-    if (!hasFiles) {
-      const legacyDirs2 = ["commands", "agents", "skills", "workflows", "hooks", "scripts"];
-      const legacyFileList = ["metadata.json"];
-      return {
-        filesToRemove: [...legacyDirs2, ...legacyFileList],
-        filesToPreserve: USER_CONFIG_PATTERNS,
-        hasManifest: false,
-        isMultiKit: false,
-        remainingKits: []
-      };
-    }
-    return {
-      filesToRemove: legacyFiles2.length > 0 ? legacyFiles2 : installedFiles,
-      filesToPreserve: detection.metadata.userConfigFiles || USER_CONFIG_PATTERNS,
-      hasManifest: true,
-      isMultiKit: false,
-      remainingKits: []
-    };
-  }
-  const legacyDirs = ["commands", "agents", "skills", "workflows", "hooks", "scripts"];
-  const legacyFiles = ["metadata.json"];
-  return {
-    filesToRemove: [...legacyDirs, ...legacyFiles],
-    filesToPreserve: USER_CONFIG_PATTERNS,
-    hasManifest: false,
-    isMultiKit: false,
-    remainingKits: []
-  };
-}
 // src/services/file-operations/manifest/manifest-tracker.ts
 import { join as join42 } from "node:path";
 
@@ -34385,7 +36517,8 @@ import { join as join40 } from "node:path";
 var ReleaseManifestFileSchema = exports_external.object({
   path: exports_external.string(),
   checksum: exports_external.string().regex(/^[a-f0-9]{64}$/),
-  size: exports_external.number()
+  size: exports_external.number(),
+  lastModified: exports_external.string().datetime({ offset: true }).optional()
 });
 var ReleaseManifestSchema = exports_external.object({
   version: exports_external.string(),
@@ -34593,15 +36726,17 @@ async function writeManifest(claudeDir, kitName, version, scope, kitType, tracke
       installedAt,
       files: trackedFiles.length > 0 ? trackedFiles : undefined
     };
+    const existingKits = existingMetadata.kits || {};
+    const otherKitsExist = Object.keys(existingKits).some((k2) => k2 !== kit);
     const metadata = {
       kits: {
-        ...existingMetadata.kits || {},
+        ...existingKits,
         [kit]: kitMetadata
       },
       scope,
-      name: kitName,
-      version,
-      installedAt,
+      name: otherKitsExist ? existingMetadata.name ?? kitName : kitName,
+      version: otherKitsExist ? existingMetadata.version ?? version : version,
+      installedAt: otherKitsExist ? existingMetadata.installedAt ?? installedAt : installedAt,
       userConfigFiles: [...USER_CONFIG_PATTERNS, ...userConfigFiles]
     };
     const validated = MetadataSchema.parse(metadata);
@@ -34672,14 +36807,16 @@ class ManifestTracker {
   getUserConfigFiles() {
     return Array.from(this.userConfigFiles).sort();
   }
-  async addTrackedFile(filePath, relativePath, ownership, installedVersion) {
+  async addTrackedFile(filePath, relativePath, ownership, installedVersion, sourceTimestamp) {
     const checksum = await OwnershipChecker.calculateChecksum(filePath);
     const normalized = relativePath.replace(/\\/g, "/");
     this.trackedFiles.set(normalized, {
       path: normalized,
       checksum,
       ownership,
-      installedVersion
+      installedVersion,
+      sourceTimestamp,
+      installedAt: new Date().toISOString()
     });
     this.installedFiles.add(normalized);
   }
@@ -34695,7 +36832,9 @@ class ManifestTracker {
           path: normalized,
           checksum,
           ownership: file.ownership,
-          installedVersion: file.installedVersion
+          installedVersion: file.installedVersion,
+          sourceTimestamp: file.sourceTimestamp,
+          installedAt: new Date().toISOString()
         });
         this.installedFiles.add(normalized);
         return true;
@@ -34748,7 +36887,8 @@ function buildFileTrackingList(options) {
       filePath,
       relativePath,
       ownership,
-      installedVersion
+      installedVersion,
+      sourceTimestamp: manifestEntry?.lastModified
     });
   }
   return filesToTrack;
@@ -34974,6 +37114,101 @@ User-created files (sample):`);
   }
 }
 
+// src/domains/ui/conflict-summary.ts
+init_logger();
+var import_picocolors17 = __toESM(require_picocolors(), 1);
+function displayConflictSummary(summary) {
+  const totalUpdated = summary.files.updated.length + summary.hooks.updated.length + summary.mcp.updated.length;
+  const totalKept = summary.files.kept.length + summary.hooks.kept.length + summary.mcp.kept.length;
+  if (totalUpdated === 0 && totalKept === 0) {
+    logger.verbose("No conflicts detected during installation");
+    return;
+  }
+  console.log();
+  console.log(import_picocolors17.default.bold("Dual-Kit Conflict Resolution"));
+  console.log(import_picocolors17.default.dim("─".repeat(40)));
+  if (summary.files.updated.length > 0 || summary.files.kept.length > 0) {
+    const updated = summary.files.updated.length;
+    const kept = summary.files.kept.length;
+    const winners = formatWinners(summary.files.updated);
+    console.log(`  Files:   ${import_picocolors17.default.green(`${updated} updated`)}${winners}, ${import_picocolors17.default.dim(`${kept} kept`)}`);
+  }
+  if (summary.hooks.updated.length > 0 || summary.hooks.kept.length > 0) {
+    const updated = summary.hooks.updated.length;
+    const kept = summary.hooks.kept.length;
+    const winners = formatHookWinners(summary.hooks.updated);
+    console.log(`  Hooks:   ${import_picocolors17.default.green(`${updated} updated`)}${winners}, ${import_picocolors17.default.dim(`${kept} kept`)}`);
+  }
+  if (summary.mcp.updated.length > 0 || summary.mcp.kept.length > 0) {
+    const updated = summary.mcp.updated.length;
+    const kept = summary.mcp.kept.length;
+    const winners = formatMcpWinners(summary.mcp.updated);
+    console.log(`  MCP:     ${import_picocolors17.default.green(`${updated} updated`)}${winners}, ${import_picocolors17.default.dim(`${kept} kept`)}`);
+  }
+  if (logger.isVerbose() && totalUpdated > 0) {
+    console.log();
+    console.log(import_picocolors17.default.dim("Details:"));
+    for (const file of summary.files.updated) {
+      console.log(`  ${import_picocolors17.default.dim("-")} ${file.relativePath}: ${import_picocolors17.default.green(file.winner)} won`);
+    }
+    for (const hook of summary.hooks.updated) {
+      const shortCmd = hook.command.length > 40 ? `${hook.command.slice(0, 40)}...` : hook.command;
+      console.log(`  ${import_picocolors17.default.dim("-")} hook: ${shortCmd} → ${import_picocolors17.default.green(hook.winner)}`);
+    }
+    for (const mcp of summary.mcp.updated) {
+      console.log(`  ${import_picocolors17.default.dim("-")} mcp: ${mcp.serverName} → ${import_picocolors17.default.green(mcp.winner)}`);
+    }
+  }
+  console.log();
+}
+function formatWinners(items) {
+  const counts = new Map;
+  for (const item of items) {
+    const kit = item.winner === "incoming" ? item.incomingKit : item.existingKit;
+    counts.set(kit, (counts.get(kit) ?? 0) + 1);
+  }
+  if (counts.size === 0)
+    return "";
+  const parts = Array.from(counts.entries()).map(([kit, count]) => `${kit}: ${count}`);
+  return import_picocolors17.default.dim(` (${parts.join(", ")})`);
+}
+function formatHookWinners(items) {
+  const counts = new Map;
+  for (const item of items) {
+    counts.set(item.winner, (counts.get(item.winner) ?? 0) + 1);
+  }
+  if (counts.size === 0)
+    return "";
+  const parts = Array.from(counts.entries()).map(([kit, count]) => `${kit}: ${count}`);
+  return import_picocolors17.default.dim(` (${parts.join(", ")})`);
+}
+function formatMcpWinners(items) {
+  const counts = new Map;
+  for (const item of items) {
+    counts.set(item.winner, (counts.get(item.winner) ?? 0) + 1);
+  }
+  if (counts.size === 0)
+    return "";
+  const parts = Array.from(counts.entries()).map(([kit, count]) => `${kit}: ${count}`);
+  return import_picocolors17.default.dim(` (${parts.join(", ")})`);
+}
+function buildConflictSummary(fileConflicts, hookConflicts, mcpConflicts) {
+  return {
+    files: {
+      updated: fileConflicts.filter((c2) => c2.winner === "incoming"),
+      kept: fileConflicts.filter((c2) => c2.winner === "existing")
+    },
+    hooks: {
+      updated: hookConflicts.filter((c2) => c2.winner !== "existing"),
+      kept: hookConflicts.filter((c2) => c2.winner === "existing")
+    },
+    mcp: {
+      updated: mcpConflicts.filter((c2) => c2.winner !== "existing"),
+      kept: mcpConflicts.filter((c2) => c2.winner === "existing")
+    }
+  };
+}
+
 // src/services/file-operations/file-scanner.ts
 import { join as join44, relative as relative8, resolve as resolve6 } from "node:path";
 init_logger();
@@ -35440,6 +37675,9 @@ async function handleMerge(ctx) {
   merger.setForceOverwriteSettings(ctx.options.forceOverwriteSettings);
   merger.setProjectDir(ctx.resolvedDir);
   merger.setKitName(ctx.kit.name);
+  if (ctx.kitType) {
+    merger.setMultiKitContext(ctx.claudeDir, ctx.kitType);
+  }
   const releaseManifest = await ReleaseManifestLoader.load(ctx.extractDir);
   if (releaseManifest) {
     merger.setManifest(releaseManifest);
@@ -35466,6 +37704,11 @@ async function handleMerge(ctx) {
   }
   const sourceDir = ctx.options.global ? join48(ctx.extractDir, ".claude") : ctx.extractDir;
   await merger.merge(sourceDir, ctx.resolvedDir, ctx.isNonInteractive);
+  const fileConflicts = merger.getFileConflicts();
+  if (fileConflicts.length > 0 && !ctx.isNonInteractive) {
+    const summary = buildConflictSummary(fileConflicts, [], []);
+    displayConflictSummary(summary);
+  }
   const installedFiles = merger.getAllInstalledFiles();
   const filesToTrack = buildFileTrackingList({
     installedFiles,
@@ -37277,6 +39520,31 @@ Optional: DISCORD_WEBHOOK_URL, TELEGRAM_BOT_TOKEN`, "Configuration skipped");
 import { mkdir as mkdir19 } from "node:fs/promises";
 import { join as join62, resolve as resolve7 } from "node:path";
 
+// src/domains/github/kit-access-checker.ts
+init_logger();
+init_types2();
+async function detectAccessibleKits() {
+  const spinner = createSpinner("Checking kit access...").start();
+  const github = new GitHubClient;
+  const results = await Promise.all(Object.entries(AVAILABLE_KITS).map(async ([type, config]) => {
+    try {
+      await github.checkAccess(config);
+      logger.debug(`Access confirmed: ${type}`);
+      return type;
+    } catch {
+      logger.debug(`No access to ${type}`);
+      return null;
+    }
+  }));
+  const accessible = results.filter((kit) => kit !== null);
+  if (accessible.length === 0) {
+    spinner.fail("No kit access found");
+  } else {
+    spinner.succeed(`Access verified: ${accessible.join(", ")}`);
+  }
+  return accessible;
+}
+
 // src/domains/installation/fresh-installer.ts
 init_logger();
 import { join as join61 } from "node:path";
@@ -37339,13 +39607,33 @@ async function handleSelection(ctx) {
     };
   }
   const config = await ConfigManager.get();
+  let accessibleKits;
+  if (!ctx.options.useGit) {
+    accessibleKits = await detectAccessibleKits();
+    if (accessibleKits.length === 0) {
+      logger.error("No ClaudeKit access found.");
+      logger.info("Purchase at https://claudekit.cc");
+      return { ...ctx, cancelled: true };
+    }
+  }
   let kitType = ctx.options.kit || config.defaults?.kit;
+  if (kitType && accessibleKits && !accessibleKits.includes(kitType)) {
+    logger.error(`No access to ${AVAILABLE_KITS[kitType].name}`);
+    logger.info("Purchase at https://claudekit.cc");
+    return { ...ctx, cancelled: true };
+  }
   if (!kitType) {
     if (ctx.isNonInteractive) {
-      kitType = "engineer";
-      logger.info("Using default kit: engineer");
+      if (!accessibleKits || accessibleKits.length === 0) {
+        throw new Error("Kit must be specified via --kit flag in non-interactive mode (no accessible kits detected)");
+      }
+      kitType = accessibleKits[0];
+      logger.info(`Auto-selected: ${AVAILABLE_KITS[kitType].name}`);
+    } else if (accessibleKits?.length === 1) {
+      kitType = accessibleKits[0];
+      logger.info(`Using ${AVAILABLE_KITS[kitType].name} (only accessible kit)`);
     } else {
-      kitType = await ctx.prompts.selectKit();
+      kitType = await ctx.prompts.selectKit(undefined, accessibleKits);
     }
   }
   const kit = AVAILABLE_KITS[kitType];
@@ -37379,6 +39667,38 @@ async function handleSelection(ctx) {
       return { ...ctx, cancelled: true };
     }
   }
+  if (!ctx.options.fresh) {
+    const prefix = PathResolver.getPathPrefix(ctx.options.global);
+    const claudeDir = prefix ? join62(resolvedDir, prefix) : resolvedDir;
+    try {
+      const existingMetadata = await readManifest(claudeDir);
+      if (existingMetadata?.kits) {
+        const existingKitTypes = Object.keys(existingMetadata.kits);
+        const otherKits = existingKitTypes.filter((k2) => k2 !== kitType);
+        if (otherKits.length > 0) {
+          const existingKitsDisplay = otherKits.map((k2) => `${k2}@${existingMetadata.kits?.[k2]?.version || "unknown"}`).join(", ");
+          if (!ctx.options.yes && !ctx.isNonInteractive) {
+            try {
+              const confirmAdd = await ctx.prompts.confirm(`${existingKitsDisplay} already installed. Add ${kit.name} alongside?`);
+              if (!confirmAdd) {
+                logger.warning("Multi-kit installation cancelled by user");
+                return { ...ctx, cancelled: true };
+              }
+              logger.info(`Adding ${kit.name} alongside existing kit(s)`);
+            } catch {
+              logger.warning("Prompt cancelled or interrupted");
+              return { ...ctx, cancelled: true };
+            }
+          } else {
+            const reason = ctx.options.yes ? "(--yes flag)" : "(non-interactive mode)";
+            logger.info(`Adding ${kit.name} alongside ${existingKitsDisplay} ${reason}`);
+          }
+        }
+      }
+    } catch (error) {
+      logger.debug(`Metadata read skipped: ${error instanceof Error ? error.message : "unknown error"}`);
+    }
+  }
   if (ctx.options.fresh) {
     const prefix = PathResolver.getPathPrefix(ctx.options.global);
     const claudeDir = prefix ? join62(resolvedDir, prefix) : resolvedDir;
@@ -37388,20 +39708,6 @@ async function handleSelection(ctx) {
     }
   }
   const github = new GitHubClient;
-  if (!ctx.options.useGit) {
-    const spinner = createSpinner("Checking repository access...").start();
-    logger.verbose("GitHub API check", { repo: kit.repo, owner: kit.owner });
-    try {
-      await github.checkAccess(kit);
-      spinner.succeed("Repository access verified");
-    } catch (error) {
-      spinner.fail("Access denied to repository");
-      logger.error(error.message || `Cannot access ${kit.name}`);
-      return { ...ctx, cancelled: true };
-    }
-  } else {
-    logger.verbose("Skipping API access check (--use-git mode)");
-  }
   let selectedVersion = ctx.options.release;
   if (!selectedVersion && ctx.isNonInteractive && !ctx.options.yes) {
     throw new Error("Non-interactive mode requires either: --release <tag> OR --yes (uses latest)");
@@ -37483,7 +39789,7 @@ import { copyFile as copyFile6, mkdir as mkdir20, open, rename as rename3, stat
 import { dirname as dirname9, join as join63, resolve as resolve8 } from "node:path";
 init_logger();
 var import_fs_extra30 = __toESM(require_lib(), 1);
-var import_picocolors18 = __toESM(require_picocolors(), 1);
+var import_picocolors19 = __toESM(require_picocolors(), 1);
 async function handleSync(ctx) {
   if (!ctx.options.sync) {
     return ctx;
@@ -37651,7 +39957,7 @@ async function executeSyncMerge(ctx) {
     }
     const backupDir = PathResolver.getBackupDir();
     await createBackup(ctx.claudeDir, trackedFiles, backupDir);
-    logger.success(`Backup created at ${import_picocolors18.default.dim(backupDir)}`);
+    logger.success(`Backup created at ${import_picocolors19.default.dim(backupDir)}`);
     if (plan.autoUpdate.length > 0) {
       logger.info(`Auto-updating ${plan.autoUpdate.length} file(s)...`);
       let updateSuccess = 0;
@@ -37761,22 +40067,22 @@ async function executeSyncMerge(ctx) {
         totalRejected += result.rejected;
       }
       console.log("");
-      console.log(import_picocolors18.default.bold("Sync Summary:"));
-      console.log(import_picocolors18.default.dim("─".repeat(40)));
+      console.log(import_picocolors19.default.bold("Sync Summary:"));
+      console.log(import_picocolors19.default.dim("─".repeat(40)));
       if (plan.autoUpdate.length > 0) {
-        console.log(import_picocolors18.default.green(`  ✓ ${plan.autoUpdate.length} file(s) auto-updated`));
+        console.log(import_picocolors19.default.green(`  ✓ ${plan.autoUpdate.length} file(s) auto-updated`));
       }
       if (totalApplied > 0) {
-        console.log(import_picocolors18.default.green(`  ✓ ${totalApplied} hunk(s) applied`));
+        console.log(import_picocolors19.default.green(`  ✓ ${totalApplied} hunk(s) applied`));
       }
       if (totalRejected > 0) {
-        console.log(import_picocolors18.default.yellow(`  ○ ${totalRejected} hunk(s) rejected`));
+        console.log(import_picocolors19.default.yellow(`  ○ ${totalRejected} hunk(s) rejected`));
       }
       if (skippedFiles > 0) {
-        console.log(import_picocolors18.default.yellow(`  ○ ${skippedFiles} file(s) skipped`));
+        console.log(import_picocolors19.default.yellow(`  ○ ${skippedFiles} file(s) skipped`));
       }
       if (plan.skipped.length > 0) {
-        console.log(import_picocolors18.default.dim(`  ─ ${plan.skipped.length} user-owned file(s) unchanged`));
+        console.log(import_picocolors19.default.dim(`  ─ ${plan.skipped.length} user-owned file(s) unchanged`));
       }
     } else if (plan.needsReview.length > 0 && ctx.isNonInteractive) {
       logger.error(`Cannot complete sync: ${plan.needsReview.length} file(s) require interactive review`);
@@ -37799,30 +40105,30 @@ Options:
 }
 function displaySyncPlan(plan) {
   console.log("");
-  console.log(import_picocolors18.default.bold("Sync Plan:"));
-  console.log(import_picocolors18.default.dim("─".repeat(40)));
+  console.log(import_picocolors19.default.bold("Sync Plan:"));
+  console.log(import_picocolors19.default.dim("─".repeat(40)));
   if (plan.autoUpdate.length > 0) {
-    console.log(import_picocolors18.default.green(`  ${plan.autoUpdate.length} file(s) will be auto-updated`));
+    console.log(import_picocolors19.default.green(`  ${plan.autoUpdate.length} file(s) will be auto-updated`));
     for (const file of plan.autoUpdate.slice(0, 5)) {
-      console.log(import_picocolors18.default.dim(`    • ${file.path}`));
+      console.log(import_picocolors19.default.dim(`    • ${file.path}`));
     }
     if (plan.autoUpdate.length > 5) {
-      console.log(import_picocolors18.default.dim(`    ... and ${plan.autoUpdate.length - 5} more`));
+      console.log(import_picocolors19.default.dim(`    ... and ${plan.autoUpdate.length - 5} more`));
     }
   }
   if (plan.needsReview.length > 0) {
-    console.log(import_picocolors18.default.yellow(`  ${plan.needsReview.length} file(s) need interactive review`));
+    console.log(import_picocolors19.default.yellow(`  ${plan.needsReview.length} file(s) need interactive review`));
     for (const file of plan.needsReview.slice(0, 5)) {
-      console.log(import_picocolors18.default.dim(`    • ${file.path}`));
+      console.log(import_picocolors19.default.dim(`    • ${file.path}`));
     }
     if (plan.needsReview.length > 5) {
-      console.log(import_picocolors18.default.dim(`    ... and ${plan.needsReview.length - 5} more`));
+      console.log(import_picocolors19.default.dim(`    ... and ${plan.needsReview.length - 5} more`));
     }
   }
   if (plan.skipped.length > 0) {
-    console.log(import_picocolors18.default.dim(`  ${plan.skipped.length} user-owned file(s) will be skipped`));
+    console.log(import_picocolors19.default.dim(`  ${plan.skipped.length} user-owned file(s) will be skipped`));
   }
-  console.log(import_picocolors18.default.dim("─".repeat(40)));
+  console.log(import_picocolors19.default.dim("─".repeat(40)));
 }
 async function createBackup(claudeDir, files, backupDir) {
   await mkdir20(backupDir, { recursive: true });
@@ -38146,6 +40452,24 @@ function transformContent(content) {
       return homePrefix;
     });
   }
+  transformed = transformed.replace(/\$CLAUDE_PROJECT_DIR\/\.claude\//g, () => {
+    changes++;
+    return claudePath;
+  });
+  transformed = transformed.replace(/"\$CLAUDE_PROJECT_DIR"\/\.claude\//g, () => {
+    changes++;
+    return `"${homePrefix}"/.claude/`;
+  });
+  transformed = transformed.replace(/\$\{CLAUDE_PROJECT_DIR\}\/\.claude\//g, () => {
+    changes++;
+    return claudePath;
+  });
+  if (IS_WINDOWS3) {
+    transformed = transformed.replace(/%CLAUDE_PROJECT_DIR%\/\.claude\//g, () => {
+      changes++;
+      return claudePath;
+    });
+  }
   transformed = transformed.replace(/\.\/\.claude\//g, () => {
     changes++;
     return claudePath;
@@ -38381,7 +40705,7 @@ Protected files (.env, etc.) were not modified.`;
 // src/commands/new/new-command.ts
 init_logger();
 init_types2();
-var import_picocolors19 = __toESM(require_picocolors(), 1);
+var import_picocolors20 = __toESM(require_picocolors(), 1);
 
 // src/commands/new/phases/directory-setup.ts
 import { resolve as resolve9 } from "node:path";
@@ -38391,12 +40715,34 @@ var import_fs_extra32 = __toESM(require_lib(), 1);
 async function directorySetup(validOptions, prompts) {
   const isNonInteractive2 = !process.stdin.isTTY || process.env.CI === "true" || process.env.NON_INTERACTIVE === "true";
   const config = await ConfigManager.get();
+  let accessibleKits;
+  if (!validOptions.useGit) {
+    accessibleKits = await detectAccessibleKits();
+    if (accessibleKits.length === 0) {
+      logger.error("No ClaudeKit access found.");
+      logger.info("Purchase at https://claudekit.cc");
+      return null;
+    }
+  }
   let kit = validOptions.kit || config.defaults?.kit;
+  if (kit && accessibleKits && !accessibleKits.includes(kit)) {
+    logger.error(`No access to ${AVAILABLE_KITS[kit].name}`);
+    logger.info("Purchase at https://claudekit.cc");
+    return null;
+  }
   if (!kit) {
     if (isNonInteractive2) {
-      throw new Error("Kit must be specified via --kit flag in non-interactive mode");
+      kit = accessibleKits?.[0];
+      if (!kit) {
+        throw new Error("Kit must be specified via --kit flag in non-interactive mode");
+      }
+      logger.info(`Auto-selected: ${AVAILABLE_KITS[kit].name}`);
+    } else if (accessibleKits?.length === 1) {
+      kit = accessibleKits[0];
+      logger.info(`Using ${AVAILABLE_KITS[kit].name} (only accessible kit)`);
+    } else {
+      kit = await prompts.selectKit(undefined, accessibleKits);
     }
-    kit = await prompts.selectKit();
   }
   const kitConfig = AVAILABLE_KITS[kit];
   logger.info(`Selected kit: ${kitConfig.name}`);
@@ -38520,20 +40866,6 @@ async function selectVersion2(kit, options, isNonInteractive2, prompts, github)
 async function projectCreation(kit, resolvedDir, validOptions, isNonInteractive2, prompts) {
   const kitConfig = AVAILABLE_KITS[kit];
   const github = new GitHubClient;
-  if (!validOptions.useGit) {
-    const spinner = createSpinner("Checking repository access...").start();
-    logger.verbose("GitHub API check", { repo: kitConfig.repo, owner: kitConfig.owner });
-    try {
-      await github.checkAccess(kitConfig);
-      spinner.succeed("Repository access verified");
-    } catch (error) {
-      spinner.fail("Access denied to repository");
-      logger.error(error.message || `Cannot access ${kitConfig.name}`);
-      return null;
-    }
-  } else {
-    logger.verbose("Skipping API access check (--use-git mode)");
-  }
   const versionResult = await selectVersion2(kitConfig, validOptions, isNonInteractive2, prompts, github);
   if (!versionResult) {
     return null;
@@ -38569,6 +40901,8 @@ async function projectCreation(kit, resolvedDir, validOptions, isNonInteractive2
   output.section("Installing");
   logger.verbose("Installation target", { directory: resolvedDir });
   const merger = new FileMerger;
+  const claudeDir = join68(resolvedDir, ".claude");
+  merger.setMultiKitContext(claudeDir, kit);
   if (validOptions.exclude && validOptions.exclude.length > 0) {
     merger.addIgnorePatterns(validOptions.exclude);
   }
@@ -38576,7 +40910,6 @@ async function projectCreation(kit, resolvedDir, validOptions, isNonInteractive2
     await CommandsPrefix.cleanupCommandsDirectory(resolvedDir, false);
   }
   await merger.merge(extractDir, resolvedDir, true);
-  const claudeDir = join68(resolvedDir, ".claude");
   const releaseManifest = await ReleaseManifestLoader.load(extractDir);
   const installedFiles = merger.getAllInstalledFiles();
   const filesToTrack = buildFileTrackingList({
@@ -38683,7 +41016,7 @@ async function newCommand(options) {
     if (ctx.cancelled)
       return;
     prompts.outro(`✨ Project created successfully at ${ctx.resolvedDir}`);
-    log.info(`${import_picocolors19.default.dim("Tip:")} To update later: ${import_picocolors19.default.cyan("ck update")} (CLI) + ${import_picocolors19.default.cyan("ck init")} (kit content)`);
+    log.info(`${import_picocolors20.default.dim("Tip:")} To update later: ${import_picocolors20.default.cyan("ck update")} (CLI) + ${import_picocolors20.default.cyan("ck init")} (kit content)`);
   } catch (error) {
     logger.error(error instanceof Error ? error.message : "Unknown error occurred");
     process.exit(1);
@@ -38692,7 +41025,7 @@ async function newCommand(options) {
 // src/commands/uninstall/uninstall-command.ts
 init_logger();
 init_types2();
-var import_picocolors21 = __toESM(require_picocolors(), 1);
+var import_picocolors22 = __toESM(require_picocolors(), 1);
 
 // src/commands/uninstall/installation-detector.ts
 var import_fs_extra33 = __toESM(require_lib(), 1);
@@ -38726,7 +41059,7 @@ var import_fs_extra34 = __toESM(require_lib(), 1);
 import { readdirSync, rmSync } from "node:fs";
 import { dirname as dirname10, join as join69 } from "node:path";
 init_logger();
-var import_picocolors20 = __toESM(require_picocolors(), 1);
+var import_picocolors21 = __toESM(require_picocolors(), 1);
 function classifyFileByOwnership(ownership, forceOverwrite, deleteReason) {
   if (ownership === "ck") {
     return { action: "delete", reason: deleteReason };
@@ -38817,27 +41150,27 @@ async function analyzeInstallation(installation, forceOverwrite, kit) {
 }
 function displayDryRunPreview(analysis, installationType) {
   console.log("");
-  log.info(import_picocolors20.default.bold(`DRY RUN - Preview for ${installationType} installation:`));
+  log.info(import_picocolors21.default.bold(`DRY RUN - Preview for ${installationType} installation:`));
   console.log("");
   if (analysis.toDelete.length > 0) {
-    console.log(import_picocolors20.default.red(import_picocolors20.default.bold(`Files to DELETE (${analysis.toDelete.length}):`)));
+    console.log(import_picocolors21.default.red(import_picocolors21.default.bold(`Files to DELETE (${analysis.toDelete.length}):`)));
     const showDelete = analysis.toDelete.slice(0, 10);
     for (const item of showDelete) {
-      console.log(`  ${import_picocolors20.default.red("✖")} ${item.path}`);
+      console.log(`  ${import_picocolors21.default.red("✖")} ${item.path}`);
     }
     if (analysis.toDelete.length > 10) {
-      console.log(import_picocolors20.default.gray(`  ... and ${analysis.toDelete.length - 10} more`));
+      console.log(import_picocolors21.default.gray(`  ... and ${analysis.toDelete.length - 10} more`));
     }
     console.log("");
   }
   if (analysis.toPreserve.length > 0) {
-    console.log(import_picocolors20.default.green(import_picocolors20.default.bold(`Files to PRESERVE (${analysis.toPreserve.length}):`)));
+    console.log(import_picocolors21.default.green(import_picocolors21.default.bold(`Files to PRESERVE (${analysis.toPreserve.length}):`)));
     const showPreserve = analysis.toPreserve.slice(0, 10);
     for (const item of showPreserve) {
-      console.log(`  ${import_picocolors20.default.green("✓")} ${item.path} ${import_picocolors20.default.gray(`(${item.reason})`)}`);
+      console.log(`  ${import_picocolors21.default.green("✓")} ${item.path} ${import_picocolors21.default.gray(`(${item.reason})`)}`);
     }
     if (analysis.toPreserve.length > 10) {
-      console.log(import_picocolors20.default.gray(`  ... and ${analysis.toPreserve.length - 10} more`));
+      console.log(import_picocolors21.default.gray(`  ... and ${analysis.toPreserve.length - 10} more`));
     }
     console.log("");
   }
@@ -38985,10 +41318,10 @@ async function uninstallCommand(options) {
     }
     displayInstallations(installations, scope);
     if (validOptions.kit) {
-      log.info(import_picocolors21.default.cyan(`Kit-scoped uninstall: ${validOptions.kit} kit only`));
+      log.info(import_picocolors22.default.cyan(`Kit-scoped uninstall: ${validOptions.kit} kit only`));
     }
     if (validOptions.dryRun) {
-      log.info(import_picocolors21.default.yellow("DRY RUN MODE - No files will be deleted"));
+      log.info(import_picocolors22.default.yellow("DRY RUN MODE - No files will be deleted"));
       await removeInstallations(installations, {
         dryRun: true,
         forceOverwrite: validOptions.forceOverwrite,
@@ -38998,8 +41331,8 @@ async function uninstallCommand(options) {
       return;
     }
     if (validOptions.forceOverwrite) {
-      log.warn(`${import_picocolors21.default.yellow(import_picocolors21.default.bold("FORCE MODE ENABLED"))}
-${import_picocolors21.default.yellow("User modifications will be permanently deleted!")}`);
+      log.warn(`${import_picocolors22.default.yellow(import_picocolors22.default.bold("FORCE MODE ENABLED"))}
+${import_picocolors22.default.yellow("User modifications will be permanently deleted!")}`);
     }
     if (!validOptions.yes) {
       const kitLabel = validOptions.kit ? ` (${validOptions.kit} kit only)` : "";
@@ -39338,7 +41671,7 @@ class CliVersionChecker {
   }
 }
 // src/domains/versioning/checking/notification-display.ts
-var import_picocolors22 = __toESM(require_picocolors(), 1);
+var import_picocolors23 = __toESM(require_picocolors(), 1);
 function createNotificationBox2(borderColor, boxWidth) {
   const contentWidth = boxWidth - 2;
   const topBorder = borderColor(`╭${"─".repeat(contentWidth)}╮`);
@@ -39363,13 +41696,13 @@ function displayKitNotification(result, options = {}) {
   const displayCurrent = normalizeVersion(currentVersion);
   const displayLatest = normalizeVersion(latestVersion);
   const boxWidth = 52;
-  const { topBorder, bottomBorder, emptyLine, padLine } = createNotificationBox2(import_picocolors22.default.cyan, boxWidth);
-  const headerText = import_picocolors22.default.bold(import_picocolors22.default.yellow("⬆ Kit Update Available"));
+  const { topBorder, bottomBorder, emptyLine, padLine } = createNotificationBox2(import_picocolors23.default.cyan, boxWidth);
+  const headerText = import_picocolors23.default.bold(import_picocolors23.default.yellow("⬆ Kit Update Available"));
   const headerLen = "⬆ Kit Update Available".length;
-  const versionText = `${import_picocolors22.default.dim(displayCurrent)} ${import_picocolors22.default.white("→")} ${import_picocolors22.default.green(import_picocolors22.default.bold(displayLatest))}`;
+  const versionText = `${import_picocolors23.default.dim(displayCurrent)} ${import_picocolors23.default.white("→")} ${import_picocolors23.default.green(import_picocolors23.default.bold(displayLatest))}`;
   const versionLen = displayCurrent.length + 3 + displayLatest.length;
   const updateCmd = isGlobal ? "ck init -g" : "ck init";
-  const commandText = `Run: ${import_picocolors22.default.cyan(import_picocolors22.default.bold(updateCmd))}`;
+  const commandText = `Run: ${import_picocolors23.default.cyan(import_picocolors23.default.bold(updateCmd))}`;
   const commandLen = `Run: ${updateCmd}`.length;
   console.log("");
   console.log(topBorder);
@@ -39387,12 +41720,12 @@ function displayCliNotification(result) {
     return;
   const { currentVersion, latestVersion } = result;
   const boxWidth = 52;
-  const { topBorder, bottomBorder, emptyLine, padLine } = createNotificationBox2(import_picocolors22.default.magenta, boxWidth);
-  const headerText = import_picocolors22.default.bold(import_picocolors22.default.yellow("⬆ CLI Update Available"));
+  const { topBorder, bottomBorder, emptyLine, padLine } = createNotificationBox2(import_picocolors23.default.magenta, boxWidth);
+  const headerText = import_picocolors23.default.bold(import_picocolors23.default.yellow("⬆ CLI Update Available"));
   const headerLen = "⬆ CLI Update Available".length;
-  const versionText = `${import_picocolors22.default.dim(currentVersion)} ${import_picocolors22.default.white("→")} ${import_picocolors22.default.green(import_picocolors22.default.bold(latestVersion))}`;
+  const versionText = `${import_picocolors23.default.dim(currentVersion)} ${import_picocolors23.default.white("→")} ${import_picocolors23.default.green(import_picocolors23.default.bold(latestVersion))}`;
   const versionLen = currentVersion.length + 3 + latestVersion.length;
-  const commandText = `Run: ${import_picocolors22.default.magenta(import_picocolors22.default.bold("ck update"))}`;
+  const commandText = `Run: ${import_picocolors23.default.magenta(import_picocolors23.default.bold("ck update"))}`;
   const commandLen = "Run: ck update".length;
   console.log("");
   console.log(topBorder);
@@ -39429,11 +41762,11 @@ init_logger();
 init_types2();
 init_types2();
 var import_compare_versions5 = __toESM(require_umd(), 1);
-var import_picocolors23 = __toESM(require_picocolors(), 1);
+var import_picocolors24 = __toESM(require_picocolors(), 1);
 // package.json
 var package_default = {
   name: "claudekit-cli",
-  version: "3.16.0",
+  version: "3.18.0",
   description: "CLI tool for bootstrapping and updating ClaudeKit projects",
   type: "module",
   repository: {
@@ -39500,6 +41833,7 @@ var package_default = {
     "p-limit": "^7.2.0",
     picocolors: "^1.1.1",
     "proper-lockfile": "^4.1.2",
+    semver: "^7.7.3",
     tar: "^7.4.3",
     tmp: "^0.2.3",
     zod: "^3.23.8"
@@ -39514,6 +41848,7 @@ var package_default = {
     "@types/fs-extra": "^11.0.4",
     "@types/node": "^22.10.1",
     "@types/proper-lockfile": "^4.1.4",
+    "@types/semver": "^7.7.1",
     "@types/tar": "^6.1.13",
     "@types/tmp": "^0.2.6",
     "semantic-release": "^24.2.0",
@@ -39560,28 +41895,28 @@ async function displayKitUpdateReminder() {
     const maxCmdLen = Math.max(cmdLocal.length, cmdGlobal.length);
     const pad = (cmd) => cmd.padEnd(maxCmdLen);
     const lines = [];
-    lines.push(import_picocolors23.default.yellow(KIT_UPDATE_REMINDER_HEADER));
+    lines.push(import_picocolors24.default.yellow(KIT_UPDATE_REMINDER_HEADER));
     lines.push("");
     lines.push("To update your ClaudeKit content (skills, commands, workflows):");
     if (hasLocal && localVersion) {
-      lines.push(`  ${import_picocolors23.default.cyan(pad(cmdLocal))}  Update local project (${localVersion})`);
+      lines.push(`  ${import_picocolors24.default.cyan(pad(cmdLocal))}  Update local project (${localVersion})`);
       const localCheck = versionCheckResults.get(localVersion);
       if (localCheck?.updateAvailable) {
         const indent = " ".repeat(maxCmdLen + 4);
-        lines.push(`${indent}${import_picocolors23.default.green(`→ ${localCheck.latestVersion} available!`)}`);
+        lines.push(`${indent}${import_picocolors24.default.green(`→ ${localCheck.latestVersion} available!`)}`);
       }
     } else {
-      lines.push(`  ${import_picocolors23.default.cyan(pad(cmdLocal))}  Initialize in current project`);
+      lines.push(`  ${import_picocolors24.default.cyan(pad(cmdLocal))}  Initialize in current project`);
     }
     if (hasGlobal && globalVersion) {
-      lines.push(`  ${import_picocolors23.default.cyan(pad(cmdGlobal))}  Update global ~/.claude (${globalVersion})`);
+      lines.push(`  ${import_picocolors24.default.cyan(pad(cmdGlobal))}  Update global ~/.claude (${globalVersion})`);
       const globalCheck = versionCheckResults.get(globalVersion);
       if (globalCheck?.updateAvailable) {
         const indent = " ".repeat(maxCmdLen + 4);
-        lines.push(`${indent}${import_picocolors23.default.green(`→ ${globalCheck.latestVersion} available!`)}`);
+        lines.push(`${indent}${import_picocolors24.default.green(`→ ${globalCheck.latestVersion} available!`)}`);
       }
     } else {
-      lines.push(`  ${import_picocolors23.default.cyan(pad(cmdGlobal))}  Initialize global ~/.claude`);
+      lines.push(`  ${import_picocolors24.default.cyan(pad(cmdGlobal))}  Initialize global ~/.claude`);
     }
     logger.info("");
     log.info(lines.join(`
@@ -39705,7 +42040,7 @@ Manual update: ${updateCmd}`);
 // src/commands/version.ts
 init_logger();
 init_types2();
-var import_picocolors24 = __toESM(require_picocolors(), 1);
+var import_picocolors25 = __toESM(require_picocolors(), 1);
 function formatRelativeTime(dateString) {
   if (!dateString)
     return "Unknown";
@@ -39727,30 +42062,30 @@ function formatRelativeTime(dateString) {
 }
 function displayKitReleases(kitName, releases) {
   console.log(`
-${import_picocolors24.default.bold(import_picocolors24.default.cyan(kitName))} - Available Versions:
+${import_picocolors25.default.bold(import_picocolors25.default.cyan(kitName))} - Available Versions:
 `);
   if (releases.length === 0) {
-    console.log(import_picocolors24.default.dim("  No releases found"));
+    console.log(import_picocolors25.default.dim("  No releases found"));
     return;
   }
   for (const release of releases) {
-    const version = import_picocolors24.default.green(release.tag_name);
+    const version = import_picocolors25.default.green(release.tag_name);
     const name2 = release.name || "No title";
     const publishedAt = formatRelativeTime(release.published_at);
     const assetCount = release.assets.length;
     const badges = [];
     if (release.prerelease)
-      badges.push(import_picocolors24.default.yellow("[prerelease]"));
+      badges.push(import_picocolors25.default.yellow("[prerelease]"));
     if (release.draft)
-      badges.push(import_picocolors24.default.gray("[draft]"));
+      badges.push(import_picocolors25.default.gray("[draft]"));
     const badgeStr = badges.length > 0 ? ` ${badges.join(" ")}` : "";
     const versionPart = version.padEnd(20);
     const namePart = name2.length > 40 ? `${name2.slice(0, 37)}...` : name2.padEnd(40);
-    const timePart = import_picocolors24.default.dim(publishedAt.padEnd(20));
-    const assetPart = import_picocolors24.default.dim(`(${assetCount} ${assetCount === 1 ? "asset" : "assets"})`);
+    const timePart = import_picocolors25.default.dim(publishedAt.padEnd(20));
+    const assetPart = import_picocolors25.default.dim(`(${assetCount} ${assetCount === 1 ? "asset" : "assets"})`);
     console.log(`  ${versionPart}  ${namePart}  ${timePart}  ${assetPart}${badgeStr}`);
   }
-  console.log(import_picocolors24.default.dim(`
+  console.log(import_picocolors25.default.dim(`
 Showing ${releases.length} ${releases.length === 1 ? "release" : "releases"}`));
 }
 async function versionCommand(options) {
@@ -39785,8 +42120,8 @@ async function versionCommand(options) {
     for (const result of results) {
       if (result.error) {
         console.log(`
-${import_picocolors24.default.bold(import_picocolors24.default.cyan(result.kitConfig.name))} - ${import_picocolors24.default.red("Error")}`);
-        console.log(import_picocolors24.default.dim(`  ${result.error}`));
+${import_picocolors25.default.bold(import_picocolors25.default.cyan(result.kitConfig.name))} - ${import_picocolors25.default.red("Error")}`);
+        console.log(import_picocolors25.default.dim(`  ${result.error}`));
       } else {
         displayKitReleases(result.kitConfig.name, result.releases);
       }
@@ -39860,6 +42195,30 @@ import { join as join72 } from "node:path";
 init_logger();
 init_types2();
 var packageVersion = package_default.version;
+function formatInstalledKits(metadata) {
+  if (!metadata.kits || Object.keys(metadata.kits).length === 0) {
+    if (metadata.version) {
+      const kitName = metadata.name || "ClaudeKit";
+      return `${metadata.version} (${kitName})`;
+    }
+    return null;
+  }
+  const kitVersions = Object.entries(metadata.kits).filter(([_3, meta]) => meta.version && meta.version.trim() !== "").map(([kit, meta]) => `${kit}@${meta.version}`).sort().join(", ");
+  return kitVersions.length > 0 ? kitVersions : null;
+}
+function getInstalledKitTypes(metadata) {
+  if (!metadata.kits)
+    return [];
+  return Object.keys(metadata.kits);
+}
+function getFirstKitVersion(metadata) {
+  const kitTypes = getInstalledKitTypes(metadata);
+  if (kitTypes.length === 0) {
+    return metadata.version ?? null;
+  }
+  const firstKit = kitTypes[0];
+  return metadata.kits?.[firstKit]?.version ?? null;
+}
 async function displayVersion() {
   console.log(`CLI Version: ${packageVersion}`);
   let foundAnyKit = false;
@@ -39874,10 +42233,10 @@ async function displayVersion() {
     try {
       const rawMetadata = JSON.parse(readFileSync5(localMetadataPath, "utf-8"));
       const metadata = MetadataSchema.parse(rawMetadata);
-      if (metadata.version) {
-        const kitName = metadata.name || "ClaudeKit";
-        console.log(`Local Kit Version: ${metadata.version} (${kitName})`);
-        localKitVersion = metadata.version;
+      const kitsDisplay = formatInstalledKits(metadata);
+      if (kitsDisplay) {
+        console.log(`Local Kit Version: ${kitsDisplay}`);
+        localKitVersion = getFirstKitVersion(metadata);
         foundAnyKit = true;
       }
     } catch (error) {
@@ -39888,11 +42247,11 @@ async function displayVersion() {
     try {
       const rawMetadata = JSON.parse(readFileSync5(globalMetadataPath, "utf-8"));
       const metadata = MetadataSchema.parse(rawMetadata);
-      if (metadata.version) {
-        const kitName = metadata.name || "ClaudeKit";
-        console.log(`Global Kit Version: ${metadata.version} (${kitName})`);
+      const kitsDisplay = formatInstalledKits(metadata);
+      if (kitsDisplay) {
+        console.log(`Global Kit Version: ${kitsDisplay}`);
         if (!localKitVersion) {
-          localKitVersion = metadata.version;
+          localKitVersion = getFirstKitVersion(metadata);
           isGlobalOnlyKit = true;
         }
         foundAnyKit = true;
@@ -39931,7 +42290,7 @@ function getPackageVersion2() {
 
 // src/shared/logger.ts
 init_output_manager();
-var import_picocolors25 = __toESM(require_picocolors(), 1);
+var import_picocolors26 = __toESM(require_picocolors(), 1);
 import { createWriteStream as createWriteStream3 } from "node:fs";
 
 class Logger2 {
@@ -39940,23 +42299,23 @@ class Logger2 {
   exitHandlerRegistered = false;
   info(message) {
     const symbols = output.getSymbols();
-    console.log(import_picocolors25.default.blue(symbols.info), message);
+    console.log(import_picocolors26.default.blue(symbols.info), message);
   }
   success(message) {
     const symbols = output.getSymbols();
-    console.log(import_picocolors25.default.green(symbols.success), message);
+    console.log(import_picocolors26.default.green(symbols.success), message);
   }
   warning(message) {
     const symbols = output.getSymbols();
-    console.log(import_picocolors25.default.yellow(symbols.warning), message);
+    console.log(import_picocolors26.default.yellow(symbols.warning), message);
   }
   error(message) {
     const symbols = output.getSymbols();
-    console.error(import_picocolors25.default.red(symbols.error), message);
+    console.error(import_picocolors26.default.red(symbols.error), message);
   }
   debug(message) {
     if (process.env.DEBUG) {
-      console.log(import_picocolors25.default.gray("[DEBUG]"), message);
+      console.log(import_picocolors26.default.gray("[DEBUG]"), message);
     }
   }
   verbose(message, context) {
@@ -39965,7 +42324,7 @@ class Logger2 {
     const timestamp = this.getTimestamp();
     const sanitizedMessage = this.sanitize(message);
     const formattedContext = context ? this.formatContext(context) : "";
-    const logLine = `${timestamp} ${import_picocolors25.default.gray("[VERBOSE]")} ${sanitizedMessage}${formattedContext}`;
+    const logLine = `${timestamp} ${import_picocolors26.default.gray("[VERBOSE]")} ${sanitizedMessage}${formattedContext}`;
     console.error(logLine);
     if (this.logFileStream) {
       const plainLogLine = `${timestamp} [VERBOSE] ${sanitizedMessage}${formattedContext}`;
@@ -40068,7 +42427,7 @@ var logger3 = new Logger2;
 
 // src/shared/output-manager.ts
 init_terminal_utils();
-var import_picocolors26 = __toESM(require_picocolors(), 1);
+var import_picocolors27 = __toESM(require_picocolors(), 1);
 var SYMBOLS2 = {
   unicode: {
     prompt: "◇",
@@ -40147,7 +42506,7 @@ class OutputManager2 {
     if (this.config.quiet)
       return;
     const symbol = this.getSymbols().success;
-    console.log(import_picocolors26.default.green(`${symbol} ${message}`));
+    console.log(import_picocolors27.default.green(`${symbol} ${message}`));
   }
   error(message, data) {
     if (this.config.json) {
@@ -40155,7 +42514,7 @@ class OutputManager2 {
       return;
     }
     const symbol = this.getSymbols().error;
-    console.error(import_picocolors26.default.red(`${symbol} ${message}`));
+    console.error(import_picocolors27.default.red(`${symbol} ${message}`));
   }
   warning(message, data) {
     if (this.config.json) {
@@ -40165,7 +42524,7 @@ class OutputManager2 {
     if (this.config.quiet)
       return;
     const symbol = this.getSymbols().warning;
-    console.log(import_picocolors26.default.yellow(`${symbol} ${message}`));
+    console.log(import_picocolors27.default.yellow(`${symbol} ${message}`));
   }
   info(message, data) {
     if (this.config.json) {
@@ -40175,7 +42534,7 @@ class OutputManager2 {
     if (this.config.quiet)
       return;
     const symbol = this.getSymbols().info;
-    console.log(import_picocolors26.default.blue(`${symbol} ${message}`));
+    console.log(import_picocolors27.default.blue(`${symbol} ${message}`));
   }
   verbose(message, data) {
     if (!this.config.verbose)
@@ -40184,7 +42543,7 @@ class OutputManager2 {
       this.addJsonEntry({ type: "info", message, data });
       return;
     }
-    console.log(import_picocolors26.default.dim(`  ${message}`));
+    console.log(import_picocolors27.default.dim(`  ${message}`));
   }
   indent(message) {
     if (this.config.json)
@@ -40209,7 +42568,7 @@ class OutputManager2 {
       return;
     const symbols = this.getSymbols();
     console.log();
-    console.log(import_picocolors26.default.bold(import_picocolors26.default.cyan(`${symbols.line} ${title}`)));
+    console.log(import_picocolors27.default.bold(import_picocolors27.default.cyan(`${symbols.line} ${title}`)));
   }
   addJsonEntry(entry) {
     this.jsonBuffer.push({