@ouro.bot/cli 0.1.0-alpha.729 → 0.1.0-alpha.730

package/dist/senses/bluebubbles/index.js

@@ -72,6 +72,7 @@ const pending_1 = require("../../mind/pending");
 const prompt_1 = require("../../mind/prompt");
 const mcp_manager_1 = require("../../repertoire/mcp-manager");
 const runtime_1 = require("../../nerves/runtime");
+const session_transaction_1 = require("../../mind/session-transaction");
 const orientation_frame_1 = require("../../heart/orientation-frame");
 const proactive_content_guard_1 = require("../proactive-content-guard");
 const bluebubbles_meta_guard_1 = require("../bluebubbles-meta-guard");
@@ -306,6 +307,7 @@ const defaultDeps = {
         bbFailoverStates.set(sessionKey, structuredClone(state));
     },
     recordProcessed: processed_log_1.recordProcessedBlueBubblesMessage,
+    withSessionTurnLease: session_transaction_1.withSessionTurnLease,
 };
 const BLUEBUBBLES_RUNTIME_SYNC_INTERVAL_MS = 30_000;
 const BLUEBUBBLES_RECOVERY_PASS_DELAY_MS = 1_000;
@@ -1513,551 +1515,560 @@ async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source, opt
             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),
-                    },
-                });
-            }
-            // Pre-load session inside the canonical turn lock so same-chat
-            // deliveries cannot race on stale trunk state.
-            const existing = resolvedDeps.loadSession(sessPath);
-            const sessionMessages = existing?.messages && existing.messages.length > 0
-                ? structuredClone(existing.messages)
-                : [{ role: "system", content: (0, prompt_1.flattenSystemPrompt)(await resolvedDeps.buildSystem("bluebubbles", {}, context)) }];
-            // Record EARLY for audit and crash recovery. This is capture truth, not
-            // a claim that the agent turn completed successfully.
-            const inboundSource = (options.semanticRecovery || 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,
-                    },
-                });
-                (0, processed_log_1.recordProcessedBlueBubblesMessage)(agentName, event, inboundSource, "session-bootstrap");
-                return { handled: true, notifiedAgent: false, kind: event.kind, reason: "already_processed" };
-            }
-            // The inbound event is canonical truth as soon as its canonical lane is
-            // reserved. Persist it before any supersedable orientation/provider work.
-            const priorMessages = sessionMessages;
-            const userMessage = {
-                role: "user",
-                content: buildInboundContent(event),
-            };
-            resolvedDeps.saveSession(sessPath, [...structuredClone(sessionMessages), structuredClone(userMessage)], existing?.lastUsage, existing?.state);
-            if (!await (0, latest_turn_1.awaitDeliveryAdmission)(options.latestTurnCapability)
-                || !(0, latest_turn_1.isCurrent)(options.latestTurnCapability)) {
-                return { handled: true, notifiedAgent: false, kind: event.kind, reason: "superseded" };
-            }
-            options.lifecycleSignal?.throwIfAborted();
-            const liveTurnId = (0, active_turns_1.beginBlueBubblesActiveTurn)(agentName, event);
-            activeTurnId = liveTurnId;
-            const mcpManager = await (0, mcp_manager_1.getSharedMcpManager)() ?? undefined;
-            if (event.chat.isGroup) {
-                await (0, friends_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.threadOriginatorGuid?.trim();
-            let repliedToText = null;
-            if (threadGuid) {
-                repliedToText = await client.getMessageText(threadGuid).catch(() => 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 },
-                });
-            }
-            // Shutdown can land during MCP/group/reply-context awaits above. Recheck
-            // before the remaining synchronous setup installs its lifecycle listener.
-            options.lifecycleSignal?.throwIfAborted();
-            const orientationFrame = (0, orientation_frame_1.buildOrientationFrame)({
-                channel: "bluebubbles",
-                messages: [...priorMessages, userMessage],
-                currentUserMessages: [userMessage],
-                structuredOutputs: existing?.structuredOutputs ?? [],
-                source: buildBlueBubblesOrientationSource(event, priorMessages, options.orientationEvidence, options.orientationConversationKind, repliedToText),
-            });
-            if (!(0, latest_turn_1.isCurrent)(options.latestTurnCapability)) {
-                return { handled: true, notifiedAgent: false, kind: event.kind, reason: "superseded" };
-            }
-            const turnStage = createBlueBubblesTurnStage(event.chat.sessionKey);
-            let finalTransportInvoked = false;
-            let finalTransportAccepted = false;
-            const outboundRuntimeConfig = (0, config_1.getBlueBubblesConfig)();
-            const callbacks = createBlueBubblesCallbacks(client, event.chat, replyTarget, event.chat.isGroup, () => (0, active_turns_1.noteBlueBubblesActiveTurnVisibleActivity)(agentName, liveTurnId), {
-                admitOutbound: async () => (!options.lifecycleSignal?.aborted
-                    && await (0, latest_turn_1.awaitDeliveryAdmission)(options.latestTurnCapability)
-                    && !options.lifecycleSignal?.aborted),
-                isOutboundCurrent: () => (!options.lifecycleSignal?.aborted
-                    && (0, latest_turn_1.isCurrent)(options.latestTurnCapability)),
-                isOutboundAdmittedNow: () => (!options.lifecycleSignal?.aborted
-                    && (0, latest_turn_1.isDeliveryAdmittedNow)(options.latestTurnCapability)),
-                onFinalTransportInvoked: () => {
-                    finalTransportInvoked = true;
-                },
-                onFinalTransportAccepted: () => {
-                    finalTransportAccepted = true;
-                },
-                durableOutbound: {
-                    agentRoot: (0, identity_1.getAgentRoot)(),
-                    idempotencyKey: blueBubblesInboundReplyIdempotencyKey(options.currentIngressEvidence.captureKeyHash),
-                    attachment: {
-                        serverUrl: outboundRuntimeConfig.serverUrl,
-                        accountId: outboundRuntimeConfig.accountId,
-                    },
-                },
-            });
-            const controller = new AbortController();
-            const lifecycleSignal = options.lifecycleSignal;
-            let rejectLifecycle;
-            const lifecyclePromise = new Promise((_resolve, reject) => {
-                rejectLifecycle = reject;
-            });
-            let resolveSupersession;
-            const supersessionPromise = new Promise((resolve) => {
-                resolveSupersession = resolve;
-            });
-            const cancelForSupersession = () => {
-                callbacks.cancelOutbound("superseded");
-                if (!finalTransportInvoked) {
-                    controller.abort(options.latestTurnCapability.signal.reason);
-                    resolveSupersession({
-                        handled: true,
-                        notifiedAgent: false,
-                        kind: event.kind,
-                        reason: "superseded",
-                    });
-                }
-            };
-            options.latestTurnCapability.signal.addEventListener("abort", cancelForSupersession, { once: true });
-            const cancelForShutdown = () => {
-                callbacks.cancelOutbound("shutdown");
-                if (!finalTransportInvoked) {
-                    const reason = lifecycleSignal.reason;
-                    controller.abort(reason);
-                    rejectLifecycle(reason);
-                }
-            };
-            lifecycleSignal?.addEventListener("abort", cancelForShutdown, { once: true });
-            let timeoutTimer;
-            let timeoutPromise;
-            let resolveTimeout;
-            let recoveryTimedOut = false;
-            // BB-specific tool context wrappers
-            const summarize = (0, core_1.createSummarize)("human");
-            const bbCapabilities = (0, friends_1.getChannelCapabilities)("bluebubbles");
-            const pendingDir = (0, pending_1.getPendingDir)(resolvedDeps.getAgentName(), friendId, "bluebubbles", event.chat.sessionKey);
-            // 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 {
-                // ── Compute trust gate context for group/acquaintance rules ─────
-                // These store reads can block on filesystem I/O. Race them against the
-                // runtime lifecycle before constructing the shared pipeline so a closed
-                // worker cannot begin new durable or outward work after the read settles.
-                const trustContext = await Promise.race([
-                    Promise.all([
-                        checkGroupHasFamilyMember(store, event),
-                        event.chat.isGroup
-                            ? Promise.resolve(false)
-                            : checkHasExistingGroupWithFamily(store, context.friend),
-                    ]),
-                    lifecyclePromise,
-                    supersessionPromise.then(() => null),
-                ]);
-                if (trustContext === null) {
-                    return {
-                        handled: true,
-                        notifiedAgent: false,
-                        kind: event.kind,
-                        reason: "superseded",
-                    };
+            return await resolvedDeps.withSessionTurnLease(sessPath, async (sessionTurnLease) => {
+                try {
+                    (0, session_cleanup_1.findObsoleteBlueBubblesThreadSessions)(sessPath);
                 }
-                const [groupHasFamilyMember, hasExistingGroupWithFamily] = trustContext;
-                lifecycleSignal?.throwIfAborted();
-                // ── Call shared pipeline ────────────────────────────────────────
-                const timeoutMs = options.timeoutMs ?? BLUEBUBBLES_LIVE_TURN_TIMEOUT_MS;
-                timeoutPromise = new Promise((resolve) => {
-                    resolveTimeout = resolve;
-                });
-                timeoutTimer = setTimeout(() => {
-                    const reason = new BlueBubblesRecoveryTurnTimeoutError(timeoutMs);
-                    recoveryTimedOut = true;
-                    if (!finalTransportInvoked) {
-                        resolveTimeout?.({
-                            handled: true,
-                            notifiedAgent: false,
-                            kind: event.kind,
-                            reason: "turn_timeout",
-                        });
-                    }
-                    callbacks.cancelOutbound("turn_timeout");
-                    (0, latest_turn_1.cancel)(options.latestTurnCapability, "turn_timeout");
-                    if (!finalTransportInvoked)
-                        controller.abort(reason);
+                catch (error) {
                     (0, runtime_1.emitNervesEvent)({
                         level: "warn",
                         component: "senses",
-                        event: "senses.bluebubbles_turn_timeout",
-                        message: "bluebubbles turn timed out",
+                        event: "senses.bluebubbles_thread_lane_cleanup_error",
+                        message: "failed to inspect obsolete bluebubbles thread-lane sessions",
                         meta: {
-                            messageGuid: event.messageGuid,
-                            sessionKey: event.chat.sessionKey,
-                            source,
-                            timeoutMs,
+                            sessionPath: sessPath,
+                            reason: error instanceof Error ? error.message : String(error),
                         },
                     });
+                }
+                // Pre-load session inside the canonical turn lock so same-chat
+                // deliveries cannot race on stale trunk state.
+                const existing = resolvedDeps.loadSession(sessPath);
+                const sessionMessages = existing?.messages && existing.messages.length > 0
+                    ? structuredClone(existing.messages)
+                    : [{ role: "system", content: (0, prompt_1.flattenSystemPrompt)(await resolvedDeps.buildSystem("bluebubbles", {}, context)) }];
+                // Record EARLY for audit and crash recovery. This is capture truth, not
+                // a claim that the agent turn completed successfully.
+                const inboundSource = (options.semanticRecovery || 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)({
-                        level: "warn",
                         component: "senses",
-                        event: "senses.bluebubbles_timeout_notice_suppressed",
-                        message: "bluebubbles timeout notice suppressed from iMessage",
+                        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,
-                            timeoutMs,
                         },
                     });
-                }, timeoutMs);
-                /* v8 ignore next -- timer handles expose unref only in some runtimes @preserve */
-                if (typeof timeoutTimer.unref === "function") {
-                    timeoutTimer.unref();
+                    (0, processed_log_1.recordProcessedBlueBubblesMessage)(agentName, event, inboundSource, "session-bootstrap");
+                    return { handled: true, notifiedAgent: false, kind: event.kind, reason: "already_processed" };
                 }
-                let preparedBlueBubblesContext = {
-                    messages: [],
-                    contextPacketIds: [],
+                // The inbound event is canonical truth as soon as its canonical lane is
+                // reserved. Persist it before any supersedable orientation/provider work.
+                const priorMessages = sessionMessages;
+                const userMessage = {
+                    role: "user",
+                    content: buildInboundContent(event),
                 };
-                const turnPromise = (0, pipeline_1.handleInboundTurn)({
+                resolvedDeps.saveSession(sessPath, [...structuredClone(sessionMessages), structuredClone(userMessage)], existing?.lastUsage, existing?.state);
+                if (!await (0, latest_turn_1.awaitDeliveryAdmission)(options.latestTurnCapability)
+                    || !(0, latest_turn_1.isCurrent)(options.latestTurnCapability)) {
+                    return { handled: true, notifiedAgent: false, kind: event.kind, reason: "superseded" };
+                }
+                options.lifecycleSignal?.throwIfAborted();
+                const liveTurnId = (0, active_turns_1.beginBlueBubblesActiveTurn)(agentName, event);
+                activeTurnId = liveTurnId;
+                const mcpManager = await (0, mcp_manager_1.getSharedMcpManager)() ?? undefined;
+                if (event.chat.isGroup) {
+                    await (0, friends_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.threadOriginatorGuid?.trim();
+                let repliedToText = null;
+                if (threadGuid) {
+                    repliedToText = await client.getMessageText(threadGuid).catch(() => 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 },
+                    });
+                }
+                // Shutdown can land during MCP/group/reply-context awaits above. Recheck
+                // before the remaining synchronous setup installs its lifecycle listener.
+                options.lifecycleSignal?.throwIfAborted();
+                const orientationFrame = (0, orientation_frame_1.buildOrientationFrame)({
                     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,
-                            structuredOutputs: existing?.structuredOutputs,
-                        }),
+                    messages: [...priorMessages, userMessage],
+                    currentUserMessages: [userMessage],
+                    structuredOutputs: existing?.structuredOutputs ?? [],
+                    source: buildBlueBubblesOrientationSource(event, priorMessages, options.orientationEvidence, options.orientationConversationKind, repliedToText),
+                });
+                if (!(0, latest_turn_1.isCurrent)(options.latestTurnCapability)) {
+                    return { handled: true, notifiedAgent: false, kind: event.kind, reason: "superseded" };
+                }
+                const turnStage = createBlueBubblesTurnStage(event.chat.sessionKey);
+                let finalTransportInvoked = false;
+                let finalTransportAccepted = false;
+                const outboundRuntimeConfig = (0, config_1.getBlueBubblesConfig)();
+                const callbacks = createBlueBubblesCallbacks(client, event.chat, replyTarget, event.chat.isGroup, () => (0, active_turns_1.noteBlueBubblesActiveTurnVisibleActivity)(agentName, liveTurnId), {
+                    admitOutbound: async () => (!options.lifecycleSignal?.aborted
+                        && await (0, latest_turn_1.awaitDeliveryAdmission)(options.latestTurnCapability)
+                        && !options.lifecycleSignal?.aborted),
+                    isOutboundCurrent: () => (!options.lifecycleSignal?.aborted
+                        && (0, latest_turn_1.isCurrent)(options.latestTurnCapability)),
+                    isOutboundAdmittedNow: () => (!options.lifecycleSignal?.aborted
+                        && (0, latest_turn_1.isDeliveryAdmittedNow)(options.latestTurnCapability)),
+                    onFinalTransportInvoked: () => {
+                        finalTransportInvoked = true;
                     },
-                    pendingDir,
-                    friendStore: store,
-                    provider: "imessage-handle",
-                    externalId: event.sender.externalId,
-                    isGroupChat: event.chat.isGroup,
-                    groupHasFamilyMember,
-                    hasExistingGroupWithFamily,
-                    enforceTrustGate: trust_gate_1.enforceTrustGate,
-                    drainPending: pending_1.drainPending,
-                    drainDeferredReturns: (deferredFriendId) => (0, pending_1.drainDeferredReturns)(resolvedDeps.getAgentName(), deferredFriendId),
-                    prepareRunAgentOptions: async ({ messages = [], currentUserMessages = [], runAgentOptions }) => {
-                        preparedBlueBubblesContext = await buildBlueBubblesContextMessages({
-                            agentName,
-                            agentRoot: (0, identity_1.getAgentRoot)(),
-                            client,
-                            event,
-                            knownMessages: messages,
+                    onFinalTransportAccepted: () => {
+                        finalTransportAccepted = true;
+                    },
+                    durableOutbound: {
+                        agentRoot: (0, identity_1.getAgentRoot)(),
+                        idempotencyKey: blueBubblesInboundReplyIdempotencyKey(options.currentIngressEvidence.captureKeyHash),
+                        attachment: {
+                            serverUrl: outboundRuntimeConfig.serverUrl,
+                            accountId: outboundRuntimeConfig.accountId,
+                        },
+                    },
+                });
+                const controller = new AbortController();
+                const lifecycleSignal = options.lifecycleSignal;
+                let rejectLifecycle;
+                const lifecyclePromise = new Promise((_resolve, reject) => {
+                    rejectLifecycle = reject;
+                });
+                let resolveSupersession;
+                const supersessionPromise = new Promise((resolve) => {
+                    resolveSupersession = resolve;
+                });
+                const cancelForSupersession = () => {
+                    callbacks.cancelOutbound("superseded");
+                    if (!finalTransportInvoked) {
+                        controller.abort(options.latestTurnCapability.signal.reason);
+                        resolveSupersession({
+                            handled: true,
+                            notifiedAgent: false,
+                            kind: event.kind,
+                            reason: "superseded",
                         });
-                        const currentUserMessage = currentUserMessages.findLast((message) => message.role === "user")
-                            ?? messages.findLast((message) => message.role === "user");
-                        if (!currentUserMessage)
-                            return undefined;
-                        Object.freeze(currentUserMessage);
-                        const { verifiedPredecessorMessage } = preparedBlueBubblesContext;
+                    }
+                };
+                options.latestTurnCapability.signal.addEventListener("abort", cancelForSupersession, { once: true });
+                const cancelForShutdown = () => {
+                    callbacks.cancelOutbound("shutdown");
+                    if (!finalTransportInvoked) {
+                        const reason = lifecycleSignal.reason;
+                        controller.abort(reason);
+                        rejectLifecycle(reason);
+                    }
+                };
+                lifecycleSignal?.addEventListener("abort", cancelForShutdown, { once: true });
+                let timeoutTimer;
+                let timeoutPromise;
+                let resolveTimeout;
+                let recoveryTimedOut = false;
+                let activeRunTurn = null;
+                // BB-specific tool context wrappers
+                const summarize = (0, core_1.createSummarize)("human");
+                const bbCapabilities = (0, friends_1.getChannelCapabilities)("bluebubbles");
+                const pendingDir = (0, pending_1.getPendingDir)(resolvedDeps.getAgentName(), friendId, "bluebubbles", event.chat.sessionKey);
+                // 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 {
+                    // ── Compute trust gate context for group/acquaintance rules ─────
+                    // These store reads can block on filesystem I/O. Race them against the
+                    // runtime lifecycle before constructing the shared pipeline so a closed
+                    // worker cannot begin new durable or outward work after the read settles.
+                    const trustContext = await Promise.race([
+                        Promise.all([
+                            checkGroupHasFamilyMember(store, event),
+                            event.chat.isGroup
+                                ? Promise.resolve(false)
+                                : checkHasExistingGroupWithFamily(store, context.friend),
+                        ]),
+                        lifecyclePromise,
+                        supersessionPromise.then(() => null),
+                    ]);
+                    if (trustContext === null) {
                         return {
-                            ...(preparedBlueBubblesContext.contextPacketIds.length > 0 ? {
-                                contextPacketIds: [
-                                    ...(runAgentOptions.contextPacketIds ?? []),
-                                    ...preparedBlueBubblesContext.contextPacketIds,
-                                ],
-                            } : {}),
-                            ...(preparedBlueBubblesContext.messages.length > 0 ? {
-                                promptOnlyEvidenceMessages: preparedBlueBubblesContext.messages,
-                            } : {}),
-                            requiredPromptEvidence: {
-                                currentUserMessage,
-                                ...(verifiedPredecessorMessage ? { verifiedPredecessorMessage } : {}),
-                            },
+                            handled: true,
+                            notifiedAgent: false,
+                            kind: event.kind,
+                            reason: "superseded",
                         };
-                    },
-                    runAgent: async (msgs, cb, channel, sig, opts) => {
-                        const { codingFeedback: _omittedCodingFeedback, ...safeToolContext } = opts?.toolContext ?? {};
-                        const requiredCurrent = opts?.requiredPromptEvidence?.currentUserMessage;
-                        const providerMessages = insertEphemeralContextMessages(msgs.map((message) => message === requiredCurrent ? message : structuredClone(message)), [
-                            ...preparedBlueBubblesContext.messages,
-                            ...(preparedBlueBubblesContext.verifiedPredecessorMessage
-                                ? [preparedBlueBubblesContext.verifiedPredecessorMessage]
-                                : []),
-                        ], requiredCurrent);
-                        let generatedMessages = [];
-                        const agentResult = await resolvedDeps.runAgent(providerMessages, cb, channel, sig, {
-                            ...opts,
-                            captureGeneratedMessages: (generated) => {
-                                opts?.captureGeneratedMessages?.(generated);
-                                generatedMessages = structuredClone(generated);
+                    }
+                    const [groupHasFamilyMember, hasExistingGroupWithFamily] = trustContext;
+                    lifecycleSignal?.throwIfAborted();
+                    // ── Call shared pipeline ────────────────────────────────────────
+                    const timeoutMs = options.timeoutMs ?? BLUEBUBBLES_LIVE_TURN_TIMEOUT_MS;
+                    timeoutPromise = new Promise((resolve) => {
+                        resolveTimeout = resolve;
+                    });
+                    timeoutTimer = setTimeout(() => {
+                        const reason = new BlueBubblesRecoveryTurnTimeoutError(timeoutMs);
+                        recoveryTimedOut = true;
+                        if (!finalTransportInvoked) {
+                            resolveTimeout?.({
+                                handled: true,
+                                notifiedAgent: false,
+                                kind: event.kind,
+                                reason: "turn_timeout",
+                            });
+                        }
+                        callbacks.cancelOutbound("turn_timeout");
+                        (0, latest_turn_1.cancel)(options.latestTurnCapability, "turn_timeout");
+                        if (!finalTransportInvoked)
+                            controller.abort(reason);
+                        (0, runtime_1.emitNervesEvent)({
+                            level: "warn",
+                            component: "senses",
+                            event: "senses.bluebubbles_turn_timeout",
+                            message: "bluebubbles turn timed out",
+                            meta: {
+                                messageGuid: event.messageGuid,
+                                sessionKey: event.chat.sessionKey,
+                                source,
+                                timeoutMs,
                             },
-                            toolContext: {
-                                /* v8 ignore next -- default no-op signin; pipeline provides the real one @preserve */
-                                signin: async () => undefined,
-                                ...safeToolContext,
-                                summarize,
-                                bluebubblesReplyTarget: {
-                                    setSelection: (selection) => replyTarget.setSelection(selection),
-                                },
+                        });
+                        (0, runtime_1.emitNervesEvent)({
+                            level: "warn",
+                            component: "senses",
+                            event: "senses.bluebubbles_timeout_notice_suppressed",
+                            message: "bluebubbles timeout notice suppressed from iMessage",
+                            meta: {
+                                messageGuid: event.messageGuid,
+                                sessionKey: event.chat.sessionKey,
+                                source,
+                                timeoutMs,
                             },
                         });
-                        if (generatedMessages.length > 0) {
-                            msgs.push(...generatedMessages);
-                        }
-                        return agentResult;
-                    },
-                    postTurn: (turnMessages, sessionPathArg, usage, hooks, state) => {
-                        const prepared = resolvedDeps.postTurnTrim(turnMessages, usage, hooks);
-                        turnStage.postTurn = {
-                            sessionPath: sessionPathArg,
-                            prepared,
-                            usage,
-                            state,
-                        };
-                    },
-                    accumulateFriendTokens: async (tokenStore, tokenFriendId, usage) => {
-                        turnStage.tokens = {
-                            store: tokenStore,
-                            friendId: tokenFriendId,
-                            usage,
-                        };
-                    },
-                    signal: controller.signal,
-                    runAgentOptions: {
-                        mcpManager,
-                        orientationFrame,
-                        toolContext: {
-                            signin: async () => undefined,
-                            agentRoot: (0, identity_1.getAgentRoot)(),
-                            currentIngressEvidence: options.currentIngressEvidence,
+                    }, timeoutMs);
+                    /* v8 ignore next -- timer handles expose unref only in some runtimes @preserve */
+                    if (typeof timeoutTimer.unref === "function") {
+                        timeoutTimer.unref();
+                    }
+                    let preparedBlueBubblesContext = {
+                        messages: [],
+                        contextPacketIds: [],
+                    };
+                    const turnPromise = (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,
+                                structuredOutputs: existing?.structuredOutputs,
+                            }),
                         },
-                    },
-                    callbacks: failoverAwareCallbacks,
-                    failoverState: turnStage.failoverState,
-                });
-                /* v8 ignore start -- detached late-rejection telemetry is asserted in timeout tests, but V8 does not reliably attribute Promise.catch callbacks @preserve */
-                void turnPromise
-                    .catch((error) => {
-                    if (!recoveryTimedOut)
-                        return;
-                    (0, runtime_1.emitNervesEvent)({
-                        level: "warn",
-                        component: "senses",
-                        event: "senses.bluebubbles_recovery_error",
-                        message: "bluebubbles recovery turn rejected after timeout",
-                        meta: {
-                            messageGuid: event.messageGuid,
-                            sessionKey: event.chat.sessionKey,
-                            source,
-                            reason: error instanceof Error ? error.message : String(error),
+                        pendingDir,
+                        friendStore: store,
+                        provider: "imessage-handle",
+                        externalId: event.sender.externalId,
+                        isGroupChat: event.chat.isGroup,
+                        groupHasFamilyMember,
+                        hasExistingGroupWithFamily,
+                        enforceTrustGate: trust_gate_1.enforceTrustGate,
+                        drainPending: pending_1.drainPending,
+                        drainDeferredReturns: (deferredFriendId) => (0, pending_1.drainDeferredReturns)(resolvedDeps.getAgentName(), deferredFriendId),
+                        prepareRunAgentOptions: async ({ messages = [], currentUserMessages = [], runAgentOptions }) => {
+                            preparedBlueBubblesContext = await buildBlueBubblesContextMessages({
+                                agentName,
+                                agentRoot: (0, identity_1.getAgentRoot)(),
+                                client,
+                                event,
+                                knownMessages: messages,
+                            });
+                            const currentUserMessage = currentUserMessages.findLast((message) => message.role === "user")
+                                ?? messages.findLast((message) => message.role === "user");
+                            if (!currentUserMessage)
+                                return undefined;
+                            Object.freeze(currentUserMessage);
+                            const { verifiedPredecessorMessage } = preparedBlueBubblesContext;
+                            return {
+                                ...(preparedBlueBubblesContext.contextPacketIds.length > 0 ? {
+                                    contextPacketIds: [
+                                        ...(runAgentOptions.contextPacketIds ?? []),
+                                        ...preparedBlueBubblesContext.contextPacketIds,
+                                    ],
+                                } : {}),
+                                ...(preparedBlueBubblesContext.messages.length > 0 ? {
+                                    promptOnlyEvidenceMessages: preparedBlueBubblesContext.messages,
+                                } : {}),
+                                requiredPromptEvidence: {
+                                    currentUserMessage,
+                                    ...(verifiedPredecessorMessage ? { verifiedPredecessorMessage } : {}),
+                                },
+                            };
+                        },
+                        runAgent: async (msgs, cb, channel, sig, opts) => {
+                            const { codingFeedback: _omittedCodingFeedback, ...safeToolContext } = opts?.toolContext ?? {};
+                            const requiredCurrent = opts?.requiredPromptEvidence?.currentUserMessage;
+                            const providerMessages = insertEphemeralContextMessages(msgs.map((message) => message === requiredCurrent ? message : structuredClone(message)), [
+                                ...preparedBlueBubblesContext.messages,
+                                ...(preparedBlueBubblesContext.verifiedPredecessorMessage
+                                    ? [preparedBlueBubblesContext.verifiedPredecessorMessage]
+                                    : []),
+                            ], requiredCurrent);
+                            let generatedMessages = [];
+                            const agentResult = await resolvedDeps.runAgent(providerMessages, cb, channel, sig, {
+                                ...opts,
+                                captureGeneratedMessages: (generated) => {
+                                    opts?.captureGeneratedMessages?.(generated);
+                                    generatedMessages = structuredClone(generated);
+                                },
+                                toolContext: {
+                                    /* v8 ignore next -- default no-op signin; pipeline provides the real one @preserve */
+                                    signin: async () => undefined,
+                                    ...safeToolContext,
+                                    summarize,
+                                    bluebubblesReplyTarget: {
+                                        setSelection: (selection) => replyTarget.setSelection(selection),
+                                    },
+                                },
+                            });
+                            if (generatedMessages.length > 0) {
+                                msgs.push(...generatedMessages);
+                            }
+                            return agentResult;
+                        },
+                        postTurn: (turnMessages, sessionPathArg, usage, hooks, state) => {
+                            const prepared = resolvedDeps.postTurnTrim(turnMessages, usage, hooks);
+                            turnStage.postTurn = {
+                                sessionPath: sessionPathArg,
+                                prepared,
+                                usage,
+                                state,
+                            };
+                        },
+                        accumulateFriendTokens: async (tokenStore, tokenFriendId, usage) => {
+                            turnStage.tokens = {
+                                store: tokenStore,
+                                friendId: tokenFriendId,
+                                usage,
+                            };
+                        },
+                        signal: controller.signal,
+                        runAgentOptions: {
+                            mcpManager,
+                            orientationFrame,
+                            toolContext: {
+                                signin: async () => undefined,
+                                agentRoot: (0, identity_1.getAgentRoot)(),
+                                currentIngressEvidence: options.currentIngressEvidence,
+                            },
                         },
+                        callbacks: failoverAwareCallbacks,
+                        sessionTurnLease,
+                        failoverState: turnStage.failoverState,
                     });
-                });
-                /* v8 ignore stop */
-                const runTurn = (async () => {
-                    const result = await turnPromise;
-                    if (recoveryTimedOut && !finalTransportInvoked) {
+                    /* v8 ignore start -- detached late-rejection telemetry is asserted in timeout tests, but V8 does not reliably attribute Promise.catch callbacks @preserve */
+                    void turnPromise
+                        .catch((error) => {
+                        if (!recoveryTimedOut)
+                            return;
                         (0, runtime_1.emitNervesEvent)({
                             level: "warn",
                             component: "senses",
-                            event: "senses.bluebubbles_timed_out_turn_suppressed",
-                            message: "suppressed late bluebubbles turn result after timeout",
+                            event: "senses.bluebubbles_recovery_error",
+                            message: "bluebubbles recovery turn rejected after timeout",
                             meta: {
                                 messageGuid: event.messageGuid,
                                 sessionKey: event.chat.sessionKey,
                                 source,
-                                reason: "turn completed after its final-transport boundary closed",
+                                reason: error instanceof Error ? error.message : String(error),
                             },
                         });
-                        return {
-                            handled: true,
-                            notifiedAgent: false,
-                            kind: event.kind,
-                            reason: "turn_timeout",
-                        };
-                    }
-                    /* v8 ignore start -- failover display + error replay @preserve */
-                    if (result.failoverMessage) {
-                        callbacks.onClearText?.();
-                        callbacks.onTextChunk(result.failoverMessage);
-                        bufferedTerminalError = null;
-                    }
-                    else if (bufferedTerminalError) {
-                        callbacks.onError(bufferedTerminalError, "terminal");
-                        bufferedTerminalError = null;
-                    }
+                    });
                     /* v8 ignore stop */
-                    // ── Handle gate result ────────────────────────────────────────
-                    let processedOutcome = "turn-complete";
-                    if (!result.gateResult.allowed) {
-                        callbacks.onClearText?.();
-                        if ("autoReply" in result.gateResult && result.gateResult.autoReply) {
-                            callbacks.onTextChunk(result.gateResult.autoReply);
+                    const runTurn = (async () => {
+                        const result = await turnPromise;
+                        if (recoveryTimedOut && !finalTransportInvoked) {
+                            (0, runtime_1.emitNervesEvent)({
+                                level: "warn",
+                                component: "senses",
+                                event: "senses.bluebubbles_timed_out_turn_suppressed",
+                                message: "suppressed late bluebubbles turn result after timeout",
+                                meta: {
+                                    messageGuid: event.messageGuid,
+                                    sessionKey: event.chat.sessionKey,
+                                    source,
+                                    reason: "turn completed after its final-transport boundary closed",
+                                },
+                            });
+                            return {
+                                handled: true,
+                                notifiedAgent: false,
+                                kind: event.kind,
+                                reason: "turn_timeout",
+                            };
                         }
-                        processedOutcome = "trust-gated";
-                    }
-                    let delivery;
-                    try {
-                        delivery = await callbacks.flush({ signal: controller.signal });
-                    }
-                    catch (error) {
+                        /* v8 ignore start -- failover display + error replay @preserve */
+                        if (result.failoverMessage) {
+                            callbacks.onClearText?.();
+                            callbacks.onTextChunk(result.failoverMessage);
+                            bufferedTerminalError = null;
+                        }
+                        else if (bufferedTerminalError) {
+                            callbacks.onError(bufferedTerminalError, "terminal");
+                            bufferedTerminalError = null;
+                        }
+                        /* v8 ignore stop */
+                        // ── Handle gate result ────────────────────────────────────────
+                        let processedOutcome = "turn-complete";
+                        if (!result.gateResult.allowed) {
+                            callbacks.onClearText?.();
+                            if ("autoReply" in result.gateResult && result.gateResult.autoReply) {
+                                callbacks.onTextChunk(result.gateResult.autoReply);
+                            }
+                            processedOutcome = "trust-gated";
+                        }
+                        let delivery;
+                        try {
+                            delivery = await callbacks.flush({ signal: controller.signal });
+                        }
+                        catch (error) {
+                            (0, runtime_1.emitNervesEvent)({
+                                level: "warn",
+                                component: "senses",
+                                event: "senses.bluebubbles_final_transport_failed",
+                                message: "bluebubbles final transport failed after invocation",
+                                meta: {
+                                    messageGuid: event.messageGuid,
+                                    sessionKey: event.chat.sessionKey,
+                                    reason: error instanceof Error ? error.message : String(error),
+                                },
+                            });
+                            return {
+                                handled: true,
+                                notifiedAgent: false,
+                                kind: event.kind,
+                                reason: "delivery_failed",
+                            };
+                        }
+                        if (delivery.status !== "accepted" || !finalTransportAccepted) {
+                            return {
+                                handled: true,
+                                notifiedAgent: false,
+                                kind: event.kind,
+                                reason: !(0, latest_turn_1.isCurrent)(options.latestTurnCapability)
+                                    ? "superseded"
+                                    : "no_visible_reply",
+                            };
+                        }
+                        // Acceptance is the visibility boundary. Publish the terminal dedupe
+                        // receipt first, then project the private generated tail while this
+                        // chat's canonical lock remains held. Even if receipt publication
+                        // fails, make the best possible canonical projection before surfacing
+                        // the retained-claim failure. Ancillary accounting follows both.
+                        let receiptFailed = false;
+                        let receiptFailure;
+                        try {
+                            options.publishAcceptedReceipt();
+                        }
+                        catch (error) {
+                            receiptFailed = true;
+                            receiptFailure = error;
+                        }
+                        persistAcceptedBlueBubblesProjection({
+                            stage: turnStage,
+                            deps: resolvedDeps,
+                            event,
+                        });
+                        if (receiptFailed)
+                            throw receiptFailure;
+                        promoteAcceptedBlueBubblesAncillaryState({
+                            stage: turnStage,
+                            deps: resolvedDeps,
+                            agentName,
+                            event,
+                            source,
+                            processedOutcome,
+                        });
                         (0, runtime_1.emitNervesEvent)({
-                            level: "warn",
                             component: "senses",
-                            event: "senses.bluebubbles_final_transport_failed",
-                            message: "bluebubbles final transport failed after invocation",
+                            event: "senses.bluebubbles_turn_end",
+                            message: "bluebubbles event handled",
                             meta: {
                                 messageGuid: event.messageGuid,
+                                kind: event.kind,
                                 sessionKey: event.chat.sessionKey,
-                                reason: error instanceof Error ? error.message : String(error),
                             },
                         });
                         return {
                             handled: true,
-                            notifiedAgent: false,
-                            kind: event.kind,
-                            reason: "delivery_failed",
-                        };
-                    }
-                    if (delivery.status !== "accepted" || !finalTransportAccepted) {
-                        return {
-                            handled: true,
-                            notifiedAgent: false,
+                            notifiedAgent: true,
                             kind: event.kind,
-                            reason: !(0, latest_turn_1.isCurrent)(options.latestTurnCapability)
-                                ? "superseded"
-                                : "no_visible_reply",
                         };
-                    }
-                    // Acceptance is the visibility boundary. Publish the terminal dedupe
-                    // receipt first, then project the private generated tail while this
-                    // chat's canonical lock remains held. Even if receipt publication
-                    // fails, make the best possible canonical projection before surfacing
-                    // the retained-claim failure. Ancillary accounting follows both.
-                    let receiptFailed = false;
-                    let receiptFailure;
-                    try {
-                        options.publishAcceptedReceipt();
-                    }
-                    catch (error) {
-                        receiptFailed = true;
-                        receiptFailure = error;
-                    }
-                    persistAcceptedBlueBubblesProjection({
-                        stage: turnStage,
-                        deps: resolvedDeps,
-                        event,
-                    });
-                    if (receiptFailed)
-                        throw receiptFailure;
-                    promoteAcceptedBlueBubblesAncillaryState({
-                        stage: turnStage,
-                        deps: resolvedDeps,
-                        agentName,
-                        event,
-                        source,
-                        processedOutcome,
-                    });
-                    (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,
-                    };
-                })();
-                /* v8 ignore start -- detached post-timeout suppression telemetry @preserve */
-                void runTurn.catch((error) => {
-                    if (!recoveryTimedOut)
-                        return;
-                    (0, runtime_1.emitNervesEvent)({
-                        level: "warn",
-                        component: "senses",
-                        event: "senses.bluebubbles_timed_out_turn_suppressed",
-                        message: "suppressed late bluebubbles turn result after timeout",
-                        meta: {
-                            messageGuid: event.messageGuid,
-                            sessionKey: event.chat.sessionKey,
-                            source,
-                            reason: error instanceof Error ? error.message : String(error),
-                        },
+                    })();
+                    activeRunTurn = runTurn;
+                    /* v8 ignore start -- detached post-timeout suppression telemetry @preserve */
+                    void runTurn.catch((error) => {
+                        if (!recoveryTimedOut)
+                            return;
+                        (0, runtime_1.emitNervesEvent)({
+                            level: "warn",
+                            component: "senses",
+                            event: "senses.bluebubbles_timed_out_turn_suppressed",
+                            message: "suppressed late bluebubbles turn result after timeout",
+                            meta: {
+                                messageGuid: event.messageGuid,
+                                sessionKey: event.chat.sessionKey,
+                                source,
+                                reason: error instanceof Error ? error.message : String(error),
+                            },
+                        });
                     });
-                });
-                /* v8 ignore stop */
-                return await Promise.race([runTurn, timeoutPromise, supersessionPromise, lifecyclePromise]);
-            }
-            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 */
+                    return await Promise.race([runTurn, timeoutPromise, supersessionPromise, lifecyclePromise]);
                 }
-                /* v8 ignore stop */
-                clearTimeout(timeoutTimer);
-                options.latestTurnCapability.signal.removeEventListener("abort", cancelForSupersession);
-                lifecycleSignal?.removeEventListener("abort", cancelForShutdown);
-                (0, active_turns_1.finishBlueBubblesActiveTurn)(agentName, liveTurnId);
-                activeTurnId = null;
-                await callbacks.finish({ timeoutMs: BLUEBUBBLES_CALLBACK_CLEANUP_TIMEOUT_MS });
-            }
+                finally {
+                    // A timed-out/superseded provider may ignore abort briefly. Never release
+                    // the cross-process session lease until that work has actually quiesced.
+                    if (activeRunTurn)
+                        await activeRunTurn.catch(() => undefined);
+                    // 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 */
+                    clearTimeout(timeoutTimer);
+                    options.latestTurnCapability.signal.removeEventListener("abort", cancelForSupersession);
+                    lifecycleSignal?.removeEventListener("abort", cancelForShutdown);
+                    (0, active_turns_1.finishBlueBubblesActiveTurn)(agentName, liveTurnId);
+                    activeTurnId = null;
+                    await callbacks.finish({ timeoutMs: BLUEBUBBLES_CALLBACK_CLEANUP_TIMEOUT_MS });
+                }
+            });
         });
     }
     finally {