agentinit 1.18.2 → 1.20.0

package/dist/cli.js

@@ -8347,6 +8347,159 @@ var require_prompts3 = __commonJS((exports, module) => {
   module.exports = isNodeLT("8.6.0") ? require_dist() : require_lib();
 });
 
+// node_modules/kleur/colors.mjs
+var init, FORCE_COLOR, NODE_DISABLE_COLORS, NO_COLOR, TERM, isTTY, $, reset, bold, dim, italic, underline, inverse, hidden, strikethrough, black, red, green, yellow, blue, magenta, cyan, white, gray, grey, bgBlack, bgRed, bgGreen, bgYellow, bgBlue, bgMagenta, bgCyan, bgWhite;
+var init_colors = __esm(() => {
+  init = function(x, y) {
+    let rgx = new RegExp(`\\x1b\\[${y}m`, "g");
+    let open = `\x1B[${x}m`, close = `\x1B[${y}m`;
+    return function(txt) {
+      if (!$.enabled || txt == null)
+        return txt;
+      return open + (~("" + txt).indexOf(close) ? txt.replace(rgx, close + open) : txt) + close;
+    };
+  };
+  isTTY = true;
+  if (typeof process !== "undefined") {
+    ({ FORCE_COLOR, NODE_DISABLE_COLORS, NO_COLOR, TERM } = process.env || {});
+    isTTY = process.stdout && process.stdout.isTTY;
+  }
+  $ = {
+    enabled: !NODE_DISABLE_COLORS && NO_COLOR == null && TERM !== "dumb" && (FORCE_COLOR != null && FORCE_COLOR !== "0" || isTTY)
+  };
+  reset = init(0, 0);
+  bold = init(1, 22);
+  dim = init(2, 22);
+  italic = init(3, 23);
+  underline = init(4, 24);
+  inverse = init(7, 27);
+  hidden = init(8, 28);
+  strikethrough = init(9, 29);
+  black = init(30, 39);
+  red = init(31, 39);
+  green = init(32, 39);
+  yellow = init(33, 39);
+  blue = init(34, 39);
+  magenta = init(35, 39);
+  cyan = init(36, 39);
+  white = init(37, 39);
+  gray = init(90, 39);
+  grey = init(90, 39);
+  bgBlack = init(40, 49);
+  bgRed = init(41, 49);
+  bgGreen = init(42, 49);
+  bgYellow = init(43, 49);
+  bgBlue = init(44, 49);
+  bgMagenta = init(45, 49);
+  bgCyan = init(46, 49);
+  bgWhite = init(47, 49);
+});
+
+// dist/utils/symbols.js
+var STATUS, TREE, BOX;
+var init_symbols = __esm(() => {
+  STATUS = {
+    success: "\u2713",
+    error: "\u2717",
+    warning: "\u26A0",
+    info: "\u2139",
+    debug: "\u2022"
+  };
+  TREE = {
+    branch: "\u251C\u2500",
+    last: "\u2514\u2500"
+  };
+  BOX = {
+    topLeft: "\u250C",
+    topRight: "\u2510",
+    bottomLeft: "\u2514",
+    bottomRight: "\u2518",
+    horizontal: "\u2500",
+    vertical: "\u2502"
+  };
+});
+
+// dist/utils/logger.js
+class Logger {
+  static instance;
+  static getInstance() {
+    if (!Logger.instance) {
+      Logger.instance = new Logger;
+    }
+    return Logger.instance;
+  }
+  info(message) {
+    console.log(cyan(STATUS.info), message);
+  }
+  success(message) {
+    console.log(green(STATUS.success), message);
+  }
+  warning(message) {
+    console.log(yellow(STATUS.warning), message);
+  }
+  warn(message) {
+    this.warning(message);
+  }
+  error(message) {
+    console.log(red(STATUS.error), message);
+  }
+  debug(message) {
+    console.log(dim(STATUS.debug), dim(message));
+  }
+  title(message) {
+    console.log(bold(cyan(message)));
+  }
+  subtitle(message) {
+    console.log(bold(message));
+  }
+  titleBox(message) {
+    const w = getTerminalWidth();
+    if (w < 8) {
+      console.log(bold(cyan(truncateText(message, w))));
+      return;
+    }
+    const maxInner = Math.max(4, w - 2);
+    const inner = Math.min(Math.max(message.length + 4, 40), maxInner);
+    const visibleMessage = truncateText(message, inner - 2);
+    const padR = Math.max(0, inner - visibleMessage.length - 2);
+    console.log(dim(BOX.topLeft + BOX.horizontal.repeat(inner) + BOX.topRight));
+    console.log(dim(BOX.vertical) + " " + bold(cyan(visibleMessage)) + " ".repeat(padR) + " " + dim(BOX.vertical));
+    console.log(dim(BOX.bottomLeft + BOX.horizontal.repeat(inner) + BOX.bottomRight));
+  }
+  section(title) {
+    const w = getTerminalWidth();
+    const lineLen = Math.max(0, w - title.length - 5);
+    console.log("");
+    console.log(bold(`${BOX.horizontal}${BOX.horizontal} ${title} ${BOX.horizontal.repeat(lineLen)}`));
+  }
+  tree(message, isLast) {
+    const connector = isLast ? TREE.last : TREE.branch;
+    console.log(`${connector} ${message}`);
+  }
+}
+var getTerminalWidth, truncateText, logger;
+var init_logger = __esm(() => {
+  init_colors();
+  init_symbols();
+  getTerminalWidth = function() {
+    const columns = process.stdout.columns;
+    return typeof columns === "number" && columns > 0 ? columns : 80;
+  };
+  truncateText = function(text, maxLength) {
+    if (maxLength <= 0) {
+      return "";
+    }
+    if (text.length <= maxLength) {
+      return text;
+    }
+    if (maxLength <= 3) {
+      return ".".repeat(maxLength);
+    }
+    return `${text.slice(0, maxLength - 3)}...`;
+  };
+  logger = Logger.getInstance();
+});
+
 // dist/utils/fs.js
 import {promises as fs} from "fs";
 import {platform} from "os";
@@ -16952,6 +17105,280 @@ var init_skills = __esm(() => {
   SHARED_SKILLS_TARGET_NAME = "AGENTS.md ecosystem";
 });
 
+// dist/core/installLock.js
+import {promises as fs22} from "fs";
+import {homedir as homedir4} from "os";
+import {dirname as dirname2, join as join4, resolve as resolve7} from "path";
+import {createHash, randomUUID} from "crypto";
+function getLockEntryTargetLabel(entry) {
+  return entry.scope === "global" ? "Global scope" : entry.projectPath;
+}
+function logLockWriteWarning(context, error) {
+  const detail = error instanceof Error ? error.message : "unknown error";
+  logger.warn(`${context}, but failed to update the install lock: ${detail}`);
+}
+async function hashDirectory(rootPath) {
+  if (!await fileExists(rootPath))
+    return null;
+  const hash = createHash("sha256");
+  const walk = async (currentPath, relativePath) => {
+    const stat = await fs22.stat(currentPath);
+    if (stat.isDirectory()) {
+      hash.update(`dir:${relativePath}\n`);
+      const entries = await fs22.readdir(currentPath);
+      entries.sort();
+      for (const entry of entries) {
+        await walk(join4(currentPath, entry), `${relativePath}/${entry}`);
+      }
+    } else {
+      const content = await fs22.readFile(currentPath);
+      hash.update(`file:${relativePath}\n`);
+      hash.update(content);
+      hash.update("\n");
+    }
+  };
+  await walk(rootPath, ".");
+  return hash.digest("hex");
+}
+
+class InstallLock {
+  state = null;
+  async load() {
+    if (this.state)
+      return this.state;
+    const content = await readFileIfExists(getLockPath());
+    if (!content) {
+      this.state = { version: 1, entries: [] };
+      return this.state;
+    }
+    try {
+      const parsed = JSON.parse(content);
+      if (parsed?.version === 1 && Array.isArray(parsed.entries)) {
+        this.state = parsed;
+      } else {
+        this.state = { version: 1, entries: [] };
+      }
+    } catch {
+      this.state = { version: 1, entries: [] };
+    }
+    return this.state;
+  }
+  async save() {
+    if (!this.state)
+      return;
+    const lockPath = getLockPath();
+    await fs22.mkdir(dirname2(lockPath), { recursive: true });
+    await fs22.writeFile(lockPath, JSON.stringify(this.state, null, 2) + "\n", {
+      encoding: "utf8",
+      mode: 384
+    });
+    await fs22.chmod(lockPath, 384).catch(() => {
+    });
+  }
+  async recordSkill(params) {
+    const state = await this.load();
+    const metadata = {
+      kind: "skill",
+      installPath: params.installPath,
+      ...params.canonicalPath ? { canonicalPath: params.canonicalPath } : {},
+      mode: params.mode
+    };
+    const entry = createEntry({
+      kind: "skill",
+      action: params.action,
+      name: params.name,
+      projectPath: resolve7(params.projectPath),
+      agents: params.agents,
+      scope: params.scope,
+      source: params.source,
+      ...params.contentHash ? { contentHash: params.contentHash } : {},
+      metadata
+    });
+    state.entries.push(entry);
+    await this.save();
+    return entry;
+  }
+  async recordMcp(params) {
+    const state = await this.load();
+    const metadata = {
+      kind: "mcp",
+      configPath: params.configPath,
+      serverType: params.serverType,
+      ...params.command ? { command: params.command } : {},
+      ...params.url ? { url: sanitizeUrlForLock(params.url) } : {}
+    };
+    const entry = createEntry({
+      kind: "mcp",
+      action: params.action,
+      name: params.name,
+      projectPath: resolve7(params.projectPath),
+      agents: params.agents,
+      scope: params.scope,
+      source: params.source,
+      metadata
+    });
+    state.entries.push(entry);
+    await this.save();
+    return entry;
+  }
+  async recordRules(params) {
+    const state = await this.load();
+    const metadata = {
+      kind: "rules",
+      configPath: params.configPath,
+      templateIds: params.templateIds,
+      ruleCount: params.ruleCount
+    };
+    const entry = createEntry({
+      kind: "rules",
+      action: params.action,
+      name: params.name,
+      projectPath: resolve7(params.projectPath),
+      agents: params.agents,
+      scope: params.scope,
+      source: params.source,
+      metadata
+    });
+    state.entries.push(entry);
+    await this.save();
+    return entry;
+  }
+  async query(options2 = {}) {
+    const state = await this.load();
+    return state.entries.filter((entry) => {
+      if (options2.kind && entry.kind !== options2.kind)
+        return false;
+      if (options2.name && entry.name.toLowerCase() !== options2.name.toLowerCase())
+        return false;
+      if (options2.projectPath && entry.projectPath !== resolve7(options2.projectPath))
+        return false;
+      if (options2.agent && !entry.agents.includes(options2.agent))
+        return false;
+      if (options2.scope && entry.scope !== options2.scope)
+        return false;
+      if (options2.action && entry.action !== options2.action)
+        return false;
+      return true;
+    });
+  }
+  async getCurrentState(options2 = {}) {
+    const entries = await this.query(options2);
+    const groups = new Map;
+    for (const entry of entries) {
+      const key = this.getCurrentStateKey(entry);
+      groups.set(key, entry);
+    }
+    return [...groups.values()].filter((e) => e.action !== "remove");
+  }
+  getCurrentStateKey(entry) {
+    const agents = [...entry.agents].sort().join(",");
+    return [
+      entry.kind,
+      entry.name.toLowerCase(),
+      getEntryTargetKey(entry),
+      entry.scope,
+      agents,
+      this.getLocationKey(entry)
+    ].join(":");
+  }
+  getLocationKey(entry) {
+    switch (entry.metadata.kind) {
+      case "skill":
+        return entry.metadata.canonicalPath || entry.metadata.installPath;
+      case "mcp":
+        return entry.metadata.configPath;
+      case "rules":
+        return `${entry.metadata.configPath}:${entry.metadata.templateIds.join(",")}`;
+    }
+  }
+  async getProjectPaths() {
+    const state = await this.load();
+    return [...new Set(state.entries.filter((entry) => entry.scope === "project").map((entry) => entry.projectPath))];
+  }
+  async findProjectsWithSkill(skillName) {
+    return this.getCurrentState({ kind: "skill", name: skillName });
+  }
+  async findStaleProjects() {
+    const projectPaths = await this.getProjectPaths();
+    const stale = [];
+    for (const projectPath of projectPaths) {
+      if (!await fileExists(projectPath)) {
+        stale.push(projectPath);
+      }
+    }
+    return stale;
+  }
+  async pruneStaleEntries() {
+    const stale = await this.findStaleProjects();
+    let entriesRemoved = 0;
+    if (stale.length === 0) {
+      return { prunedProjects: [], entriesRemoved: 0 };
+    }
+    const state = await this.load();
+    const staleSet = new Set(stale);
+    const before = state.entries.length;
+    state.entries = state.entries.filter((e) => !staleSet.has(e.projectPath));
+    entriesRemoved = before - state.entries.length;
+    if (entriesRemoved > 0) {
+      await this.save();
+    }
+    return { prunedProjects: stale, entriesRemoved };
+  }
+  async checkDrift(entry) {
+    if (!entry.contentHash) {
+      return { entry, status: "match" };
+    }
+    if (entry.metadata.kind !== "skill") {
+      return { entry, status: "match" };
+    }
+    const installPath = entry.metadata.installPath;
+    if (!await fileExists(installPath)) {
+      return { entry, status: "missing" };
+    }
+    const currentHash = await hashDirectory(installPath);
+    if (!currentHash) {
+      return { entry, status: "missing" };
+    }
+    return {
+      entry,
+      status: currentHash === entry.contentHash ? "match" : "drift",
+      currentHash
+    };
+  }
+}
+var getLockPath, getEntryTargetKey, createEntry, sanitizeUrlForLock, LOCK_FILE, GLOBAL_TARGET_KEY;
+var init_installLock = __esm(() => {
+  init_fs();
+  init_logger();
+  getLockPath = function() {
+    return join4(homedir4(), ".agentinit", LOCK_FILE);
+  };
+  getEntryTargetKey = function(entry) {
+    return entry.scope === "global" ? GLOBAL_TARGET_KEY : entry.projectPath;
+  };
+  createEntry = function(base) {
+    return {
+      id: randomUUID(),
+      timestamp: new Date().toISOString(),
+      ...base
+    };
+  };
+  sanitizeUrlForLock = function(url) {
+    try {
+      const parsed = new URL(url);
+      parsed.username = "";
+      parsed.password = "";
+      parsed.search = "";
+      parsed.hash = "";
+      return parsed.toString();
+    } catch {
+      return url.split(/[?#]/)[0] || url;
+    }
+  };
+  LOCK_FILE = "lock.json";
+  GLOBAL_TARGET_KEY = "__agentinit_global__";
+});
+
 // dist/core/mcpFilter.js
 class MCPFilter {
   static filterForAgent(agent, servers) {
@@ -17066,9 +17493,9 @@ __export(exports_pluginManager, {
     }
   }
 });
-import {resolve as resolve7, join as join4, basename as basename2, relative as relative2, dirname as dirname2} from "path";
-import {promises as fs22} from "fs";
-import {homedir as homedir4} from "os";
+import {resolve as resolve8, join as join5, basename as basename2, relative as relative2, dirname as dirname3} from "path";
+import {promises as fs24} from "fs";
+import {homedir as homedir5} from "os";
 
 class MultipleBundlePluginsError extends Error {
   entries;
@@ -17112,7 +17539,7 @@ class PluginManager {
   }
   async cleanupLoadedPluginContext(context) {
     if (context?.tempDir) {
-      await fs22.rm(context.tempDir, { recursive: true, force: true }).catch(() => {
+      await fs24.rm(context.tempDir, { recursive: true, force: true }).catch(() => {
       });
     }
   }
@@ -17190,7 +17617,7 @@ class PluginManager {
     return "unverified";
   }
   async resolvePreparedPluginDir(pluginDir, source) {
-    const claudeMarketplaceManifestPath = join4(pluginDir, ".claude-plugin", "marketplace.json");
+    const claudeMarketplaceManifestPath = join5(pluginDir, ".claude-plugin", "marketplace.json");
     if (!await fileExists(claudeMarketplaceManifestPath)) {
       return { pluginDir, warnings: [] };
     }
@@ -17225,8 +17652,8 @@ class PluginManager {
       }
       selectedEntry = matched;
     }
-    const selectedPluginDir = resolve7(pluginDir, selectedEntry.source);
-    const relativePath = relative2(resolve7(pluginDir), selectedPluginDir);
+    const selectedPluginDir = resolve8(pluginDir, selectedEntry.source);
+    const relativePath = relative2(resolve8(pluginDir), selectedPluginDir);
     if (relativePath.startsWith("..") || relativePath.includes("/../") || relativePath.includes("\\..\\")) {
       throw new Error(`Invalid bundled plugin source path "${selectedEntry.source}" in ${claudeMarketplaceManifestPath}`);
     }
@@ -17293,7 +17720,7 @@ class PluginManager {
       tempDir = await this.skillsManager.cloneRepo(resolved.url);
       pluginDir = tempDir;
     } else {
-      pluginDir = resolve7(resolved.path || source);
+      pluginDir = resolve8(resolved.path || source);
       if (!await fileExists(pluginDir)) {
         throw new Error(`Local path not found: ${pluginDir}`);
       }
@@ -17338,15 +17765,15 @@ class PluginManager {
   }
   async getClaudeNativeFeatureKinds(pluginDir, manifest) {
     const featureChecks = await Promise.all([
-      (async () => !!manifest.commands || await isDirectory(join4(pluginDir, "commands")))(),
-      (async () => !!manifest.hooks || await isDirectory(join4(pluginDir, "hooks")))(),
-      (async () => !!manifest.agents || await isDirectory(join4(pluginDir, "agents")))(),
-      isDirectory(join4(pluginDir, "skills")),
-      (async () => !!manifest.mcpServers || await fileExists(join4(pluginDir, ".mcp.json")))(),
-      isDirectory(join4(pluginDir, "prompts")),
-      isDirectory(join4(pluginDir, "schemas")),
-      isDirectory(join4(pluginDir, "scripts")),
-      isDirectory(join4(pluginDir, "templates"))
+      (async () => !!manifest.commands || await isDirectory(join5(pluginDir, "commands")))(),
+      (async () => !!manifest.hooks || await isDirectory(join5(pluginDir, "hooks")))(),
+      (async () => !!manifest.agents || await isDirectory(join5(pluginDir, "agents")))(),
+      isDirectory(join5(pluginDir, "skills")),
+      (async () => !!manifest.mcpServers || await fileExists(join5(pluginDir, ".mcp.json")))(),
+      isDirectory(join5(pluginDir, "prompts")),
+      isDirectory(join5(pluginDir, "schemas")),
+      isDirectory(join5(pluginDir, "scripts")),
+      isDirectory(join5(pluginDir, "templates"))
     ]);
     return [
       ...featureChecks[0] ? ["commands"] : [],
@@ -17364,7 +17791,7 @@ class PluginManager {
     if (plugin.format !== "claude") {
       return null;
     }
-    const manifestContent = await readFileIfExists(join4(pluginDir, ".claude-plugin", "plugin.json"));
+    const manifestContent = await readFileIfExists(join5(pluginDir, ".claude-plugin", "plugin.json"));
     if (!manifestContent) {
       return null;
     }
@@ -17384,7 +17811,7 @@ class PluginManager {
     return {
       namespace,
       pluginKey: `${plugin.name}@${namespace}`,
-      installPath: join4(homedir4(), ".claude", "plugins", "cache", namespace, plugin.name, versionDir),
+      installPath: join5(homedir5(), ".claude", "plugins", "cache", namespace, plugin.name, versionDir),
       marketplacePath: getClaudeMarketplaceInstallPath(namespace),
       features
     };
@@ -17448,12 +17875,12 @@ class PluginManager {
     await writeFile(getClaudeSettingsPath(), JSON.stringify(state, null, 2));
   }
   async findClaudeMarketplaceRoot(pluginDir) {
-    let currentDir = resolve7(pluginDir);
+    let currentDir = resolve8(pluginDir);
     while (true) {
-      if (await fileExists(join4(currentDir, ".claude-plugin", "marketplace.json"))) {
+      if (await fileExists(join5(currentDir, ".claude-plugin", "marketplace.json"))) {
         return currentDir;
       }
-      const parentDir = dirname2(currentDir);
+      const parentDir = dirname3(currentDir);
       if (parentDir === currentDir) {
         return null;
       }
@@ -17461,7 +17888,7 @@ class PluginManager {
     }
   }
   async readClaudeMarketplaceManifest(marketplaceDir) {
-    const manifestContent = await readFileIfExists(join4(marketplaceDir, ".claude-plugin", "marketplace.json"));
+    const manifestContent = await readFileIfExists(join5(marketplaceDir, ".claude-plugin", "marketplace.json"));
     if (!manifestContent) {
       return null;
     }
@@ -17480,19 +17907,19 @@ class PluginManager {
     }
   }
   async saveClaudeMarketplaceManifest(marketplaceDir, manifest) {
-    await fs22.mkdir(join4(marketplaceDir, ".claude-plugin"), { recursive: true });
-    await writeFile(join4(marketplaceDir, ".claude-plugin", "marketplace.json"), JSON.stringify(manifest, null, 2));
+    await fs24.mkdir(join5(marketplaceDir, ".claude-plugin"), { recursive: true });
+    await writeFile(join5(marketplaceDir, ".claude-plugin", "marketplace.json"), JSON.stringify(manifest, null, 2));
   }
   resolveMarketplaceSourcePath(baseDir, relativePath) {
-    const resolvedPath = resolve7(baseDir, relativePath);
-    const relativePathFromBase = relative2(resolve7(baseDir), resolvedPath);
+    const resolvedPath = resolve8(baseDir, relativePath);
+    const relativePathFromBase = relative2(resolve8(baseDir), resolvedPath);
     if (relativePathFromBase.startsWith("..") || relativePathFromBase.includes("/../") || relativePathFromBase.includes("\\..\\")) {
       throw new Error(`Invalid marketplace source path "${relativePath}" in ${baseDir}`);
     }
     return resolvedPath;
   }
   async readClaudePluginMetadata(pluginDir) {
-    const manifestContent = await readFileIfExists(join4(pluginDir, ".claude-plugin", "plugin.json"));
+    const manifestContent = await readFileIfExists(join5(pluginDir, ".claude-plugin", "plugin.json"));
     if (!manifestContent) {
       return {};
     }
@@ -17508,11 +17935,11 @@ class PluginManager {
     }
   }
   async copyClaudeMarketplacePlugin(sourcePluginDir, marketplacePath, pluginName) {
-    const marketplacePluginPath = join4(marketplacePath, "plugins", pluginName);
-    await fs22.mkdir(dirname2(marketplacePluginPath), { recursive: true });
-    await fs22.rm(marketplacePluginPath, { recursive: true, force: true }).catch(() => {
+    const marketplacePluginPath = join5(marketplacePath, "plugins", pluginName);
+    await fs24.mkdir(dirname3(marketplacePluginPath), { recursive: true });
+    await fs24.rm(marketplacePluginPath, { recursive: true, force: true }).catch(() => {
     });
-    await fs22.cp(sourcePluginDir, marketplacePluginPath, { recursive: true, dereference: true });
+    await fs24.cp(sourcePluginDir, marketplacePluginPath, { recursive: true, dereference: true });
     return marketplacePluginPath;
   }
   getClaudeMarketplaceSource(plugin, marketplaceRoot, marketplacePath) {
@@ -17533,7 +17960,7 @@ class PluginManager {
     if (plugin.source.type === "local") {
       return {
         source: "directory",
-        path: resolve7(marketplaceRoot || plugin.source.path || marketplacePath)
+        path: resolve8(marketplaceRoot || plugin.source.path || marketplacePath)
       };
     }
     return {
@@ -17544,7 +17971,7 @@ class PluginManager {
   async materializeClaudeMarketplace(plugin, pluginDir, target) {
     const marketplaceRoot = await this.findClaudeMarketplaceRoot(pluginDir);
     const marketplaceSource = this.getClaudeMarketplaceSource(plugin, marketplaceRoot, target.marketplacePath);
-    await fs22.mkdir(target.marketplacePath, { recursive: true });
+    await fs24.mkdir(target.marketplacePath, { recursive: true });
     const existingManifest = await this.readClaudeMarketplaceManifest(target.marketplacePath);
     const sourceManifest = marketplaceRoot ? await this.readClaudeMarketplaceManifest(marketplaceRoot) : null;
     const mergedManifest = {
@@ -17616,10 +18043,10 @@ class PluginManager {
       warnings.push(`Skipped native Claude plugin install because Claude already has "${plugin.name}" installed as ${conflictingKey}.`);
       return { installed, skipped, warnings };
     }
-    await fs22.rm(nativeTarget.installPath, { recursive: true, force: true }).catch(() => {
+    await fs24.rm(nativeTarget.installPath, { recursive: true, force: true }).catch(() => {
     });
-    await fs22.mkdir(dirname2(nativeTarget.installPath), { recursive: true });
-    await fs22.cp(pluginDir, nativeTarget.installPath, { recursive: true, dereference: true });
+    await fs24.mkdir(dirname3(nativeTarget.installPath), { recursive: true });
+    await fs24.cp(pluginDir, nativeTarget.installPath, { recursive: true, dereference: true });
     const marketplace = await this.materializeClaudeMarketplace(plugin, pluginDir, nativeTarget);
     const now = new Date().toISOString();
     claudeInstalled.plugins[nativeTarget.pluginKey] = [{
@@ -17659,7 +18086,7 @@ class PluginManager {
     };
     await this.saveClaudeKnownMarketplaces(knownMarketplaces);
     for (const entry of legacyEntries) {
-      await fs22.rm(entry.installPath, { recursive: true, force: true }).catch(() => {
+      await fs24.rm(entry.installPath, { recursive: true, force: true }).catch(() => {
       });
     }
     for (const legacyKey of legacyKeys) {
@@ -17707,7 +18134,7 @@ class PluginManager {
         delete knownMarketplaces[marketplaceNamespace];
         await this.saveClaudeKnownMarketplaces(knownMarketplaces);
       }
-      await fs22.rm(getClaudeMarketplaceInstallPath(marketplaceNamespace), { recursive: true, force: true }).catch(() => {
+      await fs24.rm(getClaudeMarketplaceInstallPath(marketplaceNamespace), { recursive: true, force: true }).catch(() => {
       });
     } else if (marketplaceNamespace) {
       const pluginName = component.pluginKey.split("@")[0] || "";
@@ -17715,14 +18142,14 @@ class PluginManager {
       const manifest = await this.readClaudeMarketplaceManifest(marketplacePath);
       if (pluginName && manifest) {
         manifest.plugins = (manifest.plugins || []).filter((entry) => entry.name !== pluginName);
-        const marketplacePluginPath = join4(marketplacePath, "plugins", pluginName);
-        await fs22.rm(marketplacePluginPath, { recursive: true, force: true }).catch(() => {
+        const marketplacePluginPath = join5(marketplacePath, "plugins", pluginName);
+        await fs24.rm(marketplacePluginPath, { recursive: true, force: true }).catch(() => {
         });
         await this.saveClaudeMarketplaceManifest(marketplacePath, manifest);
       }
     }
     await this.saveClaudeSettings(claudeSettings);
-    await fs22.rm(component.installPath, { recursive: true, force: true }).catch(() => {
+    await fs24.rm(component.installPath, { recursive: true, force: true }).catch(() => {
     });
     return true;
   }
@@ -17795,7 +18222,7 @@ class PluginManager {
       throw new Error(`Unknown marketplace: ${registryId}. Available: ${this.getMarketplaceIds().join(", ")}`);
     }
     const cacheDir = getMarketplaceCacheDir(registryId);
-    const cacheMetaPath = join4(cacheDir, ".agentinit-cache-meta.json");
+    const cacheMetaPath = join5(cacheDir, ".agentinit-cache-meta.json");
     const cacheMeta = await this.readMarketplaceCacheMeta(cacheMetaPath);
     if (cacheMeta?.repoUrl === registry.repoUrl) {
       const age = Date.now() - cacheMeta.fetchedAt;
@@ -17803,10 +18230,10 @@ class PluginManager {
         return cacheDir;
       }
     }
-    if (await fileExists(join4(cacheDir, ".git"))) {
+    if (await fileExists(join5(cacheDir, ".git"))) {
       const originUrl = await this.getMarketplaceCacheOriginUrl(cacheDir);
       if (originUrl !== registry.repoUrl) {
-        await fs22.rm(cacheDir, { recursive: true, force: true });
+        await fs24.rm(cacheDir, { recursive: true, force: true });
         await this.cloneMarketplace(registry.repoUrl, cacheDir);
       } else {
         const { execFile } = await import("child_process");
@@ -17815,15 +18242,15 @@ class PluginManager {
         try {
           await exec("git", ["pull", "--ff-only"], { cwd: cacheDir, timeout: 30000 });
         } catch {
-          await fs22.rm(cacheDir, { recursive: true, force: true });
+          await fs24.rm(cacheDir, { recursive: true, force: true });
           await this.cloneMarketplace(registry.repoUrl, cacheDir);
         }
       }
     } else {
       await this.cloneMarketplace(registry.repoUrl, cacheDir);
     }
-    await fs22.mkdir(cacheDir, { recursive: true });
-    await fs22.writeFile(cacheMetaPath, JSON.stringify({
+    await fs24.mkdir(cacheDir, { recursive: true });
+    await fs24.writeFile(cacheMetaPath, JSON.stringify({
       fetchedAt: Date.now(),
       repoUrl: registry.repoUrl
     }));
@@ -17834,7 +18261,7 @@ class PluginManager {
       return null;
     }
     try {
-      const meta = JSON.parse(await fs22.readFile(cacheMetaPath, "utf8"));
+      const meta = JSON.parse(await fs24.readFile(cacheMetaPath, "utf8"));
       if (typeof meta.fetchedAt !== "number") {
         return null;
       }
@@ -17862,11 +18289,11 @@ class PluginManager {
     }
   }
   async cloneMarketplace(repoUrl, dest) {
-    await fs22.mkdir(dest, { recursive: true });
+    await fs24.mkdir(dest, { recursive: true });
     const { execFile } = await import("child_process");
     const { promisify } = await import("util");
     const exec = promisify(execFile);
-    await fs22.rm(dest, { recursive: true, force: true }).catch(() => {
+    await fs24.rm(dest, { recursive: true, force: true }).catch(() => {
     });
     await exec("git", ["clone", "--depth", "1", repoUrl, dest], { timeout: 60000 });
   }
@@ -17876,7 +18303,7 @@ class PluginManager {
       throw new Error(`Unknown marketplace: ${registryId}`);
     const cacheDir = await this.ensureMarketplaceCache(registryId);
     for (const dir of registry.pluginDirs) {
-      const pluginPath = join4(cacheDir, dir, name);
+      const pluginPath = join5(cacheDir, dir, name);
       if (await isDirectory(pluginPath)) {
         return pluginPath;
       }
@@ -17892,7 +18319,7 @@ class PluginManager {
     const cacheDir = await this.ensureMarketplaceCache(registryId);
     const results = [];
     for (const dir of registry.pluginDirs) {
-      const fullDir = join4(cacheDir, dir);
+      const fullDir = join5(cacheDir, dir);
       if (!await isDirectory(fullDir))
         continue;
       const cat = getMarketplaceCategoryForDir(dir);
@@ -17902,26 +18329,26 @@ class PluginManager {
       for (const entry of entries) {
         if (entry.startsWith("."))
           continue;
-        const entryPath = join4(fullDir, entry);
+        const entryPath = join5(fullDir, entry);
         if (!await isDirectory(entryPath))
           continue;
-        const manifestPath = join4(entryPath, ".claude-plugin", "plugin.json");
+        const manifestPath = join5(entryPath, ".claude-plugin", "plugin.json");
         let name = entry;
         let description = "";
         let version = "0.0.0";
         if (await fileExists(manifestPath)) {
           try {
-            const manifest = JSON.parse(await fs22.readFile(manifestPath, "utf8"));
+            const manifest = JSON.parse(await fs24.readFile(manifestPath, "utf8"));
             name = manifest.name || entry;
             description = manifest.description || "";
             version = manifest.version || "0.0.0";
           } catch {
           }
         } else {
-          const skillMdPath = join4(entryPath, "SKILL.md");
+          const skillMdPath = join5(entryPath, "SKILL.md");
           if (await fileExists(skillMdPath)) {
             try {
-              const parsed = import_gray_matter.default(await fs22.readFile(skillMdPath, "utf8"));
+              const parsed = import_gray_matter.default(await fs24.readFile(skillMdPath, "utf8"));
               if (parsed.data.name)
                 name = parsed.data.name;
               if (parsed.data.description)
@@ -17929,10 +18356,10 @@ class PluginManager {
             } catch {
             }
           } else {
-            const mcpPath = join4(entryPath, ".mcp.json");
+            const mcpPath = join5(entryPath, ".mcp.json");
             if (await fileExists(mcpPath)) {
               try {
-                const mcpConfig = JSON.parse(await fs22.readFile(mcpPath, "utf8"));
+                const mcpConfig = JSON.parse(await fs24.readFile(mcpPath, "utf8"));
                 const serverNames = Object.keys(mcpConfig.mcpServers || mcpConfig);
                 if (serverNames.length > 0) {
                   description = `MCP server(s): ${serverNames.join(", ")}`;
@@ -17954,10 +18381,10 @@ class PluginManager {
     return results.sort((a, b) => a.name.localeCompare(b.name));
   }
   async detectFormat(pluginDir) {
-    if (await fileExists(join4(pluginDir, ".claude-plugin", "plugin.json"))) {
+    if (await fileExists(join5(pluginDir, ".claude-plugin", "plugin.json"))) {
       return "claude";
     }
-    if (await fileExists(join4(pluginDir, ".cursor-plugin", "plugin.json"))) {
+    if (await fileExists(join5(pluginDir, ".cursor-plugin", "plugin.json"))) {
       return "cursor";
     }
     return "generic";
@@ -17974,7 +18401,7 @@ class PluginManager {
     }
   }
   async parseClaudePlugin(pluginDir, source) {
-    const manifestPath = join4(pluginDir, ".claude-plugin", "plugin.json");
+    const manifestPath = join5(pluginDir, ".claude-plugin", "plugin.json");
     const manifestContent = await readFileIfExists(manifestPath);
     if (!manifestContent) {
       throw new Error(`Missing .claude-plugin/plugin.json in ${pluginDir}`);
@@ -17985,10 +18412,10 @@ class PluginManager {
     const convertedSkills = await this.convertCommandsToSkills(pluginDir, manifest);
     skills.push(...convertedSkills);
     const mcpServers = await this.parseMcpJson(pluginDir);
-    if (await isDirectory(join4(pluginDir, "hooks")) || manifest.hooks) {
+    if (await isDirectory(join5(pluginDir, "hooks")) || manifest.hooks) {
       warnings.push("Hooks (hooks/) are Claude Code-specific");
     }
-    if (await isDirectory(join4(pluginDir, "agents")) || manifest.agents) {
+    if (await isDirectory(join5(pluginDir, "agents")) || manifest.agents) {
       warnings.push("Agent definitions (agents/) are Claude Code-specific");
     }
     return {
@@ -18003,7 +18430,7 @@ class PluginManager {
     };
   }
   async parseCursorPlugin(pluginDir, source) {
-    const manifestPath = join4(pluginDir, ".cursor-plugin", "plugin.json");
+    const manifestPath = join5(pluginDir, ".cursor-plugin", "plugin.json");
     const manifestContent = await readFileIfExists(manifestPath);
     if (!manifestContent) {
       throw new Error(`Missing .cursor-plugin/plugin.json in ${pluginDir}`);
@@ -18042,7 +18469,7 @@ class PluginManager {
     };
   }
   async parseMcpJson(pluginDir) {
-    const mcpPath = join4(pluginDir, ".mcp.json");
+    const mcpPath = join5(pluginDir, ".mcp.json");
     const content = await readFileIfExists(mcpPath);
     if (!content)
       return [];
@@ -18086,10 +18513,10 @@ class PluginManager {
     if (manifest.commands) {
       const cmds = Array.isArray(manifest.commands) ? manifest.commands : [manifest.commands];
       for (const cmd of cmds) {
-        commandsDirs.push(resolve7(pluginDir, cmd));
+        commandsDirs.push(resolve8(pluginDir, cmd));
       }
     } else {
-      commandsDirs.push(join4(pluginDir, "commands"));
+      commandsDirs.push(join5(pluginDir, "commands"));
     }
     for (const commandsDir of commandsDirs) {
       if (!await isDirectory(commandsDir))
@@ -18098,7 +18525,7 @@ class PluginManager {
       for (const entry of entries) {
         if (!entry.endsWith(".md"))
           continue;
-        const cmdPath = join4(commandsDir, entry);
+        const cmdPath = join5(commandsDir, entry);
         const skill = await this.convertSingleCommandToSkill(cmdPath, manifest.name);
         if (skill)
           skills.push(skill);
@@ -18412,7 +18839,7 @@ ${body.trim()}
       }
       if (!removedSkillPaths.has(skill.path)) {
         try {
-          await fs22.rm(skill.path, { recursive: true, force: true });
+          await fs24.rm(skill.path, { recursive: true, force: true });
           removedSkillPaths.add(skill.path);
         } catch {
           details.push(`Could not remove skill path: ${skill.path}`);
@@ -18421,7 +18848,7 @@ ${body.trim()}
       }
       if (skill.canonicalPath && skill.canonicalPath !== skill.path && !removedCanonicalPaths.has(skill.canonicalPath) && !sharedCanonicalPath) {
         try {
-          await fs22.rm(skill.canonicalPath, { recursive: true, force: true });
+          await fs24.rm(skill.canonicalPath, { recursive: true, force: true });
           removedCanonicalPaths.add(skill.canonicalPath);
         } catch {
           details.push(`Could not remove canonical skill path: ${skill.canonicalPath}`);
@@ -18527,34 +18954,34 @@ var init_pluginManager = __esm(() => {
   init_skillsManager();
   init_userConfig();
   getMarketplaceCacheDir = function(registryId) {
-    return join4(homedir4(), ".agentinit", "marketplace-cache", registryId);
+    return join5(homedir5(), ".agentinit", "marketplace-cache", registryId);
   };
   getRegistryPath = function(projectPath, global3) {
     if (global3) {
-      return join4(homedir4(), ".agentinit", "plugins.json");
+      return join5(homedir5(), ".agentinit", "plugins.json");
     }
-    return join4(projectPath, ".agentinit", "plugins.json");
+    return join5(projectPath, ".agentinit", "plugins.json");
   };
   getClaudeInstalledPluginsPath = function() {
-    return join4(homedir4(), ".claude", "plugins", "installed_plugins.json");
+    return join5(homedir5(), ".claude", "plugins", "installed_plugins.json");
   };
   getClaudeKnownMarketplacesPath = function() {
-    return join4(homedir4(), ".claude", "plugins", "known_marketplaces.json");
+    return join5(homedir5(), ".claude", "plugins", "known_marketplaces.json");
   };
   getClaudeMarketplaceInstallPath = function(namespace) {
-    return join4(homedir4(), ".claude", "plugins", "marketplaces", namespace);
+    return join5(homedir5(), ".claude", "plugins", "marketplaces", namespace);
   };
   getClaudeSettingsPath = function() {
-    return join4(homedir4(), ".claude", "settings.json");
+    return join5(homedir5(), ".claude", "settings.json");
   };
 });
 
 // dist/core/skillsManager.js
-import {resolve as resolve8, join as join5, relative as relative3, basename as basename3, dirname as dirname3} from "path";
-import {promises as fs24} from "fs";
-import {homedir as homedir5, tmpdir} from "os";
+import {resolve as resolve9, join as join6, relative as relative3, basename as basename3, dirname as dirname4} from "path";
+import {promises as fs26} from "fs";
+import {homedir as homedir6, tmpdir} from "os";
 import {execFile} from "child_process";
-import {createHash} from "crypto";
+import {createHash as createHash2} from "crypto";
 import {promisify} from "util";
 
 class SkillsManager {
@@ -18705,34 +19132,34 @@ class SkillsManager {
     const skills2 = [];
     const seen = new Set;
     for (const searchDir of SKILL_SEARCH_DIRS) {
-      const fullDir = resolve8(repoPath, searchDir);
+      const fullDir = resolve9(repoPath, searchDir);
       if (!await fileExists(fullDir))
         continue;
-      const directSkillMd = join5(fullDir, "SKILL.md");
+      const directSkillMd = join6(fullDir, "SKILL.md");
       if (await fileExists(directSkillMd)) {
         const parsed = await this.parseSkillMd(directSkillMd);
         if (parsed && !seen.has(parsed.name)) {
           seen.add(parsed.name);
-          skills2.push({ ...parsed, path: resolve8(fullDir) });
+          skills2.push({ ...parsed, path: resolve9(fullDir) });
         }
       }
-      const directSkillMdLower = join5(fullDir, "skill.md");
+      const directSkillMdLower = join6(fullDir, "skill.md");
       if (await fileExists(directSkillMdLower)) {
         const parsed = await this.parseSkillMd(directSkillMdLower);
         if (parsed && !seen.has(parsed.name)) {
           seen.add(parsed.name);
-          skills2.push({ ...parsed, path: resolve8(fullDir) });
+          skills2.push({ ...parsed, path: resolve9(fullDir) });
         }
       }
       if (!await isDirectory(fullDir))
         continue;
       const entries = await listFiles(fullDir);
       for (const entry of entries) {
-        const entryPath = join5(fullDir, entry);
+        const entryPath = join6(fullDir, entry);
         if (!await isDirectory(entryPath))
           continue;
-        const skillMdPath = join5(entryPath, "SKILL.md");
-        const skillMdPathLower = join5(entryPath, "skill.md");
+        const skillMdPath = join6(entryPath, "SKILL.md");
+        const skillMdPathLower = join6(entryPath, "skill.md");
         const skillFile = await fileExists(skillMdPath) ? skillMdPath : await fileExists(skillMdPathLower) ? skillMdPathLower : null;
         if (!skillFile)
           continue;
@@ -18746,14 +19173,14 @@ class SkillsManager {
     return skills2;
   }
   async cloneRepo(url) {
-    const tempDir = await fs24.mkdtemp(join5(tmpdir(), "agentinit-skills-"));
-    await fs24.rm(tempDir, { recursive: true, force: true });
+    const tempDir = await fs26.mkdtemp(join6(tmpdir(), "agentinit-skills-"));
+    await fs26.rm(tempDir, { recursive: true, force: true });
     try {
       await execFileAsync("git", ["clone", "--depth", "1", url, tempDir], {
         timeout: 60000
       });
     } catch (error) {
-      await fs24.rm(tempDir, { recursive: true, force: true }).catch(() => {
+      await fs26.rm(tempDir, { recursive: true, force: true }).catch(() => {
       });
       throw new Error(`Failed to clone ${url}: ${error.message}`);
     }
@@ -18811,15 +19238,15 @@ class SkillsManager {
     if (!tempDir) {
       return;
     }
-    await fs24.rm(tempDir, { recursive: true, force: true }).catch(() => {
+    await fs26.rm(tempDir, { recursive: true, force: true }).catch(() => {
     });
   }
   async resolveDiscoveryRoot(repoPath, source, sourceLabel) {
-    const resolvedRepoPath = resolve8(repoPath);
+    const resolvedRepoPath = resolve9(repoPath);
     if (source.type !== "github" || !source.subpath) {
       return resolvedRepoPath;
     }
-    const discoveryRoot = resolve8(resolvedRepoPath, source.subpath);
+    const discoveryRoot = resolve9(resolvedRepoPath, source.subpath);
     if (!this.isWithinPath(resolvedRepoPath, discoveryRoot)) {
       throw new Error(`Invalid GitHub source path "${source.subpath}" in ${sourceLabel}`);
     }
@@ -18837,7 +19264,7 @@ class SkillsManager {
       return realDiscoveryRoot;
     }
     if (basename3(realDiscoveryRoot).toLowerCase() === "skill.md") {
-      return dirname3(realDiscoveryRoot);
+      return dirname4(realDiscoveryRoot);
     }
     throw new Error(`GitHub source must reference a skill directory or SKILL.md: ${sourceLabel}`);
   }
@@ -18868,7 +19295,7 @@ class SkillsManager {
         tempDir = await this.cloneRepo(resolved.url);
         repoPath = tempDir;
       } else {
-        repoPath = resolve8(resolved.path || source);
+        repoPath = resolve9(resolved.path || source);
         if (!await fileExists(repoPath)) {
           throw this.getMissingLocalPathError(source, repoPath);
         }
@@ -18955,30 +19382,30 @@ class SkillsManager {
   async installSkill(skillPath, skillName, targetDir, copy = false) {
     const normalizedSkillName = this.normalizeSkillName(skillName);
     const destPath = this.resolveInstallPath(targetDir, normalizedSkillName);
-    await fs24.mkdir(resolve8(targetDir), { recursive: true });
+    await fs26.mkdir(resolve9(targetDir), { recursive: true });
     if (await fileExists(destPath)) {
-      await fs24.rm(destPath, { recursive: true, force: true });
+      await fs26.rm(destPath, { recursive: true, force: true });
     }
     if (copy) {
       await this.copyDir(skillPath, destPath);
     } else {
-      await fs24.symlink(skillPath, destPath, "dir");
+      await fs26.symlink(skillPath, destPath, "dir");
     }
     return destPath;
   }
   async installSkillFromContent(skillName, skillContent, targetDir) {
     const normalizedSkillName = this.normalizeSkillName(skillName);
     const destPath = this.resolveInstallPath(targetDir, normalizedSkillName);
-    await fs24.mkdir(resolve8(targetDir), { recursive: true });
+    await fs26.mkdir(resolve9(targetDir), { recursive: true });
     if (await fileExists(destPath)) {
-      await fs24.rm(destPath, { recursive: true, force: true });
+      await fs26.rm(destPath, { recursive: true, force: true });
     }
-    await fs24.mkdir(destPath, { recursive: true });
-    await fs24.writeFile(join5(destPath, "SKILL.md"), skillContent, "utf8");
+    await fs26.mkdir(destPath, { recursive: true });
+    await fs26.writeFile(join6(destPath, "SKILL.md"), skillContent, "utf8");
     return destPath;
   }
   getCanonicalSkillsDir(projectPath, global3 = false) {
-    return global3 ? resolve8(homedir5(), ".agents/skills") : resolve8(projectPath, ".agents/skills");
+    return global3 ? resolve9(homedir6(), ".agents/skills") : resolve9(projectPath, ".agents/skills");
   }
   async getInstallPlan(skillName, agent, projectPath, options2 = {}) {
     const normalizedSkillName = this.normalizeSkillName(skillName);
@@ -19021,7 +19448,7 @@ class SkillsManager {
       ...options2.global !== undefined ? { global: options2.global } : {},
       ...options2.copy !== undefined ? { copy: options2.copy } : {}
     });
-    return this.compareSkillSnapshot(skill, plan.canonicalPath || plan.path);
+    return this.compareSkillInstallStatus(skill, plan);
   }
   async installSkillForAgent(skillPath, skillName, agent, projectPath, options2 = {}) {
     const plan = await this.getInstallPlan(skillName, agent, projectPath, options2);
@@ -19068,7 +19495,7 @@ class SkillsManager {
       throw new Error(`Missing canonical path for ${skillName}`);
     }
     await this.cleanAndCreateDirectory(canonicalPath);
-    await fs24.writeFile(join5(canonicalPath, "SKILL.md"), skillContent, "utf8");
+    await fs26.writeFile(join6(canonicalPath, "SKILL.md"), skillContent, "utf8");
     if (plan.path === canonicalPath) {
       return plan;
     }
@@ -19091,7 +19518,7 @@ class SkillsManager {
   async installSkillFromContentToCanonicalStore(skillName, skillContent, projectPath, options2 = {}) {
     const plan = this.getCanonicalInstallPlan(skillName, projectPath, options2);
     await this.cleanAndCreateDirectory(plan.path);
-    await fs24.writeFile(join5(plan.path, "SKILL.md"), skillContent, "utf8");
+    await fs26.writeFile(join6(plan.path, "SKILL.md"), skillContent, "utf8");
     return plan;
   }
   getCanonicalInstallPlan(skillName, projectPath, options2 = {}) {
@@ -19114,8 +19541,8 @@ class SkillsManager {
     return normalized;
   }
   resolveInstallPath(targetDir, skillName) {
-    const resolvedTargetDir = resolve8(targetDir);
-    const destPath = resolve8(resolvedTargetDir, skillName);
+    const resolvedTargetDir = resolve9(targetDir);
+    const destPath = resolve9(resolvedTargetDir, skillName);
     const relativePath = relative3(resolvedTargetDir, destPath);
     if (relativePath === "" || relativePath.startsWith("..") || relativePath.includes("/../") || relativePath.includes("\\..\\")) {
       throw new Error(`Refusing to install skill outside target directory: ${skillName}`);
@@ -19133,18 +19560,18 @@ class SkillsManager {
   async createDirectorySnapshot(rootPath) {
     if (!await fileExists(rootPath))
       return null;
-    const hash = createHash("sha256");
+    const hash = createHash2("sha256");
     const walk = async (currentPath, relativePath) => {
-      const stat = await fs24.stat(currentPath);
+      const stat = await fs26.stat(currentPath);
       if (!stat.isDirectory()) {
-        const content = await fs24.readFile(currentPath);
+        const content = await fs26.readFile(currentPath);
         this.updateSnapshotWithFile(hash, relativePath, content);
         return;
       }
       hash.update(`dir:${relativePath || "."}\n`);
-      const entries = (await fs24.readdir(currentPath)).sort((left, right) => left.localeCompare(right));
+      const entries = (await fs26.readdir(currentPath)).sort((left, right) => left.localeCompare(right));
       for (const entry of entries) {
-        await walk(join5(currentPath, entry), relativePath ? join5(relativePath, entry) : entry);
+        await walk(join6(currentPath, entry), relativePath ? join6(relativePath, entry) : entry);
       }
     };
     await walk(rootPath, "");
@@ -19155,7 +19582,7 @@ class SkillsManager {
   }
   async getNewSkillSnapshot(skill) {
     if (skill.generatedContent) {
-      const hash = createHash("sha256");
+      const hash = createHash2("sha256");
       hash.update("dir:.\n");
       this.updateSnapshotWithFile(hash, "SKILL.md", skill.generatedContent.trim());
       return hash.digest("hex");
@@ -19171,17 +19598,34 @@ class SkillsManager {
       return "new";
     return existing === incoming ? "unchanged" : "changed";
   }
+  async compareSkillInstallStatus(skill, plan) {
+    const incoming = await this.getNewSkillSnapshot(skill);
+    if (incoming === null)
+      return "new";
+    const existingAtTarget = await this.readExistingSkillSnapshot(plan.path);
+    if (existingAtTarget !== null) {
+      return existingAtTarget === incoming ? "unchanged" : "changed";
+    }
+    if (!plan.canonicalPath || plan.canonicalPath === plan.path) {
+      return "new";
+    }
+    const existingAtCanonical = await this.readExistingSkillSnapshot(plan.canonicalPath);
+    if (existingAtCanonical === null) {
+      return "new";
+    }
+    return existingAtCanonical === incoming ? "new" : "changed";
+  }
   async cleanAndCreateDirectory(path) {
-    await fs24.rm(path, { recursive: true, force: true }).catch(() => {
+    await fs26.rm(path, { recursive: true, force: true }).catch(() => {
     });
-    await fs24.mkdir(path, { recursive: true });
+    await fs26.mkdir(path, { recursive: true });
   }
   isWithinPath(basePath, targetPath) {
-    const relativePath = relative3(resolve8(basePath), resolve8(targetPath));
+    const relativePath = relative3(resolve9(basePath), resolve9(targetPath));
     return relativePath === "" || !relativePath.startsWith("..") && !relativePath.includes("/../") && !relativePath.includes("\\..\\");
   }
   async copyDir(src, dest) {
-    await fs24.cp(src, dest, { recursive: true, dereference: true });
+    await fs26.cp(src, dest, { recursive: true, dereference: true });
   }
   async addFromSource(source, projectPath, options2 = {}) {
     const context = this.takePreparedSourceContext(source, projectPath, options2.from) || await this.loadDiscoveredSkillsContext(source, projectPath, {
@@ -19260,10 +19704,10 @@ class SkillsManager {
               ...options2.copy !== undefined ? { copy: options2.copy } : {}
             };
             const plan = await this.getInstallPlan(skill.name, agent, projectPath, installOptions);
-            const comparisonPath = plan.canonicalPath || plan.path;
+            const comparisonPath = plan.path;
             let comparison = comparisonCache.get(comparisonPath);
             if (comparison === undefined) {
-              comparison = await this.compareSkillSnapshot(skill, comparisonPath);
+              comparison = await this.compareSkillInstallStatus(skill, plan);
               comparisonCache.set(comparisonPath, comparison);
             }
             if (comparison === "unchanged") {
@@ -19310,6 +19754,43 @@ class SkillsManager {
           }
         }
       }
+      try {
+        const lock = new InstallLock;
+        const fromOption = options2.from;
+        const { source: resolvedSource } = this.resolveSourceRequest(source, ...fromOption ? [{ from: fromOption }] : []);
+        const lockSource = {
+          type: resolvedSource.type,
+          ...resolvedSource.marketplace ? { marketplace: resolvedSource.marketplace } : {},
+          ...resolvedSource.pluginName ? { pluginName: resolvedSource.pluginName } : {},
+          ...resolvedSource.url ? { url: resolvedSource.url } : {},
+          ...resolvedSource.path ? { path: resolve9(projectPath, expandTilde(resolvedSource.path)) } : {},
+          ...resolvedSource.owner ? { owner: resolvedSource.owner } : {},
+          ...resolvedSource.repo ? { repo: resolvedSource.repo } : {},
+          ...resolvedSource.subpath ? { subpath: resolvedSource.subpath } : {}
+        };
+        const recordEntries = async (entries, action) => {
+          for (const entry of entries) {
+            const hashPath = entry.canonicalPath || entry.path;
+            const contentHash = await hashDirectory(hashPath);
+            await lock.recordSkill({
+              action,
+              name: entry.skill.name,
+              projectPath: resolve9(projectPath),
+              agents: [entry.agent],
+              scope: options2.global ? "global" : "project",
+              source: lockSource,
+              installPath: entry.path,
+              mode: entry.mode,
+              ...entry.canonicalPath ? { canonicalPath: entry.canonicalPath } : {},
+              ...contentHash ? { contentHash } : {}
+            });
+          }
+        };
+        await recordEntries(result.installed, "install");
+        await recordEntries(result.updated, "update");
+      } catch (error) {
+        logLockWriteWarning("Skills changed successfully", error);
+      }
       return result;
     } finally {
       await context.cleanup();
@@ -19334,11 +19815,11 @@ class SkillsManager {
           continue;
         const entries = await listFiles(dir);
         for (const entry of entries) {
-          const entryPath = join5(dir, entry);
+          const entryPath = join6(dir, entry);
           if (!await isDirectory(entryPath))
             continue;
-          const skillMdPath = join5(entryPath, "SKILL.md");
-          const skillMdPathLower = join5(entryPath, "skill.md");
+          const skillMdPath = join6(entryPath, "SKILL.md");
+          const skillMdPathLower = join6(entryPath, "skill.md");
           const skillFile = await fileExists(skillMdPath) ? skillMdPath : await fileExists(skillMdPathLower) ? skillMdPathLower : null;
           if (!skillFile)
             continue;
@@ -19348,7 +19829,7 @@ class SkillsManager {
           let isSymlink = false;
           let canonicalPath;
           try {
-            const stat = await fs24.lstat(entryPath);
+            const stat = await fs26.lstat(entryPath);
             isSymlink = stat.isSymbolicLink();
             const canonicalBase = this.getCanonicalSkillsDir(projectPath, scope === "global");
             const [resolvedEntryPath, resolvedCanonicalBase] = await Promise.all([
@@ -19358,7 +19839,7 @@ class SkillsManager {
             if (this.isWithinPath(resolvedCanonicalBase, resolvedEntryPath)) {
               canonicalPath = resolvedEntryPath;
             } else if (this.isWithinPath(canonicalBase, entryPath)) {
-              canonicalPath = resolve8(entryPath);
+              canonicalPath = resolve9(entryPath);
             }
           } catch {
           }
@@ -19378,21 +19859,21 @@ class SkillsManager {
     const includeSharedTarget = !options2.agents || options2.agents.includes(SHARED_SKILLS_TARGET_ID);
     if (includeSharedTarget) {
       const scopes = options2.global ? ["global"] : ["project", "global"];
-      const referencedCanonicalPaths = new Set(installed.map((entry) => entry.canonicalPath).filter((value) => !!value).map((value) => resolve8(value)));
+      const referencedCanonicalPaths = new Set(installed.map((entry) => entry.canonicalPath).filter((value) => !!value).map((value) => resolve9(value)));
       for (const scope of scopes) {
         const canonicalDir = this.getCanonicalSkillsDir(projectPath, scope === "global");
         if (!await fileExists(canonicalDir))
           continue;
         const entries = await listFiles(canonicalDir);
         for (const entry of entries) {
-          const entryPath = join5(canonicalDir, entry);
+          const entryPath = join6(canonicalDir, entry);
           if (!await isDirectory(entryPath))
             continue;
-          const resolvedEntryPath = resolve8(entryPath);
+          const resolvedEntryPath = resolve9(entryPath);
           if (referencedCanonicalPaths.has(resolvedEntryPath))
             continue;
-          const skillMdPath = join5(entryPath, "SKILL.md");
-          const skillMdPathLower = join5(entryPath, "skill.md");
+          const skillMdPath = join6(entryPath, "SKILL.md");
+          const skillMdPathLower = join6(entryPath, "skill.md");
           const skillFile = await fileExists(skillMdPath) ? skillMdPath : await fileExists(skillMdPathLower) ? skillMdPathLower : null;
           if (!skillFile)
             continue;
@@ -19459,7 +19940,7 @@ class SkillsManager {
       }
       if (!removedPaths.has(entry.path)) {
         try {
-          await fs24.rm(entry.path, { recursive: true, force: true });
+          await fs26.rm(entry.path, { recursive: true, force: true });
           removedPaths.add(entry.path);
         } catch {
           skipped.push({
@@ -19472,7 +19953,7 @@ class SkillsManager {
       if (entry.canonicalPath && entry.canonicalPath !== entry.path && !removedCanonicalPaths.has(entry.canonicalPath)) {
         const stillReferenced = remainingEntries.some((other) => other.name.toLowerCase() === entry.name.toLowerCase() && other.canonicalPath === entry.canonicalPath);
         if (!stillReferenced) {
-          await fs24.rm(entry.canonicalPath, { recursive: true, force: true }).catch(() => {
+          await fs26.rm(entry.canonicalPath, { recursive: true, force: true }).catch(() => {
           });
           removedCanonicalPaths.add(entry.canonicalPath);
         }
@@ -19485,6 +19966,29 @@ class SkillsManager {
         notFound.push(name);
       }
     }
+    try {
+      if (targetedEntries.length > 0) {
+        const lock = new InstallLock;
+        for (const entry of targetedEntries) {
+          const entryKey = `${entry.agent}:${entry.name}`;
+          if (!removed.includes(entryKey))
+            continue;
+          await lock.recordSkill({
+            action: "remove",
+            name: entry.name,
+            projectPath: resolve9(projectPath),
+            agents: [entry.agent],
+            scope: entry.scope,
+            source: { type: "local", path: entry.path },
+            installPath: entry.path,
+            mode: entry.mode,
+            ...entry.canonicalPath ? { canonicalPath: entry.canonicalPath } : {}
+          });
+        }
+      }
+    } catch (error) {
+      logLockWriteWarning("Skills removed successfully", error);
+    }
     return { removed, notFound, skipped };
   }
 }
@@ -19492,9 +19996,11 @@ var import_gray_matter2, execFileAsync, DEFAULT_SKILLS_CATALOG, SKILL_SEARCH_DIR
 var init_skillsManager = __esm(() => {
   import_gray_matter2 = __toESM(require_gray_matter(), 1);
   init_fs();
+  init_paths();
   init_agentManager();
   init_marketplaceRegistry();
   init_skills();
+  init_installLock();
   execFileAsync = promisify(execFile);
   DEFAULT_SKILLS_CATALOG = {
     owner: "vercel-labs",
@@ -20433,7 +20939,7 @@ var require_uri_all = __commonJS((exports, module) => {
       target.fragment = relative6.fragment;
       return target;
     }
-    function resolve12(baseURI, relativeURI, options2) {
+    function resolve13(baseURI, relativeURI, options2) {
       var schemelessOptions = assign({ scheme: "null" }, options2);
       return serialize(resolveComponents(parse4(baseURI, schemelessOptions), parse4(relativeURI, schemelessOptions), schemelessOptions, true), schemelessOptions);
     }
@@ -20701,7 +21207,7 @@ var require_uri_all = __commonJS((exports, module) => {
     exports2.removeDotSegments = removeDotSegments;
     exports2.serialize = serialize;
     exports2.resolveComponents = resolveComponents;
-    exports2.resolve = resolve12;
+    exports2.resolve = resolve13;
     exports2.normalize = normalize;
     exports2.equal = equal;
     exports2.escapeComponent = escapeComponent;
@@ -20887,7 +21393,7 @@ var require_util3 = __commonJS((exports, module) => {
     var path = jsonPointers ? toQuotedString("/" + escapeJsonPointer(prop)) : toQuotedString(getProperty(prop));
     return joinPaths(currentPath, path);
   };
-  var getData = function($data, lvl, paths5) {
+  var getData = function($data, lvl, paths6) {
     var up, jsonPointer, data, matches;
     if ($data === "")
       return "rootData";
@@ -20905,7 +21411,7 @@ var require_util3 = __commonJS((exports, module) => {
       if (jsonPointer == "#") {
         if (up >= lvl)
           throw new Error("Cannot access property/index " + up + " levels up, current level is " + lvl);
-        return paths5[lvl - up];
+        return paths6[lvl - up];
       }
       if (up > lvl)
         throw new Error("Cannot access data " + up + " levels up, current level is " + lvl);
@@ -21064,13 +21570,13 @@ var require_json_schema_traverse = __commonJS((exports, module) => {
 
 // node_modules/ajv/lib/compile/resolve.js
 var require_resolve = __commonJS((exports, module) => {
-  var resolve12 = function(compile, root, ref) {
+  var resolve13 = function(compile, root, ref) {
     var refVal = this._refs[ref];
     if (typeof refVal == "string") {
       if (this._refs[refVal])
         refVal = this._refs[refVal];
       else
-        return resolve12.call(this, compile, root, refVal);
+        return resolve13.call(this, compile, root, refVal);
     }
     refVal = refVal || this._schemas[ref];
     if (refVal instanceof SchemaObject) {
@@ -21275,13 +21781,13 @@ var require_resolve = __commonJS((exports, module) => {
   var util6 = require_util3();
   var SchemaObject = require_schema_obj();
   var traverse = require_json_schema_traverse();
-  module.exports = resolve12;
-  resolve12.normalizeId = normalizeId;
-  resolve12.fullPath = getFullPath;
-  resolve12.url = resolveUrl;
-  resolve12.ids = resolveIds;
-  resolve12.inlineRef = inlineRef;
-  resolve12.schema = resolveSchema;
+  module.exports = resolve13;
+  resolve13.normalizeId = normalizeId;
+  resolve13.fullPath = getFullPath;
+  resolve13.url = resolveUrl;
+  resolve13.ids = resolveIds;
+  resolve13.inlineRef = inlineRef;
+  resolve13.schema = resolveSchema;
   var PREVENT_SCOPE_CHANGE = util6.toHash(["properties", "patternProperties", "enum", "dependencies", "definitions"]);
   var SIMPLE_INLINED = util6.toHash([
     "type",
@@ -21312,15 +21818,15 @@ var require_error_classes = __commonJS((exports, module) => {
   };
   var MissingRefError = function(baseId, ref, message) {
     this.message = message || MissingRefError.message(baseId, ref);
-    this.missingRef = resolve12.url(baseId, ref);
-    this.missingSchema = resolve12.normalizeId(resolve12.fullPath(this.missingRef));
+    this.missingRef = resolve13.url(baseId, ref);
+    this.missingSchema = resolve13.normalizeId(resolve13.fullPath(this.missingRef));
   };
   var errorSubclass = function(Subclass) {
     Subclass.prototype = Object.create(Error.prototype);
     Subclass.prototype.constructor = Subclass;
     return Subclass;
   };
-  var resolve12 = require_resolve();
+  var resolve13 = require_resolve();
   module.exports = {
     Validation: errorSubclass(ValidationError),
     MissingRef: errorSubclass(MissingRefError)
@@ -21914,7 +22420,7 @@ var require_compile = __commonJS((exports, module) => {
         RULES,
         validate: validateGenerator,
         util: util6,
-        resolve: resolve12,
+        resolve: resolve13,
         resolveRef,
         usePattern,
         useDefault,
@@ -21953,7 +22459,7 @@ var require_compile = __commonJS((exports, module) => {
       return validate2;
     }
     function resolveRef(baseId2, ref, isRoot) {
-      ref = resolve12.url(baseId2, ref);
+      ref = resolve13.url(baseId2, ref);
       var refIndex = refs[ref];
       var _refVal, refCode;
       if (refIndex !== undefined) {
@@ -21970,11 +22476,11 @@ var require_compile = __commonJS((exports, module) => {
         }
       }
       refCode = addLocalRef(ref);
-      var v2 = resolve12.call(self, localCompile, root, ref);
+      var v2 = resolve13.call(self, localCompile, root, ref);
       if (v2 === undefined) {
         var localSchema = localRefs && localRefs[ref];
         if (localSchema) {
-          v2 = resolve12.inlineRef(localSchema, opts.inlineRefs) ? localSchema : compile.call(self, localSchema, root, localRefs, baseId2);
+          v2 = resolve13.inlineRef(localSchema, opts.inlineRefs) ? localSchema : compile.call(self, localSchema, root, localRefs, baseId2);
         }
       }
       if (v2 === undefined) {
@@ -22116,7 +22622,7 @@ var require_compile = __commonJS((exports, module) => {
       code += statement(i, arr);
     return code;
   };
-  var resolve12 = require_resolve();
+  var resolve13 = require_resolve();
   var util6 = require_util3();
   var errorClasses = require_error_classes();
   var stableStringify = require_fast_json_stable_stringify();
@@ -25365,7 +25871,7 @@ var require_ajv = __commonJS((exports, module) => {
     var id = this._getId(schema2);
     if (id !== undefined && typeof id != "string")
       throw new Error("schema id must be string");
-    key = resolve12.normalizeId(key || id);
+    key = resolve13.normalizeId(key || id);
     checkUnique(this, key);
     this._schemas[key] = this._addSchema(schema2, _skipValidation, _meta, true);
     return this;
@@ -25411,7 +25917,7 @@ var require_ajv = __commonJS((exports, module) => {
     }
   };
   var _getSchemaFragment = function(self, ref) {
-    var res = resolve12.schema.call(self, { schema: {} }, ref);
+    var res = resolve13.schema.call(self, { schema: {} }, ref);
     if (res) {
       var { schema: schema2, root, baseId } = res;
       var v = compileSchema.call(self, schema2, root, undefined, baseId);
@@ -25427,7 +25933,7 @@ var require_ajv = __commonJS((exports, module) => {
     }
   };
   var _getSchemaObj = function(self, keyRef) {
-    keyRef = resolve12.normalizeId(keyRef);
+    keyRef = resolve13.normalizeId(keyRef);
     return self._schemas[keyRef] || self._refs[keyRef] || self._fragments[keyRef];
   };
   var removeSchema = function(schemaKeyRef) {
@@ -25455,7 +25961,7 @@ var require_ajv = __commonJS((exports, module) => {
         this._cache.del(cacheKey);
         var id = this._getId(schemaKeyRef);
         if (id) {
-          id = resolve12.normalizeId(id);
+          id = resolve13.normalizeId(id);
           delete this._schemas[id];
           delete this._refs[id];
         }
@@ -25480,14 +25986,14 @@ var require_ajv = __commonJS((exports, module) => {
     if (cached)
       return cached;
     shouldAddSchema = shouldAddSchema || this._opts.addUsedSchema !== false;
-    var id = resolve12.normalizeId(this._getId(schema2));
+    var id = resolve13.normalizeId(this._getId(schema2));
     if (id && shouldAddSchema)
       checkUnique(this, id);
     var willValidate = this._opts.validateSchema !== false && !skipValidation;
     var recursiveMeta;
-    if (willValidate && !(recursiveMeta = id && id == resolve12.normalizeId(schema2.$schema)))
+    if (willValidate && !(recursiveMeta = id && id == resolve13.normalizeId(schema2.$schema)))
       this.validateSchema(schema2, true);
-    var localRefs = resolve12.ids.call(this, schema2);
+    var localRefs = resolve13.ids.call(this, schema2);
     var schemaObj = new SchemaObject({
       id,
       schema: schema2,
@@ -25634,21 +26140,21 @@ var require_ajv = __commonJS((exports, module) => {
     return metaOpts;
   };
   var setLogger = function(self) {
-    var logger5 = self._opts.logger;
-    if (logger5 === false) {
+    var logger6 = self._opts.logger;
+    if (logger6 === false) {
       self.logger = { log: noop, warn: noop, error: noop };
     } else {
-      if (logger5 === undefined)
-        logger5 = console;
-      if (!(typeof logger5 == "object" && logger5.log && logger5.warn && logger5.error))
+      if (logger6 === undefined)
+        logger6 = console;
+      if (!(typeof logger6 == "object" && logger6.log && logger6.warn && logger6.error))
         throw new Error("logger must implement log, warn and error methods");
-      self.logger = logger5;
+      self.logger = logger6;
     }
   };
   var noop = function() {
   };
   var compileSchema = require_compile();
-  var resolve12 = require_resolve();
+  var resolve13 = require_resolve();
   var Cache = require_cache();
   var SchemaObject = require_schema_obj();
   var stableStringify = require_fast_json_stable_stringify();
@@ -25709,27 +26215,27 @@ var require_windows = __commonJS((exports, module) => {
     return checkPathExt(path, options2);
   };
   var isexe = function(path, options2, cb) {
-    fs31.stat(path, function(er, stat) {
+    fs33.stat(path, function(er, stat) {
       cb(er, er ? false : checkStat(stat, path, options2));
     });
   };
   var sync = function(path, options2) {
-    return checkStat(fs31.statSync(path), path, options2);
+    return checkStat(fs33.statSync(path), path, options2);
   };
   module.exports = isexe;
   isexe.sync = sync;
-  var fs31 = __require("fs");
+  var fs33 = __require("fs");
 });
 
 // node_modules/isexe/mode.js
 var require_mode = __commonJS((exports, module) => {
   var isexe = function(path, options2, cb) {
-    fs31.stat(path, function(er, stat) {
+    fs33.stat(path, function(er, stat) {
       cb(er, er ? false : checkStat(stat, options2));
     });
   };
   var sync = function(path, options2) {
-    return checkStat(fs31.statSync(path), options2);
+    return checkStat(fs33.statSync(path), options2);
   };
   var checkStat = function(stat, options2) {
     return stat.isFile() && checkMode(stat, options2);
@@ -25749,7 +26255,7 @@ var require_mode = __commonJS((exports, module) => {
   };
   module.exports = isexe;
   isexe.sync = sync;
-  var fs31 = __require("fs");
+  var fs33 = __require("fs");
 });
 
 // node_modules/isexe/index.js
@@ -25763,12 +26269,12 @@ var require_isexe = __commonJS((exports, module) => {
       if (typeof Promise !== "function") {
         throw new TypeError("callback not provided");
       }
-      return new Promise(function(resolve12, reject) {
+      return new Promise(function(resolve13, reject) {
         isexe(path, options2 || {}, function(er, is) {
           if (er) {
             reject(er);
           } else {
-            resolve12(is);
+            resolve13(is);
           }
         });
       });
@@ -25794,7 +26300,7 @@ var require_isexe = __commonJS((exports, module) => {
       }
     }
   };
-  var fs31 = __require("fs");
+  var fs33 = __require("fs");
   var core2;
   if (process.platform === "win32" || global.TESTING_WINDOWS) {
     core2 = require_windows();
@@ -25839,27 +26345,27 @@ var require_which = __commonJS((exports, module) => {
       opt = {};
     const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
     const found = [];
-    const step = (i) => new Promise((resolve12, reject) => {
+    const step = (i) => new Promise((resolve13, reject) => {
       if (i === pathEnv.length)
-        return opt.all && found.length ? resolve12(found) : reject(getNotFoundError(cmd));
+        return opt.all && found.length ? resolve13(found) : reject(getNotFoundError(cmd));
       const ppRaw = pathEnv[i];
       const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
       const pCmd = path.join(pathPart, cmd);
       const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
-      resolve12(subStep(p, i, 0));
+      resolve13(subStep(p, i, 0));
     });
-    const subStep = (p, i, ii) => new Promise((resolve12, reject) => {
+    const subStep = (p, i, ii) => new Promise((resolve13, reject) => {
       if (ii === pathExt.length)
-        return resolve12(step(i + 1));
+        return resolve13(step(i + 1));
       const ext = pathExt[ii];
       isexe(p + ext, { pathExt: pathExtExe }, (er, is) => {
         if (!er && is) {
           if (opt.all)
             found.push(p + ext);
           else
-            return resolve12(p + ext);
+            return resolve13(p + ext);
         }
-        return resolve12(subStep(p, i, ii + 1));
+        return resolve13(subStep(p, i, ii + 1));
       });
     });
     return cb ? step(0).then((res) => cb(null, res), cb) : step(0);
@@ -26001,14 +26507,14 @@ var require_readShebang = __commonJS((exports, module) => {
     const buffer = Buffer.alloc(size);
     let fd;
     try {
-      fd = fs31.openSync(command, "r");
-      fs31.readSync(fd, buffer, 0, size, 0);
-      fs31.closeSync(fd);
+      fd = fs33.openSync(command, "r");
+      fs33.readSync(fd, buffer, 0, size, 0);
+      fs33.closeSync(fd);
     } catch (e) {
     }
     return shebangCommand(buffer.toString());
   };
-  var fs31 = __require("fs");
+  var fs33 = __require("fs");
   var shebangCommand = require_shebang_command();
   module.exports = readShebang;
 });
@@ -27461,155 +27967,7 @@ function ora(options2) {
 
 // dist/commands/init.js
 var import_prompts = __toESM(require_prompts3(), 1);
-
-// node_modules/kleur/colors.mjs
-var init = function(x, y) {
-  let rgx = new RegExp(`\\x1b\\[${y}m`, "g");
-  let open = `\x1B[${x}m`, close = `\x1B[${y}m`;
-  return function(txt) {
-    if (!$.enabled || txt == null)
-      return txt;
-    return open + (~("" + txt).indexOf(close) ? txt.replace(rgx, close + open) : txt) + close;
-  };
-};
-var FORCE_COLOR;
-var NODE_DISABLE_COLORS;
-var NO_COLOR;
-var TERM;
-var isTTY = true;
-if (typeof process !== "undefined") {
-  ({ FORCE_COLOR, NODE_DISABLE_COLORS, NO_COLOR, TERM } = process.env || {});
-  isTTY = process.stdout && process.stdout.isTTY;
-}
-var $ = {
-  enabled: !NODE_DISABLE_COLORS && NO_COLOR == null && TERM !== "dumb" && (FORCE_COLOR != null && FORCE_COLOR !== "0" || isTTY)
-};
-var reset = init(0, 0);
-var bold = init(1, 22);
-var dim = init(2, 22);
-var italic = init(3, 23);
-var underline = init(4, 24);
-var inverse = init(7, 27);
-var hidden = init(8, 28);
-var strikethrough = init(9, 29);
-var black = init(30, 39);
-var red = init(31, 39);
-var green = init(32, 39);
-var yellow = init(33, 39);
-var blue = init(34, 39);
-var magenta = init(35, 39);
-var cyan = init(36, 39);
-var white = init(37, 39);
-var gray = init(90, 39);
-var grey = init(90, 39);
-var bgBlack = init(40, 49);
-var bgRed = init(41, 49);
-var bgGreen = init(42, 49);
-var bgYellow = init(43, 49);
-var bgBlue = init(44, 49);
-var bgMagenta = init(45, 49);
-var bgCyan = init(46, 49);
-var bgWhite = init(47, 49);
-
-// dist/utils/symbols.js
-var STATUS = {
-  success: "\u2713",
-  error: "\u2717",
-  warning: "\u26A0",
-  info: "\u2139",
-  debug: "\u2022"
-};
-var TREE = {
-  branch: "\u251C\u2500",
-  last: "\u2514\u2500"
-};
-var BOX = {
-  topLeft: "\u250C",
-  topRight: "\u2510",
-  bottomLeft: "\u2514",
-  bottomRight: "\u2518",
-  horizontal: "\u2500",
-  vertical: "\u2502"
-};
-
-// dist/utils/logger.js
-var getTerminalWidth = function() {
-  const columns = process.stdout.columns;
-  return typeof columns === "number" && columns > 0 ? columns : 80;
-};
-var truncateText = function(text, maxLength) {
-  if (maxLength <= 0) {
-    return "";
-  }
-  if (text.length <= maxLength) {
-    return text;
-  }
-  if (maxLength <= 3) {
-    return ".".repeat(maxLength);
-  }
-  return `${text.slice(0, maxLength - 3)}...`;
-};
-
-class Logger {
-  static instance;
-  static getInstance() {
-    if (!Logger.instance) {
-      Logger.instance = new Logger;
-    }
-    return Logger.instance;
-  }
-  info(message) {
-    console.log(cyan(STATUS.info), message);
-  }
-  success(message) {
-    console.log(green(STATUS.success), message);
-  }
-  warning(message) {
-    console.log(yellow(STATUS.warning), message);
-  }
-  warn(message) {
-    this.warning(message);
-  }
-  error(message) {
-    console.log(red(STATUS.error), message);
-  }
-  debug(message) {
-    console.log(dim(STATUS.debug), dim(message));
-  }
-  title(message) {
-    console.log(bold(cyan(message)));
-  }
-  subtitle(message) {
-    console.log(bold(message));
-  }
-  titleBox(message) {
-    const w = getTerminalWidth();
-    if (w < 8) {
-      console.log(bold(cyan(truncateText(message, w))));
-      return;
-    }
-    const maxInner = Math.max(4, w - 2);
-    const inner = Math.min(Math.max(message.length + 4, 40), maxInner);
-    const visibleMessage = truncateText(message, inner - 2);
-    const padR = Math.max(0, inner - visibleMessage.length - 2);
-    console.log(dim(BOX.topLeft + BOX.horizontal.repeat(inner) + BOX.topRight));
-    console.log(dim(BOX.vertical) + " " + bold(cyan(visibleMessage)) + " ".repeat(padR) + " " + dim(BOX.vertical));
-    console.log(dim(BOX.bottomLeft + BOX.horizontal.repeat(inner) + BOX.bottomRight));
-  }
-  section(title) {
-    const w = getTerminalWidth();
-    const lineLen = Math.max(0, w - title.length - 5);
-    console.log("");
-    console.log(bold(`${BOX.horizontal}${BOX.horizontal} ${title} ${BOX.horizontal.repeat(lineLen)}`));
-  }
-  tree(message, isLast) {
-    const connector = isLast ? TREE.last : TREE.branch;
-    console.log(`${connector} ${message}`);
-  }
-}
-var logger = Logger.getInstance();
-
-// dist/commands/init.js
+init_logger();
 init_fs();
 
 // dist/core/agentDetector.js
@@ -28270,6 +28628,7 @@ var getProjectName = function(cwd) {
 };
 
 // dist/commands/detect.js
+init_logger();
 init_skillsManager();
 init_agentManager();
 async function detectCommand(options2) {
@@ -28338,12 +28697,13 @@ async function detectCommand(options2) {
 }
 
 // dist/commands/sync.js
+init_logger();
 import {relative as relative5} from "path";
 
 // dist/core/propagator.js
 var import_gray_matter3 = __toESM(require_gray_matter(), 1);
-import {promises as fs26} from "fs";
-import {resolve as resolve9} from "path";
+import {promises as fs28} from "fs";
+import {resolve as resolve10} from "path";
 
 // node_modules/js-yaml/dist/js-yaml.mjs
 var isNothing = function(subject) {
@@ -30990,7 +31350,7 @@ class Propagator {
       warnings: [],
       resolvedTargets: []
     };
-    const agentsPath = resolve9(projectPath, "agents.md");
+    const agentsPath = resolve10(projectPath, "agents.md");
     if (!await fileExists(agentsPath)) {
       result.success = false;
       result.errors.push("agents.md not found. Run `agentinit init` first.");
@@ -31075,7 +31435,7 @@ class Propagator {
     return [...generatedFiles.values()];
   }
   mergeGeneratedFile(projectPath, generatedFiles, output, agentId) {
-    const outputPath = resolve9(projectPath, output.path);
+    const outputPath = resolve10(projectPath, output.path);
     const nextKind = output.kind ?? "file";
     const nextContent = nextKind === "file" || output.content !== undefined ? normalizeContent(output.content || "") : undefined;
     const existing = generatedFiles.get(outputPath);
@@ -31110,14 +31470,14 @@ class Propagator {
       resolvedTargets: []
     };
     const exists = await fileExists(generatedFile.path);
-    const existingStats = exists ? await fs26.lstat(generatedFile.path).catch(() => null) : null;
+    const existingStats = exists ? await fs28.lstat(generatedFile.path).catch(() => null) : null;
     const existingContent = exists && !existingStats?.isSymbolicLink() ? await readFileIfExists(generatedFile.path) : null;
     const existingTarget = existingStats?.isSymbolicLink() ? await readSymlinkTarget(generatedFile.path) : null;
     if (options2.managedState && !options2.dryRun) {
       await options2.managedState.trackGeneratedPath(generatedFile.path, {
         kind: "file",
         source: "sync",
-        ignorePath: resolve9(projectPath, generatedFile.ignorePath)
+        ignorePath: resolve10(projectPath, generatedFile.ignorePath)
       });
     }
     if (generatedFile.kind === "file" && exists && !existingStats?.isSymbolicLink() && existingContent === generatedFile.content) {
@@ -31141,12 +31501,12 @@ class Propagator {
     if (!options2.dryRun) {
       if (generatedFile.kind === "file") {
         if (existingStats?.isSymbolicLink()) {
-          await fs26.rm(generatedFile.path, { force: true }).catch(() => {
+          await fs28.rm(generatedFile.path, { force: true }).catch(() => {
           });
         }
         await writeFile(generatedFile.path, generatedFile.content || "");
       } else {
-        const symlinkCreated = await createRelativeSymlink(resolve9(projectPath, generatedFile.target || ""), generatedFile.path);
+        const symlinkCreated = await createRelativeSymlink(resolve10(projectPath, generatedFile.target || ""), generatedFile.path);
         if (!symlinkCreated) {
           await writeFile(generatedFile.path, generatedFile.content || "");
           result.warnings.push(`Could not create symlink for ${generatedFile.path}; wrote a copied file instead.`);
@@ -31251,7 +31611,7 @@ class Propagator {
     });
   }
   async buildAiderConfig(projectPath) {
-    const configPath = resolve9(projectPath, ".aider.conf.yml");
+    const configPath = resolve10(projectPath, ".aider.conf.yml");
     const existingContent = await readFileIfExists(configPath);
     let document = {};
     if (existingContent) {
@@ -31318,14 +31678,14 @@ ${content}
 
 // dist/core/managedState.js
 init_fs();
-import {promises as fs28} from "fs";
-import {dirname as dirname4, join as join6, relative as relative4, resolve as resolve10} from "path";
+import {promises as fs30} from "fs";
+import {dirname as dirname5, join as join7, relative as relative4, resolve as resolve11} from "path";
 var toPosixPath = function(value) {
   return value.replace(/\\/g, "/");
 };
 async function pathType(targetPath) {
   try {
-    const stat = await fs28.lstat(targetPath);
+    const stat = await fs30.lstat(targetPath);
     if (stat.isSymbolicLink()) {
       return "symlink";
     }
@@ -31335,20 +31695,20 @@ async function pathType(targetPath) {
   }
 }
 async function copyDirectory(src, dest) {
-  await fs28.mkdir(dest, { recursive: true });
-  const entries = await fs28.readdir(src, { withFileTypes: true });
+  await fs30.mkdir(dest, { recursive: true });
+  const entries = await fs30.readdir(src, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = join6(src, entry.name);
-    const destPath = join6(dest, entry.name);
+    const srcPath = join7(src, entry.name);
+    const destPath = join7(dest, entry.name);
     if (entry.isDirectory()) {
       await copyDirectory(srcPath, destPath);
     } else if (entry.isSymbolicLink()) {
-      const target = await fs28.readlink(srcPath);
-      await fs28.mkdir(dirname4(destPath), { recursive: true });
-      await fs28.symlink(target, destPath);
+      const target = await fs30.readlink(srcPath);
+      await fs30.mkdir(dirname5(destPath), { recursive: true });
+      await fs30.symlink(target, destPath);
     } else {
-      await fs28.mkdir(dirname4(destPath), { recursive: true });
-      await fs28.copyFile(srcPath, destPath);
+      await fs30.mkdir(dirname5(destPath), { recursive: true });
+      await fs30.copyFile(srcPath, destPath);
     }
   }
 }
@@ -31357,14 +31717,14 @@ async function copyPath(src, dest) {
   if (!type2) {
     return;
   }
-  await fs28.mkdir(dirname4(dest), { recursive: true });
+  await fs30.mkdir(dirname5(dest), { recursive: true });
   if (type2 === "symlink") {
-    const target = await fs28.readlink(src);
-    await fs28.symlink(target, dest);
+    const target = await fs30.readlink(src);
+    await fs30.symlink(target, dest);
   } else if (type2 === "directory") {
     await copyDirectory(src, dest);
   } else {
-    await fs28.copyFile(src, dest);
+    await fs30.copyFile(src, dest);
   }
 }
 var MANAGED_STATE_FILE = "managed-state.json";
@@ -31378,11 +31738,11 @@ class ManagedStateStore {
     this.state = state;
   }
   static async open(projectPath) {
-    const agentInitDir = join6(projectPath, ".agentinit");
-    const statePath = join6(agentInitDir, MANAGED_STATE_FILE);
+    const agentInitDir = join7(projectPath, ".agentinit");
+    const statePath = join7(agentInitDir, MANAGED_STATE_FILE);
     const emptyState = { version: 1, entries: [] };
     try {
-      const raw = await fs28.readFile(statePath, "utf8");
+      const raw = await fs30.readFile(statePath, "utf8");
       const parsed = JSON.parse(raw);
       if (!parsed || parsed.version !== 1 || !Array.isArray(parsed.entries)) {
         return new ManagedStateStore(projectPath, emptyState);
@@ -31393,17 +31753,17 @@ class ManagedStateStore {
     }
   }
   get agentInitDir() {
-    return join6(this.projectPath, ".agentinit");
+    return join7(this.projectPath, ".agentinit");
   }
   get stateFilePath() {
-    return join6(this.agentInitDir, MANAGED_STATE_FILE);
+    return join7(this.agentInitDir, MANAGED_STATE_FILE);
   }
   get backupsDir() {
-    return join6(this.agentInitDir, BACKUPS_DIR);
+    return join7(this.agentInitDir, BACKUPS_DIR);
   }
   normalizeRelativePath(targetPath, preserveTrailingSlash = false) {
     const hasTrailingSlash = preserveTrailingSlash && /[\\/]$/.test(targetPath);
-    const relativePath = relative4(this.projectPath, resolve10(targetPath));
+    const relativePath = relative4(this.projectPath, resolve11(targetPath));
     const normalizedPath = toPosixPath(relativePath);
     if (hasTrailingSlash && normalizedPath) {
       return normalizedPath.endsWith("/") ? normalizedPath : `${normalizedPath}/`;
@@ -31421,14 +31781,14 @@ class ManagedStateStore {
     }
     if (type2 === "symlink") {
       try {
-        const backupLinkTarget = await fs28.readlink(targetPath);
+        const backupLinkTarget = await fs30.readlink(targetPath);
         return { backupLinkTarget };
       } catch {
         return {};
       }
     }
     const relativeTargetPath = this.normalizeRelativePath(targetPath);
-    const backupPath = join6(this.backupsDir, relativeTargetPath);
+    const backupPath = join7(this.backupsDir, relativeTargetPath);
     if (!await fileExists(backupPath)) {
       await copyPath(targetPath, backupPath);
     }
@@ -31463,20 +31823,20 @@ class ManagedStateStore {
     if (this.state.entries.length === 0) {
       return [];
     }
-    const paths5 = new Set([
+    const paths6 = new Set([
       ".agentinit/managed-state.json",
       ".agentinit/backups/"
     ]);
     for (const entry of this.state.entries) {
       if (entry.ignorePath) {
-        paths5.add(entry.ignorePath);
+        paths6.add(entry.ignorePath);
       }
     }
-    return [...paths5];
+    return [...paths6];
   }
   async save() {
-    await fs28.mkdir(this.agentInitDir, { recursive: true });
-    await fs28.writeFile(this.stateFilePath, JSON.stringify(this.state, null, 2), "utf8");
+    await fs30.mkdir(this.agentInitDir, { recursive: true });
+    await fs30.writeFile(this.stateFilePath, JSON.stringify(this.state, null, 2), "utf8");
   }
   async revertAll(options2 = {}) {
     const summary = {
@@ -31486,34 +31846,34 @@ class ManagedStateStore {
     };
     const entries = [...this.state.entries].sort((a, b) => b.path.length - a.path.length);
     for (const entry of entries) {
-      const absolutePath = resolve10(this.projectPath, entry.path);
-      const backupPath = entry.backupPath ? resolve10(this.projectPath, entry.backupPath) : null;
+      const absolutePath = resolve11(this.projectPath, entry.path);
+      const backupPath = entry.backupPath ? resolve11(this.projectPath, entry.backupPath) : null;
       const backupLinkTarget = entry.backupLinkTarget;
       if (entry.existedBefore && backupLinkTarget !== undefined) {
         if (!options2.dryRun) {
-          await fs28.rm(absolutePath, { recursive: true, force: true }).catch(() => {
+          await fs30.rm(absolutePath, { recursive: true, force: true }).catch(() => {
           });
-          await fs28.mkdir(dirname4(absolutePath), { recursive: true });
-          await fs28.symlink(backupLinkTarget, absolutePath);
+          await fs30.mkdir(dirname5(absolutePath), { recursive: true });
+          await fs30.symlink(backupLinkTarget, absolutePath);
         }
         summary.restored++;
       } else if (entry.existedBefore && backupPath && await fileExists(backupPath)) {
         if (!options2.dryRun) {
-          await fs28.rm(absolutePath, { recursive: true, force: true }).catch(() => {
+          await fs30.rm(absolutePath, { recursive: true, force: true }).catch(() => {
           });
           await copyPath(backupPath, absolutePath);
         }
         summary.restored++;
       } else {
         if (!options2.dryRun) {
-          await fs28.rm(absolutePath, { recursive: true, force: true }).catch(() => {
+          await fs30.rm(absolutePath, { recursive: true, force: true }).catch(() => {
           });
         }
         summary.removed++;
       }
       if (!options2.keepBackups && backupPath && await fileExists(backupPath)) {
         if (!options2.dryRun) {
-          await fs28.rm(backupPath, { recursive: true, force: true }).catch(() => {
+          await fs30.rm(backupPath, { recursive: true, force: true }).catch(() => {
           });
         }
         summary.backupsRemoved++;
@@ -31521,16 +31881,16 @@ class ManagedStateStore {
     }
     if (!options2.dryRun) {
       this.state.entries.length = 0;
-      await fs28.rm(this.stateFilePath, { force: true }).catch(() => {
+      await fs30.rm(this.stateFilePath, { force: true }).catch(() => {
       });
       if (!options2.keepBackups) {
-        await fs28.rm(this.backupsDir, { recursive: true, force: true }).catch(() => {
+        await fs30.rm(this.backupsDir, { recursive: true, force: true }).catch(() => {
         });
       }
       try {
-        const remainingEntries = await fs28.readdir(this.agentInitDir);
+        const remainingEntries = await fs30.readdir(this.agentInitDir);
         if (remainingEntries.length === 0) {
-          await fs28.rm(this.agentInitDir, { recursive: true, force: true });
+          await fs30.rm(this.agentInitDir, { recursive: true, force: true });
         }
       } catch {
       }
@@ -31609,6 +31969,8 @@ async function syncCommand(options2) {
 }
 
 // dist/commands/apply.js
+init_colors();
+init_logger();
 import {relative as relative6} from "path";
 
 // dist/types/index.js
@@ -31875,12 +32237,12 @@ class MCPParser {
 // dist/constants/mcp.js
 import {readFileSync as readFileSync2} from "fs";
 import {fileURLToPath} from "url";
-import {dirname as dirname5, join as join7} from "path";
+import {dirname as dirname6, join as join8} from "path";
 var getPackageVersion = function() {
   try {
     const __filename2 = fileURLToPath(import.meta.url);
-    const __dirname2 = dirname5(__filename2);
-    const packageJsonPath = join7(__dirname2, "../../package.json");
+    const __dirname2 = dirname6(__filename2);
+    const packageJsonPath = join8(__dirname2, "../../package.json");
     const packageJson = JSON.parse(readFileSync2(packageJsonPath, "utf-8"));
     return packageJson.version || "1.0.0";
   } catch {
@@ -31911,17 +32273,17 @@ import {readFileSync as readFileSync4} from "fs";
 
 // dist/core/rulesTemplateLoader.js
 var toml = __toESM(require_toml(), 1);
-import {resolve as resolve11, dirname as dirname6} from "path";
+import {resolve as resolve12, dirname as dirname7} from "path";
 import {fileURLToPath as fileURLToPath2} from "url";
 import {readFileSync as readFileSync3, readdirSync, existsSync as existsSync2} from "fs";
 var __filename2 = fileURLToPath2(import.meta.url);
-var __dirname2 = dirname6(__filename2);
+var __dirname2 = dirname7(__filename2);
 
 class RulesTemplateLoader {
   templatesPath;
   templates = new Map;
   constructor() {
-    this.templatesPath = resolve11(__dirname2, "../templates/rules");
+    this.templatesPath = resolve12(__dirname2, "../templates/rules");
     this.loadTemplates();
   }
   loadTemplates() {
@@ -31931,7 +32293,7 @@ class RulesTemplateLoader {
     const files = readdirSync(this.templatesPath).filter((file) => file.endsWith(".toml"));
     for (const file of files) {
       try {
-        const filePath = resolve11(this.templatesPath, file);
+        const filePath = resolve12(this.templatesPath, file);
         const content = readFileSync3(filePath, "utf-8");
         const parsed = toml.default.parse(content);
         const template = {
@@ -37503,7 +37865,7 @@ class Protocol {
   }
   request(request, resultSchema, options2) {
     const { relatedRequestId, resumptionToken, onresumptiontoken } = options2 !== null && options2 !== undefined ? options2 : {};
-    return new Promise((resolve12, reject) => {
+    return new Promise((resolve13, reject) => {
       var _a, _b, _c, _d, _e, _f;
       if (!this._transport) {
         reject(new Error("Not connected"));
@@ -37554,7 +37916,7 @@ class Protocol {
         }
         try {
           const result = resultSchema.parse(response.result);
-          resolve12(result);
+          resolve13(result);
         } catch (error) {
           reject(error);
         }
@@ -37934,7 +38296,7 @@ class StdioClientTransport {
     if (this._process) {
       throw new Error("StdioClientTransport already started! If using Client class, note that connect() calls start() automatically.");
     }
-    return new Promise((resolve12, reject) => {
+    return new Promise((resolve13, reject) => {
       var _a, _b, _c, _d, _e;
       this._process = import_cross_spawn.default(this._serverParams.command, (_a = this._serverParams.args) !== null && _a !== undefined ? _a : [], {
         env: {
@@ -37957,7 +38319,7 @@ class StdioClientTransport {
         (_b2 = this.onerror) === null || _b2 === undefined || _b2.call(this, error);
       });
       this._process.on("spawn", () => {
-        resolve12();
+        resolve13();
       });
       this._process.on("close", (_code) => {
         var _a2;
@@ -38012,16 +38374,16 @@ class StdioClientTransport {
     this._readBuffer.clear();
   }
   send(message) {
-    return new Promise((resolve12) => {
+    return new Promise((resolve13) => {
       var _a;
       if (!((_a = this._process) === null || _a === undefined ? undefined : _a.stdin)) {
         throw new Error("Not connected");
       }
       const json2 = serializeMessage(message);
       if (this._process.stdin.write(json2)) {
-        resolve12();
+        resolve13();
       } else {
-        this._process.stdin.once("drain", resolve12);
+        this._process.stdin.once("drain", resolve13);
       }
     });
   }
@@ -39443,7 +39805,7 @@ class SSEClientTransport {
   _startOrAuth() {
     var _a, _b, _c;
     const fetchImpl = (_c = (_b = (_a = this === null || this === undefined ? undefined : this._eventSourceInit) === null || _a === undefined ? undefined : _a.fetch) !== null && _b !== undefined ? _b : this._fetch) !== null && _c !== undefined ? _c : fetch;
-    return new Promise((resolve12, reject) => {
+    return new Promise((resolve13, reject) => {
       this._eventSource = new EventSource(this._url.href, {
         ...this._eventSourceInit,
         fetch: async (url, init2) => {
@@ -39463,7 +39825,7 @@ class SSEClientTransport {
       this._eventSource.onerror = (event) => {
         var _a2;
         if (event.code === 401 && this._authProvider) {
-          this._authThenStart().then(resolve12, reject);
+          this._authThenStart().then(resolve13, reject);
           return;
         }
         const error = new SseError(event.code, event.message, event);
@@ -39486,7 +39848,7 @@ class SSEClientTransport {
           this.close();
           return;
         }
-        resolve12();
+        resolve13();
       });
       this._eventSource.onmessage = (event) => {
         var _a2, _b2;
@@ -39563,8 +39925,11 @@ class SSEClientTransport {
 
 // dist/core/mcpClient.js
 init_lib();
+init_colors();
+init_logger();
 
 // dist/utils/packageVersion.js
+init_logger();
 function extractExplicitVersion(packageSpec) {
   const versionMatch = packageSpec.match(/@([\d]+\.[\d]+\.[\d]+(?:[-+].+)?$)/);
   if (versionMatch && versionMatch[1]) {
@@ -40150,8 +40515,8 @@ class MCPVerifier {
 }
 
 // dist/core/gitignoreManager.js
-import {promises as fs31} from "fs";
-import {dirname as dirname7, join as join8} from "path";
+import {promises as fs33} from "fs";
+import {dirname as dirname8, join as join9} from "path";
 var normalizeIgnorePath = function(projectPath, value) {
   const relative6 = value.startsWith(projectPath) ? value.slice(projectPath.length + 1) : value;
   const normalized = relative6.replace(/\\/g, "/").replace(/^\/+/, "");
@@ -40197,13 +40562,13 @@ var updateManagedBlock = function(existingContent, entries) {
   }
   return content;
 };
-async function updateManagedIgnoreFile(projectPath, paths5, options2 = {}) {
-  const ignoreFile = options2.local ? join8(".git", "info", "exclude") : ".gitignore";
-  const ignoreFilePath = join8(projectPath, ignoreFile);
+async function updateManagedIgnoreFile(projectPath, paths6, options2 = {}) {
+  const ignoreFile = options2.local ? join9(".git", "info", "exclude") : ".gitignore";
+  const ignoreFilePath = join9(projectPath, ignoreFile);
   if (options2.local) {
-    const gitDir = join8(projectPath, ".git");
+    const gitDir = join9(projectPath, ".git");
     try {
-      const stat = await fs31.stat(gitDir);
+      const stat = await fs33.stat(gitDir);
       if (!stat.isDirectory()) {
         throw new Error;
       }
@@ -40211,24 +40576,24 @@ async function updateManagedIgnoreFile(projectPath, paths5, options2 = {}) {
       throw new Error("Cannot update .git/info/exclude because this project is not a Git repository");
     }
   }
-  const normalizedPaths = [...new Set(paths5.map((path) => normalizeIgnorePath(projectPath, path)).filter(Boolean))].sort();
+  const normalizedPaths = [...new Set(paths6.map((path) => normalizeIgnorePath(projectPath, path)).filter(Boolean))].sort();
   let existingContent = "";
   try {
-    existingContent = await fs31.readFile(ignoreFilePath, "utf8");
+    existingContent = await fs33.readFile(ignoreFilePath, "utf8");
   } catch {
     existingContent = "";
   }
   const updatedContent = updateManagedBlock(existingContent, normalizedPaths);
-  await fs31.mkdir(dirname7(ignoreFilePath), { recursive: true });
-  await fs31.writeFile(ignoreFilePath, updatedContent, "utf8");
+  await fs33.mkdir(dirname8(ignoreFilePath), { recursive: true });
+  await fs33.writeFile(ignoreFilePath, updatedContent, "utf8");
   return ignoreFilePath;
 }
 async function removeManagedIgnoreBlock(projectPath, options2 = {}) {
-  const ignoreFile = options2.local ? join8(".git", "info", "exclude") : ".gitignore";
-  const ignoreFilePath = join8(projectPath, ignoreFile);
+  const ignoreFile = options2.local ? join9(".git", "info", "exclude") : ".gitignore";
+  const ignoreFilePath = join9(projectPath, ignoreFile);
   let content;
   try {
-    content = await fs31.readFile(ignoreFilePath, "utf8");
+    content = await fs33.readFile(ignoreFilePath, "utf8");
   } catch {
     return false;
   }
@@ -40244,13 +40609,13 @@ async function removeManagedIgnoreBlock(projectPath, options2 = {}) {
   const afterBlock = content.slice(endIndex + END_MARKER.length).replace(/^\n+/, "");
   let nextContent = `${beforeBlock}${afterBlock}`.replace(/\n{3,}/g, "\n\n").replace(/^\n+/, "");
   if (nextContent.trim() === "") {
-    await fs31.rm(ignoreFilePath, { force: true }).catch(() => {
+    await fs33.rm(ignoreFilePath, { force: true }).catch(() => {
     });
   } else {
     if (!nextContent.endsWith("\n")) {
       nextContent += "\n";
     }
-    await fs31.writeFile(ignoreFilePath, nextContent, "utf8");
+    await fs33.writeFile(ignoreFilePath, nextContent, "utf8");
   }
   return true;
 }
@@ -40261,12 +40626,12 @@ var END_MARKER = "# END AgentInit Generated Files";
 init_agentManager();
 init_skillsManager();
 init_fs();
-import {dirname as dirname8, join as join9} from "path";
+import {dirname as dirname9, join as join10} from "path";
 async function discoverProjectSkills(projectPath, skillsManager4) {
   const sources = [];
   const skills2 = new Map;
   for (const sourceDir of PROJECT_SKILL_SOURCE_DIRS) {
-    const absoluteSourceDir = join9(projectPath, sourceDir);
+    const absoluteSourceDir = join10(projectPath, sourceDir);
     if (!await fileExists(absoluteSourceDir)) {
       continue;
     }
@@ -40339,7 +40704,7 @@ async function applyProjectSkills(projectPath, targetAgentIds, managedState2, op
             await managedState2.trackGeneratedPath(generatedPath, {
               kind: "directory",
               source: "skills",
-              ignorePath: `${dirname8(generatedPath)}/`
+              ignorePath: `${dirname9(generatedPath)}/`
             });
           }
         }
@@ -40910,6 +41275,7 @@ var LEGACY_APPLY_FLAGS = new Set([
 ]);
 
 // dist/commands/verifyMcp.js
+init_logger();
 init_agentManager();
 async function verifyMcpCommand(args) {
   const cwd = process.cwd();
@@ -41115,6 +41481,7 @@ async function verifyMcpCommand(args) {
 }
 
 // dist/commands/revert.js
+init_logger();
 async function revertCommand(options2) {
   const cwd = process.cwd();
   logger.titleBox("AgentInit  Revert");
@@ -41159,6 +41526,7 @@ async function revertCommand(options2) {
 }
 
 // dist/utils/colors.js
+init_colors();
 var colorsEnabled = function() {
   const env2 = process.env || {};
   const isTTY2 = !!process.stdout?.isTTY;
@@ -41172,6 +41540,7 @@ function orange(text) {
 }
 
 // dist/commands/config.js
+init_logger();
 init_marketplaceRegistry();
 init_userConfig();
 var sortConfig = function(config) {
@@ -41348,12 +41717,15 @@ var BUILT_IN_VERIFIED_REPOS = new Set(getBuiltInVerifiedGithubRepos());
 
 // dist/commands/skills.js
 var import_prompts3 = __toESM(require_prompts3(), 1);
-import {homedir as homedir6} from "os";
-import {relative as relative7, resolve as resolve12} from "path";
+init_colors();
+init_logger();
+import {homedir as homedir7} from "os";
+import {relative as relative7, resolve as resolve13} from "path";
 
 // dist/utils/promptUtils.js
 var import_prompts2 = __toESM(require_prompts3(), 1);
 import {createRequire as createRequire2} from "module";
+init_logger();
 function enableUppercaseToggleAllForMultiselectPrompt() {
   if (uppercaseToggleAllPatched) {
     return;
@@ -41418,6 +41790,8 @@ init_skillsManager();
 init_pluginManager();
 init_marketplaceRegistry();
 init_agentManager();
+init_installLock();
+init_fs();
 init_skills();
 function registerSkillsCommand(program2) {
   const marketplaceHelp = getMarketplaceIds().join(", ");
@@ -41500,9 +41874,24 @@ function registerSkillsCommand(program2) {
     }
     let targetAgents = options2.agent;
     let targetGlobal = options2.global;
+    let selectedSkillNames = options2.skill;
+    if (!options2.yes && (!selectedSkillNames || selectedSkillNames.length === 0) && preparedSkills.length > 1) {
+      if (selectedPluginNames && selectedPluginNames.length > 1) {
+        logger.info("Multiple bundled plugins selected; installing all skills from each selected plugin. Use --skill to filter by skill name.");
+      } else {
+        const skillSelection = await resolveInteractiveSkillSelection(preparedSkills);
+        if (skillSelection.aborted) {
+          await skillsManager5.discardPreparedSource(source, process.cwd(), {
+            from: options2.from
+          });
+          return;
+        }
+        selectedSkillNames = skillSelection.skills;
+      }
+    }
     if (!targetAgents && !options2.yes) {
-      const selectedSkillNames = options2.skill && options2.skill.length > 0 ? new Set(options2.skill.map((name) => name.toLowerCase())) : undefined;
-      const filteredPreviewSkills = selectedSkillNames ? preparedSkills.filter((skill) => selectedSkillNames.has(skill.name.toLowerCase())) : preparedSkills;
+      const selectedSkillNameSet = selectedSkillNames && selectedSkillNames.length > 0 ? new Set(selectedSkillNames.map((name) => name.toLowerCase())) : undefined;
+      const filteredPreviewSkills = selectedSkillNameSet ? preparedSkills.filter((skill) => selectedSkillNameSet.has(skill.name.toLowerCase())) : preparedSkills;
       const selection = await resolveInteractiveSkillTargets(skillsManager5, agentManager9, source, process.cwd(), {
         from: options2.from,
         global: options2.global,
@@ -41534,7 +41923,7 @@ function registerSkillsCommand(program2) {
       ...options2.from !== undefined ? { from: options2.from } : {},
       ...targetGlobal !== undefined ? { global: targetGlobal } : {},
       ...targetAgents !== undefined ? { agents: targetAgents } : {},
-      ...options2.skill !== undefined ? { skills: options2.skill } : {},
+      ...selectedSkillNames !== undefined ? { skills: selectedSkillNames } : {},
       ...options2.copy !== undefined ? { copy: options2.copy } : {},
       ...pluginName !== undefined ? { pluginName } : {},
       ...options2.yes !== undefined ? { yes: options2.yes } : {},
@@ -41633,7 +42022,221 @@ function registerSkillsCommand(program2) {
       logger.info("Nothing to remove.");
     }
   });
+  skills3.command("update [name]").description("Update installed skills from their original source").option("--everywhere", "Update across all tracked projects (uses global lockfile)").option("-d, --dry-run", "Show what would be updated without making changes").action(async (name, options2) => {
+    logger.titleBox("AgentInit  Skills");
+    const installLock3 = new InstallLock;
+    if (options2.everywhere) {
+      if (!name) {
+        logger.error("Skill name is required with --everywhere.");
+        logger.info("Usage: agentinit skills update <name> --everywhere");
+        return;
+      }
+      const entries = await installLock3.findProjectsWithSkill(name);
+      if (entries.length === 0) {
+        logger.info(`No tracked installations found for skill "${name}".`);
+        logger.info(dim("Install the skill first, then update with --everywhere."));
+        return;
+      }
+      logger.info(`Found ${cyan(String(entries.length))} tracked target(s) with skill "${green(name)}":\n`);
+      const staleProjects = [];
+      const updateTargets = [];
+      for (const entry of entries) {
+        const targetLabel = getLockEntryTargetLabel(entry);
+        if (entry.scope !== "global" && !await fileExists(entry.projectPath)) {
+          staleProjects.push(entry.projectPath);
+          logger.info(`  ${red("x")} ${targetLabel} ${dim("(missing)")}`);
+        } else {
+          updateTargets.push(entry);
+          logger.info(`  ${green("+")} ${targetLabel} ${dim(`[${entry.agents.join(", ")}]`)}`);
+        }
+      }
+      if (staleProjects.length > 0) {
+        logger.info("");
+        logger.warn(`${staleProjects.length} project(s) no longer exist. Run "agentinit lock prune" to clean up.`);
+      }
+      if (updateTargets.length === 0) {
+        logger.info("\nNo valid projects to update.");
+        return;
+      }
+      if (options2.dryRun) {
+        logger.info(dim(`
+Dry run \u2014 no changes made.`));
+        return;
+      }
+      logger.info("");
+      const spinner = ora("Updating skills across projects...").start();
+      let updatedCount = 0;
+      let unchangedCount = 0;
+      let failedCount = 0;
+      for (const entry of updateTargets) {
+        spinner.text = `Updating in ${getLockEntryTargetLabel(entry)}...`;
+        try {
+          const sourceString = lockSourceToString(entry.source);
+          if (!sourceString) {
+            failedCount++;
+            logger.info(`  ${red("x")} ${getLockEntryTargetLabel(entry)}: cannot reconstruct source`);
+            continue;
+          }
+          const agentManager9 = new AgentManager;
+          const skillsManager5 = new SkillsManager(agentManager9);
+          const result = await skillsManager5.addFromSource(sourceString.source, entry.projectPath, {
+            ...sourceString.from ? { from: sourceString.from } : {},
+            agents: entry.agents,
+            global: entry.scope === "global",
+            skills: [name],
+            yes: true
+          });
+          if (result.updated.length > 0) {
+            updatedCount++;
+            logger.info(`  ${green("~")} ${getLockEntryTargetLabel(entry)}: updated`);
+          } else if (result.installed.length > 0) {
+            updatedCount++;
+            logger.info(`  ${green("+")} ${getLockEntryTargetLabel(entry)}: installed`);
+          } else {
+            unchangedCount++;
+            logger.info(`  ${dim("-")} ${getLockEntryTargetLabel(entry)}: ${dim("unchanged")}`);
+          }
+        } catch (error) {
+          failedCount++;
+          logger.info(`  ${red("x")} ${getLockEntryTargetLabel(entry)}: ${error instanceof Error ? error.message : "unknown error"}`);
+        }
+      }
+      if (updatedCount > 0) {
+        spinner.succeed(`Updated "${name}" in ${updatedCount} target(s)`);
+      } else {
+        spinner.info(`"${name}" is already up to date in all tracked targets`);
+      }
+      if (unchangedCount > 0)
+        logger.info(dim(`  ${unchangedCount} unchanged`));
+      if (failedCount > 0)
+        logger.info(red(`  ${failedCount} failed`));
+    } else {
+      const cwd = process.cwd();
+      const agentManager9 = new AgentManager;
+      const skillsManager5 = new SkillsManager(agentManager9);
+      if (name) {
+        const entries = await installLock3.getCurrentState({
+          kind: "skill",
+          name,
+          projectPath: resolve13(cwd),
+          scope: "project"
+        });
+        if (entries.length === 0) {
+          logger.info(`Skill "${name}" not tracked in the lockfile for this project.`);
+          logger.info(dim("Try: agentinit skills add <source> or use --everywhere for global installs."));
+          return;
+        }
+        if (options2.dryRun) {
+          logger.info(`Would update "${name}" in ${entries.length} tracked target(s):`);
+          for (const entry of entries) {
+            const sourceString = lockSourceToString(entry.source);
+            logger.info(`  ${green(entry.name)} ${dim(`[${entry.agents.join(", ")}]`)} ${sourceString ? dim(sourceString.source) : red("unavailable source")}`);
+          }
+          return;
+        }
+        const spinner = ora(`Updating skill "${name}"...`).start();
+        let updatedCount = 0;
+        let unchangedCount = 0;
+        let failedCount = 0;
+        for (const entry of entries) {
+          const sourceString = lockSourceToString(entry.source);
+          if (!sourceString) {
+            failedCount++;
+            continue;
+          }
+          try {
+            const result = await skillsManager5.addFromSource(sourceString.source, cwd, {
+              ...sourceString.from ? { from: sourceString.from } : {},
+              agents: entry.agents,
+              global: entry.scope === "global",
+              skills: [name],
+              yes: true
+            });
+            if (result.updated.length > 0 || result.installed.length > 0) {
+              updatedCount++;
+            } else {
+              unchangedCount++;
+            }
+          } catch {
+            failedCount++;
+          }
+        }
+        if (updatedCount > 0) {
+          spinner.succeed(`Updated "${name}" in ${updatedCount} target(s)`);
+        } else {
+          spinner.info(`"${name}" is already up to date`);
+        }
+        if (unchangedCount > 0)
+          logger.info(dim(`  ${unchangedCount} unchanged`));
+        if (failedCount > 0)
+          logger.info(red(`  ${failedCount} failed`));
+      } else {
+        const entries = await installLock3.getCurrentState({
+          kind: "skill",
+          projectPath: resolve13(cwd),
+          scope: "project"
+        });
+        if (entries.length === 0) {
+          logger.info("No skills tracked in the lockfile for this project.");
+          return;
+        }
+        if (options2.dryRun) {
+          logger.info(`Would update ${entries.length} skill(s):`);
+          for (const entry of entries) {
+            logger.info(`  ${green(entry.name)} ${dim(`[${entry.agents.join(", ")}]`)}`);
+          }
+          return;
+        }
+        const spinner = ora("Updating all skills...").start();
+        let updatedCount = 0;
+        for (const entry of entries) {
+          const sourceString = lockSourceToString(entry.source);
+          if (!sourceString)
+            continue;
+          spinner.text = `Updating "${entry.name}"...`;
+          try {
+            const result = await skillsManager5.addFromSource(sourceString.source, cwd, {
+              ...sourceString.from ? { from: sourceString.from } : {},
+              agents: entry.agents,
+              global: entry.scope === "global",
+              skills: [entry.name],
+              yes: true
+            });
+            if (result.updated.length > 0 || result.installed.length > 0) {
+              updatedCount++;
+            }
+          } catch {
+          }
+        }
+        if (updatedCount > 0) {
+          spinner.succeed(`Updated ${updatedCount} skill(s)`);
+        } else {
+          spinner.info("All skills are up to date");
+        }
+      }
+    }
+  });
 }
+var lockSourceToString = function(source) {
+  if (source.type === "marketplace" && source.marketplace && source.pluginName) {
+    return { source: source.pluginName, from: source.marketplace };
+  }
+  if (source.type === "github") {
+    if (source.owner && source.repo) {
+      if (source.subpath) {
+        return { source: `${source.owner}/${source.repo}/${source.subpath}` };
+      }
+      return { source: `${source.owner}/${source.repo}` };
+    }
+    if (source.url) {
+      return { source: source.url };
+    }
+  }
+  if (source.type === "local" && source.path) {
+    return { source: source.path };
+  }
+  return null;
+};
 async function resolveInteractiveSkillTargets(skillsManager5, agentManager9, source, projectPath, options2) {
   let installGlobal = !!options2.global;
   if (!options2.global) {
@@ -41706,6 +42309,24 @@ async function resolveInteractiveSkillTargets(skillsManager5, agentManager9, sou
   }
   return selection;
 }
+async function resolveInteractiveSkillSelection(skills3) {
+  const response = await promptMultiselect({
+    name: "skills",
+    message: `Select skills to install (${skills3.length} found):`,
+    min: 1,
+    choices: skills3.map((skill) => ({
+      title: skill.name,
+      value: skill.name,
+      description: skill.description,
+      selected: true
+    }))
+  });
+  if (!response.skills || response.skills.length === 0) {
+    logger.info("No skills selected. Aborting.");
+    return { aborted: true };
+  }
+  return { skills: response.skills };
+}
 async function getDetectedSkillGroups(agentManager9, projectPath, global3) {
   const detectedAgents = (await agentManager9.detectAgents(projectPath)).map((entry) => entry.agent);
   const groups = buildSkillGroups(detectedAgents, projectPath, global3);
@@ -41739,7 +42360,7 @@ var buildSkillGroups = function(agents, projectPath, global3) {
     dirToAgents.set(skillsDir, existing);
   }
   return Array.from(dirToAgents.entries()).map(([dir, groupedAgents]) => {
-    const canonicalShared = resolve12(dir) === getCanonicalSkillsDirForScope(projectPath, !!global3) && groupedAgents.every((agent) => agent.getProjectSkillsStandard() === "agents");
+    const canonicalShared = resolve13(dir) === getCanonicalSkillsDirForScope(projectPath, !!global3) && groupedAgents.every((agent) => agent.getProjectSkillsStandard() === "agents");
     return {
       dir,
       displayDir: formatSkillsDir(projectPath, dir),
@@ -41762,7 +42383,7 @@ var prependCanonicalGlobalGroup = function(agentManager9, projectPath, groups) {
   if (sharedAgents.length === 0) {
     return groups;
   }
-  const existingCanonicalIndex = groups.findIndex((group) => resolve12(group.dir) === canonicalDir);
+  const existingCanonicalIndex = groups.findIndex((group) => resolve13(group.dir) === canonicalDir);
   if (existingCanonicalIndex >= 0) {
     const existingCanonical = groups[existingCanonicalIndex];
     const remaining = groups.filter((_, index) => index !== existingCanonicalIndex);
@@ -41798,7 +42419,7 @@ var prependCanonicalGlobalGroup = function(agentManager9, projectPath, groups) {
 var formatSkillsDir = function(projectPath, dir) {
   const normalizedDir = dir.replace(/\\/g, "/").replace(/\/?$/, "/");
   const normalizedProjectPath = projectPath.replace(/\\/g, "/");
-  const normalizedHome = homedir6().replace(/\\/g, "/");
+  const normalizedHome = homedir7().replace(/\\/g, "/");
   if (normalizedDir.startsWith(`${normalizedProjectPath}/`)) {
     return `${relative7(projectPath, dir).replace(/\\/g, "/").replace(/\/?$/, "/")}`;
   }
@@ -41809,7 +42430,7 @@ var formatSkillsDir = function(projectPath, dir) {
 };
 var formatPromptPath = function(path) {
   const normalizedPath = path.replace(/\\/g, "/").replace(/\/?$/, "/");
-  const normalizedHome = homedir6().replace(/\\/g, "/");
+  const normalizedHome = homedir7().replace(/\\/g, "/");
   if (normalizedPath === `${normalizedHome}/`) {
     return "~/";
   }
@@ -41819,10 +42440,10 @@ var formatPromptPath = function(path) {
   return normalizedPath;
 };
 var getCanonicalGlobalSkillsDir = function() {
-  return resolve12(homedir6(), ".agents/skills");
+  return resolve13(homedir7(), ".agents/skills");
 };
 var getCanonicalSkillsDirForScope = function(projectPath, global3) {
-  return global3 ? getCanonicalGlobalSkillsDir() : resolve12(projectPath, ".agents/skills");
+  return global3 ? getCanonicalGlobalSkillsDir() : resolve13(projectPath, ".agents/skills");
 };
 var getCanonicalGlobalSkillsDisplayPath = function() {
   return formatPromptPath(getCanonicalGlobalSkillsDir());
@@ -41854,7 +42475,11 @@ async function buildSkillGroupPreviewDescription(skillsManager5, group, projectP
   })));
   const unchanged = statuses.filter((entry) => entry.status === "unchanged").map((entry) => entry.skill.name);
   const changed = statuses.filter((entry) => entry.status === "changed").map((entry) => entry.skill.name);
+  const fresh = statuses.filter((entry) => entry.status === "new").map((entry) => entry.skill.name);
   const parts = [];
+  if (fresh.length > 0) {
+    parts.push(`Will install: ${fresh.join(", ")}`);
+  }
   if (unchanged.length > 0) {
     parts.push(`Already up to date: ${unchanged.join(", ")}`);
   }
@@ -42052,8 +42677,11 @@ var displayInstallResult = function(result, spinner, agentManager9, skillsManage
 };
 
 // dist/commands/mcp.js
+init_colors();
+init_logger();
 init_mcpFilter();
 init_agentManager();
+init_installLock();
 var filterMcpArgs = function(args) {
   const filtered = [];
   let i = 0;
@@ -42245,6 +42873,28 @@ var registerAddCommand = function(mcp) {
             logger.info(`  ${cyan(server.name)} (${typeLabel}): ${server.url}`);
           }
         });
+        try {
+          const lock = new InstallLock;
+          const lockSource = { type: "local" };
+          for (const plan of plans) {
+            for (const server of plan.servers) {
+              await lock.recordMcp({
+                action: "install",
+                name: server.name,
+                projectPath: cwd,
+                agents: [plan.agent.id],
+                scope: plan.isGlobal ? "global" : "project",
+                source: lockSource,
+                configPath: plan.configPath,
+                serverType: server.type,
+                ...server.command ? { command: server.command } : {},
+                ...server.url ? { url: server.url } : {}
+              });
+            }
+          }
+        } catch (error) {
+          logLockWriteWarning("MCP servers were added successfully", error);
+        }
       }
     } catch (error) {
       spinner.fail("Failed to add MCP servers");
@@ -42338,8 +42988,12 @@ var registerRemoveCommand = function(mcp) {
       }
       let removedCount = 0;
       let failedCount = 0;
+      const removedTargets = [];
       for (const { agent, isGlobal: global3 } of targets) {
         try {
+          const configPath = global3 ? agent.getGlobalMcpPath() : agent.getNativeMcpPath(cwd);
+          const existingServers = global3 ? await agent.getGlobalMCPServers().catch(() => []) : await agent.getMCPServers(cwd).catch(() => []);
+          const existingServer = existingServers.find((server) => server.name.toLowerCase() === name.toLowerCase());
           let removed;
           if (global3) {
             removed = await agent.removeGlobalMCPServer(name);
@@ -42348,6 +43002,14 @@ var registerRemoveCommand = function(mcp) {
           }
           if (removed) {
             removedCount++;
+            if (configPath) {
+              removedTargets.push({
+                agent,
+                isGlobal: global3,
+                configPath,
+                ...existingServer ? { server: existingServer } : {}
+              });
+            }
             logger.info(`  ${green("-")} ${agent.name}: removed "${name}"`);
           } else {
             logger.info(`  ${yellow("~")} ${agent.name}: "${name}" not found`);
@@ -42359,6 +43021,25 @@ var registerRemoveCommand = function(mcp) {
       }
       if (removedCount > 0) {
         spinner.succeed(`Removed "${name}" from ${removedCount} agent(s)`);
+        try {
+          const lock = new InstallLock;
+          for (const { agent, isGlobal: global3, configPath, server } of removedTargets) {
+            await lock.recordMcp({
+              action: "remove",
+              name,
+              projectPath: cwd,
+              agents: [agent.id],
+              scope: global3 ? "global" : "project",
+              source: { type: "local" },
+              configPath,
+              serverType: server?.type || "stdio",
+              ...server?.command ? { command: server.command } : {},
+              ...server?.url ? { url: server.url } : {}
+            });
+          }
+        } catch (error) {
+          logLockWriteWarning("MCP servers were removed successfully", error);
+        }
       } else if (failedCount > 0) {
         spinner.fail(`Failed to remove "${name}"`);
       } else {
@@ -42547,8 +43228,11 @@ var KNOWN_ADD_OPTIONS = {
 };
 
 // dist/commands/rules.js
+init_colors();
+init_logger();
 init_agentManager();
 init_fs();
+init_installLock();
 var colorizeTokenCount2 = function(tokenCount) {
   if (tokenCount <= TOKEN_COUNT_THRESHOLDS.LOW)
     return green(tokenCount.toString());
@@ -42737,6 +43421,29 @@ function registerRulesCommand(program2) {
           }
         }
       }
+      try {
+        const lock = new InstallLock;
+        for (const { agent, result } of results) {
+          if (!result.success || result.rulesApplied === 0)
+            continue;
+          const sections = result.mergedSections || uniqueSections;
+          for (const section of sections) {
+            await lock.recordRules({
+              action: "install",
+              name: section.templateId,
+              projectPath: cwd,
+              agents: [agent.id],
+              scope: isGlobal ? "global" : "project",
+              source: { type: "local" },
+              configPath: result.configPath || "",
+              templateIds: [section.templateId],
+              ruleCount: section.rules.length
+            });
+          }
+        }
+      } catch (error) {
+        logLockWriteWarning("Rules were applied successfully", error);
+      }
     } catch (error) {
       spinner.fail("Failed to apply rules");
       logger.error(`Error: ${error instanceof Error ? error.message : "Unknown error"}`);
@@ -42799,6 +43506,7 @@ function registerRulesCommand(program2) {
     const agents = await resolveTargetAgents(agentManager11, options2, cwd);
     const spinner = ora("Removing rules...").start();
     let totalRemoved = 0;
+    const removedSections = [];
     try {
       for (const agent of agents) {
         if (!agent.capabilities.rules) {
@@ -42822,6 +43530,9 @@ function registerRulesCommand(program2) {
         const updatedContent = await agent.applyRulesConfig(configPath, buildAppliedRules(remaining), content);
         await writeFile(configPath, updatedContent);
         totalRemoved += removed.length;
+        for (const section of removed) {
+          removedSections.push({ agent, configPath, section });
+        }
         for (const s of removed) {
           logger.info(`  ${agent.name}: removed ${green(s.templateName)} (${s.rules.length} rules)`);
         }
@@ -42831,6 +43542,24 @@ function registerRulesCommand(program2) {
         logger.info('Run "agentinit rules list" to see current sections.');
       } else {
         spinner.succeed(`Removed ${totalRemoved} rule section${totalRemoved !== 1 ? "s" : ""}`);
+        try {
+          const lock = new InstallLock;
+          for (const { agent, configPath, section } of removedSections) {
+            await lock.recordRules({
+              action: "remove",
+              name: section.templateId,
+              projectPath: cwd,
+              agents: [agent.id],
+              scope: isGlobal ? "global" : "project",
+              source: { type: "local" },
+              configPath,
+              templateIds: [section.templateId],
+              ruleCount: 0
+            });
+          }
+        } catch (error) {
+          logLockWriteWarning("Rules were removed successfully", error);
+        }
       }
     } catch (error) {
       spinner.fail("Failed to remove rules");
@@ -42842,8 +43571,9 @@ function registerRulesCommand(program2) {
 
 // dist/commands/plugins.js
 var import_prompts4 = __toESM(require_prompts3(), 1);
-import {homedir as homedir7} from "os";
-import {dirname as dirname9, relative as relative8, resolve as resolve13} from "path";
+import {homedir as homedir8} from "os";
+import {dirname as dirname10, relative as relative8, resolve as resolve14} from "path";
+init_logger();
 init_pluginManager();
 init_agentManager();
 init_marketplaceRegistry();
@@ -43385,7 +44115,7 @@ var renderPluginWarnings = function(previewOrResult, projectPath) {
 var renderInstalledComponents = function(result, agentManager12, projectPath) {
   const skillGroups = new Map;
   for (const item of result.skills.installed) {
-    const targetDir = dirname9(item.path);
+    const targetDir = dirname10(item.path);
     const existing = skillGroups.get(targetDir) || { agents: new Set, skillNames: new Set };
     existing.agents.add(item.agent);
     existing.skillNames.add(item.name);
@@ -43463,7 +44193,7 @@ var buildGlobalPluginGroups = function(agentManager12, projectPath) {
     compatibleAgentNames: [],
     kind: "native"
   }));
-  const canonicalDir = resolve13(homedir7(), ".agents/skills");
+  const canonicalDir = resolve14(homedir8(), ".agents/skills");
   const sharedAgents = agentManager12.getAllAgents().filter((agent) => agent.supportsSkills() && agent.getProjectSkillsStandard() === "agents" && !!agent.getSkillsDir(projectPath, true));
   const claudeGroups = nativeGroups.filter((group) => group.agents.some((agent) => agent.id === "claude"));
   const otherGroups = nativeGroups.filter((group) => !group.agents.some((agent) => agent.id === "claude"));
@@ -43573,7 +44303,161 @@ async function interactiveAgentSelect(pluginManager3, agentManager12, projectPat
   } : undefined;
 }
 
+// dist/commands/lock.js
+init_colors();
+init_logger();
+init_installLock();
+import {resolve as resolve15} from "path";
+var formatTimestamp = function(iso) {
+  const date = new Date(iso);
+  return date.toLocaleDateString("en-US", {
+    month: "short",
+    day: "numeric",
+    year: "numeric"
+  });
+};
+var formatKind = function(kind) {
+  switch (kind) {
+    case "skill":
+      return cyan("skill");
+    case "mcp":
+      return yellow("mcp");
+    case "rules":
+      return green("rules");
+  }
+};
+var formatSource = function(entry) {
+  const src = entry.source;
+  if (src.type === "marketplace" && src.marketplace) {
+    return `${src.marketplace}/${src.pluginName || ""}`;
+  }
+  if (src.type === "github") {
+    if (src.owner && src.repo) {
+      return src.subpath ? `${src.owner}/${src.repo}/${src.subpath}` : `${src.owner}/${src.repo}`;
+    }
+    return src.url || "github";
+  }
+  if (src.type === "local" && src.path) {
+    return src.path;
+  }
+  return src.type;
+};
+function registerLockCommand(program2) {
+  const lock = program2.command("lock").description("View and manage the global install lockfile");
+  lock.command("list").alias("ls").description("List all tracked installations across projects").option("--kind <kind>", "Filter by kind: skill, mcp, rules").option("--project <path>", "Filter by project path").option("--agent <agent>", "Filter by agent ID").option("--scope <scope>", "Filter by scope: project or global").action(async (options2) => {
+    const installLock6 = new InstallLock;
+    const queryOptions = {};
+    if (options2.kind)
+      queryOptions.kind = options2.kind;
+    if (options2.project)
+      queryOptions.projectPath = resolve15(options2.project);
+    if (options2.agent)
+      queryOptions.agent = options2.agent;
+    if (options2.scope)
+      queryOptions.scope = options2.scope;
+    const entries = await installLock6.getCurrentState(queryOptions);
+    if (entries.length === 0) {
+      logger.info("No installations tracked in the lockfile.");
+      logger.info(dim("Install skills, MCPs, or rules to start tracking."));
+      return;
+    }
+    const byProject = new Map;
+    for (const entry of entries) {
+      const key = entry.scope === "global" ? "global" : entry.projectPath;
+      const group = byProject.get(key) || { label: getLockEntryTargetLabel(entry), entries: [] };
+      group.entries.push(entry);
+      byProject.set(key, group);
+    }
+    for (const { label, entries: projectEntries } of byProject.values()) {
+      logger.info(`\n${cyan(label)}`);
+      for (const entry of projectEntries) {
+        const kind = formatKind(entry.kind);
+        const scope = entry.scope === "global" ? dim(" (global)") : "";
+        const agents = dim(`[${entry.agents.join(", ")}]`);
+        const date = dim(formatTimestamp(entry.timestamp));
+        const source = dim(formatSource(entry));
+        logger.info(`  ${kind}  ${green(entry.name)}  ${agents}${scope}  ${source}  ${date}`);
+      }
+    }
+    logger.info("");
+    logger.info(dim(`${entries.length} installation(s) across ${byProject.size} target(s)`));
+  });
+  lock.command("status").description("Show summary of tracked installations").option("--check-drift", "Check for modified skill files (compares content hashes)").action(async (options2) => {
+    const installLock6 = new InstallLock;
+    const entries = await installLock6.getCurrentState();
+    if (entries.length === 0) {
+      logger.info("No installations tracked in the lockfile.");
+      return;
+    }
+    const projects = new Set(entries.filter((entry) => entry.scope === "project").map((entry) => entry.projectPath));
+    const globalTargets = entries.filter((entry) => entry.scope === "global");
+    const skills3 = entries.filter((e) => e.kind === "skill");
+    const mcps = entries.filter((e) => e.kind === "mcp");
+    const rules = entries.filter((e) => e.kind === "rules");
+    logger.info(`Projects: ${cyan(projects.size.toString())}`);
+    logger.info(`Global targets: ${cyan(globalTargets.length.toString())}`);
+    logger.info(`Skills:   ${green(skills3.length.toString())}`);
+    logger.info(`MCPs:     ${yellow(mcps.length.toString())}`);
+    logger.info(`Rules:    ${green(rules.length.toString())}`);
+    const stale = await installLock6.findStaleProjects();
+    if (stale.length > 0) {
+      logger.info("");
+      logger.info(`${red("Stale projects:")} ${stale.length}`);
+      for (const path of stale) {
+        logger.info(`  ${red("x")} ${path}`);
+      }
+      logger.info(dim('Run "agentinit lock prune" to clean up.'));
+    }
+    if (options2.checkDrift) {
+      logger.info("");
+      logger.info("Checking for drift...");
+      let driftCount = 0;
+      let missingCount = 0;
+      for (const entry of skills3) {
+        if (!entry.contentHash)
+          continue;
+        const result = await installLock6.checkDrift(entry);
+        if (result.status === "drift") {
+          driftCount++;
+          logger.info(`  ${yellow("~")} ${entry.name} in ${entry.projectPath}`);
+        } else if (result.status === "missing") {
+          missingCount++;
+          logger.info(`  ${red("x")} ${entry.name} in ${entry.projectPath} ${dim("(missing)")}`);
+        }
+      }
+      if (driftCount === 0 && missingCount === 0) {
+        logger.info(`  ${green("All skills match their installed hashes.")}`);
+      } else {
+        if (driftCount > 0)
+          logger.info(`  ${driftCount} skill(s) modified since install`);
+        if (missingCount > 0)
+          logger.info(`  ${missingCount} skill(s) missing from disk`);
+      }
+    }
+  });
+  lock.command("prune").description("Remove entries for projects that no longer exist on disk").option("-d, --dry-run", "Show what would be removed without changing the lockfile").action(async (options2) => {
+    const installLock6 = new InstallLock;
+    const stale = await installLock6.findStaleProjects();
+    if (stale.length === 0) {
+      logger.info("No stale projects found. Lockfile is clean.");
+      return;
+    }
+    logger.info(`Found ${stale.length} stale project(s):`);
+    for (const path of stale) {
+      logger.info(`  ${red("x")} ${path}`);
+    }
+    if (options2.dryRun) {
+      logger.info(dim(`
+Dry run \u2014 no changes made.`));
+      return;
+    }
+    const result = await installLock6.pruneStaleEntries();
+    logger.info(`\nRemoved ${result.entriesRemoved} entries for ${result.prunedProjects.length} stale project(s).`);
+  });
+}
+
 // dist/cli.js
+init_logger();
 var program2 = new Command;
 program2.name("agentinit").description("A CLI tool for managing and configuring AI coding agents").version("1.0.1");
 registerSkillsCommand(program2);
@@ -43581,6 +44465,7 @@ registerMcpCommand(program2);
 registerRulesCommand(program2);
 registerPluginsCommand(program2);
 registerConfigCommand(program2);
+registerLockCommand(program2);
 program2.command("init").description("Initialize agents.md configuration for the current project").option("-f, --force", "Overwrite existing configuration").option("-t, --template <template>", "Use specific template (web, cli, library)").action(initCommand);
 program2.command("detect").description("Detect current project stack and existing agent configurations").option("-v, --verbose", "Show detailed detection results").action(detectCommand);
 program2.command("sync").description("Sync agents.md with agent-specific configuration files").option("-a, --agent <agents...>", "Target specific agent(s)").option("-d, --dry-run", "Show what would be changed without making changes").option("-b, --backup", "Create backup before syncing").action(syncCommand);