@ouro.bot/cli 0.1.0-alpha.83 → 0.1.0-alpha.831

package/dist/senses/bluebubbles/index.js

@@ -0,0 +1,3841 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BB_IN_FLIGHT_MAX_AGE_MS = exports.BLUEBUBBLES_SEMANTIC_GENERATION_RETENTION_MS = void 0;
+exports.pruneBlueBubblesSemanticObservationGenerations = pruneBlueBubblesSemanticObservationGenerations;
+exports.tokenizeForDedupe = tokenizeForDedupe;
+exports.jaccardSimilarity = jaccardSimilarity;
+exports.isBlueBubblesMessageInFlight = isBlueBubblesMessageInFlight;
+exports.beginBlueBubblesMessageInFlight = beginBlueBubblesMessageInFlight;
+exports.endBlueBubblesMessageInFlight = endBlueBubblesMessageInFlight;
+exports.__resetBlueBubblesInFlightForTests = __resetBlueBubblesInFlightForTests;
+exports.createBlueBubblesCallbacks = createBlueBubblesCallbacks;
+exports.isAgentSelfHandle = isAgentSelfHandle;
+exports.getDiscoveredOwnHandles = getDiscoveredOwnHandles;
+exports.clearDiscoveredOwnHandles = clearDiscoveredOwnHandles;
+exports.recordDiscoveredOwnHandle = recordDiscoveredOwnHandle;
+exports.seedBlueBubblesStartupSemanticObservations = seedBlueBubblesStartupSemanticObservations;
+exports.handleBlueBubblesEvent = handleBlueBubblesEvent;
+exports.recoverQueuedBlueBubblesMessages = recoverQueuedBlueBubblesMessages;
+exports.catchUpMissedBlueBubblesMessages = catchUpMissedBlueBubblesMessages;
+exports.recoverCapturedBlueBubblesInboundMessages = recoverCapturedBlueBubblesInboundMessages;
+exports.recoverMissedBlueBubblesMessages = recoverMissedBlueBubblesMessages;
+exports.createBlueBubblesWebhookHandler = createBlueBubblesWebhookHandler;
+exports.sendProactiveBlueBubblesMessageToSession = sendProactiveBlueBubblesMessageToSession;
+exports.drainAndSendPendingBlueBubbles = drainAndSendPendingBlueBubbles;
+exports.startBlueBubblesApp = startBlueBubblesApp;
+const fs = __importStar(require("node:fs"));
+const http = __importStar(require("node:http"));
+const path = __importStar(require("node:path"));
+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");
+const friends_1 = require("@ouro.bot/friends");
+const pending_1 = require("../../mind/pending");
+const prompt_1 = require("../../mind/prompt");
+const mcp_manager_1 = require("../../repertoire/mcp-manager");
+const runtime_1 = require("../../nerves/runtime");
+const session_transaction_1 = require("../../mind/session-transaction");
+const orientation_frame_1 = require("../../heart/orientation-frame");
+const proactive_content_guard_1 = require("../proactive-content-guard");
+const bluebubbles_meta_guard_1 = require("../bluebubbles-meta-guard");
+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");
+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_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.
+ *
+ * Stores the timestamp (ms) when each (sessionKey, messageGuid) was claimed.
+ * Stale entries (older than BB_IN_FLIGHT_MAX_AGE_MS) are treated as expired:
+ * `isBlueBubblesMessageInFlight` returns false, and `beginBlueBubblesMessageInFlight`
+ * is allowed to replace the stale marker.
+ *
+ * Rationale: `handleBlueBubblesNormalizedEvent` has many exit paths and a leak
+ * on any one of them strands the marker forever (until BB sense process restart),
+ * which silently halts forward progress on the recovery queue. A real
+ * agent lost BlueBubbles inbound for 12+ hours on 2026-05-11 because of
+ * exactly this.
+ *
+ * The TTL bounds the worst case: a leaked marker self-clears after
+ * BB_IN_FLIGHT_MAX_AGE_MS, and the next recovery pass can retry. This is
+ * defense-in-depth alongside auditing the explicit `endBlueBubblesMessageInFlight`
+ * exit-path calls — the audit is still worthwhile, but the TTL guarantees the
+ * class of bug can't wedge the queue indefinitely.
+ */
+const bbInFlightMessageClaims = new Map();
+/**
+ * In-flight markers expire 50% beyond the longest expected turn (recovery turn
+ * timeout = 10 min). 15 min gives normal turns full headroom while preventing
+ * a leaked marker from blocking forward progress for hours.
+ */
+exports.BB_IN_FLIGHT_MAX_AGE_MS = 15 * 60_000;
+// ── 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
+// of the similarity behavior without spinning up the full callbacks closure.
+const NEAR_DUPLICATE_JACCARD_THRESHOLD = 0.7;
+const NEAR_DUPLICATE_MIN_TOKENS = 5;
+function tokenizeForDedupe(text) {
+    const matches = text.toLowerCase().match(/[a-z0-9']+/g);
+    if (!matches)
+        return new Set();
+    return new Set(matches);
+}
+function jaccardSimilarity(a, b) {
+    if (a.size === 0 || b.size === 0)
+        return 0;
+    let intersection = 0;
+    for (const token of a) {
+        if (b.has(token))
+            intersection += 1;
+    }
+    const union = a.size + b.size - intersection;
+    return intersection / union;
+}
+function blueBubblesMessageKey(sessionKey, messageGuid) {
+    return `${sessionKey}:${messageGuid.trim()}`;
+}
+function isClaimStale(claimedAtMs, nowMs = Date.now()) {
+    return nowMs - claimedAtMs >= exports.BB_IN_FLIGHT_MAX_AGE_MS;
+}
+/** Internal — exported only so unit tests can exercise the TTL semantics. */
+function isBlueBubblesMessageInFlight(sessionKey, messageGuid) {
+    if (!messageGuid.trim())
+        return false;
+    const claimedAtMs = bbInFlightMessageClaims.get(blueBubblesMessageKey(sessionKey, messageGuid));
+    if (claimedAtMs === undefined)
+        return false;
+    return !isClaimStale(claimedAtMs);
+}
+/** Internal — exported only so unit tests can exercise the TTL semantics. */
+function beginBlueBubblesMessageInFlight(sessionKey, messageGuid) {
+    if (!messageGuid.trim())
+        return true;
+    const key = blueBubblesMessageKey(sessionKey, messageGuid);
+    const existing = bbInFlightMessageClaims.get(key);
+    if (existing !== undefined && !isClaimStale(existing))
+        return false;
+    if (existing !== undefined && isClaimStale(existing)) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "senses",
+            event: "senses.bluebubbles_in_flight_marker_expired",
+            message: "in-flight marker expired by TTL; allowing re-claim",
+            meta: {
+                sessionKey,
+                messageGuid,
+                claimAgeMs: Date.now() - existing,
+                ttlMs: exports.BB_IN_FLIGHT_MAX_AGE_MS,
+            },
+        });
+    }
+    bbInFlightMessageClaims.set(key, Date.now());
+    return true;
+}
+/** Internal — exported only so unit tests can exercise the TTL semantics. */
+function endBlueBubblesMessageInFlight(sessionKey, messageGuid) {
+    bbInFlightMessageClaims.delete(blueBubblesMessageKey(sessionKey, messageGuid));
+}
+/**
+ * Test-only: clear all in-flight markers. Production code must use begin/end pairs.
+ * Exported so unit tests can reset cross-test state without resetting modules.
+ */
+function __resetBlueBubblesInFlightForTests() {
+    bbInFlightMessageClaims.clear();
+}
+const defaultDeps = {
+    getAgentName: identity_1.getAgentName,
+    buildSystem: prompt_1.buildSystem,
+    runAgent: core_1.runAgent,
+    loadSession: context_1.loadSession,
+    saveSession: context_1.saveSession,
+    postTurnTrim: context_1.postTurnTrim,
+    postTurnPersist: context_1.postTurnPersist,
+    sessionPath: config_1.sessionPath,
+    accumulateFriendTokens: friends_1.accumulateFriendTokens,
+    createClient: () => (0, client_1.createBlueBubblesClient)(),
+    recordMutation: mutation_log_1.recordBlueBubblesMutation,
+    createFriendStore: () => new friends_1.FileFriendStore(path.join((0, identity_1.getAgentRoot)(), "friends")),
+    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,
+    withSessionTurnLease: session_transaction_1.withSessionTurnLease,
+};
+const BLUEBUBBLES_RUNTIME_SYNC_INTERVAL_MS = 30_000;
+const BLUEBUBBLES_RECOVERY_PASS_DELAY_MS = 1_000;
+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_CALLBACK_CLEANUP_TIMEOUT_MS = 2_000;
+const BLUEBUBBLES_ACTIVITY_OPERATION_TIMEOUT_MS = 20_000;
+const BLUEBUBBLES_CATCHUP_PAGE_SIZE = 50;
+const BLUEBUBBLES_CATCHUP_MAX_PAGES = 20;
+const BLUEBUBBLES_HEALTHY_CATCHUP_OVERLAP_MS = 90_000;
+const BLUEBUBBLES_RECOVERY_CATCHUP_LOOKBACK_MS = 24 * 60 * 60 * 1000;
+const BLUEBUBBLES_FIRST_CATCHUP_LOOKBACK_MS = 10 * 60 * 1000;
+class BlueBubblesRecoveryTurnTimeoutError extends Error {
+    constructor(timeoutMs) {
+        super(`bluebubbles recovery turn timed out after ${timeoutMs}ms`);
+        this.name = "BlueBubblesRecoveryTurnTimeoutError";
+    }
+}
+class BlueBubblesActivityTimeoutError extends Error {
+    constructor(operation, timeoutMs) {
+        super(`bluebubbles ${operation} activity timed out after ${timeoutMs}ms`);
+        this.name = "BlueBubblesActivityTimeoutError";
+    }
+}
+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([
+        Promise.resolve().then(() => task(controller.signal)),
+        aborted,
+        new Promise((_, reject) => {
+            timer = setTimeout(() => {
+                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") {
+                timer.unref();
+            }
+        }),
+    ]).finally(() => {
+        removeAbortListener();
+        /* v8 ignore next -- timer is assigned unless a callback task throws synchronously; callback tasks are async @preserve */
+        if (timer !== null)
+            clearTimeout(timer);
+    });
+}
+async function waitForBlueBubblesCallbackCleanup(queue, timeoutMs, meta) {
+    let timer = null;
+    let timedOut = false;
+    await Promise.race([
+        queue,
+        new Promise((resolve) => {
+            timer = setTimeout(() => {
+                timedOut = true;
+                resolve();
+            }, timeoutMs);
+            /* v8 ignore next -- timer handles expose unref only in some runtimes @preserve */
+            if (typeof timer.unref === "function") {
+                timer.unref();
+            }
+        }),
+    ]).finally(() => {
+        /* v8 ignore next -- timer is assigned for the cleanup race; null only protects unusual synchronous construction failure @preserve */
+        if (timer !== null)
+            clearTimeout(timer);
+    });
+    if (!timedOut)
+        return true;
+    (0, runtime_1.emitNervesEvent)({
+        level: "warn",
+        component: "senses",
+        event: "senses.bluebubbles_activity_cleanup_timeout",
+        message: "bluebubbles callback cleanup timed out; releasing live turn lane",
+        meta: { ...meta, timeoutMs },
+    });
+    return false;
+}
+function resolveFriendParams(event) {
+    if (event.chat.isGroup) {
+        return {
+            provider: "imessage-handle",
+            externalId: `group:${event.chat.chatGuid}`,
+            displayName: event.chat.displayName ?? "Unknown Group",
+            channel: "bluebubbles",
+        };
+    }
+    return {
+        provider: "imessage-handle",
+        externalId: event.sender.externalId,
+        displayName: event.sender.displayName,
+        channel: "bluebubbles",
+    };
+}
+function resolveGroupExternalId(event) {
+    return `group:${event.chat.chatGuid}`;
+}
+/**
+ * Check if any participant in a group chat is a known family member.
+ * Looks up each participant handle in the friend store.
+ */
+async function checkGroupHasFamilyMember(store, event) {
+    if (!event.chat.isGroup)
+        return false;
+    for (const handle of event.chat.participantHandles) {
+        const friend = await store.findByExternalId("imessage-handle", handle);
+        if (friend?.trustLevel === "family")
+            return true;
+    }
+    return false;
+}
+/**
+ * Check if an acquaintance shares any group chat with a family member.
+ * Compares group-prefixed externalIds between the acquaintance and all family members.
+ */
+async function checkHasExistingGroupWithFamily(store, senderFriend) {
+    const trustLevel = senderFriend.trustLevel ?? "friend";
+    if (trustLevel !== "acquaintance")
+        return false;
+    const acquaintanceGroups = new Set((senderFriend.externalIds ?? [])
+        .filter((eid) => eid.externalId.startsWith("group:"))
+        .map((eid) => eid.externalId));
+    if (acquaintanceGroups.size === 0)
+        return false;
+    const allFriends = await (store.listAll?.() ?? Promise.resolve([]));
+    for (const friend of allFriends) {
+        if (friend.trustLevel !== "family")
+            continue;
+        const friendGroups = (friend.externalIds ?? [])
+            .filter((eid) => eid.externalId.startsWith("group:"))
+            .map((eid) => eid.externalId);
+        for (const group of friendGroups) {
+            if (acquaintanceGroups.has(group))
+                return true;
+        }
+    }
+    return false;
+}
+function extractMessageText(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .map((part) => {
+        if (part && typeof part === "object" && "type" in part && part.type === "text" && typeof part.text === "string") {
+            return part.text;
+        }
+        return "";
+    })
+        .filter(Boolean)
+        .join("\n");
+}
+function isHistoricalLaneMetadataLine(line) {
+    return /^\[(conversation scope|recent active lanes|routing control):?/i.test(line)
+        || /^- (top_level|thread:[^:]+):/i.test(line);
+}
+function extractHistoricalLaneSummary(messages) {
+    const seen = new Set();
+    const summaries = [];
+    for (let index = messages.length - 1; index >= 0; index--) {
+        const message = messages[index];
+        if (message.role !== "user")
+            continue;
+        const text = extractMessageText(message.content);
+        if (!text)
+            continue;
+        const firstLine = text.split("\n")[0].trim();
+        const threadMatch = firstLine.match(/thread id: ([^\]|]+)/i);
+        const laneKey = threadMatch
+            ? `thread:${threadMatch[1].trim()}`
+            : /top[-_]level/i.test(firstLine)
+                ? "top_level"
+                : null;
+        if (!laneKey || seen.has(laneKey))
+            continue;
+        seen.add(laneKey);
+        const snippet = text
+            .split("\n")
+            .slice(1)
+            .map((line) => line.trim())
+            .find((line) => line.length > 0 && !isHistoricalLaneMetadataLine(line))
+            ?.slice(0, 80) ?? "(no recent text)";
+        summaries.push({
+            key: laneKey,
+            label: laneKey === "top_level" ? "top_level" : laneKey,
+            snippet,
+        });
+        if (summaries.length >= 5)
+            break;
+    }
+    return summaries;
+}
+function buildBlueBubblesOrientationSource(event, existingMessages, evidence, conversationKind, repliedToText) {
+    const repairNotice = event.repairNotice?.trim();
+    const actor = evidence.actor;
+    const participants = evidence.participants
+        .filter((participant) => !(participant.provider === actor.provider
+        && participant.externalId === actor.externalId))
+        .map((participant) => ({
+        role: "group_participant_only",
+        provider: participant.provider,
+        externalId: participant.externalId,
+        displayName: participant.displayName,
+    }));
+    const presentation = {
+        authority: "presentation_only",
+        conversationKind,
+        event: {
+            provider: evidence.provider,
+            kind: evidence.kind,
+            sourceEventType: evidence.sourceEventType,
+            fromMe: evidence.fromMe,
+        },
+        actor: {
+            role: "observed_actor",
+            provider: actor.provider,
+            externalId: actor.externalId,
+            displayName: actor.displayName,
+        },
+        participants,
+    };
+    const summaries = extractHistoricalLaneSummary(existingMessages);
+    const threadId = event.threadOriginatorGuid?.trim() || undefined;
+    const hasThreadRoute = !!threadId || summaries.some((summary) => summary.key.startsWith("thread:"));
+    return {
+        kind: "bluebubbles",
+        ...presentation,
+        lane: threadId ? "thread" : "top_level",
+        defaultReplyTarget: threadId ? "current_lane" : "top_level",
+        ...(threadId ? { threadId } : {}),
+        ...(repliedToText ? { replyingToText: repliedToText } : {}),
+        ...(repairNotice ? { repairNotice } : {}),
+        ...(summaries.length > 0 ? { recentLanes: summaries } : {}),
+        ...(hasThreadRoute
+            ? { routingHint: "use bluebubbles_set_reply_target to choose current_lane, top_level, or a listed thread before sending BlueBubbles-specific replies." }
+            : {}),
+    };
+}
+function buildInboundText(event) {
+    const baseText = event.textForAgent;
+    if (!event.chat.isGroup) {
+        return baseText;
+    }
+    return `${event.sender.displayName}: ${baseText}`;
+}
+function buildInboundContent(event) {
+    const text = buildInboundText(event);
+    if (!event.inputPartsForAgent || event.inputPartsForAgent.length === 0) {
+        return text;
+    }
+    return [
+        { type: "text", text },
+        ...event.inputPartsForAgent,
+    ];
+}
+function sessionLikelyContainsMessage(event, existingMessages) {
+    const fragment = event.textForAgent.trim();
+    if (!fragment)
+        return false;
+    return existingMessages.some((message) => {
+        if (message.role !== "user")
+            return false;
+        return extractMessageText(message.content).includes(fragment);
+    });
+}
+function getBlueBubblesContinuityIngressTexts(event) {
+    const text = event.textForAgent.trim();
+    if (text.length > 0)
+        return [text];
+    const fallbackText = (event.inputPartsForAgent ?? [])
+        .map((part) => {
+        if (part.type === "text" && typeof part.text === "string") {
+            return part.text.trim();
+        }
+        return "";
+    })
+        .filter(Boolean)
+        .join("\n");
+    return fallbackText ? [fallbackText] : [];
+}
+function sha256Hex(input) {
+    return (0, node_crypto_1.createHash)("sha256").update(input).digest("hex");
+}
+function timestampIsoForAutonomy(event) {
+    return Number.isFinite(event.timestamp)
+        ? new Date(event.timestamp).toISOString()
+        : new Date().toISOString();
+}
+function blueBubblesAutonomyTarget(event) {
+    return {
+        messageGuid: event.messageGuid,
+        sessionKeyHash: sha256Hex(event.chat.sessionKey),
+        chatGuidHash: event.chat.chatGuid ? sha256Hex(event.chat.chatGuid) : undefined,
+        chatIdentifierHash: event.chat.chatIdentifier ? sha256Hex(event.chat.chatIdentifier) : undefined,
+    };
+}
+function blueBubblesRecoveryStormInput(agentName, event, source) {
+    return {
+        agent: agentName,
+        triggerType: "recovery",
+        sourceKind: "sense",
+        senseOrHabit: "bluebubbles",
+        provider: "bluebubbles-recovery",
+        target: blueBubblesAutonomyTarget(event),
+        normalizedErrorName: "BlueBubblesRecoveryError",
+        normalizedErrorCode: "RECOVERY_FAILED",
+        codeLocation: `senses/bluebubbles/${source}`,
+        idempotencyBucket: `bluebubbles-recovery:${source}`,
+    };
+}
+function shouldUseBlueBubblesRecoveryBudget(source, options) {
+    return options.autonomyBudgetTrigger === "recovery"
+        || source === "mutation-recovery"
+        || source === "upstream-catchup"
+        || source === "recovery-bootstrap";
+}
+function shouldCountBlueBubblesRecoveryResultAsSkipped(reason) {
+    return reason === "already_processed"
+        || reason === "autonomy_budget_blocked"
+        || reason === "mutation_state_only"
+        || reason === "from_me";
+}
+function recordBlueBubblesRecoveryFailureForBudget(agentName, event, source) {
+    try {
+        (0, autonomy_budget_1.recordAutonomyFailure)((0, identity_1.getAgentRoot)(agentName), {
+            ...blueBubblesRecoveryStormInput(agentName, event, source),
+            occurredAt: timestampIsoForAutonomy(event),
+        });
+    }
+    catch {
+        // Autonomy failure accounting must not turn a recovery error into a broader sense outage.
+    }
+}
+function insertEphemeralContextMessages(messages, contextMessages, currentUserMessage) {
+    if (contextMessages.length === 0)
+        return messages;
+    const requiredCurrentIndex = currentUserMessage ? messages.indexOf(currentUserMessage) : -1;
+    const insertionIndex = requiredCurrentIndex >= 0 ? requiredCurrentIndex : Math.max(0, messages.length - 1);
+    return [
+        ...messages.slice(0, insertionIndex),
+        ...contextMessages,
+        ...messages.slice(insertionIndex),
+    ];
+}
+function knownProviderMessageTexts(messages) {
+    return messages
+        .map((message) => extractMessageText(message.content))
+        .map((text) => text.trim())
+        .filter((text) => text.length > 0);
+}
+async function buildBlueBubblesContextMessages(input) {
+    const event = input.event;
+    if (!Number.isFinite(event.timestamp))
+        return { messages: [], contextPacketIds: [] };
+    let result;
+    try {
+        result = await (0, context_packet_1.buildBlueBubblesContextPacket)({
+            agentName: input.agentName,
+            client: input.client,
+            event,
+            knownMessageTexts: knownProviderMessageTexts(input.knownMessages),
+        });
+    }
+    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",
+            event: "senses.bluebubbles_context_packet_injected",
+            message: "injected bluebubbles same-chat context packet",
+            meta: {
+                packetId: packet.packetId,
+                messageGuid: event.messageGuid,
+                contextMessages: historyCount,
+            },
+        });
+        return {
+            ...prepared,
+            contextPacketIds: [packet.packetId],
+        };
+    }
+    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 { ...prepared, contextPacketIds: [] };
+    }
+}
+function createReplyTargetController(event) {
+    const defaultTargetLabel = event.threadOriginatorGuid?.trim() ? "current_lane" : "top_level";
+    let selection = event.threadOriginatorGuid?.trim()
+        ? { target: "current_lane" }
+        : { target: "top_level" };
+    return {
+        getReplyToMessageGuid() {
+            if (selection.target === "top_level")
+                return undefined;
+            if (selection.target === "thread")
+                return selection.threadOriginatorGuid.trim();
+            return event.threadOriginatorGuid?.trim() ? event.messageGuid : undefined;
+        },
+        setSelection(next) {
+            selection = next;
+            if (next.target === "top_level") {
+                return "bluebubbles reply target override: top_level";
+            }
+            if (next.target === "thread") {
+                return `bluebubbles reply target override: thread:${next.threadOriginatorGuid}`;
+            }
+            return `bluebubbles reply target: using default for this turn (${defaultTargetLabel})`;
+        },
+    };
+}
+function emitBlueBubblesMarkReadWarning(chat, error) {
+    (0, runtime_1.emitNervesEvent)({
+        level: "warn",
+        component: "senses",
+        event: "senses.bluebubbles_mark_read_error",
+        message: "failed to mark bluebubbles chat as read",
+        meta: {
+            chatGuid: chat.chatGuid ?? null,
+            reason: error instanceof Error ? error.message : String(error),
+        },
+    });
+}
+function createBlueBubblesCallbacks(client, chat, replyTarget, isGroupChat, onVisibleActivity, options = {}) {
+    let textBuffer = "";
+    let typingActive = false;
+    let typingCouldBeActive = false;
+    let queue = Promise.resolve();
+    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
+    // empty set. Mid-turn settle/proof retry loops historically caused the
+    // agent to re-emit the same answer through multiple speak calls and a
+    // final flush, surfacing as 4 near-identical iMessages from one ask
+    // (2026-05-08 06:18 incident). The guard lets the engine retry harmlessly
+    // without duplicating outward delivery to the friend.
+    //
+    // PR #699 used exact whitespace+case-normalized match. Post-#699 evidence
+    // (2026-05-09 05:25 UTC, evt-001814 + evt-001818) showed two answers that
+    // start "yep — I looked it up… Assuming you mean AMC's The Audacity…" with
+    // substantially the same content but slight rephrasing — the LLM rewrites
+    // the same answer on a retry/recovery loop and bypasses an exact-match
+    // guard. We now also keep the original token sets so a fuzzy (Jaccard)
+    // check catches near-duplicates from the same turn.
+    const sentOutwardTextNorms = new Set();
+    const sentOutwardTokenSets = [];
+    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(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",
+                event: "senses.bluebubbles_activity_error",
+                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)
+            return;
+        /* v8 ignore next -- defensive guard: public callback entrypoints already drop after outbound close @preserve */
+        if (outboundClosed)
+            return;
+        typingActive = true;
+        typingCouldBeActive = true;
+        enqueue("typing_start", async (signal) => {
+            const [markReadResult, typingResult] = await Promise.allSettled([
+                client.markChatRead(chat, signal),
+                client.setTyping(chat, true, signal),
+            ]);
+            if (markReadResult.status === "rejected") {
+                emitBlueBubblesMarkReadWarning(chat, markReadResult.reason);
+            }
+            if (typingResult.status === "rejected") {
+                throw typingResult.reason;
+            }
+        });
+    }
+    function recordVisibleActivity() {
+        onVisibleActivity?.();
+    }
+    function isDuplicateOutwardText(trimmed) {
+        const norm = trimmed.replace(/\s+/g, " ").trim().toLowerCase();
+        if (sentOutwardTextNorms.has(norm))
+            return true;
+        // Fuzzy near-duplicate: when the same answer is rephrased between speak
+        // and settle (or across two speak calls in a recovery loop), the exact
+        // norm differs but token overlap is very high. We compare against every
+        // already-sent body's token set; if any has Jaccard overlap >= the
+        // threshold, treat as a duplicate. We require a minimum token count on
+        // the new body so single-word replies ("yes", "ok") don't get suppressed
+        // against any previous short one with shared tokens.
+        const newTokens = tokenizeForDedupe(trimmed);
+        if (newTokens.size >= NEAR_DUPLICATE_MIN_TOKENS) {
+            for (const prevTokens of sentOutwardTokenSets) {
+                if (prevTokens.size < NEAR_DUPLICATE_MIN_TOKENS)
+                    continue;
+                if (jaccardSimilarity(newTokens, prevTokens) >= NEAR_DUPLICATE_JACCARD_THRESHOLD) {
+                    return true;
+                }
+            }
+        }
+        sentOutwardTextNorms.add(norm);
+        sentOutwardTokenSets.push(newTokens);
+        return false;
+    }
+    function emitDuplicateOutwardSuppressed(site, messageLength) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "senses",
+            event: "bluebubbles.duplicate_outward_suppressed",
+            message: "suppressed near-identical outward send within single inbound turn",
+            meta: {
+                site,
+                chatGuid: chat.chatGuid ?? null,
+                messageLength,
+            },
+        });
+    }
+    return {
+        settleOutputMode: "retractable_buffer",
+        onModelStart() {
+            if (outboundClosed)
+                return;
+            if (options.enableActivitySignals !== false && !isGroupChat)
+                startTypingNow();
+            (0, runtime_1.emitNervesEvent)({
+                component: "senses",
+                event: "senses.bluebubbles_turn_start",
+                message: "bluebubbles turn started",
+                meta: { chatGuid: chat.chatGuid ?? null },
+            });
+        },
+        onModelStreamStart() {
+            (0, runtime_1.emitNervesEvent)({
+                component: "senses",
+                event: "senses.bluebubbles_stream_start",
+                message: "bluebubbles non-streaming response started",
+                meta: {},
+            });
+        },
+        onTextChunk(text) {
+            if (outboundClosed)
+                return;
+            if (options.enableActivitySignals !== false && isGroupChat && !typingActive)
+                startTypingNow();
+            textBuffer += text;
+        },
+        onReasoningChunk(_text) { },
+        onToolStart(name, _args) {
+            if (outboundClosed)
+                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, 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)({
+                component: "senses",
+                event: "senses.bluebubbles_tool_start",
+                message: "bluebubbles tool execution started",
+                meta: { name },
+            });
+        },
+        onToolEnd(name, summary, success) {
+            (0, runtime_1.emitNervesEvent)({
+                component: "senses",
+                event: "senses.bluebubbles_tool_end",
+                message: "bluebubbles tool execution completed",
+                meta: { name, success, summary },
+            });
+        },
+        onError(error, severity) {
+            (0, runtime_1.emitNervesEvent)({
+                level: severity === "terminal" ? "error" : "warn",
+                component: "senses",
+                event: "senses.bluebubbles_turn_error",
+                message: "bluebubbles turn callback error",
+                meta: { severity, reason: error.message },
+            });
+        },
+        onClearText() {
+            textBuffer = "";
+        },
+        async flushNow() {
+            if (outboundClosed) {
+                textBuffer = "";
+                return;
+            }
+            // Contract: throws if delivery fails. We deliberately let `client.sendText`
+            // rejections propagate so the engine's speak interception can mark the
+            // tool call as failed and tell the agent the message did not reach the
+            // friend (rather than silently logging and pretending success).
+            const trimmed = textBuffer.trim();
+            if (!trimmed)
+                return;
+            textBuffer = "";
+            if ((0, bluebubbles_meta_guard_1.containsInternalMetaMarkers)(trimmed)) {
+                (0, bluebubbles_meta_guard_1.emitBluebubblesMetaBlocked)({
+                    site: "flushNow",
+                    message: "bluebubbles speak text blocked: internal meta markers",
+                    meta: {
+                        chatGuid: chat.chatGuid ?? null,
+                        messageLength: trimmed.length,
+                    },
+                });
+                return;
+            }
+            if (isDuplicateOutwardText(trimmed)) {
+                emitDuplicateOutwardSuppressed("flushNow", trimmed.length);
+                return;
+            }
+            if (!await canRunOutbound())
+                return;
+            await client.sendText({
+                chat,
+                text: trimmed,
+                replyToMessageGuid: replyTarget.getReplyToMessageGuid(),
+            });
+            recordVisibleActivity();
+            // Note: do NOT call client.setTyping(chat, false) here — the agent is
+            // still mid-turn, so the typing indicator stays ACTIVE.
+            (0, runtime_1.emitNervesEvent)({
+                component: "senses",
+                event: "bluebubbles.speak_flush",
+                message: "bluebubbles flushed mid-turn speak",
+                meta: { messageLength: trimmed.length },
+            });
+        },
+        async flush(flushOptions = {}) {
+            if (outboundClosed) {
+                textBuffer = "";
+                await waitForBlueBubblesCallbackCleanup(queue, BLUEBUBBLES_CALLBACK_CLEANUP_TIMEOUT_MS, {
+                    operation: "flush_after_close",
+                    chatGuid: chat.chatGuid ?? null,
+                });
+                return { status: "not_invoked", reason: "closed" };
+            }
+            await queue;
+            const trimmed = textBuffer.trim();
+            if (!trimmed) {
+                if (typingActive) {
+                    enqueueTypingStop();
+                    await queue;
+                }
+                return { status: "not_invoked", reason: "empty" };
+            }
+            textBuffer = "";
+            /* v8 ignore next 4 -- branch: typing may already be stopped before flush @preserve */
+            if (typingActive) {
+                enqueueTypingStop();
+                await queue;
+            }
+            if ((0, bluebubbles_meta_guard_1.containsInternalMetaMarkers)(trimmed)) {
+                (0, bluebubbles_meta_guard_1.emitBluebubblesMetaBlocked)({
+                    site: "flush",
+                    message: "bluebubbles outbound text blocked: internal meta markers",
+                    meta: {
+                        chatGuid: chat.chatGuid ?? null,
+                        messageLength: trimmed.length,
+                    },
+                });
+                return { status: "not_invoked", reason: "blocked_meta" };
+            }
+            if (isDuplicateOutwardText(trimmed)) {
+                emitDuplicateOutwardSuppressed("flush", trimmed.length);
+                return { status: "not_invoked", reason: "duplicate" };
+            }
+            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 = {}) {
+            const cleanupTimeoutMs = options.timeoutMs ?? BLUEBUBBLES_CALLBACK_CLEANUP_TIMEOUT_MS;
+            const needsTypingStop = typingActive;
+            if (needsTypingStop) {
+                enqueueTypingStop();
+            }
+            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 = "";
+            abortActiveActivity(`bluebubbles outbound ${reason}`);
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "senses",
+                event: "senses.bluebubbles_outbound_closed",
+                message: "bluebubbles outbound callbacks closed for timed-out turn",
+                meta: { chatGuid: chat.chatGuid ?? null, reason },
+            });
+        },
+    };
+}
+async function readRequestBody(req) {
+    let body = "";
+    for await (const chunk of req) {
+        body += chunk.toString();
+    }
+    return body;
+}
+function writeJson(res, statusCode, payload) {
+    res.statusCode = statusCode;
+    res.setHeader("Content-Type", "application/json; charset=utf-8");
+    res.end(JSON.stringify(payload));
+}
+function writeSemanticCaptureFailure(res) {
+    res.statusCode = 503;
+    res.setHeader("Content-Type", "application/json");
+    res.end('{"ok":false,"error":"semantic_capture_failed"}');
+}
+function isWebhookPasswordValid(url, expectedPassword) {
+    const provided = url.searchParams.get("password");
+    return !provided || provided === expectedPassword;
+}
+function normalizeHandleForSelfMatch(handle) {
+    const trimmed = handle.trim().toLowerCase();
+    if (!trimmed)
+        return "";
+    // Phone-shaped: strip everything but digits so +1 (415) 555-... matches 14155550000.
+    if (/[+\d]/.test(trimmed) && !trimmed.includes("@")) {
+        const digits = trimmed.replace(/\D/g, "");
+        if (digits.length >= 7)
+            return digits;
+    }
+    return trimmed;
+}
+function isAgentSelfHandle(senderExternalId, ownHandles) {
+    if (!senderExternalId || !senderExternalId.trim())
+        return false;
+    const target = normalizeHandleForSelfMatch(senderExternalId);
+    /* v8 ignore start -- target is non-empty by construction since senderExternalId was just verified non-whitespace */
+    if (!target)
+        return false;
+    /* v8 ignore stop */
+    for (const own of ownHandles) {
+        if (normalizeHandleForSelfMatch(own) === target)
+            return true;
+    }
+    return false;
+}
+/**
+ * In-memory store of agent iMessage handles auto-discovered from group-chat
+ * `event.fromMe === true` events. Bluebubbles can attribute the peer's handle
+ * as `event.sender.externalId` on 1:1 outbound messages, so discovery is
+ * intentionally limited to the group echo bug that motivated
+ * `bluebubbles.ownHandles` originally.
+ *
+ * Per-process. A daemon restart re-learns from the next outbound. The
+ * accompanying nerves event (`senses.bluebubbles_own_handle_discovered`)
+ * tells the operator what to add to `bluebubbles.ownHandles` for cross-
+ * restart durability.
+ */
+const discoveredOwnHandles = new Set();
+function getDiscoveredOwnHandles() {
+    return [...discoveredOwnHandles];
+}
+function clearDiscoveredOwnHandles() {
+    discoveredOwnHandles.clear();
+}
+function recordDiscoveredOwnHandle(senderExternalId) {
+    if (!senderExternalId || !senderExternalId.trim())
+        return false;
+    const trimmed = senderExternalId.trim();
+    const normalized = normalizeHandleForSelfMatch(trimmed);
+    /* v8 ignore next -- defensive: normalizeHandleForSelfMatch only returns falsy for empty input, already guarded above @preserve */
+    if (!normalized)
+        return false;
+    for (const existing of discoveredOwnHandles) {
+        if (normalizeHandleForSelfMatch(existing) === normalized)
+            return false;
+    }
+    discoveredOwnHandles.add(trimmed);
+    (0, runtime_1.emitNervesEvent)({
+        level: "info",
+        component: "senses",
+        event: "senses.bluebubbles_own_handle_discovered",
+        message: "captured a new agent-owned bluebubbles handle from an isFromMe outbound — add to bluebubbles.ownHandles for cross-restart durability",
+        meta: { handle: trimmed, totalDiscovered: discoveredOwnHandles.size },
+    });
+    return true;
+}
+function isSelfFriendRecord(friend, agentName) {
+    if (!friend || friend.kind !== "agent")
+        return false;
+    const normalizedAgent = agentName.trim().toLowerCase();
+    const name = friend.name?.trim().toLowerCase();
+    const bundleName = friend.agentMeta?.bundleName?.trim().toLowerCase();
+    return name === normalizedAgent || bundleName === normalizedAgent;
+}
+async function shouldFilterAgentSelfHandle(event, resolvedDeps) {
+    if (!event.chat.isGroup)
+        return false;
+    if (!isAgentSelfHandle(event.sender.externalId, resolvedDeps.getOwnHandles()))
+        return false;
+    const store = resolvedDeps.createFriendStore();
+    const knownFriend = await store
+        .findByExternalId("imessage-handle", event.sender.externalId)
+        .catch(() => null);
+    if (knownFriend && !isSelfFriendRecord(knownFriend, resolvedDeps.getAgentName())) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "senses",
+            event: "senses.bluebubbles_self_handle_bypassed_known_friend",
+            message: "did not filter bluebubbles sender even though it matched ownHandles because it resolves to a known non-self friend",
+            meta: {
+                messageGuid: event.messageGuid,
+                kind: event.kind,
+                senderExternalId: event.sender.externalId,
+                friendId: knownFriend.id,
+            },
+        });
+        return false;
+    }
+    return true;
+}
+function createBlueBubblesTurnStage(sessionKey) {
+    return {
+        failoverState: structuredClone(bbFailoverStates.get(sessionKey) ?? { pending: null }),
+    };
+}
+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_failover_state_promotion_failed",
+            message: "accepted bluebubbles reply could not promote staged failover state",
+            meta: {
+                messageGuid: event.messageGuid,
+                sessionKey: event.chat.sessionKey,
+                reason: error instanceof Error ? error.message : String(error),
+            },
+        });
+    }
+    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_processed_promotion_failed",
+            message: "accepted bluebubbles reply could not promote processed sidecar state",
+            meta: {
+                messageGuid: event.messageGuid,
+                sessionKey: event.chat.sessionKey,
+                reason: error instanceof Error ? error.message : String(error),
+            },
+        });
+    }
+}
+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 (shouldUseBlueBubblesRecoveryBudget(source, options)) {
+        const decision = (0, autonomy_budget_1.reserveAutonomyBudget)((0, identity_1.getAgentRoot)(agentName), {
+            agent: agentName,
+            triggerType: "recovery",
+            sourceKind: "sense",
+            senseOrHabit: "bluebubbles",
+            target: blueBubblesAutonomyTarget(event),
+            idempotencyKey: `bluebubbles-recovery:${source}:${event.messageGuid}`,
+            now: timestampIsoForAutonomy(event),
+            storm: blueBubblesRecoveryStormInput(agentName, event, source),
+        });
+        if (!decision.allowed) {
+            return { handled: true, notifiedAgent: false, kind: event.kind, reason: "autonomy_budget_blocked" };
+        }
+    }
+    try {
+        // 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" };
+            }
+            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);
+            return await resolvedDeps.withSessionTurnLease(sessPath, async (sessionTurnLease) => {
+                try {
+                    (0, session_cleanup_1.findObsoleteBlueBubblesThreadSessions)(sessPath);
+                }
+                catch (error) {
+                    (0, runtime_1.emitNervesEvent)({
+                        level: "warn",
+                        component: "senses",
+                        event: "senses.bluebubbles_thread_lane_cleanup_error",
+                        message: "failed to inspect obsolete bluebubbles thread-lane sessions",
+                        meta: {
+                            sessionPath: sessPath,
+                            reason: error instanceof Error ? error.message : String(error),
+                        },
+                    });
+                }
+                // Pre-load session inside the canonical turn lock so same-chat
+                // deliveries cannot race on stale trunk state.
+                const existing = resolvedDeps.loadSession(sessPath);
+                const sessionMessages = existing?.messages && existing.messages.length > 0
+                    ? structuredClone(existing.messages)
+                    : [{ role: "system", content: (0, prompt_1.flattenSystemPrompt)(await resolvedDeps.buildSystem("bluebubbles", {}, context)) }];
+                // Record EARLY for audit and crash recovery. This is capture truth, not
+                // a claim that the agent turn completed successfully.
+                const inboundSource = (options.semanticRecovery || source !== "webhook")
+                    && sessionLikelyContainsMessage(event, existing?.messages ?? sessionMessages)
+                    ? "recovery-bootstrap"
+                    : source;
+                (0, inbound_log_1.recordBlueBubblesInbound)(agentName, event, inboundSource);
+                if (inboundSource === "recovery-bootstrap") {
+                    (0, runtime_1.emitNervesEvent)({
+                        component: "senses",
+                        event: "senses.bluebubbles_recovery_skip",
+                        message: "skipped bluebubbles recovery because the session already contains the message text",
+                        meta: {
+                            messageGuid: event.messageGuid,
+                            sessionKey: event.chat.sessionKey,
+                            source,
+                        },
+                    });
+                    (0, processed_log_1.recordProcessedBlueBubblesMessage)(agentName, event, inboundSource, "session-bootstrap");
+                    return { handled: true, notifiedAgent: false, kind: event.kind, reason: "already_processed" };
+                }
+                // The inbound event is canonical truth as soon as its canonical lane is
+                // reserved. Persist it before any supersedable orientation/provider work.
+                const priorMessages = sessionMessages;
+                const userMessage = {
+                    role: "user",
+                    content: buildInboundContent(event),
+                };
+                resolvedDeps.saveSession(sessPath, [...structuredClone(sessionMessages), structuredClone(userMessage)], existing?.lastUsage, existing?.state);
+                if (!await (0, latest_turn_1.awaitDeliveryAdmission)(options.latestTurnCapability)
+                    || !(0, latest_turn_1.isCurrent)(options.latestTurnCapability)) {
+                    return { handled: true, notifiedAgent: false, kind: event.kind, reason: "superseded" };
+                }
+                options.lifecycleSignal?.throwIfAborted();
+                const mcpOwner = { agentName, agentRoot: (0, identity_1.getAgentRoot)(agentName) };
+                const liveTurnId = (0, active_turns_1.beginBlueBubblesActiveTurn)(agentName, event);
+                activeTurnId = liveTurnId;
+                const mcpManager = await (0, mcp_manager_1.getSharedMcpManager)(mcpOwner) ?? undefined;
+                if (event.chat.isGroup) {
+                    await (0, friends_1.upsertGroupContextParticipants)({
+                        store,
+                        participants: event.chat.participantHandles.map((externalId) => ({
+                            provider: "imessage-handle",
+                            externalId,
+                        })),
+                        groupExternalId: resolveGroupExternalId(event),
+                    });
+                }
+                // Fetch the text of the message being replied to (if this is a threaded reply)
+                const threadGuid = event.threadOriginatorGuid?.trim();
+                let repliedToText = null;
+                if (threadGuid) {
+                    repliedToText = await client.getMessageText(threadGuid).catch(() => null);
+                    (0, runtime_1.emitNervesEvent)({
+                        component: "senses",
+                        event: "senses.bluebubbles_reply_context",
+                        message: repliedToText ? "fetched replied-to message text" : "could not fetch replied-to message text",
+                        meta: { threadGuid, hasText: !!repliedToText },
+                    });
+                }
+                // Shutdown can land during MCP/group/reply-context awaits above. Recheck
+                // before the remaining synchronous setup installs its lifecycle listener.
+                options.lifecycleSignal?.throwIfAborted();
+                const orientationFrame = (0, orientation_frame_1.buildOrientationFrame)({
+                    channel: "bluebubbles",
+                    messages: [...priorMessages, userMessage],
+                    currentUserMessages: [userMessage],
+                    structuredOutputs: existing?.structuredOutputs ?? [],
+                    source: buildBlueBubblesOrientationSource(event, priorMessages, options.orientationEvidence, options.orientationConversationKind, repliedToText),
+                });
+                if (!(0, latest_turn_1.isCurrent)(options.latestTurnCapability)) {
+                    return { handled: true, notifiedAgent: false, kind: event.kind, reason: "superseded" };
+                }
+                const turnStage = createBlueBubblesTurnStage(event.chat.sessionKey);
+                let finalTransportInvoked = false;
+                let finalTransportAccepted = false;
+                const outboundRuntimeConfig = (0, config_1.getBlueBubblesConfig)();
+                const callbacks = createBlueBubblesCallbacks(client, event.chat, replyTarget, event.chat.isGroup, () => (0, active_turns_1.noteBlueBubblesActiveTurnVisibleActivity)(agentName, liveTurnId), {
+                    admitOutbound: async () => (!options.lifecycleSignal?.aborted
+                        && await (0, latest_turn_1.awaitDeliveryAdmission)(options.latestTurnCapability)
+                        && !options.lifecycleSignal?.aborted),
+                    isOutboundCurrent: () => (!options.lifecycleSignal?.aborted
+                        && (0, latest_turn_1.isCurrent)(options.latestTurnCapability)),
+                    isOutboundAdmittedNow: () => (!options.lifecycleSignal?.aborted
+                        && (0, latest_turn_1.isDeliveryAdmittedNow)(options.latestTurnCapability)),
+                    onFinalTransportInvoked: () => {
+                        finalTransportInvoked = true;
+                    },
+                    onFinalTransportAccepted: () => {
+                        finalTransportAccepted = true;
+                    },
+                    durableOutbound: {
+                        agentRoot: (0, identity_1.getAgentRoot)(),
+                        idempotencyKey: blueBubblesInboundReplyIdempotencyKey(options.currentIngressEvidence.captureKeyHash),
+                        attachment: {
+                            serverUrl: outboundRuntimeConfig.serverUrl,
+                            accountId: outboundRuntimeConfig.accountId,
+                        },
+                    },
+                });
+                const controller = new AbortController();
+                const lifecycleSignal = options.lifecycleSignal;
+                let rejectLifecycle;
+                const lifecyclePromise = new Promise((_resolve, reject) => {
+                    rejectLifecycle = reject;
+                });
+                let resolveSupersession;
+                const supersessionPromise = new Promise((resolve) => {
+                    resolveSupersession = resolve;
+                });
+                const cancelForSupersession = () => {
+                    callbacks.cancelOutbound("superseded");
+                    if (!finalTransportInvoked) {
+                        controller.abort(options.latestTurnCapability.signal.reason);
+                        resolveSupersession({
+                            handled: true,
+                            notifiedAgent: false,
+                            kind: event.kind,
+                            reason: "superseded",
+                        });
+                    }
+                };
+                options.latestTurnCapability.signal.addEventListener("abort", cancelForSupersession, { once: true });
+                const cancelForShutdown = () => {
+                    callbacks.cancelOutbound("shutdown");
+                    if (!finalTransportInvoked) {
+                        const reason = lifecycleSignal.reason;
+                        controller.abort(reason);
+                        rejectLifecycle(reason);
+                    }
+                };
+                lifecycleSignal?.addEventListener("abort", cancelForShutdown, { once: true });
+                let timeoutTimer;
+                let timeoutPromise;
+                let resolveTimeout;
+                let recoveryTimedOut = false;
+                let activeRunTurn = null;
+                // BB-specific tool context wrappers
+                const summarize = (0, core_1.createSummarize)("human");
+                const bbCapabilities = (0, friends_1.getChannelCapabilities)("bluebubbles");
+                const pendingDir = (0, pending_1.getPendingDir)(resolvedDeps.getAgentName(), friendId, "bluebubbles", event.chat.sessionKey);
+                // Buffer terminal errors so failover can suppress them.
+                // If failover produces a message, the buffered error is skipped.
+                // If failover doesn't fire, the buffered error is replayed.
+                let bufferedTerminalError = null;
+                /* v8 ignore start -- failover-aware error buffering @preserve */
+                const failoverAwareCallbacks = {
+                    ...callbacks,
+                    onError(error, severity) {
+                        if (severity === "terminal") {
+                            bufferedTerminalError = error;
+                            return;
+                        }
+                        callbacks.onError(error, severity);
+                    },
+                };
+                /* v8 ignore stop */
+                try {
+                    // ── Compute trust gate context for group/acquaintance rules ─────
+                    // These store reads can block on filesystem I/O. Race them against the
+                    // runtime lifecycle before constructing the shared pipeline so a closed
+                    // worker cannot begin new durable or outward work after the read settles.
+                    const trustContext = await Promise.race([
+                        Promise.all([
+                            checkGroupHasFamilyMember(store, event),
+                            event.chat.isGroup
+                                ? Promise.resolve(false)
+                                : checkHasExistingGroupWithFamily(store, context.friend),
+                        ]),
+                        lifecyclePromise,
+                        supersessionPromise.then(() => null),
+                    ]);
+                    if (trustContext === null) {
+                        return {
+                            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((resolve) => {
+                        resolveTimeout = resolve;
+                    });
+                    timeoutTimer = setTimeout(() => {
+                        const reason = new BlueBubblesRecoveryTurnTimeoutError(timeoutMs);
+                        recoveryTimedOut = true;
+                        if (!finalTransportInvoked) {
+                            resolveTimeout?.({
+                                handled: true,
+                                notifiedAgent: false,
+                                kind: event.kind,
+                                reason: "turn_timeout",
+                            });
+                        }
+                        callbacks.cancelOutbound("turn_timeout");
+                        (0, latest_turn_1.cancel)(options.latestTurnCapability, "turn_timeout");
+                        if (!finalTransportInvoked)
+                            controller.abort(reason);
+                        (0, runtime_1.emitNervesEvent)({
+                            level: "warn",
+                            component: "senses",
+                            event: "senses.bluebubbles_turn_timeout",
+                            message: "bluebubbles turn timed out",
+                            meta: {
+                                messageGuid: event.messageGuid,
+                                sessionKey: event.chat.sessionKey,
+                                source,
+                                timeoutMs,
+                            },
+                        });
+                        (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") {
+                        timeoutTimer.unref();
+                    }
+                    let preparedBlueBubblesContext = {
+                        messages: [],
+                        contextPacketIds: [],
+                    };
+                    const turnPromise = (0, pipeline_1.handleInboundTurn)({
+                        channel: "bluebubbles",
+                        sessionKey: event.chat.sessionKey,
+                        capabilities: bbCapabilities,
+                        messages: [userMessage],
+                        continuityIngressTexts: getBlueBubblesContinuityIngressTexts(event),
+                        friendResolver: { resolve: () => Promise.resolve(context) },
+                        sessionLoader: {
+                            loadOrCreate: () => Promise.resolve({
+                                messages: sessionMessages,
+                                sessionPath: sessPath,
+                                state: existing?.state,
+                                events: existing?.events,
+                                structuredOutputs: existing?.structuredOutputs,
+                            }),
+                        },
+                        pendingDir,
+                        friendStore: store,
+                        provider: "imessage-handle",
+                        externalId: event.sender.externalId,
+                        isGroupChat: event.chat.isGroup,
+                        groupHasFamilyMember,
+                        hasExistingGroupWithFamily,
+                        enforceTrustGate: trust_gate_1.enforceTrustGate,
+                        drainPending: pending_1.drainPending,
+                        drainDeferredReturns: (deferredFriendId) => (0, pending_1.drainDeferredReturns)(resolvedDeps.getAgentName(), deferredFriendId),
+                        prepareRunAgentOptions: async ({ messages = [], currentUserMessages = [], runAgentOptions }) => {
+                            preparedBlueBubblesContext = await buildBlueBubblesContextMessages({
+                                agentName,
+                                agentRoot: (0, identity_1.getAgentRoot)(),
+                                client,
+                                event,
+                                knownMessages: messages,
+                            });
+                            const currentUserMessage = currentUserMessages.findLast((message) => message.role === "user")
+                                ?? messages.findLast((message) => message.role === "user");
+                            if (!currentUserMessage)
+                                return undefined;
+                            Object.freeze(currentUserMessage);
+                            const { verifiedPredecessorMessage } = preparedBlueBubblesContext;
+                            return {
+                                ...(preparedBlueBubblesContext.contextPacketIds.length > 0 ? {
+                                    contextPacketIds: [
+                                        ...(runAgentOptions.contextPacketIds ?? []),
+                                        ...preparedBlueBubblesContext.contextPacketIds,
+                                    ],
+                                } : {}),
+                                ...(preparedBlueBubblesContext.messages.length > 0 ? {
+                                    promptOnlyEvidenceMessages: preparedBlueBubblesContext.messages,
+                                } : {}),
+                                requiredPromptEvidence: {
+                                    currentUserMessage,
+                                    ...(verifiedPredecessorMessage ? { verifiedPredecessorMessage } : {}),
+                                },
+                            };
+                        },
+                        runAgent: async (msgs, cb, channel, sig, opts) => {
+                            const { codingFeedback: _omittedCodingFeedback, ...safeToolContext } = opts?.toolContext ?? {};
+                            const requiredCurrent = opts?.requiredPromptEvidence?.currentUserMessage;
+                            const providerMessages = insertEphemeralContextMessages(msgs.map((message) => message === requiredCurrent ? message : structuredClone(message)), [
+                                ...preparedBlueBubblesContext.messages,
+                                ...(preparedBlueBubblesContext.verifiedPredecessorMessage
+                                    ? [preparedBlueBubblesContext.verifiedPredecessorMessage]
+                                    : []),
+                            ], requiredCurrent);
+                            let generatedMessages = [];
+                            const agentResult = await resolvedDeps.runAgent(providerMessages, cb, channel, sig, {
+                                ...opts,
+                                captureGeneratedMessages: (generated) => {
+                                    opts?.captureGeneratedMessages?.(generated);
+                                    generatedMessages = structuredClone(generated);
+                                },
+                                toolContext: {
+                                    /* v8 ignore next -- default no-op signin; pipeline provides the real one @preserve */
+                                    signin: async () => undefined,
+                                    ...safeToolContext,
+                                    ...mcpOwner,
+                                    summarize,
+                                    bluebubblesReplyTarget: {
+                                        setSelection: (selection) => replyTarget.setSelection(selection),
+                                    },
+                                },
+                            });
+                            if (generatedMessages.length > 0) {
+                                msgs.push(...generatedMessages);
+                            }
+                            return agentResult;
+                        },
+                        postTurn: (turnMessages, sessionPathArg, usage, hooks, state) => {
+                            const prepared = resolvedDeps.postTurnTrim(turnMessages, usage, hooks);
+                            turnStage.postTurn = {
+                                sessionPath: sessionPathArg,
+                                prepared,
+                                usage,
+                                state,
+                            };
+                        },
+                        accumulateFriendTokens: async (tokenStore, tokenFriendId, usage) => {
+                            turnStage.tokens = {
+                                store: tokenStore,
+                                friendId: tokenFriendId,
+                                usage,
+                            };
+                        },
+                        signal: controller.signal,
+                        runAgentOptions: {
+                            mcpManager,
+                            orientationFrame,
+                            toolContext: {
+                                signin: async () => undefined,
+                                ...mcpOwner,
+                                currentIngressEvidence: options.currentIngressEvidence,
+                            },
+                        },
+                        callbacks: failoverAwareCallbacks,
+                        sessionTurnLease,
+                        failoverState: turnStage.failoverState,
+                    });
+                    /* v8 ignore start -- detached late-rejection telemetry is asserted in timeout tests, but V8 does not reliably attribute Promise.catch callbacks @preserve */
+                    void turnPromise
+                        .catch((error) => {
+                        if (!recoveryTimedOut)
+                            return;
+                        (0, runtime_1.emitNervesEvent)({
+                            level: "warn",
+                            component: "senses",
+                            event: "senses.bluebubbles_recovery_error",
+                            message: "bluebubbles recovery turn rejected after timeout",
+                            meta: {
+                                messageGuid: event.messageGuid,
+                                sessionKey: event.chat.sessionKey,
+                                source,
+                                reason: error instanceof Error ? error.message : String(error),
+                            },
+                        });
+                    });
+                    /* v8 ignore stop */
+                    const runTurn = (async () => {
+                        const result = await turnPromise;
+                        if (recoveryTimedOut && !finalTransportInvoked) {
+                            (0, runtime_1.emitNervesEvent)({
+                                level: "warn",
+                                component: "senses",
+                                event: "senses.bluebubbles_timed_out_turn_suppressed",
+                                message: "suppressed late bluebubbles turn result after timeout",
+                                meta: {
+                                    messageGuid: event.messageGuid,
+                                    sessionKey: event.chat.sessionKey,
+                                    source,
+                                    reason: "turn completed after its final-transport boundary closed",
+                                },
+                            });
+                            return {
+                                handled: true,
+                                notifiedAgent: false,
+                                kind: event.kind,
+                                reason: "turn_timeout",
+                            };
+                        }
+                        /* v8 ignore start -- failover display + error replay @preserve */
+                        if (result.failoverMessage) {
+                            callbacks.onClearText?.();
+                            callbacks.onTextChunk(result.failoverMessage);
+                            bufferedTerminalError = null;
+                        }
+                        else if (bufferedTerminalError) {
+                            callbacks.onError(bufferedTerminalError, "terminal");
+                            bufferedTerminalError = null;
+                        }
+                        /* v8 ignore stop */
+                        // ── Handle gate result ────────────────────────────────────────
+                        let processedOutcome = "turn-complete";
+                        if (!result.gateResult.allowed) {
+                            callbacks.onClearText?.();
+                            if ("autoReply" in result.gateResult && result.gateResult.autoReply) {
+                                callbacks.onTextChunk(result.gateResult.autoReply);
+                            }
+                            processedOutcome = "trust-gated";
+                        }
+                        let delivery;
+                        try {
+                            delivery = await callbacks.flush({ signal: controller.signal });
+                        }
+                        catch (error) {
+                            (0, runtime_1.emitNervesEvent)({
+                                level: "warn",
+                                component: "senses",
+                                event: "senses.bluebubbles_final_transport_failed",
+                                message: "bluebubbles final transport failed after invocation",
+                                meta: {
+                                    messageGuid: event.messageGuid,
+                                    sessionKey: event.chat.sessionKey,
+                                    reason: error instanceof Error ? error.message : String(error),
+                                },
+                            });
+                            return {
+                                handled: true,
+                                notifiedAgent: false,
+                                kind: event.kind,
+                                reason: "delivery_failed",
+                            };
+                        }
+                        if (delivery.status !== "accepted" || !finalTransportAccepted) {
+                            return {
+                                handled: true,
+                                notifiedAgent: false,
+                                kind: event.kind,
+                                reason: !(0, latest_turn_1.isCurrent)(options.latestTurnCapability)
+                                    ? "superseded"
+                                    : "no_visible_reply",
+                            };
+                        }
+                        // Acceptance is the visibility boundary. Publish the terminal dedupe
+                        // receipt first, then project the private generated tail while this
+                        // chat's canonical lock remains held. Even if receipt publication
+                        // fails, make the best possible canonical projection before surfacing
+                        // the retained-claim failure. Ancillary accounting follows both.
+                        let receiptFailed = false;
+                        let receiptFailure;
+                        try {
+                            options.publishAcceptedReceipt();
+                        }
+                        catch (error) {
+                            receiptFailed = true;
+                            receiptFailure = error;
+                        }
+                        persistAcceptedBlueBubblesProjection({
+                            stage: turnStage,
+                            deps: resolvedDeps,
+                            event,
+                        });
+                        if (receiptFailed)
+                            throw receiptFailure;
+                        promoteAcceptedBlueBubblesAncillaryState({
+                            stage: turnStage,
+                            deps: resolvedDeps,
+                            agentName,
+                            event,
+                            source,
+                            processedOutcome,
+                        });
+                        (0, runtime_1.emitNervesEvent)({
+                            component: "senses",
+                            event: "senses.bluebubbles_turn_end",
+                            message: "bluebubbles event handled",
+                            meta: {
+                                messageGuid: event.messageGuid,
+                                kind: event.kind,
+                                sessionKey: event.chat.sessionKey,
+                            },
+                        });
+                        return {
+                            handled: true,
+                            notifiedAgent: true,
+                            kind: event.kind,
+                        };
+                    })();
+                    activeRunTurn = runTurn;
+                    /* v8 ignore start -- detached post-timeout suppression telemetry @preserve */
+                    void runTurn.catch((error) => {
+                        if (!recoveryTimedOut)
+                            return;
+                        (0, runtime_1.emitNervesEvent)({
+                            level: "warn",
+                            component: "senses",
+                            event: "senses.bluebubbles_timed_out_turn_suppressed",
+                            message: "suppressed late bluebubbles turn result after timeout",
+                            meta: {
+                                messageGuid: event.messageGuid,
+                                sessionKey: event.chat.sessionKey,
+                                source,
+                                reason: error instanceof Error ? error.message : String(error),
+                            },
+                        });
+                    });
+                    /* v8 ignore stop */
+                    return await Promise.race([runTurn, timeoutPromise, supersessionPromise, lifecyclePromise]);
+                }
+                finally {
+                    // A timed-out/superseded provider may ignore abort briefly. Never release
+                    // the cross-process session lease until that work has actually quiesced.
+                    if (activeRunTurn)
+                        await activeRunTurn.catch(() => undefined);
+                    // If a terminal error was buffered and never replayed (e.g., handleInboundTurn threw),
+                    // replay it now so the user still sees the error.
+                    /* v8 ignore start -- error replay on throw: tested via BB error test @preserve */
+                    if (bufferedTerminalError) {
+                        callbacks.onError(bufferedTerminalError, "terminal");
+                        bufferedTerminalError = null;
+                    }
+                    /* v8 ignore stop */
+                    clearTimeout(timeoutTimer);
+                    options.latestTurnCapability.signal.removeEventListener("abort", cancelForSupersession);
+                    lifecycleSignal?.removeEventListener("abort", cancelForShutdown);
+                    (0, active_turns_1.finishBlueBubblesActiveTurn)(agentName, liveTurnId);
+                    activeTurnId = null;
+                    await callbacks.finish({ timeoutMs: BLUEBUBBLES_CALLBACK_CLEANUP_TIMEOUT_MS });
+                }
+            });
+        });
+    }
+    finally {
+        if (activeTurnId)
+            (0, active_turns_1.finishBlueBubblesActiveTurn)(agentName, activeTurnId);
+    }
+}
+function recordBlueBubblesAuditSidecar(agentName, event, source, resolvedDeps) {
+    if (event.kind === "message") {
+        if (event.fromMe !== true)
+            (0, inbound_log_1.recordBlueBubblesInbound)(agentName, event, source);
+        return;
+    }
+    try {
+        resolvedDeps.recordMutation(agentName, event);
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "senses",
+            event: "senses.bluebubbles_mutation_log_error",
+            message: "failed recording bluebubbles mutation sidecar",
+            meta: {
+                messageGuid: event.messageGuid,
+                mutationType: event.mutationType,
+                reason: error instanceof Error ? error.message : String(error),
+            },
+        });
+    }
+}
+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",
+            component: "senses",
+            event: "senses.bluebubbles_direction_unobserved",
+            message: "kept bluebubbles event audit-only because message direction was unobserved",
+            meta: {
+                messageGuid: normalized.messageGuid,
+                kind: normalized.kind,
+                source,
+            },
+        });
+        recordBlueBubblesAuditSidecar(agentName, normalized, source, resolvedDeps);
+        return { status: "audit_only", normalized };
+    }
+    const observed = normalized;
+    const cutover = (0, semantic_receipts_1.initializeBlueBubblesSemanticCutover)(agentName);
+    let coordinateGeneration;
+    if (observed.kind === "mutation"
+        && observed.mutationType === "reaction"
+        && observed.reaction
+        && !observed.revision
+        && !Number.isFinite(observed.effectiveTimestamp)
+        && observed.sender.observed === true) {
+        const identity = (0, semantic_receipts_1.buildBlueBubblesSemanticIdentity)({
+            providerNamespace: cutover.providerNamespace,
+            kind: "reaction",
+            eventGuid: observed.messageGuid,
+            targetGuid: observed.targetMessageGuid,
+            actorExternalId: observed.sender.externalId,
+            canonicalValue: observed.reaction.canonicalValue,
+            canonicalAction: observed.reaction.action,
+            coordinateGeneration: 0,
+        });
+        if (identity?.coordinateKey && identity.coordinateHash) {
+            const coordinate = await (0, semantic_receipts_1.allocateBlueBubblesReactionCoordinate)(agentName, {
+                coordinateKey: identity.coordinateKey,
+                coordinateHash: identity.coordinateHash,
+                canonicalAction: observed.reaction.action,
+            });
+            coordinateGeneration = coordinate.generation;
+        }
+    }
+    const capture = (0, semantic_receipts_1.buildBlueBubblesSemanticCapture)({
+        cutover,
+        capturedAt,
+        observationEpoch: observationReservation.observationEpoch,
+        observationOrdinal: observationReservation.ordinal,
+        event: observed,
+        targetAuthorship: null,
+        coordinateGeneration,
+    });
+    if (!capture) {
+        (0, semantic_receipts_1.classifyBlueBubblesRecoveryRecord)(observed, cutover);
+        recordBlueBubblesAuditSidecar(agentName, observed, source, resolvedDeps);
+        return { status: "audit_only", normalized: observed };
+    }
+    const writeResult = (0, semantic_receipts_1.writeBlueBubblesSemanticCapture)(agentName, capture);
+    if (writeResult === "semantic_identity_collision") {
+        throw new Error("semantic_capture_failed");
+    }
+    recordBlueBubblesAuditSidecar(agentName, observed, source, resolvedDeps);
+    return {
+        status: "captured",
+        capture,
+        normalized: observed,
+        writeResult,
+    };
+}
+function semanticCaptureChat(capture) {
+    const event = capture.event;
+    const sessionKey = event.sessionKey?.trim();
+    const chatGuid = event.chatGuid?.trim() || undefined;
+    const chatIdentifier = event.chatIdentifier?.trim() || undefined;
+    if (!sessionKey)
+        return null;
+    const fallbackSendTarget = sessionKey.startsWith("chat:")
+        ? { kind: "chat_guid", value: sessionKey.slice("chat:".length).trim() }
+        : sessionKey.startsWith("chat_identifier:")
+            ? { kind: "chat_identifier", value: sessionKey.slice("chat_identifier:".length).trim() }
+            : null;
+    const sendTarget = chatGuid
+        ? { kind: "chat_guid", value: chatGuid }
+        : chatIdentifier
+            ? { kind: "chat_identifier", value: chatIdentifier }
+            : fallbackSendTarget;
+    if (!sendTarget?.value)
+        return null;
+    return {
+        chatGuid,
+        chatIdentifier,
+        isGroup: Boolean(chatGuid?.includes(";+;") || event.participants.length > 1),
+        sessionKey,
+        sendTarget,
+        participantHandles: event.participants.map((participant) => participant.externalId),
+    };
+}
+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 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";
+}
+function semanticCaptureToNormalizedEvent(capture) {
+    const event = capture.event;
+    const messageGuid = event.eventGuid?.trim();
+    const chat = semanticCaptureChat(capture);
+    if (!messageGuid || !chat)
+        return null;
+    const sender = {
+        provider: "imessage-handle",
+        externalId: event.actor.externalId,
+        rawId: event.actor.externalId,
+        displayName: event.actor.displayName ?? event.actor.externalId,
+        observed: true,
+    };
+    const timestamp = Date.parse(event.effectiveAt ?? capture.capturedAt);
+    if (event.kind === "message") {
+        const text = event.text ?? "";
+        return {
+            kind: "message",
+            eventType: event.sourceEventType,
+            messageGuid,
+            timestamp,
+            fromMe: event.fromMe,
+            sender,
+            chat,
+            text,
+            textForAgent: text,
+            attachments: [],
+            hasPayloadData: false,
+            requiresRepair: true,
+        };
+    }
+    const shouldNotifyAgent = event.kind === "reaction" || event.kind === "edit" || event.kind === "unsend";
+    const targetMessageGuid = event.targetGuid ?? undefined;
+    const reaction = event.kind === "reaction" && event.canonicalAction && event.canonicalValue
+        ? {
+            ...(0, model_1.describeBlueBubblesReaction)(event.rawTransportValue ?? event.canonicalValue, event.rawTransportValue ?? event.canonicalValue),
+            canonicalValue: event.canonicalValue,
+            action: event.canonicalAction,
+        }
+        : undefined;
+    const textForAgent = reaction
+        ? (0, model_1.renderBlueBubblesReactionText)(reaction, { guid: targetMessageGuid })
+        : event.kind === "edit"
+            ? event.text ? `edited message: ${event.text}` : "edited a message"
+            : event.kind === "unsend"
+                ? "unsent a message"
+                : event.kind === "read"
+                    ? "message marked as read"
+                    : "message marked as delivered";
+    return {
+        kind: "mutation",
+        eventType: event.sourceEventType,
+        mutationType: event.kind,
+        messageGuid,
+        targetMessageGuid,
+        timestamp,
+        fromMe: event.fromMe,
+        sender,
+        chat,
+        shouldNotifyAgent,
+        textForAgent,
+        requiresRepair: true,
+        ...(reaction ? { reaction } : {}),
+        ...(event.kind === "edit" && event.text !== null ? { editedText: event.text } : {}),
+        ...(event.revision ? { revision: event.revision } : {}),
+        ...(event.effectiveAt ? { effectiveTimestamp: Date.parse(event.effectiveAt) } : {}),
+        ...(event.kind === "unsend" && event.effectiveAt
+            ? { retractionTimestamp: Date.parse(event.effectiveAt) }
+            : {}),
+    };
+}
+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) {
+    const event = captured.capture.event;
+    if (event.kind !== "reaction" || !event.canonicalAction || !event.canonicalValue)
+        return null;
+    const input = {
+        fromMe: event.fromMe,
+        action: event.canonicalAction,
+        canonicalValue: event.canonicalValue,
+    };
+    return { decision: (0, reaction_policy_1.classifyBlueBubblesReaction)(input) };
+}
+function captureOnlyHandledDisposition(capture, reactionDecision) {
+    if (capture.event.kind !== "reaction") {
+        return {
+            outcome: capture.event.kind === "edit" ? "edit_capture_only" : "unsend_capture_only",
+            detailCode: null,
+        };
+    }
+    const classifiedOutcome = reactionDecision.outcome;
+    if (classifiedOutcome === "capture_only_negative" || classifiedOutcome === "capture_only_question") {
+        return {
+            outcome: "capture_only_unknown",
+            detailCode: classifiedOutcome,
+        };
+    }
+    return { outcome: classifiedOutcome, detailCode: null };
+}
+function auditOnlyHandledOutcome(kind) {
+    return kind === "read" ? "read_audit_only" : "delivery_audit_only";
+}
+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,
+    });
+    if (handledResult === "semantic_handled_collision") {
+        throw new Error("semantic_handled_collision");
+    }
+}
+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 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,
+            kind: captured.normalized.kind,
+            reason: "already_processed",
+        };
+    }
+    if (claim.status === "timeout") {
+        releaseBlueBubblesSemanticHandlingSlot(identity.keyHash, semanticHandling.slot, "retryable");
+        return {
+            handled: false,
+            notifiedAgent: false,
+            kind: captured.normalized.kind,
+            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 {
+        options.lifecycleSignal?.throwIfAborted();
+        const reactionClassification = await classifyCapturedBlueBubblesReaction(captured);
+        options.lifecycleSignal?.throwIfAborted();
+        const reactionDecision = reactionClassification?.decision ?? null;
+        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: "from_me",
+            };
+            publishTerminalReceipt("ignored_self");
+            semanticHandlingCompleted = true;
+            return result;
+        }
+        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,
+                kind: captured.normalized.kind,
+                reason: "mutation_state_only",
+            };
+        }
+        else {
+            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");
+            }
+            const identityGroundedRepaired = {
+                ...repaired,
+                fromMe: captured.normalized.fromMe,
+                sender: captured.normalized.sender,
+            };
+            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",
+                };
+            }
+            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);
+        }
+        semanticHandlingCompleted = true;
+        return result;
+    }
+    finally {
+        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 = {}) {
+    const resolvedDeps = { ...defaultDeps, ...deps };
+    let normalized;
+    try {
+        normalized = (0, model_1.normalizeBlueBubblesEvent)(payload);
+    }
+    catch (error) {
+        if (error instanceof model_1.BlueBubblesIgnoredEventError) {
+            (0, runtime_1.emitNervesEvent)({
+                component: "senses",
+                event: "senses.bluebubbles_event_skipped",
+                message: "skipped ignorable bluebubbles event",
+                meta: {
+                    eventType: error.eventType,
+                },
+            });
+            return {
+                handled: true,
+                notifiedAgent: false,
+                reason: "ignored",
+            };
+        }
+        throw error;
+    }
+    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", {
+        observationReservation,
+    });
+}
+function parseTimestampMs(value) {
+    if (!value)
+        return null;
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? parsed : null;
+}
+function resolveBlueBubblesCatchUpSince(previousState, nowMs = Date.now()) {
+    if (previousState.upstreamStatus === "error") {
+        return nowMs - BLUEBUBBLES_RECOVERY_CATCHUP_LOOKBACK_MS;
+    }
+    const lastCheckedAt = parseTimestampMs(previousState.lastCheckedAt);
+    if (lastCheckedAt !== null) {
+        return Math.max(0, lastCheckedAt - BLUEBUBBLES_HEALTHY_CATCHUP_OVERLAP_MS);
+    }
+    return nowMs - BLUEBUBBLES_FIRST_CATCHUP_LOOKBACK_MS;
+}
+function formatBlueBubblesRuntimeDetail(queued, failed, active) {
+    if (active.stalledTurnCount > 0) {
+        return `iMessage live turn appears stalled; ${active.stalledTurnCount} active turn(s) older than ${BLUEBUBBLES_LIVE_TURN_STALLED_MS}ms`;
+    }
+    if (active.activeTurnCount > 0)
+        return `upstream reachable; ${active.activeTurnCount} live turn(s) active`;
+    if (queued > 0)
+        return `upstream reachable but iMessage is not caught up; ${queued} recovery item(s) queued`;
+    if (failed > 0)
+        return `${failed} message(s) unrecoverable this cycle; upstream ok`;
+    return "upstream reachable";
+}
+function blueBubblesPendingRecoverySnapshot(agentName, nowMs = Date.now()) {
+    const pendingEntries = (0, semantic_receipts_1.listPendingBlueBubblesSemanticCaptures)(agentName);
+    const pendingRecordedAt = pendingEntries
+        .map((entry) => entry.capturedAt)
+        .map((value) => ({ value, ms: Date.parse(value) }))
+        .filter((entry) => Number.isFinite(entry.ms))
+        .sort((left, right) => left.ms - right.ms);
+    const oldest = pendingRecordedAt[0];
+    return {
+        pendingRecoveryCount: pendingEntries.length,
+        oldestPendingRecoveryAt: oldest?.value,
+        oldestPendingRecoveryAgeMs: oldest ? Math.max(0, nowMs - oldest.ms) : undefined,
+    };
+}
+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, {
+            upstreamStatus: "ok",
+            detail: "upstream reachable; recovery pass running",
+            lastCheckedAt: checkedAt,
+            proofMethod: "bluebubbles.checkHealth",
+            ...pendingBeforeCatchup,
+            ...activeBeforeCatchup,
+            lastRecoveredAt: previousState.lastRecoveredAt,
+            lastRecoveredMessageGuid: previousState.lastRecoveredMessageGuid,
+        });
+        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);
+        const queued = pendingAfterCatchup.pendingRecoveryCount;
+        // upstreamStatus reflects whether BlueBubbles itself and the local bridge
+        // can answer webhook traffic. The daemon status layer treats
+        // pendingRecoveryCount as unhealthy for user-facing iMessage reachability,
+        // while this field stays scoped to upstream transport reachability.
+        (0, runtime_state_1.writeBlueBubblesRuntimeState)(agentName, {
+            upstreamStatus: "ok",
+            detail: formatBlueBubblesRuntimeDetail(queued, failed, activeAfterCatchup),
+            lastCheckedAt: checkedAt,
+            proofMethod: "bluebubbles.checkHealth",
+            ...pendingAfterCatchup,
+            ...activeAfterCatchup,
+            pendingRecoveryCount: queued,
+            failedRecoveryCount: failed,
+            lastRecoveredAt: previousState.lastRecoveredAt,
+            lastRecoveredMessageGuid: previousState.lastRecoveredMessageGuid,
+        });
+    }
+    catch (error) {
+        if (options.lifecycleSignal?.aborted)
+            return;
+        (0, runtime_state_1.writeBlueBubblesRuntimeState)(agentName, {
+            upstreamStatus: "error",
+            detail: error instanceof Error ? error.message : String(error),
+            lastCheckedAt: checkedAt,
+            proofMethod: "bluebubbles.checkHealth",
+            ...blueBubblesPendingRecoverySnapshot(agentName),
+            ...(0, active_turns_1.snapshotBlueBubblesActiveTurns)(agentName, BLUEBUBBLES_LIVE_TURN_STALLED_MS),
+            failedRecoveryCount: 0,
+        });
+    }
+}
+async function recoverQueuedBlueBubblesMessages(deps = {}, options = {}) {
+    options.lifecycleSignal?.throwIfAborted();
+    const resolvedDeps = { ...defaultDeps, ...deps };
+    const agentName = resolvedDeps.getAgentName();
+    const previousState = (0, runtime_state_1.readBlueBubblesRuntimeState)(agentName);
+    const initialPending = blueBubblesPendingRecoverySnapshot(agentName).pendingRecoveryCount;
+    if (initialPending === 0) {
+        return { recovered: 0, skipped: 0, failed: 0, pendingRecoveryCount: 0 };
+    }
+    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;
+    const recovered = captured.recovered + recovery.recovered;
+    const skipped = captured.skipped + recovery.skipped;
+    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",
+            detail: formatBlueBubblesRuntimeDetail(pendingRecoveryCount, failed, activeSnapshot),
+            lastCheckedAt: checkedAt,
+            proofMethod: "bluebubbles.checkHealth",
+            ...pendingSnapshot,
+            ...activeSnapshot,
+            failedRecoveryCount: failed,
+            lastRecoveredAt: recovered > 0 ? checkedAt : previousState.lastRecoveredAt,
+            lastRecoveredMessageGuid: previousState.lastRecoveredMessageGuid,
+        });
+    }
+    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),
+            lastCheckedAt: checkedAt,
+            proofMethod: "bluebubbles.checkHealth",
+            ...pendingSnapshot,
+            ...(0, active_turns_1.snapshotBlueBubblesActiveTurns)(agentName, BLUEBUBBLES_LIVE_TURN_STALLED_MS),
+            failedRecoveryCount: failed,
+            lastRecoveredAt: recovered > 0 ? checkedAt : previousState.lastRecoveredAt,
+            lastRecoveredMessageGuid: previousState.lastRecoveredMessageGuid,
+        });
+    }
+    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();
+    const result = { inspected: 0, recovered: 0, skipped: 0, failed: 0 };
+    const state = previousState ?? (0, runtime_state_1.readBlueBubblesRuntimeState)(agentName);
+    const cutover = (0, semantic_receipts_1.initializeBlueBubblesSemanticCutover)(agentName);
+    const catchUpSince = Math.max(resolveBlueBubblesCatchUpSince(state), Date.parse(cutover.effectiveAt));
+    const processTurns = options.processTurns !== false;
+    /* v8 ignore next -- older injected test doubles may omit the catch-up query method */
+    if (!client.listRecentMessages)
+        return result;
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.bluebubbles_catchup_start",
+        message: "bluebubbles upstream catch-up pass started",
+        meta: {
+            since: new Date(catchUpSince).toISOString(),
+            pageSize: BLUEBUBBLES_CATCHUP_PAGE_SIZE,
+            maxPages: BLUEBUBBLES_CATCHUP_MAX_PAGES,
+        },
+    });
+    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",
+                component: "senses",
+                event: "senses.bluebubbles_catchup_error",
+                message: "bluebubbles upstream catch-up query failed",
+                meta: {
+                    offset: page * BLUEBUBBLES_CATCHUP_PAGE_SIZE,
+                    reason: error instanceof Error ? error.message : String(error),
+                },
+            });
+            break;
+        }
+        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 = pageMessages
+            .reduce((oldest, event) => Math.min(oldest, event.timestamp), Number.POSITIVE_INFINITY);
+        if (oldestMessageTimestamp <= catchUpSince)
+            break;
+        if (page === BLUEBUBBLES_CATCHUP_MAX_PAGES - 1) {
+            result.failed++;
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "senses",
+                event: "senses.bluebubbles_catchup_error",
+                message: "bluebubbles upstream catch-up reached the bounded page limit",
+                meta: {
+                    inspectedPages: BLUEBUBBLES_CATCHUP_MAX_PAGES,
+                    reason: "catch-up page limit reached before the outage window cutoff",
+                },
+            });
+        }
+    }
+    for (const prepared of preparedCandidates) {
+        result.inspected++;
+        if (prepared.status === "skip") {
+            result.skipped++;
+        }
+    }
+    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.recovered++;
+                    if (observationReservation.ordinal > lastRecoveredOrdinal) {
+                        lastRecoveredOrdinal = observationReservation.ordinal;
+                        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),
+                    },
+                });
+            }
+        }
+    }));
+    if (result.inspected > 0 || result.recovered > 0 || result.skipped > 0 || result.failed > 0) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.bluebubbles_catchup_complete",
+            message: "bluebubbles upstream catch-up pass completed",
+            meta: { ...result },
+        });
+    }
+    return result;
+}
+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(semantic_receipts_1.compareBlueBubblesSemanticCaptureOrder);
+    const preparedCandidates = [];
+    for (const capture of candidates) {
+        options.lifecycleSignal?.throwIfAborted();
+        if (seenKeyHashes.has(capture.keyHash)) {
+            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") {
+            preparedCandidates.push({ status: "skip", capture });
+            continue;
+        }
+        const normalized = semanticCaptureToNormalizedEvent(capture);
+        if (!normalized) {
+            preparedCandidates.push({ status: "invalid", capture });
+            continue;
+        }
+        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",
+                component: "senses",
+                event: "senses.bluebubbles_capture_recovery_error",
+                message: "captured bluebubbles message recovery failed",
+                meta: {
+                    messageGuid: capture.event.eventGuid,
+                    sessionKey: capture.event.sessionKey,
+                    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")
+        .map((eventGuid) => eventGuid.trim().toLowerCase()));
+    for (const legacyEntry of (0, inbound_log_1.listRecordedBlueBubblesInbound)(agentName)) {
+        if (semanticEventGuids.has(legacyEntry.messageGuid.trim().toLowerCase()))
+            continue;
+        (0, semantic_receipts_1.classifyBlueBubblesRecoveryRecord)(legacyEntry, cutover);
+        result.skipped++;
+    }
+    return result;
+}
+async function recoverMissedBlueBubblesMessages(deps = {}) {
+    const resolvedDeps = { ...defaultDeps, ...deps };
+    const agentName = resolvedDeps.getAgentName();
+    const cutover = (0, semantic_receipts_1.initializeBlueBubblesSemanticCutover)(agentName);
+    const result = { recovered: 0, skipped: 0, pending: 0, failed: 0 };
+    for (const candidate of (0, mutation_log_1.listBlueBubblesRecoveryCandidates)(agentName)) {
+        (0, semantic_receipts_1.classifyBlueBubblesRecoveryRecord)(candidate, cutover);
+        result.skipped++;
+    }
+    if (result.recovered > 0 || result.skipped > 0 || result.pending > 0 || result.failed > 0) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.bluebubbles_recovery_complete",
+            message: "bluebubbles backlog recovery pass completed",
+            meta: { ...result },
+        });
+    }
+    return result;
+}
+function createBlueBubblesWebhookHandler(deps = {}, options = {}) {
+    return async (req, res) => {
+        const url = new URL(req.url ?? "/", "http://127.0.0.1");
+        if (url.pathname === "/health") {
+            if (req.method === "GET" || req.method === "HEAD") {
+                writeJson(res, 200, { status: "ok", uptime: process.uptime() });
+                return;
+            }
+            writeJson(res, 405, { error: "Method not allowed" });
+            return;
+        }
+        const channelConfig = (0, config_1.getBlueBubblesChannelConfig)();
+        const runtimeConfig = (0, config_1.getBlueBubblesConfig)();
+        if (url.pathname !== channelConfig.webhookPath) {
+            writeJson(res, 404, { error: "Not found" });
+            return;
+        }
+        if (req.method !== "POST") {
+            writeJson(res, 405, { error: "Method not allowed" });
+            return;
+        }
+        if (!isWebhookPasswordValid(url, runtimeConfig.password)) {
+            writeJson(res, 401, { error: "Unauthorized" });
+            return;
+        }
+        let payload;
+        try {
+            const rawBody = await readRequestBody(req);
+            payload = JSON.parse(rawBody);
+        }
+        catch (error) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "senses",
+                event: "senses.bluebubbles_webhook_bad_json",
+                message: "failed to parse bluebubbles webhook body",
+                meta: {
+                    reason: error instanceof Error ? error.message : String(error),
+                },
+            });
+            writeJson(res, 400, { error: "Invalid JSON body" });
+            return;
+        }
+        let normalized;
+        try {
+            normalized = (0, model_1.normalizeBlueBubblesEvent)(payload);
+        }
+        catch (error) {
+            if (error instanceof model_1.BlueBubblesIgnoredEventError) {
+                (0, runtime_1.emitNervesEvent)({
+                    component: "senses",
+                    event: "senses.bluebubbles_event_skipped",
+                    message: "skipped ignorable bluebubbles event",
+                    meta: {
+                        eventType: error.eventType,
+                    },
+                });
+                writeJson(res, 200, {
+                    handled: true,
+                    notifiedAgent: false,
+                    reason: "ignored",
+                });
+                return;
+            }
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                component: "senses",
+                event: "senses.bluebubbles_webhook_error",
+                message: "bluebubbles webhook handling failed",
+                meta: {
+                    /* v8 ignore next -- normalizeBlueBubblesEvent throws Error subclasses; String fallback is defensive @preserve */
+                    reason: error instanceof Error ? error.message : String(error),
+                },
+            });
+            writeJson(res, 500, {
+                /* v8 ignore next -- normalizeBlueBubblesEvent throws Error subclasses; String fallback is defensive @preserve */
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return;
+        }
+        const resolvedDeps = { ...defaultDeps, ...deps };
+        const observationReservation = reserveBlueBubblesObservation(normalized);
+        let captured;
+        try {
+            captured = await captureBlueBubblesSemanticEvent(normalized, resolvedDeps, "webhook", observationReservation);
+        }
+        catch (error) {
+            (0, latest_turn_1.clearPending)(observationReservation);
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                component: "senses",
+                event: "senses.bluebubbles_webhook_error",
+                message: "bluebubbles semantic capture failed before acknowledgement",
+                meta: {
+                    messageGuid: normalized.messageGuid,
+                    reason: error instanceof Error ? error.message : String(error),
+                },
+            });
+            writeSemanticCaptureFailure(res);
+            return;
+        }
+        if (captured.status === "audit_only") {
+            (0, latest_turn_1.clearPending)(observationReservation);
+            writeJson(res, 200, {
+                handled: true,
+                notifiedAgent: false,
+                kind: normalized.kind,
+                queued: false,
+                reason: "ignored",
+            });
+            return;
+        }
+        writeJson(res, 200, {
+            handled: true,
+            notifiedAgent: false,
+            kind: normalized.kind,
+            queued: true,
+            reason: "queued",
+        });
+        setTimeout(() => {
+            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",
+                    event: "senses.bluebubbles_webhook_async_error",
+                    message: "bluebubbles webhook async handling failed after durable capture",
+                    meta: {
+                        reason: error instanceof Error ? error.message : String(error),
+                    },
+                });
+            });
+        }, 0);
+    };
+}
+function findImessageHandle(friend) {
+    for (const ext of friend.externalIds) {
+        if (ext.provider === "imessage-handle" && !ext.externalId.startsWith("group:")) {
+            return ext.externalId;
+        }
+    }
+    return undefined;
+}
+function normalizeBlueBubblesSessionKey(sessionKey) {
+    const trimmed = sessionKey.trim();
+    if (trimmed.startsWith("chat_identifier_")) {
+        return `chat_identifier:${trimmed.slice("chat_identifier_".length)}`;
+    }
+    if (trimmed.startsWith("chat_")) {
+        return `chat:${trimmed.slice("chat_".length)}`;
+    }
+    return trimmed;
+}
+function extractChatIdentifierFromSessionKey(sessionKey) {
+    const normalizedKey = normalizeBlueBubblesSessionKey(sessionKey);
+    if (normalizedKey.startsWith("chat:")) {
+        const chatGuid = normalizedKey.slice("chat:".length).trim();
+        const parts = chatGuid.split(";");
+        return parts.length >= 3 ? parts[2]?.trim() || undefined : undefined;
+    }
+    if (normalizedKey.startsWith("chat_identifier:")) {
+        const identifier = normalizedKey.slice("chat_identifier:".length).trim();
+        return identifier || undefined;
+    }
+    return undefined;
+}
+function buildChatRefForSessionKey(friend, sessionKey) {
+    const normalizedKey = normalizeBlueBubblesSessionKey(sessionKey);
+    if (normalizedKey.startsWith("chat:")) {
+        const chatGuid = normalizedKey.slice("chat:".length).trim();
+        if (!chatGuid)
+            return null;
+        return {
+            chatGuid,
+            chatIdentifier: extractChatIdentifierFromSessionKey(sessionKey) ?? findImessageHandle(friend),
+            isGroup: chatGuid.includes(";+;"),
+            sessionKey,
+            sendTarget: { kind: "chat_guid", value: chatGuid },
+            participantHandles: [],
+        };
+    }
+    const chatIdentifier = extractChatIdentifierFromSessionKey(sessionKey) ?? findImessageHandle(friend);
+    if (!chatIdentifier)
+        return null;
+    return {
+        chatIdentifier,
+        isGroup: false,
+        sessionKey,
+        sendTarget: { kind: "chat_identifier", value: chatIdentifier },
+        participantHandles: [],
+    };
+}
+async function sendProactiveBlueBubblesMessageToSession(params, deps = {}) {
+    if ((0, bluebubbles_meta_guard_1.containsInternalMetaMarkers)(params.text)) {
+        (0, bluebubbles_meta_guard_1.emitBluebubblesMetaBlocked)({
+            site: "proactive",
+            message: "bluebubbles proactive send blocked: internal meta markers",
+            meta: {
+                friendId: params.friendId,
+                sessionKey: params.sessionKey,
+            },
+        });
+        return { delivered: false, reason: "blocked_meta_content" };
+    }
+    const resolvedDeps = { ...defaultDeps, ...deps };
+    const client = resolvedDeps.createClient();
+    const store = resolvedDeps.createFriendStore();
+    let friend;
+    try {
+        friend = await store.get(params.friendId);
+    }
+    catch {
+        friend = null;
+    }
+    // Direct filesystem fallback — store.get() with name resolution wasn't working in production
+    // despite correct compiled code. Bypass the entire store abstraction.
+    /* v8 ignore start -- direct filesystem name resolution @preserve */
+    if (!friend) {
+        try {
+            const friendsDir = path.join((0, identity_1.getAgentRoot)(), "friends");
+            const files = fs.readdirSync(friendsDir).filter((f) => f.endsWith(".json"));
+            for (const file of files) {
+                const raw = JSON.parse(fs.readFileSync(path.join(friendsDir, file), "utf-8"));
+                if (raw.name?.toLowerCase() === params.friendId.toLowerCase()) {
+                    friend = raw;
+                    (0, runtime_1.emitNervesEvent)({
+                        component: "senses",
+                        event: "senses.bluebubbles_proactive_name_resolved",
+                        message: "resolved friend by name via direct filesystem scan",
+                        meta: { friendId: params.friendId, resolvedId: raw.id, name: raw.name },
+                    });
+                    break;
+                }
+            }
+        }
+        catch (err) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "senses",
+                event: "senses.bluebubbles_proactive_name_resolve_error",
+                message: "direct filesystem name resolution failed",
+                meta: { friendId: params.friendId, error: err instanceof Error ? err.message : String(err) },
+            });
+        }
+    }
+    /* v8 ignore stop */
+    if (!friend) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "senses",
+            event: "senses.bluebubbles_proactive_no_friend",
+            message: "proactive send skipped: friend not found",
+            meta: { friendId: params.friendId, sessionKey: params.sessionKey },
+        });
+        return { delivered: false, reason: "friend_not_found" };
+    }
+    const explicitCrossChatAuthorized = params.intent === "explicit_cross_chat"
+        && friends_1.TRUSTED_LEVELS.has(params.authorizingSession?.trustLevel ?? "stranger");
+    if (!explicitCrossChatAuthorized && !friends_1.TRUSTED_LEVELS.has(friend.trustLevel ?? "stranger")) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.bluebubbles_proactive_trust_skip",
+            message: "proactive send skipped: trust level not allowed",
+            meta: {
+                friendId: params.friendId,
+                sessionKey: params.sessionKey,
+                trustLevel: friend.trustLevel ?? "unknown",
+                intent: params.intent ?? "generic_outreach",
+                authorizingTrustLevel: params.authorizingSession?.trustLevel ?? null,
+            },
+        });
+        return { delivered: false, reason: "trust_skip" };
+    }
+    const chat = buildChatRefForSessionKey(friend, params.sessionKey);
+    if (!chat) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "senses",
+            event: "senses.bluebubbles_proactive_no_handle",
+            message: "proactive send skipped: no iMessage handle found",
+            meta: { friendId: params.friendId, sessionKey: params.sessionKey },
+        });
+        return { delivered: false, reason: "missing_target" };
+    }
+    // Proactive outreach to individuals must go to DMs, never group chats.
+    // Explicit cross-chat responses (bridge completions, delegation returns) ARE allowed to groups
+    // because the request originated from that group.
+    /* v8 ignore start -- group gate: only fires when proactive send targets a group session @preserve */
+    if (chat.isGroup && params.intent !== "explicit_cross_chat") {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "senses",
+            event: "senses.bluebubbles_proactive_group_blocked",
+            message: "proactive send blocked: would route to group chat",
+            meta: { friendId: params.friendId, sessionKey: params.sessionKey, chatGuid: chat.chatGuid ?? null, intent: params.intent ?? null },
+        });
+        return { delivered: false, reason: "group_blocked" };
+    }
+    /* v8 ignore stop */
+    const internalContentBlockReason = (0, proactive_content_guard_1.getProactiveInternalContentBlockReason)(params.text);
+    if (internalContentBlockReason) {
+        (0, proactive_content_guard_1.emitProactiveInternalContentBlocked)({
+            friendId: params.friendId,
+            sessionKey: params.sessionKey,
+            reason: internalContentBlockReason,
+            source: "session_send",
+            intent: params.intent ?? "generic_outreach",
+        });
+        return { delivered: false, reason: "internal_content_blocked" };
+    }
+    try {
+        await client.sendText({ chat, text: params.text });
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.bluebubbles_proactive_sent",
+            message: "proactive bluebubbles message sent",
+            meta: {
+                friendId: params.friendId,
+                sessionKey: params.sessionKey,
+                chatGuid: chat.chatGuid ?? null,
+                chatIdentifier: chat.chatIdentifier ?? null,
+            },
+        });
+        return { delivered: true };
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "senses",
+            event: "senses.bluebubbles_proactive_send_error",
+            message: "proactive bluebubbles send failed",
+            meta: {
+                friendId: params.friendId,
+                sessionKey: params.sessionKey,
+                reason: error instanceof Error ? error.message : String(error),
+            },
+        });
+        return { delivered: false, reason: "send_error" };
+    }
+}
+function scanPendingBlueBubblesFiles(pendingRoot) {
+    const results = [];
+    let friendIds;
+    try {
+        friendIds = fs.readdirSync(pendingRoot);
+    }
+    catch {
+        return results;
+    }
+    for (const friendId of friendIds) {
+        const bbDir = path.join(pendingRoot, friendId, "bluebubbles");
+        let keys;
+        try {
+            keys = fs.readdirSync(bbDir);
+        }
+        catch {
+            continue;
+        }
+        for (const key of keys) {
+            const keyDir = path.join(bbDir, key);
+            let files;
+            try {
+                files = fs.readdirSync(keyDir);
+            }
+            catch {
+                continue;
+            }
+            for (const file of files.filter((f) => f.endsWith(".json")).sort()) {
+                const filePath = path.join(keyDir, file);
+                try {
+                    const content = fs.readFileSync(filePath, "utf-8");
+                    results.push({ friendId, key, filePath, content });
+                }
+                catch {
+                    // skip unreadable files
+                }
+            }
+        }
+    }
+    return results;
+}
+async function drainAndSendPendingBlueBubbles(deps = {}, pendingRoot) {
+    const resolvedDeps = { ...defaultDeps, ...deps };
+    const root = pendingRoot ?? path.join((0, identity_1.getAgentRoot)(), "state", "pending");
+    const client = resolvedDeps.createClient();
+    const store = resolvedDeps.createFriendStore();
+    const pendingFiles = scanPendingBlueBubblesFiles(root);
+    const result = { sent: 0, skipped: 0, failed: 0 };
+    for (const { friendId, filePath, content } of pendingFiles) {
+        let parsed;
+        try {
+            parsed = JSON.parse(content);
+        }
+        catch {
+            result.failed++;
+            try {
+                fs.unlinkSync(filePath);
+            }
+            catch { /* ignore */ }
+            continue;
+        }
+        const messageText = typeof parsed.content === "string" ? parsed.content : "";
+        if (!messageText.trim()) {
+            result.skipped++;
+            try {
+                fs.unlinkSync(filePath);
+            }
+            catch { /* ignore */ }
+            continue;
+        }
+        if ((0, bluebubbles_meta_guard_1.containsInternalMetaMarkers)(messageText)) {
+            result.skipped++;
+            try {
+                fs.unlinkSync(filePath);
+            }
+            catch { /* ignore */ }
+            (0, bluebubbles_meta_guard_1.emitBluebubblesMetaBlocked)({
+                site: "drain",
+                message: "bluebubbles drain blocked: internal meta markers",
+                meta: {
+                    friendId,
+                    filePath,
+                },
+            });
+            continue;
+        }
+        const internalBlockReason = (0, proactive_content_guard_1.getProactiveInternalContentBlockReason)(messageText);
+        if (internalBlockReason) {
+            result.skipped++;
+            try {
+                fs.unlinkSync(filePath);
+            }
+            catch { /* ignore */ }
+            (0, proactive_content_guard_1.emitProactiveInternalContentBlocked)({
+                friendId,
+                reason: internalBlockReason,
+                source: "pending_drain",
+            });
+            continue;
+        }
+        let friend;
+        try {
+            friend = await store.get(friendId);
+        }
+        catch {
+            friend = null;
+        }
+        if (!friend) {
+            result.skipped++;
+            try {
+                fs.unlinkSync(filePath);
+            }
+            catch { /* ignore */ }
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "senses",
+                event: "senses.bluebubbles_proactive_no_friend",
+                message: "proactive send skipped: friend not found",
+                meta: { friendId },
+            });
+            continue;
+        }
+        if (!friends_1.TRUSTED_LEVELS.has(friend.trustLevel ?? "stranger")) {
+            result.skipped++;
+            try {
+                fs.unlinkSync(filePath);
+            }
+            catch { /* ignore */ }
+            (0, runtime_1.emitNervesEvent)({
+                component: "senses",
+                event: "senses.bluebubbles_proactive_trust_skip",
+                message: "proactive send skipped: trust level not allowed",
+                meta: { friendId, trustLevel: friend.trustLevel ?? "unknown" },
+            });
+            continue;
+        }
+        const handle = findImessageHandle(friend);
+        if (!handle) {
+            result.skipped++;
+            try {
+                fs.unlinkSync(filePath);
+            }
+            catch { /* ignore */ }
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "senses",
+                event: "senses.bluebubbles_proactive_no_handle",
+                message: "proactive send skipped: no iMessage handle found",
+                meta: { friendId },
+            });
+            continue;
+        }
+        const chat = {
+            chatIdentifier: handle,
+            isGroup: false,
+            sessionKey: friendId,
+            sendTarget: { kind: "chat_identifier", value: handle },
+            participantHandles: [],
+        };
+        try {
+            await client.sendText({ chat, text: messageText });
+            result.sent++;
+            try {
+                fs.unlinkSync(filePath);
+            }
+            catch { /* ignore */ }
+            (0, runtime_1.emitNervesEvent)({
+                component: "senses",
+                event: "senses.bluebubbles_proactive_sent",
+                message: "proactive bluebubbles message sent",
+                meta: { friendId, handle },
+            });
+        }
+        catch (error) {
+            result.failed++;
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                component: "senses",
+                event: "senses.bluebubbles_proactive_send_error",
+                message: "proactive bluebubbles send failed",
+                meta: {
+                    friendId,
+                    handle,
+                    reason: error instanceof Error ? error.message : String(error),
+                },
+            });
+        }
+    }
+    if (result.sent > 0 || result.skipped > 0 || result.failed > 0) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.bluebubbles_proactive_drain_complete",
+            message: "bluebubbles proactive drain complete",
+            meta: { sent: result.sent, skipped: result.skipped, failed: result.failed },
+        });
+    }
+    return result;
+}
+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, {
+        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, {
+            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",
+                event: "senses.bluebubbles_recovery_error",
+                message: "bluebubbles queued recovery pass failed",
+                meta: { reason: error instanceof Error ? error.message : String(error) },
+            });
+        })
+            /* v8 ignore stop */
+            .finally(() => {
+            recoveryPassRunning = false;
+        });
+    }
+    function scheduleRecoveryPass() {
+        if (closed)
+            return;
+        /* v8 ignore next -- duplicate scheduling guard for overlapping health sync completions @preserve */
+        if (recoveryDelayTimer !== null)
+            return;
+        recoveryDelayTimer = setTimeout(() => {
+            recoveryDelayTimer = null;
+            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(() => {
+        /* 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) {
+            clearTimeout(recoveryDelayTimer);
+            recoveryDelayTimer = null;
+        }
+    });
+    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",
+            message: "BlueBubbles sense started",
+            meta: { port: channelConfig.port, webhookPath: channelConfig.webhookPath },
+        });
+    });
+    triggerRuntimeSync(startupCatchUpObservationBatch);
+    return server;
+}