@ouro.bot/cli 0.1.0-alpha.485 → 0.1.0-alpha.488

package/dist/senses/bluebubbles/index.js

@@ -37,6 +37,7 @@ exports.enrichReactionText = enrichReactionText;
 exports.createStatusBatcher = createStatusBatcher;
 exports.handleBlueBubblesEvent = handleBlueBubblesEvent;
 exports.catchUpMissedBlueBubblesMessages = catchUpMissedBlueBubblesMessages;
+exports.recoverCapturedBlueBubblesInboundMessages = recoverCapturedBlueBubblesInboundMessages;
 exports.recoverMissedBlueBubblesMessages = recoverMissedBlueBubblesMessages;
 exports.createBlueBubblesWebhookHandler = createBlueBubblesWebhookHandler;
 exports.sendProactiveBlueBubblesMessageToSession = sendProactiveBlueBubblesMessageToSession;
@@ -66,6 +67,7 @@ const model_1 = require("./model");
 const client_1 = require("./client");
 const inbound_log_1 = require("./inbound-log");
 const mutation_log_1 = require("./mutation-log");
+const processed_log_1 = require("./processed-log");
 const runtime_state_1 = require("./runtime-state");
 const session_cleanup_1 = require("./session-cleanup");
 const tool_activity_callbacks_1 = require("../../heart/tool-activity-callbacks");
@@ -73,6 +75,7 @@ const commands_1 = require("../commands");
 const trust_gate_1 = require("../trust-gate");
 const pipeline_1 = require("../pipeline");
 const bbFailoverStates = new Map();
+const bbInFlightMessageGuids = new Set();
 // Enrich reaction text with the original message content for context.
 // If originalText is provided and non-empty, format as: baseText to: "truncated"
 // Otherwise return baseText unchanged.
@@ -122,6 +125,26 @@ function createStatusBatcher(send, delayMs) {
         },
     };
 }
+function blueBubblesMessageKey(sessionKey, messageGuid) {
+    return `${sessionKey}:${messageGuid.trim()}`;
+}
+function isBlueBubblesMessageInFlight(sessionKey, messageGuid) {
+    if (!messageGuid.trim())
+        return false;
+    return bbInFlightMessageGuids.has(blueBubblesMessageKey(sessionKey, messageGuid));
+}
+function beginBlueBubblesMessageInFlight(sessionKey, messageGuid) {
+    if (!messageGuid.trim())
+        return true;
+    const key = blueBubblesMessageKey(sessionKey, messageGuid);
+    if (bbInFlightMessageGuids.has(key))
+        return false;
+    bbInFlightMessageGuids.add(key);
+    return true;
+}
+function endBlueBubblesMessageInFlight(sessionKey, messageGuid) {
+    bbInFlightMessageGuids.delete(blueBubblesMessageKey(sessionKey, messageGuid));
+}
 const defaultDeps = {
     getAgentName: identity_1.getAgentName,
     buildSystem: prompt_1.buildSystem,
@@ -487,6 +510,15 @@ function createBlueBubblesCallbacks(client, chat, replyTarget, isGroupChat) {
         },
         onReasoningChunk(_text) { },
         onToolStart(name, _args) {
+            if (name === "observe") {
+                (0, runtime_1.emitNervesEvent)({
+                    component: "senses",
+                    event: "senses.bluebubbles_tool_start",
+                    message: "bluebubbles tool execution started",
+                    meta: { name },
+                });
+                return;
+            }
             // Tool activity is a reply commitment — start typing if not already
             if (!typingActive)
                 startTypingNow();
@@ -499,7 +531,9 @@ function createBlueBubblesCallbacks(client, chat, replyTarget, isGroupChat) {
             });
         },
         onToolEnd(name, summary, success) {
-            toolCallbacks.onToolEnd(name, summary, success);
+            if (name !== "observe") {
+                toolCallbacks.onToolEnd(name, summary, success);
+            }
             (0, runtime_1.emitNervesEvent)({
                 component: "senses",
                 event: "senses.bluebubbles_tool_end",
@@ -575,6 +609,7 @@ function isWebhookPasswordValid(url, expectedPassword) {
 }
 async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source) {
     const client = resolvedDeps.createClient();
+    const agentName = resolvedDeps.getAgentName();
     if (event.fromMe) {
         (0, runtime_1.emitNervesEvent)({
             component: "senses",
@@ -617,252 +652,284 @@ async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source) {
         });
         return { handled: true, notifiedAgent: false, kind: event.kind, reason: "mutation_state_only" };
     }
-    // ── Adapter setup: friend, session, content, callbacks ──────────
-    const store = resolvedDeps.createFriendStore();
-    const resolver = resolvedDeps.createFriendResolver(store, resolveFriendParams(event));
-    const baseContext = await resolver.resolve();
-    const context = { ...baseContext, isGroupChat: event.chat.isGroup };
-    const replyTarget = createReplyTargetController(event);
-    const friendId = context.friend.id;
-    const sessPath = resolvedDeps.sessionPath(friendId, "bluebubbles", event.chat.sessionKey);
-    try {
-        (0, session_cleanup_1.findObsoleteBlueBubblesThreadSessions)(sessPath);
-    }
-    catch (error) {
-        (0, runtime_1.emitNervesEvent)({
-            level: "warn",
-            component: "senses",
-            event: "senses.bluebubbles_thread_lane_cleanup_error",
-            message: "failed to inspect obsolete bluebubbles thread-lane sessions",
-            meta: {
-                sessionPath: sessPath,
-                reason: error instanceof Error ? error.message : String(error),
-            },
-        });
-    }
-    return (0, turn_coordinator_1.withSharedTurnLock)("bluebubbles", sessPath, async () => {
-        // Pre-load session inside the turn lock so same-chat deliveries cannot race on stale trunk state.
-        const existing = resolvedDeps.loadSession(sessPath);
-        const mcpManager = await (0, mcp_manager_1.getSharedMcpManager)() ?? undefined;
-        const sessionMessages = existing?.messages && existing.messages.length > 0
-            ? existing.messages
-            : [{ role: "system", content: (0, prompt_1.flattenSystemPrompt)(await resolvedDeps.buildSystem("bluebubbles", {}, context)) }];
-        if (event.kind === "message") {
-            const agentName = resolvedDeps.getAgentName();
-            if ((0, inbound_log_1.hasRecordedBlueBubblesInbound)(agentName, event.chat.sessionKey, event.messageGuid)) {
-                (0, runtime_1.emitNervesEvent)({
-                    component: "senses",
-                    event: "senses.bluebubbles_recovery_skip",
-                    message: "skipped bluebubbles message already recorded as handled",
-                    meta: {
-                        messageGuid: event.messageGuid,
-                        sessionKey: event.chat.sessionKey,
-                        source,
-                    },
-                });
-                return { handled: true, notifiedAgent: false, kind: event.kind, reason: "already_processed" };
-            }
-            // Record EARLY to prevent duplicate processing. BB webhooks can retry
-            // before the first turn completes — recording after the turn is too late.
-            const inboundSource = source !== "webhook" && sessionLikelyContainsMessage(event, existing?.messages ?? sessionMessages)
-                ? "recovery-bootstrap"
-                : source;
-            (0, inbound_log_1.recordBlueBubblesInbound)(agentName, event, inboundSource);
-            if (inboundSource === "recovery-bootstrap") {
-                (0, runtime_1.emitNervesEvent)({
-                    component: "senses",
-                    event: "senses.bluebubbles_recovery_skip",
-                    message: "skipped bluebubbles recovery because the session already contains the message text",
-                    meta: {
-                        messageGuid: event.messageGuid,
-                        sessionKey: event.chat.sessionKey,
-                        source,
-                    },
-                });
-                return { handled: true, notifiedAgent: false, kind: event.kind, reason: "already_processed" };
-            }
-        }
-        if (event.kind === "message" && event.chat.isGroup) {
-            await (0, group_context_1.upsertGroupContextParticipants)({
-                store,
-                participants: (event.chat.participantHandles ?? []).map((externalId) => ({
-                    provider: "imessage-handle",
-                    externalId,
-                })),
-                groupExternalId: resolveGroupExternalId(event),
+    let ownsInFlightMessage = false;
+    if (event.kind === "message") {
+        if ((0, processed_log_1.hasProcessedBlueBubblesMessage)(agentName, event.chat.sessionKey, event.messageGuid)) {
+            (0, runtime_1.emitNervesEvent)({
+                component: "senses",
+                event: "senses.bluebubbles_recovery_skip",
+                message: "skipped bluebubbles message already marked as handled",
+                meta: {
+                    messageGuid: event.messageGuid,
+                    sessionKey: event.chat.sessionKey,
+                    source,
+                    dedupeReason: "processed",
+                },
             });
+            return { handled: true, notifiedAgent: false, kind: event.kind, reason: "already_processed" };
         }
-        // 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);
+        if (!beginBlueBubblesMessageInFlight(event.chat.sessionKey, event.messageGuid)) {
             (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 },
+                event: "senses.bluebubbles_recovery_skip",
+                message: "skipped bluebubbles message already in flight",
+                meta: {
+                    messageGuid: event.messageGuid,
+                    sessionKey: event.chat.sessionKey,
+                    source,
+                    dedupeReason: "in_flight",
+                },
             });
+            return { handled: true, notifiedAgent: false, kind: event.kind, reason: "already_processed" };
         }
-        // Enrich reaction mutations with the original message text for context
-        const isReaction = event.kind === "mutation" && event.mutationType === "reaction";
-        if (isReaction && event.targetMessageGuid) {
-            /* v8 ignore start -- best-effort lookup; enrichReactionText covered by unit tests @preserve */
-            const originalText = await client.getMessageText(event.targetMessageGuid).catch(() => null);
-            if (originalText)
-                event.textForAgent = enrichReactionText(event.textForAgent, originalText, 80);
-            /* v8 ignore stop */
-        }
-        // Build inbound user message (adapter concern: BB-specific content formatting)
-        const userMessage = {
-            role: "user",
-            content: buildInboundContent(event, existing?.messages ?? sessionMessages, repliedToText),
-        };
-        const callbacks = createBlueBubblesCallbacks(client, event.chat, replyTarget, event.chat.isGroup);
-        const controller = new AbortController();
-        // BB-specific tool context wrappers
-        const summarize = (0, core_1.createSummarize)("human");
-        const bbCapabilities = (0, channel_1.getChannelCapabilities)("bluebubbles");
-        const pendingDir = (0, pending_1.getPendingDir)(resolvedDeps.getAgentName(), friendId, "bluebubbles", event.chat.sessionKey);
-        // ── Compute trust gate context for group/acquaintance rules ─────
-        const groupHasFamilyMember = await checkGroupHasFamilyMember(store, event);
-        const hasExistingGroupWithFamily = event.chat.isGroup
-            ? false
-            : await checkHasExistingGroupWithFamily(store, context.friend);
-        // ── Call shared pipeline ──────────────────────────────────────────
-        // Buffer terminal errors so failover can suppress them.
-        // If failover produces a message, the buffered error is skipped.
-        // If failover doesn't fire, the buffered error is replayed.
-        let bufferedTerminalError = null;
-        /* v8 ignore start -- failover-aware error buffering @preserve */
-        const failoverAwareCallbacks = {
-            ...callbacks,
-            onError(error, severity) {
-                if (severity === "terminal") {
-                    bufferedTerminalError = error;
-                    return;
-                }
-                callbacks.onError(error, severity);
-            },
-        };
-        /* v8 ignore stop */
+        ownsInFlightMessage = true;
+    }
+    try {
+        // ── Adapter setup: friend, session, content, callbacks ──────────
+        const store = resolvedDeps.createFriendStore();
+        const resolver = resolvedDeps.createFriendResolver(store, resolveFriendParams(event));
+        const baseContext = await resolver.resolve();
+        const context = { ...baseContext, isGroupChat: event.chat.isGroup };
+        const replyTarget = createReplyTargetController(event);
+        const friendId = context.friend.id;
+        const sessPath = resolvedDeps.sessionPath(friendId, "bluebubbles", event.chat.sessionKey);
         try {
-            const result = await (0, pipeline_1.handleInboundTurn)({
-                channel: "bluebubbles",
-                sessionKey: event.chat.sessionKey,
-                capabilities: bbCapabilities,
-                messages: [userMessage],
-                continuityIngressTexts: getBlueBubblesContinuityIngressTexts(event),
-                friendResolver: { resolve: () => Promise.resolve(context) },
-                sessionLoader: {
-                    loadOrCreate: () => Promise.resolve({
-                        messages: sessionMessages,
-                        sessionPath: sessPath,
-                        state: existing?.state,
-                        events: existing?.events,
-                    }),
+            (0, session_cleanup_1.findObsoleteBlueBubblesThreadSessions)(sessPath);
+        }
+        catch (error) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "senses",
+                event: "senses.bluebubbles_thread_lane_cleanup_error",
+                message: "failed to inspect obsolete bluebubbles thread-lane sessions",
+                meta: {
+                    sessionPath: sessPath,
+                    reason: error instanceof Error ? error.message : String(error),
                 },
-                pendingDir,
-                friendStore: store,
-                provider: "imessage-handle",
-                externalId: event.sender.externalId || event.sender.rawId,
-                isGroupChat: event.chat.isGroup,
-                groupHasFamilyMember,
-                hasExistingGroupWithFamily,
-                enforceTrustGate: trust_gate_1.enforceTrustGate,
-                drainPending: pending_1.drainPending,
-                drainDeferredReturns: (deferredFriendId) => (0, pending_1.drainDeferredReturns)(resolvedDeps.getAgentName(), deferredFriendId),
-                runAgent: (msgs, cb, channel, sig, opts) => resolvedDeps.runAgent(msgs, cb, channel, sig, {
-                    ...opts,
-                    toolContext: {
-                        /* v8 ignore next -- default no-op signin; pipeline provides the real one @preserve */
-                        signin: async () => undefined,
-                        ...opts?.toolContext,
-                        summarize,
-                        bluebubblesReplyTarget: {
-                            setSelection: (selection) => replyTarget.setSelection(selection),
+            });
+        }
+        return await (0, turn_coordinator_1.withSharedTurnLock)("bluebubbles", sessPath, async () => {
+            // Pre-load session inside the turn lock so same-chat deliveries cannot race on stale trunk state.
+            const existing = resolvedDeps.loadSession(sessPath);
+            const mcpManager = await (0, mcp_manager_1.getSharedMcpManager)() ?? undefined;
+            const sessionMessages = existing?.messages && existing.messages.length > 0
+                ? existing.messages
+                : [{ role: "system", content: (0, prompt_1.flattenSystemPrompt)(await resolvedDeps.buildSystem("bluebubbles", {}, context)) }];
+            if (event.kind === "message") {
+                // Record EARLY for audit and crash recovery. This is capture truth, not
+                // a claim that the agent turn completed successfully.
+                const inboundSource = source !== "webhook" && sessionLikelyContainsMessage(event, existing?.messages ?? sessionMessages)
+                    ? "recovery-bootstrap"
+                    : source;
+                (0, inbound_log_1.recordBlueBubblesInbound)(agentName, event, inboundSource);
+                if (inboundSource === "recovery-bootstrap") {
+                    (0, runtime_1.emitNervesEvent)({
+                        component: "senses",
+                        event: "senses.bluebubbles_recovery_skip",
+                        message: "skipped bluebubbles recovery because the session already contains the message text",
+                        meta: {
+                            messageGuid: event.messageGuid,
+                            sessionKey: event.chat.sessionKey,
+                            source,
                         },
-                        codingFeedback: {
-                            send: async (message) => {
-                                await client.sendText({
-                                    chat: event.chat,
-                                    text: message,
-                                    replyToMessageGuid: replyTarget.getReplyToMessageGuid(),
-                                });
+                    });
+                    (0, processed_log_1.recordProcessedBlueBubblesMessage)(agentName, event, inboundSource, "session-bootstrap");
+                    return { handled: true, notifiedAgent: false, kind: event.kind, reason: "already_processed" };
+                }
+            }
+            if (event.kind === "message" && event.chat.isGroup) {
+                await (0, group_context_1.upsertGroupContextParticipants)({
+                    store,
+                    participants: (event.chat.participantHandles ?? []).map((externalId) => ({
+                        provider: "imessage-handle",
+                        externalId,
+                    })),
+                    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 },
+                });
+            }
+            // Enrich reaction mutations with the original message text for context
+            const isReaction = event.kind === "mutation" && event.mutationType === "reaction";
+            if (isReaction && event.targetMessageGuid) {
+                /* v8 ignore start -- best-effort lookup; enrichReactionText covered by unit tests @preserve */
+                const originalText = await client.getMessageText(event.targetMessageGuid).catch(() => null);
+                if (originalText)
+                    event.textForAgent = enrichReactionText(event.textForAgent, originalText, 80);
+                /* v8 ignore stop */
+            }
+            // Build inbound user message (adapter concern: BB-specific content formatting)
+            const userMessage = {
+                role: "user",
+                content: buildInboundContent(event, existing?.messages ?? sessionMessages, repliedToText),
+            };
+            const callbacks = createBlueBubblesCallbacks(client, event.chat, replyTarget, event.chat.isGroup);
+            const controller = new AbortController();
+            // BB-specific tool context wrappers
+            const summarize = (0, core_1.createSummarize)("human");
+            const bbCapabilities = (0, channel_1.getChannelCapabilities)("bluebubbles");
+            const pendingDir = (0, pending_1.getPendingDir)(resolvedDeps.getAgentName(), friendId, "bluebubbles", event.chat.sessionKey);
+            // ── Compute trust gate context for group/acquaintance rules ─────
+            const groupHasFamilyMember = await checkGroupHasFamilyMember(store, event);
+            const hasExistingGroupWithFamily = event.chat.isGroup
+                ? false
+                : await checkHasExistingGroupWithFamily(store, context.friend);
+            // ── Call shared pipeline ──────────────────────────────────────────
+            // Buffer terminal errors so failover can suppress them.
+            // If failover produces a message, the buffered error is skipped.
+            // If failover doesn't fire, the buffered error is replayed.
+            let bufferedTerminalError = null;
+            /* v8 ignore start -- failover-aware error buffering @preserve */
+            const failoverAwareCallbacks = {
+                ...callbacks,
+                onError(error, severity) {
+                    if (severity === "terminal") {
+                        bufferedTerminalError = error;
+                        return;
+                    }
+                    callbacks.onError(error, severity);
+                },
+            };
+            /* v8 ignore stop */
+            try {
+                const result = await (0, pipeline_1.handleInboundTurn)({
+                    channel: "bluebubbles",
+                    sessionKey: event.chat.sessionKey,
+                    capabilities: bbCapabilities,
+                    messages: [userMessage],
+                    continuityIngressTexts: getBlueBubblesContinuityIngressTexts(event),
+                    friendResolver: { resolve: () => Promise.resolve(context) },
+                    sessionLoader: {
+                        loadOrCreate: () => Promise.resolve({
+                            messages: sessionMessages,
+                            sessionPath: sessPath,
+                            state: existing?.state,
+                            events: existing?.events,
+                        }),
+                    },
+                    pendingDir,
+                    friendStore: store,
+                    provider: "imessage-handle",
+                    externalId: event.sender.externalId || event.sender.rawId,
+                    isGroupChat: event.chat.isGroup,
+                    groupHasFamilyMember,
+                    hasExistingGroupWithFamily,
+                    enforceTrustGate: trust_gate_1.enforceTrustGate,
+                    drainPending: pending_1.drainPending,
+                    drainDeferredReturns: (deferredFriendId) => (0, pending_1.drainDeferredReturns)(resolvedDeps.getAgentName(), deferredFriendId),
+                    runAgent: (msgs, cb, channel, sig, opts) => resolvedDeps.runAgent(msgs, cb, channel, sig, {
+                        ...opts,
+                        toolContext: {
+                            /* v8 ignore next -- default no-op signin; pipeline provides the real one @preserve */
+                            signin: async () => undefined,
+                            ...opts?.toolContext,
+                            summarize,
+                            bluebubblesReplyTarget: {
+                                setSelection: (selection) => replyTarget.setSelection(selection),
+                            },
+                            codingFeedback: {
+                                send: async (message) => {
+                                    await client.sendText({
+                                        chat: event.chat,
+                                        text: message,
+                                        replyToMessageGuid: replyTarget.getReplyToMessageGuid(),
+                                    });
+                                },
                             },
                         },
+                    }),
+                    postTurn: (turnMessages, sessionPathArg, usage, hooks, state) => {
+                        const prepared = resolvedDeps.postTurnTrim(turnMessages, usage, hooks);
+                        resolvedDeps.deferPostTurnPersist(sessionPathArg, prepared, usage, state);
                     },
-                }),
-                postTurn: (turnMessages, sessionPathArg, usage, hooks, state) => {
-                    const prepared = resolvedDeps.postTurnTrim(turnMessages, usage, hooks);
-                    resolvedDeps.deferPostTurnPersist(sessionPathArg, prepared, usage, state);
-                },
-                accumulateFriendTokens: resolvedDeps.accumulateFriendTokens,
-                signal: controller.signal,
-                runAgentOptions: { mcpManager, ...(isReaction ? { isReactionSignal: true } : {}) },
-                callbacks: failoverAwareCallbacks,
-                failoverState: (() => {
-                    if (!bbFailoverStates.has(event.chat.sessionKey)) {
-                        bbFailoverStates.set(event.chat.sessionKey, { pending: null });
+                    accumulateFriendTokens: resolvedDeps.accumulateFriendTokens,
+                    signal: controller.signal,
+                    runAgentOptions: { mcpManager, ...(isReaction ? { isReactionSignal: true } : {}) },
+                    callbacks: failoverAwareCallbacks,
+                    failoverState: (() => {
+                        if (!bbFailoverStates.has(event.chat.sessionKey)) {
+                            bbFailoverStates.set(event.chat.sessionKey, { pending: null });
+                        }
+                        return bbFailoverStates.get(event.chat.sessionKey);
+                    })(),
+                });
+                /* v8 ignore start -- failover display + error replay @preserve */
+                if (result.failoverMessage) {
+                    // Failover handled it — show the failover message, skip the buffered error
+                    await client.sendText({ chat: event.chat, text: result.failoverMessage });
+                }
+                else if (bufferedTerminalError) {
+                    // No failover — replay the buffered terminal error
+                    callbacks.onError(bufferedTerminalError, "terminal");
+                }
+                /* v8 ignore stop */
+                // ── Handle gate result ────────────────────────────────────────
+                if (!result.gateResult.allowed) {
+                    // Send auto-reply via BB API if the gate provides one
+                    if ("autoReply" in result.gateResult && result.gateResult.autoReply) {
+                        await client.sendText({
+                            chat: event.chat,
+                            text: result.gateResult.autoReply,
+                        });
                     }
-                    return bbFailoverStates.get(event.chat.sessionKey);
-                })(),
-            });
-            /* v8 ignore start -- failover display + error replay @preserve */
-            if (result.failoverMessage) {
-                // Failover handled it — show the failover message, skip the buffered error
-                await client.sendText({ chat: event.chat, text: result.failoverMessage });
-            }
-            else if (bufferedTerminalError) {
-                // No failover — replay the buffered terminal error
-                callbacks.onError(bufferedTerminalError, "terminal");
-            }
-            /* v8 ignore stop */
-            // ── Handle gate result ────────────────────────────────────────
-            if (!result.gateResult.allowed) {
-                // Send auto-reply via BB API if the gate provides one
-                if ("autoReply" in result.gateResult && result.gateResult.autoReply) {
-                    await client.sendText({
-                        chat: event.chat,
-                        text: result.gateResult.autoReply,
-                    });
+                    if (event.kind === "message") {
+                        (0, processed_log_1.recordProcessedBlueBubblesMessage)(agentName, event, source, "trust-gated");
+                    }
+                    return {
+                        handled: true,
+                        notifiedAgent: false,
+                        kind: event.kind,
+                    };
                 }
+                // Gate allowed — flush the agent's reply
+                await callbacks.flush();
+                if (event.kind === "message") {
+                    (0, processed_log_1.recordProcessedBlueBubblesMessage)(agentName, event, source, "turn-complete");
+                }
+                (0, runtime_1.emitNervesEvent)({
+                    component: "senses",
+                    event: "senses.bluebubbles_turn_end",
+                    message: "bluebubbles event handled",
+                    meta: {
+                        messageGuid: event.messageGuid,
+                        kind: event.kind,
+                        sessionKey: event.chat.sessionKey,
+                    },
+                });
                 return {
                     handled: true,
-                    notifiedAgent: false,
+                    notifiedAgent: true,
                     kind: event.kind,
                 };
             }
-            // Gate allowed — flush the agent's reply
-            await callbacks.flush();
-            (0, runtime_1.emitNervesEvent)({
-                component: "senses",
-                event: "senses.bluebubbles_turn_end",
-                message: "bluebubbles event handled",
-                meta: {
-                    messageGuid: event.messageGuid,
-                    kind: event.kind,
-                    sessionKey: event.chat.sessionKey,
-                },
-            });
-            return {
-                handled: true,
-                notifiedAgent: true,
-                kind: event.kind,
-            };
-        }
-        finally {
-            // If a terminal error was buffered and never replayed (e.g., handleInboundTurn threw),
-            // replay it now so the user still sees the error.
-            /* v8 ignore start -- error replay on throw: tested via BB error test @preserve */
-            if (bufferedTerminalError) {
-                callbacks.onError(bufferedTerminalError, "terminal");
-                bufferedTerminalError = null;
+            finally {
+                // If a terminal error was buffered and never replayed (e.g., handleInboundTurn threw),
+                // replay it now so the user still sees the error.
+                /* v8 ignore start -- error replay on throw: tested via BB error test @preserve */
+                if (bufferedTerminalError) {
+                    callbacks.onError(bufferedTerminalError, "terminal");
+                    bufferedTerminalError = null;
+                }
+                /* v8 ignore stop */
+                await callbacks.finish();
             }
-            /* v8 ignore stop */
-            await callbacks.finish();
+        });
+    }
+    finally {
+        if (ownsInFlightMessage && event.kind === "message") {
+            endBlueBubblesMessageInFlight(event.chat.sessionKey, event.messageGuid);
         }
-    });
+    }
 }
 async function handleBlueBubblesEvent(payload, deps = {}) {
     const resolvedDeps = { ...defaultDeps, ...deps };
@@ -908,8 +975,15 @@ async function handleBlueBubblesEvent(payload, deps = {}) {
     // the downstream `already_processed` path fires its observability events
     // and the caller sees a consistent return shape.
     const agentName = resolvedDeps.getAgentName();
+    // normalizeBlueBubblesEvent rejects guidless payloads, so duplicate handling
+    // only needs to discriminate between known processed, in-flight, or new.
+    const duplicateReason = (0, processed_log_1.hasProcessedBlueBubblesMessage)(agentName, normalized.chat.sessionKey, normalized.messageGuid)
+        ? "processed"
+        : isBlueBubblesMessageInFlight(normalized.chat.sessionKey, normalized.messageGuid)
+            ? "in_flight"
+            : null;
     if (normalized.messageGuid
-        && (0, inbound_log_1.hasRecordedBlueBubblesInbound)(agentName, normalized.chat.sessionKey, normalized.messageGuid)) {
+        && duplicateReason) {
         (0, runtime_1.emitNervesEvent)({
             level: "warn",
             component: "senses",
@@ -920,6 +994,7 @@ async function handleBlueBubblesEvent(payload, deps = {}) {
                 sessionKey: normalized.chat.sessionKey,
                 eventType: normalized.eventType,
                 normalizedKind: normalized.kind,
+                dedupeReason: duplicateReason,
             },
         });
         return handleBlueBubblesNormalizedEvent(normalized, resolvedDeps, "webhook");
@@ -929,7 +1004,7 @@ async function handleBlueBubblesEvent(payload, deps = {}) {
 }
 function countPendingRecoveryCandidates(agentName) {
     return (0, mutation_log_1.listBlueBubblesRecoveryCandidates)(agentName)
-        .filter((entry) => !(0, inbound_log_1.hasRecordedBlueBubblesInbound)(agentName, entry.sessionKey, entry.messageGuid))
+        .filter((entry) => !(0, processed_log_1.hasProcessedBlueBubblesMessage)(agentName, entry.sessionKey, entry.messageGuid))
         .length;
 }
 function parseTimestampMs(value) {
@@ -959,16 +1034,23 @@ async function syncBlueBubblesRuntime(deps = {}) {
     const previousState = (0, runtime_state_1.readBlueBubblesRuntimeState)(agentName);
     try {
         await client.checkHealth();
+        const captured = await recoverCapturedBlueBubblesInboundMessages(resolvedDeps);
         const recovery = await recoverMissedBlueBubblesMessages(resolvedDeps);
         const catchUp = await catchUpMissedBlueBubblesMessages(resolvedDeps, previousState);
-        const failed = recovery.failed + catchUp.failed;
-        const recovered = recovery.recovered + catchUp.recovered;
+        const failed = captured.failed + recovery.failed + catchUp.failed;
+        const recovered = captured.recovered + recovery.recovered + catchUp.recovered;
+        // upstreamStatus reflects whether BlueBubbles itself is healthy and we
+        // have unprocessed work (pendingRecoveryCount). Per-cycle recovery
+        // failures are noted in `detail` for transparency but do NOT flip the
+        // status to error: a single permanently-unrecoverable message would
+        // otherwise stick the sense in "error" forever, contradicting `ouro
+        // doctor` which only checks upstream reachability.
         (0, runtime_state_1.writeBlueBubblesRuntimeState)(agentName, {
-            upstreamStatus: recovery.pending > 0 || failed > 0 ? "error" : "ok",
-            detail: failed > 0
-                ? `recovery failures: ${failed}`
-                : recovery.pending > 0
-                    ? `pending recovery: ${recovery.pending}`
+            upstreamStatus: recovery.pending > 0 ? "error" : "ok",
+            detail: recovery.pending > 0
+                ? `pending recovery: ${recovery.pending}`
+                : failed > 0
+                    ? `${failed} message(s) unrecoverable this cycle; upstream ok`
                     : catchUp.recovered > 0
                         ? formatRecoveredCount(catchUp.recovered)
                         : "upstream reachable",
@@ -1066,7 +1148,8 @@ async function catchUpMissedBlueBubblesMessages(deps = {}, previousState) {
         result.inspected++;
         if (event.fromMe
             || event.timestamp < catchUpSince
-            || (0, inbound_log_1.hasRecordedBlueBubblesInbound)(agentName, event.chat.sessionKey, event.messageGuid)) {
+            || (0, processed_log_1.hasProcessedBlueBubblesMessage)(agentName, event.chat.sessionKey, event.messageGuid)
+            || isBlueBubblesMessageInFlight(event.chat.sessionKey, event.messageGuid)) {
             result.skipped++;
             continue;
         }
@@ -1109,13 +1192,99 @@ async function catchUpMissedBlueBubblesMessages(deps = {}, previousState) {
     }
     return result;
 }
+function inboundEntryToRecoveryEvent(entry) {
+    const chatIdentifier = entry.chatIdentifier ?? extractChatIdentifierFromSessionKey(entry.sessionKey) ?? "unknown";
+    const normalizedSessionKey = normalizeBlueBubblesSessionKey(entry.sessionKey);
+    const chatGuid = entry.chatGuid ?? (normalizedSessionKey.startsWith("chat:") ? normalizedSessionKey.slice("chat:".length) : undefined);
+    const isGroup = normalizedSessionKey.includes("+;");
+    return {
+        kind: "message",
+        eventType: "new-message",
+        messageGuid: entry.messageGuid,
+        timestamp: parseTimestampMs(entry.recordedAt) ?? Date.now(),
+        fromMe: false,
+        sender: {
+            provider: "imessage-handle",
+            externalId: chatIdentifier,
+            rawId: chatIdentifier,
+            displayName: chatIdentifier,
+        },
+        chat: {
+            chatGuid,
+            chatIdentifier,
+            isGroup,
+            sessionKey: normalizedSessionKey,
+            sendTarget: chatGuid
+                ? { kind: "chat_guid", value: chatGuid }
+                : { kind: "chat_identifier", value: chatIdentifier },
+            participantHandles: [],
+        },
+        text: entry.textForAgent,
+        textForAgent: entry.textForAgent,
+        attachments: [],
+        hasPayloadData: false,
+        requiresRepair: true,
+    };
+}
+async function recoverCapturedBlueBubblesInboundMessages(deps = {}) {
+    const resolvedDeps = { ...defaultDeps, ...deps };
+    const agentName = resolvedDeps.getAgentName();
+    const client = resolvedDeps.createClient();
+    const result = { recovered: 0, skipped: 0, failed: 0 };
+    const seenMessageGuids = new Set();
+    const candidates = (0, inbound_log_1.listRecordedBlueBubblesInbound)(agentName)
+        .filter((entry) => {
+        if (seenMessageGuids.has(entry.messageGuid))
+            return false;
+        seenMessageGuids.add(entry.messageGuid);
+        return true;
+    })
+        .sort((left, right) => (parseTimestampMs(left.recordedAt) ?? 0) - (parseTimestampMs(right.recordedAt) ?? 0));
+    for (const entry of candidates) {
+        if ((0, processed_log_1.hasProcessedBlueBubblesMessage)(agentName, entry.sessionKey, entry.messageGuid)
+            || isBlueBubblesMessageInFlight(entry.sessionKey, entry.messageGuid)) {
+            result.skipped++;
+            continue;
+        }
+        try {
+            const repaired = await client.repairEvent(inboundEntryToRecoveryEvent(entry));
+            if (repaired.kind !== "message") {
+                result.skipped++;
+                continue;
+            }
+            const handled = await handleBlueBubblesNormalizedEvent(repaired, resolvedDeps, entry.source);
+            if (handled.reason === "already_processed") {
+                result.skipped++;
+            }
+            else {
+                result.recovered++;
+            }
+        }
+        catch (error) {
+            result.failed++;
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "senses",
+                event: "senses.bluebubbles_capture_recovery_error",
+                message: "captured bluebubbles message recovery failed",
+                meta: {
+                    messageGuid: entry.messageGuid,
+                    sessionKey: entry.sessionKey,
+                    reason: error instanceof Error ? error.message : String(error),
+                },
+            });
+        }
+    }
+    return result;
+}
 async function recoverMissedBlueBubblesMessages(deps = {}) {
     const resolvedDeps = { ...defaultDeps, ...deps };
     const agentName = resolvedDeps.getAgentName();
     const client = resolvedDeps.createClient();
     const result = { recovered: 0, skipped: 0, pending: 0, failed: 0 };
     for (const candidate of (0, mutation_log_1.listBlueBubblesRecoveryCandidates)(agentName)) {
-        if ((0, inbound_log_1.hasRecordedBlueBubblesInbound)(agentName, candidate.sessionKey, candidate.messageGuid)) {
+        if ((0, processed_log_1.hasProcessedBlueBubblesMessage)(agentName, candidate.sessionKey, candidate.messageGuid)
+            || isBlueBubblesMessageInFlight(candidate.sessionKey, candidate.messageGuid)) {
             result.skipped++;
             continue;
         }