@openclaw/imessage 2026.9.7 → 2026.10.1-beta.1

package/dist/.setup/{monitor-fv9nRuTH.mjs → channel.runtime-DY7JJ0_9.mjs}

@@ -1,24 +1,30 @@
 import { c as parseIMessageTarget, o as normalizeIMessageHandle, r as isAllowedIMessageReplyContextSender, s as parseIMessageAllowTarget, t as formatIMessageChatTarget } from "./targets-BicBiYsM.mjs";
-import { d as resolveIMessageChatDbLookupPath, f as resolveIMessageHomeDir, l as resolveIMessageRemoteHost, o as resolveIMessageAccount } from "./accounts-nzcU0cq2.mjs";
-import { r as imessageRpcSupportsMethod } from "./message-tool-api-D032l82H.mjs";
-import { D as resolveIMessageDirectChatService, b as resolveIMessageEchoMediaKey, d as isKnownFromMeIMessageTarget, f as rememberIMessageReplyCache, h as IMESSAGE_CATCHUP_CURSOR_NAMESPACE, o as createIMessageRpcClient, r as sanitizeOutboundText, v as capFailureRetriesMap, y as resolveIMessageCatchupCursorKey } from "./sanitize-outbound-3MLljgtY.mjs";
-import { d as probeIMessage, f as probeIMessagePrivateApi, i as resolveIMessageInboundConversationId, n as resolveIMessageGroupSystemPrompt } from "./group-policy-90pw4tyG.mjs";
+import { d as resolveIMessageChatDbLookupPath, f as resolveIMessageHomeDir, l as resolveIMessageRemoteHost, o as resolveIMessageAccount, r as listEnabledIMessageAccounts, s as resolveIMessageDuplicateSourceOwner } from "./accounts-evTpvJMv.mjs";
+import { r as imessageRpcSupportsMethod } from "./message-tool-api-CqfRxLlT.mjs";
+import { C as resolveIMessageDirectChatService, c as rememberIMessageReplyCache, d as IMESSAGE_CATCHUP_CURSOR_NAMESPACE, g as resolveIMessageEchoMediaKey, h as resolveIMessageCatchupCursorKey, m as capFailureRetriesMap, n as createIMessageRpcClient, s as isKnownFromMeIMessageTarget } from "./client-12apu4Ip.mjs";
+import { a as normalizeIMessageMessageId, i as normalizeIMessageGuid, n as probeIMessage, r as probeIMessagePrivateApi } from "./actions-DJqbUmbN.mjs";
 import { t as getIMessageRuntime } from "./runtime-Cza4CY5T.mjs";
-import { n as resolveIMessageAttachmentRoots, r as resolveIMessageRemoteAttachmentRoots } from "./media-contract-CagwSMvo.mjs";
-import { i as registerIMessageApprovalReactionTarget, n as handleIMessageApprovalReaction, o as listPendingIMessageApprovalReactionPollTargets, r as maybeResolveIMessageApprovalReaction, s as buildIMessageApprovalConversationKeyForInbound } from "./approval-reactions-Bp33xc83.mjs";
-import { c as iMessageApprovalControlBindings, n as hasPersistedIMessageEcho, r as normalizeIMessageEchoText, s as maybeResolveIMessageApprovalPollVote, t as sendMessageIMessage } from "./send-Cu9nl757.mjs";
-import { n as normalizeIMessageGuid, t as resolveIMessageReactionContext } from "./reaction-context-Br-vAJFp.mjs";
-import { i as resolveIMessageStartupRowidWatermark } from "./remote-file-DRPCaVmg.mjs";
-import { n as maybeResolveIMessageQuestionReaction, t as hasIMessageQuestionReactionTarget } from "./question-reactions-Cy-dmU_j.mjs";
+import { a as resolveIMessageGroupSystemPrompt, s as resolveIMessageInboundConversationId } from "./channel-CL73qdMG.mjs";
+import { r as sanitizeOutboundText } from "./sanitize-outbound-C0x4BPky.mjs";
+import { n as resolveIMessageAttachmentRoots, r as resolveIMessageRemoteAttachmentRoots } from "./media-contract-DjQGZlfl.mjs";
+import { t as IMESSAGE_LEGACY_OUTBOUND_SEND_DEP_KEYS } from "./outbound-send-deps-B-QEsLSM.mjs";
+import { i as resolveIMessageStartupRowidWatermark } from "./remote-file-BU7pA-Zi.mjs";
+import { i as registerIMessageApprovalReactionTarget, n as handleIMessageApprovalReaction, o as listPendingIMessageApprovalReactionPollTargets, r as maybeResolveIMessageApprovalReaction, s as buildIMessageApprovalConversationKeyForInbound } from "./approval-reactions-L9Ul7PAu.mjs";
+import { c as iMessageApprovalControlBindings, n as hasPersistedIMessageEcho, r as normalizeIMessageEchoText, s as maybeResolveIMessageApprovalPollVote, t as sendMessageIMessage } from "./send-pkYwL6Rt.mjs";
+import { t as resolveIMessageReactionContext } from "./reaction-context-By7kUMBC.mjs";
+import { n as maybeResolveIMessageQuestionReaction, t as hasIMessageQuestionReactionTarget } from "./question-reactions-DJV-TnA8.mjs";
+import { imessageSetupWizard } from "./setup-surface-zKhIinwY.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 { normalizeChannelDmPolicy } from "openclaw/plugin-sdk/channel-config-helpers";
+import { bindIngressLifecycleToReplyOptions, createAccountStatusSink, createChannelIngressError, createChannelIngressMonitor, createChannelMessageReplyPipeline, resolveChannelStreamingBlockEnabled, resolveOutboundSendDep } from "openclaw/plugin-sdk/channel-outbound";
 import { resolveTextChunkLimit } from "openclaw/plugin-sdk/reply-runtime";
 import { resolveAgentRoute, resolveInboundLastRouteSessionKey } from "openclaw/plugin-sdk/routing";
 import path from "node:path";
+import { resolveChannelMediaMaxBytes } from "openclaw/plugin-sdk/account-helpers";
 import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";
 import fs from "node:fs/promises";
 import { isInboundPathAllowed, kindFromMime } from "openclaw/plugin-sdk/media-runtime";
-import { createNonExitingRuntime, danger, logVerbose, shouldLogVerbose, warn } from "openclaw/plugin-sdk/runtime-env";
+import { createNonExitingRuntime, danger, logVerbose, shouldLogVerbose, sleepWithAbort, waitForAbortSignal, 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";
@@ -27,8 +33,12 @@ import { collectErrorGraphCandidates, formatErrorMessage } from "openclaw/plugin
 import { resolveChannelGroupPolicy, resolveChannelGroups, resolveChannelGroupsConfigPath, resolveScopeRequireMention } from "openclaw/plugin-sdk/channel-policy";
 import { convertMarkdownTables, findCodeRegions, isInsideCode, sanitizeTerminalText } from "openclaw/plugin-sdk/text-chunking";
 import { buildChannelInboundEventContext, buildMentionRegexes, createAcceptedChannelDeliveryResult, createChannelInboundDebouncer, createChannelPartialDeliveryError, filterChannelInboundQuoteContext, formatInboundEnvelope, formatInboundFromLabel, formatInboundMediaUnavailableText, formatMediaPlaceholderText, isChannelPartialDeliveryError, logInboundDrop, matchesMentionPatterns, resolveEnvelopeFormatOptions, resolveInboundDebounceMs, resolveInboundMentionDecision, resolveInboundSupplementalSenderAllowed, runChannelInboundEvent, shouldDebounceTextInbound, toInboundMediaFactsWithMetadata } from "openclaw/plugin-sdk/channel-inbound";
-import { resolveAgentConfig, resolveHumanDelayConfig } from "openclaw/plugin-sdk/agent-runtime";
+import { FsSafeError, openLocalFileSafely, resolvePinnedMainDmOwnerFromAllowlist } from "openclaw/plugin-sdk/security-runtime";
+import { resolvePreferredOpenClawTmpDir, withTempWorkspace } from "openclaw/plugin-sdk/temp-path";
 import { CHANNEL_APPROVAL_NATIVE_RUNTIME_CONTEXT_CAPABILITY } from "openclaw/plugin-sdk/approval-handler-runtime";
+import { resolveMarkdownTableMode } from "openclaw/plugin-sdk/markdown-table-runtime";
+import { requireRuntimeConfig } from "openclaw/plugin-sdk/plugin-config-runtime";
+import { resolveAgentConfig, resolveHumanDelayConfig } from "openclaw/plugin-sdk/agent-runtime";
 import { logTypingFailure } from "openclaw/plugin-sdk/channel-feedback";
 import { defineStableChannelIngressIdentity, fanInChannelIngressLifecycles } from "openclaw/plugin-sdk/channel-ingress-runtime";
 import { createChannelPairingChallengeIssuer } from "openclaw/plugin-sdk/channel-pairing";
@@ -37,12 +47,8 @@ import { ensureConfiguredBindingRouteReady, readChannelAllowFromStore, upsertCha
 import { channelReadyPatch } from "openclaw/plugin-sdk/gateway-runtime";
 import { redactIdentifier } from "openclaw/plugin-sdk/logging-core";
 import { resolveDefaultGroupPolicy, resolveOpenProviderRuntimeGroupPolicy, warnMissingProviderGroupPolicyFallbackOnce } from "openclaw/plugin-sdk/runtime-group-policy";
-import { FsSafeError, openLocalFileSafely, resolvePinnedMainDmOwnerFromAllowlist } from "openclaw/plugin-sdk/security-runtime";
 import { getSessionEntry, readSessionUpdatedAt, resolveSendPolicy, resolveStorePath } from "openclaw/plugin-sdk/session-store-runtime";
 import { waitForTransportReady } from "openclaw/plugin-sdk/transport-ready-runtime";
-import { requireRuntimeConfig } from "openclaw/plugin-sdk/plugin-config-runtime";
-import { resolveMarkdownTableMode } 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 { chunkMarkdownTextWithMode, resolveChunkMode } from "openclaw/plugin-sdk/reply-chunking";
 import { deliverTextOrMediaReply, resolveSendableOutboundReplyParts } from "openclaw/plugin-sdk/reply-payload";
@@ -148,12 +154,12 @@ async function bindObservedConversation(params) {
 }
 async function pollPendingIMessageApprovalReactions(params) {
 	const targets = await listPendingIMessageApprovalReactionPollTargets({ accountId: params.accountId });
-	if (targets.length === 0) return;
+	if (params.signal?.aborted || targets.length === 0) return;
 	const pendingByMessageId = buildPendingTargetsByMessageId(targets);
 	const explicitChatIds = listTargetChatIds(targets);
 	const chatIds = params.allowRecentChatDiscovery === true && hasUnscopedTarget(targets) ? [.../* @__PURE__ */ new Set([...explicitChatIds, ...await listRecentChatIds(params.client)])] : explicitChatIds;
-	if (chatIds.length === 0) return;
 	for (const chatId of chatIds) {
+		if (params.signal?.aborted) return;
 		let messages;
 		try {
 			messages = await fetchRecentHistory({
@@ -165,6 +171,7 @@ async function pollPendingIMessageApprovalReactions(params) {
 			continue;
 		}
 		for (const message of messages) {
+			if (params.signal?.aborted) return;
 			const targetGuid = message.guid?.trim();
 			if (!targetGuid) continue;
 			const target = pendingByMessageId.get(targetGuid) ?? pendingByMessageId.get(normalizeIMessageGuid(targetGuid));
@@ -174,6 +181,7 @@ async function pollPendingIMessageApprovalReactions(params) {
 				message
 			});
 			for (const reaction of message.reactions ?? []) {
+				if (params.signal?.aborted) return;
 				const reactionPayload = buildReactionPayload({
 					targetMessage: message,
 					reaction
@@ -607,21 +615,7 @@ function parseIMessageNotification(raw) {
 const PER_CHAT_HISTORY_LIMIT = 500;
 const CATCHUP_CHATS_LIST_LIMIT = 200;
 const CATCHUP_RPC_TIMEOUT_MS = 3e4;
-/**
-* Wire `performIMessageCatchup` against the live `imsg` JSON-RPC client.
-*
-* Catchup recovers messages that landed in `chat.db` while the gateway was
-* offline (crash, restart, mac sleep) by:
-*   1. listing recently-active chats via `chats.list`,
-*   2. fetching per-chat history since the cursor via `messages.history`,
-*   3. sorting cross-chat by `rowid`, capping at `perRunLimit`,
-*   4. admitting each row through the same durable GUID queue used by live
-*      notifications, so replay, coalescing, echo, and receipt behavior match.
-*
-* Runs at most once per `monitorIMessageProvider` invocation, between
-* `watch.subscribe` and the live dispatch loop. Anything that arrives during
-* catchup itself flows through live admission; queue tombstones reject overlap.
-*/
+/** Replay oldest-first through durable admission; tombstones reject live/watch overlap. */
 async function runIMessageCatchup(params) {
 	const { client, accountId, config, includeAttachments, dispatchPayload, runtime } = params;
 	const log = (msg) => runtime?.log?.(msg);
@@ -699,22 +693,13 @@ async function runIMessageCatchup(params) {
 		const sorted = collected.toSorted((a, b) => a.rowid - b.rowid);
 		const capped = sorted.slice(0, limit);
 		const isCapTruncated = capped.length < sorted.length;
-		if (isCapTruncated) {
-			warnLog(`imessage catchup: fetched ${sorted.length} rows across chats, capped to perRunLimit=${limit} (oldest first); next startup picks up the rest`);
-			const keep = new Set(capped.map((row) => row.guid));
-			for (const guid of payloadByGuid.keys()) if (!keep.has(guid)) payloadByGuid.delete(guid);
-		}
+		if (isCapTruncated) warnLog(`imessage catchup: fetched ${sorted.length} rows across chats, capped to perRunLimit=${limit} (oldest first); next startup picks up the rest`);
 		let effectiveWatermarkRowid = rawWatermarkRowid;
 		let effectiveWatermarkMs = rawWatermarkMs;
-		if (isCapTruncated && capped.length > 0) {
+		if (isCapTruncated) {
 			const last = capped.at(-1);
-			if (last) {
-				effectiveWatermarkRowid = Math.min(effectiveWatermarkRowid, last.rowid);
-				effectiveWatermarkMs = Math.min(effectiveWatermarkMs, last.date);
-			}
-		} else if (isCapTruncated && capped.length === 0) {
-			effectiveWatermarkRowid = NaN;
-			effectiveWatermarkMs = NaN;
+			effectiveWatermarkRowid = last ? Math.min(rawWatermarkRowid, last.rowid) : NaN;
+			effectiveWatermarkMs = last ? Math.min(rawWatermarkMs, last.date) : NaN;
 		}
 		return {
 			resolved: true,
@@ -828,7 +813,7 @@ function hasUsableConversationAnchor(projection) {
 	return hasPositiveChatId(projection.chat_id) || hasNonEmptyString(projection.chat_guid) || hasNonEmptyString(projection.chat_identifier);
 }
 function isIMessageAnchorless(message) {
-	if (hasPositiveChatId(message.chat_id) || hasNonEmptyString(message.chat_guid) || hasNonEmptyString(message.chat_identifier)) return false;
+	if (hasUsableConversationAnchor(message)) return false;
 	return message.chat_id === null || typeof message.chat_id === "number" && (!Number.isFinite(message.chat_id) || message.chat_id <= 0) || isExplicitEmptyString(message.chat_guid) || isExplicitEmptyString(message.chat_identifier);
 }
 function extractAuthoritativeRecoveryProjection(entry) {
@@ -1085,12 +1070,6 @@ function createIMessageThrottledDropDiagnosticCache() {
 //#region extensions/imessage/src/monitor/echo-cache.ts
 const SENT_MESSAGE_TEXT_TTL_MS = 4e3;
 const SENT_MESSAGE_ID_TTL_MS = 6e4;
-function normalizeEchoMessageIdKey(messageId) {
-	if (!messageId) return null;
-	const normalized = messageId.trim();
-	if (!normalized || normalized === "ok" || normalized === "unknown") return null;
-	return normalized;
-}
 var DefaultSentMessageCache = class {
 	constructor() {
 		this.textCache = /* @__PURE__ */ new Map();
@@ -1104,7 +1083,7 @@ var DefaultSentMessageCache = class {
 		if (textKey) this.textCache.set(`${scope}:${textKey}`, Date.now());
 		const mediaKey = resolveIMessageEchoMediaKey(lookup.media);
 		if (mediaKey) this.mediaCache.set(`${scope}:${mediaKey}`, Date.now());
-		const messageIdKey = normalizeEchoMessageIdKey(lookup.messageId);
+		const messageIdKey = normalizeIMessageMessageId(lookup.messageId);
 		if (messageIdKey) {
 			this.messageIdCache.set(`${scope}:${messageIdKey}`, Date.now());
 			if (textKey) this.textBackedByIdCache.set(`${scope}:${textKey}`, Date.now());
@@ -1125,7 +1104,7 @@ var DefaultSentMessageCache = class {
 		})) return true;
 		const textKey = normalizeIMessageEchoText(lookup.text);
 		const mediaKey = resolveIMessageEchoMediaKey(lookup.media);
-		const messageIdKey = normalizeEchoMessageIdKey(lookup.messageId);
+		const messageIdKey = normalizeIMessageMessageId(lookup.messageId);
 		let canUseMediaFallback = !messageIdKey;
 		if (messageIdKey) {
 			const idTimestamp = this.messageIdCache.get(`${scope}:${messageIdKey}`);
@@ -1450,18 +1429,11 @@ function normalizeIMessageChatIdentifierEntry(entry) {
 	const parsed = parseIMessageAllowTarget(entry.trim());
 	return parsed.kind === "chat_identifier" ? parsed.chatIdentifier.trim() || null : null;
 }
-function normalizeDmPolicy(policy) {
-	return policy === "open" || policy === "allowlist" || policy === "disabled" ? policy : "pairing";
-}
 function normalizeGroupPolicy(policy) {
 	return policy === "open" || policy === "disabled" ? policy : "allowlist";
 }
 function normalizeReplyField(value) {
-	if (typeof value === "string") {
-		const trimmed = value.trim();
-		return trimmed ? trimmed : void 0;
-	}
-	if (typeof value === "number") return String(value);
+	return typeof value === "number" ? String(value) : normalizeOptionalString(value);
 }
 function describeReplyContext(message) {
 	const body = normalizeReplyField(message.reply_to_text);
@@ -1573,6 +1545,14 @@ async function resolveIMessageInboundDecision(params) {
 	const inboundMessageIds = resolveInboundEchoMessageIds(params.message);
 	const inboundMessageId = inboundMessageIds[0];
 	const hasInboundGuid = Boolean(normalizeReplyField(params.message.guid));
+	const echoScope = buildIMessageEchoScope({
+		accountId: params.accountId,
+		isGroup,
+		chatId,
+		chatGuid,
+		chatIdentifier,
+		sender
+	});
 	if (params.message.is_from_me) {
 		if (isAmbiguousSelfThread) params.selfChatCache?.remember(selfChatLookup);
 		if (isSelfChat) {
@@ -1580,14 +1560,6 @@ async function resolveIMessageInboundDecision(params) {
 				...selfChatLookup,
 				allowCreatedAtSkew: true
 			});
-			const echoScope = buildIMessageEchoScope({
-				accountId: params.accountId,
-				isGroup,
-				chatId,
-				chatGuid,
-				chatIdentifier,
-				sender
-			});
 			if (params.echoCache && (bodyText || inboundMessageId || mediaFacts.length > 0) && await hasIMessageEchoMatch({
 				echoCache: params.echoCache,
 				scope: echoScope,
@@ -1642,7 +1614,7 @@ async function resolveIMessageInboundDecision(params) {
 			id: chatId != null ? String(chatId) : sender
 		},
 		contextBinding,
-		dmPolicy: normalizeDmPolicy(params.dmPolicy),
+		dmPolicy: normalizeChannelDmPolicy(params.dmPolicy) ?? "pairing",
 		groupPolicy: normalizeGroupPolicy(params.groupPolicy),
 		policy: { groupAllowFromFallbackToAllowFrom: false },
 		allowFrom: params.allowFrom,
@@ -1715,14 +1687,7 @@ async function resolveIMessageInboundDecision(params) {
 		const targetGuids = reactionContext.targetGuids ?? (targetGuid ? [targetGuid] : []);
 		const targetIsOwn = Boolean(targetGuid && (params.echoCache && await hasIMessageEchoMatch({
 			echoCache: params.echoCache,
-			scope: buildIMessageEchoScope({
-				accountId: params.accountId,
-				isGroup,
-				chatId,
-				chatGuid,
-				chatIdentifier,
-				sender
-			}),
+			scope: echoScope,
 			messageIds: targetGuids
 		}) || await isKnownFromMeIMessageTarget({
 			messageIds: targetGuids,
@@ -1776,14 +1741,6 @@ async function resolveIMessageInboundDecision(params) {
 		};
 	}
 	if (params.echoCache && (messageText || inboundMessageId || mediaFacts.length > 0)) {
-		const echoScope = buildIMessageEchoScope({
-			accountId: params.accountId,
-			isGroup,
-			chatId,
-			chatGuid,
-			chatIdentifier,
-			sender
-		});
 		if (await hasIMessageEchoMatch({
 			echoCache: params.echoCache,
 			scope: echoScope,
@@ -1816,7 +1773,7 @@ async function resolveIMessageInboundDecision(params) {
 		channel: "imessage",
 		accountId: params.accountId
 	});
-	const replyContextAllowFrom = Array.from(/* @__PURE__ */ new Set([...groupAllowFromForAccess, ...effectiveGroupAllowFrom]));
+	const replyContextAllowFrom = uniqueStrings([...groupAllowFromForAccess, ...effectiveGroupAllowFrom]);
 	const replySenderAllowed = resolveInboundSupplementalSenderAllowed({
 		isGroup,
 		groupPolicy: replyContextAllowFrom.length === 0 ? "open" : "allowlist",
@@ -2247,29 +2204,29 @@ function createLoopRateLimiter(opts) {
 		const now = Date.now();
 		if (now - lastCleanup < CLEANUP_INTERVAL_MS) return;
 		lastCleanup = now;
-		for (const [key, win] of conversations.entries()) {
-			const recent = win.timestamps.filter((ts) => now - ts <= windowMs);
+		for (const [key, timestamps] of conversations.entries()) {
+			const recent = timestamps.filter((ts) => now - ts <= windowMs);
 			if (recent.length === 0) conversations.delete(key);
-			else win.timestamps = recent;
+			else conversations.set(key, recent);
 		}
 	}
 	return {
 		record(conversationKey) {
 			cleanup();
-			let win = conversations.get(conversationKey);
-			if (!win) {
-				win = { timestamps: [] };
-				conversations.set(conversationKey, win);
+			let timestamps = conversations.get(conversationKey);
+			if (!timestamps) {
+				timestamps = [];
+				conversations.set(conversationKey, timestamps);
 			}
-			win.timestamps.push(Date.now());
+			timestamps.push(Date.now());
 		},
 		isRateLimited(conversationKey) {
 			cleanup();
-			const win = conversations.get(conversationKey);
-			if (!win) return false;
+			const timestamps = conversations.get(conversationKey);
+			if (!timestamps) return false;
 			const now = Date.now();
-			const recent = win.timestamps.filter((ts) => now - ts <= windowMs);
-			win.timestamps = recent;
+			const recent = timestamps.filter((ts) => now - ts <= windowMs);
+			conversations.set(conversationKey, recent);
 			return recent.length >= maxHits;
 		}
 	};
@@ -2640,9 +2597,7 @@ function buildScope(parts) {
 var DefaultSelfChatCache = class {
 	constructor() {
 		this.cache = /* @__PURE__ */ new Map();
-		this.insertionOrder = [];
-		this.insertionOrderOffset = 0;
-		this.entryCount = 0;
+		this.insertionOrder = /* @__PURE__ */ new Map();
 		this.lastCleanupAt = 0;
 		this.nextEntryId = 1;
 	}
@@ -2656,19 +2611,14 @@ var DefaultSelfChatCache = class {
 		if (!key || !isUsableTimestamp(lookup.createdAt)) return;
 		const entries = this.cache.get(key) ?? /* @__PURE__ */ new Map();
 		const entry = {
-			id: this.nextEntryId,
 			createdAt: lookup.createdAt,
 			createdAtSkewToleranceMs: lookup.allowCreatedAtSkew ? SELF_CHAT_CREATED_AT_TOLERANCE_MS : 0,
 			rememberedAt: Date.now()
 		};
-		this.nextEntryId += 1;
-		entries.set(entry.id, entry);
+		const id = this.nextEntryId++;
+		entries.set(id, entry);
 		this.cache.set(key, entries);
-		this.insertionOrder.push({
-			key,
-			id: entry.id
-		});
-		this.entryCount += 1;
+		this.insertionOrder.set(id, key);
 		this.maybeCleanup();
 	}
 	has(lookup) {
@@ -2691,25 +2641,18 @@ var DefaultSelfChatCache = class {
 		for (const [key, entries] of this.cache.entries()) {
 			for (const [id, entry] of entries.entries()) if (now - entry.rememberedAt > SELF_CHAT_TTL_MS) {
 				entries.delete(id);
-				this.entryCount -= 1;
+				this.insertionOrder.delete(id);
 			}
 			if (entries.size === 0) this.cache.delete(key);
 		}
-		while (this.entryCount > MAX_SELF_CHAT_CACHE_ENTRIES && this.insertionOrderOffset < this.insertionOrder.length) {
-			const oldest = expectDefined(this.insertionOrder[this.insertionOrderOffset], "oldest iMessage self-chat cache entry");
-			this.insertionOrderOffset += 1;
-			const entries = this.cache.get(oldest.key);
+		while (this.insertionOrder.size > MAX_SELF_CHAT_CACHE_ENTRIES) {
+			const [id, key] = expectDefined(this.insertionOrder.entries().next().value, "oldest iMessage self-chat cache entry");
+			this.insertionOrder.delete(id);
+			const entries = this.cache.get(key);
 			if (!entries) continue;
-			if (!entries.delete(oldest.id)) continue;
-			this.entryCount -= 1;
-			if (entries.size === 0) this.cache.delete(oldest.key);
+			entries.delete(id);
+			if (entries.size === 0) this.cache.delete(key);
 		}
-		this.compactInsertionOrder();
-	}
-	compactInsertionOrder() {
-		if (this.insertionOrderOffset <= 1024 && this.insertionOrder.length <= this.entryCount + 1024) return;
-		this.insertionOrder = this.insertionOrder.slice(this.insertionOrderOffset).filter((entry) => this.cache.get(entry.key)?.has(entry.id));
-		this.insertionOrderOffset = 0;
 	}
 };
 function createSelfChatCache() {
@@ -2815,22 +2758,8 @@ function describeIMessageWatchSubscribeStartupFailure(params) {
 	const retry = params.retryDelayMs !== void 0 ? ` retry_in_ms=${params.retryDelayMs}` : "";
 	return `imessage: watch.subscribe startup failed attempt=${params.attempt}/${params.maxAttempts} account=${params.accountId} cliPath=${params.cliPath} dbPath=${params.dbPath ? "configured" : "default"} remoteHost=${params.remoteHost ? "configured" : "none"} timeoutMs=${params.probeTimeoutMs} since_rowid=${params.watchSinceRowid ?? "none"} attachments=${params.includeAttachments} include_reactions=true${retry}: ${String(params.error)}`;
 }
-async function waitForWatchSubscribeRetryDelay(params) {
-	if (params.ms <= 0) return;
-	await new Promise((resolve) => {
-		const timer = setTimeout(() => {
-			params.abortSignal?.removeEventListener("abort", onAbort);
-			resolve();
-		}, params.ms);
-		const onAbort = () => {
-			clearTimeout(timer);
-			params.abortSignal?.removeEventListener("abort", onAbort);
-			resolve();
-		};
-		params.abortSignal?.addEventListener("abort", onAbort, { once: true });
-	});
-}
-async function monitorIMessageProvider(opts = {}) {
+async function monitorIMessageProvider(opts) {
+	const { scheduler } = opts;
 	const runtime = opts.runtime ?? createNonExitingRuntime();
 	const cfg = opts.config ?? getRuntimeConfig();
 	const readConfig = createRuntimeConfigReader(cfg);
@@ -2995,13 +2924,8 @@ async function monitorIMessageProvider(opts = {}) {
 							await abandon();
 							return;
 						}
-						if (entries.length === 1) {
-							await handleMessageNow(expectDefined(entries[0], "single iMessage dispatch entry").message, admissionLifecycle);
-							await settle();
-							return;
-						}
-						const combined = combineIMessagePayloads(entries.map((entry) => entry.message));
-						if (shouldLogVerbose()) {
+						const combined = entries.length === 1 ? expectDefined(entries[0], "single iMessage dispatch entry").message : combineIMessagePayloads(entries.map((entry) => entry.message));
+						if (entries.length > 1 && shouldLogVerbose()) {
 							const text = combined.text ?? "";
 							const preview = sliceUtf16Safe(text, 0, 50);
 							const ellipsis = text.length > 50 ? "..." : "";
@@ -3378,6 +3302,10 @@ async function monitorIMessageProvider(opts = {}) {
 			}
 		};
 		let directTypingController;
+		const startDirectToolTyping = async () => {
+			await directTypingController?.startTypingLoop();
+			return false;
+		};
 		const directToolTypingOptions = shouldUseDirectToolTypingOptions ? {
 			suppressDefaultToolProgressMessages: true,
 			allowToolLifecycleWhenProgressHidden: true,
@@ -3385,14 +3313,8 @@ async function monitorIMessageProvider(opts = {}) {
 			onTypingController: (typing) => {
 				directTypingController = typing;
 			},
-			onToolResult: async () => {
-				await directTypingController?.startTypingLoop();
-				return false;
-			},
-			...supportsTyping ? { onToolStart: async () => {
-				await directTypingController?.startTypingLoop();
-				return false;
-			} } : {}
+			onToolResult: startDirectToolTyping,
+			...supportsTyping ? { onToolStart: startDirectToolTyping } : {}
 		} : {};
 		const configuredBlockStreaming = resolveChannelStreamingBlockEnabled(accountInfo.config);
 		const inboundLastRouteSessionKey = resolveInboundLastRouteSessionKey({
@@ -3608,25 +3530,27 @@ async function monitorIMessageProvider(opts = {}) {
 		} catch (err) {
 			if (abort?.aborted) return;
 			const retriable = isRetriableWatchSubscribeStartupError(err);
-			if (!(attempt < WATCH_SUBSCRIBE_MAX_ATTEMPTS && retriable)) {
+			const shouldRetry = attempt < WATCH_SUBSCRIBE_MAX_ATTEMPTS && retriable;
+			const failureParams = {
+				accountId: accountInfo.accountId,
+				attempt,
+				maxAttempts: WATCH_SUBSCRIBE_MAX_ATTEMPTS,
+				cliPath,
+				dbPath,
+				remoteHost,
+				includeAttachments,
+				probeTimeoutMs,
+				watchSinceRowid,
+				error: err
+			};
+			if (!shouldRetry) {
 				opts.statusSink?.({
 					connected: false,
 					lifecycle: retriable ? "recovering" : "blocked",
 					terminalDisconnect: retriable ? void 0 : true,
 					lastError: String(err)
 				});
-				runtime.error?.(danger(`imessage: monitor failed: ${describeIMessageWatchSubscribeStartupFailure({
-					accountId: accountInfo.accountId,
-					attempt,
-					maxAttempts: WATCH_SUBSCRIBE_MAX_ATTEMPTS,
-					cliPath,
-					dbPath,
-					remoteHost,
-					includeAttachments,
-					probeTimeoutMs,
-					watchSinceRowid,
-					error: err
-				})}`));
+				runtime.error?.(danger(`imessage: monitor failed: ${describeIMessageWatchSubscribeStartupFailure(failureParams)}`));
 				throw err;
 			}
 			opts.statusSink?.({
@@ -3635,25 +3559,15 @@ async function monitorIMessageProvider(opts = {}) {
 				lastError: String(err)
 			});
 			runtime.log?.(warn(describeIMessageWatchSubscribeStartupFailure({
-				accountId: accountInfo.accountId,
-				attempt,
-				maxAttempts: WATCH_SUBSCRIBE_MAX_ATTEMPTS,
-				cliPath,
-				dbPath,
-				remoteHost,
-				includeAttachments,
-				probeTimeoutMs,
-				watchSinceRowid,
-				error: err,
+				...failureParams,
 				retryDelayMs: WATCH_SUBSCRIBE_RETRY_DELAY_MS
 			})));
 			attemptDetachAbortHandler();
 			attemptDetachAbortHandler = () => {};
 			await attemptClient?.stop();
 			attemptClient = void 0;
-			await waitForWatchSubscribeRetryDelay({
-				ms: WATCH_SUBSCRIBE_RETRY_DELAY_MS,
-				abortSignal: abort
+			await sleepWithAbort(WATCH_SUBSCRIBE_RETRY_DELAY_MS, abort).catch((error) => {
+				if (!abort?.aborted) throw error;
 			});
 			if (abort?.aborted) return;
 		} finally {
@@ -3664,7 +3578,11 @@ async function monitorIMessageProvider(opts = {}) {
 		}
 	}
 	const activeClient = client;
-	if (!activeClient) return;
+	if (!activeClient || scheduler.signal.aborted) {
+		detachAbortHandler();
+		await activeClient?.stop();
+		return;
+	}
 	ingress.start();
 	const approvalContextLease = opts.channelRuntime ? registerChannelRuntimeContext({
 		channelRuntime: opts.channelRuntime,
@@ -3674,32 +3592,29 @@ async function monitorIMessageProvider(opts = {}) {
 		context: { accountId: accountInfo.accountId },
 		abortSignal: abort
 	}) : void 0;
-	let approvalReactionPollInFlight = false;
-	const pollApprovalReactions = async (allowRecentChatDiscovery = false) => {
-		if (approvalReactionPollInFlight) return;
-		approvalReactionPollInFlight = true;
-		try {
-			await pollPendingIMessageApprovalReactions({
+	const approvalScheduler = scheduler.scope();
+	let nextDiscoveryAt = 0;
+	approvalScheduler.schedule({
+		id: "approval-reactions",
+		delayMs: 0,
+		everyMs: APPROVAL_REACTION_POLL_INTERVAL_MS,
+		run: () => {
+			const now = approvalScheduler.now();
+			const allowRecentChatDiscovery = now >= nextDiscoveryAt;
+			if (allowRecentChatDiscovery) nextDiscoveryAt = now + APPROVAL_REACTION_DISCOVERY_INTERVAL_MS;
+			return pollPendingIMessageApprovalReactions({
+				signal: approvalScheduler.signal,
 				client: activeClient,
 				cfg,
 				accountId: accountInfo.accountId,
 				allowRecentChatDiscovery,
 				gatewayRuntime: approvalGatewayRuntime,
 				logVerboseMessage: logVerbose
+			}).catch((err) => {
+				logVerbose(`imessage: approval reaction poll failed: ${String(err)}`);
 			});
-		} catch (err) {
-			logVerbose(`imessage: approval reaction poll failed: ${String(err)}`);
-		} finally {
-			approvalReactionPollInFlight = false;
 		}
-	};
-	const approvalReactionPollTimer = setInterval(() => {
-		pollApprovalReactions();
-	}, APPROVAL_REACTION_POLL_INTERVAL_MS);
-	const approvalReactionDiscoveryTimer = setInterval(() => {
-		pollApprovalReactions(true);
-	}, APPROVAL_REACTION_DISCOVERY_INTERVAL_MS);
-	pollApprovalReactions(true);
+	});
 	if (catchupCfg.enabled && !abort?.aborted) {
 		startupCatchupInProgress = true;
 		try {
@@ -3739,13 +3654,94 @@ async function monitorIMessageProvider(opts = {}) {
 		runtime.error?.(danger(`imessage: monitor failed: ${String(err)}`));
 		throw err;
 	} finally {
-		clearInterval(approvalReactionPollTimer);
-		clearInterval(approvalReactionDiscoveryTimer);
+		approvalScheduler.beginClose();
 		approvalContextLease?.dispose();
 		detachAbortHandler();
 		await activeClient.stop();
+		await approvalScheduler.stop();
 		await ingress.stop();
 	}
 }
 //#endregion
-export { monitorIMessageProvider as t };
+//#region extensions/imessage/src/channel.runtime.ts
+async function sendIMessageOutbound(params) {
+	const send = resolveOutboundSendDep(params.deps, "imessage", { legacyKeys: IMESSAGE_LEGACY_OUTBOUND_SEND_DEP_KEYS }) ?? sendMessageIMessage;
+	const maxBytes = resolveChannelMediaMaxBytes({
+		cfg: params.cfg,
+		resolveChannelLimitMb: () => resolveIMessageAccount(params).config.mediaMaxMb
+	});
+	const result = await send(params.to, params.text, {
+		config: params.cfg,
+		...params.mediaUrl ? { mediaUrl: params.mediaUrl } : {},
+		...params.mediaAccess ? { mediaAccess: params.mediaAccess } : {},
+		...params.mediaLocalRoots?.length ? { mediaLocalRoots: params.mediaLocalRoots } : {},
+		...params.mediaReadFile ? { mediaReadFile: params.mediaReadFile } : {},
+		...params.audioAsVoice ? { audioAsVoice: true } : {},
+		maxBytes,
+		accountId: params.accountId ?? void 0,
+		replyToId: params.replyToId ?? void 0,
+		conversationReadOrigin: params.conversationReadOrigin,
+		assertDirectAdapterHandoff: params.assertDirectAdapterHandoff,
+		onPlatformSendDispatch: params.onPlatformSendDispatch,
+		...params.onDeliveryResult ? { onDeliveryResult: params.onDeliveryResult } : {}
+	});
+	const meta = {
+		...result.meta,
+		...result.guid ? { imessageMessageGuid: result.guid } : {},
+		...result.sentText ? { imessageVisibleText: result.sentText } : {}
+	};
+	return Object.keys(meta).length > 0 ? {
+		...result,
+		meta
+	} : result;
+}
+async function probeIMessageAccount(params) {
+	return await probeIMessage(params?.timeoutMs, {
+		cliPath: params?.cliPath,
+		dbPath: params?.dbPath,
+		remoteHost: params?.remoteHost,
+		forceRefresh: true
+	});
+}
+async function startIMessageGatewayAccount(ctx) {
+	const account = ctx.account;
+	const cliPath = account.config.cliPath?.trim() || "imsg";
+	const dbPath = account.config.dbPath?.trim();
+	ctx.setStatus({
+		accountId: account.accountId,
+		cliPath,
+		dbPath: dbPath ?? null
+	});
+	await Promise.all(listEnabledIMessageAccounts(ctx.cfg).map(async (candidate) => {
+		await resolveIMessageRemoteHost({
+			cliPath: candidate.config.cliPath?.trim() || "imsg",
+			remoteHost: candidate.config.remoteHost
+		});
+	}));
+	const ownerAccountId = resolveIMessageDuplicateSourceOwner({
+		cfg: ctx.cfg,
+		account
+	});
+	if (ownerAccountId) {
+		ctx.log?.info?.(`[${account.accountId}] skipping watcher: duplicate iMessage source; using account "${ownerAccountId}"`);
+		await waitForAbortSignal(ctx.abortSignal);
+		return;
+	}
+	const statusSink = createAccountStatusSink({
+		accountId: account.accountId,
+		setStatus: ctx.setStatus
+	});
+	statusSink({ lifecycle: "starting" });
+	ctx.log?.info?.(`[${account.accountId}] starting provider (${cliPath}${dbPath ? ` db=${dbPath}` : ""})`);
+	return await monitorIMessageProvider({
+		scheduler: ctx.scheduler,
+		accountId: account.accountId,
+		config: ctx.cfg,
+		runtime: ctx.runtime,
+		abortSignal: ctx.abortSignal,
+		channelRuntime: ctx.channelRuntime,
+		statusSink
+	});
+}
+//#endregion
+export { imessageSetupWizard, probeIMessageAccount, sendIMessageOutbound, startIMessageGatewayAccount };