@yagni-app/code-staging 1.0.6-staging.1255.1 → 1.0.6-staging.1257.1

package/dist/claudeCompat.d.ts

@@ -34,6 +34,23 @@ export declare const CLAUDE_COMPAT_DISABLE_ENV = "YAGNI_DISABLE_CLAUDE_COMPAT";
 export declare const CLAUDE_AGENT_DIRS_ENV = "YAGNI_CLAUDE_AGENT_DIRS";
 /** `.claude/rules` dirs for the extension's rules injection (delimiter-joined). */
 export declare const CLAUDE_RULES_DIRS_ENV = "YAGNI_CLAUDE_RULES_DIRS";
+/**
+ * Plugin MCP servers for the extension's MCP client: a JSON array of
+ * `{ plugin, sourcePath, gated, servers }`. `${CLAUDE_PLUGIN_ROOT}` is already
+ * expanded to the plugin's install dir; other `${VAR}` references are left for
+ * the extension's normal env expansion. `gated` marks servers that came from
+ * repo config (repo marketplace, project-scope `enabledPlugins`) and must pass
+ * the same approval the repo's `.mcp.json` would.
+ */
+export declare const CLAUDE_PLUGIN_MCP_ENV = "YAGNI_CLAUDE_PLUGIN_MCP";
+export interface PluginMcpEnvEntry {
+    plugin: string;
+    sourcePath: string;
+    gated: boolean;
+    servers: Record<string, unknown>;
+}
+/** The MCP payload entries for a set of plugins (those without servers are skipped). */
+export declare function pluginMcpEntries(plugins: PluginAssets[], gated: boolean): PluginMcpEnvEntry[];
 export interface ClaudeAssetDirs {
     skills: string | null;
     commands: string | null;
@@ -61,6 +78,9 @@ export interface ClaudeCompatDecision {
     /** `.claude/rules` dirs, user first so project rules win in the prompt. */
     userRulesDirs: string[];
     projectRulesDirs: string[];
+    /** Plugin MCP servers, split by the same trust posture (project ones are approval-gated too). */
+    userMcp: PluginMcpEnvEntry[];
+    projectMcp: PluginMcpEnvEntry[];
     /** Ask the user for a trust decision before wiring any project content. */
     needsPrompt: boolean;
 }

package/dist/claudeCompat.js

@@ -32,11 +32,50 @@ import { existsSync, mkdirSync, readFileSync, realpathSync, renameSync, rmdirSyn
 import { homedir } from "node:os";
 import { delimiter, dirname, join, resolve } from "node:path";
 import { discoverClaudePlugins } from "./claudePlugins.js";
+import { pluginsHome, readLedger } from "./pluginStore.js";
 export const CLAUDE_COMPAT_DISABLE_ENV = "YAGNI_DISABLE_CLAUDE_COMPAT";
 /** Plugin `agents/` dirs for the extension's subagent discovery (delimiter-joined). */
 export const CLAUDE_AGENT_DIRS_ENV = "YAGNI_CLAUDE_AGENT_DIRS";
 /** `.claude/rules` dirs for the extension's rules injection (delimiter-joined). */
 export const CLAUDE_RULES_DIRS_ENV = "YAGNI_CLAUDE_RULES_DIRS";
+/**
+ * Plugin MCP servers for the extension's MCP client: a JSON array of
+ * `{ plugin, sourcePath, gated, servers }`. `${CLAUDE_PLUGIN_ROOT}` is already
+ * expanded to the plugin's install dir; other `${VAR}` references are left for
+ * the extension's normal env expansion. `gated` marks servers that came from
+ * repo config (repo marketplace, project-scope `enabledPlugins`) and must pass
+ * the same approval the repo's `.mcp.json` would.
+ */
+export const CLAUDE_PLUGIN_MCP_ENV = "YAGNI_CLAUDE_PLUGIN_MCP";
+const PLUGIN_ROOT_VAR = "${CLAUDE_PLUGIN_ROOT}";
+function expandPluginRoot(value, root) {
+    if (typeof value === "string")
+        return value.split(PLUGIN_ROOT_VAR).join(root);
+    if (Array.isArray(value))
+        return value.map((v) => expandPluginRoot(v, root));
+    if (value && typeof value === "object") {
+        const out = {};
+        for (const [k, v] of Object.entries(value))
+            out[k] = expandPluginRoot(v, root);
+        return out;
+    }
+    return value;
+}
+/** The MCP payload entries for a set of plugins (those without servers are skipped). */
+export function pluginMcpEntries(plugins, gated) {
+    const out = [];
+    for (const plugin of plugins) {
+        if (!plugin.mcp)
+            continue;
+        out.push({
+            plugin: plugin.key,
+            sourcePath: plugin.mcp.sourcePath,
+            gated,
+            servers: expandPluginRoot(plugin.mcp.servers, plugin.root),
+        });
+    }
+    return out;
+}
 function dirsToArgv(dirs) {
     const argv = [];
     if (dirs.skills)
@@ -60,7 +99,8 @@ export function decideClaudeCompat(probe) {
     const projectArgv = [...dirsToArgv(probe.project), ...pluginsToArgv(probe.projectPlugins)];
     const projectAgentDirs = probe.projectPlugins.flatMap((p) => p.agentDirs);
     const projectRulesDirs = probe.project.rules ? [probe.project.rules] : [];
-    const hasProjectContent = projectArgv.length > 0 || projectAgentDirs.length > 0 || projectRulesDirs.length > 0;
+    const projectMcp = pluginMcpEntries(probe.projectPlugins, true);
+    const hasProjectContent = projectArgv.length > 0 || projectAgentDirs.length > 0 || projectRulesDirs.length > 0 || projectMcp.length > 0;
     return {
         userArgv: [...dirsToArgv(probe.user), ...pluginsToArgv(probe.userPlugins)],
         projectArgv,
@@ -68,6 +108,8 @@ export function decideClaudeCompat(probe) {
         projectAgentDirs,
         userRulesDirs: probe.user.rules ? [probe.user.rules] : [],
         projectRulesDirs,
+        userMcp: pluginMcpEntries(probe.userPlugins, false),
+        projectMcp,
         needsPrompt: probe.interactive && hasProjectContent && probe.projectTrust === null,
     };
 }
@@ -210,7 +252,11 @@ export async function claudeCompatArgs(deps) {
     const projectTrust = readTrustDecision(deps.agentDir, deps.cwd);
     let plugins;
     try {
-        plugins = discoverClaudePlugins({ cwd: deps.cwd, homeDir: home });
+        plugins = discoverClaudePlugins({
+            cwd: deps.cwd,
+            homeDir: home,
+            yagniLedger: readLedger(pluginsHome(env, home)),
+        });
     }
     catch {
         plugins = { user: [], project: [] };
@@ -246,11 +292,17 @@ export async function claudeCompatArgs(deps) {
         ...decision.userRulesDirs,
         ...(trusted === true ? decision.projectRulesDirs : []),
     ];
+    const mcpEntries = [
+        ...decision.userMcp,
+        ...(trusted === true ? decision.projectMcp : []),
+    ];
     const extraEnv = {};
     if (agentDirs.length > 0)
         extraEnv[CLAUDE_AGENT_DIRS_ENV] = agentDirs.join(delimiter);
     if (rulesDirs.length > 0)
         extraEnv[CLAUDE_RULES_DIRS_ENV] = rulesDirs.join(delimiter);
+    if (mcpEntries.length > 0)
+        extraEnv[CLAUDE_PLUGIN_MCP_ENV] = JSON.stringify(mcpEntries);
     return { argv, env: extraEnv };
 }
 /** Whether pi's trust file exists yet (used only for messaging). */

package/dist/claudePlugins.d.ts

@@ -17,10 +17,19 @@
  *    relative-path source loads on the project side, unless explicitly
  *    disabled via `enabledPlugins`.
  *
- * Deliberately NOT here: network installation of any kind, plugin hooks, MCP
- * servers (standard MCP support lives in `src/mcpCommand.ts` + the extension's
- * `mcp/` module — see `yagni mcp --help`), LSP servers, themes, output styles.
- * Discovery is read-only.
+ * Three sources, first wins on the same `name@marketplace`:
+ *
+ * 0. YAGNI's own ledger (`~/.yagni-code/plugins`, written by `yagni plugin`;
+ *    see pluginStore.ts) — handed in by the caller as `yagniLedger`.
+ * 1. Claude Code's ledger + `enabledPlugins` (mirrored read-only).
+ * 2. The repo's own `.claude-plugin/marketplace.json`.
+ *
+ * Plugin MCP servers (`.mcp.json` at the plugin root, or the manifest's
+ * `mcpServers`) are collected here and bridged by the launcher into the
+ * extension's MCP client (see claudeCompat.ts). Deliberately NOT here:
+ * network installation (that is pluginStore.ts), plugin hooks, LSP servers,
+ * themes, output styles — those are reported as `unsupported` so `yagni
+ * plugin list` can say so. Discovery is read-only.
  *
  * Everything is fail-soft: malformed JSON, missing dirs, or hostile path
  * entries degrade to "that plugin absent" — never a failed launch. Path
@@ -28,9 +37,21 @@
  * inside the expected root) so a malicious `source` or component override
  * cannot reach outside its repo/plugin.
  */
+import type { PluginLedger } from "./pluginStore.js";
+export type PluginOrigin = "yagni" | "claude-code" | "repo-marketplace";
+export interface PluginMcp {
+    /** File the servers came from (plugin `.mcp.json` or `plugin.json`). */
+    sourcePath: string;
+    /** Raw `mcpServers` map; validated by the extension, `${CLAUDE_PLUGIN_ROOT}` expanded by the launcher. */
+    servers: Record<string, unknown>;
+}
 export interface PluginAssets {
     /** The plugin's name (marketplace-entry name — the `enabledPlugins` key half). */
     name: string;
+    /** `name@marketplace` when the marketplace is known; else the bare name. */
+    key: string;
+    origin: PluginOrigin;
+    version: string | null;
     /** Absolute plugin root directory. */
     root: string;
     /** Dirs (or a lone root SKILL.md file) for pi `--skill`. */
@@ -39,6 +60,14 @@ export interface PluginAssets {
     commandPaths: string[];
     /** Dirs of Claude Code-format agent markdown for subagent discovery. */
     agentDirs: string[];
+    mcp: PluginMcp | null;
+    /** Component kinds present in the plugin that YAGNI Code does not bridge. */
+    unsupported: string[];
+}
+export interface PluginMeta {
+    key?: string;
+    origin?: PluginOrigin;
+    version?: string | null;
 }
 export interface DiscoveredClaudePlugins {
     /** Enabled via the user's own `~/.claude` config; loads without ceremony. */
@@ -71,9 +100,18 @@ export interface EnableState {
 export declare function readEnabledPlugins(cwd: string, homeDir: string): Map<string, EnableState>;
 /** `~/.claude/plugins/known_marketplaces.json` → marketplace name → checkout dir. */
 export declare function readKnownMarketplaces(homeDir: string): Map<string, string>;
+/**
+ * Names and versions from marketplace/plugin JSON become path segments under
+ * the plugin home (`cache/<mp>/<plugin>/<version>`), so they must be plain
+ * single segments: no separators, no `.`/`..`, nothing starting with `-`.
+ */
+export declare const SAFE_SEGMENT: RegExp;
+export declare function isSafeSegment(value: unknown): value is string;
 export interface MarketplaceEntry {
     name: string;
     source: unknown;
+    version?: string;
+    description?: string;
 }
 export interface Marketplace {
     name: string;
@@ -98,10 +136,12 @@ export declare function resolveLocalPluginRoot(mp: Marketplace, entry: Marketpla
  * discovery reads whole dirs), root `SKILL.md` fallback. Null when the plugin
  * has nothing we can bridge.
  */
-export declare function pluginAssets(root: string, name: string): PluginAssets | null;
+export declare function pluginAssets(root: string, name: string, meta?: PluginMeta): PluginAssets | null;
 export interface DiscoverPluginsDeps {
     cwd: string;
     homeDir: string;
+    /** YAGNI's own ledger (`readLedger` from pluginStore.ts); wins over the mirrored Claude Code state. */
+    yagniLedger?: PluginLedger;
 }
 /**
  * All locally-present Claude Code plugin content relevant to `cwd`, split by

package/dist/claudePlugins.js

@@ -17,10 +17,19 @@
  *    relative-path source loads on the project side, unless explicitly
  *    disabled via `enabledPlugins`.
  *
- * Deliberately NOT here: network installation of any kind, plugin hooks, MCP
- * servers (standard MCP support lives in `src/mcpCommand.ts` + the extension's
- * `mcp/` module — see `yagni mcp --help`), LSP servers, themes, output styles.
- * Discovery is read-only.
+ * Three sources, first wins on the same `name@marketplace`:
+ *
+ * 0. YAGNI's own ledger (`~/.yagni-code/plugins`, written by `yagni plugin`;
+ *    see pluginStore.ts) — handed in by the caller as `yagniLedger`.
+ * 1. Claude Code's ledger + `enabledPlugins` (mirrored read-only).
+ * 2. The repo's own `.claude-plugin/marketplace.json`.
+ *
+ * Plugin MCP servers (`.mcp.json` at the plugin root, or the manifest's
+ * `mcpServers`) are collected here and bridged by the launcher into the
+ * extension's MCP client (see claudeCompat.ts). Deliberately NOT here:
+ * network installation (that is pluginStore.ts), plugin hooks, LSP servers,
+ * themes, output styles — those are reported as `unsupported` so `yagni
+ * plugin list` can say so. Discovery is read-only.
  *
  * Everything is fail-soft: malformed JSON, missing dirs, or hostile path
  * entries degrade to "that plugin absent" — never a failed launch. Path
@@ -151,10 +160,20 @@ export function readKnownMarketplaces(homeDir) {
     }
     return out;
 }
+// ── marketplace file ────────────────────────────────────────────────────────
+/**
+ * Names and versions from marketplace/plugin JSON become path segments under
+ * the plugin home (`cache/<mp>/<plugin>/<version>`), so they must be plain
+ * single segments: no separators, no `.`/`..`, nothing starting with `-`.
+ */
+export const SAFE_SEGMENT = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+export function isSafeSegment(value) {
+    return typeof value === "string" && SAFE_SEGMENT.test(value);
+}
 /** Parse `<root>/.claude-plugin/marketplace.json`; null when absent/unusable. */
 export function readMarketplace(root) {
     const parsed = readJsonObject(join(root, ".claude-plugin", "marketplace.json"));
-    if (!parsed || typeof parsed.name !== "string" || parsed.name.length === 0)
+    if (!parsed || !isSafeSegment(parsed.name))
         return null;
     if (!Array.isArray(parsed.plugins))
         return null;
@@ -166,10 +185,16 @@ export function readMarketplace(root) {
     for (const item of parsed.plugins) {
         if (!item || typeof item !== "object" || Array.isArray(item))
             continue;
-        const name = item.name;
-        if (typeof name !== "string" || name.length === 0)
+        const entry = item;
+        const name = entry.name;
+        if (!isSafeSegment(name))
             continue;
-        plugins.push({ name, source: item.source });
+        plugins.push({
+            name,
+            source: entry.source,
+            ...(isSafeSegment(entry.version) ? { version: entry.version } : {}),
+            ...(typeof entry.description === "string" ? { description: entry.description } : {}),
+        });
     }
     return { name: parsed.name, root, pluginRoot, plugins };
 }
@@ -212,13 +237,17 @@ function asStringArray(value) {
  * discovery reads whole dirs), root `SKILL.md` fallback. Null when the plugin
  * has nothing we can bridge.
  */
-export function pluginAssets(root, name) {
+export function pluginAssets(root, name, meta = {}) {
     if (!isDirectory(root))
         return null;
-    const manifest = readJsonObject(join(root, ".claude-plugin", "plugin.json")) ?? {};
+    const manifestPath = join(root, ".claude-plugin", "plugin.json");
+    const manifest = readJsonObject(manifestPath) ?? {};
+    // Default component locations go through the same containment check as
+    // manifest-declared ones: a `skills` symlink pointing outside the plugin
+    // must not hand that directory to pi.
     const skillPaths = [];
-    const defaultSkills = join(root, "skills");
-    if (isDirectory(defaultSkills))
+    const defaultSkills = containedExistingPath(root, "skills");
+    if (defaultSkills && isDirectory(defaultSkills))
         skillPaths.push(defaultSkills);
     const manifestSkills = asStringArray(manifest.skills);
     for (const rel of manifestSkills) {
@@ -227,8 +256,8 @@ export function pluginAssets(root, name) {
             skillPaths.push(contained);
     }
     if (skillPaths.length === 0 && manifestSkills.length === 0) {
-        const rootSkill = join(root, "SKILL.md");
-        if (isFile(rootSkill))
+        const rootSkill = containedExistingPath(root, "SKILL.md");
+        if (rootSkill && isFile(rootSkill))
             skillPaths.push(rootSkill);
     }
     const componentPaths = (manifestValue, defaultDir) => {
@@ -242,14 +271,62 @@ export function pluginAssets(root, name) {
             }
             return out;
         }
-        const def = join(root, defaultDir);
-        return isDirectory(def) ? [def] : [];
+        const def = containedExistingPath(root, defaultDir);
+        return def && isDirectory(def) ? [def] : [];
     };
     const commandPaths = componentPaths(manifest.commands, "commands");
     const agentDirs = componentPaths(manifest.agents, "agents").filter(isDirectory);
-    if (skillPaths.length === 0 && commandPaths.length === 0 && agentDirs.length === 0)
+    const mcp = pluginMcp(root, manifest, manifestPath);
+    const unsupported = [];
+    if (manifest.hooks !== undefined || isDirectory(join(root, "hooks")) || isFile(join(root, "hooks.json")))
+        unsupported.push("hooks");
+    if (manifest.lspServers !== undefined || isFile(join(root, ".lsp.json")))
+        unsupported.push("lsp");
+    if (manifest.outputStyles !== undefined)
+        unsupported.push("output styles");
+    if (skillPaths.length === 0 && commandPaths.length === 0 && agentDirs.length === 0 && !mcp)
         return null;
-    return { name, root, skillPaths, commandPaths, agentDirs };
+    const version = meta.version ?? (typeof manifest.version === "string" ? manifest.version : null);
+    return {
+        name,
+        key: meta.key ?? name,
+        origin: meta.origin ?? "claude-code",
+        version,
+        root,
+        skillPaths,
+        commandPaths,
+        agentDirs,
+        mcp,
+        unsupported,
+    };
+}
+/**
+ * A plugin's MCP servers, per Claude Code's rules: the manifest `mcpServers`
+ * field (an inline map, or a contained path to a JSON file with one), else
+ * `.mcp.json` at the plugin root. Malformed → null (fail-soft).
+ */
+function pluginMcp(root, manifest, manifestPath) {
+    const field = manifest.mcpServers;
+    if (field && typeof field === "object" && !Array.isArray(field)) {
+        return { sourcePath: manifestPath, servers: field };
+    }
+    const candidates = [];
+    if (typeof field === "string") {
+        const contained = containedExistingPath(root, field);
+        if (contained && isFile(contained))
+            candidates.push(contained);
+    }
+    const rootFile = containedExistingPath(root, ".mcp.json");
+    if (rootFile && isFile(rootFile))
+        candidates.push(rootFile);
+    for (const path of candidates) {
+        const parsed = readJsonObject(path);
+        const servers = parsed?.mcpServers;
+        if (servers && typeof servers === "object" && !Array.isArray(servers)) {
+            return { sourcePath: path, servers: servers };
+        }
+    }
+    return null;
 }
 function resolveInstalledRoot(key, installed, marketplaces, realCwd) {
     const entries = (installed.get(key) ?? []).filter((e) => isDirectory(e.installPath));
@@ -295,14 +372,40 @@ export function discoverClaudePlugins(deps) {
         const user = [];
         const project = [];
         const seen = new Set();
+        // YAGNI-installed plugins are the user's own explicit action (`yagni
+        // plugin install`), so both scopes load without ceremony; a project-scope
+        // install applies only inside its repo.
+        for (const [key, entries] of Object.entries(deps.yagniLedger?.plugins ?? {})) {
+            const applicable = entries.filter((e) => {
+                if (!e.enabled || !isDirectory(e.installPath))
+                    return false;
+                if (e.scope === "user")
+                    return true;
+                const real = typeof e.projectPath === "string" ? realOrNull(e.projectPath) : null;
+                return !!real && (realCwd === real || realCwd.startsWith(real + sep));
+            });
+            const chosen = applicable.find((e) => e.scope === "project") ?? applicable[0];
+            if (!chosen)
+                continue;
+            const at = key.lastIndexOf("@");
+            const assets = pluginAssets(chosen.installPath, at > 0 ? key.slice(0, at) : key, {
+                key,
+                origin: "yagni",
+                version: chosen.version,
+            });
+            if (!assets)
+                continue;
+            seen.add(key);
+            user.push(assets);
+        }
         for (const [key, state] of enabled) {
-            if (!state.enabled)
+            if (!state.enabled || seen.has(key))
                 continue;
             const root = resolveInstalledRoot(key, installed, marketplaces, realCwd);
             if (!root)
                 continue;
             const at = key.lastIndexOf("@");
-            const assets = pluginAssets(root, at > 0 ? key.slice(0, at) : key);
+            const assets = pluginAssets(root, at > 0 ? key.slice(0, at) : key, { key, origin: "claude-code" });
             if (!assets)
                 continue;
             seen.add(key);
@@ -322,7 +425,12 @@ export function discoverClaudePlugins(deps) {
                     resolveInstalledRoot(key, installed, marketplaces, realCwd);
                 if (!root)
                     continue;
-                const assets = pluginAssets(root, entry.name);
+                const declared = entry.version;
+                const assets = pluginAssets(root, entry.name, {
+                    key,
+                    origin: "repo-marketplace",
+                    version: typeof declared === "string" ? declared : null,
+                });
                 if (!assets)
                     continue;
                 seen.add(key);

package/dist/cli.js

@@ -24,6 +24,7 @@ import { DISTRIBUTION } from "./distribution.js";
 import { connectCommand } from "./connectClaudeCode.js";
 import { goCommand } from "./goHeadless.js";
 import { mcpCommand } from "./mcpCommand.js";
+import { pluginCommand } from "./pluginCommand.js";
 import { login } from "./login.js";
 import { logout } from "./logout.js";
 import { tokenCommand } from "./token.js";
@@ -520,6 +521,10 @@ export const HELP_TEXT = [
     "                           add-from-claude, and more — run `yagni mcp` for",
     "                           details. OAuth servers authenticate via the",
     "                           /mcp panel in a session.",
+    "  yagni plugin <subcommand> Claude Code plugins from a marketplace: marketplace",
+    "                           add, install, uninstall, update, list — run",
+    "                           `yagni plugin` for details. Skills, commands,",
+    "                           agents, and bundled MCP servers load on launch.",
     "  yagni token              Output the active environment's API token (for helpers).",
     "  yagni use <name>         Switch the active environment (sticky).",
     "                           Presets: prod, local. Others need --base-url <url>.",
@@ -665,6 +670,11 @@ export async function main(argv) {
     if (command === "mcp") {
         return mcpCommand(rest);
     }
+    // Claude Code plugin marketplaces: install/remove/update from YAGNI itself
+    // (state under ~/.yagni-code/plugins; Claude Code's own installs still mirror).
+    if (command === "plugin") {
+        return pluginCommand(rest);
+    }
     // The headless pipeline entry. `go` is a real subcommand, not passthrough:
     // the interactive run stays `/go` inside a session, and a `yagni go` without
     // --headless is refused with usage rather than launched as an agent prompt.

package/dist/doctor.js

@@ -422,7 +422,7 @@ async function defaultProbeMcp(env = process.env) {
         const repoRoot = mod.resolveProjectRoot(process.cwd());
         const { state } = mod.readProjectApproval(repoRoot);
         const undecided = loaded.servers
-            .filter((s) => s.scope === "project" && mod.decisionFor(state, s.name) === "undecided")
+            .filter((s) => (s.scope === "project" || s.gated === true) && mod.decisionFor(state, s.name) === "undecided")
             .map((s) => s.name);
         return {
             disabled: false,

package/dist/extension/mcp/cliConfig.d.ts

@@ -4,7 +4,7 @@
  * from its bundled copy). Pure config I/O — no pi imports, no TUI, no network —
  * so importing it from the launcher is side-effect-free.
  */
-export { McpServerConfig, McpScope, PROJECT_CONFIG_FILENAME, ScopedMcpServerConfig, expandEnvVarsInString, expandServerEnv, loadMcpServers, mcpConfigPath, readProjectMcpConfig, readUserMcpConfig, resolveProjectRoot, validateServerConfig, writeUserMcpConfig, } from "./config.js";
+export { McpServerConfig, McpScope, PLUGIN_MCP_ENV, PROJECT_CONFIG_FILENAME, ScopedMcpServerConfig, expandEnvVarsInString, expandServerEnv, loadMcpServers, mcpConfigPath, readPluginMcpServers, readProjectMcpConfig, readUserMcpConfig, resolveProjectRoot, validateServerConfig, writeUserMcpConfig, } from "./config.js";
 export { ProjectApprovalState, decisionFor, readProjectApproval, recordProjectDecision, resetProjectChoices, undecidedProjectServers, } from "./approval.js";
 export { McpAuthFile, StoredOAuthEntry, deleteStoredOAuthEntry, getServerKey, getStoredOAuthEntry, mcpAuthPath, readMcpAuth, updateStoredOAuthEntry, writeMcpAuth, } from "./authStore.js";
 export { revokeTokensOnRemove } from "./auth.js";

package/dist/extension/mcp/cliConfig.js

@@ -4,7 +4,7 @@
  * from its bundled copy). Pure config I/O — no pi imports, no TUI, no network —
  * so importing it from the launcher is side-effect-free.
  */
-export { PROJECT_CONFIG_FILENAME, expandEnvVarsInString, expandServerEnv, loadMcpServers, mcpConfigPath, readProjectMcpConfig, readUserMcpConfig, resolveProjectRoot, validateServerConfig, writeUserMcpConfig, } from "./config.js";
+export { PLUGIN_MCP_ENV, PROJECT_CONFIG_FILENAME, expandEnvVarsInString, expandServerEnv, loadMcpServers, mcpConfigPath, readPluginMcpServers, readProjectMcpConfig, readUserMcpConfig, resolveProjectRoot, validateServerConfig, writeUserMcpConfig, } from "./config.js";
 export { decisionFor, readProjectApproval, recordProjectDecision, resetProjectChoices, undecidedProjectServers, } from "./approval.js";
 export { deleteStoredOAuthEntry, getServerKey, getStoredOAuthEntry, mcpAuthPath, readMcpAuth, updateStoredOAuthEntry, writeMcpAuth, } from "./authStore.js";
 export { revokeTokensOnRemove } from "./auth.js";

package/dist/extension/mcp/config.d.ts

@@ -6,13 +6,18 @@
  *    A repo configured for Claude Code works here with zero changes.
  *  - user: top-level `mcpServers` in `~/.yagni-code/mcp.json`.
  *  - local: `projects[<absPath>].mcpServers` in the same file, keyed by cwd.
+ *  - plugin: servers bundled in Claude Code plugins (`.mcp.json` at the plugin
+ *    root), handed over by the yagni launcher as JSON in
+ *    `YAGNI_CLAUDE_PLUGIN_MCP` (see yagni-code-cli claudeCompat.ts). Entries
+ *    marked `gated` came from repo config and ride the project approval gate.
  *
- * Merge precedence (Claude Code parity): user < project < local — later wins.
+ * Merge precedence (Claude Code parity): plugin < user < project < local —
+ * later wins, so an explicit user entry beats a plugin's.
  * Writes are atomic (temp file + rename) so two concurrent sessions can never
  * interleave into a corrupt config. Validation errors are collected and
  * surfaced, never fatal: one malformed server entry must not hide the rest.
  */
-export type McpScope = "user" | "project" | "local";
+export type McpScope = "user" | "project" | "local" | "plugin";
 export interface McpStdioServerConfig {
     type?: "stdio";
     command: string;
@@ -39,7 +44,24 @@ export interface ScopedMcpServerConfig {
     scope: McpScope;
     /** Where this entry came from (file path) — surfaced in /mcp and `yagni mcp get`. */
     sourcePath: string;
+    /** `name@marketplace` of the plugin that bundles this server (plugin scope). */
+    plugin?: string;
+    /** Plugin server that came from repo config: needs the project approval gate. */
+    gated?: boolean;
 }
+/** Launcher → extension: plugin-bundled MCP servers (JSON array). */
+export declare const PLUGIN_MCP_ENV = "YAGNI_CLAUDE_PLUGIN_MCP";
+export interface PluginMcpEnvEntry {
+    plugin: string;
+    sourcePath: string;
+    gated: boolean;
+    servers: Record<string, unknown>;
+}
+/** Parse the launcher's plugin MCP payload; malformed input degrades to errors, never a throw. */
+export declare function readPluginMcpServers(env?: NodeJS.ProcessEnv): {
+    servers: ScopedMcpServerConfig[];
+    errors: McpConfigError[];
+};
 export interface McpConfigError {
     /** File the problem was found in. */
     sourcePath: string;

package/dist/extension/mcp/config.js

@@ -6,8 +6,13 @@
  *    A repo configured for Claude Code works here with zero changes.
  *  - user: top-level `mcpServers` in `~/.yagni-code/mcp.json`.
  *  - local: `projects[<absPath>].mcpServers` in the same file, keyed by cwd.
+ *  - plugin: servers bundled in Claude Code plugins (`.mcp.json` at the plugin
+ *    root), handed over by the yagni launcher as JSON in
+ *    `YAGNI_CLAUDE_PLUGIN_MCP` (see yagni-code-cli claudeCompat.ts). Entries
+ *    marked `gated` came from repo config and ride the project approval gate.
  *
- * Merge precedence (Claude Code parity): user < project < local — later wins.
+ * Merge precedence (Claude Code parity): plugin < user < project < local —
+ * later wins, so an explicit user entry beats a plugin's.
  * Writes are atomic (temp file + rename) so two concurrent sessions can never
  * interleave into a corrupt config. Validation errors are collected and
  * surfaced, never fatal: one malformed server entry must not hide the rest.
@@ -15,6 +20,70 @@
 import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { codeStateHome } from "../stateHome.js";
+/** Launcher → extension: plugin-bundled MCP servers (JSON array). */
+export const PLUGIN_MCP_ENV = "YAGNI_CLAUDE_PLUGIN_MCP";
+const CLAUDE_COMPAT_DISABLE_ENV = "YAGNI_DISABLE_CLAUDE_COMPAT";
+/** Parse the launcher's plugin MCP payload; malformed input degrades to errors, never a throw. */
+export function readPluginMcpServers(env = process.env) {
+    const disabled = env[CLAUDE_COMPAT_DISABLE_ENV];
+    if (disabled !== undefined && disabled !== "" && disabled !== "0")
+        return { servers: [], errors: [] };
+    const raw = env[PLUGIN_MCP_ENV];
+    if (!raw)
+        return { servers: [], errors: [] };
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (err) {
+        return {
+            servers: [],
+            errors: [{ sourcePath: PLUGIN_MCP_ENV, message: `could not parse plugin MCP payload (${err instanceof Error ? err.message : String(err)})` }],
+        };
+    }
+    if (!Array.isArray(parsed))
+        return { servers: [], errors: [{ sourcePath: PLUGIN_MCP_ENV, message: "plugin MCP payload is not an array" }] };
+    const servers = [];
+    const errors = [];
+    const seen = new Map();
+    for (const item of parsed) {
+        if (!item || typeof item !== "object")
+            continue;
+        const entry = item;
+        if (typeof entry.plugin !== "string" || !entry.servers || typeof entry.servers !== "object")
+            continue;
+        const sourcePath = typeof entry.sourcePath === "string" ? entry.sourcePath : entry.plugin;
+        for (const [name, value] of Object.entries(entry.servers)) {
+            const validation = validateServerConfig(value);
+            if (!validation.ok) {
+                errors.push({ sourcePath, serverName: name, message: `${validation.message} (plugin ${entry.plugin})` });
+                continue;
+            }
+            const owner = seen.get(name);
+            if (owner) {
+                errors.push({
+                    sourcePath,
+                    serverName: name,
+                    message: `also defined by plugin ${owner} — keeping that one, skipping ${entry.plugin}'s`,
+                });
+                continue;
+            }
+            const config = value;
+            const expanded = expandServerEnv(config, env);
+            if (expanded.missingVars.length > 0) {
+                errors.push({
+                    sourcePath,
+                    serverName: name,
+                    message: `missing environment variable(s): ${expanded.missingVars.join(", ")} — server skipped`,
+                });
+                continue;
+            }
+            seen.set(name, entry.plugin);
+            servers.push({ name, config, scope: "plugin", sourcePath, plugin: entry.plugin, gated: entry.gated === true });
+        }
+    }
+    return { servers, errors };
+}
 export const PROJECT_CONFIG_FILENAME = ".mcp.json";
 /**
  * Expand `${VAR}` / `${VAR:-default}` in a config string (Claude Code parity —
@@ -239,7 +308,10 @@ function defaultExists(p) {
 export function loadMcpServers(cwd, env = process.env) {
     const repoRoot = resolveProjectRoot(cwd);
     const errors = [];
-    const byScope = { user: [], project: [], local: [] };
+    const byScope = { plugin: [], user: [], project: [], local: [] };
+    const pluginLoad = readPluginMcpServers(env);
+    errors.push(...pluginLoad.errors);
+    byScope.plugin.push(...pluginLoad.servers);
     const { file: userFile, errors: userErrors } = readUserMcpConfig();
     errors.push(...userErrors);
     const userServers = userFile.mcpServers ?? {};
@@ -300,7 +372,7 @@ export function loadMcpServers(cwd, env = process.env) {
         }
     }
     const merged = new Map();
-    for (const scope of ["user", "project", "local"]) {
+    for (const scope of ["plugin", "user", "project", "local"]) {
         for (const server of byScope[scope])
             merged.set(server.name, server);
     }