@ouro.bot/cli 0.1.0-alpha.68 → 0.1.0-alpha.69

package/changelog.json

@@ -1,6 +1,15 @@
 {
   "_note": "This changelog is maintained as part of the PR/version-bump workflow. Agent-curated, not auto-generated. Agents read this file directly via read_file to understand what changed between versions.",
   "versions": [
+    {
+      "version": "0.1.0-alpha.69",
+      "changes": [
+        "Generic MCP client: ouroboros agents can now connect to any MCP server (e.g., agency mcp ado, agency mcp mail) configured in agent.json. Zero new dependencies — pure JSON-RPC over stdio.",
+        "New `ouro mcp list` and `ouro mcp call` CLI commands route through the daemon socket to persistent MCP connections, so agents use shared server instances instead of spawning fresh ones per call.",
+        "MCP tools are injected into the agent's system prompt on startup, so agents know what external capabilities are available without a discovery step.",
+        "Trust manifest: `mcp list` requires acquaintance trust, `mcp call` requires friend trust."
+      ]
+    },
     {
       "version": "0.1.0-alpha.68",
       "changes": [

package/dist/heart/daemon/daemon-cli.js

@@ -288,6 +288,8 @@ function usage() {
         "  ouro friend unlink <agent> --friend <id> --provider <p> --external-id <eid>",
         "  ouro whoami [--agent <name>]",
         "  ouro session list [--agent <name>]",
+        "  ouro mcp list",
+        "  ouro mcp call <server> <tool> [--args '{...}']",
     ].join("\n");
 }
 function formatVersionOutput() {
@@ -675,6 +677,23 @@ function parseFriendCommand(args) {
         return parseLinkCommand(rest, "friend.unlink");
     throw new Error(`Usage\n${usage()}`);
 }
+function parseMcpCommand(args) {
+    const [sub, ...rest] = args;
+    if (!sub)
+        throw new Error(`Usage\n${usage()}`);
+    if (sub === "list")
+        return { kind: "mcp.list" };
+    if (sub === "call") {
+        const server = rest[0];
+        const tool = rest[1];
+        if (!server || !tool)
+            throw new Error(`Usage\n${usage()}`);
+        const argsIdx = rest.indexOf("--args");
+        const mcpArgs = argsIdx !== -1 && rest[argsIdx + 1] ? rest[argsIdx + 1] : undefined;
+        return { kind: "mcp.call", server, tool, ...(mcpArgs ? { args: mcpArgs } : {}) };
+    }
+    throw new Error(`Usage\n${usage()}`);
+}
 function parseOuroCommand(args) {
     const [head, second] = args;
     if (!head)
@@ -697,6 +716,8 @@ function parseOuroCommand(args) {
         return parseReminderCommand(args.slice(1));
     if (head === "friend")
         return parseFriendCommand(args.slice(1));
+    if (head === "mcp")
+        return parseMcpCommand(args.slice(1));
     if (head === "whoami") {
         const { agent } = extractAgentFlag(args.slice(1));
         return { kind: "whoami", ...(agent ? { agent } : {}) };
@@ -1111,6 +1132,28 @@ function createDefaultOuroCliDeps(socketPath = socket_client_1.DEFAULT_DAEMON_SO
         },
     };
 }
+function formatMcpResponse(command, response) {
+    if (command.kind === "mcp.list") {
+        const allTools = response.data;
+        if (!allTools || allTools.length === 0) {
+            return response.message ?? "no tools available from connected MCP servers";
+        }
+        const lines = [];
+        for (const entry of allTools) {
+            lines.push(`[${entry.server}]`);
+            for (const tool of entry.tools) {
+                lines.push(`  ${tool.name}: ${tool.description}`);
+            }
+        }
+        return lines.join("\n");
+    }
+    // mcp.call
+    const result = response.data;
+    if (!result) {
+        return response.message ?? "no result";
+    }
+    return result.content.map((c) => c.text).join("\n");
+}
 function toDaemonCommand(command) {
     return command;
 }
@@ -1494,6 +1537,27 @@ async function runOuroCli(args, deps = createDefaultOuroCliDeps()) {
         deps.tailLogs();
         return "";
     }
+    // ── mcp subcommands (routed through daemon socket) ──
+    if (command.kind === "mcp.list" || command.kind === "mcp.call") {
+        const daemonCommand = toDaemonCommand(command);
+        let response;
+        try {
+            response = await deps.sendCommand(deps.socketPath, daemonCommand);
+        }
+        catch {
+            const message = "daemon unavailable — start with `ouro up` first";
+            deps.writeStdout(message);
+            return message;
+        }
+        if (!response.ok) {
+            const message = response.error ?? "unknown error";
+            deps.writeStdout(message);
+            return message;
+        }
+        const message = formatMcpResponse(command, response);
+        deps.writeStdout(message);
+        return message;
+    }
     // ── task subcommands (local, no daemon socket needed) ──
     if (command.kind === "task.board" || command.kind === "task.create" || command.kind === "task.update" ||
         command.kind === "task.show" || command.kind === "task.actionable" || command.kind === "task.deps" ||

package/dist/heart/daemon/daemon.js

@@ -49,6 +49,7 @@ const staged_restart_1 = require("./staged-restart");
 const child_process_1 = require("child_process");
 const pending_1 = require("../../mind/pending");
 const channel_1 = require("../../mind/friends/channel");
+const mcp_manager_1 = require("../../repertoire/mcp-manager");
 function buildWorkerRows(snapshots) {
     return snapshots.map((snapshot) => ({
         agent: snapshot.name,
@@ -154,6 +155,9 @@ class OuroDaemon {
             },
             /* v8 ignore stop */
         });
+        // Pre-initialize MCP connections so they're ready for the first command (non-blocking)
+        /* v8 ignore next -- catch callback: getSharedMcpManager logs errors internally @preserve */
+        (0, mcp_manager_1.getSharedMcpManager)().catch(() => { });
         await this.processManager.startAutoStartAgents();
         await this.senseManager?.startAutoStartSenses();
         this.scheduler.start?.();
@@ -330,6 +334,7 @@ class OuroDaemon {
             meta: { socketPath: this.socketPath },
         });
         (0, update_checker_1.stopUpdateChecker)();
+        (0, mcp_manager_1.shutdownSharedMcpManager)();
         this.scheduler.stop?.();
         await this.processManager.stopAll();
         await this.senseManager?.stopAll();
@@ -476,6 +481,28 @@ class OuroDaemon {
                     data: receipt,
                 };
             }
+            case "mcp.list": {
+                const mcpManager = await (0, mcp_manager_1.getSharedMcpManager)();
+                if (!mcpManager) {
+                    return { ok: true, data: [], message: "no MCP servers configured" };
+                }
+                return { ok: true, data: mcpManager.listAllTools() };
+            }
+            case "mcp.call": {
+                const mcpCallManager = await (0, mcp_manager_1.getSharedMcpManager)();
+                if (!mcpCallManager) {
+                    return { ok: false, error: "no MCP servers configured" };
+                }
+                try {
+                    const parsedArgs = command.args ? JSON.parse(command.args) : {};
+                    const result = await mcpCallManager.callTool(command.server, command.tool, parsedArgs);
+                    return { ok: true, data: result };
+                }
+                catch (error) {
+                    /* v8 ignore next -- defensive: callTool errors are always Error instances @preserve */
+                    return { ok: false, error: error instanceof Error ? error.message : String(error) };
+                }
+            }
             case "hatch.start":
                 return {
                     ok: true,

package/dist/heart/identity.js

@@ -354,6 +354,7 @@ function loadAgentConfig() {
         context: parsed.context,
         logging: parsed.logging,
         senses: normalizeSenses(parsed.senses, configFile),
+        mcpServers: parsed.mcpServers,
         phrases: parsed.phrases,
     };
     (0, runtime_1.emitNervesEvent)({

package/dist/mind/prompt.js

@@ -36,6 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.resetPsycheCache = resetPsycheCache;
 exports.buildSessionSummary = buildSessionSummary;
 exports.bodyMapSection = bodyMapSection;
+exports.mcpToolsSection = mcpToolsSection;
 exports.runtimeInfoSection = runtimeInfoSection;
 exports.toolRestrictionSection = toolRestrictionSection;
 exports.contextSection = contextSection;
@@ -169,18 +170,37 @@ my bones are the framework that gives me my tools, my senses, and
 my ability to think and talk. they update when new versions come out.
 i don't touch them directly, but they're what make me, me.
 
-my bones give me the \`ouro\` cli. always pass \`--agent ${(0, identity_1.getAgentName)()}\`:
-  ouro whoami --agent ${(0, identity_1.getAgentName)()}
-  ouro changelog --agent ${(0, identity_1.getAgentName)()}
-  ouro task board --agent ${(0, identity_1.getAgentName)()}
-  ouro task create --agent ${(0, identity_1.getAgentName)()} --type <type> <title>
-  ouro task update --agent ${(0, identity_1.getAgentName)()} <id> <status>
-  ouro friend list --agent ${(0, identity_1.getAgentName)()}
-  ouro friend show --agent ${(0, identity_1.getAgentName)()} <id>
-  ouro session list --agent ${(0, identity_1.getAgentName)()}
-  ouro reminder create --agent ${(0, identity_1.getAgentName)()} <title> --body <body>
+my bones give me the \`ouro\` cli. always pass \`--agent ${agentName}\`:
+  ouro whoami --agent ${agentName}
+  ouro changelog --agent ${agentName}
+  ouro task board --agent ${agentName}
+  ouro task create --agent ${agentName} --type <type> <title>
+  ouro task update --agent ${agentName} <id> <status>
+  ouro friend list --agent ${agentName}
+  ouro friend show --agent ${agentName} <id>
+  ouro session list --agent ${agentName}
+  ouro reminder create --agent ${agentName} <title> --body <body>
+  ouro mcp list --agent ${agentName}
+  ouro mcp call --agent ${agentName} <server> <tool> --args '{...}'
   ouro --help`;
 }
+function mcpToolsSection(mcpManager) {
+    if (!mcpManager)
+        return "";
+    const allTools = mcpManager.listAllTools();
+    if (allTools.length === 0)
+        return "";
+    const lines = [
+        `## mcp tools (use ouro mcp call <server> <tool> --args '{...}')`,
+    ];
+    for (const entry of allTools) {
+        lines.push(`### ${entry.server}`);
+        for (const tool of entry.tools) {
+            lines.push(`- ${tool.name}: ${tool.description}`);
+        }
+    }
+    return lines.join("\n");
+}
 function readBundleMeta() {
     try {
         const metaPath = path.join((0, identity_1.getAgentRoot)(), "bundle-meta.json");
@@ -578,6 +598,7 @@ async function buildSystem(channel = "cli", options, context) {
         providerSection(),
         dateSection(),
         toolsSection(channel, options, context),
+        mcpToolsSection(options?.mcpManager),
         reasoningEffortSection(options),
         toolRestrictionSection(context),
         trustContextSection(context),

package/dist/repertoire/guardrails.js

@@ -170,6 +170,8 @@ exports.OURO_CLI_TRUST_MANIFEST = {
     "friend show": "friend",
     "friend create": "friend",
     "reminder create": "friend",
+    "mcp list": "acquaintance",
+    "mcp call": "friend",
 };
 // --- trust level comparison ---
 const LEVEL_ORDER = {

package/dist/repertoire/mcp-client.js

@@ -0,0 +1,254 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.McpClient = void 0;
+const child_process_1 = require("child_process");
+const readline_1 = require("readline");
+const runtime_1 = require("../nerves/runtime");
+const MCP_PROTOCOL_VERSION = "2024-11-05";
+const DEFAULT_TOOL_CALL_TIMEOUT = 30_000;
+class McpClient {
+    config;
+    process = null;
+    nextId = 1;
+    pending = new Map();
+    connected = false;
+    cachedTools = null;
+    onCloseCallback = null;
+    constructor(config) {
+        this.config = config;
+    }
+    async connect() {
+        (0, runtime_1.emitNervesEvent)({
+            event: "mcp.connect_start",
+            component: "repertoire",
+            message: "starting MCP server connection",
+            meta: { command: this.config.command },
+        });
+        const env = { ...process.env, ...this.config.env };
+        this.process = (0, child_process_1.spawn)(this.config.command, this.config.args ?? [], {
+            env,
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        this.setupLineReader();
+        this.setupProcessHandlers();
+        try {
+            await this.initialize();
+            this.connected = true;
+            (0, runtime_1.emitNervesEvent)({
+                event: "mcp.connect_end",
+                component: "repertoire",
+                message: "MCP server connected",
+                meta: { command: this.config.command },
+            });
+        }
+        catch (error) {
+            this.connected = false;
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                event: "mcp.connect_error",
+                component: "repertoire",
+                message: "MCP server connection failed",
+                meta: {
+                    command: this.config.command,
+                    /* v8 ignore next -- defensive: spawn errors are always Error instances @preserve */
+                    reason: error instanceof Error ? error.message : String(error),
+                },
+            });
+            throw error;
+        }
+    }
+    async listTools() {
+        if (this.cachedTools) {
+            return this.cachedTools;
+        }
+        const allTools = [];
+        let cursor;
+        do {
+            const params = {};
+            if (cursor) {
+                params.cursor = cursor;
+            }
+            const result = await this.sendRequest("tools/list", params);
+            allTools.push(...result.tools);
+            cursor = result.nextCursor;
+        } while (cursor);
+        this.cachedTools = allTools;
+        return allTools;
+    }
+    async callTool(name, args, timeout = DEFAULT_TOOL_CALL_TIMEOUT) {
+        (0, runtime_1.emitNervesEvent)({
+            event: "mcp.tool_call_start",
+            component: "repertoire",
+            message: `calling MCP tool: ${name}`,
+            meta: { tool: name },
+        });
+        try {
+            const result = await this.sendRequest("tools/call", {
+                name,
+                arguments: args,
+            }, timeout);
+            (0, runtime_1.emitNervesEvent)({
+                event: "mcp.tool_call_end",
+                component: "repertoire",
+                message: `MCP tool call completed: ${name}`,
+                meta: { tool: name },
+            });
+            return result;
+        }
+        catch (error) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                event: "mcp.tool_call_error",
+                component: "repertoire",
+                message: `MCP tool call failed: ${name}`,
+                meta: {
+                    tool: name,
+                    /* v8 ignore next -- defensive: callTool errors are always Error instances @preserve */
+                    reason: error instanceof Error ? error.message : String(error),
+                },
+            });
+            throw error;
+        }
+    }
+    shutdown() {
+        this.connected = false;
+        this.rejectAllPending(new Error("Client shutdown"));
+        /* v8 ignore next -- defensive: process always exists during normal shutdown @preserve */
+        if (this.process && !this.process.killed) {
+            this.process.kill();
+        }
+        this.process = null;
+    }
+    isConnected() {
+        return this.connected;
+    }
+    onClose(callback) {
+        this.onCloseCallback = callback;
+    }
+    async initialize() {
+        const result = await this.sendRequest("initialize", {
+            protocolVersion: MCP_PROTOCOL_VERSION,
+            clientInfo: { name: "ouroboros", version: "1.0" },
+            capabilities: {},
+        });
+        // Send initialized notification (no id, no response expected)
+        this.writeMessage({
+            jsonrpc: "2.0",
+            method: "initialized",
+        });
+        return result;
+    }
+    sendRequest(method, params, timeout) {
+        return new Promise((resolve, reject) => {
+            if (!this.process || !this.connected && method !== "initialize") {
+                reject(new Error("MCP client is disconnected"));
+                return;
+            }
+            const id = this.nextId++;
+            const pending = { resolve, reject };
+            if (timeout) {
+                pending.timer = setTimeout(() => {
+                    this.pending.delete(id);
+                    reject(new Error(`MCP request timeout after ${timeout}ms: ${method}`));
+                }, timeout);
+            }
+            this.pending.set(id, pending);
+            const request = {
+                jsonrpc: "2.0",
+                id,
+                method,
+                params,
+            };
+            this.writeMessage(request);
+        });
+    }
+    writeMessage(message) {
+        /* v8 ignore next -- defensive: stdin always writable during active connection @preserve */
+        if (this.process?.stdin?.writable) {
+            this.process.stdin.write(JSON.stringify(message) + "\n");
+        }
+    }
+    setupLineReader() {
+        /* v8 ignore next -- defensive: stdout always exists after spawn @preserve */
+        if (!this.process?.stdout)
+            return;
+        const rl = (0, readline_1.createInterface)({ input: this.process.stdout });
+        rl.on("line", (line) => {
+            this.handleLine(line);
+        });
+    }
+    handleLine(line) {
+        let response;
+        try {
+            response = JSON.parse(line);
+        }
+        catch {
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                event: "mcp.connect_error",
+                component: "repertoire",
+                message: "received malformed JSON from MCP server",
+                meta: { line },
+            });
+            return;
+        }
+        if (response.id === undefined || response.id === null) {
+            // Notification or invalid — ignore
+            return;
+        }
+        const pending = this.pending.get(response.id);
+        if (!pending)
+            return;
+        this.pending.delete(response.id);
+        if (pending.timer) {
+            clearTimeout(pending.timer);
+        }
+        if (response.error) {
+            pending.reject(new Error(response.error.message));
+        }
+        else {
+            pending.resolve(response.result);
+        }
+    }
+    setupProcessHandlers() {
+        /* v8 ignore next -- defensive: process always exists after spawn @preserve */
+        if (!this.process)
+            return;
+        this.process.on("error", (error) => {
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                event: "mcp.connect_error",
+                component: "repertoire",
+                message: "MCP server process error",
+                meta: { reason: error.message },
+            });
+        });
+        this.process.on("close", (code) => {
+            const wasConnected = this.connected;
+            this.connected = false;
+            this.rejectAllPending(new Error(`MCP server process closed with code ${code}`));
+            if (wasConnected) {
+                (0, runtime_1.emitNervesEvent)({
+                    level: "error",
+                    event: "mcp.connect_error",
+                    component: "repertoire",
+                    message: "MCP server process exited unexpectedly",
+                    meta: { exitCode: code },
+                });
+            }
+            if (this.onCloseCallback) {
+                this.onCloseCallback();
+            }
+        });
+    }
+    rejectAllPending(error) {
+        for (const [id, pending] of this.pending) {
+            if (pending.timer) {
+                clearTimeout(pending.timer);
+            }
+            pending.reject(error);
+            this.pending.delete(id);
+        }
+    }
+}
+exports.McpClient = McpClient;

package/dist/repertoire/mcp-manager.js

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.McpManager = void 0;
+exports.getSharedMcpManager = getSharedMcpManager;
+exports.shutdownSharedMcpManager = shutdownSharedMcpManager;
+exports.resetSharedMcpManager = resetSharedMcpManager;
+const mcp_client_1 = require("./mcp-client");
+const identity_1 = require("../heart/identity");
+const runtime_1 = require("../nerves/runtime");
+const MAX_RESTART_RETRIES = 5;
+const RESTART_DELAY_MS = 1000;
+class McpManager {
+    servers = new Map();
+    shuttingDown = false;
+    async start(servers) {
+        (0, runtime_1.emitNervesEvent)({
+            event: "mcp.manager_start",
+            component: "repertoire",
+            message: "starting MCP manager",
+            meta: { serverCount: Object.keys(servers).length },
+        });
+        const entries = Object.entries(servers);
+        for (const [name, config] of entries) {
+            await this.connectServer(name, config);
+        }
+    }
+    listAllTools() {
+        const result = [];
+        for (const [name, entry] of this.servers) {
+            result.push({ server: name, tools: entry.cachedTools });
+        }
+        return result;
+    }
+    async callTool(server, tool, args) {
+        const entry = this.servers.get(server);
+        if (!entry) {
+            throw new Error(`Unknown server: ${server}`);
+        }
+        if (!entry.client.isConnected()) {
+            throw new Error(`Server "${server}" is disconnected`);
+        }
+        return entry.client.callTool(tool, args);
+    }
+    shutdown() {
+        this.shuttingDown = true;
+        (0, runtime_1.emitNervesEvent)({
+            event: "mcp.manager_stop",
+            component: "repertoire",
+            message: "shutting down MCP manager",
+            meta: { serverCount: this.servers.size },
+        });
+        for (const [, entry] of this.servers) {
+            entry.client.shutdown();
+        }
+        this.servers.clear();
+    }
+    async connectServer(name, config) {
+        const client = new mcp_client_1.McpClient(config);
+        const entry = {
+            name,
+            config,
+            client,
+            cachedTools: [],
+            consecutiveFailures: 0,
+        };
+        this.servers.set(name, entry);
+        client.onClose(() => {
+            if (this.shuttingDown)
+                return;
+            this.handleServerCrash(name);
+        });
+        try {
+            await client.connect();
+            const tools = await client.listTools();
+            entry.cachedTools = tools;
+            entry.consecutiveFailures = 0;
+        }
+        catch (error) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                event: "mcp.connect_error",
+                component: "repertoire",
+                message: `failed to connect MCP server: ${name}`,
+                meta: {
+                    server: name,
+                    reason: error instanceof Error ? error.message : String(error),
+                },
+            });
+        }
+    }
+    handleServerCrash(name) {
+        const entry = this.servers.get(name);
+        /* v8 ignore next -- defensive: entry removed between close event and handler @preserve */
+        if (!entry)
+            return;
+        entry.consecutiveFailures++;
+        if (entry.consecutiveFailures > MAX_RESTART_RETRIES) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                event: "mcp.connect_error",
+                component: "repertoire",
+                message: `MCP server "${name}" exceeded max restart retries (${MAX_RESTART_RETRIES})`,
+                meta: { server: name, failures: entry.consecutiveFailures },
+            });
+            return;
+        }
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            event: "mcp.server_restart",
+            component: "repertoire",
+            message: `restarting crashed MCP server: ${name}`,
+            meta: { server: name, attempt: entry.consecutiveFailures },
+        });
+        /* v8 ignore start -- timer callback: covered by mcp-manager.test.ts via fake timers but v8 can't trace @preserve */
+        setTimeout(() => {
+            if (this.shuttingDown)
+                return;
+            this.restartServer(name).catch(() => {
+                // Error handling is inside restartServer
+            });
+        }, RESTART_DELAY_MS);
+        /* v8 ignore stop */
+    }
+    /* v8 ignore start -- called from timer callback: covered by mcp-manager.test.ts via fake timers but v8 can't trace @preserve */
+    async restartServer(name) {
+        const entry = this.servers.get(name);
+        if (!entry)
+            return;
+        // Remove old entry and reconnect
+        this.servers.delete(name);
+        await this.connectServer(name, entry.config);
+        // Preserve failure count
+        const newEntry = this.servers.get(name);
+        if (newEntry) {
+            newEntry.consecutiveFailures = entry.consecutiveFailures;
+        }
+    }
+}
+exports.McpManager = McpManager;
+let _sharedManager = null;
+let _sharedManagerPromise = null;
+/**
+ * Get or create a shared McpManager instance from the agent's config.
+ * Returns null if no mcpServers are configured.
+ * Safe to call from multiple senses — will only create one instance.
+ */
+async function getSharedMcpManager() {
+    if (_sharedManager)
+        return _sharedManager;
+    /* v8 ignore next -- race guard: deduplicates concurrent initialization calls @preserve */
+    if (_sharedManagerPromise)
+        return _sharedManagerPromise;
+    _sharedManagerPromise = (async () => {
+        try {
+            const config = (0, identity_1.loadAgentConfig)();
+            const servers = config.mcpServers;
+            if (!servers || Object.keys(servers).length === 0)
+                return null;
+            const manager = new McpManager();
+            await manager.start(servers);
+            _sharedManager = manager;
+            return manager;
+        }
+        catch (error) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                event: "mcp.manager_start",
+                component: "repertoire",
+                message: "failed to initialize shared MCP manager",
+                /* v8 ignore next -- both branches tested: Error in wiring test, non-Error is defensive @preserve */
+                meta: { reason: error instanceof Error ? error.message : String(error) },
+            });
+            return null;
+        }
+        finally {
+            _sharedManagerPromise = null;
+        }
+    })();
+    return _sharedManagerPromise;
+}
+/**
+ * Shut down the shared MCP manager and clear the singleton.
+ * Called during daemon/agent shutdown.
+ */
+function shutdownSharedMcpManager() {
+    if (_sharedManager) {
+        _sharedManager.shutdown();
+        _sharedManager = null;
+    }
+}
+/** Reset for testing only */
+function resetSharedMcpManager() {
+    _sharedManager = null;
+    _sharedManagerPromise = null;
+}

package/dist/senses/bluebubbles.js

@@ -55,6 +55,7 @@ const types_1 = require("../mind/friends/types");
 const channel_1 = require("../mind/friends/channel");
 const pending_1 = require("../mind/pending");
 const prompt_1 = require("../mind/prompt");
+const mcp_manager_1 = require("../repertoire/mcp-manager");
 const phrases_1 = require("../mind/phrases");
 const runtime_1 = require("../nerves/runtime");
 const bluebubbles_model_1 = require("./bluebubbles-model");
@@ -557,9 +558,10 @@ async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source) {
     return (0, turn_coordinator_1.withSharedTurnLock)("bluebubbles", sessPath, async () => {
         // Pre-load session inside the turn lock so same-chat deliveries cannot race on stale trunk state.
         const existing = resolvedDeps.loadSession(sessPath);
+        const mcpManager = await (0, mcp_manager_1.getSharedMcpManager)() ?? undefined;
         const sessionMessages = existing?.messages && existing.messages.length > 0
             ? existing.messages
-            : [{ role: "system", content: await resolvedDeps.buildSystem("bluebubbles", undefined, context) }];
+            : [{ role: "system", content: await resolvedDeps.buildSystem("bluebubbles", { mcpManager }, context) }];
         if (event.kind === "message") {
             const agentName = resolvedDeps.getAgentName();
             if ((0, bluebubbles_inbound_log_1.hasRecordedBlueBubblesInbound)(agentName, event.chat.sessionKey, event.messageGuid)) {
@@ -661,6 +663,7 @@ async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source) {
                 postTurn: resolvedDeps.postTurn,
                 accumulateFriendTokens: resolvedDeps.accumulateFriendTokens,
                 signal: controller.signal,
+                runAgentOptions: { mcpManager },
             });
             // ── Handle gate result ────────────────────────────────────────
             if (!result.gateResult.allowed) {

package/dist/senses/cli.js

@@ -55,6 +55,7 @@ const context_1 = require("../mind/context");
 const pending_1 = require("../mind/pending");
 const commands_1 = require("./commands");
 const identity_1 = require("../heart/identity");
+const mcp_manager_1 = require("../repertoire/mcp-manager");
 const nerves_1 = require("../nerves");
 const store_file_1 = require("../mind/friends/store-file");
 const resolver_1 = require("../mind/friends/resolver");
@@ -734,9 +735,10 @@ async function main(agentName, options) {
     // Load existing session or start fresh
     const existing = (0, context_1.loadSession)(sessPath);
     let sessionState = existing?.state;
+    const mcpManager = await (0, mcp_manager_1.getSharedMcpManager)() ?? undefined;
     const sessionMessages = existing?.messages && existing.messages.length > 0
         ? existing.messages
-        : [{ role: "system", content: await (0, prompt_1.buildSystem)("cli", undefined, resolvedContext) }];
+        : [{ role: "system", content: await (0, prompt_1.buildSystem)("cli", { mcpManager }, resolvedContext) }];
     // Per-turn pipeline input: CLI capabilities and pending dir
     const cliCapabilities = (0, channel_1.getChannelCapabilities)("cli");
     const currentAgentName = (0, identity_1.getAgentName)();
@@ -784,6 +786,7 @@ async function main(agentName, options) {
                     runAgentOptions: {
                         toolChoiceRequired: (0, commands_1.getToolChoiceRequired)(),
                         traceId: (0, nerves_1.createTraceId)(),
+                        mcpManager,
                     },
                 });
                 // Handle gate rejection: display auto-reply if present

package/dist/senses/inner-dialog.js

@@ -49,6 +49,7 @@ const core_1 = require("../heart/core");
 const identity_1 = require("../heart/identity");
 const context_1 = require("../mind/context");
 const prompt_1 = require("../mind/prompt");
+const mcp_manager_1 = require("../repertoire/mcp-manager");
 const bundle_manifest_1 = require("../mind/bundle-manifest");
 const pending_1 = require("../mind/pending");
 const channel_1 = require("../mind/friends/channel");
@@ -401,13 +402,14 @@ async function runInnerDialogTurn(options) {
         const pendingDir = (0, pending_1.getInnerDialogPendingDir)(agentName);
         const selfFriend = createSelfFriend(agentName);
         const selfContext = { friend: selfFriend, channel: innerCapabilities };
+        const mcpManager = await (0, mcp_manager_1.getSharedMcpManager)() ?? undefined;
         const sessionLoader = {
             loadOrCreate: async () => {
                 if (existingMessages.length > 0) {
                     return { messages: existingMessages, sessionPath: sessionFilePath };
                 }
                 // Fresh session: build system prompt
-                const systemPrompt = await (0, prompt_1.buildSystem)("inner", { toolChoiceRequired: true });
+                const systemPrompt = await (0, prompt_1.buildSystem)("inner", { toolChoiceRequired: true, mcpManager });
                 return {
                     messages: [{ role: "system", content: systemPrompt }],
                     sessionPath: sessionFilePath,
@@ -438,6 +440,7 @@ async function runInnerDialogTurn(options) {
                 traceId,
                 toolChoiceRequired: true,
                 skipConfirmation: true,
+                mcpManager,
             },
         });
         await routeDelegatedCompletion(agentRoot, agentName, result.completion, result.drainedPending, now().getTime());

package/dist/senses/teams.js

@@ -64,6 +64,7 @@ const resolver_1 = require("../mind/friends/resolver");
 const tokens_1 = require("../mind/friends/tokens");
 const turn_coordinator_1 = require("../heart/turn-coordinator");
 const identity_1 = require("../heart/identity");
+const mcp_manager_1 = require("../repertoire/mcp-manager");
 const progress_story_1 = require("../heart/progress-story");
 const http = __importStar(require("http"));
 const path = __importStar(require("path"));
@@ -531,12 +532,14 @@ async function handleTeamsMessage(text, stream, conversationId, teamsContext, se
         botApi: teamsContext.botApi,
     } : {};
     let currentText = text;
+    const mcpManager = await (0, mcp_manager_1.getSharedMcpManager)() ?? undefined;
     while (true) {
         let drainedSteeringFollowUps = [];
         // Build runAgentOptions with Teams-specific fields
         const agentOptions = {
             traceId,
             toolContext: teamsToolContext,
+            mcpManager,
             drainSteeringFollowUps: () => {
                 drainedSteeringFollowUps = _turnCoordinator.drainFollowUps(turnKey)
                     .map(({ text: followUpText, effect }) => ({ text: followUpText, effect }));
@@ -559,7 +562,7 @@ async function handleTeamsMessage(text, stream, conversationId, teamsContext, se
                     const existing = (0, context_1.loadSession)(sessPath);
                     const messages = existing?.messages && existing.messages.length > 0
                         ? existing.messages
-                        : [{ role: "system", content: await (0, prompt_1.buildSystem)("teams", undefined, resolvedContext) }];
+                        : [{ role: "system", content: await (0, prompt_1.buildSystem)("teams", { mcpManager }, resolvedContext) }];
                     (0, core_1.repairOrphanedToolCalls)(messages);
                     return { messages, sessionPath: sessPath, state: existing?.state };
                 },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.68",
+  "version": "0.1.0-alpha.69",
   "main": "dist/heart/daemon/ouro-entry.js",
   "bin": {
     "cli": "dist/heart/daemon/ouro-bot-entry.js",