@openclaw/whatsapp 2026.7.2-beta.1 → 2026.7.2-beta.3

package/dist/{monitor-BKtA0lzq.js → monitor-_jqDKBXj.js}

@@ -1,31 +1,31 @@
-import { a as resolveWhatsAppAccount, s as resolveWhatsAppMediaMaxBytes } from "./accounts-CKOFMPf-.js";
-import { a as normalizeWhatsAppOutboundPayload, c as prepareWhatsAppOutboundMedia, r as sendReactionWhatsApp, s as normalizeWhatsAppPayloadTextPreservingIndentation, u as resolveWhatsAppReactionLevel } from "./send-D9Ydnn4o.js";
+import { a as resolveWhatsAppAccount, s as resolveWhatsAppMediaMaxBytes } from "./accounts-ejK8sXPU.js";
+import { a as normalizeWhatsAppOutboundPayload, c as prepareWhatsAppOutboundMedia, r as sendReactionWhatsApp, s as normalizeWhatsAppPayloadTextPreservingIndentation, u as resolveWhatsAppReactionLevel } from "./send-SB-4JrVZ.js";
 import { n as getWhatsAppRuntime } from "./runtime-BfAdAEYT.js";
-import { n as getWhatsAppConnectionController } from "./connection-controller-runtime-context-CbTsqmPT.js";
+import { r as getWhatsAppConnectionController } from "./connection-controller-runtime-context-9mEeAvu1.js";
 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-Bsh0HR9y.js";
 import { n as normalizeE164, t as convertMarkdownTables$1 } from "./text-runtime-BTGkMN0o.js";
-import { a as cacheInboundMessageMeta, i as buildQuotedMessageOptions, n as resolveWhatsAppGroupSessionRoute, o as lookupInboundMessageMeta, r as resolveWhatsAppLegacyGroupSessionKey } from "./group-session-key-CLTZeH_F.js";
+import { a as cacheInboundMessageMeta, i as buildQuotedMessageOptions, n as resolveWhatsAppGroupSessionRoute, o as lookupInboundMessageMeta, r as resolveWhatsAppLegacyGroupSessionKey } from "./group-session-key-Dh8WZun_.js";
 import { g as readWebSelfId, o as getWebAuthAgeMs, r as WhatsAppAuthUnstableError, v as readWebSelfIdentityForDecision } from "./auth-store-BQi9pZqQ.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-D7L8LCuH.js";
 import { n as resolveWhatsAppGroupsConfigPath } from "./group-config-path-BGyzT9Lg.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-DazDX3RB.js";
-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-W33lI2nR.js";
-import { a as createWhatsAppSocketOperationTimeoutAdapter, c as resolveWhatsAppSocketTiming, l as withWhatsAppSocketOperationTimeout, o as isWhatsAppSocketOperationTimeoutError, r as waitForWaConnection, s as resolveWhatsAppSocketOperationTimeoutMs, t as createWaSocket } from "./session-mxWFn0eS.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-jNGyZY4T.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 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-C1rwfWb4.js";
-import { n as maybeResolveWhatsAppApprovalReaction } from "./approval-reactions-BGQoz25s.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-tjy_em01.js";
+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-BG0MgoFI.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-HGaffeFb.js";
+import { n as maybeResolveWhatsAppApprovalReaction } from "./approval-reactions-CrZFAyf-.js";
+import { t as maybeResolveWhatsAppQuestionReaction } from "./question-reactions-C0qJ6wGA.js";
 import { resolveAccountEntry } from "openclaw/plugin-sdk/account-core";
-import { normalizeLowercaseStringOrEmpty, normalizeStringEntries, uniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { normalizeLowercaseStringOrEmpty, normalizeStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { filterSupplementalContextItems, resolvePinnedMainDmOwnerFromAllowlist } from "openclaw/plugin-sdk/security-runtime";
 import { DEFAULT_TIMING, createAckReactionHandle, createStatusReactionController, logAckFailure, removeAckReactionHandleAfterReply, shouldAckReactionForWhatsApp } from "openclaw/plugin-sdk/channel-feedback";
 import { formatCliCommand } from "openclaw/plugin-sdk/cli-runtime";
-import { collectErrorGraphCandidates, formatErrorMessage } from "openclaw/plugin-sdk/error-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 { createChannelMessageReplyPipeline, createDurableInboundReceiveJournalFromQueue, createMessageReceiptFromOutboundResults, deliverInboundReplyWithMessageSendContext, resolveChannelMessageSourceReplyDeliveryMode, resolveChannelStreamingBlockEnabled } from "openclaw/plugin-sdk/channel-outbound";
+import { DEFAULT_INGRESS_RETRY_DEAD_LETTER_MIN_AGE_MS, DEFAULT_INGRESS_RETRY_MAX_ATTEMPTS, bindIngressLifecycleToReplyOptions, createChannelIngressDrain, createChannelMessageReplyPipeline, createMessageReceiptFromOutboundResults, deliverInboundReplyWithMessageSendContext, 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";
@@ -34,20 +34,17 @@ import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 import { chunkMarkdownTextWithMode } from "openclaw/plugin-sdk/reply-chunking";
 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 { asDateTimestampMs, parseStrictFiniteNumber, resolveExpiresAtMsFromDurationMs } from "openclaw/plugin-sdk/number-runtime";
-import { recordInboundSession } from "openclaw/plugin-sdk/conversation-runtime";
+import { createHash } from "node:crypto";
 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 { buildChannelInboundEventContext, filterChannelInboundQuoteContext, formatInboundEnvelope, formatInboundEnvelope as formatInboundEnvelope$1, formatInboundMediaUnavailableText, formatLocationText, hasVisibleInboundReplyDispatch, resolveInboundSessionEnvelopeContext, resolveInboundSupplementalSenderAllowed, runChannelInboundEvent, shouldDebounceTextInbound, toInboundMediaFacts, toLocationContext } from "openclaw/plugin-sdk/channel-inbound";
 import { recordChannelActivity } from "openclaw/plugin-sdk/channel-activity-runtime";
-import { createHash } from "node:crypto";
-import { dispatchReplyWithBufferedBlockDispatcher, finalizeInboundContext, resolveChunkMode, resolveTextChunkLimit } from "openclaw/plugin-sdk/reply-runtime";
+import { 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 { 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 { createDedupeCache } from "openclaw/plugin-sdk/dedupe-runtime";
-import { createClaimableDedupe } from "openclaw/plugin-sdk/persistent-dedupe";
 import { saveMediaStream } from "openclaw/plugin-sdk/media-store";
 import { getRuntimeConfig as getRuntimeConfig$1, getRuntimeConfigSourceSnapshot } from "openclaw/plugin-sdk/runtime-config-snapshot";
 import { resolveChannelContextVisibilityMode } from "openclaw/plugin-sdk/context-visibility-runtime";
@@ -56,60 +53,11 @@ import { createConnectedChannelStatusPatch, createTransportActivityStatusPatch }
 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 { retryAsync } from "openclaw/plugin-sdk/retry-runtime";
-//#region extensions/whatsapp/src/inbound/dedupe.ts
-const WHATSAPP_INBOUND_DEDUPE_TTL_MS = 20 * 6e4;
-const RECENT_WEB_MESSAGE_MAX = 5e3;
-const RECENT_OUTBOUND_MESSAGE_TTL_MS = 20 * 6e4;
-const RECENT_OUTBOUND_MESSAGE_MAX = 5e3;
-const claimableInboundMessages = createClaimableDedupe({
-	ttlMs: WHATSAPP_INBOUND_DEDUPE_TTL_MS,
-	memoryMaxSize: RECENT_WEB_MESSAGE_MAX
-});
-const recentOutboundMessages = createDedupeCache({
-	ttlMs: RECENT_OUTBOUND_MESSAGE_TTL_MS,
-	maxSize: RECENT_OUTBOUND_MESSAGE_MAX
-});
-var WhatsAppRetryableInboundError = class extends Error {
-	constructor(message, options) {
-		super(message, options);
-		this.name = "WhatsAppRetryableInboundError";
-	}
-};
-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
+import { createChannelApiRetryRunner } from "openclaw/plugin-sdk/retry-runtime";
 //#region extensions/whatsapp/src/inbound/message-aliases.ts
 function normalizeQuoteSender(sender) {
 	if (!sender?.displayName && !sender?.jid && !sender?.e164) return;
@@ -434,9 +382,63 @@ function normalizeWebInboundMessage(msg) {
 	return normalizeLegacyFlatWebInboundMessage(msg);
 }
 //#endregion
+//#region extensions/whatsapp/src/inbound/dedupe.ts
+const recentOutboundMessages = createDedupeCache({
+	ttlMs: 20 * 6e4,
+	maxSize: 5e3
+});
+function buildMessageKey(params) {
+	const accountId = params.accountId.trim();
+	const remoteJid = params.remoteJid.trim();
+	const messageId = params.messageId.trim();
+	if (!accountId || !remoteJid || !messageId || messageId === "unknown") return null;
+	return `${accountId}:${remoteJid}:${messageId}`;
+}
+function resetWebInboundDedupe() {
+	recentOutboundMessages.clear();
+}
+function rememberRecentOutboundMessage(params) {
+	const key = buildMessageKey(params);
+	if (!key) return;
+	recentOutboundMessages.check(key);
+}
+function isRecentOutboundMessage(params) {
+	const key = buildMessageKey(params);
+	if (!key) return false;
+	return recentOutboundMessages.peek(key);
+}
+//#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_PENDING_MAX_ENTRIES = 450;
-const WHATSAPP_DURABLE_INBOUND_COMPLETED_MAX_ENTRIES = 450;
+const WHATSAPP_DURABLE_INBOUND_COMPLETED_MAX_ENTRIES = 5e3;
 const WHATSAPP_DURABLE_INBOUND_PENDING_TTL_MS = 720 * 60 * 60 * 1e3;
 const WHATSAPP_DURABLE_INBOUND_COMPLETED_TTL_MS = 10080 * 60 * 1e3;
 function hashNamespacePart(value) {
@@ -445,31 +447,91 @@ function hashNamespacePart(value) {
 function createWhatsAppDurableInboundMessageId(params) {
 	return createHash("sha256").update(`${params.remoteJid}\n${params.id}`).digest("hex");
 }
-function serializeWhatsAppDurableInboundMessage(message) {
-	return JSON.parse(JSON.stringify(message, BufferJSON.replacer));
-}
-function deserializeWhatsAppDurableInboundMessage(message) {
-	return JSON.parse(JSON.stringify(message), BufferJSON.reviver);
-}
-function createWhatsAppDurableInboundReceiveJournal(accountId) {
-	const accountPart = hashNamespacePart(accountId);
-	const runtime = getWhatsAppRuntime();
-	return createDurableInboundReceiveJournalFromQueue({
-		queue: runtime.state.openChannelIngressQueue({
-			accountId: accountPart,
-			stateDir: runtime.state.resolveStateDir()
+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
 		}),
-		retention: {
-			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
+		laneKey: remoteJid
+	};
+}
+/** 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()
+	});
+}
+/** Raw receive chokepoint: append first, then let the drain normalize and dispatch. */
+async function enqueueWhatsAppDurableInbound(params) {
+	const facts = inspectWhatsAppIngressMessage(params.message);
+	const receivedAt = params.receivedAt ?? Date.now();
+	await params.queue.prune({
+		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 await params.queue.enqueue(facts.eventId, {
+		message: serializeWhatsAppDurableInboundMessage(params.message),
+		upsertType: params.upsertType,
+		...params.skipStaleAppend === void 0 ? {} : { skipStaleAppend: params.skipStaleAppend },
+		...params.skipRecentOutboundEcho === void 0 ? {} : { skipRecentOutboundEcho: params.skipRecentOutboundEcho },
+		receivedAt,
+		...params.receiveOrder === void 0 ? {} : { receiveOrder: params.receiveOrder }
+	}, {
+		receivedAt,
+		laneKey: facts.laneKey
+	});
+}
+function resolveWhatsAppIngressNonRetryableFailure(error) {
+	return error instanceof WhatsAppIngressPermanentError ? {
+		reason: error.reason,
+		message: error.message
+	} : null;
+}
+/** Core drain with per-conversation lanes and completion at reply-lane adoption. */
+function createWhatsAppIngressDrain(params) {
+	return createChannelIngressDrain({
+		queue: params.queue,
+		retryPolicy: {
+			maxAttempts: DEFAULT_INGRESS_RETRY_MAX_ATTEMPTS,
+			deadLetterMinAgeMs: DEFAULT_INGRESS_RETRY_DEAD_LETTER_MIN_AGE_MS
+		},
+		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 } : {},
+		dispatchClaimedEvent: async (record, lifecycle) => {
+			const message = deserializeWhatsAppDurableInboundMessage(record.payload.message);
+			if (inspectWhatsAppIngressMessage(message).eventId !== record.id) throw new WhatsAppIngressPermanentError("event-id-mismatch", "WhatsApp ingress row id does not match its transport message key");
+			return await params.dispatch(message, record.payload, lifecycle);
 		}
 	});
 }
 //#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/lifecycle.ts
 function attachEmitterListener(emitter, event, listener) {
 	emitter.on(event, listener);
@@ -539,13 +601,8 @@ const RECONNECT_IN_PROGRESS_ERROR = "no active socket - reconnection in progress
 const GROUP_META_TTL_MS = 300 * 1e3;
 const BAILEYS_MESSAGE_TTL_MS = 600 * 1e3;
 const INBOUND_CLOSE_DRAIN_TIMEOUT_MS = 5e3;
-const REPLY_SESSION_INIT_CONFLICT_MESSAGE_RE = /reply session initialization conflicted for \S+/u;
+const WHATSAPP_INGRESS_DRAIN_INTERVAL_MS = 1e3;
 const WHATSAPP_GROUP_METADATA_CACHE_MAX_ENTRIES = 500;
-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 });
-}
 function resolveGroupMetadataExpiresAt(nowRaw = Date.now()) {
 	const now = asDateTimestampMs(nowRaw);
 	return now === void 0 ? void 0 : resolveExpiresAtMsFromDurationMs(GROUP_META_TTL_MS, { nowMs: now });
@@ -636,9 +693,6 @@ function isRetryableSendDisconnectError(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");
@@ -679,11 +733,30 @@ async function attachWebInboxToSocket(options) {
 		if (!successorIdentity || !identitiesOverlap(self, successorIdentity)) return null;
 		return successor.getCurrentSock();
 	};
-	const durableInboundJournal = createWhatsAppDurableInboundReceiveJournal(options.accountId);
+	const durableInboundQueue = options.durableInboundQueue ?? createWhatsAppDurableInboundQueue(options.accountId);
 	const inboundDebounceMs = Math.max(0, Math.trunc(options.debounceMs ?? 0));
 	const pendingDebounceKeys = /* @__PURE__ */ new Set();
 	const activeInboundFlushes = /* @__PURE__ */ new Set();
 	const pendingMessageHandlers = /* @__PURE__ */ new Set();
+	const debounceWorkWaiters = /* @__PURE__ */ new Set();
+	const notifyDebounceWork = () => {
+		if (debounceWorkWaiters.size === 0) return;
+		const waiters = [...debounceWorkWaiters];
+		debounceWorkWaiters.clear();
+		for (const resolve of waiters) resolve();
+	};
+	const waitForDebounceWorkOrIdle = (handlers) => {
+		if (pendingDebounceKeys.size > 0 || activeInboundFlushes.size > 0) return Promise.resolve();
+		if (pendingMessageHandlers.size === 0) return Promise.resolve();
+		return new Promise((resolve) => {
+			const finish = () => {
+				debounceWorkWaiters.delete(finish);
+				resolve();
+			};
+			debounceWorkWaiters.add(finish);
+			Promise.allSettled(handlers).then(finish);
+		});
+	};
 	let nextReceiveOrder = 0;
 	const publishPendingWorkState = (at = Date.now()) => {
 		options.onPendingWorkChanged?.(pendingMessageHandlers.size + pendingDebounceKeys.size + activeInboundFlushes.size, at);
@@ -701,18 +774,47 @@ async function attachWebInboxToSocket(options) {
 		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 buildFlushIngressLifecycle = (entries) => {
+		const lifecycles = entries.map((entry) => entry.turnAdoptionLifecycle).filter((lifecycle) => lifecycle !== void 0);
+		const [firstLifecycle] = lifecycles;
+		if (!firstLifecycle) return {
+			lifecycle: void 0,
+			settle: async () => {},
+			abandon: async () => {}
+		};
+		let handedOff = false;
+		const adoptAll = async () => {
+			for (const lifecycle of lifecycles) await lifecycle.onAdopted();
+		};
+		return {
+			lifecycle: {
+				abortSignal: lifecycles.length === 1 ? firstLifecycle.abortSignal : AbortSignal.any(lifecycles.map((lifecycle) => lifecycle.abortSignal)),
+				onAdopted: async () => {
+					handedOff = true;
+					await adoptAll();
+				},
+				onDeferred: () => {
+					handedOff = true;
+					for (const lifecycle of lifecycles) lifecycle.onDeferred();
+				},
+				onAdoptionFinalizing: () => {
+					for (const lifecycle of lifecycles) lifecycle.onAdoptionFinalizing();
+				},
+				onAbandoned: async () => {
+					handedOff = true;
+					await Promise.all(lifecycles.map((lifecycle) => Promise.resolve(lifecycle.onAbandoned())));
+				}
+			},
+			settle: async () => {
+				if (!handedOff) await adoptAll();
+			},
+			abandon: async () => {
+				if (!handedOff) {
+					handedOff = true;
+					await Promise.all(lifecycles.map((lifecycle) => Promise.resolve(lifecycle.onAbandoned())));
+				}
+			}
+		};
 	};
 	const debouncer = createInboundDebouncer({
 		debounceMs: inboundDebounceMs,
@@ -725,14 +827,17 @@ async function attachWebInboxToSocket(options) {
 			});
 			activeInboundFlushes.add(flushTask);
 			publishPendingWorkState();
+			notifyDebounceWork();
 			try {
 				const orderedEntries = orderDebouncedInboundEntries(entries);
 				const last = orderedEntries.at(-1);
 				if (!last) return;
+				const { lifecycle, settle, abandon } = buildFlushIngressLifecycle(orderedEntries);
 				try {
 					if (orderedEntries.length === 1) {
-						await options.onMessage(last);
-						await finalizeInboundDelivery(orderedEntries);
+						await options.onMessage(attachWhatsAppIngressLifecycle(last, lifecycle));
+						await settle();
+						await Promise.all(orderedEntries.map((entry) => maybeMarkInboundAsRead(entry.readReceipt)));
 						return;
 					}
 					const mentioned = /* @__PURE__ */ new Set();
@@ -747,8 +852,9 @@ async function attachWebInboxToSocket(options) {
 						...last.group,
 						mentions: combinedMentions
 					} : void 0;
-					const combinedMessage = withDeprecatedWebInboundMessageFlatAliases({
+					const combinedMessage = attachWhatsAppIngressLifecycle(withDeprecatedWebInboundMessageFlatAliases({
 						...last,
+						...lifecycle ? { turnAdoptionLifecycle: lifecycle } : {},
 						payload: {
 							...last.payload,
 							body: combinedBody,
@@ -759,11 +865,12 @@ async function attachWebInboxToSocket(options) {
 							...last.event,
 							isBatched: true
 						}
-					});
+					}), lifecycle);
 					await options.onMessage(combinedMessage);
-					await finalizeInboundDelivery(orderedEntries);
+					await settle();
+					await Promise.all(orderedEntries.map((entry) => maybeMarkInboundAsRead(entry.readReceipt)));
 				} catch (error) {
-					await finalizeInboundDelivery(orderedEntries, error);
+					await abandon();
 					throw error;
 				}
 			} finally {
@@ -978,20 +1085,24 @@ async function attachWebInboxToSocket(options) {
 		}
 		return content;
 	};
+	const shouldSkipRecentOutboundEcho = (msg) => {
+		const id = msg.key?.id ?? void 0;
+		const remoteJid = msg.key?.remoteJid;
+		if (!msg.key?.fromMe || !id || !remoteJid || !isRecentOutboundMessage({
+			accountId: options.accountId,
+			remoteJid,
+			messageId: id
+		})) return false;
+		logWhatsAppVerbose(options.verbose, `Skipping recent outbound WhatsApp echo ${id} for ${remoteJid}`);
+		return true;
+	};
 	const normalizeInboundMessage = async (msg) => {
 		const id = msg.key?.id ?? void 0;
 		const remoteJid = msg.key?.remoteJid;
 		if (!remoteJid) return null;
 		if (remoteJid.endsWith("@status") || remoteJid.endsWith("@broadcast")) return null;
 		const group = isJidGroup(remoteJid) === true;
-		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 (shouldSkipRecentOutboundEcho(msg)) return null;
 		if (!hasInboundUserContent(msg.message ?? void 0)) return null;
 		const participantJid = msg.key?.participant ?? void 0;
 		const from = group ? remoteJid : await resolveInboundJid(remoteJid);
@@ -1067,15 +1178,6 @@ async function attachWebInboxToSocket(options) {
 		}
 		await maybeMarkInboundAsRead(target);
 	};
-	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;
 		const APPEND_RECENT_GRACE_MS = 6e4;
@@ -1084,69 +1186,7 @@ async function attachWebInboxToSocket(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 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 preparedInboundByDurableId = /* @__PURE__ */ new Map();
 	const enrichInboundMessage = async (msg) => {
 		const location = extractLocationData(msg.message ?? void 0);
 		const locationText = location ? formatLocationText(location) : void 0;
@@ -1301,8 +1341,7 @@ async function attachWebInboxToSocket(options) {
 				}
 			} : void 0,
 			group,
-			dedupeKey: inbound.id ? `${options.accountId}:${inbound.remoteJid}:${inbound.id}` : void 0,
-			durableId: durable.durableId,
+			turnAdoptionLifecycle: durable.turnAdoptionLifecycle,
 			readReceipt: durable.readReceipt,
 			receiveOrder: durable.receiveOrder
 		});
@@ -1312,6 +1351,7 @@ async function attachWebInboxToSocket(options) {
 			if (inboundDebounceMs > 0 && shouldDebounceInboundMessage(inboundMessage)) {
 				pendingDebounceKeys.add(debounceKey);
 				publishPendingWorkState();
+				notifyDebounceWork();
 			}
 		}
 		if (inboundMessage.event.id) {
@@ -1323,16 +1363,119 @@ async function attachWebInboxToSocket(options) {
 				fromMe: inboundMessage.platform.fromMe
 			});
 		}
-		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)}`);
+		await debouncer.enqueue(inboundMessage);
+	};
+	const processWhatsAppInboundMessage = async (msg, context) => {
+		rememberBaileysMessage(msg.key?.remoteJid, msg.key?.id, msg.message);
+		if (context.skipRecentOutboundEcho === true) return "completed";
+		const preparation = context.eventId ? preparedInboundByDurableId.get(context.eventId) : void 0;
+		if (context.eventId) preparedInboundByDurableId.delete(context.eventId);
+		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(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 enrichInboundMessage(msg);
+		if (!enriched) {
+			await maybeMarkNonSelfChatReadReceipt(inbound, deliveryReadReceipt);
+			return "completed";
+		}
+		recordAcceptedInboundActivity(options.accountId);
+		await enqueueInboundMessage(msg, inbound, enriched, {
+			readReceipt: deliveryReadReceipt,
+			receiveOrder: context.receiveOrder ?? context.receivedAt,
+			turnAdoptionLifecycle: context.lifecycle
+		});
+		return "deferred";
+	};
+	let durableDrainPass;
+	let durableDrainRequested = false;
+	let durableDrainClosed = false;
+	const requestDurableInboundDrain = () => {
+		if (durableDrainClosed) return Promise.resolve();
+		durableDrainRequested = true;
+		if (!durableDrainPass) {
+			let passFailed = false;
+			const task = (async () => {
+				await durableInboundDrain.recoverStaleClaims();
+				while (durableDrainRequested) {
+					durableDrainRequested = false;
+					if ((await durableInboundDrain.drainOnce()).started > 0) {
+						await durableInboundDrain.waitForIdle();
+						durableDrainRequested = true;
+					}
+				}
+			})().catch((error) => {
+				passFailed = true;
+				throw error;
 			});
-		} catch (err) {
-			inboundLogger.error({ error: String(err) }, "failed handling inbound web message");
-			inboundConsoleLog.error(`Failed handling inbound web message: ${String(err)}`);
+			durableDrainPass = task;
+			pendingMessageHandlers.add(task);
+			publishPendingWorkState();
+			task.finally(() => {
+				if (durableDrainPass === task) durableDrainPass = void 0;
+				pendingMessageHandlers.delete(task);
+				publishPendingWorkState();
+				if (durableDrainRequested && !passFailed) requestDurableInboundDrain().catch((error) => {
+					inboundLogger.error({ error: formatError(error) }, "whatsapp durable inbound drain failed");
+				});
+			}).catch(() => void 0);
 		}
+		return durableDrainPass;
+	};
+	const requestDrainAfterLaneSettlement = () => {
+		requestDurableInboundDrain().catch((error) => {
+			inboundLogger.error({ error: formatError(error) }, "whatsapp durable inbound drain failed");
+		});
 	};
+	const continueDrainAfterLaneSettlement = (lifecycle) => ({
+		abortSignal: lifecycle.abortSignal,
+		onAdopted: async () => {
+			await lifecycle.onAdopted();
+			requestDrainAfterLaneSettlement();
+		},
+		onDeferred: lifecycle.onDeferred,
+		onAdoptionFinalizing: lifecycle.onAdoptionFinalizing,
+		onAbandoned: async () => {
+			await lifecycle.onAbandoned();
+			requestDrainAfterLaneSettlement();
+		}
+	});
+	const durableInboundDrain = createWhatsAppIngressDrain({
+		queue: durableInboundQueue,
+		dispatch: async (msg, payload, lifecycle) => {
+			const remoteJid = msg.key?.remoteJid;
+			const id = msg.key?.id;
+			return { kind: await processWhatsAppInboundMessage(msg, {
+				...payload,
+				...remoteJid && id ? { eventId: createWhatsAppDurableInboundMessageId({
+					remoteJid,
+					id
+				}) } : {},
+				lifecycle: continueDrainAfterLaneSettlement(lifecycle)
+			}) };
+		},
+		onLog: (message) => inboundLogger.warn({ message }, "whatsapp ingress drain")
+	});
+	const durableDrainTimer = setInterval(() => {
+		requestDurableInboundDrain().catch((error) => {
+			inboundLogger.error({ error: formatError(error) }, "whatsapp durable inbound drain failed");
+		});
+	}, WHATSAPP_INGRESS_DRAIN_INTERVAL_MS);
+	durableDrainTimer.unref?.();
 	const handleMessagesUpsert = async (upsert) => {
 		if (upsert.type !== "notify" && upsert.type !== "append") return;
 		for (const msg of upsert.messages ?? []) {
@@ -1348,7 +1491,78 @@ async function attachWebInboxToSocket(options) {
 				resolveReactionTargetJids,
 				logVerboseMessage: (message) => logWhatsAppVerbose(options.verbose, message)
 			})) continue;
-			await processDurableInboundMessage(msg, upsert.type, receiveOrder);
+			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 ? createWhatsAppDurableInboundMessageId({
+				remoteJid,
+				id
+			}) : 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;
+			let appendError;
+			for (const delayMs of [
+				0,
+				100,
+				300
+			]) {
+				if (delayMs > 0) await new Promise((resolve) => {
+					setTimeout(resolve, delayMs);
+				});
+				try {
+					result = await enqueueWhatsAppDurableInbound({
+						queue: durableInboundQueue,
+						message: msg,
+						upsertType: upsert.type,
+						skipStaleAppend,
+						skipRecentOutboundEcho,
+						receivedAt,
+						receiveOrder
+					});
+					appendError = void 0;
+					break;
+				} catch (error) {
+					appendError = error;
+				}
+			}
+			if (result === void 0) {
+				finishPreparation(void 0);
+				const formattedError = formatError(appendError);
+				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 === "completed") {
+				finishPreparation(void 0);
+				const inbound = await normalizeInboundMessage(msg);
+				if (inbound) await maybeMarkNonSelfChatReadReceipt(inbound, buildReadReceiptTarget(inbound));
+			} else {
+				if (result.kind === "accepted") try {
+					finishPreparation(skipRecentOutboundEcho ? null : await normalizeInboundMessage(msg), true);
+				} catch (error) {
+					finishPreparation(void 0);
+					throw error;
+				}
+				else finishPreparation(void 0);
+				requestDurableInboundDrain().catch((error) => {
+					inboundLogger.error({ error: formatError(error) }, "whatsapp durable inbound drain failed");
+				});
+			}
 		}
 	};
 	const handleMessagesUpsertEvent = (upsert) => {
@@ -1363,9 +1577,6 @@ async function attachWebInboxToSocket(options) {
 			publishPendingWorkState();
 		});
 	};
-	const waitForPendingMessageHandlers = async () => {
-		while (pendingMessageHandlers.size > 0) await Promise.all(Array.from(pendingMessageHandlers));
-	};
 	const drainDebouncedInboundMessages = async () => {
 		while (pendingDebounceKeys.size > 0 || activeInboundFlushes.size > 0) {
 			const debounceKeys = Array.from(pendingDebounceKeys);
@@ -1377,8 +1588,21 @@ async function attachWebInboxToSocket(options) {
 	};
 	const drainInboundBeforeSocketClose = async () => {
 		groupMetadataCacheClosed = true;
-		await waitForPendingMessageHandlers();
+		clearInterval(durableDrainTimer);
+		for (;;) {
+			await drainDebouncedInboundMessages();
+			if (pendingMessageHandlers.size === 0) break;
+			const handlers = Array.from(pendingMessageHandlers);
+			await Promise.race([Promise.allSettled(handlers), waitForDebounceWorkOrIdle(handlers)]);
+			if (pendingMessageHandlers.size === 0 && pendingDebounceKeys.size === 0 && activeInboundFlushes.size === 0) break;
+		}
 		await drainDebouncedInboundMessages();
+		try {
+			await durableInboundDrain.waitForIdle();
+		} finally {
+			durableDrainClosed = true;
+			durableInboundDrain.dispose();
+		}
 	};
 	const drainInboundBeforeSocketCloseWithTimeout = async () => {
 		let timeout = null;
@@ -1391,6 +1615,8 @@ async function attachWebInboxToSocket(options) {
 			})]);
 		} finally {
 			if (timeout) clearTimeout(timeout);
+			durableDrainClosed = true;
+			durableInboundDrain.dispose();
 		}
 	};
 	const handleConnectionUpdate = (update) => {
@@ -1449,16 +1675,10 @@ async function attachWebInboxToSocket(options) {
 	const detachGroupParticipantsUpdate = attachSockListener("group-participants.update", ((update) => {
 		forgetFullGroupMetadata(update.id);
 	}));
-	const replayTask = replayPendingDurableInboundMessages().catch((err) => {
+	requestDurableInboundDrain().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();
-	});
 	(async () => {
 		try {
 			const groups = await sock.groupFetchAllParticipating();
@@ -2224,29 +2444,34 @@ function isRetryableWhatsAppOutboundError(error) {
 	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 retryAsync(async () => {
+		return await runWithRetry(async () => {
 			try {
 				return await params.send();
 			} catch (error) {
 				throw new WhatsAppOutboundRetryError(error);
 			}
-		}, {
-			attempts: WHATSAPP_OUTBOUND_MAX_ATTEMPTS,
-			minDelayMs: WHATSAPP_OUTBOUND_MIN_DELAY_MS,
-			maxDelayMs: WHATSAPP_OUTBOUND_MAX_DELAY_MS,
-			jitter: 0,
-			shouldRetry: (error) => error instanceof WhatsAppOutboundRetryError && isRetryableWhatsAppOutboundError(error.original),
-			onRetry: ({ attempt, maxAttempts, delayMs, err }) => {
-				if (!(err instanceof WhatsAppOutboundRetryError)) return;
-				params.onRetry?.({
-					attempt,
-					maxAttempts,
-					backoffMs: delayMs,
-					error: err.original,
-					errorText: formatError(err.original)
-				});
-			}
 		});
 	} catch (error) {
 		if (error instanceof WhatsAppOutboundRetryError) throw error.original;
@@ -2505,25 +2730,34 @@ 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) => isWhatsAppSupplementalSenderAllowed({
+		isSenderAllowed: (entry) => resolveInboundSupplementalSenderAllowed({
+			isGroup: true,
+			groupPolicy: params.groupPolicy,
 			allowFrom: params.groupAllowFrom,
-			authDir: params.authDir,
-			sender: entry.senderJid ? { jid: entry.senderJid } : null
+			isSenderAllowed: (allowFrom) => isWhatsAppSupplementalSenderAllowed({
+				allowFrom,
+				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 senderAllowed = requireWhatsAppInboundAdmission(params.msg).conversation.kind !== "group" || params.groupPolicy !== "allowlist" ? true : isWhatsAppSupplementalSenderAllowed({
+	const senderAllowed = resolveInboundSupplementalSenderAllowed({
+		isGroup: requireWhatsAppInboundAdmission(params.msg).conversation.kind === "group",
+		groupPolicy: params.groupPolicy,
 		allowFrom: params.groupAllowFrom,
-		authDir: params.authDir,
-		sender: replyTo.sender
+		isSenderAllowed: (allowFrom) => isWhatsAppSupplementalSenderAllowed({
+			allowFrom,
+			authDir: params.authDir,
+			sender: replyTo.sender
+		})
 	});
 	return filterChannelInboundQuoteContext(params.mode, {
 		id: replyTo.id,
@@ -2662,7 +2896,6 @@ async function buildWhatsAppInboundContext(params) {
 	}] : void 0, { transcribed: (_entry, index) => params.mediaTranscribedIndexes?.includes(index) === true });
 	return buildChannelInboundEventContext({
 		channel: "whatsapp",
-		finalize: finalizeInboundContext,
 		supplemental: {
 			quote: params.visibleReplyTo ? {
 				id: params.visibleReplyTo.id,
@@ -2687,6 +2920,7 @@ async function buildWhatsAppInboundContext(params) {
 		},
 		route: {
 			agentId: params.route.agentId,
+			dmScope: params.route.dmScope,
 			accountId: params.route.accountId,
 			routeSessionKey: params.route.sessionKey
 		},
@@ -2699,7 +2933,7 @@ async function buildWhatsAppInboundContext(params) {
 			bodyForAgent: params.bodyForAgent ?? params.msg.payload.body,
 			inboundHistory,
 			rawBody: params.rawBody ?? params.msg.payload.body,
-			commandBody: params.commandBody ?? params.msg.payload.body
+			commandBody: params.command?.body ?? params.msg.payload.body
 		},
 		access: {
 			...wasMentioned !== void 0 ? { mentions: {
@@ -2707,9 +2941,9 @@ async function buildWhatsAppInboundContext(params) {
 				wasMentioned,
 				requireMention: params.msg.groupMention?.requireMention
 			} } : {},
-			commands: { authorized: params.commandAuthorized }
+			commands: { authorized: params.command?.authorized === true }
 		},
-		commandTurn: params.commandTurn,
+		command: params.command,
 		extra: {
 			Transcript: params.transcript,
 			GroupSubject: params.msg.group?.subject,
@@ -2719,40 +2953,12 @@ async function buildWhatsAppInboundContext(params) {
 				fallbackE164: params.sender.e164
 			}),
 			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) : {}
 		}
 	});
 }
-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) {
 	const admission = requireWhatsAppInboundAdmission(params.msg);
 	const conversationId = admission.conversation.id;
@@ -2783,8 +2989,9 @@ 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})`);
 }
-async function dispatchWhatsAppBufferedReply(params) {
+function createWhatsAppReplyPlan(params) {
 	const admission = requireWhatsAppInboundAdmission(params.msg);
+	const ingressLifecycle = resolveWhatsAppIngressLifecycle(params.msg);
 	const conversationId = admission.conversation.id;
 	const conversationKind = admission.conversation.kind;
 	const statusReactionController = params.statusReactionController ?? null;
@@ -2801,18 +3008,9 @@ async function dispatchWhatsAppBufferedReply(params) {
 		accountId: params.route.accountId
 	});
 	const mediaLocalRoots = getAgentScopedMediaLocalRoots(params.cfg, params.route.agentId);
-	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({
+	const sourceReplyDeliveryMode = params.context.ChatType === "group" || params.context.ChatType === "channel" ? resolveChannelMessageSourceReplyDeliveryMode({
 		cfg: params.cfg,
-		ctx: {
-			ChatType: sourceReplyChatType,
-			CommandTurn: sourceReplyCommandTurn,
-			CommandSource: sourceReplyCommandSource,
-			CommandAuthorized: sourceReplyCommandAuthorized
-		}
+		ctx: params.context
 	}) : void 0;
 	const sourceRepliesAreToolOnly = sourceReplyDeliveryMode === "message_tool_only";
 	const disableBlockStreaming = sourceRepliesAreToolOnly ? true : resolveWhatsAppDisableBlockStreaming(params.cfg);
@@ -2859,11 +3057,10 @@ async function dispatchWhatsAppBufferedReply(params) {
 	const mediaOnlyCoalescer = createWhatsAppMediaOnlyReplyCoalescer({ deliver: async (pending) => {
 		return await deliverNormalizedPayload(pending.payload, pending.info);
 	} });
-	if (statusReactionController) statusReactionController.setThinking();
-	const dispatchResult = await dispatchReplyWithBufferedBlockDispatcher({
-		ctx: params.context,
-		cfg: params.cfg,
-		replyResolver: params.replyResolver,
+	return {
+		afterRecord: () => {
+			if (statusReactionController) statusReactionController.setThinking();
+		},
 		dispatcherOptions: {
 			...params.replyPipeline,
 			onHeartbeatStrip: () => {
@@ -2872,6 +3069,14 @@ async function dispatchWhatsAppBufferedReply(params) {
 					logVerbose$1("Stripped stray HEARTBEAT_OK token from web reply");
 				}
 			},
+			onSettled: async () => {
+				const flushResult = await mediaOnlyCoalescer.flushAll();
+				logWhatsAppMediaOnlyFlushResult(flushResult);
+				return whatsAppReplyDeliveryVisibility(flushResult.delivered > 0);
+			},
+			onReplyStart: params.msg.platform.sendComposing
+		},
+		delivery: {
 			deliver: async (payload, info) => {
 				const deliveryPayload = resolveWhatsAppDeliverablePayload(payload, info);
 				if (!deliveryPayload) return whatsAppReplyDeliveryVisibility(false);
@@ -2922,8 +3127,8 @@ async function dispatchWhatsAppBufferedReply(params) {
 							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;
+						const deliveryResult = await deliverNormalizedPayload(normalizedDeliveryPayload, info);
+						return flushResult.delivered > 0 && !deliveryResult.visibleReplySent ? whatsAppReplyDeliveryVisibility(true) : deliveryResult;
 					} catch (error) {
 						throw markWhatsAppReplyDeliveryErrorVisibleAfterFlush(error, flushResult);
 					}
@@ -2944,27 +3149,12 @@ async function dispatchWhatsAppBufferedReply(params) {
 				const flushResult = await mediaOnlyCoalescer.flushExceptDuplicateMedia(mediaUrls);
 				logWhatsAppMediaOnlyFlushResult(flushResult);
 				try {
-					const delivery = await deliverNormalizedPayload(normalizedDeliveryPayload, info);
-					return flushResult.delivered > 0 && !delivery.visibleReplySent ? whatsAppReplyDeliveryVisibility(true) : delivery;
+					const deliveryResult = await deliverNormalizedPayload(normalizedDeliveryPayload, info);
+					return flushResult.delivered > 0 && !deliveryResult.visibleReplySent ? whatsAppReplyDeliveryVisibility(true) : deliveryResult;
 				} catch (error) {
 					throw markWhatsAppReplyDeliveryErrorVisibleAfterFlush(error, flushResult);
 				}
 			},
-			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) => {
 				logWhatsAppReplyDeliveryError({
 					err,
@@ -2976,39 +3166,52 @@ async function dispatchWhatsAppBufferedReply(params) {
 			}
 		},
 		replyOptions: {
+			...ingressLifecycle ? bindIngressLifecycleToReplyOptions(ingressLifecycle) : {},
 			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);
-			} } : {}
+			...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) {
+				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;
 		}
-	});
-	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") {
@@ -3343,24 +3546,13 @@ async function processMessage(params) {
 		normalizeE164
 	});
 	const shouldCheckCommandAuth = shouldComputeCommandAuthorized(commandBody, params.cfg);
-	const isTextCommand = isControlCommandMessage$1(commandBody, params.cfg);
+	const isTextCommand = isControlCommandMessage(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,
@@ -3384,9 +3576,11 @@ async function processMessage(params) {
 	const ctxPayload = await buildWhatsAppInboundContext({
 		bodyForAgent: msgForAgent.payload.body,
 		combinedBody,
-		commandBody,
-		commandAuthorized,
-		commandTurn,
+		command: {
+			kind: isTextCommand ? "text-slash" : "normal",
+			body: commandBody,
+			authorized: commandAuthorized
+		},
 		groupHistory: visibleGroupHistory,
 		groupMemberRoster: params.groupMemberNames.get(params.groupHistoryKey),
 		groupSystemPrompt: conversationSystemPrompt,
@@ -3424,6 +3618,7 @@ 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,
@@ -3457,26 +3652,8 @@ async function processMessage(params) {
 					recordHistory: false
 				} };
 			},
-			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({
+			resolveTurn: () => {
+				const { finalize, ...replyPlan } = createWhatsAppReplyPlan({
 					cfg: params.cfg,
 					connectionId: params.connectionId,
 					context: ctxPayload,
@@ -3497,11 +3674,35 @@ async function processMessage(params) {
 					route: params.route,
 					shouldClearGroupHistory,
 					statusReactionController
-				})
-			})
+				});
+				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
+				};
+			}
 		}
 	});
-	const didSendReply = turnResult.dispatched ? turnResult.dispatchResult : false;
+	const didSendReply = turnResult.dispatched ? finalizeReply?.(turnResult.dispatchResult) ?? false : false;
 	removeAckReactionHandleAfterReply({
 		removeAfterReply: Boolean(params.cfg.messages?.removeAckAfterReply && didSendReply),
 		ackReaction,
@@ -3845,6 +4046,7 @@ 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;
 async function monitorWebChannel(verbose, listenerFactory = attachWebInboxToSocket, keepAlive = true, replyResolver, runtime = defaultRuntime, abortSignal, tuning = {}) {
 	const activeReplyResolver = replyResolver ?? (await loadReplyResolverRuntime()).getReplyFromConfig;
 	const runId = newConnectionId();
@@ -3896,7 +4098,7 @@ 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_INBOUND_DEDUPE_TTL_MS);
+	const reconnectCatchUpWindowMs = Math.min(Math.max(messageTimeoutMs, 6e4), WHATSAPP_RECONNECT_CATCH_UP_MAX_MS);
 	const watchdogCheckMs = tuning.watchdogCheckMs ?? 60 * 1e3;
 	const controller = new WhatsAppConnectionController({
 		accountId: account.accountId,
@@ -3930,10 +4132,12 @@ async function monitorWebChannel(verbose, listenerFactory = attachWebInboxToSock
 			});
 			const shouldDebounce = (msg) => {
 				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);
+				return shouldDebounceTextInbound({
+					text: normalized.payload.commandBody ?? normalized.payload.body,
+					cfg,
+					hasMedia: Boolean(normalized.payload.media?.path || normalized.payload.media?.type),
+					allowDebounce: !(normalized.payload.location || normalized.quote?.id || normalized.quote?.body)
+				});
 			};
 			let connection;
 			try {