@ouro.bot/cli 0.1.0-alpha.66 → 0.1.0-alpha.660

package/dist/senses/proactive-content-guard.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProactiveInternalContentBlockReason = getProactiveInternalContentBlockReason;
+exports.emitProactiveInternalContentBlocked = emitProactiveInternalContentBlocked;
+const runtime_1 = require("../nerves/runtime");
+// ── Patterns ────────────────────────────────────────────────────
+const PROACTIVE_INTERNAL_CONTENT_PATTERNS = [
+    // PR 447 patterns: raw meta markers
+    { reason: "raw_meta_marker", pattern: /<\s*\/?\s*(think|analysis|commentary)\b[^>]*>/i },
+    { reason: "raw_meta_marker", pattern: /\[\s*surfaced from inner dialog\s*\]/i },
+    // Inner dialog / attention / obligation references
+    { reason: "inner_dialog_reference", pattern: /\binner (dialog|dialogue)\b/i },
+    { reason: "attention_queue_reference", pattern: /\battention queues?\b/i },
+    { reason: "return_obligation_reference", pattern: /\b(return|held|heart|inner)\s+obligations?\b/i },
+    // Surfacing mechanics
+    { reason: "surfacing_mechanics_reference", pattern: /\b(surface tool|surfacing (mechanics|itself)|surfaced? outward|call `?surface`?|delegationId|delegation id)\b/i },
+    // Prompt references
+    { reason: "prompt_reference", pattern: /\b(system|developer|inner|tool|orientation)\s+prompts?\b|\bprompt\/orientation\b|\bprompt wording\b/i },
+    // Routing references
+    { reason: "routing_reference", pattern: /\b(routing target|reply target|route through surface|routed through surface|proactive bluebubbles delivery)\b/i },
+    // Heartbeat / status patterns
+    { reason: "heartbeat_status", pattern: /\bheartbeat\b/i },
+    { reason: "heartbeat_status", pattern: /\bcheck-in\b/i },
+    { reason: "heartbeat_status", pattern: /\btask board\b/i },
+    { reason: "heartbeat_status", pattern: /\ball else settled\b/i },
+    { reason: "heartbeat_status", pattern: /\bobligations?\s+showing\b/i },
+    { reason: "heartbeat_status", pattern: /\bsame state\b/i },
+];
+// ── Public API ──────────────────────────────────────────────────
+function getProactiveInternalContentBlockReason(text) {
+    for (const { reason, pattern } of PROACTIVE_INTERNAL_CONTENT_PATTERNS) {
+        if (pattern.test(text))
+            return reason;
+    }
+    return null;
+}
+function emitProactiveInternalContentBlocked(params) {
+    (0, runtime_1.emitNervesEvent)({
+        level: "warn",
+        component: "senses",
+        event: "senses.proactive_internal_content_blocked",
+        message: "proactive send blocked: internal content",
+        meta: {
+            friendId: params.friendId,
+            source: params.source,
+            reason: params.reason,
+            ...(params.sessionKey ? { sessionKey: params.sessionKey } : {}),
+            ...(params.intent ? { intent: params.intent } : {}),
+        },
+    });
+}

package/dist/senses/shared-turn.js

@@ -0,0 +1,419 @@
+"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.stripThinkBlocks = stripThinkBlocks;
+exports.extractOutwardSenseDeliveryText = extractOutwardSenseDeliveryText;
+exports.runSenseTurn = runSenseTurn;
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const core_1 = require("../heart/core");
+const identity_1 = require("../heart/identity");
+const config_1 = require("../heart/config");
+const session_events_1 = require("../heart/session-events");
+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 mcp_manager_1 = require("../repertoire/mcp-manager");
+const runtime_1 = require("../nerves/runtime");
+const RESPONSE_CAP = 50_000;
+const OUTWARD_DELIVERY_TOOL_ACKS = new Map([
+    ["settle", "(delivered)"],
+    ["speak", "(spoken)"],
+]);
+/**
+ * Strip MiniMax-style `<think>...</think>` reasoning blocks from a response
+ * string. Handles unclosed open tags (treats everything from `<think>` to
+ * end of string as reasoning) and multiple blocks in sequence. Returns the
+ * trimmed remainder.
+ */
+function stripThinkBlocks(input) {
+    let out = input;
+    // Closed blocks first (greedy match removed by repeatedly slicing the leftmost pair).
+    for (;;) {
+        const open = out.indexOf("<think>");
+        if (open === -1)
+            break;
+        const close = out.indexOf("</think>", open + "<think>".length);
+        if (close === -1) {
+            // Unclosed — drop everything from <think> onward.
+            out = out.slice(0, open);
+            break;
+        }
+        out = out.slice(0, open) + out.slice(close + "</think>".length);
+    }
+    return out.trim();
+}
+function assistantContentText(content) {
+    if (typeof content !== "string")
+        return null;
+    const trimmed = content.trim();
+    return trimmed ? trimmed : null;
+}
+function parseToolStringArg(toolCall, toolName, argName) {
+    if (!toolCall || typeof toolCall !== "object")
+        return null;
+    const fn = toolCall.function;
+    if (fn?.name !== toolName || typeof fn.arguments !== "string")
+        return null;
+    try {
+        const parsed = JSON.parse(fn.arguments);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            return null;
+        const value = parsed[argName];
+        if (typeof value !== "string")
+            return null;
+        const trimmed = value.trim();
+        return trimmed ? trimmed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function hasDeliveredToolResult(messages, assistantIndex, toolCallId, toolName) {
+    if (typeof toolCallId !== "string" || !toolCallId.trim())
+        return false;
+    const expectedAck = OUTWARD_DELIVERY_TOOL_ACKS.get(toolName);
+    for (let index = assistantIndex + 1; index < messages.length; index++) {
+        const message = messages[index];
+        if (message.role !== "tool")
+            return false;
+        if (message.tool_call_id === toolCallId
+            && typeof message.content === "string"
+            && message.content.trim() === expectedAck) {
+            return true;
+        }
+    }
+    return false;
+}
+function outwardDeliveryTextFromAssistantTools(messages, assistantIndex) {
+    const assistant = messages[assistantIndex];
+    if (!Array.isArray(assistant.tool_calls))
+        return null;
+    const delivered = [];
+    for (let index = 0; index < assistant.tool_calls.length; index++) {
+        const toolCall = assistant.tool_calls[index];
+        const toolCallId = toolCall && typeof toolCall === "object"
+            ? toolCall.id
+            : undefined;
+        const settleAnswer = parseToolStringArg(toolCall, "settle", "answer");
+        if (settleAnswer && hasDeliveredToolResult(messages, assistantIndex, toolCallId, "settle")) {
+            delivered.push(settleAnswer);
+            continue;
+        }
+        const spokenMessage = parseToolStringArg(toolCall, "speak", "message");
+        if (spokenMessage && hasDeliveredToolResult(messages, assistantIndex, toolCallId, "speak")) {
+            delivered.push(spokenMessage);
+        }
+    }
+    return delivered.length > 0 ? delivered.join("\n") : null;
+}
+/**
+ * Recover the text that actually reached a friend in an outward sense turn.
+ *
+ * Ouro runs outward channels in tool-required mode. That means the visible
+ * response may be a `settle({ answer })` or `speak({ message })` tool call
+ * whose assistant message has `content: null`. The authoritative delivery
+ * signal is the following tool ack:
+ *
+ * - `(delivered)` for `settle.answer`
+ * - `(spoken)` for `speak.message`
+ *
+ * Inner-dialog `(settled)`, malformed tool arguments, rejected tools, and
+ * interrupted tool-call sequences are not outward speech. Sense transports
+ * that need to replay the turn later (Voice/Twilio TTS, future meeting audio)
+ * should use this helper instead of reading `assistant.content` directly.
+ */
+function extractOutwardSenseDeliveryText(messages) {
+    const assistantIndex = messages.findLastIndex((message) => message.role === "assistant");
+    if (assistantIndex < 0)
+        return null;
+    const assistant = messages[assistantIndex];
+    return assistantContentText(assistant.content)
+        ?? outwardDeliveryTextFromAssistantTools(messages, assistantIndex);
+}
+/**
+ * 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 (options.identity) {
+        resolverParams = {
+            provider: options.identity.provider,
+            externalId: options.identity.externalId,
+            displayName: options.identity.displayName,
+            channel,
+            ...(options.identity.tenantId ? { tenantId: options.identity.tenantId } : {}),
+        };
+    }
+    else 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;
+        resolverParams = { provider: "local", externalId: username, displayName: username, channel };
+    }
+    const resolver = new resolver_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;
+    // Session path and loading
+    const sessionDir = path.join(agentRoot, "state", "sessions", friendId, channel);
+    fs.mkdirSync(sessionDir, { recursive: true });
+    const sessPath = path.join(sessionDir, `${(0, config_1.sanitizeKey)(sessionKey)}.json`);
+    const existing = (0, context_1.loadSession)(sessPath);
+    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)) }];
+    // 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 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;
+        const delivery = { kind, text };
+        try {
+            await options.deliverySink?.onDelivery(delivery);
+            deliveries.push(delivery);
+            commitResponseText(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);
+        }
+    };
+    /* v8 ignore start — no-op callback stubs; only onTextChunk does real work (covered via mock) */
+    const callbacks = {
+        onModelStart: () => { },
+        onModelStreamStart: () => { },
+        onTextChunk: (chunk) => { pendingResponseText += chunk; },
+        onReasoningChunk: () => { },
+        onToolStart: () => { },
+        onToolEnd: (name, _summary, success) => {
+            if (name === "settle" && success)
+                terminalDeliveryKind = "settle";
+        },
+        onError: () => { },
+        onClearText: () => { pendingResponseText = ""; },
+        flushNow: () => deliverPending("speak", { throwOnError: true }),
+    };
+    /* v8 ignore stop */
+    // Run the pipeline
+    const userMsg = { role: "user", content: userMessage };
+    (0, session_events_1.stampIngressTime)(userMsg);
+    const turnResult = await (0, pipeline_1.handleInboundTurn)({
+        channel,
+        latencyMode: options.latencyMode,
+        sessionKey,
+        capabilities,
+        messages: [userMsg],
+        callbacks,
+        /* 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.latencyMode === "live" ? { skipKeptNotes: true } : {}),
+            toolContext: {
+                signin: async () => undefined,
+                ...(options.toolContext ? options.toolContext : {}),
+                currentUserMessage: userMessage,
+            },
+        },
+        /* 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: tokens_1.accumulateFriendTokens,
+    });
+    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,
+        };
+    }
+    await deliverPending(terminalDeliveryKind, { throwOnError: false });
+    const ponderDeferred = false;
+    // Build response
+    let finalResponse;
+    if (committedResponseText.length === 0) {
+        // Agent settled but no text came through callbacks — check session transcript for the settle answer
+        // Await deferred persist so the session file is up-to-date before readback
+        /* v8 ignore next -- persistPromise set inside v8-ignored postTurn callback; tested via pipeline integration @preserve */
+        if (persistPromise)
+            await persistPromise;
+        const postTurnSession = (0, context_1.loadSession)(sessPath);
+        if (postTurnSession?.messages) {
+            finalResponse = extractOutwardSenseDeliveryText(postTurnSession.messages)
+                ?? "(agent responded but response was empty)";
+        }
+        else {
+            finalResponse = "(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) {
+        (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 };
+}

package/dist/senses/surface-tool.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleSurface = handleSurface;
+const attention_queue_1 = require("./attention-queue");
+const runtime_1 = require("../nerves/runtime");
+async function handleSurface(input) {
+    const { content, delegationId, friendId, deliveryHint, queue, routeToFriend, advanceObligation, completePonderPacket, fulfillHeartObligation, } = input;
+    // Resolve target friend
+    let targetFriendId;
+    let queueItem;
+    const matchesFriend = (item, target) => item.friendId === target || item.friendName.toLowerCase() === target.toLowerCase();
+    const inferQueueItem = (target) => {
+        if (queue.length === 0)
+            return undefined;
+        const candidates = target
+            ? queue.filter((item) => matchesFriend(item, target))
+            : queue;
+        if (candidates.length === 1)
+            return candidates[0];
+        if (candidates.length > 1) {
+            return `multiple held thoughts match ${target ?? "this surface call"} — use delegationId to choose one`;
+        }
+        return undefined;
+    };
+    if (delegationId) {
+        // Look up in attention queue
+        const found = queue.find((item) => item.id === delegationId);
+        if (!found) {
+            return `no delegation found with id ${delegationId} — check your attention queue`;
+        }
+        targetFriendId = found.friendId;
+        queueItem = found;
+    }
+    else if (friendId) {
+        const inferred = inferQueueItem(friendId);
+        if (typeof inferred === "string")
+            return inferred;
+        queueItem = inferred;
+        targetFriendId = queueItem?.friendId ?? friendId;
+    }
+    else {
+        const inferred = inferQueueItem();
+        if (typeof inferred === "string")
+            return inferred;
+        if (inferred) {
+            queueItem = inferred;
+            targetFriendId = inferred.friendId;
+        }
+        else {
+            return "specify who this thought is for — use delegationId to address a held thought, or friendId for spontaneous outreach";
+        }
+    }
+    if (queueItem?.packetId && !delegationId) {
+        return `held private return ${queueItem.id} is waiting — call surface with delegationId="${queueItem.id}" so the return is tied to the correct packet`;
+    }
+    // Route to target
+    const result = deliveryHint
+        ? await routeToFriend(targetFriendId, content, queueItem, deliveryHint)
+        : await routeToFriend(targetFriendId, content, queueItem);
+    (0, runtime_1.emitNervesEvent)({
+        event: "senses.surface_routed",
+        component: "senses",
+        message: `surface routed to ${targetFriendId}: ${result.status}`,
+        meta: {
+            targetFriendId,
+            status: result.status,
+            hasDelegationId: !!delegationId,
+            ...(result.detail ? { detail: result.detail } : {}),
+        },
+    });
+    // On successful routing with delegationId:
+    // 1. Advance obligation to "returned" (disk FIRST — crash safety)
+    // 2. Dequeue from process-local queue (AFTER obligation advance)
+    if (queueItem && result.status !== "failed") {
+        if (queueItem.obligationId) {
+            advanceObligation(queueItem.obligationId, {
+                status: "returned",
+                returnedAt: Date.now(),
+                returnTarget: "surface",
+            });
+        }
+        if (completePonderPacket && queueItem.packetId) {
+            try {
+                completePonderPacket(queueItem.packetId);
+            }
+            catch {
+                // swallowed — packet completion must never break surface delivery
+            }
+        }
+        // Fulfill the heart obligation for this origin (separate from inner/mind obligation)
+        if (fulfillHeartObligation) {
+            try {
+                fulfillHeartObligation({
+                    friendId: queueItem.friendId,
+                    channel: queueItem.channel,
+                    key: queueItem.key,
+                });
+            }
+            catch {
+                // swallowed — heart obligation fulfillment must never break surface delivery
+            }
+        }
+        (0, attention_queue_1.dequeueAttentionItem)(queue, queueItem.id);
+    }
+    // Return delivery status
+    const detail = result.detail ? ` — ${result.detail}` : "";
+    return `${result.status}${detail}`;
+}

package/dist/senses/teams-entry.js

@@ -1,15 +1,67 @@
 "use strict";
-// Thin entrypoint for `npm run teams` / `node dist/senses/teams-entry.js --agent <name>`.
-// Separated from teams.ts so the Teams adapter is pure library code with clean
-// 100% test coverage -- entrypoints can't be covered by vitest since
-// require.main !== module in the test runner.
-// All config comes from the conventional ~/.agentsecrets/<agent>/secrets.json path.
+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 });
+const runtime_1 = require("../nerves/runtime");
 // Fail fast if --agent is missing (before any src/ code tries getAgentName())
-if (!process.argv.includes("--agent")) {
+const agentArgIndex = process.argv.indexOf("--agent");
+const agentName = agentArgIndex >= 0 ? process.argv[agentArgIndex + 1] : undefined;
+if (!agentName) {
     // eslint-disable-next-line no-console -- pre-boot guard: --agent check before imports
     console.error("Missing required --agent <name> argument.\nUsage: node dist/senses/teams-entry.js --agent ouroboros");
     process.exit(1);
 }
-const teams_1 = require("./teams");
-(0, teams_1.startTeamsApp)();
+(0, runtime_1.emitNervesEvent)({
+    component: "senses",
+    event: "senses.entry_boot",
+    message: "booting Teams entrypoint",
+    meta: { entry: "teams", agentName },
+});
+Promise.resolve().then(() => __importStar(require("../heart/runtime-credentials"))).then(async ({ refreshRuntimeCredentialConfig }) => {
+    void refreshRuntimeCredentialConfig(agentName, { preserveCachedOnFailure: true }).catch(() => undefined);
+    const { startTeamsApp } = await Promise.resolve().then(() => __importStar(require("./teams")));
+    startTeamsApp();
+})
+    .catch((error) => {
+    (0, runtime_1.emitNervesEvent)({
+        level: "error",
+        component: "senses",
+        event: "senses.entry_error",
+        message: "Teams entrypoint failed",
+        meta: { entry: "teams", agentName, error: error instanceof Error ? error.message : String(error) },
+    });
+    // eslint-disable-next-line no-console -- fatal startup guard for sense process
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+});