@openclaw/whatsapp 2026.7.2-beta.5 → 2026.7.2-beta.7

package/dist/{monitor-B7phZF9w.js → monitor-CfkaUSL2.js}

@@ -1,5 +1,5 @@
 import { a as resolveWhatsAppAccount, s as resolveWhatsAppMediaMaxBytes } from "./accounts-CSqLvCY5.js";
-import { a as normalizeWhatsAppOutboundPayload, c as prepareWhatsAppOutboundMedia, r as sendReactionWhatsApp, s as normalizeWhatsAppPayloadTextPreservingIndentation, u as resolveWhatsAppReactionLevel } from "./send-BTXJAyK4.js";
+import { a as normalizeWhatsAppOutboundPayload, c as prepareWhatsAppOutboundMedia, r as sendReactionWhatsApp, s as normalizeWhatsAppPayloadTextPreservingIndentation, u as resolveWhatsAppReactionLevel } from "./send-D37ddk22.js";
 import { i as getWhatsAppRuntime } from "./runtime-BLlToOi6.js";
 import { r as getWhatsAppConnectionController } from "./connection-controller-runtime-context-DG0tuYuw.js";
 import { a as markdownToWhatsAppChunks, c as toWhatsappJid, l as toWhatsappJidWithLid, n as isSelfChatMode, o as resolveEquivalentWhatsAppDirectChatJids, r as jidToE164, s as resolveJidToE164 } from "./targets-runtime-TMk0lGuy.js";
@@ -12,7 +12,7 @@ import { a as waitForWaConnection, c as isWhatsAppSocketOperationTimeoutError, d
 import { n as getStatusCode, t as formatError } from "./session-errors-JuazczrA.js";
 import { t as BufferJSON } from "./session.runtime-Nsqaehbd.js";
 import { c as requireWhatsAppInboundAdmission, i as resolveWhatsAppInboundPolicy, l as resolveWhatsAppGroupConversationId, o as buildDeprecatedFlatWhatsAppInboundAdmission, r as resolveWhatsAppCommandAuthorized, s as requireAdmittedWhatsAppInboundMessage, t as checkInboundAccessControl } from "./access-control-pZcxTmd5.js";
-import { _ as extractMediaKind, a as mayContainWhatsAppOutboundMention, b as hasInboundUserContent, c as DisconnectReason, d as normalizeMessageContent, f as describeReplyContext, g as extractLocationData, h as extractExternalAdReplyContext, i as addWhatsAppOutboundMentionsToContent, l as downloadMediaMessage, m as extractContextInfo, n as listWhatsAppSendResultMessageIds, o as resolveWhatsAppOutboundMentions, p as extractContactContext, r as normalizeWhatsAppSendResult, s as addWhatsAppImagePreviewFields, t as createWebSendApi, u as isJidGroup, v as extractMentionedJids, x as resolveInboundMediaMimetype, y as extractText } from "./send-api-BY_AkSiB.js";
+import { _ as extractMediaKind, a as mayContainWhatsAppOutboundMention, b as hasInboundUserContent, c as DisconnectReason, d as normalizeMessageContent, f as describeReplyContext, g as extractLocationData, h as extractExternalAdReplyContext, i as addWhatsAppOutboundMentionsToContent, l as downloadMediaMessage, m as extractContextInfo, n as listWhatsAppSendResultMessageIds, o as resolveWhatsAppOutboundMentions, p as extractContactContext, r as normalizeWhatsAppSendResult, s as addWhatsAppImagePreviewFields, t as createWebSendApi, u as isJidGroup, v as extractMentionedJids, x as resolveInboundMediaMimetype, y as extractText } from "./send-api-7wk6eQyW.js";
 import { c as computeBackoff, d as resolveReconnectPolicy, f as sleepWithAbort, l as newConnectionId, n as WHATSAPP_WATCHDOG_TIMEOUT_ERROR, r as WhatsAppConnectionController, s as DEFAULT_RECONNECT_POLICY, u as resolveHeartbeatSeconds } from "./connection-controller-BOB2MVKY.js";
 import { n as maybeResolveWhatsAppApprovalReaction } from "./approval-reactions-Cu66aYdq.js";
 import { t as maybeResolveWhatsAppQuestionReaction } from "./question-reactions-CRsnyoMK.js";
@@ -24,12 +24,12 @@ import { getChildLogger } from "openclaw/plugin-sdk/logging-core";
 import { resolveMarkdownTableMode as resolveMarkdownTableMode$1 } from "openclaw/plugin-sdk/markdown-table-runtime";
 import { createSubsystemLogger, defaultRuntime, formatDurationPrecise, getChildLogger as getChildLogger$1, logVerbose, logVerbose as logVerbose$1, registerUnhandledRejectionHandler, shouldLogVerbose, shouldLogVerbose as shouldLogVerbose$1, warn } from "openclaw/plugin-sdk/runtime-env";
 import { registerChannelRuntimeContext } from "openclaw/plugin-sdk/channel-runtime-context";
-import { bindIngressLifecycleToReplyOptions, createChannelIngressMonitor, createChannelMessageReplyPipeline, createMessageReceiptFromOutboundResults, resolveChannelMessageSourceReplyDeliveryMode, resolveChannelStreamingBlockEnabled } from "openclaw/plugin-sdk/channel-outbound";
+import { bindIngressLifecycleToReplyOptions, createChannelIngressMonitor, createChannelMessageReplyPipeline, createMessageReceiptFromOutboundResults, listMessageReceiptPlatformIds, resolveChannelMessageSourceReplyDeliveryMode, resolveChannelStreamingBlockEnabled } from "openclaw/plugin-sdk/channel-outbound";
 import { getAgentScopedMediaLocalRoots } from "openclaw/plugin-sdk/media-runtime";
 import { isReasoningReplyPayload, resolveSendableOutboundReplyParts, sendMediaWithLeadingCaption } from "openclaw/plugin-sdk/reply-payload";
 import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
-import { buildChannelInboundEventContext, filterChannelInboundQuoteContext, formatInboundEnvelope, formatInboundEnvelope as formatInboundEnvelope$1, formatInboundMediaUnavailableText, formatLocationText, formatMediaPlaceholderText, hasVisibleInboundReplyDispatch, isChannelPartialDeliveryError, resolveInboundSessionEnvelopeContext, resolveInboundSupplementalSenderAllowed, runChannelInboundEvent, shouldDebounceTextInbound, toInboundMediaFacts, toLocationContext } from "openclaw/plugin-sdk/channel-inbound";
+import { buildChannelInboundEventContext, createChannelPartialDeliveryError, filterChannelInboundQuoteContext, formatInboundEnvelope, formatInboundEnvelope as formatInboundEnvelope$1, formatInboundMediaUnavailableText, formatLocationText, formatMediaPlaceholderText, hasVisibleInboundReplyDispatch, isChannelPartialDeliveryError, resolveInboundSessionEnvelopeContext, resolveInboundSupplementalSenderAllowed, runChannelInboundEvent, shouldDebounceTextInbound, toInboundMediaFactsWithMetadata, toLocationContext } from "openclaw/plugin-sdk/channel-inbound";
 import { DEFAULT_ACCOUNT_ID, DEFAULT_MAIN_KEY, buildAgentMainSessionKey, buildAgentSessionKey, buildGroupHistoryKey, deriveLastRoutePolicy, normalizeAccountId, normalizeAgentId, resolveAgentRoute, resolveInboundLastRouteSessionKey } from "openclaw/plugin-sdk/routing";
 import { asDateTimestampMs, parseStrictFiniteNumber, resolveExpiresAtMsFromDurationMs } from "openclaw/plugin-sdk/number-runtime";
 import { createHash } from "node:crypto";
@@ -42,8 +42,8 @@ import { createInboundDebouncer, resolveInboundDebounceMs } from "openclaw/plugi
 import { drainPendingDeliveries } from "openclaw/plugin-sdk/delivery-queue-runtime";
 import { DEFAULT_GROUP_HISTORY_LIMIT, buildHistoryContextFromEntries, buildInboundHistoryFromEntries, createChannelHistoryWindow } from "openclaw/plugin-sdk/reply-history";
 import { enqueueSystemEvent } from "openclaw/plugin-sdk/system-event-runtime";
-import { createDedupeCache } from "openclaw/plugin-sdk/dedupe-runtime";
 import { saveMediaStream } from "openclaw/plugin-sdk/media-store";
+import { createDedupeCache } from "openclaw/plugin-sdk/dedupe-runtime";
 import { getRuntimeConfig as getRuntimeConfig$1 } from "openclaw/plugin-sdk/runtime-config-snapshot";
 import { resolveChannelContextVisibilityMode } from "openclaw/plugin-sdk/context-visibility-runtime";
 import { buildMentionRegexes, implicitMentionKindWhen, normalizeMentionText, resolveInboundMentionDecision } from "openclaw/plugin-sdk/channel-mention-gating";
@@ -57,6 +57,33 @@ import { getGlobalHookRunner } from "openclaw/plugin-sdk/plugin-runtime";
 import { resolveBatchedReplyThreadingPolicy } from "openclaw/plugin-sdk/reply-reference";
 import { LocalMediaAccessError, getDefaultLocalRoots, loadWebMedia, loadWebMediaRaw, optimizeImageToJpeg, optimizeImageToPng } from "openclaw/plugin-sdk/web-media";
 import { createChannelApiRetryRunner } from "openclaw/plugin-sdk/retry-runtime";
+//#region extensions/whatsapp/src/inbound/baileys-cache.ts
+const WHATSAPP_BAILEYS_CACHE_MAX_ENTRIES = 500;
+function rememberWhatsAppBaileysCacheEntry(cache, key, value, ttlMs) {
+	if (!cache) return;
+	if (cache.has(key)) cache.delete(key);
+	cache.set(key, {
+		expiresAt: Date.now() + ttlMs,
+		value
+	});
+	while (cache.size > WHATSAPP_BAILEYS_CACHE_MAX_ENTRIES) {
+		const oldest = cache.keys().next();
+		if (oldest.done) break;
+		cache.delete(oldest.value);
+	}
+}
+function readWhatsAppBaileysCacheEntry(cache, key) {
+	const entry = cache.get(key);
+	if (!entry) return;
+	if (entry.expiresAt <= Date.now()) {
+		cache.delete(key);
+		return;
+	}
+	cache.delete(key);
+	cache.set(key, entry);
+	return entry.value;
+}
+//#endregion
 //#region extensions/whatsapp/src/inbound/message-aliases.ts
 function normalizeQuoteSender(sender) {
 	if (!sender?.displayName && !sender?.jid && !sender?.e164) return;
@@ -174,9 +201,12 @@ function defineDeprecatedAdmissionTopLevelAccessors(msg) {
 			}
 		},
 		accessControlPassed: {
-			get: () => msg.admission ? msg.admission.ingress.decision === "allow" : fallbackAccessControlPassed,
+			get: () => {
+				if (msg.admission?.ingress.decisiveGateId === "legacy-flat-compat") return fallbackAccessControlPassed;
+				return msg.admission ? msg.admission.ingress.decision === "allow" : fallbackAccessControlPassed;
+			},
 			set: (value) => {
-				fallbackAccessControlPassed = value;
+				if (!msg.admission) fallbackAccessControlPassed = value;
 			}
 		},
 		chatType: {
@@ -397,31 +427,8 @@ function normalizeWebInboundMessage(msg) {
 	if (msg.event || msg.payload || msg.platform || msg.quote || msg.group) throw new Error("WhatsApp inbound messages must be either legacy flat or canonical nested; partial nested contexts are not supported.");
 	return normalizeLegacyFlatWebInboundMessage(msg);
 }
-//#endregion
-//#region extensions/whatsapp/src/inbound/dedupe.ts
-const recentOutboundMessages = createDedupeCache({
-	ttlMs: 20 * 6e4,
-	maxSize: 5e3
-});
-function buildMessageKey(params) {
-	const accountId = params.accountId.trim();
-	const remoteJid = params.remoteJid.trim();
-	const messageId = params.messageId.trim();
-	if (!accountId || !remoteJid || !messageId || messageId === "unknown") return null;
-	return `${accountId}:${remoteJid}:${messageId}`;
-}
-function resetWebInboundDedupe() {
-	recentOutboundMessages.clear();
-}
-function rememberRecentOutboundMessage(params) {
-	const key = buildMessageKey(params);
-	if (!key) return;
-	recentOutboundMessages.check(key);
-}
-function isRecentOutboundMessage(params) {
-	const key = buildMessageKey(params);
-	if (!key) return false;
-	return recentOutboundMessages.peek(key);
+function normalizeAdmittedWebInboundMessage(msg) {
+	return requireAdmittedWhatsAppInboundMessage(normalizeWebInboundMessage(msg));
 }
 //#endregion
 //#region extensions/whatsapp/src/inbound/durable-payload.ts
@@ -453,11 +460,6 @@ function deserializeWhatsAppDurableInboundMessage(message) {
 }
 //#endregion
 //#region extensions/whatsapp/src/inbound/durable-receive.ts
-const WHATSAPP_DURABLE_INBOUND_PENDING_MAX_ENTRIES = 450;
-const WHATSAPP_DURABLE_INBOUND_COMPLETED_MAX_ENTRIES = 5e3;
-const WHATSAPP_DURABLE_INBOUND_PENDING_TTL_MS = 720 * 60 * 60 * 1e3;
-const WHATSAPP_DURABLE_INBOUND_COMPLETED_TTL_MS = 10080 * 60 * 1e3;
-const WHATSAPP_DURABLE_INBOUND_PRUNE_INTERVAL_MS = 3600 * 1e3;
 const WHATSAPP_DURABLE_INBOUND_PAYLOAD_VERSION = 1;
 function hashNamespacePart(value) {
 	return createHash("sha256").update(value).digest("hex").slice(0, 24);
@@ -516,13 +518,9 @@ function createWhatsAppIngressMonitor(params) {
 		deliver: (admission, lifecycle) => params.dispatch(admission, lifecycle),
 		pollIntervalMs: params.pollIntervalMs,
 		retention: {
-			pruneIntervalMs: WHATSAPP_DURABLE_INBOUND_PRUNE_INTERVAL_MS,
-			pendingTtlMs: WHATSAPP_DURABLE_INBOUND_PENDING_TTL_MS,
-			pendingMaxEntries: WHATSAPP_DURABLE_INBOUND_PENDING_MAX_ENTRIES,
-			completedTtlMs: WHATSAPP_DURABLE_INBOUND_COMPLETED_TTL_MS,
-			completedMaxEntries: WHATSAPP_DURABLE_INBOUND_COMPLETED_MAX_ENTRIES,
-			failedTtlMs: WHATSAPP_DURABLE_INBOUND_PENDING_TTL_MS,
-			failedMaxEntries: WHATSAPP_DURABLE_INBOUND_PENDING_MAX_ENTRIES
+			completedTtlMs: 10080 * 60 * 1e3,
+			completedMaxEntries: 5e3,
+			failedMaxEntries: 450
 		},
 		drain: {
 			resolveNonRetryableFailure: resolveWhatsAppIngressNonRetryableFailure,
@@ -543,14 +541,190 @@ function createWhatsAppIngressMonitor(params) {
 	});
 }
 //#endregion
-//#region extensions/whatsapp/src/inbound/ingress-lifecycle.ts
-const ingressLifecycleKey = Symbol("whatsappIngressLifecycle");
-function attachWhatsAppIngressLifecycle(message, lifecycle) {
-	if (lifecycle) message[ingressLifecycleKey] = lifecycle;
-	return message;
+//#region extensions/whatsapp/src/inbound/group-metadata-cache.ts
+const GROUP_META_TTL_MS = 300 * 1e3;
+const WHATSAPP_GROUP_METADATA_CACHE_MAX_ENTRIES = 500;
+function resolveGroupMetadataExpiresAt(nowRaw = Date.now()) {
+	const now = asDateTimestampMs(nowRaw);
+	return now === void 0 ? void 0 : resolveExpiresAtMsFromDurationMs(GROUP_META_TTL_MS, { nowMs: now });
 }
-function resolveWhatsAppIngressLifecycle(message) {
-	return message[ingressLifecycleKey];
+function rememberGroupMetadataCacheEntry(cache, jid, entry) {
+	if (asDateTimestampMs(entry.expires) === void 0) {
+		cache.delete(jid);
+		return;
+	}
+	if (cache.has(jid)) cache.delete(jid);
+	cache.set(jid, entry);
+	while (cache.size > WHATSAPP_GROUP_METADATA_CACHE_MAX_ENTRIES) {
+		const oldest = cache.keys().next();
+		if (oldest.done) break;
+		cache.delete(oldest.value);
+	}
+}
+function readGroupMetadataCacheEntry(cache, jid) {
+	const entry = cache.get(jid);
+	if (!entry) return null;
+	const now = asDateTimestampMs(Date.now());
+	const expires = asDateTimestampMs(entry.expires);
+	if (now === void 0 || expires === void 0 || expires <= now) {
+		cache.delete(jid);
+		return null;
+	}
+	cache.delete(jid);
+	cache.set(jid, entry);
+	return entry;
+}
+function createWhatsAppGroupMetadataCacheOwner(params) {
+	const reconnectCache = params.reconnectCache ?? /* @__PURE__ */ new Map();
+	const localCache = /* @__PURE__ */ new Map();
+	const publishedJids = /* @__PURE__ */ new Set();
+	const invalidatedJids = /* @__PURE__ */ new Set();
+	const detachListeners = [];
+	let closed = false;
+	let started = false;
+	const summarize = async (meta) => {
+		const participantEntries = await Promise.all(meta.participants?.map(async (participant) => {
+			const mapped = await params.resolveInboundJid(participant.id);
+			return {
+				display: mapped ?? participant.id,
+				mention: {
+					id: participant.id,
+					lid: participant.lid,
+					phoneNumber: participant.phoneNumber,
+					e164: mapped
+				}
+			};
+		}) ?? []);
+		return {
+			subject: meta.subject,
+			participants: participantEntries.map((entry) => entry.display).filter(Boolean),
+			mentionParticipants: participantEntries.map((entry) => entry.mention),
+			expires: resolveGroupMetadataExpiresAt() ?? 0
+		};
+	};
+	const summarizeForReconnect = (meta) => ({
+		subject: meta.subject,
+		expires: resolveGroupMetadataExpiresAt() ?? NaN
+	});
+	const rememberFullUpdate = (jid, meta) => {
+		if (closed) return;
+		rememberWhatsAppBaileysCacheEntry(params.baileysCache, jid, meta, GROUP_META_TTL_MS);
+		publishedJids.add(jid);
+		invalidatedJids.delete(jid);
+		rememberGroupMetadataCacheEntry(reconnectCache, jid, summarizeForReconnect(meta));
+		localCache.delete(jid);
+	};
+	const forgetFullMetadata = (jid) => {
+		params.baileysCache?.delete(jid);
+		reconnectCache.delete(jid);
+		localCache.delete(jid);
+		publishedJids.delete(jid);
+		invalidatedJids.add(jid);
+	};
+	const get = async (jid) => {
+		const cached = readGroupMetadataCacheEntry(localCache, jid);
+		if (cached) return cached;
+		try {
+			const meta = await (params.getCurrentSock() ?? params.sock).groupMetadata(jid);
+			rememberWhatsAppBaileysCacheEntry(params.baileysCache, jid, meta, GROUP_META_TTL_MS);
+			publishedJids.add(jid);
+			const entry = await summarize(meta);
+			rememberGroupMetadataCacheEntry(reconnectCache, jid, {
+				subject: entry.subject,
+				expires: entry.expires
+			});
+			rememberGroupMetadataCacheEntry(localCache, jid, entry);
+			return entry;
+		} catch (error) {
+			const hydrated = readGroupMetadataCacheEntry(reconnectCache, jid);
+			if (hydrated) {
+				rememberGroupMetadataCacheEntry(localCache, jid, hydrated);
+				params.logVerbose(`Using cached group metadata for ${jid} after fetch failure: ${String(error)}`);
+				return hydrated;
+			}
+			params.logVerbose(`Failed to fetch group metadata for ${jid}: ${String(error)}`);
+			return { expires: resolveGroupMetadataExpiresAt() ?? 0 };
+		}
+	};
+	const resolveOutboundMentions = async (jid, text) => {
+		if (isJidGroup(jid) !== true || !mayContainWhatsAppOutboundMention(text)) return {
+			text,
+			mentionedJids: []
+		};
+		return resolveWhatsAppOutboundMentions({
+			chatJid: jid,
+			text,
+			participants: (await get(jid)).mentionParticipants
+		});
+	};
+	const applyOutboundMentions = async (jid, content) => {
+		if ("text" in content && typeof content.text === "string") {
+			const resolved = await resolveOutboundMentions(jid, content.text);
+			return addWhatsAppOutboundMentionsToContent({
+				...content,
+				text: resolved.text
+			}, resolved.mentionedJids);
+		}
+		const caption = content.caption;
+		if (typeof caption === "string") {
+			const resolved = await resolveOutboundMentions(jid, caption);
+			return addWhatsAppOutboundMentionsToContent({
+				...content,
+				caption: resolved.text
+			}, resolved.mentionedJids);
+		}
+		return content;
+	};
+	const start = () => {
+		if (started || closed) return;
+		started = true;
+		const listen = (event, listener) => {
+			detachListeners.push(params.listen(event, listener));
+		};
+		listen("groups.upsert", ((groups) => {
+			for (const group of groups) if (group.id) rememberFullUpdate(group.id, group);
+		}));
+		listen("groups.update", ((updates) => {
+			for (const update of updates) {
+				if (!update.id) continue;
+				if (typeof update.subject === "string" && Array.isArray(update.participants)) {
+					rememberFullUpdate(update.id, update);
+					continue;
+				}
+				forgetFullMetadata(update.id);
+			}
+		}));
+		listen("group-participants.update", ((update) => {
+			forgetFullMetadata(update.id);
+		}));
+		(async () => {
+			try {
+				const groups = await params.sock.groupFetchAllParticipating();
+				if (closed) return;
+				for (const [jid, meta] of Object.entries(groups ?? {})) if (meta && !publishedJids.has(jid) && !invalidatedJids.has(jid)) {
+					rememberGroupMetadataCacheEntry(reconnectCache, jid, summarizeForReconnect(meta));
+					rememberWhatsAppBaileysCacheEntry(params.baileysCache, jid, meta, GROUP_META_TTL_MS);
+					publishedJids.add(jid);
+				}
+				params.logVerbose(`Hydrated ${Object.keys(groups ?? {}).length} participating groups on connect`);
+			} catch (error) {
+				const formatted = String(error);
+				params.logHydrationWarning(formatted);
+				params.logVerbose(`Failed to hydrate participating groups on connect: ${formatted}`);
+			}
+		})();
+	};
+	const close = () => {
+		closed = true;
+		for (const detach of detachListeners.splice(0)) detach();
+	};
+	return {
+		start,
+		close,
+		get,
+		resolveOutboundMentions,
+		applyOutboundMentions
+	};
 }
 //#endregion
 //#region extensions/whatsapp/src/inbound/lifecycle.ts
@@ -572,6 +746,157 @@ function closeInboundMonitorSocket(sock) {
 	sock.ws?.close?.();
 }
 //#endregion
+//#region extensions/whatsapp/src/inbound/ingress-lifecycle.ts
+const ingressLifecycleKey = Symbol("whatsappIngressLifecycle");
+function attachWhatsAppIngressLifecycle(message, lifecycle) {
+	if (lifecycle) message[ingressLifecycleKey] = lifecycle;
+	return message;
+}
+function resolveWhatsAppIngressLifecycle(message) {
+	return message[ingressLifecycleKey];
+}
+//#endregion
+//#region extensions/whatsapp/src/inbound/message-debounce.ts
+function createWhatsAppInboundMessageDebouncer(options) {
+	const debounceMs = Math.max(0, Math.trunc(options.debounceMs ?? 0));
+	const pendingKeys = /* @__PURE__ */ new Map();
+	const activeFlushes = /* @__PURE__ */ new Set();
+	const workWaiters = /* @__PURE__ */ new Set();
+	const notifyWork = () => {
+		const waiters = [...workWaiters];
+		workWaiters.clear();
+		for (const resolve of waiters) resolve();
+	};
+	const buildKey = (msg) => {
+		const admission = requireWhatsAppInboundAdmission(msg);
+		const sender = msg.platform.sender;
+		const senderKey = admission.conversation.kind === "group" ? getPrimaryIdentityId(sender ?? null) ?? msg.platform.senderJid ?? msg.platform.senderE164 ?? msg.platform.senderName ?? admission.sender.id : admission.conversation.id;
+		return senderKey ? `${admission.accountId}:${admission.conversation.id}:${senderKey}` : null;
+	};
+	const shouldDebounce = (msg) => options.shouldDebounce?.(msg) ?? true;
+	const trackKey = (key) => {
+		pendingKeys.set(key, (pendingKeys.get(key) ?? 0) + 1);
+	};
+	const releaseKey = (entry) => {
+		if (!entry.debounceKey || entry.debounceKeyTracked !== true) return;
+		const remaining = (pendingKeys.get(entry.debounceKey) ?? 0) - 1;
+		if (remaining > 0) pendingKeys.set(entry.debounceKey, remaining);
+		else pendingKeys.delete(entry.debounceKey);
+	};
+	const orderEntries = (entries) => entries.toSorted((a, b) => {
+		const timestampDiff = (a.event.timestamp ?? 0) - (b.event.timestamp ?? 0);
+		return timestampDiff !== 0 ? timestampDiff : (a.receiveOrder ?? 0) - (b.receiveOrder ?? 0);
+	});
+	const debouncer = createInboundDebouncer({
+		debounceMs,
+		buildKey: (msg) => msg.debounceKey ?? buildKey(msg),
+		shouldDebounce,
+		onFlush: (entries, createFlush) => {
+			for (const entry of entries) releaseKey(entry);
+			const orderedEntries = orderEntries(entries);
+			const { lifecycle, settle, abandon } = fanInChannelIngressLifecycles(orderedEntries.map((entry) => entry.turnAdoptionLifecycle));
+			const flush = createFlush({
+				lifecycle,
+				dispatch: async (admissionLifecycle) => {
+					const last = orderedEntries.at(-1);
+					if (!last) return;
+					try {
+						if (orderedEntries.length === 1) {
+							await options.onMessage(attachWhatsAppIngressLifecycle(last, admissionLifecycle));
+							await settle();
+							await Promise.all(orderedEntries.map((entry) => options.markRead(entry.readReceipt)));
+							return;
+						}
+						const mentioned = /* @__PURE__ */ new Set();
+						for (const entry of orderedEntries) for (const jid of entry.group?.mentions?.jids ?? []) mentioned.add(jid);
+						const combinedBody = orderedEntries.map((entry) => entry.payload.body).filter(Boolean).join("\n");
+						const combinedCommandBody = orderedEntries.map((entry) => entry.payload.commandBody ?? entry.payload.body).filter(Boolean).join("\n");
+						const combinedMentions = mentioned.size > 0 ? {
+							...last.group?.mentions,
+							jids: Array.from(mentioned)
+						} : last.group?.mentions;
+						const combinedGroup = last.group || combinedMentions ? {
+							...last.group,
+							mentions: combinedMentions
+						} : void 0;
+						const combinedMessage = attachWhatsAppIngressLifecycle(withDeprecatedWebInboundMessageFlatAliases({
+							...last,
+							turnAdoptionLifecycle: admissionLifecycle,
+							payload: {
+								...last.payload,
+								body: combinedBody,
+								commandBody: combinedCommandBody
+							},
+							group: combinedGroup,
+							event: {
+								...last.event,
+								isBatched: true
+							}
+						}), admissionLifecycle);
+						await options.onMessage(combinedMessage);
+						await settle();
+						await Promise.all(orderedEntries.map((entry) => options.markRead(entry.readReceipt)));
+					} catch (error) {
+						await abandon();
+						throw error;
+					}
+				}
+			});
+			activeFlushes.add(flush.completion);
+			options.onPendingWorkChanged();
+			notifyWork();
+			const cleanup = () => {
+				activeFlushes.delete(flush.completion);
+				options.onPendingWorkChanged();
+			};
+			flush.completion.then(cleanup, cleanup);
+			return flush;
+		},
+		onError: options.onError
+	});
+	const enqueue = async (message) => {
+		const key = buildKey(message);
+		if (key) {
+			message.debounceKey = key;
+			if (debounceMs > 0 && shouldDebounce(message)) {
+				message.debounceKeyTracked = true;
+				trackKey(key);
+				options.onPendingWorkChanged();
+				notifyWork();
+			}
+		}
+		await debouncer.enqueue(message);
+	};
+	const hasPendingWork = () => pendingKeys.size > 0 || activeFlushes.size > 0;
+	const pendingWorkCount = () => pendingKeys.size + activeFlushes.size;
+	const waitForWorkOrIdle = (handlers, handlersIdle) => {
+		if (hasPendingWork() || handlersIdle) return Promise.resolve();
+		return new Promise((resolve) => {
+			const finish = () => {
+				workWaiters.delete(finish);
+				resolve();
+			};
+			workWaiters.add(finish);
+			Promise.allSettled(handlers).then(finish);
+		});
+	};
+	const drain = async () => {
+		while (hasPendingWork()) {
+			const keys = Array.from(pendingKeys.keys());
+			if (keys.length > 0) await Promise.all(keys.map((key) => debouncer.flushKey(key)));
+			await debouncer.drain();
+			await Promise.resolve();
+		}
+	};
+	return {
+		enqueue,
+		drain,
+		hasPendingWork,
+		pendingWorkCount,
+		waitForWorkOrIdle
+	};
+}
+//#endregion
 //#region extensions/whatsapp/src/inbound/media.ts
 var WhatsAppInboundMediaLimitExceededError = class extends Error {
 	constructor(maxBytes) {
@@ -616,455 +941,98 @@ async function downloadQuotedInboundMedia(msg, sock, maxBytes = 50 * 1024 * 1024
 	}, sock, maxBytes);
 }
 //#endregion
-//#region extensions/whatsapp/src/inbound/monitor.ts
-const LOGGED_OUT_STATUS = DisconnectReason.loggedOut;
-const RECONNECT_IN_PROGRESS_ERROR = "no active socket - reconnection in progress";
-const GROUP_META_TTL_MS = 300 * 1e3;
-const BAILEYS_MESSAGE_TTL_MS = 600 * 1e3;
-const INBOUND_CLOSE_DRAIN_TIMEOUT_MS = 5e3;
-const WHATSAPP_INGRESS_DRAIN_INTERVAL_MS = 1e3;
-const WHATSAPP_GROUP_METADATA_CACHE_MAX_ENTRIES = 500;
-function resolveGroupMetadataExpiresAt(nowRaw = Date.now()) {
-	const now = asDateTimestampMs(nowRaw);
-	return now === void 0 ? void 0 : resolveExpiresAtMsFromDurationMs(GROUP_META_TTL_MS, { nowMs: now });
-}
-function parseWhatsAppTimestampSeconds(value) {
-	if (value == null) return;
-	if (typeof value === "string") return parseStrictFiniteNumber(value);
-	const parsed = Number(value);
-	return Number.isFinite(parsed) ? parsed : void 0;
-}
-function rememberGroupMetadataCacheEntry(cache, jid, entry) {
-	if (asDateTimestampMs(entry.expires) === void 0) {
-		cache.delete(jid);
-		return;
+//#region extensions/whatsapp/src/inbound/message-enrichment.ts
+async function enrichWhatsAppInboundMessage(params) {
+	const { msg, sock } = params;
+	const location = extractLocationData(msg.message ?? void 0);
+	const locationText = location ? formatLocationText(location) : void 0;
+	const contactContext = extractContactContext(msg.message ?? void 0);
+	const externalAdReplyContext = extractExternalAdReplyContext(msg.message ?? void 0);
+	let mediaKind = extractMediaKind(msg.message ?? void 0);
+	let body = extractText(msg.message ?? void 0);
+	if (locationText) body = [body, locationText].filter(Boolean).join("\n").trim();
+	if (!body && !mediaKind) return null;
+	body = body ?? "";
+	const commandBody = body;
+	const replyContext = describeReplyContext(msg.message);
+	let mediaPath;
+	let mediaType = mediaKind ? resolveInboundMediaMimetype(msg.message) : void 0;
+	const nativeMedia = mediaKind ? {
+		contentType: mediaType,
+		kind: mediaKind
+	} : void 0;
+	let mediaFileName;
+	const maxBytes = (typeof params.mediaMaxMb === "number" && params.mediaMaxMb > 0 ? params.mediaMaxMb : 50) * 1024 * 1024;
+	const saveInboundMedia = async (inboundMedia) => {
+		if (!inboundMedia) return;
+		mediaPath = inboundMedia.saved.path;
+		mediaType = inboundMedia.mimetype;
+		mediaFileName = inboundMedia.fileName;
+	};
+	try {
+		await saveInboundMedia(await downloadInboundMedia(msg, sock, maxBytes));
+	} catch (error) {
+		params.logVerbose(`Inbound media download failed: ${String(error)}`);
+		body = formatInboundMediaUnavailableText({
+			body,
+			notice: "[whatsapp attachment unavailable]"
+		});
 	}
-	if (cache.has(jid)) cache.delete(jid);
-	cache.set(jid, entry);
-	while (cache.size > WHATSAPP_GROUP_METADATA_CACHE_MAX_ENTRIES) {
-		const oldest = cache.keys().next();
-		if (oldest.done) break;
-		cache.delete(oldest.value);
+	if (!mediaPath && !mediaKind && replyContext?.media) try {
+		await saveInboundMedia(await downloadQuotedInboundMedia(msg, sock, maxBytes));
+		mediaKind = replyContext.media.kind ?? void 0;
+		mediaType = mediaType ?? replyContext.media.contentType ?? void 0;
+	} catch (error) {
+		params.logVerbose(`Quoted media download failed: ${String(error)}`);
+		body = formatInboundMediaUnavailableText({
+			body,
+			notice: "[whatsapp quoted attachment unavailable]"
+		});
 	}
+	return {
+		body,
+		commandBody,
+		location: location ?? void 0,
+		contactContext,
+		externalAdReplyContext,
+		replyContext,
+		mediaPath,
+		mediaType,
+		mediaFileName,
+		mediaKind,
+		nativeMedia
+	};
 }
-function readGroupMetadataCacheEntry(cache, jid) {
-	const entry = cache.get(jid);
-	if (!entry) return null;
-	const now = asDateTimestampMs(Date.now());
-	const expires = asDateTimestampMs(entry.expires);
-	if (now === void 0 || expires === void 0 || expires <= now) {
-		cache.delete(jid);
-		return null;
-	}
-	cache.delete(jid);
-	cache.set(jid, entry);
-	return entry;
-}
-function rememberWhatsAppBaileysCacheEntry(cache, key, value, ttlMs) {
-	if (!cache) return;
-	if (cache.has(key)) cache.delete(key);
-	cache.set(key, {
-		expiresAt: Date.now() + ttlMs,
-		value
-	});
-	while (cache.size > WHATSAPP_GROUP_METADATA_CACHE_MAX_ENTRIES) {
-		const oldest = cache.keys().next();
-		if (oldest.done) break;
-		cache.delete(oldest.value);
-	}
-}
-function readWhatsAppBaileysCacheEntry(cache, key) {
-	const entry = cache.get(key);
-	if (!entry) return;
-	if (entry.expiresAt <= Date.now()) {
-		cache.delete(key);
-		return;
-	}
-	cache.delete(key);
-	cache.set(key, entry);
-	return entry.value;
-}
-function logWhatsAppVerbose(enabled, message) {
-	if (!enabled) return;
-	defaultRuntime.log(message);
-}
-function isDirectUserJid(jid) {
-	return /^(\d+)(?::\d+)?@(s\.whatsapp\.net|c\.us|lid|hosted|hosted\.lid)$/i.test(jid.trim());
-}
-function getActiveReachoutTimelock(state) {
-	if (state?.isActive !== true) return;
-	const endsAt = state.timeEnforcementEnds?.getTime();
-	return endsAt === void 0 || !Number.isFinite(endsAt) || endsAt > Date.now() ? state : void 0;
-}
-function formatReachoutTimelockError(state) {
-	const details = [state.enforcementType ? `type=${state.enforcementType}` : void 0, state.timeEnforcementEnds instanceof Date && Number.isFinite(state.timeEnforcementEnds.getTime()) ? `until=${state.timeEnforcementEnds.toISOString()}` : void 0].filter(Boolean);
-	return `WhatsApp reachout timelock is active; direct messages are temporarily blocked${details.length ? ` (${details.join(", ")})` : ""}`;
+//#endregion
+//#region extensions/whatsapp/src/inbound/dedupe.ts
+const recentOutboundMessages = createDedupeCache({
+	ttlMs: 20 * 6e4,
+	maxSize: 5e3
+});
+function buildMessageKey(params) {
+	const accountId = params.accountId.trim();
+	const remoteJid = params.remoteJid.trim();
+	const messageId = params.messageId.trim();
+	if (!accountId || !remoteJid || !messageId || messageId === "unknown") return null;
+	return `${accountId}:${remoteJid}:${messageId}`;
 }
-function recordAcceptedInboundActivity(accountId) {
-	recordChannelActivity({
-		channel: "whatsapp",
-		accountId,
-		direction: "inbound"
-	});
+function resetWebInboundDedupe() {
+	recentOutboundMessages.clear();
 }
-function isRetryableSendDisconnectError(err) {
-	if (isWhatsAppSocketOperationTimeoutError(err)) return false;
-	return /closed|reset|timed\s*out|disconnect|no active socket/i.test(formatError(err));
+function rememberRecentOutboundMessage(params) {
+	const key = buildMessageKey(params);
+	if (!key) return;
+	recentOutboundMessages.check(key);
 }
-function shouldClearSocketRefAfterSendFailure(err) {
-	return /closed|reset|disconnect|no active socket/i.test(formatError(err));
+function isRecentOutboundMessage(params) {
+	const key = buildMessageKey(params);
+	if (!key) return false;
+	return recentOutboundMessages.peek(key);
 }
-async function attachWebInboxToSocket(options) {
-	const inboundLogger = getChildLogger({ module: "web-inbound" });
-	const inboundConsoleLog = createSubsystemLogger("gateway/channels/whatsapp").child("inbound");
-	const sock = options.sock;
-	const connectedAtMs = Date.now();
-	if (options.socketRef) options.socketRef.current = sock;
-	const shouldRetryDisconnect = () => options.shouldRetryDisconnect?.() === true;
-	const disconnectRetryPolicy = options.disconnectRetryPolicy ?? DEFAULT_RECONNECT_POLICY;
-	const sendRetryMaxAttempts = disconnectRetryPolicy.maxAttempts > 0 ? disconnectRetryPolicy.maxAttempts : DEFAULT_RECONNECT_POLICY.maxAttempts;
-	const sendOperationTimeoutMs = resolveWhatsAppSocketOperationTimeoutMs(options.socketTiming.defaultQueryTimeoutMs);
-	let onCloseResolve = null;
-	const onClose = new Promise((resolve) => {
-		onCloseResolve = resolve;
-	});
-	const resolveClose = (reason) => {
-		if (!onCloseResolve) return;
-		const resolver = onCloseResolve;
-		onCloseResolve = null;
-		resolver(reason);
-	};
-	const presence = options.selfChatMode ? "unavailable" : "available";
-	try {
-		await createWhatsAppSocketOperationTimeoutAdapter(sock, sendOperationTimeoutMs).sendPresenceUpdate(presence);
-		logWhatsAppVerbose(options.verbose, `Sent global '${presence}' presence on connect`);
-	} catch (err) {
-		logWhatsAppVerbose(options.verbose, `Failed to send '${presence}' presence on connect: ${String(err)}`);
-	}
-	const selfIdentity = await readWebSelfIdentityForDecision(options.authDir, sock.user);
-	if (selfIdentity.outcome === "unstable") throw new WhatsAppAuthUnstableError("WhatsApp auth state is still stabilizing; retrying inbox attach.");
-	const self = selfIdentity.identity;
-	const getCurrentSock = () => {
-		if (!options.socketRef) return sock;
-		if (options.socketRef.current) return options.socketRef.current;
-		if (!self.e164 && !self.jid && !self.lid) return null;
-		const successor = getWhatsAppConnectionController(options.accountId);
-		if (!successor) return null;
-		const successorIdentity = successor.getSelfIdentity();
-		if (!successorIdentity || !identitiesOverlap(self, successorIdentity)) return null;
-		return successor.getCurrentSock();
-	};
-	const durableInboundQueue = options.durableInboundQueue ?? createWhatsAppDurableInboundQueue(options.accountId);
-	const inboundDebounceMs = Math.max(0, Math.trunc(options.debounceMs ?? 0));
-	const pendingDebounceKeys = /* @__PURE__ */ new Set();
-	const activeInboundFlushes = /* @__PURE__ */ new Set();
-	const pendingMessageHandlers = /* @__PURE__ */ new Set();
-	let durableIngressActive = false;
-	const debounceWorkWaiters = /* @__PURE__ */ new Set();
-	const notifyDebounceWork = () => {
-		if (debounceWorkWaiters.size === 0) return;
-		const waiters = [...debounceWorkWaiters];
-		debounceWorkWaiters.clear();
-		for (const resolve of waiters) resolve();
-	};
-	const waitForDebounceWorkOrIdle = (handlers) => {
-		if (pendingDebounceKeys.size > 0 || activeInboundFlushes.size > 0) return Promise.resolve();
-		if (pendingMessageHandlers.size === 0) return Promise.resolve();
-		return new Promise((resolve) => {
-			const finish = () => {
-				debounceWorkWaiters.delete(finish);
-				resolve();
-			};
-			debounceWorkWaiters.add(finish);
-			Promise.allSettled(handlers).then(finish);
-		});
-	};
-	let nextReceiveOrder = 0;
-	const publishPendingWorkState = (at = Date.now()) => {
-		options.onPendingWorkChanged?.(pendingMessageHandlers.size + pendingDebounceKeys.size + activeInboundFlushes.size + (durableIngressActive ? 1 : 0), at);
-	};
-	const buildInboundDebounceKey = (msg) => {
-		const admission = requireWhatsAppInboundAdmission(msg);
-		const sender = msg.platform.sender;
-		const senderKey = admission.conversation.kind === "group" ? getPrimaryIdentityId(sender ?? null) ?? msg.platform.senderJid ?? msg.platform.senderE164 ?? msg.platform.senderName ?? admission.sender.id : admission.conversation.id;
-		if (!senderKey) return null;
-		return `${admission.accountId}:${admission.conversation.id}:${senderKey}`;
-	};
-	const shouldDebounceInboundMessage = (msg) => options.shouldDebounce?.(msg) ?? true;
-	const orderDebouncedInboundEntries = (entries) => entries.toSorted((a, b) => {
-		const timestampDiff = (a.event.timestamp ?? 0) - (b.event.timestamp ?? 0);
-		if (timestampDiff !== 0) return timestampDiff;
-		return (a.receiveOrder ?? 0) - (b.receiveOrder ?? 0);
-	});
-	const debouncer = createInboundDebouncer({
-		debounceMs: inboundDebounceMs,
-		buildKey: (msg) => msg.debounceKey ?? buildInboundDebounceKey(msg),
-		shouldDebounce: shouldDebounceInboundMessage,
-		onFlush: async (entries) => {
-			let finishFlush;
-			const flushTask = new Promise((resolve) => {
-				finishFlush = resolve;
-			});
-			activeInboundFlushes.add(flushTask);
-			publishPendingWorkState();
-			notifyDebounceWork();
-			try {
-				const orderedEntries = orderDebouncedInboundEntries(entries);
-				const last = orderedEntries.at(-1);
-				if (!last) return;
-				const { lifecycle, settle, abandon } = fanInChannelIngressLifecycles(orderedEntries.map((entry) => entry.turnAdoptionLifecycle));
-				try {
-					if (orderedEntries.length === 1) {
-						await options.onMessage(attachWhatsAppIngressLifecycle(last, lifecycle));
-						await settle();
-						await Promise.all(orderedEntries.map((entry) => maybeMarkInboundAsRead(entry.readReceipt)));
-						return;
-					}
-					const mentioned = /* @__PURE__ */ new Set();
-					for (const entry of orderedEntries) for (const jid of entry.group?.mentions?.jids ?? []) mentioned.add(jid);
-					const combinedBody = orderedEntries.map((entry) => entry.payload.body).filter(Boolean).join("\n");
-					const combinedCommandBody = orderedEntries.map((entry) => entry.payload.commandBody ?? entry.payload.body).filter(Boolean).join("\n");
-					const combinedMentions = mentioned.size > 0 ? {
-						...last.group?.mentions,
-						jids: Array.from(mentioned)
-					} : last.group?.mentions;
-					const combinedGroup = last.group || combinedMentions ? {
-						...last.group,
-						mentions: combinedMentions
-					} : void 0;
-					const combinedMessage = attachWhatsAppIngressLifecycle(withDeprecatedWebInboundMessageFlatAliases({
-						...last,
-						...lifecycle ? { turnAdoptionLifecycle: lifecycle } : {},
-						payload: {
-							...last.payload,
-							body: combinedBody,
-							commandBody: combinedCommandBody
-						},
-						group: combinedGroup,
-						event: {
-							...last.event,
-							isBatched: true
-						}
-					}), lifecycle);
-					await options.onMessage(combinedMessage);
-					await settle();
-					await Promise.all(orderedEntries.map((entry) => maybeMarkInboundAsRead(entry.readReceipt)));
-				} catch (error) {
-					await abandon();
-					throw error;
-				}
-			} finally {
-				for (const entry of entries) if (entry.debounceKey) pendingDebounceKeys.delete(entry.debounceKey);
-				activeInboundFlushes.delete(flushTask);
-				finishFlush();
-				publishPendingWorkState();
-			}
-		},
-		onError: (err) => {
-			inboundLogger.error({ error: String(err) }, "failed handling inbound web message");
-			inboundConsoleLog.error(`Failed handling inbound web message: ${String(err)}`);
-		}
-	});
-	const groupMetadataCache = options.groupMetadataCache ?? /* @__PURE__ */ new Map();
-	const groupMetaCache = /* @__PURE__ */ new Map();
-	const lidLookup = sock.signalRepository?.lidMapping;
-	const publishedGroupMetadataJids = /* @__PURE__ */ new Set();
-	const invalidatedGroupMetadataJids = /* @__PURE__ */ new Set();
-	let groupMetadataCacheClosed = false;
-	const resolveInboundJid = async (jid) => resolveJidToE164(jid, {
-		authDir: options.authDir,
-		lidLookup
-	});
-	const resolveReactionTargetJids = async (jid) => resolveEquivalentWhatsAppDirectChatJids(jid, {
-		authDir: options.authDir,
-		lidLookup
-	});
-	const rememberBaileysMessage = (remoteJid, messageId, message) => {
-		if (!options.recentMessageKeys || !remoteJid || !messageId || !message) return;
-		rememberWhatsAppBaileysCacheEntry(options.recentMessageKeys, `${remoteJid}:${messageId}`, message, BAILEYS_MESSAGE_TTL_MS);
-	};
-	const rememberOutboundMessage = (remoteJid, result) => {
-		const messageId = typeof result === "object" && result && "key" in result ? result.key?.id ?? "" : "";
-		if (!messageId) return;
-		rememberRecentOutboundMessage({
-			accountId: options.accountId,
-			remoteJid,
-			messageId
-		});
-		const message = typeof result === "object" && result && "message" in result ? result.message : void 0;
-		rememberBaileysMessage(remoteJid, messageId, message);
-		cacheInboundMessageMeta(options.accountId, remoteJid, messageId, {
-			fromMe: true,
-			body: extractText(message ?? void 0)
-		});
-	};
-	const trackLateAcceptedSend = (jid, promise) => {
-		promise.then((result) => {
-			rememberOutboundMessage(jid, result);
-		}, () => {});
-	};
-	let reachoutTimeLock;
-	let reachoutTimeLockFetch;
-	let reachoutTimeLockVersion = 0;
-	let verifiedSendReady;
-	const rememberReachoutTimeLock = (state) => {
-		reachoutTimeLock = state;
-		reachoutTimeLockVersion += 1;
-		verifiedSendReady = void 0;
-	};
-	const fetchReachoutTimeLock = async (currentSock) => {
-		if (typeof currentSock.fetchAccountReachoutTimelock !== "function") return;
-		if (!reachoutTimeLockFetch) reachoutTimeLockFetch = currentSock.fetchAccountReachoutTimelock().then((state) => {
-			rememberReachoutTimeLock(state);
-			return state;
-		}).catch((err) => {
-			logWhatsAppVerbose(options.verbose, `Failed fetching WhatsApp reachout timelock before send: ${formatError(err)}`);
-		}).finally(() => {
-			reachoutTimeLockFetch = void 0;
-		});
-		return await reachoutTimeLockFetch;
-	};
-	const rememberVerifiedSendReady = (jid, currentSock) => {
-		verifiedSendReady = {
-			jid,
-			sock: currentSock,
-			reachoutTimeLockVersion
-		};
-	};
-	const consumeVerifiedSendReady = (jid, currentSock) => {
-		if (verifiedSendReady?.jid !== jid || verifiedSendReady.sock !== currentSock || verifiedSendReady.reachoutTimeLockVersion !== reachoutTimeLockVersion) return false;
-		verifiedSendReady = void 0;
-		return true;
-	};
-	const assertCanSendToJid = async (jid, currentSock, readinessOptions) => {
-		if (!isDirectUserJid(jid)) return;
-		if (readinessOptions?.useVerifiedReady && consumeVerifiedSendReady(jid, currentSock)) return;
-		const state = getActiveReachoutTimelock(reachoutTimeLock) ?? await fetchReachoutTimeLock(currentSock);
-		const activeState = getActiveReachoutTimelock(state);
-		if (activeState) throw new Error(formatReachoutTimelockError(activeState));
-		if (readinessOptions?.rememberReady && state) rememberVerifiedSendReady(jid, currentSock);
-	};
-	const assertCanSendTo = async (to) => {
-		const currentSock = getCurrentSock();
-		if (!currentSock) throw new Error(RECONNECT_IN_PROGRESS_ERROR);
-		const jid = options.authDir ? toWhatsappJidWithLid(to, { authDir: options.authDir }) : toWhatsappJid(to);
-		await assertCanSendToJid(jid, currentSock, { rememberReady: true });
-	};
-	const sendTrackedMessage = async (jid, content, sendOptions) => {
-		let lastErr = /* @__PURE__ */ new Error(RECONNECT_IN_PROGRESS_ERROR);
-		for (let attempt = 1;; attempt++) {
-			const currentSock = getCurrentSock();
-			if (currentSock) try {
-				await assertCanSendToJid(jid, currentSock, { useVerifiedReady: true });
-				const result = await createWhatsAppSocketOperationTimeoutAdapter(currentSock, sendOperationTimeoutMs, { onSendMessageTimeout: ({ jid: timedOutJid, promise }) => {
-					trackLateAcceptedSend(timedOutJid, promise);
-				} }).sendMessage(jid, content, sendOptions);
-				rememberOutboundMessage(jid, result);
-				return result;
-			} catch (err) {
-				if (!shouldRetryDisconnect() || !isRetryableSendDisconnectError(err)) throw err;
-				lastErr = err;
-				if (shouldClearSocketRefAfterSendFailure(err) && options.socketRef?.current === currentSock) options.socketRef.current = null;
-			}
-			else if (!shouldRetryDisconnect()) throw lastErr;
-			if (attempt >= sendRetryMaxAttempts) throw lastErr;
-			const delayMs = computeBackoff(disconnectRetryPolicy, attempt);
-			logWhatsAppVerbose(options.verbose, `Waiting ${delayMs}ms for WhatsApp reconnect before retrying send to ${jid}: ${formatError(lastErr)}`);
-			try {
-				await sleepWithAbort(delayMs, options.disconnectRetryAbortSignal);
-			} catch {
-				throw lastErr;
-			}
-		}
-	};
-	const sendApiSocketOperations = {
-		sendMessage: (jid, content, sendOptions) => sendTrackedMessage(jid, content, sendOptions),
-		sendPresenceUpdate: async (presenceLocal, jid) => {
-			const currentSock = getCurrentSock();
-			if (!currentSock) throw new Error(RECONNECT_IN_PROGRESS_ERROR);
-			return await createWhatsAppSocketOperationTimeoutAdapter(currentSock, sendOperationTimeoutMs).sendPresenceUpdate(presenceLocal, jid);
-		}
-	};
-	const summarizeGroupMeta = async (meta) => {
-		const participantEntries = await Promise.all(meta.participants?.map(async (p) => {
-			const mapped = await resolveInboundJid(p.id);
-			return {
-				display: mapped ?? p.id,
-				mention: {
-					id: p.id,
-					lid: p.lid,
-					phoneNumber: p.phoneNumber,
-					e164: mapped
-				}
-			};
-		}) ?? []);
-		const participants = participantEntries.map((entry) => entry.display).filter(Boolean);
-		const mentionParticipants = participantEntries.map((entry) => entry.mention);
-		return {
-			subject: meta.subject,
-			participants,
-			mentionParticipants,
-			expires: resolveGroupMetadataExpiresAt() ?? 0
-		};
-	};
-	const summarizeGroupMetaForReconnectCache = (meta) => ({
-		subject: meta.subject,
-		expires: resolveGroupMetadataExpiresAt() ?? NaN
-	});
-	const getGroupMeta = async (jid) => {
-		const cached = readGroupMetadataCacheEntry(groupMetaCache, jid);
-		if (cached) return cached;
-		try {
-			const meta = await (getCurrentSock() ?? sock).groupMetadata(jid);
-			rememberWhatsAppBaileysCacheEntry(options.baileysGroupMetaCache, jid, meta, GROUP_META_TTL_MS);
-			publishedGroupMetadataJids.add(jid);
-			const entry = await summarizeGroupMeta(meta);
-			rememberGroupMetadataCacheEntry(groupMetadataCache, jid, {
-				subject: entry.subject,
-				expires: entry.expires
-			});
-			rememberGroupMetadataCacheEntry(groupMetaCache, jid, entry);
-			return entry;
-		} catch (err) {
-			const hydrated = readGroupMetadataCacheEntry(groupMetadataCache, jid);
-			if (hydrated) {
-				rememberGroupMetadataCacheEntry(groupMetaCache, jid, hydrated);
-				logWhatsAppVerbose(options.verbose, `Using cached group metadata for ${jid} after fetch failure: ${String(err)}`);
-				return hydrated;
-			}
-			logWhatsAppVerbose(options.verbose, `Failed to fetch group metadata for ${jid}: ${String(err)}`);
-			return { expires: resolveGroupMetadataExpiresAt() ?? 0 };
-		}
-	};
-	const resolveOutboundMentionsForGroup = async (jid, text) => {
-		if (isJidGroup(jid) !== true || !mayContainWhatsAppOutboundMention(text)) return {
-			text,
-			mentionedJids: []
-		};
-		return resolveWhatsAppOutboundMentions({
-			chatJid: jid,
-			text,
-			participants: (await getGroupMeta(jid)).mentionParticipants
-		});
-	};
-	const applyOutboundMentionsToContent = async (jid, content) => {
-		if ("text" in content && typeof content.text === "string") {
-			const resolved = await resolveOutboundMentionsForGroup(jid, content.text);
-			return addWhatsAppOutboundMentionsToContent({
-				...content,
-				text: resolved.text
-			}, resolved.mentionedJids);
-		}
-		const caption = content.caption;
-		if (typeof caption === "string") {
-			const resolved = await resolveOutboundMentionsForGroup(jid, caption);
-			return addWhatsAppOutboundMentionsToContent({
-				...content,
-				caption: resolved.text
-			}, resolved.mentionedJids);
-		}
-		return content;
-	};
+//#endregion
+//#region extensions/whatsapp/src/inbound/message-normalization.ts
+function createWhatsAppInboundMessageNormalizer(options) {
+	const { socketSession, groupMetadata } = options;
 	const shouldSkipRecentOutboundEcho = (msg) => {
 		const id = msg.key?.id ?? void 0;
 		const remoteJid = msg.key?.remoteJid;
@@ -1073,44 +1041,43 @@ async function attachWebInboxToSocket(options) {
 			remoteJid,
 			messageId: id
 		})) return false;
-		logWhatsAppVerbose(options.verbose, `Skipping recent outbound WhatsApp echo ${id} for ${remoteJid}`);
+		options.logVerbose(`Skipping recent outbound WhatsApp echo ${id} for ${remoteJid}`);
 		return true;
 	};
-	const normalizeInboundMessage = async (msg) => {
+	const normalize = async (msg) => {
 		const id = msg.key?.id ?? void 0;
 		const remoteJid = msg.key?.remoteJid;
-		if (!remoteJid) return null;
-		if (remoteJid.endsWith("@status") || remoteJid.endsWith("@broadcast")) return null;
+		if (!remoteJid || remoteJid.endsWith("@status") || remoteJid.endsWith("@broadcast")) return null;
 		const group = isJidGroup(remoteJid) === true;
 		if (shouldSkipRecentOutboundEcho(msg)) return null;
 		if (!hasInboundUserContent(msg.message ?? void 0)) return null;
 		const participantJid = msg.key?.participant ?? void 0;
-		const from = group ? remoteJid : await resolveInboundJid(remoteJid);
+		const from = group ? remoteJid : await socketSession.resolveInboundJid(remoteJid);
 		if (!from) return null;
-		const senderE164 = group ? participantJid ? await resolveInboundJid(participantJid) : null : from;
+		const senderE164 = group ? participantJid ? await socketSession.resolveInboundJid(participantJid) : null : from;
 		let groupSubject;
 		let groupParticipants;
 		if (group) {
-			const meta = await getGroupMeta(remoteJid);
+			const meta = await groupMetadata.get(remoteJid);
 			groupSubject = meta.subject;
 			groupParticipants = meta.participants;
 		}
-		const messageTimestampSeconds = parseWhatsAppTimestampSeconds(msg.messageTimestamp);
+		const messageTimestampSeconds = options.parseTimestampSeconds(msg.messageTimestamp);
 		const messageTimestampMs = messageTimestampSeconds !== void 0 ? messageTimestampSeconds * 1e3 : void 0;
 		const access = await checkInboundAccessControl({
 			cfg: options.loadConfig?.() ?? options.cfg,
 			accountId: options.accountId,
 			from,
-			selfE164: self.e164 ?? null,
+			selfE164: socketSession.self.e164 ?? null,
 			senderE164,
 			senderJid: participantJid,
 			group,
 			pushName: msg.pushName ?? void 0,
 			isFromMe: Boolean(msg.key?.fromMe),
 			messageTimestampMs,
-			connectedAtMs,
+			connectedAtMs: socketSession.connectedAtMs,
 			verbose: options.verbose,
-			sock: { sendMessage: (jid, content) => sendTrackedMessage(jid, content) },
+			sock: { sendMessage: (jid, content) => socketSession.sendTrackedMessage(jid, content) },
 			remoteJid
 		});
 		if (!access.allowed) return null;
@@ -1127,6 +1094,58 @@ async function attachWebInboxToSocket(options) {
 			access
 		};
 	};
+	return {
+		normalize,
+		shouldSkipRecentOutboundEcho
+	};
+}
+//#endregion
+//#region extensions/whatsapp/src/inbound/message-delivery.ts
+const INBOUND_CLOSE_DRAIN_TIMEOUT_MS = 5e3;
+const WHATSAPP_INGRESS_DRAIN_INTERVAL_MS = 1e3;
+function parseWhatsAppTimestampSeconds(value) {
+	if (value == null) return;
+	if (typeof value === "string") return parseStrictFiniteNumber(value);
+	const parsed = Number(value);
+	return Number.isFinite(parsed) ? parsed : void 0;
+}
+function logWhatsAppVerbose$1(enabled, message) {
+	if (!enabled) return;
+	defaultRuntime.log(message);
+}
+function recordAcceptedInboundActivity(accountId) {
+	recordChannelActivity({
+		channel: "whatsapp",
+		accountId,
+		direction: "inbound"
+	});
+}
+function createWhatsAppMessageDeliveryCoordinator(options) {
+	const inboundLogger = getChildLogger({ module: "web-inbound" });
+	const inboundConsoleLog = createSubsystemLogger("gateway/channels/whatsapp").child("inbound");
+	const sock = options.sock;
+	const socketSession = options.socketSession;
+	const groupMetadata = options.groupMetadata;
+	const { connectedAtMs, self, getCurrentSock, resolveInboundJid, resolveReactionTargetJids, rememberBaileysMessage, assertCanSendToJid, sendTrackedMessage, socketOperations } = socketSession;
+	const durableInboundQueue = options.durableInboundQueue ?? createWhatsAppDurableInboundQueue(options.accountId);
+	const pendingMessageHandlers = /* @__PURE__ */ new Set();
+	let durableIngressActive = false;
+	let nextReceiveOrder = 0;
+	const publishPendingWorkState = (at = Date.now()) => {
+		options.onPendingWorkChanged?.(pendingMessageHandlers.size + messageDebouncer.pendingWorkCount() + (durableIngressActive ? 1 : 0), at);
+	};
+	const messageNormalizer = createWhatsAppInboundMessageNormalizer({
+		cfg: options.cfg,
+		loadConfig: options.loadConfig,
+		accountId: options.accountId,
+		verbose: options.verbose,
+		socketSession,
+		groupMetadata,
+		parseTimestampSeconds: parseWhatsAppTimestampSeconds,
+		logVerbose: (message) => logWhatsAppVerbose$1(options.verbose, message)
+	});
+	const normalizeInboundMessage = messageNormalizer.normalize;
+	const shouldSkipRecentOutboundEcho = messageNormalizer.shouldSkipRecentOutboundEcho;
 	const buildReadReceiptTarget = (inbound) => inbound.id ? {
 		remoteJid: inbound.remoteJid,
 		id: inbound.id,
@@ -1136,20 +1155,15 @@ async function attachWebInboxToSocket(options) {
 		if (!target || options.sendReadReceipts === false) return;
 		const { id, remoteJid, participant } = target;
 		try {
-			await withWhatsAppSocketOperationTimeout("readMessages", (getCurrentSock() ?? sock).readMessages([{
-				remoteJid,
-				id,
-				participant,
-				fromMe: false
-			}]), sendOperationTimeoutMs);
+			await socketSession.markRead(target);
 			const suffix = participant ? ` (participant ${participant})` : "";
-			logWhatsAppVerbose(options.verbose, `Marked message ${id} as read for ${remoteJid}${suffix}`);
+			logWhatsAppVerbose$1(options.verbose, `Marked message ${id} as read for ${remoteJid}${suffix}`);
 		} catch (err) {
-			logWhatsAppVerbose(options.verbose, `Failed to mark message ${id} read: ${String(err)}`);
+			logWhatsAppVerbose$1(options.verbose, `Failed to mark message ${id} read: ${String(err)}`);
 		}
 	};
 	const maybeLogSkippedSelfChatReadReceipt = (inbound, target) => {
-		if (target?.id && inbound.access.isSelfChat && options.verbose) logWhatsAppVerbose(options.verbose, `Self-chat mode: skipping read receipt for ${target.id}`);
+		if (target?.id && inbound.access.isSelfChat && options.verbose) logWhatsAppVerbose$1(options.verbose, `Self-chat mode: skipping read receipt for ${target.id}`);
 	};
 	const maybeMarkNonSelfChatReadReceipt = async (inbound, target) => {
 		if (inbound.access.isSelfChat) {
@@ -1158,6 +1172,17 @@ async function attachWebInboxToSocket(options) {
 		}
 		await maybeMarkInboundAsRead(target);
 	};
+	const messageDebouncer = createWhatsAppInboundMessageDebouncer({
+		debounceMs: options.debounceMs,
+		onMessage: options.onMessage,
+		shouldDebounce: options.shouldDebounce,
+		markRead: maybeMarkInboundAsRead,
+		onPendingWorkChanged: publishPendingWorkState,
+		onError: (error) => {
+			inboundLogger.error({ error: String(error) }, "failed handling inbound web message");
+			inboundConsoleLog.error(`Failed handling inbound web message: ${String(error)}`);
+		}
+	});
 	const shouldSkipStaleAppend = (msg, upsertType) => {
 		if (upsertType !== "append") return false;
 		const APPEND_RECENT_GRACE_MS = 6e4;
@@ -1167,66 +1192,6 @@ async function attachWebInboxToSocket(options) {
 		return msgTsMs < (options.appendReplyWindow && nowMs <= options.appendReplyWindow.untilMs ? Math.max(options.appendReplyWindow.afterMs, nowMs - options.appendReplyWindow.maxAgeMs) : connectedAtMs - APPEND_RECENT_GRACE_MS);
 	};
 	const preparedInboundByDurableId = /* @__PURE__ */ new Map();
-	const enrichInboundMessage = async (msg) => {
-		const location = extractLocationData(msg.message ?? void 0);
-		const locationText = location ? formatLocationText(location) : void 0;
-		const contactContext = extractContactContext(msg.message ?? void 0);
-		const externalAdReplyContext = extractExternalAdReplyContext(msg.message ?? void 0);
-		let mediaKind = extractMediaKind(msg.message ?? void 0);
-		let body = extractText(msg.message ?? void 0);
-		if (locationText) body = [body, locationText].filter(Boolean).join("\n").trim();
-		if (!body && !mediaKind) return null;
-		body = body ?? "";
-		const commandBody = body;
-		const replyContext = describeReplyContext(msg.message);
-		let mediaPath;
-		let mediaType = mediaKind ? resolveInboundMediaMimetype(msg.message) : void 0;
-		const nativeMedia = mediaKind ? {
-			contentType: mediaType,
-			kind: mediaKind
-		} : void 0;
-		let mediaFileName;
-		const maxBytes = (typeof options.mediaMaxMb === "number" && options.mediaMaxMb > 0 ? options.mediaMaxMb : 50) * 1024 * 1024;
-		const saveInboundMedia = async (inboundMedia) => {
-			if (!inboundMedia) return;
-			mediaPath = inboundMedia.saved.path;
-			mediaType = inboundMedia.mimetype;
-			mediaFileName = inboundMedia.fileName;
-		};
-		try {
-			await saveInboundMedia(await downloadInboundMedia(msg, sock, maxBytes));
-		} catch (err) {
-			logWhatsAppVerbose(options.verbose, `Inbound media download failed: ${String(err)}`);
-			body = formatInboundMediaUnavailableText({
-				body,
-				notice: "[whatsapp attachment unavailable]"
-			});
-		}
-		if (!mediaPath && !mediaKind && replyContext?.media) try {
-			await saveInboundMedia(await downloadQuotedInboundMedia(msg, sock, maxBytes));
-			mediaKind = replyContext.media.kind ?? void 0;
-			mediaType = mediaType ?? replyContext.media.contentType ?? void 0;
-		} catch (err) {
-			logWhatsAppVerbose(options.verbose, `Quoted media download failed: ${String(err)}`);
-			body = formatInboundMediaUnavailableText({
-				body,
-				notice: "[whatsapp quoted attachment unavailable]"
-			});
-		}
-		return {
-			body,
-			commandBody,
-			location: location ?? void 0,
-			contactContext,
-			externalAdReplyContext,
-			replyContext,
-			mediaPath,
-			mediaType,
-			mediaFileName,
-			mediaKind,
-			nativeMedia
-		};
-	};
 	const enqueueInboundMessage = async (msg, inbound, enriched, durable) => {
 		const chatJid = inbound.remoteJid;
 		const sendComposing = async () => {
@@ -1234,18 +1199,18 @@ async function attachWebInboxToSocket(options) {
 			if (!currentSock) return;
 			try {
 				await assertCanSendToJid(chatJid, currentSock);
-				await sendApiSocketOperations.sendPresenceUpdate("composing", chatJid);
+				await socketOperations.sendPresenceUpdate("composing", chatJid);
 			} catch (err) {
-				logWhatsAppVerbose(options.verbose, `Presence update failed: ${String(err)}`);
+				logWhatsAppVerbose$1(options.verbose, `Presence update failed: ${String(err)}`);
 			}
 		};
 		const reply = async (text, optionsResult) => {
-			const resolved = await resolveOutboundMentionsForGroup(chatJid, text);
+			const resolved = await groupMetadata.resolveOutboundMentions(chatJid, text);
 			return normalizeWhatsAppSendResult(await sendTrackedMessage(chatJid, addWhatsAppOutboundMentionsToContent({ text: resolved.text }, resolved.mentionedJids), optionsResult), "text");
 		};
 		const sendMedia = async (payload, optionsValue) => {
 			const previewPayload = await addWhatsAppImagePreviewFields(payload);
-			return normalizeWhatsAppSendResult(await sendTrackedMessage(chatJid, await applyOutboundMentionsToContent(chatJid, previewPayload), optionsValue), "media");
+			return normalizeWhatsAppSendResult(await sendTrackedMessage(chatJid, await groupMetadata.applyOutboundMentions(chatJid, previewPayload), optionsValue), "media");
 		};
 		const timestamp = inbound.messageTimestampMs;
 		const mentionedJids = extractMentionedJids(msg.message);
@@ -1341,15 +1306,6 @@ async function attachWebInboxToSocket(options) {
 			readReceipt: durable.readReceipt,
 			receiveOrder: durable.receiveOrder
 		});
-		const debounceKey = buildInboundDebounceKey(inboundMessage);
-		if (debounceKey) {
-			inboundMessage.debounceKey = debounceKey;
-			if (inboundDebounceMs > 0 && shouldDebounceInboundMessage(inboundMessage)) {
-				pendingDebounceKeys.add(debounceKey);
-				publishPendingWorkState();
-				notifyDebounceWork();
-			}
-		}
 		if (inboundMessage.event.id) {
 			const admission = requireWhatsAppInboundAdmission(inboundMessage);
 			cacheInboundMessageMeta(admission.accountId, inboundMessage.platform.chatJid, inboundMessage.event.id, {
@@ -1360,7 +1316,7 @@ async function attachWebInboxToSocket(options) {
 				fromMe: inboundMessage.platform.fromMe
 			});
 		}
-		await debouncer.enqueue(inboundMessage);
+		await messageDebouncer.enqueue(inboundMessage);
 	};
 	const processDurableInboundMessage = async (admission, lifecycle) => {
 		const { message: msg, ...context } = admission;
@@ -1381,7 +1337,7 @@ async function attachWebInboxToSocket(options) {
 			msg,
 			senderId: inbound.senderE164 ?? inbound.from,
 			resolveReactionTargetJids,
-			logDebug: (message) => logWhatsAppVerbose(options.verbose, message)
+			logDebug: (message) => logWhatsAppVerbose$1(options.verbose, message)
 		})) return "completed";
 		const readReceipt = buildReadReceiptTarget(inbound);
 		const deliveryReadReceipt = inbound.access.isSelfChat ? void 0 : readReceipt;
@@ -1389,7 +1345,12 @@ async function attachWebInboxToSocket(options) {
 			await maybeMarkNonSelfChatReadReceipt(inbound, readReceipt);
 			return "completed";
 		}
-		const enriched = await enrichInboundMessage(msg);
+		const enriched = await enrichWhatsAppInboundMessage({
+			msg,
+			sock,
+			mediaMaxMb: options.mediaMaxMb,
+			logVerbose: (message) => logWhatsAppVerbose$1(options.verbose, message)
+		});
 		if (!enriched) {
 			await maybeMarkNonSelfChatReadReceipt(inbound, deliveryReadReceipt);
 			return "completed";
@@ -1426,7 +1387,7 @@ async function attachWebInboxToSocket(options) {
 				selfLid: self.lid,
 				resolveInboundJid,
 				resolveReactionTargetJids,
-				logVerboseMessage: (message) => logWhatsAppVerbose(options.verbose, message)
+				logVerboseMessage: (message) => logWhatsAppVerbose$1(options.verbose, message)
 			})) continue;
 			const receivedAt = Date.now();
 			const skipStaleAppend = shouldSkipStaleAppend(msg, upsert.type);
@@ -1479,58 +1440,254 @@ async function attachWebInboxToSocket(options) {
 			else finishPreparation(void 0);
 		}
 	};
-	const handleMessagesUpsertEvent = (upsert) => {
-		const task = handleMessagesUpsert(upsert).catch((err) => {
-			inboundLogger.error({ error: String(err) }, "messages.upsert handler error");
-			inboundConsoleLog.error(`Messages upsert handler error: ${String(err)}`);
+	const handleMessagesUpsertEvent = (upsert) => {
+		const task = handleMessagesUpsert(upsert).catch((err) => {
+			inboundLogger.error({ error: String(err) }, "messages.upsert handler error");
+			inboundConsoleLog.error(`Messages upsert handler error: ${String(err)}`);
+		});
+		pendingMessageHandlers.add(task);
+		publishPendingWorkState();
+		task.finally(() => {
+			pendingMessageHandlers.delete(task);
+			publishPendingWorkState();
+		});
+	};
+	const drainDebouncedInboundMessages = async () => {
+		await messageDebouncer.drain();
+	};
+	const drainInboundBeforeSocketClose = async () => {
+		for (;;) {
+			await drainDebouncedInboundMessages();
+			if (pendingMessageHandlers.size === 0) break;
+			const handlers = Array.from(pendingMessageHandlers);
+			await Promise.race([Promise.allSettled(handlers), messageDebouncer.waitForWorkOrIdle(handlers, pendingMessageHandlers.size === 0)]);
+			if (pendingMessageHandlers.size === 0 && !messageDebouncer.hasPendingWork()) break;
+		}
+		await drainDebouncedInboundMessages();
+		for (;;) {
+			await durableInboundMonitor.waitForIdle();
+			if (!messageDebouncer.hasPendingWork()) break;
+			await drainDebouncedInboundMessages();
+		}
+		await durableInboundMonitor.stop();
+	};
+	const drainInboundBeforeSocketCloseWithTimeout = async () => {
+		let timeout = null;
+		try {
+			await Promise.race([drainInboundBeforeSocketClose(), new Promise((_, reject) => {
+				timeout = setTimeout(() => {
+					reject(/* @__PURE__ */ new Error(`Timed out draining WhatsApp inbound debounce after ${INBOUND_CLOSE_DRAIN_TIMEOUT_MS}ms`));
+				}, INBOUND_CLOSE_DRAIN_TIMEOUT_MS);
+				timeout.unref?.();
+			})]);
+		} finally {
+			if (timeout) clearTimeout(timeout);
+			durableInboundMonitor.stop();
+		}
+	};
+	let detachMessagesUpsert;
+	const start = () => {
+		if (detachMessagesUpsert) return;
+		detachMessagesUpsert = socketSession.listen("messages.upsert", handleMessagesUpsertEvent);
+		durableInboundMonitor.start();
+	};
+	const stopIntake = () => {
+		detachMessagesUpsert?.();
+		detachMessagesUpsert = void 0;
+	};
+	return {
+		start,
+		stopIntake,
+		drain: drainInboundBeforeSocketCloseWithTimeout
+	};
+}
+//#endregion
+//#region extensions/whatsapp/src/inbound/socket-session.ts
+const LOGGED_OUT_STATUS = DisconnectReason.loggedOut;
+const RECONNECT_IN_PROGRESS_ERROR = "no active socket - reconnection in progress";
+const BAILEYS_MESSAGE_TTL_MS = 600 * 1e3;
+function isDirectUserJid(jid) {
+	return /^(\d+)(?::\d+)?@(s\.whatsapp\.net|c\.us|lid|hosted|hosted\.lid)$/i.test(jid.trim());
+}
+function getActiveReachoutTimelock(state) {
+	if (state?.isActive !== true) return;
+	const endsAt = state.timeEnforcementEnds?.getTime();
+	return endsAt === void 0 || !Number.isFinite(endsAt) || endsAt > Date.now() ? state : void 0;
+}
+function formatReachoutTimelockError(state) {
+	const details = [state.enforcementType ? `type=${state.enforcementType}` : void 0, state.timeEnforcementEnds instanceof Date && Number.isFinite(state.timeEnforcementEnds.getTime()) ? `until=${state.timeEnforcementEnds.toISOString()}` : void 0].filter(Boolean);
+	return `WhatsApp reachout timelock is active; direct messages are temporarily blocked${details.length ? ` (${details.join(", ")})` : ""}`;
+}
+function isRetryableSendDisconnectError(error) {
+	if (isWhatsAppSocketOperationTimeoutError(error)) return false;
+	return /closed|reset|timed\s*out|disconnect|no active socket/i.test(formatError(error));
+}
+function shouldClearSocketRefAfterSendFailure(error) {
+	return /closed|reset|disconnect|no active socket/i.test(formatError(error));
+}
+async function createWhatsAppAttachedSocketSession(options) {
+	const { sock } = options;
+	const connectedAtMs = Date.now();
+	if (options.socketRef) options.socketRef.current = sock;
+	const shouldRetryDisconnect = () => options.shouldRetryDisconnect?.() === true;
+	const disconnectRetryPolicy = options.disconnectRetryPolicy ?? DEFAULT_RECONNECT_POLICY;
+	const sendRetryMaxAttempts = disconnectRetryPolicy.maxAttempts > 0 ? disconnectRetryPolicy.maxAttempts : DEFAULT_RECONNECT_POLICY.maxAttempts;
+	const sendOperationTimeoutMs = resolveWhatsAppSocketOperationTimeoutMs(options.socketTiming.defaultQueryTimeoutMs);
+	let onCloseResolve = null;
+	const onClose = new Promise((resolve) => {
+		onCloseResolve = resolve;
+	});
+	const resolveClose = (reason) => {
+		if (!onCloseResolve) return;
+		const resolver = onCloseResolve;
+		onCloseResolve = null;
+		resolver(reason);
+	};
+	const presence = options.selfChatMode ? "unavailable" : "available";
+	try {
+		await createWhatsAppSocketOperationTimeoutAdapter(sock, sendOperationTimeoutMs).sendPresenceUpdate(presence);
+		options.logVerbose(`Sent global '${presence}' presence on connect`);
+	} catch (error) {
+		options.logVerbose(`Failed to send '${presence}' presence on connect: ${String(error)}`);
+	}
+	const selfIdentity = await readWebSelfIdentityForDecision(options.authDir, sock.user);
+	if (selfIdentity.outcome === "unstable") throw new WhatsAppAuthUnstableError("WhatsApp auth state is still stabilizing; retrying inbox attach.");
+	const self = selfIdentity.identity;
+	const getCurrentSock = () => {
+		if (!options.socketRef) return sock;
+		if (options.socketRef.current) return options.socketRef.current;
+		if (!self.e164 && !self.jid && !self.lid) return null;
+		const successor = getWhatsAppConnectionController(options.accountId);
+		if (!successor) return null;
+		const successorIdentity = successor.getSelfIdentity();
+		if (!successorIdentity || !identitiesOverlap(self, successorIdentity)) return null;
+		return successor.getCurrentSock();
+	};
+	const lidLookup = sock.signalRepository?.lidMapping;
+	const resolveInboundJid = async (jid) => resolveJidToE164(jid, {
+		authDir: options.authDir,
+		lidLookup
+	});
+	const resolveReactionTargetJids = async (jid) => resolveEquivalentWhatsAppDirectChatJids(jid, {
+		authDir: options.authDir,
+		lidLookup
+	});
+	const rememberBaileysMessage = (remoteJid, messageId, message) => {
+		if (!options.recentMessageKeys || !remoteJid || !messageId || !message) return;
+		rememberWhatsAppBaileysCacheEntry(options.recentMessageKeys, `${remoteJid}:${messageId}`, message, BAILEYS_MESSAGE_TTL_MS);
+	};
+	const rememberOutboundMessage = (remoteJid, result) => {
+		const messageId = typeof result === "object" && result && "key" in result ? result.key?.id ?? "" : "";
+		if (!messageId) return;
+		rememberRecentOutboundMessage({
+			accountId: options.accountId,
+			remoteJid,
+			messageId
 		});
-		pendingMessageHandlers.add(task);
-		publishPendingWorkState();
-		task.finally(() => {
-			pendingMessageHandlers.delete(task);
-			publishPendingWorkState();
+		const message = typeof result === "object" && result && "message" in result ? result.message : void 0;
+		rememberBaileysMessage(remoteJid, messageId, message);
+		cacheInboundMessageMeta(options.accountId, remoteJid, messageId, {
+			fromMe: true,
+			body: extractText(message ?? void 0)
 		});
 	};
-	const drainDebouncedInboundMessages = async () => {
-		while (pendingDebounceKeys.size > 0 || activeInboundFlushes.size > 0) {
-			const debounceKeys = Array.from(pendingDebounceKeys);
-			if (debounceKeys.length > 0) await Promise.all(debounceKeys.map((key) => debouncer.flushKey(key)));
-			const flushes = Array.from(activeInboundFlushes);
-			if (flushes.length > 0) await Promise.allSettled(flushes);
-			await Promise.resolve();
-		}
+	const trackLateAcceptedSend = (jid, promise) => {
+		promise.then((result) => {
+			rememberOutboundMessage(jid, result);
+		}, () => {});
 	};
-	const drainInboundBeforeSocketClose = async () => {
-		groupMetadataCacheClosed = true;
-		for (;;) {
-			await drainDebouncedInboundMessages();
-			if (pendingMessageHandlers.size === 0) break;
-			const handlers = Array.from(pendingMessageHandlers);
-			await Promise.race([Promise.allSettled(handlers), waitForDebounceWorkOrIdle(handlers)]);
-			if (pendingMessageHandlers.size === 0 && pendingDebounceKeys.size === 0 && activeInboundFlushes.size === 0) break;
-		}
-		await drainDebouncedInboundMessages();
-		for (;;) {
-			await durableInboundMonitor.waitForIdle();
-			if (pendingDebounceKeys.size === 0 && activeInboundFlushes.size === 0) break;
-			await drainDebouncedInboundMessages();
+	let reachoutTimeLock;
+	let reachoutTimeLockFetch;
+	let reachoutTimeLockVersion = 0;
+	let verifiedSendReady;
+	const rememberReachoutTimeLock = (state) => {
+		reachoutTimeLock = state;
+		reachoutTimeLockVersion += 1;
+		verifiedSendReady = void 0;
+	};
+	const fetchReachoutTimeLock = async (currentSock) => {
+		if (typeof currentSock.fetchAccountReachoutTimelock !== "function") return;
+		if (!reachoutTimeLockFetch) reachoutTimeLockFetch = currentSock.fetchAccountReachoutTimelock().then((state) => {
+			rememberReachoutTimeLock(state);
+			return state;
+		}).catch((error) => {
+			options.logVerbose(`Failed fetching WhatsApp reachout timelock before send: ${formatError(error)}`);
+		}).finally(() => {
+			reachoutTimeLockFetch = void 0;
+		});
+		return await reachoutTimeLockFetch;
+	};
+	const rememberVerifiedSendReady = (jid, currentSock) => {
+		verifiedSendReady = {
+			jid,
+			sock: currentSock,
+			reachoutTimeLockVersion
+		};
+	};
+	const consumeVerifiedSendReady = (jid, currentSock) => {
+		if (verifiedSendReady?.jid !== jid || verifiedSendReady.sock !== currentSock || verifiedSendReady.reachoutTimeLockVersion !== reachoutTimeLockVersion) return false;
+		verifiedSendReady = void 0;
+		return true;
+	};
+	const assertCanSendToJid = async (jid, currentSock, readinessOptions) => {
+		if (!isDirectUserJid(jid)) return;
+		if (readinessOptions?.useVerifiedReady && consumeVerifiedSendReady(jid, currentSock)) return;
+		const state = getActiveReachoutTimelock(reachoutTimeLock) ?? await fetchReachoutTimeLock(currentSock);
+		const activeState = getActiveReachoutTimelock(state);
+		if (activeState) throw new Error(formatReachoutTimelockError(activeState));
+		if (readinessOptions?.rememberReady && state) rememberVerifiedSendReady(jid, currentSock);
+	};
+	const assertSendReady = async (to) => {
+		const currentSock = getCurrentSock();
+		if (!currentSock) throw new Error(RECONNECT_IN_PROGRESS_ERROR);
+		const jid = options.authDir ? toWhatsappJidWithLid(to, { authDir: options.authDir }) : toWhatsappJid(to);
+		await assertCanSendToJid(jid, currentSock, { rememberReady: true });
+	};
+	const sendTrackedMessage = async (jid, content, sendOptions) => {
+		let lastError = /* @__PURE__ */ new Error(RECONNECT_IN_PROGRESS_ERROR);
+		for (let attempt = 1;; attempt += 1) {
+			const currentSock = getCurrentSock();
+			if (currentSock) try {
+				await assertCanSendToJid(jid, currentSock, { useVerifiedReady: true });
+				const result = await createWhatsAppSocketOperationTimeoutAdapter(currentSock, sendOperationTimeoutMs, { onSendMessageTimeout: ({ jid: timedOutJid, promise }) => {
+					trackLateAcceptedSend(timedOutJid, promise);
+				} }).sendMessage(jid, content, sendOptions);
+				rememberOutboundMessage(jid, result);
+				return result;
+			} catch (error) {
+				if (!shouldRetryDisconnect() || !isRetryableSendDisconnectError(error)) throw error;
+				lastError = error;
+				if (shouldClearSocketRefAfterSendFailure(error) && options.socketRef?.current === currentSock) options.socketRef.current = null;
+			}
+			else if (!shouldRetryDisconnect()) throw lastError;
+			if (attempt >= sendRetryMaxAttempts) throw lastError;
+			const delayMs = computeBackoff(disconnectRetryPolicy, attempt);
+			options.logVerbose(`Waiting ${delayMs}ms for WhatsApp reconnect before retrying send to ${jid}: ${formatError(lastError)}`);
+			try {
+				await sleepWithAbort(delayMs, options.disconnectRetryAbortSignal);
+			} catch {
+				throw lastError;
+			}
 		}
-		await durableInboundMonitor.stop();
 	};
-	const drainInboundBeforeSocketCloseWithTimeout = async () => {
-		let timeout = null;
-		try {
-			await Promise.race([drainInboundBeforeSocketClose(), new Promise((_, reject) => {
-				timeout = setTimeout(() => {
-					reject(/* @__PURE__ */ new Error(`Timed out draining WhatsApp inbound debounce after ${INBOUND_CLOSE_DRAIN_TIMEOUT_MS}ms`));
-				}, INBOUND_CLOSE_DRAIN_TIMEOUT_MS);
-				timeout.unref?.();
-			})]);
-		} finally {
-			if (timeout) clearTimeout(timeout);
-			durableInboundMonitor.stop();
+	const socketOperations = {
+		sendMessage: (jid, content, sendOptions) => sendTrackedMessage(jid, content, sendOptions),
+		sendPresenceUpdate: async (presenceLocal, jid) => {
+			const currentSock = getCurrentSock();
+			if (!currentSock) throw new Error(RECONNECT_IN_PROGRESS_ERROR);
+			return await createWhatsAppSocketOperationTimeoutAdapter(currentSock, sendOperationTimeoutMs).sendPresenceUpdate(presenceLocal, jid);
 		}
 	};
+	const markRead = async (target) => {
+		const { id, remoteJid, participant } = target;
+		await withWhatsAppSocketOperationTimeout("readMessages", (getCurrentSock() ?? sock).readMessages([{
+			remoteJid,
+			id,
+			participant,
+			fromMe: false
+		}]), sendOperationTimeoutMs);
+	};
+	const attachSockListener = (event, listener) => attachEmitterListener(sock.ev, event, listener);
 	const handleConnectionUpdate = (update) => {
 		try {
 			if ("reachoutTimeLock" in update) rememberReachoutTimeLock(update.reachoutTimeLock);
@@ -1543,101 +1700,135 @@ async function attachWebInboxToSocket(options) {
 					error: update.lastDisconnect?.error
 				});
 			}
-		} catch (err) {
-			inboundLogger.error({ error: String(err) }, "connection.update handler error");
+		} catch (error) {
+			options.logConnectionError(error);
 			resolveClose({
 				status: void 0,
 				isLoggedOut: false,
-				error: err
+				error
 			});
 		}
 	};
-	const attachSockListener = (event, listener) => attachEmitterListener(sock.ev, event, listener);
-	const detachMessagesUpsert = attachSockListener("messages.upsert", handleMessagesUpsertEvent);
-	const detachConnectionUpdate = attachSockListener("connection.update", handleConnectionUpdate);
-	const isFullGroupMetadataUpdate = (update) => typeof update.id === "string" && typeof update.subject === "string" && Array.isArray(update.participants);
-	const rememberFullGroupMetadataUpdate = (jid, meta) => {
-		if (groupMetadataCacheClosed) return;
-		rememberWhatsAppBaileysCacheEntry(options.baileysGroupMetaCache, jid, meta, GROUP_META_TTL_MS);
-		publishedGroupMetadataJids.add(jid);
-		invalidatedGroupMetadataJids.delete(jid);
-		rememberGroupMetadataCacheEntry(groupMetadataCache, jid, summarizeGroupMetaForReconnectCache(meta));
-		groupMetaCache.delete(jid);
+	let detachConnectionUpdate;
+	const start = () => {
+		detachConnectionUpdate ??= attachSockListener("connection.update", handleConnectionUpdate);
 	};
-	const forgetFullGroupMetadata = (jid) => {
-		options.baileysGroupMetaCache?.delete(jid);
-		groupMetadataCache.delete(jid);
-		groupMetaCache.delete(jid);
-		publishedGroupMetadataJids.delete(jid);
-		invalidatedGroupMetadataJids.add(jid);
+	const stop = () => {
+		detachConnectionUpdate?.();
+		detachConnectionUpdate = void 0;
 	};
-	const detachGroupsUpsert = attachSockListener("groups.upsert", ((groups) => {
-		for (const group of groups) if (group.id) rememberFullGroupMetadataUpdate(group.id, group);
-	}));
-	const detachGroupsUpdate = attachSockListener("groups.update", ((updates) => {
-		for (const update of updates) {
-			if (!update.id) continue;
-			if (isFullGroupMetadataUpdate(update)) {
-				rememberFullGroupMetadataUpdate(update.id, update);
-				continue;
-			}
-			forgetFullGroupMetadata(update.id);
-		}
-	}));
-	const detachGroupParticipantsUpdate = attachSockListener("group-participants.update", ((update) => {
-		forgetFullGroupMetadata(update.id);
-	}));
-	durableInboundMonitor.start();
-	(async () => {
+	const closeSocket = () => {
 		try {
-			const groups = await sock.groupFetchAllParticipating();
-			if (groupMetadataCacheClosed) return;
-			for (const [jid, meta] of Object.entries(groups ?? {})) if (meta && !publishedGroupMetadataJids.has(jid) && !invalidatedGroupMetadataJids.has(jid)) {
-				rememberGroupMetadataCacheEntry(groupMetadataCache, jid, summarizeGroupMetaForReconnectCache(meta));
-				rememberWhatsAppBaileysCacheEntry(options.baileysGroupMetaCache, jid, meta, GROUP_META_TTL_MS);
-				publishedGroupMetadataJids.add(jid);
-			}
-			logWhatsAppVerbose(options.verbose, `Hydrated ${Object.keys(groups ?? {}).length} participating groups on connect`);
-		} catch (err) {
-			const error = String(err);
+			closeInboundMonitorSocket(sock);
+		} catch (error) {
+			options.logVerbose(`Socket close failed: ${String(error)}`);
+		}
+	};
+	return {
+		connectedAtMs,
+		self,
+		onClose,
+		signalClose: (reason) => {
+			resolveClose(reason ?? {
+				status: void 0,
+				isLoggedOut: false,
+				error: "closed"
+			});
+		},
+		start,
+		stop,
+		closeSocket,
+		listen: attachSockListener,
+		getCurrentSock,
+		resolveInboundJid,
+		resolveReactionTargetJids,
+		rememberBaileysMessage,
+		assertCanSendToJid,
+		assertSendReady,
+		sendTrackedMessage,
+		socketOperations,
+		markRead
+	};
+}
+//#endregion
+//#region extensions/whatsapp/src/inbound/monitor.ts
+function logWhatsAppVerbose(enabled, message) {
+	if (enabled) defaultRuntime.log(message);
+}
+async function attachWebInboxToSocket(options) {
+	const inboundLogger = getChildLogger({ module: "web-inbound" });
+	const inboundConsoleLog = createSubsystemLogger("gateway/channels/whatsapp").child("inbound");
+	const socketSession = await createWhatsAppAttachedSocketSession({
+		sock: options.sock,
+		socketRef: options.socketRef,
+		accountId: options.accountId,
+		authDir: options.authDir,
+		selfChatMode: options.selfChatMode,
+		socketTiming: options.socketTiming,
+		shouldRetryDisconnect: options.shouldRetryDisconnect,
+		disconnectRetryPolicy: options.disconnectRetryPolicy,
+		disconnectRetryAbortSignal: options.disconnectRetryAbortSignal,
+		recentMessageKeys: options.recentMessageKeys,
+		logVerbose: (message) => logWhatsAppVerbose(options.verbose, message),
+		logConnectionError: (error) => {
+			inboundLogger.error({ error: String(error) }, "connection.update handler error");
+		}
+	});
+	const groupMetadata = createWhatsAppGroupMetadataCacheOwner({
+		sock: options.sock,
+		getCurrentSock: socketSession.getCurrentSock,
+		resolveInboundJid: socketSession.resolveInboundJid,
+		reconnectCache: options.groupMetadataCache,
+		baileysCache: options.baileysGroupMetaCache,
+		listen: socketSession.listen,
+		logVerbose: (message) => logWhatsAppVerbose(options.verbose, message),
+		logHydrationWarning: (error) => {
 			inboundLogger.warn({ error }, "failed hydrating participating groups on connect");
 			inboundConsoleLog.warn(`Failed hydrating participating groups on connect: ${error}`);
-			logWhatsAppVerbose(options.verbose, `Failed to hydrate participating groups on connect: ${error}`);
 		}
-	})();
+	});
+	const delivery = createWhatsAppMessageDeliveryCoordinator({
+		cfg: options.cfg,
+		loadConfig: options.loadConfig,
+		verbose: options.verbose,
+		accountId: options.accountId,
+		sock: options.sock,
+		socketSession,
+		groupMetadata,
+		onMessage: options.onMessage,
+		mediaMaxMb: options.mediaMaxMb,
+		sendReadReceipts: options.sendReadReceipts,
+		debounceMs: options.debounceMs,
+		appendReplyWindow: options.appendReplyWindow,
+		shouldDebounce: options.shouldDebounce,
+		onPendingWorkChanged: options.onPendingWorkChanged,
+		durableInboundQueue: options.durableInboundQueue ?? createWhatsAppDurableInboundQueue(options.accountId)
+	});
 	const sendApi = createWebSendApi({
-		sock: sendApiSocketOperations,
+		sock: socketSession.socketOperations,
 		defaultAccountId: options.accountId,
-		resolveOutboundMentions: ({ jid, text }) => resolveOutboundMentionsForGroup(jid, text),
+		resolveOutboundMentions: ({ jid, text }) => groupMetadata.resolveOutboundMentions(jid, text),
 		authDir: options.authDir
 	});
+	delivery.start();
+	socketSession.start();
+	groupMetadata.start();
 	return {
 		close: async () => {
+			delivery.stopIntake();
+			socketSession.stop();
+			groupMetadata.close();
 			try {
-				detachMessagesUpsert();
-				detachConnectionUpdate();
-				detachGroupsUpsert();
-				detachGroupsUpdate();
-				detachGroupParticipantsUpdate();
-				await drainInboundBeforeSocketCloseWithTimeout();
-			} catch (err) {
-				logWhatsAppVerbose(options.verbose, `Inbound close drain failed: ${String(err)}`);
-			}
-			try {
-				closeInboundMonitorSocket(sock);
-			} catch (err) {
-				logWhatsAppVerbose(options.verbose, `Socket close failed: ${String(err)}`);
+				await delivery.drain();
+			} catch (error) {
+				logWhatsAppVerbose(options.verbose, `Inbound close drain failed: ${String(error)}`);
+			} finally {
+				socketSession.closeSocket();
 			}
 		},
-		onClose,
-		signalClose: (reason) => {
-			resolveClose(reason ?? {
-				status: void 0,
-				isLoggedOut: false,
-				error: "closed"
-			});
-		},
-		assertSendReady: assertCanSendTo,
+		onClose: socketSession.onClose,
+		signalClose: socketSession.signalClose,
+		assertSendReady: socketSession.assertSendReady,
 		sendComposingTo: sendApi.sendComposingTo,
 		sendMessage: sendApi.sendMessage,
 		sendPoll: sendApi.sendPoll,
@@ -1659,18 +1850,16 @@ async function monitorWebInbox(options) {
 	});
 	try {
 		await waitForWaConnection(sock, { timeoutMs: socketTiming.connectTimeoutMs });
-	} catch (err) {
+	} catch (error) {
 		closeInboundMonitorSocket(sock);
-		throw err;
+		throw error;
 	}
-	const shouldDebounce = options.shouldDebounce;
-	const normalizeAdmittedWebInboundMessage = (msg) => requireAdmittedWhatsAppInboundMessage(normalizeWebInboundMessage(msg));
 	return attachWebInboxToSocket({
 		...options,
 		onMessage: async (msg) => {
 			await options.onMessage(normalizeAdmittedWebInboundMessage(msg));
 		},
-		shouldDebounce: shouldDebounce ? (msg) => shouldDebounce(normalizeAdmittedWebInboundMessage(msg)) : void 0,
+		shouldDebounce: options.shouldDebounce ? (msg) => options.shouldDebounce?.(normalizeAdmittedWebInboundMessage(msg)) ?? true : void 0,
 		socketTiming,
 		sock,
 		recentMessageKeys,
@@ -1848,6 +2037,7 @@ function createEchoTracker(params) {
 	const recentlySent = /* @__PURE__ */ new Set();
 	const maxItems = Math.max(1, params.maxItems ?? 100);
 	const buildCombinedKey = (p) => `combined:${p.sessionKey}:${p.combinedBody}`;
+	const buildTextKey = (text, conversationId) => conversationId ? `${conversationId}\0${text}` : text;
 	const trim = () => {
 		while (recentlySent.size > maxItems) {
 			const firstKey = recentlySent.values().next().value;
@@ -1857,7 +2047,7 @@ function createEchoTracker(params) {
 	};
 	const rememberText = (text, opts) => {
 		if (!text) return;
-		recentlySent.add(text);
+		recentlySent.add(buildTextKey(text, opts.conversationId));
 		if (opts.combinedBody && opts.combinedBodySessionKey) recentlySent.add(buildCombinedKey({
 			sessionKey: opts.combinedBodySessionKey,
 			combinedBody: opts.combinedBody
@@ -1867,9 +2057,9 @@ function createEchoTracker(params) {
 	};
 	return {
 		rememberText,
-		has: (key) => recentlySent.has(key),
-		forget: (key) => {
-			recentlySent.delete(key);
+		has: (key, conversationId) => recentlySent.has(buildTextKey(key, conversationId)),
+		forget: (key, conversationId) => {
+			recentlySent.delete(buildTextKey(key, conversationId));
 		},
 		buildCombinedKey
 	};
@@ -2465,6 +2655,20 @@ function isLikelyWhatsAppCryptoError(reason) {
 }
 //#endregion
 //#region extensions/whatsapp/src/auto-reply/deliver-reply.ts
+function createWhatsAppReplyTransportContext(msg) {
+	const admission = requireWhatsAppInboundAdmission(msg);
+	return {
+		accountId: admission.accountId,
+		conversationId: admission.conversation.id,
+		conversationKind: admission.conversation.kind,
+		chatJid: msg.platform.chatJid,
+		senderJid: msg.platform.senderJid,
+		recipientJid: msg.platform.recipientJid,
+		correlationId: msg.event.id,
+		reply: msg.platform.reply,
+		sendMedia: msg.platform.sendMedia
+	};
+}
 function resolveWhatsAppReceiptKind(results) {
 	if (results.length > 0 && results.every((result) => result.kind === "text")) return "text";
 	if (results.length > 0 && results.every((result) => result.kind === "media")) return "media";
@@ -2502,10 +2706,9 @@ function createWhatsAppReplyDeliveryReceipt(results) {
 	});
 }
 async function deliverWebReply(params) {
-	const { replyResult, msg, maxMediaBytes, textLimit, replyLogger, connectionId, skipLog } = params;
-	const admission = requireWhatsAppInboundAdmission(msg);
-	const conversationId = admission.conversation.id;
-	const isGroupConversation = admission.conversation.kind === "group";
+	const { replyResult, transport, maxMediaBytes, textLimit, replyLogger, connectionId, skipLog } = params;
+	const conversationId = transport.conversationId;
+	const isGroupConversation = transport.conversationKind === "group";
 	const replyStarted = Date.now();
 	const sendResults = [];
 	const rememberSendResult = (result) => {
@@ -2530,12 +2733,12 @@ async function deliverWebReply(params) {
 	const mediaList = normalizedReply.mediaUrls ?? [];
 	const getQuote = () => {
 		if (!replyResult.replyToId) return;
-		const cached = lookupInboundMessageMeta(admission.accountId, msg.platform.chatJid, replyResult.replyToId);
+		const cached = lookupInboundMessageMeta(transport.accountId, transport.chatJid, replyResult.replyToId);
 		return buildQuotedMessageOptions({
 			messageId: replyResult.replyToId,
-			remoteJid: msg.platform.chatJid,
+			remoteJid: transport.chatJid,
 			fromMe: cached?.fromMe ?? false,
-			participant: cached?.participant ?? (isGroupConversation ? msg.platform.senderJid : void 0),
+			participant: cached?.participant ?? (isGroupConversation ? transport.senderJid : void 0),
 			messageText: cached?.body ?? "",
 			media: cached?.media
 		});
@@ -2558,7 +2761,7 @@ async function deliverWebReply(params) {
 		for (const [index, chunk] of textChunks.entries()) {
 			const chunkStarted = Date.now();
 			const quote = getQuote();
-			rememberSendResult(await sendWithRetry(() => msg.platform.reply(chunk, quote), "text"));
+			rememberSendResult(await sendWithRetry(() => transport.reply(chunk, quote), "text"));
 			if (!skipLog) {
 				const durationMs = Date.now() - chunkStarted;
 				whatsappOutboundLog.debug(`Sent chunk ${index + 1}/${totalChunks} to ${conversationId} (${durationMs.toFixed(0)}ms)`);
@@ -2566,10 +2769,10 @@ async function deliverWebReply(params) {
 		}
 		const delivery = finishDelivery();
 		const logPayload = {
-			correlationId: msg.event.id ?? newConnectionId(),
+			correlationId: transport.correlationId ?? newConnectionId(),
 			connectionId: connectionId ?? null,
 			to: conversationId,
-			from: msg.platform.recipientJid,
+			from: transport.recipientJid,
 			text: elide(replyResult.text, 240),
 			mediaUrl: null,
 			mediaSizeBytes: null,
@@ -2595,29 +2798,29 @@ async function deliverWebReply(params) {
 			}
 			if (media.kind === "image") {
 				const quote = getQuote();
-				rememberSendResult(await sendWithRetry(() => msg.platform.sendMedia({
+				rememberSendResult(await sendWithRetry(() => transport.sendMedia({
 					image: media.buffer,
 					caption,
 					mimetype: media.mimetype
 				}, quote), "media:image"));
 			} else if (media.kind === "audio") {
 				const quote = getQuote();
-				rememberSendResult(await sendWithRetry(() => msg.platform.sendMedia({
+				rememberSendResult(await sendWithRetry(() => transport.sendMedia({
 					audio: media.buffer,
 					ptt: true,
 					mimetype: media.mimetype
 				}, quote), "media:audio"));
-				if (caption) rememberSendResult(await sendWithRetry(() => msg.platform.reply(caption, quote), "media:audio-text"));
+				if (caption) rememberSendResult(await sendWithRetry(() => transport.reply(caption, quote), "media:audio-text"));
 			} else if (media.kind === "video") {
 				const quote = getQuote();
-				rememberSendResult(await sendWithRetry(() => msg.platform.sendMedia({
+				rememberSendResult(await sendWithRetry(() => transport.sendMedia({
 					video: media.buffer,
 					caption,
 					mimetype: media.mimetype
 				}, quote), "media:video"));
 			} else {
 				const quote = getQuote();
-				rememberSendResult(await sendWithRetry(() => msg.platform.sendMedia({
+				rememberSendResult(await sendWithRetry(() => transport.sendMedia({
 					document: media.buffer,
 					fileName: media.fileName,
 					caption,
@@ -2626,10 +2829,10 @@ async function deliverWebReply(params) {
 			}
 			whatsappOutboundLog.info(`Sent media reply to ${conversationId} (${(media.buffer.length / (1024 * 1024)).toFixed(2)}MB)`);
 			replyLogger.info({
-				correlationId: msg.event.id ?? newConnectionId(),
+				correlationId: transport.correlationId ?? newConnectionId(),
 				connectionId: connectionId ?? null,
 				to: conversationId,
-				from: msg.platform.recipientJid,
+				from: transport.recipientJid,
 				text: caption ?? null,
 				mediaUrl,
 				mediaSizeBytes: media.buffer.length,
@@ -2645,16 +2848,16 @@ async function deliverWebReply(params) {
 			}, "failed to send web media reply");
 			if (!isFirst) {
 				whatsappOutboundLog.warn(`Trailing media failed; sent warning to ${conversationId}`);
-				rememberSendResult(await sendWithRetry(() => msg.platform.reply("⚠️ Media unavailable.", getQuote()), "media:fallback-unavailable"));
+				rememberSendResult(await sendWithRetry(() => transport.reply("⚠️ Media unavailable.", getQuote()), "media:fallback-unavailable"));
 				return;
 			}
 			const fallbackText = [caption ?? "", "⚠️ Media failed."].filter(Boolean).join("\n");
 			if (!fallbackText) return;
 			whatsappOutboundLog.warn(`Media skipped; sent text-only to ${conversationId}`);
-			rememberSendResult(await sendWithRetry(() => msg.platform.reply(fallbackText, getQuote()), "media:fallback-text"));
+			rememberSendResult(await sendWithRetry(() => transport.reply(fallbackText, getQuote()), "media:fallback-text"));
 		}
 	});
-	for (const chunk of remainingText) rememberSendResult(await sendWithRetry(() => msg.platform.reply(chunk, getQuote()), "media:text"));
+	for (const chunk of remainingText) rememberSendResult(await sendWithRetry(() => transport.reply(chunk, getQuote()), "media:text"));
 	return finishDelivery();
 }
 //#endregion
@@ -2715,6 +2918,65 @@ function resolveVisibleWhatsAppReplyContext(params) {
 	} : null;
 }
 //#endregion
+//#region extensions/whatsapp/src/auto-reply/monitor/prepared-inbound.ts
+function resolvePreparedCommandFacts(command) {
+	if (!command) return;
+	const { authorization, ...facts } = command;
+	return {
+		...facts,
+		...authorization.kind === "not_checked" ? {} : { authorized: authorization.kind === "authorized" }
+	};
+}
+function projectPreparedChannelInbound(params) {
+	const { inbound, control } = params;
+	const command = resolvePreparedCommandFacts(inbound.command);
+	const commandAuthorization = inbound.command?.authorization;
+	const commandAccess = commandAuthorization && commandAuthorization.kind !== "not_checked" ? { authorized: commandAuthorization.kind === "authorized" } : void 0;
+	return {
+		input: {
+			id: inbound.event.id,
+			timestamp: inbound.event.timestamp,
+			rawText: inbound.message.rawBody,
+			textForAgent: inbound.message.bodyForAgent,
+			textForCommands: inbound.message.commandBody,
+			raw: inbound
+		},
+		context: buildChannelInboundEventContext({
+			...inbound,
+			messageId: inbound.event.id,
+			messageIdFull: inbound.event.fullId,
+			timestamp: inbound.event.timestamp,
+			command,
+			access: inbound.mentions || commandAccess ? {
+				mentions: inbound.mentions,
+				commands: commandAccess
+			} : void 0,
+			extra: {
+				Transcript: inbound.context?.transcript,
+				...inbound.context && "groupSubject" in inbound.context ? { GroupSubject: inbound.context.groupSubject ?? void 0 } : {},
+				GroupMembers: inbound.context?.groupMembers,
+				SenderE164: inbound.context?.senderE164,
+				ReplyThreading: inbound.context?.replyThreading,
+				SuppressMessageReceivedHooks: control.messageReceivedHooks === "channel",
+				...inbound.context?.location ? toLocationContext(inbound.context.location) : {}
+			}
+		})
+	};
+}
+/** Keeps WhatsApp reply-policy mapping beside the transport that applies it. */
+function resolveWhatsAppInboundReplyPolicy(params) {
+	const sourceReplyDeliveryMode = params.ctx.ChatType === "group" || params.ctx.ChatType === "channel" ? resolveChannelMessageSourceReplyDeliveryMode({
+		cfg: params.cfg,
+		ctx: params.ctx
+	}) : void 0;
+	const sourceRepliesAreToolOnly = sourceReplyDeliveryMode === "message_tool_only";
+	return {
+		sourceReplyDeliveryMode,
+		disableBlockStreaming: sourceRepliesAreToolOnly ? true : typeof params.blockStreamingEnabled === "boolean" ? !params.blockStreamingEnabled : void 0,
+		suppressTyping: sourceRepliesAreToolOnly && params.ctx.ChatType === "group" && params.ctx.WasMentioned !== true
+	};
+}
+//#endregion
 //#region extensions/whatsapp/src/auto-reply/monitor/inbound-dispatch.ts
 function normalizeErrForLog(err) {
 	if (err instanceof Error) return {
@@ -2728,6 +2990,15 @@ function normalizeErrForLog(err) {
 function whatsAppReplyDeliveryVisibility(visibleReplySent) {
 	return { visibleReplySent };
 }
+function createWhatsAppChannelDeliveryResult(params) {
+	const messageIds = listMessageReceiptPlatformIds(params.delivery.receipt);
+	return {
+		receipt: params.delivery.receipt,
+		...messageIds.length > 0 ? { messageIds } : {},
+		content: params.content,
+		visibleReplySent: params.delivery.providerAccepted
+	};
+}
 function isWhatsAppVisibleDeliveryError(error) {
 	return typeof error === "object" && error !== null && !Array.isArray(error) && error.visibleReplySent === true || isChannelPartialDeliveryError(error) && error.deliveryResult.visibleReplySent;
 }
@@ -2740,16 +3011,15 @@ function markWhatsAppReplyDeliveryErrorVisibleAfterFlush(error, flushResult) {
 	return markWhatsAppVisibleDeliveryError(new Error("deferred WhatsApp media delivery failed after an earlier visible send", { cause: error }));
 }
 function logWhatsAppReplyDeliveryError(params) {
-	const admission = requireWhatsAppInboundAdmission(params.msg);
 	params.replyLogger.error({
 		err: normalizeErrForLog(params.err),
 		replyKind: params.info.kind,
-		correlationId: params.msg.event.id ?? null,
+		correlationId: params.transport.correlationId ?? null,
 		connectionId: params.connectionId,
-		conversationId: admission.conversation.id,
-		chatId: params.msg.platform.chatJid ?? null,
-		to: admission.conversation.id,
-		from: params.msg.platform.recipientJid ?? null
+		conversationId: params.transport.conversationId,
+		chatId: params.transport.chatJid,
+		to: params.transport.conversationId,
+		from: params.transport.recipientJid
 	}, "auto-reply delivery failed");
 }
 function resolveWhatsAppDurableReplyToId(params) {
@@ -2757,14 +3027,10 @@ function resolveWhatsAppDurableReplyToId(params) {
 	const explicitPayloadReplyToId = readTrimmedString(params.payload.replyToId);
 	if (explicitPayloadReplyToId) return explicitPayloadReplyToId;
 	const hasVisibleInboundReplyTarget = Boolean(readTrimmedString(params.context.ReplyToId)) || Boolean(readTrimmedString(params.context.ReplyToIdFull));
-	const currentInboundMessageId = readTrimmedString(params.msg.event.id);
+	const currentInboundMessageId = readTrimmedString(params.currentMessageId);
 	if (params.info.kind === "final" && hasVisibleInboundReplyTarget && currentInboundMessageId) return currentInboundMessageId;
 	return null;
 }
-function resolveWhatsAppDisableBlockStreaming(cfg) {
-	const enabled = resolveChannelStreamingBlockEnabled(cfg.channels?.whatsapp);
-	return typeof enabled === "boolean" ? !enabled : void 0;
-}
 function resolveWhatsAppDeliverablePayload(payload, info) {
 	if (payload.isReasoning === true || payload.isCompactionNotice === true) return null;
 	if (payload.isError === true) return null;
@@ -2852,7 +3118,13 @@ function resolveWhatsAppResponsePrefix(params) {
 	const configuredResponsePrefix = params.cfg.messages?.responsePrefix;
 	return params.pipelineResponsePrefix ?? (configuredResponsePrefix === "auto" ? resolveIdentityNamePrefix$1(params.cfg, params.agentId) : configuredResponsePrefix) ?? (params.isSelfChat ? resolveIdentityNamePrefix$1(params.cfg, params.agentId) : void 0);
 }
-async function buildWhatsAppInboundContext(params) {
+function buildWhatsAppInboundTransportContext(msg) {
+	return {
+		...createWhatsAppReplyTransportContext(msg),
+		sendComposing: msg.platform.sendComposing
+	};
+}
+async function prepareWhatsAppInboundContext(params) {
 	const admission = requireWhatsAppInboundAdmission(params.msg);
 	const conversationId = admission.conversation.id;
 	const conversationKind = admission.conversation.kind;
@@ -2867,13 +3139,14 @@ async function buildWhatsAppInboundContext(params) {
 		})),
 		limit: params.groupHistory?.length ?? 1
 	}) : void 0;
-	const media = toInboundMediaFacts(params.msg.payload.media ? [{
+	const media = await toInboundMediaFactsWithMetadata(params.msg.payload.media ? [{
 		path: params.msg.payload.media?.path,
 		url: params.msg.payload.media?.url ?? params.msg.payload.media?.path,
 		contentType: params.msg.payload.media?.type,
 		kind: params.msg.payload.media?.kind
 	}] : void 0, { transcribed: (_entry, index) => params.mediaTranscribedIndexes?.includes(index) === true });
-	return buildChannelInboundEventContext({
+	const control = { messageReceivedHooks: params.suppressMessageReceivedHooks ? "channel" : "core" };
+	const inbound = {
 		channel: "whatsapp",
 		supplemental: {
 			quote: params.visibleReplyTo ? {
@@ -2885,8 +3158,10 @@ async function buildWhatsAppInboundContext(params) {
 			channelStructuredContext: params.msg.payload.channelStructuredContext
 		},
 		media,
-		messageId: params.msg.event.id,
-		timestamp: params.msg.event.timestamp,
+		event: {
+			id: params.msg.event.id ?? `${conversationId}:${newConnectionId()}`,
+			timestamp: params.msg.event.timestamp
+		},
 		from: conversationId,
 		sender: {
 			id: params.sender.id ?? params.sender.e164,
@@ -2905,7 +3180,8 @@ async function buildWhatsAppInboundContext(params) {
 		},
 		reply: {
 			to: params.msg.platform.recipientJid,
-			originatingTo: conversationId
+			originatingTo: conversationId,
+			replyToId: params.visibleReplyTo?.id
 		},
 		message: {
 			body: params.combinedBody,
@@ -2915,29 +3191,35 @@ async function buildWhatsAppInboundContext(params) {
 			commandBody: params.command?.body ?? params.msg.payload.body
 		},
 		sessionTranscript: { historyLimit: conversationKind === "group" ? params.groupHistoryLimit ?? params.groupHistory?.length ?? 0 : 0 },
-		access: {
-			...wasMentioned !== void 0 ? { mentions: {
-				canDetectMention: conversationKind === "group",
-				wasMentioned,
-				requireMention: params.msg.groupMention?.requireMention
-			} } : {},
-			commands: { authorized: params.command?.authorized === true }
-		},
+		mentions: wasMentioned !== void 0 ? {
+			canDetectMention: conversationKind === "group",
+			wasMentioned,
+			requireMention: params.msg.groupMention?.requireMention
+		} : void 0,
 		command: params.command,
-		extra: {
-			Transcript: params.transcript,
-			GroupSubject: params.msg.group?.subject,
-			GroupMembers: formatGroupMembers({
+		context: {
+			transcript: params.transcript,
+			groupSubject: params.msg.group?.subject ?? null,
+			groupMembers: formatGroupMembers({
 				participants: params.msg.group?.participants,
 				roster: params.groupMemberRoster,
 				fallbackE164: params.sender.e164
 			}),
-			SenderE164: params.sender.e164,
-			ReplyThreading: params.replyThreading,
-			SuppressMessageReceivedHooks: params.suppressMessageReceivedHooks,
-			...params.msg.payload.location ? toLocationContext(params.msg.payload.location) : {}
+			senderE164: params.sender.e164,
+			replyThreading: params.replyThreading,
+			location: params.msg.payload.location
 		}
+	};
+	const projected = projectPreparedChannelInbound({
+		inbound,
+		control
 	});
+	return {
+		inbound,
+		control,
+		turnInput: projected.input,
+		ctxPayload: projected.context
+	};
 }
 function resolveWhatsAppDmRouteTarget(params) {
 	const admission = requireWhatsAppInboundAdmission(params.msg);
@@ -2970,10 +3252,7 @@ function updateWhatsAppMainLastRoute(params) {
 	if (params.dmRouteTarget && inboundLastRouteSessionKey === params.route.mainSessionKey && params.pinnedMainDmRecipient) logVerbose$1(`Skipping main-session last route update for ${params.dmRouteTarget} (pinned owner ${params.pinnedMainDmRecipient})`);
 }
 function createWhatsAppReplyPlan(params) {
-	const admission = requireWhatsAppInboundAdmission(params.msg);
-	const ingressLifecycle = resolveWhatsAppIngressLifecycle(params.msg);
-	const conversationId = admission.conversation.id;
-	const conversationKind = admission.conversation.kind;
+	const conversationId = params.inbound.conversation.id;
 	const statusReactionController = params.statusReactionController ?? null;
 	const textLimit = params.maxMediaTextChunkLimit ?? resolveTextChunkLimit(params.cfg, "whatsapp");
 	const chunkMode = resolveChunkMode(params.cfg, "whatsapp", params.route.accountId);
@@ -2983,12 +3262,11 @@ function createWhatsAppReplyPlan(params) {
 		accountId: params.route.accountId
 	});
 	const mediaLocalRoots = getAgentScopedMediaLocalRoots(params.cfg, params.route.agentId);
-	const sourceReplyDeliveryMode = params.context.ChatType === "group" || params.context.ChatType === "channel" ? resolveChannelMessageSourceReplyDeliveryMode({
+	const replyPolicy = resolveWhatsAppInboundReplyPolicy({
 		cfg: params.cfg,
-		ctx: params.context
-	}) : void 0;
-	const sourceRepliesAreToolOnly = sourceReplyDeliveryMode === "message_tool_only";
-	const disableBlockStreaming = sourceRepliesAreToolOnly ? true : resolveWhatsAppDisableBlockStreaming(params.cfg);
+		ctx: params.context,
+		blockStreamingEnabled: resolveChannelStreamingBlockEnabled(params.cfg.channels?.whatsapp)
+	});
 	let didSendReply = false;
 	let didLogHeartbeatStrip = false;
 	const recordDeliveredPayload = (payload) => {
@@ -2997,6 +3275,7 @@ function createWhatsAppReplyPlan(params) {
 		params.rememberSentText(payload.text, {
 			combinedBody: params.context.Body,
 			combinedBodySessionKey: params.route.sessionKey,
+			conversationId,
 			logVerboseMessage: shouldLog
 		});
 		if (shouldLogVerbose$1()) {
@@ -3007,36 +3286,53 @@ function createWhatsAppReplyPlan(params) {
 	const deliverNormalizedPayload = async (normalizedDeliveryPayload, info, options) => {
 		const reply = resolveSendableOutboundReplyParts(normalizedDeliveryPayload);
 		if (!reply.hasMedia && !reply.text.trim()) return whatsAppReplyDeliveryVisibility(false);
-		if (!(await params.deliverReply({
-			replyResult: normalizedDeliveryPayload,
-			normalizedReplyResult: normalizedDeliveryPayload,
-			msg: params.msg,
-			mediaLocalRoots,
-			maxMediaBytes: params.maxMediaBytes,
-			textLimit,
-			chunkMode,
-			replyLogger: params.replyLogger,
-			connectionId: params.connectionId,
-			skipLog: false,
-			tableMode
-		})).providerAccepted) {
+		let delivery;
+		try {
+			delivery = await params.deliverReply({
+				replyResult: normalizedDeliveryPayload,
+				normalizedReplyResult: normalizedDeliveryPayload,
+				transport: params.transport,
+				mediaLocalRoots,
+				maxMediaBytes: params.maxMediaBytes,
+				textLimit,
+				chunkMode,
+				replyLogger: params.replyLogger,
+				connectionId: params.connectionId,
+				skipLog: false,
+				tableMode
+			});
+		} catch (error) {
+			if (isWhatsAppVisibleDeliveryError(error) && !isChannelPartialDeliveryError(error)) throw createChannelPartialDeliveryError(error, {
+				content: reply.text,
+				visibleReplySent: true
+			});
+			throw error;
+		}
+		const result = createWhatsAppChannelDeliveryResult({
+			content: reply.text,
+			delivery
+		});
+		if (!result.visibleReplySent) {
 			params.replyLogger.warn({
-				correlationId: params.msg.event.id ?? null,
+				correlationId: params.transport.correlationId ?? null,
 				connectionId: params.connectionId,
 				conversationId,
-				chatId: params.msg.platform.chatJid,
+				chatId: params.transport.chatJid,
 				to: conversationId,
-				from: params.msg.platform.recipientJid,
+				from: params.transport.recipientJid,
 				replyKind: info.kind
 			}, "auto-reply was not accepted by WhatsApp provider");
-			return whatsAppReplyDeliveryVisibility(false);
+			return result;
 		}
 		if (options?.recordDelivery !== false) try {
 			recordDeliveredPayload(normalizedDeliveryPayload);
 		} catch (error) {
-			throw markWhatsAppVisibleDeliveryError(error);
+			throw createChannelPartialDeliveryError(error, {
+				...result,
+				visibleReplySent: true
+			});
 		}
-		return whatsAppReplyDeliveryVisibility(true);
+		return result;
 	};
 	const mediaOnlyCoalescer = createWhatsAppMediaOnlyReplyCoalescer({ deliver: async (pending) => {
 		return await deliverNormalizedPayload(pending.payload, pending.info);
@@ -3058,9 +3354,10 @@ function createWhatsAppReplyPlan(params) {
 				logWhatsAppMediaOnlyFlushResult(flushResult);
 				return whatsAppReplyDeliveryVisibility(didSendReply || flushResult.delivered > 0);
 			},
-			onReplyStart: params.msg.platform.sendComposing
+			onReplyStart: params.transport.sendComposing
 		},
 		delivery: {
+			observeMessageSent: true,
 			preparePayload: async (payload, info) => {
 				const deliveryPayload = resolveWhatsAppDeliverablePayload(payload, info);
 				if (!deliveryPayload) return null;
@@ -3090,7 +3387,7 @@ function createWhatsAppReplyPlan(params) {
 					replyToId: resolveWhatsAppDurableReplyToId({
 						context: params.context,
 						info,
-						msg: params.msg,
+						currentMessageId: params.transport.correlationId,
 						payload
 					}),
 					formatting: {
@@ -3136,16 +3433,16 @@ function createWhatsAppReplyPlan(params) {
 					err,
 					info,
 					connectionId: params.connectionId,
-					msg: params.msg,
+					transport: params.transport,
 					replyLogger: params.replyLogger
 				});
 			}
 		},
 		replyOptions: {
-			...ingressLifecycle ? bindIngressLifecycleToReplyOptions(ingressLifecycle) : {},
-			suppressTyping: sourceRepliesAreToolOnly && conversationKind === "group" && !(params.msg.groupMention?.wasMentioned ?? params.msg.wasMentioned),
-			disableBlockStreaming,
-			...sourceReplyDeliveryMode ? { sourceReplyDeliveryMode } : {},
+			...params.turnAdoptionLifecycle ? { turnAdoptionLifecycle: params.turnAdoptionLifecycle } : {},
+			suppressTyping: replyPolicy.suppressTyping,
+			disableBlockStreaming: replyPolicy.disableBlockStreaming,
+			...replyPolicy.sourceReplyDeliveryMode ? { sourceReplyDeliveryMode: replyPolicy.sourceReplyDeliveryMode } : {},
 			onModelSelected: params.onModelSelected,
 			...statusReactionController ? {
 				onToolStart: async (payload) => {
@@ -3490,13 +3787,14 @@ async function processMessage(params) {
 		accountConfig: account,
 		peerId: dmRouteTarget ?? conversationId
 	});
-	const ctxPayload = await buildWhatsAppInboundContext({
+	const commandAuthorization = commandAuthorized === void 0 ? { kind: "not_checked" } : commandAuthorized ? { kind: "authorized" } : { kind: "denied" };
+	const { inbound, turnInput, ctxPayload } = await prepareWhatsAppInboundContext({
 		bodyForAgent: msgForAgent.payload.body,
 		combinedBody,
 		command: {
 			kind: isTextCommand ? "text-slash" : "normal",
 			body: commandBody,
-			authorized: commandAuthorized
+			authorization: commandAuthorization
 		},
 		groupHistory: visibleGroupHistory,
 		groupHistoryLimit: params.groupHistoryLimit,
@@ -3516,6 +3814,9 @@ async function processMessage(params) {
 		visibleReplyTo: visibleReplyTo ?? void 0,
 		suppressMessageReceivedHooks: true
 	});
+	const transport = buildWhatsAppInboundTransportContext(params.msg);
+	const ingressLifecycle = resolveWhatsAppIngressLifecycle(params.msg);
+	const turnAdoptionLifecycle = ingressLifecycle ? bindIngressLifecycleToReplyOptions(ingressLifecycle).turnAdoptionLifecycle : void 0;
 	emitWhatsAppMessageReceivedHooksIfEnabled({
 		cfg: params.cfg,
 		ctx: ctxPayload,
@@ -3540,16 +3841,10 @@ async function processMessage(params) {
 	const turnResult = await runChannelInboundEvent({
 		channel: "whatsapp",
 		accountId: params.route.accountId,
-		raw: params.msg,
+		raw: inbound,
+		...turnAdoptionLifecycle ? { turnAdoptionLifecycle } : {},
 		adapter: {
-			ingest: () => ({
-				id: params.msg.event.id ?? `${conversationId}:${Date.now()}`,
-				timestamp: params.msg.event.timestamp,
-				rawText: ctxPayload.RawBody ?? "",
-				textForAgent: ctxPayload.BodyForAgent,
-				textForCommands: ctxPayload.CommandBody,
-				raw: params.msg
-			}),
+			ingest: () => turnInput,
 			preflight: () => {
 				const reason = admission.ingress.reasonCode;
 				if (admission.ingress.admission === "dispatch") return { admission: {
@@ -3580,7 +3875,7 @@ async function processMessage(params) {
 					groupHistoryKey: params.groupHistoryKey,
 					maxMediaBytes: params.maxMediaBytes,
 					maxMediaTextChunkLimit: params.maxMediaTextChunkLimit,
-					msg: params.msg,
+					inbound,
 					onModelSelected,
 					rememberSentText: params.rememberSentText,
 					replyLogger: params.replyLogger,
@@ -3591,7 +3886,9 @@ async function processMessage(params) {
 					replyResolver: params.replyResolver,
 					route: params.route,
 					shouldClearGroupHistory,
-					statusReactionController
+					statusReactionController,
+					transport,
+					turnAdoptionLifecycle
 				});
 				finalizeReply = finalize;
 				return {
@@ -3637,8 +3934,14 @@ async function processMessage(params) {
 }
 //#endregion
 //#region extensions/whatsapp/src/auto-reply/monitor/on-message.ts
+function readDeprecatedAccessControlPassed(msg) {
+	return msg.accessControlPassed;
+}
 function createWebOnMessageHandler(params) {
-	const hasExplicitlyPassedInboundAccess = (msg) => msg.admission ? msg.admission.ingress.decision === "allow" : msg.accessControlPassed === true;
+	const hasExplicitlyPassedInboundAccess = (msg) => {
+		if (msg.admission.ingress.decisiveGateId === "legacy-flat-compat") return readDeprecatedAccessControlPassed(msg) === true;
+		return msg.admission.ingress.decision === "allow";
+	};
 	const withDirectSenderPeer = (msg, peerId) => {
 		if (requireWhatsAppInboundAdmission(msg).conversation.kind === "group" || msg.platform.sender?.e164 || msg.platform.senderE164 || !peerId.startsWith("+")) return msg;
 		const normalized = normalizeE164(peerId);
@@ -3683,9 +3986,8 @@ function createWebOnMessageHandler(params) {
 		if (opts?.statusReactionController !== void 0) processParams.statusReactionController = opts.statusReactionController;
 		return processMessage(processParams);
 	};
-	return async (rawMsg) => {
-		const canRunDirectEarlyAudioPreflight = hasExplicitlyPassedInboundAccess(rawMsg);
-		const normalizedMsg = requireAdmittedWhatsAppInboundMessage(normalizeWebInboundMessage(rawMsg));
+	return async (normalizedMsg) => {
+		const canRunDirectEarlyAudioPreflight = hasExplicitlyPassedInboundAccess(normalizedMsg);
 		const cfg = params.loadConfig?.() ?? params.cfg;
 		const peerId = resolvePeerId(normalizedMsg);
 		const msg = withDirectSenderPeer(normalizedMsg, peerId);
@@ -3710,9 +4012,9 @@ function createWebOnMessageHandler(params) {
 		});
 		const baseMentionConfig = buildMentionConfig(cfg);
 		if (conversationId === msg.platform.recipientJid) logVerbose(`📱 Same-phone mode detected (from === to: ${conversationId})`);
-		if (params.echoTracker.has(msg.payload.body)) {
+		if (params.echoTracker.has(msg.payload.body, conversationId)) {
 			logVerbose("Skipping auto-reply: detected echo (message matches recently sent text)");
-			params.echoTracker.forget(msg.payload.body);
+			params.echoTracker.forget(msg.payload.body, conversationId);
 			return;
 		}
 		const configuredRoute = resolveConfiguredBindingRoute({
@@ -4033,12 +4335,12 @@ async function monitorWebChannel(verbose, listenerFactory = attachWebInboxToSock
 				channel: "whatsapp"
 			});
 			const shouldDebounce = (msg) => {
-				const normalized = normalizeWebInboundMessage(msg);
+				const admitted = normalizeAdmittedWebInboundMessage(msg);
 				return shouldDebounceTextInbound({
-					text: normalized.payload.commandBody ?? normalized.payload.body,
+					text: admitted.payload.commandBody ?? admitted.payload.body,
 					cfg,
-					hasMedia: Boolean(normalized.payload.media?.path || normalized.payload.media?.type),
-					allowDebounce: !(normalized.payload.location || normalized.quote?.id || normalized.quote?.body)
+					hasMedia: Boolean(admitted.payload.media?.path || admitted.payload.media?.type),
+					allowDebounce: !(admitted.payload.location || admitted.quote?.id || admitted.quote?.body)
 				});
 			};
 			let connection;
@@ -4092,11 +4394,11 @@ async function monitorWebChannel(verbose, listenerFactory = attachWebInboxToSock
 							recentMessageKeys,
 							baileysGroupMetaCache,
 							onMessage: async (msg) => {
-								const normalized = normalizeWebInboundMessage(msg);
+								const admitted = normalizeAdmittedWebInboundMessage(msg);
 								const inboundAt = Date.now();
 								controller.noteInbound(inboundAt);
 								statusController.noteInbound(inboundAt);
-								await onMessage(normalized);
+								await onMessage(admitted);
 							},
 							onPendingWorkChanged: (pendingWorkCount, at) => {
 								statusController.noteBusy(pendingWorkCount > 0, at);