@ouro.bot/cli 0.1.0-alpha.804 → 0.1.0-alpha.806

package/dist/senses/shared-turn.js

@@ -60,11 +60,16 @@ const pipeline_1 = require("./pipeline");
 const mcp_manager_1 = require("../repertoire/mcp-manager");
 const runtime_1 = require("../nerves/runtime");
 const session_transaction_1 = require("../mind/session-transaction");
+const turn_execution_lease_1 = require("../heart/turn-execution-lease");
 const RESPONSE_CAP = 50_000;
 const OUTWARD_DELIVERY_TOOL_ACKS = new Map([
     ["settle", "(delivered)"],
     ["speak", "(spoken)"],
 ]);
+async function releaseRuntimeMcpServersAfterTurn() {
+    const manager = await Promise.resolve().then(() => __importStar(require("../repertoire/mcp-manager")));
+    await manager.releaseRuntimeMcpServers();
+}
 /**
  * Strip MiniMax-style `<think>...</think>` reasoning blocks from a response
  * string. Handles unclosed open tags (treats everything from `<think>` to
@@ -315,6 +320,19 @@ function getSenseSessionPath(agentName, friendId, channel, sessionKey, agentRoot
  * this function handles all pipeline wiring.
  */
 async function runSenseTurn(options) {
+    return (0, turn_execution_lease_1.withTurnExecutionLease)(async () => {
+        (0, identity_1.setAgentName)(options.agentName);
+        try {
+            return await runSenseTurnExclusive(options);
+        }
+        finally {
+            if (options.runtimeMcpServers && !options.disableTools) {
+                await releaseRuntimeMcpServersAfterTurn();
+            }
+        }
+    });
+}
+async function runSenseTurnExclusive(options) {
     const { agentName, channel, sessionKey, friendId, userMessage } = options;
     (0, runtime_1.emitNervesEvent)({
         component: "senses",
@@ -364,279 +382,373 @@ async function runSenseTurn(options) {
     const resolver = new friends_1.FriendResolver(friendStore, resolverParams);
     // Initialize MCP manager so MCP tools appear as first-class tools in the agent's tool list.
     // Runtime MCP servers (e.g. Workbench's ouro_workbench) are passed per-turn for THIS agent only.
-    const mcpManager = await (0, mcp_manager_1.getSharedMcpManager)(options.runtimeMcpServers ? { runtimeServers: options.runtimeMcpServers } : undefined) ?? undefined;
+    const mcpManager = options.disableTools
+        ? undefined
+        : await (0, mcp_manager_1.getSharedMcpManager)(options.runtimeMcpServers ? { runtimeServers: options.runtimeMcpServers } : undefined) ?? undefined;
     // Session path and loading
-    const sessionDir = path.join(agentRoot, "state", "sessions", friendId, channel);
+    const ephemeralRoot = options.disablePersistence
+        ? fs.mkdtempSync(path.join(os.tmpdir(), "ouro-observe-only-"))
+        : null;
+    const sessionDir = ephemeralRoot ?? path.join(agentRoot, "state", "sessions", friendId, channel);
     fs.mkdirSync(sessionDir, { recursive: true });
-    const sessPath = getSenseSessionPath(agentName, friendId, channel, sessionKey, agentRoot);
+    const sessPath = ephemeralRoot
+        ? path.join(ephemeralRoot, "session.json")
+        : getSenseSessionPath(agentName, friendId, channel, sessionKey, agentRoot);
+    const reportedSessionPath = ephemeralRoot ? undefined : sessPath;
     const runWithLease = options._withSessionTurnLease ?? session_transaction_1.withSessionTurnLease;
-    return runWithLease(sessPath, async (sessionTurnLease) => {
-        const baseSessionRevision = (0, session_transaction_1.readSessionTransaction)(sessPath, sessionTurnLease).revision;
-        const existing = (0, context_1.loadSession)(sessPath);
-        const precommittedIngressEvent = options.precommittedIngress
-            ? existing?.events?.find((candidate) => candidate.id === options.precommittedIngress.eventId)
-            : undefined;
-        if (options.precommittedIngress) {
-            const latestUserEvent = existing?.events?.filter((candidate) => candidate.role === "user").at(-1);
-            if (!precommittedIngressEvent || precommittedIngressEvent !== latestUserEvent || precommittedIngressEvent.role !== "user" || precommittedIngressEvent.content !== userMessage
-                || !precommittedIngressEvent.relations.references.includes(options.precommittedIngress.reference)) {
-                throw new Error("shared turn precommitted ingress is missing, mismatched, or no longer current");
+    try {
+        return await runWithLease(sessPath, async (sessionTurnLease) => {
+            const baseSessionRevision = (0, session_transaction_1.readSessionTransaction)(sessPath, sessionTurnLease).revision;
+            const existing = options.disablePersistence ? undefined : (0, context_1.loadSession)(sessPath);
+            const precommittedIngressEvent = options.precommittedIngress
+                ? existing?.events?.find((candidate) => candidate.id === options.precommittedIngress.eventId)
+                : undefined;
+            if (options.precommittedIngress) {
+                const latestUserEvent = existing?.events?.filter((candidate) => candidate.role === "user").at(-1);
+                if (!precommittedIngressEvent || precommittedIngressEvent !== latestUserEvent || precommittedIngressEvent.role !== "user" || precommittedIngressEvent.content !== userMessage
+                    || !precommittedIngressEvent.relations.references.includes(options.precommittedIngress.reference)) {
+                    throw new Error("shared turn precommitted ingress is missing, mismatched, or no longer current");
+                }
             }
-        }
-        const existingEventIds = new Set(existing?.events?.map((event) => event.id) ?? []);
-        let sessionState = existing?.state;
-        let persistPromise;
-        const sessionMessages = existing?.messages && existing.messages.length > 0
-            ? existing.messages
-            : [{ role: "system", content: (0, prompt_1.flattenSystemPrompt)(await (0, prompt_1.buildSystem)(channel, {}, undefined)) }];
-        if (precommittedIngressEvent) {
-            const projectedIngress = exactProjectedIngressMessage(existing, sessionMessages, precommittedIngressEvent.id);
-            if (!projectedIngress || projectedIngress.role !== "user" || projectedIngress.content !== userMessage)
-                throw new Error("shared turn precommitted ingress is absent from the provider projection");
-            (0, session_events_1.stampIngressRelations)(projectedIngress, {
-                replyToEventId: precommittedIngressEvent.relations.replyToEventId,
-                threadRootEventId: precommittedIngressEvent.relations.threadRootEventId,
-                references: precommittedIngressEvent.relations.references,
+            const existingEventIds = new Set(existing?.events?.map((event) => event.id) ?? []);
+            const existingStructuredOutputIds = new Set(existing?.structuredOutputs?.map((output) => output.id) ?? []);
+            let sessionState = existing?.state;
+            let persistPromise;
+            const sessionMessages = existing?.messages && existing.messages.length > 0
+                ? existing.messages
+                : [{
+                        role: "system",
+                        content: (0, prompt_1.flattenSystemPrompt)(await (0, prompt_1.buildSystem)(channel, options.disableTools ? { tools: [], hardDisableTools: true } : {}, undefined)),
+                    }];
+            if (precommittedIngressEvent) {
+                const projectedIngress = exactProjectedIngressMessage(existing, sessionMessages, precommittedIngressEvent.id);
+                if (!projectedIngress || projectedIngress.role !== "user" || projectedIngress.content !== userMessage)
+                    throw new Error("shared turn precommitted ingress is absent from the provider projection");
+                (0, session_events_1.stampIngressRelations)(projectedIngress, {
+                    replyToEventId: precommittedIngressEvent.relations.replyToEventId,
+                    threadRootEventId: precommittedIngressEvent.relations.threadRootEventId,
+                    references: precommittedIngressEvent.relations.references,
+                });
+            }
+            // Pending dir
+            const pendingDir = (0, pending_1.getPendingDir)(agentName, friendId, channel, sessionKey);
+            // Accumulate outward text through the same callback boundary used by chat
+            // channels. `speak` flushes pending text immediately; `settle` is delivered
+            // once the turn completes.
+            let committedResponseText = "";
+            let pendingResponseText = "";
+            let terminalDeliveryKind = "text";
+            const deliveries = [];
+            const deliveryFailures = [];
+            const deliveryAttempts = [];
+            let providerInvocationCount = 0;
+            let toolInvocationCount = 0;
+            let hadReasoningChunk = false;
+            const commitResponseText = (text) => {
+                const cleaned = stripThinkBlocks(text);
+                /* v8 ignore next -- deliverPending strips first; this is a defensive direct-call guard @preserve */
+                if (!cleaned)
+                    return;
+                committedResponseText = committedResponseText
+                    ? `${committedResponseText}\n${cleaned}`
+                    : cleaned;
+            };
+            const deliveryErrorMessage = (error) => error instanceof Error ? error.message : String(error);
+            const emitFrontendEvent = (event) => {
+                options.frontendEventSink?.onEvent(event);
+            };
+            const deliverPending = async (kind, optionsForDelivery) => {
+                const text = stripThinkBlocks(pendingResponseText);
+                pendingResponseText = "";
+                if (!text)
+                    return undefined;
+                const delivery = { kind, text };
+                const attempt = { kind, text, delivered: false };
+                const attemptIndex = deliveryAttempts.length;
+                deliveryAttempts.push(attempt);
+                try {
+                    await options.deliverySink?.onDelivery(delivery);
+                    attempt.delivered = true;
+                    deliveries.push(delivery);
+                    commitResponseText(text);
+                    emitFrontendEvent({ type: "assistant_delivery", data: { kind, text } });
+                }
+                catch (error) {
+                    const failure = { ...delivery, error: deliveryErrorMessage(error) };
+                    deliveryFailures.push(failure);
+                    (0, runtime_1.emitNervesEvent)({
+                        level: "error",
+                        component: "senses",
+                        event: "senses.shared_turn_delivery_error",
+                        message: "shared turn outward delivery failed",
+                        meta: { agentName, channel, sessionKey, friendId, kind, error: failure.error, textLength: text.length },
+                    });
+                    if (optionsForDelivery.throwOnError)
+                        throw error;
+                    commitResponseText(text);
+                }
+                return attemptIndex;
+            };
+            /* v8 ignore start — callback stubs are exercised through the pipeline integration */
+            const callbacks = {
+                settleOutputMode: "retractable_buffer",
+                onModelStart: () => {
+                    providerInvocationCount += 1;
+                    if (options.turnMetricsObserver)
+                        options.turnMetricsObserver.providerInvocationCount += 1;
+                    emitFrontendEvent({ type: "model_started", data: {} });
+                },
+                onModelStreamStart: () => emitFrontendEvent({ type: "model_stream_started", data: {} }),
+                onTextChunk: (chunk) => {
+                    pendingResponseText += chunk;
+                    emitFrontendEvent({ type: "text_delta", data: { text: chunk } });
+                },
+                onReasoningChunk: (chunk) => {
+                    hadReasoningChunk = true;
+                    emitFrontendEvent({ type: "reasoning_delta", data: { text: chunk } });
+                },
+                onToolStart: (name, args) => {
+                    toolInvocationCount += 1;
+                    if (options.turnMetricsObserver)
+                        options.turnMetricsObserver.toolInvocationCount += 1;
+                    emitFrontendEvent({ type: "tool_started", data: { name, args } });
+                },
+                onToolEnd: (name, _summary, success) => {
+                    if (name === "settle" && success)
+                        terminalDeliveryKind = "settle";
+                    emitFrontendEvent({ type: "tool_completed", data: { name, summary: _summary, success } });
+                },
+                onError: (error, severity) => {
+                    emitFrontendEvent({ type: "error", data: { message: error.message, severity } });
+                },
+                onClearText: () => {
+                    pendingResponseText = "";
+                    emitFrontendEvent({ type: "text_cleared", data: {} });
+                },
+                flushNow: async () => { await deliverPending("speak", { throwOnError: true }); },
+            };
+            /* v8 ignore stop */
+            // Run the pipeline
+            const inboundMessages = [];
+            if (!options.precommittedIngress) {
+                const userMsg = { role: "user", content: userMessage };
+                (0, session_events_1.stampIngressTime)(userMsg);
+                if (options.ingressRelations)
+                    (0, session_events_1.stampIngressRelations)(userMsg, options.ingressRelations);
+                inboundMessages.push(userMsg);
+            }
+            const turnResult = await (0, pipeline_1.handleInboundTurn)({
+                channel,
+                latencyMode: options.latencyMode,
+                sessionKey,
+                capabilities,
+                messages: inboundMessages,
+                callbacks,
+                sessionTurnLease,
+                /* v8 ignore start — delegation wrappers; pipeline integration tested separately */
+                friendResolver: { resolve: () => resolver.resolve() },
+                sessionLoader: {
+                    loadOrCreate: () => Promise.resolve({
+                        messages: sessionMessages,
+                        sessionPath: sessPath,
+                        state: sessionState,
+                        events: existing?.events,
+                        structuredOutputs: existing?.structuredOutputs,
+                    }),
+                },
+                /* v8 ignore stop */
+                pendingDir,
+                friendStore,
+                signal: options.signal,
+                provider: resolverParams.provider,
+                externalId: resolverParams.externalId,
+                tenantId: resolverParams.tenantId,
+                enforceTrustGate: trust_gate_1.enforceTrustGate,
+                drainPending: options.disablePersistence ? () => [] : pending_1.drainPending,
+                runAgentOptions: {
+                    mcpManager,
+                    ...(options.disableTools ? { tools: [], hardDisableTools: true } : {}),
+                    ...(options.approvalCoordinatorFactory && !options.disablePersistence ? { approvalCoordinator: options.approvalCoordinatorFactory({ sessionPath: sessPath, baseSessionRevision }) } : {}),
+                    ...(options.latencyMode === "live" ? { skipKeptNotes: true } : {}),
+                    ...(options.orientationFrame ? { orientationFrame: options.orientationFrame } : {}),
+                    toolContext: {
+                        signin: async () => undefined,
+                        ...(options.toolContext ? options.toolContext : {}),
+                        currentUserMessage: userMessage,
+                    },
+                },
+                ...(options.prepareRunAgentOptions ? { prepareRunAgentOptions: options.prepareRunAgentOptions } : {}),
+                /* v8 ignore start — delegation wrappers; these just forward to the real functions */
+                runAgent: (msgs, cb, ch, sig, opts) => (0, core_1.runAgent)(msgs, cb, ch, sig, opts),
+                postTurn: (turnMessages, sessionPathArg, usage, hooks, state) => {
+                    const prepared = (0, context_2.postTurnTrim)(turnMessages, usage, hooks);
+                    sessionState = state;
+                    if (options.disablePersistence)
+                        return;
+                    persistPromise = (0, context_2.deferPostTurnPersist)(sessionPathArg, prepared, usage, state);
+                },
+                /* v8 ignore stop */
+                accumulateFriendTokens: options.disablePersistence ? async () => undefined : friends_1.accumulateFriendTokens,
             });
-        }
-        // Pending dir
-        const pendingDir = (0, pending_1.getPendingDir)(agentName, friendId, channel, sessionKey);
-        // Accumulate outward text through the same callback boundary used by chat
-        // channels. `speak` flushes pending text immediately; `settle` is delivered
-        // once the turn completes.
-        let committedResponseText = "";
-        let pendingResponseText = "";
-        let terminalDeliveryKind = "text";
-        const deliveries = [];
-        const deliveryFailures = [];
-        const deliveryAttempts = [];
-        let providerInvocationCount = 0;
-        let toolInvocationCount = 0;
-        let hadReasoningChunk = false;
-        const commitResponseText = (text) => {
-            const cleaned = stripThinkBlocks(text);
-            /* v8 ignore next -- deliverPending strips first; this is a defensive direct-call guard @preserve */
-            if (!cleaned)
-                return;
-            committedResponseText = committedResponseText
-                ? `${committedResponseText}\n${cleaned}`
-                : cleaned;
-        };
-        const deliveryErrorMessage = (error) => error instanceof Error ? error.message : String(error);
-        const deliverPending = async (kind, optionsForDelivery) => {
-            const text = stripThinkBlocks(pendingResponseText);
-            pendingResponseText = "";
-            if (!text)
-                return undefined;
-            const delivery = { kind, text };
-            const attempt = { kind, text, delivered: false };
-            const attemptIndex = deliveryAttempts.length;
-            deliveryAttempts.push(attempt);
-            try {
-                await options.deliverySink?.onDelivery(delivery);
-                attempt.delivered = true;
-                deliveries.push(delivery);
-                commitResponseText(text);
+            if (turnResult.gateResult && !turnResult.gateResult.allowed) {
+                const blockedResponse = "autoReply" in turnResult.gateResult
+                    ? turnResult.gateResult.autoReply
+                    : `(blocked by trust gate: ${turnResult.gateResult.reason})`;
+                return {
+                    response: blockedResponse,
+                    ponderDeferred: false,
+                    deliveries,
+                    deliveryFailures,
+                    providerInvocationCount,
+                    toolInvocationCount,
+                    sessionPath: reportedSessionPath,
+                    turnOutcome: turnResult.turnOutcome ?? "blocked",
+                };
+            }
+            if (turnResult.turnOutcome === "aborted") {
+                pendingResponseText = "";
+                if (persistPromise)
+                    await persistPromise;
+                return {
+                    response: "",
+                    ponderDeferred: false,
+                    deliveries,
+                    deliveryFailures,
+                    providerInvocationCount,
+                    toolInvocationCount,
+                    sessionPath: reportedSessionPath,
+                    turnOutcome: "aborted",
+                };
+            }
+            if (turnResult.turnOutcome === "suspended") {
+                if (!turnResult.suspension)
+                    throw new Error("suspended shared turn omitted durable approval suspension");
+                pendingResponseText = "";
+                return {
+                    response: "",
+                    ponderDeferred: false,
+                    deliveries,
+                    deliveryFailures,
+                    providerInvocationCount,
+                    toolInvocationCount,
+                    sessionPath: reportedSessionPath,
+                    turnOutcome: "suspended",
+                    suspension: turnResult.suspension,
+                };
+            }
+            const persistedEvents = persistPromise ? await persistPromise : [];
+            const terminalEvents = persistedEvents.length > 0
+                ? persistedEvents
+                : rawSessionEvents((0, session_transaction_1.readSessionTransaction)(sessPath, sessionTurnLease).value);
+            const eventView = currentTurnEventView(terminalEvents, existingEventIds, userMessage, options.precommittedIngress, options.ingressRelations);
+            let finalDeliveryKind = terminalDeliveryKind;
+            const acceptedTerminalOutcome = turnResult.turnOutcome === "settled" || turnResult.turnOutcome === "blocked";
+            const failoverText = turnResult.turnOutcome === "errored" ? turnResult.failoverMessage?.trim() : undefined;
+            const expectsOutwardResponse = acceptedTerminalOutcome || turnResult.turnOutcome === "command" || Boolean(failoverText);
+            let finalCausalCoordinate;
+            if (acceptedTerminalOutcome) {
+                const completionText = stripThinkBlocks(turnResult.completion?.answer ?? "");
+                let authoritativeText = completionText;
+                if (!authoritativeText && eventView?.terminal) {
+                    authoritativeText = eventView.terminal.text;
+                    finalDeliveryKind = eventView.terminal.kind;
+                }
+                if (eventView?.terminal?.kind === finalDeliveryKind && eventView.terminal.text === authoritativeText)
+                    finalCausalCoordinate = eventView.terminal;
+                const terminalAlreadyDelivered = finalCausalCoordinate
+                    ? alignedDeliveryCoordinates(eventView, deliveryAttempts).includes(finalCausalCoordinate)
+                    : false;
+                pendingResponseText = authoritativeText && !terminalAlreadyDelivered ? authoritativeText : "";
+            }
+            else if (turnResult.turnOutcome === "command") {
+                // Slash-command text is emitted directly by the pipeline and has no assistant event.
+            }
+            else if (failoverText) {
+                pendingResponseText = failoverText;
+            }
+            else {
+                pendingResponseText = "";
+            }
+            if (persistPromise && options.frontendEventSink && !options.disablePersistence) {
+                const currentStructuredOutputs = (0, context_1.loadSession)(sessPath)?.structuredOutputs ?? [];
+                for (const output of currentStructuredOutputs) {
+                    if (!existingStructuredOutputIds.has(output.id)) {
+                        emitFrontendEvent({ type: "structured_output", data: { output } });
+                    }
+                }
             }
-            catch (error) {
-                const failure = { ...delivery, error: deliveryErrorMessage(error) };
-                deliveryFailures.push(failure);
+            const finalDeliveryAttemptIndex = await deliverPending(finalDeliveryKind, { throwOnError: false });
+            const ponderDeferred = false;
+            // Build response
+            let finalResponse;
+            const finalDeliveryAttempt = finalDeliveryAttemptIndex === undefined ? undefined : deliveryAttempts[finalDeliveryAttemptIndex];
+            const responseDeliveryFailure = finalDeliveryAttempt && !finalDeliveryAttempt.delivered ? deliveryFailures.at(-1) : undefined;
+            const responseCausalSessionEventId = finalDeliveryAttempt && !finalDeliveryAttempt.delivered ? finalCausalCoordinate?.eventId : undefined;
+            if (committedResponseText.length === 0) {
+                if (!expectsOutwardResponse) {
+                    finalResponse = "";
+                }
+                else {
+                    const emptyFallback = options.emptyResponseFallback?.();
+                    finalResponse = emptyFallback ?? (hadReasoningChunk ? "" : "(agent responded but response was empty)");
+                }
+            }
+            else {
+                finalResponse = committedResponseText;
+            }
+            // Strip MiniMax-style <think>...</think> blocks from the final response.
+            // When a reasoning-style model emits only a think block and no final answer
+            // (no settle tool call, no post-think text), the readback path above
+            // surfaces the raw saved assistant content — which includes the think tags
+            // and renders as empty (or as raw reasoning) on MCP/CLI clients. Strip
+            // here so the caller sees the actual delivered text. If only reasoning
+            // came through and nothing else, surface a clear diagnostic message
+            // instead of a blank response so the operator knows what happened.
+            finalResponse = stripThinkBlocks(finalResponse);
+            if (finalResponse.length === 0 && expectsOutwardResponse) {
                 (0, runtime_1.emitNervesEvent)({
-                    level: "error",
+                    level: "warn",
                     component: "senses",
-                    event: "senses.shared_turn_delivery_error",
-                    message: "shared turn outward delivery failed",
-                    meta: { agentName, channel, sessionKey, friendId, kind, error: failure.error, textLength: text.length },
+                    event: "senses.shared_turn_only_reasoning",
+                    message: "agent produced only <think> reasoning with no final answer — likely a model that closed the think tag without continuing",
+                    meta: { agentName, channel, sessionKey, friendId },
                 });
-                if (optionsForDelivery.throwOnError)
-                    throw error;
-                commitResponseText(text);
+                finalResponse = "(agent produced reasoning but no final answer this turn — try again, or check the session transcript for the trace)";
             }
-            return attemptIndex;
-        };
-        /* v8 ignore start — callback stubs are exercised through the pipeline integration */
-        const callbacks = {
-            settleOutputMode: "retractable_buffer",
-            onModelStart: () => { providerInvocationCount += 1; if (options.turnMetricsObserver)
-                options.turnMetricsObserver.providerInvocationCount += 1; },
-            onModelStreamStart: () => { },
-            onTextChunk: (chunk) => { pendingResponseText += chunk; },
-            onReasoningChunk: () => { hadReasoningChunk = true; },
-            onToolStart: () => { toolInvocationCount += 1; if (options.turnMetricsObserver)
-                options.turnMetricsObserver.toolInvocationCount += 1; },
-            onToolEnd: (name, _summary, success) => {
-                if (name === "settle" && success)
-                    terminalDeliveryKind = "settle";
-            },
-            onError: () => { },
-            onClearText: () => { pendingResponseText = ""; },
-            flushNow: async () => { await deliverPending("speak", { throwOnError: true }); },
-        };
-        /* v8 ignore stop */
-        // Run the pipeline
-        const inboundMessages = [];
-        if (!options.precommittedIngress) {
-            const userMsg = { role: "user", content: userMessage };
-            (0, session_events_1.stampIngressTime)(userMsg);
-            if (options.ingressRelations)
-                (0, session_events_1.stampIngressRelations)(userMsg, options.ingressRelations);
-            inboundMessages.push(userMsg);
-        }
-        const turnResult = await (0, pipeline_1.handleInboundTurn)({
-            channel,
-            latencyMode: options.latencyMode,
-            sessionKey,
-            capabilities,
-            messages: inboundMessages,
-            callbacks,
-            sessionTurnLease,
-            /* v8 ignore start — delegation wrappers; pipeline integration tested separately */
-            friendResolver: { resolve: () => resolver.resolve() },
-            sessionLoader: {
-                loadOrCreate: () => Promise.resolve({
-                    messages: sessionMessages,
-                    sessionPath: sessPath,
-                    state: sessionState,
-                    events: existing?.events,
-                    structuredOutputs: existing?.structuredOutputs,
-                }),
-            },
-            /* v8 ignore stop */
-            pendingDir,
-            friendStore,
-            provider: resolverParams.provider,
-            externalId: resolverParams.externalId,
-            tenantId: resolverParams.tenantId,
-            enforceTrustGate: trust_gate_1.enforceTrustGate,
-            drainPending: pending_1.drainPending,
-            runAgentOptions: {
-                mcpManager,
-                ...(options.approvalCoordinatorFactory ? { approvalCoordinator: options.approvalCoordinatorFactory({ sessionPath: sessPath, baseSessionRevision }) } : {}),
-                ...(options.latencyMode === "live" ? { skipKeptNotes: true } : {}),
-                ...(options.orientationFrame ? { orientationFrame: options.orientationFrame } : {}),
-                toolContext: {
-                    signin: async () => undefined,
-                    ...(options.toolContext ? options.toolContext : {}),
-                    currentUserMessage: userMessage,
-                },
-            },
-            ...(options.prepareRunAgentOptions ? { prepareRunAgentOptions: options.prepareRunAgentOptions } : {}),
-            /* v8 ignore start — delegation wrappers; these just forward to the real functions */
-            runAgent: (msgs, cb, ch, sig, opts) => (0, core_1.runAgent)(msgs, cb, ch, sig, opts),
-            postTurn: (turnMessages, sessionPathArg, usage, hooks, state) => {
-                const prepared = (0, context_2.postTurnTrim)(turnMessages, usage, hooks);
-                sessionState = state;
-                persistPromise = (0, context_2.deferPostTurnPersist)(sessionPathArg, prepared, usage, state);
-            },
-            /* v8 ignore stop */
-            accumulateFriendTokens: friends_1.accumulateFriendTokens,
-        });
-        if (turnResult.gateResult && !turnResult.gateResult.allowed) {
-            const blockedResponse = "autoReply" in turnResult.gateResult
-                ? turnResult.gateResult.autoReply
-                : `(blocked by trust gate: ${turnResult.gateResult.reason})`;
+            // Cap response length
+            if (finalResponse.length > RESPONSE_CAP) {
+                finalResponse = finalResponse.slice(0, RESPONSE_CAP) + "\n\n[truncated — response exceeded 50K characters]";
+            }
+            (0, runtime_1.emitNervesEvent)({
+                component: "senses",
+                event: "senses.shared_turn_end",
+                message: "shared turn runner complete",
+                meta: { agentName, channel, sessionKey, friendId, ponderDeferred, responseLength: finalResponse.length },
+            });
             return {
-                response: blockedResponse,
-                ponderDeferred: false,
+                response: finalResponse,
+                ponderDeferred,
                 deliveries,
                 deliveryFailures,
+                ...(responseDeliveryFailure ? { responseDeliveryFailure } : {}),
                 providerInvocationCount,
                 toolInvocationCount,
-                sessionPath: sessPath,
+                sessionPath: reportedSessionPath,
+                turnOutcome: turnResult.turnOutcome,
+                ...(deliveries.length > 0 ? { causalSessionEventIds: causalSessionEventIds(eventView, deliveryAttempts, finalDeliveryAttemptIndex, finalCausalCoordinate) } : {}),
+                ...(responseCausalSessionEventId ? { responseCausalSessionEventId } : {}),
             };
-        }
-        const persistedEvents = persistPromise ? await persistPromise : [];
-        const terminalEvents = persistedEvents.length > 0
-            ? persistedEvents
-            : rawSessionEvents((0, session_transaction_1.readSessionTransaction)(sessPath, sessionTurnLease).value);
-        const eventView = currentTurnEventView(terminalEvents, existingEventIds, userMessage, options.precommittedIngress, options.ingressRelations);
-        let finalDeliveryKind = terminalDeliveryKind;
-        const acceptedTerminalOutcome = turnResult.turnOutcome === "settled" || turnResult.turnOutcome === "blocked";
-        const failoverText = turnResult.turnOutcome === "errored" ? turnResult.failoverMessage?.trim() : undefined;
-        const expectsOutwardResponse = acceptedTerminalOutcome || turnResult.turnOutcome === "command" || Boolean(failoverText);
-        let finalCausalCoordinate;
-        if (acceptedTerminalOutcome) {
-            const completionText = stripThinkBlocks(turnResult.completion?.answer ?? "");
-            let authoritativeText = completionText;
-            if (!authoritativeText && eventView?.terminal) {
-                authoritativeText = eventView.terminal.text;
-                finalDeliveryKind = eventView.terminal.kind;
-            }
-            if (eventView?.terminal?.kind === finalDeliveryKind && eventView.terminal.text === authoritativeText)
-                finalCausalCoordinate = eventView.terminal;
-            const terminalAlreadyDelivered = finalCausalCoordinate
-                ? alignedDeliveryCoordinates(eventView, deliveryAttempts).includes(finalCausalCoordinate)
-                : false;
-            pendingResponseText = authoritativeText && !terminalAlreadyDelivered ? authoritativeText : "";
-        }
-        else if (turnResult.turnOutcome === "command") {
-            // Slash-command text is emitted directly by the pipeline and has no assistant event.
-        }
-        else if (failoverText) {
-            pendingResponseText = failoverText;
-        }
-        else {
-            pendingResponseText = "";
-        }
-        const finalDeliveryAttemptIndex = await deliverPending(finalDeliveryKind, { throwOnError: false });
-        const ponderDeferred = false;
-        // Build response
-        let finalResponse;
-        const finalDeliveryAttempt = finalDeliveryAttemptIndex === undefined ? undefined : deliveryAttempts[finalDeliveryAttemptIndex];
-        const responseDeliveryFailure = finalDeliveryAttempt && !finalDeliveryAttempt.delivered ? deliveryFailures.at(-1) : undefined;
-        const responseCausalSessionEventId = finalDeliveryAttempt && !finalDeliveryAttempt.delivered ? finalCausalCoordinate?.eventId : undefined;
-        if (committedResponseText.length === 0) {
-            if (!expectsOutwardResponse) {
-                finalResponse = "";
-            }
-            else {
-                const emptyFallback = options.emptyResponseFallback?.();
-                finalResponse = emptyFallback ?? (hadReasoningChunk ? "" : "(agent responded but response was empty)");
+        });
+    }
+    finally {
+        if (ephemeralRoot) {
+            for (const entry of fs.readdirSync(ephemeralRoot, { withFileTypes: true })) {
+                if (!entry.isFile() && !entry.isSymbolicLink()) {
+                    throw new Error(`observe-only session cleanup found unexpected entry: ${entry.name}`);
+                }
+                fs.unlinkSync(path.join(ephemeralRoot, entry.name));
             }
+            fs.rmdirSync(ephemeralRoot);
         }
-        else {
-            finalResponse = committedResponseText;
-        }
-        // Strip MiniMax-style <think>...</think> blocks from the final response.
-        // When a reasoning-style model emits only a think block and no final answer
-        // (no settle tool call, no post-think text), the readback path above
-        // surfaces the raw saved assistant content — which includes the think tags
-        // and renders as empty (or as raw reasoning) on MCP/CLI clients. Strip
-        // here so the caller sees the actual delivered text. If only reasoning
-        // came through and nothing else, surface a clear diagnostic message
-        // instead of a blank response so the operator knows what happened.
-        finalResponse = stripThinkBlocks(finalResponse);
-        if (finalResponse.length === 0 && expectsOutwardResponse) {
-            (0, runtime_1.emitNervesEvent)({
-                level: "warn",
-                component: "senses",
-                event: "senses.shared_turn_only_reasoning",
-                message: "agent produced only <think> reasoning with no final answer — likely a model that closed the think tag without continuing",
-                meta: { agentName, channel, sessionKey, friendId },
-            });
-            finalResponse = "(agent produced reasoning but no final answer this turn — try again, or check the session transcript for the trace)";
-        }
-        // Cap response length
-        if (finalResponse.length > RESPONSE_CAP) {
-            finalResponse = finalResponse.slice(0, RESPONSE_CAP) + "\n\n[truncated — response exceeded 50K characters]";
-        }
-        (0, runtime_1.emitNervesEvent)({
-            component: "senses",
-            event: "senses.shared_turn_end",
-            message: "shared turn runner complete",
-            meta: { agentName, channel, sessionKey, friendId, ponderDeferred, responseLength: finalResponse.length },
-        });
-        return {
-            response: finalResponse,
-            ponderDeferred,
-            deliveries,
-            deliveryFailures,
-            ...(responseDeliveryFailure ? { responseDeliveryFailure } : {}),
-            providerInvocationCount,
-            toolInvocationCount,
-            sessionPath: sessPath,
-            ...(deliveries.length > 0 ? { causalSessionEventIds: causalSessionEventIds(eventView, deliveryAttempts, finalDeliveryAttemptIndex, finalCausalCoordinate) } : {}),
-            ...(responseCausalSessionEventId ? { responseCausalSessionEventId } : {}),
-        };
-    });
+    }
 }