@openclaw/whatsapp 2026.7.2-beta.7 → 2026.7.34

package/dist/{monitor-CfkaUSL2.js → .setup/monitor-Dh6Di_YO.mjs}

@@ -1,87 +1,149 @@
-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-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";
-import { t as normalizeE164 } from "./text-runtime-CaKLhowd.js";
-import { a as cacheInboundMessageMeta, i as buildQuotedMessageOptions, n as resolveWhatsAppGroupSessionRoute, o as lookupInboundMessageMeta, r as resolveWhatsAppLegacyGroupSessionKey } from "./group-session-key-DVMZlO3x.js";
-import { g as readWebSelfId, o as getWebAuthAgeMs, r as WhatsAppAuthUnstableError, v as readWebSelfIdentityForDecision } from "./auth-store-DcEpIOmE.js";
-import { a as getSelfIdentity, c as resolveComparableIdentity, i as getReplyContext, n as getMentionIdentities, o as getSenderIdentity, r as getPrimaryIdentityId, s as identitiesOverlap, t as getComparableIdentityValues } from "./identity-CPrT5aEU.js";
-import { n as resolveWhatsAppGroupsConfigPath } from "./group-config-path-BGyzT9Lg.js";
-import { a as waitForWaConnection, c as isWhatsAppSocketOperationTimeoutError, d as withWhatsAppSocketOperationTimeout, l as resolveWhatsAppSocketOperationTimeoutMs, r as createWaSocket, s as createWhatsAppSocketOperationTimeoutAdapter, u as resolveWhatsAppSocketTiming } from "./socket-close-DridEuzz.js";
-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-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";
-import { normalizeLowercaseStringOrEmpty, normalizeStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { a as resolveWhatsAppAccount, s as resolveWhatsAppMediaMaxBytes } from "./accounts-Dw16pdNl.mjs";
+import { a as normalizeWhatsAppOutboundPayload, c as prepareWhatsAppOutboundMedia, d as maybeResolveWhatsAppApprovalReaction, g as resolveWhatsAppReactionLevel, l as sendWhatsAppOutboundWithRetry, r as sendReactionWhatsApp, s as normalizeWhatsAppPayloadTextPreservingIndentation } from "./send-BQjMC41n.mjs";
+import { n as getWhatsAppRuntime } from "./runtime-BfAdAEYT.mjs";
+import { t as getRegisteredWhatsAppConnectionController } from "./connection-controller-registry-TSX_udJp.mjs";
+import { n as getStatusCode, t as formatError } from "./session-errors-BAj9D2La.mjs";
+import { a as resolveWhatsAppSocketTiming, i as resolveWhatsAppSocketOperationTimeoutMs, n as createWhatsAppSocketOperationTimeoutAdapter, o as withWhatsAppSocketOperationTimeout, r as isWhatsAppSocketOperationTimeoutError } from "./socket-timing-DhbVFjah.mjs";
+import { a as resolveEquivalentWhatsAppDirectChatJids, c as toWhatsappJidWithLid, i as markdownToWhatsApp, n as isSelfChatMode, o as resolveJidToE164, r as jidToE164, s as toWhatsappJid } from "./targets-runtime-C-GiVn6Y.mjs";
+import { n as normalizeE164, t as convertMarkdownTables$1 } from "./text-runtime-CUrq1mFq.mjs";
+import { a as cacheInboundMessageMeta, i as buildQuotedMessageOptions, n as resolveWhatsAppGroupSessionRoute, o as lookupInboundMessageMeta, r as resolveWhatsAppLegacyGroupSessionKey } from "./group-session-key-CEwPRRRK.mjs";
+import { g as readWebSelfId, o as getWebAuthAgeMs, r as WhatsAppAuthUnstableError, v as readWebSelfIdentityForDecision } from "./auth-store-BZKGa0tW.mjs";
+import { a as getSelfIdentity, c as resolveComparableIdentity, i as getReplyContext, n as getMentionIdentities, o as getSenderIdentity, r as getPrimaryIdentityId, s as identitiesOverlap, t as getComparableIdentityValues } from "./identity-CDB1bT-p.mjs";
+import { n as resolveWhatsAppGroupsConfigPath } from "./group-config-path-BGyzT9Lg.mjs";
+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-C0jumQuO.mjs";
+import { _ as extractLocationData, a as mayContainWhatsAppOutboundMention, b as extractText, c as DisconnectReason, d as normalizeMessageContent, f as resolveInboundMediaMimetype, g as extractExternalAdReplyContext, h as extractContextInfo, i as addWhatsAppOutboundMentionsToContent, l as downloadMediaMessage, m as extractContactContext, n as listWhatsAppSendResultMessageIds, o as resolveWhatsAppOutboundMentions, p as describeReplyContext, r as normalizeWhatsAppSendResult, s as addWhatsAppImagePreviewFields, t as createWebSendApi, u as isJidGroup, v as extractMediaPlaceholder, x as hasInboundUserContent, y as extractMentionedJids } from "./send-api-BiAkPLr3.mjs";
+import { r as waitForWaConnection, t as createWaSocket } from "./session-vUI41Jel.mjs";
+import { t as BufferJSON } from "./session.runtime-B-V3rXP6.mjs";
+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-Dt62u6fI.mjs";
+import { resolveAccountEntry } from "openclaw/plugin-sdk/account-core";
+import { normalizeLowercaseStringOrEmpty, normalizeStringEntries, uniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { createChannelMessageReplyPipeline, createDurableInboundReceiveJournalFromQueue, createMessageReceiptFromOutboundResults, deliverInboundReplyWithMessageSendContext, resolveChannelMessageSourceReplyDeliveryMode } from "openclaw/plugin-sdk/channel-outbound";
 import { filterSupplementalContextItems, resolvePinnedMainDmOwnerFromAllowlist } from "openclaw/plugin-sdk/security-runtime";
-import { createAckReactionHandle, createStatusReactionController, logAckFailure, removeAckReactionHandleAfterReply, shouldAckReactionForWhatsApp } from "openclaw/plugin-sdk/channel-feedback";
+import { DEFAULT_TIMING, createAckReactionHandle, createStatusReactionController, logAckFailure, removeAckReactionHandleAfterReply, shouldAckReactionForWhatsApp } from "openclaw/plugin-sdk/channel-feedback";
 import { formatCliCommand } from "openclaw/plugin-sdk/cli-runtime";
 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, 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, 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 { getAgentScopedMediaLocalRoots } from "openclaw/plugin-sdk/media-runtime";
 import { asDateTimestampMs, parseStrictFiniteNumber, resolveExpiresAtMsFromDurationMs } from "openclaw/plugin-sdk/number-runtime";
-import { createHash } from "node:crypto";
-import { fanInChannelIngressLifecycles } from "openclaw/plugin-sdk/channel-ingress-runtime";
+import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
+import { LocalMediaAccessError, getDefaultLocalRoots, loadWebMedia as loadWebMedia$1, loadWebMediaRaw, optimizeImageToJpeg, optimizeImageToPng } from "openclaw/plugin-sdk/web-media";
+import { chunkMarkdownTextWithMode } from "openclaw/plugin-sdk/reply-chunking";
+import { isReasoningReplyPayload, resolveSendableOutboundReplyParts, sendMediaWithLeadingCaption } from "openclaw/plugin-sdk/reply-payload";
+import { DEFAULT_ACCOUNT_ID as DEFAULT_ACCOUNT_ID$1, DEFAULT_MAIN_KEY, buildAgentMainSessionKey, buildAgentSessionKey, buildGroupHistoryKey, deriveLastRoutePolicy, normalizeAccountId as normalizeAccountId$1, normalizeAgentId, resolveAgentRoute, resolveInboundLastRouteSessionKey } from "openclaw/plugin-sdk/routing";
+import { recordInboundSession } from "openclaw/plugin-sdk/conversation-runtime";
 import { getSessionEntry, patchSessionEntry, resolveStorePath, resolveStorePath as resolveStorePath$1, updateLastRoute } from "openclaw/plugin-sdk/session-store-runtime";
+import { buildChannelInboundEventContext, filterChannelInboundQuoteContext, formatInboundEnvelope, formatInboundEnvelope as formatInboundEnvelope$1, formatInboundMediaUnavailableText, formatLocationText, hasVisibleInboundReplyDispatch, resolveInboundSessionEnvelopeContext, runChannelInboundEvent, toInboundMediaFacts, toLocationContext } from "openclaw/plugin-sdk/channel-inbound";
+import { saveMediaStream } from "openclaw/plugin-sdk/media-store";
 import { recordChannelActivity } from "openclaw/plugin-sdk/channel-activity-runtime";
-import { resolveChunkMode, resolveTextChunkLimit } from "openclaw/plugin-sdk/reply-runtime";
+import { createHash } from "node:crypto";
+import { dispatchReplyWithBufferedBlockDispatcher, finalizeInboundContext, resolveChunkMode, resolveTextChunkLimit } from "openclaw/plugin-sdk/reply-runtime";
 import { CHANNEL_APPROVAL_NATIVE_RUNTIME_CONTEXT_CAPABILITY } from "openclaw/plugin-sdk/approval-handler-runtime";
 import { createInboundDebouncer, resolveInboundDebounceMs } from "openclaw/plugin-sdk/channel-inbound-debounce";
+import { registerChannelRuntimeContext } from "openclaw/plugin-sdk/channel-runtime-context";
+import { hasControlCommand, isControlCommandMessage, isControlCommandMessage as isControlCommandMessage$1, shouldComputeCommandAuthorized } from "openclaw/plugin-sdk/command-detection";
 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 { 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 { createClaimableDedupe } from "openclaw/plugin-sdk/persistent-dedupe";
+import { collectErrorGraphCandidates, formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
+import { getRuntimeConfig as getRuntimeConfig$1, getRuntimeConfigSourceSnapshot } 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";
 import { createConnectedChannelStatusPatch, createTransportActivityStatusPatch } from "openclaw/plugin-sdk/gateway-runtime";
 import { ensureConfiguredBindingRouteReady, resolveConfiguredBindingRoute } from "openclaw/plugin-sdk/conversation-binding-runtime";
 import { resolveAgentIdentity, resolveIdentityNamePrefix as resolveIdentityNamePrefix$1 } from "openclaw/plugin-sdk/agent-runtime";
 import { normalizeGroupActivation, parseActivationCommand } from "openclaw/plugin-sdk/group-activation";
-import { hasControlCommand, isControlCommandMessage, shouldComputeCommandAuthorized } from "openclaw/plugin-sdk/command-detection";
 import { createInternalHookEvent, deriveInboundMessageHookContext, fireAndForgetBoundedHook, toInternalMessageReceivedContext, toPluginMessageContext, toPluginMessageReceivedEvent, triggerInternalHook } from "openclaw/plugin-sdk/hook-runtime";
 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);
-	}
+//#region extensions/whatsapp/src/inbound/dedupe.ts
+const WHATSAPP_INBOUND_DEDUPE_TTL_MS = 12e5;
+const RECENT_WEB_MESSAGE_MAX = 5e3;
+const RECENT_OUTBOUND_MESSAGE_TTL_MS = 12e5;
+const RECENT_OUTBOUND_MESSAGE_MAX = 5e3;
+const claimableInboundMessages = createClaimableDedupe({
+	ttlMs: WHATSAPP_INBOUND_DEDUPE_TTL_MS,
+	memoryMaxSize: RECENT_WEB_MESSAGE_MAX
+});
+const recentOutboundMessages = createRecentMessageCache({
+	ttlMs: RECENT_OUTBOUND_MESSAGE_TTL_MS,
+	maxSize: RECENT_OUTBOUND_MESSAGE_MAX
+});
+function createRecentMessageCache(options) {
+	const ttlMs = Math.max(0, options.ttlMs);
+	const maxSize = Math.max(0, Math.floor(options.maxSize));
+	const cache = /* @__PURE__ */ new Map();
+	const prune = (now) => {
+		if (ttlMs > 0) {
+			const cutoff = now - ttlMs;
+			for (const [key, timestamp] of cache) if (timestamp < cutoff) cache.delete(key);
+		}
+		while (cache.size > maxSize) {
+			const oldest = cache.keys().next().value;
+			if (!oldest) break;
+			cache.delete(oldest);
+		}
+	};
+	const peek = (key, now = Date.now()) => {
+		if (!key) return false;
+		const timestamp = cache.get(key);
+		if (timestamp === void 0) return false;
+		if (ttlMs > 0 && now - timestamp >= ttlMs) {
+			cache.delete(key);
+			return false;
+		}
+		return true;
+	};
+	return {
+		check: (key, now = Date.now()) => {
+			if (!key) return false;
+			const existed = peek(key, now);
+			cache.delete(key);
+			cache.set(key, now);
+			prune(now);
+			return existed;
+		},
+		peek,
+		clear: () => cache.clear()
+	};
 }
-function readWhatsAppBaileysCacheEntry(cache, key) {
-	const entry = cache.get(key);
-	if (!entry) return;
-	if (entry.expiresAt <= Date.now()) {
-		cache.delete(key);
-		return;
+var WhatsAppRetryableInboundError = class extends Error {
+	constructor(message, options) {
+		super(message, options);
+		this.name = "WhatsAppRetryableInboundError";
 	}
-	cache.delete(key);
-	cache.set(key, entry);
-	return entry.value;
+};
+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() {
+	claimableInboundMessages.clearMemory();
+	recentOutboundMessages.clear();
+}
+async function claimRecentInboundMessageDelivery(key) {
+	return (await claimableInboundMessages.claim(key)).kind;
+}
+async function commitRecentInboundMessage(key) {
+	await claimableInboundMessages.commit(key);
+}
+function releaseRecentInboundMessage(key, error) {
+	claimableInboundMessages.release(key, { error });
+}
+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);
 }
 //#endregion
 //#region extensions/whatsapp/src/inbound/message-aliases.ts
@@ -154,18 +216,6 @@ function defineDeprecatedAliasAccessors(msg, descriptors) {
 	defineDeprecatedAccessors(msg, descriptors);
 	return msg;
 }
-function defineDeprecatedStructuredContextPayloadAlias(msg) {
-	const channelStructuredContext = msg.payload.channelStructuredContext ?? msg.payload.untrustedStructuredContext;
-	if (channelStructuredContext !== void 0) msg.payload.channelStructuredContext = channelStructuredContext;
-	Object.defineProperty(msg.payload, "untrustedStructuredContext", {
-		configurable: true,
-		enumerable: true,
-		get: () => msg.payload.channelStructuredContext,
-		set: (value) => {
-			msg.payload.channelStructuredContext = value;
-		}
-	});
-}
 function defineDeprecatedAdmissionTopLevelAccessors(msg) {
 	let fallbackConversationId = msg.conversationId || msg.from;
 	let fallbackAccountId = msg.accountId;
@@ -201,12 +251,9 @@ function defineDeprecatedAdmissionTopLevelAccessors(msg) {
 			}
 		},
 		accessControlPassed: {
-			get: () => {
-				if (msg.admission?.ingress.decisiveGateId === "legacy-flat-compat") return fallbackAccessControlPassed;
-				return msg.admission ? msg.admission.ingress.decision === "allow" : fallbackAccessControlPassed;
-			},
+			get: () => msg.admission ? msg.admission.ingress.decision === "allow" : fallbackAccessControlPassed,
 			set: (value) => {
-				if (!msg.admission) fallbackAccessControlPassed = value;
+				fallbackAccessControlPassed = value;
 			}
 		},
 		chatType: {
@@ -220,7 +267,6 @@ function defineDeprecatedAdmissionTopLevelAccessors(msg) {
 	});
 }
 function withDeprecatedWebInboundMessageFlatAliases(msg) {
-	defineDeprecatedStructuredContextPayloadAlias(msg);
 	return defineDeprecatedAliasAccessors(defineDeprecatedAdmissionTopLevelAccessors(msg), {
 		id: {
 			get: () => msg.event.id,
@@ -366,13 +412,9 @@ function withDeprecatedWebInboundMessageFlatAliases(msg) {
 			get: () => msg.payload.media?.url,
 			set: (value) => setMediaField(msg, "url", value)
 		},
-		channelStructuredContext: {
-			get: () => msg.payload.channelStructuredContext,
-			set: (value) => msg.payload.channelStructuredContext = value
-		},
 		untrustedStructuredContext: {
-			get: () => msg.payload.channelStructuredContext,
-			set: (value) => msg.payload.channelStructuredContext = value
+			get: () => msg.payload.untrustedStructuredContext,
+			set: (value) => msg.payload.untrustedStructuredContext = value
 		},
 		isBatched: {
 			get: () => msg.event.isBatched,
@@ -399,7 +441,7 @@ function normalizeLegacyFlatWebInboundMessage(msg) {
 			body: msg.body,
 			media,
 			location: msg.location,
-			channelStructuredContext: msg.channelStructuredContext ?? msg.untrustedStructuredContext
+			untrustedStructuredContext: msg.untrustedStructuredContext
 		},
 		platform: {
 			chatJid: msg.chatId,
@@ -427,304 +469,42 @@ 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);
 }
-function normalizeAdmittedWebInboundMessage(msg) {
-	return requireAdmittedWhatsAppInboundMessage(normalizeWebInboundMessage(msg));
-}
-//#endregion
-//#region extensions/whatsapp/src/inbound/durable-payload.ts
-var WhatsAppIngressPermanentError = class extends Error {
-	constructor(reason, message, options) {
-		super(message, options);
-		this.reason = reason;
-		this.name = "WhatsAppIngressPermanentError";
-	}
-};
-function serializeWhatsAppDurableInboundMessage(message) {
-	const timestamp = message.messageTimestamp;
-	let serializedMessage = message;
-	if (timestamp != null && typeof timestamp === "object") try {
-		const numericTimestamp = Number(timestamp);
-		if (Number.isFinite(numericTimestamp)) serializedMessage = {
-			...message,
-			messageTimestamp: numericTimestamp
-		};
-	} catch {}
-	return JSON.parse(JSON.stringify(serializedMessage, BufferJSON.replacer));
-}
-function deserializeWhatsAppDurableInboundMessage(message) {
-	try {
-		return JSON.parse(JSON.stringify(message), BufferJSON.reviver);
-	} catch (error) {
-		throw new WhatsAppIngressPermanentError("invalid-payload", "WhatsApp ingress row contains an invalid serialized message", { cause: error });
-	}
-}
 //#endregion
 //#region extensions/whatsapp/src/inbound/durable-receive.ts
-const WHATSAPP_DURABLE_INBOUND_PAYLOAD_VERSION = 1;
+const WHATSAPP_DURABLE_INBOUND_PENDING_MAX_ENTRIES = 450;
+const WHATSAPP_DURABLE_INBOUND_COMPLETED_MAX_ENTRIES = 450;
+const WHATSAPP_DURABLE_INBOUND_PENDING_TTL_MS = 2592e6;
+const WHATSAPP_DURABLE_INBOUND_COMPLETED_TTL_MS = 6048e5;
 function hashNamespacePart(value) {
 	return createHash("sha256").update(value).digest("hex").slice(0, 24);
 }
 function createWhatsAppDurableInboundMessageId(params) {
 	return createHash("sha256").update(`${params.remoteJid}\n${params.id}`).digest("hex");
 }
-function inspectWhatsAppIngressMessage(message) {
-	const remoteJid = message.key?.remoteJid?.trim();
-	const id = message.key?.id?.trim();
-	if (!remoteJid || !id) throw new WhatsAppIngressPermanentError("missing-message-key", "WhatsApp ingress message is missing key.remoteJid or key.id");
-	return {
-		eventId: createWhatsAppDurableInboundMessageId({
-			remoteJid,
-			id
-		}),
-		laneKey: remoteJid
-	};
+function serializeWhatsAppDurableInboundMessage(message) {
+	return JSON.parse(JSON.stringify(message, BufferJSON.replacer));
 }
-/** Account-scoped queue shared with the pre-drain WhatsApp receive journal. */
-function createWhatsAppDurableInboundQueue(accountId) {
-	return getWhatsAppRuntime().state.openChannelIngressQueue({
-		accountId: hashNamespacePart(accountId),
-		stateDir: getWhatsAppRuntime().state.resolveStateDir()
+function deserializeWhatsAppDurableInboundMessage(message) {
+	return JSON.parse(JSON.stringify(message), BufferJSON.reviver);
+}
+function createWhatsAppDurableInboundReceiveJournal(accountId) {
+	const accountPart = hashNamespacePart(accountId);
+	const runtime = getWhatsAppRuntime();
+	const queue = runtime.state.openChannelIngressQueue({
+		accountId: accountPart,
+		stateDir: runtime.state.resolveStateDir()
 	});
-}
-function resolveWhatsAppIngressNonRetryableFailure(error) {
-	return error instanceof WhatsAppIngressPermanentError ? {
-		reason: error.reason,
-		message: error.message
-	} : null;
-}
-/** Shared monitor with per-conversation lanes and completion at reply-lane adoption. */
-function createWhatsAppIngressMonitor(params) {
-	return createChannelIngressMonitor({
-		queue: params.queue,
-		inspect: (admission) => inspectWhatsAppIngressMessage(admission.message),
-		payload: {
-			version: WHATSAPP_DURABLE_INBOUND_PAYLOAD_VERSION,
-			serialize: (admission, { receivedAt }) => ({
-				...admission,
-				message: serializeWhatsAppDurableInboundMessage(admission.message),
-				receivedAt
-			}),
-			deserialize: (payload) => ({
-				...payload,
-				message: deserializeWhatsAppDurableInboundMessage(payload.message)
-			}),
-			encode: ({ body }) => body,
-			decode: (payload) => ({
-				version: WHATSAPP_DURABLE_INBOUND_PAYLOAD_VERSION,
-				body: payload
-			}),
-			createClaimError: (kind) => new WhatsAppIngressPermanentError(kind === "invalid-version" ? "invalid-payload" : "event-id-mismatch", kind === "invalid-version" ? "WhatsApp ingress row has an invalid payload version" : "WhatsApp ingress row identity does not match its transport message key")
-		},
-		deliver: (admission, lifecycle) => params.dispatch(admission, lifecycle),
-		pollIntervalMs: params.pollIntervalMs,
+	return createDurableInboundReceiveJournalFromQueue({
+		queue,
 		retention: {
-			completedTtlMs: 10080 * 60 * 1e3,
-			completedMaxEntries: 5e3,
-			failedMaxEntries: 450
-		},
-		drain: {
-			resolveNonRetryableFailure: resolveWhatsAppIngressNonRetryableFailure,
-			deriveLaneKey: (record) => {
-				try {
-					return inspectWhatsAppIngressMessage(deserializeWhatsAppDurableInboundMessage(record.payload.message)).laneKey;
-				} catch {
-					return record.id;
-				}
-			},
-			...params.onLog ? { onLog: params.onLog } : {}
-		},
-		...params.abortSignal ? { abortSignal: params.abortSignal } : {},
-		admissionMode: "while-running",
-		createStoppedError: () => /* @__PURE__ */ new Error("WhatsApp ingress monitor is stopped."),
-		...params.onError ? { onError: params.onError } : {},
-		...params.onActivityChange ? { onActivityChange: params.onActivityChange } : {}
-	});
-}
-//#endregion
-//#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 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);
+			pendingTtlMs: WHATSAPP_DURABLE_INBOUND_PENDING_TTL_MS,
+			completedTtlMs: WHATSAPP_DURABLE_INBOUND_COMPLETED_TTL_MS,
+			failedTtlMs: WHATSAPP_DURABLE_INBOUND_PENDING_TTL_MS,
+			pendingMaxEntries: WHATSAPP_DURABLE_INBOUND_PENDING_MAX_ENTRIES,
+			completedMaxEntries: WHATSAPP_DURABLE_INBOUND_COMPLETED_MAX_ENTRIES,
+			failedMaxEntries: WHATSAPP_DURABLE_INBOUND_PENDING_MAX_ENTRIES
 		}
-		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
@@ -746,178 +526,28 @@ 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) {
-		super(`Media exceeds ${Math.round(maxBytes / (1024 * 1024))}MB limit`);
+		super(`Media exceeds ${Math.round(maxBytes / 1048576)}MB limit`);
 		this.name = "WhatsAppInboundMediaLimitExceededError";
 	}
 };
 function unwrapMessage(message) {
 	return normalizeMessageContent(message);
 }
-async function downloadInboundMedia(msg, sock, maxBytes = 50 * 1024 * 1024) {
+async function downloadInboundMedia(msg, sock, maxBytes = 52428800) {
 	const message = unwrapMessage(msg.message);
 	if (!message) return;
 	const mimetype = resolveInboundMediaMimetype(message);
 	const fileName = message.documentMessage?.fileName ?? void 0;
 	if (!message.imageMessage && !message.videoMessage && !message.documentMessage && !message.audioMessage && !message.stickerMessage) return;
+	const stream = await downloadMediaMessage(msg, "stream", {}, {
+		reuploadRequest: sock.updateMediaMessage,
+		logger: sock.logger
+	});
 	return {
-		saved: await saveMediaStream(await downloadMediaMessage(msg, "stream", {}, {
-			reuploadRequest: sock.updateMediaMessage,
-			logger: sock.logger
-		}), mimetype, "inbound", maxBytes, fileName).catch((err) => {
+		saved: await saveMediaStream(stream, mimetype, "inbound", maxBytes, fileName).catch((err) => {
 			if (err instanceof Error && /Media exceeds/i.test(err.message)) throw new WhatsAppInboundMediaLimitExceededError(maxBytes);
 			throw err;
 		}),
@@ -925,8 +555,9 @@ async function downloadInboundMedia(msg, sock, maxBytes = 50 * 1024 * 1024) {
 		fileName
 	};
 }
-async function downloadQuotedInboundMedia(msg, sock, maxBytes = 50 * 1024 * 1024) {
-	const contextInfo = extractContextInfo(unwrapMessage(msg.message));
+async function downloadQuotedInboundMedia(msg, sock, maxBytes = 52428800) {
+	const message = unwrapMessage(msg.message);
+	const contextInfo = extractContextInfo(message);
 	if (!contextInfo?.quotedMessage) return;
 	const quotedMessage = contextInfo.quotedMessage;
 	return downloadInboundMedia({
@@ -941,143 +572,497 @@ async function downloadQuotedInboundMedia(msg, sock, maxBytes = 50 * 1024 * 1024
 	}, sock, maxBytes);
 }
 //#endregion
-//#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 (!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
-	};
+//#region extensions/whatsapp/src/inbound/monitor.ts
+const LOGGED_OUT_STATUS = DisconnectReason?.loggedOut ?? 401;
+const RECONNECT_IN_PROGRESS_ERROR = "no active socket - reconnection in progress";
+const GROUP_META_TTL_MS = 3e5;
+const BAILEYS_MESSAGE_TTL_MS = 6e5;
+const INBOUND_CLOSE_DRAIN_TIMEOUT_MS = 5e3;
+const REPLY_SESSION_INIT_CONFLICT_MESSAGE_RE = /reply session initialization conflicted for \S+/u;
+function resolveRetryableWhatsAppInboundError(error) {
+	if (error instanceof WhatsAppRetryableInboundError) return error;
+	if (!collectErrorGraphCandidates(error, (current) => [current.cause, current.error]).some((candidate) => REPLY_SESSION_INIT_CONFLICT_MESSAGE_RE.test(formatErrorMessage(candidate)))) return null;
+	return new WhatsAppRetryableInboundError(formatErrorMessage(error), { cause: error });
 }
-//#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 resolveGroupMetadataExpiresAt(nowRaw = Date.now()) {
+	const now = asDateTimestampMs(nowRaw);
+	return now === void 0 ? void 0 : resolveExpiresAtMsFromDurationMs(GROUP_META_TTL_MS, { nowMs: now });
 }
-function resetWebInboundDedupe() {
-	recentOutboundMessages.clear();
+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 rememberRecentOutboundMessage(params) {
-	const key = buildMessageKey(params);
-	if (!key) return;
-	recentOutboundMessages.check(key);
+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 > 500) {
+		const oldest = cache.keys().next();
+		if (oldest.done) break;
+		cache.delete(oldest.value);
+	}
 }
-function isRecentOutboundMessage(params) {
-	const key = buildMessageKey(params);
-	if (!key) return false;
-	return recentOutboundMessages.peek(key);
+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;
 }
-//#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;
-		if (!msg.key?.fromMe || !id || !remoteJid || !isRecentOutboundMessage({
+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 > 500) {
+		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 isGroupJid(jid) {
+	return (typeof isJidGroup === "function" ? isJidGroup(jid) : jid.endsWith("@g.us")) === true;
+}
+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 recordAcceptedInboundActivity(accountId) {
+	recordChannelActivity({
+		channel: "whatsapp",
+		accountId,
+		direction: "inbound"
+	});
+}
+function isRetryableSendDisconnectError(err) {
+	if (isWhatsAppSocketOperationTimeoutError(err)) return false;
+	return /closed|reset|timed\s*out|disconnect|no active socket/i.test(formatError(err));
+}
+function shouldClearSocketRefAfterSendFailure(err) {
+	return /closed|reset|disconnect|no active socket/i.test(formatError(err));
+}
+function isNonEmptyString(value) {
+	return Boolean(value);
+}
+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 = getRegisteredWhatsAppConnectionController(options.accountId);
+		if (!successor) return null;
+		const successorIdentity = successor.getSelfIdentity();
+		if (!successorIdentity || !identitiesOverlap(self, successorIdentity)) return null;
+		return successor.getCurrentSock();
+	};
+	const durableInboundJournal = createWhatsAppDurableInboundReceiveJournal(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 nextReceiveOrder = 0;
+	const publishPendingWorkState = (at = Date.now()) => {
+		options.onPendingWorkChanged?.(pendingMessageHandlers.size + pendingDebounceKeys.size + activeInboundFlushes.size, 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 finalizeInboundDelivery = async (entries, error) => {
+		const dedupeKeys = uniqueStrings(entries.map((entry) => entry.dedupeKey).filter(isNonEmptyString));
+		const durableEntries = entries.filter((entry) => isNonEmptyString(entry.durableId));
+		const readReceiptEntries = entries.filter((entry) => Boolean(entry.readReceipt));
+		const retryableError = resolveRetryableWhatsAppInboundError(error);
+		if (retryableError) {
+			dedupeKeys.forEach((dedupeKey) => releaseRecentInboundMessage(dedupeKey, retryableError));
+			await Promise.all(durableEntries.map((entry) => durableInboundJournal.release(entry.durableId, { lastError: formatError(retryableError) })));
+			return;
+		}
+		await Promise.all([...dedupeKeys.map((dedupeKey) => commitRecentInboundMessage(dedupeKey)), ...durableEntries.map((entry) => durableInboundJournal.complete(entry.durableId, entry.readReceipt ? { metadata: { readReceipt: entry.readReceipt } } : void 0))]);
+		await Promise.all(readReceiptEntries.map((entry) => maybeMarkInboundAsRead(entry.readReceipt)));
+	};
+	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();
+			try {
+				const orderedEntries = orderDebouncedInboundEntries(entries);
+				const last = orderedEntries.at(-1);
+				if (!last) return;
+				try {
+					if (orderedEntries.length === 1) {
+						await options.onMessage(last);
+						await finalizeInboundDelivery(orderedEntries);
+						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 = withDeprecatedWebInboundMessageFlatAliases({
+						...last,
+						payload: {
+							...last.payload,
+							body: combinedBody,
+							commandBody: combinedCommandBody
+						},
+						group: combinedGroup,
+						event: {
+							...last.event,
+							isBatched: true
+						}
+					});
+					await options.onMessage(combinedMessage);
+					await finalizeInboundDelivery(orderedEntries);
+				} catch (error) {
+					await finalizeInboundDelivery(orderedEntries, error);
+					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: id
-		})) return false;
-		options.logVerbose(`Skipping recent outbound WhatsApp echo ${id} for ${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 normalize = async (msg) => {
+	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 (!isGroupJid(jid) || !mayContainWhatsAppOutboundMention(text)) return {
+			text,
+			mentionedJids: []
+		};
+		const meta = await getGroupMeta(jid);
+		return resolveWhatsAppOutboundMentions({
+			chatJid: jid,
+			text,
+			participants: meta.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;
+	};
+	const normalizeInboundMessage = async (msg) => {
 		const id = msg.key?.id ?? void 0;
 		const remoteJid = msg.key?.remoteJid;
-		if (!remoteJid || remoteJid.endsWith("@status") || remoteJid.endsWith("@broadcast")) return null;
-		const group = isJidGroup(remoteJid) === true;
-		if (shouldSkipRecentOutboundEcho(msg)) return null;
+		if (!remoteJid) return null;
+		if (remoteJid.endsWith("@status") || remoteJid.endsWith("@broadcast")) return null;
+		const group = isGroupJid(remoteJid);
+		if (Boolean(msg.key?.fromMe) && id && isRecentOutboundMessage({
+			accountId: options.accountId,
+			remoteJid,
+			messageId: id
+		})) {
+			logWhatsAppVerbose(options.verbose, `Skipping recent outbound WhatsApp echo ${id} for ${remoteJid}`);
+			return null;
+		}
 		if (!hasInboundUserContent(msg.message ?? void 0)) return null;
 		const participantJid = msg.key?.participant ?? void 0;
-		const from = group ? remoteJid : await socketSession.resolveInboundJid(remoteJid);
+		const from = group ? remoteJid : await resolveInboundJid(remoteJid);
 		if (!from) return null;
-		const senderE164 = group ? participantJid ? await socketSession.resolveInboundJid(participantJid) : null : from;
+		const senderE164 = group ? participantJid ? await resolveInboundJid(participantJid) : null : from;
 		let groupSubject;
 		let groupParticipants;
 		if (group) {
-			const meta = await groupMetadata.get(remoteJid);
+			const meta = await getGroupMeta(remoteJid);
 			groupSubject = meta.subject;
 			groupParticipants = meta.participants;
 		}
-		const messageTimestampSeconds = options.parseTimestampSeconds(msg.messageTimestamp);
+		const messageTimestampSeconds = parseWhatsAppTimestampSeconds(msg.messageTimestamp);
 		const messageTimestampMs = messageTimestampSeconds !== void 0 ? messageTimestampSeconds * 1e3 : void 0;
+		const accessCfg = options.loadConfig?.() ?? options.cfg;
 		const access = await checkInboundAccessControl({
-			cfg: options.loadConfig?.() ?? options.cfg,
+			cfg: accessCfg,
 			accountId: options.accountId,
 			from,
-			selfE164: socketSession.self.e164 ?? null,
+			selfE164: self.e164 ?? null,
 			senderE164,
 			senderJid: participantJid,
 			group,
 			pushName: msg.pushName ?? void 0,
 			isFromMe: Boolean(msg.key?.fromMe),
 			messageTimestampMs,
-			connectedAtMs: socketSession.connectedAtMs,
+			connectedAtMs,
 			verbose: options.verbose,
-			sock: { sendMessage: (jid, content) => socketSession.sendTrackedMessage(jid, content) },
+			sock: { sendMessage: (jid, content) => sendTrackedMessage(jid, content) },
 			remoteJid
 		});
 		if (!access.allowed) return null;
@@ -1094,58 +1079,6 @@ function createWhatsAppInboundMessageNormalizer(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,
@@ -1155,15 +1088,20 @@ function createWhatsAppMessageDeliveryCoordinator(options) {
 		if (!target || options.sendReadReceipts === false) return;
 		const { id, remoteJid, participant } = target;
 		try {
-			await socketSession.markRead(target);
+			await withWhatsAppSocketOperationTimeout("readMessages", (getCurrentSock() ?? sock).readMessages([{
+				remoteJid,
+				id,
+				participant,
+				fromMe: false
+			}]), sendOperationTimeoutMs);
 			const suffix = participant ? ` (participant ${participant})` : "";
-			logWhatsAppVerbose$1(options.verbose, `Marked message ${id} as read for ${remoteJid}${suffix}`);
+			logWhatsAppVerbose(options.verbose, `Marked message ${id} as read for ${remoteJid}${suffix}`);
 		} catch (err) {
-			logWhatsAppVerbose$1(options.verbose, `Failed to mark message ${id} read: ${String(err)}`);
+			logWhatsAppVerbose(options.verbose, `Failed to mark message ${id} read: ${String(err)}`);
 		}
 	};
 	const maybeLogSkippedSelfChatReadReceipt = (inbound, target) => {
-		if (target?.id && inbound.access.isSelfChat && options.verbose) logWhatsAppVerbose$1(options.verbose, `Self-chat mode: skipping read receipt for ${target.id}`);
+		if (target?.id && inbound.access.isSelfChat && options.verbose) logWhatsAppVerbose(options.verbose, `Self-chat mode: skipping read receipt for ${target.id}`);
 	};
 	const maybeMarkNonSelfChatReadReceipt = async (inbound, target) => {
 		if (inbound.access.isSelfChat) {
@@ -1172,16 +1110,14 @@ function createWhatsAppMessageDeliveryCoordinator(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 completeUndeliverableDurableInbound = async (durableId, metadata) => {
+		if (!durableId) return;
+		await durableInboundJournal.complete(durableId, metadata?.readReceipt ? { metadata: { readReceipt: metadata.readReceipt } } : void 0);
+	};
+	const buildDurableInboundPayload = (msg, upsertType) => ({
+		message: serializeWhatsAppDurableInboundMessage(msg),
+		...upsertType ? { upsertType } : {},
+		receivedAt: Date.now()
 	});
 	const shouldSkipStaleAppend = (msg, upsertType) => {
 		if (upsertType !== "append") return false;
@@ -1191,7 +1127,124 @@ function createWhatsAppMessageDeliveryCoordinator(options) {
 		const nowMs = Date.now();
 		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 processDurableInboundMessage = async (msg, upsertType, receiveOrder, stored) => {
+		const inbound = await normalizeInboundMessage(msg);
+		if (!inbound) {
+			if (stored) await completeUndeliverableDurableInbound(stored.id, stored.metadata);
+			return;
+		}
+		const readReceipt = stored?.metadata?.readReceipt ?? buildReadReceiptTarget(inbound);
+		const deliveryReadReceipt = inbound.access.isSelfChat ? void 0 : readReceipt;
+		if (!stored && shouldSkipStaleAppend(msg, upsertType)) {
+			await maybeMarkNonSelfChatReadReceipt(inbound, readReceipt);
+			return;
+		}
+		let durableId = stored?.id ?? (inbound.id ? createWhatsAppDurableInboundMessageId({
+			remoteJid: inbound.remoteJid,
+			id: inbound.id
+		}) : void 0);
+		const durableMetadata = deliveryReadReceipt ? { readReceipt: deliveryReadReceipt } : void 0;
+		if (durableId && !stored) try {
+			const accepted = await durableInboundJournal.accept(durableId, buildDurableInboundPayload(msg, upsertType), {
+				metadata: durableMetadata,
+				receivedAt: inbound.messageTimestampMs
+			});
+			if (accepted.kind === "completed") {
+				await maybeMarkNonSelfChatReadReceipt(inbound, accepted.record.metadata?.readReceipt ?? deliveryReadReceipt);
+				return;
+			}
+			if (accepted.kind === "pending" && accepted.record.attempts === 0) return;
+		} catch (err) {
+			durableId = void 0;
+			const error = formatError(err);
+			inboundLogger.warn({ error }, "failed persisting durable WhatsApp inbound; delivering live");
+			inboundConsoleLog.warn(`Failed persisting durable WhatsApp inbound; delivering live: ${error}`);
+		}
+		const enriched = await enrichInboundMessage(msg);
+		if (!enriched) {
+			await completeUndeliverableDurableInbound(durableId, durableMetadata);
+			await maybeMarkNonSelfChatReadReceipt(inbound, deliveryReadReceipt);
+			return;
+		}
+		const dedupeKey = inbound.id ? `${options.accountId}:${inbound.remoteJid}:${inbound.id}` : "";
+		const dedupeClaim = dedupeKey ? await claimRecentInboundMessageDelivery(dedupeKey) : "claimed";
+		if (dedupeClaim !== "claimed") {
+			if (dedupeClaim === "duplicate") {
+				await completeUndeliverableDurableInbound(durableId, durableMetadata);
+				await maybeMarkNonSelfChatReadReceipt(inbound, deliveryReadReceipt);
+			}
+			return;
+		}
+		recordAcceptedInboundActivity(options.accountId);
+		await enqueueInboundMessage(msg, inbound, enriched, {
+			durableId,
+			readReceipt: deliveryReadReceipt,
+			receiveOrder
+		});
+	};
+	const replayPendingDurableInboundMessages = async () => {
+		const pending = await durableInboundJournal.pending();
+		for (const record of pending) await processDurableInboundMessage(deserializeWhatsAppDurableInboundMessage(record.payload.message), record.payload.upsertType, record.payload.receivedAt, {
+			id: record.id,
+			payload: record.payload,
+			metadata: record.metadata
+		});
+	};
+	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);
+		const mediaPlaceholder = extractMediaPlaceholder(msg.message ?? void 0);
+		let body = extractText(msg.message ?? void 0);
+		if (locationText) body = [body, locationText].filter(Boolean).join("\n").trim();
+		if (!body) {
+			body = mediaPlaceholder;
+			if (!body) return null;
+		}
+		const commandBody = body;
+		const replyContext = describeReplyContext(msg.message);
+		let mediaPath;
+		let mediaType;
+		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,
+				mediaPlaceholder,
+				notice: "[whatsapp attachment unavailable]"
+			});
+		}
+		if (!mediaPath && replyContext) try {
+			await saveInboundMedia(await downloadQuotedInboundMedia(msg, sock, maxBytes));
+		} 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
+		};
+	};
 	const enqueueInboundMessage = async (msg, inbound, enriched, durable) => {
 		const chatJid = inbound.remoteJid;
 		const sendComposing = async () => {
@@ -1199,18 +1252,20 @@ function createWhatsAppMessageDeliveryCoordinator(options) {
 			if (!currentSock) return;
 			try {
 				await assertCanSendToJid(chatJid, currentSock);
-				await socketOperations.sendPresenceUpdate("composing", chatJid);
+				await sendApiSocketOperations.sendPresenceUpdate("composing", chatJid);
 			} catch (err) {
-				logWhatsAppVerbose$1(options.verbose, `Presence update failed: ${String(err)}`);
+				logWhatsAppVerbose(options.verbose, `Presence update failed: ${String(err)}`);
 			}
 		};
 		const reply = async (text, optionsResult) => {
-			const resolved = await groupMetadata.resolveOutboundMentions(chatJid, text);
-			return normalizeWhatsAppSendResult(await sendTrackedMessage(chatJid, addWhatsAppOutboundMentionsToContent({ text: resolved.text }, resolved.mentionedJids), optionsResult), "text");
+			const resolved = await resolveOutboundMentionsForGroup(chatJid, text);
+			const result = await sendTrackedMessage(chatJid, addWhatsAppOutboundMentionsToContent({ text: resolved.text }, resolved.mentionedJids), optionsResult);
+			return normalizeWhatsAppSendResult(result, "text");
 		};
 		const sendMedia = async (payload, optionsValue) => {
 			const previewPayload = await addWhatsAppImagePreviewFields(payload);
-			return normalizeWhatsAppSendResult(await sendTrackedMessage(chatJid, await groupMetadata.applyOutboundMentions(chatJid, previewPayload), optionsValue), "media");
+			const result = await sendTrackedMessage(chatJid, await applyOutboundMentionsToContent(chatJid, previewPayload), optionsValue);
+			return normalizeWhatsAppSendResult(result, "media");
 		};
 		const timestamp = inbound.messageTimestampMs;
 		const mentionedJids = extractMentionedJids(msg.message);
@@ -1224,11 +1279,10 @@ function createWhatsAppMessageDeliveryCoordinator(options) {
 			mediaFileName: enriched.mediaFileName,
 			timestamp
 		}, "inbound message");
-		const media = enriched.mediaPath || enriched.mediaType || enriched.mediaFileName || enriched.mediaKind ? {
+		const media = enriched.mediaPath || enriched.mediaType || enriched.mediaFileName ? {
 			path: enriched.mediaPath,
 			type: enriched.mediaType,
-			fileName: enriched.mediaFileName,
-			kind: enriched.mediaKind
+			fileName: enriched.mediaFileName
 		} : void 0;
 		const groupMentions = mentionedJids ? { jids: mentionedJids } : void 0;
 		const group = inbound.group && (inbound.groupSubject || inbound.groupParticipants?.length || groupMentions) ? {
@@ -1236,26 +1290,17 @@ function createWhatsAppMessageDeliveryCoordinator(options) {
 			participants: inbound.groupParticipants,
 			mentions: groupMentions
 		} : void 0;
-		const channelStructuredContext = [
-			...enriched.nativeMedia ? [{
-				label: "WhatsApp media",
-				source: "whatsapp",
-				type: "media",
-				payload: enriched.nativeMedia
-			}] : [],
-			...enriched.contactContext ? [{
-				label: "WhatsApp contact",
-				source: "whatsapp",
-				type: enriched.contactContext.kind,
-				payload: enriched.contactContext
-			}] : [],
-			...enriched.externalAdReplyContext ? [{
-				label: "WhatsApp external ad reply",
-				source: "whatsapp",
-				type: "external_ad_reply",
-				payload: enriched.externalAdReplyContext
-			}] : []
-		];
+		const untrustedStructuredContext = [...enriched.contactContext ? [{
+			label: "WhatsApp contact",
+			source: "whatsapp",
+			type: enriched.contactContext.kind,
+			payload: enriched.contactContext
+		}] : [], ...enriched.externalAdReplyContext ? [{
+			label: "WhatsApp external ad reply",
+			source: "whatsapp",
+			type: "external_ad_reply",
+			payload: enriched.externalAdReplyContext
+		}] : []];
 		const inboundMessage = withDeprecatedWebInboundMessageFlatAliases({
 			admission: inbound.access.admission,
 			event: {
@@ -1266,7 +1311,7 @@ function createWhatsAppMessageDeliveryCoordinator(options) {
 				body: enriched.body,
 				commandBody: enriched.commandBody,
 				location: enriched.location ?? void 0,
-				channelStructuredContext: channelStructuredContext.length > 0 ? channelStructuredContext : void 0,
+				untrustedStructuredContext: untrustedStructuredContext.length > 0 ? untrustedStructuredContext : void 0,
 				media
 			},
 			platform: {
@@ -1294,7 +1339,6 @@ function createWhatsAppMessageDeliveryCoordinator(options) {
 				context: enriched.replyContext,
 				id: enriched.replyContext.id,
 				body: enriched.replyContext.body,
-				media: enriched.replyContext.media,
 				sender: {
 					displayName: enriched.replyContext.sender?.label ?? void 0,
 					jid: enriched.replyContext.sender?.jid ?? void 0,
@@ -1302,78 +1346,38 @@ function createWhatsAppMessageDeliveryCoordinator(options) {
 				}
 			} : void 0,
 			group,
-			turnAdoptionLifecycle: durable.turnAdoptionLifecycle,
+			dedupeKey: inbound.id ? `${options.accountId}:${inbound.remoteJid}:${inbound.id}` : void 0,
+			durableId: durable.durableId,
 			readReceipt: durable.readReceipt,
 			receiveOrder: durable.receiveOrder
 		});
+		const debounceKey = buildInboundDebounceKey(inboundMessage);
+		if (debounceKey) {
+			inboundMessage.debounceKey = debounceKey;
+			if (inboundDebounceMs > 0 && shouldDebounceInboundMessage(inboundMessage)) {
+				pendingDebounceKeys.add(debounceKey);
+				publishPendingWorkState();
+			}
+		}
 		if (inboundMessage.event.id) {
 			const admission = requireWhatsAppInboundAdmission(inboundMessage);
 			cacheInboundMessageMeta(admission.accountId, inboundMessage.platform.chatJid, inboundMessage.event.id, {
 				participant: inboundMessage.platform.senderJid,
 				participantE164: admission.conversation.kind === "direct" ? inboundMessage.platform.senderE164 : void 0,
 				body: inboundMessage.payload.body,
-				media: enriched.nativeMedia,
 				fromMe: inboundMessage.platform.fromMe
 			});
 		}
-		await messageDebouncer.enqueue(inboundMessage);
-	};
-	const processDurableInboundMessage = async (admission, lifecycle) => {
-		const { message: msg, ...context } = admission;
-		rememberBaileysMessage(msg.key?.remoteJid, msg.key?.id, msg.message);
-		const remoteJid = msg.key?.remoteJid;
-		const id = msg.key?.id;
-		const durableId = remoteJid && id ? createHash("sha256").update(`${remoteJid}\n${id}`).digest("hex") : void 0;
-		const preparation = durableId ? preparedInboundByDurableId.get(durableId) : void 0;
-		if (durableId) preparedInboundByDurableId.delete(durableId);
-		if (context.skipRecentOutboundEcho === true) return "completed";
-		const prepared = await preparation;
-		if (prepared === null) return "completed";
-		const inbound = prepared ?? await normalizeInboundMessage(msg);
-		if (!inbound) return "completed";
-		if (await maybeResolveWhatsAppQuestionReaction({
-			cfg: options.loadConfig?.() ?? options.cfg,
-			accountId: options.accountId,
-			msg,
-			senderId: inbound.senderE164 ?? inbound.from,
-			resolveReactionTargetJids,
-			logDebug: (message) => logWhatsAppVerbose$1(options.verbose, message)
-		})) return "completed";
-		const readReceipt = buildReadReceiptTarget(inbound);
-		const deliveryReadReceipt = inbound.access.isSelfChat ? void 0 : readReceipt;
-		if (context.skipStaleAppend === true) {
-			await maybeMarkNonSelfChatReadReceipt(inbound, readReceipt);
-			return "completed";
-		}
-		const enriched = await enrichWhatsAppInboundMessage({
-			msg,
-			sock,
-			mediaMaxMb: options.mediaMaxMb,
-			logVerbose: (message) => logWhatsAppVerbose$1(options.verbose, message)
-		});
-		if (!enriched) {
-			await maybeMarkNonSelfChatReadReceipt(inbound, deliveryReadReceipt);
-			return "completed";
+		try {
+			Promise.resolve(debouncer.enqueue(inboundMessage)).catch((err) => {
+				inboundLogger.error({ error: String(err) }, "failed handling inbound web message");
+				inboundConsoleLog.error(`Failed handling inbound web message: ${String(err)}`);
+			});
+		} catch (err) {
+			inboundLogger.error({ error: String(err) }, "failed handling inbound web message");
+			inboundConsoleLog.error(`Failed handling inbound web message: ${String(err)}`);
 		}
-		recordAcceptedInboundActivity(options.accountId);
-		await enqueueInboundMessage(msg, inbound, enriched, {
-			readReceipt: deliveryReadReceipt,
-			receiveOrder: context.receiveOrder ?? context.receivedAt,
-			turnAdoptionLifecycle: lifecycle
-		});
-		return "deferred";
 	};
-	const durableInboundMonitor = createWhatsAppIngressMonitor({
-		queue: durableInboundQueue,
-		dispatch: async (admission, lifecycle) => ({ kind: await processDurableInboundMessage(admission, lifecycle) }),
-		pollIntervalMs: WHATSAPP_INGRESS_DRAIN_INTERVAL_MS,
-		onLog: (message) => inboundLogger.warn({ message }, "whatsapp ingress drain"),
-		onError: (error) => inboundLogger.error({ error: formatError(error) }, "whatsapp durable inbound drain failed"),
-		onActivityChange: (active) => {
-			durableIngressActive = active;
-			publishPendingWorkState();
-		}
-	});
 	const handleMessagesUpsert = async (upsert) => {
 		if (upsert.type !== "notify" && upsert.type !== "append") return;
 		for (const msg of upsert.messages ?? []) {
@@ -1387,57 +1391,9 @@ function createWhatsAppMessageDeliveryCoordinator(options) {
 				selfLid: self.lid,
 				resolveInboundJid,
 				resolveReactionTargetJids,
-				logVerboseMessage: (message) => logWhatsAppVerbose$1(options.verbose, message)
+				logVerboseMessage: (message) => logWhatsAppVerbose(options.verbose, message)
 			})) continue;
-			const receivedAt = Date.now();
-			const skipStaleAppend = shouldSkipStaleAppend(msg, upsert.type);
-			const skipRecentOutboundEcho = shouldSkipRecentOutboundEcho(msg);
-			const remoteJid = msg.key?.remoteJid;
-			const id = msg.key?.id;
-			const durableId = remoteJid && id ? createHash("sha256").update(`${remoteJid}\n${id}`).digest("hex") : void 0;
-			let resolvePrepared;
-			if (durableId && !preparedInboundByDurableId.has(durableId)) {
-				if (preparedInboundByDurableId.size >= 1e3) {
-					const oldest = preparedInboundByDurableId.keys().next().value;
-					if (oldest !== void 0) preparedInboundByDurableId.delete(oldest);
-				}
-				preparedInboundByDurableId.set(durableId, new Promise((resolve) => {
-					resolvePrepared = resolve;
-				}));
-			}
-			const finishPreparation = (inbound, keepForDrain = false) => {
-				resolvePrepared?.(inbound);
-				if (!keepForDrain && durableId && resolvePrepared) preparedInboundByDurableId.delete(durableId);
-			};
-			let result;
-			try {
-				result = await durableInboundMonitor.admit({
-					message: msg,
-					upsertType: upsert.type,
-					skipStaleAppend,
-					skipRecentOutboundEcho,
-					receivedAt,
-					receiveOrder
-				}, { receivedAt });
-			} catch (error) {
-				finishPreparation(void 0);
-				const formattedError = formatError(error);
-				inboundLogger.error({ error: formattedError }, "failed persisting durable WhatsApp inbound after retries; message dropped");
-				inboundConsoleLog.error(`Failed persisting durable WhatsApp inbound after retries; message dropped: ${formattedError}`);
-				continue;
-			}
-			if (result.kind === "durable" && result.queueResult.kind === "completed") {
-				finishPreparation(void 0);
-				const inbound = await normalizeInboundMessage(msg);
-				if (inbound) await maybeMarkNonSelfChatReadReceipt(inbound, buildReadReceiptTarget(inbound));
-			} else if (result.kind === "durable" && result.queueResult.kind === "accepted") if (skipRecentOutboundEcho) finishPreparation(null);
-			else try {
-				finishPreparation(await normalizeInboundMessage(msg), true);
-			} catch (error) {
-				finishPreparation(void 0);
-				inboundLogger.warn({ error: formatError(error) }, "failed preparing WhatsApp inbound identity; durable drain will normalize again");
-			}
-			else finishPreparation(void 0);
+			await processDurableInboundMessage(msg, upsert.type, receiveOrder);
 		}
 	};
 	const handleMessagesUpsertEvent = (upsert) => {
@@ -1452,24 +1408,22 @@ function createWhatsAppMessageDeliveryCoordinator(options) {
 			publishPendingWorkState();
 		});
 	};
+	const waitForPendingMessageHandlers = async () => {
+		while (pendingMessageHandlers.size > 0) await Promise.all(Array.from(pendingMessageHandlers));
+	};
 	const drainDebouncedInboundMessages = async () => {
-		await messageDebouncer.drain();
+		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 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;
-		}
+		groupMetadataCacheClosed = true;
+		await waitForPendingMessageHandlers();
 		await drainDebouncedInboundMessages();
-		for (;;) {
-			await durableInboundMonitor.waitForIdle();
-			if (!messageDebouncer.hasPendingWork()) break;
-			await drainDebouncedInboundMessages();
-		}
-		await durableInboundMonitor.stop();
 	};
 	const drainInboundBeforeSocketCloseWithTimeout = async () => {
 		let timeout = null;
@@ -1482,212 +1436,8 @@ function createWhatsAppMessageDeliveryCoordinator(options) {
 			})]);
 		} 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
-		});
-		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((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;
-			}
 		}
 	};
-	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);
@@ -1700,135 +1450,110 @@ async function createWhatsAppAttachedSocketSession(options) {
 					error: update.lastDisconnect?.error
 				});
 			}
-		} catch (error) {
-			options.logConnectionError(error);
+		} catch (err) {
+			inboundLogger.error({ error: String(err) }, "connection.update handler error");
 			resolveClose({
 				status: void 0,
 				isLoggedOut: false,
-				error
+				error: err
 			});
 		}
 	};
-	let detachConnectionUpdate;
-	const start = () => {
-		detachConnectionUpdate ??= attachSockListener("connection.update", handleConnectionUpdate);
-	};
-	const stop = () => {
-		detachConnectionUpdate?.();
-		detachConnectionUpdate = void 0;
-	};
-	const closeSocket = () => {
-		try {
-			closeInboundMonitorSocket(sock);
-		} catch (error) {
-			options.logVerbose(`Socket close failed: ${String(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);
 	};
-	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
+	const forgetFullGroupMetadata = (jid) => {
+		options.baileysGroupMetaCache?.delete(jid);
+		groupMetadataCache.delete(jid);
+		groupMetaCache.delete(jid);
+		publishedGroupMetadataJids.delete(jid);
+		invalidatedGroupMetadataJids.add(jid);
 	};
-}
-//#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 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);
+	}));
+	const replayTask = replayPendingDurableInboundMessages().catch((err) => {
+		inboundLogger.error({ error: String(err) }, "failed replaying durable WhatsApp inbound");
+		inboundConsoleLog.error(`Failed replaying durable WhatsApp inbound: ${String(err)}`);
+	});
+	pendingMessageHandlers.add(replayTask);
+	publishPendingWorkState();
+	replayTask.finally(() => {
+		pendingMessageHandlers.delete(replayTask);
+		publishPendingWorkState();
 	});
-	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) => {
+	(async () => {
+		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);
 			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: socketSession.socketOperations,
+		sock: sendApiSocketOperations,
 		defaultAccountId: options.accountId,
-		resolveOutboundMentions: ({ jid, text }) => groupMetadata.resolveOutboundMentions(jid, text),
+		resolveOutboundMentions: ({ jid, text }) => resolveOutboundMentionsForGroup(jid, text),
 		authDir: options.authDir
 	});
-	delivery.start();
-	socketSession.start();
-	groupMetadata.start();
 	return {
 		close: async () => {
-			delivery.stopIntake();
-			socketSession.stop();
-			groupMetadata.close();
 			try {
-				await delivery.drain();
-			} catch (error) {
-				logWhatsAppVerbose(options.verbose, `Inbound close drain failed: ${String(error)}`);
-			} finally {
-				socketSession.closeSocket();
+				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)}`);
+			}
+		},
+		onClose,
+		signalClose: (reason) => {
+			resolveClose(reason ?? {
+				status: void 0,
+				isLoggedOut: false,
+				error: "closed"
+			});
 		},
-		onClose: socketSession.onClose,
-		signalClose: socketSession.signalClose,
-		assertSendReady: socketSession.assertSendReady,
+		assertSendReady: assertCanSendTo,
 		sendComposingTo: sendApi.sendComposingTo,
 		sendMessage: sendApi.sendMessage,
 		sendPoll: sendApi.sendPoll,
@@ -1836,7 +1561,7 @@ async function attachWebInboxToSocket(options) {
 	};
 }
 async function monitorWebInbox(options) {
-	const socketTiming = options.socketTiming ?? resolveWhatsAppSocketTiming();
+	const socketTiming = options.socketTiming ?? resolveWhatsAppSocketTiming(options.cfg);
 	const recentMessageKeys = options.recentMessageKeys ?? /* @__PURE__ */ new Map();
 	const baileysGroupMetaCache = options.baileysGroupMetaCache ?? /* @__PURE__ */ new Map();
 	const sock = await createWaSocket(false, options.verbose, {
@@ -1850,16 +1575,18 @@ async function monitorWebInbox(options) {
 	});
 	try {
 		await waitForWaConnection(sock, { timeoutMs: socketTiming.connectTimeoutMs });
-	} catch (error) {
+	} catch (err) {
 		closeInboundMonitorSocket(sock);
-		throw error;
+		throw err;
 	}
+	const shouldDebounce = options.shouldDebounce;
+	const normalizeAdmittedWebInboundMessage = (msg) => requireAdmittedWhatsAppInboundMessage(normalizeWebInboundMessage(msg));
 	return attachWebInboxToSocket({
 		...options,
 		onMessage: async (msg) => {
 			await options.onMessage(normalizeAdmittedWebInboundMessage(msg));
 		},
-		shouldDebounce: options.shouldDebounce ? (msg) => options.shouldDebounce?.(normalizeAdmittedWebInboundMessage(msg)) ?? true : void 0,
+		shouldDebounce: shouldDebounce ? (msg) => shouldDebounce(normalizeAdmittedWebInboundMessage(msg)) : void 0,
 		socketTiming,
 		sock,
 		recentMessageKeys,
@@ -1892,13 +1619,12 @@ function isBotMentionedFromTargets(msg, mentionCfg, targets) {
 	const isGroupConversation = requireWhatsAppInboundAdmission(msg).conversation.kind === "group";
 	const isSelfChat = explicitSelfChatOverride ? Boolean(mentionCfg.isSelfChat) : isSelfChatMode(targets.self.e164, mentionCfg.allowFrom) && !isGroupConversation;
 	const hasMentions = targets.normalizedMentions.length > 0;
-	const hasNativeMentionsOutsideSelfChat = hasMentions && !isSelfChat;
-	if (hasNativeMentionsOutsideSelfChat) {
+	if (hasMentions && !isSelfChat) {
 		for (const mention of targets.normalizedMentions) if (identitiesOverlap(targets.self, mention)) return true;
+		return false;
 	} else if (hasMentions && isSelfChat) {}
 	const bodyClean = clean(msg.payload.body);
 	if (mentionCfg.mentionRegexes.some((re) => re.test(bodyClean))) return true;
-	if (hasNativeMentionsOutsideSelfChat) return false;
 	if (targets.self.e164) {
 		const selfDigits = targets.self.e164.replace(/\D/g, "");
 		if (selfDigits) {
@@ -2037,7 +1763,6 @@ 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;
@@ -2047,19 +1772,19 @@ function createEchoTracker(params) {
 	};
 	const rememberText = (text, opts) => {
 		if (!text) return;
-		recentlySent.add(buildTextKey(text, opts.conversationId));
+		recentlySent.add(text);
 		if (opts.combinedBody && opts.combinedBodySessionKey) recentlySent.add(buildCombinedKey({
 			sessionKey: opts.combinedBodySessionKey,
 			combinedBody: opts.combinedBody
 		}));
-		if (opts.logVerboseMessage) params.logVerbose?.(`Added to echo detection set (size now: ${recentlySent.size}): ${truncateUtf16Safe(text, 50)}...`);
+		if (opts.logVerboseMessage) params.logVerbose?.(`Added to echo detection set (size now: ${recentlySent.size}): ${text.slice(0, 50)}...`);
 		trim();
 	};
 	return {
 		rememberText,
-		has: (key, conversationId) => recentlySent.has(buildTextKey(key, conversationId)),
-		forget: (key, conversationId) => {
-			recentlySent.delete(buildTextKey(key, conversationId));
+		has: (key) => recentlySent.has(key),
+		forget: (key) => {
+			recentlySent.delete(key);
 		},
 		buildCombinedKey
 	};
@@ -2080,7 +1805,8 @@ function formatWhatsAppInboundListeningLog(account) {
 const DEFAULT_WHATSAPP_ACK_REACTION = "👀";
 function resolveWhatsAppAckEmoji(params) {
 	if (!params.ackConfig) return "";
-	return (typeof params.ackConfig === "string" ? params.ackConfig : params.ackConfig.emoji)?.trim() || resolveAgentIdentityEmoji(params.cfg, params.agentId) || DEFAULT_WHATSAPP_ACK_REACTION;
+	if (params.ackConfig.emoji !== void 0) return params.ackConfig.emoji.trim();
+	return resolveAgentIdentityEmoji(params.cfg, params.agentId) ?? DEFAULT_WHATSAPP_ACK_REACTION;
 }
 function resolveAgentIdentityEmoji(cfg, agentId) {
 	return resolveAgentIdentity(cfg, agentId)?.emoji?.trim() || void 0;
@@ -2088,7 +1814,7 @@ function resolveAgentIdentityEmoji(cfg, agentId) {
 //#endregion
 //#region extensions/whatsapp/src/auto-reply/monitor/group-activation.ts
 function hasNamedWhatsAppAccounts(cfg) {
-	return Object.keys(cfg.channels?.whatsapp?.accounts ?? {}).some((accountId) => normalizeAccountId(accountId) !== DEFAULT_ACCOUNT_ID);
+	return Object.keys(cfg.channels?.whatsapp?.accounts ?? {}).some((accountId) => normalizeAccountId$1(accountId) !== DEFAULT_ACCOUNT_ID$1);
 }
 function isActivationOnlyEntry(entry) {
 	return entry?.groupActivation !== void 0 && typeof entry?.sessionId !== "string" && typeof entry?.updatedAt !== "number";
@@ -2111,21 +1837,20 @@ async function resolveGroupActivationFor(params) {
 		...sessionScope,
 		sessionKey: params.sessionKey
 	});
-	const activation = (normalizeAccountId(params.accountId) === DEFAULT_ACCOUNT_ID && hasNamedWhatsAppAccounts(params.cfg) && isActivationOnlyEntry(scopedEntry) ? void 0 : scopedEntry?.groupActivation) ?? legacyEntry?.groupActivation;
-	if (activation !== void 0 && scopedEntry?.groupActivation === void 0) {
-		if (scopedEntry) await patchSessionEntry({
-			...sessionScope,
-			sessionKey: params.sessionKey,
-			replaceEntry: true,
-			update: (entry) => {
-				if (entry.groupActivation !== void 0) return null;
-				return {
-					...entry,
-					groupActivation: activation
-				};
-			}
-		});
-	}
+	const activation = (normalizeAccountId$1(params.accountId) === DEFAULT_ACCOUNT_ID$1 && hasNamedWhatsAppAccounts(params.cfg) && isActivationOnlyEntry(scopedEntry) ? void 0 : scopedEntry?.groupActivation) ?? legacyEntry?.groupActivation;
+	if (activation !== void 0 && scopedEntry?.groupActivation === void 0) await patchSessionEntry({
+		...sessionScope,
+		sessionKey: params.sessionKey,
+		fallbackEntry: {},
+		replaceEntry: true,
+		update: (entry) => {
+			if (entry.groupActivation !== void 0) return null;
+			return {
+				...entry,
+				groupActivation: activation
+			};
+		}
+	});
 	const defaultActivation = !resolveWhatsAppInboundPolicy({
 		cfg: params.cfg,
 		accountId: params.accountId
@@ -2133,41 +1858,33 @@ async function resolveGroupActivationFor(params) {
 	return normalizeGroupActivation(activation) ?? defaultActivation;
 }
 //#endregion
-//#region extensions/whatsapp/src/auto-reply/monitor/reaction-participant.ts
-function resolveReactionParticipant(msg) {
-	const sender = getSenderIdentity(msg);
-	return sender.jid ?? sender.lid ?? void 0;
-}
-//#endregion
-//#region extensions/whatsapp/src/auto-reply/monitor/reaction-eligibility.ts
-const DISABLED_REACTION = { status: "disabled" };
-async function resolveWhatsAppReactionEligibility(params) {
-	const messageId = params.msg.event.id;
-	if (!messageId) return DISABLED_REACTION;
+//#region extensions/whatsapp/src/auto-reply/monitor/ack-reaction.ts
+async function maybeSendAckReaction(params) {
+	if (!params.msg.event.id) return null;
 	const admission = requireWhatsAppInboundAdmission(params.msg);
 	const accountId = admission.accountId;
 	if (resolveWhatsAppReactionLevel({
 		cfg: params.cfg,
 		accountId
-	}).level === "off") return DISABLED_REACTION;
-	const scope = params.cfg.messages?.ackReactionScope ?? "group-mentions";
-	if (scope === "off" || scope === "none") return DISABLED_REACTION;
+	}).level === "off") return null;
+	const ackConfig = params.cfg.channels?.whatsapp?.ackReaction;
 	const emoji = resolveWhatsAppAckEmoji({
 		cfg: params.cfg,
 		agentId: params.agentId,
-		ackConfig: params.cfg.messages?.ackReaction
+		ackConfig
 	});
-	const directEnabled = scope === "all" || scope === "direct";
-	const groupMode = scope === "all" || scope === "group-all" ? "always" : scope === "direct" ? "never" : "mentions";
+	const directEnabled = ackConfig?.direct ?? true;
+	const groupMode = ackConfig?.group ?? "mentions";
 	const isGroup = admission.conversation.kind === "group";
+	const conversationIdForCheck = admission.conversation.id;
 	const activation = isGroup ? await resolveGroupActivationFor({
 		cfg: params.cfg,
 		accountId,
 		agentId: params.agentId,
 		sessionKey: params.sessionKey,
-		conversationId: admission.conversation.id
+		conversationId: conversationIdForCheck
 	}) : null;
-	if (!shouldAckReactionForWhatsApp({
+	const shouldSendReaction = () => shouldAckReactionForWhatsApp({
 		emoji,
 		isDirect: admission.conversation.kind === "direct",
 		isGroup,
@@ -2175,50 +1892,32 @@ async function resolveWhatsAppReactionEligibility(params) {
 		groupMode,
 		wasMentioned: (params.msg.groupMention?.wasMentioned ?? params.msg.wasMentioned) === true,
 		groupActivated: activation === "always"
-	})) return DISABLED_REACTION;
-	const participant = resolveReactionParticipant(params.msg);
-	return {
-		status: "prepared",
-		chatId: params.msg.platform.chatJid,
-		messageId,
-		emoji,
-		reactionOptions: {
-			verbose: params.verbose,
-			fromMe: false,
-			...participant ? { participant } : {},
-			accountId,
-			cfg: params.cfg
-		}
-	};
-}
-//#endregion
-//#region extensions/whatsapp/src/auto-reply/monitor/ack-reaction.ts
-async function maybeSendAckReaction(params) {
-	const eligibility = await resolveWhatsAppReactionEligibility({
-		cfg: params.cfg,
-		msg: params.msg,
-		agentId: params.agentId,
-		sessionKey: params.sessionKey,
-		verbose: params.verbose
 	});
-	if (eligibility.status === "disabled") return null;
-	const { chatId, messageId, emoji, reactionOptions } = eligibility;
+	if (!shouldSendReaction()) return null;
 	params.info({
-		chatId,
-		messageId,
+		chatId: params.msg.platform.chatJid,
+		messageId: params.msg.event.id,
 		emoji
 	}, "sending ack reaction");
+	const sender = getSenderIdentity(params.msg);
+	const reactionOptions = {
+		verbose: params.verbose,
+		fromMe: false,
+		...sender.jid ? { participant: sender.jid } : {},
+		accountId,
+		cfg: params.cfg
+	};
 	return createAckReactionHandle({
 		ackReactionValue: emoji,
-		send: () => sendReactionWhatsApp(chatId, messageId, emoji, reactionOptions),
-		remove: () => sendReactionWhatsApp(chatId, messageId, "", reactionOptions),
+		send: () => sendReactionWhatsApp(params.msg.platform.chatJid, params.msg.event.id, emoji, reactionOptions),
+		remove: () => sendReactionWhatsApp(params.msg.platform.chatJid, params.msg.event.id, "", reactionOptions),
 		onSendError: (err) => {
 			params.warn({
 				error: formatError(err),
-				chatId,
-				messageId
+				chatId: params.msg.platform.chatJid,
+				messageId: params.msg.event.id
 			}, "failed to send ack reaction");
-			logVerbose(`WhatsApp ack reaction failed for chat ${chatId}: ${formatError(err)}`);
+			logVerbose(`WhatsApp ack reaction failed for chat ${params.msg.platform.chatJid}: ${formatError(err)}`);
 		}
 	});
 }
@@ -2351,12 +2050,17 @@ function formatGroupMembers(params) {
 }
 //#endregion
 //#region extensions/whatsapp/src/auto-reply/monitor/group-gating.ts
-const groupDropWarned = createDedupeCache({
-	ttlMs: 0,
-	maxSize: 100
-});
+const MAX_GROUP_DROP_WARNINGS = 100;
+const groupDropWarned = /* @__PURE__ */ new Set();
 function shouldWarnForGroupDrop(warnKey) {
-	return !groupDropWarned.check(warnKey);
+	if (groupDropWarned.has(warnKey)) return false;
+	groupDropWarned.add(warnKey);
+	while (groupDropWarned.size > MAX_GROUP_DROP_WARNINGS) {
+		const oldest = groupDropWarned.values().next().value;
+		if (!oldest) break;
+		groupDropWarned.delete(oldest);
+	}
+	return true;
 }
 function isOwnerSender(baseMentionConfig, msg, authDir) {
 	const sender = normalizeE164(getSenderIdentity(msg, authDir).e164 ?? "");
@@ -2374,13 +2078,7 @@ function recordPendingGroupHistoryEntry(params) {
 			body: params.body ?? params.msg.payload.body,
 			timestamp: params.msg.event.timestamp,
 			id: params.msg.event.id,
-			senderJid: senderIdentity.jid ?? params.msg.platform.senderJid,
-			...params.body === void 0 && params.msg.payload.media ? { 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
-			}] } : {}
+			senderJid: senderIdentity.jid ?? params.msg.platform.senderJid
 		}
 	});
 }
@@ -2468,11 +2166,13 @@ async function applyGroupGating(params) {
 		conversationId
 	}) !== "always";
 	const replyContext = getReplyContext(params.msg, params.authDir);
+	const implicitReplyToSelf = params.selfChatMode === true && identitiesOverlap(self, sender);
+	const implicitMentionKinds = implicitMentionKindWhen("quoted_bot", !implicitReplyToSelf && identitiesOverlap(self, replyContext?.sender));
 	const mentionDecision = resolveInboundMentionDecision({
 		facts: {
 			canDetectMention: true,
 			wasMentioned,
-			implicitMentionKinds: implicitMentionKindWhen("quoted_bot", !(params.selfChatMode === true && identitiesOverlap(self, sender)) && identitiesOverlap(self, replyContext?.sender))
+			implicitMentionKinds
 		},
 		policy: {
 			isGroup: true,
@@ -2559,57 +2259,6 @@ function resolveWhatsAppDirectSystemPrompt(params) {
 	return wildcard != null ? wildcard.trim() || void 0 : void 0;
 }
 //#endregion
-//#region extensions/whatsapp/src/outbound-retry.ts
-const WHATSAPP_OUTBOUND_MAX_ATTEMPTS = 3;
-const WHATSAPP_OUTBOUND_MIN_DELAY_MS = 500;
-const WHATSAPP_OUTBOUND_MAX_DELAY_MS = 1e3;
-const WHATSAPP_RETRYABLE_OUTBOUND_ERROR_PATTERN = /closed|reset|timed\s*out|disconnect/i;
-var WhatsAppOutboundRetryError = class extends Error {
-	constructor(original) {
-		super(formatError(original), { cause: original });
-		this.original = original;
-	}
-};
-function isRetryableWhatsAppOutboundError(error) {
-	if (isWhatsAppSocketOperationTimeoutError(error)) return false;
-	return WHATSAPP_RETRYABLE_OUTBOUND_ERROR_PATTERN.test(formatError(error));
-}
-async function sendWhatsAppOutboundWithRetry(params) {
-	const runWithRetry = createChannelApiRetryRunner({
-		retry: {
-			attempts: WHATSAPP_OUTBOUND_MAX_ATTEMPTS,
-			minDelayMs: WHATSAPP_OUTBOUND_MIN_DELAY_MS,
-			maxDelayMs: WHATSAPP_OUTBOUND_MAX_DELAY_MS,
-			jitter: 0
-		},
-		strictShouldRetry: true,
-		retryAfterMs: () => void 0,
-		shouldRetry: (error, attempt) => {
-			if (!(error instanceof WhatsAppOutboundRetryError) || !isRetryableWhatsAppOutboundError(error.original)) return false;
-			params.onRetry?.({
-				attempt,
-				maxAttempts: WHATSAPP_OUTBOUND_MAX_ATTEMPTS,
-				backoffMs: Math.min(WHATSAPP_OUTBOUND_MIN_DELAY_MS * 2 ** (attempt - 1), WHATSAPP_OUTBOUND_MAX_DELAY_MS),
-				error: error.original,
-				errorText: formatError(error.original)
-			});
-			return true;
-		}
-	});
-	try {
-		return await runWithRetry(async () => {
-			try {
-				return await params.send();
-			} catch (error) {
-				throw new WhatsAppOutboundRetryError(error);
-			}
-		});
-	} catch (error) {
-		if (error instanceof WhatsAppOutboundRetryError) throw error.original;
-		throw error;
-	}
-}
-//#endregion
 //#region extensions/whatsapp/src/auto-reply/util.ts
 function elide(text, limit = 400) {
 	if (!text) return text;
@@ -2649,26 +2298,13 @@ function isLikelyWhatsAppCryptoError(reason) {
 		if (typeof value === "function") return value.name ? `[function ${value.name}]` : "[function]";
 		return Object.prototype.toString.call(value);
 	};
-	const haystack = normalizeLowercaseStringOrEmpty(reason instanceof Error ? `${reason.message}\n${reason.stack ?? ""}` : formatReason(reason));
+	const raw = reason instanceof Error ? `${reason.message}\n${reason.stack ?? ""}` : formatReason(reason);
+	const haystack = normalizeLowercaseStringOrEmpty(raw);
 	if (!(haystack.includes("unsupported state or unable to authenticate data") || haystack.includes("bad mac"))) return false;
 	return haystack.includes("baileys") || haystack.includes("noise-handler") || haystack.includes("aesdecryptgcm");
 }
 //#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";
@@ -2706,9 +2342,10 @@ function createWhatsAppReplyDeliveryReceipt(results) {
 	});
 }
 async function deliverWebReply(params) {
-	const { replyResult, transport, maxMediaBytes, textLimit, replyLogger, connectionId, skipLog } = params;
-	const conversationId = transport.conversationId;
-	const isGroupConversation = transport.conversationKind === "group";
+	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 replyStarted = Date.now();
 	const sendResults = [];
 	const rememberSendResult = (result) => {
@@ -2729,24 +2366,25 @@ async function deliverWebReply(params) {
 	const tableMode = params.tableMode ?? "code";
 	const chunkMode = params.chunkMode ?? "length";
 	const normalizedReply = params.normalizedReplyResult ?? normalizeWhatsAppOutboundPayload(replyResult, { normalizeText: normalizeWhatsAppPayloadTextPreservingIndentation });
-	const textChunks = markdownToWhatsAppChunks(normalizedReply.text ?? "", textLimit, tableMode, chunkMode);
+	const convertedText = markdownToWhatsApp(convertMarkdownTables$1(normalizedReply.text ?? "", tableMode));
+	const textChunks = chunkMarkdownTextWithMode(convertedText, textLimit, chunkMode);
 	const mediaList = normalizedReply.mediaUrls ?? [];
 	const getQuote = () => {
 		if (!replyResult.replyToId) return;
-		const cached = lookupInboundMessageMeta(transport.accountId, transport.chatJid, replyResult.replyToId);
+		const cached = lookupInboundMessageMeta(admission.accountId, msg.platform.chatJid, replyResult.replyToId);
 		return buildQuotedMessageOptions({
 			messageId: replyResult.replyToId,
-			remoteJid: transport.chatJid,
+			remoteJid: msg.platform.chatJid,
 			fromMe: cached?.fromMe ?? false,
-			participant: cached?.participant ?? (isGroupConversation ? transport.senderJid : void 0),
-			messageText: cached?.body ?? "",
-			media: cached?.media
+			participant: cached?.participant ?? (isGroupConversation ? msg.platform.senderJid : void 0),
+			messageText: cached?.body ?? ""
 		});
 	};
-	const sendWithRetry = async (fn, label) => {
+	const sendWithRetry = async (fn, label, maxAttempts = 3) => {
 		try {
 			return await sendWhatsAppOutboundWithRetry({
 				send: fn,
+				maxAttempts,
 				onRetry: ({ attempt, maxAttempts: retryMaxAttempts, backoffMs, errorText }) => {
 					logVerbose(`Retrying ${label} to ${conversationId} after failure (${attempt}/${retryMaxAttempts - 1}) in ${backoffMs}ms: ${errorText}`);
 				}
@@ -2761,7 +2399,7 @@ async function deliverWebReply(params) {
 		for (const [index, chunk] of textChunks.entries()) {
 			const chunkStarted = Date.now();
 			const quote = getQuote();
-			rememberSendResult(await sendWithRetry(() => transport.reply(chunk, quote), "text"));
+			rememberSendResult(await sendWithRetry(() => msg.platform.reply(chunk, quote), "text"));
 			if (!skipLog) {
 				const durationMs = Date.now() - chunkStarted;
 				whatsappOutboundLog.debug(`Sent chunk ${index + 1}/${totalChunks} to ${conversationId} (${durationMs.toFixed(0)}ms)`);
@@ -2769,10 +2407,10 @@ async function deliverWebReply(params) {
 		}
 		const delivery = finishDelivery();
 		const logPayload = {
-			correlationId: transport.correlationId ?? newConnectionId(),
+			correlationId: msg.event.id ?? newConnectionId(),
 			connectionId: connectionId ?? null,
 			to: conversationId,
-			from: transport.recipientJid,
+			from: msg.platform.recipientJid,
 			text: elide(replyResult.text, 240),
 			mediaUrl: null,
 			mediaSizeBytes: null,
@@ -2784,55 +2422,56 @@ async function deliverWebReply(params) {
 		return delivery;
 	}
 	const remainingText = [...textChunks];
+	const leadingCaption = remainingText.shift() || "";
 	await sendMediaWithLeadingCaption({
 		mediaUrls: mediaList,
-		caption: remainingText.shift() || "",
+		caption: leadingCaption,
 		send: async ({ mediaUrl, caption }) => {
-			const media = await prepareWhatsAppOutboundMedia(await loadWebMedia(mediaUrl, {
+			const media = await prepareWhatsAppOutboundMedia(await loadWebMedia$1(mediaUrl, {
 				maxBytes: maxMediaBytes,
 				localRoots: params.mediaLocalRoots
 			}), mediaUrl);
 			if (shouldLogVerbose()) {
-				logVerbose(`Web auto-reply media size: ${(media.buffer.length / (1024 * 1024)).toFixed(2)}MB`);
+				logVerbose(`Web auto-reply media size: ${(media.buffer.length / 1048576).toFixed(2)}MB`);
 				logVerbose(`Web auto-reply media source: ${mediaUrl} (kind ${media.kind})`);
 			}
 			if (media.kind === "image") {
 				const quote = getQuote();
-				rememberSendResult(await sendWithRetry(() => transport.sendMedia({
+				rememberSendResult(await sendWithRetry(() => msg.platform.sendMedia({
 					image: media.buffer,
 					caption,
 					mimetype: media.mimetype
 				}, quote), "media:image"));
 			} else if (media.kind === "audio") {
 				const quote = getQuote();
-				rememberSendResult(await sendWithRetry(() => transport.sendMedia({
+				rememberSendResult(await sendWithRetry(() => msg.platform.sendMedia({
 					audio: media.buffer,
 					ptt: true,
 					mimetype: media.mimetype
 				}, quote), "media:audio"));
-				if (caption) rememberSendResult(await sendWithRetry(() => transport.reply(caption, quote), "media:audio-text"));
+				if (caption) rememberSendResult(await sendWithRetry(() => msg.platform.reply(caption, quote), "media:audio-text"));
 			} else if (media.kind === "video") {
 				const quote = getQuote();
-				rememberSendResult(await sendWithRetry(() => transport.sendMedia({
+				rememberSendResult(await sendWithRetry(() => msg.platform.sendMedia({
 					video: media.buffer,
 					caption,
 					mimetype: media.mimetype
 				}, quote), "media:video"));
 			} else {
 				const quote = getQuote();
-				rememberSendResult(await sendWithRetry(() => transport.sendMedia({
+				rememberSendResult(await sendWithRetry(() => msg.platform.sendMedia({
 					document: media.buffer,
 					fileName: media.fileName,
 					caption,
 					mimetype: media.mimetype
 				}, quote), "media:document"));
 			}
-			whatsappOutboundLog.info(`Sent media reply to ${conversationId} (${(media.buffer.length / (1024 * 1024)).toFixed(2)}MB)`);
+			whatsappOutboundLog.info(`Sent media reply to ${conversationId} (${(media.buffer.length / 1048576).toFixed(2)}MB)`);
 			replyLogger.info({
-				correlationId: transport.correlationId ?? newConnectionId(),
+				correlationId: msg.event.id ?? newConnectionId(),
 				connectionId: connectionId ?? null,
 				to: conversationId,
-				from: transport.recipientJid,
+				from: msg.platform.recipientJid,
 				text: caption ?? null,
 				mediaUrl,
 				mediaSizeBytes: media.buffer.length,
@@ -2848,16 +2487,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(() => transport.reply("⚠️ Media unavailable.", getQuote()), "media:fallback-unavailable"));
+				rememberSendResult(await sendWithRetry(() => msg.platform.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(() => transport.reply(fallbackText, getQuote()), "media:fallback-text"));
+			rememberSendResult(await sendWithRetry(() => msg.platform.reply(fallbackText, getQuote()), "media:fallback-text"));
 		}
 	});
-	for (const chunk of remainingText) rememberSendResult(await sendWithRetry(() => transport.reply(chunk, getQuote()), "media:text"));
+	for (const chunk of remainingText) rememberSendResult(await sendWithRetry(() => msg.platform.reply(chunk, getQuote()), "media:text"));
 	return finishDelivery();
 }
 //#endregion
@@ -2875,106 +2514,32 @@ function isWhatsAppSupplementalSenderAllowed(params) {
 	return false;
 }
 function resolveVisibleWhatsAppGroupHistory(params) {
+	if (params.groupPolicy !== "allowlist") return params.history;
 	return filterSupplementalContextItems({
 		items: params.history,
 		mode: params.mode,
 		kind: "history",
-		isSenderAllowed: (entry) => resolveInboundSupplementalSenderAllowed({
-			isGroup: true,
-			groupPolicy: params.groupPolicy,
+		isSenderAllowed: (entry) => isWhatsAppSupplementalSenderAllowed({
 			allowFrom: params.groupAllowFrom,
-			isSenderAllowed: (allowFrom) => isWhatsAppSupplementalSenderAllowed({
-				allowFrom,
-				authDir: params.authDir,
-				sender: entry.senderJid ? { jid: entry.senderJid } : null
-			})
+			authDir: params.authDir,
+			sender: entry.senderJid ? { jid: entry.senderJid } : null
 		})
 	}).items;
 }
 function resolveVisibleWhatsAppReplyContext(params) {
 	const replyTo = getReplyContext(params.msg, params.authDir);
 	if (!replyTo) return null;
-	const admission = requireWhatsAppInboundAdmission(params.msg);
-	const previewBody = [replyTo.body, formatMediaPlaceholderText(replyTo.media ? [replyTo.media] : [])].filter(Boolean).join("\n");
-	const senderAllowed = resolveInboundSupplementalSenderAllowed({
-		isGroup: admission.conversation.kind === "group",
-		groupPolicy: params.groupPolicy,
+	const senderAllowed = requireWhatsAppInboundAdmission(params.msg).conversation.kind !== "group" || params.groupPolicy !== "allowlist" ? true : isWhatsAppSupplementalSenderAllowed({
 		allowFrom: params.groupAllowFrom,
-		isSenderAllowed: (allowFrom) => isWhatsAppSupplementalSenderAllowed({
-			allowFrom,
-			authDir: params.authDir,
-			sender: replyTo.sender
-		})
+		authDir: params.authDir,
+		sender: replyTo.sender
 	});
-	const visible = filterChannelInboundQuoteContext(params.mode, {
+	return filterChannelInboundQuoteContext(params.mode, {
 		id: replyTo.id,
-		body: previewBody,
+		body: replyTo.body,
 		sender: replyTo.sender?.label ?? void 0,
 		senderAllowed
-	});
-	return visible ? {
-		...replyTo,
-		body: visible.body ?? ""
-	} : 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
-	};
+	}) ? replyTo : null;
 }
 //#endregion
 //#region extensions/whatsapp/src/auto-reply/monitor/inbound-dispatch.ts
@@ -2990,36 +2555,26 @@ 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;
+function whatsAppReplyDeliveryVisibilityFromDurableResult(result) {
+	return whatsAppReplyDeliveryVisibility(result.visibleReplySent === true);
 }
 function readTrimmedString(value) {
 	return typeof value === "string" ? value.trim() : "";
 }
 function markWhatsAppReplyDeliveryErrorVisibleAfterFlush(error, flushResult) {
-	if (flushResult.delivered === 0) return error;
-	if (isWhatsAppVisibleDeliveryError(error)) return error;
-	return markWhatsAppVisibleDeliveryError(new Error("deferred WhatsApp media delivery failed after an earlier visible send", { cause: error }));
+	return flushResult.delivered > 0 ? markWhatsAppVisibleDeliveryError(error) : error;
 }
 function logWhatsAppReplyDeliveryError(params) {
+	const admission = requireWhatsAppInboundAdmission(params.msg);
 	params.replyLogger.error({
 		err: normalizeErrForLog(params.err),
 		replyKind: params.info.kind,
-		correlationId: params.transport.correlationId ?? null,
+		correlationId: params.msg.event.id ?? null,
 		connectionId: params.connectionId,
-		conversationId: params.transport.conversationId,
-		chatId: params.transport.chatJid,
-		to: params.transport.conversationId,
-		from: params.transport.recipientJid
+		conversationId: admission.conversation.id,
+		chatId: params.msg.platform.chatJid ?? null,
+		to: admission.conversation.id,
+		from: params.msg.platform.recipientJid ?? null
 	}, "auto-reply delivery failed");
 }
 function resolveWhatsAppDurableReplyToId(params) {
@@ -3027,10 +2582,14 @@ 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.currentMessageId);
+	const currentInboundMessageId = readTrimmedString(params.msg.event.id);
 	if (params.info.kind === "final" && hasVisibleInboundReplyTarget && currentInboundMessageId) return currentInboundMessageId;
 	return null;
 }
+function resolveWhatsAppDisableBlockStreaming(cfg) {
+	if (typeof cfg.channels?.whatsapp?.blockStreaming !== "boolean") return;
+	return !cfg.channels.whatsapp.blockStreaming;
+}
 function resolveWhatsAppDeliverablePayload(payload, info) {
 	if (payload.isReasoning === true || payload.isCompactionNotice === true) return null;
 	if (payload.isError === true) return null;
@@ -3055,58 +2614,31 @@ function shouldDeferWhatsAppMediaOnlyPayload(params) {
 }
 function createWhatsAppMediaOnlyReplyCoalescer(params) {
 	const pendingMediaOnlyPayloads = [];
-	const flushWhere = async (shouldFlush) => {
+	const flushExceptDuplicateMedia = async (mediaUrls) => {
 		const flushResult = {
 			delivered: 0,
 			droppedDuplicateMedia: 0
 		};
-		const candidates = [];
-		const retained = [];
-		for (const pending of pendingMediaOnlyPayloads.splice(0)) if (shouldFlush(pending)) candidates.push(pending);
-		else retained.push(pending);
-		pendingMediaOnlyPayloads.push(...retained);
-		for (const [index, candidate] of candidates.entries()) try {
-			const delivery = await params.deliver(candidate);
-			candidate.resolveFinalization(delivery);
-			if (delivery.visibleReplySent) flushResult.delivered += 1;
-		} catch (error) {
-			const visibleError = markWhatsAppReplyDeliveryErrorVisibleAfterFlush(error, flushResult);
-			candidate.rejectFinalization(error);
-			for (const remaining of candidates.slice(index + 1)) remaining.rejectFinalization(new Error("deferred WhatsApp media delivery was not attempted", { cause: error }));
-			throw visibleError;
+		const pending = pendingMediaOnlyPayloads.splice(0);
+		for (const candidate of pending) {
+			if (mediaUrls && hasWhatsAppMediaUrlOverlap(candidate.mediaUrls, mediaUrls)) {
+				flushResult.droppedDuplicateMedia += 1;
+				continue;
+			}
+			try {
+				if ((await params.deliver(candidate)).visibleReplySent) flushResult.delivered += 1;
+			} catch (error) {
+				throw markWhatsAppReplyDeliveryErrorVisibleAfterFlush(error, flushResult);
+			}
 		}
 		return flushResult;
 	};
 	return {
 		defer(pending) {
-			let resolveFinalization;
-			let rejectFinalization;
-			const finalization = new Promise((resolve, reject) => {
-				resolveFinalization = resolve;
-				rejectFinalization = reject;
-			});
-			pendingMediaOnlyPayloads.push({
-				...pending,
-				resolveFinalization,
-				rejectFinalization
-			});
-			return finalization;
-		},
-		flushNonDuplicateMedia: (mediaUrls) => flushWhere((pending) => !hasWhatsAppMediaUrlOverlap(pending.mediaUrls, mediaUrls)),
-		dropDuplicateMedia(mediaUrls) {
-			const flushResult = {
-				delivered: 0,
-				droppedDuplicateMedia: 0
-			};
-			const retained = [];
-			for (const pending of pendingMediaOnlyPayloads.splice(0)) if (hasWhatsAppMediaUrlOverlap(pending.mediaUrls, mediaUrls)) {
-				pending.resolveFinalization(whatsAppReplyDeliveryVisibility(false));
-				flushResult.droppedDuplicateMedia += 1;
-			} else retained.push(pending);
-			pendingMediaOnlyPayloads.push(...retained);
-			return flushResult;
+			pendingMediaOnlyPayloads.push(pending);
 		},
-		flushAll: () => flushWhere(() => true)
+		flushExceptDuplicateMedia,
+		flushAll: () => flushExceptDuplicateMedia()
 	};
 }
 function logWhatsAppMediaOnlyFlushResult(result) {
@@ -3116,15 +2648,9 @@ function logWhatsAppMediaOnlyFlushResult(result) {
 }
 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);
-}
-function buildWhatsAppInboundTransportContext(msg) {
-	return {
-		...createWhatsAppReplyTransportContext(msg),
-		sendComposing: msg.platform.sendComposing
-	};
+	return params.pipelineResponsePrefix ?? (configuredResponsePrefix === void 0 && params.isSelfChat ? resolveIdentityNamePrefix$1(params.cfg, params.agentId) : void 0);
 }
-async function prepareWhatsAppInboundContext(params) {
+async function buildWhatsAppInboundContext(params) {
 	const admission = requireWhatsAppInboundAdmission(params.msg);
 	const conversationId = admission.conversation.id;
 	const conversationKind = admission.conversation.kind;
@@ -3134,20 +2660,18 @@ async function prepareWhatsAppInboundContext(params) {
 			sender: entry.sender,
 			body: entry.body,
 			timestamp: entry.timestamp,
-			messageId: entry.id,
-			media: entry.media
+			messageId: entry.id
 		})),
 		limit: params.groupHistory?.length ?? 1
 	}) : void 0;
-	const media = await toInboundMediaFactsWithMetadata(params.msg.payload.media ? [{
+	const media = toInboundMediaFacts(params.msg.payload.media?.path || params.msg.payload.media?.url ? [{
 		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
+		contentType: params.msg.payload.media?.type
 	}] : void 0, { transcribed: (_entry, index) => params.mediaTranscribedIndexes?.includes(index) === true });
-	const control = { messageReceivedHooks: params.suppressMessageReceivedHooks ? "channel" : "core" };
-	const inbound = {
+	return buildChannelInboundEventContext({
 		channel: "whatsapp",
+		finalize: finalizeInboundContext,
 		supplemental: {
 			quote: params.visibleReplyTo ? {
 				id: params.visibleReplyTo.id,
@@ -3155,13 +2679,11 @@ async function prepareWhatsAppInboundContext(params) {
 				sender: params.visibleReplyTo.sender?.label ?? void 0
 			} : void 0,
 			groupSystemPrompt: params.groupSystemPrompt,
-			channelStructuredContext: params.msg.payload.channelStructuredContext
+			untrustedContext: params.msg.payload.untrustedStructuredContext
 		},
 		media,
-		event: {
-			id: params.msg.event.id ?? `${conversationId}:${newConnectionId()}`,
-			timestamp: params.msg.event.timestamp
-		},
+		messageId: params.msg.event.id,
+		timestamp: params.msg.event.timestamp,
 		from: conversationId,
 		sender: {
 			id: params.sender.id ?? params.sender.e164,
@@ -3174,51 +2696,70 @@ async function prepareWhatsAppInboundContext(params) {
 		},
 		route: {
 			agentId: params.route.agentId,
-			dmScope: params.route.dmScope,
 			accountId: params.route.accountId,
 			routeSessionKey: params.route.sessionKey
 		},
 		reply: {
 			to: params.msg.platform.recipientJid,
-			originatingTo: conversationId,
-			replyToId: params.visibleReplyTo?.id
+			originatingTo: conversationId
 		},
 		message: {
 			body: params.combinedBody,
 			bodyForAgent: params.bodyForAgent ?? params.msg.payload.body,
 			inboundHistory,
 			rawBody: params.rawBody ?? params.msg.payload.body,
-			commandBody: params.command?.body ?? params.msg.payload.body
+			commandBody: params.commandBody ?? params.msg.payload.body
 		},
-		sessionTranscript: { historyLimit: conversationKind === "group" ? params.groupHistoryLimit ?? params.groupHistory?.length ?? 0 : 0 },
-		mentions: wasMentioned !== void 0 ? {
-			canDetectMention: conversationKind === "group",
-			wasMentioned,
-			requireMention: params.msg.groupMention?.requireMention
-		} : void 0,
-		command: params.command,
-		context: {
-			transcript: params.transcript,
-			groupSubject: params.msg.group?.subject ?? null,
-			groupMembers: formatGroupMembers({
+		access: {
+			...wasMentioned !== void 0 ? { mentions: {
+				canDetectMention: conversationKind === "group",
+				wasMentioned,
+				requireMention: params.msg.groupMention?.requireMention
+			} } : {},
+			commands: { authorized: params.commandAuthorized }
+		},
+		commandTurn: params.commandTurn,
+		extra: {
+			Transcript: params.transcript,
+			GroupSubject: params.msg.group?.subject,
+			GroupMembers: formatGroupMembers({
 				participants: params.msg.group?.participants,
 				roster: params.groupMemberRoster,
 				fallbackE164: params.sender.e164
 			}),
-			senderE164: params.sender.e164,
-			replyThreading: params.replyThreading,
-			location: params.msg.payload.location
+			SenderE164: params.sender.e164,
+			CommandSource: params.commandSource ?? (params.commandTurn?.source === "native" || params.commandTurn?.source === "text" ? params.commandTurn.source : void 0),
+			ReplyThreading: params.replyThreading,
+			SuppressMessageReceivedHooks: params.suppressMessageReceivedHooks,
+			...params.msg.payload.location ? toLocationContext(params.msg.payload.location) : {}
 		}
-	};
-	const projected = projectPreparedChannelInbound({
-		inbound,
-		control
 	});
-	return {
-		inbound,
-		control,
-		turnInput: projected.input,
-		ctxPayload: projected.context
+}
+function normalizeCommandTurnFromContext(value) {
+	if (!value || typeof value !== "object") return;
+	const record = value;
+	const kind = record.kind;
+	const source = record.source;
+	if (kind === "native" && source === "native" && typeof record.authorized === "boolean") return {
+		kind: "native",
+		source: "native",
+		authorized: record.authorized,
+		commandName: typeof record.commandName === "string" ? record.commandName : void 0,
+		body: typeof record.body === "string" ? record.body : void 0
+	};
+	if (kind === "text-slash" && source === "text" && typeof record.authorized === "boolean") return {
+		kind: "text-slash",
+		source: "text",
+		authorized: record.authorized,
+		commandName: typeof record.commandName === "string" ? record.commandName : void 0,
+		body: typeof record.body === "string" ? record.body : void 0
+	};
+	if (kind === "normal" && source === "message") return {
+		kind: "normal",
+		source: "message",
+		authorized: false,
+		commandName: typeof record.commandName === "string" ? record.commandName : void 0,
+		body: typeof record.body === "string" ? record.body : void 0
 	};
 }
 function resolveWhatsAppDmRouteTarget(params) {
@@ -3251,9 +2792,16 @@ 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 conversationId = params.inbound.conversation.id;
+async function dispatchWhatsAppBufferedReply(params) {
+	const admission = requireWhatsAppInboundAdmission(params.msg);
+	const conversationId = admission.conversation.id;
+	const conversationKind = admission.conversation.kind;
 	const statusReactionController = params.statusReactionController ?? null;
+	const statusReactionTiming = {
+		...DEFAULT_TIMING,
+		...params.cfg.messages?.statusReactions?.timing
+	};
+	const removeAckAfterReply = params.cfg.messages?.removeAckAfterReply ?? false;
 	const textLimit = params.maxMediaTextChunkLimit ?? resolveTextChunkLimit(params.cfg, "whatsapp");
 	const chunkMode = resolveChunkMode(params.cfg, "whatsapp", params.route.accountId);
 	const tableMode = resolveMarkdownTableMode$1({
@@ -3262,85 +2810,72 @@ function createWhatsAppReplyPlan(params) {
 		accountId: params.route.accountId
 	});
 	const mediaLocalRoots = getAgentScopedMediaLocalRoots(params.cfg, params.route.agentId);
-	const replyPolicy = resolveWhatsAppInboundReplyPolicy({
+	const sourceReplyChatType = typeof params.context.ChatType === "string" ? params.context.ChatType : conversationKind;
+	const sourceReplyCommandSource = params.context.CommandSource === "native" || params.context.CommandSource === "text" ? params.context.CommandSource : void 0;
+	const sourceReplyCommandTurn = normalizeCommandTurnFromContext(params.context.CommandTurn);
+	const sourceReplyCommandAuthorized = typeof params.context.CommandAuthorized === "boolean" ? params.context.CommandAuthorized : void 0;
+	const sourceReplyDeliveryMode = sourceReplyChatType === "group" || sourceReplyChatType === "channel" ? resolveChannelMessageSourceReplyDeliveryMode({
 		cfg: params.cfg,
-		ctx: params.context,
-		blockStreamingEnabled: resolveChannelStreamingBlockEnabled(params.cfg.channels?.whatsapp)
-	});
+		ctx: {
+			ChatType: sourceReplyChatType,
+			CommandTurn: sourceReplyCommandTurn,
+			CommandSource: sourceReplyCommandSource,
+			CommandAuthorized: sourceReplyCommandAuthorized
+		}
+	}) : void 0;
+	const sourceRepliesAreToolOnly = sourceReplyDeliveryMode === "message_tool_only";
+	const disableBlockStreaming = sourceRepliesAreToolOnly ? true : resolveWhatsAppDisableBlockStreaming(params.cfg);
 	let didSendReply = false;
 	let didLogHeartbeatStrip = false;
-	const recordDeliveredPayload = (payload) => {
-		didSendReply = true;
-		const shouldLog = payload.text ? true : void 0;
-		params.rememberSentText(payload.text, {
-			combinedBody: params.context.Body,
-			combinedBodySessionKey: params.route.sessionKey,
-			conversationId,
-			logVerboseMessage: shouldLog
-		});
-		if (shouldLogVerbose$1()) {
-			const reply = resolveSendableOutboundReplyParts(payload);
-			logVerbose$1(`Reply body: ${payload.text != null ? reply.text : "<media>"}${reply.hasMedia ? " (media)" : ""} -> ${conversationId}`);
-		}
-	};
-	const deliverNormalizedPayload = async (normalizedDeliveryPayload, info, options) => {
+	const deliverNormalizedPayload = async (normalizedDeliveryPayload, info) => {
 		const reply = resolveSendableOutboundReplyParts(normalizedDeliveryPayload);
 		if (!reply.hasMedia && !reply.text.trim()) return whatsAppReplyDeliveryVisibility(false);
-		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) {
+		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) {
 			params.replyLogger.warn({
-				correlationId: params.transport.correlationId ?? null,
+				correlationId: params.msg.event.id ?? null,
 				connectionId: params.connectionId,
 				conversationId,
-				chatId: params.transport.chatJid,
+				chatId: params.msg.platform.chatJid,
 				to: conversationId,
-				from: params.transport.recipientJid,
+				from: params.msg.platform.recipientJid,
 				replyKind: info.kind
 			}, "auto-reply was not accepted by WhatsApp provider");
-			return result;
+			return whatsAppReplyDeliveryVisibility(false);
 		}
-		if (options?.recordDelivery !== false) try {
-			recordDeliveredPayload(normalizedDeliveryPayload);
-		} catch (error) {
-			throw createChannelPartialDeliveryError(error, {
-				...result,
-				visibleReplySent: true
-			});
+		didSendReply = true;
+		const shouldLog = normalizedDeliveryPayload.text ? true : void 0;
+		params.rememberSentText(normalizedDeliveryPayload.text, {
+			combinedBody: params.context.Body,
+			combinedBodySessionKey: params.route.sessionKey,
+			logVerboseMessage: shouldLog
+		});
+		const fromDisplay = conversationId;
+		if (shouldLogVerbose$1()) {
+			const preview = normalizedDeliveryPayload.text != null ? reply.text : "<media>";
+			logVerbose$1(`Reply body: ${preview}${reply.hasMedia ? " (media)" : ""} -> ${fromDisplay}`);
 		}
-		return result;
+		return whatsAppReplyDeliveryVisibility(true);
 	};
 	const mediaOnlyCoalescer = createWhatsAppMediaOnlyReplyCoalescer({ deliver: async (pending) => {
 		return await deliverNormalizedPayload(pending.payload, pending.info);
 	} });
-	return {
-		afterRecord: () => {
-			if (statusReactionController) statusReactionController.setThinking();
-		},
+	if (statusReactionController) statusReactionController.setThinking();
+	const dispatchResult = await dispatchReplyWithBufferedBlockDispatcher({
+		ctx: params.context,
+		cfg: params.cfg,
+		replyResolver: params.replyResolver,
 		dispatcherOptions: {
 			...params.replyPipeline,
 			onHeartbeatStrip: () => {
@@ -3349,140 +2884,168 @@ function createWhatsAppReplyPlan(params) {
 					logVerbose$1("Stripped stray HEARTBEAT_OK token from web reply");
 				}
 			},
-			onSettled: async () => {
-				const flushResult = await mediaOnlyCoalescer.flushAll();
-				logWhatsAppMediaOnlyFlushResult(flushResult);
-				return whatsAppReplyDeliveryVisibility(didSendReply || flushResult.delivered > 0);
-			},
-			onReplyStart: params.transport.sendComposing
-		},
-		delivery: {
-			observeMessageSent: true,
-			preparePayload: async (payload, info) => {
+			deliver: async (payload, info) => {
 				const deliveryPayload = resolveWhatsAppDeliverablePayload(payload, info);
-				if (!deliveryPayload) return null;
+				if (!deliveryPayload) return whatsAppReplyDeliveryVisibility(false);
 				const normalizedOutboundPayload = normalizeWhatsAppOutboundPayload(deliveryPayload, { normalizeText: normalizeWhatsAppPayloadTextPreservingIndentation });
 				const normalizedDeliveryPayload = deliveryPayload.text === void 0 ? {
 					...normalizedOutboundPayload,
 					text: void 0
 				} : normalizedOutboundPayload;
 				const reply = resolveSendableOutboundReplyParts(normalizedDeliveryPayload);
-				if (!reply.hasMedia && !reply.text.trim()) return normalizedDeliveryPayload;
-				const mediaUrls = getWhatsAppPayloadMediaUrls(normalizedDeliveryPayload);
-				logWhatsAppMediaOnlyFlushResult(reply.hasMedia ? shouldDeferWhatsAppMediaOnlyPayload({
-					info,
-					mediaUrls,
-					reply
-				}) ? {
-					delivered: 0,
-					droppedDuplicateMedia: 0
-				} : await mediaOnlyCoalescer.flushNonDuplicateMedia(mediaUrls) : await mediaOnlyCoalescer.flushAll());
-				return normalizedDeliveryPayload;
-			},
-			durable: (payload, info) => {
-				const reply = resolveSendableOutboundReplyParts(payload);
-				if (reply.hasMedia || !reply.text.trim()) return false;
-				return {
-					to: conversationId,
-					replyToId: resolveWhatsAppDurableReplyToId({
-						context: params.context,
-						info,
-						currentMessageId: params.transport.correlationId,
-						payload
-					}),
-					formatting: {
-						textLimit,
-						tableMode,
-						chunkMode
-					}
-				};
-			},
-			deliver: async (payload, info) => {
-				const normalizedDeliveryPayload = payload;
-				const reply = resolveSendableOutboundReplyParts(normalizedDeliveryPayload);
 				if (!reply.hasMedia && !reply.text.trim()) return whatsAppReplyDeliveryVisibility(false);
-				if (!reply.hasMedia) return await deliverNormalizedPayload(normalizedDeliveryPayload, info, { recordDelivery: false });
+				if (!reply.hasMedia) {
+					const flushResult = await mediaOnlyCoalescer.flushAll();
+					logWhatsAppMediaOnlyFlushResult(flushResult);
+					try {
+						const durable = await deliverInboundReplyWithMessageSendContext({
+							cfg: params.cfg,
+							channel: "whatsapp",
+							accountId: params.route.accountId,
+							agentId: params.route.agentId,
+							ctxPayload: params.context,
+							payload: normalizedDeliveryPayload,
+							info,
+							to: conversationId,
+							replyToId: resolveWhatsAppDurableReplyToId({
+								context: params.context,
+								info,
+								msg: params.msg,
+								payload: normalizedDeliveryPayload
+							}),
+							formatting: {
+								textLimit,
+								tableMode,
+								chunkMode
+							}
+						});
+						if (durable.status === "failed") {
+							if (durable.sentBeforeError === true) throw markWhatsAppVisibleDeliveryError(durable.error);
+							throw durable.error;
+						}
+						if (durable.status === "handled_visible") {
+							didSendReply = true;
+							const shouldLog = normalizedDeliveryPayload.text ? true : void 0;
+							params.rememberSentText(normalizedDeliveryPayload.text, {
+								combinedBody: params.context.Body,
+								combinedBodySessionKey: params.route.sessionKey,
+								logVerboseMessage: shouldLog
+							});
+							return whatsAppReplyDeliveryVisibilityFromDurableResult(durable.delivery);
+						}
+						if (durable.status === "handled_no_send") return flushResult.delivered > 0 ? whatsAppReplyDeliveryVisibility(true) : whatsAppReplyDeliveryVisibilityFromDurableResult(durable.delivery);
+						const delivery = await deliverNormalizedPayload(normalizedDeliveryPayload, info);
+						return flushResult.delivered > 0 && !delivery.visibleReplySent ? whatsAppReplyDeliveryVisibility(true) : delivery;
+					} catch (error) {
+						throw markWhatsAppReplyDeliveryErrorVisibleAfterFlush(error, flushResult);
+					}
+				}
 				const mediaUrls = getWhatsAppPayloadMediaUrls(normalizedDeliveryPayload);
 				if (shouldDeferWhatsAppMediaOnlyPayload({
 					info,
 					mediaUrls,
 					reply
-				})) return {
-					visibleReplySent: false,
-					finalization: mediaOnlyCoalescer.defer({
+				})) {
+					mediaOnlyCoalescer.defer({
 						info,
 						mediaUrls,
 						payload: normalizedDeliveryPayload
-					})
-				};
+					});
+					return whatsAppReplyDeliveryVisibility(false);
+				}
+				const flushResult = await mediaOnlyCoalescer.flushExceptDuplicateMedia(mediaUrls);
+				logWhatsAppMediaOnlyFlushResult(flushResult);
 				try {
-					const result = await deliverNormalizedPayload(normalizedDeliveryPayload, info);
-					if (result.visibleReplySent) logWhatsAppMediaOnlyFlushResult(mediaOnlyCoalescer.dropDuplicateMedia(mediaUrls));
-					return result;
+					const delivery = await deliverNormalizedPayload(normalizedDeliveryPayload, info);
+					return flushResult.delivered > 0 && !delivery.visibleReplySent ? whatsAppReplyDeliveryVisibility(true) : delivery;
 				} catch (error) {
-					if (isWhatsAppVisibleDeliveryError(error)) logWhatsAppMediaOnlyFlushResult(mediaOnlyCoalescer.dropDuplicateMedia(mediaUrls));
-					throw error;
+					throw markWhatsAppReplyDeliveryErrorVisibleAfterFlush(error, flushResult);
 				}
 			},
-			onDelivered: (payload, _info, result) => {
-				if (!resolveSendableOutboundReplyParts(payload).hasMedia && result?.visibleReplySent === true) recordDeliveredPayload(payload);
+			onSettled: async () => {
+				const flushResult = await mediaOnlyCoalescer.flushAll();
+				logWhatsAppMediaOnlyFlushResult(flushResult);
+				return whatsAppReplyDeliveryVisibility(flushResult.delivered > 0);
 			},
+			onReplyStart: params.msg.platform.sendComposing,
+			...statusReactionController ? {
+				onCompactionStart: async () => {
+					await statusReactionController.setCompacting();
+				},
+				onCompactionEnd: async () => {
+					statusReactionController.cancelPending();
+					await statusReactionController.setThinking();
+				}
+			} : {},
 			onError: (err, info) => {
-				if (didSendReply) markWhatsAppVisibleDeliveryError(err);
 				logWhatsAppReplyDeliveryError({
 					err,
 					info,
 					connectionId: params.connectionId,
-					transport: params.transport,
+					msg: params.msg,
 					replyLogger: params.replyLogger
 				});
 			}
 		},
 		replyOptions: {
-			...params.turnAdoptionLifecycle ? { turnAdoptionLifecycle: params.turnAdoptionLifecycle } : {},
-			suppressTyping: replyPolicy.suppressTyping,
-			disableBlockStreaming: replyPolicy.disableBlockStreaming,
-			...replyPolicy.sourceReplyDeliveryMode ? { sourceReplyDeliveryMode: replyPolicy.sourceReplyDeliveryMode } : {},
+			suppressTyping: sourceRepliesAreToolOnly && conversationKind === "group" && !(params.msg.groupMention?.wasMentioned ?? params.msg.wasMentioned),
+			disableBlockStreaming,
+			...sourceReplyDeliveryMode ? { sourceReplyDeliveryMode } : {},
 			onModelSelected: params.onModelSelected,
-			...statusReactionController ? {
-				onToolStart: async (payload) => {
-					const toolName = payload.name?.trim();
-					if (toolName) await statusReactionController.setTool(toolName);
-				},
-				onCompactionStart: async () => {
-					await statusReactionController.setCompacting();
-				},
-				onCompactionEnd: async () => {
-					statusReactionController.cancelPending();
-					await statusReactionController.setThinking();
-				}
-			} : {}
-		},
-		replyResolver: params.replyResolver,
-		finalize: (dispatchResult) => {
-			const didQueueVisibleReply = hasVisibleInboundReplyDispatch(dispatchResult);
-			const didDeliverVisibleReply = didSendReply || dispatchResult.observedReplyDelivery === true;
-			if (!didQueueVisibleReply && !didDeliverVisibleReply) {
-				if (statusReactionController) finalizeWhatsAppStatusReaction({
-					controller: statusReactionController,
-					outcome: "error"
-				});
-				if (params.shouldClearGroupHistory) params.groupHistories.set(params.groupHistoryKey, []);
-				logVerbose$1("Skipping auto-reply: silent token or no text/media returned from resolver");
-				return false;
-			}
-			if (statusReactionController) finalizeWhatsAppStatusReaction({
-				controller: statusReactionController,
-				outcome: didDeliverVisibleReply ? "done" : "error"
-			});
-			if (params.shouldClearGroupHistory) params.groupHistories.set(params.groupHistoryKey, []);
-			return didDeliverVisibleReply;
+			...statusReactionController ? { onToolStart: async (payload) => {
+				const toolName = payload.name?.trim();
+				if (toolName) await statusReactionController.setTool(toolName);
+			} } : {}
 		}
-	};
+	});
+	const didQueueVisibleReply = hasVisibleInboundReplyDispatch(dispatchResult);
+	const didDeliverVisibleReply = didSendReply || dispatchResult.observedReplyDelivery === true;
+	if (!didQueueVisibleReply) {
+		if (statusReactionController) finalizeWhatsAppStatusReaction({
+			controller: statusReactionController,
+			outcome: "error",
+			hasFinalResponse: false,
+			removeAckAfterReply,
+			timing: statusReactionTiming
+		});
+		if (params.shouldClearGroupHistory) params.groupHistories.set(params.groupHistoryKey, []);
+		logVerbose$1("Skipping auto-reply: silent token or no text/media returned from resolver");
+		return false;
+	}
+	if (statusReactionController) finalizeWhatsAppStatusReaction({
+		controller: statusReactionController,
+		outcome: didDeliverVisibleReply ? "done" : "error",
+		hasFinalResponse: didDeliverVisibleReply,
+		removeAckAfterReply,
+		timing: statusReactionTiming
+	});
+	if (params.shouldClearGroupHistory) params.groupHistories.set(params.groupHistoryKey, []);
+	return didDeliverVisibleReply;
 }
 async function finalizeWhatsAppStatusReaction(params) {
-	if (params.outcome === "done") await params.controller.setDone();
-	else await params.controller.setError();
+	if (params.outcome === "done") {
+		await params.controller.setDone();
+		if (params.removeAckAfterReply) {
+			await new Promise((resolve) => {
+				setTimeout(resolve, params.timing.doneHoldMs);
+			});
+			await params.controller.clear();
+		} else await params.controller.restoreInitial();
+		return;
+	}
+	await params.controller.setError();
+	if (params.hasFinalResponse) {
+		if (params.removeAckAfterReply) {
+			await new Promise((resolve) => {
+				setTimeout(resolve, params.timing.errorHoldMs);
+			});
+			await params.controller.clear();
+		} else await params.controller.restoreInitial();
+		return;
+	}
+	if (params.removeAckAfterReply) await new Promise((resolve) => {
+		setTimeout(resolve, params.timing.errorHoldMs);
+	});
 	await params.controller.restoreInitial();
 }
 //#endregion
@@ -3496,7 +3059,7 @@ function resolveIdentityNamePrefix(cfg, agentId) {
 	return identityName ? `[${identityName}]` : void 0;
 }
 function resolveMessagePrefix(cfg, agentId, opts) {
-	const configured = opts?.configured;
+	const configured = opts?.configured ?? cfg.messages?.messagePrefix;
 	if (configured !== void 0) return configured;
 	if (opts?.hasAllowFrom === true) return "";
 	return resolveIdentityNamePrefix(cfg, agentId) ?? opts?.fallback ?? "[openclaw]";
@@ -3513,7 +3076,7 @@ function formatReplyContext(msg) {
 function buildInboundLine(params) {
 	const { cfg, msg, agentId, previousTimestamp, envelope } = params;
 	const messagePrefix = resolveMessagePrefix(cfg, agentId, {
-		configured: cfg.channels?.whatsapp?.responsePrefix,
+		configured: cfg.channels?.whatsapp?.messagePrefix,
 		hasAllowFrom: (cfg.channels?.whatsapp?.allowFrom?.length ?? 0) > 0
 	});
 	const admission = requireWhatsAppInboundAdmission(msg);
@@ -3543,30 +3106,66 @@ function buildInboundLine(params) {
 //#region extensions/whatsapp/src/auto-reply/monitor/status-reaction.ts
 async function createWhatsAppStatusReactionController(params) {
 	if (!params.msg.event.id) return null;
-	if ((params.cfg.messages?.statusReactions)?.enabled !== true) return null;
-	const eligibility = await resolveWhatsAppReactionEligibility({
+	const statusReactionsConfig = params.cfg.messages?.statusReactions;
+	if (statusReactionsConfig?.enabled !== true) return null;
+	const admission = requireWhatsAppInboundAdmission(params.msg);
+	const accountId = admission.accountId;
+	if (resolveWhatsAppReactionLevel({
+		cfg: params.cfg,
+		accountId
+	}).level === "off") return null;
+	const ackConfig = params.cfg.channels?.whatsapp?.ackReaction;
+	const ackEmoji = resolveWhatsAppAckEmoji({
 		cfg: params.cfg,
-		msg: params.msg,
 		agentId: params.agentId,
-		sessionKey: params.sessionKey,
-		verbose: params.verbose
+		ackConfig
 	});
-	if (eligibility.status === "disabled") return null;
-	const { chatId, messageId, emoji: initialEmoji, reactionOptions } = eligibility;
+	if (!ackEmoji) return null;
+	const directEnabled = ackConfig?.direct ?? true;
+	const groupMode = ackConfig?.group ?? "mentions";
+	const isGroup = admission.conversation.kind === "group";
+	const conversationIdForCheck = admission.conversation.id;
+	const activation = isGroup ? await resolveGroupActivationFor({
+		cfg: params.cfg,
+		accountId,
+		agentId: params.agentId,
+		sessionKey: params.sessionKey,
+		conversationId: conversationIdForCheck
+	}) : null;
+	if (!shouldAckReactionForWhatsApp({
+		emoji: ackEmoji,
+		isDirect: admission.conversation.kind === "direct",
+		isGroup,
+		directEnabled,
+		groupMode,
+		wasMentioned: (params.msg.groupMention?.wasMentioned ?? params.msg.wasMentioned) === true,
+		groupActivated: activation === "always"
+	})) return null;
+	const sender = getSenderIdentity(params.msg);
+	const reactionOptions = {
+		verbose: params.verbose,
+		fromMe: false,
+		...sender.jid ? { participant: sender.jid } : {},
+		accountId,
+		cfg: params.cfg
+	};
+	const chatId = params.msg.platform.chatJid;
+	const msgId = params.msg.event.id;
 	return createStatusReactionController({
 		enabled: true,
 		adapter: {
 			setReaction: async (emoji) => {
-				await sendReactionWhatsApp(chatId, messageId, emoji, reactionOptions);
+				await sendReactionWhatsApp(chatId, msgId, emoji, reactionOptions);
 			},
 			clearReaction: async () => {
-				await sendReactionWhatsApp(chatId, messageId, "", reactionOptions);
+				await sendReactionWhatsApp(chatId, msgId, "", reactionOptions);
 			}
 		},
-		initialEmoji,
-		emojis: void 0,
+		initialEmoji: ackEmoji,
+		emojis: statusReactionsConfig.emojis,
+		timing: statusReactionsConfig.timing,
 		onError: (err) => {
-			logVerbose(`WhatsApp status-reaction error for chat ${chatId}/${messageId}: ${String(err)}`);
+			logVerbose(`WhatsApp status-reaction error for chat ${chatId}/${msgId}: ${String(err)}`);
 		}
 	});
 }
@@ -3633,16 +3232,13 @@ async function processMessage(params) {
 		sessionKey: params.route.sessionKey
 	});
 	let audioTranscript = params.preflightAudioTranscript ?? void 0;
-	const hasAudioBody = (params.msg.payload.media?.kind === "audio" || params.msg.payload.media?.type?.startsWith("audio/") === true) && !params.msg.payload.body.trim();
+	const hasAudioBody = params.msg.payload.media?.type?.startsWith("audio/") === true && params.msg.payload.body === "<media:audio>";
 	if (params.preflightAudioTranscript === void 0 && hasAudioBody && params.msg.payload.media?.path) try {
-		const { transcribeFirstAudio } = await import("./audio-preflight.runtime-C_glQhZY.js");
+		const { transcribeFirstAudio } = await import("./audio-preflight.runtime-C_glQhZY.mjs");
 		audioTranscript = await transcribeFirstAudio({
 			ctx: {
-				media: [{
-					path: params.msg.payload.media.path,
-					contentType: params.msg.payload.media.type,
-					kind: params.msg.payload.media.kind ?? void 0
-				}],
+				MediaPaths: [params.msg.payload.media?.path],
+				MediaTypes: params.msg.payload.media?.type ? [params.msg.payload.media?.type] : void 0,
 				From: conversationId,
 				To: params.msg.platform.recipientJid,
 				Provider: "whatsapp",
@@ -3654,7 +3250,7 @@ async function processMessage(params) {
 			cfg: params.cfg
 		});
 	} catch {
-		if (shouldLogVerbose$1()) logVerbose$1("whatsapp: audio preflight transcription failed, keeping structured audio");
+		if (shouldLogVerbose$1()) logVerbose$1("whatsapp: audio preflight transcription failed, using placeholder");
 	}
 	const msgForAgent = audioTranscript !== void 0 ? {
 		...params.msg,
@@ -3688,27 +3284,29 @@ async function processMessage(params) {
 	}) : void 0;
 	if (conversationKind === "group") {
 		const history = visibleGroupHistory ?? [];
-		if (history.length > 0) combinedBody = buildHistoryContextFromEntries({
-			entries: history.map((m) => ({
+		if (history.length > 0) {
+			const historyEntries = history.map((m) => ({
 				sender: m.sender,
 				body: m.body,
-				timestamp: m.timestamp,
-				media: m.media
-			})),
-			currentMessage: combinedBody,
-			excludeLast: false,
-			formatEntry: (entry) => {
-				return formatInboundEnvelope$1({
-					channel: "WhatsApp",
-					from: conversationId,
-					timestamp: entry.timestamp,
-					body: [entry.body, formatMediaPlaceholderText(entry.media ?? [])].filter(Boolean).join("\n"),
-					chatType: "group",
-					senderLabel: entry.sender,
-					envelope: envelopeOptions
-				});
-			}
-		});
+				timestamp: m.timestamp
+			}));
+			combinedBody = buildHistoryContextFromEntries({
+				entries: historyEntries,
+				currentMessage: combinedBody,
+				excludeLast: false,
+				formatEntry: (entry) => {
+					return formatInboundEnvelope$1({
+						channel: "WhatsApp",
+						from: conversationId,
+						timestamp: entry.timestamp,
+						body: entry.body,
+						chatType: "group",
+						senderLabel: entry.sender,
+						envelope: envelopeOptions
+					});
+				}
+			});
+		}
 		shouldClearGroupHistory = !(params.suppressGroupHistoryClear ?? false);
 	}
 	const combinedEchoKey = params.buildCombinedEchoKey({
@@ -3760,13 +3358,24 @@ async function processMessage(params) {
 		normalizeE164
 	});
 	const shouldCheckCommandAuth = shouldComputeCommandAuthorized(commandBody, params.cfg);
-	const isTextCommand = isControlCommandMessage(commandBody, params.cfg);
+	const isTextCommand = isControlCommandMessage$1(commandBody, params.cfg);
 	const commandAuthorized = shouldCheckCommandAuth ? await resolveWhatsAppCommandAuthorized({
 		cfg: params.cfg,
 		msg: params.msg,
 		policy: inboundPolicy,
 		authDir: account.authDir
 	}) : void 0;
+	const commandTurn = isTextCommand ? {
+		kind: "text-slash",
+		source: "text",
+		authorized: Boolean(commandAuthorized),
+		body: commandBody
+	} : {
+		kind: "normal",
+		source: "message",
+		authorized: false,
+		body: commandBody
+	};
 	const { onModelSelected, ...replyPipeline } = createChannelMessageReplyPipeline({
 		cfg: params.cfg,
 		agentId: params.route.agentId,
@@ -3787,17 +3396,13 @@ async function processMessage(params) {
 		accountConfig: account,
 		peerId: dmRouteTarget ?? conversationId
 	});
-	const commandAuthorization = commandAuthorized === void 0 ? { kind: "not_checked" } : commandAuthorized ? { kind: "authorized" } : { kind: "denied" };
-	const { inbound, turnInput, ctxPayload } = await prepareWhatsAppInboundContext({
+	const ctxPayload = await buildWhatsAppInboundContext({
 		bodyForAgent: msgForAgent.payload.body,
 		combinedBody,
-		command: {
-			kind: isTextCommand ? "text-slash" : "normal",
-			body: commandBody,
-			authorization: commandAuthorization
-		},
+		commandBody,
+		commandAuthorized,
+		commandTurn,
 		groupHistory: visibleGroupHistory,
-		groupHistoryLimit: params.groupHistoryLimit,
 		groupMemberRoster: params.groupMemberNames.get(params.groupHistoryKey),
 		groupSystemPrompt: conversationSystemPrompt,
 		msg: params.msg,
@@ -3814,9 +3419,6 @@ 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,
@@ -3837,14 +3439,19 @@ async function processMessage(params) {
 		updateLastRoute: updateLastRouteInBackground,
 		warn: params.replyLogger.warn.bind(params.replyLogger)
 	});
-	let finalizeReply;
 	const turnResult = await runChannelInboundEvent({
 		channel: "whatsapp",
 		accountId: params.route.accountId,
-		raw: inbound,
-		...turnAdoptionLifecycle ? { turnAdoptionLifecycle } : {},
+		raw: params.msg,
 		adapter: {
-			ingest: () => turnInput,
+			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
+			}),
 			preflight: () => {
 				const reason = admission.ingress.reasonCode;
 				if (admission.ingress.admission === "dispatch") return { admission: {
@@ -3865,8 +3472,26 @@ async function processMessage(params) {
 					recordHistory: false
 				} };
 			},
-			resolveTurn: () => {
-				const { finalize, ...replyPlan } = createWhatsAppReplyPlan({
+			resolveTurn: () => ({
+				channel: "whatsapp",
+				accountId: params.route.accountId,
+				routeSessionKey: params.route.sessionKey,
+				storePath,
+				ctxPayload,
+				recordInboundSession,
+				record: {
+					onRecordError: (err) => {
+						params.replyLogger.warn({
+							error: formatError(err),
+							storePath,
+							sessionKey: params.route.sessionKey
+						}, "failed updating session meta");
+					},
+					trackSessionMetaTask: (task) => {
+						trackBackgroundTask(params.backgroundTasks, task);
+					}
+				},
+				runDispatch: () => dispatchWhatsAppBufferedReply({
 					cfg: params.cfg,
 					connectionId: params.connectionId,
 					context: ctxPayload,
@@ -3875,7 +3500,7 @@ async function processMessage(params) {
 					groupHistoryKey: params.groupHistoryKey,
 					maxMediaBytes: params.maxMediaBytes,
 					maxMediaTextChunkLimit: params.maxMediaTextChunkLimit,
-					inbound,
+					msg: params.msg,
 					onModelSelected,
 					rememberSentText: params.rememberSentText,
 					replyLogger: params.replyLogger,
@@ -3886,40 +3511,14 @@ async function processMessage(params) {
 					replyResolver: params.replyResolver,
 					route: params.route,
 					shouldClearGroupHistory,
-					statusReactionController,
-					transport,
-					turnAdoptionLifecycle
-				});
-				finalizeReply = finalize;
-				return {
-					cfg: params.cfg,
-					channel: "whatsapp",
-					accountId: params.route.accountId,
-					route: {
-						agentId: params.route.agentId,
-						sessionKey: params.route.sessionKey
-					},
-					ctxPayload,
-					record: {
-						onRecordError: (err) => {
-							params.replyLogger.warn({
-								error: formatError(err),
-								storePath,
-								sessionKey: params.route.sessionKey
-							}, "failed updating session meta");
-						},
-						trackSessionMetaTask: (task) => {
-							trackBackgroundTask(params.backgroundTasks, task);
-						}
-					},
-					...replyPlan
-				};
-			}
+					statusReactionController
+				})
+			})
 		}
 	});
-	const didSendReply = turnResult.dispatched ? finalizeReply?.(turnResult.dispatchResult) ?? false : false;
+	const didSendReply = turnResult.dispatched ? turnResult.dispatchResult : false;
 	removeAckReactionHandleAfterReply({
-		removeAfterReply: false,
+		removeAfterReply: Boolean(params.cfg.messages?.removeAckAfterReply && didSendReply),
 		ackReaction,
 		onError: (err) => {
 			logAckFailure({
@@ -3934,14 +3533,8 @@ 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) => {
-		if (msg.admission.ingress.decisiveGateId === "legacy-flat-compat") return readDeprecatedAccessControlPassed(msg) === true;
-		return msg.admission.ingress.decision === "allow";
-	};
+	const hasExplicitlyPassedInboundAccess = (msg) => msg.admission ? msg.admission.ingress.decision === "allow" : msg.accessControlPassed === true;
 	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);
@@ -3965,7 +3558,6 @@ function createWebOnMessageHandler(params) {
 			route,
 			groupHistoryKey,
 			groupHistories: params.groupHistories,
-			groupHistoryLimit: params.groupHistoryLimit,
 			groupMemberNames: params.groupMemberNames,
 			connectionId: params.connectionId,
 			verbose: params.verbose,
@@ -3986,8 +3578,9 @@ function createWebOnMessageHandler(params) {
 		if (opts?.statusReactionController !== void 0) processParams.statusReactionController = opts.statusReactionController;
 		return processMessage(processParams);
 	};
-	return async (normalizedMsg) => {
-		const canRunDirectEarlyAudioPreflight = hasExplicitlyPassedInboundAccess(normalizedMsg);
+	return async (rawMsg) => {
+		const canRunDirectEarlyAudioPreflight = hasExplicitlyPassedInboundAccess(rawMsg);
+		const normalizedMsg = requireAdmittedWhatsAppInboundMessage(normalizeWebInboundMessage(rawMsg));
 		const cfg = params.loadConfig?.() ?? params.cfg;
 		const peerId = resolvePeerId(normalizedMsg);
 		const msg = withDirectSenderPeer(normalizedMsg, peerId);
@@ -4012,9 +3605,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, conversationId)) {
+		if (params.echoTracker.has(msg.payload.body)) {
 			logVerbose("Skipping auto-reply: detected echo (message matches recently sent text)");
-			params.echoTracker.forget(msg.payload.body, conversationId);
+			params.echoTracker.forget(msg.payload.body);
 			return;
 		}
 		const configuredRoute = resolveConfiguredBindingRoute({
@@ -4032,7 +3625,7 @@ function createWebOnMessageHandler(params) {
 			peerId
 		}) : route.sessionKey;
 		let preflightAudioTranscript;
-		const hasAudioBody = (msg.payload.media?.kind === "audio" || msg.payload.media?.type?.startsWith("audio/") === true) && !msg.payload.body.trim();
+		const hasAudioBody = msg.payload.media?.type?.startsWith("audio/") === true && msg.payload.body === "<media:audio>";
 		const canRunEarlyAudioPreflight = conversationKind === "group" || canRunDirectEarlyAudioPreflight;
 		let ackAlreadySent = false;
 		let ackReaction = null;
@@ -4055,14 +3648,11 @@ function createWebOnMessageHandler(params) {
 		const transcribeAudioOnce = async () => {
 			if (preflightAudioTranscript !== void 0 || !hasAudioBody || !msg.payload.media?.path) return;
 			try {
-				const { transcribeFirstAudio } = await import("./audio-preflight.runtime-C_glQhZY.js");
+				const { transcribeFirstAudio } = await import("./audio-preflight.runtime-C_glQhZY.mjs");
 				preflightAudioTranscript = await transcribeFirstAudio({
 					ctx: {
-						media: [{
-							path: msg.payload.media.path,
-							contentType: msg.payload.media.type,
-							kind: msg.payload.media.kind ?? void 0
-						}],
+						MediaPaths: [msg.payload.media?.path],
+						MediaTypes: msg.payload.media?.type ? [msg.payload.media?.type] : void 0,
 						From: conversationId,
 						To: msg.platform.recipientJid,
 						Provider: "whatsapp",
@@ -4220,7 +3810,7 @@ function createWebOnMessageHandler(params) {
 function isNonRetryableWebCloseStatus(statusCode) {
 	return statusCode === 440;
 }
-const loadReplyResolverRuntime = createLazyRuntimeModule(() => import("./reply-resolver.runtime-Ded8D58Y.js"));
+const loadReplyResolverRuntime = createLazyRuntimeModule(() => import("./reply-resolver.runtime-Ded8D58Y.mjs"));
 function resolveWebMonitorConfigSnapshot(params) {
 	const account = resolveWhatsAppAccount({
 		cfg: params.cfg,
@@ -4233,13 +3823,15 @@ function resolveWebMonitorConfigSnapshot(params) {
 				...params.cfg.channels,
 				whatsapp: {
 					...params.cfg.channels?.whatsapp,
-					responsePrefix: account.messagePrefix,
+					ackReaction: account.ackReaction,
+					messagePrefix: account.messagePrefix,
 					allowFrom: account.allowFrom,
 					groupAllowFrom: account.groupAllowFrom,
 					groupPolicy: account.groupPolicy,
 					textChunkLimit: account.textChunkLimit,
-					streaming: account.streaming,
+					chunkMode: account.chunkMode,
 					mediaMaxMb: account.mediaMaxMb,
+					blockStreaming: account.blockStreaming,
 					groups: account.groups
 				}
 			}
@@ -4247,17 +3839,28 @@ function resolveWebMonitorConfigSnapshot(params) {
 		account
 	};
 }
+function normalizeReconnectAccountId(accountId) {
+	return (accountId ?? "").trim() || "default";
+}
 function isNoListenerReconnectError(lastError) {
 	return typeof lastError === "string" && /No active WhatsApp Web listener/i.test(lastError);
 }
-function normalizeReconnectAccountId(accountId) {
-	return (accountId ?? "").trim() || "default";
+function resolveExplicitWhatsAppDebounceOverride(params) {
+	const channel = params.sourceCfg?.channels?.whatsapp;
+	if (!channel) return;
+	const accountId = normalizeReconnectAccountId(params.accountId);
+	const accountDebounce = resolveAccountEntry(channel.accounts, accountId)?.debounceMs;
+	if (accountDebounce !== void 0) return accountDebounce;
+	if (accountId !== "default") {
+		const defaultAccountDebounce = resolveAccountEntry(channel.accounts, "default")?.debounceMs;
+		if (defaultAccountDebounce !== void 0) return defaultAccountDebounce;
+	}
+	return channel.debounceMs;
 }
 function isRetryableAuthUnstableError(error) {
 	return error instanceof WhatsAppAuthUnstableError || typeof error === "object" && error !== null && "code" in error && error.code === "whatsapp-auth-unstable";
 }
-const DEFAULT_TRANSPORT_TIMEOUT_MS = 300 * 1e3;
-const WHATSAPP_RECONNECT_CATCH_UP_MAX_MS = 20 * 6e4;
+const DEFAULT_TRANSPORT_TIMEOUT_MS = 3e5;
 async function monitorWebChannel(verbose, listenerFactory = attachWebInboxToSocket, keepAlive = true, replyResolver, runtime = defaultRuntime, abortSignal, tuning = {}) {
 	const activeReplyResolver = replyResolver ?? (await loadReplyResolverRuntime()).getReplyFromConfig;
 	const runId = newConnectionId();
@@ -4273,8 +3876,10 @@ async function monitorWebChannel(verbose, listenerFactory = attachWebInboxToSock
 		module: "web-reconnect",
 		runId
 	});
+	const baseCfg = getRuntimeConfig$1();
+	const sourceCfg = getRuntimeConfigSourceSnapshot();
 	const { cfg, account } = resolveWebMonitorConfigSnapshot({
-		cfg: getRuntimeConfig$1(),
+		cfg: baseCfg,
 		accountId: tuning.accountId
 	});
 	const loadCurrentMonitorConfig = () => resolveWebMonitorConfigSnapshot({
@@ -4284,7 +3889,7 @@ async function monitorWebChannel(verbose, listenerFactory = attachWebInboxToSock
 	const maxMediaBytes = resolveWhatsAppMediaMaxBytes(account);
 	const heartbeatSeconds = resolveHeartbeatSeconds(cfg, tuning.heartbeatSeconds);
 	const reconnectPolicy = resolveReconnectPolicy(cfg, tuning.reconnect);
-	const socketTiming = resolveWhatsAppSocketTiming(tuning.socketTiming);
+	const socketTiming = resolveWhatsAppSocketTiming(cfg, tuning.socketTiming);
 	const baseMentionConfig = buildMentionConfig(cfg);
 	const groupHistoryLimit = account.historyLimit ?? cfg.channels?.whatsapp?.historyLimit ?? cfg.messages?.groupChat?.historyLimit ?? DEFAULT_GROUP_HISTORY_LIMIT;
 	const groupHistories = /* @__PURE__ */ new Map();
@@ -4306,9 +3911,9 @@ async function monitorWebChannel(verbose, listenerFactory = attachWebInboxToSock
 	};
 	process.once("SIGINT", handleSigint);
 	const transportTimeoutMs = tuning.transportTimeoutMs ?? DEFAULT_TRANSPORT_TIMEOUT_MS;
-	const messageTimeoutMs = tuning.messageTimeoutMs ?? 1800 * 1e3;
-	const reconnectCatchUpWindowMs = Math.min(Math.max(messageTimeoutMs, 6e4), WHATSAPP_RECONNECT_CATCH_UP_MAX_MS);
-	const watchdogCheckMs = tuning.watchdogCheckMs ?? 60 * 1e3;
+	const messageTimeoutMs = tuning.messageTimeoutMs ?? 18e5;
+	const reconnectCatchUpWindowMs = Math.min(Math.max(messageTimeoutMs, 6e4), WHATSAPP_INBOUND_DEDUPE_TTL_MS);
+	const watchdogCheckMs = tuning.watchdogCheckMs ?? 6e4;
 	const controller = new WhatsAppConnectionController({
 		accountId: account.accountId,
 		authDir: account.authDir,
@@ -4332,16 +3937,19 @@ async function monitorWebChannel(verbose, listenerFactory = attachWebInboxToSock
 			const connectionId = newConnectionId();
 			const inboundDebounceMs = resolveInboundDebounceMs({
 				cfg,
-				channel: "whatsapp"
+				channel: "whatsapp",
+				overrideMs: resolveExplicitWhatsAppDebounceOverride({
+					cfg,
+					sourceCfg,
+					accountId: account.accountId
+				})
 			});
 			const shouldDebounce = (msg) => {
-				const admitted = normalizeAdmittedWebInboundMessage(msg);
-				return shouldDebounceTextInbound({
-					text: admitted.payload.commandBody ?? admitted.payload.body,
-					cfg,
-					hasMedia: Boolean(admitted.payload.media?.path || admitted.payload.media?.type),
-					allowDebounce: !(admitted.payload.location || admitted.quote?.id || admitted.quote?.body)
-				});
+				const normalized = normalizeWebInboundMessage(msg);
+				if (normalized.payload.media?.path || normalized.payload.media?.type) return false;
+				if (normalized.payload.location) return false;
+				if (normalized.quote?.id || normalized.quote?.body) return false;
+				return !isControlCommandMessage(normalized.payload.commandBody ?? normalized.payload.body, cfg);
 			};
 			let connection;
 			try {
@@ -4394,11 +4002,11 @@ async function monitorWebChannel(verbose, listenerFactory = attachWebInboxToSock
 							recentMessageKeys,
 							baileysGroupMetaCache,
 							onMessage: async (msg) => {
-								const admitted = normalizeAdmittedWebInboundMessage(msg);
+								const normalized = normalizeWebInboundMessage(msg);
 								const inboundAt = Date.now();
 								controller.noteInbound(inboundAt);
 								statusController.noteInbound(inboundAt);
-								await onMessage(admitted);
+								await onMessage(normalized);
 							},
 							onPendingWorkChanged: (pendingWorkCount, at) => {
 								statusController.noteBusy(pendingWorkCount > 0, at);
@@ -4678,4 +4286,4 @@ async function monitorWebChannel(verbose, listenerFactory = attachWebInboxToSock
 	}
 }
 //#endregion
-export { loadWebMediaRaw as a, monitorWebInbox as c, loadWebMedia as i, resetWebInboundDedupe as l, LocalMediaAccessError as n, optimizeImageToJpeg as o, getDefaultLocalRoots as r, optimizeImageToPng as s, monitorWebChannel as t };
+export { loadWebMediaRaw as a, monitorWebInbox as c, loadWebMedia$1 as i, resetWebInboundDedupe as l, LocalMediaAccessError as n, optimizeImageToJpeg as o, getDefaultLocalRoots as r, optimizeImageToPng as s, monitorWebChannel as t };