specrails-desktop 2.30.2 → 2.31.0

package/server/dist/plugin-manager.js

@@ -11,11 +11,18 @@ const claude_approval_1 = require("./plugins/claude-approval");
 const drift_1 = require("./plugins/drift");
 const providers_1 = require("./providers");
 const paths_1 = require("./plugins/paths");
-function readMcpServersMap(projectPath) {
+function providerMcpJsonPath(projectPath, providerId) {
+    if (providerId && (0, providers_1.hasAdapter)(providerId)) {
+        return (0, providers_1.getAdapter)(providerId).projectMcpPath?.(projectPath) ?? (0, paths_1.mcpJsonPath)(projectPath);
+    }
+    return (0, paths_1.mcpJsonPath)(projectPath);
+}
+function readMcpServersMap(projectPath, providerId) {
     try {
-        if (!fs_1.default.existsSync((0, paths_1.mcpJsonPath)(projectPath)))
+        const file = providerMcpJsonPath(projectPath, providerId);
+        if (!fs_1.default.existsSync(file))
             return {};
-        const raw = fs_1.default.readFileSync((0, paths_1.mcpJsonPath)(projectPath), 'utf8');
+        const raw = fs_1.default.readFileSync(file, 'utf8');
         if (!raw.trim())
             return {};
         const parsed = JSON.parse(raw);
@@ -27,6 +34,87 @@ function readMcpServersMap(projectPath) {
 }
 const json_mutation_1 = require("./plugins/json-mutation");
 const contributors_1 = require("./plugins/contributors");
+const LEGACY_PROVIDER = 'claude';
+function targetProvider(providerId) {
+    return providerId?.trim() || LEGACY_PROVIDER;
+}
+function legacyProvider(providerId, legacyProviderId) {
+    return legacyProviderId?.trim() || providerId;
+}
+function legacyProviderState(entry) {
+    return {
+        installedAt: entry.installedAt,
+        installedFiles: [...(entry.installedFiles ?? [])],
+        health: entry.health,
+        healthReason: entry.healthReason,
+        ownedMcpServers: [...(entry.ownedMcpServers ?? [])],
+    };
+}
+/** Resolve one provider without pretending a legacy primary install also
+ * belongs to every secondary provider. */
+function getProviderState(entry, providerId, legacyProviderId) {
+    if (!entry)
+        return undefined;
+    if (entry.providers)
+        return entry.providers[providerId];
+    return providerId === legacyProviderId ? legacyProviderState(entry) : undefined;
+}
+/** Materialize the provider map lazily when the first post-migration mutation
+ * occurs. Until then legacy state remains byte-compatible on disk. */
+function ensureProviderStates(entry, legacyProviderId) {
+    if (!entry.providers) {
+        entry.providers = { [legacyProviderId]: legacyProviderState(entry) };
+    }
+    return entry.providers;
+}
+/** Keep the schema-v1 aggregate fields truthful for older Desktop builds and
+ * diagnostics that have not learned the provider map yet. */
+function syncAggregateState(entry) {
+    const states = Object.values(entry.providers ?? {});
+    if (states.length === 0)
+        return;
+    entry.installedAt = states
+        .map((state) => state.installedAt)
+        .sort()[0] ?? entry.installedAt;
+    entry.installedFiles = Array.from(new Set(states.flatMap((state) => state.installedFiles ?? [])));
+    const degraded = states.find((state) => state.health === 'degraded');
+    if (degraded) {
+        entry.health = 'degraded';
+        entry.healthReason = degraded.healthReason;
+    }
+    else if (states.every((state) => state.health === 'ok')) {
+        entry.health = 'ok';
+        delete entry.healthReason;
+    }
+    else {
+        entry.health = 'unknown';
+        delete entry.healthReason;
+    }
+    entry.ownedMcpServers = Array.from(new Set(states.flatMap((state) => state.ownedMcpServers ?? [])));
+}
+function supportsProvider(plugin, providerId) {
+    const declared = plugin.manifest.providerSupport;
+    return declared === undefined
+        ? providerId === LEGACY_PROVIDER
+        : Object.prototype.hasOwnProperty.call(declared, providerId);
+}
+function sameInstructionsFile(leftProviderId, rightProviderId) {
+    if (!(0, providers_1.hasAdapter)(leftProviderId) || !(0, providers_1.hasAdapter)(rightProviderId))
+        return false;
+    return (0, providers_1.getAdapter)(leftProviderId).instructionsFilename === (0, providers_1.getAdapter)(rightProviderId).instructionsFilename;
+}
+/** A single managed instructions block may be shared by providers that declare
+ * the same project-relative instructions path. Removing or deactivating one
+ * provider must not remove that block while another such provider still has
+ * the plugin active. Codex (`AGENTS.md`) and Kimi
+ * (`.kimi-code/AGENTS.md`) are intentionally independent. */
+function hasOtherActiveContributor(entry, providerId) {
+    if (!entry.providers)
+        return false;
+    return Object.entries(entry.providers).some(([candidate, state]) => candidate !== providerId &&
+        state.active !== false &&
+        sameInstructionsFile(candidate, providerId));
+}
 class PluginNotFoundError extends Error {
     constructor(name) {
         super(`plugin not found in registry: ${name}`);
@@ -103,33 +191,35 @@ class PluginManager {
         });
     }
     // ─── Catalog ───────────────────────────────────────────────────────────────
-    async listAvailable(projectPath, providerId) {
+    async listAvailable(projectPath, providerId, legacyProviderId) {
+        const provider = targetProvider(providerId);
+        const primaryProvider = legacyProvider(provider, legacyProviderId);
         const state = this.getProjectState(projectPath);
         const entries = [];
         // Bundled plugins, regardless of install state.
         for (const plugin of this.registry.byName.values()) {
             const m = plugin.manifest;
             const stateEntry = state.plugins[m.name];
+            const providerState = getProviderState(stateEntry, provider, primaryProvider);
             let status;
             // Provider applicability: a plugin is `not-applicable` when the
             // project's provider is registered, providerSupport is declared, and
             // there's no entry for this provider. Plugins that don't declare
             // providerSupport at all default to claude-compatible (preserves
             // pre-§14 behaviour for unchanged manifests).
-            const supportsThisProvider = providerId === undefined
-                ? true
-                : m.providerSupport === undefined
-                    ? providerId === 'claude'
-                    : providerId in m.providerSupport;
+            const supportsThisProvider = supportsProvider(plugin, provider);
             if (!supportsThisProvider) {
                 status = 'not-applicable';
             }
-            else if (!stateEntry) {
+            else if (!providerState) {
                 status = 'not-installed';
             }
-            else if (stateEntry.health === 'degraded') {
+            else if (providerState.health === 'degraded') {
                 status = 'degraded';
             }
+            else if (providerState.active === false) {
+                status = 'deactivated';
+            }
             else {
                 // Plugin install lives in two files:
                 //   (a) state.json — the app's record that the plugin is installed
@@ -139,14 +229,14 @@ class PluginManager {
                 // (b) check is skipped because the registration lives outside the
                 // project filesystem (CODEX_HOME).
                 let allKeysPresent = true;
-                if (providerId === 'codex') {
+                if ((0, providers_1.hasAdapter)(provider) && (0, providers_1.getAdapter)(provider).mcpRegistration === 'cli-add') {
                     // For codex we trust state.json — `codex mcp list` against the
                     // per-project CODEX_HOME is the source of truth, but it requires a
                     // subprocess which is too expensive for a catalog listing call.
                     allKeysPresent = true;
                 }
                 else {
-                    const mcpServers = readMcpServersMap(projectPath);
+                    const mcpServers = readMcpServersMap(projectPath, provider);
                     for (const server of m.owns.mcpServers ?? []) {
                         if (!(server in mcpServers)) {
                             allKeysPresent = false;
@@ -160,18 +250,22 @@ class PluginManager {
             // affordance when our project-scoped install is being shadowed.
             const conflicts = [];
             const cachedDisabled = [];
-            for (const server of m.owns.mcpServers ?? []) {
-                for (const key of (0, claude_approval_1.findEnabledMarketplaceKeys)(server)) {
-                    if (!conflicts.includes(key))
-                        conflicts.push(key);
-                }
-                for (const key of (0, claude_approval_1.findInstalledButNotEnabledMarketplaceKeys)(server)) {
-                    if (!cachedDisabled.includes(key))
-                        cachedDisabled.push(key);
+            if (provider === 'claude') {
+                for (const server of m.owns.mcpServers ?? []) {
+                    for (const key of (0, claude_approval_1.findEnabledMarketplaceKeys)(server)) {
+                        if (!conflicts.includes(key))
+                            conflicts.push(key);
+                    }
+                    for (const key of (0, claude_approval_1.findInstalledButNotEnabledMarketplaceKeys)(server)) {
+                        if (!cachedDisabled.includes(key))
+                            cachedDisabled.push(key);
+                    }
                 }
             }
             // Drift detection: only meaningful when actually installed.
-            const updateAvailable = stateEntry ? (0, drift_1.detectMcpDrift)(projectPath, plugin) : false;
+            const updateAvailable = providerState
+                ? (0, drift_1.detectMcpDrift)(projectPath, plugin, provider)
+                : false;
             entries.push({
                 name: m.name,
                 version: m.version,
@@ -181,9 +275,10 @@ class PluginManager {
                 requirements: m.requirements ?? [],
                 owns: m.owns,
                 status,
-                installedAt: stateEntry?.installedAt,
-                health: stateEntry?.health,
-                healthReason: stateEntry?.healthReason,
+                installedAt: providerState?.installedAt,
+                health: providerState?.health,
+                healthReason: providerState?.healthReason,
+                providerId: provider,
                 marketplaceConflicts: conflicts.length > 0 ? conflicts : undefined,
                 marketplaceCachedButDisabled: cachedDisabled.length > 0 ? cachedDisabled : undefined,
                 updateAvailable: updateAvailable || undefined,
@@ -193,6 +288,9 @@ class PluginManager {
         for (const [name, entry] of Object.entries(state.plugins)) {
             if (this.registry.byName.has(name))
                 continue;
+            const providerState = getProviderState(entry, provider, primaryProvider);
+            if (!providerState)
+                continue;
             entries.push({
                 name,
                 version: entry.version,
@@ -201,24 +299,34 @@ class PluginManager {
                 requirements: [],
                 owns: {},
                 status: 'orphan',
-                installedAt: entry.installedAt,
-                health: entry.health,
-                healthReason: entry.healthReason,
+                installedAt: providerState.installedAt,
+                health: providerState.health,
+                healthReason: providerState.healthReason,
+                providerId: provider,
             });
         }
         return entries.sort((a, b) => a.name.localeCompare(b.name));
     }
     // ─── Preview install ───────────────────────────────────────────────────────
-    async previewInstall(projectPath, projectId, name) {
+    async previewInstall(projectPath, projectId, name, providerId, slug) {
         const plugin = this.registry.byName.get(name);
         if (!plugin)
             throw new PluginNotFoundError(name);
+        const provider = targetProvider(providerId);
+        if (!supportsProvider(plugin, provider)) {
+            throw new PluginInstallError(`plugin '${name}' is not applicable for provider '${provider}'.`);
+        }
         let files;
         if (plugin.previewInstall) {
-            files = await plugin.previewInstall({ projectPath, projectId });
+            files = await plugin.previewInstall({
+                projectPath,
+                projectId,
+                providerId: provider,
+                slug,
+            });
         }
         else {
-            files = this._derivePreviewFiles(projectPath, plugin);
+            files = this._derivePreviewFiles(projectPath, plugin, provider);
         }
         const requirements = await Promise.all((plugin.manifest.requirements ?? []).map(async (req) => {
             if (this._options.checkPrerequisite) {
@@ -236,25 +344,26 @@ class PluginManager {
             platformNote,
         };
     }
-    _derivePreviewFiles(projectPath, plugin) {
+    _derivePreviewFiles(projectPath, plugin, providerId) {
         const out = [];
         const m = plugin.manifest;
         // .mcp.json
         if ((m.owns.mcpServers ?? []).length > 0) {
-            const mcpExists = fs_1.default.existsSync((0, paths_1.mcpJsonPath)(projectPath));
+            const mcpFile = providerMcpJsonPath(projectPath, providerId);
+            const mcpExists = fs_1.default.existsSync(mcpFile);
             out.push({
-                path: '.mcp.json',
+                path: path_1.default.relative(projectPath, mcpFile),
                 op: mcpExists ? 'modify' : 'create',
                 summary: `+ mcpServers.${(m.owns.mcpServers ?? []).join(', mcpServers.')}`,
             });
         }
         // Agent fragments
-        for (const frag of m.owns.agentFragments ?? []) {
+        for (const frag of providerId && providerId !== 'claude' ? [] : (m.owns.agentFragments ?? [])) {
             const exists = fs_1.default.existsSync(path_1.default.join(projectPath, frag));
             out.push({ path: frag, op: exists ? 'modify' : 'create' });
         }
         // Shared-file contributors (CLAUDE.md today, more in the future).
-        for (const rel of (0, contributors_1.contributorPaths)(plugin)) {
+        for (const rel of (0, contributors_1.contributorPaths)(plugin, providerId)) {
             const exists = fs_1.default.existsSync(path_1.default.join(projectPath, rel));
             out.push({
                 path: rel,
@@ -272,32 +381,34 @@ class PluginManager {
         return out;
     }
     // ─── Install ───────────────────────────────────────────────────────────────
-    async install(projectPath, projectId, name, broadcast, providerId, slug) {
+    async install(projectPath, projectId, name, broadcast, providerId, slug, legacyProviderId) {
         const plugin = this.registry.byName.get(name);
         if (!plugin)
             throw new PluginNotFoundError(name);
+        const provider = targetProvider(providerId);
+        const primaryProvider = legacyProvider(provider, legacyProviderId);
         // Provider applicability gate: refuse to install a plugin that has no
         // providerSupport entry for this project's provider. Plugins that omit
         // providerSupport altogether default to claude-compatible.
-        if (providerId !== undefined && providerId !== 'claude') {
+        if (!supportsProvider(plugin, provider)) {
             const declared = plugin.manifest.providerSupport;
-            if (declared !== undefined && !(providerId in declared)) {
-                throw new PluginInstallError(`plugin '${name}' is not applicable for provider '${providerId}'. Declared providers: ${Object.keys(declared).join(', ')}.`);
-            }
+            throw new PluginInstallError(`plugin '${name}' is not applicable for provider '${provider}'. Declared providers: ${declared ? Object.keys(declared).join(', ') : LEGACY_PROVIDER}.`);
         }
         const state = this.getProjectState(projectPath);
-        if (state.plugins[name])
+        const existingEntry = state.plugins[name];
+        if (getProviderState(existingEntry, provider, primaryProvider)) {
             throw new PluginAlreadyInstalledError(name);
+        }
         // Check for ownership conflicts with user-authored `.mcp.json` entries.
         // Only meaningful for `project-json` MCP registration providers (claude
         // today). Codex registers via `codex mcp add` against per-project
         // CODEX_HOME, which the plugin's install path checks via `codex mcp list`.
-        const adapter = providerId !== undefined && (0, providers_1.hasAdapter)(providerId)
-            ? (0, providers_1.getAdapter)(providerId)
+        const adapter = (0, providers_1.hasAdapter)(provider)
+            ? (0, providers_1.getAdapter)(provider)
             : null;
         const usesProjectJsonMcp = adapter === null || adapter.mcpRegistration === 'project-json';
         if (usesProjectJsonMcp) {
-            const mcpFile = (0, paths_1.mcpJsonPath)(projectPath);
+            const mcpFile = providerMcpJsonPath(projectPath, provider);
             if (fs_1.default.existsSync(mcpFile)) {
                 const raw = fs_1.default.readFileSync(mcpFile, 'utf8');
                 let parsed;
@@ -307,12 +418,12 @@ class PluginManager {
                 catch {
                     // A hand-edited / broken `.mcp.json` should yield an actionable 409,
                     // not an opaque 500 with a raw "Unexpected token" SyntaxError.
-                    throw new PluginInstallError(`cannot install '${name}': '${(0, paths_1.mcpJsonPath)(projectPath)}' is not valid JSON; fix it first.`);
+                    throw new PluginInstallError(`cannot install '${name}': '${mcpFile}' is not valid JSON; fix it first.`);
                 }
                 const servers = parsed.mcpServers ?? {};
                 for (const key of plugin.manifest.owns.mcpServers ?? []) {
                     if (key in servers) {
-                        throw new PluginInstallError(`cannot install '${name}': '${(0, paths_1.mcpJsonPath)(projectPath)}' already has a 'mcpServers.${key}' entry. Remove it first.`);
+                        throw new PluginInstallError(`cannot install '${name}': '${mcpFile}' already has a 'mcpServers.${key}' entry. Remove it first.`);
                     }
                 }
             }
@@ -320,14 +431,15 @@ class PluginManager {
         // Snapshot pre-install state of every file the plugin might touch — we
         // need exact bytes to roll back if install/verify fails.
         const targetPaths = [
-            (0, paths_1.mcpJsonPath)(projectPath),
+            providerMcpJsonPath(projectPath, provider),
             (0, paths_1.stateFilePath)(projectPath),
-            ...(plugin.manifest.owns.agentFragments ?? []).map((f) => path_1.default.join(projectPath, f)),
+            ...(provider !== 'claude' ? [] : (plugin.manifest.owns.agentFragments ?? []))
+                .map((f) => path_1.default.join(projectPath, f)),
             // Include the shared instructions file (CLAUDE.md / AGENTS.md) so a failed
             // install rolls it back too — otherwise an applyContributors write that
             // survives a later failure leaves an orphaned managed block with no state
             // entry, which uninstall can never remove (breaks byte-identical restore).
-            ...(0, contributors_1.contributorPaths)(plugin, providerId).map((rel) => path_1.default.join(projectPath, rel)),
+            ...(0, contributors_1.contributorPaths)(plugin, provider).map((rel) => path_1.default.join(projectPath, rel)),
         ];
         const preState = new Map();
         for (const p of targetPaths) {
@@ -339,6 +451,7 @@ class PluginManager {
                 type: 'plugin.install_progress',
                 projectId,
                 name,
+                providerId: provider,
                 line,
                 timestamp: new Date().toISOString(),
             };
@@ -348,7 +461,7 @@ class PluginManager {
             projectPath,
             projectId,
             slug,
-            providerId,
+            providerId: provider,
             recordInstalledFile: (rel) => { installedFiles.push(rel); },
             log: onLog,
         };
@@ -356,7 +469,7 @@ class PluginManager {
             await plugin.install(ctx);
             // Verify immediately. A degraded result also triggers rollback because
             // the spec requires verify-pass before we commit state.
-            const verify = await this._runVerify(plugin, projectPath, projectId);
+            const verify = await this._runVerify(plugin, projectPath, projectId, provider, slug);
             if (!verify.ok) {
                 throw new PluginInstallError(`verify failed after install: ${verify.reason ?? 'unknown'}`);
             }
@@ -366,31 +479,64 @@ class PluginManager {
             // the merged `.mcp.json` entries instead of leaving them loaded forever.
             const ownedMcpServers = [...(plugin.manifest.owns.mcpServers ?? [])];
             await this.lockedUpdateState(projectPath, (s) => {
-                const entry = {
-                    version: plugin.manifest.version,
-                    installedAt: new Date().toISOString(),
-                    installedFiles,
+                const installedAt = new Date().toISOString();
+                const providerEntry = {
+                    installedAt,
+                    installedFiles: [...installedFiles],
+                    active: true,
                     health: 'ok',
+                    ownedMcpServers,
                 };
-                if (ownedMcpServers.length > 0)
-                    entry.ownedMcpServers = ownedMcpServers;
-                s.plugins[name] = entry;
+                const current = s.plugins[name];
+                if (!current) {
+                    const entry = {
+                        version: plugin.manifest.version,
+                        installedAt,
+                        installedFiles: [...installedFiles],
+                        health: 'ok',
+                    };
+                    if (ownedMcpServers.length > 0)
+                        entry.ownedMcpServers = ownedMcpServers;
+                    // A primary-provider-only install stays in the historical shape.
+                    // The provider map is materialised only when it is required, keeping
+                    // state byte-compatible for existing single-provider projects.
+                    if (provider !== primaryProvider) {
+                        entry.providers = { [provider]: providerEntry };
+                    }
+                    s.plugins[name] = entry;
+                    return;
+                }
+                const providerStates = ensureProviderStates(current, primaryProvider);
+                if (providerStates[provider]) {
+                    throw new PluginAlreadyInstalledError(name);
+                }
+                current.version = plugin.manifest.version;
+                providerStates[provider] = providerEntry;
+                syncAggregateState(current);
             });
             // No additional approval write needed: any server in `.mcp.json` loads
             // automatically when Claude opens the project. Install IS active.
             // Apply shared-file contributors (CLAUDE.md block today, more in the
             // future). Each contributor is per-plugin and idempotent.
-            const sharedTouched = await (0, contributors_1.applyContributors)(plugin, projectPath, providerId);
+            const sharedTouched = await (0, contributors_1.applyContributors)(plugin, projectPath, provider);
             if (sharedTouched.length > 0) {
                 for (const p of sharedTouched) {
                     if (!installedFiles.includes(p))
                         installedFiles.push(p);
                 }
                 await this.lockedUpdateState(projectPath, (s) => {
-                    if (s.plugins[name])
-                        s.plugins[name].installedFiles = installedFiles;
-                    else
+                    const entry = s.plugins[name];
+                    if (!entry)
                         return false;
+                    if (!entry.providers && provider === primaryProvider) {
+                        entry.installedFiles = [...installedFiles];
+                        return;
+                    }
+                    const providerState = getProviderState(entry, provider, primaryProvider);
+                    if (!providerState)
+                        return false;
+                    ensureProviderStates(entry, primaryProvider)[provider].installedFiles = [...installedFiles];
+                    syncAggregateState(entry);
                 });
             }
         }
@@ -417,10 +563,10 @@ class PluginManager {
             // CODEX_HOME, NOT the snapshotted filesystem — the file rollback above
             // can't undo it. Run the plugin's uninstall so a verify-failed codex
             // install leaves no orphaned MCP registration (best-effort).
-            if (providerId && (0, providers_1.hasAdapter)(providerId) && (0, providers_1.getAdapter)(providerId).mcpRegistration === 'cli-add') {
+            if ((0, providers_1.hasAdapter)(provider) && (0, providers_1.getAdapter)(provider).mcpRegistration === 'cli-add') {
                 try {
                     await plugin.uninstall({
-                        projectPath, projectId, slug, providerId,
+                        projectPath, projectId, slug, providerId: provider,
                         recordInstalledFile: () => { }, log: onLog,
                     });
                 }
@@ -433,15 +579,19 @@ class PluginManager {
             projectId,
             name,
             version: plugin.manifest.version,
+            providerId: provider,
             timestamp: new Date().toISOString(),
         };
         broadcast(msg);
     }
     // ─── Uninstall ─────────────────────────────────────────────────────────────
-    async uninstall(projectPath, projectId, name, broadcast, providerId, slug) {
+    async uninstall(projectPath, projectId, name, broadcast, providerId, slug, legacyProviderId) {
+        const provider = targetProvider(providerId);
+        const primaryProvider = legacyProvider(provider, legacyProviderId);
         const state = this.getProjectState(projectPath);
         const entry = state.plugins[name];
-        if (!entry)
+        const providerState = getProviderState(entry, provider, primaryProvider);
+        if (!entry || !providerState)
             throw new PluginNotInstalledError(name);
         const plugin = this.registry.byName.get(name);
         const onLog = (line) => {
@@ -449,19 +599,22 @@ class PluginManager {
                 type: 'plugin.install_progress',
                 projectId,
                 name,
+                providerId: provider,
                 line,
                 timestamp: new Date().toISOString(),
             });
         };
         if (plugin) {
-            // Revert shared-file contributors first so a partial uninstall doesn't
+            // Revert provider instruction contributors first so a partial uninstall doesn't
             // leave dangling instructions referencing missing tools.
-            await (0, contributors_1.revertContributors)(plugin, projectPath, providerId);
+            if (!hasOtherActiveContributor(entry, provider)) {
+                await (0, contributors_1.revertContributors)(plugin, projectPath, provider);
+            }
             await plugin.uninstall({
                 projectPath,
                 projectId,
                 slug,
-                providerId,
+                providerId: provider,
                 recordInstalledFile: () => { },
                 log: onLog,
             });
@@ -472,15 +625,22 @@ class PluginManager {
             // mcpServers keys were persisted in state at install time (BUG-PLUGIN-04),
             // so even with the plugin code gone we can surgically strip the merged
             // `.mcp.json` entries instead of leaving them loaded by Claude forever.
-            const ownedMcpServers = entry.ownedMcpServers ?? [];
+            const ownedMcpServers = providerState.ownedMcpServers ?? [];
             if (ownedMcpServers.length > 0) {
                 try {
-                    await PluginManager.removeMcpServers(projectPath, ownedMcpServers);
+                    await PluginManager.removeMcpServers(projectPath, ownedMcpServers, provider);
                 }
                 catch { /* best-effort: leave .mcp.json untouched on failure */ }
             }
             const root = path_1.default.resolve(projectPath);
-            for (const rel of entry.installedFiles ?? []) {
+            const remainingFiles = new Set(Object.entries(entry.providers ?? {})
+                .filter(([candidate]) => candidate !== provider)
+                .flatMap(([, candidateState]) => candidateState.installedFiles ?? []));
+            for (const rel of providerState.installedFiles ?? []) {
+                // A managed contributor path may be referenced by more than one
+                // provider. Never unlink a file still owned by another provider install.
+                if (remainingFiles.has(rel))
+                    continue;
                 const abs = path_1.default.resolve(projectPath, rel);
                 // M5: installedFiles comes from state.json, which a hostile repo can
                 // ship. Without containment, `rel` of "../../../Users/victim/x" (or an
@@ -499,12 +659,29 @@ class PluginManager {
             }
         }
         await this.lockedUpdateState(projectPath, (s) => {
-            delete s.plugins[name];
+            const current = s.plugins[name];
+            if (!current)
+                return false;
+            if (!current.providers && provider === primaryProvider) {
+                delete s.plugins[name];
+                return;
+            }
+            const providers = ensureProviderStates(current, primaryProvider);
+            if (!providers[provider])
+                return false;
+            delete providers[provider];
+            if (Object.keys(providers).length === 0) {
+                delete s.plugins[name];
+            }
+            else {
+                syncAggregateState(current);
+            }
         });
         broadcast({
             type: 'plugin.uninstalled',
             projectId,
             name,
+            providerId: provider,
             timestamp: new Date().toISOString(),
         });
     }
@@ -514,29 +691,65 @@ class PluginManager {
      * `owns.mcpServers` keys are touched; user entries are preserved. Used to
      * resolve drift surfaced by `updateAvailable`.
      */
-    async updateMcpEntry(projectPath, projectId, name, broadcast, providerId) {
+    async updateMcpEntry(projectPath, projectId, name, broadcast, providerId, slug, legacyProviderId) {
         const plugin = this.registry.byName.get(name);
         if (!plugin)
             throw new PluginNotFoundError(name);
+        const provider = targetProvider(providerId);
+        const primaryProvider = legacyProvider(provider, legacyProviderId);
         const state = this.getProjectState(projectPath);
-        if (!state.plugins[name])
+        const entry = state.plugins[name];
+        if (!getProviderState(entry, provider, primaryProvider)) {
             throw new PluginNotInstalledError(name);
+        }
         const expected = plugin.expectedMcpEntry?.();
         if (!expected) {
             throw new PluginInstallError(`'${name}' does not declare expectedMcpEntry; cannot update`);
         }
         const owned = plugin.manifest.owns.mcpServers ?? [];
-        const entries = {};
-        for (const key of owned)
-            entries[key] = expected;
-        await PluginManager.mergeMcpServers(projectPath, entries);
+        if ((0, providers_1.hasAdapter)(provider) && (0, providers_1.getAdapter)(provider).mcpRegistration === 'cli-add') {
+            const lifecycle = {
+                projectPath,
+                projectId,
+                slug,
+                providerId: provider,
+                recordInstalledFile: () => { },
+                log: () => { },
+            };
+            await plugin.uninstall(lifecycle);
+            await plugin.install(lifecycle);
+        }
+        else {
+            const entries = {};
+            for (const key of owned)
+                entries[key] = expected;
+            await PluginManager.mergeMcpServers(projectPath, entries, provider);
+        }
         // Refresh shared-file contributions too: a drift may exist in CLAUDE.md
         // even when the .mcp.json entry matches.
-        await (0, contributors_1.applyContributors)(plugin, projectPath, providerId);
+        await (0, contributors_1.applyContributors)(plugin, projectPath, provider);
+        await this.lockedUpdateState(projectPath, (s) => {
+            const current = s.plugins[name];
+            if (!current)
+                return false;
+            if (!current.providers && provider === primaryProvider) {
+                current.health = 'unknown';
+                delete current.healthReason;
+                return;
+            }
+            const providerState = getProviderState(current, provider, primaryProvider);
+            if (!providerState)
+                return false;
+            const mutable = ensureProviderStates(current, primaryProvider)[provider];
+            mutable.health = 'unknown';
+            delete mutable.healthReason;
+            syncAggregateState(current);
+        });
         broadcast({
             type: 'plugin.health_changed',
             projectId,
             name,
+            providerId: provider,
             status: 'unknown',
             reason: 'updated',
             timestamp: new Date().toISOString(),
@@ -556,13 +769,17 @@ class PluginManager {
      * Plugin install state survives across toggles. Uninstall is the only
      * action that clears state.json + custom-*.md fragments.
      */
-    async setActive(projectPath, projectId, name, active, broadcast, providerId) {
+    async setActive(projectPath, projectId, name, active, broadcast, providerId, slug, legacyProviderId) {
         const plugin = this.registry.byName.get(name);
         if (!plugin)
             throw new PluginNotFoundError(name);
+        const provider = targetProvider(providerId);
+        const primaryProvider = legacyProvider(provider, legacyProviderId);
         const state = this.getProjectState(projectPath);
-        if (!state.plugins[name])
+        const entry = state.plugins[name];
+        if (!entry || !getProviderState(entry, provider, primaryProvider)) {
             throw new PluginNotInstalledError(name);
+        }
         const owned = plugin.manifest.owns.mcpServers ?? [];
         if (owned.length === 0) {
             throw new PluginInstallError(`'${name}' owns no mcpServers; cannot toggle activation`);
@@ -572,47 +789,100 @@ class PluginManager {
             if (!expected) {
                 throw new PluginInstallError(`'${name}' does not declare expectedMcpEntry; cannot activate`);
             }
-            const entries = {};
-            for (const k of owned)
-                entries[k] = expected;
-            await PluginManager.mergeMcpServers(projectPath, entries);
-            await (0, contributors_1.applyContributors)(plugin, projectPath, providerId);
+            if ((0, providers_1.hasAdapter)(provider) && (0, providers_1.getAdapter)(provider).mcpRegistration === 'cli-add') {
+                await plugin.install({
+                    projectPath,
+                    projectId,
+                    slug,
+                    providerId: provider,
+                    recordInstalledFile: () => { },
+                    log: () => { },
+                });
+            }
+            else {
+                const entries = {};
+                for (const k of owned)
+                    entries[k] = expected;
+                await PluginManager.mergeMcpServers(projectPath, entries, provider);
+            }
+            await (0, contributors_1.applyContributors)(plugin, projectPath, provider);
         }
         else {
-            await PluginManager.removeMcpServers(projectPath, owned);
-            await (0, contributors_1.revertContributors)(plugin, projectPath, providerId);
+            if ((0, providers_1.hasAdapter)(provider) && (0, providers_1.getAdapter)(provider).mcpRegistration === 'cli-add') {
+                await plugin.uninstall({
+                    projectPath,
+                    projectId,
+                    slug,
+                    providerId: provider,
+                    recordInstalledFile: () => { },
+                    log: () => { },
+                });
+            }
+            else {
+                await PluginManager.removeMcpServers(projectPath, owned, provider);
+            }
+            if (!hasOtherActiveContributor(entry, provider)) {
+                await (0, contributors_1.revertContributors)(plugin, projectPath, provider);
+            }
         }
+        await this.lockedUpdateState(projectPath, (s) => {
+            const current = s.plugins[name];
+            if (!current)
+                return false;
+            if (!current.providers && provider === primaryProvider) {
+                // Legacy state has no explicit active field. Materialise only when a
+                // value is needed, preserving legacy reads while making the toggle
+                // durable.
+                const providerState = ensureProviderStates(current, primaryProvider)[provider];
+                providerState.active = active;
+                providerState.health = active ? 'ok' : 'unknown';
+                delete providerState.healthReason;
+                syncAggregateState(current);
+                return;
+            }
+            const providerState = getProviderState(current, provider, primaryProvider);
+            if (!providerState)
+                return false;
+            const mutable = ensureProviderStates(current, primaryProvider)[provider];
+            mutable.active = active;
+            mutable.health = active ? 'ok' : 'unknown';
+            delete mutable.healthReason;
+            syncAggregateState(current);
+        });
         broadcast({
             type: 'plugin.health_changed',
             projectId,
             name,
+            providerId: provider,
             status: active ? 'ok' : 'unknown',
             reason: active ? 'activated' : 'deactivated',
             timestamp: new Date().toISOString(),
         });
     }
     /** Drop a state.json entry for a plugin no longer in the registry. */
-    async removeOrphan(projectPath, projectId, name, broadcast) {
+    async removeOrphan(projectPath, projectId, name, broadcast, providerId, slug, legacyProviderId) {
         if (this.registry.byName.has(name)) {
             throw new PluginInstallError(`'${name}' is not orphan; it is still bundled. Use uninstall instead.`);
         }
-        return this.uninstall(projectPath, projectId, name, broadcast);
+        return this.uninstall(projectPath, projectId, name, broadcast, providerId, slug, legacyProviderId);
     }
     // ─── Verify ────────────────────────────────────────────────────────────────
-    async verify(projectPath, projectId, name, broadcast) {
+    async verify(projectPath, projectId, name, broadcast, providerId, legacyProviderId, slug) {
         const plugin = this.registry.byName.get(name);
         if (!plugin)
             throw new PluginNotFoundError(name);
-        const result = await this._runVerify(plugin, projectPath, projectId);
-        await this._cacheHealth(projectPath, projectId, name, result, broadcast);
+        const provider = targetProvider(providerId);
+        const primaryProvider = legacyProvider(provider, legacyProviderId);
+        const result = await this._runVerify(plugin, projectPath, projectId, provider, slug);
+        await this._cacheHealth(projectPath, projectId, name, result, broadcast, provider, primaryProvider);
         return result;
     }
-    async _runVerify(plugin, projectPath, projectId) {
+    async _runVerify(plugin, projectPath, projectId, providerId, slug) {
         const timeout = plugin.manifest.verifyTimeoutMs ?? this._options.defaultVerifyTimeoutMs;
         const checkedAt = new Date().toISOString();
         try {
             const result = await Promise.race([
-                plugin.verify({ projectPath, projectId }),
+                plugin.verify({ projectPath, projectId, providerId, slug }),
                 new Promise((resolve) => setTimeout(() => resolve({ __timeout: true }), timeout).unref?.()),
             ]);
             if ('__timeout' in result) {
@@ -624,7 +894,9 @@ class PluginManager {
             return { ok: false, reason: `verify-exception: ${err?.message ?? String(err)}`, checkedAt };
         }
     }
-    async _cacheHealth(projectPath, projectId, name, result, broadcast) {
+    async _cacheHealth(projectPath, projectId, name, result, broadcast, providerId, legacyProviderId) {
+        const provider = targetProvider(providerId);
+        const primaryProvider = legacyProvider(provider, legacyProviderId);
         const newHealth = result.ok ? 'ok' : 'degraded';
         // Read → compare → write under ONE lock so concurrent verifies on the same
         // project (resolvePluginsForSpawn runs every installed plugin's verify in
@@ -636,11 +908,22 @@ class PluginManager {
             const entry = state.plugins[name];
             if (!entry)
                 return false;
-            const changed = entry.health !== newHealth || entry.healthReason !== result.reason;
+            const providerState = getProviderState(entry, provider, primaryProvider);
+            if (!providerState)
+                return false;
+            const changed = providerState.health !== newHealth || providerState.healthReason !== result.reason;
             if (!changed)
                 return false; // nothing to persist — avoids per-spawn write churn (verify runs on every rail spawn)
-            entry.health = newHealth;
-            entry.healthReason = result.reason;
+            if (!entry.providers && provider === primaryProvider) {
+                entry.health = newHealth;
+                entry.healthReason = result.reason;
+            }
+            else {
+                const mutable = ensureProviderStates(entry, primaryProvider)[provider];
+                mutable.health = newHealth;
+                mutable.healthReason = result.reason;
+                syncAggregateState(entry);
+            }
             didChange = true;
         });
         if (!didChange)
@@ -650,6 +933,7 @@ class PluginManager {
                 type: 'plugin.health_changed',
                 projectId,
                 name,
+                providerId: provider,
                 status: newHealth,
                 reason: result.reason,
                 timestamp: new Date().toISOString(),
@@ -659,8 +943,9 @@ class PluginManager {
     }
     // ─── Surgical helpers exposed to plugins ───────────────────────────────────
     /** Helper: surgically merge `mcpServers.<key>` entries into .mcp.json. */
-    static async mergeMcpServers(projectPath, entries) {
-        await (0, json_mutation_1.surgicalMergeJson)((0, paths_1.mcpJsonPath)(projectPath), (current) => {
+    static async mergeMcpServers(projectPath, entries, providerId) {
+        const mcpFile = providerMcpJsonPath(projectPath, providerId);
+        await (0, json_mutation_1.surgicalMergeJson)(mcpFile, (current) => {
             const next = (current ?? {});
             // BUG-PLUGIN-05: `mcpServers` MUST be a plain object. The old `?? {}`
             // fallback only covered null/undefined — if it was a JSON array (or any
@@ -673,7 +958,7 @@ class PluginManager {
                 raw === null ||
                 (typeof raw === 'object' && !Array.isArray(raw));
             if (!isPlainObject) {
-                throw new PluginInstallError(`cannot merge mcpServers into '${(0, paths_1.mcpJsonPath)(projectPath)}': ` +
+                throw new PluginInstallError(`cannot merge mcpServers into '${mcpFile}': ` +
                     `'mcpServers' must be a JSON object but is ${Array.isArray(raw) ? 'an array' : typeof raw}; fix it first.`);
             }
             const servers = (raw ?? {});
@@ -684,10 +969,10 @@ class PluginManager {
         });
     }
     /** Helper: remove specific `mcpServers.<key>` entries from .mcp.json. */
-    static async removeMcpServers(projectPath, keys) {
+    static async removeMcpServers(projectPath, keys, providerId) {
         if (keys.length === 0)
             return;
-        await (0, json_mutation_1.surgicalRemoveKeys)((0, paths_1.mcpJsonPath)(projectPath), keys.map((k) => `mcpServers.${k}`));
+        await (0, json_mutation_1.surgicalRemoveKeys)(providerMcpJsonPath(projectPath, providerId), keys.map((k) => `mcpServers.${k}`));
     }
 }
 exports.PluginManager = PluginManager;