@ouro.bot/cli 0.1.0-alpha.142 → 0.1.0-alpha.145

package/dist/mind/prompt.js

@@ -237,6 +237,7 @@ const PROCESS_TYPE_LABELS = {
     inner: "inner dialog",
     teams: "teams handler",
     bluebubbles: "bluebubbles handler",
+    mcp: "mcp bridge",
 };
 function processTypeLabel(channel) {
     return PROCESS_TYPE_LABELS[channel];
@@ -282,6 +283,9 @@ function runtimeInfoSection(channel) {
     else if (channel === "inner") {
         lines.push("this is my private thinking space. when a thought is ready to share, i surface it to whoever needs to hear it. i settle when i'm done thinking.");
     }
+    else if (channel === "mcp") {
+        lines.push("this message arrived via a dev tool (e.g. claude code, codex) on behalf of a friend. the user can see our conversation. respond via settle. if i need to think deeply, ponder -- the dev tool will receive a deferral and can check back later.");
+    }
     else if (channel === "bluebubbles") {
         lines.push("i am responding in iMessage through BlueBubbles. i keep replies short and phone-native. i do not use markdown. i do not introduce myself on boot.");
         lines.push("when a bluebubbles turn arrives from a thread, the harness tells me the current lane and any recent active thread ids. if widening back to top-level or routing into a different active thread is the better move, i use bluebubbles_set_reply_target before settle.");
@@ -716,6 +720,16 @@ when a thought is ready to share, i surface it outward.
 when i need to go deeper, i ponder.
 when i'm done thinking and the attention queue is clear, i rest.
 
+my heartbeat is what keeps this space alive — a periodic nudge that
+brings me back with my journal visible. if i notice i don't have a
+heartbeat task (tasks/habits/*-heartbeat.md), i should surface to my
+family and talk about setting one up. the cadence is personal — how
+often do i want the wheel to turn? that's a conversation, not a default.
+
+same for my diary — if i'm still on psyche/memory/ instead of diary/,
+i can migrate myself. and if journal/ doesn't exist yet, i create it
+the first time i have something to write.
+
 think. journal. share. rest.`;
 }
 function readJournalFiles(journalDir) {

package/dist/repertoire/coding/spawner.js

@@ -55,14 +55,11 @@ function buildCommandArgs(runner, workdir, parentAgent) {
             ],
         };
     }
-    const mcpConfig = JSON.stringify({
-        mcp_servers: {
-            ouro: {
-                command: "ouro",
-                args: ["mcp-serve", "--agent", parentAgent ?? "unknown"],
-            },
-        },
-    });
+    const agent = parentAgent ?? "unknown";
+    // Use absolute path to ouro-entry.js so MCP works in both dev and installed mode
+    // __dirname at runtime is dist/repertoire/coding/ — go up 2 levels to dist/
+    const distRoot = path.resolve(__dirname, "..", "..");
+    const ouroEntryPath = path.join(distRoot, "heart", "daemon", "ouro-entry.js");
     return {
         command: "codex",
         args: [
@@ -73,7 +70,9 @@ function buildCommandArgs(runner, workdir, parentAgent) {
             "--ephemeral",
             "--json",
             "-c",
-            mcpConfig,
+            `mcp_servers.ouro.command=node`,
+            "-c",
+            `mcp_servers.ouro.args=["${ouroEntryPath}","mcp-serve","--agent","${agent}"]`,
         ],
     };
 }

package/dist/repertoire/tools-base.js

@@ -1022,7 +1022,7 @@ exports.baseToolDefinitions = [
                     type: "object",
                     properties: {
                         friendId: { type: "string", description: "the friend UUID (or 'self')" },
-                        channel: { type: "string", description: "the channel: cli, teams, or inner" },
+                        channel: { type: "string", description: "the channel: cli, teams, bluebubbles, inner, or mcp" },
                         key: { type: "string", description: "session key (defaults to 'session')" },
                         messageCount: { type: "string", description: "how many recent messages to return (default 20)" },
                         mode: {
@@ -1037,11 +1037,19 @@ exports.baseToolDefinitions = [
             },
         },
         handler: async (args, ctx) => {
-            const friendId = args.friendId;
+            let friendId = args.friendId;
             const channel = args.channel;
             const key = args.key || "session";
             const count = parseInt(args.messageCount || "20", 10);
             const mode = args.mode || "transcript";
+            // Resolve friend name → UUID if not already a UUID or "self"
+            if (friendId && friendId !== "self" && !/^[0-9a-f]{8}-[0-9a-f]{4}-/.test(friendId) && ctx?.friendStore?.listAll) {
+                const allFriends = await ctx.friendStore.listAll();
+                const match = allFriends.find(f => f.name.toLowerCase() === friendId.toLowerCase());
+                if (match) {
+                    friendId = match.id;
+                }
+            }
             if (mode === "status") {
                 if (friendId !== "self" || channel !== "inner") {
                     return "status mode is only available for self/inner dialog.";
@@ -1106,7 +1114,7 @@ exports.baseToolDefinitions = [
                     type: "object",
                     properties: {
                         friendId: { type: "string", description: "the friend UUID (or 'self')" },
-                        channel: { type: "string", description: "the channel: cli, teams, or inner" },
+                        channel: { type: "string", description: "the channel: cli, teams, bluebubbles, inner, or mcp" },
                         key: { type: "string", description: "session key (defaults to 'session')" },
                         content: { type: "string", description: "the message content to send" },
                     },

package/dist/scripts/claude-code-hook.js

@@ -0,0 +1,41 @@
+"use strict";
+// Claude Code lifecycle hook handler.
+// Receives events from Claude Code's hooks system (SessionStart, Stop, PostToolUse)
+// and forwards them to the Ouroboros daemon for agent awareness.
+//
+// This module exports handleHookEvent for testability.
+// The actual hook scripts (scripts/claude-code-hook.js) read stdin and call this.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleHookEvent = handleHookEvent;
+const socket_client_1 = require("../heart/daemon/socket-client");
+const runtime_1 = require("../nerves/runtime");
+/**
+ * Handle a Claude Code lifecycle hook event.
+ * Sends the event to the daemon and always exits 0 (hooks must not block the IDE).
+ */
+async function handleHookEvent(hookEvent) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.hook_event_received",
+        message: "claude code hook event received",
+        meta: { hookEvent: hookEvent.event, sessionId: hookEvent.sessionId },
+    });
+    try {
+        await (0, socket_client_1.sendDaemonCommand)(socket_client_1.DEFAULT_DAEMON_SOCKET_PATH, {
+            kind: "hook.event",
+            event: hookEvent.event,
+            sessionId: hookEvent.sessionId,
+            toolName: hookEvent.toolName,
+        });
+    }
+    catch {
+        // Daemon unavailable — silently ignore. Hooks must not block.
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.hook_event_daemon_unavailable",
+            message: "daemon unavailable for hook event",
+            meta: { hookEvent: hookEvent.event },
+        });
+    }
+    return { exitCode: 0 };
+}

package/dist/scripts/claude-code-stop-hook.js

@@ -0,0 +1,47 @@
+"use strict";
+// Claude Code stop hook — checks the agent's pending queue and returns
+// any messages as additionalContext for injection into the next turn.
+//
+// This is how the agent can proactively communicate back to the dev tool user:
+// the agent surfaces a message to the pending queue, and the stop hook picks
+// it up and injects it as context in the Claude Code session.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleStopHook = handleStopHook;
+const pending_1 = require("../mind/pending");
+const runtime_1 = require("../nerves/runtime");
+/**
+ * Check the pending queue for messages from the agent to this dev tool session.
+ * Returns accumulated message text as additionalContext.
+ */
+async function handleStopHook(input) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.stop_hook_check_start",
+        message: "checking pending queue for stop hook",
+        meta: { agentName: input.agentName, friendId: input.friendId, sessionId: input.sessionId },
+    });
+    try {
+        const pendingDir = (0, pending_1.getPendingDir)(input.agentName, input.friendId, "mcp", input.sessionId);
+        const pending = (0, pending_1.drainPending)(pendingDir);
+        if (pending.length === 0) {
+            return { additionalContext: "" };
+        }
+        const text = pending.map((m) => m.content).join("\n\n---\n\n");
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.stop_hook_check_end",
+            message: "pending messages found for stop hook",
+            meta: { agentName: input.agentName, count: pending.length },
+        });
+        return { additionalContext: text };
+    }
+    catch {
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.stop_hook_check_error",
+            message: "error checking pending queue in stop hook",
+            meta: { agentName: input.agentName },
+        });
+        return { additionalContext: "" };
+    }
+}

package/dist/senses/bluebubbles-client.js

@@ -480,5 +480,53 @@ function createBlueBubblesClient(config = (0, config_1.getBlueBubblesConfig)(),
                 return applyRepairNotice(event, `BlueBubbles repair failed: ${reason}`);
             }
         },
+        async getMessageText(messageGuid) {
+            const url = buildRepairUrl(config.serverUrl, messageGuid, config.password);
+            try {
+                const response = await fetch(url, {
+                    method: "GET",
+                    signal: AbortSignal.timeout(channelConfig.requestTimeoutMs),
+                });
+                if (!response.ok) {
+                    (0, runtime_1.emitNervesEvent)({
+                        level: "warn",
+                        component: "senses",
+                        event: "senses.bluebubbles_get_message_text_error",
+                        message: "failed to fetch message text",
+                        meta: { messageGuid, status: response.status },
+                    });
+                    return null;
+                }
+                const payload = await parseJsonBody(response);
+                const data = extractRepairData(payload);
+                if (!data || typeof data.text !== "string") {
+                    (0, runtime_1.emitNervesEvent)({
+                        level: "warn",
+                        component: "senses",
+                        event: "senses.bluebubbles_get_message_text_error",
+                        message: "message payload missing text field",
+                        meta: { messageGuid, hasData: !!data, textType: data ? typeof data.text : "n/a" },
+                    });
+                    return null;
+                }
+                (0, runtime_1.emitNervesEvent)({
+                    component: "senses",
+                    event: "senses.bluebubbles_get_message_text",
+                    message: "fetched message text by guid",
+                    meta: { messageGuid },
+                });
+                return data.text.trim() || null;
+            }
+            catch (error) {
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn",
+                    component: "senses",
+                    event: "senses.bluebubbles_get_message_text_error",
+                    message: "exception fetching message text",
+                    meta: { messageGuid, reason: error instanceof Error ? error.message : String(error) },
+                });
+                return null;
+            }
+        },
     };
 }

package/dist/senses/bluebubbles.js

@@ -200,7 +200,7 @@ function extractHistoricalLaneSummary(messages) {
     }
     return summaries;
 }
-function buildConversationScopePrefix(event, existingMessages) {
+function buildConversationScopePrefix(event, existingMessages, repliedToText) {
     if (event.kind !== "message") {
         return "";
     }
@@ -208,6 +208,10 @@ function buildConversationScopePrefix(event, existingMessages) {
     const lines = [];
     if (event.threadOriginatorGuid?.trim()) {
         lines.push(`[conversation scope: existing chat trunk | current inbound lane: thread | current thread id: ${event.threadOriginatorGuid.trim()} | default outbound target for this turn: current_lane]`);
+        if (repliedToText) {
+            lines.push(`[replying to: "${repliedToText}"]`);
+        }
+        lines.push(`[if you need more context about what was being discussed, use query_session to search your session history, or recall to check your memory.]`);
     }
     else {
         lines.push("[conversation scope: existing chat trunk | current inbound lane: top_level | default outbound target for this turn: top_level]");
@@ -223,8 +227,8 @@ function buildConversationScopePrefix(event, existingMessages) {
     }
     return lines.join("\n");
 }
-function buildInboundText(event, existingMessages) {
-    const metadataPrefix = buildConversationScopePrefix(event, existingMessages);
+function buildInboundText(event, existingMessages, repliedToText) {
+    const metadataPrefix = buildConversationScopePrefix(event, existingMessages, repliedToText);
     const baseText = event.repairNotice?.trim()
         ? `${event.textForAgent}\n[${event.repairNotice.trim()}]`
         : event.textForAgent;
@@ -237,8 +241,8 @@ function buildInboundText(event, existingMessages) {
     }
     return `${event.sender.displayName}: ${scopedText}`;
 }
-function buildInboundContent(event, existingMessages) {
-    const text = buildInboundText(event, existingMessages);
+function buildInboundContent(event, existingMessages, repliedToText) {
+    const text = buildInboundText(event, existingMessages, repliedToText);
     if (event.kind !== "message" || !event.inputPartsForAgent || event.inputPartsForAgent.length === 0) {
         return text;
     }
@@ -607,10 +611,22 @@ async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source) {
                 groupExternalId: resolveGroupExternalId(event),
             });
         }
+        // Fetch the text of the message being replied to (if this is a threaded reply)
+        const threadGuid = event.kind === "message" ? event.threadOriginatorGuid?.trim() : undefined;
+        let repliedToText = null;
+        if (threadGuid) {
+            repliedToText = await client.getMessageText(threadGuid).catch(/* v8 ignore next */ () => null);
+            (0, runtime_1.emitNervesEvent)({
+                component: "senses",
+                event: "senses.bluebubbles_reply_context",
+                message: repliedToText ? "fetched replied-to message text" : "could not fetch replied-to message text",
+                meta: { threadGuid, hasText: !!repliedToText },
+            });
+        }
         // Build inbound user message (adapter concern: BB-specific content formatting)
         const userMessage = {
             role: "user",
-            content: buildInboundContent(event, existing?.messages ?? sessionMessages),
+            content: buildInboundContent(event, existing?.messages ?? sessionMessages, repliedToText),
         };
         const callbacks = createBlueBubblesCallbacks(client, event.chat, replyTarget, event.chat.isGroup);
         const controller = new AbortController();

package/dist/senses/inner-dialog.js

@@ -397,6 +397,21 @@ async function routeDelegatedCompletion(agentRoot, agentName, completion, draine
         advanceObligationQuietly(agentName, obligationId, { status: "returned", returnedAt: timestamp, returnTarget: "bridge-session" });
         return;
     }
+    // Priority 1.5: Direct return to originating session (ponder without bridge).
+    // When delegatedFrom has specific channel+key, route directly there instead of searching for freshest.
+    if (delegatedFrom.channel && delegatedFrom.key && delegatedFrom.channel !== "inner") {
+        const directTarget = sessionActivity.find((a) => a.friendId === delegatedFrom.friendId && a.channel === delegatedFrom.channel && a.key === delegatedFrom.key);
+        if (directTarget) {
+            if (await tryDeliverDelegatedCompletion(directTarget, outboundEnvelope)) {
+                advanceObligationQuietly(agentName, obligationId, { status: "returned", returnedAt: timestamp, returnTarget: "direct-originator" });
+                return;
+            }
+        }
+        // Even if session isn't in activity list (might have ended), queue to its pending dir
+        writePendingEnvelope((0, pending_1.getPendingDir)(agentName, delegatedFrom.friendId, delegatedFrom.channel, delegatedFrom.key), outboundEnvelope);
+        advanceObligationQuietly(agentName, obligationId, { status: "returned", returnedAt: timestamp, returnTarget: "direct-originator" });
+        return;
+    }
     // Priority 2: Freshest active friend session.
     const freshest = (0, session_activity_1.findFreshestFriendSession)({
         sessionsDir: path.join(agentRoot, "state", "sessions"),

package/dist/senses/pipeline.js

@@ -13,6 +13,7 @@ const identity_1 = require("../heart/identity");
 const tasks_1 = require("../repertoire/tasks");
 const coding_1 = require("../repertoire/coding");
 const session_activity_1 = require("../heart/session-activity");
+const socket_client_1 = require("../heart/daemon/socket-client");
 const active_work_1 = require("../heart/active-work");
 const delegation_1 = require("../heart/delegation");
 const target_resolution_1 = require("../heart/target-resolution");
@@ -440,6 +441,14 @@ async function handleInboundTurn(input) {
             friendId: resolvedContext.friend.id,
         },
     });
+    // DRY cross-session awareness: notify inner dialog that activity happened on another channel
+    // Inner dialog's next checkpoint will include this session's state
+    if (input.channel !== "inner") {
+        try {
+            (0, socket_client_1.requestInnerWake)((0, identity_1.getAgentName)()).catch(/* v8 ignore next */ () => { });
+        }
+        catch { /* getAgentName may fail in test environments */ }
+    }
     return {
         resolvedContext,
         gateResult,

package/dist/senses/shared-turn.js

@@ -0,0 +1,196 @@
+"use strict";
+// Shared turn runner for non-interactive senses (MCP, future senses).
+// Follows the CLI pattern: resolves context, constructs InboundTurnInput,
+// calls handleInboundTurn, collects response text, detects ponder deferral.
+//
+// Does NOT refactor CLI — CLI is stable with 2280+ tests. This is a new
+// code path for new senses that follows the same pipeline pattern.
+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.runSenseTurn = runSenseTurn;
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const core_1 = require("../heart/core");
+const identity_1 = require("../heart/identity");
+const config_1 = require("../heart/config");
+const context_1 = require("../mind/context");
+const prompt_1 = require("../mind/prompt");
+const channel_1 = require("../mind/friends/channel");
+const resolver_1 = require("../mind/friends/resolver");
+const store_file_1 = require("../mind/friends/store-file");
+const pending_1 = require("../mind/pending");
+const context_2 = require("../mind/context");
+const tokens_1 = require("../mind/friends/tokens");
+const trust_gate_1 = require("./trust-gate");
+const pipeline_1 = require("./pipeline");
+const runtime_1 = require("../nerves/runtime");
+const RESPONSE_CAP = 50_000;
+/**
+ * Run a single agent turn through the inbound pipeline.
+ * Caller provides channel, session key, friend, and message;
+ * this function handles all pipeline wiring.
+ */
+async function runSenseTurn(options) {
+    const { agentName, channel, sessionKey, friendId, userMessage } = options;
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.shared_turn_start",
+        message: "shared turn runner starting",
+        meta: { agentName, channel, sessionKey, friendId },
+    });
+    // Resolve context
+    const agentRoot = (0, identity_1.getAgentRoot)(agentName);
+    const friendsPath = path.join(agentRoot, "friends");
+    const friendStore = new store_file_1.FileFriendStore(friendsPath);
+    const capabilities = (0, channel_1.getChannelCapabilities)(channel);
+    // If friendId looks like a UUID, look up the friend record directly and use its identity.
+    // Otherwise, resolve as a local user (same pattern as CLI sense).
+    const isUuid = /^[0-9a-f]{8}-[0-9a-f]{4}-/.test(friendId);
+    let resolverParams;
+    if (isUuid) {
+        const existingFriend = await friendStore.get(friendId);
+        if (existingFriend) {
+            // Use the friend's first external ID for resolver context
+            const ext = existingFriend.externalIds?.[0];
+            resolverParams = {
+                provider: (ext?.provider ?? "local"),
+                externalId: ext?.externalId ?? friendId,
+                displayName: existingFriend.name ?? friendId,
+                channel,
+            };
+        }
+        else {
+            resolverParams = { provider: "local", externalId: friendId, displayName: friendId, channel };
+        }
+    }
+    else {
+        // Treat as local user identity (username@hostname pattern)
+        const username = os.userInfo().username;
+        const hostname = os.hostname();
+        resolverParams = { provider: "local", externalId: `${username}@${hostname}`, displayName: username, channel };
+    }
+    const resolver = new resolver_1.FriendResolver(friendStore, resolverParams);
+    // Session path and loading
+    const sessPath = (0, config_1.sessionPath)(friendId, channel, sessionKey);
+    const existing = (0, context_1.loadSession)(sessPath);
+    let sessionState = existing?.state;
+    const sessionMessages = existing?.messages && existing.messages.length > 0
+        ? existing.messages
+        : [{ role: "system", content: await (0, prompt_1.buildSystem)(channel, {}, undefined) }];
+    // Pending dir
+    const pendingDir = (0, pending_1.getPendingDir)(agentName, friendId, channel, sessionKey);
+    // Accumulate response text via callbacks
+    let responseText = "";
+    /* v8 ignore start — no-op callback stubs; only onTextChunk does real work (covered via mock) */
+    const callbacks = {
+        onModelStart: () => { },
+        onModelStreamStart: () => { },
+        onTextChunk: (chunk) => { responseText += chunk; },
+        onReasoningChunk: () => { },
+        onToolStart: () => { },
+        onToolEnd: () => { },
+        onError: () => { },
+    };
+    /* v8 ignore stop */
+    // Run the pipeline
+    const result = await (0, pipeline_1.handleInboundTurn)({
+        channel,
+        sessionKey,
+        capabilities,
+        messages: [{ role: "user", content: userMessage }],
+        callbacks,
+        /* v8 ignore start — delegation wrappers; pipeline integration tested separately */
+        friendResolver: { resolve: () => resolver.resolve() },
+        sessionLoader: {
+            loadOrCreate: () => Promise.resolve({
+                messages: sessionMessages,
+                sessionPath: sessPath,
+                state: sessionState,
+            }),
+        },
+        /* v8 ignore stop */
+        pendingDir,
+        friendStore,
+        provider: "local",
+        externalId: friendId,
+        enforceTrustGate: trust_gate_1.enforceTrustGate,
+        drainPending: pending_1.drainPending,
+        /* 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) => {
+            (0, context_2.postTurn)(turnMessages, sessionPathArg, usage, hooks, state);
+            sessionState = state;
+        },
+        /* v8 ignore stop */
+        accumulateFriendTokens: tokens_1.accumulateFriendTokens,
+    });
+    // Detect ponder deferral
+    const ponderDeferred = result.turnOutcome === "pondered";
+    // Build response
+    let finalResponse;
+    if (ponderDeferred) {
+        finalResponse = "the agent is pondering this — check back shortly via check_response.";
+    }
+    else if (responseText.length === 0) {
+        // Agent settled but no text came through callbacks — check session transcript for the settle answer
+        const postTurnSession = (0, context_1.loadSession)(sessPath);
+        if (postTurnSession?.messages) {
+            const lastAssistant = [...postTurnSession.messages].reverse().find(m => m.role === "assistant");
+            if (lastAssistant && typeof lastAssistant.content === "string" && lastAssistant.content.trim()) {
+                finalResponse = lastAssistant.content;
+            }
+            else {
+                finalResponse = "(agent responded but response was empty)";
+            }
+        }
+        else {
+            finalResponse = "(agent responded but response was empty)";
+        }
+    }
+    else {
+        finalResponse = responseText;
+    }
+    // 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 };
+}

package/package.json

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