agentinit 1.12.1 → 1.13.1

package/dist/core/pluginManager.js

@@ -1,4 +1,4 @@
-import { resolve, join, basename } from 'path';
+import { resolve, join, basename, relative, dirname } from 'path';
 import { promises as fs } from 'fs';
 import { homedir } from 'os';
 import matter from 'gray-matter';
@@ -7,6 +7,24 @@ import { AgentManager } from './agentManager.js';
 import { MCPFilter } from './mcpFilter.js';
 import { MARKETPLACES, getMarketplace as lookupMarketplace, getMarketplaceIds as lookupMarketplaceIds } from './marketplaceRegistry.js';
 import { SkillsManager } from './skillsManager.js';
+export class MarketplacePluginNotFoundError extends Error {
+    pluginName;
+    marketplaceId;
+    marketplaceName;
+    suggestions;
+    constructor(pluginName, marketplaceId, marketplaceName, suggestions) {
+        let msg = `Plugin "${pluginName}" not found in ${marketplaceName} marketplace.`;
+        if (suggestions.length > 0) {
+            msg += ` Did you mean: ${suggestions.join(', ')}?`;
+        }
+        super(msg);
+        this.name = 'MarketplacePluginNotFoundError';
+        this.pluginName = pluginName;
+        this.marketplaceId = marketplaceId;
+        this.marketplaceName = marketplaceName;
+        this.suggestions = suggestions;
+    }
+}
 function getMarketplaceCacheDir(registryId) {
     return join(homedir(), '.agentinit', 'marketplace-cache', registryId);
 }
@@ -16,13 +34,390 @@ function getRegistryPath(projectPath, global) {
     }
     return join(projectPath, '.agentinit', 'plugins.json');
 }
+function getClaudeInstalledPluginsPath() {
+    return join(homedir(), '.claude', 'plugins', 'installed_plugins.json');
+}
 export class PluginManager {
     agentManager;
     skillsManager;
+    preparedInstallContexts = new Map();
     constructor(agentManager) {
         this.agentManager = agentManager || new AgentManager();
         this.skillsManager = new SkillsManager(this.agentManager);
     }
+    getPreparedInstallKey(source, from) {
+        return `${from || ''}\n${source}`;
+    }
+    async cleanupLoadedPluginContext(context) {
+        if (context?.tempDir) {
+            await fs.rm(context.tempDir, { recursive: true, force: true }).catch(() => { });
+        }
+    }
+    async storePreparedInstallContext(source, from, context) {
+        const key = this.getPreparedInstallKey(source, from);
+        const existing = this.preparedInstallContexts.get(key);
+        this.preparedInstallContexts.set(key, context);
+        if (existing && existing !== context) {
+            await this.cleanupLoadedPluginContext(existing);
+        }
+    }
+    takePreparedInstallContext(source, from) {
+        const key = this.getPreparedInstallKey(source, from);
+        const existing = this.preparedInstallContexts.get(key) || null;
+        if (existing) {
+            this.preparedInstallContexts.delete(key);
+        }
+        return existing;
+    }
+    async discardPreparedPlugin(source, options = {}) {
+        const context = this.takePreparedInstallContext(source, options.from);
+        await this.cleanupLoadedPluginContext(context);
+    }
+    parseGitHubRepo(url) {
+        const normalized = url.replace(/\.git$/, '');
+        const match = normalized.match(/github\.com[:/]([^/]+)\/([^/]+)/i);
+        if (!match) {
+            return null;
+        }
+        const [, owner, repo] = match;
+        if (!owner || !repo) {
+            return null;
+        }
+        return {
+            owner,
+            repo,
+        };
+    }
+    deriveGitHubFallbackSource(source, marketplaceId) {
+        const repoShorthandMatch = source.match(/^([a-zA-Z0-9._-]+)\/([a-zA-Z0-9._-]+)$/);
+        if (repoShorthandMatch) {
+            const [, owner, repo] = repoShorthandMatch;
+            return {
+                type: 'github',
+                url: `https://github.com/${owner}/${repo}.git`,
+                owner,
+                repo,
+            };
+        }
+        if (!marketplaceId || !/^[a-zA-Z0-9._-]+$/.test(source)) {
+            return null;
+        }
+        const registry = this.getMarketplace(marketplaceId);
+        const registryRepo = registry ? this.parseGitHubRepo(registry.repoUrl) : null;
+        if (!registryRepo) {
+            return null;
+        }
+        return {
+            type: 'github',
+            url: `https://github.com/${registryRepo.owner}/${source}.git`,
+            owner: registryRepo.owner,
+            repo: source,
+        };
+    }
+    formatGitHubRepoUrl(source) {
+        if (!source.owner || !source.repo) {
+            return null;
+        }
+        return `https://github.com/${source.owner}/${source.repo}`;
+    }
+    async resolvePreparedPluginDir(pluginDir, source) {
+        const claudeMarketplaceManifestPath = join(pluginDir, '.claude-plugin', 'marketplace.json');
+        if (!(await fileExists(claudeMarketplaceManifestPath))) {
+            return { pluginDir, warnings: [] };
+        }
+        const manifestContent = await readFileIfExists(claudeMarketplaceManifestPath);
+        if (!manifestContent) {
+            return { pluginDir, warnings: [] };
+        }
+        let manifest;
+        try {
+            manifest = JSON.parse(manifestContent);
+        }
+        catch {
+            throw new Error(`Invalid .claude-plugin/marketplace.json in ${pluginDir}`);
+        }
+        const entries = Array.isArray(manifest.plugins)
+            ? manifest.plugins.filter((entry) => typeof entry?.name === 'string' && typeof entry?.source === 'string')
+            : [];
+        if (entries.length === 0) {
+            throw new Error(`No plugins declared in .claude-plugin/marketplace.json for ${pluginDir}`);
+        }
+        const [firstEntry] = entries;
+        if (!firstEntry) {
+            throw new Error(`No plugins declared in .claude-plugin/marketplace.json for ${pluginDir}`);
+        }
+        let selectedEntry = firstEntry;
+        if (entries.length > 1) {
+            const candidates = new Set([source.pluginName, source.repo]
+                .filter((value) => !!value)
+                .flatMap(value => [value, basename(value)]));
+            const matched = entries.find(entry => candidates.has(entry.name) || candidates.has(basename(entry.source)));
+            if (!matched) {
+                throw new Error(`Repository "${pluginDir}" is a Claude marketplace bundle with multiple plugins. Select one of: ${entries.map(entry => entry.name).join(', ')}.`);
+            }
+            selectedEntry = matched;
+        }
+        const selectedPluginDir = resolve(pluginDir, selectedEntry.source);
+        const relativePath = relative(resolve(pluginDir), selectedPluginDir);
+        if (relativePath.startsWith('..') ||
+            relativePath.includes('/../') ||
+            relativePath.includes('\\..\\')) {
+            throw new Error(`Invalid bundled plugin source path "${selectedEntry.source}" in ${claudeMarketplaceManifestPath}`);
+        }
+        if (!(await isDirectory(selectedPluginDir))) {
+            throw new Error(`Bundled plugin path not found: ${selectedPluginDir}`);
+        }
+        const sourceLabel = this.formatGitHubRepoUrl(source) || pluginDir;
+        return {
+            pluginDir: selectedPluginDir,
+            warnings: [
+                `Source "${sourceLabel}" is a Claude Code marketplace bundle; using bundled plugin "${selectedEntry.name}".`,
+            ],
+            claudeBundle: {
+                bundleName: manifest.name || selectedEntry.name,
+                pluginName: selectedEntry.name,
+            },
+        };
+    }
+    async loadPluginFromDirectory(pluginDir, source, warnings = []) {
+        const preparedPlugin = await this.resolvePreparedPluginDir(pluginDir, source);
+        const parsedPlugin = await this.parsePlugin(preparedPlugin.pluginDir, source);
+        return {
+            ...parsedPlugin,
+            warnings: [...warnings, ...preparedPlugin.warnings, ...parsedPlugin.warnings],
+            resolvedPluginDir: preparedPlugin.pluginDir,
+            ...(preparedPlugin.claudeBundle ? { nativeClaudeBundle: preparedPlugin.claudeBundle } : {}),
+        };
+    }
+    async loadPluginContext(source, options = {}) {
+        const resolved = this.resolveSource(source, { from: options.from });
+        let effectiveSource = resolved;
+        let pluginDir;
+        let tempDir = null;
+        const resolutionWarnings = [];
+        if (resolved.type === 'marketplace') {
+            try {
+                pluginDir = await this.resolveMarketplacePlugin(resolved.pluginName, resolved.marketplace || 'claude');
+            }
+            catch (error) {
+                if (!(error instanceof MarketplacePluginNotFoundError)) {
+                    throw error;
+                }
+                const fallbackSource = this.deriveGitHubFallbackSource(source, resolved.marketplace);
+                if (!fallbackSource || !fallbackSource.url) {
+                    throw error;
+                }
+                const fallbackUrl = this.formatGitHubRepoUrl(fallbackSource) || fallbackSource.url.replace(/\.git$/, '');
+                resolutionWarnings.push(error.message);
+                resolutionWarnings.push(`Marketplace lookup failed; trying unverified GitHub repository ${fallbackUrl} instead.`);
+                try {
+                    tempDir = await this.skillsManager.cloneRepo(fallbackSource.url);
+                }
+                catch (fallbackError) {
+                    throw new Error(`${error.message} Tried unverified GitHub repository ${fallbackUrl} but failed: ${fallbackError instanceof Error ? fallbackError.message : 'Unknown error'}`);
+                }
+                effectiveSource = {
+                    ...fallbackSource,
+                    ...(resolved.pluginName ? { pluginName: resolved.pluginName } : {}),
+                };
+                pluginDir = tempDir;
+            }
+        }
+        else if (resolved.type === 'github') {
+            if (!resolved.url)
+                throw new Error(`Invalid source: ${source}`);
+            tempDir = await this.skillsManager.cloneRepo(resolved.url);
+            pluginDir = tempDir;
+        }
+        else {
+            pluginDir = resolve(resolved.path || source);
+            if (!(await fileExists(pluginDir))) {
+                throw new Error(`Local path not found: ${pluginDir}`);
+            }
+        }
+        return {
+            plugin: await this.loadPluginFromDirectory(pluginDir, effectiveSource, resolutionWarnings),
+            effectiveSource,
+            tempDir,
+        };
+    }
+    async buildPluginInspection(context) {
+        const nativeTarget = await this.getClaudeNativeInstallTarget(context.plugin, context.plugin.resolvedPluginDir);
+        return {
+            plugin: context.plugin,
+            nativePreview: nativeTarget ? this.toNativePluginPreview(nativeTarget) : null,
+        };
+    }
+    async preparePluginInstall(source, options = {}) {
+        const context = await this.loadPluginContext(source, options);
+        try {
+            const inspection = await this.buildPluginInspection(context);
+            await this.storePreparedInstallContext(source, options.from, context);
+            return inspection;
+        }
+        catch (error) {
+            await this.cleanupLoadedPluginContext(context);
+            throw error;
+        }
+    }
+    async inspectPlugin(source, options = {}) {
+        const context = await this.loadPluginContext(source, options);
+        try {
+            return await this.buildPluginInspection(context);
+        }
+        finally {
+            await this.cleanupLoadedPluginContext(context);
+        }
+    }
+    slugifyPluginNamespace(value) {
+        return value
+            .trim()
+            .toLowerCase()
+            .replace(/[^a-z0-9._-]+/g, '-')
+            .replace(/^-+|-+$/g, '') || 'plugin';
+    }
+    async getClaudeNativeFeatureKinds(pluginDir, manifest) {
+        const featureChecks = await Promise.all([
+            (async () => !!manifest.commands || await isDirectory(join(pluginDir, 'commands')))(),
+            (async () => !!manifest.hooks || await isDirectory(join(pluginDir, 'hooks')))(),
+            (async () => !!manifest.agents || await isDirectory(join(pluginDir, 'agents')))(),
+            isDirectory(join(pluginDir, 'prompts')),
+            isDirectory(join(pluginDir, 'schemas')),
+            isDirectory(join(pluginDir, 'scripts')),
+            isDirectory(join(pluginDir, 'templates')),
+        ]);
+        return [
+            ...(featureChecks[0] ? ['commands'] : []),
+            ...(featureChecks[1] ? ['hooks'] : []),
+            ...(featureChecks[2] ? ['agents'] : []),
+            ...(featureChecks[3] ? ['prompts'] : []),
+            ...(featureChecks[4] ? ['schemas'] : []),
+            ...(featureChecks[5] ? ['scripts'] : []),
+            ...(featureChecks[6] ? ['templates'] : []),
+        ];
+    }
+    async getClaudeNativeInstallTarget(plugin, pluginDir) {
+        if (plugin.format !== 'claude') {
+            return null;
+        }
+        const manifestContent = await readFileIfExists(join(pluginDir, '.claude-plugin', 'plugin.json'));
+        if (!manifestContent) {
+            return null;
+        }
+        let manifest;
+        try {
+            manifest = JSON.parse(manifestContent);
+        }
+        catch {
+            return null;
+        }
+        const features = await this.getClaudeNativeFeatureKinds(pluginDir, manifest);
+        if (features.length === 0) {
+            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 versionDir = this.slugifyPluginNamespace(plugin.version || '0.0.0');
+        return {
+            namespace,
+            pluginKey: `${plugin.name}@${namespace}`,
+            installPath: join(homedir(), '.claude', 'plugins', 'cache', namespace, plugin.name, versionDir),
+            features,
+        };
+    }
+    async readClaudeInstalledPlugins() {
+        const path = getClaudeInstalledPluginsPath();
+        const content = await readFileIfExists(path);
+        if (!content) {
+            return { version: 2, plugins: {} };
+        }
+        try {
+            const parsed = JSON.parse(content);
+            if (!parsed || parsed.version !== 2 || typeof parsed.plugins !== 'object' || parsed.plugins === null) {
+                return { version: 2, plugins: {} };
+            }
+            return parsed;
+        }
+        catch {
+            return { version: 2, plugins: {} };
+        }
+    }
+    async saveClaudeInstalledPlugins(state) {
+        await writeFile(getClaudeInstalledPluginsPath(), JSON.stringify(state, null, 2));
+    }
+    async installNativeClaudePlugin(plugin, pluginDir, agents) {
+        const installed = [];
+        const skipped = [];
+        const warnings = [];
+        const nativeTarget = await this.getClaudeNativeInstallTarget(plugin, pluginDir);
+        if (!nativeTarget) {
+            return { installed, skipped, warnings };
+        }
+        const hasClaudeTarget = agents.some(agent => agent.id === 'claude');
+        const featureLabel = nativeTarget.features.join(', ');
+        if (!hasClaudeTarget) {
+            skipped.push({
+                agent: 'claude',
+                reason: `Claude Code was not selected; skipped native plugin components (${featureLabel}).`,
+            });
+            warnings.push(`Claude Code-native plugin components detected (${featureLabel}), but no Claude Code target was selected; skipped native install.`);
+            return { installed, skipped, warnings };
+        }
+        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}@`));
+        if (conflictingKey) {
+            skipped.push({
+                agent: 'claude',
+                reason: `Claude plugin "${plugin.name}" is already installed as ${conflictingKey}; skipped native install to avoid duplicates.`,
+            });
+            warnings.push(`Skipped native Claude plugin install because Claude already has "${plugin.name}" installed as ${conflictingKey}.`);
+            return { installed, skipped, warnings };
+        }
+        await fs.rm(nativeTarget.installPath, { recursive: true, force: true }).catch(() => { });
+        await fs.mkdir(dirname(nativeTarget.installPath), { recursive: true });
+        await fs.cp(pluginDir, nativeTarget.installPath, { recursive: true, dereference: true });
+        const now = new Date().toISOString();
+        claudeInstalled.plugins[nativeTarget.pluginKey] = [{
+                scope: 'user',
+                installPath: nativeTarget.installPath,
+                version: plugin.version,
+                installedAt: now,
+                lastUpdated: now,
+            }];
+        await this.saveClaudeInstalledPlugins(claudeInstalled);
+        installed.push({
+            agent: 'claude',
+            pluginKey: nativeTarget.pluginKey,
+            installPath: nativeTarget.installPath,
+        });
+        warnings.push('Reload plugins in Claude Code with /reload-plugins to activate native plugin components.');
+        return { installed, skipped, warnings };
+    }
+    toNativePluginPreview(target) {
+        return {
+            agent: 'claude',
+            pluginKey: target.pluginKey,
+            installPath: target.installPath,
+            features: target.features,
+        };
+    }
+    async removeNativeClaudePlugin(component) {
+        const claudeInstalled = await this.readClaudeInstalledPlugins();
+        const entries = claudeInstalled.plugins[component.pluginKey] || [];
+        const remainingEntries = entries.filter(entry => entry.installPath !== component.installPath);
+        if (remainingEntries.length > 0) {
+            claudeInstalled.plugins[component.pluginKey] = remainingEntries;
+        }
+        else {
+            delete claudeInstalled.plugins[component.pluginKey];
+        }
+        await this.saveClaudeInstalledPlugins(claudeInstalled);
+        await fs.rm(component.installPath, { recursive: true, force: true }).catch(() => { });
+        return true;
+    }
     // ── Source Resolution ──────────────────────────────────────────────
     /**
      * Resolve a source string into a PluginSource.
@@ -182,11 +577,7 @@ export class PluginManager {
             .filter(p => p.name.includes(name) || name.includes(p.name))
             .map(p => p.name)
             .slice(0, 5);
-        let msg = `Plugin "${name}" not found in ${registry.name} marketplace.`;
-        if (suggestions.length > 0) {
-            msg += ` Did you mean: ${suggestions.join(', ')}?`;
-        }
-        throw new Error(msg);
+        throw new MarketplacePluginNotFoundError(name, registryId, registry.name, suggestions);
     }
     /**
      * List all plugins in a marketplace, optionally filtered
@@ -201,7 +592,13 @@ export class PluginManager {
             const fullDir = join(cacheDir, dir);
             if (!(await isDirectory(fullDir)))
                 continue;
-            const cat = dir === 'plugins' ? 'official' : dir === 'external_plugins' ? 'community' : dir;
+            const cat = dir === 'plugins'
+                ? 'official'
+                : dir === 'external_plugins'
+                    ? 'community'
+                    : dir.startsWith('skills/.')
+                        ? dir.slice('skills/.'.length)
+                        : dir;
             if (category && cat !== category)
                 continue;
             const entries = await listFiles(fullDir);
@@ -312,10 +709,10 @@ export class PluginManager {
         const mcpServers = await this.parseMcpJson(pluginDir);
         // Warn about agent-specific features
         if (await isDirectory(join(pluginDir, 'hooks')) || manifest.hooks) {
-            warnings.push('Hooks (hooks/) are Claude Code-specific and were not installed');
+            warnings.push('Hooks (hooks/) are Claude Code-specific');
         }
         if (await isDirectory(join(pluginDir, 'agents')) || manifest.agents) {
-            warnings.push('Agent definitions (agents/) are Claude Code-specific and were not installed');
+            warnings.push('Agent definitions (agents/) are Claude Code-specific');
         }
         return {
             name: manifest.name,
@@ -499,34 +896,18 @@ ${body.trim()}
      * This is the main one-liner entry point.
      */
     async installPlugin(source, projectPath, options = {}) {
-        const resolved = this.resolveSource(source, { from: options.from });
-        let pluginDir;
-        let tempDir = null;
-        // 1. Resolve source to a local directory
-        if (resolved.type === 'marketplace') {
-            pluginDir = await this.resolveMarketplacePlugin(resolved.pluginName, resolved.marketplace || 'claude');
-        }
-        else if (resolved.type === 'github') {
-            if (!resolved.url)
-                throw new Error(`Invalid source: ${source}`);
-            tempDir = await this.skillsManager.cloneRepo(resolved.url);
-            pluginDir = tempDir;
-        }
-        else {
-            pluginDir = resolve(resolved.path || source);
-            if (!(await fileExists(pluginDir))) {
-                throw new Error(`Local path not found: ${pluginDir}`);
-            }
-        }
+        const context = this.takePreparedInstallContext(source, options.from)
+            || await this.loadPluginContext(source, { from: options.from });
         try {
             // 2. Parse plugin
-            const plugin = await this.parsePlugin(pluginDir, resolved);
+            const plugin = context.plugin;
             // 3. If --list, return early with contents
             if (options.list) {
                 return {
                     plugin,
                     skills: { installed: [], skipped: [] },
                     mcpServers: { applied: [], skipped: [] },
+                    nativePlugins: { installed: [], skipped: [] },
                     warnings: plugin.warnings,
                 };
             }
@@ -537,6 +918,7 @@ ${body.trim()}
                     plugin,
                     skills: { installed: [], skipped: plugin.skills.map(s => ({ name: s.name, reason: 'No target agents found' })) },
                     mcpServers: { applied: [], skipped: plugin.mcpServers.map(s => ({ name: s.name, reason: 'No target agents found' })) },
+                    nativePlugins: { installed: [], skipped: [] },
                     warnings: plugin.warnings,
                 };
             }
@@ -544,21 +926,25 @@ ${body.trim()}
             const skillResult = await this.installPluginSkills(plugin, projectPath, agents, options);
             // 6. Apply MCP servers per agent
             const mcpResult = await this.applyPluginMcpServers(plugin, projectPath, agents, options.global);
-            // 7. Save to registry only when the install actually applied portable components.
-            if (skillResult.installed.length > 0 || mcpResult.applied.length > 0) {
+            // 7. Install agent-native plugin payloads when supported.
+            const nativePluginResult = await this.installNativeClaudePlugin(plugin, plugin.resolvedPluginDir, agents);
+            const installWarnings = [...plugin.warnings, ...nativePluginResult.warnings];
+            // 8. Save to registry only when the install actually applied components.
+            if (skillResult.installed.length > 0 || mcpResult.applied.length > 0 || nativePluginResult.installed.length > 0) {
                 const installed = {
                     name: plugin.name,
                     version: plugin.version,
                     description: plugin.description,
-                    source: resolved,
+                    source: context.effectiveSource,
                     format: plugin.format,
                     installedAt: new Date().toISOString(),
                     scope: options.global ? 'global' : 'project',
                     components: {
                         skills: skillResult.installed,
                         mcpServers: mcpResult.applied,
+                        nativePlugins: nativePluginResult.installed,
                     },
-                    warnings: plugin.warnings,
+                    warnings: installWarnings,
                 };
                 await this.addToRegistry(installed, projectPath, options.global);
             }
@@ -566,13 +952,12 @@ ${body.trim()}
                 plugin,
                 skills: skillResult,
                 mcpServers: mcpResult,
-                warnings: plugin.warnings,
+                nativePlugins: nativePluginResult,
+                warnings: installWarnings,
             };
         }
         finally {
-            if (tempDir) {
-                await fs.rm(tempDir, { recursive: true, force: true }).catch(() => { });
-            }
+            await this.cleanupLoadedPluginContext(context);
         }
     }
     /**
@@ -765,7 +1150,8 @@ ${body.trim()}
         if (options.agents && options.agents.length > 0) {
             const agentSet = new Set(options.agents);
             plugins = plugins.filter(p => p.components.skills.some(s => agentSet.has(s.agent)) ||
-                p.components.mcpServers.some(m => agentSet.has(m.agent)));
+                p.components.mcpServers.some(m => agentSet.has(m.agent)) ||
+                (p.components.nativePlugins || []).some(nativePlugin => agentSet.has(nativePlugin.agent)));
         }
         return plugins;
     }
@@ -778,7 +1164,8 @@ ${body.trim()}
         if (!plugin) {
             return { removed: false, details: [`Plugin "${name}" not found in registry`] };
         }
-        if (plugin.components.skills.length === 0 && plugin.components.mcpServers.length === 0) {
+        const pluginNativeComponents = plugin.components.nativePlugins || [];
+        if (plugin.components.skills.length === 0 && plugin.components.mcpServers.length === 0 && pluginNativeComponents.length === 0) {
             registry.plugins = registry.plugins.filter(p => p.name !== name);
             await this.saveRegistry(registry, projectPath, options.global);
             return {
@@ -877,7 +1264,48 @@ ${body.trim()}
             ...retainedMcpServers,
             ...targetedMcpServers.filter(mcp => !removedMcpKeys.has(`${mcp.agent}:${mcp.name}`)),
         ];
-        if (removedSkillPaths.size === 0 && removedMcpKeys.size === 0) {
+        const targetedNativePlugins = agentFilter
+            ? pluginNativeComponents.filter(nativePlugin => agentFilter.has(nativePlugin.agent))
+            : pluginNativeComponents;
+        const retainedNativePlugins = agentFilter
+            ? pluginNativeComponents.filter(nativePlugin => !agentFilter.has(nativePlugin.agent))
+            : [];
+        const otherScopeRegistry = await this.getRegistry(projectPath, !options.global);
+        const otherRegistryNativePlugins = otherScopeRegistry.plugins
+            .flatMap(entry => entry.components.nativePlugins || []);
+        const otherPluginNativePlugins = registry.plugins
+            .filter(entry => entry.name !== plugin.name)
+            .flatMap(entry => entry.components.nativePlugins || []);
+        const remainingNativeRefs = [
+            ...retainedNativePlugins,
+            ...otherPluginNativePlugins,
+            ...otherRegistryNativePlugins,
+        ];
+        const removedNativeKeys = new Set();
+        for (const nativePlugin of targetedNativePlugins) {
+            const nativeKey = `${nativePlugin.agent}:${nativePlugin.pluginKey}:${nativePlugin.installPath}`;
+            if (removedNativeKeys.has(nativeKey)) {
+                continue;
+            }
+            const sharedNativeInstall = remainingNativeRefs.some(other => other.installPath === nativePlugin.installPath || other.pluginKey === nativePlugin.pluginKey);
+            if (sharedNativeInstall) {
+                details.push(`Skipped shared native plugin payload: ${nativePlugin.pluginKey} (${nativePlugin.agent})`);
+                continue;
+            }
+            try {
+                await this.removeNativeClaudePlugin(nativePlugin);
+                removedNativeKeys.add(nativeKey);
+                details.push(`Removed native plugin payload: ${nativePlugin.pluginKey} (${nativePlugin.agent})`);
+            }
+            catch {
+                details.push(`Could not remove native plugin payload: ${nativePlugin.pluginKey} (${nativePlugin.agent})`);
+            }
+        }
+        const remainingNativePlugins = [
+            ...retainedNativePlugins,
+            ...targetedNativePlugins.filter(nativePlugin => !removedNativeKeys.has(`${nativePlugin.agent}:${nativePlugin.pluginKey}:${nativePlugin.installPath}`)),
+        ];
+        if (removedSkillPaths.size === 0 && removedMcpKeys.size === 0 && removedNativeKeys.size === 0) {
             if (agentFilter) {
                 details.push(`No removable plugin components matched the requested agents for "${name}"`);
             }
@@ -888,10 +1316,13 @@ ${body.trim()}
             components: {
                 skills: remainingSkills,
                 mcpServers: remainingMcpServers,
+                nativePlugins: remainingNativePlugins,
             },
         };
         registry.plugins = registry.plugins.filter(p => p.name !== name);
-        if (updatedPlugin.components.skills.length > 0 || updatedPlugin.components.mcpServers.length > 0) {
+        if (updatedPlugin.components.skills.length > 0 ||
+            updatedPlugin.components.mcpServers.length > 0 ||
+            (updatedPlugin.components.nativePlugins || []).length > 0) {
             registry.plugins.push(updatedPlugin);
             details.push('Updated plugin registry');
         }