@yagni-app/code 1.0.5 → 1.0.7

package/dist/claudePlugins.js

@@ -17,8 +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, 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
@@ -149,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;
@@ -164,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 };
 }
@@ -210,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) {
@@ -225,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) => {
@@ -240,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));
@@ -293,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);
@@ -320,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

@@ -23,6 +23,8 @@ import { agentDir, credentialsDir, piPackageDir } from "./credentials.js";
 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";
@@ -246,10 +248,10 @@ async function runDefault(passthroughArgs) {
     catch {
         compat = { argv: [], env: {} };
     }
-    // OTel export: load pi-otel only when an OTLP endpoint is configured — the
-    // user's env, the workspace's admin-set config (fetched fail-soft, cached),
-    // or the repo's .pi/settings.json, in that order. undefined keeps the
-    // launch untouched. See otel.ts for the policy.
+    // OTel export: on only when an OTLP endpoint is configured — the user's
+    // env, the workspace's admin-set config (fetched fail-soft, cached), or the
+    // repo's .pi/settings.json, in that order. undefined keeps the launch
+    // untouched. See otel.ts for the policy.
     const otel = await resolveOtelLaunchWithWorkspace({
         env: process.env,
         cwd: process.cwd(),
@@ -515,6 +517,14 @@ export const HELP_TEXT = [
     "  yagni connect claude-code  Route Claude Code through the YAGNI model proxy",
     "                           (--project scopes to this repo; --off disconnects).",
     "  yagni connect codex      Route Codex CLI through the YAGNI model proxy.",
+    "  yagni mcp <subcommand>    Manage MCP servers: add, remove, list, get,",
+    "                           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>.",
@@ -536,6 +546,9 @@ export const HELP_TEXT = [
     "  /mode plan|review|auto   Hold writes for planning, or confirm each change.",
     "  /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.",
@@ -653,6 +666,17 @@ export async function main(argv) {
     if (command === "connect") {
         return connectCommand(rest);
     }
+    // MCP server configuration: same three-scope model and file homes the
+    // in-session /mcp panel uses, shared code via the bundled extension's
+    // config entry. `list` runs real health-check connections.
+    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.d.ts

@@ -61,12 +61,44 @@ export declare function checkCliUpdate(probe: {
     latest: string | null;
 }): CheckResult;
 export declare function checkGh(onPath: boolean): CheckResult;
+/** One signal's verdict from the extension's probe (see telemetry/probe.ts). */
+export interface OtelProbeSignal {
+    signal: "traces" | "metrics" | "logs";
+    url: string;
+    protocol: string;
+    ok: boolean;
+    error?: string;
+}
+/**
+ * Advisory OTel-export line: says whether sessions will stream telemetry to
+ * an OTLP collector, from which config source, and — when a collector is
+ * configured — whether it ACCEPTED a real record on each signal (a wrong API
+ * key, a wrong path, or a protocol mismatch shows up as the collector's own
+ * error). Never flips the exit code — most machines have no collector, and
+ * that is the healthy default.
+ */
+export declare function checkOtelExport(config: OtelLaunchConfig | undefined, deps?: {
+    probe?: (env: NodeJS.ProcessEnv) => Promise<OtelProbeSignal[]>;
+    baseEnv?: NodeJS.ProcessEnv;
+}): Promise<CheckResult>;
+/** Config-only MCP snapshot (no connections — health checks live in `mcp list`/`get`). */
+export interface McpProbe {
+    /** YAGNI_CODE_MCP_DISABLED kill-switch is active. */
+    disabled: boolean;
+    /** Count of configured servers (post-merge, before the approval gate). */
+    serverCount: number;
+    /** Project-scope servers that are neither enabled nor disabled. */
+    undecidedProjectServers: string[];
+    /** Config parse/validation errors (already human-readable). */
+    errors: string[];
+}
 /**
- * Advisory OTel-export line: says whether sessions will stream traces to an
- * OTLP collector, and from which config source. Never flips the exit code —
- * most machines have no collector, and that is the healthy default.
+ * Advisory (never required) MCP line: reports config health without connecting
+ * to anything — `yagni mcp list`/`get` already run the real health checks, and
+ * doctor must never spawn an unapproved server process. The kill-switch and
+ * pending-approval cases read as `warn`, config errors as `fail` (non-required).
  */
-export declare function checkOtelExport(config: OtelLaunchConfig | undefined): CheckResult;
+export declare function checkMcpConfig(probe: McpProbe): CheckResult;
 /** What the Windows bash probe found (pi needs a bash — Git Bash — on win32). */
 export interface BashProbe {
     found: boolean;
@@ -95,6 +127,12 @@ export interface DoctorDeps {
     probeBash?: () => BashProbe;
     currentVersion?: string;
     probeLatestVersion?: () => Promise<string | null>;
+    /** MCP config snapshot (config-only, no connections). */
+    probeMcp?: () => Promise<McpProbe>;
+    /** OTel gate resolution (env / workspace / repo settings); tests stub it. */
+    resolveOtel?: (profile: Profile) => Promise<OtelLaunchConfig | undefined>;
+    /** OTel export probe: one real record per signal against the session env. */
+    probeOtel?: (env: NodeJS.ProcessEnv) => Promise<OtelProbeSignal[]>;
     log?: (msg: string) => void;
 }
 /** Whether a `gh` executable is resolvable on PATH (no subprocess spawn). */

package/dist/doctor.js

@@ -17,9 +17,10 @@ import { delimiter, join } from "node:path";
 import { credentialsDir } from "./credentials.js";
 import { currentCliVersion, fetchLatestVersion, isNewerVersion } from "./upgrade.js";
 import { classifyTokenExpiry } from "./launch.js";
-import { resolveOtelLaunchWithWorkspace } from "./otel.js";
-import { resolveExtensionPath, resolvePiCliPath, resolvePiPackageDir } from "./paths.js";
+import { otelChildEnv, resolveOtelLaunchWithWorkspace } from "./otel.js";
+import { resolveExtensionPath, resolvePiCliPath, resolvePiPackageDir, resolveTelemetryProbePath } from "./paths.js";
 import { readActiveProfile } from "./profiles.js";
+import { resolveMcpConfigPath } from "./mcpCommand.js";
 // ── Pure check builders ─────────────────────────────────────────────────────
 export function checkPiEngine(probe) {
     if (!probe.binPath || !probe.binExists) {
@@ -200,11 +201,24 @@ export function checkGh(onPath) {
     };
 }
 /**
- * Advisory OTel-export line: says whether sessions will stream traces to an
- * OTLP collector, and from which config source. Never flips the exit code —
- * most machines have no collector, and that is the healthy default.
+ * Run the extension's telemetry probe against the exact env a session would
+ * get: one real span, one metric point, one log record, each reported with
+ * the collector's actual verdict. Dynamic import so `doctor` on a machine
+ * with no collector never loads the OTel SDK graph.
  */
-export function checkOtelExport(config) {
+async function defaultProbeOtel(env) {
+    const mod = (await import(resolveTelemetryProbePath()));
+    return (await mod.probeTelemetryExport(env)).results;
+}
+/**
+ * Advisory OTel-export line: says whether sessions will stream telemetry to
+ * an OTLP collector, from which config source, and — when a collector is
+ * configured — whether it ACCEPTED a real record on each signal (a wrong API
+ * key, a wrong path, or a protocol mismatch shows up as the collector's own
+ * error). Never flips the exit code — most machines have no collector, and
+ * that is the healthy default.
+ */
+export async function checkOtelExport(config, deps = {}) {
     if (!config) {
         return {
             name: "otel export (optional)",
@@ -214,14 +228,97 @@ export function checkOtelExport(config) {
         };
     }
     const source = config.source === "env"
-        ? "OTEL_EXPORTER_OTLP_ENDPOINT"
+        ? (config.envVar ?? "OTEL_EXPORTER_OTLP_ENDPOINT")
         : config.source === "workspace"
             ? "workspace settings"
             : ".pi/settings.json";
+    const base = `on → ${config.endpoint} (${source}, metadata-only)`;
+    const baseEnv = deps.baseEnv ?? process.env;
+    const env = { ...baseEnv, ...otelChildEnv(config, baseEnv) };
+    const doProbe = deps.probe ?? defaultProbeOtel;
+    try {
+        const results = await doProbe(env);
+        const accepted = results.filter((r) => r.ok).map((r) => r.signal);
+        const failed = results.filter((r) => !r.ok);
+        const summary = results.map((r) => `${r.signal} ${r.ok ? "accepted" : "FAILED"}`).join(", ");
+        if (failed.length === 0) {
+            return {
+                name: "otel export (optional)",
+                status: "ok",
+                detail: `${base}; ${summary}`,
+                required: false,
+            };
+        }
+        const reasons = failed.map((r) => `${r.signal} → ${r.url} (${r.protocol}): ${r.error ?? "rejected"}`).join("; ");
+        return {
+            name: "otel export (optional)",
+            status: "warn",
+            detail: `${base}; ${summary}`,
+            hint: `${reasons}. A 401/403 means the collector key is wrong, a 404 the path or site is wrong, ` +
+                `a connection error the collector is unreachable from this machine` +
+                (accepted.length > 0 ? `; ${accepted.join(" and ")} still export` : ""),
+            required: false,
+        };
+    }
+    catch {
+        // The probe itself errored (not "endpoint down" — the check could not
+        // run). Distinct from a verified-healthy line so nobody reads an
+        // unverified config as checked-and-good.
+        return {
+            name: "otel export (optional)",
+            status: "warn",
+            detail: `${base}, export probe failed`,
+            hint: "the export probe could not run (the bundled extension is missing or the OTel SDK failed to load) — export is configured but unverified; sessions may still export normally",
+            required: false,
+        };
+    }
+}
+/**
+ * Advisory (never required) MCP line: reports config health without connecting
+ * to anything — `yagni mcp list`/`get` already run the real health checks, and
+ * doctor must never spawn an unapproved server process. The kill-switch and
+ * pending-approval cases read as `warn`, config errors as `fail` (non-required).
+ */
+export function checkMcpConfig(probe) {
+    if (probe.disabled) {
+        return {
+            name: "mcp servers",
+            status: "warn",
+            detail: "disabled (YAGNI_CODE_MCP_DISABLED=1)",
+            hint: "unset YAGNI_CODE_MCP_DISABLED to re-enable MCP servers",
+            required: false,
+        };
+    }
+    if (probe.errors.length > 0) {
+        return {
+            name: "mcp servers",
+            status: "fail",
+            detail: `${probe.serverCount} configured, ${probe.errors.length} config error${probe.errors.length === 1 ? "" : "s"}`,
+            hint: `run \`yagni mcp list\` (first error: ${probe.errors[0]})`,
+            required: false,
+        };
+    }
+    if (probe.serverCount === 0) {
+        return {
+            name: "mcp servers",
+            status: "ok",
+            detail: "none configured",
+            required: false,
+        };
+    }
+    if (probe.undecidedProjectServers.length > 0) {
+        return {
+            name: "mcp servers",
+            status: "warn",
+            detail: `${probe.serverCount} configured, ${probe.undecidedProjectServers.length} awaiting approval`,
+            hint: "run /mcp to approve the project servers",
+            required: false,
+        };
+    }
     return {
-        name: "otel export (optional)",
+        name: "mcp servers",
         status: "ok",
-        detail: `on → ${config.endpoint} (${source}, metadata-only)`,
+        detail: `${probe.serverCount} configured`,
         required: false,
     };
 }
@@ -312,6 +409,37 @@ function defaultProbeStateDir() {
         return { path, exists: false, mode: null };
     }
 }
+async function defaultProbeMcp(env = process.env) {
+    const disabled = env.YAGNI_CODE_MCP_DISABLED === "1";
+    if (disabled)
+        return { disabled: true, serverCount: 0, undecidedProjectServers: [], errors: [] };
+    try {
+        const mod = (await import(resolveMcpConfigPath()));
+        if (typeof mod?.loadMcpServers !== "function") {
+            return { disabled: false, serverCount: 0, undecidedProjectServers: [], errors: ["extension MCP config entry missing"] };
+        }
+        const loaded = mod.loadMcpServers(process.cwd(), env);
+        const repoRoot = mod.resolveProjectRoot(process.cwd());
+        const { state } = mod.readProjectApproval(repoRoot);
+        const undecided = loaded.servers
+            .filter((s) => (s.scope === "project" || s.gated === true) && mod.decisionFor(state, s.name) === "undecided")
+            .map((s) => s.name);
+        return {
+            disabled: false,
+            serverCount: loaded.servers.length,
+            undecidedProjectServers: undecided,
+            errors: loaded.errors.map((e) => (e.serverName ? `${e.serverName}: ${e.message}` : e.message)),
+        };
+    }
+    catch (err) {
+        return {
+            disabled: false,
+            serverCount: 0,
+            undecidedProjectServers: [],
+            errors: [err instanceof Error ? err.message : String(err)],
+        };
+    }
+}
 async function defaultProbeBackend(baseUrl, token) {
     if (!token)
         return { kind: "skipped" };
@@ -378,6 +506,7 @@ export async function gatherChecks(deps = {}) {
     const readProfile = deps.readActiveProfile ?? readActiveProfile;
     const probeBackend = deps.probeBackend ?? defaultProbeBackend;
     const probeStateDir = deps.probeStateDir ?? defaultProbeStateDir;
+    const probeMcp = deps.probeMcp ?? (() => defaultProbeMcp());
     const ghOnPath = deps.ghOnPath ?? (() => ghOnPathDefault());
     const platform = deps.platform ?? process.platform;
     const probeBash = deps.probeBash ?? (() => bashOnWindowsDefault());
@@ -406,12 +535,18 @@ export async function gatherChecks(deps = {}) {
     checks.push(checkBackend(backend));
     checks.push(checkStateDir(probeStateDir()));
     checks.push(checkGh(ghOnPath()));
-    checks.push(checkOtelExport(await resolveOtelLaunchWithWorkspace({
-        env: process.env,
-        cwd: process.cwd(),
-        creds: profile.token ? { baseUrl: profile.baseUrl, token: profile.token } : null,
-        profileName: profile.name,
-    })));
+    checks.push(checkMcpConfig(await probeMcp()));
+    const resolveOtel = deps.resolveOtel ??
+        ((p) => resolveOtelLaunchWithWorkspace({
+            env: process.env,
+            cwd: process.cwd(),
+            creds: p.token ? { baseUrl: p.baseUrl, token: p.token } : null,
+            profileName: p.name,
+        }));
+    checks.push(await checkOtelExport(await resolveOtel(profile), {
+        ...(deps.probeOtel ? { probe: deps.probeOtel } : {}),
+        baseEnv: process.env,
+    }));
     return checks;
 }
 /**

package/dist/extension/condensedTools.d.ts

@@ -24,7 +24,7 @@
  * pattern) so tests run against plain text. Renderer exceptions are swallowed
  * by pi (degrading to the built-in fallback), so everything stays total.
  */
-import { SettingsManager, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { SettingsManager, type ExtensionAPI, type ToolDefinition } from "@earendil-works/pi-coding-agent";
 import type { RenderTheme } from "./subagentRender.js";
 import { ToolRunTracker } from "./toolRuns.js";
 /** Lines of write content shown collapsed (mirrors Claude Code's preview). */
@@ -87,6 +87,17 @@ export interface RegisterCondensedToolsDeps {
      * image autoResize. Injectable so tests never touch the config dir.
      */
     loadSettings?: (cwd: string) => SettingsManager;
+    /**
+     * sandbox composition: when present, the bash definition is passed
+     * through this wrap before registration — the sandbox adds its schema field
+     * (dangerouslyDisableSandbox), wrap-on-execute, and violation annotation
+     * while condensed keeps its rendering. The compose fn is built by
+     * sandbox/session.ts (makeSandboxBashComposition) and is a no-op when the
+     * sandbox is disabled. Condensed registers LAST among the bash-defining
+     * sites, so composing HERE is what makes the sandbox actually reach the
+     * model's tool calls.
+     */
+    wrapBash?: (def: ToolDefinition) => ToolDefinition;
 }
 /**
  * Re-register the seven built-ins with condensed renderers. Returns the

package/dist/extension/condensedTools.js

@@ -291,15 +291,23 @@ export function registerCondensedTools(pi, deps = {}) {
     catch {
         toolOptions = { bash: {}, read: {} };
     }
-    const buildDefinitions = (cwd) => ({
-        read: createReadToolDefinition(cwd, toolOptions.read),
-        bash: createBashToolDefinition(cwd, toolOptions.bash),
-        edit: createEditToolDefinition(cwd),
-        write: createWriteToolDefinition(cwd),
-        grep: createGrepToolDefinition(cwd),
-        find: createFindToolDefinition(cwd),
-        ls: createLsToolDefinition(cwd),
-    });
+    const buildDefinitions = (cwd) => {
+        const defs = {
+            read: createReadToolDefinition(cwd, toolOptions.read),
+            bash: createBashToolDefinition(cwd, toolOptions.bash),
+            edit: createEditToolDefinition(cwd),
+            write: createWriteToolDefinition(cwd),
+            grep: createGrepToolDefinition(cwd),
+            find: createFindToolDefinition(cwd),
+            ls: createLsToolDefinition(cwd),
+        };
+        // the sandbox wraps the bash DEFINITION (not the registration
+        // wrapper) so the cwd-delegating execute below still lands on the
+        // sandbox-aware tool for every cwd the session visits.
+        if (defs.bash && deps.wrapBash)
+            defs.bash = deps.wrapBash(defs.bash);
+        return defs;
+    };
     const definitionsByCwd = new Map();
     const definitionsFor = (cwd) => {
         let defs = definitionsByCwd.get(cwd);