@ouro.bot/cli 0.1.0-alpha.48 → 0.1.0-alpha.481

package/dist/senses/{bluebubbles.js → bluebubbles/index.js}

@@ -33,52 +33,116 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.enrichReactionText = enrichReactionText;
+exports.createStatusBatcher = createStatusBatcher;
 exports.handleBlueBubblesEvent = handleBlueBubblesEvent;
+exports.catchUpMissedBlueBubblesMessages = catchUpMissedBlueBubblesMessages;
 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 core_1 = require("../heart/core");
-const config_1 = require("../heart/config");
-const identity_1 = require("../heart/identity");
-const turn_coordinator_1 = require("../heart/turn-coordinator");
-const context_1 = require("../mind/context");
-const tokens_1 = require("../mind/friends/tokens");
-const resolver_1 = require("../mind/friends/resolver");
-const store_file_1 = require("../mind/friends/store-file");
-const types_1 = require("../mind/friends/types");
-const channel_1 = require("../mind/friends/channel");
-const pending_1 = require("../mind/pending");
-const prompt_1 = require("../mind/prompt");
-const phrases_1 = require("../mind/phrases");
-const runtime_1 = require("../nerves/runtime");
-const bluebubbles_model_1 = require("./bluebubbles-model");
-const bluebubbles_client_1 = require("./bluebubbles-client");
-const bluebubbles_inbound_log_1 = require("./bluebubbles-inbound-log");
-const bluebubbles_mutation_log_1 = require("./bluebubbles-mutation-log");
-const bluebubbles_runtime_state_1 = require("./bluebubbles-runtime-state");
-const bluebubbles_session_cleanup_1 = require("./bluebubbles-session-cleanup");
-const debug_activity_1 = require("./debug-activity");
-const trust_gate_1 = require("./trust-gate");
-const pipeline_1 = require("./pipeline");
+const core_1 = require("../../heart/core");
+const config_1 = require("../../heart/config");
+const identity_1 = require("../../heart/identity");
+const turn_coordinator_1 = require("../../heart/turn-coordinator");
+const context_1 = require("../../mind/context");
+const tokens_1 = require("../../mind/friends/tokens");
+const group_context_1 = require("../../mind/friends/group-context");
+const resolver_1 = require("../../mind/friends/resolver");
+const store_file_1 = require("../../mind/friends/store-file");
+const types_1 = require("../../mind/friends/types");
+const channel_1 = require("../../mind/friends/channel");
+const pending_1 = require("../../mind/pending");
+const prompt_1 = require("../../mind/prompt");
+const mcp_manager_1 = require("../../repertoire/mcp-manager");
+// getPhrases removed — no longer needed after debug-activity cleanup
+const runtime_1 = require("../../nerves/runtime");
+const proactive_content_guard_1 = require("../proactive-content-guard");
+const model_1 = require("./model");
+const client_1 = require("./client");
+const inbound_log_1 = require("./inbound-log");
+const mutation_log_1 = require("./mutation-log");
+const runtime_state_1 = require("./runtime-state");
+const session_cleanup_1 = require("./session-cleanup");
+const tool_activity_callbacks_1 = require("../../heart/tool-activity-callbacks");
+const commands_1 = require("../commands");
+const trust_gate_1 = require("../trust-gate");
+const pipeline_1 = require("../pipeline");
+const bbFailoverStates = new Map();
+// Enrich reaction text with the original message content for context.
+// If originalText is provided and non-empty, format as: baseText to: "truncated"
+// Otherwise return baseText unchanged.
+function enrichReactionText(baseText, originalText, maxLen) {
+    if (!originalText)
+        return baseText;
+    const truncated = originalText.length > maxLen
+        ? originalText.slice(0, maxLen - 3) + "..."
+        : originalText;
+    return `${baseText} to: "${truncated}"`;
+}
+/**
+ * Accumulates status descriptions and debounces them.
+ * If multiple descriptions arrive within `delayMs`, they are joined with ` · `
+ * and sent as a single message. Flush sends immediately and clears the timer.
+ */
+function createStatusBatcher(send, delayMs) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.bluebubbles_status_batcher_created",
+        message: "status batcher initialized",
+        meta: { delayMs },
+    });
+    let pending = [];
+    let timer = null;
+    function fire() {
+        if (pending.length === 0)
+            return;
+        const combined = pending.join(" \u00b7 ");
+        pending = [];
+        timer = null;
+        send(combined);
+    }
+    return {
+        add(text) {
+            pending.push(text);
+            if (timer !== null)
+                clearTimeout(timer);
+            timer = setTimeout(fire, delayMs);
+        },
+        flush() {
+            if (timer !== null) {
+                clearTimeout(timer);
+                timer = null;
+            }
+            fire();
+        },
+    };
+}
 const defaultDeps = {
     getAgentName: identity_1.getAgentName,
     buildSystem: prompt_1.buildSystem,
     runAgent: core_1.runAgent,
     loadSession: context_1.loadSession,
-    postTurn: context_1.postTurn,
+    postTurnTrim: context_1.postTurnTrim,
+    deferPostTurnPersist: context_1.deferPostTurnPersist,
     sessionPath: config_1.sessionPath,
     accumulateFriendTokens: tokens_1.accumulateFriendTokens,
-    createClient: () => (0, bluebubbles_client_1.createBlueBubblesClient)(),
-    recordMutation: bluebubbles_mutation_log_1.recordBlueBubblesMutation,
+    createClient: () => (0, client_1.createBlueBubblesClient)(),
+    recordMutation: mutation_log_1.recordBlueBubblesMutation,
     createFriendStore: () => new store_file_1.FileFriendStore(path.join((0, identity_1.getAgentRoot)(), "friends")),
     createFriendResolver: (store, params) => new resolver_1.FriendResolver(store, params),
     createServer: http.createServer,
 };
 const BLUEBUBBLES_RUNTIME_SYNC_INTERVAL_MS = 30_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;
 function resolveFriendParams(event) {
     if (event.chat.isGroup) {
         const groupKey = event.chat.chatGuid ?? event.chat.chatIdentifier ?? event.sender.externalId;
@@ -96,6 +160,10 @@ function resolveFriendParams(event) {
         channel: "bluebubbles",
     };
 }
+function resolveGroupExternalId(event) {
+    const groupKey = event.chat.chatGuid ?? event.chat.chatIdentifier ?? event.sender.externalId;
+    return `group:${groupKey}`;
+}
 /**
  * Check if any participant in a group chat is a known family member.
  * Looks up each participant handle in the friend store.
@@ -192,7 +260,7 @@ function extractHistoricalLaneSummary(messages) {
     }
     return summaries;
 }
-function buildConversationScopePrefix(event, existingMessages) {
+function buildConversationScopePrefix(event, existingMessages, repliedToText) {
     if (event.kind !== "message") {
         return "";
     }
@@ -200,6 +268,10 @@ function buildConversationScopePrefix(event, existingMessages) {
     const lines = [];
     if (event.threadOriginatorGuid?.trim()) {
         lines.push(`[conversation scope: existing chat trunk | current inbound lane: thread | current thread id: ${event.threadOriginatorGuid.trim()} | default outbound target for this turn: current_lane]`);
+        if (repliedToText) {
+            lines.push(`[replying to: "${repliedToText}"]`);
+        }
+        lines.push(`[if you need more context about what was being discussed, use query_session to search your session history, or search_notes to search diary/journal notes.]`);
     }
     else {
         lines.push("[conversation scope: existing chat trunk | current inbound lane: top_level | default outbound target for this turn: top_level]");
@@ -215,8 +287,8 @@ function buildConversationScopePrefix(event, existingMessages) {
     }
     return lines.join("\n");
 }
-function buildInboundText(event, existingMessages) {
-    const metadataPrefix = buildConversationScopePrefix(event, existingMessages);
+function buildInboundText(event, existingMessages, repliedToText) {
+    const metadataPrefix = buildConversationScopePrefix(event, existingMessages, repliedToText);
     const baseText = event.repairNotice?.trim()
         ? `${event.textForAgent}\n[${event.repairNotice.trim()}]`
         : event.textForAgent;
@@ -229,8 +301,8 @@ function buildInboundText(event, existingMessages) {
     }
     return `${event.sender.displayName}: ${scopedText}`;
 }
-function buildInboundContent(event, existingMessages) {
-    const text = buildInboundText(event, existingMessages);
+function buildInboundContent(event, existingMessages, repliedToText) {
+    const text = buildInboundText(event, existingMessages, repliedToText);
     if (event.kind !== "message" || !event.inputPartsForAgent || event.inputPartsForAgent.length === 0) {
         return text;
     }
@@ -336,64 +408,63 @@ function emitBlueBubblesMarkReadWarning(chat, error) {
         },
     });
 }
-function createBlueBubblesCallbacks(client, chat, replyTarget) {
+function createBlueBubblesCallbacks(client, chat, replyTarget, isGroupChat) {
     let textBuffer = "";
-    const phrases = (0, phrases_1.getPhrases)();
-    const activity = (0, debug_activity_1.createDebugActivityController)({
-        thinkingPhrases: phrases.thinking,
-        followupPhrases: phrases.followup,
-        startTypingOnModelStart: true,
-        suppressInitialModelStatus: true,
-        suppressFollowupPhraseStatus: true,
-        transport: {
-            sendStatus: async (text) => {
-                const sent = await client.sendText({
-                    chat,
-                    text,
-                    replyToMessageGuid: replyTarget.getReplyToMessageGuid(),
-                });
-                return sent.messageGuid;
-            },
-            editStatus: async (_messageGuid, text) => {
-                await client.sendText({
-                    chat,
-                    text,
-                    replyToMessageGuid: replyTarget.getReplyToMessageGuid(),
-                });
-            },
-            setTyping: async (active) => {
-                if (!active) {
-                    await client.setTyping(chat, false);
-                    return;
-                }
-                const [markReadResult, typingResult] = await Promise.allSettled([
-                    client.markChatRead(chat),
-                    client.setTyping(chat, true),
-                ]);
-                if (markReadResult.status === "rejected") {
-                    emitBlueBubblesMarkReadWarning(chat, markReadResult.reason);
-                }
-                if (typingResult.status === "rejected") {
-                    throw typingResult.reason;
-                }
-            },
-        },
-        onTransportError: (operation, error) => {
+    let typingActive = false;
+    let queue = Promise.resolve();
+    function enqueue(operation, task) {
+        queue = queue.then(task).catch((error) => {
             (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),
-                },
+                meta: { operation, reason: error instanceof Error ? error.message : String(error) },
             });
-        },
+        });
+    }
+    function startTypingNow() {
+        /* v8 ignore next -- defensive guard: callers already check typingActive @preserve */
+        if (typingActive)
+            return;
+        typingActive = true;
+        enqueue("typing_start", async () => {
+            const [markReadResult, typingResult] = await Promise.allSettled([
+                client.markChatRead(chat),
+                client.setTyping(chat, true),
+            ]);
+            if (markReadResult.status === "rejected") {
+                emitBlueBubblesMarkReadWarning(chat, markReadResult.reason);
+            }
+            if (typingResult.status === "rejected") {
+                throw typingResult.reason;
+            }
+        });
+    }
+    function sendStatus(text) {
+        enqueue("send_status", async () => {
+            await client.sendText({
+                chat,
+                text,
+                replyToMessageGuid: replyTarget.getReplyToMessageGuid(),
+            });
+            // Re-enable typing indicator — sending a message clears the typing bubble
+            await client.setTyping(chat, true);
+        });
+    }
+    const statusBatcher = createStatusBatcher((text) => sendStatus(text), 500);
+    const toolCallbacks = (0, tool_activity_callbacks_1.createToolActivityCallbacks)({
+        onDescription: (text) => statusBatcher.add(text),
+        /* v8 ignore next -- onResult only called in debug mode; tested via tool-activity-callbacks.test.ts @preserve */
+        onResult: (text) => { statusBatcher.flush(); sendStatus(text); },
+        /* v8 ignore next -- onFailure only called on tool failure; tested via tool-activity-callbacks.test.ts @preserve */
+        onFailure: (text) => { statusBatcher.flush(); sendStatus(text); },
+        isDebug: commands_1.getDebugMode,
     });
     return {
         onModelStart() {
-            activity.onModelStart();
+            if (!isGroupChat)
+                startTypingNow();
             (0, runtime_1.emitNervesEvent)({
                 component: "senses",
                 event: "senses.bluebubbles_turn_start",
@@ -410,12 +481,16 @@ function createBlueBubblesCallbacks(client, chat, replyTarget) {
             });
         },
         onTextChunk(text) {
-            activity.onTextChunk(text);
+            if (isGroupChat && !typingActive)
+                startTypingNow();
             textBuffer += text;
         },
         onReasoningChunk(_text) { },
         onToolStart(name, _args) {
-            activity.onToolStart(name, _args);
+            // Tool activity is a reply commitment — start typing if not already
+            if (!typingActive)
+                startTypingNow();
+            toolCallbacks.onToolStart(name, _args);
             (0, runtime_1.emitNervesEvent)({
                 component: "senses",
                 event: "senses.bluebubbles_tool_start",
@@ -424,7 +499,7 @@ function createBlueBubblesCallbacks(client, chat, replyTarget) {
             });
         },
         onToolEnd(name, summary, success) {
-            activity.onToolEnd(name, summary, success);
+            toolCallbacks.onToolEnd(name, summary, success);
             (0, runtime_1.emitNervesEvent)({
                 component: "senses",
                 event: "senses.bluebubbles_tool_end",
@@ -433,7 +508,7 @@ function createBlueBubblesCallbacks(client, chat, replyTarget) {
             });
         },
         onError(error, severity) {
-            activity.onError(error);
+            sendStatus(`\u2717 ${error.message}`);
             (0, runtime_1.emitNervesEvent)({
                 level: severity === "terminal" ? "error" : "warn",
                 component: "senses",
@@ -446,14 +521,24 @@ function createBlueBubblesCallbacks(client, chat, replyTarget) {
             textBuffer = "";
         },
         async flush() {
-            await activity.drain();
+            statusBatcher.flush();
+            await queue;
             const trimmed = textBuffer.trim();
             if (!trimmed) {
-                await activity.finish();
+                if (typingActive) {
+                    typingActive = false;
+                    enqueue("typing_stop", async () => { await client.setTyping(chat, false); });
+                    await queue;
+                }
                 return;
             }
             textBuffer = "";
-            await activity.finish();
+            /* v8 ignore next 4 -- branch: typing may already be stopped before flush @preserve */
+            if (typingActive) {
+                typingActive = false;
+                enqueue("typing_stop", async () => { await client.setTyping(chat, false); });
+                await queue;
+            }
             await client.sendText({
                 chat,
                 text: trimmed,
@@ -461,7 +546,14 @@ function createBlueBubblesCallbacks(client, chat, replyTarget) {
             });
         },
         async finish() {
-            await activity.finish();
+            statusBatcher.flush();
+            if (!typingActive) {
+                await queue;
+                return;
+            }
+            typingActive = false;
+            enqueue("typing_stop", async () => { await client.setTyping(chat, false); });
+            await queue;
         },
     };
 }
@@ -534,7 +626,7 @@ async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source) {
     const friendId = context.friend.id;
     const sessPath = resolvedDeps.sessionPath(friendId, "bluebubbles", event.chat.sessionKey);
     try {
-        (0, bluebubbles_session_cleanup_1.findObsoleteBlueBubblesThreadSessions)(sessPath);
+        (0, session_cleanup_1.findObsoleteBlueBubblesThreadSessions)(sessPath);
     }
     catch (error) {
         (0, runtime_1.emitNervesEvent)({
@@ -551,12 +643,13 @@ async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source) {
     return (0, turn_coordinator_1.withSharedTurnLock)("bluebubbles", sessPath, async () => {
         // Pre-load session inside the turn lock so same-chat deliveries cannot race on stale trunk state.
         const existing = resolvedDeps.loadSession(sessPath);
+        const mcpManager = await (0, mcp_manager_1.getSharedMcpManager)() ?? undefined;
         const sessionMessages = existing?.messages && existing.messages.length > 0
             ? existing.messages
-            : [{ role: "system", content: await resolvedDeps.buildSystem("bluebubbles", undefined, context) }];
+            : [{ role: "system", content: (0, prompt_1.flattenSystemPrompt)(await resolvedDeps.buildSystem("bluebubbles", {}, context)) }];
         if (event.kind === "message") {
             const agentName = resolvedDeps.getAgentName();
-            if ((0, bluebubbles_inbound_log_1.hasRecordedBlueBubblesInbound)(agentName, event.chat.sessionKey, event.messageGuid)) {
+            if ((0, inbound_log_1.hasRecordedBlueBubblesInbound)(agentName, event.chat.sessionKey, event.messageGuid)) {
                 (0, runtime_1.emitNervesEvent)({
                     component: "senses",
                     event: "senses.bluebubbles_recovery_skip",
@@ -569,8 +662,13 @@ async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source) {
                 });
                 return { handled: true, notifiedAgent: false, kind: event.kind, reason: "already_processed" };
             }
-            if (source !== "webhook" && sessionLikelyContainsMessage(event, existing?.messages ?? sessionMessages)) {
-                (0, bluebubbles_inbound_log_1.recordBlueBubblesInbound)(agentName, event, "recovery-bootstrap");
+            // Record EARLY to prevent duplicate processing. BB webhooks can retry
+            // before the first turn completes — recording after the turn is too late.
+            const inboundSource = source !== "webhook" && sessionLikelyContainsMessage(event, existing?.messages ?? sessionMessages)
+                ? "recovery-bootstrap"
+                : source;
+            (0, inbound_log_1.recordBlueBubblesInbound)(agentName, event, inboundSource);
+            if (inboundSource === "recovery-bootstrap") {
                 (0, runtime_1.emitNervesEvent)({
                     component: "senses",
                     event: "senses.bluebubbles_recovery_skip",
@@ -584,15 +682,46 @@ async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source) {
                 return { handled: true, notifiedAgent: false, kind: event.kind, reason: "already_processed" };
             }
         }
+        if (event.kind === "message" && event.chat.isGroup) {
+            await (0, group_context_1.upsertGroupContextParticipants)({
+                store,
+                participants: (event.chat.participantHandles ?? []).map((externalId) => ({
+                    provider: "imessage-handle",
+                    externalId,
+                })),
+                groupExternalId: resolveGroupExternalId(event),
+            });
+        }
+        // Fetch the text of the message being replied to (if this is a threaded reply)
+        const threadGuid = event.kind === "message" ? event.threadOriginatorGuid?.trim() : undefined;
+        let repliedToText = null;
+        if (threadGuid) {
+            repliedToText = await client.getMessageText(threadGuid).catch(/* v8 ignore next */ () => null);
+            (0, runtime_1.emitNervesEvent)({
+                component: "senses",
+                event: "senses.bluebubbles_reply_context",
+                message: repliedToText ? "fetched replied-to message text" : "could not fetch replied-to message text",
+                meta: { threadGuid, hasText: !!repliedToText },
+            });
+        }
+        // Enrich reaction mutations with the original message text for context
+        const isReaction = event.kind === "mutation" && event.mutationType === "reaction";
+        if (isReaction && event.targetMessageGuid) {
+            /* v8 ignore start -- best-effort lookup; enrichReactionText covered by unit tests @preserve */
+            const originalText = await client.getMessageText(event.targetMessageGuid).catch(() => null);
+            if (originalText)
+                event.textForAgent = enrichReactionText(event.textForAgent, originalText, 80);
+            /* v8 ignore stop */
+        }
         // Build inbound user message (adapter concern: BB-specific content formatting)
         const userMessage = {
             role: "user",
-            content: buildInboundContent(event, existing?.messages ?? sessionMessages),
+            content: buildInboundContent(event, existing?.messages ?? sessionMessages, repliedToText),
         };
-        const callbacks = createBlueBubblesCallbacks(client, event.chat, replyTarget);
+        const callbacks = createBlueBubblesCallbacks(client, event.chat, replyTarget, event.chat.isGroup);
         const controller = new AbortController();
         // BB-specific tool context wrappers
-        const summarize = (0, core_1.createSummarize)();
+        const summarize = (0, core_1.createSummarize)("human");
         const bbCapabilities = (0, channel_1.getChannelCapabilities)("bluebubbles");
         const pendingDir = (0, pending_1.getPendingDir)(resolvedDeps.getAgentName(), friendId, "bluebubbles", event.chat.sessionKey);
         // ── Compute trust gate context for group/acquaintance rules ─────
@@ -601,15 +730,38 @@ async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source) {
             ? false
             : await checkHasExistingGroupWithFamily(store, context.friend);
         // ── Call shared pipeline ──────────────────────────────────────────
+        // Buffer terminal errors so failover can suppress them.
+        // If failover produces a message, the buffered error is skipped.
+        // If failover doesn't fire, the buffered error is replayed.
+        let bufferedTerminalError = null;
+        /* v8 ignore start -- failover-aware error buffering @preserve */
+        const failoverAwareCallbacks = {
+            ...callbacks,
+            onError(error, severity) {
+                if (severity === "terminal") {
+                    bufferedTerminalError = error;
+                    return;
+                }
+                callbacks.onError(error, severity);
+            },
+        };
+        /* v8 ignore stop */
         try {
             const result = await (0, pipeline_1.handleInboundTurn)({
                 channel: "bluebubbles",
+                sessionKey: event.chat.sessionKey,
                 capabilities: bbCapabilities,
                 messages: [userMessage],
                 continuityIngressTexts: getBlueBubblesContinuityIngressTexts(event),
-                callbacks,
                 friendResolver: { resolve: () => Promise.resolve(context) },
-                sessionLoader: { loadOrCreate: () => Promise.resolve({ messages: sessionMessages, sessionPath: sessPath, state: existing?.state }) },
+                sessionLoader: {
+                    loadOrCreate: () => Promise.resolve({
+                        messages: sessionMessages,
+                        sessionPath: sessPath,
+                        state: existing?.state,
+                        events: existing?.events,
+                    }),
+                },
                 pendingDir,
                 friendStore: store,
                 provider: "imessage-handle",
@@ -619,6 +771,7 @@ async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source) {
                 hasExistingGroupWithFamily,
                 enforceTrustGate: trust_gate_1.enforceTrustGate,
                 drainPending: pending_1.drainPending,
+                drainDeferredReturns: (deferredFriendId) => (0, pending_1.drainDeferredReturns)(resolvedDeps.getAgentName(), deferredFriendId),
                 runAgent: (msgs, cb, channel, sig, opts) => resolvedDeps.runAgent(msgs, cb, channel, sig, {
                     ...opts,
                     toolContext: {
@@ -640,10 +793,31 @@ async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source) {
                         },
                     },
                 }),
-                postTurn: resolvedDeps.postTurn,
+                postTurn: (turnMessages, sessionPathArg, usage, hooks, state) => {
+                    const prepared = resolvedDeps.postTurnTrim(turnMessages, usage, hooks);
+                    resolvedDeps.deferPostTurnPersist(sessionPathArg, prepared, usage, state);
+                },
                 accumulateFriendTokens: resolvedDeps.accumulateFriendTokens,
                 signal: controller.signal,
+                runAgentOptions: { mcpManager, ...(isReaction ? { isReactionSignal: true } : {}) },
+                callbacks: failoverAwareCallbacks,
+                failoverState: (() => {
+                    if (!bbFailoverStates.has(event.chat.sessionKey)) {
+                        bbFailoverStates.set(event.chat.sessionKey, { pending: null });
+                    }
+                    return bbFailoverStates.get(event.chat.sessionKey);
+                })(),
             });
+            /* v8 ignore start -- failover display + error replay @preserve */
+            if (result.failoverMessage) {
+                // Failover handled it — show the failover message, skip the buffered error
+                await client.sendText({ chat: event.chat, text: result.failoverMessage });
+            }
+            else if (bufferedTerminalError) {
+                // No failover — replay the buffered terminal error
+                callbacks.onError(bufferedTerminalError, "terminal");
+            }
+            /* v8 ignore stop */
             // ── Handle gate result ────────────────────────────────────────
             if (!result.gateResult.allowed) {
                 // Send auto-reply via BB API if the gate provides one
@@ -653,9 +827,6 @@ async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source) {
                         text: result.gateResult.autoReply,
                     });
                 }
-                if (event.kind === "message") {
-                    (0, bluebubbles_inbound_log_1.recordBlueBubblesInbound)(resolvedDeps.getAgentName(), event, source);
-                }
                 return {
                     handled: true,
                     notifiedAgent: false,
@@ -664,9 +835,6 @@ async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source) {
             }
             // Gate allowed — flush the agent's reply
             await callbacks.flush();
-            if (event.kind === "message") {
-                (0, bluebubbles_inbound_log_1.recordBlueBubblesInbound)(resolvedDeps.getAgentName(), event, source);
-            }
             (0, runtime_1.emitNervesEvent)({
                 component: "senses",
                 event: "senses.bluebubbles_turn_end",
@@ -684,6 +852,14 @@ async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source) {
             };
         }
         finally {
+            // If a terminal error was buffered and never replayed (e.g., handleInboundTurn threw),
+            // replay it now so the user still sees the error.
+            /* v8 ignore start -- error replay on throw: tested via BB error test @preserve */
+            if (bufferedTerminalError) {
+                callbacks.onError(bufferedTerminalError, "terminal");
+                bufferedTerminalError = null;
+            }
+            /* v8 ignore stop */
             await callbacks.finish();
         }
     });
@@ -691,36 +867,119 @@ async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source) {
 async function handleBlueBubblesEvent(payload, deps = {}) {
     const resolvedDeps = { ...defaultDeps, ...deps };
     const client = resolvedDeps.createClient();
-    const event = await client.repairEvent((0, bluebubbles_model_1.normalizeBlueBubblesEvent)(payload));
+    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;
+    }
+    // Pre-repair dedup: if we've already processed this messageGuid, skip the
+    // repair+hydrate path entirely. Applies to BOTH `kind: "message"` AND
+    // `kind: "mutation"` events — BlueBubbles often sends a `new-message`
+    // webhook for a fresh message AND one or more follow-up `updated-message`
+    // webhooks for delivery/read status. The mutation path (inside repairEvent)
+    // can promote an updated-message back to a message if it has recoverable
+    // content, which then re-runs the full VLM-describe pipeline on the same
+    // attachment.
+    //
+    // Without this early check, we paid DOUBLE latency and double tokens on
+    // every image-bearing message. Verified live on 2026-04-08T00:58Z: two
+    // sequential VLM describes for attachment guid 317E37EB-..., 13.7s +
+    // 14.0s each, for the exact same 291KB JPEG — triggered by a sequence of
+    // `new-message` followed ~3s later by `updated-message` for the same guid.
+    //
+    // We still route the skip through `handleBlueBubblesNormalizedEvent` so
+    // the downstream `already_processed` path fires its observability events
+    // and the caller sees a consistent return shape.
+    const agentName = resolvedDeps.getAgentName();
+    if (normalized.messageGuid
+        && (0, inbound_log_1.hasRecordedBlueBubblesInbound)(agentName, normalized.chat.sessionKey, normalized.messageGuid)) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "senses",
+            event: "senses.bluebubbles_repair_skipped_duplicate",
+            message: "skipped repair+hydrate for already-processed bluebubbles messageGuid",
+            meta: {
+                messageGuid: normalized.messageGuid,
+                sessionKey: normalized.chat.sessionKey,
+                eventType: normalized.eventType,
+                normalizedKind: normalized.kind,
+            },
+        });
+        return handleBlueBubblesNormalizedEvent(normalized, resolvedDeps, "webhook");
+    }
+    const event = await client.repairEvent(normalized);
     return handleBlueBubblesNormalizedEvent(event, resolvedDeps, "webhook");
 }
 function countPendingRecoveryCandidates(agentName) {
-    return (0, bluebubbles_mutation_log_1.listBlueBubblesRecoveryCandidates)(agentName)
-        .filter((entry) => !(0, bluebubbles_inbound_log_1.hasRecordedBlueBubblesInbound)(agentName, entry.sessionKey, entry.messageGuid))
+    return (0, mutation_log_1.listBlueBubblesRecoveryCandidates)(agentName)
+        .filter((entry) => !(0, inbound_log_1.hasRecordedBlueBubblesInbound)(agentName, entry.sessionKey, entry.messageGuid))
         .length;
 }
+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 formatRecoveredCount(count) {
+    return `caught up ${count} missed message(s)`;
+}
 async function syncBlueBubblesRuntime(deps = {}) {
     const resolvedDeps = { ...defaultDeps, ...deps };
     const agentName = resolvedDeps.getAgentName();
     const client = resolvedDeps.createClient();
     const checkedAt = new Date().toISOString();
+    const previousState = (0, runtime_state_1.readBlueBubblesRuntimeState)(agentName);
     try {
         await client.checkHealth();
         const recovery = await recoverMissedBlueBubblesMessages(resolvedDeps);
-        (0, bluebubbles_runtime_state_1.writeBlueBubblesRuntimeState)(agentName, {
-            upstreamStatus: recovery.pending > 0 || recovery.failed > 0 ? "error" : "ok",
-            detail: recovery.failed > 0
-                ? `recovery failures: ${recovery.failed}`
+        const catchUp = await catchUpMissedBlueBubblesMessages(resolvedDeps, previousState);
+        const failed = recovery.failed + catchUp.failed;
+        const recovered = recovery.recovered + catchUp.recovered;
+        (0, runtime_state_1.writeBlueBubblesRuntimeState)(agentName, {
+            upstreamStatus: recovery.pending > 0 || failed > 0 ? "error" : "ok",
+            detail: failed > 0
+                ? `recovery failures: ${failed}`
                 : recovery.pending > 0
                     ? `pending recovery: ${recovery.pending}`
-                    : "upstream reachable",
+                    : catchUp.recovered > 0
+                        ? formatRecoveredCount(catchUp.recovered)
+                        : "upstream reachable",
             lastCheckedAt: checkedAt,
             pendingRecoveryCount: recovery.pending,
-            lastRecoveredAt: recovery.recovered > 0 ? checkedAt : undefined,
+            lastRecoveredAt: recovered > 0 ? checkedAt : previousState.lastRecoveredAt,
+            lastRecoveredMessageGuid: catchUp.lastRecoveredMessageGuid ?? previousState.lastRecoveredMessageGuid,
         });
     }
     catch (error) {
-        (0, bluebubbles_runtime_state_1.writeBlueBubblesRuntimeState)(agentName, {
+        (0, runtime_state_1.writeBlueBubblesRuntimeState)(agentName, {
             upstreamStatus: "error",
             detail: error instanceof Error ? error.message : String(error),
             lastCheckedAt: checkedAt,
@@ -728,13 +987,135 @@ async function syncBlueBubblesRuntime(deps = {}) {
         });
     }
 }
+async function catchUpMissedBlueBubblesMessages(deps = {}, previousState) {
+    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 catchUpSince = resolveBlueBubblesCatchUpSince(state);
+    /* 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 recentEvents = [];
+    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,
+            });
+        }
+        catch (error) {
+            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;
+        }
+        recentEvents.push(...pageEvents);
+        if (pageEvents.length < BLUEBUBBLES_CATCHUP_PAGE_SIZE)
+            break;
+        const oldestMessageTimestamp = pageEvents
+            .filter((event) => event.kind === "message")
+            .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",
+                },
+            });
+        }
+    }
+    const seenMessageGuids = new Set();
+    const candidates = recentEvents
+        .filter((event) => event.kind === "message")
+        .filter((event) => {
+        if (seenMessageGuids.has(event.messageGuid))
+            return false;
+        seenMessageGuids.add(event.messageGuid);
+        return true;
+    })
+        .sort((left, right) => left.timestamp - right.timestamp);
+    for (const event of candidates) {
+        result.inspected++;
+        if (event.fromMe
+            || event.timestamp < catchUpSince
+            || (0, inbound_log_1.hasRecordedBlueBubblesInbound)(agentName, event.chat.sessionKey, event.messageGuid)) {
+            result.skipped++;
+            continue;
+        }
+        try {
+            const repaired = await client.repairEvent(event);
+            if (repaired.kind !== "message") {
+                result.skipped++;
+                continue;
+            }
+            const handled = await handleBlueBubblesNormalizedEvent(repaired, resolvedDeps, "upstream-catchup");
+            if (handled.reason === "already_processed") {
+                result.skipped++;
+            }
+            else {
+                result.recovered++;
+                result.lastRecoveredMessageGuid = repaired.messageGuid;
+            }
+        }
+        catch (error) {
+            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 recoverMissedBlueBubblesMessages(deps = {}) {
     const resolvedDeps = { ...defaultDeps, ...deps };
     const agentName = resolvedDeps.getAgentName();
     const client = resolvedDeps.createClient();
     const result = { recovered: 0, skipped: 0, pending: 0, failed: 0 };
-    for (const candidate of (0, bluebubbles_mutation_log_1.listBlueBubblesRecoveryCandidates)(agentName)) {
-        if ((0, bluebubbles_inbound_log_1.hasRecordedBlueBubblesInbound)(agentName, candidate.sessionKey, candidate.messageGuid)) {
+    for (const candidate of (0, mutation_log_1.listBlueBubblesRecoveryCandidates)(agentName)) {
+        if ((0, inbound_log_1.hasRecordedBlueBubblesInbound)(agentName, candidate.sessionKey, candidate.messageGuid)) {
             result.skipped++;
             continue;
         }
@@ -779,6 +1160,14 @@ async function recoverMissedBlueBubblesMessages(deps = {}) {
 function createBlueBubblesWebhookHandler(deps = {}) {
     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) {
@@ -839,6 +1228,192 @@ function findImessageHandle(friend) {
     }
     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 = {}) {
+    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"
+        && types_1.TRUSTED_LEVELS.has(params.authorizingSession?.trustLevel ?? "stranger");
+    if (!explicitCrossChatAuthorized && !types_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;
@@ -909,6 +1484,20 @@ async function drainAndSendPendingBlueBubbles(deps = {}, pendingRoot) {
             catch { /* ignore */ }
             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);