@openclaw/whatsapp 2026.7.2-beta.2 → 2026.7.2-beta.4

package/dist/{monitor-BZ8QvCeV.js → monitor-CBVNJ2lb.js}

@@ -1,52 +1,48 @@
-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 { n as getWhatsAppRuntime } from "./runtime-BfAdAEYT.js";
-import { n as getWhatsAppConnectionController } from "./connection-controller-runtime-context-CbTsqmPT.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 { 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 { a as resolveWhatsAppAccount, s as resolveWhatsAppMediaMaxBytes } from "./accounts-CxPuEFi-.js";
+import { a as normalizeWhatsAppOutboundPayload, c as prepareWhatsAppOutboundMedia, r as sendReactionWhatsApp, s as normalizeWhatsAppPayloadTextPreservingIndentation, u as resolveWhatsAppReactionLevel } from "./send-DhJVN30g.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-CKFrhoX4.js";
+import { t as normalizeE164 } from "./text-runtime-CU_IlbK5.js";
+import { a as cacheInboundMessageMeta, i as buildQuotedMessageOptions, n as resolveWhatsAppGroupSessionRoute, o as lookupInboundMessageMeta, r as resolveWhatsAppLegacyGroupSessionKey } from "./group-session-key-DJSdYfnb.js";
+import { g as readWebSelfId, o as getWebAuthAgeMs, r as WhatsAppAuthUnstableError, v as readWebSelfIdentityForDecision } from "./auth-store-DirYMTbo.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-BM4_wZeM.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-BoSHhQNJ.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-CRz_v6bR.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-CpHwbor_.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-BVRExqrB.js";
+import { n as maybeResolveWhatsAppApprovalReaction } from "./approval-reactions-P2HXjmln.js";
+import { t as maybeResolveWhatsAppQuestionReaction } from "./question-reactions-CaOrSYzU.js";
 import { resolveAccountEntry } from "openclaw/plugin-sdk/account-core";
 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 { 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 { bindIngressLifecycleToReplyOptions, createChannelIngressMonitor, 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";
-import { LocalMediaAccessError, getDefaultLocalRoots, loadWebMedia as loadWebMedia$1, loadWebMediaRaw, optimizeImageToJpeg, optimizeImageToPng } from "openclaw/plugin-sdk/web-media";
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
-import { chunkMarkdownTextWithMode } from "openclaw/plugin-sdk/reply-chunking";
+import { buildChannelInboundEventContext, filterChannelInboundQuoteContext, formatInboundEnvelope, formatInboundEnvelope as formatInboundEnvelope$1, formatInboundMediaUnavailableText, formatLocationText, formatMediaPlaceholderText, hasVisibleInboundReplyDispatch, resolveInboundSessionEnvelopeContext, resolveInboundSupplementalSenderAllowed, runChannelInboundEvent, shouldDebounceTextInbound, toInboundMediaFacts, toLocationContext } from "openclaw/plugin-sdk/channel-inbound";
 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, 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, 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 { 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 { createChannelReplayGuard } 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";
@@ -59,51 +55,8 @@ import { hasControlCommand, isControlCommandMessage, shouldComputeCommandAuthori
 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/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 whatsAppInboundReplayGuard = createChannelReplayGuard({
-	dedupe: {
-		ttlMs: WHATSAPP_INBOUND_DEDUPE_TTL_MS,
-		memoryMaxSize: RECENT_WEB_MESSAGE_MAX
-	},
-	buildReplayKey: (keys) => keys
-});
-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() {
-	whatsAppInboundReplayGuard.clearMemory();
-	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/message-aliases.ts
 function normalizeQuoteSender(sender) {
 	if (!sender?.displayName && !sender?.jid && !sender?.e164) return;
@@ -428,42 +381,173 @@ 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;
+const WHATSAPP_DURABLE_INBOUND_PRUNE_INTERVAL_MS = 3600 * 1e3;
+const WHATSAPP_DURABLE_INBOUND_PAYLOAD_VERSION = 1;
 function hashNamespacePart(value) {
 	return createHash("sha256").update(value).digest("hex").slice(0, 24);
 }
 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
 		}),
+		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();
+	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;
+}
+/** Shared monitor with per-conversation lanes and completion at reply-lane adoption. */
+function createWhatsAppIngressMonitor(params) {
+	return createChannelIngressMonitor({
+		queue: params.queue,
+		inspect: (message) => inspectWhatsAppIngressMessage(message),
+		payload: {
+			version: WHATSAPP_DURABLE_INBOUND_PAYLOAD_VERSION,
+			serialize: (message, { receivedAt }) => ({
+				message: serializeWhatsAppDurableInboundMessage(message),
+				receivedAt
+			}),
+			deserialize: (payload) => 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: (message, lifecycle, claim) => params.dispatch(message, claim.payload, lifecycle),
+		pollIntervalMs: params.pollIntervalMs,
 		retention: {
+			pruneIntervalMs: WHATSAPP_DURABLE_INBOUND_PRUNE_INTERVAL_MS,
 			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,
+			completedTtlMs: WHATSAPP_DURABLE_INBOUND_COMPLETED_TTL_MS,
 			completedMaxEntries: WHATSAPP_DURABLE_INBOUND_COMPLETED_MAX_ENTRIES,
+			failedTtlMs: WHATSAPP_DURABLE_INBOUND_PENDING_TTL_MS,
 			failedMaxEntries: WHATSAPP_DURABLE_INBOUND_PENDING_MAX_ENTRIES
-		}
+		},
+		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/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);
@@ -533,13 +617,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 });
@@ -630,9 +709,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");
@@ -673,14 +749,34 @@ 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();
+	let durableIngressActive = false;
+	const debounceWorkWaiters = /* @__PURE__ */ new Set();
+	const notifyDebounceWork = () => {
+		if (debounceWorkWaiters.size === 0) return;
+		const waiters = [...debounceWorkWaiters];
+		debounceWorkWaiters.clear();
+		for (const resolve of waiters) resolve();
+	};
+	const waitForDebounceWorkOrIdle = (handlers) => {
+		if (pendingDebounceKeys.size > 0 || activeInboundFlushes.size > 0) return Promise.resolve();
+		if (pendingMessageHandlers.size === 0) return Promise.resolve();
+		return new Promise((resolve) => {
+			const finish = () => {
+				debounceWorkWaiters.delete(finish);
+				resolve();
+			};
+			debounceWorkWaiters.add(finish);
+			Promise.allSettled(handlers).then(finish);
+		});
+	};
 	let nextReceiveOrder = 0;
 	const publishPendingWorkState = (at = Date.now()) => {
-		options.onPendingWorkChanged?.(pendingMessageHandlers.size + pendingDebounceKeys.size + activeInboundFlushes.size, at);
+		options.onPendingWorkChanged?.(pendingMessageHandlers.size + pendingDebounceKeys.size + activeInboundFlushes.size + (durableIngressActive ? 1 : 0), at);
 	};
 	const buildInboundDebounceKey = (msg) => {
 		const admission = requireWhatsAppInboundAdmission(msg);
@@ -695,18 +791,47 @@ async function attachWebInboxToSocket(options) {
 		if (timestampDiff !== 0) return timestampDiff;
 		return (a.receiveOrder ?? 0) - (b.receiveOrder ?? 0);
 	});
-	const finalizeInboundDelivery = async (entries, error) => {
-		const replayClaims = entries.map((entry) => entry.replayClaim).filter((claim) => claim !== void 0);
-		const durableEntries = entries.filter((entry) => isNonEmptyString(entry.durableId));
-		const readReceiptEntries = entries.filter((entry) => Boolean(entry.readReceipt));
-		const retryableError = resolveRetryableWhatsAppInboundError(error);
-		if (retryableError) {
-			for (const claim of replayClaims) claim.release({ error: retryableError });
-			await Promise.all(durableEntries.map((entry) => durableInboundJournal.release(entry.durableId, { lastError: formatError(retryableError) })));
-			return;
-		}
-		await Promise.all([...replayClaims.map((claim) => claim.commit()), ...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,
@@ -719,14 +844,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();
@@ -741,8 +869,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,
@@ -753,11 +882,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 {
@@ -972,20 +1102,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);
@@ -1061,15 +1195,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;
@@ -1078,86 +1203,25 @@ 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 whatsAppInboundReplayGuard.claim(dedupeKey) : { kind: "invalid" };
-		if (dedupeClaim.kind === "duplicate" || dedupeClaim.kind === "inflight") {
-			if (dedupeClaim.kind === "duplicate") {
-				await completeUndeliverableDurableInbound(durableId, durableMetadata);
-				await maybeMarkNonSelfChatReadReceipt(inbound, deliveryReadReceipt);
-			}
-			return;
-		}
-		recordAcceptedInboundActivity(options.accountId);
-		await enqueueInboundMessage(msg, inbound, enriched, {
-			durableId,
-			readReceipt: deliveryReadReceipt,
-			receiveOrder,
-			...dedupeClaim.kind === "claimed" ? { replayClaim: dedupeClaim.handle } : {}
-		});
-	};
-	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;
 		const contactContext = extractContactContext(msg.message ?? void 0);
 		const externalAdReplyContext = extractExternalAdReplyContext(msg.message ?? void 0);
-		const mediaPlaceholder = extractMediaPlaceholder(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) {
-			body = mediaPlaceholder;
-			if (!body) return null;
-		}
+		if (!body && !mediaKind) return null;
+		body = body ?? "";
 		const commandBody = body;
 		const replyContext = describeReplyContext(msg.message);
 		let mediaPath;
-		let mediaType;
+		let mediaType = mediaKind ? resolveInboundMediaMimetype(msg.message) : void 0;
+		const nativeMedia = mediaKind ? {
+			contentType: mediaType,
+			kind: mediaKind
+		} : void 0;
 		let mediaFileName;
 		const maxBytes = (typeof options.mediaMaxMb === "number" && options.mediaMaxMb > 0 ? options.mediaMaxMb : 50) * 1024 * 1024;
 		const saveInboundMedia = async (inboundMedia) => {
@@ -1172,12 +1236,13 @@ async function attachWebInboxToSocket(options) {
 			logWhatsAppVerbose(options.verbose, `Inbound media download failed: ${String(err)}`);
 			body = formatInboundMediaUnavailableText({
 				body,
-				mediaPlaceholder,
 				notice: "[whatsapp attachment unavailable]"
 			});
 		}
-		if (!mediaPath && replyContext) try {
+		if (!mediaPath && !mediaKind && replyContext?.media) try {
 			await saveInboundMedia(await downloadQuotedInboundMedia(msg, sock, maxBytes));
+			mediaKind = replyContext.media.kind ?? void 0;
+			mediaType = mediaType ?? replyContext.media.contentType ?? void 0;
 		} catch (err) {
 			logWhatsAppVerbose(options.verbose, `Quoted media download failed: ${String(err)}`);
 			body = formatInboundMediaUnavailableText({
@@ -1194,7 +1259,9 @@ async function attachWebInboxToSocket(options) {
 			replyContext,
 			mediaPath,
 			mediaType,
-			mediaFileName
+			mediaFileName,
+			mediaKind,
+			nativeMedia
 		};
 	};
 	const enqueueInboundMessage = async (msg, inbound, enriched, durable) => {
@@ -1229,10 +1296,11 @@ async function attachWebInboxToSocket(options) {
 			mediaFileName: enriched.mediaFileName,
 			timestamp
 		}, "inbound message");
-		const media = enriched.mediaPath || enriched.mediaType || enriched.mediaFileName ? {
+		const media = enriched.mediaPath || enriched.mediaType || enriched.mediaFileName || enriched.mediaKind ? {
 			path: enriched.mediaPath,
 			type: enriched.mediaType,
-			fileName: enriched.mediaFileName
+			fileName: enriched.mediaFileName,
+			kind: enriched.mediaKind
 		} : void 0;
 		const groupMentions = mentionedJids ? { jids: mentionedJids } : void 0;
 		const group = inbound.group && (inbound.groupSubject || inbound.groupParticipants?.length || groupMentions) ? {
@@ -1240,17 +1308,26 @@ async function attachWebInboxToSocket(options) {
 			participants: inbound.groupParticipants,
 			mentions: groupMentions
 		} : void 0;
-		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 untrustedStructuredContext = [
+			...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 inboundMessage = withDeprecatedWebInboundMessageFlatAliases({
 			admission: inbound.access.admission,
 			event: {
@@ -1289,6 +1366,7 @@ async function attachWebInboxToSocket(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,
@@ -1296,8 +1374,7 @@ async function attachWebInboxToSocket(options) {
 				}
 			} : void 0,
 			group,
-			replayClaim: durable.replayClaim,
-			durableId: durable.durableId,
+			turnAdoptionLifecycle: durable.turnAdoptionLifecycle,
 			readReceipt: durable.readReceipt,
 			receiveOrder: durable.receiveOrder
 		});
@@ -1307,6 +1384,7 @@ async function attachWebInboxToSocket(options) {
 			if (inboundDebounceMs > 0 && shouldDebounceInboundMessage(inboundMessage)) {
 				pendingDebounceKeys.add(debounceKey);
 				publishPendingWorkState();
+				notifyDebounceWork();
 			}
 		}
 		if (inboundMessage.event.id) {
@@ -1315,19 +1393,70 @@ async function attachWebInboxToSocket(options) {
 				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
 			});
 		}
-		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)}`);
+		await debouncer.enqueue(inboundMessage);
+	};
+	const processDurableInboundMessage = 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";
 	};
+	const durableInboundMonitor = createWhatsAppIngressMonitor({
+		queue: durableInboundQueue,
+		dispatch: async (msg, payload, lifecycle) => {
+			const remoteJid = msg.key?.remoteJid;
+			const id = msg.key?.id;
+			return { kind: await processDurableInboundMessage(msg, {
+				...payload,
+				...remoteJid && id ? { eventId: createWhatsAppDurableInboundMessageId({
+					remoteJid,
+					id
+				}) } : {},
+				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 ?? []) {
@@ -1343,7 +1472,76 @@ 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);
+				durableInboundMonitor.requestDrain();
+			}
 		}
 	};
 	const handleMessagesUpsertEvent = (upsert) => {
@@ -1358,9 +1556,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);
@@ -1372,8 +1567,20 @@ async function attachWebInboxToSocket(options) {
 	};
 	const drainInboundBeforeSocketClose = async () => {
 		groupMetadataCacheClosed = true;
-		await waitForPendingMessageHandlers();
+		for (;;) {
+			await drainDebouncedInboundMessages();
+			if (pendingMessageHandlers.size === 0) break;
+			const handlers = Array.from(pendingMessageHandlers);
+			await Promise.race([Promise.allSettled(handlers), waitForDebounceWorkOrIdle(handlers)]);
+			if (pendingMessageHandlers.size === 0 && pendingDebounceKeys.size === 0 && activeInboundFlushes.size === 0) break;
+		}
 		await drainDebouncedInboundMessages();
+		for (;;) {
+			await durableInboundMonitor.waitForIdle();
+			if (pendingDebounceKeys.size === 0 && activeInboundFlushes.size === 0) break;
+			await drainDebouncedInboundMessages();
+		}
+		await durableInboundMonitor.stop();
 	};
 	const drainInboundBeforeSocketCloseWithTimeout = async () => {
 		let timeout = null;
@@ -1386,6 +1593,7 @@ async function attachWebInboxToSocket(options) {
 			})]);
 		} finally {
 			if (timeout) clearTimeout(timeout);
+			durableInboundMonitor.stop();
 		}
 	};
 	const handleConnectionUpdate = (update) => {
@@ -1444,16 +1652,7 @@ async function attachWebInboxToSocket(options) {
 	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();
-	});
+	durableInboundMonitor.start();
 	(async () => {
 		try {
 			const groups = await sock.groupFetchAllParticipating();
@@ -1511,7 +1710,7 @@ async function attachWebInboxToSocket(options) {
 	};
 }
 async function monitorWebInbox(options) {
-	const socketTiming = options.socketTiming ?? resolveWhatsAppSocketTiming(options.cfg);
+	const socketTiming = options.socketTiming ?? resolveWhatsAppSocketTiming();
 	const recentMessageKeys = options.recentMessageKeys ?? /* @__PURE__ */ new Map();
 	const baileysGroupMetaCache = options.baileysGroupMetaCache ?? /* @__PURE__ */ new Map();
 	const sock = await createWaSocket(false, options.verbose, {
@@ -1569,12 +1768,13 @@ 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;
-	if (hasMentions && !isSelfChat) {
+	const hasNativeMentionsOutsideSelfChat = hasMentions && !isSelfChat;
+	if (hasNativeMentionsOutsideSelfChat) {
 		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) {
@@ -1755,8 +1955,7 @@ function formatWhatsAppInboundListeningLog(account) {
 const DEFAULT_WHATSAPP_ACK_REACTION = "👀";
 function resolveWhatsAppAckEmoji(params) {
 	if (!params.ackConfig) return "";
-	if (params.ackConfig.emoji !== void 0) return params.ackConfig.emoji.trim();
-	return resolveAgentIdentityEmoji(params.cfg, params.agentId) ?? DEFAULT_WHATSAPP_ACK_REACTION;
+	return (typeof params.ackConfig === "string" ? params.ackConfig : params.ackConfig.emoji)?.trim() || resolveAgentIdentityEmoji(params.cfg, params.agentId) || DEFAULT_WHATSAPP_ACK_REACTION;
 }
 function resolveAgentIdentityEmoji(cfg, agentId) {
 	return resolveAgentIdentity(cfg, agentId)?.emoji?.trim() || void 0;
@@ -1809,6 +2008,12 @@ 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/ack-reaction.ts
 async function maybeSendAckReaction(params) {
 	if (!params.msg.event.id) return null;
@@ -1818,14 +2023,16 @@ async function maybeSendAckReaction(params) {
 		cfg: params.cfg,
 		accountId
 	}).level === "off") return null;
-	const ackConfig = params.cfg.channels?.whatsapp?.ackReaction;
+	const ackConfig = params.cfg.messages?.ackReaction;
+	const scope = params.cfg.messages?.ackReactionScope ?? "group-mentions";
+	if (scope === "off" || scope === "none") return null;
 	const emoji = resolveWhatsAppAckEmoji({
 		cfg: params.cfg,
 		agentId: params.agentId,
 		ackConfig
 	});
-	const directEnabled = ackConfig?.direct ?? true;
-	const groupMode = ackConfig?.group ?? "mentions";
+	const directEnabled = scope === "all" || scope === "direct";
+	const groupMode = scope === "all" || scope === "group-all" ? "always" : scope === "direct" ? "never" : "mentions";
 	const isGroup = admission.conversation.kind === "group";
 	const conversationIdForCheck = admission.conversation.id;
 	const activation = isGroup ? await resolveGroupActivationFor({
@@ -1850,11 +2057,11 @@ async function maybeSendAckReaction(params) {
 		messageId: params.msg.event.id,
 		emoji
 	}, "sending ack reaction");
-	const sender = getSenderIdentity(params.msg);
+	const participant = resolveReactionParticipant(params.msg);
 	const reactionOptions = {
 		verbose: params.verbose,
 		fromMe: false,
-		...sender.jid ? { participant: sender.jid } : {},
+		...participant ? { participant } : {},
 		accountId,
 		cfg: params.cfg
 	};
@@ -2024,7 +2231,13 @@ 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
+			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
+			}] } : {}
 		}
 	});
 }
@@ -2360,7 +2573,7 @@ async function deliverWebReply(params) {
 	const tableMode = params.tableMode ?? "code";
 	const chunkMode = params.chunkMode ?? "length";
 	const normalizedReply = params.normalizedReplyResult ?? normalizeWhatsAppOutboundPayload(replyResult, { normalizeText: normalizeWhatsAppPayloadTextPreservingIndentation });
-	const textChunks = chunkMarkdownTextWithMode(markdownToWhatsApp(convertMarkdownTables$1(normalizedReply.text ?? "", tableMode)), textLimit, chunkMode);
+	const textChunks = markdownToWhatsAppChunks(normalizedReply.text ?? "", textLimit, tableMode, chunkMode);
 	const mediaList = normalizedReply.mediaUrls ?? [];
 	const getQuote = () => {
 		if (!replyResult.replyToId) return;
@@ -2370,7 +2583,8 @@ async function deliverWebReply(params) {
 			remoteJid: msg.platform.chatJid,
 			fromMe: cached?.fromMe ?? false,
 			participant: cached?.participant ?? (isGroupConversation ? msg.platform.senderJid : void 0),
-			messageText: cached?.body ?? ""
+			messageText: cached?.body ?? "",
+			media: cached?.media
 		});
 	};
 	const sendWithRetry = async (fn, label) => {
@@ -2418,7 +2632,7 @@ async function deliverWebReply(params) {
 		mediaUrls: mediaList,
 		caption: remainingText.shift() || "",
 		send: async ({ mediaUrl, caption }) => {
-			const media = await prepareWhatsAppOutboundMedia(await loadWebMedia$1(mediaUrl, {
+			const media = await prepareWhatsAppOutboundMedia(await loadWebMedia(mediaUrl, {
 				maxBytes: maxMediaBytes,
 				localRoots: params.mediaLocalRoots
 			}), mediaUrl);
@@ -2505,32 +2719,47 @@ 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 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,
 		allowFrom: params.groupAllowFrom,
-		authDir: params.authDir,
-		sender: replyTo.sender
+		isSenderAllowed: (allowFrom) => isWhatsAppSupplementalSenderAllowed({
+			allowFrom,
+			authDir: params.authDir,
+			sender: replyTo.sender
+		})
 	});
-	return filterChannelInboundQuoteContext(params.mode, {
+	const visible = filterChannelInboundQuoteContext(params.mode, {
 		id: replyTo.id,
-		body: replyTo.body,
+		body: previewBody,
 		sender: replyTo.sender?.label ?? void 0,
 		senderAllowed
-	}) ? replyTo : null;
+	});
+	return visible ? {
+		...replyTo,
+		body: visible.body ?? ""
+	} : null;
 }
 //#endregion
 //#region extensions/whatsapp/src/auto-reply/monitor/inbound-dispatch.ts
@@ -2639,7 +2868,7 @@ function logWhatsAppMediaOnlyFlushResult(result) {
 }
 function resolveWhatsAppResponsePrefix(params) {
 	const configuredResponsePrefix = params.cfg.messages?.responsePrefix;
-	return params.pipelineResponsePrefix ?? (configuredResponsePrefix === void 0 && params.isSelfChat ? resolveIdentityNamePrefix$1(params.cfg, params.agentId) : void 0);
+	return params.pipelineResponsePrefix ?? (configuredResponsePrefix === "auto" ? resolveIdentityNamePrefix$1(params.cfg, params.agentId) : configuredResponsePrefix) ?? (params.isSelfChat ? resolveIdentityNamePrefix$1(params.cfg, params.agentId) : void 0);
 }
 async function buildWhatsAppInboundContext(params) {
 	const admission = requireWhatsAppInboundAdmission(params.msg);
@@ -2651,14 +2880,16 @@ async function buildWhatsAppInboundContext(params) {
 			sender: entry.sender,
 			body: entry.body,
 			timestamp: entry.timestamp,
-			messageId: entry.id
+			messageId: entry.id,
+			media: entry.media
 		})),
 		limit: params.groupHistory?.length ?? 1
 	}) : void 0;
-	const media = toInboundMediaFacts(params.msg.payload.media?.path || params.msg.payload.media?.url ? [{
+	const media = toInboundMediaFacts(params.msg.payload.media ? [{
 		path: params.msg.payload.media?.path,
 		url: params.msg.payload.media?.url ?? params.msg.payload.media?.path,
-		contentType: params.msg.payload.media?.type
+		contentType: params.msg.payload.media?.type,
+		kind: params.msg.payload.media?.kind
 	}] : void 0, { transcribed: (_entry, index) => params.mediaTranscribedIndexes?.includes(index) === true });
 	return buildChannelInboundEventContext({
 		channel: "whatsapp",
@@ -2686,6 +2917,7 @@ async function buildWhatsAppInboundContext(params) {
 		},
 		route: {
 			agentId: params.route.agentId,
+			dmScope: params.route.dmScope,
 			accountId: params.route.accountId,
 			routeSessionKey: params.route.sessionKey
 		},
@@ -2700,6 +2932,7 @@ async function buildWhatsAppInboundContext(params) {
 			rawBody: params.rawBody ?? params.msg.payload.body,
 			commandBody: params.command?.body ?? params.msg.payload.body
 		},
+		sessionTranscript: { historyLimit: conversationKind === "group" ? params.groupHistoryLimit ?? params.groupHistory?.length ?? 0 : 0 },
 		access: {
 			...wasMentioned !== void 0 ? { mentions: {
 				canDetectMention: conversationKind === "group",
@@ -2754,16 +2987,12 @@ 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;
-	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({
@@ -2821,11 +3050,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: () => {
@@ -2834,6 +3062,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);
@@ -2884,8 +3120,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);
 					}
@@ -2906,27 +3142,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,
@@ -2938,64 +3159,50 @@ 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"
+				});
+				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;
 		}
-	});
-	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();
-		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);
-	});
+	if (params.outcome === "done") await params.controller.setDone();
+	else await params.controller.setError();
 	await params.controller.restoreInitial();
 }
 //#endregion
@@ -3009,7 +3216,7 @@ function resolveIdentityNamePrefix(cfg, agentId) {
 	return identityName ? `[${identityName}]` : void 0;
 }
 function resolveMessagePrefix(cfg, agentId, opts) {
-	const configured = opts?.configured ?? cfg.messages?.messagePrefix;
+	const configured = opts?.configured;
 	if (configured !== void 0) return configured;
 	if (opts?.hasAllowFrom === true) return "";
 	return resolveIdentityNamePrefix(cfg, agentId) ?? opts?.fallback ?? "[openclaw]";
@@ -3026,7 +3233,7 @@ function formatReplyContext(msg) {
 function buildInboundLine(params) {
 	const { cfg, msg, agentId, previousTimestamp, envelope } = params;
 	const messagePrefix = resolveMessagePrefix(cfg, agentId, {
-		configured: cfg.channels?.whatsapp?.messagePrefix,
+		configured: cfg.channels?.whatsapp?.responsePrefix,
 		hasAllowFrom: (cfg.channels?.whatsapp?.allowFrom?.length ?? 0) > 0
 	});
 	const admission = requireWhatsAppInboundAdmission(msg);
@@ -3056,23 +3263,24 @@ function buildInboundLine(params) {
 //#region extensions/whatsapp/src/auto-reply/monitor/status-reaction.ts
 async function createWhatsAppStatusReactionController(params) {
 	if (!params.msg.event.id) return null;
-	const statusReactionsConfig = params.cfg.messages?.statusReactions;
-	if (statusReactionsConfig?.enabled !== true) return null;
+	if ((params.cfg.messages?.statusReactions)?.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 ackConfig = params.cfg.messages?.ackReaction;
+	const scope = params.cfg.messages?.ackReactionScope ?? "group-mentions";
+	if (scope === "off" || scope === "none") return null;
 	const ackEmoji = resolveWhatsAppAckEmoji({
 		cfg: params.cfg,
 		agentId: params.agentId,
 		ackConfig
 	});
 	if (!ackEmoji) return null;
-	const directEnabled = ackConfig?.direct ?? true;
-	const groupMode = ackConfig?.group ?? "mentions";
+	const directEnabled = scope === "all" || scope === "direct";
+	const groupMode = scope === "all" || scope === "group-all" ? "always" : scope === "direct" ? "never" : "mentions";
 	const isGroup = admission.conversation.kind === "group";
 	const conversationIdForCheck = admission.conversation.id;
 	const activation = isGroup ? await resolveGroupActivationFor({
@@ -3091,11 +3299,11 @@ async function createWhatsAppStatusReactionController(params) {
 		wasMentioned: (params.msg.groupMention?.wasMentioned ?? params.msg.wasMentioned) === true,
 		groupActivated: activation === "always"
 	})) return null;
-	const sender = getSenderIdentity(params.msg);
+	const participant = resolveReactionParticipant(params.msg);
 	const reactionOptions = {
 		verbose: params.verbose,
 		fromMe: false,
-		...sender.jid ? { participant: sender.jid } : {},
+		...participant ? { participant } : {},
 		accountId,
 		cfg: params.cfg
 	};
@@ -3112,8 +3320,7 @@ async function createWhatsAppStatusReactionController(params) {
 			}
 		},
 		initialEmoji: ackEmoji,
-		emojis: statusReactionsConfig.emojis,
-		timing: statusReactionsConfig.timing,
+		emojis: void 0,
 		onError: (err) => {
 			logVerbose(`WhatsApp status-reaction error for chat ${chatId}/${msgId}: ${String(err)}`);
 		}
@@ -3182,13 +3389,16 @@ async function processMessage(params) {
 		sessionKey: params.route.sessionKey
 	});
 	let audioTranscript = params.preflightAudioTranscript ?? void 0;
-	const hasAudioBody = params.msg.payload.media?.type?.startsWith("audio/") === true && params.msg.payload.body === "<media:audio>";
+	const hasAudioBody = (params.msg.payload.media?.kind === "audio" || params.msg.payload.media?.type?.startsWith("audio/") === true) && !params.msg.payload.body.trim();
 	if (params.preflightAudioTranscript === void 0 && hasAudioBody && params.msg.payload.media?.path) try {
 		const { transcribeFirstAudio } = await import("./audio-preflight.runtime-C_glQhZY.js");
 		audioTranscript = await transcribeFirstAudio({
 			ctx: {
-				MediaPaths: [params.msg.payload.media?.path],
-				MediaTypes: params.msg.payload.media?.type ? [params.msg.payload.media?.type] : void 0,
+				media: [{
+					path: params.msg.payload.media.path,
+					contentType: params.msg.payload.media.type,
+					kind: params.msg.payload.media.kind ?? void 0
+				}],
 				From: conversationId,
 				To: params.msg.platform.recipientJid,
 				Provider: "whatsapp",
@@ -3200,7 +3410,7 @@ async function processMessage(params) {
 			cfg: params.cfg
 		});
 	} catch {
-		if (shouldLogVerbose$1()) logVerbose$1("whatsapp: audio preflight transcription failed, using placeholder");
+		if (shouldLogVerbose$1()) logVerbose$1("whatsapp: audio preflight transcription failed, keeping structured audio");
 	}
 	const msgForAgent = audioTranscript !== void 0 ? {
 		...params.msg,
@@ -3238,7 +3448,8 @@ async function processMessage(params) {
 			entries: history.map((m) => ({
 				sender: m.sender,
 				body: m.body,
-				timestamp: m.timestamp
+				timestamp: m.timestamp,
+				media: m.media
 			})),
 			currentMessage: combinedBody,
 			excludeLast: false,
@@ -3247,7 +3458,7 @@ async function processMessage(params) {
 					channel: "WhatsApp",
 					from: conversationId,
 					timestamp: entry.timestamp,
-					body: entry.body,
+					body: [entry.body, formatMediaPlaceholderText(entry.media ?? [])].filter(Boolean).join("\n"),
 					chatType: "group",
 					senderLabel: entry.sender,
 					envelope: envelopeOptions
@@ -3341,6 +3552,7 @@ async function processMessage(params) {
 			authorized: commandAuthorized
 		},
 		groupHistory: visibleGroupHistory,
+		groupHistoryLimit: params.groupHistoryLimit,
 		groupMemberRoster: params.groupMemberNames.get(params.groupHistoryKey),
 		groupSystemPrompt: conversationSystemPrompt,
 		msg: params.msg,
@@ -3377,6 +3589,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,
@@ -3410,26 +3623,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,
@@ -3450,13 +3645,37 @@ 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),
+		removeAfterReply: false,
 		ackReaction,
 		onError: (err) => {
 			logAckFailure({
@@ -3496,6 +3715,7 @@ function createWebOnMessageHandler(params) {
 			route,
 			groupHistoryKey,
 			groupHistories: params.groupHistories,
+			groupHistoryLimit: params.groupHistoryLimit,
 			groupMemberNames: params.groupMemberNames,
 			connectionId: params.connectionId,
 			verbose: params.verbose,
@@ -3563,7 +3783,7 @@ function createWebOnMessageHandler(params) {
 			peerId
 		}) : route.sessionKey;
 		let preflightAudioTranscript;
-		const hasAudioBody = msg.payload.media?.type?.startsWith("audio/") === true && msg.payload.body === "<media:audio>";
+		const hasAudioBody = (msg.payload.media?.kind === "audio" || msg.payload.media?.type?.startsWith("audio/") === true) && !msg.payload.body.trim();
 		const canRunEarlyAudioPreflight = conversationKind === "group" || canRunDirectEarlyAudioPreflight;
 		let ackAlreadySent = false;
 		let ackReaction = null;
@@ -3589,8 +3809,11 @@ function createWebOnMessageHandler(params) {
 				const { transcribeFirstAudio } = await import("./audio-preflight.runtime-C_glQhZY.js");
 				preflightAudioTranscript = await transcribeFirstAudio({
 					ctx: {
-						MediaPaths: [msg.payload.media?.path],
-						MediaTypes: msg.payload.media?.type ? [msg.payload.media?.type] : void 0,
+						media: [{
+							path: msg.payload.media.path,
+							contentType: msg.payload.media.type,
+							kind: msg.payload.media.kind ?? void 0
+						}],
 						From: conversationId,
 						To: msg.platform.recipientJid,
 						Provider: "whatsapp",
@@ -3761,8 +3984,7 @@ function resolveWebMonitorConfigSnapshot(params) {
 				...params.cfg.channels,
 				whatsapp: {
 					...params.cfg.channels?.whatsapp,
-					ackReaction: account.ackReaction,
-					messagePrefix: account.messagePrefix,
+					responsePrefix: account.messagePrefix,
 					allowFrom: account.allowFrom,
 					groupAllowFrom: account.groupAllowFrom,
 					groupPolicy: account.groupPolicy,
@@ -3798,6 +4020,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();
@@ -3826,7 +4049,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(cfg, tuning.socketTiming);
+	const socketTiming = resolveWhatsAppSocketTiming(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();
@@ -3849,7 +4072,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,
@@ -4225,4 +4448,4 @@ async function monitorWebChannel(verbose, listenerFactory = attachWebInboxToSock
 	}
 }
 //#endregion
-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 };
+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 };