agentinit 1.16.0 → 1.16.2

package/dist/cli.js

@@ -17312,6 +17312,8 @@ class PluginManager {
       (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")),
@@ -17321,10 +17323,12 @@ class PluginManager {
       ...featureChecks[0] ? ["commands"] : [],
       ...featureChecks[1] ? ["hooks"] : [],
       ...featureChecks[2] ? ["agents"] : [],
-      ...featureChecks[3] ? ["prompts"] : [],
-      ...featureChecks[4] ? ["schemas"] : [],
-      ...featureChecks[5] ? ["scripts"] : [],
-      ...featureChecks[6] ? ["templates"] : []
+      ...featureChecks[3] ? ["skills"] : [],
+      ...featureChecks[4] ? ["mcp servers"] : [],
+      ...featureChecks[5] ? ["prompts"] : [],
+      ...featureChecks[6] ? ["schemas"] : [],
+      ...featureChecks[7] ? ["scripts"] : [],
+      ...featureChecks[8] ? ["templates"] : []
     ];
   }
   async getClaudeNativeInstallTarget(plugin, pluginDir) {
@@ -17346,12 +17350,13 @@ class PluginManager {
       return null;
     }
     const baseNamespace = plugin.nativeClaudeBundle?.bundleName || plugin.source.marketplace || (plugin.source.owner && plugin.source.repo ? `${plugin.source.owner}-${plugin.source.repo}` : plugin.name);
-    const namespace = `agentinit-${this.slugifyPluginNamespace(baseNamespace)}`;
+    const namespace = this.slugifyPluginNamespace(baseNamespace);
     const versionDir = this.slugifyPluginNamespace(plugin.version || "0.0.0");
     return {
       namespace,
       pluginKey: `${plugin.name}@${namespace}`,
       installPath: join4(homedir4(), ".claude", "plugins", "cache", namespace, plugin.name, versionDir),
+      marketplacePath: getClaudeMarketplaceInstallPath(namespace),
       features
     };
   }
@@ -17374,6 +17379,24 @@ class PluginManager {
   async saveClaudeInstalledPlugins(state) {
     await writeFile(getClaudeInstalledPluginsPath(), JSON.stringify(state, null, 2));
   }
+  async readClaudeKnownMarketplaces() {
+    const content = await readFileIfExists(getClaudeKnownMarketplacesPath());
+    if (!content) {
+      return {};
+    }
+    try {
+      const parsed = JSON.parse(content);
+      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        return {};
+      }
+      return parsed;
+    } catch {
+      return {};
+    }
+  }
+  async saveClaudeKnownMarketplaces(state) {
+    await writeFile(getClaudeKnownMarketplacesPath(), JSON.stringify(state, null, 2));
+  }
   async readClaudeSettings() {
     const content = await readFileIfExists(getClaudeSettingsPath());
     if (!content) {
@@ -17395,6 +17418,145 @@ class PluginManager {
   async saveClaudeSettings(state) {
     await writeFile(getClaudeSettingsPath(), JSON.stringify(state, null, 2));
   }
+  async findClaudeMarketplaceRoot(pluginDir) {
+    let currentDir = resolve7(pluginDir);
+    while (true) {
+      if (await fileExists(join4(currentDir, ".claude-plugin", "marketplace.json"))) {
+        return currentDir;
+      }
+      const parentDir = dirname2(currentDir);
+      if (parentDir === currentDir) {
+        return null;
+      }
+      currentDir = parentDir;
+    }
+  }
+  async readClaudeMarketplaceManifest(marketplaceDir) {
+    const manifestContent = await readFileIfExists(join4(marketplaceDir, ".claude-plugin", "marketplace.json"));
+    if (!manifestContent) {
+      return null;
+    }
+    try {
+      const parsed = JSON.parse(manifestContent);
+      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        return null;
+      }
+      const plugins = Array.isArray(parsed.plugins) ? parsed.plugins.filter((entry) => !!entry && typeof entry === "object" && !Array.isArray(entry)) : [];
+      return {
+        ...parsed,
+        plugins
+      };
+    } catch {
+      return null;
+    }
+  }
+  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));
+  }
+  resolveMarketplaceSourcePath(baseDir, relativePath) {
+    const resolvedPath = resolve7(baseDir, relativePath);
+    const relativePathFromBase = relative2(resolve7(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"));
+    if (!manifestContent) {
+      return {};
+    }
+    try {
+      const manifest = JSON.parse(manifestContent);
+      return {
+        ...typeof manifest.description === "string" ? { description: manifest.description } : {},
+        ...typeof manifest.version === "string" ? { version: manifest.version } : {},
+        ...manifest.author ? { author: manifest.author } : {}
+      };
+    } catch {
+      return {};
+    }
+  }
+  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(() => {
+    });
+    await fs22.cp(sourcePluginDir, marketplacePluginPath, { recursive: true, dereference: true });
+    return marketplacePluginPath;
+  }
+  getClaudeMarketplaceSource(plugin, marketplaceRoot, marketplacePath) {
+    if (plugin.source.type === "github") {
+      if (plugin.source.owner && plugin.source.repo) {
+        return {
+          source: "github",
+          repo: `${plugin.source.owner}/${plugin.source.repo}`
+        };
+      }
+      if (plugin.source.url) {
+        return {
+          source: "git",
+          url: plugin.source.url
+        };
+      }
+    }
+    if (plugin.source.type === "local") {
+      return {
+        source: "directory",
+        path: resolve7(marketplaceRoot || plugin.source.path || marketplacePath)
+      };
+    }
+    return {
+      source: "directory",
+      path: marketplacePath
+    };
+  }
+  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 });
+    const existingManifest = await this.readClaudeMarketplaceManifest(target.marketplacePath);
+    const sourceManifest = marketplaceRoot ? await this.readClaudeMarketplaceManifest(marketplaceRoot) : null;
+    const mergedManifest = {
+      ...sourceManifest || {},
+      ...existingManifest || {},
+      name: target.namespace
+    };
+    const mergedEntries = new Map;
+    for (const entry of existingManifest?.plugins || []) {
+      if (typeof entry.name === "string" && entry.name) {
+        mergedEntries.set(entry.name, entry);
+      }
+    }
+    if (marketplaceRoot && sourceManifest) {
+      for (const entry of sourceManifest.plugins || []) {
+        if (typeof entry.name !== "string" || !entry.name || typeof entry.source !== "string" || !entry.source) {
+          continue;
+        }
+        const sourcePluginDir = this.resolveMarketplaceSourcePath(marketplaceRoot, entry.source);
+        await this.copyClaudeMarketplacePlugin(sourcePluginDir, target.marketplacePath, entry.name);
+        mergedEntries.set(entry.name, {
+          ...entry,
+          source: `./plugins/${entry.name}`
+        });
+      }
+    } else {
+      await this.copyClaudeMarketplacePlugin(pluginDir, target.marketplacePath, plugin.name);
+      const pluginMetadata = await this.readClaudePluginMetadata(pluginDir);
+      mergedEntries.set(plugin.name, {
+        ...mergedEntries.get(plugin.name) || {},
+        name: plugin.name,
+        source: `./plugins/${plugin.name}`,
+        ...plugin.description ? { description: plugin.description } : {},
+        ...plugin.version ? { version: plugin.version } : {},
+        ...pluginMetadata
+      });
+    }
+    mergedManifest.plugins = [...mergedEntries.values()].sort((left, right) => (left.name || "").localeCompare(right.name || ""));
+    await this.saveClaudeMarketplaceManifest(target.marketplacePath, mergedManifest);
+    return { source: marketplaceSource };
+  }
   async installNativeClaudePlugin(plugin, pluginDir, agents) {
     const installed = [];
     const skipped = [];
@@ -17415,7 +17577,8 @@ class PluginManager {
     }
     warnings.push(`Claude Code-native plugin components detected (${featureLabel}); they will only work in Claude Code and install into ~/.claude/plugins.`);
     const claudeInstalled = await this.readClaudeInstalledPlugins();
-    const conflictingKey = Object.keys(claudeInstalled.plugins).find((key) => key !== nativeTarget.pluginKey && key.startsWith(`${plugin.name}@`));
+    const legacyKeys = Object.keys(claudeInstalled.plugins).filter((key) => key !== nativeTarget.pluginKey && key.startsWith(`${plugin.name}@agentinit-`));
+    const conflictingKey = Object.keys(claudeInstalled.plugins).find((key) => key !== nativeTarget.pluginKey && !legacyKeys.includes(key) && key.startsWith(`${plugin.name}@`));
     if (conflictingKey) {
       skipped.push({
         agent: "claude",
@@ -17428,6 +17591,7 @@ class PluginManager {
     });
     await fs22.mkdir(dirname2(nativeTarget.installPath), { recursive: true });
     await fs22.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] = [{
       scope: "user",
@@ -17436,13 +17600,42 @@ class PluginManager {
       installedAt: now,
       lastUpdated: now
     }];
+    const legacyEntries = legacyKeys.flatMap((key) => claudeInstalled.plugins[key] || []);
+    for (const legacyKey of legacyKeys) {
+      delete claudeInstalled.plugins[legacyKey];
+    }
     await this.saveClaudeInstalledPlugins(claudeInstalled);
     const claudeSettings = await this.readClaudeSettings();
     claudeSettings.enabledPlugins = {
       ...claudeSettings.enabledPlugins || {},
       [nativeTarget.pluginKey]: true
     };
+    claudeSettings.extraKnownMarketplaces = {
+      ...claudeSettings.extraKnownMarketplaces || {},
+      [nativeTarget.namespace]: {
+        source: marketplace.source
+      }
+    };
+    for (const legacyKey of legacyKeys) {
+      if (claudeSettings.enabledPlugins && legacyKey in claudeSettings.enabledPlugins) {
+        delete claudeSettings.enabledPlugins[legacyKey];
+      }
+    }
     await this.saveClaudeSettings(claudeSettings);
+    const knownMarketplaces = await this.readClaudeKnownMarketplaces();
+    knownMarketplaces[nativeTarget.namespace] = {
+      source: marketplace.source,
+      installLocation: nativeTarget.marketplacePath,
+      lastUpdated: now
+    };
+    await this.saveClaudeKnownMarketplaces(knownMarketplaces);
+    for (const entry of legacyEntries) {
+      await fs22.rm(entry.installPath, { recursive: true, force: true }).catch(() => {
+      });
+    }
+    for (const legacyKey of legacyKeys) {
+      warnings.push(`Replaced legacy AgentInit Claude plugin install ${legacyKey} with ${nativeTarget.pluginKey}.`);
+    }
     installed.push({
       agent: "claude",
       pluginKey: nativeTarget.pluginKey,
@@ -17463,6 +17656,7 @@ class PluginManager {
     const claudeInstalled = await this.readClaudeInstalledPlugins();
     const entries = claudeInstalled.plugins[component.pluginKey] || [];
     const remainingEntries = entries.filter((entry) => entry.installPath !== component.installPath);
+    const marketplaceNamespace = component.pluginKey.includes("@") ? component.pluginKey.split("@").slice(1).join("@") : "";
     if (remainingEntries.length > 0) {
       claudeInstalled.plugins[component.pluginKey] = remainingEntries;
     } else {
@@ -17473,8 +17667,32 @@ class PluginManager {
     if (claudeSettings.enabledPlugins && component.pluginKey in claudeSettings.enabledPlugins) {
       const { [component.pluginKey]: _removed, ...remainingEnabledPlugins } = claudeSettings.enabledPlugins;
       claudeSettings.enabledPlugins = remainingEnabledPlugins;
-      await this.saveClaudeSettings(claudeSettings);
     }
+    const namespaceStillInstalled = marketplaceNamespace ? Object.keys(claudeInstalled.plugins).some((pluginKey) => pluginKey.endsWith(`@${marketplaceNamespace}`)) : false;
+    if (!namespaceStillInstalled && marketplaceNamespace) {
+      if (claudeSettings.extraKnownMarketplaces && marketplaceNamespace in claudeSettings.extraKnownMarketplaces) {
+        delete claudeSettings.extraKnownMarketplaces[marketplaceNamespace];
+      }
+      const knownMarketplaces = await this.readClaudeKnownMarketplaces();
+      if (marketplaceNamespace in knownMarketplaces) {
+        delete knownMarketplaces[marketplaceNamespace];
+        await this.saveClaudeKnownMarketplaces(knownMarketplaces);
+      }
+      await fs22.rm(getClaudeMarketplaceInstallPath(marketplaceNamespace), { recursive: true, force: true }).catch(() => {
+      });
+    } else if (marketplaceNamespace) {
+      const pluginName = component.pluginKey.split("@")[0] || "";
+      const marketplacePath = getClaudeMarketplaceInstallPath(marketplaceNamespace);
+      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(() => {
+        });
+        await this.saveClaudeMarketplaceManifest(marketplacePath, manifest);
+      }
+    }
+    await this.saveClaudeSettings(claudeSettings);
     await fs22.rm(component.installPath, { recursive: true, force: true }).catch(() => {
     });
     return true;
@@ -17915,8 +18133,11 @@ ${body.trim()}
           warnings: plugin.warnings
         };
       }
-      const skillResult = await this.installPluginSkills(plugin, projectPath, agents, options2);
-      const mcpResult = await this.applyPluginMcpServers(plugin, projectPath, agents, options2.global);
+      const nativeClaudeTarget = await this.getClaudeNativeInstallTarget(plugin, plugin.resolvedPluginDir);
+      const portableSkillAgents = nativeClaudeTarget ? this.getPortableSkillAgents(agents, projectPath, options2.global) : agents;
+      const portableMcpAgents = nativeClaudeTarget ? agents.filter((agent) => agent.id !== "claude") : agents;
+      const skillResult = await this.installPluginSkills(plugin, projectPath, portableSkillAgents, options2);
+      const mcpResult = await this.applyPluginMcpServers(plugin, projectPath, portableMcpAgents, options2.global);
       const nativePluginResult = await this.installNativeClaudePlugin(plugin, plugin.resolvedPluginDir, agents);
       const installWarnings = [...plugin.warnings, ...nativePluginResult.warnings];
       if (skillResult.installed.length > 0 || mcpResult.applied.length > 0 || nativePluginResult.installed.length > 0) {
@@ -17981,6 +18202,25 @@ ${body.trim()}
     }
     return { installed, skipped };
   }
+  getPortableSkillAgents(agents, projectPath, global3) {
+    const claudeAgent = agents.find((agent) => agent.id === "claude");
+    if (!claudeAgent || !claudeAgent.supportsSkills()) {
+      return agents;
+    }
+    const claudeSkillsDir = claudeAgent.getSkillsDir(projectPath, global3);
+    if (!claudeSkillsDir) {
+      return agents.filter((agent) => agent.id !== "claude");
+    }
+    return agents.filter((agent) => {
+      if (agent.id === "claude") {
+        return false;
+      }
+      if (!agent.supportsSkills()) {
+        return true;
+      }
+      return agent.getSkillsDir(projectPath, global3) !== claudeSkillsDir;
+    });
+  }
   async applyPluginMcpServers(plugin, projectPath, agents, global3) {
     const applied = [];
     const skipped = [];
@@ -18245,7 +18485,7 @@ ${body.trim()}
     return { removed: true, details };
   }
 }
-var import_gray_matter, getMarketplaceCacheDir, getRegistryPath, getClaudeInstalledPluginsPath, getClaudeSettingsPath;
+var import_gray_matter, getMarketplaceCacheDir, getRegistryPath, getClaudeInstalledPluginsPath, getClaudeKnownMarketplacesPath, getClaudeMarketplaceInstallPath, getClaudeSettingsPath;
 var init_pluginManager = __esm(() => {
   import_gray_matter = __toESM(require_gray_matter(), 1);
   init_fs();
@@ -18266,13 +18506,19 @@ var init_pluginManager = __esm(() => {
   getClaudeInstalledPluginsPath = function() {
     return join4(homedir4(), ".claude", "plugins", "installed_plugins.json");
   };
+  getClaudeKnownMarketplacesPath = function() {
+    return join4(homedir4(), ".claude", "plugins", "known_marketplaces.json");
+  };
+  getClaudeMarketplaceInstallPath = function(namespace) {
+    return join4(homedir4(), ".claude", "plugins", "marketplaces", namespace);
+  };
   getClaudeSettingsPath = function() {
     return join4(homedir4(), ".claude", "settings.json");
   };
 });
 
 // dist/core/skillsManager.js
-import {resolve as resolve8, join as join5, relative as relative3} from "path";
+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 {execFile} from "child_process";
@@ -18287,15 +18533,9 @@ class SkillsManager {
     if (source.startsWith(".") || source.startsWith("/") || source.startsWith("~")) {
       return { type: "local", path: source };
     }
-    if (source.startsWith("https://github.com/") || source.startsWith("http://github.com/")) {
-      const url = source.replace(/\.git$/, "");
-      const match = url.match(/github\.com\/([^/]+)\/([^/]+)/);
-      return {
-        type: "github",
-        url: `https://github.com/${match?.[1]}/${match?.[2]}.git`,
-        owner: match?.[1],
-        repo: match?.[2]
-      };
+    const githubUrlSource = this.parseGitHubHttpSource(source);
+    if (githubUrlSource) {
+      return githubUrlSource;
     }
     if (source.startsWith("git@") || source.endsWith(".git")) {
       return { type: "github", url: source };
@@ -18310,6 +18550,10 @@ class SkillsManager {
         pluginName: source
       };
     }
+    const githubShorthandSource = this.parseGitHubShorthandSource(source);
+    if (githubShorthandSource?.subpath) {
+      return githubShorthandSource;
+    }
     const marketplacePrefixMatch = source.match(/^([a-zA-Z0-9._-]+)\/(.+)$/);
     if (marketplacePrefixMatch) {
       const [, marketplaceId, pluginName] = marketplacePrefixMatch;
@@ -18321,14 +18565,8 @@ class SkillsManager {
         };
       }
     }
-    if (/^[a-zA-Z0-9._-]+\/[a-zA-Z0-9._-]+$/.test(source)) {
-      const [owner, repo] = source.split("/");
-      return {
-        type: "github",
-        url: `https://github.com/${owner}/${repo}.git`,
-        owner,
-        repo
-      };
+    if (githubShorthandSource) {
+      return githubShorthandSource;
     }
     return { type: "local", path: source };
   }
@@ -18367,6 +18605,54 @@ class SkillsManager {
       implicitSkills: []
     };
   }
+  parseGitHubHttpSource(source) {
+    if (!source.startsWith("https://github.com/") && !source.startsWith("http://github.com/")) {
+      return null;
+    }
+    try {
+      const parsedUrl = new URL(source);
+      const segments = parsedUrl.pathname.replace(/\/+$/, "").split("/").filter(Boolean);
+      if (segments.length < 2) {
+        return null;
+      }
+      const [owner, rawRepo, ...rest] = segments;
+      const repo = rawRepo?.replace(/\.git$/, "");
+      if (!owner || !repo) {
+        return null;
+      }
+      let subpath;
+      if (rest[0] === "tree" || rest[0] === "blob") {
+        if (rest.length > 2) {
+          subpath = rest.slice(2).join("/");
+        }
+      } else if (rest.length > 0) {
+        subpath = rest.join("/");
+      }
+      return {
+        type: "github",
+        url: `https://github.com/${owner}/${repo}.git`,
+        owner,
+        repo,
+        ...subpath ? { subpath } : {}
+      };
+    } catch {
+      return null;
+    }
+  }
+  parseGitHubShorthandSource(source) {
+    const githubShorthandMatch = source.match(/^([a-zA-Z0-9._-]+)\/([a-zA-Z0-9._-]+)(?:\/(.+))?$/);
+    if (!githubShorthandMatch) {
+      return null;
+    }
+    const [, owner, repo, subpath] = githubShorthandMatch;
+    return {
+      type: "github",
+      url: `https://github.com/${owner}/${repo}.git`,
+      owner,
+      repo,
+      ...subpath ? { subpath } : {}
+    };
+  }
   async parseSkillMd(filePath) {
     const content = await readFileIfExists(filePath);
     if (!content)
@@ -18486,13 +18772,55 @@ class SkillsManager {
       warnings
     };
   }
-  async discoverFromSource(source, projectPath, options2 = {}) {
+  async cleanupTempDir(tempDir) {
+    if (!tempDir) {
+      return;
+    }
+    await fs24.rm(tempDir, { recursive: true, force: true }).catch(() => {
+    });
+  }
+  async resolveDiscoveryRoot(repoPath, source, sourceLabel) {
+    const resolvedRepoPath = resolve8(repoPath);
+    if (source.type !== "github" || !source.subpath) {
+      return resolvedRepoPath;
+    }
+    const discoveryRoot = resolve8(resolvedRepoPath, source.subpath);
+    if (!this.isWithinPath(resolvedRepoPath, discoveryRoot)) {
+      throw new Error(`Invalid GitHub source path "${source.subpath}" in ${sourceLabel}`);
+    }
+    if (!await fileExists(discoveryRoot)) {
+      throw new Error(`Source path not found in repository: ${sourceLabel}`);
+    }
+    const [realRepoPath, realDiscoveryRoot] = await Promise.all([
+      resolveRealPathOrSelf(resolvedRepoPath),
+      resolveRealPathOrSelf(discoveryRoot)
+    ]);
+    if (!this.isWithinPath(realRepoPath, realDiscoveryRoot)) {
+      throw new Error(`Invalid GitHub source path "${source.subpath}" in ${sourceLabel}`);
+    }
+    if (await isDirectory(realDiscoveryRoot)) {
+      return realDiscoveryRoot;
+    }
+    if (basename3(realDiscoveryRoot).toLowerCase() === "skill.md") {
+      return dirname3(realDiscoveryRoot);
+    }
+    throw new Error(`GitHub source must reference a skill directory or SKILL.md: ${sourceLabel}`);
+  }
+  async loadDiscoveredSkillsContext(source, projectPath, options2 = {}) {
     const request = this.resolveSourceRequest(source, options2);
     const resolved = request.source;
     let tempDir = null;
+    const cleanup = async () => {
+      await this.cleanupTempDir(tempDir);
+      tempDir = null;
+    };
     try {
       if (resolved.type === "marketplace") {
-        return await this.discoverMarketplaceSkills(resolved, projectPath);
+        const discovered = await this.discoverMarketplaceSkills(resolved, projectPath);
+        return {
+          ...discovered,
+          cleanup
+        };
       }
       let repoPath;
       if (resolved.type === "github") {
@@ -18507,10 +18835,11 @@ class SkillsManager {
           throw this.getMissingLocalPathError(source, repoPath);
         }
       }
-      let skills = await this.discoverSkills(repoPath);
+      const discoveryRoot = await this.resolveDiscoveryRoot(repoPath, resolved, source);
+      let skills = await this.discoverSkills(discoveryRoot);
       let pluginWarnings = [];
       if (skills.length === 0) {
-        const pluginBackedSkills = await this.discoverPortablePluginSkills(repoPath, source, resolved, projectPath);
+        const pluginBackedSkills = await this.discoverPortablePluginSkills(discoveryRoot, source, resolved, projectPath);
         if (pluginBackedSkills) {
           skills = pluginBackedSkills.skills;
           pluginWarnings = pluginBackedSkills.warnings;
@@ -18524,12 +18853,21 @@ class SkillsManager {
         ...pluginWarnings,
         ...request.implicitSkills.length > 0 ? [`Resolved "${source}" from the default skills catalog ${DEFAULT_SKILLS_CATALOG.owner}/${DEFAULT_SKILLS_CATALOG.repo}. Use "./${source}" for a local path.`] : []
       ];
-      return { skills, warnings };
+      return { skills, warnings, cleanup };
+    } catch (error) {
+      await cleanup();
+      throw error;
+    }
+  }
+  async discoverFromSource(source, projectPath, options2 = {}) {
+    const context = await this.loadDiscoveredSkillsContext(source, projectPath, options2);
+    try {
+      return {
+        skills: context.skills,
+        warnings: context.warnings
+      };
     } finally {
-      if (tempDir) {
-        await fs24.rm(tempDir, { recursive: true, force: true }).catch(() => {
-        });
-      }
+      await context.cleanup();
     }
   }
   async getTargetAgents(projectPath, options2) {
@@ -18694,58 +19032,62 @@ class SkillsManager {
     await fs24.cp(src, dest, { recursive: true, dereference: true });
   }
   async addFromSource(source, projectPath, options2 = {}) {
-    const discovered = await this.discoverFromSource(source, projectPath, {
+    const context = await this.loadDiscoveredSkillsContext(source, projectPath, {
       ...options2.from !== undefined ? { from: options2.from } : {}
     });
-    let skills = discovered.skills;
-    if (skills.length === 0) {
-      return { installed: [], skipped: [], warnings: discovered.warnings };
-    }
-    if (options2.skills && options2.skills.length > 0) {
-      const names = new Set(options2.skills.map((skill) => skill.toLowerCase()));
-      skills = skills.filter((skill) => names.has(skill.name.toLowerCase()));
-    }
-    const agents = await this.getTargetAgents(projectPath, options2);
-    if (agents.length === 0) {
-      return {
-        installed: [],
-        skipped: skills.map((skill) => ({ skill, reason: "No target agents found" })),
-        warnings: discovered.warnings
-      };
-    }
-    const result = { installed: [], skipped: [], warnings: discovered.warnings };
-    const installableAgents = [];
-    for (const agent of agents) {
-      if (!agent.supportsSkills()) {
-        for (const skill of skills) {
-          result.skipped.push({ skill, reason: `${agent.name} does not support skills` });
-        }
-        continue;
+    try {
+      let skills = context.skills;
+      if (skills.length === 0) {
+        return { installed: [], skipped: [], warnings: context.warnings };
       }
-      const skillsDir = agent.getSkillsDir(projectPath, options2.global);
-      if (!skillsDir) {
-        for (const skill of skills) {
-          result.skipped.push({ skill, reason: `No skills directory for ${agent.name}` });
+      if (options2.skills && options2.skills.length > 0) {
+        const names = new Set(options2.skills.map((skill) => skill.toLowerCase()));
+        skills = skills.filter((skill) => names.has(skill.name.toLowerCase()));
+      }
+      const agents = await this.getTargetAgents(projectPath, options2);
+      if (agents.length === 0) {
+        return {
+          installed: [],
+          skipped: skills.map((skill) => ({ skill, reason: "No target agents found" })),
+          warnings: context.warnings
+        };
+      }
+      const result = { installed: [], skipped: [], warnings: context.warnings };
+      const installableAgents = [];
+      for (const agent of agents) {
+        if (!agent.supportsSkills()) {
+          for (const skill of skills) {
+            result.skipped.push({ skill, reason: `${agent.name} does not support skills` });
+          }
+          continue;
         }
-        continue;
+        const skillsDir = agent.getSkillsDir(projectPath, options2.global);
+        if (!skillsDir) {
+          for (const skill of skills) {
+            result.skipped.push({ skill, reason: `No skills directory for ${agent.name}` });
+          }
+          continue;
+        }
+        installableAgents.push(agent);
       }
-      installableAgents.push(agent);
-    }
-    for (const skill of skills) {
-      for (const agent of installableAgents) {
-        try {
-          const installOptions = {
-            ...options2.global !== undefined ? { global: options2.global } : {},
-            ...options2.copy !== undefined ? { copy: options2.copy } : {}
-          };
-          const installed = skill.generatedContent ? await this.installSkillFromContentForAgent(skill.name, skill.generatedContent, agent, projectPath, installOptions) : await this.installSkillForAgent(skill.path, skill.name, agent, projectPath, installOptions);
-          result.installed.push({ skill, agent: agent.id, ...installed });
-        } catch (error) {
-          result.skipped.push({ skill, reason: error.message });
+      for (const skill of skills) {
+        for (const agent of installableAgents) {
+          try {
+            const installOptions = {
+              ...options2.global !== undefined ? { global: options2.global } : {},
+              ...options2.copy !== undefined ? { copy: options2.copy } : {}
+            };
+            const installed = skill.generatedContent ? await this.installSkillFromContentForAgent(skill.name, skill.generatedContent, agent, projectPath, installOptions) : await this.installSkillForAgent(skill.path, skill.name, agent, projectPath, installOptions);
+            result.installed.push({ skill, agent: agent.id, ...installed });
+          } catch (error) {
+            result.skipped.push({ skill, reason: error.message });
+          }
         }
       }
+      return result;
+    } finally {
+      await context.cleanup();
     }
-    return result;
   }
   async listInstalled(projectPath, options2 = {}) {
     const agents = await this.getTargetAgents(projectPath, options2);
@@ -30705,7 +31047,7 @@ ${content}
 // dist/core/managedState.js
 init_fs();
 import {promises as fs28} from "fs";
-import {dirname as dirname3, join as join6, relative as relative4, resolve as resolve10} from "path";
+import {dirname as dirname4, join as join6, relative as relative4, resolve as resolve10} from "path";
 var toPosixPath = function(value) {
   return value.replace(/\\/g, "/");
 };
@@ -30730,10 +31072,10 @@ async function copyDirectory(src, dest) {
       await copyDirectory(srcPath, destPath);
     } else if (entry.isSymbolicLink()) {
       const target = await fs28.readlink(srcPath);
-      await fs28.mkdir(dirname3(destPath), { recursive: true });
+      await fs28.mkdir(dirname4(destPath), { recursive: true });
       await fs28.symlink(target, destPath);
     } else {
-      await fs28.mkdir(dirname3(destPath), { recursive: true });
+      await fs28.mkdir(dirname4(destPath), { recursive: true });
       await fs28.copyFile(srcPath, destPath);
     }
   }
@@ -30743,7 +31085,7 @@ async function copyPath(src, dest) {
   if (!type2) {
     return;
   }
-  await fs28.mkdir(dirname3(dest), { recursive: true });
+  await fs28.mkdir(dirname4(dest), { recursive: true });
   if (type2 === "symlink") {
     const target = await fs28.readlink(src);
     await fs28.symlink(target, dest);
@@ -30879,7 +31221,7 @@ class ManagedStateStore {
         if (!options2.dryRun) {
           await fs28.rm(absolutePath, { recursive: true, force: true }).catch(() => {
           });
-          await fs28.mkdir(dirname3(absolutePath), { recursive: true });
+          await fs28.mkdir(dirname4(absolutePath), { recursive: true });
           await fs28.symlink(backupLinkTarget, absolutePath);
         }
         summary.restored++;
@@ -31261,11 +31603,11 @@ class MCPParser {
 // dist/constants/mcp.js
 import {readFileSync as readFileSync2} from "fs";
 import {fileURLToPath} from "url";
-import {dirname as dirname4, join as join7} from "path";
+import {dirname as dirname5, join as join7} from "path";
 var getPackageVersion = function() {
   try {
     const __filename2 = fileURLToPath(import.meta.url);
-    const __dirname2 = dirname4(__filename2);
+    const __dirname2 = dirname5(__filename2);
     const packageJsonPath = join7(__dirname2, "../../package.json");
     const packageJson = JSON.parse(readFileSync2(packageJsonPath, "utf-8"));
     return packageJson.version || "1.0.0";
@@ -31297,11 +31639,11 @@ import {readFileSync as readFileSync4} from "fs";
 
 // dist/core/rulesTemplateLoader.js
 var toml = __toESM(require_toml(), 1);
-import {resolve as resolve11, dirname as dirname5} from "path";
+import {resolve as resolve11, dirname as dirname6} 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 = dirname5(__filename2);
+var __dirname2 = dirname6(__filename2);
 
 class RulesTemplateLoader {
   templatesPath;
@@ -39537,7 +39879,7 @@ class MCPVerifier {
 
 // dist/core/gitignoreManager.js
 import {promises as fs31} from "fs";
-import {dirname as dirname6, join as join8} from "path";
+import {dirname as dirname7, join as join8} from "path";
 var normalizeIgnorePath = function(projectPath, value) {
   const relative6 = value.startsWith(projectPath) ? value.slice(projectPath.length + 1) : value;
   const normalized = relative6.replace(/\\/g, "/").replace(/^\/+/, "");
@@ -39605,7 +39947,7 @@ async function updateManagedIgnoreFile(projectPath, paths5, options2 = {}) {
     existingContent = "";
   }
   const updatedContent = updateManagedBlock(existingContent, normalizedPaths);
-  await fs31.mkdir(dirname6(ignoreFilePath), { recursive: true });
+  await fs31.mkdir(dirname7(ignoreFilePath), { recursive: true });
   await fs31.writeFile(ignoreFilePath, updatedContent, "utf8");
   return ignoreFilePath;
 }
@@ -39647,7 +39989,7 @@ var END_MARKER = "# END AgentInit Generated Files";
 init_agentManager();
 init_skillsManager();
 init_fs();
-import {dirname as dirname7, join as join9} from "path";
+import {dirname as dirname8, join as join9} from "path";
 async function discoverProjectSkills(projectPath, skillsManager4) {
   const sources = [];
   const skills = new Map;
@@ -39725,7 +40067,7 @@ async function applyProjectSkills(projectPath, targetAgentIds, managedState2, op
             await managedState2.trackGeneratedPath(generatedPath, {
               kind: "directory",
               source: "skills",
-              ignorePath: `${dirname7(generatedPath)}/`
+              ignorePath: `${dirname8(generatedPath)}/`
             });
           }
         }
@@ -41982,7 +42324,7 @@ function registerRulesCommand(program2) {
 // dist/commands/plugins.js
 var import_prompts3 = __toESM(require_prompts3(), 1);
 import {homedir as homedir7} from "os";
-import {dirname as dirname8, relative as relative8, resolve as resolve13} from "path";
+import {dirname as dirname9, relative as relative8, resolve as resolve13} from "path";
 init_pluginManager();
 init_agentManager();
 init_marketplaceRegistry();
@@ -42370,7 +42712,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 = dirname8(item.path);
+    const targetDir = dirname9(item.path);
     const existing = skillGroups.get(targetDir) || { agents: new Set, skillNames: new Set };
     existing.agents.add(item.agent);
     existing.skillNames.add(item.name);