agentinit 1.15.1 → 1.16.1

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [1.16.1](https://github.com/agentinit/agentinit/compare/v1.16.0...v1.16.1) (2026-04-01)
+
+
+### Bug Fixes
+
+* align Claude native plugin installs with marketplace behavior ([bdfa280](https://github.com/agentinit/agentinit/commit/bdfa2801a9ad933727fd72327cd9b121dfe0a543))
+
+# [1.16.0](https://github.com/agentinit/agentinit/compare/v1.15.1...v1.16.0) (2026-04-01)
+
+
+### Features
+
+* restore canonical global plugin target ([fad7b5e](https://github.com/agentinit/agentinit/commit/fad7b5e6a6fe359ed721f388e0991d7774a85bb2))
+
 ## [1.15.1](https://github.com/agentinit/agentinit/compare/v1.15.0...v1.15.1) (2026-04-01)
 
 
@@ -135,7 +149,7 @@
 * add OpenClaw as a skills target with shared project installs via `.agents/skills/` and dedicated global installs via `~/.openclaw/skills/`
 * add Hermes as a skills target with shared project installs via `.agents/skills/` and dedicated global installs via `~/.hermes/skills/`
 * warn and fall back to GitHub repos for marketplace misses, marking allowlisted repos like `openai/codex-plugin-cc` as verified
-* install Claude Code-native plugin payloads during `plugins install` when Claude-only components are detected and Claude Code is targeted
+* install Claude Code-native plugin payloads during `plugins install` when Claude-only components are detected and Claude Code is targeted, registering native marketplace metadata under `~/.claude/plugins`
 
 ### Bug Fixes
 
@@ -145,7 +159,7 @@
 * update docs and onboarding to the `mcp add|verify`, `rules add`, and `skills add` command model
 * parse Claude Code marketplace bundle repos like `openai/codex-plugin-cc` when installing portable skills or plugins
 * keep interactive plugin target defaults on all detected agents, warn clearly when Claude-native payloads are skipped, and reuse the previewed remote source during install
-* enable Claude-native plugin payloads in `~/.claude/settings.json` so installed Claude plugins actually activate
+* enable Claude-native plugin payloads in `~/.claude/settings.json`, register them in `known_marketplaces.json`, and migrate legacy `agentinit-*` Claude namespaces to native marketplace ids
 
 # [1.7.0](https://github.com/agentinit/agentinit/compare/v1.6.0...v1.7.0) (2025-10-17)
 

package/README.md

@@ -263,7 +263,7 @@ agentinit plugins remove code-review
 - Implemented marketplaces today include `claude` (Anthropic's Claude plugin marketplace) and `openai` (the OpenAI Codex skills catalog).
 - You can add your own marketplaces with `agentinit config marketplaces add <identifier> <repo-url>`.
 - If a marketplace lookup misses but the source still looks like `owner/repo`, AgentInit warns and tries that GitHub repository directly. Exact repos added with `agentinit config verified-repos add <owner/repo>` are labeled as verified during that fallback.
-- For Claude-format plugins, `plugins install` still installs portable skills and MCP servers for the selected agents. If Claude Code-native components are also present, AgentInit previews that compatibility before target selection. The native plugin payload installs only when `claude` is one of the selected targets; otherwise AgentInit warns that the Claude-only parts were skipped. When the native payload is installed, AgentInit reminds you to run `/reload-plugins`.
+- For Claude-format plugins, `plugins install` installs portable skills and MCP servers for compatible selected agents. If a native Claude Code plugin bundle is also present, AgentInit installs that bundle into `~/.claude/plugins` when `claude` is selected, registers the corresponding Claude marketplace metadata, and skips portable skill fallback for any selected agents that share Claude Code's skills directory. Portable MCP installs still apply to other compatible agents.
 - Claude-native plugin payloads are user-scoped and stored under `~/.claude/plugins`, even when the AgentInit install itself is project-scoped.
 
 ### `agentinit config`

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,6 +18506,12 @@ 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");
   };
@@ -41981,7 +42227,8 @@ function registerRulesCommand(program2) {
 
 // dist/commands/plugins.js
 var import_prompts3 = __toESM(require_prompts3(), 1);
-import {dirname as dirname8, relative as relative8} from "path";
+import {homedir as homedir7} from "os";
+import {dirname as dirname8, relative as relative8, resolve as resolve13} from "path";
 init_pluginManager();
 init_agentManager();
 init_marketplaceRegistry();
@@ -42439,13 +42686,45 @@ var buildGlobalPluginGroups = function(agentManager12, projectPath) {
     existing.push(agent);
     dirToAgents.set(skillsDir, existing);
   }
-  return Array.from(dirToAgents.entries()).map(([dir, agents]) => ({
+  const nativeGroups = Array.from(dirToAgents.entries()).map(([dir, agents]) => ({
     dir,
     displayDir: formatPathForDisplay(dir, projectPath),
     agents,
     agentNames: agents.map((agent) => agent.name),
-    compatibleAgentNames: []
+    compatibleAgentNames: [],
+    kind: "native"
   }));
+  const canonicalDir = resolve13(homedir7(), ".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"));
+  if (sharedAgents.length === 0) {
+    return [...claudeGroups, ...otherGroups];
+  }
+  return [
+    {
+      dir: canonicalDir,
+      displayDir: formatPathForDisplay(canonicalDir, projectPath),
+      agents: sharedAgents,
+      agentNames: sharedAgents.map((agent) => agent.name),
+      compatibleAgentNames: [],
+      kind: "canonical-shared"
+    },
+    ...claudeGroups,
+    ...otherGroups
+  ];
+};
+var shouldPreselectPluginGroup = function(group, installGlobal, preview) {
+  if (!installGlobal) {
+    return true;
+  }
+  if (group.kind === "canonical-shared") {
+    return true;
+  }
+  if (preview.nativePreview) {
+    return group.agents.some((agent) => agent.id === preview.nativePreview?.agent);
+  }
+  return false;
 };
 var getPluginGroupDescription = function(group, preview, projectPath) {
   const portableSummary = getPortableComponentSummary(preview);
@@ -42512,7 +42791,7 @@ async function interactiveAgentSelect(pluginManager2, agentManager12, projectPat
         title: `${group.displayDir} -> ${getAgentLabel(group.agents.map((agent) => agent.id), agentManager12)}${compatible}`,
         description: getPluginGroupDescription(group, preview, projectPath),
         value: group.agents.map((agent) => agent.id),
-        selected: true
+        selected: shouldPreselectPluginGroup(group, installGlobal, preview)
       };
     })
   });

package/dist/commands/plugins.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plugins.d.ts","sourceRoot":"","sources":["../../src/commands/plugins.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA0BpC,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAkT7D"}
+{"version":3,"file":"plugins.d.ts","sourceRoot":"","sources":["../../src/commands/plugins.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA4BpC,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAkT7D"}

package/dist/commands/plugins.js

@@ -1,6 +1,7 @@
 import ora from 'ora';
 import prompts from 'prompts';
-import { dirname, relative } from 'path';
+import { homedir } from 'os';
+import { dirname, relative, resolve } from 'path';
 import { green, dim, bold, cyan, yellow, orange } from '../utils/colors.js';
 import { logger } from '../utils/logger.js';
 import { PluginManager } from '../core/pluginManager.js';
@@ -530,13 +531,47 @@ function buildGlobalPluginGroups(agentManager, projectPath) {
         existing.push(agent);
         dirToAgents.set(skillsDir, existing);
     }
-    return Array.from(dirToAgents.entries()).map(([dir, agents]) => ({
+    const nativeGroups = Array.from(dirToAgents.entries()).map(([dir, agents]) => ({
         dir,
         displayDir: formatPathForDisplay(dir, projectPath),
         agents,
         agentNames: agents.map(agent => agent.name),
         compatibleAgentNames: [],
+        kind: 'native',
     }));
+    const canonicalDir = resolve(homedir(), '.agents/skills');
+    const sharedAgents = agentManager.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'));
+    if (sharedAgents.length === 0) {
+        return [...claudeGroups, ...otherGroups];
+    }
+    return [
+        {
+            dir: canonicalDir,
+            displayDir: formatPathForDisplay(canonicalDir, projectPath),
+            agents: sharedAgents,
+            agentNames: sharedAgents.map(agent => agent.name),
+            compatibleAgentNames: [],
+            kind: 'canonical-shared',
+        },
+        ...claudeGroups,
+        ...otherGroups,
+    ];
+}
+function shouldPreselectPluginGroup(group, installGlobal, preview) {
+    if (!installGlobal) {
+        return true;
+    }
+    if (group.kind === 'canonical-shared') {
+        return true;
+    }
+    if (preview.nativePreview) {
+        return group.agents.some(agent => agent.id === preview.nativePreview?.agent);
+    }
+    return false;
 }
 function getPluginGroupDescription(group, preview, projectPath) {
     const portableSummary = getPortableComponentSummary(preview);
@@ -614,7 +649,7 @@ async function interactiveAgentSelect(pluginManager, agentManager, projectPath,
                 title: `${group.displayDir} -> ${getAgentLabel(group.agents.map(agent => agent.id), agentManager)}${compatible}`,
                 description: getPluginGroupDescription(group, preview, projectPath),
                 value: group.agents.map(agent => agent.id),
-                selected: true,
+                selected: shouldPreselectPluginGroup(group, installGlobal, preview),
             };
         }),
     });