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

package/dist/monitor-CBVNJ2lb.js

@@ -1,4451 +0,0 @@
-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 { 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 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 { createAckReactionHandle, createStatusReactionController, logAckFailure, removeAckReactionHandleAfterReply, shouldAckReactionForWhatsApp } from "openclaw/plugin-sdk/channel-feedback";
-import { formatCliCommand } from "openclaw/plugin-sdk/cli-runtime";
-import { getChildLogger } from "openclaw/plugin-sdk/logging-core";
-import { resolveMarkdownTableMode as resolveMarkdownTableMode$1 } from "openclaw/plugin-sdk/markdown-table-runtime";
-import { createSubsystemLogger, defaultRuntime, formatDurationPrecise, getChildLogger as getChildLogger$1, logVerbose, logVerbose as logVerbose$1, registerUnhandledRejectionHandler, shouldLogVerbose, shouldLogVerbose as shouldLogVerbose$1, warn } from "openclaw/plugin-sdk/runtime-env";
-import { registerChannelRuntimeContext } from "openclaw/plugin-sdk/channel-runtime-context";
-import { bindIngressLifecycleToReplyOptions, createChannelIngressMonitor, createChannelMessageReplyPipeline, createMessageReceiptFromOutboundResults, 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 { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
-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 { createHash } from "node:crypto";
-import { getSessionEntry, patchSessionEntry, resolveStorePath, resolveStorePath as resolveStorePath$1, updateLastRoute } from "openclaw/plugin-sdk/session-store-runtime";
-import { recordChannelActivity } from "openclaw/plugin-sdk/channel-activity-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 { 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";
-import { buildMentionRegexes, implicitMentionKindWhen, normalizeMentionText, resolveInboundMentionDecision } from "openclaw/plugin-sdk/channel-mention-gating";
-import { createConnectedChannelStatusPatch, createTransportActivityStatusPatch } from "openclaw/plugin-sdk/gateway-runtime";
-import { ensureConfiguredBindingRouteReady, resolveConfiguredBindingRoute } from "openclaw/plugin-sdk/conversation-binding-runtime";
-import { resolveAgentIdentity, resolveIdentityNamePrefix as resolveIdentityNamePrefix$1 } from "openclaw/plugin-sdk/agent-runtime";
-import { normalizeGroupActivation, parseActivationCommand } from "openclaw/plugin-sdk/group-activation";
-import { hasControlCommand, isControlCommandMessage, shouldComputeCommandAuthorized } from "openclaw/plugin-sdk/command-detection";
-import { createInternalHookEvent, deriveInboundMessageHookContext, fireAndForgetBoundedHook, toInternalMessageReceivedContext, toPluginMessageContext, toPluginMessageReceivedEvent, triggerInternalHook } from "openclaw/plugin-sdk/hook-runtime";
-import { getGlobalHookRunner } from "openclaw/plugin-sdk/plugin-runtime";
-import { resolveBatchedReplyThreadingPolicy } from "openclaw/plugin-sdk/reply-reference";
-import { LocalMediaAccessError, getDefaultLocalRoots, loadWebMedia, loadWebMediaRaw, optimizeImageToJpeg, optimizeImageToPng } from "openclaw/plugin-sdk/web-media";
-import { createChannelApiRetryRunner } from "openclaw/plugin-sdk/retry-runtime";
-//#region extensions/whatsapp/src/inbound/message-aliases.ts
-function normalizeQuoteSender(sender) {
-	if (!sender?.displayName && !sender?.jid && !sender?.e164) return;
-	return sender;
-}
-function buildQuoteFromFlatAliases(msg) {
-	if (msg.replyTo) return {
-		context: msg.replyTo,
-		id: msg.replyTo.id,
-		body: msg.replyTo.body,
-		sender: normalizeQuoteSender({
-			displayName: msg.replyTo.sender?.label ?? msg.replyToSender,
-			jid: msg.replyTo.sender?.jid ?? msg.replyToSenderJid,
-			e164: msg.replyTo.sender?.e164 ?? msg.replyToSenderE164
-		})
-	};
-	if (!msg.replyToId && !msg.replyToBody && !msg.replyToSender && !msg.replyToSenderJid && !msg.replyToSenderE164) return;
-	return {
-		id: msg.replyToId,
-		body: msg.replyToBody,
-		sender: normalizeQuoteSender({
-			displayName: msg.replyToSender,
-			jid: msg.replyToSenderJid,
-			e164: msg.replyToSenderE164
-		})
-	};
-}
-function buildGroupFromFlatAliases(msg) {
-	const mentionJids = msg.mentions ?? msg.mentionedJids;
-	if (!msg.groupSubject && !msg.groupParticipants?.length && !mentionJids?.length) return;
-	return {
-		subject: msg.groupSubject,
-		participants: msg.groupParticipants,
-		mentions: mentionJids?.length ? { jids: mentionJids } : void 0
-	};
-}
-function ensureQuote(msg) {
-	return msg.quote ??= {};
-}
-function ensureQuoteSender(msg) {
-	const quote = ensureQuote(msg);
-	return quote.sender ??= {};
-}
-function ensureGroup(msg) {
-	return msg.group ??= {};
-}
-function ensureGroupMentions(msg) {
-	const group = ensureGroup(msg);
-	return group.mentions ??= {};
-}
-function ensureMedia(msg) {
-	return msg.payload.media ??= {};
-}
-function setMediaField(msg, key, value) {
-	if (value === void 0 && !msg.payload.media) return;
-	ensureMedia(msg)[key] = value;
-}
-function defineDeprecatedAccessors(msg, descriptors) {
-	Object.defineProperties(msg, Object.fromEntries(Object.entries(descriptors).map(([key, descriptor]) => [key, {
-		configurable: true,
-		enumerable: true,
-		get: descriptor.get,
-		set: descriptor.set
-	}])));
-	return msg;
-}
-function defineDeprecatedAliasAccessors(msg, descriptors) {
-	defineDeprecatedAccessors(msg, descriptors);
-	return msg;
-}
-function defineDeprecatedAdmissionTopLevelAccessors(msg) {
-	let fallbackConversationId = msg.conversationId || msg.from;
-	let fallbackAccountId = msg.accountId;
-	let fallbackAccessControlPassed = msg.accessControlPassed;
-	let fallbackChatType = msg.chatType;
-	const conversationId = () => msg.admission?.conversation.id ?? fallbackConversationId;
-	const setConversationId = (value) => {
-		const next = value;
-		fallbackConversationId = next;
-		if (msg.admission) {
-			msg.admission.conversation.id = next;
-			msg.admission.conversation.groupSessionId = resolveWhatsAppGroupConversationId(next);
-		}
-	};
-	return defineDeprecatedAccessors(msg, {
-		from: {
-			get: conversationId,
-			set: setConversationId
-		},
-		conversationId: {
-			get: conversationId,
-			set: setConversationId
-		},
-		accountId: {
-			get: () => msg.admission?.accountId ?? fallbackAccountId,
-			set: (value) => {
-				const next = value;
-				fallbackAccountId = next;
-				if (msg.admission) {
-					msg.admission.accountId = next;
-					msg.admission.account.accountId = next;
-				}
-			}
-		},
-		accessControlPassed: {
-			get: () => msg.admission ? msg.admission.ingress.decision === "allow" : fallbackAccessControlPassed,
-			set: (value) => {
-				fallbackAccessControlPassed = value;
-			}
-		},
-		chatType: {
-			get: () => msg.admission?.conversation.kind ?? fallbackChatType,
-			set: (value) => {
-				const next = value;
-				fallbackChatType = next;
-				if (msg.admission) msg.admission.conversation.kind = next;
-			}
-		}
-	});
-}
-function withDeprecatedWebInboundMessageFlatAliases(msg) {
-	return defineDeprecatedAliasAccessors(defineDeprecatedAdmissionTopLevelAccessors(msg), {
-		id: {
-			get: () => msg.event.id,
-			set: (value) => msg.event.id = value
-		},
-		to: {
-			get: () => msg.platform.recipientJid,
-			set: (value) => msg.platform.recipientJid = value
-		},
-		body: {
-			get: () => msg.payload.body,
-			set: (value) => msg.payload.body = value
-		},
-		pushName: {
-			get: () => msg.platform.pushName,
-			set: (value) => msg.platform.pushName = value
-		},
-		timestamp: {
-			get: () => msg.event.timestamp,
-			set: (value) => msg.event.timestamp = value
-		},
-		chatId: {
-			get: () => msg.platform.chatJid,
-			set: (value) => msg.platform.chatJid = value
-		},
-		sender: {
-			get: () => msg.platform.sender,
-			set: (value) => msg.platform.sender = value
-		},
-		senderJid: {
-			get: () => msg.platform.senderJid,
-			set: (value) => msg.platform.senderJid = value
-		},
-		senderE164: {
-			get: () => msg.platform.senderE164,
-			set: (value) => msg.platform.senderE164 = value
-		},
-		senderName: {
-			get: () => msg.platform.senderName,
-			set: (value) => msg.platform.senderName = value
-		},
-		replyTo: {
-			get: () => msg.quote?.context,
-			set: (value) => ensureQuote(msg).context = value
-		},
-		replyToId: {
-			get: () => msg.quote?.id ?? msg.quote?.context?.id,
-			set: (value) => ensureQuote(msg).id = value
-		},
-		replyToBody: {
-			get: () => msg.quote?.body ?? msg.quote?.context?.body,
-			set: (value) => ensureQuote(msg).body = value
-		},
-		replyToSender: {
-			get: () => msg.quote?.context?.sender?.label ?? msg.quote?.sender?.displayName,
-			set: (value) => {
-				const sender = ensureQuoteSender(msg);
-				sender.displayName = value;
-				if (msg.quote?.context?.sender) msg.quote.context.sender.label = value;
-			}
-		},
-		replyToSenderJid: {
-			get: () => msg.quote?.context?.sender?.jid ?? msg.quote?.sender?.jid,
-			set: (value) => {
-				const jid = value;
-				ensureQuoteSender(msg).jid = jid;
-				if (msg.quote?.context?.sender) msg.quote.context.sender.jid = jid;
-			}
-		},
-		replyToSenderE164: {
-			get: () => msg.quote?.context?.sender?.e164 ?? msg.quote?.sender?.e164,
-			set: (value) => {
-				const e164 = value;
-				ensureQuoteSender(msg).e164 = e164;
-				if (msg.quote?.context?.sender) msg.quote.context.sender.e164 = e164;
-			}
-		},
-		groupSubject: {
-			get: () => msg.group?.subject,
-			set: (value) => ensureGroup(msg).subject = value
-		},
-		groupParticipants: {
-			get: () => msg.group?.participants,
-			set: (value) => ensureGroup(msg).participants = value
-		},
-		mentions: {
-			get: () => msg.group?.mentions?.jids,
-			set: (value) => ensureGroupMentions(msg).jids = value
-		},
-		mentionedJids: {
-			get: () => msg.group?.mentions?.jids,
-			set: (value) => ensureGroupMentions(msg).jids = value
-		},
-		self: {
-			get: () => msg.platform.self,
-			set: (value) => msg.platform.self = value
-		},
-		selfJid: {
-			get: () => msg.platform.selfJid,
-			set: (value) => msg.platform.selfJid = value
-		},
-		selfLid: {
-			get: () => msg.platform.selfLid,
-			set: (value) => msg.platform.selfLid = value
-		},
-		selfE164: {
-			get: () => msg.platform.selfE164,
-			set: (value) => msg.platform.selfE164 = value
-		},
-		fromMe: {
-			get: () => msg.platform.fromMe,
-			set: (value) => msg.platform.fromMe = value
-		},
-		location: {
-			get: () => msg.payload.location,
-			set: (value) => msg.payload.location = value
-		},
-		sendComposing: {
-			get: () => msg.platform.sendComposing,
-			set: (value) => msg.platform.sendComposing = value
-		},
-		reply: {
-			get: () => msg.platform.reply,
-			set: (value) => msg.platform.reply = value
-		},
-		sendMedia: {
-			get: () => msg.platform.sendMedia,
-			set: (value) => msg.platform.sendMedia = value
-		},
-		mediaPath: {
-			get: () => msg.payload.media?.path,
-			set: (value) => setMediaField(msg, "path", value)
-		},
-		mediaType: {
-			get: () => msg.payload.media?.type,
-			set: (value) => setMediaField(msg, "type", value)
-		},
-		mediaFileName: {
-			get: () => msg.payload.media?.fileName,
-			set: (value) => setMediaField(msg, "fileName", value)
-		},
-		mediaUrl: {
-			get: () => msg.payload.media?.url,
-			set: (value) => setMediaField(msg, "url", value)
-		},
-		untrustedStructuredContext: {
-			get: () => msg.payload.untrustedStructuredContext,
-			set: (value) => msg.payload.untrustedStructuredContext = value
-		},
-		isBatched: {
-			get: () => msg.event.isBatched,
-			set: (value) => msg.event.isBatched = value
-		}
-	});
-}
-function normalizeLegacyFlatWebInboundMessage(msg) {
-	const media = msg.mediaPath || msg.mediaType || msg.mediaFileName || msg.mediaUrl ? {
-		path: msg.mediaPath,
-		type: msg.mediaType,
-		fileName: msg.mediaFileName,
-		url: msg.mediaUrl
-	} : void 0;
-	return withDeprecatedWebInboundMessageFlatAliases({
-		...msg,
-		admission: msg.admission ?? buildDeprecatedFlatWhatsAppInboundAdmission(msg),
-		event: {
-			id: msg.id,
-			timestamp: msg.timestamp,
-			isBatched: msg.isBatched
-		},
-		payload: {
-			body: msg.body,
-			media,
-			location: msg.location,
-			untrustedStructuredContext: msg.untrustedStructuredContext
-		},
-		platform: {
-			chatJid: msg.chatId,
-			recipientJid: msg.to,
-			sender: msg.sender,
-			senderJid: msg.senderJid,
-			senderE164: msg.senderE164,
-			senderName: msg.senderName,
-			pushName: msg.pushName,
-			self: msg.self,
-			selfJid: msg.selfJid,
-			selfLid: msg.selfLid,
-			selfE164: msg.selfE164,
-			fromMe: msg.fromMe,
-			sendComposing: msg.sendComposing,
-			reply: msg.reply,
-			sendMedia: msg.sendMedia
-		},
-		quote: buildQuoteFromFlatAliases(msg),
-		group: buildGroupFromFlatAliases(msg)
-	});
-}
-function normalizeWebInboundMessage(msg) {
-	if (msg.event && msg.payload && msg.platform) return withDeprecatedWebInboundMessageFlatAliases(msg);
-	if (msg.event || msg.payload || msg.platform || msg.quote || msg.group) throw new Error("WhatsApp inbound messages must be either legacy flat or canonical nested; partial nested contexts are not supported.");
-	return normalizeLegacyFlatWebInboundMessage(msg);
-}
-//#endregion
-//#region extensions/whatsapp/src/inbound/dedupe.ts
-const recentOutboundMessages = createDedupeCache({
-	ttlMs: 20 * 6e4,
-	maxSize: 5e3
-});
-function buildMessageKey(params) {
-	const accountId = params.accountId.trim();
-	const remoteJid = params.remoteJid.trim();
-	const messageId = params.messageId.trim();
-	if (!accountId || !remoteJid || !messageId || messageId === "unknown") return null;
-	return `${accountId}:${remoteJid}:${messageId}`;
-}
-function resetWebInboundDedupe() {
-	recentOutboundMessages.clear();
-}
-function rememberRecentOutboundMessage(params) {
-	const key = buildMessageKey(params);
-	if (!key) return;
-	recentOutboundMessages.check(key);
-}
-function isRecentOutboundMessage(params) {
-	const key = buildMessageKey(params);
-	if (!key) return false;
-	return recentOutboundMessages.peek(key);
-}
-//#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 = 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 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,
-			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);
-	return () => {
-		if (typeof emitter.off === "function") {
-			emitter.off(event, listener);
-			return;
-		}
-		if (typeof emitter.removeListener === "function") emitter.removeListener(event, listener);
-	};
-}
-function closeInboundMonitorSocket(sock) {
-	if (typeof sock.end === "function") {
-		sock.end(/* @__PURE__ */ new Error("OpenClaw WhatsApp listener close"));
-		return;
-	}
-	sock.ws?.close?.();
-}
-//#endregion
-//#region extensions/whatsapp/src/inbound/media.ts
-var WhatsAppInboundMediaLimitExceededError = class extends Error {
-	constructor(maxBytes) {
-		super(`Media exceeds ${Math.round(maxBytes / (1024 * 1024))}MB limit`);
-		this.name = "WhatsAppInboundMediaLimitExceededError";
-	}
-};
-function unwrapMessage(message) {
-	return normalizeMessageContent(message);
-}
-async function downloadInboundMedia(msg, sock, maxBytes = 50 * 1024 * 1024) {
-	const message = unwrapMessage(msg.message);
-	if (!message) return;
-	const mimetype = resolveInboundMediaMimetype(message);
-	const fileName = message.documentMessage?.fileName ?? void 0;
-	if (!message.imageMessage && !message.videoMessage && !message.documentMessage && !message.audioMessage && !message.stickerMessage) return;
-	return {
-		saved: await saveMediaStream(await downloadMediaMessage(msg, "stream", {}, {
-			reuploadRequest: sock.updateMediaMessage,
-			logger: sock.logger
-		}), mimetype, "inbound", maxBytes, fileName).catch((err) => {
-			if (err instanceof Error && /Media exceeds/i.test(err.message)) throw new WhatsAppInboundMediaLimitExceededError(maxBytes);
-			throw err;
-		}),
-		mimetype,
-		fileName
-	};
-}
-async function downloadQuotedInboundMedia(msg, sock, maxBytes = 50 * 1024 * 1024) {
-	const contextInfo = extractContextInfo(unwrapMessage(msg.message));
-	if (!contextInfo?.quotedMessage) return;
-	const quotedMessage = contextInfo.quotedMessage;
-	return downloadInboundMedia({
-		key: {
-			id: contextInfo?.stanzaId || void 0,
-			remoteJid: contextInfo.remoteJid ?? msg.key?.remoteJid ?? void 0,
-			participant: contextInfo?.participant ?? void 0,
-			fromMe: false
-		},
-		message: quotedMessage,
-		messageTimestamp: msg.messageTimestamp
-	}, sock, maxBytes);
-}
-//#endregion
-//#region extensions/whatsapp/src/inbound/monitor.ts
-const LOGGED_OUT_STATUS = DisconnectReason.loggedOut;
-const RECONNECT_IN_PROGRESS_ERROR = "no active socket - reconnection in progress";
-const GROUP_META_TTL_MS = 300 * 1e3;
-const BAILEYS_MESSAGE_TTL_MS = 600 * 1e3;
-const INBOUND_CLOSE_DRAIN_TIMEOUT_MS = 5e3;
-const WHATSAPP_INGRESS_DRAIN_INTERVAL_MS = 1e3;
-const WHATSAPP_GROUP_METADATA_CACHE_MAX_ENTRIES = 500;
-function resolveGroupMetadataExpiresAt(nowRaw = Date.now()) {
-	const now = asDateTimestampMs(nowRaw);
-	return now === void 0 ? void 0 : resolveExpiresAtMsFromDurationMs(GROUP_META_TTL_MS, { nowMs: now });
-}
-function parseWhatsAppTimestampSeconds(value) {
-	if (value == null) return;
-	if (typeof value === "string") return parseStrictFiniteNumber(value);
-	const parsed = Number(value);
-	return Number.isFinite(parsed) ? parsed : void 0;
-}
-function rememberGroupMetadataCacheEntry(cache, jid, entry) {
-	if (asDateTimestampMs(entry.expires) === void 0) {
-		cache.delete(jid);
-		return;
-	}
-	if (cache.has(jid)) cache.delete(jid);
-	cache.set(jid, entry);
-	while (cache.size > WHATSAPP_GROUP_METADATA_CACHE_MAX_ENTRIES) {
-		const oldest = cache.keys().next();
-		if (oldest.done) break;
-		cache.delete(oldest.value);
-	}
-}
-function readGroupMetadataCacheEntry(cache, jid) {
-	const entry = cache.get(jid);
-	if (!entry) return null;
-	const now = asDateTimestampMs(Date.now());
-	const expires = asDateTimestampMs(entry.expires);
-	if (now === void 0 || expires === void 0 || expires <= now) {
-		cache.delete(jid);
-		return null;
-	}
-	cache.delete(jid);
-	cache.set(jid, entry);
-	return entry;
-}
-function rememberWhatsAppBaileysCacheEntry(cache, key, value, ttlMs) {
-	if (!cache) return;
-	if (cache.has(key)) cache.delete(key);
-	cache.set(key, {
-		expiresAt: Date.now() + ttlMs,
-		value
-	});
-	while (cache.size > WHATSAPP_GROUP_METADATA_CACHE_MAX_ENTRIES) {
-		const oldest = cache.keys().next();
-		if (oldest.done) break;
-		cache.delete(oldest.value);
-	}
-}
-function readWhatsAppBaileysCacheEntry(cache, key) {
-	const entry = cache.get(key);
-	if (!entry) return;
-	if (entry.expiresAt <= Date.now()) {
-		cache.delete(key);
-		return;
-	}
-	cache.delete(key);
-	cache.set(key, entry);
-	return entry.value;
-}
-function logWhatsAppVerbose(enabled, message) {
-	if (!enabled) return;
-	defaultRuntime.log(message);
-}
-function isDirectUserJid(jid) {
-	return /^(\d+)(?::\d+)?@(s\.whatsapp\.net|c\.us|lid|hosted|hosted\.lid)$/i.test(jid.trim());
-}
-function getActiveReachoutTimelock(state) {
-	if (state?.isActive !== true) return;
-	const endsAt = state.timeEnforcementEnds?.getTime();
-	return endsAt === void 0 || !Number.isFinite(endsAt) || endsAt > Date.now() ? state : void 0;
-}
-function formatReachoutTimelockError(state) {
-	const details = [state.enforcementType ? `type=${state.enforcementType}` : void 0, state.timeEnforcementEnds instanceof Date && Number.isFinite(state.timeEnforcementEnds.getTime()) ? `until=${state.timeEnforcementEnds.toISOString()}` : void 0].filter(Boolean);
-	return `WhatsApp reachout timelock is active; direct messages are temporarily blocked${details.length ? ` (${details.join(", ")})` : ""}`;
-}
-function recordAcceptedInboundActivity(accountId) {
-	recordChannelActivity({
-		channel: "whatsapp",
-		accountId,
-		direction: "inbound"
-	});
-}
-function isRetryableSendDisconnectError(err) {
-	if (isWhatsAppSocketOperationTimeoutError(err)) return false;
-	return /closed|reset|timed\s*out|disconnect|no active socket/i.test(formatError(err));
-}
-function shouldClearSocketRefAfterSendFailure(err) {
-	return /closed|reset|disconnect|no active socket/i.test(formatError(err));
-}
-async function attachWebInboxToSocket(options) {
-	const inboundLogger = getChildLogger({ module: "web-inbound" });
-	const inboundConsoleLog = createSubsystemLogger("gateway/channels/whatsapp").child("inbound");
-	const sock = options.sock;
-	const connectedAtMs = Date.now();
-	if (options.socketRef) options.socketRef.current = sock;
-	const shouldRetryDisconnect = () => options.shouldRetryDisconnect?.() === true;
-	const disconnectRetryPolicy = options.disconnectRetryPolicy ?? DEFAULT_RECONNECT_POLICY;
-	const sendRetryMaxAttempts = disconnectRetryPolicy.maxAttempts > 0 ? disconnectRetryPolicy.maxAttempts : DEFAULT_RECONNECT_POLICY.maxAttempts;
-	const sendOperationTimeoutMs = resolveWhatsAppSocketOperationTimeoutMs(options.socketTiming.defaultQueryTimeoutMs);
-	let onCloseResolve = null;
-	const onClose = new Promise((resolve) => {
-		onCloseResolve = resolve;
-	});
-	const resolveClose = (reason) => {
-		if (!onCloseResolve) return;
-		const resolver = onCloseResolve;
-		onCloseResolve = null;
-		resolver(reason);
-	};
-	const presence = options.selfChatMode ? "unavailable" : "available";
-	try {
-		await createWhatsAppSocketOperationTimeoutAdapter(sock, sendOperationTimeoutMs).sendPresenceUpdate(presence);
-		logWhatsAppVerbose(options.verbose, `Sent global '${presence}' presence on connect`);
-	} catch (err) {
-		logWhatsAppVerbose(options.verbose, `Failed to send '${presence}' presence on connect: ${String(err)}`);
-	}
-	const selfIdentity = await readWebSelfIdentityForDecision(options.authDir, sock.user);
-	if (selfIdentity.outcome === "unstable") throw new WhatsAppAuthUnstableError("WhatsApp auth state is still stabilizing; retrying inbox attach.");
-	const self = selfIdentity.identity;
-	const getCurrentSock = () => {
-		if (!options.socketRef) return sock;
-		if (options.socketRef.current) return options.socketRef.current;
-		if (!self.e164 && !self.jid && !self.lid) return null;
-		const successor = getWhatsAppConnectionController(options.accountId);
-		if (!successor) return null;
-		const successorIdentity = successor.getSelfIdentity();
-		if (!successorIdentity || !identitiesOverlap(self, successorIdentity)) return null;
-		return successor.getCurrentSock();
-	};
-	const durableInboundQueue = options.durableInboundQueue ?? createWhatsAppDurableInboundQueue(options.accountId);
-	const inboundDebounceMs = Math.max(0, Math.trunc(options.debounceMs ?? 0));
-	const pendingDebounceKeys = /* @__PURE__ */ new Set();
-	const activeInboundFlushes = /* @__PURE__ */ new Set();
-	const pendingMessageHandlers = /* @__PURE__ */ new Set();
-	let durableIngressActive = false;
-	const debounceWorkWaiters = /* @__PURE__ */ new Set();
-	const notifyDebounceWork = () => {
-		if (debounceWorkWaiters.size === 0) return;
-		const waiters = [...debounceWorkWaiters];
-		debounceWorkWaiters.clear();
-		for (const resolve of waiters) resolve();
-	};
-	const waitForDebounceWorkOrIdle = (handlers) => {
-		if (pendingDebounceKeys.size > 0 || activeInboundFlushes.size > 0) return Promise.resolve();
-		if (pendingMessageHandlers.size === 0) return Promise.resolve();
-		return new Promise((resolve) => {
-			const finish = () => {
-				debounceWorkWaiters.delete(finish);
-				resolve();
-			};
-			debounceWorkWaiters.add(finish);
-			Promise.allSettled(handlers).then(finish);
-		});
-	};
-	let nextReceiveOrder = 0;
-	const publishPendingWorkState = (at = Date.now()) => {
-		options.onPendingWorkChanged?.(pendingMessageHandlers.size + pendingDebounceKeys.size + activeInboundFlushes.size + (durableIngressActive ? 1 : 0), at);
-	};
-	const buildInboundDebounceKey = (msg) => {
-		const admission = requireWhatsAppInboundAdmission(msg);
-		const sender = msg.platform.sender;
-		const senderKey = admission.conversation.kind === "group" ? getPrimaryIdentityId(sender ?? null) ?? msg.platform.senderJid ?? msg.platform.senderE164 ?? msg.platform.senderName ?? admission.sender.id : admission.conversation.id;
-		if (!senderKey) return null;
-		return `${admission.accountId}:${admission.conversation.id}:${senderKey}`;
-	};
-	const shouldDebounceInboundMessage = (msg) => options.shouldDebounce?.(msg) ?? true;
-	const orderDebouncedInboundEntries = (entries) => entries.toSorted((a, b) => {
-		const timestampDiff = (a.event.timestamp ?? 0) - (b.event.timestamp ?? 0);
-		if (timestampDiff !== 0) return timestampDiff;
-		return (a.receiveOrder ?? 0) - (b.receiveOrder ?? 0);
-	});
-	const 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,
-		buildKey: (msg) => msg.debounceKey ?? buildInboundDebounceKey(msg),
-		shouldDebounce: shouldDebounceInboundMessage,
-		onFlush: async (entries) => {
-			let finishFlush;
-			const flushTask = new Promise((resolve) => {
-				finishFlush = resolve;
-			});
-			activeInboundFlushes.add(flushTask);
-			publishPendingWorkState();
-			notifyDebounceWork();
-			try {
-				const orderedEntries = orderDebouncedInboundEntries(entries);
-				const last = orderedEntries.at(-1);
-				if (!last) return;
-				const { lifecycle, settle, abandon } = buildFlushIngressLifecycle(orderedEntries);
-				try {
-					if (orderedEntries.length === 1) {
-						await options.onMessage(attachWhatsAppIngressLifecycle(last, lifecycle));
-						await settle();
-						await Promise.all(orderedEntries.map((entry) => maybeMarkInboundAsRead(entry.readReceipt)));
-						return;
-					}
-					const mentioned = /* @__PURE__ */ new Set();
-					for (const entry of orderedEntries) for (const jid of entry.group?.mentions?.jids ?? []) mentioned.add(jid);
-					const combinedBody = orderedEntries.map((entry) => entry.payload.body).filter(Boolean).join("\n");
-					const combinedCommandBody = orderedEntries.map((entry) => entry.payload.commandBody ?? entry.payload.body).filter(Boolean).join("\n");
-					const combinedMentions = mentioned.size > 0 ? {
-						...last.group?.mentions,
-						jids: Array.from(mentioned)
-					} : last.group?.mentions;
-					const combinedGroup = last.group || combinedMentions ? {
-						...last.group,
-						mentions: combinedMentions
-					} : void 0;
-					const combinedMessage = attachWhatsAppIngressLifecycle(withDeprecatedWebInboundMessageFlatAliases({
-						...last,
-						...lifecycle ? { turnAdoptionLifecycle: lifecycle } : {},
-						payload: {
-							...last.payload,
-							body: combinedBody,
-							commandBody: combinedCommandBody
-						},
-						group: combinedGroup,
-						event: {
-							...last.event,
-							isBatched: true
-						}
-					}), lifecycle);
-					await options.onMessage(combinedMessage);
-					await settle();
-					await Promise.all(orderedEntries.map((entry) => maybeMarkInboundAsRead(entry.readReceipt)));
-				} catch (error) {
-					await abandon();
-					throw error;
-				}
-			} finally {
-				for (const entry of entries) if (entry.debounceKey) pendingDebounceKeys.delete(entry.debounceKey);
-				activeInboundFlushes.delete(flushTask);
-				finishFlush();
-				publishPendingWorkState();
-			}
-		},
-		onError: (err) => {
-			inboundLogger.error({ error: String(err) }, "failed handling inbound web message");
-			inboundConsoleLog.error(`Failed handling inbound web message: ${String(err)}`);
-		}
-	});
-	const groupMetadataCache = options.groupMetadataCache ?? /* @__PURE__ */ new Map();
-	const groupMetaCache = /* @__PURE__ */ new Map();
-	const lidLookup = sock.signalRepository?.lidMapping;
-	const publishedGroupMetadataJids = /* @__PURE__ */ new Set();
-	const invalidatedGroupMetadataJids = /* @__PURE__ */ new Set();
-	let groupMetadataCacheClosed = false;
-	const resolveInboundJid = async (jid) => resolveJidToE164(jid, {
-		authDir: options.authDir,
-		lidLookup
-	});
-	const resolveReactionTargetJids = async (jid) => resolveEquivalentWhatsAppDirectChatJids(jid, {
-		authDir: options.authDir,
-		lidLookup
-	});
-	const rememberBaileysMessage = (remoteJid, messageId, message) => {
-		if (!options.recentMessageKeys || !remoteJid || !messageId || !message) return;
-		rememberWhatsAppBaileysCacheEntry(options.recentMessageKeys, `${remoteJid}:${messageId}`, message, BAILEYS_MESSAGE_TTL_MS);
-	};
-	const rememberOutboundMessage = (remoteJid, result) => {
-		const messageId = typeof result === "object" && result && "key" in result ? result.key?.id ?? "" : "";
-		if (!messageId) return;
-		rememberRecentOutboundMessage({
-			accountId: options.accountId,
-			remoteJid,
-			messageId
-		});
-		const message = typeof result === "object" && result && "message" in result ? result.message : void 0;
-		rememberBaileysMessage(remoteJid, messageId, message);
-		cacheInboundMessageMeta(options.accountId, remoteJid, messageId, {
-			fromMe: true,
-			body: extractText(message ?? void 0)
-		});
-	};
-	const trackLateAcceptedSend = (jid, promise) => {
-		promise.then((result) => {
-			rememberOutboundMessage(jid, result);
-		}, () => {});
-	};
-	let reachoutTimeLock;
-	let reachoutTimeLockFetch;
-	let reachoutTimeLockVersion = 0;
-	let verifiedSendReady;
-	const rememberReachoutTimeLock = (state) => {
-		reachoutTimeLock = state;
-		reachoutTimeLockVersion += 1;
-		verifiedSendReady = void 0;
-	};
-	const fetchReachoutTimeLock = async (currentSock) => {
-		if (typeof currentSock.fetchAccountReachoutTimelock !== "function") return;
-		if (!reachoutTimeLockFetch) reachoutTimeLockFetch = currentSock.fetchAccountReachoutTimelock().then((state) => {
-			rememberReachoutTimeLock(state);
-			return state;
-		}).catch((err) => {
-			logWhatsAppVerbose(options.verbose, `Failed fetching WhatsApp reachout timelock before send: ${formatError(err)}`);
-		}).finally(() => {
-			reachoutTimeLockFetch = void 0;
-		});
-		return await reachoutTimeLockFetch;
-	};
-	const rememberVerifiedSendReady = (jid, currentSock) => {
-		verifiedSendReady = {
-			jid,
-			sock: currentSock,
-			reachoutTimeLockVersion
-		};
-	};
-	const consumeVerifiedSendReady = (jid, currentSock) => {
-		if (verifiedSendReady?.jid !== jid || verifiedSendReady.sock !== currentSock || verifiedSendReady.reachoutTimeLockVersion !== reachoutTimeLockVersion) return false;
-		verifiedSendReady = void 0;
-		return true;
-	};
-	const assertCanSendToJid = async (jid, currentSock, readinessOptions) => {
-		if (!isDirectUserJid(jid)) return;
-		if (readinessOptions?.useVerifiedReady && consumeVerifiedSendReady(jid, currentSock)) return;
-		const state = getActiveReachoutTimelock(reachoutTimeLock) ?? await fetchReachoutTimeLock(currentSock);
-		const activeState = getActiveReachoutTimelock(state);
-		if (activeState) throw new Error(formatReachoutTimelockError(activeState));
-		if (readinessOptions?.rememberReady && state) rememberVerifiedSendReady(jid, currentSock);
-	};
-	const assertCanSendTo = async (to) => {
-		const currentSock = getCurrentSock();
-		if (!currentSock) throw new Error(RECONNECT_IN_PROGRESS_ERROR);
-		const jid = options.authDir ? toWhatsappJidWithLid(to, { authDir: options.authDir }) : toWhatsappJid(to);
-		await assertCanSendToJid(jid, currentSock, { rememberReady: true });
-	};
-	const sendTrackedMessage = async (jid, content, sendOptions) => {
-		let lastErr = /* @__PURE__ */ new Error(RECONNECT_IN_PROGRESS_ERROR);
-		for (let attempt = 1;; attempt++) {
-			const currentSock = getCurrentSock();
-			if (currentSock) try {
-				await assertCanSendToJid(jid, currentSock, { useVerifiedReady: true });
-				const result = await createWhatsAppSocketOperationTimeoutAdapter(currentSock, sendOperationTimeoutMs, { onSendMessageTimeout: ({ jid: timedOutJid, promise }) => {
-					trackLateAcceptedSend(timedOutJid, promise);
-				} }).sendMessage(jid, content, sendOptions);
-				rememberOutboundMessage(jid, result);
-				return result;
-			} catch (err) {
-				if (!shouldRetryDisconnect() || !isRetryableSendDisconnectError(err)) throw err;
-				lastErr = err;
-				if (shouldClearSocketRefAfterSendFailure(err) && options.socketRef?.current === currentSock) options.socketRef.current = null;
-			}
-			else if (!shouldRetryDisconnect()) throw lastErr;
-			if (attempt >= sendRetryMaxAttempts) throw lastErr;
-			const delayMs = computeBackoff(disconnectRetryPolicy, attempt);
-			logWhatsAppVerbose(options.verbose, `Waiting ${delayMs}ms for WhatsApp reconnect before retrying send to ${jid}: ${formatError(lastErr)}`);
-			try {
-				await sleepWithAbort(delayMs, options.disconnectRetryAbortSignal);
-			} catch {
-				throw lastErr;
-			}
-		}
-	};
-	const sendApiSocketOperations = {
-		sendMessage: (jid, content, sendOptions) => sendTrackedMessage(jid, content, sendOptions),
-		sendPresenceUpdate: async (presenceLocal, jid) => {
-			const currentSock = getCurrentSock();
-			if (!currentSock) throw new Error(RECONNECT_IN_PROGRESS_ERROR);
-			return await createWhatsAppSocketOperationTimeoutAdapter(currentSock, sendOperationTimeoutMs).sendPresenceUpdate(presenceLocal, jid);
-		}
-	};
-	const summarizeGroupMeta = async (meta) => {
-		const participantEntries = await Promise.all(meta.participants?.map(async (p) => {
-			const mapped = await resolveInboundJid(p.id);
-			return {
-				display: mapped ?? p.id,
-				mention: {
-					id: p.id,
-					lid: p.lid,
-					phoneNumber: p.phoneNumber,
-					e164: mapped
-				}
-			};
-		}) ?? []);
-		const participants = participantEntries.map((entry) => entry.display).filter(Boolean);
-		const mentionParticipants = participantEntries.map((entry) => entry.mention);
-		return {
-			subject: meta.subject,
-			participants,
-			mentionParticipants,
-			expires: resolveGroupMetadataExpiresAt() ?? 0
-		};
-	};
-	const summarizeGroupMetaForReconnectCache = (meta) => ({
-		subject: meta.subject,
-		expires: resolveGroupMetadataExpiresAt() ?? NaN
-	});
-	const getGroupMeta = async (jid) => {
-		const cached = readGroupMetadataCacheEntry(groupMetaCache, jid);
-		if (cached) return cached;
-		try {
-			const meta = await (getCurrentSock() ?? sock).groupMetadata(jid);
-			rememberWhatsAppBaileysCacheEntry(options.baileysGroupMetaCache, jid, meta, GROUP_META_TTL_MS);
-			publishedGroupMetadataJids.add(jid);
-			const entry = await summarizeGroupMeta(meta);
-			rememberGroupMetadataCacheEntry(groupMetadataCache, jid, {
-				subject: entry.subject,
-				expires: entry.expires
-			});
-			rememberGroupMetadataCacheEntry(groupMetaCache, jid, entry);
-			return entry;
-		} catch (err) {
-			const hydrated = readGroupMetadataCacheEntry(groupMetadataCache, jid);
-			if (hydrated) {
-				rememberGroupMetadataCacheEntry(groupMetaCache, jid, hydrated);
-				logWhatsAppVerbose(options.verbose, `Using cached group metadata for ${jid} after fetch failure: ${String(err)}`);
-				return hydrated;
-			}
-			logWhatsAppVerbose(options.verbose, `Failed to fetch group metadata for ${jid}: ${String(err)}`);
-			return { expires: resolveGroupMetadataExpiresAt() ?? 0 };
-		}
-	};
-	const resolveOutboundMentionsForGroup = async (jid, text) => {
-		if (isJidGroup(jid) !== true || !mayContainWhatsAppOutboundMention(text)) return {
-			text,
-			mentionedJids: []
-		};
-		return resolveWhatsAppOutboundMentions({
-			chatJid: jid,
-			text,
-			participants: (await getGroupMeta(jid)).mentionParticipants
-		});
-	};
-	const applyOutboundMentionsToContent = async (jid, content) => {
-		if ("text" in content && typeof content.text === "string") {
-			const resolved = await resolveOutboundMentionsForGroup(jid, content.text);
-			return addWhatsAppOutboundMentionsToContent({
-				...content,
-				text: resolved.text
-			}, resolved.mentionedJids);
-		}
-		const caption = content.caption;
-		if (typeof caption === "string") {
-			const resolved = await resolveOutboundMentionsForGroup(jid, caption);
-			return addWhatsAppOutboundMentionsToContent({
-				...content,
-				caption: resolved.text
-			}, resolved.mentionedJids);
-		}
-		return content;
-	};
-	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 (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);
-		if (!from) return null;
-		const senderE164 = group ? participantJid ? await resolveInboundJid(participantJid) : null : from;
-		let groupSubject;
-		let groupParticipants;
-		if (group) {
-			const meta = await getGroupMeta(remoteJid);
-			groupSubject = meta.subject;
-			groupParticipants = meta.participants;
-		}
-		const messageTimestampSeconds = parseWhatsAppTimestampSeconds(msg.messageTimestamp);
-		const messageTimestampMs = messageTimestampSeconds !== void 0 ? messageTimestampSeconds * 1e3 : void 0;
-		const access = await checkInboundAccessControl({
-			cfg: options.loadConfig?.() ?? options.cfg,
-			accountId: options.accountId,
-			from,
-			selfE164: self.e164 ?? null,
-			senderE164,
-			senderJid: participantJid,
-			group,
-			pushName: msg.pushName ?? void 0,
-			isFromMe: Boolean(msg.key?.fromMe),
-			messageTimestampMs,
-			connectedAtMs,
-			verbose: options.verbose,
-			sock: { sendMessage: (jid, content) => sendTrackedMessage(jid, content) },
-			remoteJid
-		});
-		if (!access.allowed) return null;
-		return {
-			id,
-			remoteJid,
-			group,
-			participantJid,
-			from,
-			senderE164,
-			groupSubject,
-			groupParticipants,
-			messageTimestampMs,
-			access
-		};
-	};
-	const buildReadReceiptTarget = (inbound) => inbound.id ? {
-		remoteJid: inbound.remoteJid,
-		id: inbound.id,
-		...inbound.participantJid ? { participant: inbound.participantJid } : {}
-	} : void 0;
-	const maybeMarkInboundAsRead = async (target) => {
-		if (!target || options.sendReadReceipts === false) return;
-		const { id, remoteJid, participant } = target;
-		try {
-			await withWhatsAppSocketOperationTimeout("readMessages", (getCurrentSock() ?? sock).readMessages([{
-				remoteJid,
-				id,
-				participant,
-				fromMe: false
-			}]), sendOperationTimeoutMs);
-			const suffix = participant ? ` (participant ${participant})` : "";
-			logWhatsAppVerbose(options.verbose, `Marked message ${id} as read for ${remoteJid}${suffix}`);
-		} catch (err) {
-			logWhatsAppVerbose(options.verbose, `Failed to mark message ${id} read: ${String(err)}`);
-		}
-	};
-	const maybeLogSkippedSelfChatReadReceipt = (inbound, target) => {
-		if (target?.id && inbound.access.isSelfChat && options.verbose) logWhatsAppVerbose(options.verbose, `Self-chat mode: skipping read receipt for ${target.id}`);
-	};
-	const maybeMarkNonSelfChatReadReceipt = async (inbound, target) => {
-		if (inbound.access.isSelfChat) {
-			maybeLogSkippedSelfChatReadReceipt(inbound, target);
-			return;
-		}
-		await maybeMarkInboundAsRead(target);
-	};
-	const shouldSkipStaleAppend = (msg, upsertType) => {
-		if (upsertType !== "append") return false;
-		const APPEND_RECENT_GRACE_MS = 6e4;
-		const msgTsSeconds = parseWhatsAppTimestampSeconds(msg.messageTimestamp);
-		const msgTsMs = msgTsSeconds !== void 0 ? msgTsSeconds * 1e3 : 0;
-		const nowMs = Date.now();
-		return msgTsMs < (options.appendReplyWindow && nowMs <= options.appendReplyWindow.untilMs ? Math.max(options.appendReplyWindow.afterMs, nowMs - options.appendReplyWindow.maxAgeMs) : connectedAtMs - APPEND_RECENT_GRACE_MS);
-	};
-	const preparedInboundByDurableId = /* @__PURE__ */ new Map();
-	const enrichInboundMessage = async (msg) => {
-		const location = extractLocationData(msg.message ?? void 0);
-		const locationText = location ? formatLocationText(location) : void 0;
-		const contactContext = extractContactContext(msg.message ?? void 0);
-		const externalAdReplyContext = extractExternalAdReplyContext(msg.message ?? void 0);
-		let mediaKind = extractMediaKind(msg.message ?? void 0);
-		let body = extractText(msg.message ?? void 0);
-		if (locationText) body = [body, locationText].filter(Boolean).join("\n").trim();
-		if (!body && !mediaKind) return null;
-		body = body ?? "";
-		const commandBody = body;
-		const replyContext = describeReplyContext(msg.message);
-		let mediaPath;
-		let mediaType = mediaKind ? resolveInboundMediaMimetype(msg.message) : void 0;
-		const nativeMedia = mediaKind ? {
-			contentType: mediaType,
-			kind: mediaKind
-		} : void 0;
-		let mediaFileName;
-		const maxBytes = (typeof options.mediaMaxMb === "number" && options.mediaMaxMb > 0 ? options.mediaMaxMb : 50) * 1024 * 1024;
-		const saveInboundMedia = async (inboundMedia) => {
-			if (!inboundMedia) return;
-			mediaPath = inboundMedia.saved.path;
-			mediaType = inboundMedia.mimetype;
-			mediaFileName = inboundMedia.fileName;
-		};
-		try {
-			await saveInboundMedia(await downloadInboundMedia(msg, sock, maxBytes));
-		} catch (err) {
-			logWhatsAppVerbose(options.verbose, `Inbound media download failed: ${String(err)}`);
-			body = formatInboundMediaUnavailableText({
-				body,
-				notice: "[whatsapp attachment unavailable]"
-			});
-		}
-		if (!mediaPath && !mediaKind && replyContext?.media) try {
-			await saveInboundMedia(await downloadQuotedInboundMedia(msg, sock, maxBytes));
-			mediaKind = replyContext.media.kind ?? void 0;
-			mediaType = mediaType ?? replyContext.media.contentType ?? void 0;
-		} catch (err) {
-			logWhatsAppVerbose(options.verbose, `Quoted media download failed: ${String(err)}`);
-			body = formatInboundMediaUnavailableText({
-				body,
-				notice: "[whatsapp quoted attachment unavailable]"
-			});
-		}
-		return {
-			body,
-			commandBody,
-			location: location ?? void 0,
-			contactContext,
-			externalAdReplyContext,
-			replyContext,
-			mediaPath,
-			mediaType,
-			mediaFileName,
-			mediaKind,
-			nativeMedia
-		};
-	};
-	const enqueueInboundMessage = async (msg, inbound, enriched, durable) => {
-		const chatJid = inbound.remoteJid;
-		const sendComposing = async () => {
-			const currentSock = getCurrentSock();
-			if (!currentSock) return;
-			try {
-				await assertCanSendToJid(chatJid, currentSock);
-				await sendApiSocketOperations.sendPresenceUpdate("composing", chatJid);
-			} catch (err) {
-				logWhatsAppVerbose(options.verbose, `Presence update failed: ${String(err)}`);
-			}
-		};
-		const reply = async (text, optionsResult) => {
-			const resolved = await resolveOutboundMentionsForGroup(chatJid, text);
-			return normalizeWhatsAppSendResult(await sendTrackedMessage(chatJid, addWhatsAppOutboundMentionsToContent({ text: resolved.text }, resolved.mentionedJids), optionsResult), "text");
-		};
-		const sendMedia = async (payload, optionsValue) => {
-			const previewPayload = await addWhatsAppImagePreviewFields(payload);
-			return normalizeWhatsAppSendResult(await sendTrackedMessage(chatJid, await applyOutboundMentionsToContent(chatJid, previewPayload), optionsValue), "media");
-		};
-		const timestamp = inbound.messageTimestampMs;
-		const mentionedJids = extractMentionedJids(msg.message);
-		const senderName = msg.pushName ?? void 0;
-		inboundLogger.info({
-			from: inbound.from,
-			to: self.e164 ?? "me",
-			body: enriched.body,
-			mediaPath: enriched.mediaPath,
-			mediaType: enriched.mediaType,
-			mediaFileName: enriched.mediaFileName,
-			timestamp
-		}, "inbound message");
-		const media = enriched.mediaPath || enriched.mediaType || enriched.mediaFileName || enriched.mediaKind ? {
-			path: enriched.mediaPath,
-			type: enriched.mediaType,
-			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) ? {
-			subject: inbound.groupSubject,
-			participants: inbound.groupParticipants,
-			mentions: groupMentions
-		} : void 0;
-		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: {
-				id: inbound.id,
-				timestamp
-			},
-			payload: {
-				body: enriched.body,
-				commandBody: enriched.commandBody,
-				location: enriched.location ?? void 0,
-				untrustedStructuredContext: untrustedStructuredContext.length > 0 ? untrustedStructuredContext : void 0,
-				media
-			},
-			platform: {
-				chatJid: inbound.remoteJid,
-				recipientJid: self.e164 ?? "me",
-				pushName: senderName,
-				sender: resolveComparableIdentity({
-					jid: inbound.participantJid,
-					e164: inbound.senderE164 ?? void 0,
-					name: senderName
-				}),
-				senderJid: inbound.participantJid,
-				senderE164: inbound.senderE164 ?? void 0,
-				senderName,
-				self,
-				selfJid: self.jid ?? void 0,
-				selfLid: self.lid ?? void 0,
-				selfE164: self.e164 ?? void 0,
-				fromMe: Boolean(msg.key?.fromMe),
-				sendComposing,
-				reply,
-				sendMedia
-			},
-			quote: enriched.replyContext ? {
-				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,
-					e164: enriched.replyContext.sender?.e164 ?? void 0
-				}
-			} : void 0,
-			group,
-			turnAdoptionLifecycle: durable.turnAdoptionLifecycle,
-			readReceipt: durable.readReceipt,
-			receiveOrder: durable.receiveOrder
-		});
-		const debounceKey = buildInboundDebounceKey(inboundMessage);
-		if (debounceKey) {
-			inboundMessage.debounceKey = debounceKey;
-			if (inboundDebounceMs > 0 && shouldDebounceInboundMessage(inboundMessage)) {
-				pendingDebounceKeys.add(debounceKey);
-				publishPendingWorkState();
-				notifyDebounceWork();
-			}
-		}
-		if (inboundMessage.event.id) {
-			const admission = requireWhatsAppInboundAdmission(inboundMessage);
-			cacheInboundMessageMeta(admission.accountId, inboundMessage.platform.chatJid, inboundMessage.event.id, {
-				participant: inboundMessage.platform.senderJid,
-				participantE164: admission.conversation.kind === "direct" ? inboundMessage.platform.senderE164 : void 0,
-				body: inboundMessage.payload.body,
-				media: enriched.nativeMedia,
-				fromMe: inboundMessage.platform.fromMe
-			});
-		}
-		await 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 ?? []) {
-			rememberBaileysMessage(msg.key?.remoteJid, msg.key?.id, msg.message);
-			const receiveOrder = nextReceiveOrder++;
-			if (await maybeResolveWhatsAppApprovalReaction({
-				cfg: options.loadConfig?.() ?? options.cfg,
-				accountId: options.accountId,
-				msg,
-				selfJid: self.jid,
-				selfLid: self.lid,
-				resolveInboundJid,
-				resolveReactionTargetJids,
-				logVerboseMessage: (message) => logWhatsAppVerbose(options.verbose, message)
-			})) continue;
-			const receivedAt = Date.now();
-			const skipStaleAppend = shouldSkipStaleAppend(msg, upsert.type);
-			const skipRecentOutboundEcho = shouldSkipRecentOutboundEcho(msg);
-			const remoteJid = msg.key?.remoteJid;
-			const id = msg.key?.id;
-			const durableId = remoteJid && id ? 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) => {
-		const task = handleMessagesUpsert(upsert).catch((err) => {
-			inboundLogger.error({ error: String(err) }, "messages.upsert handler error");
-			inboundConsoleLog.error(`Messages upsert handler error: ${String(err)}`);
-		});
-		pendingMessageHandlers.add(task);
-		publishPendingWorkState();
-		task.finally(() => {
-			pendingMessageHandlers.delete(task);
-			publishPendingWorkState();
-		});
-	};
-	const drainDebouncedInboundMessages = async () => {
-		while (pendingDebounceKeys.size > 0 || activeInboundFlushes.size > 0) {
-			const debounceKeys = Array.from(pendingDebounceKeys);
-			if (debounceKeys.length > 0) await Promise.all(debounceKeys.map((key) => debouncer.flushKey(key)));
-			const flushes = Array.from(activeInboundFlushes);
-			if (flushes.length > 0) await Promise.allSettled(flushes);
-			await Promise.resolve();
-		}
-	};
-	const drainInboundBeforeSocketClose = async () => {
-		groupMetadataCacheClosed = true;
-		for (;;) {
-			await drainDebouncedInboundMessages();
-			if (pendingMessageHandlers.size === 0) break;
-			const handlers = Array.from(pendingMessageHandlers);
-			await Promise.race([Promise.allSettled(handlers), waitForDebounceWorkOrIdle(handlers)]);
-			if (pendingMessageHandlers.size === 0 && pendingDebounceKeys.size === 0 && activeInboundFlushes.size === 0) break;
-		}
-		await drainDebouncedInboundMessages();
-		for (;;) {
-			await durableInboundMonitor.waitForIdle();
-			if (pendingDebounceKeys.size === 0 && activeInboundFlushes.size === 0) break;
-			await drainDebouncedInboundMessages();
-		}
-		await durableInboundMonitor.stop();
-	};
-	const drainInboundBeforeSocketCloseWithTimeout = async () => {
-		let timeout = null;
-		try {
-			await Promise.race([drainInboundBeforeSocketClose(), new Promise((_, reject) => {
-				timeout = setTimeout(() => {
-					reject(/* @__PURE__ */ new Error(`Timed out draining WhatsApp inbound debounce after ${INBOUND_CLOSE_DRAIN_TIMEOUT_MS}ms`));
-				}, INBOUND_CLOSE_DRAIN_TIMEOUT_MS);
-				timeout.unref?.();
-			})]);
-		} finally {
-			if (timeout) clearTimeout(timeout);
-			durableInboundMonitor.stop();
-		}
-	};
-	const handleConnectionUpdate = (update) => {
-		try {
-			if ("reachoutTimeLock" in update) rememberReachoutTimeLock(update.reachoutTimeLock);
-			if (update.connection === "close") {
-				if (options.socketRef?.current === sock) options.socketRef.current = null;
-				const status = getStatusCode(update.lastDisconnect?.error);
-				resolveClose({
-					status,
-					isLoggedOut: status === LOGGED_OUT_STATUS,
-					error: update.lastDisconnect?.error
-				});
-			}
-		} catch (err) {
-			inboundLogger.error({ error: String(err) }, "connection.update handler error");
-			resolveClose({
-				status: void 0,
-				isLoggedOut: false,
-				error: err
-			});
-		}
-	};
-	const attachSockListener = (event, listener) => attachEmitterListener(sock.ev, event, listener);
-	const detachMessagesUpsert = attachSockListener("messages.upsert", handleMessagesUpsertEvent);
-	const detachConnectionUpdate = attachSockListener("connection.update", handleConnectionUpdate);
-	const isFullGroupMetadataUpdate = (update) => typeof update.id === "string" && typeof update.subject === "string" && Array.isArray(update.participants);
-	const rememberFullGroupMetadataUpdate = (jid, meta) => {
-		if (groupMetadataCacheClosed) return;
-		rememberWhatsAppBaileysCacheEntry(options.baileysGroupMetaCache, jid, meta, GROUP_META_TTL_MS);
-		publishedGroupMetadataJids.add(jid);
-		invalidatedGroupMetadataJids.delete(jid);
-		rememberGroupMetadataCacheEntry(groupMetadataCache, jid, summarizeGroupMetaForReconnectCache(meta));
-		groupMetaCache.delete(jid);
-	};
-	const forgetFullGroupMetadata = (jid) => {
-		options.baileysGroupMetaCache?.delete(jid);
-		groupMetadataCache.delete(jid);
-		groupMetaCache.delete(jid);
-		publishedGroupMetadataJids.delete(jid);
-		invalidatedGroupMetadataJids.add(jid);
-	};
-	const detachGroupsUpsert = attachSockListener("groups.upsert", ((groups) => {
-		for (const group of groups) if (group.id) rememberFullGroupMetadataUpdate(group.id, group);
-	}));
-	const detachGroupsUpdate = attachSockListener("groups.update", ((updates) => {
-		for (const update of updates) {
-			if (!update.id) continue;
-			if (isFullGroupMetadataUpdate(update)) {
-				rememberFullGroupMetadataUpdate(update.id, update);
-				continue;
-			}
-			forgetFullGroupMetadata(update.id);
-		}
-	}));
-	const detachGroupParticipantsUpdate = attachSockListener("group-participants.update", ((update) => {
-		forgetFullGroupMetadata(update.id);
-	}));
-	durableInboundMonitor.start();
-	(async () => {
-		try {
-			const groups = await sock.groupFetchAllParticipating();
-			if (groupMetadataCacheClosed) return;
-			for (const [jid, meta] of Object.entries(groups ?? {})) if (meta && !publishedGroupMetadataJids.has(jid) && !invalidatedGroupMetadataJids.has(jid)) {
-				rememberGroupMetadataCacheEntry(groupMetadataCache, jid, summarizeGroupMetaForReconnectCache(meta));
-				rememberWhatsAppBaileysCacheEntry(options.baileysGroupMetaCache, jid, meta, GROUP_META_TTL_MS);
-				publishedGroupMetadataJids.add(jid);
-			}
-			logWhatsAppVerbose(options.verbose, `Hydrated ${Object.keys(groups ?? {}).length} participating groups on connect`);
-		} catch (err) {
-			const error = String(err);
-			inboundLogger.warn({ error }, "failed hydrating participating groups on connect");
-			inboundConsoleLog.warn(`Failed hydrating participating groups on connect: ${error}`);
-			logWhatsAppVerbose(options.verbose, `Failed to hydrate participating groups on connect: ${error}`);
-		}
-	})();
-	const sendApi = createWebSendApi({
-		sock: sendApiSocketOperations,
-		defaultAccountId: options.accountId,
-		resolveOutboundMentions: ({ jid, text }) => resolveOutboundMentionsForGroup(jid, text),
-		authDir: options.authDir
-	});
-	return {
-		close: async () => {
-			try {
-				detachMessagesUpsert();
-				detachConnectionUpdate();
-				detachGroupsUpsert();
-				detachGroupsUpdate();
-				detachGroupParticipantsUpdate();
-				await drainInboundBeforeSocketCloseWithTimeout();
-			} catch (err) {
-				logWhatsAppVerbose(options.verbose, `Inbound close drain failed: ${String(err)}`);
-			}
-			try {
-				closeInboundMonitorSocket(sock);
-			} catch (err) {
-				logWhatsAppVerbose(options.verbose, `Socket close failed: ${String(err)}`);
-			}
-		},
-		onClose,
-		signalClose: (reason) => {
-			resolveClose(reason ?? {
-				status: void 0,
-				isLoggedOut: false,
-				error: "closed"
-			});
-		},
-		assertSendReady: assertCanSendTo,
-		sendComposingTo: sendApi.sendComposingTo,
-		sendMessage: sendApi.sendMessage,
-		sendPoll: sendApi.sendPoll,
-		sendReaction: sendApi.sendReaction
-	};
-}
-async function monitorWebInbox(options) {
-	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, {
-		authDir: options.authDir,
-		...socketTiming,
-		getMessage: async (key) => key.id && key.remoteJid ? readWhatsAppBaileysCacheEntry(recentMessageKeys, `${key.remoteJid}:${key.id}`) : void 0,
-		cachedGroupMetadata: async (jid) => {
-			const meta = readWhatsAppBaileysCacheEntry(baileysGroupMetaCache, jid);
-			return meta?.participants?.length ? meta : void 0;
-		}
-	});
-	try {
-		await waitForWaConnection(sock, { timeoutMs: socketTiming.connectTimeoutMs });
-	} catch (err) {
-		closeInboundMonitorSocket(sock);
-		throw err;
-	}
-	const shouldDebounce = options.shouldDebounce;
-	const normalizeAdmittedWebInboundMessage = (msg) => requireAdmittedWhatsAppInboundMessage(normalizeWebInboundMessage(msg));
-	return attachWebInboxToSocket({
-		...options,
-		onMessage: async (msg) => {
-			await options.onMessage(normalizeAdmittedWebInboundMessage(msg));
-		},
-		shouldDebounce: shouldDebounce ? (msg) => shouldDebounce(normalizeAdmittedWebInboundMessage(msg)) : void 0,
-		socketTiming,
-		sock,
-		recentMessageKeys,
-		baileysGroupMetaCache
-	});
-}
-//#endregion
-//#region extensions/whatsapp/src/auto-reply/loggers.ts
-const whatsappLog = createSubsystemLogger("gateway/channels/whatsapp");
-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
-function cloneStatus(status) {
-	return {
-		...status,
-		lastDisconnect: status.lastDisconnect ? { ...status.lastDisconnect } : null
-	};
-}
-function isTerminalHealthState(healthState) {
-	return healthState === "conflict" || healthState === "logged-out" || healthState === "stopped";
-}
-function createWebChannelStatusController(statusSink) {
-	let lastDisconnectWasWatchdogRecovery = false;
-	const status = {
-		running: true,
-		connected: false,
-		reconnectAttempts: 0,
-		lastConnectedAt: null,
-		lastDisconnect: null,
-		lastInboundAt: null,
-		lastMessageAt: null,
-		lastEventAt: null,
-		lastError: null,
-		busy: false,
-		lastRunActivityAt: null,
-		healthState: "starting"
-	};
-	const emit = () => {
-		statusSink?.(cloneStatus(status));
-	};
-	return {
-		emit,
-		snapshot: () => status,
-		noteConnected(at = Date.now()) {
-			Object.assign(status, createConnectedChannelStatusPatch(at));
-			Object.assign(status, createTransportActivityStatusPatch(at));
-			if (lastDisconnectWasWatchdogRecovery) {
-				status.lastDisconnect = null;
-				status.reconnectAttempts = 0;
-				lastDisconnectWasWatchdogRecovery = false;
-			}
-			status.lastError = null;
-			status.healthState = "healthy";
-			status.terminalDisconnect = void 0;
-			emit();
-		},
-		noteInbound(at = Date.now()) {
-			status.lastInboundAt = at;
-			status.lastMessageAt = at;
-			status.lastEventAt = at;
-			Object.assign(status, createTransportActivityStatusPatch(at));
-			if (status.connected) status.healthState = "healthy";
-			emit();
-		},
-		noteTransportActivity(at = Date.now()) {
-			if (status.lastTransportActivityAt === at) return;
-			Object.assign(status, createTransportActivityStatusPatch(at));
-			emit();
-		},
-		noteBusy(busy, at = Date.now()) {
-			if (status.busy === busy && status.lastRunActivityAt === at) return;
-			status.busy = busy;
-			status.lastRunActivityAt = at;
-			if (status.connected && busy) status.healthState = "healthy";
-			emit();
-		},
-		noteWatchdogStale(at = Date.now()) {
-			status.lastEventAt = at;
-			if (status.connected) status.healthState = "stale";
-			emit();
-		},
-		noteReconnectAttempts(reconnectAttempts) {
-			status.reconnectAttempts = reconnectAttempts;
-			emit();
-		},
-		noteClose(params) {
-			const at = params.at ?? Date.now();
-			lastDisconnectWasWatchdogRecovery = params.watchdogRecovery === true;
-			status.connected = false;
-			status.lastEventAt = at;
-			status.lastDisconnect = {
-				at,
-				status: params.statusCode,
-				error: params.error,
-				loggedOut: Boolean(params.loggedOut)
-			};
-			status.lastError = params.error ?? null;
-			status.reconnectAttempts = params.reconnectAttempts;
-			status.healthState = params.healthState;
-			emit();
-		},
-		markStopped(at = Date.now()) {
-			status.running = false;
-			status.connected = false;
-			status.lastEventAt = at;
-			status.terminalDisconnect = status.healthState === "logged-out" || status.healthState === "conflict";
-			if (!isTerminalHealthState(status.healthState)) status.healthState = "stopped";
-			emit();
-		}
-	};
-}
-//#endregion
-//#region extensions/whatsapp/src/auto-reply/monitor/echo.ts
-function createEchoTracker(params) {
-	const recentlySent = /* @__PURE__ */ new Set();
-	const maxItems = Math.max(1, params.maxItems ?? 100);
-	const buildCombinedKey = (p) => `combined:${p.sessionKey}:${p.combinedBody}`;
-	const trim = () => {
-		while (recentlySent.size > maxItems) {
-			const firstKey = recentlySent.values().next().value;
-			if (!firstKey) break;
-			recentlySent.delete(firstKey);
-		}
-	};
-	const rememberText = (text, opts) => {
-		if (!text) return;
-		recentlySent.add(text);
-		if (opts.combinedBody && opts.combinedBodySessionKey) recentlySent.add(buildCombinedKey({
-			sessionKey: opts.combinedBodySessionKey,
-			combinedBody: opts.combinedBody
-		}));
-		if (opts.logVerboseMessage) params.logVerbose?.(`Added to echo detection set (size now: ${recentlySent.size}): ${truncateUtf16Safe(text, 50)}...`);
-		trim();
-	};
-	return {
-		rememberText,
-		has: (key) => recentlySent.has(key),
-		forget: (key) => {
-			recentlySent.delete(key);
-		},
-		buildCombinedKey
-	};
-}
-//#endregion
-//#region extensions/whatsapp/src/auto-reply/monitor/listener-log.ts
-function formatWhatsAppInboundListeningLog(account) {
-	if (account.groupPolicy === "disabled") return "Listening for WhatsApp inbound messages (DM + groups disabled by groupPolicy).";
-	if (account.groupPolicy === "allowlist" && !account.hasGroupAllowFrom) return "Listening for WhatsApp inbound messages (DM + group inbound blocked by empty groupPolicy allowlist).";
-	const groups = account.groups ?? {};
-	if (Object.keys(groups).length === 0) return `Listening for WhatsApp inbound messages (DM + all groups; ${account.groupPolicy === "allowlist" ? "sender allowlist configured" : "no group allowlist configured"}).`;
-	if (Object.hasOwn(groups, "*")) return "Listening for WhatsApp inbound messages (DM + all groups; wildcard configured).";
-	const explicitGroupCount = Object.keys(groups).length;
-	return `Listening for WhatsApp inbound messages (DM + ${explicitGroupCount} configured ${explicitGroupCount === 1 ? "group" : "groups"}).`;
-}
-//#endregion
-//#region extensions/whatsapp/src/auto-reply/monitor/ack-emoji.ts
-const DEFAULT_WHATSAPP_ACK_REACTION = "👀";
-function resolveWhatsAppAckEmoji(params) {
-	if (!params.ackConfig) return "";
-	return (typeof params.ackConfig === "string" ? params.ackConfig : params.ackConfig.emoji)?.trim() || resolveAgentIdentityEmoji(params.cfg, params.agentId) || DEFAULT_WHATSAPP_ACK_REACTION;
-}
-function resolveAgentIdentityEmoji(cfg, agentId) {
-	return resolveAgentIdentity(cfg, agentId)?.emoji?.trim() || void 0;
-}
-//#endregion
-//#region extensions/whatsapp/src/auto-reply/monitor/group-activation.ts
-function hasNamedWhatsAppAccounts(cfg) {
-	return Object.keys(cfg.channels?.whatsapp?.accounts ?? {}).some((accountId) => normalizeAccountId$1(accountId) !== DEFAULT_ACCOUNT_ID$1);
-}
-function isActivationOnlyEntry(entry) {
-	return entry?.groupActivation !== void 0 && typeof entry?.sessionId !== "string" && typeof entry?.updatedAt !== "number";
-}
-/** Resolves group activation for a WhatsApp conversation and backfills scoped session metadata. */
-async function resolveGroupActivationFor(params) {
-	const sessionScope = {
-		storePath: resolveStorePath(params.cfg.session?.store, { agentId: params.agentId }),
-		agentId: params.agentId
-	};
-	const legacySessionKey = resolveWhatsAppLegacyGroupSessionKey({
-		sessionKey: params.sessionKey,
-		accountId: params.accountId
-	});
-	const legacyEntry = legacySessionKey ? getSessionEntry({
-		...sessionScope,
-		sessionKey: legacySessionKey
-	}) : void 0;
-	const scopedEntry = getSessionEntry({
-		...sessionScope,
-		sessionKey: params.sessionKey
-	});
-	const activation = (normalizeAccountId$1(params.accountId) === DEFAULT_ACCOUNT_ID$1 && hasNamedWhatsAppAccounts(params.cfg) && isActivationOnlyEntry(scopedEntry) ? void 0 : scopedEntry?.groupActivation) ?? legacyEntry?.groupActivation;
-	if (activation !== void 0 && scopedEntry?.groupActivation === void 0) {
-		if (scopedEntry) await patchSessionEntry({
-			...sessionScope,
-			sessionKey: params.sessionKey,
-			replaceEntry: true,
-			update: (entry) => {
-				if (entry.groupActivation !== void 0) return null;
-				return {
-					...entry,
-					groupActivation: activation
-				};
-			}
-		});
-	}
-	const defaultActivation = !resolveWhatsAppInboundPolicy({
-		cfg: params.cfg,
-		accountId: params.accountId
-	}).resolveConversationRequireMention(params.conversationId) ? "always" : "mention";
-	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;
-	const admission = requireWhatsAppInboundAdmission(params.msg);
-	const accountId = admission.accountId;
-	if (resolveWhatsAppReactionLevel({
-		cfg: params.cfg,
-		accountId
-	}).level === "off") return null;
-	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 = 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({
-		cfg: params.cfg,
-		accountId,
-		agentId: params.agentId,
-		sessionKey: params.sessionKey,
-		conversationId: conversationIdForCheck
-	}) : null;
-	const shouldSendReaction = () => shouldAckReactionForWhatsApp({
-		emoji,
-		isDirect: admission.conversation.kind === "direct",
-		isGroup,
-		directEnabled,
-		groupMode,
-		wasMentioned: (params.msg.groupMention?.wasMentioned ?? params.msg.wasMentioned) === true,
-		groupActivated: activation === "always"
-	});
-	if (!shouldSendReaction()) return null;
-	params.info({
-		chatId: params.msg.platform.chatJid,
-		messageId: params.msg.event.id,
-		emoji
-	}, "sending ack reaction");
-	const participant = resolveReactionParticipant(params.msg);
-	const reactionOptions = {
-		verbose: params.verbose,
-		fromMe: false,
-		...participant ? { participant } : {},
-		accountId,
-		cfg: params.cfg
-	};
-	return createAckReactionHandle({
-		ackReactionValue: emoji,
-		send: () => sendReactionWhatsApp(params.msg.platform.chatJid, params.msg.event.id, emoji, reactionOptions),
-		remove: () => sendReactionWhatsApp(params.msg.platform.chatJid, params.msg.event.id, "", reactionOptions),
-		onSendError: (err) => {
-			params.warn({
-				error: formatError(err),
-				chatId: params.msg.platform.chatJid,
-				messageId: params.msg.event.id
-			}, "failed to send ack reaction");
-			logVerbose(`WhatsApp ack reaction failed for chat ${params.msg.platform.chatJid}: ${formatError(err)}`);
-		}
-	});
-}
-//#endregion
-//#region extensions/whatsapp/src/auto-reply/monitor/broadcast.ts
-function buildBroadcastRouteKeys(params) {
-	const admission = requireWhatsAppInboundAdmission(params.msg);
-	const sessionKey = buildAgentSessionKey({
-		agentId: params.agentId,
-		channel: "whatsapp",
-		accountId: params.route.accountId,
-		peer: {
-			kind: admission.conversation.kind,
-			id: params.peerId
-		},
-		dmScope: params.cfg.session?.dmScope,
-		identityLinks: params.cfg.session?.identityLinks
-	});
-	const mainSessionKey = buildAgentMainSessionKey({
-		agentId: params.agentId,
-		mainKey: DEFAULT_MAIN_KEY
-	});
-	return {
-		sessionKey,
-		mainSessionKey,
-		lastRoutePolicy: deriveLastRoutePolicy({
-			sessionKey,
-			mainSessionKey
-		})
-	};
-}
-async function maybeBroadcastMessage(params) {
-	const broadcastAgents = params.cfg.broadcast?.[params.peerId];
-	if (!broadcastAgents || !Array.isArray(broadcastAgents)) return false;
-	if (broadcastAgents.length === 0) return false;
-	const strategy = params.cfg.broadcast?.strategy || "parallel";
-	whatsappInboundLog.info(`Broadcasting message to ${broadcastAgents.length} agents (${strategy})`);
-	const agentIds = params.cfg.agents?.list?.map((agent) => normalizeAgentId(agent.id));
-	const hasKnownAgents = (agentIds?.length ?? 0) > 0;
-	const isGroupConversation = requireWhatsAppInboundAdmission(params.msg).conversation.kind === "group";
-	const groupHistorySnapshot = isGroupConversation ? params.groupHistories.get(params.groupHistoryKey) ?? [] : void 0;
-	const processForAgent = async (agentId) => {
-		const normalizedAgentId = normalizeAgentId(agentId);
-		if (hasKnownAgents && !agentIds?.includes(normalizedAgentId)) {
-			whatsappInboundLog.warn(`Broadcast agent ${agentId} not found in agents.list; skipping`);
-			return false;
-		}
-		const routeKeys = buildBroadcastRouteKeys({
-			cfg: params.cfg,
-			msg: params.msg,
-			route: params.route,
-			peerId: params.peerId,
-			agentId: normalizedAgentId
-		});
-		const baseAgentRoute = {
-			...params.route,
-			agentId: normalizedAgentId,
-			...routeKeys
-		};
-		const agentRoute = isGroupConversation ? resolveWhatsAppGroupSessionRoute(baseAgentRoute) : baseAgentRoute;
-		try {
-			const opts = {
-				groupHistory: groupHistorySnapshot,
-				suppressGroupHistoryClear: true
-			};
-			if (params.preflightAudioTranscript !== void 0) opts.preflightAudioTranscript = params.preflightAudioTranscript;
-			if (params.ackAlreadySent === true) opts.ackAlreadySent = true;
-			if (params.ackReaction !== void 0) opts.ackReaction = params.ackReaction;
-			return await params.processMessage(params.msg, agentRoute, params.groupHistoryKey, opts);
-		} catch (err) {
-			whatsappInboundLog.error(`Broadcast agent ${agentId} failed: ${formatError(err)}`);
-			return false;
-		}
-	};
-	if (strategy === "sequential") for (const agentId of broadcastAgents) await processForAgent(agentId);
-	else await Promise.allSettled(broadcastAgents.map(processForAgent));
-	if (isGroupConversation) params.groupHistories.set(params.groupHistoryKey, []);
-	return true;
-}
-//#endregion
-//#region extensions/whatsapp/src/auto-reply/monitor/commands.ts
-function stripMentionsForCommand(text, mentionRegexes, selfE164) {
-	let result = text;
-	for (const re of mentionRegexes) result = result.replace(re, " ");
-	if (selfE164) {
-		const digits = selfE164.replace(/\D/g, "");
-		if (digits) {
-			const pattern = new RegExp(`\\+?${digits}`, "g");
-			result = result.replace(pattern, " ");
-		}
-	}
-	return result.replace(/\s+/g, " ").trim();
-}
-//#endregion
-//#region extensions/whatsapp/src/auto-reply/monitor/group-members.ts
-function appendNormalizedUnique(entries, seen, ordered) {
-	for (const entry of entries) {
-		const normalized = normalizeE164(entry) ?? entry;
-		if (!normalized || seen.has(normalized)) continue;
-		seen.add(normalized);
-		ordered.push(normalized);
-	}
-}
-function noteGroupMember(groupMemberNames, conversationId, e164, name) {
-	if (!e164 || !name) return;
-	const key = normalizeE164(e164) ?? e164;
-	if (!key) return;
-	let roster = groupMemberNames.get(conversationId);
-	if (!roster) {
-		roster = /* @__PURE__ */ new Map();
-		groupMemberNames.set(conversationId, roster);
-	}
-	roster.set(key, name);
-}
-function formatGroupMembers(params) {
-	const { participants, roster, fallbackE164 } = params;
-	const seen = /* @__PURE__ */ new Set();
-	const ordered = [];
-	if (participants?.length) appendNormalizedUnique(participants, seen, ordered);
-	if (roster) appendNormalizedUnique(roster.keys(), seen, ordered);
-	if (ordered.length === 0 && fallbackE164) {
-		const normalized = normalizeE164(fallbackE164) ?? fallbackE164;
-		if (normalized) ordered.push(normalized);
-	}
-	if (ordered.length === 0) return;
-	return ordered.map((entry) => {
-		const name = roster?.get(entry);
-		return name ? `${name} (${entry})` : entry;
-	}).join(", ");
-}
-//#endregion
-//#region extensions/whatsapp/src/auto-reply/monitor/group-gating.ts
-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 ?? "");
-	if (!sender) return false;
-	return resolveOwnerList(baseMentionConfig, getSelfIdentity(msg, authDir).e164 ?? void 0).includes(sender);
-}
-function recordPendingGroupHistoryEntry(params) {
-	const senderIdentity = getSenderIdentity(params.msg);
-	const sender = senderIdentity.name && senderIdentity.e164 ? `${senderIdentity.name} (${senderIdentity.e164})` : senderIdentity.name ?? senderIdentity.e164 ?? getPrimaryIdentityId(senderIdentity) ?? "Unknown";
-	createChannelHistoryWindow({ historyMap: params.groupHistories }).record({
-		historyKey: params.groupHistoryKey,
-		limit: params.groupHistoryLimit,
-		entry: {
-			sender,
-			body: params.body ?? params.msg.payload.body,
-			timestamp: params.msg.event.timestamp,
-			id: params.msg.event.id,
-			senderJid: senderIdentity.jid ?? params.msg.platform.senderJid,
-			...params.body === void 0 && params.msg.payload.media ? { media: [{
-				path: params.msg.payload.media.path,
-				url: params.msg.payload.media.url ?? params.msg.payload.media.path,
-				contentType: params.msg.payload.media.type,
-				kind: params.msg.payload.media.kind ?? void 0
-			}] } : {}
-		}
-	});
-}
-function skipGroupMessageAndStoreHistory(params, verboseMessage, body) {
-	params.logVerbose(verboseMessage);
-	recordPendingGroupHistoryEntry({
-		msg: params.msg,
-		body,
-		groupHistories: params.groupHistories,
-		groupHistoryKey: params.groupHistoryKey,
-		groupHistoryLimit: params.groupHistoryLimit
-	});
-	return { shouldProcess: false };
-}
-async function applyGroupGating(params) {
-	const sender = getSenderIdentity(params.msg);
-	const self = getSelfIdentity(params.msg, params.authDir);
-	const admission = requireWhatsAppInboundAdmission(params.msg);
-	const conversationId = admission.conversation.id;
-	const inboundPolicy = resolveWhatsAppInboundPolicy({
-		cfg: params.cfg,
-		accountId: admission.accountId,
-		selfE164: self.e164 ?? null
-	});
-	const conversationGroupPolicy = inboundPolicy.resolveConversationGroupPolicy(conversationId);
-	if (conversationGroupPolicy.allowlistEnabled && !conversationGroupPolicy.allowed) {
-		const accountId = inboundPolicy.account.accountId;
-		if (shouldWarnForGroupDrop(`${accountId}:${conversationId}`)) {
-			const groupsPath = resolveWhatsAppGroupsConfigPath({
-				cfg: params.cfg,
-				accountId
-			});
-			params.replyLogger.warn({
-				conversationId,
-				accountId,
-				groupsPath
-			}, `WhatsApp group ${conversationId} not in ${groupsPath} — inbound dropped. Add the group JID to ${groupsPath} (or add "*" there to admit all groups). Sender authorization still applies.`);
-		}
-		params.logVerbose(`Dropping message from unregistered WhatsApp group ${conversationId}. Add the group JID to channels.whatsapp.groups, or add "*" there to admit all groups. Sender authorization still applies.`);
-		return { shouldProcess: false };
-	}
-	noteGroupMember(params.groupMemberNames, params.groupHistoryKey, sender.e164 ?? void 0, sender.name ?? void 0);
-	const baseMentionConfig = {
-		...params.baseMentionConfig,
-		allowFrom: inboundPolicy.configuredAllowFrom
-	};
-	const mentionConfig = {
-		...buildMentionConfig(params.cfg, params.agentId, {
-			provider: "whatsapp",
-			conversationId,
-			providerPolicy: params.providerMentionPatterns
-		}),
-		allowFrom: inboundPolicy.configuredAllowFrom
-	};
-	const mentionMsg = params.mentionText !== void 0 ? {
-		...params.msg,
-		payload: {
-			...params.msg.payload,
-			body: params.mentionText
-		}
-	} : {
-		...params.msg,
-		payload: {
-			...params.msg.payload,
-			body: params.msg.payload.commandBody ?? params.msg.payload.body
-		}
-	};
-	const commandBody = stripMentionsForCommand(mentionMsg.payload.body, mentionConfig.mentionRegexes, self.e164);
-	const activationCommand = parseActivationCommand(commandBody);
-	const owner = isOwnerSender(baseMentionConfig, params.msg, params.authDir);
-	const shouldBypassMention = owner && hasControlCommand(commandBody, params.cfg);
-	if (activationCommand.hasCommand && !owner) return skipGroupMessageAndStoreHistory(params, `Ignoring /activation from non-owner in group ${conversationId}`);
-	const mentionDebug = debugMention(mentionMsg, mentionConfig, params.authDir);
-	params.replyLogger.debug({
-		conversationId,
-		wasMentioned: mentionDebug.wasMentioned,
-		...mentionDebug.details
-	}, "group mention debug");
-	const wasMentioned = mentionDebug.wasMentioned;
-	const requireMention = await resolveGroupActivationFor({
-		cfg: params.cfg,
-		accountId: inboundPolicy.account.accountId,
-		agentId: params.agentId,
-		sessionKey: params.sessionKey,
-		conversationId
-	}) !== "always";
-	const replyContext = getReplyContext(params.msg, params.authDir);
-	const mentionDecision = resolveInboundMentionDecision({
-		facts: {
-			canDetectMention: true,
-			wasMentioned,
-			implicitMentionKinds: implicitMentionKindWhen("quoted_bot", !(params.selfChatMode === true && identitiesOverlap(self, sender)) && identitiesOverlap(self, replyContext?.sender))
-		},
-		policy: {
-			isGroup: true,
-			requireMention,
-			allowTextCommands: false,
-			hasControlCommand: false,
-			commandAuthorized: false
-		}
-	});
-	const effectiveWasMentioned = mentionDecision.effectiveWasMentioned || shouldBypassMention;
-	params.msg.groupMention = {
-		wasMentioned: effectiveWasMentioned,
-		requireMention
-	};
-	if (!shouldBypassMention && requireMention && mentionDecision.shouldSkip) {
-		if (params.deferMissingMention === true) {
-			params.logVerbose(`Deferring group mention skip until audio preflight completes in ${conversationId}`);
-			return {
-				shouldProcess: false,
-				needsMentionText: true
-			};
-		}
-		return skipGroupMessageAndStoreHistory(params, `Group message stored for context (no mention detected) in ${conversationId}: ${mentionMsg.payload.body}`, params.mentionText);
-	}
-	return { shouldProcess: true };
-}
-//#endregion
-//#region extensions/whatsapp/src/auto-reply/monitor/last-route.ts
-function trackBackgroundTask(backgroundTasks, task) {
-	backgroundTasks.add(task);
-	const cleanup = () => {
-		backgroundTasks.delete(task);
-	};
-	task.then(cleanup, cleanup);
-}
-function updateLastRouteInBackground(params) {
-	const storePath = resolveStorePath$1(params.cfg.session?.store, { agentId: params.storeAgentId });
-	const task = updateLastRoute({
-		storePath,
-		sessionKey: params.sessionKey,
-		deliveryContext: {
-			channel: params.channel,
-			to: params.to,
-			accountId: params.accountId
-		},
-		ctx: params.ctx
-	}).catch((err) => {
-		params.warn({
-			error: formatError(err),
-			storePath,
-			sessionKey: params.sessionKey,
-			to: params.to
-		}, "failed updating last route");
-	});
-	trackBackgroundTask(params.backgroundTasks, task);
-}
-//#endregion
-//#region extensions/whatsapp/src/auto-reply/monitor/peer.ts
-function resolvePeerId(msg) {
-	const admission = requireWhatsAppInboundAdmission(msg);
-	if (admission.conversation.kind === "group") return admission.conversation.id;
-	const sender = getSenderIdentity(msg);
-	if (sender.e164) return normalizeE164(sender.e164) ?? sender.e164;
-	const conversationId = admission.conversation.id;
-	if (conversationId.includes("@")) return jidToE164(conversationId) ?? conversationId;
-	return normalizeE164(conversationId) ?? conversationId;
-}
-//#endregion
-//#region extensions/whatsapp/src/system-prompt.ts
-function resolveWhatsAppGroupSystemPrompt(params) {
-	if (!params.groupId) return;
-	const groups = params.accountConfig?.groups;
-	const specific = groups?.[params.groupId];
-	if (specific != null && specific.systemPrompt != null) return specific.systemPrompt.trim() || void 0;
-	const wildcard = groups?.["*"]?.systemPrompt;
-	return wildcard != null ? wildcard.trim() || void 0 : void 0;
-}
-function resolveWhatsAppDirectSystemPrompt(params) {
-	if (!params.peerId) return;
-	const direct = params.accountConfig?.direct;
-	const specific = direct?.[params.peerId];
-	if (specific != null && specific.systemPrompt != null) return specific.systemPrompt.trim() || void 0;
-	const wildcard = direct?.["*"]?.systemPrompt;
-	return wildcard != null ? wildcard.trim() || void 0 : void 0;
-}
-//#endregion
-//#region extensions/whatsapp/src/outbound-retry.ts
-const WHATSAPP_OUTBOUND_MAX_ATTEMPTS = 3;
-const WHATSAPP_OUTBOUND_MIN_DELAY_MS = 500;
-const WHATSAPP_OUTBOUND_MAX_DELAY_MS = 1e3;
-const WHATSAPP_RETRYABLE_OUTBOUND_ERROR_PATTERN = /closed|reset|timed\s*out|disconnect/i;
-var WhatsAppOutboundRetryError = class extends Error {
-	constructor(original) {
-		super(formatError(original), { cause: original });
-		this.original = original;
-	}
-};
-function isRetryableWhatsAppOutboundError(error) {
-	if (isWhatsAppSocketOperationTimeoutError(error)) return false;
-	return WHATSAPP_RETRYABLE_OUTBOUND_ERROR_PATTERN.test(formatError(error));
-}
-async function sendWhatsAppOutboundWithRetry(params) {
-	const runWithRetry = createChannelApiRetryRunner({
-		retry: {
-			attempts: WHATSAPP_OUTBOUND_MAX_ATTEMPTS,
-			minDelayMs: WHATSAPP_OUTBOUND_MIN_DELAY_MS,
-			maxDelayMs: WHATSAPP_OUTBOUND_MAX_DELAY_MS,
-			jitter: 0
-		},
-		strictShouldRetry: true,
-		retryAfterMs: () => void 0,
-		shouldRetry: (error, attempt) => {
-			if (!(error instanceof WhatsAppOutboundRetryError) || !isRetryableWhatsAppOutboundError(error.original)) return false;
-			params.onRetry?.({
-				attempt,
-				maxAttempts: WHATSAPP_OUTBOUND_MAX_ATTEMPTS,
-				backoffMs: Math.min(WHATSAPP_OUTBOUND_MIN_DELAY_MS * 2 ** (attempt - 1), WHATSAPP_OUTBOUND_MAX_DELAY_MS),
-				error: error.original,
-				errorText: formatError(error.original)
-			});
-			return true;
-		}
-	});
-	try {
-		return await runWithRetry(async () => {
-			try {
-				return await params.send();
-			} catch (error) {
-				throw new WhatsAppOutboundRetryError(error);
-			}
-		});
-	} catch (error) {
-		if (error instanceof WhatsAppOutboundRetryError) throw error.original;
-		throw error;
-	}
-}
-//#endregion
-//#region extensions/whatsapp/src/auto-reply/util.ts
-function elide(text, limit = 400) {
-	if (!text) return text;
-	if (text.length <= limit) return text;
-	const truncated = truncateUtf16Safe(text, limit);
-	return `${truncated}… (truncated ${text.length - truncated.length} chars)`;
-}
-function markWhatsAppVisibleDeliveryError(error) {
-	if (typeof error === "object" && error !== null && !Array.isArray(error)) try {
-		Object.assign(error, {
-			sentBeforeError: true,
-			visibleReplySent: true
-		});
-		return error;
-	} catch {}
-	const visibleError = new Error("visible WhatsApp reply delivery failed", { cause: error });
-	Object.assign(visibleError, {
-		sentBeforeError: true,
-		visibleReplySent: true
-	});
-	return visibleError;
-}
-function isLikelyWhatsAppCryptoError(reason) {
-	const formatReason = (value) => {
-		if (value == null) return "";
-		if (typeof value === "string") return value;
-		if (value instanceof Error) return `${value.message}\n${value.stack ?? ""}`;
-		if (typeof value === "object") try {
-			return JSON.stringify(value);
-		} 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 === "symbol") return value.description ?? value.toString();
-		if (typeof value === "function") return value.name ? `[function ${value.name}]` : "[function]";
-		return Object.prototype.toString.call(value);
-	};
-	const haystack = normalizeLowercaseStringOrEmpty(reason instanceof Error ? `${reason.message}\n${reason.stack ?? ""}` : formatReason(reason));
-	if (!(haystack.includes("unsupported state or unable to authenticate data") || haystack.includes("bad mac"))) return false;
-	return haystack.includes("baileys") || haystack.includes("noise-handler") || haystack.includes("aesdecryptgcm");
-}
-//#endregion
-//#region extensions/whatsapp/src/auto-reply/deliver-reply.ts
-function resolveWhatsAppReceiptKind(results) {
-	if (results.length > 0 && results.every((result) => result.kind === "text")) return "text";
-	if (results.length > 0 && results.every((result) => result.kind === "media")) return "media";
-	return "unknown";
-}
-function createWhatsAppReplyDeliveryReceipt(results) {
-	const receiptResultsById = /* @__PURE__ */ new Map();
-	for (const result of results) {
-		if (result.receipt?.parts.length) {
-			for (const part of result.receipt.parts) receiptResultsById.set(part.platformMessageId, {
-				...part.raw ?? {
-					channel: "whatsapp",
-					messageId: part.platformMessageId
-				},
-				meta: {
-					...part.raw?.meta,
-					kind: result.kind,
-					providerAccepted: result.providerAccepted
-				}
-			});
-			continue;
-		}
-		for (const messageId of listWhatsAppSendResultMessageIds(result)) receiptResultsById.set(messageId, {
-			channel: "whatsapp",
-			messageId,
-			meta: {
-				kind: result.kind,
-				providerAccepted: result.providerAccepted
-			}
-		});
-	}
-	return createMessageReceiptFromOutboundResults({
-		results: [...receiptResultsById.values()],
-		kind: resolveWhatsAppReceiptKind(results)
-	});
-}
-async function deliverWebReply(params) {
-	const { replyResult, msg, maxMediaBytes, textLimit, replyLogger, connectionId, skipLog } = params;
-	const admission = requireWhatsAppInboundAdmission(msg);
-	const conversationId = admission.conversation.id;
-	const isGroupConversation = admission.conversation.kind === "group";
-	const replyStarted = Date.now();
-	const sendResults = [];
-	const rememberSendResult = (result) => {
-		if (result) sendResults.push(result);
-	};
-	const finishDelivery = () => {
-		const receipt = createWhatsAppReplyDeliveryReceipt(sendResults);
-		return {
-			results: sendResults,
-			receipt,
-			providerAccepted: sendResults.some((result) => result.providerAccepted)
-		};
-	};
-	if (isReasoningReplyPayload(replyResult)) {
-		whatsappOutboundLog.debug(`Suppressed reasoning payload to ${conversationId}`);
-		return finishDelivery();
-	}
-	const tableMode = params.tableMode ?? "code";
-	const chunkMode = params.chunkMode ?? "length";
-	const normalizedReply = params.normalizedReplyResult ?? normalizeWhatsAppOutboundPayload(replyResult, { normalizeText: normalizeWhatsAppPayloadTextPreservingIndentation });
-	const textChunks = markdownToWhatsAppChunks(normalizedReply.text ?? "", textLimit, tableMode, chunkMode);
-	const mediaList = normalizedReply.mediaUrls ?? [];
-	const getQuote = () => {
-		if (!replyResult.replyToId) return;
-		const cached = lookupInboundMessageMeta(admission.accountId, msg.platform.chatJid, replyResult.replyToId);
-		return buildQuotedMessageOptions({
-			messageId: replyResult.replyToId,
-			remoteJid: msg.platform.chatJid,
-			fromMe: cached?.fromMe ?? false,
-			participant: cached?.participant ?? (isGroupConversation ? msg.platform.senderJid : void 0),
-			messageText: cached?.body ?? "",
-			media: cached?.media
-		});
-	};
-	const sendWithRetry = async (fn, label) => {
-		try {
-			return await sendWhatsAppOutboundWithRetry({
-				send: fn,
-				onRetry: ({ attempt, maxAttempts: retryMaxAttempts, backoffMs, errorText }) => {
-					logVerbose(`Retrying ${label} to ${conversationId} after failure (${attempt}/${retryMaxAttempts - 1}) in ${backoffMs}ms: ${errorText}`);
-				}
-			});
-		} catch (error) {
-			if (sendResults.some((result) => result.providerAccepted)) throw markWhatsAppVisibleDeliveryError(error);
-			throw error;
-		}
-	};
-	if (mediaList.length === 0 && textChunks.length) {
-		const totalChunks = textChunks.length;
-		for (const [index, chunk] of textChunks.entries()) {
-			const chunkStarted = Date.now();
-			const quote = getQuote();
-			rememberSendResult(await sendWithRetry(() => msg.platform.reply(chunk, quote), "text"));
-			if (!skipLog) {
-				const durationMs = Date.now() - chunkStarted;
-				whatsappOutboundLog.debug(`Sent chunk ${index + 1}/${totalChunks} to ${conversationId} (${durationMs.toFixed(0)}ms)`);
-			}
-		}
-		const delivery = finishDelivery();
-		const logPayload = {
-			correlationId: msg.event.id ?? newConnectionId(),
-			connectionId: connectionId ?? null,
-			to: conversationId,
-			from: msg.platform.recipientJid,
-			text: elide(replyResult.text, 240),
-			mediaUrl: null,
-			mediaSizeBytes: null,
-			mediaKind: null,
-			durationMs: Date.now() - replyStarted
-		};
-		if (delivery.providerAccepted) replyLogger.info(logPayload, "auto-reply sent (text)");
-		else replyLogger.warn(logPayload, "auto-reply text was not accepted by WhatsApp provider");
-		return delivery;
-	}
-	const remainingText = [...textChunks];
-	await sendMediaWithLeadingCaption({
-		mediaUrls: mediaList,
-		caption: remainingText.shift() || "",
-		send: async ({ mediaUrl, caption }) => {
-			const media = await prepareWhatsAppOutboundMedia(await loadWebMedia(mediaUrl, {
-				maxBytes: maxMediaBytes,
-				localRoots: params.mediaLocalRoots
-			}), mediaUrl);
-			if (shouldLogVerbose()) {
-				logVerbose(`Web auto-reply media size: ${(media.buffer.length / (1024 * 1024)).toFixed(2)}MB`);
-				logVerbose(`Web auto-reply media source: ${mediaUrl} (kind ${media.kind})`);
-			}
-			if (media.kind === "image") {
-				const quote = getQuote();
-				rememberSendResult(await sendWithRetry(() => msg.platform.sendMedia({
-					image: media.buffer,
-					caption,
-					mimetype: media.mimetype
-				}, quote), "media:image"));
-			} else if (media.kind === "audio") {
-				const quote = getQuote();
-				rememberSendResult(await sendWithRetry(() => msg.platform.sendMedia({
-					audio: media.buffer,
-					ptt: true,
-					mimetype: media.mimetype
-				}, quote), "media:audio"));
-				if (caption) rememberSendResult(await sendWithRetry(() => msg.platform.reply(caption, quote), "media:audio-text"));
-			} else if (media.kind === "video") {
-				const quote = getQuote();
-				rememberSendResult(await sendWithRetry(() => msg.platform.sendMedia({
-					video: media.buffer,
-					caption,
-					mimetype: media.mimetype
-				}, quote), "media:video"));
-			} else {
-				const quote = getQuote();
-				rememberSendResult(await sendWithRetry(() => msg.platform.sendMedia({
-					document: media.buffer,
-					fileName: media.fileName,
-					caption,
-					mimetype: media.mimetype
-				}, quote), "media:document"));
-			}
-			whatsappOutboundLog.info(`Sent media reply to ${conversationId} (${(media.buffer.length / (1024 * 1024)).toFixed(2)}MB)`);
-			replyLogger.info({
-				correlationId: msg.event.id ?? newConnectionId(),
-				connectionId: connectionId ?? null,
-				to: conversationId,
-				from: msg.platform.recipientJid,
-				text: caption ?? null,
-				mediaUrl,
-				mediaSizeBytes: media.buffer.length,
-				mediaKind: media.kind,
-				durationMs: Date.now() - replyStarted
-			}, "auto-reply sent (media)");
-		},
-		onError: async ({ error, mediaUrl, caption, isFirst }) => {
-			whatsappOutboundLog.error(`Failed sending web media to ${conversationId}: ${formatError(error)}`);
-			replyLogger.warn({
-				err: error,
-				mediaUrl
-			}, "failed to send web media reply");
-			if (!isFirst) {
-				whatsappOutboundLog.warn(`Trailing media failed; sent warning to ${conversationId}`);
-				rememberSendResult(await sendWithRetry(() => msg.platform.reply("⚠️ Media unavailable.", getQuote()), "media:fallback-unavailable"));
-				return;
-			}
-			const fallbackText = [caption ?? "", "⚠️ Media failed."].filter(Boolean).join("\n");
-			if (!fallbackText) return;
-			whatsappOutboundLog.warn(`Media skipped; sent text-only to ${conversationId}`);
-			rememberSendResult(await sendWithRetry(() => msg.platform.reply(fallbackText, getQuote()), "media:fallback-text"));
-		}
-	});
-	for (const chunk of remainingText) rememberSendResult(await sendWithRetry(() => msg.platform.reply(chunk, getQuote()), "media:text"));
-	return finishDelivery();
-}
-//#endregion
-//#region extensions/whatsapp/src/auto-reply/monitor/inbound-context.ts
-function isWhatsAppSupplementalSenderAllowed(params) {
-	if (params.allowFrom.includes("*")) return true;
-	const senderValues = new Set(getComparableIdentityValues(resolveComparableIdentity(params.sender, params.authDir)));
-	if (senderValues.size === 0) return false;
-	for (const entry of params.allowFrom) {
-		const rawEntry = entry.trim();
-		if (!rawEntry) continue;
-		const normalizedEntry = normalizeE164(rawEntry);
-		if (normalizedEntry && senderValues.has(normalizedEntry) || senderValues.has(rawEntry)) return true;
-	}
-	return false;
-}
-function resolveVisibleWhatsAppGroupHistory(params) {
-	return filterSupplementalContextItems({
-		items: params.history,
-		mode: params.mode,
-		kind: "history",
-		isSenderAllowed: (entry) => resolveInboundSupplementalSenderAllowed({
-			isGroup: true,
-			groupPolicy: params.groupPolicy,
-			allowFrom: params.groupAllowFrom,
-			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 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,
-		isSenderAllowed: (allowFrom) => isWhatsAppSupplementalSenderAllowed({
-			allowFrom,
-			authDir: params.authDir,
-			sender: replyTo.sender
-		})
-	});
-	const visible = filterChannelInboundQuoteContext(params.mode, {
-		id: replyTo.id,
-		body: previewBody,
-		sender: replyTo.sender?.label ?? void 0,
-		senderAllowed
-	});
-	return visible ? {
-		...replyTo,
-		body: visible.body ?? ""
-	} : null;
-}
-//#endregion
-//#region extensions/whatsapp/src/auto-reply/monitor/inbound-dispatch.ts
-function normalizeErrForLog(err) {
-	if (err instanceof Error) return {
-		...Object.fromEntries(Object.entries(err)),
-		type: err.name,
-		message: err.message,
-		stack: err.stack
-	};
-	return err;
-}
-function whatsAppReplyDeliveryVisibility(visibleReplySent) {
-	return { visibleReplySent };
-}
-function whatsAppReplyDeliveryVisibilityFromDurableResult(result) {
-	return whatsAppReplyDeliveryVisibility(result.visibleReplySent === true);
-}
-function readTrimmedString(value) {
-	return typeof value === "string" ? value.trim() : "";
-}
-function markWhatsAppReplyDeliveryErrorVisibleAfterFlush(error, flushResult) {
-	return flushResult.delivered > 0 ? markWhatsAppVisibleDeliveryError(error) : error;
-}
-function logWhatsAppReplyDeliveryError(params) {
-	const admission = requireWhatsAppInboundAdmission(params.msg);
-	params.replyLogger.error({
-		err: normalizeErrForLog(params.err),
-		replyKind: params.info.kind,
-		correlationId: params.msg.event.id ?? null,
-		connectionId: params.connectionId,
-		conversationId: admission.conversation.id,
-		chatId: params.msg.platform.chatJid ?? null,
-		to: admission.conversation.id,
-		from: params.msg.platform.recipientJid ?? null
-	}, "auto-reply delivery failed");
-}
-function resolveWhatsAppDurableReplyToId(params) {
-	if (params.payload.replyToId === null) return null;
-	const explicitPayloadReplyToId = readTrimmedString(params.payload.replyToId);
-	if (explicitPayloadReplyToId) return explicitPayloadReplyToId;
-	const hasVisibleInboundReplyTarget = Boolean(readTrimmedString(params.context.ReplyToId)) || Boolean(readTrimmedString(params.context.ReplyToIdFull));
-	const currentInboundMessageId = readTrimmedString(params.msg.event.id);
-	if (params.info.kind === "final" && hasVisibleInboundReplyTarget && currentInboundMessageId) return currentInboundMessageId;
-	return null;
-}
-function resolveWhatsAppDisableBlockStreaming(cfg) {
-	const enabled = resolveChannelStreamingBlockEnabled(cfg.channels?.whatsapp);
-	return typeof enabled === "boolean" ? !enabled : void 0;
-}
-function resolveWhatsAppDeliverablePayload(payload, info) {
-	if (payload.isReasoning === true || payload.isCompactionNotice === true) return null;
-	if (payload.isError === true) return null;
-	if (info.kind === "tool") {
-		if (!resolveSendableOutboundReplyParts(payload).hasMedia) return null;
-		return {
-			...payload,
-			text: void 0
-		};
-	}
-	return payload;
-}
-function getWhatsAppPayloadMediaUrls(payload) {
-	return new Set(normalizeStringEntries([...Array.isArray(payload.mediaUrls) ? payload.mediaUrls : [], ...typeof payload.mediaUrl === "string" ? [payload.mediaUrl] : []]));
-}
-function hasWhatsAppMediaUrlOverlap(left, right) {
-	for (const url of left) if (right.has(url)) return true;
-	return false;
-}
-function shouldDeferWhatsAppMediaOnlyPayload(params) {
-	return params.info.kind !== "final" && params.reply.hasMedia && !params.reply.text.trim() && params.mediaUrls.size > 0;
-}
-function createWhatsAppMediaOnlyReplyCoalescer(params) {
-	const pendingMediaOnlyPayloads = [];
-	const flushExceptDuplicateMedia = async (mediaUrls) => {
-		const flushResult = {
-			delivered: 0,
-			droppedDuplicateMedia: 0
-		};
-		const pending = pendingMediaOnlyPayloads.splice(0);
-		for (const candidate of pending) {
-			if (mediaUrls && hasWhatsAppMediaUrlOverlap(candidate.mediaUrls, mediaUrls)) {
-				flushResult.droppedDuplicateMedia += 1;
-				continue;
-			}
-			try {
-				if ((await params.deliver(candidate)).visibleReplySent) flushResult.delivered += 1;
-			} catch (error) {
-				throw markWhatsAppReplyDeliveryErrorVisibleAfterFlush(error, flushResult);
-			}
-		}
-		return flushResult;
-	};
-	return {
-		defer(pending) {
-			pendingMediaOnlyPayloads.push(pending);
-		},
-		flushExceptDuplicateMedia,
-		flushAll: () => flushExceptDuplicateMedia()
-	};
-}
-function logWhatsAppMediaOnlyFlushResult(result) {
-	if (!shouldLogVerbose$1()) return;
-	if (result.droppedDuplicateMedia > 0) logVerbose$1(`Dropped ${result.droppedDuplicateMedia} deferred media-only WhatsApp reply payload(s) superseded by captioned media`);
-	if (result.delivered > 0) logVerbose$1(`Flushed ${result.delivered} deferred media-only WhatsApp reply payload(s)`);
-}
-function resolveWhatsAppResponsePrefix(params) {
-	const configuredResponsePrefix = params.cfg.messages?.responsePrefix;
-	return params.pipelineResponsePrefix ?? (configuredResponsePrefix === "auto" ? resolveIdentityNamePrefix$1(params.cfg, params.agentId) : configuredResponsePrefix) ?? (params.isSelfChat ? resolveIdentityNamePrefix$1(params.cfg, params.agentId) : void 0);
-}
-async function buildWhatsAppInboundContext(params) {
-	const admission = requireWhatsAppInboundAdmission(params.msg);
-	const conversationId = admission.conversation.id;
-	const conversationKind = admission.conversation.kind;
-	const wasMentioned = params.msg.groupMention?.wasMentioned ?? params.msg.wasMentioned;
-	const inboundHistory = conversationKind === "group" ? buildInboundHistoryFromEntries({
-		entries: (params.groupHistory ?? []).map((entry) => ({
-			sender: entry.sender,
-			body: entry.body,
-			timestamp: entry.timestamp,
-			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?.path,
-		url: params.msg.payload.media?.url ?? params.msg.payload.media?.path,
-		contentType: params.msg.payload.media?.type,
-		kind: params.msg.payload.media?.kind
-	}] : void 0, { transcribed: (_entry, index) => params.mediaTranscribedIndexes?.includes(index) === true });
-	return buildChannelInboundEventContext({
-		channel: "whatsapp",
-		supplemental: {
-			quote: params.visibleReplyTo ? {
-				id: params.visibleReplyTo.id,
-				body: params.visibleReplyTo.body,
-				sender: params.visibleReplyTo.sender?.label ?? void 0
-			} : void 0,
-			groupSystemPrompt: params.groupSystemPrompt,
-			untrustedContext: params.msg.payload.untrustedStructuredContext
-		},
-		media,
-		messageId: params.msg.event.id,
-		timestamp: params.msg.event.timestamp,
-		from: conversationId,
-		sender: {
-			id: params.sender.id ?? params.sender.e164,
-			name: params.sender.name
-		},
-		conversation: {
-			kind: conversationKind,
-			id: conversationId,
-			label: conversationId
-		},
-		route: {
-			agentId: params.route.agentId,
-			dmScope: params.route.dmScope,
-			accountId: params.route.accountId,
-			routeSessionKey: params.route.sessionKey
-		},
-		reply: {
-			to: params.msg.platform.recipientJid,
-			originatingTo: conversationId
-		},
-		message: {
-			body: params.combinedBody,
-			bodyForAgent: params.bodyForAgent ?? params.msg.payload.body,
-			inboundHistory,
-			rawBody: params.rawBody ?? params.msg.payload.body,
-			commandBody: params.command?.body ?? params.msg.payload.body
-		},
-		sessionTranscript: { historyLimit: conversationKind === "group" ? params.groupHistoryLimit ?? params.groupHistory?.length ?? 0 : 0 },
-		access: {
-			...wasMentioned !== void 0 ? { mentions: {
-				canDetectMention: conversationKind === "group",
-				wasMentioned,
-				requireMention: params.msg.groupMention?.requireMention
-			} } : {},
-			commands: { authorized: params.command?.authorized === true }
-		},
-		command: params.command,
-		extra: {
-			Transcript: params.transcript,
-			GroupSubject: params.msg.group?.subject,
-			GroupMembers: formatGroupMembers({
-				participants: params.msg.group?.participants,
-				roster: params.groupMemberRoster,
-				fallbackE164: params.sender.e164
-			}),
-			SenderE164: params.sender.e164,
-			ReplyThreading: params.replyThreading,
-			SuppressMessageReceivedHooks: params.suppressMessageReceivedHooks,
-			...params.msg.payload.location ? toLocationContext(params.msg.payload.location) : {}
-		}
-	});
-}
-function resolveWhatsAppDmRouteTarget(params) {
-	const admission = requireWhatsAppInboundAdmission(params.msg);
-	const conversationId = admission.conversation.id;
-	if (admission.conversation.kind === "group") return;
-	if (params.senderE164) return params.normalizeE164(params.senderE164) ?? void 0;
-	if (conversationId.includes("@")) return jidToE164(conversationId) ?? void 0;
-	return params.normalizeE164(conversationId) ?? void 0;
-}
-function updateWhatsAppMainLastRoute(params) {
-	const shouldUpdateMainLastRoute = !params.pinnedMainDmRecipient || params.pinnedMainDmRecipient === params.dmRouteTarget;
-	const inboundLastRouteSessionKey = resolveInboundLastRouteSessionKey({
-		route: params.route,
-		sessionKey: params.route.sessionKey
-	});
-	if (params.dmRouteTarget && inboundLastRouteSessionKey === params.route.mainSessionKey && shouldUpdateMainLastRoute) {
-		params.updateLastRoute({
-			cfg: params.cfg,
-			backgroundTasks: params.backgroundTasks,
-			storeAgentId: params.route.agentId,
-			sessionKey: params.route.mainSessionKey,
-			channel: "whatsapp",
-			to: params.dmRouteTarget,
-			accountId: params.route.accountId,
-			ctx: params.ctx,
-			warn: params.warn
-		});
-		return;
-	}
-	if (params.dmRouteTarget && inboundLastRouteSessionKey === params.route.mainSessionKey && params.pinnedMainDmRecipient) logVerbose$1(`Skipping main-session last route update for ${params.dmRouteTarget} (pinned owner ${params.pinnedMainDmRecipient})`);
-}
-function createWhatsAppReplyPlan(params) {
-	const admission = requireWhatsAppInboundAdmission(params.msg);
-	const ingressLifecycle = resolveWhatsAppIngressLifecycle(params.msg);
-	const conversationId = admission.conversation.id;
-	const conversationKind = admission.conversation.kind;
-	const statusReactionController = params.statusReactionController ?? null;
-	const textLimit = params.maxMediaTextChunkLimit ?? resolveTextChunkLimit(params.cfg, "whatsapp");
-	const chunkMode = resolveChunkMode(params.cfg, "whatsapp", params.route.accountId);
-	const tableMode = resolveMarkdownTableMode$1({
-		cfg: params.cfg,
-		channel: "whatsapp",
-		accountId: params.route.accountId
-	});
-	const mediaLocalRoots = getAgentScopedMediaLocalRoots(params.cfg, params.route.agentId);
-	const sourceReplyDeliveryMode = params.context.ChatType === "group" || params.context.ChatType === "channel" ? resolveChannelMessageSourceReplyDeliveryMode({
-		cfg: params.cfg,
-		ctx: params.context
-	}) : void 0;
-	const sourceRepliesAreToolOnly = sourceReplyDeliveryMode === "message_tool_only";
-	const disableBlockStreaming = sourceRepliesAreToolOnly ? true : resolveWhatsAppDisableBlockStreaming(params.cfg);
-	let didSendReply = false;
-	let didLogHeartbeatStrip = false;
-	const deliverNormalizedPayload = async (normalizedDeliveryPayload, info) => {
-		const reply = resolveSendableOutboundReplyParts(normalizedDeliveryPayload);
-		if (!reply.hasMedia && !reply.text.trim()) return whatsAppReplyDeliveryVisibility(false);
-		if (!(await params.deliverReply({
-			replyResult: normalizedDeliveryPayload,
-			normalizedReplyResult: normalizedDeliveryPayload,
-			msg: params.msg,
-			mediaLocalRoots,
-			maxMediaBytes: params.maxMediaBytes,
-			textLimit,
-			chunkMode,
-			replyLogger: params.replyLogger,
-			connectionId: params.connectionId,
-			skipLog: false,
-			tableMode
-		})).providerAccepted) {
-			params.replyLogger.warn({
-				correlationId: params.msg.event.id ?? null,
-				connectionId: params.connectionId,
-				conversationId,
-				chatId: params.msg.platform.chatJid,
-				to: conversationId,
-				from: params.msg.platform.recipientJid,
-				replyKind: info.kind
-			}, "auto-reply was not accepted by WhatsApp provider");
-			return whatsAppReplyDeliveryVisibility(false);
-		}
-		didSendReply = true;
-		const shouldLog = normalizedDeliveryPayload.text ? true : void 0;
-		params.rememberSentText(normalizedDeliveryPayload.text, {
-			combinedBody: params.context.Body,
-			combinedBodySessionKey: params.route.sessionKey,
-			logVerboseMessage: shouldLog
-		});
-		const fromDisplay = conversationId;
-		if (shouldLogVerbose$1()) logVerbose$1(`Reply body: ${normalizedDeliveryPayload.text != null ? reply.text : "<media>"}${reply.hasMedia ? " (media)" : ""} -> ${fromDisplay}`);
-		return whatsAppReplyDeliveryVisibility(true);
-	};
-	const mediaOnlyCoalescer = createWhatsAppMediaOnlyReplyCoalescer({ deliver: async (pending) => {
-		return await deliverNormalizedPayload(pending.payload, pending.info);
-	} });
-	return {
-		afterRecord: () => {
-			if (statusReactionController) statusReactionController.setThinking();
-		},
-		dispatcherOptions: {
-			...params.replyPipeline,
-			onHeartbeatStrip: () => {
-				if (!didLogHeartbeatStrip) {
-					didLogHeartbeatStrip = true;
-					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);
-				const normalizedOutboundPayload = normalizeWhatsAppOutboundPayload(deliveryPayload, { normalizeText: normalizeWhatsAppPayloadTextPreservingIndentation });
-				const normalizedDeliveryPayload = deliveryPayload.text === void 0 ? {
-					...normalizedOutboundPayload,
-					text: void 0
-				} : normalizedOutboundPayload;
-				const reply = resolveSendableOutboundReplyParts(normalizedDeliveryPayload);
-				if (!reply.hasMedia && !reply.text.trim()) return whatsAppReplyDeliveryVisibility(false);
-				if (!reply.hasMedia) {
-					const flushResult = await mediaOnlyCoalescer.flushAll();
-					logWhatsAppMediaOnlyFlushResult(flushResult);
-					try {
-						const durable = await deliverInboundReplyWithMessageSendContext({
-							cfg: params.cfg,
-							channel: "whatsapp",
-							accountId: params.route.accountId,
-							agentId: params.route.agentId,
-							ctxPayload: params.context,
-							payload: normalizedDeliveryPayload,
-							info,
-							to: conversationId,
-							replyToId: resolveWhatsAppDurableReplyToId({
-								context: params.context,
-								info,
-								msg: params.msg,
-								payload: normalizedDeliveryPayload
-							}),
-							formatting: {
-								textLimit,
-								tableMode,
-								chunkMode
-							}
-						});
-						if (durable.status === "failed") {
-							if (durable.sentBeforeError === true) throw markWhatsAppVisibleDeliveryError(durable.error);
-							throw durable.error;
-						}
-						if (durable.status === "handled_visible") {
-							didSendReply = true;
-							const shouldLog = normalizedDeliveryPayload.text ? true : void 0;
-							params.rememberSentText(normalizedDeliveryPayload.text, {
-								combinedBody: params.context.Body,
-								combinedBodySessionKey: params.route.sessionKey,
-								logVerboseMessage: shouldLog
-							});
-							return whatsAppReplyDeliveryVisibilityFromDurableResult(durable.delivery);
-						}
-						if (durable.status === "handled_no_send") return flushResult.delivered > 0 ? whatsAppReplyDeliveryVisibility(true) : whatsAppReplyDeliveryVisibilityFromDurableResult(durable.delivery);
-						const deliveryResult = await deliverNormalizedPayload(normalizedDeliveryPayload, info);
-						return flushResult.delivered > 0 && !deliveryResult.visibleReplySent ? whatsAppReplyDeliveryVisibility(true) : deliveryResult;
-					} catch (error) {
-						throw markWhatsAppReplyDeliveryErrorVisibleAfterFlush(error, flushResult);
-					}
-				}
-				const mediaUrls = getWhatsAppPayloadMediaUrls(normalizedDeliveryPayload);
-				if (shouldDeferWhatsAppMediaOnlyPayload({
-					info,
-					mediaUrls,
-					reply
-				})) {
-					mediaOnlyCoalescer.defer({
-						info,
-						mediaUrls,
-						payload: normalizedDeliveryPayload
-					});
-					return whatsAppReplyDeliveryVisibility(false);
-				}
-				const flushResult = await mediaOnlyCoalescer.flushExceptDuplicateMedia(mediaUrls);
-				logWhatsAppMediaOnlyFlushResult(flushResult);
-				try {
-					const deliveryResult = await deliverNormalizedPayload(normalizedDeliveryPayload, info);
-					return flushResult.delivered > 0 && !deliveryResult.visibleReplySent ? whatsAppReplyDeliveryVisibility(true) : deliveryResult;
-				} catch (error) {
-					throw markWhatsAppReplyDeliveryErrorVisibleAfterFlush(error, flushResult);
-				}
-			},
-			onError: (err, info) => {
-				logWhatsAppReplyDeliveryError({
-					err,
-					info,
-					connectionId: params.connectionId,
-					msg: params.msg,
-					replyLogger: params.replyLogger
-				});
-			}
-		},
-		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);
-				},
-				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;
-		}
-	};
-}
-async function finalizeWhatsAppStatusReaction(params) {
-	if (params.outcome === "done") await params.controller.setDone();
-	else await params.controller.setError();
-	await params.controller.restoreInitial();
-}
-//#endregion
-//#region extensions/whatsapp/src/auto-reply/monitor/message-line.runtime.ts
-function normalizeAgentId$1(agentId) {
-	return agentId.trim().toLowerCase() || "main";
-}
-function resolveIdentityNamePrefix(cfg, agentId) {
-	const normalizedAgentId = normalizeAgentId$1(agentId);
-	const identityName = cfg.agents?.list?.find((agent) => normalizeAgentId$1(agent.id ?? "") === normalizedAgentId)?.identity?.name?.trim();
-	return identityName ? `[${identityName}]` : void 0;
-}
-function resolveMessagePrefix(cfg, agentId, opts) {
-	const configured = opts?.configured;
-	if (configured !== void 0) return configured;
-	if (opts?.hasAllowFrom === true) return "";
-	return resolveIdentityNamePrefix(cfg, agentId) ?? opts?.fallback ?? "[openclaw]";
-}
-//#endregion
-//#region extensions/whatsapp/src/auto-reply/monitor/message-line.ts
-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 { cfg, msg, agentId, previousTimestamp, envelope } = params;
-	const messagePrefix = resolveMessagePrefix(cfg, agentId, {
-		configured: cfg.channels?.whatsapp?.responsePrefix,
-		hasAllowFrom: (cfg.channels?.whatsapp?.allowFrom?.length ?? 0) > 0
-	});
-	const admission = requireWhatsAppInboundAdmission(msg);
-	const conversationId = admission.conversation.id;
-	const conversationKind = admission.conversation.kind;
-	const prefixStr = messagePrefix ? `${messagePrefix} ` : "";
-	const replyContext = params.visibleReplyTo === void 0 ? formatReplyContext(msg) : formatReplyTarget(params.visibleReplyTo);
-	const baseLine = `${prefixStr}${msg.payload.body}${replyContext ? `\n\n${replyContext}` : ""}`;
-	const sender = getSenderIdentity(msg);
-	return formatInboundEnvelope({
-		channel: "WhatsApp",
-		from: conversationKind === "group" ? conversationId : conversationId.replace(/^whatsapp:/, ""),
-		timestamp: msg.event.timestamp,
-		body: baseLine,
-		chatType: conversationKind,
-		sender: {
-			name: sender.name ?? void 0,
-			e164: sender.e164 ?? void 0,
-			id: getPrimaryIdentityId(sender) ?? void 0
-		},
-		previousTimestamp,
-		envelope,
-		fromMe: msg.platform.fromMe
-	});
-}
-//#endregion
-//#region extensions/whatsapp/src/auto-reply/monitor/status-reaction.ts
-async function createWhatsAppStatusReactionController(params) {
-	if (!params.msg.event.id) return null;
-	if ((params.cfg.messages?.statusReactions)?.enabled !== true) return null;
-	const admission = requireWhatsAppInboundAdmission(params.msg);
-	const accountId = admission.accountId;
-	if (resolveWhatsAppReactionLevel({
-		cfg: params.cfg,
-		accountId
-	}).level === "off") return null;
-	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 = 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({
-		cfg: params.cfg,
-		accountId,
-		agentId: params.agentId,
-		sessionKey: params.sessionKey,
-		conversationId: conversationIdForCheck
-	}) : null;
-	if (!shouldAckReactionForWhatsApp({
-		emoji: ackEmoji,
-		isDirect: admission.conversation.kind === "direct",
-		isGroup,
-		directEnabled,
-		groupMode,
-		wasMentioned: (params.msg.groupMention?.wasMentioned ?? params.msg.wasMentioned) === true,
-		groupActivated: activation === "always"
-	})) return null;
-	const participant = resolveReactionParticipant(params.msg);
-	const reactionOptions = {
-		verbose: params.verbose,
-		fromMe: false,
-		...participant ? { participant } : {},
-		accountId,
-		cfg: params.cfg
-	};
-	const chatId = params.msg.platform.chatJid;
-	const msgId = params.msg.event.id;
-	return createStatusReactionController({
-		enabled: true,
-		adapter: {
-			setReaction: async (emoji) => {
-				await sendReactionWhatsApp(chatId, msgId, emoji, reactionOptions);
-			},
-			clearReaction: async () => {
-				await sendReactionWhatsApp(chatId, msgId, "", reactionOptions);
-			}
-		},
-		initialEmoji: ackEmoji,
-		emojis: void 0,
-		onError: (err) => {
-			logVerbose(`WhatsApp status-reaction error for chat ${chatId}/${msgId}: ${String(err)}`);
-		}
-	});
-}
-//#endregion
-//#region extensions/whatsapp/src/auto-reply/monitor/process-message.ts
-const WHATSAPP_MESSAGE_RECEIVED_HOOK_LIMITS = {
-	maxConcurrency: 8,
-	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 shouldEmitWhatsAppMessageReceivedHooks(params) {
-	const channelConfig = params.cfg.channels?.whatsapp;
-	return readWhatsAppMessageReceivedHookOptIn(params.accountId && channelConfig?.accounts ? channelConfig.accounts[params.accountId] : void 0) ?? readWhatsAppMessageReceivedHookOptIn(channelConfig) ?? false;
-}
-function emitWhatsAppMessageReceivedHooks(params) {
-	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;
-	const conversationId = admission.conversation.id;
-	const conversationKind = admission.conversation.kind;
-	const self = getSelfIdentity(params.msg);
-	const inboundPolicy = resolveWhatsAppInboundPolicy({
-		cfg: params.cfg,
-		accountId: params.route.accountId ?? admission.accountId,
-		selfE164: self.e164 ?? null
-	});
-	const account = inboundPolicy.account;
-	const contextVisibilityMode = resolveChannelContextVisibilityMode({
-		cfg: params.cfg,
-		channel: "whatsapp",
-		accountId: account.accountId
-	});
-	const { storePath, envelopeOptions, previousTimestamp } = resolveInboundSessionEnvelopeContext({
-		cfg: params.cfg,
-		agentId: params.route.agentId,
-		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.js");
-		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
-		});
-	} catch {
-		if (shouldLogVerbose$1()) logVerbose$1("whatsapp: audio preflight transcription failed, keeping structured audio");
-	}
-	const msgForAgent = audioTranscript !== void 0 ? {
-		...params.msg,
-		payload: {
-			...params.msg.payload,
-			body: audioTranscript
-		}
-	} : params.msg;
-	const visibleReplyTo = resolveVisibleWhatsAppReplyContext({
-		msg: params.msg,
-		authDir: account.authDir,
-		mode: contextVisibilityMode,
-		groupPolicy: inboundPolicy.groupPolicy,
-		groupAllowFrom: inboundPolicy.groupAllowFrom
-	});
-	let combinedBody = buildInboundLine({
-		cfg: params.cfg,
-		msg: msgForAgent,
-		agentId: params.route.agentId,
-		previousTimestamp,
-		envelope: envelopeOptions,
-		visibleReplyTo
-	});
-	let shouldClearGroupHistory = false;
-	const visibleGroupHistory = conversationKind === "group" ? resolveVisibleWhatsAppGroupHistory({
-		history: params.groupHistory ?? params.groupHistories.get(params.groupHistoryKey) ?? [],
-		mode: contextVisibilityMode,
-		groupPolicy: inboundPolicy.groupPolicy,
-		groupAllowFrom: inboundPolicy.groupAllowFrom,
-		authDir: account.authDir
-	}) : void 0;
-	if (conversationKind === "group") {
-		const history = visibleGroupHistory ?? [];
-		if (history.length > 0) combinedBody = buildHistoryContextFromEntries({
-			entries: history.map((m) => ({
-				sender: m.sender,
-				body: m.body,
-				timestamp: m.timestamp,
-				media: m.media
-			})),
-			currentMessage: combinedBody,
-			excludeLast: false,
-			formatEntry: (entry) => {
-				return formatInboundEnvelope$1({
-					channel: "WhatsApp",
-					from: conversationId,
-					timestamp: entry.timestamp,
-					body: [entry.body, formatMediaPlaceholderText(entry.media ?? [])].filter(Boolean).join("\n"),
-					chatType: "group",
-					senderLabel: entry.sender,
-					envelope: envelopeOptions
-				});
-			}
-		});
-		shouldClearGroupHistory = !(params.suppressGroupHistoryClear ?? false);
-	}
-	const combinedEchoKey = params.buildCombinedEchoKey({
-		sessionKey: params.route.sessionKey,
-		combinedBody
-	});
-	if (params.echoHas(combinedEchoKey)) {
-		logVerbose$1("Skipping auto-reply: detected echo for combined message");
-		params.echoForget(combinedEchoKey);
-		return false;
-	}
-	const statusReactionController = params.statusReactionController ?? (params.cfg.messages?.statusReactions?.enabled === true && !params.ackAlreadySent ? await createWhatsAppStatusReactionController({
-		cfg: params.cfg,
-		msg: params.msg,
-		agentId: params.route.agentId,
-		sessionKey: params.route.sessionKey,
-		verbose: params.verbose
-	}) : null);
-	if (statusReactionController && !params.statusReactionController) statusReactionController.setQueued();
-	let ackReaction = params.ackReaction ?? null;
-	if (!statusReactionController && !ackReaction && params.ackAlreadySent !== true) ackReaction = await maybeSendAckReaction({
-		cfg: params.cfg,
-		msg: params.msg,
-		agentId: params.route.agentId,
-		sessionKey: params.route.sessionKey,
-		verbose: params.verbose,
-		info: params.replyLogger.info.bind(params.replyLogger),
-		warn: params.replyLogger.warn.bind(params.replyLogger)
-	});
-	const correlationId = params.msg.event.id ?? newConnectionId();
-	params.replyLogger.info({
-		connectionId: params.connectionId,
-		correlationId,
-		from: conversationId,
-		to: params.msg.platform.recipientJid,
-		body: elide(combinedBody, 240),
-		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)`);
-	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
-	});
-	const shouldCheckCommandAuth = shouldComputeCommandAuthorized(commandBody, params.cfg);
-	const isTextCommand = isControlCommandMessage(commandBody, params.cfg);
-	const commandAuthorized = shouldCheckCommandAuth ? await resolveWhatsAppCommandAuthorized({
-		cfg: params.cfg,
-		msg: params.msg,
-		policy: inboundPolicy,
-		authDir: account.authDir
-	}) : void 0;
-	const { onModelSelected, ...replyPipeline } = createChannelMessageReplyPipeline({
-		cfg: params.cfg,
-		agentId: params.route.agentId,
-		channel: "whatsapp",
-		accountId: params.route.accountId
-	});
-	const responsePrefix = resolveWhatsAppResponsePrefix({
-		cfg: params.cfg,
-		agentId: params.route.agentId,
-		isSelfChat: conversationKind !== "group" && inboundPolicy.isSelfChat,
-		pipelineResponsePrefix: replyPipeline.responsePrefix
-	});
-	const replyThreading = resolveBatchedReplyThreadingPolicy(account.replyToMode ?? "off", params.msg.event.isBatched === true);
-	const conversationSystemPrompt = conversationKind === "group" ? resolveWhatsAppGroupSystemPrompt({
-		accountConfig: account,
-		groupId: conversationId
-	}) : resolveWhatsAppDirectSystemPrompt({
-		accountConfig: account,
-		peerId: dmRouteTarget ?? conversationId
-	});
-	const ctxPayload = await buildWhatsAppInboundContext({
-		bodyForAgent: msgForAgent.payload.body,
-		combinedBody,
-		command: {
-			kind: isTextCommand ? "text-slash" : "normal",
-			body: commandBody,
-			authorized: commandAuthorized
-		},
-		groupHistory: visibleGroupHistory,
-		groupHistoryLimit: params.groupHistoryLimit,
-		groupMemberRoster: params.groupMemberNames.get(params.groupHistoryKey),
-		groupSystemPrompt: conversationSystemPrompt,
-		msg: params.msg,
-		rawBody: commandBody,
-		route: params.route,
-		sender: {
-			id: getPrimaryIdentityId(sender) ?? void 0,
-			name: sender.name ?? void 0,
-			e164: sender.e164 ?? void 0
-		},
-		...audioTranscript !== void 0 ? { transcript: audioTranscript } : {},
-		...audioTranscript !== void 0 ? { mediaTranscribedIndexes: [0] } : {},
-		replyThreading,
-		visibleReplyTo: visibleReplyTo ?? void 0,
-		suppressMessageReceivedHooks: true
-	});
-	emitWhatsAppMessageReceivedHooksIfEnabled({
-		cfg: params.cfg,
-		ctx: ctxPayload,
-		accountId: params.route.accountId,
-		sessionKey: params.route.sessionKey
-	});
-	const pinnedMainDmRecipient = resolvePinnedMainDmRecipient({
-		cfg: params.cfg,
-		allowFrom: inboundPolicy.configuredAllowFrom
-	});
-	updateWhatsAppMainLastRoute({
-		backgroundTasks: params.backgroundTasks,
-		cfg: params.cfg,
-		ctx: ctxPayload,
-		dmRouteTarget,
-		pinnedMainDmRecipient,
-		route: params.route,
-		updateLastRoute: updateLastRouteInBackground,
-		warn: params.replyLogger.warn.bind(params.replyLogger)
-	});
-	let finalizeReply;
-	const turnResult = await runChannelInboundEvent({
-		channel: "whatsapp",
-		accountId: params.route.accountId,
-		raw: params.msg,
-		adapter: {
-			ingest: () => ({
-				id: params.msg.event.id ?? `${conversationId}:${Date.now()}`,
-				timestamp: params.msg.event.timestamp,
-				rawText: ctxPayload.RawBody ?? "",
-				textForAgent: ctxPayload.BodyForAgent,
-				textForCommands: ctxPayload.CommandBody,
-				raw: params.msg
-			}),
-			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
-				} };
-			},
-			resolveTurn: () => {
-				const { finalize, ...replyPlan } = createWhatsAppReplyPlan({
-					cfg: params.cfg,
-					connectionId: params.connectionId,
-					context: ctxPayload,
-					deliverReply: deliverWebReply,
-					groupHistories: params.groupHistories,
-					groupHistoryKey: params.groupHistoryKey,
-					maxMediaBytes: params.maxMediaBytes,
-					maxMediaTextChunkLimit: params.maxMediaTextChunkLimit,
-					msg: params.msg,
-					onModelSelected,
-					rememberSentText: params.rememberSentText,
-					replyLogger: params.replyLogger,
-					replyPipeline: {
-						...replyPipeline,
-						responsePrefix
-					},
-					replyResolver: params.replyResolver,
-					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 ? finalizeReply?.(turnResult.dispatchResult) ?? false : false;
-	removeAckReactionHandleAfterReply({
-		removeAfterReply: false,
-		ackReaction,
-		onError: (err) => {
-			logAckFailure({
-				log: logVerbose$1,
-				channel: "whatsapp",
-				target: `${params.msg.platform.chatJid ?? conversationId}/${params.msg.event.id ?? "unknown"}`,
-				error: err
-			});
-		}
-	});
-	return didSendReply;
-}
-//#endregion
-//#region extensions/whatsapp/src/auto-reply/monitor/on-message.ts
-function createWebOnMessageHandler(params) {
-	const hasExplicitlyPassedInboundAccess = (msg) => msg.admission ? msg.admission.ingress.decision === "allow" : msg.accessControlPassed === true;
-	const withDirectSenderPeer = (msg, peerId) => {
-		if (requireWhatsAppInboundAdmission(msg).conversation.kind === "group" || msg.platform.sender?.e164 || msg.platform.senderE164 || !peerId.startsWith("+")) return msg;
-		const normalized = normalizeE164(peerId);
-		if (!normalized) return msg;
-		return requireAdmittedWhatsAppInboundMessage(withDeprecatedWebInboundMessageFlatAliases({
-			...msg,
-			platform: {
-				...msg.platform,
-				sender: {
-					...msg.platform.sender,
-					e164: normalized
-				},
-				senderE164: normalized
-			}
-		}));
-	};
-	const processForRoute = async (cfg, msg, route, groupHistoryKey, opts) => {
-		const processParams = {
-			cfg,
-			msg,
-			route,
-			groupHistoryKey,
-			groupHistories: params.groupHistories,
-			groupHistoryLimit: params.groupHistoryLimit,
-			groupMemberNames: params.groupMemberNames,
-			connectionId: params.connectionId,
-			verbose: params.verbose,
-			maxMediaBytes: params.maxMediaBytes,
-			replyResolver: params.replyResolver,
-			replyLogger: params.replyLogger,
-			backgroundTasks: params.backgroundTasks,
-			rememberSentText: params.echoTracker.rememberText,
-			echoHas: params.echoTracker.has,
-			echoForget: params.echoTracker.forget,
-			buildCombinedEchoKey: params.echoTracker.buildCombinedKey
-		};
-		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);
-	};
-	return async (rawMsg) => {
-		const canRunDirectEarlyAudioPreflight = hasExplicitlyPassedInboundAccess(rawMsg);
-		const normalizedMsg = requireAdmittedWhatsAppInboundMessage(normalizeWebInboundMessage(rawMsg));
-		const cfg = params.loadConfig?.() ?? params.cfg;
-		const peerId = resolvePeerId(normalizedMsg);
-		const msg = withDirectSenderPeer(normalizedMsg, peerId);
-		const admission = requireWhatsAppInboundAdmission(msg);
-		if (admission.ingress.admission !== "dispatch" && admission.ingress.admission !== "observe") return;
-		const conversationId = admission.conversation.id;
-		const conversationKind = admission.conversation.kind;
-		const baseRoute = resolveAgentRoute({
-			cfg,
-			channel: "whatsapp",
-			accountId: admission.accountId,
-			peer: {
-				kind: conversationKind,
-				id: peerId
-			}
-		});
-		const baseConversationRoute = conversationKind === "group" ? resolveWhatsAppGroupSessionRoute(baseRoute) : baseRoute;
-		const routeAccountId = baseConversationRoute.accountId ?? admission.accountId;
-		const account = resolveWhatsAppAccount({
-			cfg,
-			accountId: routeAccountId
-		});
-		const baseMentionConfig = buildMentionConfig(cfg);
-		if (conversationId === msg.platform.recipientJid) logVerbose(`📱 Same-phone mode detected (from === to: ${conversationId})`);
-		if (params.echoTracker.has(msg.payload.body)) {
-			logVerbose("Skipping auto-reply: detected echo (message matches recently sent text)");
-			params.echoTracker.forget(msg.payload.body);
-			return;
-		}
-		const configuredRoute = resolveConfiguredBindingRoute({
-			cfg,
-			route: baseConversationRoute,
-			channel: "whatsapp",
-			accountId: routeAccountId,
-			conversationId: peerId
-		});
-		const route = configuredRoute.route;
-		const groupHistoryKey = conversationKind === "group" ? buildGroupHistoryKey({
-			channel: "whatsapp",
-			accountId: route.accountId,
-			peerKind: "group",
-			peerId
-		}) : route.sessionKey;
-		let preflightAudioTranscript;
-		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;
-		let statusReactionController = null;
-		let recordAcceptedConfiguredGroupRoute = null;
-		const clearPreDispatchReaction = async () => {
-			try {
-				if (statusReactionController) {
-					const controller = statusReactionController;
-					statusReactionController = null;
-					controller.cancelPending();
-					await controller.clear();
-					return;
-				}
-				if (ackReaction && await ackReaction.ackReactionPromise) await ackReaction.remove();
-			} catch (err) {
-				params.replyLogger.warn({ error: String(err) }, "whatsapp: failed to clear pre-dispatch reaction after pre-dispatch rejection");
-			}
-		};
-		const transcribeAudioOnce = async () => {
-			if (preflightAudioTranscript !== void 0 || !hasAudioBody || !msg.payload.media?.path) return;
-			try {
-				const { transcribeFirstAudio } = await import("./audio-preflight.runtime-C_glQhZY.js");
-				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;
-			} catch {
-				preflightAudioTranscript = null;
-			}
-		};
-		const runAudioPreflightOnce = async () => {
-			if (preflightAudioTranscript !== void 0 || !canRunEarlyAudioPreflight || !hasAudioBody || !msg.payload.media?.path) return;
-			if (cfg.messages?.statusReactions?.enabled === true) {
-				statusReactionController = await createWhatsAppStatusReactionController({
-					cfg,
-					msg,
-					agentId: route.agentId,
-					sessionKey: route.sessionKey,
-					verbose: params.verbose
-				});
-				if (statusReactionController) await statusReactionController.setQueued();
-			} else {
-				ackReaction = await maybeSendAckReaction({
-					cfg,
-					msg,
-					agentId: route.agentId,
-					sessionKey: route.sessionKey,
-					verbose: params.verbose,
-					info: params.replyLogger.info.bind(params.replyLogger),
-					warn: params.replyLogger.warn.bind(params.replyLogger)
-				});
-				ackAlreadySent = ackReaction !== null;
-			}
-			await transcribeAudioOnce();
-		};
-		if (conversationKind === "group") {
-			const sender = getSenderIdentity(msg);
-			const metaCtx = {
-				From: conversationId,
-				To: msg.platform.recipientJid,
-				SessionKey: route.sessionKey,
-				AccountId: route.accountId,
-				ChatType: conversationKind,
-				ConversationLabel: conversationId,
-				GroupSubject: msg.group?.subject,
-				SenderName: sender.name ?? void 0,
-				SenderId: getPrimaryIdentityId(sender) ?? void 0,
-				SenderE164: sender.e164 ?? void 0,
-				Provider: "whatsapp",
-				Surface: "whatsapp",
-				OriginatingChannel: "whatsapp",
-				OriginatingTo: conversationId
-			};
-			const recordGroupRoute = () => updateLastRouteInBackground({
-				cfg,
-				backgroundTasks: params.backgroundTasks,
-				storeAgentId: route.agentId,
-				sessionKey: route.sessionKey,
-				channel: "whatsapp",
-				to: conversationId,
-				accountId: route.accountId,
-				ctx: metaCtx,
-				warn: params.replyLogger.warn.bind(params.replyLogger)
-			});
-			recordAcceptedConfiguredGroupRoute = recordGroupRoute;
-			let gating = await applyGroupGating({
-				cfg,
-				msg,
-				deferMissingMention: hasAudioBody && Boolean(msg.payload.media?.path),
-				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
-			});
-			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
-				});
-			}
-			if (!gating.shouldProcess) {
-				await clearPreDispatchReaction();
-				return;
-			}
-		}
-		if (configuredRoute.bindingResolution) {
-			const ensured = await ensureConfiguredBindingRouteReady({
-				cfg,
-				bindingResolution: configuredRoute.bindingResolution
-			});
-			if (!ensured.ok) {
-				params.replyLogger.warn(`whatsapp: configured ACP binding unavailable for conversation ${configuredRoute.bindingResolution.record.conversation.conversationId}: ${ensured.error}`);
-				await clearPreDispatchReaction();
-				return;
-			}
-		}
-		if (recordAcceptedConfiguredGroupRoute && !configuredRoute.bindingResolution) {
-			recordAcceptedConfiguredGroupRoute();
-			recordAcceptedConfiguredGroupRoute = null;
-		}
-		await runAudioPreflightOnce();
-		const hasBroadcastTargets = !configuredRoute.bindingResolution && Array.isArray(cfg.broadcast?.[peerId]) && cfg.broadcast[peerId].length > 0;
-		if (hasBroadcastTargets && statusReactionController) await clearPreDispatchReaction();
-		if (hasBroadcastTargets && !canRunEarlyAudioPreflight) await transcribeAudioOnce();
-		if (!configuredRoute.bindingResolution && await maybeBroadcastMessage({
-			cfg,
-			msg,
-			peerId,
-			route,
-			groupHistoryKey,
-			groupHistories: params.groupHistories,
-			...preflightAudioTranscript !== void 0 ? { preflightAudioTranscript } : {},
-			...ackAlreadySent && conversationKind !== "group" ? { ackAlreadySent: true } : {},
-			...ackReaction && conversationKind !== "group" ? { ackReaction } : {},
-			...statusReactionController && conversationKind !== "group" ? { ackAlreadySent: true } : {},
-			processMessage: (m, r, k, opts) => processForRoute(cfg, m, r, k, opts)
-		})) return;
-		recordAcceptedConfiguredGroupRoute?.();
-		await processForRoute(cfg, msg, route, groupHistoryKey, {
-			...preflightAudioTranscript !== void 0 ? { preflightAudioTranscript } : {},
-			...ackAlreadySent ? { ackAlreadySent: true } : {},
-			...ackReaction ? { ackReaction } : {},
-			...statusReactionController ? { statusReactionController } : {}
-		});
-	};
-}
-//#endregion
-//#region extensions/whatsapp/src/auto-reply/monitor.ts
-function isNonRetryableWebCloseStatus(statusCode) {
-	return statusCode === 440;
-}
-const loadReplyResolverRuntime = createLazyRuntimeModule(() => import("./reply-resolver.runtime-Ded8D58Y.js"));
-function resolveWebMonitorConfigSnapshot(params) {
-	const account = resolveWhatsAppAccount({
-		cfg: params.cfg,
-		accountId: params.accountId
-	});
-	return {
-		cfg: {
-			...params.cfg,
-			channels: {
-				...params.cfg.channels,
-				whatsapp: {
-					...params.cfg.channels?.whatsapp,
-					responsePrefix: account.messagePrefix,
-					allowFrom: account.allowFrom,
-					groupAllowFrom: account.groupAllowFrom,
-					groupPolicy: account.groupPolicy,
-					textChunkLimit: account.textChunkLimit,
-					streaming: account.streaming,
-					mediaMaxMb: account.mediaMaxMb,
-					groups: account.groups
-				}
-			}
-		},
-		account
-	};
-}
-function normalizeReconnectAccountId(accountId) {
-	return (accountId ?? "").trim() || "default";
-}
-function isNoListenerReconnectError(lastError) {
-	return typeof lastError === "string" && /No active WhatsApp Web listener/i.test(lastError);
-}
-function resolveExplicitWhatsAppDebounceOverride(params) {
-	const channel = params.sourceCfg?.channels?.whatsapp;
-	if (!channel) return;
-	const accountId = normalizeReconnectAccountId(params.accountId);
-	const accountDebounce = resolveAccountEntry(channel.accounts, accountId)?.debounceMs;
-	if (accountDebounce !== void 0) return accountDebounce;
-	if (accountId !== "default") {
-		const defaultAccountDebounce = resolveAccountEntry(channel.accounts, "default")?.debounceMs;
-		if (defaultAccountDebounce !== void 0) return defaultAccountDebounce;
-	}
-	return channel.debounceMs;
-}
-function isRetryableAuthUnstableError(error) {
-	return error instanceof WhatsAppAuthUnstableError || typeof error === "object" && error !== null && "code" in error && error.code === "whatsapp-auth-unstable";
-}
-const DEFAULT_TRANSPORT_TIMEOUT_MS = 300 * 1e3;
-const WHATSAPP_RECONNECT_CATCH_UP_MAX_MS = 20 * 6e4;
-async function monitorWebChannel(verbose, listenerFactory = attachWebInboxToSocket, keepAlive = true, replyResolver, runtime = defaultRuntime, abortSignal, tuning = {}) {
-	const activeReplyResolver = replyResolver ?? (await loadReplyResolverRuntime()).getReplyFromConfig;
-	const runId = newConnectionId();
-	const replyLogger = getChildLogger$1({
-		module: "web-auto-reply",
-		runId
-	});
-	const heartbeatLogger = getChildLogger$1({
-		module: "web-heartbeat",
-		runId
-	});
-	const reconnectLogger = getChildLogger$1({
-		module: "web-reconnect",
-		runId
-	});
-	const baseCfg = getRuntimeConfig$1();
-	const sourceCfg = getRuntimeConfigSourceSnapshot();
-	const { cfg, account } = resolveWebMonitorConfigSnapshot({
-		cfg: baseCfg,
-		accountId: tuning.accountId
-	});
-	const loadCurrentMonitorConfig = () => resolveWebMonitorConfigSnapshot({
-		cfg: getRuntimeConfig$1(),
-		accountId: account.accountId
-	}).cfg;
-	const maxMediaBytes = resolveWhatsAppMediaMaxBytes(account);
-	const heartbeatSeconds = resolveHeartbeatSeconds(cfg, tuning.heartbeatSeconds);
-	const reconnectPolicy = resolveReconnectPolicy(cfg, tuning.reconnect);
-	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();
-	const groupMemberNames = /* @__PURE__ */ new Map();
-	const groupMetadataCache = /* @__PURE__ */ new Map();
-	const recentMessageKeys = /* @__PURE__ */ new Map();
-	const baileysGroupMetaCache = /* @__PURE__ */ new Map();
-	const echoTracker = createEchoTracker({
-		maxItems: 100,
-		logVerbose
-	});
-	const sleep = tuning.sleep ?? ((ms, signal) => sleepWithAbort(ms, signal ?? abortSignal));
-	const stopRequested = () => abortSignal?.aborted === true;
-	const currentMaxListeners = process.getMaxListeners?.() ?? 10;
-	if (process.setMaxListeners && currentMaxListeners < 50) process.setMaxListeners(50);
-	let sigintStop = false;
-	const handleSigint = () => {
-		sigintStop = true;
-	};
-	process.once("SIGINT", handleSigint);
-	const transportTimeoutMs = tuning.transportTimeoutMs ?? DEFAULT_TRANSPORT_TIMEOUT_MS;
-	const messageTimeoutMs = tuning.messageTimeoutMs ?? 1800 * 1e3;
-	const reconnectCatchUpWindowMs = Math.min(Math.max(messageTimeoutMs, 6e4), WHATSAPP_RECONNECT_CATCH_UP_MAX_MS);
-	const watchdogCheckMs = tuning.watchdogCheckMs ?? 60 * 1e3;
-	const controller = new WhatsAppConnectionController({
-		accountId: account.accountId,
-		authDir: account.authDir,
-		verbose,
-		keepAlive,
-		heartbeatSeconds,
-		transportTimeoutMs,
-		messageTimeoutMs,
-		watchdogCheckMs,
-		reconnectPolicy,
-		socketTiming,
-		abortSignal,
-		sleep,
-		isNonRetryableStatus: isNonRetryableWebCloseStatus
-	});
-	const statusController = createWebChannelStatusController(tuning.statusSink);
-	statusController.emit();
-	try {
-		while (true) {
-			if (stopRequested()) break;
-			const connectionId = newConnectionId();
-			const inboundDebounceMs = resolveInboundDebounceMs({
-				cfg,
-				channel: "whatsapp",
-				overrideMs: resolveExplicitWhatsAppDebounceOverride({
-					cfg,
-					sourceCfg,
-					accountId: account.accountId
-				})
-			});
-			const shouldDebounce = (msg) => {
-				const normalized = normalizeWebInboundMessage(msg);
-				return shouldDebounceTextInbound({
-					text: normalized.payload.commandBody ?? normalized.payload.body,
-					cfg,
-					hasMedia: Boolean(normalized.payload.media?.path || normalized.payload.media?.type),
-					allowDebounce: !(normalized.payload.location || normalized.quote?.id || normalized.quote?.body)
-				});
-			};
-			let connection;
-			try {
-				connection = await controller.openConnection({
-					connectionId,
-					getMessage: async (key) => key.id && key.remoteJid ? readWhatsAppBaileysCacheEntry(recentMessageKeys, `${key.remoteJid}:${key.id}`) : void 0,
-					cachedGroupMetadata: async (jid) => {
-						const meta = readWhatsAppBaileysCacheEntry(baileysGroupMetaCache, jid);
-						return meta?.participants?.length ? meta : void 0;
-					},
-					createListener: async ({ sock, connection: connectionLocal }) => {
-						const onMessage = createWebOnMessageHandler({
-							cfg,
-							loadConfig: loadCurrentMonitorConfig,
-							verbose,
-							connectionId,
-							maxMediaBytes,
-							groupHistoryLimit,
-							groupHistories,
-							groupMemberNames,
-							echoTracker,
-							backgroundTasks: connectionLocal.backgroundTasks,
-							replyResolver: activeReplyResolver,
-							replyLogger,
-							baseMentionConfig,
-							account
-						});
-						return await (listenerFactory ?? attachWebInboxToSocket)({
-							cfg,
-							loadConfig: loadCurrentMonitorConfig,
-							verbose,
-							accountId: account.accountId,
-							authDir: account.authDir,
-							mediaMaxMb: account.mediaMaxMb,
-							selfChatMode: account.selfChatMode,
-							sendReadReceipts: account.sendReadReceipts,
-							socketTiming,
-							debounceMs: inboundDebounceMs,
-							appendReplyWindow: connectionLocal.openedAfterRecentInbound ? {
-								afterMs: connectionLocal.startedAt - reconnectCatchUpWindowMs,
-								untilMs: connectionLocal.startedAt + reconnectCatchUpWindowMs,
-								maxAgeMs: reconnectCatchUpWindowMs
-							} : void 0,
-							shouldDebounce,
-							socketRef: controller.socketRef,
-							shouldRetryDisconnect: () => !sigintStop && controller.shouldRetryDisconnect(),
-							disconnectRetryPolicy: reconnectPolicy,
-							disconnectRetryAbortSignal: controller.getDisconnectRetryAbortSignal(),
-							groupMetadataCache,
-							recentMessageKeys,
-							baileysGroupMetaCache,
-							onMessage: async (msg) => {
-								const normalized = normalizeWebInboundMessage(msg);
-								const inboundAt = Date.now();
-								controller.noteInbound(inboundAt);
-								statusController.noteInbound(inboundAt);
-								await onMessage(normalized);
-							},
-							onPendingWorkChanged: (pendingWorkCount, at) => {
-								statusController.noteBusy(pendingWorkCount > 0, at);
-							},
-							sock
-						});
-					},
-					onHeartbeat: (snapshot) => {
-						const authAgeMs = getWebAuthAgeMs(account.authDir);
-						const minutesSinceLastMessage = snapshot.lastInboundAt ? Math.floor((Date.now() - snapshot.lastInboundAt) / 6e4) : null;
-						const logData = {
-							connectionId: snapshot.connectionId,
-							reconnectAttempts: snapshot.reconnectAttempts,
-							messagesHandled: snapshot.handledMessages,
-							lastInboundAt: snapshot.lastInboundAt,
-							lastTransportActivityAt: snapshot.lastTransportActivityAt,
-							authAgeMs,
-							uptimeMs: snapshot.uptimeMs,
-							...minutesSinceLastMessage !== null && minutesSinceLastMessage > 30 ? { minutesSinceLastMessage } : {}
-						};
-						statusController.noteTransportActivity(snapshot.lastTransportActivityAt);
-						if (minutesSinceLastMessage && minutesSinceLastMessage > 30) heartbeatLogger.warn(logData, "⚠️ web gateway heartbeat - no messages in 30+ minutes");
-						else heartbeatLogger.info(logData, "web gateway heartbeat");
-					},
-					onWatchdogTimeout: (snapshot) => {
-						const now = Date.now();
-						const transportSilentMs = now - snapshot.lastTransportActivityAt;
-						const appBaselineAt = snapshot.lastInboundAt ?? snapshot.startedAt;
-						const minutesSinceTransportActivity = Math.floor(transportSilentMs / 6e4);
-						const minutesSinceAppActivity = Math.floor((now - appBaselineAt) / 6e4);
-						const watchdogReason = transportSilentMs > transportTimeoutMs ? "transport-inactive" : "app-silent";
-						statusController.noteWatchdogStale();
-						heartbeatLogger.warn({
-							connectionId: snapshot.connectionId,
-							watchdogReason,
-							minutesSinceTransportActivity,
-							minutesSinceAppActivity,
-							lastInboundAt: snapshot.lastInboundAt ? new Date(snapshot.lastInboundAt) : null,
-							lastTransportActivityAt: new Date(snapshot.lastTransportActivityAt),
-							messagesHandled: snapshot.handledMessages
-						}, "WhatsApp watchdog timeout detected - forcing reconnect");
-						whatsappHeartbeatLog.warn(`WhatsApp watchdog timeout (${watchdogReason}) - restarting connection`);
-					}
-				});
-			} catch (error) {
-				const setupDecision = controller.resolveSetupErrorDecision(error);
-				if (setupDecision === "aborted") {
-					await controller.shutdown();
-					break;
-				}
-				if (setupDecision) {
-					statusController.noteReconnectAttempts(setupDecision.reconnectAttempts);
-					statusController.noteClose({
-						statusCode: setupDecision.normalized.statusCode,
-						error: formatError(error),
-						reconnectAttempts: setupDecision.reconnectAttempts,
-						healthState: setupDecision.healthState
-					});
-					if (setupDecision.action === "stop") {
-						reconnectLogger.warn({
-							connectionId,
-							status: setupDecision.normalized.statusLabel,
-							reconnectAttempts: setupDecision.reconnectAttempts,
-							maxAttempts: reconnectPolicy.maxAttempts
-						}, "web reconnect: setup status error; max attempts reached");
-						if (setupDecision.healthState === "logged-out") runtime.error(`WhatsApp session logged out during setup. Run \`${formatCliCommand("openclaw channels login --channel whatsapp")}\` to relink.`);
-						else if (setupDecision.healthState === "conflict") runtime.error(`WhatsApp Web connection closed during setup (status ${setupDecision.normalized.statusLabel}: session conflict). Resolve conflicting WhatsApp Web sessions, then restart the channel. To force a fresh QR, run \`${formatCliCommand("openclaw channels logout --channel whatsapp")}\` before \`${formatCliCommand("openclaw channels login --channel whatsapp")}\`. Stopping web monitoring.`);
-						else runtime.error(`WhatsApp Web connection closed during setup (status ${setupDecision.normalized.statusLabel}) after ${setupDecision.reconnectAttempts}/${reconnectPolicy.maxAttempts} attempts. Relink with \`${formatCliCommand("openclaw channels login --channel whatsapp")}\` if the issue persists.`);
-						await controller.shutdown();
-						break;
-					}
-					reconnectLogger.info({
-						connectionId,
-						status: setupDecision.normalized.statusLabel,
-						reconnectAttempts: setupDecision.reconnectAttempts,
-						delayMs: setupDecision.delayMs
-					}, "web reconnect: setup status error; retrying");
-					runtime.error(`WhatsApp Web connection closed during setup (status ${setupDecision.normalized.statusLabel}). Retry ${setupDecision.reconnectAttempts}/${reconnectPolicy.maxAttempts || "∞"} in ${formatDurationPrecise(setupDecision.delayMs ?? 0)}.`);
-					try {
-						await controller.waitBeforeRetry(setupDecision.delayMs ?? 0);
-					} catch {
-						break;
-					}
-					continue;
-				}
-				if (!isRetryableAuthUnstableError(error)) throw error;
-				const retryDecision = controller.consumeReconnectAttempt();
-				statusController.noteReconnectAttempts(retryDecision.reconnectAttempts);
-				statusController.noteClose({
-					error: error.message,
-					reconnectAttempts: retryDecision.reconnectAttempts,
-					healthState: retryDecision.healthState
-				});
-				if (retryDecision.action === "stop") {
-					reconnectLogger.warn({
-						connectionId,
-						reconnectAttempts: retryDecision.reconnectAttempts,
-						maxAttempts: reconnectPolicy.maxAttempts
-					}, "web reconnect: auth state stayed unstable; max attempts reached");
-					runtime.error(`WhatsApp auth state is still stabilizing after ${retryDecision.reconnectAttempts}/${reconnectPolicy.maxAttempts} attempts. Stopping web monitoring.`);
-					await controller.shutdown();
-					break;
-				}
-				reconnectLogger.info({
-					connectionId,
-					reconnectAttempts: retryDecision.reconnectAttempts,
-					delayMs: retryDecision.delayMs
-				}, "web reconnect: auth state still stabilizing during inbox attach; retrying");
-				runtime.error(`WhatsApp auth state is still stabilizing. Retry ${retryDecision.reconnectAttempts}/${reconnectPolicy.maxAttempts || "∞"} for inbox attach in ${formatDurationPrecise(retryDecision.delayMs ?? 0)}.`);
-				try {
-					await controller.waitBeforeRetry(retryDecision.delayMs ?? 0);
-				} catch {
-					break;
-				}
-				continue;
-			}
-			statusController.noteConnected();
-			const approvalContextLease = registerChannelRuntimeContext({
-				channelRuntime: tuning.channelRuntime,
-				channelId: "whatsapp",
-				accountId: account.accountId,
-				capability: CHANNEL_APPROVAL_NATIVE_RUNTIME_CONTEXT_CAPABILITY,
-				context: { accountId: account.accountId },
-				abortSignal
-			});
-			controller.setUnhandledRejectionCleanup(registerUnhandledRejectionHandler((reason) => {
-				if (!isLikelyWhatsAppCryptoError(reason)) return false;
-				const errorStr = formatError(reason);
-				reconnectLogger.warn({
-					connectionId: connection.connectionId,
-					error: errorStr
-				}, "web reconnect: unhandled rejection from WhatsApp socket; forcing reconnect");
-				controller.forceClose({
-					status: 499,
-					isLoggedOut: false,
-					error: reason
-				});
-				return true;
-			}));
-			const { e164: selfE164 } = readWebSelfId(account.authDir);
-			const connectRoute = resolveAgentRoute({
-				cfg,
-				channel: "whatsapp",
-				accountId: account.accountId
-			});
-			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(() => {
-				drainPendingDeliveries({
-					drainKey: `whatsapp:${normalizedAccountId}`,
-					logLabel: "WhatsApp periodic drain",
-					cfg,
-					log: reconnectLogger,
-					selectEntry: (entry) => ({
-						match: entry.channel === "whatsapp" && normalizeReconnectAccountId(entry.accountId) === normalizedAccountId,
-						bypassBackoff: false
-					})
-				}).catch((err) => {
-					reconnectLogger.warn({
-						connectionId: connection.connectionId,
-						error: String(err)
-					}, "periodic drain failed");
-				});
-			}, 3e4);
-			const inboundPolicy = resolveWhatsAppInboundPolicy({
-				cfg,
-				accountId: account.accountId,
-				selfE164: selfE164 ?? null
-			});
-			whatsappLog.info(formatWhatsAppInboundListeningLog({
-				groups: inboundPolicy.account.groups,
-				groupPolicy: inboundPolicy.groupPolicy,
-				hasGroupAllowFrom: inboundPolicy.groupAllowFrom.length > 0
-			}));
-			if (process.stdout.isTTY || process.stderr.isTTY) whatsappLog.raw("Ctrl+C to stop.");
-			if (!keepAlive) {
-				clearInterval(periodicDrainInterval);
-				approvalContextLease?.dispose();
-				await controller.shutdown();
-				return;
-			}
-			const reason = await controller.waitForClose().finally(() => {
-				clearInterval(periodicDrainInterval);
-				approvalContextLease?.dispose();
-			});
-			if (stopRequested() || sigintStop || reason === "aborted") {
-				await controller.shutdown();
-				break;
-			}
-			const decision = controller.resolveCloseDecision(reason);
-			if (decision === "aborted") {
-				await controller.shutdown();
-				break;
-			}
-			statusController.noteReconnectAttempts(controller.getReconnectAttempts());
-			reconnectLogger.info({
-				connectionId: connection.connectionId,
-				status: decision.normalized.statusLabel,
-				loggedOut: decision.normalized.isLoggedOut,
-				reconnectAttempts: decision.reconnectAttempts,
-				error: decision.normalized.errorText
-			}, "web reconnect: connection closed");
-			enqueueSystemEvent(`WhatsApp gateway disconnected (status ${decision.normalized.statusLabel})`, { sessionKey: connectRoute.sessionKey });
-			if (decision.action === "stop") {
-				await controller.closeCurrentConnection();
-				statusController.noteClose({
-					statusCode: decision.normalized.statusCode,
-					loggedOut: decision.normalized.isLoggedOut,
-					error: decision.normalized.errorText,
-					reconnectAttempts: decision.reconnectAttempts,
-					healthState: decision.healthState
-				});
-				if (decision.healthState === "logged-out") runtime.error(`WhatsApp session logged out. Run \`${formatCliCommand("openclaw channels login --channel whatsapp")}\` to relink.`);
-				else if (decision.healthState === "conflict") {
-					reconnectLogger.warn({
-						connectionId: connection.connectionId,
-						status: decision.normalized.statusLabel,
-						error: decision.normalized.errorText
-					}, "web reconnect: non-retryable close status; stopping monitor");
-					runtime.error(`WhatsApp Web connection closed (status ${decision.normalized.statusLabel}: session conflict). Resolve conflicting WhatsApp Web sessions, then restart the channel. To force a fresh QR, run \`${formatCliCommand("openclaw channels logout --channel whatsapp")}\` before \`${formatCliCommand("openclaw channels login --channel whatsapp")}\`. Stopping web monitoring.`);
-				} else {
-					reconnectLogger.warn({
-						connectionId: connection.connectionId,
-						status: decision.normalized.statusLabel,
-						reconnectAttempts: decision.reconnectAttempts,
-						maxAttempts: reconnectPolicy.maxAttempts
-					}, "web reconnect: max attempts reached; continuing in degraded mode");
-					runtime.error(`WhatsApp Web reconnect: max attempts reached (${decision.reconnectAttempts}/${reconnectPolicy.maxAttempts}). Stopping web monitoring.`);
-				}
-				await controller.shutdown();
-				break;
-			}
-			const isWatchdogRecoveryReconnect = decision.normalized.error === WHATSAPP_WATCHDOG_TIMEOUT_ERROR;
-			statusController.noteClose({
-				statusCode: decision.normalized.statusCode,
-				error: decision.normalized.errorText,
-				reconnectAttempts: decision.reconnectAttempts,
-				healthState: decision.healthState,
-				watchdogRecovery: isWatchdogRecoveryReconnect
-			});
-			reconnectLogger.info({
-				connectionId: connection.connectionId,
-				status: decision.normalized.statusLabel,
-				reconnectAttempts: decision.reconnectAttempts,
-				maxAttempts: reconnectPolicy.maxAttempts || "unlimited",
-				delayMs: decision.delayMs
-			}, "web reconnect: scheduling retry");
-			const reconnectMessage = isWatchdogRecoveryReconnect ? `WhatsApp Web watchdog is recovering a stale connection (status ${decision.normalized.statusLabel}). Retry ${decision.reconnectAttempts}/${reconnectPolicy.maxAttempts || "∞"} in ${formatDurationPrecise(decision.delayMs ?? 0)}.` : `WhatsApp Web connection closed (status ${decision.normalized.statusLabel}). Retry ${decision.reconnectAttempts}/${reconnectPolicy.maxAttempts || "∞"} in ${formatDurationPrecise(decision.delayMs ?? 0)}… (${decision.normalized.errorText})`;
-			if (isWatchdogRecoveryReconnect) runtime.log(warn(reconnectMessage));
-			else runtime.error(reconnectMessage);
-			await controller.closeCurrentConnection();
-			try {
-				await controller.waitBeforeRetry(decision.delayMs ?? 0);
-			} catch {
-				break;
-			}
-		}
-	} finally {
-		statusController.markStopped();
-		process.removeListener("SIGINT", handleSigint);
-		await controller.shutdown();
-	}
-}
-//#endregion
-export { loadWebMediaRaw as a, monitorWebInbox as c, loadWebMedia as i, resetWebInboundDedupe as l, LocalMediaAccessError as n, optimizeImageToJpeg as o, getDefaultLocalRoots as r, optimizeImageToPng as s, monitorWebChannel as t };