@ouro.bot/cli 0.1.0-alpha.726 → 0.1.0-alpha.728

package/dist/senses/bluebubbles/index.js

@@ -33,11 +33,10 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BB_IN_FLIGHT_MAX_AGE_MS = void 0;
-exports.resolveReactionTarget = resolveReactionTarget;
+exports.BB_IN_FLIGHT_MAX_AGE_MS = exports.BLUEBUBBLES_SEMANTIC_GENERATION_RETENTION_MS = void 0;
+exports.pruneBlueBubblesSemanticObservationGenerations = pruneBlueBubblesSemanticObservationGenerations;
 exports.tokenizeForDedupe = tokenizeForDedupe;
 exports.jaccardSimilarity = jaccardSimilarity;
-exports.createStatusBatcher = createStatusBatcher;
 exports.isBlueBubblesMessageInFlight = isBlueBubblesMessageInFlight;
 exports.beginBlueBubblesMessageInFlight = beginBlueBubblesMessageInFlight;
 exports.endBlueBubblesMessageInFlight = endBlueBubblesMessageInFlight;
@@ -47,6 +46,7 @@ exports.isAgentSelfHandle = isAgentSelfHandle;
 exports.getDiscoveredOwnHandles = getDiscoveredOwnHandles;
 exports.clearDiscoveredOwnHandles = clearDiscoveredOwnHandles;
 exports.recordDiscoveredOwnHandle = recordDiscoveredOwnHandle;
+exports.seedBlueBubblesStartupSemanticObservations = seedBlueBubblesStartupSemanticObservations;
 exports.handleBlueBubblesEvent = handleBlueBubblesEvent;
 exports.recoverQueuedBlueBubblesMessages = recoverQueuedBlueBubblesMessages;
 exports.catchUpMissedBlueBubblesMessages = catchUpMissedBlueBubblesMessages;
@@ -63,6 +63,7 @@ const node_crypto_1 = require("node:crypto");
 const core_1 = require("../../heart/core");
 const config_1 = require("../../heart/config");
 const identity_1 = require("../../heart/identity");
+const machine_identity_1 = require("../../heart/machine-identity");
 const runtime_cwd_1 = require("../../heart/runtime-cwd");
 const turn_coordinator_1 = require("../../heart/turn-coordinator");
 const context_1 = require("../../mind/context");
@@ -76,6 +77,7 @@ const proactive_content_guard_1 = require("../proactive-content-guard");
 const bluebubbles_meta_guard_1 = require("../bluebubbles-meta-guard");
 const model_1 = require("./model");
 const client_1 = require("./client");
+const webhook_registration_1 = require("./webhook-registration");
 const inbound_log_1 = require("./inbound-log");
 const mutation_log_1 = require("./mutation-log");
 const processed_log_1 = require("./processed-log");
@@ -83,14 +85,106 @@ const semantic_receipts_1 = require("./semantic-receipts");
 const runtime_state_1 = require("./runtime-state");
 const session_cleanup_1 = require("./session-cleanup");
 const reaction_policy_1 = require("./reaction-policy");
+const latest_turn_1 = require("./latest-turn");
 const active_turns_1 = require("./active-turns");
 const trust_gate_1 = require("../trust-gate");
 const pipeline_1 = require("../pipeline");
-const context_packets_1 = require("../context-packets");
 const context_packet_ledger_1 = require("../context-packet-ledger");
 const context_packet_1 = require("./context-packet");
 const autonomy_budget_1 = require("../../heart/autonomy-budget");
+const outbound_state_1 = require("./outbound-state");
 const bbFailoverStates = new Map();
+const activeSemanticHandlingSlots = new Map();
+const semanticObservationGenerations = new Map();
+const BLUEBUBBLES_VISIBLE_OUTBOUND_STATUSES = new Set([
+    "accepted",
+    "enqueued",
+    "local-visible",
+    "delivered",
+]);
+exports.BLUEBUBBLES_SEMANTIC_GENERATION_RETENTION_MS = 15 * 60_000;
+function pruneBlueBubblesSemanticObservationGenerations(nowMs = Date.now()) {
+    let pruned = 0;
+    for (const [keyHash, generation] of semanticObservationGenerations) {
+        if (generation.retainedAtMs === null
+            || nowMs - generation.retainedAtMs < exports.BLUEBUBBLES_SEMANTIC_GENERATION_RETENTION_MS)
+            continue;
+        (0, latest_turn_1.clearPending)(generation.reservation);
+        semanticObservationGenerations.delete(keyHash);
+        pruned += 1;
+    }
+    return pruned;
+}
+function adoptBlueBubblesSemanticObservation(keyHash, observedReservation, activate) {
+    pruneBlueBubblesSemanticObservationGenerations();
+    const existing = semanticObservationGenerations.get(keyHash);
+    if (!existing) {
+        const generation = { reservation: observedReservation, retry: false, retainedAtMs: null };
+        semanticObservationGenerations.set(keyHash, generation);
+        return generation;
+    }
+    (0, latest_turn_1.mergeObservationReservations)(existing.reservation, observedReservation);
+    if (activate) {
+        existing.retainedAtMs = null;
+        (0, latest_turn_1.reactivateObservation)(existing.reservation);
+    }
+    return existing;
+}
+function suspendBlueBubblesSemanticObservation(generation) {
+    generation.retry = true;
+    generation.retainedAtMs = Date.now();
+    (0, latest_turn_1.reactivateObservation)(generation.reservation);
+}
+function completeBlueBubblesSemanticObservation(keyHash, generation) {
+    (0, latest_turn_1.clearPending)(generation.reservation);
+    semanticObservationGenerations.delete(keyHash);
+}
+async function acquireBlueBubblesSemanticHandlingSlot(keyHash, generation) {
+    const active = activeSemanticHandlingSlots.get(keyHash);
+    if (!active) {
+        const slot = {
+            generation,
+            reservation: generation.reservation,
+            waiters: [],
+        };
+        activeSemanticHandlingSlots.set(keyHash, slot);
+        return {
+            status: "owner",
+            slot,
+            reservation: generation.reservation,
+            allowSameGenerationRetry: generation.retry,
+        };
+    }
+    return await new Promise((resolve) => {
+        active.waiters.push(resolve);
+    });
+}
+function releaseBlueBubblesSemanticHandlingSlot(keyHash, slot, outcome) {
+    if (outcome === "retryable") {
+        slot.generation.retry = true;
+        const next = slot.waiters.shift();
+        if (next) {
+            (0, latest_turn_1.reactivateObservation)(slot.reservation);
+            next({
+                status: "owner",
+                slot,
+                reservation: slot.reservation,
+                allowSameGenerationRetry: true,
+            });
+            return;
+        }
+    }
+    activeSemanticHandlingSlots.delete(keyHash);
+    if (outcome === "terminal") {
+        completeBlueBubblesSemanticObservation(keyHash, slot.generation);
+    }
+    else {
+        suspendBlueBubblesSemanticObservation(slot.generation);
+    }
+    for (const resolve of slot.waiters.splice(0)) {
+        resolve({ status: "handled_by_owner" });
+    }
+}
 /**
  * In-flight message tracker.
  *
@@ -118,20 +212,6 @@ const bbInFlightMessageClaims = new Map();
  * a leaked marker from blocking forward progress for hours.
  */
 exports.BB_IN_FLIGHT_MAX_AGE_MS = 15 * 60_000;
-// Resolve the message a reaction points at, so the agent is told *what* was
-// reacted to and *whose* message it was rather than a bare "reacted with love".
-// Prefers the authorship-carrying lookup; falls back to text-only when the client
-// does not provide one. Every failure path returns an explicit "unknown" rather
-// than a value the caller could mistake for a resolved target.
-async function resolveReactionTarget(client, targetMessageGuid) {
-    const base = { guid: targetMessageGuid };
-    if (client.getMessageDetails) {
-        const details = await client.getMessageDetails(targetMessageGuid).catch(() => null);
-        return { ...base, text: details?.text ?? null, fromMe: details?.fromMe ?? null };
-    }
-    const text = await client.getMessageText(targetMessageGuid).catch(() => null);
-    return { ...base, text, fromMe: null };
-}
 // ── Near-duplicate outward-text detection ────────────────────────
 // Used by createBlueBubblesCallbacks to collapse mid-turn rephrasings of the
 // same answer/status into a single delivery. Exposed for direct unit testing
@@ -155,44 +235,6 @@ function jaccardSimilarity(a, b) {
     const union = a.size + b.size - intersection;
     return intersection / union;
 }
-/**
- * Accumulates status descriptions and debounces them.
- * If multiple descriptions arrive within `delayMs`, they are joined with ` · `
- * and sent as a single message. Flush sends immediately and clears the timer.
- */
-function createStatusBatcher(send, delayMs) {
-    (0, runtime_1.emitNervesEvent)({
-        component: "senses",
-        event: "senses.bluebubbles_status_batcher_created",
-        message: "status batcher initialized",
-        meta: { delayMs },
-    });
-    let pending = [];
-    let timer = null;
-    function fire() {
-        if (pending.length === 0)
-            return;
-        const combined = pending.join(" \u00b7 ");
-        pending = [];
-        timer = null;
-        send(combined);
-    }
-    return {
-        add(text) {
-            pending.push(text);
-            if (timer !== null)
-                clearTimeout(timer);
-            timer = setTimeout(fire, delayMs);
-        },
-        flush() {
-            if (timer !== null) {
-                clearTimeout(timer);
-                timer = null;
-            }
-            fire();
-        },
-    };
-}
 function blueBubblesMessageKey(sessionKey, messageGuid) {
     return `${sessionKey}:${messageGuid.trim()}`;
 }
@@ -249,8 +291,9 @@ const defaultDeps = {
     buildSystem: prompt_1.buildSystem,
     runAgent: core_1.runAgent,
     loadSession: context_1.loadSession,
+    saveSession: context_1.saveSession,
     postTurnTrim: context_1.postTurnTrim,
-    deferPostTurnPersist: context_1.deferPostTurnPersist,
+    postTurnPersist: context_1.postTurnPersist,
     sessionPath: config_1.sessionPath,
     accumulateFriendTokens: friends_1.accumulateFriendTokens,
     createClient: () => (0, client_1.createBlueBubblesClient)(),
@@ -259,6 +302,10 @@ const defaultDeps = {
     createFriendResolver: (store, params) => new friends_1.FriendResolver(store, params),
     createServer: http.createServer,
     getOwnHandles: () => [...(0, config_1.getBlueBubblesConfig)().ownHandles, ...discoveredOwnHandles],
+    promoteFailoverState: (sessionKey, state) => {
+        bbFailoverStates.set(sessionKey, structuredClone(state));
+    },
+    recordProcessed: processed_log_1.recordProcessedBlueBubblesMessage,
 };
 const BLUEBUBBLES_RUNTIME_SYNC_INTERVAL_MS = 30_000;
 const BLUEBUBBLES_RECOVERY_PASS_DELAY_MS = 1_000;
@@ -266,7 +313,6 @@ const BLUEBUBBLES_RECOVERY_PASS_INTERVAL_MS = 30_000;
 const BLUEBUBBLES_LIVE_TURN_TIMEOUT_MS = 2 * 60_000;
 const BLUEBUBBLES_RECOVERY_TURN_TIMEOUT_MS = 10 * 60_000;
 const BLUEBUBBLES_LIVE_TURN_STALLED_MS = 90_000;
-const BLUEBUBBLES_SILENCE_WATCHDOG_MS = 75_000;
 const BLUEBUBBLES_CALLBACK_CLEANUP_TIMEOUT_MS = 2_000;
 const BLUEBUBBLES_ACTIVITY_OPERATION_TIMEOUT_MS = 20_000;
 const BLUEBUBBLES_CATCHUP_PAGE_SIZE = 50;
@@ -280,32 +326,31 @@ class BlueBubblesRecoveryTurnTimeoutError extends Error {
         this.name = "BlueBubblesRecoveryTurnTimeoutError";
     }
 }
-function getBlueBubblesTimeoutReason(timeoutReason, timeoutMs) {
-    /* v8 ignore next 3 -- timeoutReason is set atomically with recoveryTimedOut; fallback keeps the invariant fail-closed @preserve */
-    if (!timeoutReason) {
-        return new BlueBubblesRecoveryTurnTimeoutError(timeoutMs);
-    }
-    return timeoutReason;
-}
 class BlueBubblesActivityTimeoutError extends Error {
     constructor(operation, timeoutMs) {
         super(`bluebubbles ${operation} activity timed out after ${timeoutMs}ms`);
         this.name = "BlueBubblesActivityTimeoutError";
     }
 }
-function isBlueBubblesRecoveryTurnTimeout(error) {
-    return error instanceof BlueBubblesRecoveryTurnTimeoutError
-        || (error instanceof Error
-            && error.name === "BlueBubblesRecoveryTurnTimeoutError"
-            && error.message.startsWith("bluebubbles recovery turn timed out after "));
-}
-function withBlueBubblesActivityTimeout(operation, timeoutMs, task) {
+function withBlueBubblesActivityTimeout(operation, timeoutMs, controller, task) {
     let timer = null;
+    controller.signal.throwIfAborted();
+    let removeAbortListener;
+    const aborted = new Promise((_, reject) => {
+        const rejectFromAbort = () => {
+            reject(controller.signal.reason);
+        };
+        controller.signal.addEventListener("abort", rejectFromAbort, { once: true });
+        removeAbortListener = () => controller.signal.removeEventListener("abort", rejectFromAbort);
+    });
     return Promise.race([
-        task(),
+        Promise.resolve().then(() => task(controller.signal)),
+        aborted,
         new Promise((_, reject) => {
             timer = setTimeout(() => {
-                reject(new BlueBubblesActivityTimeoutError(operation, timeoutMs));
+                const error = new BlueBubblesActivityTimeoutError(operation, timeoutMs);
+                controller.abort(error);
+                reject(error);
             }, timeoutMs);
             /* v8 ignore next -- timer handles expose unref only in some runtimes @preserve */
             if (typeof timer.unref === "function") {
@@ -313,6 +358,7 @@ function withBlueBubblesActivityTimeout(operation, timeoutMs, task) {
             }
         }),
     ]).finally(() => {
+        removeAbortListener();
         /* v8 ignore next -- timer is assigned unless a callback task throws synchronously; callback tasks are async @preserve */
         if (timer !== null)
             clearTimeout(timer);
@@ -339,7 +385,7 @@ async function waitForBlueBubblesCallbackCleanup(queue, timeoutMs, meta) {
             clearTimeout(timer);
     });
     if (!timedOut)
-        return;
+        return true;
     (0, runtime_1.emitNervesEvent)({
         level: "warn",
         component: "senses",
@@ -347,13 +393,13 @@ async function waitForBlueBubblesCallbackCleanup(queue, timeoutMs, meta) {
         message: "bluebubbles callback cleanup timed out; releasing live turn lane",
         meta: { ...meta, timeoutMs },
     });
+    return false;
 }
 function resolveFriendParams(event) {
     if (event.chat.isGroup) {
-        const groupKey = event.chat.chatGuid ?? event.chat.chatIdentifier ?? event.sender.externalId;
         return {
             provider: "imessage-handle",
-            externalId: `group:${groupKey}`,
+            externalId: `group:${event.chat.chatGuid}`,
             displayName: event.chat.displayName ?? "Unknown Group",
             channel: "bluebubbles",
         };
@@ -366,8 +412,7 @@ function resolveFriendParams(event) {
     };
 }
 function resolveGroupExternalId(event) {
-    const groupKey = event.chat.chatGuid ?? event.chat.chatIdentifier ?? event.sender.externalId;
-    return `group:${groupKey}`;
+    return `group:${event.chat.chatGuid}`;
 }
 /**
  * Check if any participant in a group chat is a known family member.
@@ -376,7 +421,7 @@ function resolveGroupExternalId(event) {
 async function checkGroupHasFamilyMember(store, event) {
     if (!event.chat.isGroup)
         return false;
-    for (const handle of event.chat.participantHandles ?? []) {
+    for (const handle of event.chat.participantHandles) {
         const friend = await store.findByExternalId("imessage-handle", handle);
         if (friend?.trustLevel === "family")
             return true;
@@ -477,8 +522,6 @@ function buildBlueBubblesOrientationSource(event, existingMessages, evidence, co
         externalId: participant.externalId,
         displayName: participant.displayName,
     }));
-    const targetGuid = evidence.targetGuid;
-    const targetAuthorship = evidence.targetAuthorship;
     const presentation = {
         authority: "presentation_only",
         conversationKind,
@@ -495,23 +538,7 @@ function buildBlueBubblesOrientationSource(event, existingMessages, evidence, co
             displayName: actor.displayName,
         },
         participants,
-        ...(targetGuid
-            ? {
-                target: {
-                    messageGuid: targetGuid,
-                    authorship: targetAuthorship ?? "unknown",
-                },
-            }
-            : {}),
     };
-    if (event.kind !== "message") {
-        return {
-            kind: "bluebubbles",
-            ...presentation,
-            lane: "mutation",
-            ...(repairNotice ? { repairNotice } : {}),
-        };
-    }
     const summaries = extractHistoricalLaneSummary(existingMessages);
     const threadId = event.threadOriginatorGuid?.trim() || undefined;
     const hasThreadRoute = !!threadId || summaries.some((summary) => summary.key.startsWith("thread:"));
@@ -534,14 +561,11 @@ function buildInboundText(event) {
     if (!event.chat.isGroup) {
         return baseText;
     }
-    if (event.kind === "mutation") {
-        return `${event.sender.displayName} ${baseText}`;
-    }
     return `${event.sender.displayName}: ${baseText}`;
 }
 function buildInboundContent(event) {
     const text = buildInboundText(event);
-    if (event.kind !== "message" || !event.inputPartsForAgent || event.inputPartsForAgent.length === 0) {
+    if (!event.inputPartsForAgent || event.inputPartsForAgent.length === 0) {
         return text;
     }
     return [
@@ -560,8 +584,6 @@ function sessionLikelyContainsMessage(event, existingMessages) {
     });
 }
 function getBlueBubblesContinuityIngressTexts(event) {
-    if (event.kind !== "message")
-        return [];
     const text = event.textForAgent.trim();
     if (text.length > 0)
         return [text];
@@ -629,10 +651,11 @@ function recordBlueBubblesRecoveryFailureForBudget(agentName, event, source) {
         // Autonomy failure accounting must not turn a recovery error into a broader sense outage.
     }
 }
-function insertEphemeralContextMessages(messages, contextMessages) {
+function insertEphemeralContextMessages(messages, contextMessages, currentUserMessage) {
     if (contextMessages.length === 0)
         return messages;
-    const insertionIndex = Math.max(0, messages.length - 1);
+    const requiredCurrentIndex = currentUserMessage ? messages.indexOf(currentUserMessage) : -1;
+    const insertionIndex = requiredCurrentIndex >= 0 ? requiredCurrentIndex : Math.max(0, messages.length - 1);
     return [
         ...messages.slice(0, insertionIndex),
         ...contextMessages,
@@ -646,23 +669,41 @@ function knownProviderMessageTexts(messages) {
         .filter((text) => text.length > 0);
 }
 async function buildBlueBubblesContextMessages(input) {
-    if (input.event.kind !== "message")
-        return { messages: [], contextPacketIds: [] };
     const event = input.event;
     if (!Number.isFinite(event.timestamp))
         return { messages: [], contextPacketIds: [] };
-    const chatGuidHash = (0, context_packet_1.blueBubblesContextChatKeyHash)(event);
-    const anchorTimestamp = new Date(event.timestamp).toISOString();
+    let result;
     try {
-        const result = await (0, context_packet_1.buildBlueBubblesContextPacket)({
+        result = await (0, context_packet_1.buildBlueBubblesContextPacket)({
             agentName: input.agentName,
             client: input.client,
             event,
-            knownMessageTexts: knownProviderMessageTexts(input.knownMessages ?? []),
+            knownMessageTexts: knownProviderMessageTexts(input.knownMessages),
         });
-        if (!result)
-            return { messages: [], contextPacketIds: [] };
-        const { packet, rendered, historyCount } = result;
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "senses",
+            event: "senses.bluebubbles_context_packet_error",
+            message: "failed to build live bluebubbles context packet",
+            meta: {
+                messageGuid: event.messageGuid,
+                reason: error instanceof Error ? error.message : String(error),
+            },
+        });
+        return { messages: [], contextPacketIds: [] };
+    }
+    if (!result)
+        return { messages: [], contextPacketIds: [] };
+    const { packet, optionalRendered, verifiedPredecessorMessage, historyCount } = result;
+    const prepared = {
+        messages: optionalRendered
+            ? [{ role: "system", content: optionalRendered.text }]
+            : [],
+        verifiedPredecessorMessage,
+    };
+    try {
         (0, context_packet_ledger_1.writeSenseContextPacket)(input.agentRoot, packet);
         (0, runtime_1.emitNervesEvent)({
             component: "senses",
@@ -675,7 +716,7 @@ async function buildBlueBubblesContextMessages(input) {
             },
         });
         return {
-            messages: [{ role: "system", content: rendered.text }],
+            ...prepared,
             contextPacketIds: [packet.packetId],
         };
     }
@@ -690,30 +731,16 @@ async function buildBlueBubblesContextMessages(input) {
                 reason: error instanceof Error ? error.message : String(error),
             },
         });
-        const fallback = (0, context_packet_ledger_1.readLatestVisibleSenseContextPacket)(input.agentRoot, {
-            sense: "bluebubbles",
-            chatKeyHash: chatGuidHash,
-            beforeAnchorTimestamp: anchorTimestamp,
-            maxAgeMs: 24 * 60 * 60 * 1000,
-        });
-        if (!fallback)
-            return { messages: [], contextPacketIds: [] };
-        const rendered = (0, context_packets_1.renderSenseContextPacketForPrompt)(fallback);
-        return {
-            messages: [{ role: "system", content: rendered.text }],
-            contextPacketIds: [fallback.packetId],
-        };
+        return { ...prepared, contextPacketIds: [] };
     }
 }
 function createReplyTargetController(event) {
-    const defaultTargetLabel = event.kind === "message" && event.threadOriginatorGuid?.trim() ? "current_lane" : "top_level";
-    let selection = event.kind === "message" && event.threadOriginatorGuid?.trim()
+    const defaultTargetLabel = event.threadOriginatorGuid?.trim() ? "current_lane" : "top_level";
+    let selection = event.threadOriginatorGuid?.trim()
         ? { target: "current_lane" }
         : { target: "top_level" };
     return {
         getReplyToMessageGuid() {
-            if (event.kind !== "message")
-                return undefined;
             if (selection.target === "top_level")
                 return undefined;
             if (selection.target === "thread")
@@ -747,10 +774,12 @@ function emitBlueBubblesMarkReadWarning(chat, error) {
 function createBlueBubblesCallbacks(client, chat, replyTarget, isGroupChat, onVisibleActivity, options = {}) {
     let textBuffer = "";
     let typingActive = false;
+    let typingCouldBeActive = false;
     let queue = Promise.resolve();
-    let lastVisibleActivityMs = Date.now();
-    let silenceWatchdog = null;
     let outboundClosed = false;
+    let nextCleanupToken = 0;
+    const activeCleanupTokens = new Set();
+    const activeActivityControllers = new Set();
     // Per-turn outward-send dedupe. A single createBlueBubblesCallbacks lifetime
     // serves one inbound turn, so collapsing identical outward bodies inside
     // this closure is scoped tightly: each fresh inbound turn starts with an
@@ -769,13 +798,37 @@ function createBlueBubblesCallbacks(client, chat, replyTarget, isGroupChat, onVi
     // check catches near-duplicates from the same turn.
     const sentOutwardTextNorms = new Set();
     const sentOutwardTokenSets = [];
-    function enqueue(operation, task, options = {}) {
-        /* v8 ignore next -- defensive guard: public callback entrypoints already drop after outbound close @preserve */
-        if (outboundClosed && !options.allowAfterClose)
-            return;
+    async function canRunOutbound() {
+        if (outboundClosed)
+            return false;
+        if (options.isOutboundCurrent && !options.isOutboundCurrent())
+            return false;
+        if (options.admitOutbound && !await options.admitOutbound())
+            return false;
+        if (outboundClosed)
+            return false;
+        if (options.isOutboundCurrent && !options.isOutboundCurrent())
+            return false;
+        return true;
+    }
+    function enqueue(operation, task, enqueueOptions = {}) {
+        const cleanupToken = enqueueOptions.cleanupToken;
+        const controller = new AbortController();
+        activeActivityControllers.add(controller);
         queue = queue
-            .then(() => withBlueBubblesActivityTimeout(operation, BLUEBUBBLES_ACTIVITY_OPERATION_TIMEOUT_MS, task))
+            .then(async () => {
+            if (cleanupToken === undefined) {
+                if (!await canRunOutbound())
+                    return;
+            }
+            else if (!activeCleanupTokens.has(cleanupToken)) {
+                return;
+            }
+            await withBlueBubblesActivityTimeout(operation, BLUEBUBBLES_ACTIVITY_OPERATION_TIMEOUT_MS, controller, task);
+        })
             .catch((error) => {
+            if (controller.signal.aborted && !(error instanceof BlueBubblesActivityTimeoutError))
+                return;
             (0, runtime_1.emitNervesEvent)({
                 level: "warn",
                 component: "senses",
@@ -783,8 +836,30 @@ function createBlueBubblesCallbacks(client, chat, replyTarget, isGroupChat, onVi
                 message: "bluebubbles activity transport failed",
                 meta: { operation, reason: error instanceof Error ? error.message : String(error) },
             });
+        })
+            .finally(() => {
+            activeActivityControllers.delete(controller);
         });
     }
+    function abortActiveActivity(reason) {
+        for (const controller of activeActivityControllers) {
+            controller.abort(new Error(reason));
+        }
+    }
+    function enqueueTypingStop() {
+        typingActive = false;
+        const cleanupToken = ++nextCleanupToken;
+        activeCleanupTokens.add(cleanupToken);
+        enqueue("typing_stop", async (signal) => {
+            try {
+                await client.setTyping(chat, false, signal);
+                typingCouldBeActive = false;
+            }
+            finally {
+                activeCleanupTokens.delete(cleanupToken);
+            }
+        }, { cleanupToken });
+    }
     function startTypingNow() {
         /* v8 ignore next -- defensive guard: callers already check typingActive @preserve */
         if (typingActive)
@@ -793,10 +868,11 @@ function createBlueBubblesCallbacks(client, chat, replyTarget, isGroupChat, onVi
         if (outboundClosed)
             return;
         typingActive = true;
-        enqueue("typing_start", async () => {
+        typingCouldBeActive = true;
+        enqueue("typing_start", async (signal) => {
             const [markReadResult, typingResult] = await Promise.allSettled([
-                client.markChatRead(chat),
-                client.setTyping(chat, true),
+                client.markChatRead(chat, signal),
+                client.setTyping(chat, true, signal),
             ]);
             if (markReadResult.status === "rejected") {
                 emitBlueBubblesMarkReadWarning(chat, markReadResult.reason);
@@ -807,7 +883,6 @@ function createBlueBubblesCallbacks(client, chat, replyTarget, isGroupChat, onVi
         });
     }
     function recordVisibleActivity() {
-        lastVisibleActivityMs = Date.now();
         onVisibleActivity?.();
     }
     function isDuplicateOutwardText(trimmed) {
@@ -848,62 +923,11 @@ function createBlueBubblesCallbacks(client, chat, replyTarget, isGroupChat, onVi
             },
         });
     }
-    function stopSilenceWatchdog() {
-        if (silenceWatchdog === null)
-            return;
-        clearInterval(silenceWatchdog);
-        silenceWatchdog = null;
-    }
-    function startSilenceWatchdog() {
-        if (silenceWatchdog !== null)
-            return;
-        silenceWatchdog = setInterval(() => {
-            if (Date.now() - lastVisibleActivityMs < BLUEBUBBLES_SILENCE_WATCHDOG_MS)
-                return;
-            sendStatus("still working on this...");
-        }, BLUEBUBBLES_SILENCE_WATCHDOG_MS);
-        /* v8 ignore next -- timer handles expose unref only in some runtimes @preserve */
-        if (typeof silenceWatchdog.unref === "function") {
-            silenceWatchdog.unref();
-        }
-    }
-    function sendStatus(text) {
-        /* v8 ignore next -- defensive guard: cancelOutbound stops the only status caller before it can fire @preserve */
-        if (outboundClosed)
-            return;
-        const trimmed = text.trim();
-        /* v8 ignore next -- defensive guard; current status callers always provide non-empty text @preserve */
-        if (!trimmed)
-            return;
-        // Status surfaces share the per-turn dedupe set so a status-style
-        // outward message (tool description, error notice, watchdog ping)
-        // can't deliver a near-duplicate of an already-sent answer or status
-        // (post-#699 evidence: evt-001820 + evt-001821 + evt-001823 on
-        // 2026-05-09 — overlapping status surface updates about the same
-        // duplicate issue, which the flushNow/flush-only guard could not catch
-        // because sendStatus writes directly via client.sendText).
-        if (isDuplicateOutwardText(trimmed)) {
-            emitDuplicateOutwardSuppressed("status", trimmed.length);
-            return;
-        }
-        enqueue("send_status", async () => {
-            await client.sendText({
-                chat,
-                text: trimmed,
-                replyToMessageGuid: replyTarget.getReplyToMessageGuid(),
-            });
-            recordVisibleActivity();
-            // Re-enable typing indicator — sending a message clears the typing bubble
-            await client.setTyping(chat, true);
-        });
-    }
     return {
         settleOutputMode: "retractable_buffer",
         onModelStart() {
             if (outboundClosed)
                 return;
-            if (options.enableSilenceWatchdog !== false)
-                startSilenceWatchdog();
             if (options.enableActivitySignals !== false && !isGroupChat)
                 startTypingNow();
             (0, runtime_1.emitNervesEvent)({
@@ -934,8 +958,8 @@ function createBlueBubblesCallbacks(client, chat, replyTarget, isGroupChat, onVi
                 return;
             // Tool activity is a reply commitment, but iMessage is not a tool-progress
             // console. Keep the human-facing thread quiet until the agent has real
-            // text (or the generic silence watchdog fires), while preserving native
-            // read/typing signals and nerves telemetry for debugging.
+            // text, while preserving native read/typing signals and nerves telemetry
+            // for debugging.
             if (options.enableActivitySignals !== false && !typingActive && name !== "observe" && name !== "speak")
                 startTypingNow();
             (0, runtime_1.emitNervesEvent)({
@@ -993,6 +1017,8 @@ function createBlueBubblesCallbacks(client, chat, replyTarget, isGroupChat, onVi
                 emitDuplicateOutwardSuppressed("flushNow", trimmed.length);
                 return;
             }
+            if (!await canRunOutbound())
+                return;
             await client.sendText({
                 chat,
                 text: trimmed,
@@ -1015,23 +1041,21 @@ function createBlueBubblesCallbacks(client, chat, replyTarget, isGroupChat, onVi
                     operation: "flush_after_close",
                     chatGuid: chat.chatGuid ?? null,
                 });
-                return;
+                return { status: "not_invoked", reason: "closed" };
             }
             await queue;
             const trimmed = textBuffer.trim();
             if (!trimmed) {
                 if (typingActive) {
-                    typingActive = false;
-                    enqueue("typing_stop", async () => { await client.setTyping(chat, false); }, { allowAfterClose: true });
+                    enqueueTypingStop();
                     await queue;
                 }
-                return;
+                return { status: "not_invoked", reason: "empty" };
             }
             textBuffer = "";
             /* v8 ignore next 4 -- branch: typing may already be stopped before flush @preserve */
             if (typingActive) {
-                typingActive = false;
-                enqueue("typing_stop", async () => { await client.setTyping(chat, false); }, { allowAfterClose: true });
+                enqueueTypingStop();
                 await queue;
             }
             if ((0, bluebubbles_meta_guard_1.containsInternalMetaMarkers)(trimmed)) {
@@ -1043,35 +1067,181 @@ function createBlueBubblesCallbacks(client, chat, replyTarget, isGroupChat, onVi
                         messageLength: trimmed.length,
                     },
                 });
-                return;
+                return { status: "not_invoked", reason: "blocked_meta" };
             }
             if (isDuplicateOutwardText(trimmed)) {
                 emitDuplicateOutwardSuppressed("flush", trimmed.length);
-                return;
+                return { status: "not_invoked", reason: "duplicate" };
             }
-            await client.sendText({
-                chat,
-                text: trimmed,
-                replyToMessageGuid: replyTarget.getReplyToMessageGuid(),
-                ...(flushOptions.signal ? { signal: flushOptions.signal } : {}),
-            });
+            if (!await canRunOutbound())
+                return { status: "not_invoked", reason: "not_current" };
+            const replyToMessageGuid = replyTarget.getReplyToMessageGuid();
+            const durableOutbound = options.durableOutbound;
+            const durableTempGuid = durableOutbound
+                ? `ouro-inbound-${(0, node_crypto_1.createHash)("sha256")
+                    .update(durableOutbound.idempotencyKey)
+                    .digest("hex")
+                    .slice(0, 32)}`
+                : null;
+            const boundaryState = { durableRecord: null, denialReason: "not_current" };
+            const admitFinalTransport = () => {
+                if (outboundClosed
+                    || (options.isOutboundCurrent && !options.isOutboundCurrent())
+                    || (options.isOutboundAdmittedNow && !options.isOutboundAdmittedNow())) {
+                    boundaryState.denialReason = "not_current";
+                    return false;
+                }
+                if (!durableOutbound || boundaryState.durableRecord)
+                    return true;
+                const reservation = (0, outbound_state_1.reserveBlueBubblesOutbound)({
+                    agentRoot: durableOutbound.agentRoot,
+                    idempotencyKey: durableOutbound.idempotencyKey,
+                    chat,
+                    attachment: durableOutbound.attachment,
+                    text: trimmed,
+                    tempGuid: durableTempGuid,
+                    ...(replyToMessageGuid ? { replyToMessageGuid } : {}),
+                });
+                if (reservation.status !== "reserved") {
+                    boundaryState.denialReason = "durable_duplicate";
+                    return false;
+                }
+                boundaryState.durableRecord = reservation.record;
+                return true;
+            };
+            const markDurableFailure = (error) => {
+                const durableRecord = boundaryState.durableRecord;
+                if (!durableRecord || !durableOutbound)
+                    return;
+                try {
+                    (0, outbound_state_1.markBlueBubblesOutboundFailed)({
+                        agentRoot: durableOutbound.agentRoot,
+                        recordId: durableRecord.recordId,
+                        failedAt: new Date().toISOString(),
+                        reason: error instanceof Error ? error.message : String(error),
+                    });
+                }
+                catch (stateError) {
+                    (0, runtime_1.emitNervesEvent)({
+                        level: "error",
+                        component: "senses",
+                        event: "senses.bluebubbles_outbound_state_error",
+                        message: "failed to record bluebubbles outbound transport failure",
+                        meta: {
+                            recordId: durableRecord.recordId,
+                            reason: String(stateError),
+                        },
+                    });
+                }
+            };
+            let response;
+            while (true) {
+                try {
+                    flushOptions.signal?.throwIfAborted();
+                    response = await client.sendText({
+                        chat,
+                        text: trimmed,
+                        replyToMessageGuid,
+                        ...(durableTempGuid ? { tempGuid: durableTempGuid } : {}),
+                        ...(flushOptions.signal ? { signal: flushOptions.signal } : {}),
+                        beforeTransportInvocation: admitFinalTransport,
+                        onTransportInvocation: options.onFinalTransportInvoked,
+                    });
+                    break;
+                }
+                catch (error) {
+                    if (error instanceof client_1.BlueBubblesSendError
+                        && error.transportInvoked === false
+                        && error.errorCode === "admission_denied") {
+                        if (boundaryState.denialReason === "durable_duplicate") {
+                            return { status: "not_invoked", reason: "durable_duplicate" };
+                        }
+                        // A newer observation may be only a temporary fence (duplicate,
+                        // audit-only, or otherwise non-promoting). Re-await admission and
+                        // retry the same durable reservation if this turn remains current.
+                        if (!await canRunOutbound()) {
+                            markDurableFailure(error);
+                            return { status: "not_invoked", reason: "not_current" };
+                        }
+                        continue;
+                    }
+                    markDurableFailure(error);
+                    throw error;
+                }
+            }
+            const durableRecord = boundaryState.durableRecord;
+            if (durableRecord && durableOutbound) {
+                try {
+                    (0, outbound_state_1.markBlueBubblesOutboundAccepted)({
+                        agentRoot: durableOutbound.agentRoot,
+                        recordId: durableRecord.recordId,
+                        acceptedAt: new Date().toISOString(),
+                        ...(response.messageGuid ? { messageGuid: response.messageGuid } : {}),
+                    });
+                }
+                catch (stateError) {
+                    (0, runtime_1.emitNervesEvent)({
+                        level: "error",
+                        component: "senses",
+                        event: "senses.bluebubbles_outbound_state_error",
+                        message: "failed to record accepted bluebubbles outbound transport",
+                        meta: {
+                            recordId: durableRecord.recordId,
+                            reason: String(stateError),
+                        },
+                    });
+                }
+            }
+            options.onFinalTransportAccepted?.();
             recordVisibleActivity();
+            return { status: "accepted" };
         },
         async finish(options = {}) {
-            stopSilenceWatchdog();
-            if (typingActive) {
-                typingActive = false;
-                enqueue("typing_stop", async () => { await client.setTyping(chat, false); }, { allowAfterClose: true });
+            const cleanupTimeoutMs = options.timeoutMs ?? BLUEBUBBLES_CALLBACK_CLEANUP_TIMEOUT_MS;
+            const needsTypingStop = typingActive;
+            if (needsTypingStop) {
+                enqueueTypingStop();
             }
-            await waitForBlueBubblesCallbackCleanup(queue, options.timeoutMs ?? BLUEBUBBLES_CALLBACK_CLEANUP_TIMEOUT_MS, {
+            const drained = await waitForBlueBubblesCallbackCleanup(queue, cleanupTimeoutMs, {
                 operation: "finish",
                 chatGuid: chat.chatGuid ?? null,
             });
+            if (!drained) {
+                // The queued start/read request may outlive this turn's bounded lane.
+                // Invalidate its deferred stop, then issue one stop request now while A
+                // still owns the canonical lock so B cannot start typing ahead of it.
+                activeCleanupTokens.clear();
+                abortActiveActivity("bluebubbles activity superseded by bounded cleanup");
+                await waitForBlueBubblesCallbackCleanup(queue, cleanupTimeoutMs, {
+                    operation: "finish_after_activity_abort",
+                    chatGuid: chat.chatGuid ?? null,
+                });
+            }
+            if (typingCouldBeActive) {
+                const fallbackController = new AbortController();
+                try {
+                    await withBlueBubblesActivityTimeout("typing_stop_fallback", cleanupTimeoutMs, fallbackController, (signal) => client.setTyping(chat, false, signal));
+                    typingCouldBeActive = false;
+                }
+                catch (error) {
+                    (0, runtime_1.emitNervesEvent)({
+                        level: "warn",
+                        component: "senses",
+                        event: "senses.bluebubbles_activity_error",
+                        message: "bluebubbles activity transport failed",
+                        meta: {
+                            operation: "typing_stop_fallback",
+                            reason: error instanceof Error ? error.message : String(error),
+                        },
+                    });
+                }
+            }
+            activeCleanupTokens.clear();
         },
         cancelOutbound(reason) {
             outboundClosed = true;
             textBuffer = "";
-            stopSilenceWatchdog();
+            abortActiveActivity(`bluebubbles outbound ${reason}`);
             (0, runtime_1.emitNervesEvent)({
                 level: "warn",
                 component: "senses",
@@ -1204,62 +1374,98 @@ async function shouldFilterAgentSelfHandle(event, resolvedDeps) {
     }
     return true;
 }
-function hasObservedBlueBubblesDirection(event) {
-    return typeof event.fromMe === "boolean";
+function createBlueBubblesTurnStage(sessionKey) {
+    return {
+        failoverState: structuredClone(bbFailoverStates.get(sessionKey) ?? { pending: null }),
+    };
 }
-async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source, options) {
-    const client = resolvedDeps.createClient();
-    const agentName = resolvedDeps.getAgentName();
-    (0, runtime_cwd_1.recoverRuntimeCwd)();
-    if (event.fromMe) {
-        (0, runtime_1.emitNervesEvent)({
-            component: "senses",
-            event: "senses.bluebubbles_from_me_ignored",
-            message: "ignored from-me bluebubbles event",
-            meta: {
-                messageGuid: event.messageGuid,
-                kind: event.kind,
-            },
-        });
-        if (event.chat.isGroup)
-            recordDiscoveredOwnHandle(event.sender.externalId);
-        return { handled: true, notifiedAgent: false, kind: event.kind, reason: "from_me" };
-    }
-    // Fallback self-detection: BlueBubbles sometimes broadcasts a group-chat
-    // outbound message back through the webhook with `isFromMe` missing/false.
-    // Without this guard the agent ingests its own message and replies to it
-    // ("the agent talking to itself"). Compare the sender's externalId against
-    // the agent's known iMessage handles. Keep this group-only: 1:1 outbound
-    // echoes can be attributed to the peer handle, and stale ownHandles entries
-    // must not make real DMs disappear.
-    if (await shouldFilterAgentSelfHandle(event, resolvedDeps)) {
+function persistAcceptedBlueBubblesProjection(input) {
+    const { stage, deps, event } = input;
+    if (stage.postTurn) {
+        try {
+            deps.postTurnPersist(stage.postTurn.sessionPath, stage.postTurn.prepared, stage.postTurn.usage, stage.postTurn.state);
+        }
+        catch (error) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                component: "senses",
+                event: "senses.bluebubbles_accepted_projection_failed",
+                message: "accepted bluebubbles reply could not be projected into canonical session history",
+                meta: {
+                    messageGuid: event.messageGuid,
+                    sessionKey: event.chat.sessionKey,
+                    reason: error instanceof Error ? error.message : String(error),
+                },
+            });
+        }
+    }
+}
+function promoteAcceptedBlueBubblesAncillaryState(input) {
+    const { stage, deps, agentName, event, source } = input;
+    try {
+        deps.promoteFailoverState(event.chat.sessionKey, stage.failoverState);
+    }
+    catch (error) {
         (0, runtime_1.emitNervesEvent)({
             level: "warn",
             component: "senses",
-            event: "senses.bluebubbles_self_handle_filtered",
-            message: "filtered bluebubbles event whose sender matched an agent-owned handle (isFromMe was missing/false)",
+            event: "senses.bluebubbles_failover_state_promotion_failed",
+            message: "accepted bluebubbles reply could not promote staged failover state",
             meta: {
                 messageGuid: event.messageGuid,
-                kind: event.kind,
-                senderExternalId: event.sender.externalId,
+                sessionKey: event.chat.sessionKey,
+                reason: error instanceof Error ? error.message : String(error),
             },
         });
-        return { handled: true, notifiedAgent: false, kind: event.kind, reason: "from_me" };
     }
-    if (event.kind === "mutation" && !event.shouldNotifyAgent) {
+    if (stage.tokens) {
+        const emitTokenPromotionFailure = (error) => {
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "senses",
+                event: "senses.bluebubbles_token_promotion_failed",
+                message: "accepted bluebubbles reply could not promote staged token usage",
+                meta: {
+                    messageGuid: event.messageGuid,
+                    sessionKey: event.chat.sessionKey,
+                    reason: error instanceof Error ? error.message : String(error),
+                },
+            });
+        };
+        try {
+            void deps.accumulateFriendTokens(stage.tokens.store, stage.tokens.friendId, stage.tokens.usage).catch(emitTokenPromotionFailure);
+        }
+        catch (error) {
+            emitTokenPromotionFailure(error);
+        }
+    }
+    try {
+        deps.recordProcessed(agentName, event, source, input.processedOutcome);
+    }
+    catch (error) {
         (0, runtime_1.emitNervesEvent)({
+            level: "warn",
             component: "senses",
-            event: "senses.bluebubbles_state_mutation_recorded",
-            message: "recorded non-notify bluebubbles mutation",
+            event: "senses.bluebubbles_processed_promotion_failed",
+            message: "accepted bluebubbles reply could not promote processed sidecar state",
             meta: {
                 messageGuid: event.messageGuid,
-                mutationType: event.mutationType,
+                sessionKey: event.chat.sessionKey,
+                reason: error instanceof Error ? error.message : String(error),
             },
         });
-        return { handled: true, notifiedAgent: false, kind: event.kind, reason: "mutation_state_only" };
     }
+}
+function hasObservedBlueBubblesDirection(event) {
+    return typeof event.fromMe === "boolean";
+}
+async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source, options) {
+    options.lifecycleSignal?.throwIfAborted();
+    const client = resolvedDeps.createClient();
+    const agentName = resolvedDeps.getAgentName();
+    (0, runtime_cwd_1.recoverRuntimeCwd)();
     let activeTurnId = null;
-    if (event.kind === "message" && shouldUseBlueBubblesRecoveryBudget(source, options)) {
+    if (shouldUseBlueBubblesRecoveryBudget(source, options)) {
         const decision = (0, autonomy_budget_1.reserveAutonomyBudget)((0, identity_1.getAgentRoot)(agentName), {
             agent: agentName,
             triggerType: "recovery",
@@ -1275,66 +1481,100 @@ async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source, opt
         }
     }
     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 {
-            (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 await (0, turn_coordinator_1.withSharedTurnLock)("bluebubbles", sessPath, async () => {
-            if (event.kind === "message" && activeTurnId === null) {
-                activeTurnId = (0, active_turns_1.beginBlueBubblesActiveTurn)(agentName, event);
+        // Reserve the canonical chat lane before any asynchronous adapter setup.
+        // Every admitted inbound is projected in observation order even when a
+        // newer turn supersedes its inference before provider work begins.
+        return await (0, turn_coordinator_1.withSharedTurnLock)("bluebubbles", `${agentName}:${event.chat.sessionKey}`, async () => {
+            options.lifecycleSignal?.throwIfAborted();
+            // Fallback self-detection: BlueBubbles sometimes broadcasts a group-chat
+            // outbound message back through the webhook with `isFromMe` missing/false.
+            // Keep this group-only: stale ownHandles entries must not hide real DMs.
+            if (await shouldFilterAgentSelfHandle(event, resolvedDeps)) {
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn",
+                    component: "senses",
+                    event: "senses.bluebubbles_self_handle_filtered",
+                    message: "filtered bluebubbles event whose sender matched an agent-owned handle (isFromMe was missing/false)",
+                    meta: {
+                        messageGuid: event.messageGuid,
+                        kind: event.kind,
+                        senderExternalId: event.sender.externalId,
+                    },
+                });
+                return { handled: true, notifiedAgent: false, kind: event.kind, reason: "from_me" };
             }
-            // Pre-load session inside the turn lock so same-chat deliveries cannot race on stale trunk state.
+            options.lifecycleSignal?.throwIfAborted();
+            // ── Adapter setup: friend, session, content, callbacks ────────
+            const store = resolvedDeps.createFriendStore();
+            const resolver = resolvedDeps.createFriendResolver(store, resolveFriendParams(event));
+            const baseContext = await resolver.resolve();
+            options.lifecycleSignal?.throwIfAborted();
+            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),
+                    },
+                });
+            }
+            // Pre-load session inside the canonical 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
+                ? structuredClone(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 = (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" };
-                }
+            // 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" };
             }
-            if (event.kind === "message" && event.chat.isGroup) {
+            // 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) => ({
+                    participants: event.chat.participantHandles.map((externalId) => ({
                         provider: "imessage-handle",
                         externalId,
                     })),
@@ -1342,10 +1582,10 @@ async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source, opt
                 });
             }
             // Fetch the text of the message being replied to (if this is a threaded reply)
-            const threadGuid = event.kind === "message" ? event.threadOriginatorGuid?.trim() : undefined;
+            const threadGuid = event.threadOriginatorGuid?.trim();
             let repliedToText = null;
             if (threadGuid) {
-                repliedToText = await client.getMessageText(threadGuid).catch(/* v8 ignore next */ () => null);
+                repliedToText = await client.getMessageText(threadGuid).catch(() => null);
                 (0, runtime_1.emitNervesEvent)({
                     component: "senses",
                     event: "senses.bluebubbles_reply_context",
@@ -1353,12 +1593,9 @@ async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source, opt
                     meta: { threadGuid, hasText: !!repliedToText },
                 });
             }
-            // Build inbound user message as user-visible speech only; source/routing facts live in the orientation frame.
-            const priorMessages = existing?.messages ?? sessionMessages;
-            const userMessage = {
-                role: "user",
-                content: buildInboundContent(event),
-            };
+            // 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],
@@ -1366,26 +1603,76 @@ async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source, opt
                 structuredOutputs: existing?.structuredOutputs ?? [],
                 source: buildBlueBubblesOrientationSource(event, priorMessages, options.orientationEvidence, options.orientationConversationKind, repliedToText),
             });
-            const visibleActivityTurnId = activeTurnId;
-            const callbacks = createBlueBubblesCallbacks(client, event.chat, replyTarget, event.chat.isGroup, visibleActivityTurnId
-                ? () => (0, active_turns_1.noteBlueBubblesActiveTurnVisibleActivity)(agentName, visibleActivityTurnId)
-                : undefined);
+            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 timeoutReject;
+            let resolveTimeout;
             let recoveryTimedOut = false;
-            let timeoutReason = 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);
-            // ── 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.
@@ -1403,17 +1690,50 @@ async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source, opt
             };
             /* 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",
+                    };
+                }
+                const [groupHasFamilyMember, hasExistingGroupWithFamily] = trustContext;
+                lifecycleSignal?.throwIfAborted();
+                // ── Call shared pipeline ────────────────────────────────────────
                 const timeoutMs = options.timeoutMs ?? BLUEBUBBLES_LIVE_TURN_TIMEOUT_MS;
-                timeoutPromise = new Promise((_, reject) => {
-                    timeoutReject = reject;
+                timeoutPromise = new Promise((resolve) => {
+                    resolveTimeout = resolve;
                 });
                 timeoutTimer = setTimeout(() => {
                     const reason = new BlueBubblesRecoveryTurnTimeoutError(timeoutMs);
-                    timeoutReason = reason;
                     recoveryTimedOut = true;
+                    if (!finalTransportInvoked) {
+                        resolveTimeout?.({
+                            handled: true,
+                            notifiedAgent: false,
+                            kind: event.kind,
+                            reason: "turn_timeout",
+                        });
+                    }
                     callbacks.cancelOutbound("turn_timeout");
-                    controller.abort(reason);
-                    timeoutReject?.(reason);
+                    (0, latest_turn_1.cancel)(options.latestTurnCapability, "turn_timeout");
+                    if (!finalTransportInvoked)
+                        controller.abort(reason);
                     (0, runtime_1.emitNervesEvent)({
                         level: "warn",
                         component: "senses",
@@ -1426,6 +1746,18 @@ async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source, opt
                             timeoutMs,
                         },
                     });
+                    (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,
+                        },
+                    });
                 }, timeoutMs);
                 /* v8 ignore next -- timer handles expose unref only in some runtimes @preserve */
                 if (typeof timeoutTimer.unref === "function") {
@@ -1461,7 +1793,7 @@ async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source, opt
                     enforceTrustGate: trust_gate_1.enforceTrustGate,
                     drainPending: pending_1.drainPending,
                     drainDeferredReturns: (deferredFriendId) => (0, pending_1.drainDeferredReturns)(resolvedDeps.getAgentName(), deferredFriendId),
-                    prepareRunAgentOptions: async ({ messages, runAgentOptions }) => {
+                    prepareRunAgentOptions: async ({ messages = [], currentUserMessages = [], runAgentOptions }) => {
                         preparedBlueBubblesContext = await buildBlueBubblesContextMessages({
                             agentName,
                             agentRoot: (0, identity_1.getAgentRoot)(),
@@ -1469,41 +1801,75 @@ async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source, opt
                             event,
                             knownMessages: messages,
                         });
-                        if (preparedBlueBubblesContext.contextPacketIds.length === 0)
+                        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 {
-                            contextPacketIds: [
-                                ...(runAgentOptions.contextPacketIds ?? []),
-                                ...preparedBlueBubblesContext.contextPacketIds,
-                            ],
+                            ...(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) => resolvedDeps.runAgent(insertEphemeralContextMessages(msgs, preparedBlueBubblesContext.messages), 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),
+                    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);
                             },
-                            codingFeedback: {
-                                send: async (message) => {
-                                    await client.sendText({
-                                        chat: event.chat,
-                                        text: message,
-                                        replyToMessageGuid: replyTarget.getReplyToMessageGuid(),
-                                    });
+                            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);
-                        resolvedDeps.deferPostTurnPersist(sessionPathArg, prepared, usage, state);
+                        turnStage.postTurn = {
+                            sessionPath: sessionPathArg,
+                            prepared,
+                            usage,
+                            state,
+                        };
+                    },
+                    accumulateFriendTokens: async (tokenStore, tokenFriendId, usage) => {
+                        turnStage.tokens = {
+                            store: tokenStore,
+                            friendId: tokenFriendId,
+                            usage,
+                        };
                     },
-                    accumulateFriendTokens: resolvedDeps.accumulateFriendTokens,
                     signal: controller.signal,
                     runAgentOptions: {
                         mcpManager,
@@ -1515,12 +1881,7 @@ async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source, opt
                         },
                     },
                     callbacks: failoverAwareCallbacks,
-                    failoverState: (() => {
-                        if (!bbFailoverStates.has(event.chat.sessionKey)) {
-                            bbFailoverStates.set(event.chat.sessionKey, { pending: null });
-                        }
-                        return bbFailoverStates.get(event.chat.sessionKey);
-                    })(),
+                    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
@@ -1543,43 +1904,108 @@ async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source, opt
                 /* v8 ignore stop */
                 const runTurn = (async () => {
                     const result = await turnPromise;
-                    if (recoveryTimedOut)
-                        throw getBlueBubblesTimeoutReason(timeoutReason, timeoutMs);
+                    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",
+                        };
+                    }
                     /* 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 });
+                        callbacks.onClearText?.();
+                        callbacks.onTextChunk(result.failoverMessage);
+                        bufferedTerminalError = null;
                     }
                     else if (bufferedTerminalError) {
-                        // No failover — replay the buffered terminal error
                         callbacks.onError(bufferedTerminalError, "terminal");
+                        bufferedTerminalError = null;
                     }
                     /* v8 ignore stop */
                     // ── Handle gate result ────────────────────────────────────────
+                    let processedOutcome = "turn-complete";
                     if (!result.gateResult.allowed) {
-                        // Send auto-reply via BB API if the gate provides one
+                        callbacks.onClearText?.();
                         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");
+                            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",
                         };
                     }
-                    // Gate allowed — flush the agent's reply
-                    await callbacks.flush();
-                    if (recoveryTimedOut)
-                        throw getBlueBubblesTimeoutReason(timeoutReason, timeoutMs);
-                    if (event.kind === "message") {
-                        (0, processed_log_1.recordProcessedBlueBubblesMessage)(agentName, event, source, "turn-complete");
+                    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)({
                         component: "senses",
                         event: "senses.bluebubbles_turn_end",
@@ -1614,28 +2040,7 @@ async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source, opt
                     });
                 });
                 /* v8 ignore stop */
-                return await (async () => {
-                    try {
-                        return await Promise.race([runTurn, timeoutPromise]);
-                    }
-                    catch (error) {
-                        if (isBlueBubblesRecoveryTurnTimeout(error)) {
-                            (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,
-                                },
-                            });
-                        }
-                        throw error;
-                    }
-                })();
+                return await Promise.race([runTurn, timeoutPromise, supersessionPromise, lifecyclePromise]);
             }
             finally {
                 // If a terminal error was buffered and never replayed (e.g., handleInboundTurn threw),
@@ -1647,10 +2052,10 @@ async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source, opt
                 }
                 /* v8 ignore stop */
                 clearTimeout(timeoutTimer);
-                if (activeTurnId) {
-                    (0, active_turns_1.finishBlueBubblesActiveTurn)(agentName, activeTurnId);
-                    activeTurnId = null;
-                }
+                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 });
             }
         });
@@ -1683,11 +2088,9 @@ function recordBlueBubblesAuditSidecar(agentName, event, source, resolvedDeps) {
         });
     }
 }
-function reactionTargetAuthorship(target) {
-    return target.fromMe === true ? "agent" : "non_agent_unknown";
-}
-async function captureBlueBubblesSemanticEvent(normalized, resolvedDeps, source) {
+async function captureBlueBubblesSemanticEvent(normalized, resolvedDeps, source, observationReservation) {
     const agentName = resolvedDeps.getAgentName();
+    const capturedAt = new Date().toISOString();
     if (!hasObservedBlueBubblesDirection(normalized)) {
         (0, runtime_1.emitNervesEvent)({
             level: "warn",
@@ -1705,14 +2108,6 @@ async function captureBlueBubblesSemanticEvent(normalized, resolvedDeps, source)
     }
     const observed = normalized;
     const cutover = (0, semantic_receipts_1.initializeBlueBubblesSemanticCutover)(agentName);
-    let resolvedReactionTarget;
-    let targetAuthorship = null;
-    if (observed.kind === "mutation"
-        && observed.mutationType === "reaction"
-        && observed.targetMessageGuid) {
-        resolvedReactionTarget = await resolveReactionTarget(resolvedDeps.createClient(), observed.targetMessageGuid);
-        targetAuthorship = reactionTargetAuthorship(resolvedReactionTarget);
-    }
     let coordinateGeneration;
     if (observed.kind === "mutation"
         && observed.mutationType === "reaction"
@@ -1741,9 +2136,11 @@ async function captureBlueBubblesSemanticEvent(normalized, resolvedDeps, source)
     }
     const capture = (0, semantic_receipts_1.buildBlueBubblesSemanticCapture)({
         cutover,
-        capturedAt: new Date().toISOString(),
+        capturedAt,
+        observationEpoch: observationReservation.observationEpoch,
+        observationOrdinal: observationReservation.ordinal,
         event: observed,
-        targetAuthorship,
+        targetAuthorship: null,
         coordinateGeneration,
     });
     if (!capture) {
@@ -1761,7 +2158,6 @@ async function captureBlueBubblesSemanticEvent(normalized, resolvedDeps, source)
         capture,
         normalized: observed,
         writeResult,
-        ...(resolvedReactionTarget ? { resolvedReactionTarget } : {}),
     };
 }
 function semanticCaptureChat(capture) {
@@ -1792,11 +2188,58 @@ function semanticCaptureChat(capture) {
         participantHandles: event.participants.map((participant) => participant.externalId),
     };
 }
-function semanticCaptureRequiresRoutingRepair(capture) {
-    return !capture.event.chatGuid?.trim() && !capture.event.chatIdentifier?.trim();
+function semanticCaptureRequiresRoutingRepair(capture) {
+    return !capture.event.chatGuid?.trim() && !capture.event.chatIdentifier?.trim();
+}
+function hasResolvedBlueBubblesRouting(event) {
+    return Boolean(event.chat.chatGuid?.trim() || event.chat.chatIdentifier?.trim());
+}
+function reserveBlueBubblesObservation(event) {
+    return (0, latest_turn_1.reserveObservation)({
+        chatGuid: event.chat.chatGuid,
+        chatIdentifier: event.chat.chatIdentifier,
+    });
+}
+function groupBlueBubblesObservationsByLane(candidates) {
+    let groups = [];
+    for (const candidate of candidates) {
+        const keys = new Set((0, latest_turn_1.observationSchedulingKeys)(candidate.observationReservation));
+        const destination = { keys: new Set(keys), candidates: [candidate] };
+        const independentGroups = [];
+        for (const group of groups) {
+            const intersects = (keys.has("unresolved:*")
+                || group.keys.has("unresolved:*")
+                || [...keys].some((key) => group.keys.has(key)));
+            if (!intersects) {
+                independentGroups.push(group);
+                continue;
+            }
+            destination.candidates.push(...group.candidates);
+            for (const key of group.keys)
+                destination.keys.add(key);
+        }
+        groups = [...independentGroups, destination];
+    }
+    return groups.map((group) => group.candidates.sort((left, right) => (right.observationReservation.ordinal - left.observationReservation.ordinal)));
+}
+function canonicalizeBlueBubblesEvent(event, capability) {
+    const canonical = capability.canonicalChat;
+    const { chatIdentifier: _observedIdentifier, ...observedChat } = event.chat;
+    return {
+        ...event,
+        chat: {
+            ...observedChat,
+            chatGuid: canonical.chatGuid,
+            ...(canonical.chatIdentifier ? { chatIdentifier: canonical.chatIdentifier } : {}),
+            sessionKey: canonical.sessionKey,
+            sendTarget: { kind: "chat_guid", value: canonical.chatGuid },
+        },
+    };
 }
-function hasResolvedBlueBubblesRouting(event) {
-    return Boolean(event.chat.chatGuid?.trim() || event.chat.chatIdentifier?.trim());
+function isCaptureOnlyBlueBubblesMutation(capture) {
+    return capture.event.kind === "reaction"
+        || capture.event.kind === "edit"
+        || capture.event.kind === "unsend";
 }
 function isAuditOnlySemanticCapture(capture) {
     return capture.event.kind === "read" || capture.event.kind === "delivery";
@@ -1872,43 +2315,30 @@ function semanticCaptureToNormalizedEvent(capture) {
             : {}),
     };
 }
-function semanticHandledOutcome(event, result) {
-    if (result.reason === "from_me")
-        return "ignored_self";
-    if (event.kind === "message") {
-        return result.notifiedAgent ? "message_completed" : "message_observed";
-    }
-    switch (event.mutationType) {
-        case "edit": return "edit_capture_only";
-        case "unsend": return "unsend_capture_only";
-        case "read": return "read_audit_only";
-        case "delivery": return "delivery_audit_only";
-        case "reaction":
-            if (result.reason === "restricted_feedback_settled")
-                return "restricted_feedback_settled";
-            if (result.reason === "restricted_feedback_observed")
-                return "restricted_feedback_observed";
-            return "restricted_feedback_failed";
-    }
-}
-function materializeRestrictedBlueBubblesReactionEvent(captured, repaired) {
-    // Classification reached `restricted_feedback` from the validated v1
-    // capture's reaction tuple. Direct capture and recovery both construct the
-    // paired normalized event from that same tuple, so it is the authoritative
-    // reaction object; repair contributes routing only and may legitimately
-    // promote its own transport-shaped result to `message`.
-    const event = captured.normalized;
-    return {
-        ...event,
-        mutationType: "reaction",
-        reaction: event.reaction,
-        targetMessageGuid: event.targetMessageGuid,
-        chat: repaired.chat,
-        requiresRepair: repaired.requiresRepair,
-        repairNotice: repaired.repairNotice,
-    };
+function seedBlueBubblesStartupSemanticObservations(deps = {}) {
+    const resolvedDeps = { ...defaultDeps, ...deps };
+    const agentName = resolvedDeps.getAgentName();
+    const cutover = (0, semantic_receipts_1.initializeBlueBubblesSemanticCutover)(agentName);
+    let seeded = 0;
+    for (const capture of (0, semantic_receipts_1.listPendingBlueBubblesSemanticCaptures)(agentName)
+        .sort(semantic_receipts_1.compareBlueBubblesSemanticCaptureOrder)) {
+        const disposition = (0, semantic_receipts_1.classifyBlueBubblesRecoveryRecord)(capture, cutover);
+        if (disposition.disposition === "audit_only")
+            continue;
+        const normalized = semanticCaptureToNormalizedEvent(capture);
+        if (!normalized)
+            continue;
+        const generation = adoptBlueBubblesSemanticObservation(capture.keyHash, reserveBlueBubblesObservation(normalized), false);
+        // Startup seeding runs synchronously before listen. Retain each fence so
+        // persisted pre-restart observations remain causally older than any live
+        // webhook accepted by this process and can reuse the same generation when
+        // the delayed recovery pass begins.
+        suspendBlueBubblesSemanticObservation(generation);
+        seeded += 1;
+    }
+    return seeded;
 }
-async function classifyCapturedBlueBubblesReaction(captured, resolvedDeps) {
+async function classifyCapturedBlueBubblesReaction(captured) {
     const event = captured.capture.event;
     if (event.kind !== "reaction" || !event.canonicalAction || !event.canonicalValue)
         return null;
@@ -1916,151 +2346,78 @@ async function classifyCapturedBlueBubblesReaction(captured, resolvedDeps) {
         fromMe: event.fromMe,
         action: event.canonicalAction,
         canonicalValue: event.canonicalValue,
-        targetAuthorship: event.targetAuthorship,
-    };
-    const initial = (0, reaction_policy_1.classifyBlueBubblesReaction)(input);
-    if (initial.route !== "trust_required") {
-        return { decision: initial, trustedFriend: null };
-    }
-    let trustedActor = false;
-    let trustedFriend = null;
-    try {
-        const friend = await resolvedDeps.createFriendStore().findByExternalId("imessage-handle", event.actor.externalId);
-        trustedActor = friends_1.TRUSTED_LEVELS.has(friend?.trustLevel ?? "stranger");
-        if (trustedActor && friend)
-            trustedFriend = friend;
-    }
-    catch (error) {
-        (0, runtime_1.emitNervesEvent)({
-            level: "warn",
-            component: "senses",
-            event: "senses.bluebubbles_reaction_trust_lookup_error",
-            message: "failed direct actor trust lookup for bluebubbles reaction",
-            meta: {
-                keyHash: captured.capture.keyHash,
-                provider: event.actor.provider,
-                reason: error instanceof Error ? error.message : String(error),
-            },
-        });
-    }
-    return {
-        decision: (0, reaction_policy_1.classifyBlueBubblesReaction)({ ...input, trustedActor }),
-        trustedFriend,
     };
+    return { decision: (0, reaction_policy_1.classifyBlueBubblesReaction)(input) };
 }
-async function handleRestrictedBlueBubblesReactionFeedback(input) {
-    const { event, trustedFriend, client, resolvedDeps, options } = input;
-    const target = input.resolvedReactionTarget
-        ?? await resolveReactionTarget(client, event.targetMessageGuid);
-    event.textForAgent = (0, model_1.renderBlueBubblesReactionText)(event.reaction, target);
-    const channel = (0, friends_1.getChannelCapabilities)("bluebubbles");
-    const context = { friend: trustedFriend, channel, isGroupChat: event.chat.isGroup };
-    const userMessage = {
-        role: "user",
-        content: buildInboundContent(event),
-    };
-    const orientationFrame = (0, orientation_frame_1.buildOrientationFrame)({
-        channel: "bluebubbles",
-        messages: [userMessage],
-        currentUserMessages: [userMessage],
-        source: buildBlueBubblesOrientationSource(event, [], options.orientationEvidence, options.orientationConversationKind),
-        speechKind: "reaction",
-    });
-    const callbacks = createBlueBubblesCallbacks(client, event.chat, createReplyTargetController(event), event.chat.isGroup, undefined, { enableSilenceWatchdog: false, enableActivitySignals: false });
-    const controller = new AbortController();
-    const timeoutMs = options.timeoutMs ?? BLUEBUBBLES_LIVE_TURN_TIMEOUT_MS;
-    let timeoutTimer;
-    const timeoutPromise = new Promise((_, reject) => {
-        timeoutTimer = setTimeout(() => {
-            const error = new BlueBubblesRecoveryTurnTimeoutError(timeoutMs);
-            callbacks.cancelOutbound("turn_timeout");
-            controller.abort(error);
-            reject(error);
-        }, timeoutMs);
-        if (typeof timeoutTimer.unref === "function") {
-            timeoutTimer.unref();
-        }
-    });
-    try {
-        const restrictedTurnAndDelivery = async () => {
-            const result = await resolvedDeps.runAgent([userMessage], callbacks, "bluebubbles", controller.signal, {
-                isReactionSignal: true,
-                restrictedReactionFeedback: true,
-                skipKeptNotes: true,
-                orientationFrame,
-                toolContext: {
-                    signin: async () => undefined,
-                    context,
-                    currentIngressEvidence: options.currentIngressEvidence,
-                },
-            });
-            if (result.outcome === "settled" || result.outcome === "blocked") {
-                await callbacks.flush({ signal: controller.signal });
-            }
-            return result;
-        };
-        const result = await Promise.race([
-            restrictedTurnAndDelivery(),
-            timeoutPromise,
-        ]);
-        if (result.outcome === "settled" || result.outcome === "blocked") {
-            return {
-                handled: true,
-                notifiedAgent: true,
-                kind: event.kind,
-                reason: "restricted_feedback_settled",
-            };
-        }
-        if (result.outcome === "observed") {
-            return {
-                handled: true,
-                notifiedAgent: false,
-                kind: event.kind,
-                reason: "restricted_feedback_observed",
-            };
-        }
+function captureOnlyHandledDisposition(capture, reactionDecision) {
+    if (capture.event.kind !== "reaction") {
         return {
-            handled: true,
-            notifiedAgent: false,
-            kind: event.kind,
-            reason: "restricted_feedback_failed",
+            outcome: capture.event.kind === "edit" ? "edit_capture_only" : "unsend_capture_only",
+            detailCode: null,
         };
     }
-    catch (error) {
-        callbacks.onError(error instanceof Error ? error : new Error(String(error)), "terminal");
+    const classifiedOutcome = reactionDecision.outcome;
+    if (classifiedOutcome === "capture_only_negative" || classifiedOutcome === "capture_only_question") {
         return {
-            handled: true,
-            notifiedAgent: false,
-            kind: event.kind,
-            reason: "restricted_feedback_failed",
+            outcome: "capture_only_unknown",
+            detailCode: classifiedOutcome,
         };
     }
-    finally {
-        clearTimeout(timeoutTimer);
-        await callbacks.finish({ timeoutMs: BLUEBUBBLES_CALLBACK_CLEANUP_TIMEOUT_MS });
-    }
+    return { outcome: classifiedOutcome, detailCode: null };
+}
+function auditOnlyHandledOutcome(kind) {
+    return kind === "read" ? "read_audit_only" : "delivery_audit_only";
 }
-function writeCapturedBlueBubblesHandled(agentName, capture, outcome) {
+function writeCapturedBlueBubblesHandled(agentName, capture, outcome, detailCode = null) {
     const handledResult = (0, semantic_receipts_1.writeBlueBubblesSemanticHandled)(agentName, {
         schemaVersion: 1,
         canonicalKey: capture.canonicalKey,
         keyHash: capture.keyHash,
         handledAt: new Date().toISOString(),
         outcome,
-        detailCode: null,
+        detailCode,
     });
     if (handledResult === "semantic_handled_collision") {
         throw new Error("semantic_handled_collision");
     }
 }
-async function handleCapturedBlueBubblesSemanticEvent(captured, resolvedDeps, source, options = {}) {
+function blueBubblesInboundReplyIdempotencyKey(captureKeyHash) {
+    return `bluebubbles-inbound-reply:${captureKeyHash}`;
+}
+function blueBubblesRecoveredOutboundOutcome(record) {
+    return BLUEBUBBLES_VISIBLE_OUTBOUND_STATUSES.has(record.status)
+        ? "message_completed"
+        : "message_observed";
+}
+async function handleCapturedBlueBubblesSemanticEvent(captured, resolvedDeps, source, options) {
+    options.lifecycleSignal?.throwIfAborted();
     const agentName = resolvedDeps.getAgentName();
     const identity = {
         canonicalKey: captured.capture.canonicalKey,
         keyHash: captured.capture.keyHash,
     };
-    const claim = await (0, semantic_receipts_1.acquireBlueBubblesSemanticClaim)(agentName, identity);
+    const generation = adoptBlueBubblesSemanticObservation(identity.keyHash, options.observationReservation, true);
+    const semanticHandling = await acquireBlueBubblesSemanticHandlingSlot(identity.keyHash, generation);
+    if (semanticHandling.status === "handled_by_owner") {
+        return {
+            handled: true,
+            notifiedAgent: false,
+            kind: captured.normalized.kind,
+            reason: "already_processed",
+        };
+    }
+    const reservation = semanticHandling.reservation;
+    let claim;
+    try {
+        options.lifecycleSignal?.throwIfAborted();
+        claim = await (0, semantic_receipts_1.acquireBlueBubblesSemanticClaim)(agentName, identity);
+    }
+    catch (error) {
+        releaseBlueBubblesSemanticHandlingSlot(identity.keyHash, semanticHandling.slot, "retryable");
+        throw error;
+    }
     if (claim.status === "already_handled") {
+        releaseBlueBubblesSemanticHandlingSlot(identity.keyHash, semanticHandling.slot, "terminal");
         return {
             handled: true,
             notifiedAgent: false,
@@ -2069,6 +2426,7 @@ async function handleCapturedBlueBubblesSemanticEvent(captured, resolvedDeps, so
         };
     }
     if (claim.status === "timeout") {
+        releaseBlueBubblesSemanticHandlingSlot(identity.keyHash, semanticHandling.slot, "retryable");
         return {
             handled: false,
             notifiedAgent: false,
@@ -2076,32 +2434,97 @@ async function handleCapturedBlueBubblesSemanticEvent(captured, resolvedDeps, so
             reason: "semantic_claim_timeout",
         };
     }
+    let latestTurnCapability = null;
+    let semanticHandlingCompleted = false;
+    let retainSemanticClaim = false;
+    let acceptedReceiptPublished = false;
+    const publishTerminalReceipt = (outcome, detailCode = null) => {
+        try {
+            writeCapturedBlueBubblesHandled(agentName, captured.capture, outcome, detailCode);
+        }
+        catch (error) {
+            // A missing terminal receipt must never reopen this semantic event. Keep
+            // the durable claim live so recovery cannot resurrect a canceled turn or
+            // duplicate a reply whose transport is already externally visible.
+            retainSemanticClaim = true;
+            semanticHandlingCompleted = true;
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                component: "senses",
+                event: "senses.bluebubbles_terminal_receipt_failed",
+                message: "bluebubbles event could not publish its terminal semantic receipt",
+                meta: {
+                    messageGuid: captured.normalized.messageGuid,
+                    keyHash: captured.capture.keyHash,
+                    outcome,
+                    reason: error instanceof Error ? error.message : String(error),
+                },
+            });
+            throw error;
+        }
+    };
+    const publishAcceptedReceipt = () => {
+        if (acceptedReceiptPublished)
+            return;
+        publishTerminalReceipt("message_completed");
+        acceptedReceiptPublished = true;
+    };
     try {
-        const capturedOptions = {
-            ...options,
-            currentIngressEvidence: Object.freeze({
-                schemaVersion: 1,
-                provider: "bluebubbles",
-                captureKeyHash: captured.capture.keyHash,
-            }),
-            orientationEvidence: captured.capture.event,
-            orientationConversationKind: captured.normalized.chat.isGroup ? "group" : "one_to_one",
-        };
-        const reactionClassification = await classifyCapturedBlueBubblesReaction(captured, resolvedDeps);
+        options.lifecycleSignal?.throwIfAborted();
+        const reactionClassification = await classifyCapturedBlueBubblesReaction(captured);
+        options.lifecycleSignal?.throwIfAborted();
         const reactionDecision = reactionClassification?.decision ?? null;
-        if (reactionDecision?.route === "capture_only") {
+        if (captured.capture.event.fromMe) {
+            (0, runtime_1.emitNervesEvent)({
+                component: "senses",
+                event: "senses.bluebubbles_from_me_ignored",
+                message: "ignored from-me bluebubbles event",
+                meta: {
+                    messageGuid: captured.normalized.messageGuid,
+                    kind: captured.normalized.kind,
+                },
+            });
+            if (captured.normalized.chat.isGroup) {
+                recordDiscoveredOwnHandle(captured.normalized.sender.externalId);
+            }
             const result = {
                 handled: true,
                 notifiedAgent: false,
                 kind: captured.normalized.kind,
-                reason: reactionDecision.outcome === "ignored_self" ? "from_me" : "mutation_state_only",
+                reason: "from_me",
             };
-            writeCapturedBlueBubblesHandled(agentName, captured.capture, reactionDecision.outcome);
+            publishTerminalReceipt("ignored_self");
+            semanticHandlingCompleted = true;
             return result;
         }
-        let handledEvent = captured.normalized;
+        const durableOutbound = (0, outbound_state_1.readBlueBubblesOutboundRecordByIdempotencyKey)((0, identity_1.getAgentRoot)(), blueBubblesInboundReplyIdempotencyKey(captured.capture.keyHash));
+        if (durableOutbound) {
+            const outcome = blueBubblesRecoveredOutboundOutcome(durableOutbound);
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "senses",
+                event: "senses.bluebubbles_inbound_reply_recovery_suppressed",
+                message: "suppressed bluebubbles inbound reply recovery at its durable send boundary",
+                meta: {
+                    messageGuid: captured.normalized.messageGuid,
+                    recordId: durableOutbound.recordId,
+                    outboundStatus: durableOutbound.status,
+                    outcome,
+                },
+            });
+            publishTerminalReceipt(outcome);
+            semanticHandlingCompleted = true;
+            return {
+                handled: true,
+                notifiedAgent: false,
+                kind: captured.normalized.kind,
+                reason: "already_processed",
+            };
+        }
+        let handledOutcome = "message_observed";
         let result;
         if (isAuditOnlySemanticCapture(captured.capture)) {
+            handledOutcome = auditOnlyHandledOutcome(captured.capture.event.kind);
             result = {
                 handled: true,
                 notifiedAgent: false,
@@ -2110,8 +2533,11 @@ async function handleCapturedBlueBubblesSemanticEvent(captured, resolvedDeps, so
             };
         }
         else {
-            const client = resolvedDeps.createClient();
-            const repaired = await client.repairEvent(captured.normalized);
+            const captureOnlyMutation = isCaptureOnlyBlueBubblesMutation(captured.capture);
+            const repaired = captureOnlyMutation && captured.normalized.chat.chatGuid?.trim()
+                ? captured.normalized
+                : await resolvedDeps.createClient().repairEvent(captured.normalized);
+            options.lifecycleSignal?.throwIfAborted();
             if (semanticCaptureRequiresRoutingRepair(captured.capture)
                 && !hasResolvedBlueBubblesRouting(repaired)) {
                 throw new Error("semantic_capture_routing_invalid");
@@ -2121,31 +2547,89 @@ async function handleCapturedBlueBubblesSemanticEvent(captured, resolvedDeps, so
                 fromMe: captured.normalized.fromMe,
                 sender: captured.normalized.sender,
             };
-            handledEvent = identityGroundedRepaired;
-            if (reactionDecision?.route === "restricted_feedback") {
-                const restrictedEvent = materializeRestrictedBlueBubblesReactionEvent(captured, repaired);
-                handledEvent = restrictedEvent;
-                result = await handleRestrictedBlueBubblesReactionFeedback({
-                    event: restrictedEvent,
-                    trustedFriend: reactionClassification.trustedFriend,
-                    client,
-                    resolvedDeps,
-                    options: capturedOptions,
-                    resolvedReactionTarget: captured.resolvedReactionTarget ?? options.resolvedReactionTarget,
-                });
+            const promotion = (0, latest_turn_1.promote)(reservation, {
+                chatGuid: identityGroundedRepaired.chat.chatGuid,
+                chatIdentifier: identityGroundedRepaired.chat.chatIdentifier,
+            }, {
+                allowSameGenerationRetry: semanticHandling.allowSameGenerationRetry,
+            });
+            if (promotion.status !== "promoted") {
+                if (!captureOnlyMutation && promotion.status === "unresolved") {
+                    throw new Error("semantic_capture_routing_invalid");
+                }
+                const disposition = captureOnlyMutation
+                    ? captureOnlyHandledDisposition(captured.capture, reactionDecision)
+                    : { outcome: "message_observed", detailCode: null };
+                publishTerminalReceipt(disposition.outcome, disposition.detailCode);
+                semanticHandlingCompleted = true;
+                return {
+                    handled: true,
+                    notifiedAgent: false,
+                    kind: captured.normalized.kind,
+                    reason: captureOnlyMutation ? "mutation_state_only" : "superseded",
+                };
             }
-            else {
-                result = await handleBlueBubblesNormalizedEvent(identityGroundedRepaired, resolvedDeps, source, {
-                    ...capturedOptions,
-                    resolvedReactionTarget: captured.resolvedReactionTarget ?? options.resolvedReactionTarget,
-                });
+            latestTurnCapability = promotion.capability;
+            if (captureOnlyMutation) {
+                const disposition = captureOnlyHandledDisposition(captured.capture, reactionDecision);
+                publishTerminalReceipt(disposition.outcome, disposition.detailCode);
+                semanticHandlingCompleted = true;
+                return {
+                    handled: true,
+                    notifiedAgent: false,
+                    kind: captured.normalized.kind,
+                    reason: "mutation_state_only",
+                };
+            }
+            if (identityGroundedRepaired.kind === "mutation") {
+                const outcome = auditOnlyHandledOutcome(identityGroundedRepaired.mutationType);
+                publishTerminalReceipt(outcome);
+                semanticHandlingCompleted = true;
+                return {
+                    handled: true,
+                    notifiedAgent: false,
+                    kind: captured.normalized.kind,
+                    reason: "mutation_state_only",
+                };
             }
+            const canonicalEvent = canonicalizeBlueBubblesEvent(identityGroundedRepaired, latestTurnCapability);
+            const capturedOptions = {
+                ...options,
+                latestTurnCapability,
+                currentIngressEvidence: Object.freeze({
+                    schemaVersion: 1,
+                    provider: "bluebubbles",
+                    captureKeyHash: captured.capture.keyHash,
+                }),
+                orientationEvidence: captured.capture.event,
+                orientationConversationKind: canonicalEvent.chat.isGroup ? "group" : "one_to_one",
+                publishAcceptedReceipt,
+            };
+            result = await handleBlueBubblesNormalizedEvent(canonicalEvent, resolvedDeps, source, capturedOptions);
+            handledOutcome = result.notifiedAgent ? "message_completed" : "message_observed";
+        }
+        if (result.notifiedAgent) {
+            publishAcceptedReceipt();
+        }
+        else {
+            publishTerminalReceipt(handledOutcome);
         }
-        writeCapturedBlueBubblesHandled(agentName, captured.capture, semanticHandledOutcome(handledEvent, result));
+        semanticHandlingCompleted = true;
         return result;
     }
     finally {
-        (0, semantic_receipts_1.releaseBlueBubblesSemanticClaim)(agentName, claim);
+        if (latestTurnCapability)
+            (0, latest_turn_1.finish)(latestTurnCapability);
+        try {
+            if (!retainSemanticClaim) {
+                (0, semantic_receipts_1.releaseBlueBubblesSemanticClaim)(agentName, claim);
+            }
+        }
+        finally {
+            releaseBlueBubblesSemanticHandlingSlot(identity.keyHash, semanticHandling.slot, retainSemanticClaim
+                ? "retained"
+                : semanticHandlingCompleted ? "terminal" : "retryable");
+        }
     }
 }
 async function handleBlueBubblesEvent(payload, deps = {}) {
@@ -2172,11 +2656,22 @@ async function handleBlueBubblesEvent(payload, deps = {}) {
         }
         throw error;
     }
-    const captured = await captureBlueBubblesSemanticEvent(normalized, resolvedDeps, "webhook");
+    const observationReservation = reserveBlueBubblesObservation(normalized);
+    let captured;
+    try {
+        captured = await captureBlueBubblesSemanticEvent(normalized, resolvedDeps, "webhook", observationReservation);
+    }
+    catch (error) {
+        (0, latest_turn_1.clearPending)(observationReservation);
+        throw error;
+    }
     if (captured.status === "audit_only") {
+        (0, latest_turn_1.clearPending)(observationReservation);
         return { handled: true, notifiedAgent: false, kind: normalized.kind, reason: "ignored" };
     }
-    return handleCapturedBlueBubblesSemanticEvent(captured, resolvedDeps, "webhook");
+    return handleCapturedBlueBubblesSemanticEvent(captured, resolvedDeps, "webhook", {
+        observationReservation,
+    });
 }
 function parseTimestampMs(value) {
     if (!value)
@@ -2220,14 +2715,20 @@ function blueBubblesPendingRecoverySnapshot(agentName, nowMs = Date.now()) {
         oldestPendingRecoveryAgeMs: oldest ? Math.max(0, nowMs - oldest.ms) : undefined,
     };
 }
-async function syncBlueBubblesRuntime(deps = {}) {
+async function syncBlueBubblesRuntime(deps = {}, options = {}) {
+    options.lifecycleSignal?.throwIfAborted();
     const resolvedDeps = { ...defaultDeps, ...deps };
     const agentName = resolvedDeps.getAgentName();
+    // Allocate before the first health-probe await. Any live webhook accepted
+    // while that probe is pending must remain causally newer than this pass.
+    const catchUpObservationBatch = options.catchUpObservationBatch ?? (0, latest_turn_1.beginObservationBatch)(BLUEBUBBLES_CATCHUP_PAGE_SIZE * BLUEBUBBLES_CATCHUP_MAX_PAGES);
+    pruneBlueBubblesSemanticObservationGenerations();
     const client = resolvedDeps.createClient();
     const checkedAt = new Date().toISOString();
     const previousState = (0, runtime_state_1.readBlueBubblesRuntimeState)(agentName);
     try {
         await client.checkHealth();
+        options.lifecycleSignal?.throwIfAborted();
         const pendingBeforeCatchup = blueBubblesPendingRecoverySnapshot(agentName);
         const activeBeforeCatchup = (0, active_turns_1.snapshotBlueBubblesActiveTurns)(agentName, BLUEBUBBLES_LIVE_TURN_STALLED_MS);
         (0, runtime_state_1.writeBlueBubblesRuntimeState)(agentName, {
@@ -2242,7 +2743,10 @@ async function syncBlueBubblesRuntime(deps = {}) {
         });
         const catchUp = await catchUpMissedBlueBubblesMessages(resolvedDeps, previousState, {
             processTurns: false,
+            observationBatch: catchUpObservationBatch,
+            lifecycleSignal: options.lifecycleSignal,
         });
+        options.lifecycleSignal?.throwIfAborted();
         const failed = catchUp.failed;
         const pendingAfterCatchup = blueBubblesPendingRecoverySnapshot(agentName);
         const activeAfterCatchup = (0, active_turns_1.snapshotBlueBubblesActiveTurns)(agentName, BLUEBUBBLES_LIVE_TURN_STALLED_MS);
@@ -2265,6 +2769,8 @@ async function syncBlueBubblesRuntime(deps = {}) {
         });
     }
     catch (error) {
+        if (options.lifecycleSignal?.aborted)
+            return;
         (0, runtime_state_1.writeBlueBubblesRuntimeState)(agentName, {
             upstreamStatus: "error",
             detail: error instanceof Error ? error.message : String(error),
@@ -2276,7 +2782,8 @@ async function syncBlueBubblesRuntime(deps = {}) {
         });
     }
 }
-async function recoverQueuedBlueBubblesMessages(deps = {}) {
+async function recoverQueuedBlueBubblesMessages(deps = {}, options = {}) {
+    options.lifecycleSignal?.throwIfAborted();
     const resolvedDeps = { ...defaultDeps, ...deps };
     const agentName = resolvedDeps.getAgentName();
     const previousState = (0, runtime_state_1.readBlueBubblesRuntimeState)(agentName);
@@ -2284,8 +2791,10 @@ async function recoverQueuedBlueBubblesMessages(deps = {}) {
     if (initialPending === 0) {
         return { recovered: 0, skipped: 0, failed: 0, pendingRecoveryCount: 0 };
     }
-    const captured = await recoverCapturedBlueBubblesInboundMessages(resolvedDeps);
+    const captured = await recoverCapturedBlueBubblesInboundMessages(resolvedDeps, options);
+    options.lifecycleSignal?.throwIfAborted();
     const recovery = await recoverMissedBlueBubblesMessages(resolvedDeps);
+    options.lifecycleSignal?.throwIfAborted();
     const pendingSnapshot = blueBubblesPendingRecoverySnapshot(agentName);
     const pendingRecoveryCount = pendingSnapshot.pendingRecoveryCount;
     const failed = captured.failed + recovery.failed;
@@ -2294,6 +2803,7 @@ async function recoverQueuedBlueBubblesMessages(deps = {}) {
     const checkedAt = new Date().toISOString();
     try {
         await resolvedDeps.createClient().checkHealth();
+        options.lifecycleSignal?.throwIfAborted();
         const activeSnapshot = (0, active_turns_1.snapshotBlueBubblesActiveTurns)(agentName, BLUEBUBBLES_LIVE_TURN_STALLED_MS);
         (0, runtime_state_1.writeBlueBubblesRuntimeState)(agentName, {
             upstreamStatus: "ok",
@@ -2308,6 +2818,8 @@ async function recoverQueuedBlueBubblesMessages(deps = {}) {
         });
     }
     catch (error) {
+        if (options.lifecycleSignal?.aborted)
+            throw options.lifecycleSignal.reason;
         (0, runtime_state_1.writeBlueBubblesRuntimeState)(agentName, {
             upstreamStatus: "error",
             detail: error instanceof Error ? error.message : String(error),
@@ -2323,6 +2835,7 @@ async function recoverQueuedBlueBubblesMessages(deps = {}) {
     return { recovered, skipped, failed, pendingRecoveryCount };
 }
 async function catchUpMissedBlueBubblesMessages(deps = {}, previousState, options = {}) {
+    options.lifecycleSignal?.throwIfAborted();
     const resolvedDeps = { ...defaultDeps, ...deps };
     const agentName = resolvedDeps.getAgentName();
     const client = resolvedDeps.createClient();
@@ -2344,16 +2857,21 @@ async function catchUpMissedBlueBubblesMessages(deps = {}, previousState, option
             maxPages: BLUEBUBBLES_CATCHUP_MAX_PAGES,
         },
     });
-    const recentEvents = [];
+    const preparedCandidates = [];
+    const seenMessageGuids = new Set();
+    const observationBatch = options.observationBatch ?? (0, latest_turn_1.beginObservationBatch)(BLUEBUBBLES_CATCHUP_PAGE_SIZE * BLUEBUBBLES_CATCHUP_MAX_PAGES);
     for (let page = 0; page < BLUEBUBBLES_CATCHUP_MAX_PAGES; page++) {
         let pageEvents;
         try {
             pageEvents = await client.listRecentMessages({
                 limit: BLUEBUBBLES_CATCHUP_PAGE_SIZE,
                 offset: page * BLUEBUBBLES_CATCHUP_PAGE_SIZE,
+                beforeTimestamp: observationBatch.beforeTimestamp,
             });
         }
         catch (error) {
+            if (options.lifecycleSignal?.aborted)
+                throw options.lifecycleSignal.reason;
             result.failed++;
             (0, runtime_1.emitNervesEvent)({
                 level: "warn",
@@ -2367,11 +2885,36 @@ async function catchUpMissedBlueBubblesMessages(deps = {}, previousState, option
             });
             break;
         }
-        recentEvents.push(...pageEvents);
+        options.lifecycleSignal?.throwIfAborted();
+        const pageMessages = pageEvents
+            .filter((event) => event.kind === "message")
+            .sort((left, right) => right.timestamp - left.timestamp);
+        for (let pageIndex = 0; pageIndex < pageMessages.length; pageIndex++) {
+            const event = pageMessages[pageIndex];
+            if (seenMessageGuids.has(event.messageGuid))
+                continue;
+            seenMessageGuids.add(event.messageGuid);
+            if (event.fromMe
+                || event.timestamp < catchUpSince
+                || (Number.isFinite(event.timestamp) && event.timestamp > observationBatch.beforeTimestamp)) {
+                preparedCandidates.push({ status: "skip", event });
+                continue;
+            }
+            // The bounded ordinal range and upstream snapshot were fixed before the
+            // first query. Each returned page can therefore publish its fences
+            // before the next await, while later ingress stays outside this pass.
+            preparedCandidates.push({
+                status: "ready",
+                event,
+                observationReservation: (0, latest_turn_1.reserveObservationFromBatch)(observationBatch, page * BLUEBUBBLES_CATCHUP_PAGE_SIZE + pageIndex, {
+                    chatGuid: event.chat.chatGuid,
+                    chatIdentifier: event.chat.chatIdentifier,
+                }),
+            });
+        }
         if (pageEvents.length < BLUEBUBBLES_CATCHUP_PAGE_SIZE)
             break;
-        const oldestMessageTimestamp = pageEvents
-            .filter((event) => event.kind === "message")
+        const oldestMessageTimestamp = pageMessages
             .reduce((oldest, event) => Math.min(oldest, event.timestamp), Number.POSITIVE_INFINITY);
         if (oldestMessageTimestamp <= catchUpSince)
             break;
@@ -2389,68 +2932,91 @@ async function catchUpMissedBlueBubblesMessages(deps = {}, previousState, option
             });
         }
     }
-    const seenMessageGuids = new Set();
-    const candidates = recentEvents
-        .filter((event) => event.kind === "message")
-        .filter((event) => {
-        if (seenMessageGuids.has(event.messageGuid))
-            return false;
-        seenMessageGuids.add(event.messageGuid);
-        return true;
-    })
-        .sort((left, right) => left.timestamp - right.timestamp);
-    for (const event of candidates) {
+    for (const prepared of preparedCandidates) {
         result.inspected++;
-        if (event.fromMe
-            || event.timestamp < catchUpSince) {
+        if (prepared.status === "skip") {
             result.skipped++;
-            continue;
         }
-        try {
-            const captured = await captureBlueBubblesSemanticEvent(event, resolvedDeps, "upstream-catchup");
-            if (captured.status === "audit_only") {
-                result.skipped++;
-                continue;
-            }
-            if (!processTurns) {
-                if (captured.writeResult === "semantic_capture_duplicate") {
+    }
+    const readyCandidates = preparedCandidates.filter((prepared) => prepared.status === "ready");
+    let lastRecoveredOrdinal = -1;
+    await Promise.all(groupBlueBubblesObservationsByLane(readyCandidates).map(async (lane) => {
+        for (const prepared of lane) {
+            const { event, observationReservation } = prepared;
+            let semanticGenerationOwned = false;
+            try {
+                options.lifecycleSignal?.throwIfAborted();
+                const captured = await captureBlueBubblesSemanticEvent(event, resolvedDeps, "upstream-catchup", observationReservation);
+                if (captured.status === "audit_only") {
+                    (0, latest_turn_1.clearPending)(observationReservation);
+                    result.skipped++;
+                    continue;
+                }
+                if (!processTurns) {
+                    const generation = adoptBlueBubblesSemanticObservation(captured.capture.keyHash, observationReservation, false);
+                    semanticGenerationOwned = true;
+                    if (captured.writeResult === "semantic_capture_duplicate") {
+                        if (!activeSemanticHandlingSlots.has(captured.capture.keyHash)) {
+                            suspendBlueBubblesSemanticObservation(generation);
+                        }
+                        result.skipped++;
+                    }
+                    else {
+                        // Runtime sync only captures work for the delayed recovery pass,
+                        // but its original generation must revoke older work now and be
+                        // reused by the queued recovery pass after any intervening turn.
+                        const promotion = (0, latest_turn_1.promote)(generation.reservation, {
+                            chatGuid: event.chat.chatGuid,
+                            chatIdentifier: event.chat.chatIdentifier,
+                        });
+                        if (promotion.status === "promoted")
+                            (0, latest_turn_1.finish)(promotion.capability);
+                        suspendBlueBubblesSemanticObservation(generation);
+                        result.queued = (result.queued ?? 0) + 1;
+                    }
+                    continue;
+                }
+                semanticGenerationOwned = true;
+                const handled = await handleCapturedBlueBubblesSemanticEvent(captured, resolvedDeps, "upstream-catchup", {
+                    timeoutMs: BLUEBUBBLES_RECOVERY_TURN_TIMEOUT_MS,
+                    autonomyBudgetTrigger: "recovery",
+                    observationReservation,
+                    lifecycleSignal: options.lifecycleSignal,
+                });
+                if (handled.reason === "semantic_claim_timeout") {
+                    continue;
+                }
+                if (shouldCountBlueBubblesRecoveryResultAsSkipped(handled.reason) || !handled.notifiedAgent) {
                     result.skipped++;
                 }
                 else {
-                    result.queued = (result.queued ?? 0) + 1;
+                    result.recovered++;
+                    if (observationReservation.ordinal > lastRecoveredOrdinal) {
+                        lastRecoveredOrdinal = observationReservation.ordinal;
+                        result.lastRecoveredMessageGuid = event.messageGuid;
+                    }
                 }
-                continue;
-            }
-            const handled = await handleCapturedBlueBubblesSemanticEvent(captured, resolvedDeps, "upstream-catchup", {
-                timeoutMs: BLUEBUBBLES_RECOVERY_TURN_TIMEOUT_MS,
-                autonomyBudgetTrigger: "recovery",
-            });
-            if (handled.reason === "semantic_claim_timeout") {
-                continue;
-            }
-            if (shouldCountBlueBubblesRecoveryResultAsSkipped(handled.reason) || !handled.notifiedAgent) {
-                result.skipped++;
             }
-            else {
-                result.recovered++;
-                result.lastRecoveredMessageGuid = event.messageGuid;
+            catch (error) {
+                if (!semanticGenerationOwned)
+                    (0, latest_turn_1.clearPending)(observationReservation);
+                if (options.lifecycleSignal?.aborted)
+                    throw options.lifecycleSignal.reason;
+                recordBlueBubblesRecoveryFailureForBudget(agentName, event, "upstream-catchup");
+                result.failed++;
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn",
+                    component: "senses",
+                    event: "senses.bluebubbles_catchup_error",
+                    message: "bluebubbles upstream catch-up message failed",
+                    meta: {
+                        messageGuid: event.messageGuid,
+                        reason: error instanceof Error ? error.message : String(error),
+                    },
+                });
             }
         }
-        catch (error) {
-            recordBlueBubblesRecoveryFailureForBudget(agentName, event, "upstream-catchup");
-            result.failed++;
-            (0, runtime_1.emitNervesEvent)({
-                level: "warn",
-                component: "senses",
-                event: "senses.bluebubbles_catchup_error",
-                message: "bluebubbles upstream catch-up message failed",
-                meta: {
-                    messageGuid: event.messageGuid,
-                    reason: error instanceof Error ? error.message : String(error),
-                },
-            });
-        }
-    }
+    }));
     if (result.inspected > 0 || result.recovered > 0 || result.skipped > 0 || result.failed > 0) {
         (0, runtime_1.emitNervesEvent)({
             component: "senses",
@@ -2461,52 +3027,47 @@ async function catchUpMissedBlueBubblesMessages(deps = {}, previousState, option
     }
     return result;
 }
-async function recoverCapturedBlueBubblesInboundMessages(deps = {}) {
+async function recoverCapturedBlueBubblesInboundMessages(deps = {}, options = {}) {
+    options.lifecycleSignal?.throwIfAborted();
     const resolvedDeps = { ...defaultDeps, ...deps };
     const agentName = resolvedDeps.getAgentName();
     const cutover = (0, semantic_receipts_1.initializeBlueBubblesSemanticCutover)(agentName);
     const result = { recovered: 0, skipped: 0, failed: 0 };
     const seenKeyHashes = new Set();
     const candidates = (0, semantic_receipts_1.listPendingBlueBubblesSemanticCaptures)(agentName)
-        .sort((left, right) => left.capturedAt.localeCompare(right.capturedAt));
+        .sort(semantic_receipts_1.compareBlueBubblesSemanticCaptureOrder);
+    const preparedCandidates = [];
     for (const capture of candidates) {
+        options.lifecycleSignal?.throwIfAborted();
         if (seenKeyHashes.has(capture.keyHash)) {
-            result.skipped++;
+            preparedCandidates.push({ status: "skip", capture });
             continue;
         }
         seenKeyHashes.add(capture.keyHash);
         const disposition = (0, semantic_receipts_1.classifyBlueBubblesRecoveryRecord)(capture, cutover);
         if (disposition.disposition === "audit_only" && disposition.reason !== "audit_event") {
-            result.skipped++;
+            preparedCandidates.push({ status: "skip", capture });
             continue;
         }
         const normalized = semanticCaptureToNormalizedEvent(capture);
-        try {
-            if (!normalized)
-                throw new Error("semantic_capture_routing_invalid");
-            const handled = await handleCapturedBlueBubblesSemanticEvent({
-                status: "captured",
-                capture,
-                normalized,
-                writeResult: "semantic_capture_duplicate",
-            }, resolvedDeps, "webhook", {
-                timeoutMs: BLUEBUBBLES_RECOVERY_TURN_TIMEOUT_MS,
-                autonomyBudgetTrigger: "recovery",
-                semanticRecovery: true,
-            });
-            if (handled.reason === "semantic_claim_timeout") {
-                continue;
-            }
-            if (shouldCountBlueBubblesRecoveryResultAsSkipped(handled.reason) || !handled.notifiedAgent) {
-                result.skipped++;
-            }
-            else {
-                result.recovered++;
-            }
+        if (!normalized) {
+            preparedCandidates.push({ status: "invalid", capture });
+            continue;
         }
-        catch (error) {
-            if (normalized)
-                recordBlueBubblesRecoveryFailureForBudget(agentName, normalized, "webhook");
+        preparedCandidates.push({
+            status: "ready",
+            capture,
+            normalized,
+            observationReservation: reserveBlueBubblesObservation(normalized),
+        });
+    }
+    for (const prepared of preparedCandidates) {
+        const { capture } = prepared;
+        if (prepared.status === "skip") {
+            result.skipped++;
+            continue;
+        }
+        if (prepared.status === "invalid") {
             result.failed++;
             (0, runtime_1.emitNervesEvent)({
                 level: "warn",
@@ -2516,11 +3077,58 @@ async function recoverCapturedBlueBubblesInboundMessages(deps = {}) {
                 meta: {
                     messageGuid: capture.event.eventGuid,
                     sessionKey: capture.event.sessionKey,
-                    reason: error instanceof Error ? error.message : String(error),
+                    reason: "semantic_capture_routing_invalid",
                 },
             });
         }
     }
+    const readyCandidates = preparedCandidates.filter((prepared) => prepared.status === "ready");
+    await Promise.all(groupBlueBubblesObservationsByLane(readyCandidates).map(async (lane) => {
+        for (const prepared of lane) {
+            const { capture, normalized, observationReservation } = prepared;
+            try {
+                options.lifecycleSignal?.throwIfAborted();
+                const handled = await handleCapturedBlueBubblesSemanticEvent({
+                    status: "captured",
+                    capture,
+                    normalized,
+                    writeResult: "semantic_capture_duplicate",
+                }, resolvedDeps, "webhook", {
+                    timeoutMs: BLUEBUBBLES_RECOVERY_TURN_TIMEOUT_MS,
+                    autonomyBudgetTrigger: "recovery",
+                    semanticRecovery: true,
+                    observationReservation,
+                    lifecycleSignal: options.lifecycleSignal,
+                });
+                if (handled.reason === "semantic_claim_timeout") {
+                    continue;
+                }
+                if (shouldCountBlueBubblesRecoveryResultAsSkipped(handled.reason) || !handled.notifiedAgent) {
+                    result.skipped++;
+                }
+                else {
+                    result.recovered++;
+                }
+            }
+            catch (error) {
+                if (options.lifecycleSignal?.aborted)
+                    throw options.lifecycleSignal.reason;
+                recordBlueBubblesRecoveryFailureForBudget(agentName, normalized, "webhook");
+                result.failed++;
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn",
+                    component: "senses",
+                    event: "senses.bluebubbles_capture_recovery_error",
+                    message: "captured bluebubbles message recovery failed",
+                    meta: {
+                        messageGuid: capture.event.eventGuid,
+                        sessionKey: capture.event.sessionKey,
+                        reason: error instanceof Error ? error.message : String(error),
+                    },
+                });
+            }
+        }
+    }));
     const semanticEventGuids = new Set(candidates
         .map((capture) => capture.event.eventGuid)
         .filter((eventGuid) => typeof eventGuid === "string")
@@ -2552,7 +3160,7 @@ async function recoverMissedBlueBubblesMessages(deps = {}) {
     }
     return result;
 }
-function createBlueBubblesWebhookHandler(deps = {}) {
+function createBlueBubblesWebhookHandler(deps = {}, options = {}) {
     return async (req, res) => {
         const url = new URL(req.url ?? "/", "http://127.0.0.1");
         if (url.pathname === "/health") {
@@ -2633,11 +3241,13 @@ function createBlueBubblesWebhookHandler(deps = {}) {
             return;
         }
         const resolvedDeps = { ...defaultDeps, ...deps };
+        const observationReservation = reserveBlueBubblesObservation(normalized);
         let captured;
         try {
-            captured = await captureBlueBubblesSemanticEvent(normalized, resolvedDeps, "webhook");
+            captured = await captureBlueBubblesSemanticEvent(normalized, resolvedDeps, "webhook", observationReservation);
         }
         catch (error) {
+            (0, latest_turn_1.clearPending)(observationReservation);
             (0, runtime_1.emitNervesEvent)({
                 level: "error",
                 component: "senses",
@@ -2652,6 +3262,7 @@ function createBlueBubblesWebhookHandler(deps = {}) {
             return;
         }
         if (captured.status === "audit_only") {
+            (0, latest_turn_1.clearPending)(observationReservation);
             writeJson(res, 200, {
                 handled: true,
                 notifiedAgent: false,
@@ -2669,7 +3280,16 @@ function createBlueBubblesWebhookHandler(deps = {}) {
             reason: "queued",
         });
         setTimeout(() => {
-            void handleCapturedBlueBubblesSemanticEvent(captured, resolvedDeps, "webhook").catch((error) => {
+            if (options.lifecycleSignal?.aborted) {
+                (0, latest_turn_1.clearPending)(observationReservation);
+                return;
+            }
+            void handleCapturedBlueBubblesSemanticEvent(captured, resolvedDeps, "webhook", {
+                observationReservation,
+                lifecycleSignal: options.lifecycleSignal,
+            }).catch((error) => {
+                if (options.lifecycleSignal?.aborted)
+                    return;
                 (0, runtime_1.emitNervesEvent)({
                     level: "error",
                     component: "senses",
@@ -3088,20 +3708,35 @@ async function drainAndSendPendingBlueBubbles(deps = {}, pendingRoot) {
 }
 function startBlueBubblesApp(deps = {}) {
     const resolvedDeps = { ...defaultDeps, ...deps };
+    const lifecycleController = new AbortController();
     (0, semantic_receipts_1.initializeBlueBubblesSemanticCutover)(resolvedDeps.getAgentName());
     resolvedDeps.createClient();
+    seedBlueBubblesStartupSemanticObservations(resolvedDeps);
+    const startupCatchUpObservationBatch = (0, latest_turn_1.beginObservationBatch)(BLUEBUBBLES_CATCHUP_PAGE_SIZE * BLUEBUBBLES_CATCHUP_MAX_PAGES);
     const channelConfig = (0, config_1.getBlueBubblesChannelConfig)();
-    const server = resolvedDeps.createServer(createBlueBubblesWebhookHandler(deps));
+    const server = resolvedDeps.createServer(createBlueBubblesWebhookHandler(deps, {
+        lifecycleSignal: lifecycleController.signal,
+    }));
     let recoveryPassRunning = false;
+    let runtimeSyncRunning = false;
     let recoveryDelayTimer = null;
+    let webhookReconciler = null;
+    let closed = false;
     function triggerRecoveryPass() {
+        /* v8 ignore next -- close clears both recovery timers; guard covers an already-queued host callback @preserve */
+        if (closed)
+            return;
         /* v8 ignore next -- re-entrant timer guard; difficult to force deterministically without timing the turn lock @preserve */
         if (recoveryPassRunning)
             return;
         recoveryPassRunning = true;
-        void recoverQueuedBlueBubblesMessages(resolvedDeps)
+        void recoverQueuedBlueBubblesMessages(resolvedDeps, {
+            lifecycleSignal: lifecycleController.signal,
+        })
             /* v8 ignore start -- defensive wrapper; expected per-message failures are handled inside recovery helpers @preserve */
             .catch((error) => {
+            if (closed || lifecycleController.signal.aborted)
+                return;
             (0, runtime_1.emitNervesEvent)({
                 level: "warn",
                 component: "senses",
@@ -3116,6 +3751,8 @@ function startBlueBubblesApp(deps = {}) {
         });
     }
     function scheduleRecoveryPass() {
+        if (closed)
+            return;
         /* v8 ignore next -- duplicate scheduling guard for overlapping health sync completions @preserve */
         if (recoveryDelayTimer !== null)
             return;
@@ -3124,11 +3761,42 @@ function startBlueBubblesApp(deps = {}) {
             triggerRecoveryPass();
         }, BLUEBUBBLES_RECOVERY_PASS_DELAY_MS);
     }
+    function triggerRuntimeSync(catchUpObservationBatch) {
+        if (closed || runtimeSyncRunning)
+            return;
+        runtimeSyncRunning = true;
+        void syncBlueBubblesRuntime(resolvedDeps, {
+            ...(catchUpObservationBatch ? { catchUpObservationBatch } : {}),
+            lifecycleSignal: lifecycleController.signal,
+        })
+            .then(scheduleRecoveryPass)
+            .catch((error) => {
+            if (closed)
+                return;
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "senses",
+                event: "senses.bluebubbles_recovery_error",
+                message: "bluebubbles runtime sync failed",
+                meta: { reason: error instanceof Error ? error.message : String(error) },
+            });
+        })
+            .finally(() => {
+            runtimeSyncRunning = false;
+        });
+    }
     const runtimeTimer = setInterval(() => {
-        void syncBlueBubblesRuntime(resolvedDeps).then(scheduleRecoveryPass);
+        /* v8 ignore next -- close clears this interval; guard covers an already-queued host callback @preserve */
+        if (closed)
+            return;
+        triggerRuntimeSync();
     }, BLUEBUBBLES_RUNTIME_SYNC_INTERVAL_MS);
     const recoveryTimer = setInterval(triggerRecoveryPass, BLUEBUBBLES_RECOVERY_PASS_INTERVAL_MS);
     server.on?.("close", () => {
+        closed = true;
+        webhookReconciler?.close();
+        webhookReconciler = null;
+        lifecycleController.abort(new Error("bluebubbles_runtime_shutdown"));
         clearInterval(runtimeTimer);
         clearInterval(recoveryTimer);
         if (recoveryDelayTimer !== null) {
@@ -3137,6 +3805,17 @@ function startBlueBubblesApp(deps = {}) {
         }
     });
     server.listen(channelConfig.port, () => {
+        const blueBubblesConfig = (0, config_1.getBlueBubblesConfig)();
+        webhookReconciler = (0, webhook_registration_1.createBlueBubblesWebhookReconciler)({
+            serverUrl: blueBubblesConfig.serverUrl,
+            password: blueBubblesConfig.password,
+            callbackPort: channelConfig.port,
+            callbackPath: channelConfig.webhookPath,
+            agentName: resolvedDeps.getAgentName(),
+            machineId: (0, machine_identity_1.loadOrCreateMachineIdentity)().machineId,
+            requestTimeoutMs: channelConfig.requestTimeoutMs,
+            listenerReady: true,
+        });
         (0, runtime_1.emitNervesEvent)({
             component: "channels",
             event: "channel.app_started",
@@ -3144,6 +3823,6 @@ function startBlueBubblesApp(deps = {}) {
             meta: { port: channelConfig.port, webhookPath: channelConfig.webhookPath },
         });
     });
-    void syncBlueBubblesRuntime(resolvedDeps).then(scheduleRecoveryPass);
+    triggerRuntimeSync(startupCatchUpObservationBatch);
     return server;
 }