@openclaw/imessage 2026.9.4 → 2026.9.6

package/dist/{monitor-xaD-9h0b.js → .setup/monitor-BJ3Ozi6I.mjs}

@@ -1,24 +1,25 @@
-import { d as resolveIMessageChatDbLookupPath, f as resolveIMessageHomeDir, l as resolveIMessageRemoteHost, o as resolveIMessageAccount } from "./accounts-CCirBEIm.js";
-import { c as parseIMessageAllowTarget, f as getCachedIMessagePrivateApiStatus, i as isAllowedIMessageReplyContextSender, l as parseIMessageTarget, n as formatIMessageChatTarget, p as imessageRpcSupportsMethod, s as normalizeIMessageHandle } from "./message-tool-api-CUoFESHj.js";
-import { d as rememberIMessageReplyCache, o as createIMessageRpcClient, r as sanitizeOutboundText, u as isKnownFromMeIMessageMessageId, y as resolveIMessageDirectChatService } from "./sanitize-outbound-C6UF2cvr.js";
-import { f as probeIMessage, r as resolveIMessageInboundConversationId } from "./group-policy-Duro87b4.js";
-import { t as getIMessageRuntime } from "./runtime-Cza4CY5T.js";
-import { d as resolveIMessageEchoMediaKey, l as capFailureRetriesMap, t as IMESSAGE_CATCHUP_CURSOR_NAMESPACE, u as resolveIMessageCatchupCursorKey } from "./state-contract-DvahEY4X.js";
-import { n as resolveIMessageAttachmentRoots, r as resolveIMessageRemoteAttachmentRoots } from "./media-contract-pns3TSS5.js";
-import { i as registerIMessageApprovalReactionTarget, n as handleIMessageApprovalReaction, o as listPendingIMessageApprovalReactionPollTargets, r as maybeResolveIMessageApprovalReaction, s as buildIMessageApprovalConversationKeyForInbound } from "./approval-reactions-BM_AwHPq.js";
-import { c as iMessageApprovalControlBindings, n as hasPersistedIMessageEcho, r as stripLeadingEchoTextCorruptionMarkers, s as maybeResolveIMessageApprovalPollVote, t as sendMessageIMessage } from "./send-CIHiLtcY.js";
-import { n as normalizeIMessageGuid, t as resolveIMessageReactionContext } from "./reaction-context-Br-vAJFp.js";
-import { n as maybeResolveIMessageQuestionReaction, t as hasIMessageQuestionReactionTarget } from "./question-reactions-9tBYB1_F.js";
+import { c as parseIMessageTarget, o as normalizeIMessageHandle, r as isAllowedIMessageReplyContextSender, s as parseIMessageAllowTarget, t as formatIMessageChatTarget } from "./targets-Cc9vthzI.mjs";
+import { d as resolveIMessageChatDbLookupPath, f as resolveIMessageHomeDir, l as resolveIMessageRemoteHost, o as resolveIMessageAccount } from "./accounts-CUxZrTcY.mjs";
+import { r as imessageRpcSupportsMethod } from "./message-tool-api-pvlcOJPG.mjs";
+import { b as resolveIMessageDirectChatService, d as isKnownFromMeIMessageMessageId, f as rememberIMessageReplyCache, o as createIMessageRpcClient, r as sanitizeOutboundText } from "./sanitize-outbound-sJPF2DVM.mjs";
+import { d as probeIMessage, f as probeIMessagePrivateApi, i as resolveIMessageInboundConversationId, n as resolveIMessageGroupSystemPrompt } from "./group-policy-Cjztkquv.mjs";
+import { t as getIMessageRuntime } from "./runtime-Cza4CY5T.mjs";
+import { d as resolveIMessageEchoMediaKey, l as capFailureRetriesMap, t as IMESSAGE_CATCHUP_CURSOR_NAMESPACE, u as resolveIMessageCatchupCursorKey } from "./state-contract-DvahEY4X.mjs";
+import { n as resolveIMessageAttachmentRoots, r as resolveIMessageRemoteAttachmentRoots } from "./media-contract-DKJK7rh3.mjs";
+import { i as registerIMessageApprovalReactionTarget, n as handleIMessageApprovalReaction, o as listPendingIMessageApprovalReactionPollTargets, r as maybeResolveIMessageApprovalReaction, s as buildIMessageApprovalConversationKeyForInbound } from "./approval-reactions-D6RFg6lU.mjs";
+import { c as maybeResolveIMessageApprovalPollVote, i as resolveIMessageStartupRowidWatermark, l as iMessageApprovalControlBindings, n as hasPersistedIMessageEcho, r as stripLeadingEchoTextCorruptionMarkers, t as sendMessageIMessage } from "./send-odAfTQ2J.mjs";
+import { n as normalizeIMessageGuid, t as resolveIMessageReactionContext } from "./reaction-context-Br-vAJFp.mjs";
+import { n as maybeResolveIMessageQuestionReaction, t as hasIMessageQuestionReactionTarget } from "./question-reactions-lm8OxWbb.mjs";
+import { asSafeIntegerInRange, hasNonEmptyString, isRecord, normalizeOptionalString, normalizeStringEntries, uniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { bindIngressLifecycleToReplyOptions, createChannelIngressError, createChannelIngressMonitor, createChannelMessageReplyPipeline, resolveChannelStreamingBlockEnabled } from "openclaw/plugin-sdk/channel-outbound";
-import { chunkMarkdownTextWithMode as chunkTextWithMode, resolveChunkMode, resolveTextChunkLimit } from "openclaw/plugin-sdk/reply-runtime";
+import { resolveTextChunkLimit } from "openclaw/plugin-sdk/reply-runtime";
 import { resolveAgentRoute, resolveInboundLastRouteSessionKey } from "openclaw/plugin-sdk/routing";
 import path from "node:path";
 import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";
-import { asSafeIntegerInRange, hasNonEmptyString, isRecord, normalizeOptionalString, normalizeStringEntries, uniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";
 import fs from "node:fs/promises";
-import { createNonExitingRuntime, danger, logVerbose, shouldLogVerbose, warn } from "openclaw/plugin-sdk/runtime-env";
 import { isInboundPathAllowed, kindFromMime } from "openclaw/plugin-sdk/media-runtime";
-import { asDateTimestampMs, asPositiveFiniteNumber, parseDateStringTimestampMs, resolveIntegerOption, timestampMsToIsoString } from "openclaw/plugin-sdk/number-runtime";
+import { createNonExitingRuntime, danger, logVerbose, shouldLogVerbose, warn } from "openclaw/plugin-sdk/runtime-env";
+import { asDateTimestampMs, asPositiveFiniteNumber, parseDateStringTimestampMs, resolveIntegerOption, resolvePromptHistoryLimit, timestampMsToIsoString } from "openclaw/plugin-sdk/number-runtime";
 import { createHash } from "node:crypto";
 import { createRuntimeConfigReader, getRuntimeConfig } from "openclaw/plugin-sdk/runtime-config-snapshot";
 import { sliceUtf16Safe, truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
@@ -29,33 +30,34 @@ import { buildChannelInboundEventContext, buildMentionRegexes, createAcceptedCha
 import { resolveAgentConfig, resolveHumanDelayConfig } from "openclaw/plugin-sdk/agent-runtime";
 import { CHANNEL_APPROVAL_NATIVE_RUNTIME_CONTEXT_CAPABILITY } from "openclaw/plugin-sdk/approval-handler-runtime";
 import { logTypingFailure } from "openclaw/plugin-sdk/channel-feedback";
-import { createChannelIngressResolver, defineStableChannelIngressIdentity, fanInChannelIngressLifecycles } from "openclaw/plugin-sdk/channel-ingress-runtime";
+import { defineStableChannelIngressIdentity, fanInChannelIngressLifecycles } from "openclaw/plugin-sdk/channel-ingress-runtime";
 import { createChannelPairingChallengeIssuer } from "openclaw/plugin-sdk/channel-pairing";
 import { registerChannelRuntimeContext } from "openclaw/plugin-sdk/channel-runtime-context";
 import { ensureConfiguredBindingRouteReady, readChannelAllowFromStore, resolveConfiguredBindingRoute, resolveRuntimeConversationBindingRoute, upsertChannelPairingRequest } from "openclaw/plugin-sdk/conversation-runtime";
 import { channelReadyPatch } from "openclaw/plugin-sdk/gateway-runtime";
 import { redactIdentifier } from "openclaw/plugin-sdk/logging-core";
-import { DEFAULT_GROUP_HISTORY_LIMIT, createChannelHistoryWindow } from "openclaw/plugin-sdk/reply-history";
 import { resolveDefaultGroupPolicy, resolveOpenProviderRuntimeGroupPolicy, warnMissingProviderGroupPolicyFallbackOnce } from "openclaw/plugin-sdk/runtime-group-policy";
-import { openLocalFileSafely, resolvePinnedMainDmOwnerFromAllowlist } from "openclaw/plugin-sdk/security-runtime";
+import { FsSafeError, openLocalFileSafely, resolvePinnedMainDmOwnerFromAllowlist } from "openclaw/plugin-sdk/security-runtime";
 import { getSessionEntry, readSessionUpdatedAt, resolveSendPolicy, resolveStorePath } from "openclaw/plugin-sdk/session-store-runtime";
-import { openNodeSqliteDatabase } from "openclaw/plugin-sdk/sqlite-runtime";
 import { waitForTransportReady } from "openclaw/plugin-sdk/transport-ready-runtime";
 import { requireRuntimeConfig } from "openclaw/plugin-sdk/plugin-config-runtime";
 import { resolveMarkdownTableMode as resolveMarkdownTableMode$1 } from "openclaw/plugin-sdk/markdown-table-runtime";
 import { resolvePreferredOpenClawTmpDir, withTempWorkspace } from "openclaw/plugin-sdk/temp-path";
 import { KeyedAsyncQueue } from "openclaw/plugin-sdk/keyed-async-queue";
 import { deliverTextOrMediaReply, resolveSendableOutboundReplyParts } from "openclaw/plugin-sdk/reply-payload";
+import { chunkMarkdownTextWithMode as chunkTextWithMode, resolveChunkMode } from "openclaw/plugin-sdk/reply-chunking";
 import { createDedupeCache } from "openclaw/plugin-sdk/dedupe-runtime";
 import { hasControlCommand } from "openclaw/plugin-sdk/command-auth-native";
 import { resolveChannelContextVisibilityMode } from "openclaw/plugin-sdk/context-visibility-runtime";
+import { createChannelHistoryWindow } from "openclaw/plugin-sdk/reply-history";
 import { isRecord as isRecord$1 } from "openclaw/plugin-sdk/channel-secret-basic-runtime";
+import { readFileHandleBounded } from "openclaw/plugin-sdk/file-access-runtime";
 import { saveMediaBuffer } from "openclaw/plugin-sdk/media-store";
 import { loadWebMedia } from "openclaw/plugin-sdk/web-media";
-import { enqueueSystemEvent } from "openclaw/plugin-sdk/system-event-runtime";
+import { enqueueRoutedSystemEvent } from "openclaw/plugin-sdk/system-event-runtime";
 //#region extensions/imessage/src/approval-reaction-poller.ts
 const RECENT_CHAT_LIMIT = 50;
-const PER_CHAT_HISTORY_LIMIT = 30;
+const PER_CHAT_HISTORY_LIMIT$1 = 30;
 function normalizeChatId(value) {
 	return asPositiveFiniteNumber(value) ?? null;
 }
@@ -89,7 +91,7 @@ async function listRecentChatIds(client) {
 async function fetchRecentHistory(params) {
 	return ((await params.client.request("messages.history", {
 		chat_id: params.chatId,
-		limit: PER_CHAT_HISTORY_LIMIT
+		limit: PER_CHAT_HISTORY_LIMIT$1
 	}, { timeoutMs: 1e4 })).messages ?? []).filter((message) => Boolean(message && typeof message === "object"));
 }
 function buildReactionPayload(params) {
@@ -129,14 +131,14 @@ function buildConversationKeyFromMessage(message) {
 		...normalizeChatId(message.chat_id) !== null ? { chatId: message.chat_id } : {}
 	};
 }
-function bindObservedConversation(params) {
+async function bindObservedConversation(params) {
 	const nowMs = asDateTimestampMs(Date.now());
 	const expiresAtMs = asDateTimestampMs(params.target.expiresAtMs);
 	if (nowMs === void 0 || expiresAtMs === void 0 || expiresAtMs <= nowMs) return;
 	const ttlMs = expiresAtMs - nowMs;
 	const conversation = buildConversationKeyFromMessage(params.message);
 	const messageIds = /* @__PURE__ */ new Set([...enumerateMessageGuidCandidates(params.target.messageId), ...enumerateMessageGuidCandidates(params.message.guid ?? "")]);
-	for (const messageId of messageIds) registerIMessageApprovalReactionTarget({
+	await Promise.all([...messageIds].map((messageId) => registerIMessageApprovalReactionTarget({
 		accountId: params.target.accountId,
 		conversation,
 		messageId,
@@ -144,7 +146,7 @@ function bindObservedConversation(params) {
 		approvalKind: params.target.approvalKind,
 		allowedDecisions: params.target.allowedDecisions,
 		ttlMs
-	});
+	})));
 }
 async function pollPendingIMessageApprovalReactions(params) {
 	const targets = await listPendingIMessageApprovalReactionPollTargets({ accountId: params.accountId });
@@ -169,7 +171,7 @@ async function pollPendingIMessageApprovalReactions(params) {
 			if (!targetGuid) continue;
 			const target = pendingByMessageId.get(targetGuid) ?? pendingByMessageId.get(normalizeIMessageGuid(targetGuid));
 			if (!target) continue;
-			bindObservedConversation({
+			await bindObservedConversation({
 				target,
 				message
 			});
@@ -270,16 +272,11 @@ const DEFAULT_MAX_FAILURE_RETRIES = 10;
 const MAX_MAX_FAILURE_RETRIES = 1e3;
 const cursorWriteQueue = new KeyedAsyncQueue();
 function openCatchupCursorStore() {
-	return getIMessageRuntime().state.openSyncKeyedStore({
+	return getIMessageRuntime().state.openKeyedStore({
 		namespace: IMESSAGE_CATCHUP_CURSOR_NAMESPACE,
 		maxEntries: 256
 	});
 }
-function updateCatchupCursorStore(key, updateValue) {
-	const store = openCatchupCursorStore();
-	if (!store.update) throw new Error("iMessage catchup cursor persistence requires atomic plugin-state update.");
-	return store.update(key, updateValue);
-}
 function enqueueCursorWrite(accountId, fn) {
 	const key = resolveIMessageCatchupCursorKey(accountId);
 	return cursorWriteQueue.enqueue(key, fn);
@@ -308,39 +305,58 @@ function normalizeIMessageCatchupCursor(value) {
 		...hasRetries ? { failureRetries } : {}
 	};
 }
-function readIMessageCatchupCursor(accountId) {
-	return normalizeIMessageCatchupCursor(openCatchupCursorStore().lookup(resolveIMessageCatchupCursorKey(accountId)));
-}
 async function loadIMessageCatchupCursor(accountId) {
-	return readIMessageCatchupCursor(accountId);
+	return normalizeIMessageCatchupCursor(await openCatchupCursorStore().lookup(resolveIMessageCatchupCursorKey(accountId)));
 }
-function buildIMessageCatchupCursor(next) {
+function buildIMessageCatchupCursor(next, updatedAt) {
 	const sanitized = sanitizeFailureRetriesInput(next.failureRetries);
 	const hasRetries = Object.keys(sanitized).length > 0;
 	return {
 		lastSeenMs: next.lastSeenMs,
 		lastSeenRowid: next.lastSeenRowid,
-		updatedAt: Date.now(),
+		updatedAt,
 		...hasRetries ? { failureRetries: sanitized } : {}
 	};
 }
-async function saveIMessageCatchupCursor(accountId, next, options = {}) {
-	const cursor = buildIMessageCatchupCursor(next);
-	updateCatchupCursorStore(resolveIMessageCatchupCursorKey(accountId), (existingValue) => {
-		const existing = normalizeIMessageCatchupCursor(existingValue);
-		if (existing && cursor.lastSeenRowid < existing.lastSeenRowid) {
-			if (!options.allowCursorRewindForRetries) return;
-			return buildIMessageCatchupCursor({
+function decideCatchupCursorSave(existingValue, cursor, allowCursorRewindForRetries) {
+	const existing = normalizeIMessageCatchupCursor(existingValue);
+	if (existing && cursor.lastSeenRowid < existing.lastSeenRowid) {
+		if (!allowCursorRewindForRetries) return {
+			operation: "update",
+			action: "keep"
+		};
+		return {
+			operation: "update",
+			action: "set",
+			value: buildIMessageCatchupCursor({
 				lastSeenMs: cursor.lastSeenMs,
 				lastSeenRowid: cursor.lastSeenRowid,
 				failureRetries: {
 					...existing.failureRetries,
 					...cursor.failureRetries
 				}
-			});
-		}
-		return cursor;
-	});
+			}, cursor.updatedAt)
+		};
+	}
+	return {
+		operation: "update",
+		action: "set",
+		value: cursor
+	};
+}
+async function saveIMessageCatchupCursor(accountId, next, options = {}) {
+	const cursor = buildIMessageCatchupCursor(next, Date.now());
+	const allowCursorRewindForRetries = options.allowCursorRewindForRetries === true;
+	const store = openCatchupCursorStore();
+	if (!store.observe || !store.compareAndApply) throw new Error("iMessage catchup cursor persistence requires plugin-state comparison support.");
+	const key = resolveIMessageCatchupCursorKey(accountId);
+	let observation = await store.observe(key);
+	for (;;) {
+		const intent = decideCatchupCursorSave(observation.value, cursor, allowCursorRewindForRetries);
+		const result = await store.compareAndApply(key, observation.comparison, intent);
+		if (result.status !== "conflict") return;
+		observation = result.current;
+	}
 }
 function clampInt(value, min, max, fallback) {
 	return resolveIntegerOption(value, fallback, {
@@ -357,22 +373,41 @@ function resolveCatchupConfig(raw) {
 		maxFailureRetries: clampInt(raw?.maxFailureRetries, 1, MAX_MAX_FAILURE_RETRIES, DEFAULT_MAX_FAILURE_RETRIES)
 	};
 }
+function decideLiveCatchupCursorAdvance(existingValue, next, maxFailureRetries) {
+	const cursor = normalizeIMessageCatchupCursor(existingValue);
+	if (cursor && next.lastSeenRowid <= cursor.lastSeenRowid) return {
+		operation: "update",
+		action: "keep"
+	};
+	if (Object.values(cursor?.failureRetries ?? {}).some((count) => count < maxFailureRetries)) return {
+		operation: "update",
+		action: "keep"
+	};
+	return {
+		operation: "update",
+		action: "set",
+		value: buildIMessageCatchupCursor({
+			lastSeenMs: Math.max(cursor?.lastSeenMs ?? next.lastSeenMs, next.lastSeenMs),
+			lastSeenRowid: next.lastSeenRowid,
+			failureRetries: cursor?.failureRetries
+		}, next.updatedAt)
+	};
+}
 async function advanceIMessageCatchupCursor(accountId, next, config) {
 	if (!Number.isFinite(next.lastSeenMs) || !Number.isFinite(next.lastSeenRowid)) return false;
 	return await enqueueCursorWrite(accountId, async () => {
-		let advanced = false;
-		updateCatchupCursorStore(resolveIMessageCatchupCursorKey(accountId), (existingValue) => {
-			const cursor = normalizeIMessageCatchupCursor(existingValue);
-			if (cursor && next.lastSeenRowid <= cursor.lastSeenRowid) return;
-			if (Object.values(cursor?.failureRetries ?? {}).some((count) => count < config.maxFailureRetries)) return;
-			advanced = true;
-			return buildIMessageCatchupCursor({
-				lastSeenMs: Math.max(cursor?.lastSeenMs ?? next.lastSeenMs, next.lastSeenMs),
-				lastSeenRowid: next.lastSeenRowid,
-				failureRetries: cursor?.failureRetries
-			});
-		});
-		return advanced;
+		const cursor = buildIMessageCatchupCursor(next, Date.now());
+		const maxFailureRetries = config.maxFailureRetries;
+		const store = openCatchupCursorStore();
+		if (!store.observe || !store.compareAndApply) throw new Error("iMessage catchup cursor persistence requires plugin-state comparison support.");
+		const key = resolveIMessageCatchupCursorKey(accountId);
+		let observation = await store.observe(key);
+		for (;;) {
+			const intent = decideLiveCatchupCursorAdvance(observation.value, cursor, maxFailureRetries);
+			const result = await store.compareAndApply(key, observation.comparison, intent);
+			if (result.status !== "conflict") return result.status === "applied";
+			observation = result.current;
+		}
 	});
 }
 /**
@@ -594,7 +629,7 @@ function parseIMessageNotification(raw) {
 }
 //#endregion
 //#region extensions/imessage/src/monitor/catchup-bridge.ts
-const PER_CHAT_HISTORY_LIMIT_CAP = 500;
+const PER_CHAT_HISTORY_LIMIT = 500;
 const CATCHUP_CHATS_LIST_LIMIT = 200;
 const CATCHUP_RPC_TIMEOUT_MS = 3e4;
 /**
@@ -638,7 +673,6 @@ async function runIMessageCatchup(params) {
 		}
 		const chats = chatsResult?.chats ?? [];
 		const collected = [];
-		const perChatLimit = Math.min(limit, PER_CHAT_HISTORY_LIMIT_CAP);
 		let historyFetchFailed = false;
 		let rawWatermarkRowid = -Infinity;
 		let rawWatermarkMs = -Infinity;
@@ -651,7 +685,7 @@ async function runIMessageCatchup(params) {
 			try {
 				historyResult = await client.request("messages.history", {
 					chat_id: chatId,
-					limit: perChatLimit,
+					limit: PER_CHAT_HISTORY_LIMIT,
 					start: sinceISO,
 					attachments: includeAttachments
 				}, { timeoutMs: CATCHUP_RPC_TIMEOUT_MS });
@@ -758,7 +792,6 @@ async function runIMessageCatchup(params) {
 */
 const MAX_COALESCED_TEXT_CHARS = 4e3;
 const MAX_COALESCED_ATTACHMENTS = 20;
-const MAX_COALESCED_ENTRIES = 10;
 /**
 * Combine consecutive same-sender iMessage payloads into a single payload for
 * downstream dispatch. Used for the general inbound debounce
@@ -773,44 +806,56 @@ function combineIMessagePayloads(payloads) {
 	if (payloads.length === 0) throw new Error("combineIMessagePayloads: cannot combine empty payloads");
 	const first = expectDefined(payloads[0], "first iMessage payload to coalesce");
 	if (payloads.length === 1) return first;
-	const last = expectDefined(payloads.at(-1), "last iMessage payload to coalesce");
-	const boundedPayloads = payloads.length > MAX_COALESCED_ENTRIES ? [...payloads.slice(0, 9), last] : payloads;
 	const seenTexts = /* @__PURE__ */ new Set();
 	const textParts = [];
-	for (const payload of boundedPayloads) {
-		const text = (payload.text ?? "").trim();
-		if (!text) continue;
-		const normalized = text.toLowerCase();
-		if (seenTexts.has(normalized)) continue;
-		seenTexts.add(normalized);
-		textParts.push(text);
-	}
-	let combinedText = textParts.join(" ");
-	if (combinedText.length > MAX_COALESCED_TEXT_CHARS) combinedText = `${sliceUtf16Safe(combinedText, 0, MAX_COALESCED_TEXT_CHARS)}…[truncated]`;
-	const allAttachments = boundedPayloads.flatMap((p) => p.attachments ?? []).slice(0, MAX_COALESCED_ATTACHMENTS);
-	const createdAts = payloads.map((p) => p.created_at).filter((c) => typeof c === "string" && c.length > 0);
-	const latestCreatedAt = createdAts.length > 0 ? createdAts.reduce((a, b) => a > b ? a : b) : first.created_at;
+	const allAttachments = [];
+	const seenGuids = /* @__PURE__ */ new Set();
+	const coalescedMessageGuids = [];
+	let textLength = 0;
+	let latestCreatedAt;
 	let maxRowid = -Infinity;
 	let maxDateMs = -Infinity;
+	let reply;
+	let payloadIndex = 0;
 	for (const payload of payloads) {
+		const keepContent = payloadIndex < 9 || payloadIndex === payloads.length - 1;
+		payloadIndex += 1;
+		const createdAt = payload.created_at;
+		if (typeof createdAt === "string" && createdAt.length > 0 && (latestCreatedAt === void 0 || createdAt > latestCreatedAt)) latestCreatedAt = createdAt;
 		if (typeof payload.id === "number" && Number.isFinite(payload.id)) maxRowid = Math.max(maxRowid, payload.id);
-		const dateMs = typeof payload.created_at === "string" ? Date.parse(payload.created_at) : NaN;
+		const dateMs = typeof createdAt === "string" ? Date.parse(createdAt) : NaN;
 		if (Number.isFinite(dateMs)) maxDateMs = Math.max(maxDateMs, dateMs);
-	}
-	const seenGuids = /* @__PURE__ */ new Set();
-	const coalescedMessageGuids = [];
-	for (const payload of payloads) {
 		const guid = payload.guid?.trim();
-		if (!guid || seenGuids.has(guid)) continue;
-		seenGuids.add(guid);
-		coalescedMessageGuids.push(guid);
+		if (guid && !seenGuids.has(guid)) {
+			seenGuids.add(guid);
+			coalescedMessageGuids.push(guid);
+		}
+		if (!reply && (payload.thread_originator_guid != null || payload.reply_to_guid != null)) reply = payload;
+		if (!keepContent) continue;
+		const text = textLength <= MAX_COALESCED_TEXT_CHARS ? (payload.text ?? "").trim() : "";
+		if (text) {
+			const normalized = seenTexts.size > 0 ? text.toLowerCase() : void 0;
+			if (normalized === void 0 || !seenTexts.has(normalized)) {
+				const separatorLength = textParts.length > 0 ? 1 : 0;
+				const part = text.slice(0, 4001 - textLength - separatorLength);
+				textParts.push(part);
+				textLength += separatorLength + part.length;
+				if (textLength <= MAX_COALESCED_TEXT_CHARS) seenTexts.add(normalized ?? text.toLowerCase());
+			}
+		}
+		if (allAttachments.length < MAX_COALESCED_ATTACHMENTS) for (const attachment of payload.attachments ?? []) {
+			allAttachments.push(attachment);
+			if (allAttachments.length === MAX_COALESCED_ATTACHMENTS) break;
+		}
 	}
-	const reply = payloads.find((payload) => payload.thread_originator_guid != null || payload.reply_to_guid != null) ?? first;
+	let combinedText = textParts.join(" ");
+	if (textLength > MAX_COALESCED_TEXT_CHARS) combinedText = `${sliceUtf16Safe(combinedText, 0, MAX_COALESCED_TEXT_CHARS)}…[truncated]`;
+	reply ??= first;
 	return {
 		...first,
 		text: combinedText,
 		attachments: allAttachments.length > 0 ? allAttachments : null,
-		created_at: latestCreatedAt,
+		created_at: latestCreatedAt ?? first.created_at,
 		thread_originator_guid: reply.thread_originator_guid ?? null,
 		reply_to_guid: reply.reply_to_guid ?? null,
 		reply_to_text: reply.reply_to_text ?? null,
@@ -1140,10 +1185,10 @@ var DefaultSentMessageCache = class {
 		}
 		this.cleanup();
 	}
-	has(scope, lookup, options = false) {
+	async has(scope, lookup, options = false) {
 		this.cleanup();
 		const resolvedOptions = typeof options === "boolean" ? { skipIdShortCircuit: options } : options;
-		if (hasPersistedIMessageEcho({
+		if (await hasPersistedIMessageEcho({
 			scope,
 			text: lookup.text,
 			media: lookup.media,
@@ -1434,12 +1479,7 @@ function describeReplyContext(message) {
 }
 function resolveInboundEchoMessageIds(message) {
 	const values = [message.id != null ? String(message.id) : void 0, normalizeReplyField(message.guid)];
-	const ids = [];
-	for (const value of values) {
-		if (!value || ids.includes(value)) continue;
-		ids.push(value);
-	}
-	return ids;
+	return uniqueStrings(values.filter((value) => Boolean(value)));
 }
 function rememberIMessageSkippedFromMeForSelfChatDedupe(params) {
 	if (params.message.is_from_me !== true) return;
@@ -1467,14 +1507,14 @@ function rememberIMessageSkippedFromMeForSelfChatDedupe(params) {
 	});
 	else if (isAmbiguousSelfThread) params.selfChatCache?.remember(lookup);
 }
-function hasIMessageEchoMatch(params) {
+async function hasIMessageEchoMatch(params) {
 	const scopes = typeof params.scope === "string" ? [params.scope] : params.scope;
 	for (const scope of scopes) {
 		if (!scope) continue;
-		for (const messageId of params.messageIds) if (params.echoCache.has(scope, { messageId })) return true;
+		for (const messageId of params.messageIds) if (await params.echoCache.has(scope, { messageId })) return true;
 		const fallbackMessageId = params.messageIds[0];
 		if (!params.text && !params.media && !fallbackMessageId) continue;
-		if (params.echoCache.has(scope, {
+		if (await params.echoCache.has(scope, {
 			text: params.text,
 			media: params.media,
 			messageId: fallbackMessageId
@@ -1485,34 +1525,17 @@ function hasIMessageEchoMatch(params) {
 	}
 	return false;
 }
-function isKnownFromMeIMessageReactionTarget(params) {
-	const { messageId, accountId, chatId, chatGuid, chatIdentifier } = params;
+async function isKnownFromMeIMessageReactionTarget(params) {
+	const { accountId, chatId, chatGuid, chatIdentifier } = params;
 	const ctx = {
 		accountId,
 		chatId,
 		chatGuid,
 		chatIdentifier
 	};
-	if (params.isKnownFromMeMessageId) return params.isKnownFromMeMessageId(messageId, ctx);
-	return isKnownFromMeIMessageMessageId(messageId, ctx);
-}
-/**
-* Per-group `systemPrompt` resolution. Mirrors `resolveWhatsAppGroupSystemPrompt`
-* in `extensions/whatsapp/src/system-prompt.ts`:
-*
-* 1. If the matched per-`chat_id` entry exists AND defines `systemPrompt` (key
-*    is present, value is non-null), use it. Trim whitespace; if the trim
-*    leaves an empty string, return `undefined` and DO NOT fall through to the
-*    wildcard. This is how operators say "this specific group has no prompt"
-*    without inheriting from `groups["*"]`.
-* 2. Otherwise, return the wildcard `groups["*"].systemPrompt` (trimmed; empty
-*    after trim → `undefined`).
-*/
-function resolveIMessageGroupSystemPrompt(params) {
-	const specific = params.groupConfig;
-	if (specific != null && specific.systemPrompt != null) return specific.systemPrompt.trim() || void 0;
-	const wildcard = params.defaultConfig?.systemPrompt;
-	return wildcard != null ? wildcard.trim() || void 0 : void 0;
+	const isKnownFromMe = params.isKnownFromMeMessageId ?? isKnownFromMeIMessageMessageId;
+	for (const messageId of params.messageIds) if (await isKnownFromMe(messageId, ctx)) return true;
+	return false;
 }
 async function resolveIMessageInboundDecision(params) {
 	const sender = (params.message.sender ?? "").trim();
@@ -1581,7 +1604,7 @@ async function resolveIMessageInboundDecision(params) {
 				chatIdentifier,
 				sender
 			});
-			if (params.echoCache && (bodyText || inboundMessageId || mediaFacts.length > 0) && hasIMessageEchoMatch({
+			if (params.echoCache && (bodyText || inboundMessageId || mediaFacts.length > 0) && await hasIMessageEchoMatch({
 				echoCache: params.echoCache,
 				scope: echoScope,
 				text: bodyText || void 0,
@@ -1614,13 +1637,14 @@ async function resolveIMessageInboundDecision(params) {
 		sender,
 		chatId
 	});
-	const accessDecision = await createChannelIngressResolver({
+	const ingressResolver = getIMessageRuntime().channel.inbound.ingress.createResolver({
 		channelId: "imessage",
 		accountId: params.accountId,
 		identity: imessageIngressIdentity,
 		cfg: params.cfg,
 		readStoreAllowFrom: async () => params.storeAllowFrom
-	}).message({
+	});
+	const resolveChannelIngress = (contextBinding) => ingressResolver.message({
 		subject: {
 			stableId: sender,
 			aliases: {
@@ -1631,13 +1655,9 @@ async function resolveIMessageInboundDecision(params) {
 		},
 		conversation: {
 			kind: isGroup ? "group" : "direct",
-			id: isGroup ? String(chatId ?? chatGuid ?? chatIdentifier ?? "unknown") : normalizeIMessageHandle(sender)
+			id: chatId != null ? String(chatId) : sender
 		},
-		...reactionContext ? {} : { contextBinding: {
-			agentId: route.agentId,
-			sessionKey: route.sessionKey,
-			inboundEventKind: "user_request"
-		} },
+		contextBinding,
 		dmPolicy: normalizeDmPolicy(params.dmPolicy),
 		groupPolicy: normalizeGroupPolicy(params.groupPolicy),
 		policy: { groupAllowFromFallbackToAllowFrom: false },
@@ -1649,7 +1669,7 @@ async function resolveIMessageInboundDecision(params) {
 			directGroupAllowFrom: "effective"
 		}
 	});
-	const { commandAccess, senderAccess } = accessDecision;
+	const { commandAccess, senderAccess } = await resolveChannelIngress();
 	const effectiveGroupAllowFrom = senderAccess.effectiveGroupAllowFrom;
 	if (senderAccess.decision !== "allow") {
 		if (isGroup) {
@@ -1709,7 +1729,7 @@ async function resolveIMessageInboundDecision(params) {
 		};
 		const targetGuid = reactionContext.targetGuid;
 		const targetGuids = reactionContext.targetGuids ?? (targetGuid ? [targetGuid] : []);
-		const targetIsOwn = Boolean(targetGuid && (params.echoCache && hasIMessageEchoMatch({
+		const targetIsOwn = Boolean(targetGuid && (params.echoCache && await hasIMessageEchoMatch({
 			echoCache: params.echoCache,
 			scope: buildIMessageEchoScope({
 				accountId: params.accountId,
@@ -1720,14 +1740,14 @@ async function resolveIMessageInboundDecision(params) {
 				sender
 			}),
 			messageIds: targetGuids
-		}) || targetGuids.some((messageId) => isKnownFromMeIMessageReactionTarget({
-			messageId,
+		}) || await isKnownFromMeIMessageReactionTarget({
+			messageIds: targetGuids,
 			accountId: params.accountId,
 			chatId,
 			chatGuid,
 			chatIdentifier,
 			isKnownFromMeMessageId: params.isKnownFromMeMessageId
-		}))));
+		})));
 		if (notificationMode === "own" && !targetIsOwn) return {
 			kind: "drop",
 			reason: "reaction target not sent by agent"
@@ -1780,7 +1800,7 @@ async function resolveIMessageInboundDecision(params) {
 			chatIdentifier,
 			sender
 		});
-		if (hasIMessageEchoMatch({
+		if (await hasIMessageEchoMatch({
 			echoCache: params.echoCache,
 			scope: echoScope,
 			text: bodyText || void 0,
@@ -1894,7 +1914,7 @@ async function resolveIMessageInboundDecision(params) {
 	}
 	return {
 		kind: "dispatch",
-		channelIngress: accessDecision,
+		resolveChannelIngress,
 		isGroup,
 		chatId,
 		chatGuid,
@@ -1924,7 +1944,7 @@ async function buildIMessageInboundContext(params) {
 	const chatId = decision.chatId;
 	const chatTarget = decision.isGroup && chatId != null ? formatIMessageChatTarget(chatId) : void 0;
 	const messageGuid = normalizeReplyField(params.message.guid);
-	const messageSid = (messageGuid ? rememberIMessageReplyCache({
+	const messageSid = (messageGuid ? await rememberIMessageReplyCache({
 		accountId: decision.route.accountId,
 		messageId: messageGuid,
 		chatGuid: decision.chatGuid,
@@ -1985,9 +2005,15 @@ async function buildIMessageInboundContext(params) {
 		...entry,
 		url: entry.url ?? entry.path
 	})));
+	const channelIngress = await decision.resolveChannelIngress({
+		agentId: decision.route.agentId,
+		sessionKey: decision.route.sessionKey,
+		messageId: messageSid,
+		inboundEventKind: "user_request"
+	});
 	return {
-		ctxPayload: (params.buildContext ?? buildChannelInboundEventContext)({
-			channelIngress: decision.channelIngress,
+		ctxPayload: await (params.buildContext ?? buildChannelInboundEventContext)({
+			channelIngress,
 			channel: "imessage",
 			supplemental: {
 				quote: decision.replyContext ? {
@@ -2017,9 +2043,7 @@ async function buildIMessageInboundContext(params) {
 				label: conversationName
 			},
 			route: {
-				agentId: decision.route.agentId,
-				dmScope: decision.route.dmScope,
-				accountId: decision.route.accountId,
+				...decision.route,
 				routeSessionKey: decision.route.sessionKey
 			},
 			reply: { to: replyTarget },
@@ -2302,19 +2326,6 @@ async function assertAllowedCanonicalAttachmentPath(params) {
 		roots: canonicalRoots
 	})) throw new Error("attachment path resolves outside allowed roots");
 }
-async function readPinnedAttachmentBytes(handle, maxBytes) {
-	const chunks = [];
-	let totalBytes = 0;
-	while (totalBytes <= maxBytes) {
-		const remaining = maxBytes + 1 - totalBytes;
-		const chunk = Buffer.allocUnsafe(Math.min(65536, remaining));
-		const { bytesRead } = await handle.read(chunk, 0, chunk.length, null);
-		if (bytesRead === 0) return Buffer.concat(chunks, totalBytes);
-		chunks.push(chunk.subarray(0, bytesRead));
-		totalBytes += bytesRead;
-	}
-	throw new Error(`attachment exceeds ${Math.round(maxBytes / 1048576)}MB limit`);
-}
 async function readAttachmentBuffer(params) {
 	const opened = await (params.deps.openLocalFileSafely ?? openLocalFileSafely)({ filePath: params.attachmentPath });
 	try {
@@ -2323,7 +2334,10 @@ async function readAttachmentBuffer(params) {
 			canonicalPath: opened.realPath,
 			allowedRoots: params.allowedRoots
 		});
-		const buffer = await readPinnedAttachmentBytes(opened.handle, params.maxBytes);
+		const buffer = await readFileHandleBounded(opened.handle, params.maxBytes).catch((error) => {
+			if (error instanceof FsSafeError && error.code === "too-large") throw new Error(`attachment exceeds ${Math.round(params.maxBytes / 1048576)}MB limit`);
+			throw error;
+		});
 		if (isHeicAttachment(params.attachmentPath, params.mimeType)) try {
 			const convert = params.deps.convertHeicToJpeg;
 			return {
@@ -2471,25 +2485,21 @@ function renderIMessagePollBody(poll, sender, renderOptions) {
 //#region extensions/imessage/src/monitor/reaction-system-event.ts
 function enqueueIMessageReactionSystemEvent(params) {
 	const { decision, runtime } = params;
-	const queued = enqueueSystemEvent(decision.text, {
-		sessionKey: decision.route.sessionKey,
-		contextKey: decision.contextKey
-	});
+	const queued = enqueueRoutedSystemEvent(decision.text, decision.route, { contextKey: decision.contextKey });
 	runtime.log?.(`imessage: reaction system event ${queued ? "queued" : "deduped"} session=${decision.route.sessionKey} target=${decision.reaction.targetGuid ?? "unknown"} action=${decision.reaction.action} emoji=${decision.reaction.emoji}`);
 	params.logVerbose?.(`imessage: reaction event enqueued: ${decision.text}`);
 	return queued;
 }
 //#endregion
 //#region extensions/imessage/src/monitor/recovery-cursor.ts
-const IMESSAGE_RECOVERY_CURSOR_NAMESPACE = "imessage.recovery-cursor";
-const IMESSAGE_RECOVERY_CURSOR_MAX_ENTRIES = 64;
+const RECOVERY_CURSOR_STORE_OPTIONS = {
+	namespace: "imessage.recovery-cursor",
+	maxEntries: 64
+};
 const LEGACY_CATCHUP_CURSOR_NAMESPACE = "imessage.catchup-cursors";
 const LEGACY_CATCHUP_CURSOR_MAX_ENTRIES = 256;
 function openRecoveryCursorStore() {
-	return getIMessageRuntime().state.openSyncKeyedStore({
-		namespace: IMESSAGE_RECOVERY_CURSOR_NAMESPACE,
-		maxEntries: IMESSAGE_RECOVERY_CURSOR_MAX_ENTRIES
-	});
+	return getIMessageRuntime().state.openKeyedStore(RECOVERY_CURSOR_STORE_OPTIONS);
 }
 function normalizeLocalDbPath(dbPath) {
 	let resolved = dbPath.trim();
@@ -2521,67 +2531,105 @@ function resolveIMessageRecoveryCursorDbIdentity(params) {
 function recoveryCursorStoreKey(accountId, dbIdentity) {
 	return `${accountId}\u0000${dbIdentity}`;
 }
-function readRecoveryCursor(accountId, dbIdentity) {
+function decideRecoveryCursorUpdate(current, update) {
+	if (update.kind === "rewind") {
+		if (current?.lastRowid !== update.expectedRowid) return;
+	} else if (current && current.lastRowid >= update.rowid) return;
+	return { lastRowid: update.rowid };
+}
+async function applyRecoveryCursorUpdate(key, update) {
+	const state = getIMessageRuntime().state;
+	const store = state.openKeyedStore(RECOVERY_CURSOR_STORE_OPTIONS);
+	if (!store.observe || !store.compareAndApply) {
+		const legacy = state.openSyncKeyedStore(RECOVERY_CURSOR_STORE_OPTIONS);
+		if (!legacy.update) throw new Error("iMessage recovery cursor persistence requires atomic update support.");
+		let result;
+		legacy.update(key, (current) => {
+			const next = decideRecoveryCursorUpdate(current, update);
+			result = next ?? current;
+			return next;
+		});
+		return result;
+	}
+	const observe = store.observe.bind(store);
+	const compareAndApply = store.compareAndApply.bind(store);
+	let observation = await observe(key);
+	for (;;) {
+		const next = decideRecoveryCursorUpdate(observation.value, update);
+		if (!next) return observation.value;
+		const result = await compareAndApply(key, observation.comparison, {
+			operation: "update",
+			action: "set",
+			value: next
+		});
+		if (result.status !== "conflict") return next;
+		observation = result.current;
+	}
+}
+async function readRecoveryCursor(accountId, dbIdentity) {
 	try {
 		const store = openRecoveryCursorStore();
 		const key = recoveryCursorStoreKey(accountId, dbIdentity);
-		const value = store.lookup(key);
+		const value = await store.lookup(key);
 		if (value) return Number.isFinite(value.lastRowid) ? value.lastRowid : null;
-		const legacy = store.consume(accountId);
+		const legacy = await store.consume(accountId);
 		if (legacy && Number.isFinite(legacy.lastRowid)) {
-			store.register(key, { lastRowid: legacy.lastRowid });
-			return legacy.lastRowid;
+			await store.registerIfAbsent(key, { lastRowid: legacy.lastRowid });
+			const adopted = await store.lookup(key);
+			return adopted && Number.isFinite(adopted.lastRowid) ? adopted.lastRowid : null;
 		}
 		return null;
 	} catch {
 		return null;
 	}
 }
-function migrateLegacyCatchupCursor(accountId, dbIdentity) {
+async function migrateLegacyCatchupCursor(accountId, dbIdentity) {
 	try {
-		const legacy = getIMessageRuntime().state.openSyncKeyedStore({
+		const legacy = getIMessageRuntime().state.openKeyedStore({
 			namespace: LEGACY_CATCHUP_CURSOR_NAMESPACE,
 			maxEntries: LEGACY_CATCHUP_CURSOR_MAX_ENTRIES
 		});
 		const key = createHash("sha256").update(accountId, "utf8").digest("hex").slice(0, 32);
-		const value = legacy.consume(key);
+		const value = await legacy.consume(key);
 		const rowid = typeof value?.lastSeenRowid === "number" && Number.isFinite(value.lastSeenRowid) ? value.lastSeenRowid : null;
-		if (rowid !== null) advanceIMessageRecoveryCursor(accountId, dbIdentity, rowid);
+		if (rowid !== null) await advanceIMessageRecoveryCursor(accountId, dbIdentity, rowid);
 		return rowid;
 	} catch {
 		return null;
 	}
 }
-function reconcileRecoveryCursorToWatermark(accountId, dbIdentity, cursorRowid, watermarkRowid) {
+async function reconcileRecoveryCursorToWatermark(accountId, dbIdentity, cursorRowid, watermarkRowid) {
 	if (cursorRowid === null || watermarkRowid === null || cursorRowid <= watermarkRowid) return cursorRowid;
 	try {
-		openRecoveryCursorStore().register(recoveryCursorStoreKey(accountId, dbIdentity), { lastRowid: watermarkRowid });
+		return (await applyRecoveryCursorUpdate(recoveryCursorStoreKey(accountId, dbIdentity), {
+			kind: "rewind",
+			rowid: watermarkRowid,
+			expectedRowid: cursorRowid
+		}))?.lastRowid ?? watermarkRowid;
 	} catch {
 		return watermarkRowid;
 	}
-	return watermarkRowid;
 }
 /**
 * Last durably admitted rowid for this account on `dbIdentity`, or null when
 * none is recorded yet (including when the only stored cursor belongs to a
 * different database).
 */
-function loadIMessageRecoveryCursor(accountId, dbIdentity, options = {}) {
+async function loadIMessageRecoveryCursor(accountId, dbIdentity, options = {}) {
 	const watermarkRowid = typeof options.watermarkRowid === "number" && Number.isFinite(options.watermarkRowid) ? options.watermarkRowid : null;
-	const current = readRecoveryCursor(accountId, dbIdentity);
-	if (current !== null) return reconcileRecoveryCursorToWatermark(accountId, dbIdentity, current, watermarkRowid);
+	const current = await readRecoveryCursor(accountId, dbIdentity);
+	if (current !== null) return await reconcileRecoveryCursorToWatermark(accountId, dbIdentity, current, watermarkRowid);
 	if (options.migrateLegacyCatchup === false) return null;
-	return reconcileRecoveryCursorToWatermark(accountId, dbIdentity, migrateLegacyCatchupCursor(accountId, dbIdentity), watermarkRowid);
+	return await reconcileRecoveryCursorToWatermark(accountId, dbIdentity, await migrateLegacyCatchupCursor(accountId, dbIdentity), watermarkRowid);
 }
 /** Advance the cursor forward to `rowid` (monotonic per database; never rewinds). */
-function advanceIMessageRecoveryCursor(accountId, dbIdentity, rowid) {
+async function advanceIMessageRecoveryCursor(accountId, dbIdentity, rowid) {
 	if (!Number.isFinite(rowid)) return;
 	try {
-		const store = openRecoveryCursorStore();
-		const key = recoveryCursorStoreKey(accountId, dbIdentity);
-		const current = store.lookup(key);
-		if (current && current.lastRowid >= rowid) return;
-		store.register(key, { lastRowid: rowid });
+		await applyRecoveryCursorUpdate(recoveryCursorStoreKey(accountId, dbIdentity), {
+			kind: "advance",
+			rowid
+		});
 	} catch {}
 }
 //#endregion
@@ -2761,20 +2809,6 @@ function formatIMessageInboundMediaBody(params) {
 function resolveIMessageWatchSourceDbPath(params) {
 	return resolveIMessageChatDbLookupPath(params);
 }
-async function resolveIMessageStartupRowidWatermark(dbPath) {
-	let database;
-	try {
-		database = openNodeSqliteDatabase(dbPath, { readOnly: true });
-		const row = database.prepare("SELECT MAX(ROWID) AS maxRowid FROM message").get();
-		if (typeof row?.maxRowid === "number" && Number.isFinite(row.maxRowid)) return row.maxRowid;
-		return row?.maxRowid === null ? 0 : null;
-	} catch (err) {
-		logVerbose(`imessage: startup rowid watermark unavailable for db=${dbPath}: ${String(err)}`);
-		return null;
-	} finally {
-		database?.close();
-	}
-}
 const warnIfImsgUpgradeNeeded = (() => {
 	let fired = false;
 	return { fireOnce: (rpcMethods, runtime) => {
@@ -2841,7 +2875,7 @@ async function monitorIMessageProvider(opts = {}) {
 		capability: CHANNEL_APPROVAL_GATEWAY_RUNTIME_CONTEXT_CAPABILITY
 	});
 	const imessageCfg = accountInfo.config;
-	const historyLimit = Math.max(0, imessageCfg.historyLimit ?? cfg.messages?.groupChat?.historyLimit ?? DEFAULT_GROUP_HISTORY_LIMIT);
+	const historyLimit = resolvePromptHistoryLimit(imessageCfg.historyLimit ?? cfg.messages?.groupChat?.historyLimit);
 	const groupHistories = /* @__PURE__ */ new Map();
 	const sentMessageCache = createSentMessageCache();
 	const selfChatCache = createSelfChatCache();
@@ -2905,7 +2939,7 @@ async function monitorIMessageProvider(opts = {}) {
 		dbPath,
 		remoteHost
 	});
-	const recoveryCursorRowid = loadIMessageRecoveryCursor(accountInfo.accountId, recoveryCursorDbIdentity, {
+	const recoveryCursorRowid = await loadIMessageRecoveryCursor(accountInfo.accountId, recoveryCursorDbIdentity, {
 		migrateLegacyCatchup: !catchupCfg.enabled,
 		watermarkRowid: recoveryBoundaryRowid
 	});
@@ -2919,7 +2953,7 @@ async function monitorIMessageProvider(opts = {}) {
 		for (const value of values) min = min === null ? value : Math.min(min, value);
 		return min;
 	}
-	function advanceRecoveryCursorAfterDurableEnqueue(rowid) {
+	async function advanceRecoveryCursorAfterDurableEnqueue(rowid) {
 		if (catchupCfg.enabled) return;
 		failedRecoveryCursorRowids.delete(rowid);
 		durableRecoveryCursorRowids.add(rowid);
@@ -2927,7 +2961,7 @@ async function monitorIMessageProvider(opts = {}) {
 		const holdFloor = minSetValue(failedRecoveryCursorRowids);
 		const nextCursorRowid = holdFloor !== null && maxDurableRowid >= holdFloor ? holdFloor - 1 : maxDurableRowid;
 		if (nextCursorRowid >= 0 && nextCursorRowid > latestAdvancedRecoveryCursorRowid) {
-			advanceIMessageRecoveryCursor(accountInfo.accountId, recoveryCursorDbIdentity, nextCursorRowid);
+			await advanceIMessageRecoveryCursor(accountInfo.accountId, recoveryCursorDbIdentity, nextCursorRowid);
 			latestAdvancedRecoveryCursorRowid = nextCursorRowid;
 			for (const durableRowid of durableRecoveryCursorRowids) if (durableRowid <= nextCursorRowid) durableRecoveryCursorRowids.delete(durableRowid);
 		}
@@ -3190,10 +3224,10 @@ async function monitorIMessageProvider(opts = {}) {
 			}
 		}
 		const storePath = resolveStorePath(cfg.session?.store, { agentId: decision.route.agentId });
-		const privateApiStatus = getCachedIMessagePrivateApiStatus(cliPath);
+		const privateApiStatus = await probeIMessagePrivateApi(cliPath, probeTimeoutMs);
 		const supportsTyping = imessageRpcSupportsMethod(privateApiStatus, "typing");
 		const supportsRead = imessageRpcSupportsMethod(privateApiStatus, "read");
-		if (privateApiStatus?.available === true) {
+		if (privateApiStatus.available) {
 			if (!supportsTyping || !supportsRead) warnIfImsgUpgradeNeeded.fireOnce(privateApiStatus.rpcMethods, runtime);
 		}
 		const configuredTypingMode = resolveConfiguredIMessageTypingMode(cfg, decision.route.agentId);
@@ -3566,7 +3600,7 @@ async function monitorIMessageProvider(opts = {}) {
 			return { kind: "deferred" };
 		},
 		onDurableEnqueue: async (facts) => {
-			advanceRecoveryCursorAfterDurableEnqueue(facts.rowid);
+			await advanceRecoveryCursorAfterDurableEnqueue(facts.rowid);
 			await maybeAdvanceLiveCatchupCursor({
 				id: facts.rowid,
 				created_at: facts.createdAt