@openclaw/imessage 2026.9.4 → 2026.9.5

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

@@ -1,20 +1,21 @@
-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-Dv0uksBG.mjs";
+import { r as imessageRpcSupportsMethod } from "./message-tool-api-DZSH-2gY.mjs";
+import { b as resolveIMessageDirectChatService, d as isKnownFromMeIMessageMessageId, f as rememberIMessageReplyCache, o as createIMessageRpcClient, r as sanitizeOutboundText } from "./sanitize-outbound-o1ePXajW.mjs";
+import { d as probeIMessagePrivateApi, r as resolveIMessageInboundConversationId, u as probeIMessage } from "./group-policy-BoOAkmoQ.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-BpPh5Oh1.mjs";
+import { i as registerIMessageApprovalReactionTarget, n as handleIMessageApprovalReaction, o as listPendingIMessageApprovalReactionPollTargets, r as maybeResolveIMessageApprovalReaction, s as buildIMessageApprovalConversationKeyForInbound } from "./approval-reactions-CX1-6KeG.mjs";
+import { c as iMessageApprovalControlBindings, n as hasPersistedIMessageEcho, r as stripLeadingEchoTextCorruptionMarkers, s as maybeResolveIMessageApprovalPollVote, t as sendMessageIMessage } from "./send-DXiUWygv.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";
@@ -37,7 +38,7 @@ 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";
@@ -46,16 +47,18 @@ import { resolveMarkdownTableMode as resolveMarkdownTableMode$1 } from "openclaw
 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 { 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";
 //#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 +92,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 +132,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 +147,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 +172,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 +273,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 +306,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 +374,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 +630,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 +674,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 +686,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 +793,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 +807,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 +1186,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,
@@ -1467,14 +1513,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,16 +1531,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);
+	const isKnownFromMe = params.isKnownFromMeMessageId ?? isKnownFromMeIMessageMessageId;
+	for (const messageId of params.messageIds) if (await isKnownFromMe(messageId, ctx)) return true;
+	return false;
 }
 /**
 * Per-group `systemPrompt` resolution. Mirrors `resolveWhatsAppGroupSystemPrompt`
@@ -1581,7 +1628,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,
@@ -1709,7 +1756,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 +1767,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 +1827,7 @@ async function resolveIMessageInboundDecision(params) {
 			chatIdentifier,
 			sender
 		});
-		if (hasIMessageEchoMatch({
+		if (await hasIMessageEchoMatch({
 			echoCache: params.echoCache,
 			scope: echoScope,
 			text: bodyText || void 0,
@@ -1924,7 +1971,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,
@@ -2302,19 +2349,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 +2357,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 {
@@ -2481,15 +2518,14 @@ function enqueueIMessageReactionSystemEvent(params) {
 }
 //#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 +2557,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
@@ -2905,7 +2979,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 +2993,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 +3001,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 +3264,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 +3640,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