@openclaw/whatsapp 2026.9.6 → 2026.9.7

package/dist/.setup/{monitor-By82ehLA.mjs → monitor-CGpV2VNN.mjs}

@@ -1,20 +1,19 @@
-import { a as resolveWhatsAppAccount, s as resolveWhatsAppMediaMaxBytes } from "./accounts-D_NGDjCx.mjs";
-import { c as normalizeWhatsAppPayloadTextPreservingIndentation, d as listWhatsAppSendResultMessageIds, f as mergeWhatsAppAcceptedSendError, g as withWhatsAppLogicalDeliveryActivity, h as rememberWhatsAppPartialSend, l as prepareWhatsAppOutboundMedia, m as rememberWhatsAppAcceptedSend, o as normalizeWhatsAppOutboundPayload, p as normalizeWhatsAppSendResult, r as sendReactionWhatsApp, v as resolveWhatsAppReactionLevel } from "./send-C6jDmcL9.mjs";
-import { i as getWhatsAppRuntime, r as getWhatsAppChannelRuntime } from "./runtime-BLlToOi6.mjs";
+import { n as __reExport, t as __exportAll } from "./rolldown-runtime-BBjsoOtd.mjs";
+import { a as resolveWhatsAppAccount, s as resolveWhatsAppMediaMaxBytes } from "./accounts-CtRPAQCL.mjs";
+import { c as normalizeWhatsAppPayloadTextPreservingIndentation, d as listWhatsAppSendResultMessageIds, f as mergeWhatsAppAcceptedSendError, g as withWhatsAppLogicalDeliveryActivity, h as rememberWhatsAppPartialSend, l as prepareWhatsAppOutboundMedia, m as rememberWhatsAppAcceptedSend, o as normalizeWhatsAppOutboundPayload, p as normalizeWhatsAppSendResult, r as sendReactionWhatsApp, v as resolveWhatsAppReactionLevel } from "./send-BGdvf5cC.mjs";
+import { i as getWhatsAppRuntime } from "./runtime-BLlToOi6.mjs";
 import { r as getWhatsAppConnectionController } from "./connection-controller-runtime-context-hgLJoRc8.mjs";
-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-RBjx3pg_.mjs";
-import { t as normalizeE164 } from "./text-runtime-CHl0iPYe.mjs";
-import { a as cacheInboundMessageMeta, i as buildQuotedMessageOptions, n as resolveWhatsAppGroupSessionRoute, o as lookupInboundMessageMeta, r as resolveWhatsAppLegacyGroupSessionKey } from "./group-session-key-D22hYMdE.mjs";
-import { C as getMentionIdentities, D as getSenderIdentity, E as getSelfIdentity, O as identitiesOverlap, S as getComparableIdentityValues, T as getReplyContext, g as readWebSelfId, k as resolveComparableIdentity, o as getWebAuthAgeMs, r as WhatsAppAuthUnstableError, v as readWebSelfIdentityForDecision, w as getPrimaryIdentityId } from "./auth-store-Dh8a3cba.mjs";
-import { n as resolveWhatsAppGroupsConfigPath } from "./group-config-path-BGyzT9Lg.mjs";
-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-CCVSFufF.mjs";
-import { n as getStatusCode, t as formatError } from "./session-errors-JuazczrA.mjs";
-import { t as BufferJSON } from "./session.runtime-DcJuO42v.mjs";
-import { _ as resolveInboundMediaMimetype, a as addWhatsAppImagePreviewFields, c as extractContextInfo, d as extractMediaKind, f as extractMentionedJids, g as projectWhatsAppInboundMessage, h as hasInboundUserContent, i as resolveWhatsAppOutboundMentions, l as extractExternalAdReplyContext, n as addWhatsAppOutboundMentionsToContent, o as describeReplyContext, p as extractText, r as mayContainWhatsAppOutboundMention, s as extractContactContext, t as createWebSendApi, u as extractLocationData } from "./send-api-B4DOt2RJ.mjs";
-import { t as resolveWhatsAppRuntimeGroupPolicy } from "./runtime-group-policy-DeSRFXEV.mjs";
-import { c as computeBackoff, d as resolveReconnectPolicy, f as sleepWithAbort, l as newConnectionId, n as WHATSAPP_WATCHDOG_TIMEOUT_ERROR, r as WhatsAppConnectionController, s as DEFAULT_RECONNECT_POLICY, u as resolveHeartbeatSeconds } from "./connection-controller-C60mU7j7.mjs";
-import { n as maybeResolveWhatsAppApprovalReaction } from "./approval-reactions-BnXw-UZI.mjs";
-import { t as maybeResolveWhatsAppQuestionReaction } from "./question-reactions-D3Zq9Gbn.mjs";
+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-DmiqXIXO.mjs";
+import { a as cacheInboundMessageMeta, i as buildQuotedMessageOptions, n as resolveWhatsAppGroupSessionRoute, o as lookupInboundMessageMeta, r as resolveWhatsAppLegacyGroupSessionKey } from "./group-session-key-2-mja4OF.mjs";
+import { C as getMentionIdentities, D as getSenderIdentity, E as getSelfIdentity, O as identitiesOverlap, S as getComparableIdentityValues, T as getReplyContext, g as readWebSelfId, k as resolveComparableIdentity, o as getWebAuthAgeMs, r as WhatsAppAuthUnstableError, v as readWebSelfIdentityForDecision, w as getPrimaryIdentityId } from "./auth-store-BBonwKks.mjs";
+import { n as resolveWhatsAppGroupsConfigPath } from "./group-config-path-DZr3ucUO.mjs";
+import { a as DEFAULT_RECONNECT_POLICY, c as resolveHeartbeatSeconds, f as createWhatsAppSocketOperationTimeoutAdapter, g as withWhatsAppSocketOperationTimeout, h as resolveWhatsAppSocketTiming, i as waitForWaConnection, l as resolveReconnectPolicy, m as resolveWhatsAppSocketOperationTimeoutMs, o as computeBackoff, p as isWhatsAppSocketOperationTimeoutError, r as createWaSocket, s as newConnectionId, u as sleepWithAbort } from "./socket-close-CT__V2fz.mjs";
+import { n as getStatusCode, t as formatError } from "./session-errors-B8UcAnZN.mjs";
+import { t as BufferJSON } from "./session.runtime-st1konFI.mjs";
+import { _ as resolveInboundMediaMimetype, a as addWhatsAppImagePreviewFields, c as extractContextInfo, d as extractMediaKind, f as extractMentionedJids, g as projectWhatsAppInboundMessage, h as hasInboundUserContent, i as resolveWhatsAppOutboundMentions, l as extractExternalAdReplyContext, n as addWhatsAppOutboundMentionsToContent, o as describeReplyContext, p as extractText, r as mayContainWhatsAppOutboundMention, s as extractContactContext, t as createWebSendApi, u as extractLocationData } from "./send-api-H4AkQJjT.mjs";
+import { n as WHATSAPP_WATCHDOG_TIMEOUT_ERROR, r as WhatsAppConnectionController } from "./connection-controller-CHo1oRJA.mjs";
+import { n as maybeResolveWhatsAppApprovalReaction } from "./approval-reactions-DiOFvb1s.mjs";
+import { t as maybeResolveWhatsAppQuestionReaction } from "./question-reactions-CPyyi5AY.mjs";
 import { normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { createAckReactionHandle, createStatusReactionController, logAckFailure, removeAckReactionHandleAfterReply, shouldAckReaction } from "openclaw/plugin-sdk/channel-feedback";
 import { bindIngressLifecycleToReplyOptions, createChannelIngressMonitor, createChannelMessageReplyPipeline, createMessageReceiptFromOutboundResults, listMessageReceiptPlatformIds, resolveChannelMessageSourceReplyDeliveryMode, resolveChannelStreamingBlockEnabled } from "openclaw/plugin-sdk/channel-outbound";
@@ -28,7 +27,7 @@ import { recordChannelActivity } from "openclaw/plugin-sdk/channel-activity-runt
 import { buildChannelInboundEventContext, createChannelPartialDeliveryError, filterChannelInboundQuoteContext, formatInboundEnvelope, formatInboundEnvelope as formatInboundEnvelope$1, formatInboundMediaUnavailableText, formatLocationText, formatMediaPlaceholderText, hasVisibleInboundReplyDispatch, isChannelPartialDeliveryError, readAgentRunTerminalOutcome, resolveGroupThreadConfig, resolveInboundSessionEnvelopeContext, resolveInboundSupplementalSenderAllowed, runChannelInboundEvent, runGroupThread, shouldDebounceTextInbound, toInboundMediaFactsWithMetadata, toLocationContext } from "openclaw/plugin-sdk/channel-inbound";
 import { getAgentScopedMediaLocalRoots } from "openclaw/plugin-sdk/media-runtime";
 import { isReasoningReplyPayload, resolveSendableOutboundReplyParts, resolveTextChunksWithFallback, sendMediaWithLeadingCaption } from "openclaw/plugin-sdk/reply-payload";
-import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
+import { normalizeE164, normalizeE164 as normalizeE164$1, normalizeE164 as normalizeE164$2, truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 import { DisconnectReason, downloadMediaMessage, isHostedLidUser, isHostedPnUser, isJidGroup, isJidGroup as isJidGroup$1, jidDecode, jidEncode, jidNormalizedUser, normalizeMessageContent as normalizeMessageContent$1 } from "baileys";
 import { DEFAULT_ACCOUNT_ID, DEFAULT_MAIN_KEY, buildAgentMainSessionKey, buildAgentSessionKey, buildGroupHistoryKey, deriveLastRoutePolicy, normalizeAccountId, resolveAgentRoute, resolveInboundLastRouteSessionKey } from "openclaw/plugin-sdk/routing";
@@ -36,13 +35,15 @@ import { asDateTimestampMs, parseStrictFiniteNumber, resolveExpiresAtMsFromDurat
 import { filterSupplementalContextItems, resolvePinnedMainDmOwnerFromAllowlist } from "openclaw/plugin-sdk/security-runtime";
 import { resolveChannelGroupPolicy, resolveChannelGroupRequireMention } from "openclaw/plugin-sdk/channel-policy";
 import { createChannelPairingChallengeIssuer } from "openclaw/plugin-sdk/channel-pairing";
+import { createDeferred } from "openclaw/plugin-sdk/extension-shared";
 import { createHash } from "node:crypto";
-import { resolveDefaultGroupPolicy, warnMissingProviderGroupPolicyFallbackOnce } from "openclaw/plugin-sdk/runtime-group-policy";
+import { resolveDefaultGroupPolicy, resolveOpenProviderRuntimeGroupPolicy, warnMissingProviderGroupPolicyFallbackOnce } from "openclaw/plugin-sdk/runtime-group-policy";
 import { resolveChunkMode, resolveTextChunkLimit } from "openclaw/plugin-sdk/reply-runtime";
 import { CHANNEL_APPROVAL_NATIVE_RUNTIME_CONTEXT_CAPABILITY } from "openclaw/plugin-sdk/approval-handler-runtime";
 import { drainPendingDeliveries } from "openclaw/plugin-sdk/delivery-queue-runtime";
 import { enqueueSystemEvent } from "openclaw/plugin-sdk/system-event-runtime";
 import { getSessionEntry, patchSessionEntry, resolveGroupSessionKey, resolveStorePath, resolveStorePath as resolveStorePath$1, updateLastRoute } from "openclaw/plugin-sdk/session-store-runtime";
+import { pruneMapToMaxSize } from "openclaw/plugin-sdk/collection-runtime";
 import { createInboundDebouncer, resolveInboundDebounceMs } from "openclaw/plugin-sdk/channel-inbound-debounce";
 import { fanInChannelIngressLifecycles } from "openclaw/plugin-sdk/channel-ingress-runtime";
 import { saveMediaStream } from "openclaw/plugin-sdk/media-store";
@@ -50,7 +51,6 @@ import { upsertChannelPairingRequest } from "openclaw/plugin-sdk/conversation-ru
 import { createDedupeCache } from "openclaw/plugin-sdk/dedupe-runtime";
 import { getRuntimeConfig as getRuntimeConfig$1 } from "openclaw/plugin-sdk/runtime-config-snapshot";
 import { resolveChannelContextVisibilityMode } from "openclaw/plugin-sdk/context-visibility-runtime";
-import { buildMentionRegexes, implicitMentionKindWhen, normalizeMentionText, resolveInboundMentionDecision } from "openclaw/plugin-sdk/channel-mention-gating";
 import { channelReadyPatch, channelStoppedPatch, createTransportActivityStatusPatch } from "openclaw/plugin-sdk/gateway-runtime";
 import { ensureConfiguredBindingRouteReady, resolveConfiguredBindingRoute } from "openclaw/plugin-sdk/conversation-binding-runtime";
 import { resolveAgentIdentity, resolveIdentityNamePrefix } from "openclaw/plugin-sdk/agent-runtime";
@@ -142,12 +142,6 @@ function normalizeWhatsAppIngressPhone(value) {
 	if (!trimmed) return null;
 	return normalizeE164(trimmed);
 }
-function buildResolvedWhatsAppGroupConfig(params) {
-	return { channels: { whatsapp: {
-		groupPolicy: params.groupPolicy,
-		groups: params.groups
-	} } };
-}
 function resolveWhatsAppInboundPolicy(params) {
 	const account = resolveWhatsAppAccount({
 		cfg: params.cfg,
@@ -158,15 +152,15 @@ function resolveWhatsAppInboundPolicy(params) {
 	const dmAllowFrom = configuredAllowFrom.length > 0 ? configuredAllowFrom : params.selfE164 ? [params.selfE164] : [];
 	const groupAllowFrom = (Array.isArray(account.groupAllowFrom) && account.groupAllowFrom.length > 0 ? account.groupAllowFrom : void 0) ?? (configuredAllowFrom.length > 0 ? configuredAllowFrom : void 0) ?? [];
 	const defaultGroupPolicy = resolveDefaultGroupPolicy(params.cfg);
-	const { groupPolicy, providerMissingFallbackApplied } = resolveWhatsAppRuntimeGroupPolicy({
+	const { groupPolicy, providerMissingFallbackApplied } = resolveOpenProviderRuntimeGroupPolicy({
 		providerConfigPresent: params.cfg.channels?.whatsapp !== void 0,
 		groupPolicy: account.groupPolicy,
 		defaultGroupPolicy
 	});
-	const resolvedGroupCfg = buildResolvedWhatsAppGroupConfig({
+	const resolvedGroupCfg = { channels: { whatsapp: {
 		groupPolicy,
 		groups: account.groups
-	});
+	} } };
 	const isSamePhone = (value) => typeof value === "string" && typeof params.selfE164 === "string" && value === params.selfE164;
 	return {
 		account,
@@ -192,7 +186,7 @@ function resolveWhatsAppInboundPolicy(params) {
 	};
 }
 async function resolveWhatsAppIngressAccess(params) {
-	return await getWhatsAppChannelRuntime().inbound.ingress.resolveStable({
+	return await getWhatsAppRuntime().channel.inbound.ingress.resolveStable({
 		channelId: "whatsapp",
 		accountId: params.policy.account.accountId,
 		identity: {
@@ -251,11 +245,7 @@ function rememberWhatsAppBaileysCacheEntry(cache, key, value, ttlMs) {
 		expiresAt: Date.now() + ttlMs,
 		value
 	});
-	while (cache.size > WHATSAPP_BAILEYS_CACHE_MAX_ENTRIES) {
-		const oldest = cache.keys().next();
-		if (oldest.done) break;
-		cache.delete(oldest.value);
-	}
+	pruneMapToMaxSize(cache, WHATSAPP_BAILEYS_CACHE_MAX_ENTRIES);
 }
 function readWhatsAppBaileysCacheEntry(cache, key) {
 	const entry = cache.get(key);
@@ -269,117 +259,6 @@ function readWhatsAppBaileysCacheEntry(cache, key) {
 	return entry.value;
 }
 //#endregion
-//#region extensions/whatsapp/src/inbound/durable-payload.ts
-var WhatsAppIngressPermanentError = class extends Error {
-	constructor(reason, message, options) {
-		super(message, options);
-		this.reason = reason;
-		this.name = "WhatsAppIngressPermanentError";
-	}
-};
-function serializeWhatsAppDurableInboundMessage(message) {
-	const timestamp = message.messageTimestamp;
-	let serializedMessage = message;
-	if (timestamp != null && typeof timestamp === "object") try {
-		const numericTimestamp = Number(timestamp);
-		if (Number.isFinite(numericTimestamp)) serializedMessage = {
-			...message,
-			messageTimestamp: numericTimestamp
-		};
-	} catch {}
-	return JSON.parse(JSON.stringify(serializedMessage, BufferJSON.replacer));
-}
-function deserializeWhatsAppDurableInboundMessage(message) {
-	try {
-		return JSON.parse(JSON.stringify(message), BufferJSON.reviver);
-	} catch (error) {
-		throw new WhatsAppIngressPermanentError("invalid-payload", "WhatsApp ingress row contains an invalid serialized message", { cause: error });
-	}
-}
-//#endregion
-//#region extensions/whatsapp/src/inbound/durable-receive.ts
-const WHATSAPP_DURABLE_INBOUND_PAYLOAD_VERSION = 1;
-function hashNamespacePart(value) {
-	return createHash("sha256").update(value).digest("hex").slice(0, 24);
-}
-function createWhatsAppDurableInboundMessageId(params) {
-	return createHash("sha256").update(`${params.remoteJid}\n${params.id}`).digest("hex");
-}
-function inspectWhatsAppIngressMessage(message) {
-	const remoteJid = message.key?.remoteJid?.trim();
-	const id = message.key?.id?.trim();
-	if (!remoteJid || !id) throw new WhatsAppIngressPermanentError("missing-message-key", "WhatsApp ingress message is missing key.remoteJid or key.id");
-	return {
-		eventId: createWhatsAppDurableInboundMessageId({
-			remoteJid,
-			id
-		}),
-		laneKey: remoteJid
-	};
-}
-/** Account-scoped queue shared with the pre-drain WhatsApp receive journal. */
-function createWhatsAppDurableInboundQueue(accountId) {
-	return getWhatsAppRuntime().state.openChannelIngressQueue({
-		accountId: hashNamespacePart(accountId),
-		stateDir: getWhatsAppRuntime().state.resolveStateDir()
-	});
-}
-function resolveWhatsAppIngressNonRetryableFailure(error) {
-	return error instanceof WhatsAppIngressPermanentError ? {
-		reason: error.reason,
-		message: error.message
-	} : null;
-}
-/** Shared monitor with per-conversation lanes and completion at reply-lane adoption. */
-function createWhatsAppIngressMonitor(params) {
-	return createChannelIngressMonitor({
-		queue: params.queue,
-		inspect: (admission) => inspectWhatsAppIngressMessage(admission.message),
-		payload: {
-			version: WHATSAPP_DURABLE_INBOUND_PAYLOAD_VERSION,
-			serialize: (admission, { receivedAt }) => ({
-				...admission,
-				message: serializeWhatsAppDurableInboundMessage(admission.message),
-				receivedAt
-			}),
-			deserialize: (payload) => ({
-				...payload,
-				message: deserializeWhatsAppDurableInboundMessage(payload.message)
-			}),
-			encode: ({ body }) => body,
-			decode: (payload) => ({
-				version: WHATSAPP_DURABLE_INBOUND_PAYLOAD_VERSION,
-				body: payload
-			}),
-			createClaimError: (kind) => new WhatsAppIngressPermanentError(kind === "invalid-version" ? "invalid-payload" : "event-id-mismatch", kind === "invalid-version" ? "WhatsApp ingress row has an invalid payload version" : "WhatsApp ingress row identity does not match its transport message key")
-		},
-		deliver: (admission, lifecycle) => params.dispatch(admission, lifecycle),
-		pollIntervalMs: params.pollIntervalMs,
-		retention: {
-			completedTtlMs: 6048e5,
-			completedMaxEntries: 5e3,
-			failedMaxEntries: 450
-		},
-		drain: {
-			deferredLaneOccupancy: "release",
-			resolveNonRetryableFailure: resolveWhatsAppIngressNonRetryableFailure,
-			deriveLaneKey: (record) => {
-				try {
-					return inspectWhatsAppIngressMessage(deserializeWhatsAppDurableInboundMessage(record.payload.message)).laneKey;
-				} catch {
-					return record.id;
-				}
-			},
-			...params.onLog ? { onLog: params.onLog } : {}
-		},
-		...params.abortSignal ? { abortSignal: params.abortSignal } : {},
-		admissionMode: "while-running",
-		createStoppedError: () => /* @__PURE__ */ new Error("WhatsApp ingress monitor is stopped."),
-		...params.onError ? { onError: params.onError } : {},
-		...params.onActivityChange ? { onActivityChange: params.onActivityChange } : {}
-	});
-}
-//#endregion
 //#region extensions/whatsapp/src/inbound/group-metadata-cache.ts
 const GROUP_META_TTL_MS = 3e5;
 const WHATSAPP_GROUP_METADATA_CACHE_MAX_ENTRIES = 500;
@@ -394,11 +273,7 @@ function rememberGroupMetadataCacheEntry(cache, jid, entry) {
 	}
 	if (cache.has(jid)) cache.delete(jid);
 	cache.set(jid, entry);
-	while (cache.size > WHATSAPP_GROUP_METADATA_CACHE_MAX_ENTRIES) {
-		const oldest = cache.keys().next();
-		if (oldest.done) break;
-		cache.delete(oldest.value);
-	}
+	pruneMapToMaxSize(cache, WHATSAPP_GROUP_METADATA_CACHE_MAX_ENTRIES);
 }
 function readGroupMetadataCacheEntry(cache, jid) {
 	const entry = cache.get(jid);
@@ -588,6 +463,117 @@ function closeInboundMonitorSocket(sock) {
 	sock.ws?.close?.();
 }
 //#endregion
+//#region extensions/whatsapp/src/inbound/durable-payload.ts
+var WhatsAppIngressPermanentError = class extends Error {
+	constructor(reason, message, options) {
+		super(message, options);
+		this.reason = reason;
+		this.name = "WhatsAppIngressPermanentError";
+	}
+};
+function serializeWhatsAppDurableInboundMessage(message) {
+	const timestamp = message.messageTimestamp;
+	let serializedMessage = message;
+	if (timestamp != null && typeof timestamp === "object") try {
+		const numericTimestamp = Number(timestamp);
+		if (Number.isFinite(numericTimestamp)) serializedMessage = {
+			...message,
+			messageTimestamp: numericTimestamp
+		};
+	} catch {}
+	return JSON.parse(JSON.stringify(serializedMessage, BufferJSON.replacer));
+}
+function deserializeWhatsAppDurableInboundMessage(message) {
+	try {
+		return JSON.parse(JSON.stringify(message), BufferJSON.reviver);
+	} catch (error) {
+		throw new WhatsAppIngressPermanentError("invalid-payload", "WhatsApp ingress row contains an invalid serialized message", { cause: error });
+	}
+}
+//#endregion
+//#region extensions/whatsapp/src/inbound/durable-receive.ts
+const WHATSAPP_DURABLE_INBOUND_PAYLOAD_VERSION = 1;
+function hashNamespacePart(value) {
+	return createHash("sha256").update(value).digest("hex").slice(0, 24);
+}
+function createWhatsAppDurableInboundMessageId(params) {
+	return createHash("sha256").update(`${params.remoteJid}\n${params.id}`).digest("hex");
+}
+function inspectWhatsAppIngressMessage(message) {
+	const remoteJid = message.key?.remoteJid?.trim();
+	const id = message.key?.id?.trim();
+	if (!remoteJid || !id) throw new WhatsAppIngressPermanentError("missing-message-key", "WhatsApp ingress message is missing key.remoteJid or key.id");
+	return {
+		eventId: createWhatsAppDurableInboundMessageId({
+			remoteJid,
+			id
+		}),
+		laneKey: remoteJid
+	};
+}
+/** Account-scoped queue shared with the pre-drain WhatsApp receive journal. */
+function createWhatsAppDurableInboundQueue(accountId) {
+	return getWhatsAppRuntime().state.openChannelIngressQueue({
+		accountId: hashNamespacePart(accountId),
+		stateDir: getWhatsAppRuntime().state.resolveStateDir()
+	});
+}
+function resolveWhatsAppIngressNonRetryableFailure(error) {
+	return error instanceof WhatsAppIngressPermanentError ? {
+		reason: error.reason,
+		message: error.message
+	} : null;
+}
+/** Shared monitor with per-conversation lanes and completion at reply-lane adoption. */
+function createWhatsAppIngressMonitor(params) {
+	return createChannelIngressMonitor({
+		queue: params.queue,
+		inspect: (admission) => inspectWhatsAppIngressMessage(admission.message),
+		payload: {
+			version: WHATSAPP_DURABLE_INBOUND_PAYLOAD_VERSION,
+			serialize: (admission, { receivedAt }) => ({
+				...admission,
+				message: serializeWhatsAppDurableInboundMessage(admission.message),
+				receivedAt
+			}),
+			deserialize: (payload) => ({
+				...payload,
+				message: deserializeWhatsAppDurableInboundMessage(payload.message)
+			}),
+			encode: ({ body }) => body,
+			decode: (payload) => ({
+				version: WHATSAPP_DURABLE_INBOUND_PAYLOAD_VERSION,
+				body: payload
+			}),
+			createClaimError: (kind) => new WhatsAppIngressPermanentError(kind === "invalid-version" ? "invalid-payload" : "event-id-mismatch", kind === "invalid-version" ? "WhatsApp ingress row has an invalid payload version" : "WhatsApp ingress row identity does not match its transport message key")
+		},
+		deliver: (admission, lifecycle) => params.dispatch(admission, lifecycle),
+		pollIntervalMs: params.pollIntervalMs,
+		retention: {
+			completedTtlMs: 6048e5,
+			completedMaxEntries: 5e3,
+			failedMaxEntries: 450
+		},
+		drain: {
+			deferredLaneOccupancy: "release",
+			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) {
@@ -708,17 +694,15 @@ function createWhatsAppInboundMessageDebouncer(options) {
 			debounceMs: options.resolveDebounceMs()
 		};
 		const key = buildKey(message);
-		if (key) {
-			message.debounceKey = key;
-			const senderKey = resolveSenderKey(message);
-			const pending = pendingKeys.get(key);
-			if (pending && pending.senderKey !== senderKey) await debouncer.flushKey(key);
-			if (message.debounceMs > 0 && shouldDebounce(message)) {
-				message.debounceKeyTracked = true;
-				trackKey(key, senderKey);
-				options.onPendingWorkChanged();
-				notifyWork();
-			}
+		message.debounceKey = key;
+		const senderKey = resolveSenderKey(message);
+		const pending = pendingKeys.get(key);
+		if (pending && pending.senderKey !== senderKey) await debouncer.flushKey(key);
+		if (message.debounceMs > 0 && shouldDebounce(message)) {
+			message.debounceKeyTracked = true;
+			trackKey(key, senderKey);
+			options.onPendingWorkChanged();
+			notifyWork();
 		}
 		await debouncer.enqueue(message);
 	};
@@ -753,11 +737,8 @@ function createWhatsAppInboundMessageDebouncer(options) {
 }
 //#endregion
 //#region extensions/whatsapp/src/inbound/media.ts
-function unwrapMessage(message) {
-	return normalizeMessageContent$1(message);
-}
 async function downloadInboundMedia(msg, sock, maxBytes = 52428800, normalizedMessage) {
-	const message = normalizedMessage ?? unwrapMessage(msg.message);
+	const message = normalizedMessage ?? normalizeMessageContent$1(msg.message);
 	if (!message) return;
 	const mimetype = resolveInboundMediaMimetype(message);
 	const fileName = message.documentMessage?.fileName ?? void 0;
@@ -773,7 +754,7 @@ async function downloadInboundMedia(msg, sock, maxBytes = 52428800, normalizedMe
 	};
 }
 async function downloadQuotedInboundMedia(msg, sock, maxBytes = 52428800) {
-	const message = unwrapMessage(msg.message);
+	const message = normalizeMessageContent$1(msg.message);
 	const contextInfo = extractContextInfo(message);
 	if (!contextInfo?.quotedMessage) return;
 	const quotedMessage = contextInfo.quotedMessage;
@@ -1180,12 +1161,9 @@ function createWhatsAppMessageDeliveryCoordinator(options) {
 			logWhatsAppVerbose$1(options.verbose, `Failed to mark message ${id} read: ${String(err)}`);
 		}
 	};
-	const maybeLogSkippedSelfChatReadReceipt = (inbound, target) => {
-		if (target?.id && inbound.access.isSelfChat && options.verbose) logWhatsAppVerbose$1(options.verbose, `Self-chat mode: skipping read receipt for ${target.id}`);
-	};
 	const maybeMarkNonSelfChatReadReceipt = async (inbound, target) => {
 		if (inbound.access.isSelfChat) {
-			maybeLogSkippedSelfChatReadReceipt(inbound, target);
+			if (target?.id) logWhatsAppVerbose$1(options.verbose, `Self-chat mode: skipping read receipt for ${target.id}`);
 			return;
 		}
 		await maybeMarkInboundAsRead(target);
@@ -1261,25 +1239,27 @@ function createWhatsAppMessageDeliveryCoordinator(options) {
 			mentions: groupMentions
 		} : void 0;
 		const channelStructuredContext = [
-			...enriched.nativeMedia ? [{
-				label: "WhatsApp media",
-				source: "whatsapp",
-				type: "media",
-				payload: enriched.nativeMedia
-			}] : [],
-			...enriched.contactContext ? [{
-				label: "WhatsApp contact",
-				source: "whatsapp",
-				type: enriched.contactContext.kind,
-				payload: enriched.contactContext
-			}] : [],
-			...enriched.externalAdReplyContext ? [{
-				label: "WhatsApp external ad reply",
-				source: "whatsapp",
-				type: "external_ad_reply",
-				payload: enriched.externalAdReplyContext
-			}] : []
-		];
+			[
+				"WhatsApp media",
+				"media",
+				enriched.nativeMedia
+			],
+			[
+				"WhatsApp contact",
+				enriched.contactContext?.kind,
+				enriched.contactContext
+			],
+			[
+				"WhatsApp external ad reply",
+				"external_ad_reply",
+				enriched.externalAdReplyContext
+			]
+		].flatMap(([label, type, payload]) => payload ? [{
+			label,
+			source: "whatsapp",
+			type,
+			payload
+		}] : []);
 		const inboundMessage = {
 			admission: inbound.access.admission,
 			event: {
@@ -1342,25 +1322,29 @@ function createWhatsAppMessageDeliveryCoordinator(options) {
 		}
 		await messageDebouncer.enqueue(inboundMessage);
 	};
+	const resolveApprovalReaction = (msg) => maybeResolveWhatsAppApprovalReaction({
+		cfg: options.loadConfig?.() ?? options.cfg,
+		accountId: options.accountId,
+		msg,
+		selfJid: self.jid,
+		selfLid: self.lid,
+		resolveInboundJid,
+		resolveReactionTargetJids,
+		logVerboseMessage: (message) => logWhatsAppVerbose$1(options.verbose, message)
+	});
 	const processDurableInboundMessage = async (admission, lifecycle) => {
 		const { message: msg, ...context } = admission;
 		rememberBaileysMessage(msg.key?.remoteJid, msg.key?.id, msg.message);
 		const remoteJid = msg.key?.remoteJid;
 		const id = msg.key?.id;
-		const durableId = remoteJid && id ? createHash("sha256").update(`${remoteJid}\n${id}`).digest("hex") : void 0;
+		const durableId = remoteJid && id ? createWhatsAppDurableInboundMessageId({
+			remoteJid,
+			id
+		}) : void 0;
 		const preparation = durableId ? preparedInboundByDurableId.get(durableId) : void 0;
 		if (durableId) preparedInboundByDurableId.delete(durableId);
 		if (context.skipRecentOutboundEcho === true) return "completed";
-		if (await maybeResolveWhatsAppApprovalReaction({
-			cfg: options.loadConfig?.() ?? options.cfg,
-			accountId: options.accountId,
-			msg,
-			selfJid: self.jid,
-			selfLid: self.lid,
-			resolveInboundJid,
-			resolveReactionTargetJids,
-			logVerboseMessage: (message) => logWhatsAppVerbose$1(options.verbose, message)
-		})) return "completed";
+		if (await resolveApprovalReaction(msg)) return "completed";
 		const prepared = await preparation;
 		if (prepared === null) return "completed";
 		const inbound = prepared ?? await normalizeInboundMessage(msg);
@@ -1415,16 +1399,7 @@ function createWhatsAppMessageDeliveryCoordinator(options) {
 			const receiveOrder = nextReceiveOrder++;
 			let approvalReactionResolved = false;
 			try {
-				approvalReactionResolved = await maybeResolveWhatsAppApprovalReaction({
-					cfg: options.loadConfig?.() ?? options.cfg,
-					accountId: options.accountId,
-					msg,
-					selfJid: self.jid,
-					selfLid: self.lid,
-					resolveInboundJid,
-					resolveReactionTargetJids,
-					logVerboseMessage: (message) => logWhatsAppVerbose$1(options.verbose, message)
-				});
+				approvalReactionResolved = await resolveApprovalReaction(msg);
 			} catch (error) {
 				inboundLogger.warn({ error: formatError(error) }, "whatsapp approval reaction resolution failed; admitting reaction for durable replay");
 			}
@@ -1434,16 +1409,19 @@ function createWhatsAppMessageDeliveryCoordinator(options) {
 			const skipRecentOutboundEcho = shouldSkipRecentOutboundEcho(msg);
 			const remoteJid = msg.key?.remoteJid;
 			const id = msg.key?.id;
-			const durableId = remoteJid && id ? createHash("sha256").update(`${remoteJid}\n${id}`).digest("hex") : void 0;
+			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 prepared = createDeferred();
+				resolvePrepared = prepared.resolve;
+				preparedInboundByDurableId.set(durableId, prepared.promise);
 			}
 			const finishPreparation = (inbound, keepForDrain = false) => {
 				resolvePrepared?.(inbound);
@@ -1493,22 +1471,19 @@ function createWhatsAppMessageDeliveryCoordinator(options) {
 			publishPendingWorkState();
 		});
 	};
-	const drainDebouncedInboundMessages = async () => {
-		await messageDebouncer.drain();
-	};
 	const drainInboundBeforeSocketClose = async () => {
 		for (;;) {
-			await drainDebouncedInboundMessages();
+			await messageDebouncer.drain();
 			if (pendingMessageHandlers.size === 0) break;
 			const handlers = Array.from(pendingMessageHandlers);
 			await Promise.race([Promise.allSettled(handlers), messageDebouncer.waitForWorkOrIdle(handlers, pendingMessageHandlers.size === 0)]);
 			if (pendingMessageHandlers.size === 0 && !messageDebouncer.hasPendingWork()) break;
 		}
-		await drainDebouncedInboundMessages();
+		await messageDebouncer.drain();
 		for (;;) {
 			await durableInboundMonitor.waitForIdle();
 			if (!messageDebouncer.hasPendingWork()) break;
-			await drainDebouncedInboundMessages();
+			await messageDebouncer.drain();
 		}
 		await durableInboundMonitor.stop();
 	};
@@ -1574,16 +1549,7 @@ async function createWhatsAppAttachedSocketSession(options) {
 	const disconnectRetryPolicy = options.disconnectRetryPolicy ?? DEFAULT_RECONNECT_POLICY;
 	const sendRetryMaxAttempts = disconnectRetryPolicy.maxAttempts > 0 ? disconnectRetryPolicy.maxAttempts : DEFAULT_RECONNECT_POLICY.maxAttempts;
 	const sendOperationTimeoutMs = resolveWhatsAppSocketOperationTimeoutMs(options.socketTiming.defaultQueryTimeoutMs);
-	let onCloseResolve = null;
-	const onClose = new Promise((resolve) => {
-		onCloseResolve = resolve;
-	});
-	const resolveClose = (reason) => {
-		if (!onCloseResolve) return;
-		const resolver = onCloseResolve;
-		onCloseResolve = null;
-		resolver(reason);
-	};
+	const { promise: onClose, resolve: resolveClose } = createDeferred();
 	const presence = options.selfChatMode ? "unavailable" : "available";
 	try {
 		await createWhatsAppSocketOperationTimeoutAdapter(sock, sendOperationTimeoutMs).sendPresenceUpdate(presence);
@@ -1618,14 +1584,14 @@ async function createWhatsAppAttachedSocketSession(options) {
 		rememberWhatsAppBaileysCacheEntry(options.recentMessageKeys, `${remoteJid}:${messageId}`, message, BAILEYS_MESSAGE_TTL_MS);
 	};
 	const rememberOutboundMessage = (remoteJid, result) => {
-		const messageId = typeof result === "object" && result && "key" in result ? result.key?.id ?? "" : "";
+		const messageId = result?.key?.id;
 		if (!messageId) return;
 		rememberRecentOutboundMessage({
 			accountId: options.accountId,
 			remoteJid,
 			messageId
 		});
-		const message = typeof result === "object" && result && "message" in result ? result.message : void 0;
+		const message = result?.message;
 		rememberBaileysMessage(remoteJid, messageId, message);
 		cacheInboundMessageMeta(options.accountId, remoteJid, messageId, {
 			fromMe: true,
@@ -1715,7 +1681,7 @@ async function createWhatsAppAttachedSocketSession(options) {
 		}
 	};
 	const socketOperations = {
-		sendMessage: (jid, content, sendOptions) => sendTrackedMessage(jid, content, sendOptions),
+		sendMessage: sendTrackedMessage,
 		sendPresenceUpdate: async (presenceLocal, jid) => {
 			const currentSock = getCurrentSock();
 			if (!currentSock) throw new Error(RECONNECT_IN_PROGRESS_ERROR);
@@ -1846,7 +1812,7 @@ async function attachWebInboxToSocket(options) {
 		appendReplyWindow: options.appendReplyWindow,
 		shouldDebounce: options.shouldDebounce,
 		onPendingWorkChanged: options.onPendingWorkChanged,
-		durableInboundQueue: options.durableInboundQueue ?? createWhatsAppDurableInboundQueue(options.accountId)
+		durableInboundQueue: options.durableInboundQueue
 	});
 	const sendApi = createWebSendApi({
 		sock: socketSession.socketOperations,
@@ -1913,64 +1879,6 @@ const whatsappInboundLog = whatsappLog.child("inbound");
 const whatsappOutboundLog = whatsappLog.child("outbound");
 const whatsappHeartbeatLog = whatsappLog.child("heartbeat");
 //#endregion
-//#region extensions/whatsapp/src/auto-reply/mentions.ts
-function buildMentionConfig(cfg, agentId, options) {
-	return {
-		mentionRegexes: buildMentionRegexes(cfg, agentId, options),
-		allowFrom: cfg.channels?.whatsapp?.allowFrom
-	};
-}
-function resolveMentionTargets(msg, authDir) {
-	return {
-		normalizedMentions: getMentionIdentities(msg, authDir),
-		self: getSelfIdentity(msg, authDir)
-	};
-}
-function isBotMentionedFromTargets(msg, mentionCfg, targets) {
-	const clean = (text) => normalizeMentionText(text);
-	const explicitSelfChatOverride = typeof mentionCfg.isSelfChat === "boolean";
-	const isGroupConversation = requireWhatsAppInboundAdmission(msg).conversation.kind === "group";
-	const isSelfChat = explicitSelfChatOverride ? Boolean(mentionCfg.isSelfChat) : isSelfChatMode(targets.self.e164, mentionCfg.allowFrom) && !isGroupConversation;
-	const hasMentions = targets.normalizedMentions.length > 0;
-	const hasNativeMentionsOutsideSelfChat = hasMentions && !isSelfChat;
-	if (hasNativeMentionsOutsideSelfChat) {
-		for (const mention of targets.normalizedMentions) if (identitiesOverlap(targets.self, mention)) return true;
-	} 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) {
-			if (bodyClean.replace(/[^\d]/g, "").includes(selfDigits)) return true;
-			const bodyNoSpace = msg.payload.body.replace(/[\s-]/g, "");
-			if (new RegExp(`\\+?${selfDigits}`, "i").test(bodyNoSpace)) return true;
-		}
-	}
-	return false;
-}
-function debugMention(msg, mentionCfg, authDir) {
-	const mentionTargets = resolveMentionTargets(msg, authDir);
-	return {
-		wasMentioned: isBotMentionedFromTargets(msg, mentionCfg, mentionTargets),
-		details: {
-			from: requireWhatsAppInboundAdmission(msg).conversation.id,
-			body: msg.payload.body,
-			bodyClean: normalizeMentionText(msg.payload.body),
-			mentionedJids: msg.group?.mentions?.jids ?? null,
-			normalizedMentionedJids: mentionTargets.normalizedMentions.length ? mentionTargets.normalizedMentions.map((identity) => getComparableIdentityValues(identity)) : null,
-			selfJid: msg.platform.self?.jid ?? msg.platform.selfJid ?? null,
-			selfLid: msg.platform.self?.lid ?? msg.platform.selfLid ?? null,
-			selfE164: msg.platform.self?.e164 ?? msg.platform.selfE164 ?? null,
-			resolvedSelf: mentionTargets.self
-		}
-	};
-}
-function resolveOwnerList(mentionCfg, selfE164) {
-	const allowFrom = mentionCfg.allowFrom;
-	return (Array.isArray(allowFrom) && allowFrom.length > 0 ? allowFrom : selfE164 ? [selfE164] : []).filter((entry) => Boolean(entry && entry !== "*")).map((entry) => normalizeE164(entry)).filter((entry) => Boolean(entry));
-}
-//#endregion
 //#region extensions/whatsapp/src/auto-reply/monitor-state.ts
 const LIFECYCLE_BY_HEALTH_STATE = {
 	starting: "starting",
@@ -2112,6 +2020,76 @@ function formatWhatsAppInboundListeningLog(account) {
 	return `Listening for WhatsApp inbound messages (DM + ${explicitGroupCount} configured ${explicitGroupCount === 1 ? "group" : "groups"}).`;
 }
 //#endregion
+//#region src/channels/mention-gating.ts
+function resolveBotThreadMentionPolicy(params) {
+	if (!params.isBotOwnedThread || params.requireMentionInBotThreads === void 0) return {
+		requireMention: params.requireMention,
+		implicitMentionKinds: params.implicitMentionKinds
+	};
+	return {
+		requireMention: params.requireMentionInBotThreads,
+		implicitMentionKinds: params.requireMentionInBotThreads ? params.implicitMentionKinds?.filter((kind) => kind === "native") : params.implicitMentionKinds
+	};
+}
+//#endregion
+//#region \0openclaw:bundled-sdk:openclaw/plugin-sdk/channel-mention-gating
+var channel_mention_gating_exports = /* @__PURE__ */ __exportAll({ resolveBotThreadMentionPolicy: () => resolveBotThreadMentionPolicy });
+import * as import_openclaw_plugin_sdk_channel_mention_gating from "openclaw/plugin-sdk/channel-mention-gating";
+__reExport(channel_mention_gating_exports, import_openclaw_plugin_sdk_channel_mention_gating);
+//#endregion
+//#region extensions/whatsapp/src/auto-reply/mentions.ts
+function buildMentionConfig(cfg, agentId, options) {
+	return {
+		mentionRegexes: (0, channel_mention_gating_exports.buildMentionRegexes)(cfg, agentId, options),
+		allowFrom: cfg.channels?.whatsapp?.allowFrom
+	};
+}
+function isBotMentionedFromTargets(msg, mentionCfg, targets) {
+	const explicitSelfChatOverride = typeof mentionCfg.isSelfChat === "boolean";
+	const isGroupConversation = requireWhatsAppInboundAdmission(msg).conversation.kind === "group";
+	const isSelfChat = explicitSelfChatOverride ? Boolean(mentionCfg.isSelfChat) : isSelfChatMode(targets.self.e164, mentionCfg.allowFrom) && !isGroupConversation;
+	const hasNativeMentionsOutsideSelfChat = targets.normalizedMentions.length > 0 && !isSelfChat;
+	if (hasNativeMentionsOutsideSelfChat) {
+		for (const mention of targets.normalizedMentions) if (identitiesOverlap(targets.self, mention)) return true;
+	}
+	const bodyClean = (0, channel_mention_gating_exports.normalizeMentionText)(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) {
+			if (bodyClean.replace(/[^\d]/g, "").includes(selfDigits)) return true;
+			const bodyNoSpace = msg.payload.body.replace(/[\s-]/g, "");
+			if (new RegExp(`\\+?${selfDigits}`, "i").test(bodyNoSpace)) return true;
+		}
+	}
+	return false;
+}
+function debugMention(msg, mentionCfg, authDir) {
+	const mentionTargets = {
+		normalizedMentions: getMentionIdentities(msg, authDir),
+		self: getSelfIdentity(msg, authDir)
+	};
+	return {
+		wasMentioned: isBotMentionedFromTargets(msg, mentionCfg, mentionTargets),
+		details: {
+			from: requireWhatsAppInboundAdmission(msg).conversation.id,
+			body: msg.payload.body,
+			bodyClean: (0, channel_mention_gating_exports.normalizeMentionText)(msg.payload.body),
+			mentionedJids: msg.group?.mentions?.jids ?? null,
+			normalizedMentionedJids: mentionTargets.normalizedMentions.length ? mentionTargets.normalizedMentions.map((identity) => getComparableIdentityValues(identity)) : null,
+			selfJid: msg.platform.self?.jid ?? msg.platform.selfJid ?? null,
+			selfLid: msg.platform.self?.lid ?? msg.platform.selfLid ?? null,
+			selfE164: msg.platform.self?.e164 ?? msg.platform.selfE164 ?? null,
+			resolvedSelf: mentionTargets.self
+		}
+	};
+}
+function resolveOwnerList(mentionCfg, selfE164) {
+	const allowFrom = mentionCfg.allowFrom;
+	return (Array.isArray(allowFrom) && allowFrom.length > 0 ? allowFrom : selfE164 ? [selfE164] : []).filter((entry) => Boolean(entry && entry !== "*")).map((entry) => normalizeE164(entry)).filter((entry) => Boolean(entry));
+}
+//#endregion
 //#region extensions/whatsapp/src/auto-reply/monitor/ack-emoji.ts
 const DEFAULT_WHATSAPP_ACK_REACTION = "👀";
 function resolveWhatsAppAckEmoji(params) {
@@ -2228,13 +2206,7 @@ async function resolveWhatsAppReactionEligibility(params) {
 //#endregion
 //#region extensions/whatsapp/src/auto-reply/monitor/ack-reaction.ts
 async function maybeSendAckReaction(params) {
-	const eligibility = await resolveWhatsAppReactionEligibility({
-		cfg: params.cfg,
-		msg: params.msg,
-		agentId: params.agentId,
-		sessionKey: params.sessionKey,
-		verbose: params.verbose
-	});
+	const eligibility = await resolveWhatsAppReactionEligibility(params);
 	if (eligibility.status === "disabled") return null;
 	const { chatId, messageId, emoji, reactionOptions } = eligibility;
 	params.info({
@@ -2257,6 +2229,33 @@ async function maybeSendAckReaction(params) {
 	});
 }
 //#endregion
+//#region extensions/whatsapp/src/auto-reply/monitor/audio-preflight.ts
+function hasWhatsAppAudioBody(msg) {
+	return (msg.payload.media?.kind === "audio" || msg.payload.media?.type?.startsWith("audio/") === true) && !msg.payload.body.trim();
+}
+async function transcribeWhatsAppAudioMessage(cfg, msg, accountId) {
+	const { transcribeFirstAudio } = await import("./audio-preflight.runtime-C_glQhZY.mjs");
+	const media = msg.payload.media;
+	const conversationId = msg.admission.conversation.id;
+	return await transcribeFirstAudio({
+		ctx: {
+			media: [{
+				path: media?.path,
+				contentType: media?.type,
+				kind: media?.kind ?? void 0
+			}],
+			From: conversationId,
+			To: msg.platform.recipientJid,
+			Provider: "whatsapp",
+			Surface: "whatsapp",
+			OriginatingChannel: "whatsapp",
+			OriginatingTo: conversationId,
+			AccountId: accountId
+		},
+		cfg
+	});
+}
+//#endregion
 //#region extensions/whatsapp/src/auto-reply/monitor/broadcast.ts
 function buildBroadcastRouteKeys(params) {
 	const admission = requireWhatsAppInboundAdmission(params.msg);
@@ -2388,11 +2387,8 @@ const groupDropWarned = createDedupeCache({
 	ttlMs: 0,
 	maxSize: 100
 });
-function shouldWarnForGroupDrop(warnKey) {
-	return !groupDropWarned.check(warnKey);
-}
 function isOwnerSender(baseMentionConfig, msg, authDir) {
-	const sender = normalizeE164(getSenderIdentity(msg, authDir).e164 ?? "");
+	const sender = normalizeE164$2(getSenderIdentity(msg, authDir).e164 ?? "");
 	if (!sender) return false;
 	return resolveOwnerList(baseMentionConfig, getSelfIdentity(msg, authDir).e164 ?? void 0).includes(sender);
 }
@@ -2441,11 +2437,12 @@ async function applyGroupGating(params) {
 	const conversationGroupPolicy = inboundPolicy.resolveConversationGroupPolicy(conversationId);
 	if (conversationGroupPolicy.allowlistEnabled && !conversationGroupPolicy.allowed) {
 		const accountId = inboundPolicy.account.accountId;
-		if (shouldWarnForGroupDrop(JSON.stringify([
+		const warnKey = JSON.stringify([
 			accountId,
 			conversationId,
 			"group registry"
-		]))) {
+		]);
+		if (!groupDropWarned.check(warnKey)) {
 			const groupsPath = resolveWhatsAppGroupsConfigPath({
 				cfg: params.cfg,
 				accountId
@@ -2472,17 +2469,11 @@ async function applyGroupGating(params) {
 		}),
 		allowFrom: inboundPolicy.configuredAllowFrom
 	};
-	const mentionMsg = params.mentionText !== void 0 ? {
-		...params.msg,
-		payload: {
-			...params.msg.payload,
-			body: params.mentionText
-		}
-	} : {
+	const mentionMsg = {
 		...params.msg,
 		payload: {
 			...params.msg.payload,
-			body: params.msg.payload.commandBody ?? params.msg.payload.body
+			body: params.mentionText ?? params.msg.payload.commandBody ?? params.msg.payload.body
 		}
 	};
 	const commandBody = stripMentionsForCommand(mentionMsg.payload.body, mentionConfig.mentionRegexes, self.e164);
@@ -2506,8 +2497,8 @@ async function applyGroupGating(params) {
 	}) !== "always";
 	const replyContext = getReplyContext(params.msg, params.authDir);
 	const implicitReplyToSelf = params.selfChatMode === true && identitiesOverlap(self, sender);
-	const implicitMentionKinds = implicitMentionKindWhen("quoted_bot", !implicitReplyToSelf && identitiesOverlap(self, replyContext?.sender));
-	const mentionDecision = resolveInboundMentionDecision({
+	const implicitMentionKinds = (0, channel_mention_gating_exports.implicitMentionKindWhen)("quoted_bot", !implicitReplyToSelf && identitiesOverlap(self, replyContext?.sender));
+	const mentionDecision = (0, channel_mention_gating_exports.resolveInboundMentionDecision)({
 		facts: {
 			canDetectMention: true,
 			wasMentioned,
@@ -2535,7 +2526,7 @@ async function applyGroupGating(params) {
 			};
 		}
 		const accountId = inboundPolicy.account.accountId;
-		if (shouldWarnForGroupDrop(JSON.stringify([
+		if (!groupDropWarned.check(JSON.stringify([
 			accountId,
 			conversationId,
 			"no mention"
@@ -2692,15 +2683,12 @@ function isLikelyWhatsAppCryptoError(reason) {
 		} catch {
 			return Object.prototype.toString.call(value);
 		}
-		if (typeof value === "number") return String(value);
-		if (typeof value === "boolean") return String(value);
-		if (typeof value === "bigint") return String(value);
+		if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") return String(value);
 		if (typeof value === "symbol") return value.description ?? value.toString();
 		if (typeof value === "function") return value.name ? `[function ${value.name}]` : "[function]";
 		return Object.prototype.toString.call(value);
 	};
-	const raw = reason instanceof Error ? `${reason.message}\n${reason.stack ?? ""}` : formatReason(reason);
-	const haystack = normalizeLowercaseStringOrEmpty(raw);
+	const haystack = normalizeLowercaseStringOrEmpty(formatReason(reason));
 	if (!(haystack.includes("unsupported state or unable to authenticate data") || haystack.includes("bad mac"))) return false;
 	return haystack.includes("baileys") || haystack.includes("noise-handler") || haystack.includes("aesdecryptgcm");
 }
@@ -2930,7 +2918,6 @@ async function deliverWebReplyInActivityScope(params) {
 				return;
 			}
 			const fallbackText = [caption ?? "", "⚠️ Media failed."].filter(Boolean).join("\n");
-			if (!fallbackText) return;
 			whatsappOutboundLog.warn(`Media skipped; sent text-only to ${conversationId}`);
 			rememberSendResult(await sendWithRetry(() => transport.reply(fallbackText, getQuote()), "media:fallback-text", "text"));
 		}
@@ -3065,9 +3052,6 @@ function normalizeErrForLog(err) {
 	};
 	return err;
 }
-function whatsAppReplyDeliveryVisibility(visibleReplySent) {
-	return { visibleReplySent };
-}
 function createWhatsAppChannelDeliveryResult(params) {
 	const messageIds = listMessageReceiptPlatformIds(params.delivery.receipt);
 	return {
@@ -3154,18 +3138,13 @@ function createWhatsAppMediaOnlyReplyCoalescer(params) {
 	};
 	return {
 		defer(pending) {
-			let resolveFinalization;
-			let rejectFinalization;
-			const finalization = new Promise((resolve, reject) => {
-				resolveFinalization = resolve;
-				rejectFinalization = reject;
-			});
+			const finalization = createDeferred();
 			pendingMediaOnlyPayloads.push({
 				...pending,
-				resolveFinalization,
-				rejectFinalization
+				resolveFinalization: finalization.resolve,
+				rejectFinalization: finalization.reject
 			});
-			return finalization;
+			return finalization.promise;
 		},
 		flushNonDuplicateMedia: (mediaUrls) => flushWhere((pending) => !hasWhatsAppMediaUrlOverlap(pending.mediaUrls, mediaUrls)),
 		supersedeMedia(mediaUrl) {
@@ -3185,7 +3164,7 @@ function createWhatsAppMediaOnlyReplyCoalescer(params) {
 					};
 				}
 				if (pending.mediaUrls.size === 0) {
-					pending.resolveFinalization(whatsAppReplyDeliveryVisibility(false));
+					pending.resolveFinalization({ visibleReplySent: false });
 					continue;
 				}
 				retained.push(pending);
@@ -3376,7 +3355,7 @@ function createWhatsAppReplyPlan(params) {
 	};
 	const deliverNormalizedPayload = async (normalizedDeliveryPayload, info, options) => {
 		const reply = resolveSendableOutboundReplyParts(normalizedDeliveryPayload);
-		if (!reply.hasMedia && !reply.text.trim()) return whatsAppReplyDeliveryVisibility(false);
+		if (!reply.hasMedia && !reply.text.trim()) return { visibleReplySent: false };
 		let delivery;
 		try {
 			delivery = await params.deliverReply({
@@ -3437,7 +3416,7 @@ function createWhatsAppReplyPlan(params) {
 			onSettled: async () => {
 				const flushResult = await mediaOnlyCoalescer.flushAll();
 				logWhatsAppMediaOnlyFlushResult(flushResult);
-				return whatsAppReplyDeliveryVisibility(didSendReply || flushResult.delivered > 0);
+				return { visibleReplySent: didSendReply || flushResult.delivered > 0 };
 			},
 			onReplyStart: params.transport.sendComposing
 		},
@@ -3485,7 +3464,7 @@ function createWhatsAppReplyPlan(params) {
 			deliver: async (payload, info) => {
 				const normalizedDeliveryPayload = payload;
 				const reply = resolveSendableOutboundReplyParts(normalizedDeliveryPayload);
-				if (!reply.hasMedia && !reply.text.trim()) return whatsAppReplyDeliveryVisibility(false);
+				if (!reply.hasMedia && !reply.text.trim()) return { visibleReplySent: false };
 				if (!reply.hasMedia) return await deliverNormalizedPayload(normalizedDeliveryPayload, info, { recordDelivery: false });
 				const mediaUrls = new Set(normalizedDeliveryPayload.mediaUrls);
 				if (shouldDeferWhatsAppMediaOnlyPayload({
@@ -3546,20 +3525,11 @@ function createWhatsAppReplyPlan(params) {
 		finalize: (dispatchResult) => {
 			const didQueueVisibleReply = hasVisibleInboundReplyDispatch(dispatchResult);
 			const didDeliverVisibleReply = didSendReply || dispatchResult.observedReplyDelivery === true;
-			if (!didQueueVisibleReply && !didDeliverVisibleReply) {
-				if (statusReactionController) finalizeWhatsAppStatusReaction({
-					controller: statusReactionController,
-					outcome: "error"
-				});
-				if (params.shouldClearGroupHistory) params.groupHistories.set(params.groupHistoryKey, []);
-				logVerbose$1("Skipping auto-reply: silent token or no text/media returned from resolver");
-				return false;
-			}
 			if (statusReactionController) finalizeWhatsAppStatusReaction({
 				controller: statusReactionController,
 				outcome: readAgentRunTerminalOutcome(dispatchResult) === "failed" || !didDeliverVisibleReply ? "error" : "done"
 			});
-			if (params.shouldClearGroupHistory) params.groupHistories.set(params.groupHistoryKey, []);
+			if (!didQueueVisibleReply && !didDeliverVisibleReply) logVerbose$1("Skipping auto-reply: silent token or no text/media returned from resolver");
 			return didDeliverVisibleReply;
 		}
 	};
@@ -3575,15 +3545,12 @@ function formatReplyTarget(replyTo) {
 	if (!replyTo?.body) return null;
 	return `[Replying to ${replyTo.sender?.label ?? replyTo.sender?.e164 ?? "unknown sender"}${replyTo.id ? ` id:${replyTo.id}` : ""}]\n${replyTo.body}\n[/Replying]`;
 }
-function formatReplyContext(msg) {
-	return formatReplyTarget(getReplyContext(msg));
-}
 function buildInboundLine(params) {
 	const { msg, previousTimestamp, envelope } = params;
 	const admission = requireWhatsAppInboundAdmission(msg);
 	const conversationId = admission.conversation.id;
 	const conversationKind = admission.conversation.kind;
-	const replyContext = params.visibleReplyTo === void 0 ? formatReplyContext(msg) : formatReplyTarget(params.visibleReplyTo);
+	const replyContext = formatReplyTarget(params.visibleReplyTo === void 0 ? getReplyContext(msg) : params.visibleReplyTo);
 	const baseLine = `${msg.payload.body}${replyContext ? `\n\n${replyContext}` : ""}`;
 	const sender = getSenderIdentity(msg);
 	return formatInboundEnvelope({
@@ -3607,13 +3574,7 @@ function buildInboundLine(params) {
 async function createWhatsAppStatusReactionController(params) {
 	if (!params.msg.event.id) return null;
 	if ((params.cfg.messages?.statusReactions)?.enabled !== true) return null;
-	const eligibility = await resolveWhatsAppReactionEligibility({
-		cfg: params.cfg,
-		msg: params.msg,
-		agentId: params.agentId,
-		sessionKey: params.sessionKey,
-		verbose: params.verbose
-	});
+	const eligibility = await resolveWhatsAppReactionEligibility(params);
 	if (eligibility.status === "disabled") return null;
 	const { chatId, messageId, emoji: initialEmoji, reactionOptions } = eligibility;
 	return createStatusReactionController({
@@ -3640,39 +3601,37 @@ const WHATSAPP_MESSAGE_RECEIVED_HOOK_LIMITS = {
 	maxQueue: 128,
 	timeoutMs: 2e3
 };
-function readWhatsAppMessageReceivedHookOptIn(value) {
-	if (!value || typeof value !== "object") return;
-	const pluginHooks = value.pluginHooks;
-	if (pluginHooks?.messageReceived === void 0) return;
-	return pluginHooks.messageReceived;
+function mapWhatsAppIngressToTurnAdmission(ingress) {
+	const reason = ingress.reasonCode;
+	if (ingress.admission === "dispatch") return {
+		kind: "dispatch",
+		reason
+	};
+	if (ingress.admission === "observe") return {
+		kind: "observeOnly",
+		reason
+	};
+	if (ingress.admission === "skip") return {
+		kind: "handled",
+		reason
+	};
+	return {
+		kind: "drop",
+		reason,
+		recordHistory: false
+	};
 }
 function shouldEmitWhatsAppMessageReceivedHooks(params) {
 	const channelConfig = params.cfg.channels?.whatsapp;
-	return readWhatsAppMessageReceivedHookOptIn(params.accountId && channelConfig?.accounts ? channelConfig.accounts[params.accountId] : void 0) ?? readWhatsAppMessageReceivedHookOptIn(channelConfig) ?? false;
+	return (params.accountId ? channelConfig?.accounts?.[params.accountId] : void 0)?.pluginHooks?.messageReceived ?? channelConfig?.pluginHooks?.messageReceived ?? false;
 }
-function emitWhatsAppMessageReceivedHooks(params) {
+function emitWhatsAppMessageReceivedHooksIfEnabled(params) {
+	if (!shouldEmitWhatsAppMessageReceivedHooks(params)) return;
 	const canonical = deriveInboundMessageHookContext(params.ctx);
 	const hookRunner = getGlobalHookRunner();
 	if (hookRunner?.hasHooks("message_received")) fireAndForgetBoundedHook(() => hookRunner.runMessageReceived(toPluginMessageReceivedEvent(canonical), toPluginMessageContext(canonical)), "whatsapp: message_received plugin hook failed", void 0, WHATSAPP_MESSAGE_RECEIVED_HOOK_LIMITS);
 	fireAndForgetBoundedHook(() => triggerInternalHook(createInternalHookEvent("message", "received", params.sessionKey, toInternalMessageReceivedContext(canonical))), "whatsapp: message_received internal hook failed", void 0, WHATSAPP_MESSAGE_RECEIVED_HOOK_LIMITS);
 }
-function emitWhatsAppMessageReceivedHooksIfEnabled(params) {
-	if (!shouldEmitWhatsAppMessageReceivedHooks({
-		cfg: params.cfg,
-		accountId: params.accountId
-	})) return;
-	emitWhatsAppMessageReceivedHooks({
-		ctx: params.ctx,
-		sessionKey: params.sessionKey
-	});
-}
-function resolvePinnedMainDmRecipient(params) {
-	return resolvePinnedMainDmOwnerFromAllowlist({
-		dmScope: params.cfg.session?.dmScope,
-		allowFrom: params.allowFrom,
-		normalizeEntry: (entry) => normalizeE164(entry)
-	});
-}
 async function processMessage(params) {
 	const admission = requireWhatsAppInboundAdmission(params.msg);
 	if (admission.ingress.admission !== "dispatch" && admission.ingress.admission !== "observe") return false;
@@ -3696,26 +3655,8 @@ async function processMessage(params) {
 		sessionKey: params.route.sessionKey
 	});
 	let audioTranscript = params.preflightAudioTranscript ?? void 0;
-	const hasAudioBody = (params.msg.payload.media?.kind === "audio" || params.msg.payload.media?.type?.startsWith("audio/") === true) && !params.msg.payload.body.trim();
-	if (params.preflightAudioTranscript === void 0 && hasAudioBody && params.msg.payload.media?.path) try {
-		const { transcribeFirstAudio } = await import("./audio-preflight.runtime-C_glQhZY.mjs");
-		audioTranscript = await transcribeFirstAudio({
-			ctx: {
-				media: [{
-					path: params.msg.payload.media.path,
-					contentType: params.msg.payload.media.type,
-					kind: params.msg.payload.media.kind ?? void 0
-				}],
-				From: conversationId,
-				To: params.msg.platform.recipientJid,
-				Provider: "whatsapp",
-				Surface: "whatsapp",
-				OriginatingChannel: "whatsapp",
-				OriginatingTo: conversationId,
-				AccountId: params.route.accountId
-			},
-			cfg: params.cfg
-		});
+	if (params.preflightAudioTranscript === void 0 && hasWhatsAppAudioBody(params.msg) && params.msg.payload.media?.path) try {
+		audioTranscript = await transcribeWhatsAppAudioMessage(params.cfg, params.msg, params.route.accountId);
 	} catch {
 		if (shouldLogVerbose$1()) logVerbose$1("whatsapp: audio preflight transcription failed, keeping structured audio");
 	}
@@ -3739,7 +3680,6 @@ async function processMessage(params) {
 		envelope: envelopeOptions,
 		visibleReplyTo
 	});
-	let shouldClearGroupHistory = false;
 	const visibleGroupHistory = conversationKind === "group" ? resolveVisibleWhatsAppGroupHistory({
 		history: params.groupHistory ?? params.groupHistories.get(params.groupHistoryKey) ?? [],
 		mode: contextVisibilityMode,
@@ -3773,7 +3713,6 @@ async function processMessage(params) {
 				}
 			});
 		}
-		shouldClearGroupHistory = !(params.suppressGroupHistoryClear ?? false);
 	}
 	const statusReactionController = params.statusReactionController ?? (params.cfg.messages?.statusReactions?.enabled === true && !params.ackAlreadySent ? await createWhatsAppStatusReactionController({
 		cfg: params.cfg,
@@ -3803,16 +3742,15 @@ async function processMessage(params) {
 		mediaType: params.msg.payload.media?.type ?? null,
 		mediaPath: params.msg.payload.media?.path ?? null
 	}, "inbound web message");
-	const fromDisplay = conversationId;
 	const kindLabel = params.msg.payload.media?.type ? `, ${params.msg.payload.media?.type}` : "";
-	whatsappInboundLog.info(`Inbound message ${fromDisplay} -> ${params.msg.platform.recipientJid} (${conversationKind}${kindLabel}, ${combinedBody.length} chars)`);
+	whatsappInboundLog.info(`Inbound message ${conversationId} -> ${params.msg.platform.recipientJid} (${conversationKind}${kindLabel}, ${combinedBody.length} chars)`);
 	if (shouldLogVerbose$1()) whatsappInboundLog.debug(`Inbound body: ${elide(combinedBody, 400)}`);
 	const sender = getSenderIdentity(params.msg);
 	const commandBody = params.msg.payload.commandBody ?? params.msg.payload.body;
 	const dmRouteTarget = resolveWhatsAppDmRouteTarget({
 		msg: params.msg,
 		senderE164: sender.e164 ?? void 0,
-		normalizeE164
+		normalizeE164: normalizeE164$1
 	});
 	const shouldCheckCommandAuth = shouldComputeCommandAuthorized(commandBody, params.cfg);
 	const isTextCommand = isControlCommandMessage(commandBody, params.cfg);
@@ -3870,6 +3808,8 @@ async function processMessage(params) {
 		visibleReplyTo: visibleReplyTo ?? void 0,
 		suppressMessageReceivedHooks: true
 	});
+	const turnAdmission = mapWhatsAppIngressToTurnAdmission(inbound.channelIngress?.ingress ?? admission.ingress);
+	const shouldClearGroupHistory = conversationKind === "group" && params.suppressGroupHistoryClear !== true;
 	const transport = buildWhatsAppInboundTransportContext(params.msg);
 	const ingressLifecycle = resolveWhatsAppIngressLifecycle(params.msg);
 	const turnAdoptionLifecycle = ingressLifecycle ? bindIngressLifecycleToReplyOptions(ingressLifecycle).turnAdoptionLifecycle : void 0;
@@ -3879,9 +3819,10 @@ async function processMessage(params) {
 		accountId: params.route.accountId,
 		sessionKey: params.route.sessionKey
 	});
-	const pinnedMainDmRecipient = resolvePinnedMainDmRecipient({
-		cfg: params.cfg,
-		allowFrom: inboundPolicy.configuredAllowFrom
+	const pinnedMainDmRecipient = resolvePinnedMainDmOwnerFromAllowlist({
+		dmScope: params.cfg.session?.dmScope,
+		allowFrom: inboundPolicy.configuredAllowFrom,
+		normalizeEntry: normalizeE164$1
 	});
 	updateWhatsAppMainLastRoute({
 		backgroundTasks: params.backgroundTasks,
@@ -3901,25 +3842,9 @@ async function processMessage(params) {
 		...turnAdoptionLifecycle ? { turnAdoptionLifecycle } : {},
 		adapter: {
 			ingest: () => turnInput,
-			preflight: () => {
-				const reason = admission.ingress.reasonCode;
-				if (admission.ingress.admission === "dispatch") return { admission: {
-					kind: "dispatch",
-					reason
-				} };
-				if (admission.ingress.admission === "observe") return { admission: {
-					kind: "observeOnly",
-					reason
-				} };
-				if (admission.ingress.admission === "skip") return { admission: {
-					kind: "handled",
-					reason
-				} };
-				return { admission: {
-					kind: "drop",
-					reason,
-					recordHistory: false
-				} };
+			preflight: () => ({ admission: turnAdmission }),
+			onFinalize: (result) => {
+				if (result.dispatched && turnAdmission.kind === "dispatch" && shouldClearGroupHistory) params.groupHistories.set(params.groupHistoryKey, []);
 			},
 			resolveTurn: () => {
 				const { finalize, ...replyPlan } = createWhatsAppReplyPlan({
@@ -3927,8 +3852,6 @@ async function processMessage(params) {
 					connectionId: params.connectionId,
 					context: ctxPayload,
 					deliverReply: deliverWebReply,
-					groupHistories: params.groupHistories,
-					groupHistoryKey: params.groupHistoryKey,
 					maxMediaBytes: params.maxMediaBytes,
 					maxMediaTextChunkLimit: params.maxMediaTextChunkLimit,
 					inbound,
@@ -3940,7 +3863,6 @@ async function processMessage(params) {
 					},
 					replyResolver: params.replyResolver,
 					route: params.route,
-					shouldClearGroupHistory,
 					statusReactionController,
 					transport,
 					turnAdoptionLifecycle
@@ -3991,7 +3913,6 @@ async function processMessage(params) {
 //#endregion
 //#region extensions/whatsapp/src/auto-reply/monitor/on-message.ts
 function createWebOnMessageHandler(params) {
-	const hasExplicitlyPassedInboundAccess = (msg) => msg.admission.ingress.decision === "allow";
 	const withDirectSenderPeer = (msg, peerId) => {
 		if (requireWhatsAppInboundAdmission(msg).conversation.kind === "group" || msg.platform.sender?.e164 || msg.platform.senderE164 || !peerId.startsWith("+")) return msg;
 		const normalized = normalizeE164(peerId);
@@ -4009,7 +3930,7 @@ function createWebOnMessageHandler(params) {
 		};
 	};
 	const processForRoute = async (cfg, msg, route, groupHistoryKey, opts) => {
-		const processParams = {
+		return processMessage({
 			cfg,
 			msg,
 			route,
@@ -4024,18 +3945,12 @@ function createWebOnMessageHandler(params) {
 			replyLogger: params.replyLogger,
 			backgroundTasks: params.backgroundTasks,
 			buildContext: params.buildContext,
-			dispatchReplyFromConfig: params.dispatchReplyFromConfig
-		};
-		if (opts?.groupHistory !== void 0) processParams.groupHistory = opts.groupHistory;
-		if (opts?.suppressGroupHistoryClear !== void 0) processParams.suppressGroupHistoryClear = opts.suppressGroupHistoryClear;
-		if (opts?.preflightAudioTranscript !== void 0) processParams.preflightAudioTranscript = opts.preflightAudioTranscript;
-		if (opts?.ackAlreadySent === true) processParams.ackAlreadySent = true;
-		if (opts?.ackReaction !== void 0) processParams.ackReaction = opts.ackReaction;
-		if (opts?.statusReactionController !== void 0) processParams.statusReactionController = opts.statusReactionController;
-		return processMessage(processParams);
+			dispatchReplyFromConfig: params.dispatchReplyFromConfig,
+			...opts
+		});
 	};
 	return async (normalizedMsg) => {
-		const canRunDirectEarlyAudioPreflight = hasExplicitlyPassedInboundAccess(normalizedMsg);
+		const canRunDirectEarlyAudioPreflight = normalizedMsg.admission.ingress.decision === "allow";
 		const cfg = params.loadConfig?.() ?? params.cfg;
 		const peerId = resolvePeerId(normalizedMsg);
 		const msg = withDirectSenderPeer(normalizedMsg, peerId);
@@ -4075,7 +3990,7 @@ function createWebOnMessageHandler(params) {
 			peerId
 		}) : route.sessionKey;
 		let preflightAudioTranscript;
-		const hasAudioBody = (msg.payload.media?.kind === "audio" || msg.payload.media?.type?.startsWith("audio/") === true) && !msg.payload.body.trim();
+		const hasAudioBody = hasWhatsAppAudioBody(msg);
 		const canRunEarlyAudioPreflight = conversationKind === "group" || canRunDirectEarlyAudioPreflight;
 		let ackAlreadySent = false;
 		let ackReaction = null;
@@ -4098,24 +4013,7 @@ function createWebOnMessageHandler(params) {
 		const transcribeAudioOnce = async () => {
 			if (preflightAudioTranscript !== void 0 || !hasAudioBody || !msg.payload.media?.path) return;
 			try {
-				const { transcribeFirstAudio } = await import("./audio-preflight.runtime-C_glQhZY.mjs");
-				preflightAudioTranscript = await transcribeFirstAudio({
-					ctx: {
-						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",
-						Surface: "whatsapp",
-						OriginatingChannel: "whatsapp",
-						OriginatingTo: conversationId,
-						AccountId: route.accountId
-					},
-					cfg
-				}) ?? null;
+				preflightAudioTranscript = await transcribeWhatsAppAudioMessage(cfg, msg, route.accountId) ?? null;
 			} catch {
 				preflightAudioTranscript = null;
 			}
@@ -4175,10 +4073,9 @@ function createWebOnMessageHandler(params) {
 				warn: params.replyLogger.warn.bind(params.replyLogger)
 			});
 			recordAcceptedConfiguredGroupRoute = recordGroupRoute;
-			let gating = await applyGroupGating({
+			const gatingParams = {
 				cfg,
 				msg,
-				deferMissingMention: hasAudioBody && Boolean(msg.payload.media?.path),
 				groupHistoryKey,
 				agentId: route.agentId,
 				sessionKey: route.sessionKey,
@@ -4191,25 +4088,16 @@ function createWebOnMessageHandler(params) {
 				groupMemberNames: params.groupMemberNames,
 				logVerbose,
 				replyLogger: params.replyLogger
+			};
+			let gating = await applyGroupGating({
+				...gatingParams,
+				deferMissingMention: hasAudioBody && Boolean(msg.payload.media?.path)
 			});
 			if (!gating.shouldProcess && "needsMentionText" in gating && gating.needsMentionText === true) {
 				await runAudioPreflightOnce();
 				gating = await applyGroupGating({
-					cfg,
-					msg,
-					...typeof preflightAudioTranscript === "string" ? { mentionText: preflightAudioTranscript } : {},
-					groupHistoryKey,
-					agentId: route.agentId,
-					sessionKey: route.sessionKey,
-					baseMentionConfig,
-					providerMentionPatterns: account.mentionPatterns,
-					authDir: account.authDir,
-					selfChatMode: account.selfChatMode,
-					groupHistories: params.groupHistories,
-					groupHistoryLimit: params.groupHistoryLimit,
-					groupMemberNames: params.groupMemberNames,
-					logVerbose,
-					replyLogger: params.replyLogger
+					...gatingParams,
+					...typeof preflightAudioTranscript === "string" ? { mentionText: preflightAudioTranscript } : {}
 				});
 			}
 			if (!gating.shouldProcess) {
@@ -4332,7 +4220,6 @@ async function monitorWebChannel(verbose, listenerFactory = attachWebInboxToSock
 	const heartbeatSeconds = resolveHeartbeatSeconds(cfg, tuning.heartbeatSeconds);
 	const reconnectPolicy = resolveReconnectPolicy(cfg, tuning.reconnect);
 	const socketTiming = resolveWhatsAppSocketTiming(tuning.socketTiming);
-	const baseMentionConfig = buildMentionConfig(cfg);
 	const groupHistoryLimit = resolvePromptHistoryLimit(account.historyLimit ?? cfg.channels?.whatsapp?.historyLimit ?? cfg.messages?.groupChat?.historyLimit);
 	const groupHistories = /* @__PURE__ */ new Map();
 	const groupMemberNames = /* @__PURE__ */ new Map();
@@ -4402,8 +4289,6 @@ async function monitorWebChannel(verbose, listenerFactory = attachWebInboxToSock
 							backgroundTasks: connectionLocal.backgroundTasks,
 							replyResolver: activeReplyResolver,
 							replyLogger,
-							baseMentionConfig,
-							account,
 							buildContext: pluginChannelRuntime?.inbound.buildContext,
 							dispatchReplyFromConfig: pluginChannelRuntime?.reply?.dispatchReplyFromConfig
 						});
@@ -4583,38 +4468,25 @@ async function monitorWebChannel(verbose, listenerFactory = attachWebInboxToSock
 			});
 			enqueueSystemEvent(`WhatsApp gateway connected${selfE164 ? ` as ${selfE164}` : ""}.`, { sessionKey: connectRoute.sessionKey });
 			const normalizedAccountId = normalizeReconnectAccountId(account.accountId);
-			drainPendingDeliveries({
-				drainKey: `whatsapp:${normalizedAccountId}`,
-				logLabel: "WhatsApp reconnect drain",
-				cfg,
-				log: reconnectLogger,
-				selectEntry: (entry) => ({
-					match: entry.channel === "whatsapp" && normalizeReconnectAccountId(entry.accountId) === normalizedAccountId,
-					bypassBackoff: isNoListenerReconnectError(entry.lastError)
-				})
-			}).catch((err) => {
-				reconnectLogger.warn({
-					connectionId: connection.connectionId,
-					error: String(err)
-				}, "reconnect drain failed");
-			});
-			const periodicDrainInterval = setInterval(() => {
+			const drainDeliveries = (mode) => {
 				drainPendingDeliveries({
 					drainKey: `whatsapp:${normalizedAccountId}`,
-					logLabel: "WhatsApp periodic drain",
+					logLabel: `WhatsApp ${mode} drain`,
 					cfg,
 					log: reconnectLogger,
 					selectEntry: (entry) => ({
 						match: entry.channel === "whatsapp" && normalizeReconnectAccountId(entry.accountId) === normalizedAccountId,
-						bypassBackoff: false
+						bypassBackoff: mode === "reconnect" && isNoListenerReconnectError(entry.lastError)
 					})
 				}).catch((err) => {
 					reconnectLogger.warn({
 						connectionId: connection.connectionId,
 						error: String(err)
-					}, "periodic drain failed");
+					}, `${mode} drain failed`);
 				});
-			}, 3e4);
+			};
+			drainDeliveries("reconnect");
+			const periodicDrainInterval = setInterval(() => drainDeliveries("periodic"), 3e4);
 			const inboundPolicy = resolveWhatsAppInboundPolicy({
 				cfg,
 				accountId: account.accountId,