claudekit-cli 3.10.2 → 3.11.0

package/dist/index.js

@@ -6600,7 +6600,8 @@ var init_commands = __esm(() => {
     global: exports_external.boolean().default(false),
     all: exports_external.boolean().default(false),
     dryRun: exports_external.boolean().default(false),
-    forceOverwrite: exports_external.boolean().default(false)
+    forceOverwrite: exports_external.boolean().default(false),
+    kit: KitType.optional()
   }).merge(GlobalOutputOptionsSchema);
   UpdateCliOptionsSchema = exports_external.object({
     release: exports_external.string().optional(),
@@ -6643,7 +6644,7 @@ var init_github = __esm(() => {
 });
 
 // src/types/metadata.ts
-var TrackedFileSchema, MetadataSchema, ConfigSchema;
+var TrackedFileSchema, KitMetadataSchema, MultiKitMetadataSchema, LegacyMetadataSchema, MetadataSchema, ConfigSchema;
 var init_metadata = __esm(() => {
   init_zod();
   init_commands();
@@ -6654,7 +6655,22 @@ var init_metadata = __esm(() => {
     ownership: exports_external.enum(["ck", "user", "ck-modified"]),
     installedVersion: exports_external.string()
   });
-  MetadataSchema = exports_external.object({
+  KitMetadataSchema = exports_external.object({
+    version: exports_external.string(),
+    installedAt: exports_external.string(),
+    files: exports_external.array(TrackedFileSchema).optional()
+  });
+  MultiKitMetadataSchema = exports_external.object({
+    kits: exports_external.record(KitType, KitMetadataSchema).optional(),
+    scope: exports_external.enum(["local", "global"]).optional(),
+    name: exports_external.string().optional(),
+    version: exports_external.string().optional(),
+    installedAt: exports_external.string().optional(),
+    installedFiles: exports_external.array(exports_external.string()).optional(),
+    userConfigFiles: exports_external.array(exports_external.string()).optional(),
+    files: exports_external.array(TrackedFileSchema).optional()
+  });
+  LegacyMetadataSchema = exports_external.object({
     name: exports_external.string().optional(),
     version: exports_external.string().optional(),
     installedAt: exports_external.string().optional(),
@@ -6663,6 +6679,7 @@ var init_metadata = __esm(() => {
     userConfigFiles: exports_external.array(exports_external.string()).optional(),
     files: exports_external.array(TrackedFileSchema).optional()
   });
+  MetadataSchema = MultiKitMetadataSchema;
   ConfigSchema = exports_external.object({
     defaults: exports_external.object({
       kit: KitType.optional(),
@@ -6747,8 +6764,11 @@ __export(exports_types, {
   PROTECTED_PATTERNS: () => PROTECTED_PATTERNS,
   NewCommandOptionsSchema: () => NewCommandOptionsSchema,
   NEVER_COPY_PATTERNS: () => NEVER_COPY_PATTERNS,
+  MultiKitMetadataSchema: () => MultiKitMetadataSchema,
   MetadataSchema: () => MetadataSchema,
+  LegacyMetadataSchema: () => LegacyMetadataSchema,
   KitType: () => KitType,
+  KitMetadataSchema: () => KitMetadataSchema,
   KitConfigSchema: () => KitConfigSchema,
   GitHubReleaseSchema: () => GitHubReleaseSchema,
   GitHubReleaseAssetSchema: () => GitHubReleaseAssetSchema,
@@ -12253,9 +12273,751 @@ var require_ignore = __commonJS((exports, module) => {
   }
 });
 
+// node_modules/retry/lib/retry_operation.js
+var require_retry_operation = __commonJS((exports, module) => {
+  function RetryOperation(timeouts, options) {
+    if (typeof options === "boolean") {
+      options = { forever: options };
+    }
+    this._originalTimeouts = JSON.parse(JSON.stringify(timeouts));
+    this._timeouts = timeouts;
+    this._options = options || {};
+    this._maxRetryTime = options && options.maxRetryTime || Infinity;
+    this._fn = null;
+    this._errors = [];
+    this._attempts = 1;
+    this._operationTimeout = null;
+    this._operationTimeoutCb = null;
+    this._timeout = null;
+    this._operationStart = null;
+    if (this._options.forever) {
+      this._cachedTimeouts = this._timeouts.slice(0);
+    }
+  }
+  module.exports = RetryOperation;
+  RetryOperation.prototype.reset = function() {
+    this._attempts = 1;
+    this._timeouts = this._originalTimeouts;
+  };
+  RetryOperation.prototype.stop = function() {
+    if (this._timeout) {
+      clearTimeout(this._timeout);
+    }
+    this._timeouts = [];
+    this._cachedTimeouts = null;
+  };
+  RetryOperation.prototype.retry = function(err) {
+    if (this._timeout) {
+      clearTimeout(this._timeout);
+    }
+    if (!err) {
+      return false;
+    }
+    var currentTime = new Date().getTime();
+    if (err && currentTime - this._operationStart >= this._maxRetryTime) {
+      this._errors.unshift(new Error("RetryOperation timeout occurred"));
+      return false;
+    }
+    this._errors.push(err);
+    var timeout = this._timeouts.shift();
+    if (timeout === undefined) {
+      if (this._cachedTimeouts) {
+        this._errors.splice(this._errors.length - 1, this._errors.length);
+        this._timeouts = this._cachedTimeouts.slice(0);
+        timeout = this._timeouts.shift();
+      } else {
+        return false;
+      }
+    }
+    var self2 = this;
+    var timer = setTimeout(function() {
+      self2._attempts++;
+      if (self2._operationTimeoutCb) {
+        self2._timeout = setTimeout(function() {
+          self2._operationTimeoutCb(self2._attempts);
+        }, self2._operationTimeout);
+        if (self2._options.unref) {
+          self2._timeout.unref();
+        }
+      }
+      self2._fn(self2._attempts);
+    }, timeout);
+    if (this._options.unref) {
+      timer.unref();
+    }
+    return true;
+  };
+  RetryOperation.prototype.attempt = function(fn, timeoutOps) {
+    this._fn = fn;
+    if (timeoutOps) {
+      if (timeoutOps.timeout) {
+        this._operationTimeout = timeoutOps.timeout;
+      }
+      if (timeoutOps.cb) {
+        this._operationTimeoutCb = timeoutOps.cb;
+      }
+    }
+    var self2 = this;
+    if (this._operationTimeoutCb) {
+      this._timeout = setTimeout(function() {
+        self2._operationTimeoutCb();
+      }, self2._operationTimeout);
+    }
+    this._operationStart = new Date().getTime();
+    this._fn(this._attempts);
+  };
+  RetryOperation.prototype.try = function(fn) {
+    console.log("Using RetryOperation.try() is deprecated");
+    this.attempt(fn);
+  };
+  RetryOperation.prototype.start = function(fn) {
+    console.log("Using RetryOperation.start() is deprecated");
+    this.attempt(fn);
+  };
+  RetryOperation.prototype.start = RetryOperation.prototype.try;
+  RetryOperation.prototype.errors = function() {
+    return this._errors;
+  };
+  RetryOperation.prototype.attempts = function() {
+    return this._attempts;
+  };
+  RetryOperation.prototype.mainError = function() {
+    if (this._errors.length === 0) {
+      return null;
+    }
+    var counts = {};
+    var mainError = null;
+    var mainErrorCount = 0;
+    for (var i = 0;i < this._errors.length; i++) {
+      var error = this._errors[i];
+      var message = error.message;
+      var count = (counts[message] || 0) + 1;
+      counts[message] = count;
+      if (count >= mainErrorCount) {
+        mainError = error;
+        mainErrorCount = count;
+      }
+    }
+    return mainError;
+  };
+});
+
+// node_modules/retry/lib/retry.js
+var require_retry = __commonJS((exports) => {
+  var RetryOperation = require_retry_operation();
+  exports.operation = function(options) {
+    var timeouts = exports.timeouts(options);
+    return new RetryOperation(timeouts, {
+      forever: options && options.forever,
+      unref: options && options.unref,
+      maxRetryTime: options && options.maxRetryTime
+    });
+  };
+  exports.timeouts = function(options) {
+    if (options instanceof Array) {
+      return [].concat(options);
+    }
+    var opts = {
+      retries: 10,
+      factor: 2,
+      minTimeout: 1 * 1000,
+      maxTimeout: Infinity,
+      randomize: false
+    };
+    for (var key in options) {
+      opts[key] = options[key];
+    }
+    if (opts.minTimeout > opts.maxTimeout) {
+      throw new Error("minTimeout is greater than maxTimeout");
+    }
+    var timeouts = [];
+    for (var i = 0;i < opts.retries; i++) {
+      timeouts.push(this.createTimeout(i, opts));
+    }
+    if (options && options.forever && !timeouts.length) {
+      timeouts.push(this.createTimeout(i, opts));
+    }
+    timeouts.sort(function(a3, b3) {
+      return a3 - b3;
+    });
+    return timeouts;
+  };
+  exports.createTimeout = function(attempt, opts) {
+    var random = opts.randomize ? Math.random() + 1 : 1;
+    var timeout = Math.round(random * opts.minTimeout * Math.pow(opts.factor, attempt));
+    timeout = Math.min(timeout, opts.maxTimeout);
+    return timeout;
+  };
+  exports.wrap = function(obj, options, methods) {
+    if (options instanceof Array) {
+      methods = options;
+      options = null;
+    }
+    if (!methods) {
+      methods = [];
+      for (var key in obj) {
+        if (typeof obj[key] === "function") {
+          methods.push(key);
+        }
+      }
+    }
+    for (var i = 0;i < methods.length; i++) {
+      var method = methods[i];
+      var original = obj[method];
+      obj[method] = function retryWrapper(original2) {
+        var op = exports.operation(options);
+        var args = Array.prototype.slice.call(arguments, 1);
+        var callback = args.pop();
+        args.push(function(err) {
+          if (op.retry(err)) {
+            return;
+          }
+          if (err) {
+            arguments[0] = op.mainError();
+          }
+          callback.apply(this, arguments);
+        });
+        op.attempt(function() {
+          original2.apply(obj, args);
+        });
+      }.bind(obj, original);
+      obj[method].options = options;
+    }
+  };
+});
+
+// node_modules/signal-exit/signals.js
+var require_signals = __commonJS((exports, module) => {
+  module.exports = [
+    "SIGABRT",
+    "SIGALRM",
+    "SIGHUP",
+    "SIGINT",
+    "SIGTERM"
+  ];
+  if (process.platform !== "win32") {
+    module.exports.push("SIGVTALRM", "SIGXCPU", "SIGXFSZ", "SIGUSR2", "SIGTRAP", "SIGSYS", "SIGQUIT", "SIGIOT");
+  }
+  if (process.platform === "linux") {
+    module.exports.push("SIGIO", "SIGPOLL", "SIGPWR", "SIGSTKFLT", "SIGUNUSED");
+  }
+});
+
+// node_modules/signal-exit/index.js
+var require_signal_exit = __commonJS((exports, module) => {
+  var process10 = global.process;
+  var processOk2 = function(process11) {
+    return process11 && typeof process11 === "object" && typeof process11.removeListener === "function" && typeof process11.emit === "function" && typeof process11.reallyExit === "function" && typeof process11.listeners === "function" && typeof process11.kill === "function" && typeof process11.pid === "number" && typeof process11.on === "function";
+  };
+  if (!processOk2(process10)) {
+    module.exports = function() {
+      return function() {};
+    };
+  } else {
+    assert3 = __require("assert");
+    signals2 = require_signals();
+    isWin = /^win/i.test(process10.platform);
+    EE3 = __require("events");
+    if (typeof EE3 !== "function") {
+      EE3 = EE3.EventEmitter;
+    }
+    if (process10.__signal_exit_emitter__) {
+      emitter = process10.__signal_exit_emitter__;
+    } else {
+      emitter = process10.__signal_exit_emitter__ = new EE3;
+      emitter.count = 0;
+      emitter.emitted = {};
+    }
+    if (!emitter.infinite) {
+      emitter.setMaxListeners(Infinity);
+      emitter.infinite = true;
+    }
+    module.exports = function(cb, opts) {
+      if (!processOk2(global.process)) {
+        return function() {};
+      }
+      assert3.equal(typeof cb, "function", "a callback must be provided for exit handler");
+      if (loaded === false) {
+        load2();
+      }
+      var ev = "exit";
+      if (opts && opts.alwaysLast) {
+        ev = "afterexit";
+      }
+      var remove = function() {
+        emitter.removeListener(ev, cb);
+        if (emitter.listeners("exit").length === 0 && emitter.listeners("afterexit").length === 0) {
+          unload2();
+        }
+      };
+      emitter.on(ev, cb);
+      return remove;
+    };
+    unload2 = function unload() {
+      if (!loaded || !processOk2(global.process)) {
+        return;
+      }
+      loaded = false;
+      signals2.forEach(function(sig) {
+        try {
+          process10.removeListener(sig, sigListeners[sig]);
+        } catch (er) {}
+      });
+      process10.emit = originalProcessEmit;
+      process10.reallyExit = originalProcessReallyExit;
+      emitter.count -= 1;
+    };
+    module.exports.unload = unload2;
+    emit = function emit(event, code2, signal) {
+      if (emitter.emitted[event]) {
+        return;
+      }
+      emitter.emitted[event] = true;
+      emitter.emit(event, code2, signal);
+    };
+    sigListeners = {};
+    signals2.forEach(function(sig) {
+      sigListeners[sig] = function listener() {
+        if (!processOk2(global.process)) {
+          return;
+        }
+        var listeners = process10.listeners(sig);
+        if (listeners.length === emitter.count) {
+          unload2();
+          emit("exit", null, sig);
+          emit("afterexit", null, sig);
+          if (isWin && sig === "SIGHUP") {
+            sig = "SIGINT";
+          }
+          process10.kill(process10.pid, sig);
+        }
+      };
+    });
+    module.exports.signals = function() {
+      return signals2;
+    };
+    loaded = false;
+    load2 = function load() {
+      if (loaded || !processOk2(global.process)) {
+        return;
+      }
+      loaded = true;
+      emitter.count += 1;
+      signals2 = signals2.filter(function(sig) {
+        try {
+          process10.on(sig, sigListeners[sig]);
+          return true;
+        } catch (er) {
+          return false;
+        }
+      });
+      process10.emit = processEmit;
+      process10.reallyExit = processReallyExit;
+    };
+    module.exports.load = load2;
+    originalProcessReallyExit = process10.reallyExit;
+    processReallyExit = function processReallyExit(code2) {
+      if (!processOk2(global.process)) {
+        return;
+      }
+      process10.exitCode = code2 || 0;
+      emit("exit", process10.exitCode, null);
+      emit("afterexit", process10.exitCode, null);
+      originalProcessReallyExit.call(process10, process10.exitCode);
+    };
+    originalProcessEmit = process10.emit;
+    processEmit = function processEmit(ev, arg) {
+      if (ev === "exit" && processOk2(global.process)) {
+        if (arg !== undefined) {
+          process10.exitCode = arg;
+        }
+        var ret = originalProcessEmit.apply(this, arguments);
+        emit("exit", process10.exitCode, null);
+        emit("afterexit", process10.exitCode, null);
+        return ret;
+      } else {
+        return originalProcessEmit.apply(this, arguments);
+      }
+    };
+  }
+  var assert3;
+  var signals2;
+  var isWin;
+  var EE3;
+  var emitter;
+  var unload2;
+  var emit;
+  var sigListeners;
+  var loaded;
+  var load2;
+  var originalProcessReallyExit;
+  var processReallyExit;
+  var originalProcessEmit;
+  var processEmit;
+});
+
+// node_modules/proper-lockfile/lib/mtime-precision.js
+var require_mtime_precision = __commonJS((exports, module) => {
+  var cacheSymbol = Symbol();
+  function probe(file, fs12, callback) {
+    const cachedPrecision = fs12[cacheSymbol];
+    if (cachedPrecision) {
+      return fs12.stat(file, (err, stat3) => {
+        if (err) {
+          return callback(err);
+        }
+        callback(null, stat3.mtime, cachedPrecision);
+      });
+    }
+    const mtime = new Date(Math.ceil(Date.now() / 1000) * 1000 + 5);
+    fs12.utimes(file, mtime, mtime, (err) => {
+      if (err) {
+        return callback(err);
+      }
+      fs12.stat(file, (err2, stat3) => {
+        if (err2) {
+          return callback(err2);
+        }
+        const precision = stat3.mtime.getTime() % 1000 === 0 ? "s" : "ms";
+        Object.defineProperty(fs12, cacheSymbol, { value: precision });
+        callback(null, stat3.mtime, precision);
+      });
+    });
+  }
+  function getMtime(precision) {
+    let now = Date.now();
+    if (precision === "s") {
+      now = Math.ceil(now / 1000) * 1000;
+    }
+    return new Date(now);
+  }
+  exports.probe = probe;
+  exports.getMtime = getMtime;
+});
+
+// node_modules/proper-lockfile/lib/lockfile.js
+var require_lockfile = __commonJS((exports, module) => {
+  var path9 = __require("path");
+  var fs12 = require_graceful_fs();
+  var retry = require_retry();
+  var onExit2 = require_signal_exit();
+  var mtimePrecision = require_mtime_precision();
+  var locks = {};
+  function getLockFile(file, options) {
+    return options.lockfilePath || `${file}.lock`;
+  }
+  function resolveCanonicalPath(file, options, callback) {
+    if (!options.realpath) {
+      return callback(null, path9.resolve(file));
+    }
+    options.fs.realpath(file, callback);
+  }
+  function acquireLock(file, options, callback) {
+    const lockfilePath = getLockFile(file, options);
+    options.fs.mkdir(lockfilePath, (err) => {
+      if (!err) {
+        return mtimePrecision.probe(lockfilePath, options.fs, (err2, mtime, mtimePrecision2) => {
+          if (err2) {
+            options.fs.rmdir(lockfilePath, () => {});
+            return callback(err2);
+          }
+          callback(null, mtime, mtimePrecision2);
+        });
+      }
+      if (err.code !== "EEXIST") {
+        return callback(err);
+      }
+      if (options.stale <= 0) {
+        return callback(Object.assign(new Error("Lock file is already being held"), { code: "ELOCKED", file }));
+      }
+      options.fs.stat(lockfilePath, (err2, stat3) => {
+        if (err2) {
+          if (err2.code === "ENOENT") {
+            return acquireLock(file, { ...options, stale: 0 }, callback);
+          }
+          return callback(err2);
+        }
+        if (!isLockStale(stat3, options)) {
+          return callback(Object.assign(new Error("Lock file is already being held"), { code: "ELOCKED", file }));
+        }
+        removeLock(file, options, (err3) => {
+          if (err3) {
+            return callback(err3);
+          }
+          acquireLock(file, { ...options, stale: 0 }, callback);
+        });
+      });
+    });
+  }
+  function isLockStale(stat3, options) {
+    return stat3.mtime.getTime() < Date.now() - options.stale;
+  }
+  function removeLock(file, options, callback) {
+    options.fs.rmdir(getLockFile(file, options), (err) => {
+      if (err && err.code !== "ENOENT") {
+        return callback(err);
+      }
+      callback();
+    });
+  }
+  function updateLock(file, options) {
+    const lock2 = locks[file];
+    if (lock2.updateTimeout) {
+      return;
+    }
+    lock2.updateDelay = lock2.updateDelay || options.update;
+    lock2.updateTimeout = setTimeout(() => {
+      lock2.updateTimeout = null;
+      options.fs.stat(lock2.lockfilePath, (err, stat3) => {
+        const isOverThreshold = lock2.lastUpdate + options.stale < Date.now();
+        if (err) {
+          if (err.code === "ENOENT" || isOverThreshold) {
+            return setLockAsCompromised(file, lock2, Object.assign(err, { code: "ECOMPROMISED" }));
+          }
+          lock2.updateDelay = 1000;
+          return updateLock(file, options);
+        }
+        const isMtimeOurs = lock2.mtime.getTime() === stat3.mtime.getTime();
+        if (!isMtimeOurs) {
+          return setLockAsCompromised(file, lock2, Object.assign(new Error("Unable to update lock within the stale threshold"), { code: "ECOMPROMISED" }));
+        }
+        const mtime = mtimePrecision.getMtime(lock2.mtimePrecision);
+        options.fs.utimes(lock2.lockfilePath, mtime, mtime, (err2) => {
+          const isOverThreshold2 = lock2.lastUpdate + options.stale < Date.now();
+          if (lock2.released) {
+            return;
+          }
+          if (err2) {
+            if (err2.code === "ENOENT" || isOverThreshold2) {
+              return setLockAsCompromised(file, lock2, Object.assign(err2, { code: "ECOMPROMISED" }));
+            }
+            lock2.updateDelay = 1000;
+            return updateLock(file, options);
+          }
+          lock2.mtime = mtime;
+          lock2.lastUpdate = Date.now();
+          lock2.updateDelay = null;
+          updateLock(file, options);
+        });
+      });
+    }, lock2.updateDelay);
+    if (lock2.updateTimeout.unref) {
+      lock2.updateTimeout.unref();
+    }
+  }
+  function setLockAsCompromised(file, lock2, err) {
+    lock2.released = true;
+    if (lock2.updateTimeout) {
+      clearTimeout(lock2.updateTimeout);
+    }
+    if (locks[file] === lock2) {
+      delete locks[file];
+    }
+    lock2.options.onCompromised(err);
+  }
+  function lock(file, options, callback) {
+    options = {
+      stale: 1e4,
+      update: null,
+      realpath: true,
+      retries: 0,
+      fs: fs12,
+      onCompromised: (err) => {
+        throw err;
+      },
+      ...options
+    };
+    options.retries = options.retries || 0;
+    options.retries = typeof options.retries === "number" ? { retries: options.retries } : options.retries;
+    options.stale = Math.max(options.stale || 0, 2000);
+    options.update = options.update == null ? options.stale / 2 : options.update || 0;
+    options.update = Math.max(Math.min(options.update, options.stale / 2), 1000);
+    resolveCanonicalPath(file, options, (err, file2) => {
+      if (err) {
+        return callback(err);
+      }
+      const operation = retry.operation(options.retries);
+      operation.attempt(() => {
+        acquireLock(file2, options, (err2, mtime, mtimePrecision2) => {
+          if (operation.retry(err2)) {
+            return;
+          }
+          if (err2) {
+            return callback(operation.mainError());
+          }
+          const lock2 = locks[file2] = {
+            lockfilePath: getLockFile(file2, options),
+            mtime,
+            mtimePrecision: mtimePrecision2,
+            options,
+            lastUpdate: Date.now()
+          };
+          updateLock(file2, options);
+          callback(null, (releasedCallback) => {
+            if (lock2.released) {
+              return releasedCallback && releasedCallback(Object.assign(new Error("Lock is already released"), { code: "ERELEASED" }));
+            }
+            unlock(file2, { ...options, realpath: false }, releasedCallback);
+          });
+        });
+      });
+    });
+  }
+  function unlock(file, options, callback) {
+    options = {
+      fs: fs12,
+      realpath: true,
+      ...options
+    };
+    resolveCanonicalPath(file, options, (err, file2) => {
+      if (err) {
+        return callback(err);
+      }
+      const lock2 = locks[file2];
+      if (!lock2) {
+        return callback(Object.assign(new Error("Lock is not acquired/owned by you"), { code: "ENOTACQUIRED" }));
+      }
+      lock2.updateTimeout && clearTimeout(lock2.updateTimeout);
+      lock2.released = true;
+      delete locks[file2];
+      removeLock(file2, options, callback);
+    });
+  }
+  function check(file, options, callback) {
+    options = {
+      stale: 1e4,
+      realpath: true,
+      fs: fs12,
+      ...options
+    };
+    options.stale = Math.max(options.stale || 0, 2000);
+    resolveCanonicalPath(file, options, (err, file2) => {
+      if (err) {
+        return callback(err);
+      }
+      options.fs.stat(getLockFile(file2, options), (err2, stat3) => {
+        if (err2) {
+          return err2.code === "ENOENT" ? callback(null, false) : callback(err2);
+        }
+        return callback(null, !isLockStale(stat3, options));
+      });
+    });
+  }
+  function getLocks() {
+    return locks;
+  }
+  onExit2(() => {
+    for (const file in locks) {
+      const options = locks[file].options;
+      try {
+        options.fs.rmdirSync(getLockFile(file, options));
+      } catch (e2) {}
+    }
+  });
+  exports.lock = lock;
+  exports.unlock = unlock;
+  exports.check = check;
+  exports.getLocks = getLocks;
+});
+
+// node_modules/proper-lockfile/lib/adapter.js
+var require_adapter = __commonJS((exports, module) => {
+  var fs12 = require_graceful_fs();
+  function createSyncFs(fs13) {
+    const methods = ["mkdir", "realpath", "stat", "rmdir", "utimes"];
+    const newFs = { ...fs13 };
+    methods.forEach((method) => {
+      newFs[method] = (...args) => {
+        const callback = args.pop();
+        let ret;
+        try {
+          ret = fs13[`${method}Sync`](...args);
+        } catch (err) {
+          return callback(err);
+        }
+        callback(null, ret);
+      };
+    });
+    return newFs;
+  }
+  function toPromise(method) {
+    return (...args) => new Promise((resolve3, reject) => {
+      args.push((err, result) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve3(result);
+        }
+      });
+      method(...args);
+    });
+  }
+  function toSync(method) {
+    return (...args) => {
+      let err;
+      let result;
+      args.push((_err, _result) => {
+        err = _err;
+        result = _result;
+      });
+      method(...args);
+      if (err) {
+        throw err;
+      }
+      return result;
+    };
+  }
+  function toSyncOptions(options) {
+    options = { ...options };
+    options.fs = createSyncFs(options.fs || fs12);
+    if (typeof options.retries === "number" && options.retries > 0 || options.retries && typeof options.retries.retries === "number" && options.retries.retries > 0) {
+      throw Object.assign(new Error("Cannot use retries with the sync api"), { code: "ESYNC" });
+    }
+    return options;
+  }
+  module.exports = {
+    toPromise,
+    toSync,
+    toSyncOptions
+  };
+});
+
+// node_modules/proper-lockfile/index.js
+var require_proper_lockfile = __commonJS((exports, module) => {
+  var lockfile = require_lockfile();
+  var { toPromise, toSync, toSyncOptions } = require_adapter();
+  async function lock(file, options) {
+    const release = await toPromise(lockfile.lock)(file, options);
+    return toPromise(release);
+  }
+  function lockSync(file, options) {
+    const release = toSync(lockfile.lock)(file, toSyncOptions(options));
+    return toSync(release);
+  }
+  function unlock(file, options) {
+    return toPromise(lockfile.unlock)(file, options);
+  }
+  function unlockSync(file, options) {
+    return toSync(lockfile.unlock)(file, toSyncOptions(options));
+  }
+  function check(file, options) {
+    return toPromise(lockfile.check)(file, options);
+  }
+  function checkSync(file, options) {
+    return toSync(lockfile.check)(file, toSyncOptions(options));
+  }
+  module.exports = lock;
+  module.exports.lock = lock;
+  module.exports.unlock = unlock;
+  module.exports.lockSync = lockSync;
+  module.exports.unlockSync = unlockSync;
+  module.exports.check = check;
+  module.exports.checkSync = checkSync;
+});
+
 // src/services/package-installer/install-error-handler.ts
 import { existsSync as existsSync6, readFileSync as readFileSync4, unlinkSync as unlinkSync2 } from "node:fs";
-import { join as join24 } from "node:path";
+import { join as join25 } from "node:path";
 function parseNameReason(str) {
   const colonIndex = str.indexOf(":");
   if (colonIndex === -1) {
@@ -12264,7 +13026,7 @@ function parseNameReason(str) {
   return [str.slice(0, colonIndex).trim(), str.slice(colonIndex + 1).trim()];
 }
 function displayInstallErrors(skillsDir) {
-  const summaryPath = join24(skillsDir, ".install-error-summary.json");
+  const summaryPath = join25(skillsDir, ".install-error-summary.json");
   if (!existsSync6(summaryPath)) {
     logger.error("Skills installation failed. Run with --verbose for details.");
     return;
@@ -12355,7 +13117,7 @@ async function checkNeedsSudoPackages() {
   }
 }
 function hasInstallState(skillsDir) {
-  const stateFilePath = join24(skillsDir, ".install-state.json");
+  const stateFilePath = join25(skillsDir, ".install-state.json");
   return existsSync6(stateFilePath);
 }
 var WHICH_COMMAND_TIMEOUT_MS = 5000;
@@ -12374,14 +13136,14 @@ __export(exports_gemini_mcp_linker, {
   addGeminiToGitignore: () => addGeminiToGitignore
 });
 import { existsSync as existsSync7, lstatSync, readlinkSync } from "node:fs";
-import { mkdir as mkdir9, readFile as readFile14, symlink as symlink2, writeFile as writeFile12 } from "node:fs/promises";
+import { mkdir as mkdir9, readFile as readFile15, symlink as symlink2, writeFile as writeFile13 } from "node:fs/promises";
 import { homedir as homedir4 } from "node:os";
-import { dirname as dirname6, join as join25, resolve as resolve3 } from "node:path";
+import { dirname as dirname6, join as join26, resolve as resolve3 } from "node:path";
 function getGlobalMcpConfigPath() {
-  return join25(homedir4(), ".claude", ".mcp.json");
+  return join26(homedir4(), ".claude", ".mcp.json");
 }
 function getLocalMcpConfigPath(projectDir) {
-  return join25(projectDir, ".mcp.json");
+  return join26(projectDir, ".mcp.json");
 }
 function findMcpConfigPath(projectDir) {
   const localPath = getLocalMcpConfigPath(projectDir);
@@ -12399,9 +13161,9 @@ function findMcpConfigPath(projectDir) {
 }
 function getGeminiSettingsPath(projectDir, isGlobal) {
   if (isGlobal) {
-    return join25(homedir4(), ".gemini", "settings.json");
+    return join26(homedir4(), ".gemini", "settings.json");
   }
-  return join25(projectDir, ".gemini", "settings.json");
+  return join26(projectDir, ".gemini", "settings.json");
 }
 function checkExistingGeminiConfig(projectDir, isGlobal = false) {
   const geminiSettingsPath = getGeminiSettingsPath(projectDir, isGlobal);
@@ -12426,7 +13188,7 @@ function checkExistingGeminiConfig(projectDir, isGlobal = false) {
 }
 async function readJsonFile(filePath) {
   try {
-    const content = await readFile14(filePath, "utf-8");
+    const content = await readFile15(filePath, "utf-8");
     return JSON.parse(content);
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : "Unknown error";
@@ -12445,7 +13207,7 @@ async function createSymlink(targetPath, linkPath, projectDir, isGlobal) {
   if (isGlobal) {
     symlinkTarget = getGlobalMcpConfigPath();
   } else {
-    const localMcpPath = join25(projectDir, ".mcp.json");
+    const localMcpPath = join26(projectDir, ".mcp.json");
     const isLocalConfig = targetPath === localMcpPath;
     symlinkTarget = isLocalConfig ? "../.mcp.json" : targetPath;
   }
@@ -12478,7 +13240,7 @@ async function createNewSettingsWithMerge(geminiSettingsPath, mcpConfigPath) {
   }
   const newSettings = { mcpServers };
   try {
-    await writeFile12(geminiSettingsPath, JSON.stringify(newSettings, null, 2), "utf-8");
+    await writeFile13(geminiSettingsPath, JSON.stringify(newSettings, null, 2), "utf-8");
     logger.debug(`Created new Gemini settings with mcpServers: ${geminiSettingsPath}`);
     return { success: true, method: "merge", targetPath: mcpConfigPath };
   } catch (error) {
@@ -12508,7 +13270,7 @@ async function mergeGeminiSettings(geminiSettingsPath, mcpConfigPath) {
     mcpServers
   };
   try {
-    await writeFile12(geminiSettingsPath, JSON.stringify(mergedSettings, null, 2), "utf-8");
+    await writeFile13(geminiSettingsPath, JSON.stringify(mergedSettings, null, 2), "utf-8");
     logger.debug(`Merged mcpServers into: ${geminiSettingsPath}`);
     return { success: true, method: "merge", targetPath: mcpConfigPath };
   } catch (error) {
@@ -12521,12 +13283,12 @@ async function mergeGeminiSettings(geminiSettingsPath, mcpConfigPath) {
   }
 }
 async function addGeminiToGitignore(projectDir) {
-  const gitignorePath = join25(projectDir, ".gitignore");
+  const gitignorePath = join26(projectDir, ".gitignore");
   const geminiPattern = ".gemini/";
   try {
     let content = "";
     if (existsSync7(gitignorePath)) {
-      content = await readFile14(gitignorePath, "utf-8");
+      content = await readFile15(gitignorePath, "utf-8");
       const lines = content.split(`
 `).map((line) => line.trim()).filter((line) => !line.startsWith("#"));
       const geminiPatterns = [".gemini/", ".gemini", "/.gemini/", "/.gemini"];
@@ -12539,7 +13301,7 @@ async function addGeminiToGitignore(projectDir) {
 `) || content === "" ? "" : `
 `;
     const comment = "# Gemini CLI settings (contains user-specific config)";
-    await writeFile12(gitignorePath, `${content}${newLine}${comment}
+    await writeFile13(gitignorePath, `${content}${newLine}${comment}
 ${geminiPattern}
 `, "utf-8");
     logger.debug(`Added ${geminiPattern} to .gitignore`);
@@ -12631,7 +13393,7 @@ __export(exports_package_installer, {
   getPackageVersion: () => getPackageVersion
 });
 import { exec as exec5, execFile as execFile2, spawn } from "node:child_process";
-import { join as join26, resolve as resolve4 } from "node:path";
+import { join as join27, resolve as resolve4 } from "node:path";
 import { promisify as promisify5 } from "node:util";
 function executeInteractiveScript(command, args, options) {
   return new Promise((resolve5, reject) => {
@@ -12826,7 +13588,7 @@ async function installOpenCode() {
     logger.info(`Installing ${displayName}...`);
     const { unlink: unlink5 } = await import("node:fs/promises");
     const { tmpdir: tmpdir3 } = await import("node:os");
-    const tempScriptPath = join26(tmpdir3(), "opencode-install.sh");
+    const tempScriptPath = join27(tmpdir3(), "opencode-install.sh");
     try {
       logger.info("Downloading OpenCode installation script...");
       await execFileAsync("curl", ["-fsSL", "https://opencode.ai/install", "-o", tempScriptPath], {
@@ -12945,7 +13707,7 @@ async function installSkillsDependencies(skillsDir) {
     const clack = await Promise.resolve().then(() => (init_dist2(), exports_dist));
     const platform9 = process.platform;
     const scriptName = platform9 === "win32" ? "install.ps1" : "install.sh";
-    const scriptPath = join26(skillsDir, scriptName);
+    const scriptPath = join27(skillsDir, scriptName);
     try {
       validateScriptPath(skillsDir, scriptPath);
     } catch (error) {
@@ -12961,7 +13723,7 @@ async function installSkillsDependencies(skillsDir) {
       logger.warning(`Skills installation script not found: ${scriptPath}`);
       logger.info("");
       logger.info("\uD83D\uDCD6 Manual Installation Instructions:");
-      logger.info(`  See: ${join26(skillsDir, "INSTALLATION.md")}`);
+      logger.info(`  See: ${join27(skillsDir, "INSTALLATION.md")}`);
       logger.info("");
       logger.info("Quick start:");
       logger.info("  cd .claude/skills/ai-multimodal/scripts");
@@ -12977,8 +13739,8 @@ async function installSkillsDependencies(skillsDir) {
     logger.info(`  Platform: ${platform9 === "win32" ? "Windows (PowerShell)" : "Unix (bash)"}`);
     if (logger.isVerbose()) {
       try {
-        const { readFile: readFile15 } = await import("node:fs/promises");
-        const scriptContent = await readFile15(scriptPath, "utf-8");
+        const { readFile: readFile16 } = await import("node:fs/promises");
+        const scriptContent = await readFile16(scriptPath, "utf-8");
         const previewLines = scriptContent.split(`
 `).slice(0, 20);
         logger.verbose("Script preview (first 20 lines):");
@@ -13004,7 +13766,7 @@ async function installSkillsDependencies(skillsDir) {
       logger.info(`  ${platform9 === "win32" ? `powershell -File "${scriptPath}"` : `bash ${scriptPath}`}`);
       logger.info("");
       logger.info("Or see complete guide:");
-      logger.info(`  ${join26(skillsDir, "INSTALLATION.md")}`);
+      logger.info(`  ${join27(skillsDir, "INSTALLATION.md")}`);
       return {
         success: false,
         package: displayName,
@@ -13105,7 +13867,7 @@ async function installSkillsDependencies(skillsDir) {
     logger.info("\uD83D\uDCD6 Manual Installation Instructions:");
     logger.info("");
     logger.info("See complete guide:");
-    logger.info(`  cat ${join26(skillsDir, "INSTALLATION.md")}`);
+    logger.info(`  cat ${join27(skillsDir, "INSTALLATION.md")}`);
     logger.info("");
     logger.info("Quick start:");
     logger.info("  cd .claude/skills/ai-multimodal/scripts");
@@ -14099,7 +14861,7 @@ var init_help_interceptor = __esm(() => {
 
 // src/index.ts
 import { existsSync as existsSync9, readFileSync as readFileSync5 } from "fs";
-import { join as join36 } from "path";
+import { join as join37 } from "path";
 
 // node_modules/cac/dist/index.mjs
 import { EventEmitter } from "events";
@@ -14704,7 +15466,7 @@ var cac = (name = "") => new CAC(name);
 // package.json
 var package_default = {
   name: "claudekit-cli",
-  version: "3.10.2",
+  version: "3.11.0",
   description: "CLI tool for bootstrapping and updating ClaudeKit projects",
   type: "module",
   repository: {
@@ -14724,7 +15486,7 @@ var package_default = {
   ],
   scripts: {
     dev: "bun run src/index.ts",
-    build: "bun build src/index.ts --outdir dist --target node --external keytar --external @octokit/rest",
+    build: "bun build src/index.ts --outdir dist --target node --external @octokit/rest",
     compile: "bun build src/index.ts --compile --outfile ck",
     "compile:binary": "bun build src/index.ts --compile --outfile bin/ck",
     "compile:binaries": "node scripts/build-all-binaries.js",
@@ -14765,11 +15527,11 @@ var package_default = {
     "extract-zip": "^2.0.1",
     "fs-extra": "^11.2.0",
     ignore: "^5.3.2",
-    keytar: "^7.9.0",
     minimatch: "^10.1.1",
     ora: "^8.0.0",
     "p-limit": "^7.2.0",
     picocolors: "^1.1.1",
+    "proper-lockfile": "^4.1.2",
     tar: "^7.4.3",
     tmp: "^0.2.3",
     zod: "^3.23.8"
@@ -14782,6 +15544,7 @@ var package_default = {
     "@types/cli-progress": "^3.11.6",
     "@types/fs-extra": "^11.0.4",
     "@types/node": "^22.10.1",
+    "@types/proper-lockfile": "^4.1.4",
     "@types/tar": "^6.1.13",
     "@types/tmp": "^0.2.6",
     "semantic-release": "^24.2.0",
@@ -18650,7 +19413,7 @@ async function doctorCommand(options = {}) {
 }
 
 // src/commands/init.ts
-import { join as join31, resolve as resolve6 } from "node:path";
+import { join as join32, resolve as resolve6 } from "node:path";
 
 // src/domains/config/config-manager.ts
 init_logger();
@@ -27647,7 +28410,7 @@ Solutions:
 }
 
 // src/domains/installation/file-merger.ts
-import { dirname as dirname5, join as join12, relative as relative2 } from "node:path";
+import { dirname as dirname5, join as join12, relative as relative3 } from "node:path";
 
 // src/domains/config/settings-merger.ts
 init_logger();
@@ -29293,7 +30056,130 @@ minimatch.Minimatch = Minimatch;
 minimatch.escape = escape;
 minimatch.unescape = unescape;
 
-// src/domains/installation/file-merger.ts
+// src/domains/installation/selective-merger.ts
+import { stat as stat2 } from "node:fs/promises";
+
+// src/services/file-operations/ownership-checker.ts
+import { createHash } from "node:crypto";
+import { createReadStream } from "node:fs";
+import { stat } from "node:fs/promises";
+import { relative as relative2 } from "node:path";
+
+class OwnershipChecker {
+  static async calculateChecksum(filePath) {
+    return new Promise((resolve3, reject) => {
+      const hash = createHash("sha256");
+      const stream = createReadStream(filePath);
+      stream.on("data", (chunk) => hash.update(chunk));
+      stream.on("end", () => {
+        resolve3(hash.digest("hex"));
+      });
+      stream.on("error", (err) => {
+        stream.destroy();
+        reject(new Error(`Failed to calculate checksum for "${filePath}": ${err.message}`));
+      });
+    });
+  }
+  static async checkOwnership(filePath, metadata, claudeDir) {
+    try {
+      await stat(filePath);
+    } catch {
+      return { path: filePath, ownership: "user", exists: false };
+    }
+    if (!metadata || !metadata.files || metadata.files.length === 0) {
+      return { path: filePath, ownership: "user", exists: true };
+    }
+    const relativePath = relative2(claudeDir, filePath).replace(/\\/g, "/");
+    const tracked = metadata.files.find((f3) => f3.path === relativePath);
+    if (!tracked) {
+      return { path: filePath, ownership: "user", exists: true };
+    }
+    const actualChecksum = await OwnershipChecker.calculateChecksum(filePath);
+    if (actualChecksum === tracked.checksum) {
+      return {
+        path: filePath,
+        ownership: "ck",
+        expectedChecksum: tracked.checksum,
+        actualChecksum,
+        exists: true
+      };
+    }
+    return {
+      path: filePath,
+      ownership: "ck-modified",
+      expectedChecksum: tracked.checksum,
+      actualChecksum,
+      exists: true
+    };
+  }
+  static async checkBatch(filePaths, metadata, claudeDir) {
+    const results = await Promise.all(filePaths.map((path9) => OwnershipChecker.checkOwnership(path9, metadata, claudeDir)));
+    return new Map(results.map((r2) => [r2.path, r2]));
+  }
+}
+
+// src/domains/installation/selective-merger.ts
+init_logger();
+
+class SelectiveMerger {
+  manifest;
+  manifestMap;
+  constructor(manifest) {
+    this.manifest = manifest;
+    this.manifestMap = new Map;
+    if (manifest) {
+      for (const file of manifest.files) {
+        this.manifestMap.set(file.path, file);
+      }
+    }
+  }
+  async shouldCopyFile(destPath, relativePath) {
+    let destStat;
+    try {
+      destStat = await stat2(destPath);
+    } catch {
+      return { changed: true, reason: "new" };
+    }
+    const manifestEntry = this.manifestMap.get(relativePath);
+    if (!manifestEntry) {
+      logger.debug(`No manifest entry for ${relativePath}, will copy`);
+      return { changed: true, reason: "new" };
+    }
+    if (destStat.size !== manifestEntry.size) {
+      logger.debug(`Size differs for ${relativePath}: ${destStat.size} vs ${manifestEntry.size}`);
+      return {
+        changed: true,
+        reason: "size-differ",
+        sourceChecksum: manifestEntry.checksum
+      };
+    }
+    const destChecksum = await OwnershipChecker.calculateChecksum(destPath);
+    if (destChecksum !== manifestEntry.checksum) {
+      logger.debug(`Checksum differs for ${relativePath}`);
+      return {
+        changed: true,
+        reason: "checksum-differ",
+        sourceChecksum: manifestEntry.checksum,
+        destChecksum
+      };
+    }
+    logger.debug(`Unchanged: ${relativePath}`);
+    return {
+      changed: false,
+      reason: "unchanged",
+      sourceChecksum: manifestEntry.checksum,
+      destChecksum
+    };
+  }
+  hasManifest() {
+    return this.manifest !== null && this.manifestMap.size > 0;
+  }
+  getManifestFileCount() {
+    return this.manifestMap.size;
+  }
+}
+
+// src/domains/installation/file-merger.ts
 class FileMerger {
   neverCopyChecker = import_ignore2.default().add(NEVER_COPY_PATTERNS);
   userConfigChecker = import_ignore2.default().add(USER_CONFIG_PATTERNS);
@@ -29302,6 +30188,8 @@ class FileMerger {
   forceOverwriteSettings = false;
   installedFiles = new Set;
   installedDirectories = new Set;
+  selectiveMerger = null;
+  unchangedSkipped = 0;
   setIncludePatterns(patterns) {
     this.includePatterns = patterns;
   }
@@ -29311,6 +30199,12 @@ class FileMerger {
   setForceOverwriteSettings(force) {
     this.forceOverwriteSettings = force;
   }
+  setManifest(manifest) {
+    this.selectiveMerger = manifest ? new SelectiveMerger(manifest) : null;
+    if (manifest && this.selectiveMerger?.hasManifest()) {
+      logger.debug(`Selective merge enabled with ${this.selectiveMerger.getManifestFileCount()} tracked files`);
+    }
+  }
   async merge(sourceDir, destDir, skipConfirmation = false) {
     const conflicts = await this.detectConflicts(sourceDir, destDir);
     if (conflicts.length > 0 && !skipConfirmation) {
@@ -29332,7 +30226,7 @@ class FileMerger {
     const conflicts = [];
     const files = await this.getFiles(sourceDir, sourceDir);
     for (const file of files) {
-      const relativePath = relative2(sourceDir, file);
+      const relativePath = relative3(sourceDir, file);
       const normalizedRelativePath = relativePath.replace(/\\/g, "/");
       const destPath = join12(destDir, relativePath);
       if (await import_fs_extra3.pathExists(destPath)) {
@@ -29354,7 +30248,7 @@ class FileMerger {
     let copiedCount = 0;
     let skippedCount = 0;
     for (const file of files) {
-      const relativePath = relative2(sourceDir, file);
+      const relativePath = relative3(sourceDir, file);
       const normalizedRelativePath = relativePath.replace(/\\/g, "/");
       const destPath = join12(destDir, relativePath);
       if (this.neverCopyChecker.ignores(normalizedRelativePath)) {
@@ -29377,11 +30271,24 @@ class FileMerger {
         copiedCount++;
         continue;
       }
+      if (this.selectiveMerger?.hasManifest()) {
+        const compareResult = await this.selectiveMerger.shouldCopyFile(destPath, normalizedRelativePath);
+        if (!compareResult.changed) {
+          logger.debug(`Skipping unchanged: ${normalizedRelativePath}`);
+          this.unchangedSkipped++;
+          this.trackInstalledFile(normalizedRelativePath);
+          continue;
+        }
+      }
       await import_fs_extra3.copy(file, destPath, { overwrite: true });
       this.trackInstalledFile(normalizedRelativePath);
       copiedCount++;
     }
-    logger.success(`Copied ${copiedCount} file(s), skipped ${skippedCount} protected file(s)`);
+    if (this.unchangedSkipped > 0) {
+      logger.success(`Updated ${copiedCount} file(s), skipped ${this.unchangedSkipped} unchanged, skipped ${skippedCount} protected`);
+    } else {
+      logger.success(`Copied ${copiedCount} file(s), skipped ${skippedCount} protected file(s)`);
+    }
   }
   async processSettingsJson(sourceFile, destFile) {
     try {
@@ -29472,7 +30379,7 @@ class FileMerger {
     const entries = await import_fs_extra3.readdir(dir, { encoding: "utf8" });
     for (const entry of entries) {
       const fullPath = join12(dir, entry);
-      const relativePath = relative2(baseDir, fullPath);
+      const relativePath = relative3(baseDir, fullPath);
       const normalizedRelativePath = relativePath.replace(/\\/g, "/");
       const stats = await import_fs_extra3.lstat(fullPath);
       if (stats.isSymbolicLink()) {
@@ -29731,14 +30638,165 @@ async function runSetupWizard(options) {
 }
 
 // src/domains/migration/legacy-migration.ts
-import { readdir as readdir4, stat as stat2 } from "node:fs/promises";
-import { join as join18, relative as relative4 } from "node:path";
+import { readdir as readdir4, stat as stat3 } from "node:fs/promises";
+import { join as join19, relative as relative4 } from "node:path";
 
 // src/services/file-operations/manifest-writer.ts
+import { join as join17 } from "node:path";
+
+// src/domains/migration/metadata-migration.ts
 init_logger();
-init_types2();
 var import_fs_extra7 = __toESM(require_lib(), 1);
 import { join as join16 } from "node:path";
+async function detectMetadataFormat(claudeDir) {
+  const metadataPath = join16(claudeDir, "metadata.json");
+  if (!await import_fs_extra7.pathExists(metadataPath)) {
+    return { format: "none", metadata: null, detectedKit: null };
+  }
+  try {
+    const content = await import_fs_extra7.readFile(metadataPath, "utf-8");
+    const parsed = JSON.parse(content);
+    if (parsed.kits && Object.keys(parsed.kits).length > 0) {
+      const installedKits = Object.keys(parsed.kits);
+      return {
+        format: "multi-kit",
+        metadata: parsed,
+        detectedKit: installedKits[0] || null
+      };
+    }
+    if (parsed.name || parsed.version || parsed.files) {
+      let detectedKit = null;
+      const nameToCheck = parsed.name || "";
+      if (/\bengineer\b/i.test(nameToCheck)) {
+        detectedKit = "engineer";
+      } else if (/\bmarketing\b/i.test(nameToCheck)) {
+        detectedKit = "marketing";
+      } else {
+        detectedKit = "engineer";
+      }
+      return { format: "legacy", metadata: parsed, detectedKit };
+    }
+    logger.warning("Metadata file exists but has unrecognized format (missing kits, name, version, or files)");
+    return { format: "none", metadata: null, detectedKit: null };
+  } catch (error) {
+    logger.warning(`Failed to read metadata file (may be corrupted): ${error}`);
+    return { format: "none", metadata: null, detectedKit: null };
+  }
+}
+async function migrateToMultiKit(claudeDir) {
+  const detection = await detectMetadataFormat(claudeDir);
+  if (detection.format === "multi-kit") {
+    return {
+      success: true,
+      migrated: false,
+      fromFormat: "multi-kit",
+      toFormat: "multi-kit"
+    };
+  }
+  if (detection.format === "none") {
+    return {
+      success: true,
+      migrated: false,
+      fromFormat: "none",
+      toFormat: "multi-kit"
+    };
+  }
+  const metadataPath = join16(claudeDir, "metadata.json");
+  const legacy = detection.metadata;
+  if (!legacy) {
+    return {
+      success: false,
+      migrated: false,
+      fromFormat: "legacy",
+      toFormat: "multi-kit",
+      error: "Metadata exists but could not be read"
+    };
+  }
+  const legacyKit = detection.detectedKit || "engineer";
+  try {
+    const kitMetadata = {
+      version: legacy.version || "unknown",
+      installedAt: legacy.installedAt || new Date().toISOString(),
+      files: legacy.files || []
+    };
+    const multiKit = {
+      kits: {
+        [legacyKit]: kitMetadata
+      },
+      scope: legacy.scope,
+      name: legacy.name,
+      version: legacy.version,
+      installedAt: legacy.installedAt,
+      installedFiles: legacy.installedFiles,
+      userConfigFiles: legacy.userConfigFiles,
+      files: legacy.files
+    };
+    await import_fs_extra7.writeFile(metadataPath, JSON.stringify(multiKit, null, 2), "utf-8");
+    logger.info(`Migrated metadata from legacy format to multi-kit (detected: ${legacyKit})`);
+    return {
+      success: true,
+      migrated: true,
+      fromFormat: "legacy",
+      toFormat: "multi-kit"
+    };
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : "Unknown error";
+    logger.error(`Metadata migration failed: ${errorMsg}`);
+    return {
+      success: false,
+      migrated: false,
+      fromFormat: "legacy",
+      toFormat: "multi-kit",
+      error: errorMsg
+    };
+  }
+}
+function getKitMetadata(metadata, kit) {
+  if (metadata.kits?.[kit]) {
+    return metadata.kits[kit];
+  }
+  if (!metadata.kits && metadata.version) {
+    return {
+      version: metadata.version,
+      installedAt: metadata.installedAt || "",
+      files: metadata.files
+    };
+  }
+  return null;
+}
+function getAllTrackedFiles(metadata) {
+  if (metadata.kits) {
+    const allFiles = [];
+    for (const kit of Object.values(metadata.kits)) {
+      if (kit.files) {
+        allFiles.push(...kit.files);
+      }
+    }
+    return allFiles;
+  }
+  return metadata.files || [];
+}
+function getInstalledKits(metadata) {
+  if (metadata.kits) {
+    return Object.keys(metadata.kits);
+  }
+  const nameToCheck = metadata.name || "";
+  if (/\bengineer\b/i.test(nameToCheck)) {
+    return ["engineer"];
+  }
+  if (/\bmarketing\b/i.test(nameToCheck)) {
+    return ["marketing"];
+  }
+  if (metadata.version) {
+    return ["engineer"];
+  }
+  return [];
+}
+
+// src/services/file-operations/manifest-writer.ts
+init_logger();
+init_types2();
+var import_fs_extra8 = __toESM(require_lib(), 1);
 
 // node_modules/yocto-queue/index.js
 class Node2 {
@@ -29880,66 +30938,8 @@ function validateConcurrency(concurrency) {
   }
 }
 
-// src/services/file-operations/ownership-checker.ts
-import { createHash } from "node:crypto";
-import { createReadStream } from "node:fs";
-import { stat } from "node:fs/promises";
-import { relative as relative3 } from "node:path";
-
-class OwnershipChecker {
-  static async calculateChecksum(filePath) {
-    return new Promise((resolve3, reject) => {
-      const hash = createHash("sha256");
-      const stream = createReadStream(filePath);
-      stream.on("data", (chunk) => hash.update(chunk));
-      stream.on("end", () => {
-        resolve3(hash.digest("hex"));
-      });
-      stream.on("error", (err) => {
-        stream.destroy();
-        reject(new Error(`Failed to calculate checksum for "${filePath}": ${err.message}`));
-      });
-    });
-  }
-  static async checkOwnership(filePath, metadata, claudeDir) {
-    try {
-      await stat(filePath);
-    } catch {
-      return { path: filePath, ownership: "user", exists: false };
-    }
-    if (!metadata || !metadata.files || metadata.files.length === 0) {
-      return { path: filePath, ownership: "user", exists: true };
-    }
-    const relativePath = relative3(claudeDir, filePath).replace(/\\/g, "/");
-    const tracked = metadata.files.find((f3) => f3.path === relativePath);
-    if (!tracked) {
-      return { path: filePath, ownership: "user", exists: true };
-    }
-    const actualChecksum = await OwnershipChecker.calculateChecksum(filePath);
-    if (actualChecksum === tracked.checksum) {
-      return {
-        path: filePath,
-        ownership: "ck",
-        expectedChecksum: tracked.checksum,
-        actualChecksum,
-        exists: true
-      };
-    }
-    return {
-      path: filePath,
-      ownership: "ck-modified",
-      expectedChecksum: tracked.checksum,
-      actualChecksum,
-      exists: true
-    };
-  }
-  static async checkBatch(filePaths, metadata, claudeDir) {
-    const results = await Promise.all(filePaths.map((path9) => OwnershipChecker.checkOwnership(path9, metadata, claudeDir)));
-    return new Map(results.map((r2) => [r2.path, r2]));
-  }
-}
-
 // src/services/file-operations/manifest-writer.ts
+var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
 class ManifestWriter {
   installedFiles = new Set;
   userConfigFiles = new Set;
@@ -29995,13 +30995,16 @@ class ManifestWriter {
         return false;
       }
     }));
-    let completed = 0;
     const progressInterval = Math.max(1, Math.floor(total / 20));
-    const results = await Promise.all(tasks.map(async (task) => {
+    let reportedProgress = 0;
+    const results = await Promise.all(tasks.map(async (task, index) => {
       const result = await task;
-      completed++;
+      const completed = index + 1;
       if (completed % progressInterval === 0 || completed === total) {
-        onProgress?.(completed, total);
+        if (completed > reportedProgress) {
+          reportedProgress = completed;
+          onProgress?.(completed, total);
+        }
       }
       return result;
     }));
@@ -30015,39 +31018,70 @@ class ManifestWriter {
   getTrackedFiles() {
     return Array.from(this.trackedFiles.values()).sort((a3, b3) => a3.path.localeCompare(b3.path));
   }
-  async writeManifest(claudeDir, kitName, version, scope) {
-    const metadataPath = join16(claudeDir, "metadata.json");
-    let existingMetadata = {};
-    if (await import_fs_extra7.pathExists(metadataPath)) {
-      try {
-        const content = await import_fs_extra7.readFile(metadataPath, "utf-8");
-        existingMetadata = JSON.parse(content);
-      } catch (error) {
-        logger.debug(`Could not read existing metadata: ${error}`);
+  async writeManifest(claudeDir, kitName, version, scope, kitType) {
+    const metadataPath = join17(claudeDir, "metadata.json");
+    const kit = kitType || (/\bmarketing\b/i.test(kitName) ? "marketing" : "engineer");
+    await import_fs_extra8.ensureFile(metadataPath);
+    let release = null;
+    try {
+      release = await import_proper_lockfile.lock(metadataPath, {
+        retries: { retries: 5, minTimeout: 100, maxTimeout: 1000 },
+        stale: 60000
+      });
+      logger.debug(`Acquired lock on ${metadataPath}`);
+      const migrationResult = await migrateToMultiKit(claudeDir);
+      if (!migrationResult.success) {
+        logger.warning(`Metadata migration warning: ${migrationResult.error}`);
+      }
+      let existingMetadata = { kits: {} };
+      if (await import_fs_extra8.pathExists(metadataPath)) {
+        try {
+          const content = await import_fs_extra8.readFile(metadataPath, "utf-8");
+          const parsed = JSON.parse(content);
+          if (parsed && typeof parsed === "object" && Object.keys(parsed).length > 0) {
+            existingMetadata = parsed;
+          }
+        } catch (error) {
+          logger.debug(`Could not read existing metadata: ${error}`);
+        }
+      }
+      const trackedFiles = this.getTrackedFiles();
+      const installedAt = new Date().toISOString();
+      const kitMetadata = {
+        version,
+        installedAt,
+        files: trackedFiles.length > 0 ? trackedFiles : undefined
+      };
+      const metadata = {
+        kits: {
+          ...existingMetadata.kits,
+          [kit]: kitMetadata
+        },
+        scope,
+        name: kitName,
+        version,
+        installedAt,
+        installedFiles: this.getInstalledFiles(),
+        userConfigFiles: [...USER_CONFIG_PATTERNS, ...this.getUserConfigFiles()],
+        files: trackedFiles.length > 0 ? trackedFiles : undefined
+      };
+      const validated = MetadataSchema.parse(metadata);
+      await import_fs_extra8.writeFile(metadataPath, JSON.stringify(validated, null, 2), "utf-8");
+      logger.debug(`Wrote manifest for kit "${kit}" with ${trackedFiles.length} tracked files`);
+    } finally {
+      if (release) {
+        await release();
+        logger.debug(`Released lock on ${metadataPath}`);
       }
     }
-    const trackedFiles = this.getTrackedFiles();
-    const metadata = {
-      ...existingMetadata,
-      name: kitName,
-      version,
-      installedAt: new Date().toISOString(),
-      scope,
-      installedFiles: this.getInstalledFiles(),
-      userConfigFiles: [...USER_CONFIG_PATTERNS, ...this.getUserConfigFiles()],
-      files: trackedFiles.length > 0 ? trackedFiles : undefined
-    };
-    const validated = MetadataSchema.parse(metadata);
-    await import_fs_extra7.writeFile(metadataPath, JSON.stringify(validated, null, 2), "utf-8");
-    logger.debug(`Wrote manifest with ${this.installedFiles.size} installed files, ${trackedFiles.length} tracked`);
   }
   static async readManifest(claudeDir) {
-    const metadataPath = join16(claudeDir, "metadata.json");
-    if (!await import_fs_extra7.pathExists(metadataPath)) {
+    const metadataPath = join17(claudeDir, "metadata.json");
+    if (!await import_fs_extra8.pathExists(metadataPath)) {
       return null;
     }
     try {
-      const content = await import_fs_extra7.readFile(metadataPath, "utf-8");
+      const content = await import_fs_extra8.readFile(metadataPath, "utf-8");
       const parsed = JSON.parse(content);
       return MetadataSchema.parse(parsed);
     } catch (error) {
@@ -30055,13 +31089,82 @@ class ManifestWriter {
       return null;
     }
   }
-  static async getUninstallManifest(claudeDir) {
+  static async readKitManifest(claudeDir, kit) {
     const metadata = await ManifestWriter.readManifest(claudeDir);
-    if (metadata?.installedFiles && metadata.installedFiles.length > 0) {
+    if (!metadata)
+      return null;
+    return getKitMetadata(metadata, kit);
+  }
+  static async 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: metadata.installedFiles,
-        filesToPreserve: metadata.userConfigFiles || USER_CONFIG_PATTERNS,
-        hasManifest: true
+        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"];
@@ -30069,20 +31172,55 @@ class ManifestWriter {
     return {
       filesToRemove: [...legacyDirs, ...legacyFiles],
       filesToPreserve: USER_CONFIG_PATTERNS,
-      hasManifest: false
+      hasManifest: false,
+      isMultiKit: false,
+      remainingKits: []
     };
   }
+  static async removeKitFromManifest(claudeDir, kit) {
+    const metadataPath = join17(claudeDir, "metadata.json");
+    if (!await import_fs_extra8.pathExists(metadataPath))
+      return false;
+    let release = null;
+    try {
+      release = await import_proper_lockfile.lock(metadataPath, {
+        retries: { retries: 5, minTimeout: 100, maxTimeout: 1000 },
+        stale: 60000
+      });
+      logger.debug(`Acquired lock on ${metadataPath} for kit removal`);
+      const metadata = await ManifestWriter.readManifest(claudeDir);
+      if (!metadata?.kits?.[kit])
+        return false;
+      const { [kit]: _removed, ...remainingKits } = metadata.kits;
+      if (Object.keys(remainingKits).length === 0) {
+        logger.debug("No kits remaining, metadata.json will be cleaned up");
+        return true;
+      }
+      const updated = {
+        ...metadata,
+        kits: remainingKits
+      };
+      await import_fs_extra8.writeFile(metadataPath, JSON.stringify(updated, null, 2), "utf-8");
+      logger.debug(`Removed kit "${kit}" from metadata, ${Object.keys(remainingKits).length} kit(s) remaining`);
+      return true;
+    } finally {
+      if (release) {
+        await release();
+        logger.debug(`Released lock on ${metadataPath}`);
+      }
+    }
+  }
 }
 
 // src/domains/migration/legacy-migration.ts
 init_logger();
-var import_fs_extra9 = __toESM(require_lib(), 1);
+var import_fs_extra10 = __toESM(require_lib(), 1);
 
 // src/domains/migration/release-manifest.ts
 init_logger();
 init_zod();
-var import_fs_extra8 = __toESM(require_lib(), 1);
-import { join as join17 } from "node:path";
+var import_fs_extra9 = __toESM(require_lib(), 1);
+import { join as join18 } from "node:path";
 var ReleaseManifestFileSchema = exports_external.object({
   path: exports_external.string(),
   checksum: exports_external.string().regex(/^[a-f0-9]{64}$/),
@@ -30096,9 +31234,9 @@ var ReleaseManifestSchema = exports_external.object({
 
 class ReleaseManifestLoader {
   static async load(extractDir) {
-    const manifestPath = join17(extractDir, "release-manifest.json");
+    const manifestPath = join18(extractDir, "release-manifest.json");
     try {
-      const content = await import_fs_extra8.readFile(manifestPath, "utf-8");
+      const content = await import_fs_extra9.readFile(manifestPath, "utf-8");
       const parsed = JSON.parse(content);
       return ReleaseManifestSchema.parse(parsed);
     } catch (error) {
@@ -30142,10 +31280,10 @@ class LegacyMigration {
     for (const entry of entries) {
       if (entry === "metadata.json")
         continue;
-      const fullPath = join18(dir, entry);
+      const fullPath = join19(dir, entry);
       let stats;
       try {
-        stats = await stat2(fullPath);
+        stats = await stat3(fullPath);
       } catch (err) {
         const error = err;
         if (error.code === "ENOENT") {
@@ -30244,7 +31382,7 @@ User-created files (sample):`);
     ];
     if (filesToChecksum.length > 0) {
       const checksumResults = await Promise.all(filesToChecksum.map(async ({ relativePath, ownership }) => {
-        const fullPath = join18(claudeDir, relativePath);
+        const fullPath = join19(claudeDir, relativePath);
         const checksum = await OwnershipChecker.calculateChecksum(fullPath);
         return { relativePath, checksum, ownership };
       }));
@@ -30265,8 +31403,8 @@ User-created files (sample):`);
       installedAt: new Date().toISOString(),
       files: trackedFiles
     };
-    const metadataPath = join18(claudeDir, "metadata.json");
-    await import_fs_extra9.writeFile(metadataPath, JSON.stringify(updatedMetadata, null, 2));
+    const metadataPath = join19(claudeDir, "metadata.json");
+    await import_fs_extra10.writeFile(metadataPath, JSON.stringify(updatedMetadata, null, 2));
     logger.success(`Migration complete: tracked ${trackedFiles.length} files`);
     return true;
   }
@@ -30274,24 +31412,24 @@ User-created files (sample):`);
 
 // src/domains/skills/skills-detector.ts
 init_logger();
-var import_fs_extra11 = __toESM(require_lib(), 1);
+var import_fs_extra12 = __toESM(require_lib(), 1);
 import { readdir as readdir6 } from "node:fs/promises";
-import { join as join20 } from "node:path";
+import { join as join21 } from "node:path";
 
 // src/domains/skills/skills-manifest.ts
 init_logger();
 init_types2();
-var import_fs_extra10 = __toESM(require_lib(), 1);
+var import_fs_extra11 = __toESM(require_lib(), 1);
 import { createHash as createHash2 } from "node:crypto";
-import { readFile as readFile12, readdir as readdir5, writeFile as writeFile11 } from "node:fs/promises";
-import { join as join19, relative as relative5 } from "node:path";
+import { readFile as readFile13, readdir as readdir5, writeFile as writeFile12 } from "node:fs/promises";
+import { join as join20, relative as relative5 } from "node:path";
 
 class SkillsManifestManager {
   static MANIFEST_FILENAME = ".skills-manifest.json";
   static MANIFEST_VERSION = "1.0.0";
   static async generateManifest(skillsDir) {
     logger.debug(`Generating manifest for: ${skillsDir}`);
-    if (!await import_fs_extra10.pathExists(skillsDir)) {
+    if (!await import_fs_extra11.pathExists(skillsDir)) {
       throw new SkillsMigrationError(`Skills directory does not exist: ${skillsDir}`);
     }
     const structure = await SkillsManifestManager.detectStructure(skillsDir);
@@ -30306,18 +31444,18 @@ class SkillsManifestManager {
     return manifest;
   }
   static async writeManifest(skillsDir, manifest) {
-    const manifestPath = join19(skillsDir, SkillsManifestManager.MANIFEST_FILENAME);
-    await writeFile11(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
+    const manifestPath = join20(skillsDir, SkillsManifestManager.MANIFEST_FILENAME);
+    await writeFile12(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
     logger.debug(`Wrote manifest to: ${manifestPath}`);
   }
   static async readManifest(skillsDir) {
-    const manifestPath = join19(skillsDir, SkillsManifestManager.MANIFEST_FILENAME);
-    if (!await import_fs_extra10.pathExists(manifestPath)) {
+    const manifestPath = join20(skillsDir, SkillsManifestManager.MANIFEST_FILENAME);
+    if (!await import_fs_extra11.pathExists(manifestPath)) {
       logger.debug(`No manifest found at: ${manifestPath}`);
       return null;
     }
     try {
-      const content = await readFile12(manifestPath, "utf-8");
+      const content = await readFile13(manifestPath, "utf-8");
       const data = JSON.parse(content);
       const manifest = SkillsManifestSchema.parse(data);
       logger.debug(`Read manifest from: ${manifestPath}`);
@@ -30334,7 +31472,7 @@ class SkillsManifestManager {
       return "flat";
     }
     for (const dir of dirs.slice(0, 3)) {
-      const dirPath = join19(skillsDir, dir.name);
+      const dirPath = join20(skillsDir, dir.name);
       const subEntries = await readdir5(dirPath, { withFileTypes: true });
       const hasSubdirs = subEntries.some((entry) => entry.isDirectory());
       if (hasSubdirs) {
@@ -30353,7 +31491,7 @@ class SkillsManifestManager {
       const entries = await readdir5(skillsDir, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isDirectory() && entry.name !== "node_modules" && !entry.name.startsWith(".")) {
-          const skillPath = join19(skillsDir, entry.name);
+          const skillPath = join20(skillsDir, entry.name);
           const hash = await SkillsManifestManager.hashDirectory(skillPath);
           skills.push({
             name: entry.name,
@@ -30365,11 +31503,11 @@ class SkillsManifestManager {
       const categories = await readdir5(skillsDir, { withFileTypes: true });
       for (const category of categories) {
         if (category.isDirectory() && category.name !== "node_modules" && !category.name.startsWith(".")) {
-          const categoryPath = join19(skillsDir, category.name);
+          const categoryPath = join20(skillsDir, category.name);
           const skillEntries = await readdir5(categoryPath, { withFileTypes: true });
           for (const skillEntry of skillEntries) {
             if (skillEntry.isDirectory() && !skillEntry.name.startsWith(".")) {
-              const skillPath = join19(categoryPath, skillEntry.name);
+              const skillPath = join20(categoryPath, skillEntry.name);
               const hash = await SkillsManifestManager.hashDirectory(skillPath);
               skills.push({
                 name: skillEntry.name,
@@ -30389,7 +31527,7 @@ class SkillsManifestManager {
     files.sort();
     for (const file of files) {
       const relativePath = relative5(dirPath, file);
-      const content = await readFile12(file);
+      const content = await readFile13(file);
       hash.update(relativePath);
       hash.update(content);
     }
@@ -30399,7 +31537,7 @@ class SkillsManifestManager {
     const files = [];
     const entries = await readdir5(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join19(dirPath, entry.name);
+      const fullPath = join20(dirPath, entry.name);
       if (entry.name.startsWith(".") || entry.name === "node_modules") {
         continue;
       }
@@ -30519,8 +31657,8 @@ function getPathMapping(skillName, oldBasePath, newBasePath) {
 class SkillsMigrationDetector {
   static async detectMigration(oldSkillsDir, currentSkillsDir) {
     logger.debug("Detecting skills migration need...");
-    const oldExists = await import_fs_extra11.pathExists(oldSkillsDir);
-    const currentExists = await import_fs_extra11.pathExists(currentSkillsDir);
+    const oldExists = await import_fs_extra12.pathExists(oldSkillsDir);
+    const currentExists = await import_fs_extra12.pathExists(currentSkillsDir);
     if (!oldExists && !currentExists) {
       logger.debug("No skills directories found, migration not needed");
       return {
@@ -30631,7 +31769,7 @@ class SkillsMigrationDetector {
     };
   }
   static async scanDirectory(skillsDir) {
-    if (!await import_fs_extra11.pathExists(skillsDir)) {
+    if (!await import_fs_extra12.pathExists(skillsDir)) {
       return ["flat", []];
     }
     const entries = await readdir6(skillsDir, { withFileTypes: true });
@@ -30642,12 +31780,12 @@ class SkillsMigrationDetector {
     let totalSkillLikeCount = 0;
     const allSkills = [];
     for (const dir of dirs) {
-      const dirPath = join20(skillsDir, dir.name);
+      const dirPath = join21(skillsDir, dir.name);
       const subEntries = await readdir6(dirPath, { withFileTypes: true });
       const subdirs = subEntries.filter((entry) => entry.isDirectory() && !entry.name.startsWith("."));
       if (subdirs.length > 0) {
         for (const subdir of subdirs.slice(0, 3)) {
-          const subdirPath = join20(dirPath, subdir.name);
+          const subdirPath = join21(dirPath, subdir.name);
           const subdirFiles = await readdir6(subdirPath, { withFileTypes: true });
           const hasSkillMarker = subdirFiles.some((file) => file.isFile() && (file.name === "skill.md" || file.name === "README.md" || file.name === "readme.md" || file.name === "config.json" || file.name === "package.json"));
           if (hasSkillMarker) {
@@ -30684,16 +31822,16 @@ class SkillsMigrationDetector {
 // src/domains/skills/skills-migrator.ts
 init_logger();
 init_types2();
-var import_fs_extra14 = __toESM(require_lib(), 1);
+var import_fs_extra15 = __toESM(require_lib(), 1);
 import { copyFile as copyFile2, mkdir as mkdir8, readdir as readdir9, rm as rm3 } from "node:fs/promises";
-import { join as join23 } from "node:path";
+import { join as join24 } from "node:path";
 
 // src/domains/skills/skills-backup-manager.ts
 init_logger();
 init_types2();
-var import_fs_extra12 = __toESM(require_lib(), 1);
-import { copyFile, mkdir as mkdir7, readdir as readdir7, rm as rm2, stat as stat3 } from "node:fs/promises";
-import { basename as basename2, join as join21, normalize as normalize4 } from "node:path";
+var import_fs_extra13 = __toESM(require_lib(), 1);
+import { copyFile, mkdir as mkdir7, readdir as readdir7, rm as rm2, stat as stat4 } from "node:fs/promises";
+import { basename as basename2, join as join22, normalize as normalize4 } from "node:path";
 function validatePath(path9, paramName) {
   if (!path9 || typeof path9 !== "string") {
     throw new SkillsMigrationError(`${paramName} must be a non-empty string`);
@@ -30713,13 +31851,13 @@ class SkillsBackupManager {
     if (parentDir) {
       validatePath(parentDir, "parentDir");
     }
-    if (!await import_fs_extra12.pathExists(skillsDir)) {
+    if (!await import_fs_extra13.pathExists(skillsDir)) {
       throw new SkillsMigrationError(`Cannot create backup: Skills directory does not exist: ${skillsDir}`);
     }
     const timestamp = Date.now();
     const randomSuffix = Math.random().toString(36).substring(2, 8);
     const backupDirName = `${SkillsBackupManager.BACKUP_PREFIX}${timestamp}-${randomSuffix}`;
-    const backupDir = parentDir ? join21(parentDir, backupDirName) : join21(skillsDir, "..", backupDirName);
+    const backupDir = parentDir ? join22(parentDir, backupDirName) : join22(skillsDir, "..", backupDirName);
     logger.info(`Creating backup at: ${backupDir}`);
     try {
       await mkdir7(backupDir, { recursive: true });
@@ -30736,12 +31874,12 @@ class SkillsBackupManager {
   static async restoreBackup(backupDir, targetDir) {
     validatePath(backupDir, "backupDir");
     validatePath(targetDir, "targetDir");
-    if (!await import_fs_extra12.pathExists(backupDir)) {
+    if (!await import_fs_extra13.pathExists(backupDir)) {
       throw new SkillsMigrationError(`Cannot restore: Backup directory does not exist: ${backupDir}`);
     }
     logger.info(`Restoring from backup: ${backupDir}`);
     try {
-      if (await import_fs_extra12.pathExists(targetDir)) {
+      if (await import_fs_extra13.pathExists(targetDir)) {
         await rm2(targetDir, { recursive: true, force: true });
       }
       await mkdir7(targetDir, { recursive: true });
@@ -30752,7 +31890,7 @@ class SkillsBackupManager {
     }
   }
   static async deleteBackup(backupDir) {
-    if (!await import_fs_extra12.pathExists(backupDir)) {
+    if (!await import_fs_extra13.pathExists(backupDir)) {
       logger.warning(`Backup directory does not exist: ${backupDir}`);
       return;
     }
@@ -30765,12 +31903,12 @@ class SkillsBackupManager {
     }
   }
   static async listBackups(parentDir) {
-    if (!await import_fs_extra12.pathExists(parentDir)) {
+    if (!await import_fs_extra13.pathExists(parentDir)) {
       return [];
     }
     try {
       const entries = await readdir7(parentDir, { withFileTypes: true });
-      const backups = entries.filter((entry) => entry.isDirectory() && entry.name.startsWith(SkillsBackupManager.BACKUP_PREFIX)).map((entry) => join21(parentDir, entry.name));
+      const backups = entries.filter((entry) => entry.isDirectory() && entry.name.startsWith(SkillsBackupManager.BACKUP_PREFIX)).map((entry) => join22(parentDir, entry.name));
       backups.sort().reverse();
       return backups;
     } catch (error) {
@@ -30790,7 +31928,7 @@ class SkillsBackupManager {
     }
   }
   static async getBackupSize(backupDir) {
-    if (!await import_fs_extra12.pathExists(backupDir)) {
+    if (!await import_fs_extra13.pathExists(backupDir)) {
       return 0;
     }
     return await SkillsBackupManager.getDirectorySize(backupDir);
@@ -30798,8 +31936,8 @@ class SkillsBackupManager {
   static async copyDirectory(sourceDir, destDir) {
     const entries = await readdir7(sourceDir, { withFileTypes: true });
     for (const entry of entries) {
-      const sourcePath = join21(sourceDir, entry.name);
-      const destPath = join21(destDir, entry.name);
+      const sourcePath = join22(sourceDir, entry.name);
+      const destPath = join22(destDir, entry.name);
       if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.isSymbolicLink()) {
         continue;
       }
@@ -30815,14 +31953,14 @@ class SkillsBackupManager {
     let size = 0;
     const entries = await readdir7(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join21(dirPath, entry.name);
+      const fullPath = join22(dirPath, entry.name);
       if (entry.isSymbolicLink()) {
         continue;
       }
       if (entry.isDirectory()) {
         size += await SkillsBackupManager.getDirectorySize(fullPath);
       } else if (entry.isFile()) {
-        const stats = await stat3(fullPath);
+        const stats = await stat4(fullPath);
         size += stats.size;
       }
     }
@@ -30842,11 +31980,11 @@ class SkillsBackupManager {
 // src/domains/skills/skills-customization-scanner.ts
 init_logger();
 init_types2();
-var import_fs_extra13 = __toESM(require_lib(), 1);
+var import_fs_extra14 = __toESM(require_lib(), 1);
 import { createHash as createHash3 } from "node:crypto";
 import { createReadStream as createReadStream2 } from "node:fs";
-import { readFile as readFile13, readdir as readdir8 } from "node:fs/promises";
-import { join as join22, normalize as normalize5, relative as relative6 } from "node:path";
+import { readFile as readFile14, readdir as readdir8 } from "node:fs/promises";
+import { join as join23, normalize as normalize5, relative as relative6 } from "node:path";
 function validatePath2(path9, paramName) {
   if (!path9 || typeof path9 !== "string") {
     throw new SkillsMigrationError(`${paramName} must be a non-empty string`);
@@ -30925,7 +32063,7 @@ class SkillsCustomizationScanner {
   static async detectFileChanges(currentSkillPath, baselineSkillPath) {
     const changes = [];
     const currentFiles = await SkillsCustomizationScanner.getAllFiles(currentSkillPath);
-    const baselineFiles = await import_fs_extra13.pathExists(baselineSkillPath) ? await SkillsCustomizationScanner.getAllFiles(baselineSkillPath) : [];
+    const baselineFiles = await import_fs_extra14.pathExists(baselineSkillPath) ? await SkillsCustomizationScanner.getAllFiles(baselineSkillPath) : [];
     const currentFileMap = new Map(await Promise.all(currentFiles.map(async (f3) => {
       const relPath = relative6(currentSkillPath, f3);
       const hash = await SkillsCustomizationScanner.hashFile(f3);
@@ -30985,7 +32123,7 @@ class SkillsCustomizationScanner {
     return false;
   }
   static async scanSkillsDirectory(skillsDir) {
-    if (!await import_fs_extra13.pathExists(skillsDir)) {
+    if (!await import_fs_extra14.pathExists(skillsDir)) {
       return ["flat", []];
     }
     const entries = await readdir8(skillsDir, { withFileTypes: true });
@@ -30993,13 +32131,13 @@ class SkillsCustomizationScanner {
     if (dirs.length === 0) {
       return ["flat", []];
     }
-    const firstDirPath = join22(skillsDir, dirs[0].name);
+    const firstDirPath = join23(skillsDir, dirs[0].name);
     const subEntries = await readdir8(firstDirPath, { withFileTypes: true });
     const subdirs = subEntries.filter((entry) => entry.isDirectory() && !entry.name.startsWith("."));
     if (subdirs.length > 0) {
       let skillLikeCount = 0;
       for (const subdir of subdirs.slice(0, 3)) {
-        const subdirPath = join22(firstDirPath, subdir.name);
+        const subdirPath = join23(firstDirPath, subdir.name);
         const subdirFiles = await readdir8(subdirPath, { withFileTypes: true });
         const hasSkillMarker = subdirFiles.some((file) => file.isFile() && (file.name === "skill.md" || file.name === "README.md" || file.name === "readme.md" || file.name === "config.json" || file.name === "package.json"));
         if (hasSkillMarker) {
@@ -31009,7 +32147,7 @@ class SkillsCustomizationScanner {
       if (skillLikeCount > 0) {
         const skills = [];
         for (const dir of dirs) {
-          const categoryPath = join22(skillsDir, dir.name);
+          const categoryPath = join23(skillsDir, dir.name);
           const skillDirs = await readdir8(categoryPath, { withFileTypes: true });
           skills.push(...skillDirs.filter((entry) => entry.isDirectory() && !entry.name.startsWith(".")).map((entry) => entry.name));
         }
@@ -31019,8 +32157,8 @@ class SkillsCustomizationScanner {
     return ["flat", dirs.map((dir) => dir.name)];
   }
   static async findSkillPath(skillsDir, skillName) {
-    const flatPath = join22(skillsDir, skillName);
-    if (await import_fs_extra13.pathExists(flatPath)) {
+    const flatPath = join23(skillsDir, skillName);
+    if (await import_fs_extra14.pathExists(flatPath)) {
       return { path: flatPath, category: undefined };
     }
     const entries = await readdir8(skillsDir, { withFileTypes: true });
@@ -31028,9 +32166,9 @@ class SkillsCustomizationScanner {
       if (!entry.isDirectory() || entry.name.startsWith(".") || entry.name === "node_modules") {
         continue;
       }
-      const categoryPath = join22(skillsDir, entry.name);
-      const skillPath = join22(categoryPath, skillName);
-      if (await import_fs_extra13.pathExists(skillPath)) {
+      const categoryPath = join23(skillsDir, entry.name);
+      const skillPath = join23(categoryPath, skillName);
+      if (await import_fs_extra14.pathExists(skillPath)) {
         return { path: skillPath, category: entry.name };
       }
     }
@@ -31040,7 +32178,7 @@ class SkillsCustomizationScanner {
     const files = [];
     const entries = await readdir8(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join22(dirPath, entry.name);
+      const fullPath = join23(dirPath, entry.name);
       if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.isSymbolicLink()) {
         continue;
       }
@@ -31073,7 +32211,7 @@ class SkillsCustomizationScanner {
     files.sort();
     for (const file of files) {
       const relativePath = relative6(dirPath, file);
-      const content = await readFile13(file);
+      const content = await readFile14(file);
       hash.update(relativePath);
       hash.update(content);
     }
@@ -31283,7 +32421,7 @@ class SkillsMigrator {
         }
       }
       if (options.backup && !options.dryRun) {
-        const claudeDir = join23(currentSkillsDir, "..");
+        const claudeDir = join24(currentSkillsDir, "..");
         result.backupPath = await SkillsBackupManager.createBackup(currentSkillsDir, claudeDir);
         logger.success(`Backup created at: ${result.backupPath}`);
       }
@@ -31335,14 +32473,14 @@ class SkillsMigrator {
     const migrated = [];
     const preserved = [];
     const errors2 = [];
-    const tempDir = join23(currentSkillsDir, "..", ".skills-migration-temp");
+    const tempDir = join24(currentSkillsDir, "..", ".skills-migration-temp");
     await mkdir8(tempDir, { recursive: true });
     try {
       for (const mapping of mappings) {
         try {
           const skillName = mapping.skillName;
           const currentSkillPath = mapping.oldPath;
-          if (!await import_fs_extra14.pathExists(currentSkillPath)) {
+          if (!await import_fs_extra15.pathExists(currentSkillPath)) {
             logger.warning(`Skill not found, skipping: ${skillName}`);
             continue;
           }
@@ -31356,9 +32494,9 @@ class SkillsMigrator {
             }
           }
           const category = mapping.category;
-          const targetPath = category ? join23(tempDir, category, skillName) : join23(tempDir, skillName);
+          const targetPath = category ? join24(tempDir, category, skillName) : join24(tempDir, skillName);
           if (category) {
-            await mkdir8(join23(tempDir, category), { recursive: true });
+            await mkdir8(join24(tempDir, category), { recursive: true });
           }
           await SkillsMigrator.copySkillDirectory(currentSkillPath, targetPath);
           migrated.push(skillName);
@@ -31392,8 +32530,8 @@ class SkillsMigrator {
     await mkdir8(destDir, { recursive: true });
     const entries = await readdir9(sourceDir, { withFileTypes: true });
     for (const entry of entries) {
-      const sourcePath = join23(sourceDir, entry.name);
-      const destPath = join23(destDir, entry.name);
+      const sourcePath = join24(sourceDir, entry.name);
+      const destPath = join24(destDir, entry.name);
       if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.isSymbolicLink()) {
         continue;
       }
@@ -31981,31 +33119,31 @@ class PromptsManager {
 
 // src/services/file-operations/file-scanner.ts
 init_logger();
-import { join as join27, relative as relative7, resolve as resolve5 } from "node:path";
-var import_fs_extra15 = __toESM(require_lib(), 1);
+import { join as join28, relative as relative7, resolve as resolve5 } from "node:path";
+var import_fs_extra16 = __toESM(require_lib(), 1);
 
 class FileScanner {
   static async getFiles(dirPath, relativeTo) {
     const basePath = relativeTo || dirPath;
     const files = [];
-    if (!await import_fs_extra15.pathExists(dirPath)) {
+    if (!await import_fs_extra16.pathExists(dirPath)) {
       return files;
     }
     try {
-      const entries = await import_fs_extra15.readdir(dirPath, { encoding: "utf8" });
+      const entries = await import_fs_extra16.readdir(dirPath, { encoding: "utf8" });
       for (const entry of entries) {
         if (SKIP_DIRS_ALL.includes(entry)) {
           logger.debug(`Skipping directory: ${entry}`);
           continue;
         }
-        const fullPath = join27(dirPath, entry);
+        const fullPath = join28(dirPath, entry);
         if (!FileScanner.isSafePath(basePath, fullPath)) {
           logger.warning(`Skipping potentially unsafe path: ${entry}`);
           continue;
         }
         let stats;
         try {
-          stats = await import_fs_extra15.lstat(fullPath);
+          stats = await import_fs_extra16.lstat(fullPath);
         } catch (error) {
           if (error instanceof Error && "code" in error && (error.code === "EACCES" || error.code === "EPERM")) {
             logger.warning(`Skipping inaccessible path: ${entry}`);
@@ -32033,8 +33171,8 @@ class FileScanner {
     return files;
   }
   static async findCustomFiles(destDir, sourceDir, subPath) {
-    const destSubDir = join27(destDir, subPath);
-    const sourceSubDir = join27(sourceDir, subPath);
+    const destSubDir = join28(destDir, subPath);
+    const sourceSubDir = join28(sourceDir, subPath);
     logger.debug(`findCustomFiles - destDir: ${destDir}`);
     logger.debug(`findCustomFiles - sourceDir: ${sourceDir}`);
     logger.debug(`findCustomFiles - subPath: "${subPath}"`);
@@ -32044,7 +33182,7 @@ class FileScanner {
     const sourceFiles = await FileScanner.getFiles(sourceSubDir, sourceDir);
     logger.debug(`findCustomFiles - destFiles count: ${destFiles.length}`);
     logger.debug(`findCustomFiles - sourceFiles count: ${sourceFiles.length}`);
-    const sourceExists = await import_fs_extra15.pathExists(sourceSubDir);
+    const sourceExists = await import_fs_extra16.pathExists(sourceSubDir);
     if (sourceExists && sourceFiles.length === 0 && destFiles.length > 100) {
       logger.warning(`Source directory exists but is empty while destination has ${destFiles.length} files. This may indicate an extraction issue. Skipping custom file detection.`);
       return [];
@@ -32072,10 +33210,10 @@ class FileScanner {
 }
 
 // src/services/transformers/commands-prefix.ts
-import { lstat as lstat3, mkdir as mkdir10, readdir as readdir11, stat as stat4 } from "node:fs/promises";
-import { join as join28 } from "node:path";
+import { lstat as lstat3, mkdir as mkdir10, readdir as readdir11, stat as stat5 } from "node:fs/promises";
+import { join as join29 } from "node:path";
 init_logger();
-var import_fs_extra16 = __toESM(require_lib(), 1);
+var import_fs_extra17 = __toESM(require_lib(), 1);
 function stripWindowsDrivePrefix(path9) {
   if (path9.length >= 2 && /[a-zA-Z]/.test(path9[0]) && path9[1] === ":") {
     return path9.slice(2);
@@ -32114,14 +33252,14 @@ function validatePath4(path9, paramName) {
 class CommandsPrefix {
   static async applyPrefix(extractDir) {
     validatePath4(extractDir, "extractDir");
-    const commandsDir = join28(extractDir, ".claude", "commands");
-    if (!await import_fs_extra16.pathExists(commandsDir)) {
+    const commandsDir = join29(extractDir, ".claude", "commands");
+    if (!await import_fs_extra17.pathExists(commandsDir)) {
       logger.verbose("No commands directory found, skipping prefix application");
       return;
     }
     logger.info("Applying /ck: prefix to slash commands...");
-    const backupDir = join28(extractDir, ".commands-backup");
-    const tempDir = join28(extractDir, ".commands-prefix-temp");
+    const backupDir = join29(extractDir, ".commands-backup");
+    const tempDir = join29(extractDir, ".commands-prefix-temp");
     try {
       const entries = await readdir11(commandsDir);
       if (entries.length === 0) {
@@ -32129,28 +33267,28 @@ class CommandsPrefix {
         return;
       }
       if (entries.length === 1 && entries[0] === "ck") {
-        const ckDir2 = join28(commandsDir, "ck");
-        const ckStat = await stat4(ckDir2);
+        const ckDir2 = join29(commandsDir, "ck");
+        const ckStat = await stat5(ckDir2);
         if (ckStat.isDirectory()) {
           logger.verbose("Commands already have /ck: prefix, skipping");
           return;
         }
       }
-      await import_fs_extra16.copy(commandsDir, backupDir);
+      await import_fs_extra17.copy(commandsDir, backupDir);
       logger.verbose("Created backup of commands directory");
       await mkdir10(tempDir, { recursive: true });
-      const ckDir = join28(tempDir, "ck");
+      const ckDir = join29(tempDir, "ck");
       await mkdir10(ckDir, { recursive: true });
       let processedCount = 0;
       for (const entry of entries) {
-        const sourcePath = join28(commandsDir, entry);
+        const sourcePath = join29(commandsDir, entry);
         const stats = await lstat3(sourcePath);
         if (stats.isSymbolicLink()) {
           logger.warning(`Skipping symlink for security: ${entry}`);
           continue;
         }
-        const destPath = join28(ckDir, entry);
-        await import_fs_extra16.copy(sourcePath, destPath, {
+        const destPath = join29(ckDir, entry);
+        await import_fs_extra17.copy(sourcePath, destPath, {
           overwrite: false,
           errorOnExist: true
         });
@@ -32159,35 +33297,35 @@ class CommandsPrefix {
       }
       if (processedCount === 0) {
         logger.warning("No files to move (all were symlinks or invalid)");
-        await import_fs_extra16.remove(backupDir);
-        await import_fs_extra16.remove(tempDir);
+        await import_fs_extra17.remove(backupDir);
+        await import_fs_extra17.remove(tempDir);
         return;
       }
-      await import_fs_extra16.remove(commandsDir);
-      await import_fs_extra16.move(tempDir, commandsDir);
-      await import_fs_extra16.remove(backupDir);
+      await import_fs_extra17.remove(commandsDir);
+      await import_fs_extra17.move(tempDir, commandsDir);
+      await import_fs_extra17.remove(backupDir);
       logger.success("Successfully applied /ck: prefix to all commands");
     } catch (error) {
-      if (await import_fs_extra16.pathExists(backupDir)) {
+      if (await import_fs_extra17.pathExists(backupDir)) {
         try {
-          await import_fs_extra16.remove(commandsDir).catch(() => {});
-          await import_fs_extra16.move(backupDir, commandsDir);
+          await import_fs_extra17.remove(commandsDir).catch(() => {});
+          await import_fs_extra17.move(backupDir, commandsDir);
           logger.info("Restored original commands directory from backup");
         } catch (rollbackError) {
           logger.error(`Rollback failed: ${rollbackError}`);
         }
       }
-      if (await import_fs_extra16.pathExists(tempDir)) {
-        await import_fs_extra16.remove(tempDir).catch(() => {});
+      if (await import_fs_extra17.pathExists(tempDir)) {
+        await import_fs_extra17.remove(tempDir).catch(() => {});
       }
       logger.error("Failed to apply /ck: prefix to commands");
       throw error;
     } finally {
-      if (await import_fs_extra16.pathExists(backupDir)) {
-        await import_fs_extra16.remove(backupDir).catch(() => {});
+      if (await import_fs_extra17.pathExists(backupDir)) {
+        await import_fs_extra17.remove(backupDir).catch(() => {});
       }
-      if (await import_fs_extra16.pathExists(tempDir)) {
-        await import_fs_extra16.remove(tempDir).catch(() => {});
+      if (await import_fs_extra17.pathExists(tempDir)) {
+        await import_fs_extra17.remove(tempDir).catch(() => {});
       }
     }
   }
@@ -32197,15 +33335,15 @@ class CommandsPrefix {
   static async cleanupCommandsDirectory(targetDir, isGlobal, options = {}) {
     const { dryRun = false, forceOverwrite = false } = options;
     validatePath4(targetDir, "targetDir");
-    const claudeDir = isGlobal ? targetDir : join28(targetDir, ".claude");
-    const commandsDir = join28(claudeDir, "commands");
+    const claudeDir = isGlobal ? targetDir : join29(targetDir, ".claude");
+    const commandsDir = join29(claudeDir, "commands");
     const result = {
       results: [],
       deletedCount: 0,
       preservedCount: 0,
       wasDryRun: dryRun
     };
-    if (!await import_fs_extra16.pathExists(commandsDir)) {
+    if (!await import_fs_extra17.pathExists(commandsDir)) {
       logger.verbose(`Commands directory does not exist: ${commandsDir}`);
       return result;
     }
@@ -32226,7 +33364,7 @@ class CommandsPrefix {
       return result;
     }
     for (const entry of entries) {
-      const entryPath = join28(commandsDir, entry);
+      const entryPath = join29(commandsDir, entry);
       const stats = await lstat3(entryPath);
       if (stats.isSymbolicLink()) {
         logger.warning(`Skipping symlink: ${entry}`);
@@ -32252,7 +33390,7 @@ class CommandsPrefix {
               action: "delete"
             });
             if (!dryRun) {
-              await import_fs_extra16.remove(file);
+              await import_fs_extra17.remove(file);
               logger.verbose(`Deleted CK file: ${relativePath}`);
             }
             result.deletedCount++;
@@ -32265,7 +33403,7 @@ class CommandsPrefix {
                 reason: "force overwrite"
               });
               if (!dryRun) {
-                await import_fs_extra16.remove(file);
+                await import_fs_extra17.remove(file);
                 logger.verbose(`Force-deleted modified file: ${relativePath}`);
               }
               result.deletedCount++;
@@ -32289,7 +33427,7 @@ class CommandsPrefix {
                 reason: "force overwrite"
               });
               if (!dryRun) {
-                await import_fs_extra16.remove(file);
+                await import_fs_extra17.remove(file);
                 logger.verbose(`Force-deleted user file: ${relativePath}`);
               }
               result.deletedCount++;
@@ -32307,7 +33445,7 @@ class CommandsPrefix {
           }
         }
         if (canDeleteDir && !dryRun) {
-          await import_fs_extra16.remove(entryPath);
+          await import_fs_extra17.remove(entryPath);
           logger.verbose(`Removed directory: ${entry}`);
         }
       } else {
@@ -32320,7 +33458,7 @@ class CommandsPrefix {
             action: "delete"
           });
           if (!dryRun) {
-            await import_fs_extra16.remove(entryPath);
+            await import_fs_extra17.remove(entryPath);
             logger.verbose(`Deleted CK file: ${entry}`);
           }
           result.deletedCount++;
@@ -32333,7 +33471,7 @@ class CommandsPrefix {
               reason: "force overwrite"
             });
             if (!dryRun) {
-              await import_fs_extra16.remove(entryPath);
+              await import_fs_extra17.remove(entryPath);
               logger.verbose(`Force-deleted modified file: ${entry}`);
             }
             result.deletedCount++;
@@ -32356,7 +33494,7 @@ class CommandsPrefix {
               reason: "force overwrite"
             });
             if (!dryRun) {
-              await import_fs_extra16.remove(entryPath);
+              await import_fs_extra17.remove(entryPath);
               logger.verbose(`Force-deleted user file: ${entry}`);
             }
             result.deletedCount++;
@@ -32392,7 +33530,7 @@ class CommandsPrefix {
     const files = [];
     const entries = await readdir11(dir);
     for (const entry of entries) {
-      const fullPath = join28(dir, entry);
+      const fullPath = join29(dir, entry);
       const stats = await lstat3(fullPath);
       if (stats.isSymbolicLink()) {
         continue;
@@ -32410,9 +33548,9 @@ class CommandsPrefix {
 // src/services/transformers/folder-path-transformer.ts
 init_logger();
 init_types2();
-var import_fs_extra17 = __toESM(require_lib(), 1);
-import { readFile as readFile15, readdir as readdir12, rename as rename3, writeFile as writeFile13 } from "node:fs/promises";
-import { join as join29, relative as relative8 } from "node:path";
+var import_fs_extra18 = __toESM(require_lib(), 1);
+import { readFile as readFile16, readdir as readdir12, rename as rename3, writeFile as writeFile14 } from "node:fs/promises";
+import { join as join30, relative as relative8 } from "node:path";
 var TRANSFORMABLE_FILE_PATTERNS = [
   ".md",
   ".txt",
@@ -32458,34 +33596,34 @@ async function transformFolderPaths(extractDir, folders, options = {}) {
   }
   const dirsToRename = [];
   if (folders.docs !== DEFAULT_FOLDERS.docs) {
-    const docsPath = join29(extractDir, DEFAULT_FOLDERS.docs);
-    if (await import_fs_extra17.pathExists(docsPath)) {
+    const docsPath = join30(extractDir, DEFAULT_FOLDERS.docs);
+    if (await import_fs_extra18.pathExists(docsPath)) {
       dirsToRename.push({
         from: docsPath,
-        to: join29(extractDir, folders.docs)
+        to: join30(extractDir, folders.docs)
       });
     }
-    const claudeDocsPath = join29(extractDir, ".claude", DEFAULT_FOLDERS.docs);
-    if (await import_fs_extra17.pathExists(claudeDocsPath)) {
+    const claudeDocsPath = join30(extractDir, ".claude", DEFAULT_FOLDERS.docs);
+    if (await import_fs_extra18.pathExists(claudeDocsPath)) {
       dirsToRename.push({
         from: claudeDocsPath,
-        to: join29(extractDir, ".claude", folders.docs)
+        to: join30(extractDir, ".claude", folders.docs)
       });
     }
   }
   if (folders.plans !== DEFAULT_FOLDERS.plans) {
-    const plansPath = join29(extractDir, DEFAULT_FOLDERS.plans);
-    if (await import_fs_extra17.pathExists(plansPath)) {
+    const plansPath = join30(extractDir, DEFAULT_FOLDERS.plans);
+    if (await import_fs_extra18.pathExists(plansPath)) {
       dirsToRename.push({
         from: plansPath,
-        to: join29(extractDir, folders.plans)
+        to: join30(extractDir, folders.plans)
       });
     }
-    const claudePlansPath = join29(extractDir, ".claude", DEFAULT_FOLDERS.plans);
-    if (await import_fs_extra17.pathExists(claudePlansPath)) {
+    const claudePlansPath = join30(extractDir, ".claude", DEFAULT_FOLDERS.plans);
+    if (await import_fs_extra18.pathExists(claudePlansPath)) {
       dirsToRename.push({
         from: claudePlansPath,
-        to: join29(extractDir, ".claude", folders.plans)
+        to: join30(extractDir, ".claude", folders.plans)
       });
     }
   }
@@ -32522,7 +33660,7 @@ async function transformFileContents(dir, compiledReplacements, options) {
   let replacementsCount = 0;
   const entries = await readdir12(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = join29(dir, entry.name);
+    const fullPath = join30(dir, entry.name);
     if (entry.isDirectory()) {
       if (entry.name === "node_modules" || entry.name === ".git") {
         continue;
@@ -32535,7 +33673,7 @@ async function transformFileContents(dir, compiledReplacements, options) {
       if (!shouldTransform)
         continue;
       try {
-        const content = await readFile15(fullPath, "utf-8");
+        const content = await readFile16(fullPath, "utf-8");
         let newContent = content;
         let changeCount = 0;
         for (const { regex: regex2, replacement } of compiledReplacements) {
@@ -32551,7 +33689,7 @@ async function transformFileContents(dir, compiledReplacements, options) {
           if (options.dryRun) {
             logger.debug(`[dry-run] Would update ${relative8(dir, fullPath)}: ${changeCount} replacement(s)`);
           } else {
-            await writeFile13(fullPath, newContent, "utf-8");
+            await writeFile14(fullPath, newContent, "utf-8");
             logger.debug(`Updated ${relative8(dir, fullPath)}: ${changeCount} replacement(s)`);
           }
           filesChanged++;
@@ -32631,9 +33769,9 @@ function validateFolderName(name2) {
 
 // src/services/transformers/global-path-transformer.ts
 init_logger();
-import { readFile as readFile16, readdir as readdir13, writeFile as writeFile14 } from "node:fs/promises";
+import { readFile as readFile17, readdir as readdir13, writeFile as writeFile15 } from "node:fs/promises";
 import { platform as platform9 } from "node:os";
-import { extname, join as join30 } from "node:path";
+import { extname, join as join31 } from "node:path";
 var IS_WINDOWS2 = platform9() === "win32";
 var HOME_PREFIX = IS_WINDOWS2 ? "%USERPROFILE%" : "$HOME";
 function getHomeDirPrefix() {
@@ -32725,7 +33863,7 @@ async function transformPathsForGlobalInstall(directory, options = {}) {
   async function processDirectory(dir) {
     const entries = await readdir13(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join30(dir, entry.name);
+      const fullPath = join31(dir, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name.startsWith(".") && entry.name !== ".claude") {
           continue;
@@ -32733,10 +33871,10 @@ async function transformPathsForGlobalInstall(directory, options = {}) {
         await processDirectory(fullPath);
       } else if (entry.isFile() && shouldTransformFile(entry.name)) {
         try {
-          const content = await readFile16(fullPath, "utf-8");
+          const content = await readFile17(fullPath, "utf-8");
           const { transformed, changes } = transformContent(content);
           if (changes > 0) {
-            await writeFile14(fullPath, transformed, "utf-8");
+            await writeFile15(fullPath, transformed, "utf-8");
             filesTransformed++;
             totalChanges += changes;
             if (options.verbose) {
@@ -32767,7 +33905,7 @@ init_environment();
 init_logger();
 init_output_manager();
 init_types2();
-var import_fs_extra18 = __toESM(require_lib(), 1);
+var import_fs_extra19 = __toESM(require_lib(), 1);
 async function initCommand(options) {
   const prompts = new PromptsManager;
   prompts.intro("\uD83D\uDD27 ClaudeKit - Initialize/Update Project");
@@ -32786,8 +33924,8 @@ async function initCommand(options) {
       const globalKitDir = PathResolver.getGlobalKitDir();
       const cwdResolved = resolve6(process.cwd());
       const isInGlobalDir = cwdResolved === globalKitDir || cwdResolved === resolve6(globalKitDir, "..");
-      const localSettingsPath = join31(process.cwd(), ".claude", "settings.json");
-      if (!isInGlobalDir && await import_fs_extra18.pathExists(localSettingsPath)) {
+      const localSettingsPath = join32(process.cwd(), ".claude", "settings.json");
+      if (!isInGlobalDir && await import_fs_extra19.pathExists(localSettingsPath)) {
         if (isNonInteractive2) {
           logger.warning("Local .claude/settings.json detected. Local settings take precedence over global.");
           logger.warning("Consider removing local installation: rm -rf .claude");
@@ -32798,9 +33936,9 @@ async function initCommand(options) {
             return;
           }
           if (choice === "remove") {
-            const localClaudeDir = join31(process.cwd(), ".claude");
+            const localClaudeDir = join32(process.cwd(), ".claude");
             try {
-              await import_fs_extra18.remove(localClaudeDir);
+              await import_fs_extra19.remove(localClaudeDir);
               logger.success("Removed local .claude/ directory");
             } catch (error) {
               logger.error(`Failed to remove local installation: ${error instanceof Error ? error.message : "Unknown error"}`);
@@ -32844,7 +33982,7 @@ async function initCommand(options) {
     }
     const resolvedDir = resolve6(targetDir);
     logger.info(`Target directory: ${resolvedDir}`);
-    if (!await import_fs_extra18.pathExists(resolvedDir)) {
+    if (!await import_fs_extra19.pathExists(resolvedDir)) {
       if (validOptions.global) {
         const { mkdir: mkdir11 } = await import("node:fs/promises");
         await mkdir11(resolvedDir, { recursive: true });
@@ -32857,7 +33995,7 @@ async function initCommand(options) {
     }
     if (validOptions.fresh) {
       const prefix = PathResolver.getPathPrefix(validOptions.global);
-      const claudeDir2 = prefix ? join31(resolvedDir, prefix) : resolvedDir;
+      const claudeDir2 = prefix ? join32(resolvedDir, prefix) : resolvedDir;
       const canProceed = await handleFreshInstallation(claudeDir2, prompts);
       if (!canProceed) {
         return;
@@ -32885,7 +34023,7 @@ async function initCommand(options) {
       logger.info("Fetching available versions...");
       let currentVersion = null;
       try {
-        const metadataPath = validOptions.global ? join31(PathResolver.getGlobalKitDir(), "metadata.json") : join31(resolvedDir, ".claude", "metadata.json");
+        const metadataPath = validOptions.global ? join32(PathResolver.getGlobalKitDir(), "metadata.json") : join32(resolvedDir, ".claude", "metadata.json");
         const metadata = await readClaudeKitMetadata(metadataPath);
         currentVersion = metadata?.version || null;
         if (currentVersion) {
@@ -33010,9 +34148,9 @@ async function initCommand(options) {
       }
     }
     if (!validOptions.fresh) {
-      const newSkillsDir = join31(extractDir, ".claude", "skills");
+      const newSkillsDir = join32(extractDir, ".claude", "skills");
       const currentSkillsDir = PathResolver.buildSkillsPath(resolvedDir, validOptions.global);
-      if (await import_fs_extra18.pathExists(newSkillsDir) && await import_fs_extra18.pathExists(currentSkillsDir)) {
+      if (await import_fs_extra19.pathExists(newSkillsDir) && await import_fs_extra19.pathExists(currentSkillsDir)) {
         logger.info("Checking for skills directory migration...");
         const migrationDetection = await SkillsMigrationDetector.detectMigration(newSkillsDir, currentSkillsDir);
         if (migrationDetection.status === "recommended" || migrationDetection.status === "required") {
@@ -33035,7 +34173,7 @@ async function initCommand(options) {
     let customClaudeFiles = [];
     if (!validOptions.fresh) {
       logger.info("Scanning for custom .claude files...");
-      const scanSourceDir = validOptions.global ? join31(extractDir, ".claude") : extractDir;
+      const scanSourceDir = validOptions.global ? join32(extractDir, ".claude") : extractDir;
       const scanTargetSubdir = validOptions.global ? "" : ".claude";
       customClaudeFiles = await FileScanner.findCustomFiles(resolvedDir, scanSourceDir, scanTargetSubdir);
     } else {
@@ -33070,9 +34208,12 @@ async function initCommand(options) {
     }
     merger.setGlobalFlag(validOptions.global);
     merger.setForceOverwriteSettings(validOptions.forceOverwriteSettings);
-    const claudeDir = validOptions.global ? resolvedDir : join31(resolvedDir, ".claude");
+    const claudeDir = validOptions.global ? resolvedDir : join32(resolvedDir, ".claude");
     const releaseManifest = await ReleaseManifestLoader.load(extractDir);
-    if (!validOptions.fresh && await import_fs_extra18.pathExists(claudeDir)) {
+    if (releaseManifest) {
+      merger.setManifest(releaseManifest);
+    }
+    if (!validOptions.fresh && await import_fs_extra19.pathExists(claudeDir)) {
       const legacyDetection = await LegacyMigration.detectLegacy(claudeDir);
       if (legacyDetection.isLegacy && releaseManifest) {
         logger.info("Legacy installation detected - migrating to ownership tracking...");
@@ -33092,7 +34233,7 @@ async function initCommand(options) {
         return;
       }
     }
-    const sourceDir = validOptions.global ? join31(extractDir, ".claude") : extractDir;
+    const sourceDir = validOptions.global ? join32(extractDir, ".claude") : extractDir;
     await merger.merge(sourceDir, resolvedDir, false);
     const manifestWriter = new ManifestWriter;
     const installedFiles = merger.getAllInstalledFiles();
@@ -33101,7 +34242,7 @@ async function initCommand(options) {
       if (!validOptions.global && !installedPath.startsWith(".claude/"))
         continue;
       const relativePath = validOptions.global ? installedPath : installedPath.replace(/^\.claude\//, "");
-      const filePath = join31(claudeDir, relativePath);
+      const filePath = join32(claudeDir, relativePath);
       const manifestEntry = releaseManifest ? ReleaseManifestLoader.findFile(releaseManifest, installedPath) : null;
       const ownership = manifestEntry ? "ck" : "user";
       filesToTrack.push({
@@ -33120,13 +34261,13 @@ async function initCommand(options) {
       }
     });
     trackingSpinner.succeed(`Tracked ${trackResult.success} files`);
-    await manifestWriter.writeManifest(claudeDir, kitConfig.name, release.tag_name, validOptions.global ? "global" : "local");
+    await manifestWriter.writeManifest(claudeDir, kitConfig.name, release.tag_name, validOptions.global ? "global" : "local", kit);
     if (validOptions.global) {
-      const claudeMdSource = join31(extractDir, "CLAUDE.md");
-      const claudeMdDest = join31(resolvedDir, "CLAUDE.md");
-      if (await import_fs_extra18.pathExists(claudeMdSource)) {
-        if (!await import_fs_extra18.pathExists(claudeMdDest)) {
-          await import_fs_extra18.copy(claudeMdSource, claudeMdDest);
+      const claudeMdSource = join32(extractDir, "CLAUDE.md");
+      const claudeMdDest = join32(resolvedDir, "CLAUDE.md");
+      if (await import_fs_extra19.pathExists(claudeMdSource)) {
+        if (!await import_fs_extra19.pathExists(claudeMdDest)) {
+          await import_fs_extra19.copy(claudeMdSource, claudeMdDest);
           logger.success("Copied CLAUDE.md to global directory");
         } else {
           logger.debug("CLAUDE.md already exists in global directory (preserved)");
@@ -33165,8 +34306,8 @@ async function initCommand(options) {
       }
     }
     if (!validOptions.skipSetup && !isNonInteractive2) {
-      const envPath = join31(claudeDir, ".env");
-      if (!await import_fs_extra18.pathExists(envPath)) {
+      const envPath = join32(claudeDir, ".env");
+      if (!await import_fs_extra19.pathExists(envPath)) {
         const shouldSetup = await prompts.confirm("Set up API keys now? (Gemini API key for ai-multimodal skill, optional webhooks)");
         if (shouldSetup) {
           await runSetupWizard({
@@ -33196,13 +34337,13 @@ Protected files (.env, etc.) were not modified.`;
 }
 
 // src/commands/new.ts
-import { join as join32, resolve as resolve7 } from "node:path";
+import { join as join33, resolve as resolve7 } from "node:path";
 init_package_installer();
 init_environment();
 init_logger();
 init_output_manager();
 init_types2();
-var import_fs_extra19 = __toESM(require_lib(), 1);
+var import_fs_extra20 = __toESM(require_lib(), 1);
 async function newCommand(options) {
   const prompts = new PromptsManager;
   prompts.intro("\uD83D\uDE80 ClaudeKit - Create New Project");
@@ -33229,8 +34370,8 @@ async function newCommand(options) {
     }
     const resolvedDir = resolve7(targetDir);
     logger.info(`Target directory: ${resolvedDir}`);
-    if (await import_fs_extra19.pathExists(resolvedDir)) {
-      const files = await import_fs_extra19.readdir(resolvedDir);
+    if (await import_fs_extra20.pathExists(resolvedDir)) {
+      const files = await import_fs_extra20.readdir(resolvedDir);
       const isEmpty = files.length === 0;
       if (!isEmpty) {
         if (isNonInteractive2) {
@@ -33377,7 +34518,7 @@ async function newCommand(options) {
       await CommandsPrefix.cleanupCommandsDirectory(resolvedDir, false);
     }
     await merger.merge(extractDir, resolvedDir, true);
-    const claudeDir = join32(resolvedDir, ".claude");
+    const claudeDir = join33(resolvedDir, ".claude");
     const manifestWriter = new ManifestWriter;
     const releaseManifest = await ReleaseManifestLoader.load(extractDir);
     const installedFiles = merger.getAllInstalledFiles();
@@ -33386,7 +34527,7 @@ async function newCommand(options) {
       if (!installedPath.startsWith(".claude/"))
         continue;
       const relativePath = installedPath.replace(/^\.claude\//, "");
-      const filePath = join32(claudeDir, relativePath);
+      const filePath = join33(claudeDir, relativePath);
       const manifestEntry = releaseManifest ? ReleaseManifestLoader.findFile(releaseManifest, installedPath) : null;
       const ownership = manifestEntry ? "ck" : "user";
       filesToTrack.push({
@@ -33439,10 +34580,10 @@ async function newCommand(options) {
 
 // src/commands/uninstall.ts
 import { readdirSync, rmSync } from "node:fs";
-import { dirname as dirname7, join as join33 } from "node:path";
+import { dirname as dirname7, join as join34 } from "node:path";
 init_logger();
 init_types2();
-var import_fs_extra20 = __toESM(require_lib(), 1);
+var import_fs_extra21 = __toESM(require_lib(), 1);
 var import_picocolors13 = __toESM(require_picocolors(), 1);
 async function detectInstallations() {
   const installations = [];
@@ -33451,14 +34592,14 @@ async function detectInstallations() {
     installations.push({
       type: "local",
       path: setup.project.path,
-      exists: await import_fs_extra20.pathExists(setup.project.path)
+      exists: await import_fs_extra21.pathExists(setup.project.path)
     });
   }
   if (setup.global.path && setup.global.metadata) {
     installations.push({
       type: "global",
       path: setup.global.path,
-      exists: await import_fs_extra20.pathExists(setup.global.path)
+      exists: await import_fs_extra21.pathExists(setup.global.path)
     });
   }
   return installations.filter((i) => i.exists);
@@ -33491,14 +34632,26 @@ async function promptScope(installations) {
   }
   return selected;
 }
-async function confirmUninstall(scope) {
+async function confirmUninstall(scope, kitLabel = "") {
   const scopeText = scope === "all" ? "all ClaudeKit installations" : scope === "local" ? "local ClaudeKit installation" : "global ClaudeKit installation";
   const confirmed = await se({
-    message: `Continue with uninstalling ${scopeText}?`,
+    message: `Continue with uninstalling ${scopeText}${kitLabel}?`,
     initialValue: false
   });
   return confirmed === true;
 }
+function classifyFileByOwnership(ownership, forceOverwrite, deleteReason) {
+  if (ownership === "ck") {
+    return { action: "delete", reason: deleteReason };
+  }
+  if (ownership === "ck-modified") {
+    if (forceOverwrite) {
+      return { action: "delete", reason: "force overwrite" };
+    }
+    return { action: "preserve", reason: "modified by user" };
+  }
+  return { action: "preserve", reason: "user-created" };
+}
 async function cleanupEmptyDirectories(filePath, installationRoot) {
   let cleaned = 0;
   let currentDir = dirname7(filePath);
@@ -33519,33 +34672,56 @@ async function cleanupEmptyDirectories(filePath, installationRoot) {
   }
   return cleaned;
 }
-async function analyzeInstallation(installation, forceOverwrite) {
-  const result = { toDelete: [], toPreserve: [] };
+async function analyzeInstallation(installation, forceOverwrite, kit) {
+  const result = {
+    toDelete: [],
+    toPreserve: [],
+    remainingKits: []
+  };
   const metadata = await ManifestWriter.readManifest(installation.path);
+  const uninstallManifest = await ManifestWriter.getUninstallManifest(installation.path, kit);
+  result.remainingKits = uninstallManifest.remainingKits;
+  if (uninstallManifest.isMultiKit && kit && metadata?.kits?.[kit]) {
+    const kitFiles = metadata.kits[kit].files || [];
+    for (const trackedFile of kitFiles) {
+      const filePath = join34(installation.path, trackedFile.path);
+      if (uninstallManifest.filesToPreserve.includes(trackedFile.path)) {
+        result.toPreserve.push({ path: trackedFile.path, reason: "shared with other kit" });
+        continue;
+      }
+      const ownershipResult = await OwnershipChecker.checkOwnership(filePath, metadata, installation.path);
+      if (!ownershipResult.exists)
+        continue;
+      const classification = classifyFileByOwnership(ownershipResult.ownership, forceOverwrite, `${kit} kit (pristine)`);
+      if (classification.action === "delete") {
+        result.toDelete.push({ path: trackedFile.path, reason: classification.reason });
+      } else {
+        result.toPreserve.push({ path: trackedFile.path, reason: classification.reason });
+      }
+    }
+    if (result.remainingKits.length === 0) {
+      result.toDelete.push({ path: "metadata.json", reason: "metadata file" });
+    }
+    return result;
+  }
   if (!metadata?.files || metadata.files.length === 0) {
-    const { filesToRemove, filesToPreserve } = await ManifestWriter.getUninstallManifest(installation.path);
-    for (const item of filesToRemove) {
-      if (!filesToPreserve.includes(item)) {
+    for (const item of uninstallManifest.filesToRemove) {
+      if (!uninstallManifest.filesToPreserve.includes(item)) {
         result.toDelete.push({ path: item, reason: "legacy installation" });
       }
     }
     return result;
   }
-  for (const trackedFile of metadata.files) {
-    const filePath = join33(installation.path, trackedFile.path);
+  for (const trackedFile of metadata.files || []) {
+    const filePath = join34(installation.path, trackedFile.path);
     const ownershipResult = await OwnershipChecker.checkOwnership(filePath, metadata, installation.path);
     if (!ownershipResult.exists)
       continue;
-    if (ownershipResult.ownership === "ck") {
-      result.toDelete.push({ path: trackedFile.path, reason: "CK-owned (pristine)" });
-    } else if (ownershipResult.ownership === "ck-modified") {
-      if (forceOverwrite) {
-        result.toDelete.push({ path: trackedFile.path, reason: "force overwrite" });
-      } else {
-        result.toPreserve.push({ path: trackedFile.path, reason: "modified by user" });
-      }
+    const classification = classifyFileByOwnership(ownershipResult.ownership, forceOverwrite, "CK-owned (pristine)");
+    if (classification.action === "delete") {
+      result.toDelete.push({ path: trackedFile.path, reason: classification.reason });
     } else {
-      result.toPreserve.push({ path: trackedFile.path, reason: "user-created" });
+      result.toPreserve.push({ path: trackedFile.path, reason: classification.reason });
     }
   }
   result.toDelete.push({ path: "metadata.json", reason: "metadata file" });
@@ -33580,24 +34756,32 @@ function displayDryRunPreview(analysis, installationType) {
 }
 async function removeInstallations(installations, options) {
   for (const installation of installations) {
-    const analysis = await analyzeInstallation(installation, options.forceOverwrite);
+    const analysis = await analyzeInstallation(installation, options.forceOverwrite, options.kit);
     if (options.dryRun) {
-      displayDryRunPreview(analysis, installation.type);
+      const label = options.kit ? `${installation.type} (${options.kit} kit)` : installation.type;
+      displayDryRunPreview(analysis, label);
+      if (analysis.remainingKits.length > 0) {
+        log.info(`Remaining kits after uninstall: ${analysis.remainingKits.join(", ")}`);
+      }
       continue;
     }
-    const spinner = createSpinner(`Removing ${installation.type} ClaudeKit files...`).start();
+    const kitLabel = options.kit ? ` ${options.kit} kit` : "";
+    const spinner = createSpinner(`Removing ${installation.type}${kitLabel} ClaudeKit files...`).start();
     try {
       let removedCount = 0;
       let cleanedDirs = 0;
       for (const item of analysis.toDelete) {
-        const filePath = join33(installation.path, item.path);
-        if (await import_fs_extra20.pathExists(filePath)) {
-          await import_fs_extra20.remove(filePath);
+        const filePath = join34(installation.path, item.path);
+        if (await import_fs_extra21.pathExists(filePath)) {
+          await import_fs_extra21.remove(filePath);
           removedCount++;
           logger.debug(`Removed: ${item.path}`);
           cleanedDirs += await cleanupEmptyDirectories(filePath, installation.path);
         }
       }
+      if (options.kit && analysis.remainingKits.length > 0) {
+        await ManifestWriter.removeKitFromManifest(installation.path, options.kit);
+      }
       try {
         const remaining = readdirSync(installation.path);
         if (remaining.length === 0) {
@@ -33605,7 +34789,8 @@ async function removeInstallations(installations, options) {
           logger.debug(`Removed empty installation directory: ${installation.path}`);
         }
       } catch {}
-      spinner.succeed(`Removed ${removedCount} files${cleanedDirs > 0 ? `, cleaned ${cleanedDirs} empty directories` : ""}, preserved ${analysis.toPreserve.length} customizations`);
+      const kitsInfo = analysis.remainingKits.length > 0 ? `, ${analysis.remainingKits.join(", ")} kit(s) preserved` : "";
+      spinner.succeed(`Removed ${removedCount} files${cleanedDirs > 0 ? `, cleaned ${cleanedDirs} empty directories` : ""}, preserved ${analysis.toPreserve.length} customizations${kitsInfo}`);
       if (analysis.toPreserve.length > 0) {
         log.info("Preserved customizations:");
         analysis.toPreserve.slice(0, 5).forEach((f3) => log.message(`  - ${f3.path} (${f3.reason})`));
@@ -33627,6 +34812,23 @@ async function uninstallCommand(options) {
       logger.info("No ClaudeKit installations found.");
       return;
     }
+    if (validOptions.kit) {
+      let kitFound = false;
+      for (const inst of allInstallations) {
+        const metadata = await ManifestWriter.readManifest(inst.path);
+        if (metadata) {
+          const installedKits = getInstalledKits(metadata);
+          if (installedKits.includes(validOptions.kit)) {
+            kitFound = true;
+            break;
+          }
+        }
+      }
+      if (!kitFound) {
+        logger.info(`Kit "${validOptions.kit}" is not installed.`);
+        return;
+      }
+    }
     let scope;
     if (validOptions.all || validOptions.local && validOptions.global) {
       scope = "all";
@@ -33653,11 +34855,15 @@ async function uninstallCommand(options) {
       return;
     }
     displayInstallations(installations, scope);
+    if (validOptions.kit) {
+      log.info(import_picocolors13.default.cyan(`Kit-scoped uninstall: ${validOptions.kit} kit only`));
+    }
     if (validOptions.dryRun) {
       log.info(import_picocolors13.default.yellow("DRY RUN MODE - No files will be deleted"));
       await removeInstallations(installations, {
         dryRun: true,
-        forceOverwrite: validOptions.forceOverwrite
+        forceOverwrite: validOptions.forceOverwrite,
+        kit: validOptions.kit
       });
       outro("Dry-run complete. No changes were made.");
       return;
@@ -33667,7 +34873,8 @@ async function uninstallCommand(options) {
 ${import_picocolors13.default.yellow("User modifications will be permanently deleted!")}`);
     }
     if (!validOptions.yes) {
-      const confirmed = await confirmUninstall(scope);
+      const kitLabel = validOptions.kit ? ` (${validOptions.kit} kit only)` : "";
+      const confirmed = await confirmUninstall(scope, kitLabel);
       if (!confirmed) {
         logger.info("Uninstall cancelled.");
         return;
@@ -33675,9 +34882,11 @@ ${import_picocolors13.default.yellow("User modifications will be permanently del
     }
     await removeInstallations(installations, {
       dryRun: false,
-      forceOverwrite: validOptions.forceOverwrite
+      forceOverwrite: validOptions.forceOverwrite,
+      kit: validOptions.kit
     });
-    outro("ClaudeKit uninstalled successfully!");
+    const kitMsg = validOptions.kit ? ` (${validOptions.kit} kit)` : "";
+    outro(`ClaudeKit${kitMsg} uninstalled successfully!`);
   } catch (error) {
     logger.error(error instanceof Error ? error.message : "Unknown error");
     process.exit(1);
@@ -33831,7 +35040,7 @@ var import_compare_versions2 = __toESM(require_umd(), 1);
 // package.json
 var package_default2 = {
   name: "claudekit-cli",
-  version: "3.10.2",
+  version: "3.11.0",
   description: "CLI tool for bootstrapping and updating ClaudeKit projects",
   type: "module",
   repository: {
@@ -33851,7 +35060,7 @@ var package_default2 = {
   ],
   scripts: {
     dev: "bun run src/index.ts",
-    build: "bun build src/index.ts --outdir dist --target node --external keytar --external @octokit/rest",
+    build: "bun build src/index.ts --outdir dist --target node --external @octokit/rest",
     compile: "bun build src/index.ts --compile --outfile ck",
     "compile:binary": "bun build src/index.ts --compile --outfile bin/ck",
     "compile:binaries": "node scripts/build-all-binaries.js",
@@ -33892,11 +35101,11 @@ var package_default2 = {
     "extract-zip": "^2.0.1",
     "fs-extra": "^11.2.0",
     ignore: "^5.3.2",
-    keytar: "^7.9.0",
     minimatch: "^10.1.1",
     ora: "^8.0.0",
     "p-limit": "^7.2.0",
     picocolors: "^1.1.1",
+    "proper-lockfile": "^4.1.2",
     tar: "^7.4.3",
     tmp: "^0.2.3",
     zod: "^3.23.8"
@@ -33909,6 +35118,7 @@ var package_default2 = {
     "@types/cli-progress": "^3.11.6",
     "@types/fs-extra": "^11.0.4",
     "@types/node": "^22.10.1",
+    "@types/proper-lockfile": "^4.1.4",
     "@types/tar": "^6.1.13",
     "@types/tmp": "^0.2.6",
     "semantic-release": "^24.2.0",
@@ -34139,14 +35349,14 @@ var import_picocolors15 = __toESM(require_picocolors(), 1);
 // src/domains/versioning/version-cache.ts
 init_logger();
 import { existsSync as existsSync8 } from "node:fs";
-import { mkdir as mkdir11, readFile as readFile17, writeFile as writeFile15 } from "node:fs/promises";
-import { join as join34 } from "node:path";
+import { mkdir as mkdir11, readFile as readFile18, writeFile as writeFile16 } from "node:fs/promises";
+import { join as join35 } from "node:path";
 class VersionCacheManager {
   static CACHE_FILENAME = "version-check.json";
   static CACHE_TTL_MS = 7 * 24 * 60 * 60 * 1000;
   static getCacheFile() {
     const cacheDir = PathResolver.getCacheDir(false);
-    return join34(cacheDir, VersionCacheManager.CACHE_FILENAME);
+    return join35(cacheDir, VersionCacheManager.CACHE_FILENAME);
   }
   static async load() {
     const cacheFile = VersionCacheManager.getCacheFile();
@@ -34155,7 +35365,7 @@ class VersionCacheManager {
         logger.debug("Version check cache not found");
         return null;
       }
-      const content = await readFile17(cacheFile, "utf-8");
+      const content = await readFile18(cacheFile, "utf-8");
       const cache2 = JSON.parse(content);
       if (!cache2.lastCheck || !cache2.currentVersion || !cache2.latestVersion) {
         logger.debug("Invalid cache structure, ignoring");
@@ -34175,7 +35385,7 @@ class VersionCacheManager {
       if (!existsSync8(cacheDir)) {
         await mkdir11(cacheDir, { recursive: true, mode: 448 });
       }
-      await writeFile15(cacheFile, JSON.stringify(cache2, null, 2), "utf-8");
+      await writeFile16(cacheFile, JSON.stringify(cache2, null, 2), "utf-8");
       logger.debug(`Version check cache saved to ${cacheFile}`);
     } catch (error) {
       logger.debug(`Failed to save version check cache: ${error}`);
@@ -34658,7 +35868,7 @@ var output2 = new OutputManager2;
 
 // src/shared/path-resolver.ts
 import { homedir as homedir5, platform as platform10 } from "node:os";
-import { join as join35, normalize as normalize6 } from "node:path";
+import { join as join36, normalize as normalize6 } from "node:path";
 
 class PathResolver2 {
   static getTestHomeDir() {
@@ -34691,50 +35901,50 @@ class PathResolver2 {
   static getConfigDir(global3 = false) {
     const testHome = PathResolver2.getTestHomeDir();
     if (testHome) {
-      return global3 ? join35(testHome, ".config", "claude") : join35(testHome, ".claudekit");
+      return global3 ? join36(testHome, ".config", "claude") : join36(testHome, ".claudekit");
     }
     if (!global3) {
-      return join35(homedir5(), ".claudekit");
+      return join36(homedir5(), ".claudekit");
     }
     const os2 = platform10();
     if (os2 === "win32") {
-      const localAppData = process.env.LOCALAPPDATA || join35(homedir5(), "AppData", "Local");
-      return join35(localAppData, "claude");
+      const localAppData = process.env.LOCALAPPDATA || join36(homedir5(), "AppData", "Local");
+      return join36(localAppData, "claude");
     }
     const xdgConfigHome = process.env.XDG_CONFIG_HOME;
     if (xdgConfigHome) {
-      return join35(xdgConfigHome, "claude");
+      return join36(xdgConfigHome, "claude");
     }
-    return join35(homedir5(), ".config", "claude");
+    return join36(homedir5(), ".config", "claude");
   }
   static getConfigFile(global3 = false) {
-    return join35(PathResolver2.getConfigDir(global3), "config.json");
+    return join36(PathResolver2.getConfigDir(global3), "config.json");
   }
   static getCacheDir(global3 = false) {
     const testHome = PathResolver2.getTestHomeDir();
     if (testHome) {
-      return global3 ? join35(testHome, ".cache", "claude") : join35(testHome, ".claudekit", "cache");
+      return global3 ? join36(testHome, ".cache", "claude") : join36(testHome, ".claudekit", "cache");
     }
     if (!global3) {
-      return join35(homedir5(), ".claudekit", "cache");
+      return join36(homedir5(), ".claudekit", "cache");
     }
     const os2 = platform10();
     if (os2 === "win32") {
-      const localAppData = process.env.LOCALAPPDATA || join35(homedir5(), "AppData", "Local");
-      return join35(localAppData, "claude", "cache");
+      const localAppData = process.env.LOCALAPPDATA || join36(homedir5(), "AppData", "Local");
+      return join36(localAppData, "claude", "cache");
     }
     const xdgCacheHome = process.env.XDG_CACHE_HOME;
     if (xdgCacheHome) {
-      return join35(xdgCacheHome, "claude");
+      return join36(xdgCacheHome, "claude");
     }
-    return join35(homedir5(), ".cache", "claude");
+    return join36(homedir5(), ".cache", "claude");
   }
   static getGlobalKitDir() {
     const testHome = PathResolver2.getTestHomeDir();
     if (testHome) {
-      return join35(testHome, ".claude");
+      return join36(testHome, ".claude");
     }
-    return join35(homedir5(), ".claude");
+    return join36(homedir5(), ".claude");
   }
   static getPathPrefix(global3) {
     return global3 ? "" : ".claude";
@@ -34742,9 +35952,9 @@ class PathResolver2 {
   static buildSkillsPath(baseDir, global3) {
     const prefix = PathResolver2.getPathPrefix(global3);
     if (prefix) {
-      return join35(baseDir, prefix, "skills");
+      return join36(baseDir, prefix, "skills");
     }
-    return join35(baseDir, "skills");
+    return join36(baseDir, "skills");
   }
   static buildComponentPath(baseDir, component, global3) {
     if (!PathResolver2.isPathSafe(component)) {
@@ -34752,9 +35962,9 @@ class PathResolver2 {
     }
     const prefix = PathResolver2.getPathPrefix(global3);
     if (prefix) {
-      return join35(baseDir, prefix, component);
+      return join36(baseDir, prefix, component);
     }
-    return join35(baseDir, component);
+    return join36(baseDir, component);
   }
 }
 
@@ -34786,9 +35996,9 @@ async function displayVersion() {
   let localKitVersion = null;
   let isGlobalOnlyKit = false;
   const globalKitDir = PathResolver2.getGlobalKitDir();
-  const globalMetadataPath = join36(globalKitDir, "metadata.json");
+  const globalMetadataPath = join37(globalKitDir, "metadata.json");
   const prefix = PathResolver2.getPathPrefix(false);
-  const localMetadataPath = prefix ? join36(process.cwd(), prefix, "metadata.json") : join36(process.cwd(), "metadata.json");
+  const localMetadataPath = prefix ? join37(process.cwd(), prefix, "metadata.json") : join37(process.cwd(), "metadata.json");
   const isLocalSameAsGlobal = localMetadataPath === globalMetadataPath;
   if (!isLocalSameAsGlobal && existsSync9(localMetadataPath)) {
     try {
@@ -34892,7 +36102,7 @@ cli.command("versions", "List available versions of ClaudeKit repositories").opt
 cli.command("doctor", "Comprehensive health check for ClaudeKit").option("--report", "Generate shareable diagnostic report").option("--fix", "Auto-fix all fixable issues").option("--check-only", "CI mode: no prompts, exit 1 on failures").option("--json", "Output JSON format").option("--full", "Include extended priority checks (slower)").action(async (options) => {
   await doctorCommand(options);
 });
-cli.command("uninstall", "Remove ClaudeKit installations").option("-y, --yes", "Skip confirmation prompt").option("-l, --local", "Uninstall only local installation (current project)").option("-g, --global", "Uninstall only global installation (~/.claude/)").option("-A, --all", "Uninstall from both local and global locations").option("--dry-run", "Preview what would be removed without deleting").option("--force-overwrite", "Delete even user-modified files (requires confirmation)").action(async (options) => {
+cli.command("uninstall", "Remove ClaudeKit installations").option("-y, --yes", "Skip confirmation prompt").option("-l, --local", "Uninstall only local installation (current project)").option("-g, --global", "Uninstall only global installation (~/.claude/)").option("-A, --all", "Uninstall from both local and global locations").option("-k, --kit <type>", "Uninstall specific kit only (engineer, marketing)").option("--dry-run", "Preview what would be removed without deleting").option("--force-overwrite", "Delete even user-modified files (requires confirmation)").action(async (options) => {
   await uninstallCommand(options);
 });
 cli.option("-V, --version", "Display version number");