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

package/dist/claudeCompat.d.ts

@@ -34,6 +34,30 @@ 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";
+/**
+ * `name@marketplace` keys of the plugins wired at launch (delimiter-joined).
+ * `/reload-plugins` diffs a fresh inventory against this baseline: pi already
+ * holds the launch-time plugins through argv, so only newer ones need the
+ * extension's `resources_discover` contribution.
+ */
+export declare const CLAUDE_PLUGIN_KEYS_ENV = "YAGNI_CLAUDE_PLUGIN_KEYS";
+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 +85,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;
 }
@@ -104,6 +131,38 @@ export interface ClaudeCompatLaunch {
  * compat can only add flags/env, never break a launch.
  */
 export declare function claudeCompatArgs(deps: ClaudeCompatDeps): Promise<ClaudeCompatLaunch>;
+/** One plugin as the in-session `/plugin` panel sees it. */
+export interface InventoryPlugin {
+    key: string;
+    name: string;
+    origin: PluginAssets["origin"];
+    version: string | null;
+    root: string;
+    /** Repo-sourced: its MCP servers ride the project approval gate. */
+    gated: boolean;
+    skillPaths: string[];
+    commandPaths: string[];
+    agentDirs: string[];
+    mcpServers: string[];
+    unsupported: string[];
+}
+export interface PluginInventory {
+    /** Plugins that load for `cwd` right now (trust respected, never prompting). */
+    plugins: InventoryPlugin[];
+    /** The MCP payload those plugins contribute (same shape as YAGNI_CLAUDE_PLUGIN_MCP). */
+    mcp: PluginMcpEnvEntry[];
+    /** Repo-sourced plugins held back because the folder is not trusted yet. */
+    pendingTrust: string[];
+    /** Plugin agent dirs, user first (same order as YAGNI_CLAUDE_AGENT_DIRS). */
+    agentDirs: string[];
+}
+/**
+ * The plugin inventory a launch from `cwd` would wire, computed without
+ * prompting: the user's own plugins always, repo-sourced ones only once the
+ * folder is trusted. Backs `yagni plugin inventory --json`, which the
+ * in-session `/plugin` panel and `/reload-plugins` call.
+ */
+export declare function pluginInventory(deps: Omit<ClaudeCompatDeps, "confirm" | "interactive">): PluginInventory;
 /** Whether pi's trust file exists yet (used only for messaging). */
 export declare function trustFileExists(agentDir: string): boolean;
 //# sourceMappingURL=claudeCompat.d.ts.map

package/dist/claudeCompat.js

@@ -32,11 +32,57 @@ 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";
+/**
+ * `name@marketplace` keys of the plugins wired at launch (delimiter-joined).
+ * `/reload-plugins` diffs a fresh inventory against this baseline: pi already
+ * holds the launch-time plugins through argv, so only newer ones need the
+ * extension's `resources_discover` contribution.
+ */
+export const CLAUDE_PLUGIN_KEYS_ENV = "YAGNI_CLAUDE_PLUGIN_KEYS";
+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 +106,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 +115,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 +259,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,13 +299,67 @@ export async function claudeCompatArgs(deps) {
         ...decision.userRulesDirs,
         ...(trusted === true ? decision.projectRulesDirs : []),
     ];
+    const mcpEntries = [
+        ...decision.userMcp,
+        ...(trusted === true ? decision.projectMcp : []),
+    ];
+    const loadedKeys = [
+        ...plugins.user.map((p) => p.key),
+        ...(trusted === true ? plugins.project.map((p) => p.key) : []),
+    ];
     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);
+    if (loadedKeys.length > 0)
+        extraEnv[CLAUDE_PLUGIN_KEYS_ENV] = loadedKeys.join(delimiter);
     return { argv, env: extraEnv };
 }
+function toInventory(plugin, gated) {
+    return {
+        key: plugin.key,
+        name: plugin.name,
+        origin: plugin.origin,
+        version: plugin.version,
+        root: plugin.root,
+        gated,
+        skillPaths: plugin.skillPaths,
+        commandPaths: plugin.commandPaths,
+        agentDirs: plugin.agentDirs,
+        mcpServers: plugin.mcp ? Object.keys(plugin.mcp.servers) : [],
+        unsupported: plugin.unsupported,
+    };
+}
+/**
+ * The plugin inventory a launch from `cwd` would wire, computed without
+ * prompting: the user's own plugins always, repo-sourced ones only once the
+ * folder is trusted. Backs `yagni plugin inventory --json`, which the
+ * in-session `/plugin` panel and `/reload-plugins` call.
+ */
+export function pluginInventory(deps) {
+    const env = deps.env ?? process.env;
+    if (compatDisabled(env))
+        return { plugins: [], mcp: [], pendingTrust: [], agentDirs: [] };
+    const home = deps.homeDir ?? homedir();
+    const trusted = readTrustDecision(deps.agentDir, deps.cwd);
+    let plugins;
+    try {
+        plugins = discoverClaudePlugins({ cwd: deps.cwd, homeDir: home, yagniLedger: readLedger(pluginsHome(env, home)) });
+    }
+    catch {
+        plugins = { user: [], project: [] };
+    }
+    const project = trusted === true ? plugins.project : [];
+    return {
+        plugins: [...plugins.user.map((p) => toInventory(p, false)), ...project.map((p) => toInventory(p, true))],
+        mcp: [...pluginMcpEntries(plugins.user, false), ...pluginMcpEntries(project, true)],
+        pendingTrust: trusted === true ? [] : plugins.project.map((p) => p.key),
+        agentDirs: [...plugins.user, ...project].flatMap((p) => p.agentDirs),
+    };
+}
 /** Whether pi's trust file exists yet (used only for messaging). */
 export function trustFileExists(agentDir) {
     return existsSync(trustPath(agentDir));

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>.",
@@ -542,6 +547,8 @@ export const HELP_TEXT = [
     "  /todos                   Show the agent's live task list.",
     "  /cost                    Session usage and credit headroom.",
     "  /mcp                     Manage MCP servers; authenticate OAuth servers.",
+    "  /plugin                  Browse, install, and remove Claude Code plugins.",
+    "  /reload-plugins          Apply plugin changes without restarting.",
     "",
     "The active environment is sticky; `use` switches it (prod is the default).",
     "Set YAGNI_BASE_URL to override the base URL for a single run.",
@@ -665,6 +672,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/index.d.ts

@@ -3,6 +3,7 @@ import { type SpendResponse } from "./costHud.js";
 import { runInitPass as defaultRunInitPass } from "./initPass.js";
 import { startMcp as defaultStartMcp } from "./mcp/startup.js";
 import { type GuardianGateEvent } from "./permission/gate.js";
+import { type PluginCliRunner } from "./plugins/panel.js";
 import { type FlushOutcome, type SpoolClientOpts } from "./spool.js";
 import { type TokenProvider } from "./tokenProvider.js";
 import { type CatalogResult, type ContextBrief } from "./config.js";
@@ -59,6 +60,8 @@ export interface RegisterYagniDeps {
      * homes or spawning servers. Default runs the real startup.
      */
     startMcp?: typeof defaultStartMcp;
+    /** Test seam for the /plugin panel: runs `yagni plugin …` (defaults to spawning YAGNI_CLI_PATH). */
+    runPluginCli?: PluginCliRunner;
     /**
      * The CLI init pass (Onramp Door B). Injectable so tests assert it fires on a
      * fresh-workspace first-run and is skipped otherwise, without a network or disk.

package/dist/extension/index.js

@@ -41,6 +41,7 @@ import { sandboxAutoAllowDecision } from "./sandbox/bash.js";
 import { registerTelemetry } from "./telemetry/register.js";
 import { loadHooksConfig, makeHookRunner, registerHooks } from "./hooks.js";
 import { loadPermissionRules } from "./permissionRules/loadConfig.js";
+import { registerPluginPanel } from "./plugins/panel.js";
 import { registerSubagents } from "./subagents.js";
 import { createUltraHolder, registerUltraCommand } from "./ultra.js";
 import { registerTodos } from "./todos.js";
@@ -278,6 +279,9 @@ export async function registerYagni(pi, deps = {}) {
     // before_agent_start handler below) and widens the tool's fan-out ceiling.
     const ultraHolder = createUltraHolder();
     registerSubagents(pi, { isUltra: () => ultraHolder.get(), workingLine, childUsage });
+    // /plugin + /reload-plugins: manage Claude Code marketplace plugins from the
+    // session, driving the launcher's `yagni plugin …` (YAGNI_CLI_PATH).
+    registerPluginPanel(pi, { env: deps.env, runCli: deps.runPluginCli });
     registerUltraCommand(pi, ultraHolder);
     // Shared fetch timeout for the small, interactive display-path reads below
     // (/cost's spend + headroom, and Task 8's per-run spend for /go's summary):

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";