@ouro.bot/cli 0.1.0-alpha.803 → 0.1.0-alpha.805

package/dist/repertoire/mcp-manager.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.McpManager = void 0;
 exports.getSharedMcpManager = getSharedMcpManager;
+exports.releaseRuntimeMcpServers = releaseRuntimeMcpServers;
 exports.shutdownSharedMcpManager = shutdownSharedMcpManager;
 exports.resetSharedMcpManager = resetSharedMcpManager;
 const mcp_client_1 = require("./mcp-client");
@@ -57,10 +58,20 @@ function buildMergedServerConfig(runtimeServers) {
     }
     return { mergedServers, pluginOrigins };
 }
+function sameMcpServerConfig(left, right) {
+    const leftEnv = Object.entries(left.env ?? {}).sort();
+    const rightEnv = Object.entries(right.env ?? {}).sort();
+    return left.command === right.command
+        && JSON.stringify(left.args ?? []) === JSON.stringify(right.args ?? [])
+        && JSON.stringify(leftEnv) === JSON.stringify(rightEnv)
+        && (left.cwd ?? "") === (right.cwd ?? "");
+}
 class McpManager {
     servers = new Map();
+    desiredGenerations = new Map();
+    nextGeneration = 0;
     shuttingDown = false;
-    async start(servers, pluginOrigins = {}) {
+    async start(servers, pluginOrigins = {}, ownerAgent) {
         (0, runtime_1.emitNervesEvent)({
             event: "mcp.manager_start",
             component: "repertoire",
@@ -72,7 +83,7 @@ class McpManager {
         });
         const entries = Object.entries(servers);
         for (const [name, config] of entries) {
-            await this.connectServer(name, config, pluginOrigins[name]);
+            await this.connectServer(name, config, pluginOrigins[name], ownerAgent);
         }
     }
     listAllTools() {
@@ -150,18 +161,34 @@ class McpManager {
     async reconcile(runtimeServers) {
         try {
             const { mergedServers, pluginOrigins } = buildMergedServerConfig(runtimeServers);
+            const ownerAgent = (0, identity_1.getAgentName)();
             const currentNames = new Set(this.servers.keys());
             const desiredNames = new Set(Object.keys(mergedServers));
             // Connect new servers
             for (const [name, cfg] of Object.entries(mergedServers)) {
-                if (!currentNames.has(name)) {
+                const current = this.servers.get(name);
+                const pluginId = pluginOrigins[name];
+                if (!current) {
                     (0, runtime_1.emitNervesEvent)({
                         event: "mcp.server_added",
                         component: "repertoire",
                         message: `connecting new MCP server: ${name}`,
                         meta: { server: name, command: cfg.command },
                     });
-                    await this.connectServer(name, cfg, pluginOrigins[name]);
+                    await this.connectServer(name, cfg, pluginId, ownerAgent);
+                }
+                else if (!sameMcpServerConfig(current.config, cfg)
+                    || current.pluginId !== pluginId
+                    || current.ownerAgent !== ownerAgent) {
+                    (0, runtime_1.emitNervesEvent)({
+                        event: "mcp.server_changed",
+                        component: "repertoire",
+                        message: `reconnecting changed MCP server: ${name}`,
+                        meta: { server: name, command: cfg.command },
+                    });
+                    current.client.shutdown();
+                    this.servers.delete(name);
+                    await this.connectServer(name, cfg, pluginId, ownerAgent);
                 }
             }
             // Disconnect removed servers
@@ -178,8 +205,10 @@ class McpManager {
                     if (entry)
                         entry.client.shutdown();
                     this.servers.delete(name);
+                    this.desiredGenerations.delete(name);
                 }
             }
+            return true;
         }
         catch (error) {
             (0, runtime_1.emitNervesEvent)({
@@ -189,6 +218,8 @@ class McpManager {
                 message: "failed to reconcile MCP servers",
                 meta: { reason: error instanceof Error ? error.message : String(error) },
             });
+            this.shutdown();
+            return false;
         }
     }
     shutdown() {
@@ -205,12 +236,13 @@ class McpManager {
             entry.client.shutdown();
         }
         this.servers.clear();
+        this.desiredGenerations.clear();
     }
     /**
      * Resolve `vault:DOMAIN/FIELD` references in server env config.
      * Returns resolved env or throws with a descriptive error.
      */
-    async resolveVaultEnv(_serverName, env) {
+    async resolveVaultEnv(_serverName, env, ownerAgent) {
         const resolved = { ...env };
         // Short-circuit: only spin up a credential store if at least one env value
         // actually requests vault resolution. Plugin MCP servers commonly ship with
@@ -219,7 +251,7 @@ class McpManager {
         const hasVaultRef = Object.values(resolved).some((v) => /^vault:/.test(v));
         if (!hasVaultRef)
             return resolved;
-        const store = (0, credential_access_1.getCredentialStore)();
+        const store = (0, credential_access_1.getCredentialStore)(ownerAgent);
         for (const [key, value] of Object.entries(resolved)) {
             const match = value.match(/^vault:([^/]+)\/(.+)$/);
             if (!match)
@@ -244,12 +276,14 @@ class McpManager {
         }
         return resolved;
     }
-    async connectServer(name, config, pluginId) {
+    async connectServer(name, config, pluginId, ownerAgent) {
+        const generation = ++this.nextGeneration;
+        this.desiredGenerations.set(name, generation);
         // Resolve vault: references in env before spawning
         let resolvedConfig = config;
         if (config.env) {
             try {
-                const resolvedEnv = await this.resolveVaultEnv(name, config.env);
+                const resolvedEnv = await this.resolveVaultEnv(name, config.env, ownerAgent);
                 resolvedConfig = { ...config, env: resolvedEnv };
             }
             catch (err) {
@@ -262,9 +296,14 @@ class McpManager {
                     message: `skipping MCP server "${name}": ${reason}`,
                     meta: { server: name, reason },
                 });
+                if (this.desiredGenerations.get(name) === generation) {
+                    this.desiredGenerations.delete(name);
+                }
                 return; // Skip this server, continue to next
             }
         }
+        if (this.shuttingDown || this.desiredGenerations.get(name) !== generation)
+            return;
         const client = new mcp_client_1.McpClient(resolvedConfig);
         const entry = {
             name,
@@ -273,16 +312,26 @@ class McpManager {
             cachedTools: [],
             consecutiveFailures: 0,
             pluginId,
+            ownerAgent,
+            generation,
         };
         this.servers.set(name, entry);
         client.onClose(() => {
             if (this.shuttingDown)
                 return;
-            this.handleServerCrash(name);
+            if (this.servers.get(name)?.client !== client)
+                return;
+            this.handleServerCrash(name, client);
         });
         try {
             await client.connect();
             const tools = await client.listTools();
+            if (this.shuttingDown
+                || this.desiredGenerations.get(name) !== generation
+                || this.servers.get(name)?.client !== client) {
+                client.shutdown();
+                return;
+            }
             entry.cachedTools = tools;
             entry.consecutiveFailures = 0;
         }
@@ -302,10 +351,10 @@ class McpManager {
             });
         }
     }
-    handleServerCrash(name) {
+    handleServerCrash(name, crashedClient) {
         const entry = this.servers.get(name);
-        /* v8 ignore next -- defensive: entry removed between close event and handler @preserve */
-        if (!entry)
+        /* v8 ignore next -- defensive: entry removed or replaced between close event and handler @preserve */
+        if (!entry || entry.client !== crashedClient)
             return;
         entry.consecutiveFailures++;
         if (entry.consecutiveFailures > MAX_RESTART_RETRIES) {
@@ -329,21 +378,26 @@ class McpManager {
         setTimeout(() => {
             if (this.shuttingDown)
                 return;
-            this.restartServer(name).catch(() => {
+            if (this.servers.get(name)?.client !== crashedClient)
+                return;
+            this.restartServer(name, crashedClient).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) {
+    async restartServer(name, expectedClient) {
         const entry = this.servers.get(name);
         if (!entry)
             return;
+        if (expectedClient && entry.client !== expectedClient)
+            return;
         // Remove old entry and reconnect
         this.servers.delete(name);
+        this.desiredGenerations.delete(name);
         entry.client.shutdown();
-        await this.connectServer(name, entry.config);
+        await this.connectServer(name, entry.config, entry.pluginId, entry.ownerAgent);
         // Preserve failure count
         const newEntry = this.servers.get(name);
         if (newEntry) {
@@ -383,7 +437,11 @@ async function getSharedMcpManager(options) {
     // AND this turn's runtime overrides. Passing runtimeServers per-call is what
     // scopes the runtime MCP to the active agent's turn.
     if (_sharedManager) {
-        await _sharedManager.reconcile(runtimeServers);
+        const reconciled = await _sharedManager.reconcile(runtimeServers);
+        if (!reconciled) {
+            _sharedManager = null;
+            return null;
+        }
         return _sharedManager;
     }
     /* v8 ignore next -- race guard: deduplicates concurrent initialization calls @preserve */
@@ -396,7 +454,7 @@ async function getSharedMcpManager(options) {
             if (Object.keys(mergedServers).length === 0)
                 return null;
             const manager = new McpManager();
-            await manager.start(mergedServers, pluginOrigins);
+            await manager.start(mergedServers, pluginOrigins, (0, identity_1.getAgentName)());
             _sharedManager = manager;
             return manager;
         }
@@ -417,6 +475,13 @@ async function getSharedMcpManager(options) {
     })();
     return _sharedManagerPromise;
 }
+async function releaseRuntimeMcpServers() {
+    if (!_sharedManager)
+        return;
+    if (!await _sharedManager.reconcile()) {
+        _sharedManager = null;
+    }
+}
 /**
  * Shut down the shared MCP manager and clear the singleton.
  * Called during daemon/agent shutdown.

package/dist/senses/acp-server.js

@@ -0,0 +1,386 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAcpServer = createAcpServer;
+const node_crypto_1 = require("node:crypto");
+const readline = __importStar(require("node:readline"));
+const frontend_socket_client_1 = require("../heart/frontend-socket-client");
+const runtime_1 = require("../nerves/runtime");
+const SESSION_ID = /^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/;
+class AcpProtocolError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "AcpProtocolError";
+    }
+}
+function createAcpServer(options) {
+    const sessions = new Set();
+    const activePrompts = new Map();
+    const pendingOutbound = new Map();
+    const createClient = options.createFrontendClient ?? (async () => new frontend_socket_client_1.SocketFrontendClient(options.frontendSocketPath));
+    let clientPromise = null;
+    let frontendClient = null;
+    let removeEventListener = null;
+    let removeCloseListener = null;
+    let lines = null;
+    let running = false;
+    function write(message) {
+        options.stdout.write(`${JSON.stringify(message)}\n`);
+    }
+    function result(id, value) {
+        write({ jsonrpc: "2.0", id, result: value });
+    }
+    function error(id, code, message) {
+        write({ jsonrpc: "2.0", id, error: { code, message } });
+    }
+    async function client() {
+        if (!clientPromise) {
+            clientPromise = createClient().then((value) => {
+                frontendClient = value;
+                removeEventListener = value.onEvent(handleFrontendEvent);
+                removeCloseListener = value.onClose((error) => {
+                    const failure = error ?? new Error("frontend provider disconnected");
+                    for (const prompt of activePrompts.values())
+                        prompt.reject(failure);
+                    pendingOutbound.clear();
+                });
+                return value;
+            });
+        }
+        return clientPromise;
+    }
+    async function subscribe(sessionId) {
+        await (await client()).request("session.subscribe", { sessionKey: sessionId });
+        sessions.add(sessionId);
+    }
+    function sessionUpdate(sessionId, update) {
+        write({ jsonrpc: "2.0", method: "session/update", params: { sessionId, update } });
+    }
+    function permissionRequest(sessionId, event) {
+        const requestId = typeof event.requestId === "string" ? event.requestId : "";
+        if (!requestId || [...pendingOutbound.values()].some((pending) => pending.requestId === requestId))
+            return;
+        const rpcId = `ouro:${(0, node_crypto_1.randomUUID)()}`;
+        pendingOutbound.set(rpcId, { sessionId, requestId });
+        write({
+            jsonrpc: "2.0",
+            id: rpcId,
+            method: "session/request_permission",
+            params: {
+                sessionId,
+                toolCall: {
+                    toolCallId: String(event.toolCallId ?? requestId),
+                    title: String(event.title ?? "Permission requested"),
+                },
+                options: Array.isArray(event.options) ? event.options : [],
+            },
+        });
+    }
+    function replayEvent(sessionId, event) {
+        const data = event.data ?? {};
+        if (event.type === "user_message" && typeof data.text === "string") {
+            sessionUpdate(sessionId, {
+                sessionUpdate: "user_message_chunk",
+                messageId: `${event.turnId}:user`,
+                content: { type: "text", text: data.text },
+            });
+        }
+        else if (event.type === "assistant_delivery" && typeof data.text === "string") {
+            sessionUpdate(sessionId, {
+                sessionUpdate: "agent_message_chunk",
+                messageId: `${event.turnId}:agent`,
+                content: { type: "text", text: data.text },
+            });
+        }
+        else if (event.type === "tool_started") {
+            sessionUpdate(sessionId, {
+                sessionUpdate: "tool_call",
+                toolCallId: `${event.turnId}:${String(data.name ?? "tool")}`,
+                title: String(data.name ?? "tool"),
+                status: "pending",
+                rawInput: data.args ?? {},
+            });
+        }
+        else if (event.type === "tool_completed") {
+            sessionUpdate(sessionId, {
+                sessionUpdate: "tool_call_update",
+                toolCallId: `${event.turnId}:${String(data.name ?? "tool")}`,
+                status: data.success === false ? "failed" : "completed",
+                content: [{ type: "content", content: { type: "text", text: String(data.summary ?? "") } }],
+            });
+        }
+        else if (event.type === "structured_output") {
+            const output = data.output;
+            sessionUpdate(sessionId, {
+                sessionUpdate: "plan",
+                entries: (output?.items ?? []).flatMap((item) => typeof item.text === "string" && item.text.trim()
+                    ? [{ content: item.text.trim(), status: "pending" }]
+                    : []),
+            });
+        }
+    }
+    function handleFrontendEvent(event) {
+        const sessionId = typeof event.sessionKey === "string" ? event.sessionKey : "";
+        if (!sessions.has(sessionId))
+            return;
+        const turnId = typeof event.turnId === "string" ? event.turnId : "";
+        const active = activePrompts.get(sessionId);
+        if (event.event === "text.delta" && typeof event.text === "string") {
+            sessionUpdate(sessionId, {
+                sessionUpdate: "agent_message_chunk",
+                messageId: `${turnId}:agent`,
+                content: { type: "text", text: event.text },
+            });
+        }
+        else if (event.event === "reasoning.delta" && typeof event.text === "string") {
+            sessionUpdate(sessionId, {
+                sessionUpdate: "agent_thought_chunk",
+                messageId: `${turnId}:thought`,
+                content: { type: "text", text: event.text },
+            });
+        }
+        else if (event.event === "tool.started") {
+            replayEvent(sessionId, { type: "tool_started", turnId, data: event });
+        }
+        else if (event.event === "tool.completed") {
+            replayEvent(sessionId, { type: "tool_completed", turnId, data: event });
+        }
+        else if (event.event === "structured.output") {
+            replayEvent(sessionId, { type: "structured_output", turnId, data: event });
+        }
+        else if (event.event === "permission.requested") {
+            const requestId = typeof event.requestId === "string" ? event.requestId : "";
+            if (!requestId || !active || active.turnId !== turnId)
+                return;
+            permissionRequest(sessionId, event);
+        }
+        else if (active && active.turnId === turnId && event.event === "turn.completed") {
+            active.resolve("end_turn");
+        }
+        else if (active && active.turnId === turnId && event.event === "turn.cancelled") {
+            active.resolve("cancelled");
+        }
+        else if (active && active.turnId === turnId && event.event === "turn.failed") {
+            active.reject(new Error(String(event.error ?? "frontend turn failed")));
+        }
+    }
+    function params(value) {
+        if (!value || typeof value !== "object" || Array.isArray(value))
+            throw new AcpProtocolError(-32602, "params must be an object");
+        return value;
+    }
+    function requiredString(value, field) {
+        if (typeof value !== "string" || !value.trim())
+            throw new AcpProtocolError(-32602, `${field} must be a non-empty string`);
+        return value.trim();
+    }
+    function promptText(value) {
+        if (!Array.isArray(value))
+            throw new AcpProtocolError(-32602, "prompt must be an array");
+        const text = value
+            .flatMap((part) => part?.type === "text" && typeof part.text === "string" ? [part.text] : [])
+            .join("");
+        if (!text.trim())
+            throw new AcpProtocolError(-32602, "prompt must contain text");
+        return text;
+    }
+    async function handleResponse(response) {
+        if (response.jsonrpc !== "2.0")
+            throw new AcpProtocolError(-32600, "jsonrpc must be 2.0");
+        if (typeof response.id !== "string")
+            throw new AcpProtocolError(-32602, "response id must be a string");
+        const pending = pendingOutbound.get(response.id);
+        if (!pending)
+            throw new AcpProtocolError(-32602, `unknown response id: ${response.id}`);
+        pendingOutbound.delete(response.id);
+        const outcome = response.result?.outcome;
+        const optionId = outcome?.outcome === "selected" && typeof outcome.optionId === "string"
+            ? outcome.optionId
+            : "cancelled";
+        await (await client()).request("permission.resolve", { requestId: pending.requestId, optionId });
+    }
+    async function handle(request) {
+        if (request.jsonrpc !== "2.0")
+            throw new AcpProtocolError(-32600, "jsonrpc must be 2.0");
+        const method = requiredString(request.method, "method");
+        const requestParams = params(request.params ?? {});
+        const id = request.id;
+        if (method === "initialize") {
+            if (id === undefined)
+                return;
+            if (requestParams.protocolVersion !== 1)
+                throw new AcpProtocolError(-32602, "protocolVersion must be 1");
+            result(id, { protocolVersion: 1 });
+            return;
+        }
+        if (method === "session/new") {
+            if (id === undefined)
+                return;
+            const sessionId = requestParams.sessionId === undefined
+                ? (0, node_crypto_1.randomUUID)()
+                : requiredString(requestParams.sessionId, "sessionId");
+            if (!SESSION_ID.test(sessionId))
+                throw new AcpProtocolError(-32602, "sessionId must be a safe identifier");
+            if (sessions.has(sessionId))
+                throw new AcpProtocolError(-32002, `session already exists: ${sessionId}`);
+            await subscribe(sessionId);
+            result(id, { sessionId, friendId: options.friendId });
+            return;
+        }
+        if (method === "session/load") {
+            if (id === undefined)
+                return;
+            if (options.disableTools) {
+                throw new AcpProtocolError(-32601, "session/load is unavailable in observe-only mode");
+            }
+            const sessionId = requiredString(requestParams.sessionId, "sessionId");
+            const frontend = await client();
+            const replay = await frontend.request("session.load", {
+                agent: options.agent,
+                friendId: options.friendId,
+                sessionKey: sessionId,
+                afterSequence: 0,
+            });
+            if (!Array.isArray(replay?.events) || replay.events.length === 0) {
+                throw new AcpProtocolError(-32001, "session not found");
+            }
+            for (const event of replay.events)
+                replayEvent(sessionId, event);
+            await subscribe(sessionId);
+            for (const pending of replay.pendingPermissions ?? [])
+                permissionRequest(sessionId, pending);
+            result(id, {});
+            return;
+        }
+        if (method === "session/prompt") {
+            if (id === undefined)
+                return;
+            const sessionId = requiredString(requestParams.sessionId, "sessionId");
+            if (!sessions.has(sessionId))
+                throw new AcpProtocolError(-32001, `unknown session: ${sessionId}`);
+            if (activePrompts.has(sessionId))
+                throw new AcpProtocolError(-32002, "session already has an active prompt");
+            const message = promptText(requestParams.prompt);
+            const turnId = (0, node_crypto_1.randomUUID)();
+            const completion = Promise.withResolvers();
+            activePrompts.set(sessionId, { rpcId: id, turnId, resolve: completion.resolve, reject: completion.reject });
+            try {
+                await (await client()).request(options.disableTools ? "turn.start.observe-only" : "turn.start", {
+                    turnId,
+                    agent: options.agent,
+                    friendId: options.friendId,
+                    channel: "mcp",
+                    sessionKey: sessionId,
+                    message,
+                    ...(options.runtimeMcpServers ? { runtimeMcpServers: options.runtimeMcpServers } : {}),
+                });
+                result(id, { stopReason: await completion.promise });
+            }
+            finally {
+                activePrompts.delete(sessionId);
+            }
+            return;
+        }
+        if (method === "session/cancel") {
+            const sessionId = requiredString(requestParams.sessionId, "sessionId");
+            const active = activePrompts.get(sessionId);
+            if (active)
+                await (await client()).request("turn.cancel", { turnId: active.turnId });
+            return;
+        }
+        throw new AcpProtocolError(-32601, `method not found: ${method}`);
+    }
+    async function dispatch(line) {
+        let request;
+        try {
+            request = JSON.parse(line);
+        }
+        catch {
+            error(null, -32700, "parse error");
+            return;
+        }
+        try {
+            if (request.method === undefined && (request.result !== undefined || request.error !== undefined)) {
+                await handleResponse(request);
+            }
+            else {
+                await handle(request);
+            }
+        }
+        catch (caught) {
+            const id = request.id ?? null;
+            const code = caught instanceof AcpProtocolError ? caught.code : -32000;
+            error(id, code, caught instanceof Error ? caught.message : String(caught));
+        }
+    }
+    return {
+        start() {
+            if (running)
+                return;
+            running = true;
+            (0, runtime_1.emitNervesEvent)({
+                component: "senses",
+                event: "senses.acp_server_started",
+                message: "ACP server started",
+            });
+            lines = readline.createInterface({ input: options.stdin, crlfDelay: Infinity });
+            lines.on("line", (line) => {
+                if (line.trim())
+                    void dispatch(line);
+            });
+        },
+        stop() {
+            if (!running)
+                return;
+            running = false;
+            lines?.close();
+            lines = null;
+            removeEventListener?.();
+            removeEventListener = null;
+            removeCloseListener?.();
+            removeCloseListener = null;
+            frontendClient?.close();
+            frontendClient = null;
+            clientPromise = null;
+            for (const prompt of activePrompts.values())
+                prompt.reject(new Error("ACP server stopped"));
+            activePrompts.clear();
+            pendingOutbound.clear();
+            sessions.clear();
+        },
+    };
+}

package/dist/senses/pipeline.js

@@ -73,6 +73,7 @@ const orientation_frame_1 = require("../heart/orientation-frame");
 const flight_recorder_1 = require("../arc/flight-recorder");
 const context_loss_sentinel_1 = require("../heart/context-loss-sentinel");
 const cares_1 = require("../arc/cares");
+const turn_execution_lease_1 = require("../heart/turn-execution-lease");
 const VOICE_PENDING_MAX_AGE_MS = 15 * 60 * 1_000;
 const TELEGRAM_GENERIC_OUTREACH_PENDING_MAX_AGE_MS = 15 * 60 * 1_000;
 function pendingExpirationReason(channel, message, now, agentName) {
@@ -497,6 +498,9 @@ function prepareInboundRunLedger(input) {
     }
 }
 async function handleInboundTurn(input) {
+    return (0, turn_execution_lease_1.withTurnExecutionLease)(() => handleInboundTurnExclusive(input));
+}
+async function handleInboundTurnExclusive(input) {
     // Continuity resumption is structured caller intent. Never infer it from the
     // current message or from similarity to prior obligations.
     const resumePriorWork = input.runAgentOptions?.resumePriorWork === true;
@@ -769,6 +773,7 @@ async function handleInboundTurn(input) {
             currentSession,
             channel: input.channel,
             friendStore: input.friendStore,
+            includeAmbientBackgroundDiscovery: !liveLatencyMode,
         });
         // Propagate sync failure from pre-turn pull
         ctx.syncFailure = syncFailure;