@openclaw/whatsapp 2026.7.2-beta.7 → 2026.8.1-beta.3

package/dist/{monitor-CfkaUSL2.js → monitor-IzwQKizW.js}

@@ -1,62 +1,248 @@
-import { a as resolveWhatsAppAccount, s as resolveWhatsAppMediaMaxBytes } from "./accounts-CSqLvCY5.js";
-import { a as normalizeWhatsAppOutboundPayload, c as prepareWhatsAppOutboundMedia, r as sendReactionWhatsApp, s as normalizeWhatsAppPayloadTextPreservingIndentation, u as resolveWhatsAppReactionLevel } from "./send-D37ddk22.js";
+import { a as resolveWhatsAppAccount, s as resolveWhatsAppMediaMaxBytes } from "./accounts-BX2fZUyR.js";
+import { c as normalizeWhatsAppPayloadTextPreservingIndentation, d as listWhatsAppSendResultMessageIds, f as mergeWhatsAppAcceptedSendError, g as withWhatsAppLogicalDeliveryActivity, h as rememberWhatsAppPartialSend, l as prepareWhatsAppOutboundMedia, m as rememberWhatsAppAcceptedSend, o as normalizeWhatsAppOutboundPayload, p as normalizeWhatsAppSendResult, r as sendReactionWhatsApp, v as resolveWhatsAppReactionLevel } from "./send-CwvTU4RI.js";
 import { i as getWhatsAppRuntime } from "./runtime-BLlToOi6.js";
 import { r as getWhatsAppConnectionController } from "./connection-controller-runtime-context-DG0tuYuw.js";
 import { a as markdownToWhatsAppChunks, c as toWhatsappJid, l as toWhatsappJidWithLid, n as isSelfChatMode, o as resolveEquivalentWhatsAppDirectChatJids, r as jidToE164, s as resolveJidToE164 } from "./targets-runtime-TMk0lGuy.js";
 import { t as normalizeE164 } from "./text-runtime-CaKLhowd.js";
-import { a as cacheInboundMessageMeta, i as buildQuotedMessageOptions, n as resolveWhatsAppGroupSessionRoute, o as lookupInboundMessageMeta, r as resolveWhatsAppLegacyGroupSessionKey } from "./group-session-key-DVMZlO3x.js";
-import { g as readWebSelfId, o as getWebAuthAgeMs, r as WhatsAppAuthUnstableError, v as readWebSelfIdentityForDecision } from "./auth-store-DcEpIOmE.js";
-import { a as getSelfIdentity, c as resolveComparableIdentity, i as getReplyContext, n as getMentionIdentities, o as getSenderIdentity, r as getPrimaryIdentityId, s as identitiesOverlap, t as getComparableIdentityValues } from "./identity-CPrT5aEU.js";
+import { a as cacheInboundMessageMeta, i as buildQuotedMessageOptions, n as resolveWhatsAppGroupSessionRoute, o as lookupInboundMessageMeta, r as resolveWhatsAppLegacyGroupSessionKey } from "./group-session-key-DmFc_Cqi.js";
+import { C as getMentionIdentities, D as getSenderIdentity, E as getSelfIdentity, O as identitiesOverlap, S as getComparableIdentityValues, T as getReplyContext, g as readWebSelfId, k as resolveComparableIdentity, o as getWebAuthAgeMs, r as WhatsAppAuthUnstableError, v as readWebSelfIdentityForDecision, w as getPrimaryIdentityId } from "./auth-store-CtpBqH5S.js";
 import { n as resolveWhatsAppGroupsConfigPath } from "./group-config-path-BGyzT9Lg.js";
-import { a as waitForWaConnection, c as isWhatsAppSocketOperationTimeoutError, d as withWhatsAppSocketOperationTimeout, l as resolveWhatsAppSocketOperationTimeoutMs, r as createWaSocket, s as createWhatsAppSocketOperationTimeoutAdapter, u as resolveWhatsAppSocketTiming } from "./socket-close-DridEuzz.js";
+import { a as waitForWaConnection, c as isWhatsAppSocketOperationTimeoutError, d as withWhatsAppSocketOperationTimeout, l as resolveWhatsAppSocketOperationTimeoutMs, r as createWaSocket, s as createWhatsAppSocketOperationTimeoutAdapter, u as resolveWhatsAppSocketTiming } from "./socket-close-2T0_jZTN.js";
 import { n as getStatusCode, t as formatError } from "./session-errors-JuazczrA.js";
 import { t as BufferJSON } from "./session.runtime-Nsqaehbd.js";
-import { c as requireWhatsAppInboundAdmission, i as resolveWhatsAppInboundPolicy, l as resolveWhatsAppGroupConversationId, o as buildDeprecatedFlatWhatsAppInboundAdmission, r as resolveWhatsAppCommandAuthorized, s as requireAdmittedWhatsAppInboundMessage, t as checkInboundAccessControl } from "./access-control-pZcxTmd5.js";
-import { _ as extractMediaKind, a as mayContainWhatsAppOutboundMention, b as hasInboundUserContent, c as DisconnectReason, d as normalizeMessageContent, f as describeReplyContext, g as extractLocationData, h as extractExternalAdReplyContext, i as addWhatsAppOutboundMentionsToContent, l as downloadMediaMessage, m as extractContextInfo, n as listWhatsAppSendResultMessageIds, o as resolveWhatsAppOutboundMentions, p as extractContactContext, r as normalizeWhatsAppSendResult, s as addWhatsAppImagePreviewFields, t as createWebSendApi, u as isJidGroup, v as extractMentionedJids, x as resolveInboundMediaMimetype, y as extractText } from "./send-api-7wk6eQyW.js";
-import { c as computeBackoff, d as resolveReconnectPolicy, f as sleepWithAbort, l as newConnectionId, n as WHATSAPP_WATCHDOG_TIMEOUT_ERROR, r as WhatsAppConnectionController, s as DEFAULT_RECONNECT_POLICY, u as resolveHeartbeatSeconds } from "./connection-controller-BOB2MVKY.js";
-import { n as maybeResolveWhatsAppApprovalReaction } from "./approval-reactions-Cu66aYdq.js";
-import { t as maybeResolveWhatsAppQuestionReaction } from "./question-reactions-CRsnyoMK.js";
-import { normalizeLowercaseStringOrEmpty, normalizeStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { _ as resolveInboundMediaMimetype, a as addWhatsAppImagePreviewFields, c as extractContextInfo, d as extractMediaKind, f as extractMentionedJids, g as projectWhatsAppInboundMessage, h as hasInboundUserContent, i as resolveWhatsAppOutboundMentions, l as extractExternalAdReplyContext, n as addWhatsAppOutboundMentionsToContent, o as describeReplyContext, p as extractText, r as mayContainWhatsAppOutboundMention, s as extractContactContext, t as createWebSendApi, u as extractLocationData } from "./send-api-obOSm2cC.js";
+import { t as resolveWhatsAppRuntimeGroupPolicy } from "./runtime-group-policy-DeSRFXEV.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-CIYuBJrs.js";
+import { n as maybeResolveWhatsAppApprovalReaction } from "./approval-reactions-Jyr1JaAK.js";
+import { t as maybeResolveWhatsAppQuestionReaction } from "./question-reactions-D3eAeB0i.js";
+import { normalizeLowercaseStringOrEmpty, normalizeOptionalString, 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 { createAckReactionHandle, createStatusReactionController, logAckFailure, removeAckReactionHandleAfterReply, shouldAckReaction } from "openclaw/plugin-sdk/channel-feedback";
 import { formatCliCommand } from "openclaw/plugin-sdk/cli-runtime";
-import { getChildLogger } from "openclaw/plugin-sdk/logging-core";
+import { PlatformMessageNotDispatchedError } from "openclaw/plugin-sdk/error-runtime";
+import { createSubsystemLogger, getChildLogger, redactToolPayloadText } 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 { createSubsystemLogger as createSubsystemLogger$1, 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 { recordChannelActivity } from "openclaw/plugin-sdk/channel-activity-runtime";
+import { buildChannelInboundEventContext, createChannelPartialDeliveryError, filterChannelInboundQuoteContext, formatInboundEnvelope, formatInboundEnvelope as formatInboundEnvelope$1, formatInboundMediaUnavailableText, formatLocationText, formatMediaPlaceholderText, hasVisibleInboundReplyDispatch, isChannelPartialDeliveryError, readAgentRunTerminalOutcome, resolveInboundSessionEnvelopeContext, resolveInboundSupplementalSenderAllowed, runChannelInboundEvent, shouldDebounceTextInbound, toInboundMediaFactsWithMetadata, toLocationContext } from "openclaw/plugin-sdk/channel-inbound";
 import { bindIngressLifecycleToReplyOptions, createChannelIngressMonitor, createChannelMessageReplyPipeline, createMessageReceiptFromOutboundResults, listMessageReceiptPlatformIds, resolveChannelMessageSourceReplyDeliveryMode, resolveChannelStreamingBlockEnabled } from "openclaw/plugin-sdk/channel-outbound";
 import { getAgentScopedMediaLocalRoots } from "openclaw/plugin-sdk/media-runtime";
 import { isReasoningReplyPayload, resolveSendableOutboundReplyParts, sendMediaWithLeadingCaption } from "openclaw/plugin-sdk/reply-payload";
 import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
-import { buildChannelInboundEventContext, createChannelPartialDeliveryError, filterChannelInboundQuoteContext, formatInboundEnvelope, formatInboundEnvelope as formatInboundEnvelope$1, formatInboundMediaUnavailableText, formatLocationText, formatMediaPlaceholderText, hasVisibleInboundReplyDispatch, isChannelPartialDeliveryError, resolveInboundSessionEnvelopeContext, resolveInboundSupplementalSenderAllowed, runChannelInboundEvent, shouldDebounceTextInbound, toInboundMediaFactsWithMetadata, toLocationContext } from "openclaw/plugin-sdk/channel-inbound";
+import { DisconnectReason, downloadMediaMessage, isHostedLidUser, isHostedPnUser, isJidGroup, isJidGroup as isJidGroup$1, jidDecode, jidEncode, jidNormalizedUser, normalizeMessageContent as normalizeMessageContent$1 } from "baileys";
+import { resolveChannelGroupPolicy, resolveChannelGroupRequireMention } from "openclaw/plugin-sdk/channel-policy";
 import { DEFAULT_ACCOUNT_ID, DEFAULT_MAIN_KEY, buildAgentMainSessionKey, buildAgentSessionKey, buildGroupHistoryKey, deriveLastRoutePolicy, normalizeAccountId, normalizeAgentId, resolveAgentRoute, resolveInboundLastRouteSessionKey } from "openclaw/plugin-sdk/routing";
 import { asDateTimestampMs, parseStrictFiniteNumber, resolveExpiresAtMsFromDurationMs } from "openclaw/plugin-sdk/number-runtime";
+import { createChannelPairingChallengeIssuer } from "openclaw/plugin-sdk/channel-pairing";
 import { createHash } from "node:crypto";
-import { fanInChannelIngressLifecycles } from "openclaw/plugin-sdk/channel-ingress-runtime";
-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 { resolveDefaultGroupPolicy, warnMissingProviderGroupPolicyFallbackOnce } from "openclaw/plugin-sdk/runtime-group-policy";
 import { resolveChunkMode, resolveTextChunkLimit } from "openclaw/plugin-sdk/reply-runtime";
 import { CHANNEL_APPROVAL_NATIVE_RUNTIME_CONTEXT_CAPABILITY } from "openclaw/plugin-sdk/approval-handler-runtime";
 import { 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 { fanInChannelIngressLifecycles, resolveStableChannelMessageIngress } from "openclaw/plugin-sdk/channel-ingress-runtime";
+import { getSessionEntry, patchSessionEntry, resolveGroupSessionKey, resolveStorePath, resolveStorePath as resolveStorePath$1, updateLastRoute } from "openclaw/plugin-sdk/session-store-runtime";
 import { saveMediaStream } from "openclaw/plugin-sdk/media-store";
+import { upsertChannelPairingRequest } from "openclaw/plugin-sdk/conversation-runtime";
 import { createDedupeCache } from "openclaw/plugin-sdk/dedupe-runtime";
 import { getRuntimeConfig as getRuntimeConfig$1 } from "openclaw/plugin-sdk/runtime-config-snapshot";
 import { resolveChannelContextVisibilityMode } from "openclaw/plugin-sdk/context-visibility-runtime";
 import { buildMentionRegexes, implicitMentionKindWhen, normalizeMentionText, resolveInboundMentionDecision } from "openclaw/plugin-sdk/channel-mention-gating";
-import { createConnectedChannelStatusPatch, createTransportActivityStatusPatch } from "openclaw/plugin-sdk/gateway-runtime";
+import { channelReadyPatch, channelStoppedPatch, 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 { formatAudioTranscriptForAgent } from "openclaw/plugin-sdk/media-understanding-runtime";
 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";
+import { resolveAgentConfig } from "openclaw/plugin-sdk/agent-scope-runtime";
+//#region extensions/whatsapp/src/inbound/group-conversation.ts
+function resolveWhatsAppGroupConversationId(conversationId) {
+	return resolveGroupSessionKey({
+		From: conversationId,
+		ChatType: "group",
+		Provider: "whatsapp"
+	})?.id ?? conversationId;
+}
+//#endregion
+//#region extensions/whatsapp/src/inbound/admission.ts
+const ingressResolverByAdmission = /* @__PURE__ */ new WeakMap();
+function copyAccount(account) {
+	const copied = {
+		accountId: account.accountId,
+		enabled: account.enabled,
+		sendReadReceipts: account.sendReadReceipts
+	};
+	if (account.name) copied.name = account.name;
+	if (typeof account.selfChatMode === "boolean") copied.selfChatMode = account.selfChatMode;
+	if (account.replyToMode) copied.replyToMode = account.replyToMode;
+	return copied;
+}
+function buildWhatsAppInboundAdmission(params) {
+	const admission = {
+		channelIngress: params.channelIngress,
+		accountId: params.policy.account.accountId,
+		isSelfChat: params.policy.isSelfChat,
+		account: copyAccount(params.policy.account),
+		conversation: {
+			kind: params.isGroup ? "group" : "direct",
+			id: params.conversationId,
+			groupSessionId: resolveWhatsAppGroupConversationId(params.conversationId)
+		},
+		sender: {
+			id: params.senderId,
+			isSamePhone: params.policy.isSamePhone(params.senderId)
+		},
+		ingress: {
+			admission: params.access.ingress.admission,
+			decision: params.access.ingress.decision,
+			decisiveGateId: params.access.ingress.decisiveGateId,
+			reasonCode: params.access.ingress.reasonCode
+		},
+		senderAccess: {
+			allowed: params.access.senderAccess.allowed,
+			decision: params.access.senderAccess.decision,
+			reasonCode: params.access.senderAccess.reasonCode,
+			providerMissingFallbackApplied: params.access.senderAccess.providerMissingFallbackApplied
+		},
+		commandAccess: {
+			requested: params.access.commandAccess.requested,
+			authorized: params.access.commandAccess.authorized,
+			shouldBlockControlCommand: params.access.commandAccess.shouldBlockControlCommand,
+			reasonCode: params.access.commandAccess.reasonCode
+		},
+		activationAccess: {
+			ran: params.access.activationAccess.ran,
+			allowed: params.access.activationAccess.allowed,
+			shouldSkip: params.access.activationAccess.shouldSkip,
+			reasonCode: params.access.activationAccess.reasonCode
+		}
+	};
+	if (params.resolveChannelIngress) ingressResolverByAdmission.set(admission, params.resolveChannelIngress);
+	return admission;
+}
+async function resolveWhatsAppAdmissionChannelIngress(admission, contextBinding) {
+	return await ingressResolverByAdmission.get(admission)?.(contextBinding);
+}
+function requireWhatsAppInboundAdmission(params) {
+	if (!params.admission) throw new Error("WhatsApp inbound message is missing admission facts");
+	return params.admission;
+}
+//#endregion
+//#region extensions/whatsapp/src/inbound-policy.ts
+function normalizeWhatsAppIngressPhone(value) {
+	const trimmed = value.trim();
+	if (!trimmed) return null;
+	return normalizeE164(trimmed);
+}
+function buildResolvedWhatsAppGroupConfig(params) {
+	return { channels: { whatsapp: {
+		groupPolicy: params.groupPolicy,
+		groups: params.groups
+	} } };
+}
+function resolveWhatsAppInboundPolicy(params) {
+	const account = resolveWhatsAppAccount({
+		cfg: params.cfg,
+		accountId: params.accountId
+	});
+	const configuredAllowFrom = account.allowFrom ?? [];
+	const dmPolicy = account.dmPolicy ?? "pairing";
+	const dmAllowFrom = configuredAllowFrom.length > 0 ? configuredAllowFrom : params.selfE164 ? [params.selfE164] : [];
+	const groupAllowFrom = (Array.isArray(account.groupAllowFrom) && account.groupAllowFrom.length > 0 ? account.groupAllowFrom : void 0) ?? (configuredAllowFrom.length > 0 ? configuredAllowFrom : void 0) ?? [];
+	const defaultGroupPolicy = resolveDefaultGroupPolicy(params.cfg);
+	const { groupPolicy, providerMissingFallbackApplied } = resolveWhatsAppRuntimeGroupPolicy({
+		providerConfigPresent: params.cfg.channels?.whatsapp !== void 0,
+		groupPolicy: account.groupPolicy,
+		defaultGroupPolicy
+	});
+	const resolvedGroupCfg = buildResolvedWhatsAppGroupConfig({
+		groupPolicy,
+		groups: account.groups
+	});
+	const isSamePhone = (value) => typeof value === "string" && typeof params.selfE164 === "string" && value === params.selfE164;
+	return {
+		account,
+		dmPolicy,
+		groupPolicy,
+		configuredAllowFrom,
+		dmAllowFrom,
+		groupAllowFrom,
+		isSelfChat: account.selfChatMode ?? isSelfChatMode(params.selfE164, configuredAllowFrom),
+		providerMissingFallbackApplied,
+		isSamePhone,
+		resolveConversationGroupPolicy: (conversationId) => resolveChannelGroupPolicy({
+			cfg: resolvedGroupCfg,
+			channel: "whatsapp",
+			groupId: resolveWhatsAppGroupConversationId(conversationId),
+			hasGroupAllowFrom: groupAllowFrom.length > 0
+		}),
+		resolveConversationRequireMention: (conversationId) => resolveChannelGroupRequireMention({
+			cfg: resolvedGroupCfg,
+			channel: "whatsapp",
+			groupId: resolveWhatsAppGroupConversationId(conversationId)
+		})
+	};
+}
+async function resolveWhatsAppIngressAccess(params) {
+	return await resolveStableChannelMessageIngress({
+		channelId: "whatsapp",
+		accountId: params.policy.account.accountId,
+		identity: {
+			key: "whatsapp-sender-phone",
+			kind: "phone",
+			normalize: normalizeWhatsAppIngressPhone,
+			sensitivity: "pii",
+			entryIdPrefix: "whatsapp-entry"
+		},
+		cfg: params.cfg,
+		useDefaultPairingStore: true,
+		subject: { stableId: params.senderId ?? "" },
+		conversation: {
+			kind: params.isGroup ? "group" : "direct",
+			id: params.conversationId
+		},
+		contextBinding: params.contextBinding,
+		dmPolicy: params.policy.dmPolicy,
+		groupPolicy: params.policy.groupPolicy,
+		policy: { groupAllowFromFallbackToAllowFrom: false },
+		providerMissingFallbackApplied: params.policy.providerMissingFallbackApplied,
+		allowFrom: !params.isGroup && params.policy.account.selfChatMode !== false && params.senderId && params.policy.isSamePhone(params.senderId) ? [...params.policy.dmAllowFrom, params.senderId] : params.policy.dmAllowFrom,
+		groupAllowFrom: params.policy.groupAllowFrom,
+		command: params.includeCommand === true ? {} : void 0
+	});
+}
+async function resolveWhatsAppCommandAuthorized(params) {
+	const self = getSelfIdentity(params.msg, params.authDir);
+	const admission = requireWhatsAppInboundAdmission(params.msg);
+	const policy = params.policy ?? resolveWhatsAppInboundPolicy({
+		cfg: params.cfg,
+		accountId: admission.accountId,
+		selfE164: self.e164 ?? null
+	});
+	const isGroup = admission.conversation.kind === "group";
+	const sender = getSenderIdentity(params.msg, params.authDir);
+	const dmSender = sender.e164 ?? admission.conversation.id;
+	const groupSender = sender.e164 ?? "";
+	if (!normalizeE164(isGroup ? groupSender : dmSender)) return false;
+	return (await resolveWhatsAppIngressAccess({
+		cfg: params.cfg,
+		policy,
+		isGroup,
+		conversationId: admission.conversation.id,
+		senderId: isGroup ? groupSender : dmSender,
+		includeCommand: true
+	})).commandAccess.authorized;
+}
+//#endregion
 //#region extensions/whatsapp/src/inbound/baileys-cache.ts
 const WHATSAPP_BAILEYS_CACHE_MAX_ENTRIES = 500;
 function rememberWhatsAppBaileysCacheEntry(cache, key, value, ttlMs) {
@@ -84,353 +270,6 @@ function readWhatsAppBaileysCacheEntry(cache, key) {
 	return entry.value;
 }
 //#endregion
-//#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 defineDeprecatedStructuredContextPayloadAlias(msg) {
-	const channelStructuredContext = msg.payload.channelStructuredContext ?? msg.payload.untrustedStructuredContext;
-	if (channelStructuredContext !== void 0) msg.payload.channelStructuredContext = channelStructuredContext;
-	Object.defineProperty(msg.payload, "untrustedStructuredContext", {
-		configurable: true,
-		enumerable: true,
-		get: () => msg.payload.channelStructuredContext,
-		set: (value) => {
-			msg.payload.channelStructuredContext = value;
-		}
-	});
-}
-function defineDeprecatedAdmissionTopLevelAccessors(msg) {
-	let fallbackConversationId = msg.conversationId || msg.from;
-	let fallbackAccountId = msg.accountId;
-	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: () => {
-				if (msg.admission?.ingress.decisiveGateId === "legacy-flat-compat") return fallbackAccessControlPassed;
-				return msg.admission ? msg.admission.ingress.decision === "allow" : fallbackAccessControlPassed;
-			},
-			set: (value) => {
-				if (!msg.admission) 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) {
-	defineDeprecatedStructuredContextPayloadAlias(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)
-		},
-		channelStructuredContext: {
-			get: () => msg.payload.channelStructuredContext,
-			set: (value) => msg.payload.channelStructuredContext = value
-		},
-		untrustedStructuredContext: {
-			get: () => msg.payload.channelStructuredContext,
-			set: (value) => msg.payload.channelStructuredContext = 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,
-			channelStructuredContext: msg.channelStructuredContext ?? 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);
-}
-function normalizeAdmittedWebInboundMessage(msg) {
-	return requireAdmittedWhatsAppInboundMessage(normalizeWebInboundMessage(msg));
-}
-//#endregion
 //#region extensions/whatsapp/src/inbound/durable-payload.ts
 var WhatsAppIngressPermanentError = class extends Error {
 	constructor(reason, message, options) {
@@ -625,10 +464,14 @@ function createWhatsAppGroupMetadataCacheOwner(params) {
 		const cached = readGroupMetadataCacheEntry(localCache, jid);
 		if (cached) return cached;
 		try {
-			const meta = await (params.getCurrentSock() ?? params.sock).groupMetadata(jid);
-			rememberWhatsAppBaileysCacheEntry(params.baileysCache, jid, meta, GROUP_META_TTL_MS);
+			const hydratedEntry = params.baileysCache?.get(jid);
+			const providerMetadata = params.baileysCache ? readWhatsAppBaileysCacheEntry(params.baileysCache, jid) : void 0;
+			const hydratedMetadata = providerMetadata?.participants?.length ? providerMetadata : void 0;
+			const meta = hydratedMetadata ?? await (params.getCurrentSock() ?? params.sock).groupMetadata(jid);
+			if (!hydratedMetadata) rememberWhatsAppBaileysCacheEntry(params.baileysCache, jid, meta, GROUP_META_TTL_MS);
 			publishedJids.add(jid);
 			const entry = await summarize(meta);
+			if (hydratedMetadata && hydratedEntry) entry.expires = hydratedEntry.expiresAt;
 			rememberGroupMetadataCacheEntry(reconnectCache, jid, {
 				subject: entry.subject,
 				expires: entry.expires
@@ -647,7 +490,7 @@ function createWhatsAppGroupMetadataCacheOwner(params) {
 		}
 	};
 	const resolveOutboundMentions = async (jid, text) => {
-		if (isJidGroup(jid) !== true || !mayContainWhatsAppOutboundMention(text)) return {
+		if (isJidGroup$1(jid) !== true || !mayContainWhatsAppOutboundMention(text)) return {
 			text,
 			mentionedJids: []
 		};
@@ -819,7 +662,7 @@ function createWhatsAppInboundMessageDebouncer(options) {
 							...last.group,
 							mentions: combinedMentions
 						} : void 0;
-						const combinedMessage = attachWhatsAppIngressLifecycle(withDeprecatedWebInboundMessageFlatAliases({
+						const combinedMessage = attachWhatsAppIngressLifecycle({
 							...last,
 							turnAdoptionLifecycle: admissionLifecycle,
 							payload: {
@@ -832,7 +675,7 @@ function createWhatsAppInboundMessageDebouncer(options) {
 								...last.event,
 								isBatched: true
 							}
-						}), admissionLifecycle);
+						}, admissionLifecycle);
 						await options.onMessage(combinedMessage);
 						await settle();
 						await Promise.all(orderedEntries.map((entry) => options.markRead(entry.readReceipt)));
@@ -898,27 +741,21 @@ function createWhatsAppInboundMessageDebouncer(options) {
 }
 //#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);
+	return normalizeMessageContent$1(message);
 }
-async function downloadInboundMedia(msg, sock, maxBytes = 50 * 1024 * 1024) {
-	const message = unwrapMessage(msg.message);
+async function downloadInboundMedia(msg, sock, maxBytes = 50 * 1024 * 1024, normalizedMessage) {
+	const message = normalizedMessage ?? 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;
+	if (!message.imageMessage && !message.videoMessage && !message.ptvMessage && !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);
+			if (err instanceof Error && /Media exceeds/i.test(err.message)) throw new Error(`Media exceeds ${Math.round(maxBytes / (1024 * 1024))}MB limit`);
 			throw err;
 		}),
 		mimetype,
@@ -929,12 +766,18 @@ async function downloadQuotedInboundMedia(msg, sock, maxBytes = 50 * 1024 * 1024
 	const contextInfo = extractContextInfo(unwrapMessage(msg.message));
 	if (!contextInfo?.quotedMessage) return;
 	const quotedMessage = contextInfo.quotedMessage;
+	const self = sock.user;
+	const quotedFromMe = identitiesOverlap({ jid: contextInfo.participant }, {
+		jid: self?.id,
+		lid: self?.lid,
+		e164: self?.phoneNumber
+	});
 	return downloadInboundMedia({
 		key: {
 			id: contextInfo?.stanzaId || void 0,
 			remoteJid: contextInfo.remoteJid ?? msg.key?.remoteJid ?? void 0,
 			participant: contextInfo?.participant ?? void 0,
-			fromMe: false
+			fromMe: quotedFromMe
 		},
 		message: quotedMessage,
 		messageTimestamp: msg.messageTimestamp
@@ -942,19 +785,46 @@ async function downloadQuotedInboundMedia(msg, sock, maxBytes = 50 * 1024 * 1024
 }
 //#endregion
 //#region extensions/whatsapp/src/inbound/message-enrichment.ts
+const inboundMediaLogger = createSubsystemLogger("gateway/channels/whatsapp").child("inbound");
+const MAX_MEDIA_ERROR_MESSAGE_CHARS = 256;
+function sanitizeMediaErrorMessage(error) {
+	return truncateUtf16Safe(redactToolPayloadText(error instanceof Error ? error.message : String(error)).replace(/https?:\/\/\S+/giu, "[redacted-url]").replace(/\b[^@\s]+@[a-z][a-z\d.-]*\b/giu, "[redacted-jid]").replace(/\+?\d[\d ().-]{6,}\d/gu, "[redacted-phone]").split("\n", 1)[0]?.trim() || "unknown error", MAX_MEDIA_ERROR_MESSAGE_CHARS);
+}
+function logMediaMaterializationFailure(params) {
+	const errorClass = params.error instanceof Error && /^[A-Za-z][A-Za-z0-9_.-]{0,63}$/u.test(params.error.name) ? params.error.name : "Error";
+	const statusCode = getStatusCode(params.error);
+	const errorMessage = sanitizeMediaErrorMessage(params.error);
+	const failureDetails = [
+		`stage=${params.failureStage}`,
+		...params.mediaKind ? [`kind=${params.mediaKind}`] : [],
+		...typeof statusCode === "number" ? [`status=${statusCode}`] : []
+	].join(" ");
+	inboundMediaLogger.warn("WhatsApp inbound media materialization failed", {
+		channel: "whatsapp",
+		messageId: params.messageId ?? void 0,
+		mediaKind: params.mediaKind,
+		mimeType: params.mimeType,
+		failureStage: params.failureStage,
+		errorClass,
+		...typeof statusCode === "number" ? { statusCode } : {},
+		errorMessage,
+		consoleMessage: `WhatsApp inbound media materialization failed (${failureDetails}): ${errorMessage}`
+	});
+}
 async function enrichWhatsAppInboundMessage(params) {
 	const { msg, sock } = params;
-	const location = extractLocationData(msg.message ?? void 0);
+	const messageProjection = projectWhatsAppInboundMessage(msg.message ?? void 0);
+	const location = extractLocationData(messageProjection);
 	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);
+	const contactContext = extractContactContext(messageProjection);
+	const externalAdReplyContext = extractExternalAdReplyContext(messageProjection);
+	let mediaKind = extractMediaKind(messageProjection);
+	let body = extractText(messageProjection);
 	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);
+	const replyContext = describeReplyContext(messageProjection);
 	let mediaPath;
 	let mediaType = mediaKind ? resolveInboundMediaMimetype(msg.message) : void 0;
 	const nativeMedia = mediaKind ? {
@@ -970,8 +840,15 @@ async function enrichWhatsAppInboundMessage(params) {
 		mediaFileName = inboundMedia.fileName;
 	};
 	try {
-		await saveInboundMedia(await downloadInboundMedia(msg, sock, maxBytes));
+		await saveInboundMedia(await downloadInboundMedia(msg, sock, maxBytes, messageProjection[0]));
 	} catch (error) {
+		logMediaMaterializationFailure({
+			messageId: msg.key?.id,
+			mediaKind,
+			mimeType: mediaType,
+			failureStage: "direct",
+			error
+		});
 		params.logVerbose(`Inbound media download failed: ${String(error)}`);
 		body = formatInboundMediaUnavailableText({
 			body,
@@ -983,6 +860,13 @@ async function enrichWhatsAppInboundMessage(params) {
 		mediaKind = replyContext.media.kind ?? void 0;
 		mediaType = mediaType ?? replyContext.media.contentType ?? void 0;
 	} catch (error) {
+		logMediaMaterializationFailure({
+			messageId: msg.key?.id,
+			mediaKind: replyContext.media.kind ?? void 0,
+			mimeType: replyContext.media.contentType ?? void 0,
+			failureStage: "quoted",
+			error
+		});
 		params.logVerbose(`Quoted media download failed: ${String(error)}`);
 		body = formatInboundMediaUnavailableText({
 			body,
@@ -1000,7 +884,114 @@ async function enrichWhatsAppInboundMessage(params) {
 		mediaType,
 		mediaFileName,
 		mediaKind,
-		nativeMedia
+		nativeMedia,
+		mentionedJids: extractMentionedJids(messageProjection)
+	};
+}
+//#endregion
+//#region extensions/whatsapp/src/inbound/access-control.ts
+const PAIRING_REPLY_HISTORY_GRACE_MS = 3e4;
+function logWhatsAppVerbose$2(enabled, message) {
+	if (!enabled) return;
+	defaultRuntime.log(message);
+}
+function blockedInboundAccess(policy) {
+	return {
+		allowed: false,
+		shouldMarkRead: false,
+		isSelfChat: policy.isSelfChat,
+		resolvedAccountId: policy.account.accountId
+	};
+}
+async function checkInboundAccessControl(params) {
+	const policy = resolveWhatsAppInboundPolicy({
+		cfg: params.cfg,
+		accountId: params.accountId,
+		selfE164: params.selfE164
+	});
+	const pairingGraceMs = typeof params.pairingGraceMs === "number" && params.pairingGraceMs > 0 ? params.pairingGraceMs : PAIRING_REPLY_HISTORY_GRACE_MS;
+	const suppressPairingReply = typeof params.connectedAtMs === "number" && typeof params.messageTimestampMs === "number" && params.messageTimestampMs < params.connectedAtMs - pairingGraceMs;
+	warnMissingProviderGroupPolicyFallbackOnce({
+		providerMissingFallbackApplied: policy.providerMissingFallbackApplied,
+		providerKey: "whatsapp",
+		accountId: policy.account.accountId,
+		log: (message) => logWhatsAppVerbose$2(params.verbose, message)
+	});
+	const conversationId = params.group ? params.remoteJid : params.from;
+	const accessSenderId = params.group ? params.senderE164 : params.from;
+	const admissionSenderId = params.group ? params.senderE164 ?? params.senderJid ?? params.from : params.from;
+	const resolveChannelIngress = async (contextBinding) => await resolveWhatsAppIngressAccess({
+		cfg: params.cfg,
+		policy,
+		isGroup: params.group,
+		conversationId,
+		senderId: accessSenderId,
+		contextBinding
+	});
+	const access = await resolveChannelIngress();
+	const { senderAccess } = access;
+	if (params.group && senderAccess.decision !== "allow") {
+		if (senderAccess.reasonCode === "group_policy_disabled") logWhatsAppVerbose$2(params.verbose, "Blocked group message (groupPolicy: disabled)");
+		else if (senderAccess.reasonCode === "group_policy_empty_allowlist") logWhatsAppVerbose$2(params.verbose, "Blocked group message (groupPolicy: allowlist, no groupAllowFrom)");
+		else logWhatsAppVerbose$2(params.verbose, `Blocked group message from ${params.senderE164 ?? "unknown sender"} (groupPolicy: allowlist)`);
+		return blockedInboundAccess(policy);
+	}
+	if (!params.group) {
+		if (params.isFromMe && (policy.account.selfChatMode === false || !policy.isSamePhone(params.from))) {
+			logWhatsAppVerbose$2(params.verbose, "Skipping outbound DM (fromMe); no pairing reply needed.");
+			return blockedInboundAccess(policy);
+		}
+		if (senderAccess.decision === "block" && senderAccess.reasonCode === "dm_policy_disabled") {
+			logWhatsAppVerbose$2(params.verbose, "Blocked dm (dmPolicy: disabled)");
+			return blockedInboundAccess(policy);
+		}
+		if (senderAccess.decision === "pairing" && !policy.isSamePhone(params.from)) {
+			const candidate = params.from;
+			if (suppressPairingReply) logWhatsAppVerbose$2(params.verbose, `Skipping pairing reply for historical DM from ${candidate}.`);
+			else await createChannelPairingChallengeIssuer({
+				channel: "whatsapp",
+				accountId: policy.account.accountId,
+				upsertPairingRequest: async ({ id, meta }) => await upsertChannelPairingRequest({
+					channel: "whatsapp",
+					id,
+					accountId: policy.account.accountId,
+					meta
+				})
+			})({
+				senderId: candidate,
+				senderIdLine: `Your WhatsApp phone number: ${candidate}`,
+				meta: { name: (params.pushName ?? "").trim() || void 0 },
+				onCreated: () => {
+					logWhatsAppVerbose$2(params.verbose, `whatsapp pairing request sender=${candidate} name=${params.pushName ?? "unknown"}`);
+				},
+				sendPairingReply: async (text) => {
+					await params.sock.sendMessage(params.remoteJid, { text });
+				},
+				onReplyError: (err) => {
+					logWhatsAppVerbose$2(params.verbose, `whatsapp pairing reply failed for ${candidate}: ${String(err)}`);
+				}
+			});
+			return blockedInboundAccess(policy);
+		}
+		if (senderAccess.decision !== "allow") {
+			logWhatsAppVerbose$2(params.verbose, `Blocked unauthorized sender ${params.from} (dmPolicy=${policy.dmPolicy})`);
+			return blockedInboundAccess(policy);
+		}
+	}
+	return {
+		allowed: true,
+		shouldMarkRead: true,
+		isSelfChat: policy.isSelfChat,
+		resolvedAccountId: policy.account.accountId,
+		admission: buildWhatsAppInboundAdmission({
+			policy,
+			access,
+			channelIngress: access,
+			resolveChannelIngress,
+			isGroup: params.group,
+			conversationId,
+			senderId: admissionSenderId
+		})
 	};
 }
 //#endregion
@@ -1011,7 +1002,14 @@ const recentOutboundMessages = createDedupeCache({
 });
 function buildMessageKey(params) {
 	const accountId = params.accountId.trim();
-	const remoteJid = params.remoteJid.trim();
+	const rawRemoteJid = params.remoteJid.trim();
+	const hostedPhone = isHostedPnUser(rawRemoteJid);
+	let remoteJid;
+	if (hostedPhone || isHostedLidUser(rawRemoteJid)) {
+		const decodedJid = jidDecode(rawRemoteJid);
+		if (!decodedJid) return null;
+		remoteJid = jidEncode(decodedJid.user, hostedPhone ? "s.whatsapp.net" : "lid");
+	} else remoteJid = jidNormalizedUser(rawRemoteJid);
 	const messageId = params.messageId.trim();
 	if (!accountId || !remoteJid || !messageId || messageId === "unknown") return null;
 	return `${accountId}:${remoteJid}:${messageId}`;
@@ -1027,7 +1025,13 @@ function rememberRecentOutboundMessage(params) {
 function isRecentOutboundMessage(params) {
 	const key = buildMessageKey(params);
 	if (!key) return false;
-	return recentOutboundMessages.peek(key);
+	if (recentOutboundMessages.peek(key)) return true;
+	if (!params.alternateRemoteJid || isJidGroup(params.remoteJid)) return false;
+	const alternateKey = buildMessageKey({
+		...params,
+		remoteJid: params.alternateRemoteJid
+	});
+	return alternateKey !== null && recentOutboundMessages.peek(alternateKey);
 }
 //#endregion
 //#region extensions/whatsapp/src/inbound/message-normalization.ts
@@ -1039,6 +1043,7 @@ function createWhatsAppInboundMessageNormalizer(options) {
 		if (!msg.key?.fromMe || !id || !remoteJid || !isRecentOutboundMessage({
 			accountId: options.accountId,
 			remoteJid,
+			alternateRemoteJid: msg.key?.remoteJidAlt,
 			messageId: id
 		})) return false;
 		options.logVerbose(`Skipping recent outbound WhatsApp echo ${id} for ${remoteJid}`);
@@ -1048,7 +1053,7 @@ function createWhatsAppInboundMessageNormalizer(options) {
 		const id = msg.key?.id ?? void 0;
 		const remoteJid = msg.key?.remoteJid;
 		if (!remoteJid || remoteJid.endsWith("@status") || remoteJid.endsWith("@broadcast")) return null;
-		const group = isJidGroup(remoteJid) === true;
+		const group = isJidGroup$1(remoteJid) === true;
 		if (shouldSkipRecentOutboundEcho(msg)) return null;
 		if (!hasInboundUserContent(msg.message ?? void 0)) return null;
 		const participantJid = msg.key?.participant ?? void 0;
@@ -1122,7 +1127,7 @@ function recordAcceptedInboundActivity(accountId) {
 }
 function createWhatsAppMessageDeliveryCoordinator(options) {
 	const inboundLogger = getChildLogger({ module: "web-inbound" });
-	const inboundConsoleLog = createSubsystemLogger("gateway/channels/whatsapp").child("inbound");
+	const inboundConsoleLog = createSubsystemLogger$1("gateway/channels/whatsapp").child("inbound");
 	const sock = options.sock;
 	const socketSession = options.socketSession;
 	const groupMetadata = options.groupMetadata;
@@ -1213,7 +1218,7 @@ function createWhatsAppMessageDeliveryCoordinator(options) {
 			return normalizeWhatsAppSendResult(await sendTrackedMessage(chatJid, await groupMetadata.applyOutboundMentions(chatJid, previewPayload), optionsValue), "media");
 		};
 		const timestamp = inbound.messageTimestampMs;
-		const mentionedJids = extractMentionedJids(msg.message);
+		const mentionedJids = enriched.mentionedJids;
 		const senderName = msg.pushName ?? void 0;
 		inboundLogger.info({
 			from: inbound.from,
@@ -1256,7 +1261,7 @@ function createWhatsAppMessageDeliveryCoordinator(options) {
 				payload: enriched.externalAdReplyContext
 			}] : []
 		];
-		const inboundMessage = withDeprecatedWebInboundMessageFlatAliases({
+		const inboundMessage = {
 			admission: inbound.access.admission,
 			event: {
 				id: inbound.id,
@@ -1305,7 +1310,7 @@ function createWhatsAppMessageDeliveryCoordinator(options) {
 			turnAdoptionLifecycle: durable.turnAdoptionLifecycle,
 			readReceipt: durable.readReceipt,
 			receiveOrder: durable.receiveOrder
-		});
+		};
 		if (inboundMessage.event.id) {
 			const admission = requireWhatsAppInboundAdmission(inboundMessage);
 			cacheInboundMessageMeta(admission.accountId, inboundMessage.platform.chatJid, inboundMessage.event.id, {
@@ -1634,7 +1639,10 @@ async function createWhatsAppAttachedSocketSession(options) {
 		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 (activeState) {
+			const error = new Error(formatReachoutTimelockError(activeState));
+			throw readinessOptions?.rememberReady ? new PlatformMessageNotDispatchedError(error.message, { cause: error }) : error;
+		}
 		if (readinessOptions?.rememberReady && state) rememberVerifiedSendReady(jid, currentSock);
 	};
 	const assertSendReady = async (to) => {
@@ -1757,7 +1765,7 @@ function logWhatsAppVerbose(enabled, message) {
 }
 async function attachWebInboxToSocket(options) {
 	const inboundLogger = getChildLogger({ module: "web-inbound" });
-	const inboundConsoleLog = createSubsystemLogger("gateway/channels/whatsapp").child("inbound");
+	const inboundConsoleLog = createSubsystemLogger$1("gateway/channels/whatsapp").child("inbound");
 	const socketSession = await createWhatsAppAttachedSocketSession({
 		sock: options.sock,
 		socketRef: options.socketRef,
@@ -1856,10 +1864,6 @@ async function monitorWebInbox(options) {
 	}
 	return attachWebInboxToSocket({
 		...options,
-		onMessage: async (msg) => {
-			await options.onMessage(normalizeAdmittedWebInboundMessage(msg));
-		},
-		shouldDebounce: options.shouldDebounce ? (msg) => options.shouldDebounce?.(normalizeAdmittedWebInboundMessage(msg)) ?? true : void 0,
 		socketTiming,
 		sock,
 		recentMessageKeys,
@@ -1868,7 +1872,7 @@ async function monitorWebInbox(options) {
 }
 //#endregion
 //#region extensions/whatsapp/src/auto-reply/loggers.ts
-const whatsappLog = createSubsystemLogger("gateway/channels/whatsapp");
+const whatsappLog = createSubsystemLogger$1("gateway/channels/whatsapp");
 const whatsappInboundLog = whatsappLog.child("inbound");
 const whatsappOutboundLog = whatsappLog.child("outbound");
 const whatsappHeartbeatLog = whatsappLog.child("heartbeat");
@@ -1932,6 +1936,15 @@ function resolveOwnerList(mentionCfg, selfE164) {
 }
 //#endregion
 //#region extensions/whatsapp/src/auto-reply/monitor-state.ts
+const LIFECYCLE_BY_HEALTH_STATE = {
+	starting: "starting",
+	healthy: "ready",
+	stale: "recovering",
+	reconnecting: "recovering",
+	conflict: "blocked",
+	"logged-out": "blocked",
+	stopped: "blocked"
+};
 function cloneStatus(status) {
 	return {
 		...status,
@@ -1955,7 +1968,8 @@ function createWebChannelStatusController(statusSink) {
 		lastError: null,
 		busy: false,
 		lastRunActivityAt: null,
-		healthState: "starting"
+		healthState: "starting",
+		lifecycle: "starting"
 	};
 	const emit = () => {
 		statusSink?.(cloneStatus(status));
@@ -1964,16 +1978,17 @@ function createWebChannelStatusController(statusSink) {
 		emit,
 		snapshot: () => status,
 		noteConnected(at = Date.now()) {
-			Object.assign(status, createConnectedChannelStatusPatch(at));
+			Object.assign(status, channelReadyPatch({
+				lastConnectedAt: at,
+				lastEventAt: 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()) {
@@ -1981,7 +1996,10 @@ function createWebChannelStatusController(statusSink) {
 			status.lastMessageAt = at;
 			status.lastEventAt = at;
 			Object.assign(status, createTransportActivityStatusPatch(at));
-			if (status.connected) status.healthState = "healthy";
+			if (status.connected) {
+				status.healthState = "healthy";
+				status.lifecycle = "ready";
+			}
 			emit();
 		},
 		noteTransportActivity(at = Date.now()) {
@@ -1993,12 +2011,18 @@ function createWebChannelStatusController(statusSink) {
 			if (status.busy === busy && status.lastRunActivityAt === at) return;
 			status.busy = busy;
 			status.lastRunActivityAt = at;
-			if (status.connected && busy) status.healthState = "healthy";
+			if (status.connected && busy) {
+				status.healthState = "healthy";
+				status.lifecycle = "ready";
+			}
 			emit();
 		},
 		noteWatchdogStale(at = Date.now()) {
 			status.lastEventAt = at;
-			if (status.connected) status.healthState = "stale";
+			if (status.connected) {
+				status.healthState = "stale";
+				status.lifecycle = "recovering";
+			}
 			emit();
 		},
 		noteReconnectAttempts(reconnectAttempts) {
@@ -2019,52 +2043,28 @@ function createWebChannelStatusController(statusSink) {
 			status.lastError = params.error ?? null;
 			status.reconnectAttempts = params.reconnectAttempts;
 			status.healthState = params.healthState;
+			status.lifecycle = LIFECYCLE_BY_HEALTH_STATE[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";
+			const terminalDisconnect = status.lifecycle === "blocked";
+			if (!isTerminalHealthState(status.healthState)) {
+				Object.assign(status, channelStoppedPatch({
+					lastEventAt: at,
+					terminalDisconnect
+				}));
+				status.healthState = "stopped";
+			} else Object.assign(status, {
+				running: false,
+				connected: false,
+				lastEventAt: at,
+				terminalDisconnect
+			});
 			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 buildTextKey = (text, conversationId) => conversationId ? `${conversationId}\0${text}` : text;
-	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(buildTextKey(text, opts.conversationId));
-		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, conversationId) => recentlySent.has(buildTextKey(key, conversationId)),
-		forget: (key, conversationId) => {
-			recentlySent.delete(buildTextKey(key, conversationId));
-		},
-		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).";
@@ -2157,8 +2157,6 @@ async function resolveWhatsAppReactionEligibility(params) {
 		agentId: params.agentId,
 		ackConfig: params.cfg.messages?.ackReaction
 	});
-	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 activation = isGroup ? await resolveGroupActivationFor({
 		cfg: params.cfg,
@@ -2167,14 +2165,14 @@ async function resolveWhatsAppReactionEligibility(params) {
 		sessionKey: params.sessionKey,
 		conversationId: admission.conversation.id
 	}) : null;
-	if (!shouldAckReactionForWhatsApp({
-		emoji,
+	if (!emoji || !shouldAckReaction({
+		scope,
 		isDirect: admission.conversation.kind === "direct",
 		isGroup,
-		directEnabled,
-		groupMode,
-		wasMentioned: (params.msg.groupMention?.wasMentioned ?? params.msg.wasMentioned) === true,
-		groupActivated: activation === "always"
+		isMentionableGroup: isGroup,
+		canDetectMention: isGroup,
+		effectiveWasMentioned: (params.msg.groupMention?.wasMentioned ?? params.msg.wasMentioned) === true,
+		shouldBypassMention: activation === "always"
 	})) return DISABLED_REACTION;
 	const participant = resolveReactionParticipant(params.msg);
 	return {
@@ -2184,7 +2182,7 @@ async function resolveWhatsAppReactionEligibility(params) {
 		emoji,
 		reactionOptions: {
 			verbose: params.verbose,
-			fromMe: false,
+			fromMe: params.msg.platform.fromMe === true,
 			...participant ? { participant } : {},
 			accountId,
 			cfg: params.cfg
@@ -2375,7 +2373,7 @@ function recordPendingGroupHistoryEntry(params) {
 			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: [{
+			...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,
@@ -2495,7 +2493,8 @@ async function applyGroupGating(params) {
 				needsMentionText: true
 			};
 		}
-		return skipGroupMessageAndStoreHistory(params, `Group message stored for context (no mention detected) in ${conversationId}: ${mentionMsg.payload.body}`, params.mentionText);
+		const pendingHistoryBody = params.mentionText === void 0 ? void 0 : formatAudioTranscriptForAgent(params.mentionText);
+		return skipGroupMessageAndStoreHistory(params, `Group message stored for context (no mention detected) in ${conversationId}: ${mentionMsg.payload.body}`, pendingHistoryBody);
 	}
 	return { shouldProcess: true };
 }
@@ -2571,7 +2570,7 @@ var WhatsAppOutboundRetryError = class extends Error {
 	}
 };
 function isRetryableWhatsAppOutboundError(error) {
-	if (isWhatsAppSocketOperationTimeoutError(error)) return false;
+	if (isChannelPartialDeliveryError(error) || isWhatsAppSocketOperationTimeoutError(error)) return false;
 	return WHATSAPP_RETRYABLE_OUTBOUND_ERROR_PATTERN.test(formatError(error));
 }
 async function sendWhatsAppOutboundWithRetry(params) {
@@ -2706,14 +2705,14 @@ function createWhatsAppReplyDeliveryReceipt(results) {
 	});
 }
 async function deliverWebReply(params) {
+	return await withWhatsAppLogicalDeliveryActivity(() => deliverWebReplyInActivityScope(params));
+}
+async function deliverWebReplyInActivityScope(params) {
 	const { replyResult, transport, maxMediaBytes, textLimit, replyLogger, connectionId, skipLog } = params;
 	const conversationId = transport.conversationId;
 	const isGroupConversation = transport.conversationKind === "group";
 	const replyStarted = Date.now();
 	const sendResults = [];
-	const rememberSendResult = (result) => {
-		if (result) sendResults.push(result);
-	};
 	const finishDelivery = () => {
 		const receipt = createWhatsAppReplyDeliveryReceipt(sendResults);
 		return {
@@ -2722,6 +2721,32 @@ async function deliverWebReply(params) {
 			providerAccepted: sendResults.some((result) => result.providerAccepted)
 		};
 	};
+	const preserveAcceptedDeliveryError = (error, kind) => {
+		const sendKind = kind ?? sendResults[0]?.kind ?? "text";
+		if (isChannelPartialDeliveryError(error)) rememberWhatsAppPartialSend({
+			error,
+			kind: sendKind,
+			results: sendResults
+		});
+		return mergeWhatsAppAcceptedSendError({
+			error,
+			kind: sendKind,
+			results: sendResults
+		});
+	};
+	const rememberSendResult = (result) => {
+		if (!result) return;
+		try {
+			rememberWhatsAppAcceptedSend({
+				accountId: transport.accountId,
+				result,
+				results: sendResults
+			});
+		} catch (error) {
+			if (sendResults.some((accepted) => accepted.providerAccepted)) throw preserveAcceptedDeliveryError(error, result.kind);
+			throw error;
+		}
+	};
 	if (isReasoningReplyPayload(replyResult)) {
 		whatsappOutboundLog.debug(`Suppressed reasoning payload to ${conversationId}`);
 		return finishDelivery();
@@ -2743,7 +2768,7 @@ async function deliverWebReply(params) {
 			media: cached?.media
 		});
 	};
-	const sendWithRetry = async (fn, label) => {
+	const sendWithRetry = async (fn, label, kind) => {
 		try {
 			return await sendWhatsAppOutboundWithRetry({
 				send: fn,
@@ -2752,7 +2777,7 @@ async function deliverWebReply(params) {
 				}
 			});
 		} catch (error) {
-			if (sendResults.some((result) => result.providerAccepted)) throw markWhatsAppVisibleDeliveryError(error);
+			if (isChannelPartialDeliveryError(error) || sendResults.some((result) => result.providerAccepted)) throw preserveAcceptedDeliveryError(error, kind);
 			throw error;
 		}
 	};
@@ -2761,7 +2786,7 @@ async function deliverWebReply(params) {
 		for (const [index, chunk] of textChunks.entries()) {
 			const chunkStarted = Date.now();
 			const quote = getQuote();
-			rememberSendResult(await sendWithRetry(() => transport.reply(chunk, quote), "text"));
+			rememberSendResult(await sendWithRetry(() => transport.reply(chunk, quote), "text", "text"));
 			if (!skipLog) {
 				const durationMs = Date.now() - chunkStarted;
 				whatsappOutboundLog.debug(`Sent chunk ${index + 1}/${totalChunks} to ${conversationId} (${durationMs.toFixed(0)}ms)`);
@@ -2784,10 +2809,13 @@ async function deliverWebReply(params) {
 		return delivery;
 	}
 	const remainingText = [...textChunks];
+	const leadingCaption = remainingText.shift() || "";
+	let acceptedIdsBeforeCurrentMedia = /* @__PURE__ */ new Set();
 	await sendMediaWithLeadingCaption({
 		mediaUrls: mediaList,
-		caption: remainingText.shift() || "",
+		caption: leadingCaption,
 		send: async ({ mediaUrl, caption }) => {
+			acceptedIdsBeforeCurrentMedia = new Set(sendResults.flatMap(listWhatsAppSendResultMessageIds));
 			const media = await prepareWhatsAppOutboundMedia(await loadWebMedia(mediaUrl, {
 				maxBytes: maxMediaBytes,
 				localRoots: params.mediaLocalRoots
@@ -2802,22 +2830,22 @@ async function deliverWebReply(params) {
 					image: media.buffer,
 					caption,
 					mimetype: media.mimetype
-				}, quote), "media:image"));
+				}, quote), "media:image", "media"));
 			} else if (media.kind === "audio") {
 				const quote = getQuote();
 				rememberSendResult(await sendWithRetry(() => transport.sendMedia({
 					audio: media.buffer,
 					ptt: true,
 					mimetype: media.mimetype
-				}, quote), "media:audio"));
-				if (caption) rememberSendResult(await sendWithRetry(() => transport.reply(caption, quote), "media:audio-text"));
+				}, quote), "media:audio", "media"));
+				if (caption) rememberSendResult(await sendWithRetry(() => transport.reply(caption, quote), "media:audio-text", "text"));
 			} else if (media.kind === "video") {
 				const quote = getQuote();
 				rememberSendResult(await sendWithRetry(() => transport.sendMedia({
 					video: media.buffer,
 					caption,
 					mimetype: media.mimetype
-				}, quote), "media:video"));
+				}, quote), "media:video", "media"));
 			} else {
 				const quote = getQuote();
 				rememberSendResult(await sendWithRetry(() => transport.sendMedia({
@@ -2825,7 +2853,7 @@ async function deliverWebReply(params) {
 					fileName: media.fileName,
 					caption,
 					mimetype: media.mimetype
-				}, quote), "media:document"));
+				}, quote), "media:document", "media"));
 			}
 			whatsappOutboundLog.info(`Sent media reply to ${conversationId} (${(media.buffer.length / (1024 * 1024)).toFixed(2)}MB)`);
 			replyLogger.info({
@@ -2841,6 +2869,7 @@ async function deliverWebReply(params) {
 			}, "auto-reply sent (media)");
 		},
 		onError: async ({ error, mediaUrl, caption, isFirst }) => {
+			if (sendResults.some((result) => listWhatsAppSendResultMessageIds(result).some((messageId) => !acceptedIdsBeforeCurrentMedia.has(messageId)))) throw preserveAcceptedDeliveryError(error);
 			whatsappOutboundLog.error(`Failed sending web media to ${conversationId}: ${formatError(error)}`);
 			replyLogger.warn({
 				err: error,
@@ -2848,16 +2877,16 @@ async function deliverWebReply(params) {
 			}, "failed to send web media reply");
 			if (!isFirst) {
 				whatsappOutboundLog.warn(`Trailing media failed; sent warning to ${conversationId}`);
-				rememberSendResult(await sendWithRetry(() => transport.reply("⚠️ Media unavailable.", getQuote()), "media:fallback-unavailable"));
+				rememberSendResult(await sendWithRetry(() => transport.reply("⚠️ Media unavailable.", getQuote()), "media:fallback-unavailable", "text"));
 				return;
 			}
 			const fallbackText = [caption ?? "", "⚠️ Media failed."].filter(Boolean).join("\n");
 			if (!fallbackText) return;
 			whatsappOutboundLog.warn(`Media skipped; sent text-only to ${conversationId}`);
-			rememberSendResult(await sendWithRetry(() => transport.reply(fallbackText, getQuote()), "media:fallback-text"));
+			rememberSendResult(await sendWithRetry(() => transport.reply(fallbackText, getQuote()), "media:fallback-text", "text"));
 		}
 	});
-	for (const chunk of remainingText) rememberSendResult(await sendWithRetry(() => transport.reply(chunk, getQuote()), "media:text"));
+	for (const chunk of remainingText) rememberSendResult(await sendWithRetry(() => transport.reply(chunk, getQuote()), "media:text", "text"));
 	return finishDelivery();
 }
 //#endregion
@@ -2941,7 +2970,7 @@ function projectPreparedChannelInbound(params) {
 			textForCommands: inbound.message.commandBody,
 			raw: inbound
 		},
-		context: buildChannelInboundEventContext({
+		context: params.buildContext({
 			...inbound,
 			messageId: inbound.event.id,
 			messageIdFull: inbound.event.fullId,
@@ -3003,7 +3032,7 @@ function isWhatsAppVisibleDeliveryError(error) {
 	return typeof error === "object" && error !== null && !Array.isArray(error) && error.visibleReplySent === true || isChannelPartialDeliveryError(error) && error.deliveryResult.visibleReplySent;
 }
 function readTrimmedString(value) {
-	return typeof value === "string" ? value.trim() : "";
+	return normalizeOptionalString(value) ?? "";
 }
 function markWhatsAppReplyDeliveryErrorVisibleAfterFlush(error, flushResult) {
 	if (flushResult.delivered === 0) return error;
@@ -3128,6 +3157,13 @@ async function prepareWhatsAppInboundContext(params) {
 	const admission = requireWhatsAppInboundAdmission(params.msg);
 	const conversationId = admission.conversation.id;
 	const conversationKind = admission.conversation.kind;
+	const eventId = params.msg.event.id ?? `${conversationId}:${newConnectionId()}`;
+	const channelIngress = await resolveWhatsAppAdmissionChannelIngress(admission, {
+		agentId: params.route.agentId,
+		sessionKey: params.route.sessionKey,
+		messageId: eventId,
+		inboundEventKind: "user_request"
+	}) ?? admission.channelIngress;
 	const wasMentioned = params.msg.groupMention?.wasMentioned ?? params.msg.wasMentioned;
 	const inboundHistory = conversationKind === "group" ? buildInboundHistoryFromEntries({
 		entries: (params.groupHistory ?? []).map((entry) => ({
@@ -3147,6 +3183,7 @@ async function prepareWhatsAppInboundContext(params) {
 	}] : void 0, { transcribed: (_entry, index) => params.mediaTranscribedIndexes?.includes(index) === true });
 	const control = { messageReceivedHooks: params.suppressMessageReceivedHooks ? "channel" : "core" };
 	const inbound = {
+		channelIngress,
 		channel: "whatsapp",
 		supplemental: {
 			quote: params.visibleReplyTo ? {
@@ -3159,7 +3196,7 @@ async function prepareWhatsAppInboundContext(params) {
 		},
 		media,
 		event: {
-			id: params.msg.event.id ?? `${conversationId}:${newConnectionId()}`,
+			id: eventId,
 			timestamp: params.msg.event.timestamp
 		},
 		from: conversationId,
@@ -3212,7 +3249,8 @@ async function prepareWhatsAppInboundContext(params) {
 	};
 	const projected = projectPreparedChannelInbound({
 		inbound,
-		control
+		control,
+		buildContext: params.buildContext ?? buildChannelInboundEventContext
 	});
 	return {
 		inbound,
@@ -3271,13 +3309,6 @@ function createWhatsAppReplyPlan(params) {
 	let didLogHeartbeatStrip = false;
 	const recordDeliveredPayload = (payload) => {
 		didSendReply = true;
-		const shouldLog = payload.text ? true : void 0;
-		params.rememberSentText(payload.text, {
-			combinedBody: params.context.Body,
-			combinedBodySessionKey: params.route.sessionKey,
-			conversationId,
-			logVerboseMessage: shouldLog
-		});
 		if (shouldLogVerbose$1()) {
 			const reply = resolveSendableOutboundReplyParts(payload);
 			logVerbose$1(`Reply body: ${payload.text != null ? reply.text : "<media>"}${reply.hasMedia ? " (media)" : ""} -> ${conversationId}`);
@@ -3324,14 +3355,7 @@ function createWhatsAppReplyPlan(params) {
 			}, "auto-reply was not accepted by WhatsApp provider");
 			return result;
 		}
-		if (options?.recordDelivery !== false) try {
-			recordDeliveredPayload(normalizedDeliveryPayload);
-		} catch (error) {
-			throw createChannelPartialDeliveryError(error, {
-				...result,
-				visibleReplySent: true
-			});
-		}
+		if (options?.recordDelivery !== false) recordDeliveredPayload(normalizedDeliveryPayload);
 		return result;
 	};
 	const mediaOnlyCoalescer = createWhatsAppMediaOnlyReplyCoalescer({ deliver: async (pending) => {
@@ -3448,13 +3472,16 @@ function createWhatsAppReplyPlan(params) {
 				onToolStart: async (payload) => {
 					const toolName = payload.name?.trim();
 					if (toolName) await statusReactionController.setTool(toolName);
+					return false;
 				},
 				onCompactionStart: async () => {
 					await statusReactionController.setCompacting();
+					return false;
 				},
 				onCompactionEnd: async () => {
 					statusReactionController.cancelPending();
 					await statusReactionController.setThinking();
+					return false;
 				}
 			} : {}
 		},
@@ -3473,7 +3500,7 @@ function createWhatsAppReplyPlan(params) {
 			}
 			if (statusReactionController) finalizeWhatsAppStatusReaction({
 				controller: statusReactionController,
-				outcome: didDeliverVisibleReply ? "done" : "error"
+				outcome: readAgentRunTerminalOutcome(dispatchResult) === "failed" || !didDeliverVisibleReply ? "error" : "done"
 			});
 			if (params.shouldClearGroupHistory) params.groupHistories.set(params.groupHistoryKey, []);
 			return didDeliverVisibleReply;
@@ -3487,12 +3514,8 @@ async function finalizeWhatsAppStatusReaction(params) {
 }
 //#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();
+	const identityName = resolveAgentConfig(cfg, agentId)?.identity?.name?.trim();
 	return identityName ? `[${identityName}]` : void 0;
 }
 function resolveMessagePrefix(cfg, agentId, opts) {
@@ -3660,7 +3683,7 @@ async function processMessage(params) {
 		...params.msg,
 		payload: {
 			...params.msg.payload,
-			body: audioTranscript
+			body: formatAudioTranscriptForAgent(audioTranscript)
 		}
 	} : params.msg;
 	const visibleReplyTo = resolveVisibleWhatsAppReplyContext({
@@ -3711,15 +3734,6 @@ async function processMessage(params) {
 		});
 		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,
@@ -3803,6 +3817,7 @@ async function processMessage(params) {
 		msg: params.msg,
 		rawBody: commandBody,
 		route: params.route,
+		buildContext: params.buildContext,
 		sender: {
 			id: getPrimaryIdentityId(sender) ?? void 0,
 			name: sender.name ?? void 0,
@@ -3877,7 +3892,6 @@ async function processMessage(params) {
 					maxMediaTextChunkLimit: params.maxMediaTextChunkLimit,
 					inbound,
 					onModelSelected,
-					rememberSentText: params.rememberSentText,
 					replyLogger: params.replyLogger,
 					replyPipeline: {
 						...replyPipeline,
@@ -3900,6 +3914,7 @@ async function processMessage(params) {
 						sessionKey: params.route.sessionKey
 					},
 					ctxPayload,
+					dispatchReplyFromConfig: params.dispatchReplyFromConfig,
 					record: {
 						onRecordError: (err) => {
 							params.replyLogger.warn({
@@ -3934,19 +3949,13 @@ async function processMessage(params) {
 }
 //#endregion
 //#region extensions/whatsapp/src/auto-reply/monitor/on-message.ts
-function readDeprecatedAccessControlPassed(msg) {
-	return msg.accessControlPassed;
-}
 function createWebOnMessageHandler(params) {
-	const hasExplicitlyPassedInboundAccess = (msg) => {
-		if (msg.admission.ingress.decisiveGateId === "legacy-flat-compat") return readDeprecatedAccessControlPassed(msg) === true;
-		return msg.admission.ingress.decision === "allow";
-	};
+	const hasExplicitlyPassedInboundAccess = (msg) => msg.admission.ingress.decision === "allow";
 	const withDirectSenderPeer = (msg, peerId) => {
 		if (requireWhatsAppInboundAdmission(msg).conversation.kind === "group" || msg.platform.sender?.e164 || msg.platform.senderE164 || !peerId.startsWith("+")) return msg;
 		const normalized = normalizeE164(peerId);
 		if (!normalized) return msg;
-		return requireAdmittedWhatsAppInboundMessage(withDeprecatedWebInboundMessageFlatAliases({
+		return {
 			...msg,
 			platform: {
 				...msg.platform,
@@ -3956,7 +3965,7 @@ function createWebOnMessageHandler(params) {
 				},
 				senderE164: normalized
 			}
-		}));
+		};
 	};
 	const processForRoute = async (cfg, msg, route, groupHistoryKey, opts) => {
 		const processParams = {
@@ -3973,10 +3982,8 @@ function createWebOnMessageHandler(params) {
 			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
+			buildContext: params.buildContext,
+			dispatchReplyFromConfig: params.dispatchReplyFromConfig
 		};
 		if (opts?.groupHistory !== void 0) processParams.groupHistory = opts.groupHistory;
 		if (opts?.suppressGroupHistoryClear !== void 0) processParams.suppressGroupHistoryClear = opts.suppressGroupHistoryClear;
@@ -4012,11 +4019,6 @@ function createWebOnMessageHandler(params) {
 		});
 		const baseMentionConfig = buildMentionConfig(cfg);
 		if (conversationId === msg.platform.recipientJid) logVerbose(`📱 Same-phone mode detected (from === to: ${conversationId})`);
-		if (params.echoTracker.has(msg.payload.body, conversationId)) {
-			logVerbose("Skipping auto-reply: detected echo (message matches recently sent text)");
-			params.echoTracker.forget(msg.payload.body, conversationId);
-			return;
-		}
 		const configuredRoute = resolveConfiguredBindingRoute({
 			cfg,
 			route: baseConversationRoute,
@@ -4292,10 +4294,6 @@ async function monitorWebChannel(verbose, listenerFactory = attachWebInboxToSock
 	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;
@@ -4334,15 +4332,12 @@ async function monitorWebChannel(verbose, listenerFactory = attachWebInboxToSock
 				cfg,
 				channel: "whatsapp"
 			});
-			const shouldDebounce = (msg) => {
-				const admitted = normalizeAdmittedWebInboundMessage(msg);
-				return shouldDebounceTextInbound({
-					text: admitted.payload.commandBody ?? admitted.payload.body,
-					cfg,
-					hasMedia: Boolean(admitted.payload.media?.path || admitted.payload.media?.type),
-					allowDebounce: !(admitted.payload.location || admitted.quote?.id || admitted.quote?.body)
-				});
-			};
+			const shouldDebounce = (msg) => shouldDebounceTextInbound({
+				text: msg.payload.commandBody ?? msg.payload.body,
+				cfg,
+				hasMedia: Boolean(msg.payload.media?.path || msg.payload.media?.type),
+				allowDebounce: !(msg.payload.location || msg.quote?.id || msg.quote?.body)
+			});
 			let connection;
 			try {
 				connection = await controller.openConnection({
@@ -4353,6 +4348,7 @@ async function monitorWebChannel(verbose, listenerFactory = attachWebInboxToSock
 						return meta?.participants?.length ? meta : void 0;
 					},
 					createListener: async ({ sock, connection: connectionLocal }) => {
+						const pluginChannelRuntime = tuning.channelRuntime;
 						const onMessage = createWebOnMessageHandler({
 							cfg,
 							loadConfig: loadCurrentMonitorConfig,
@@ -4362,12 +4358,13 @@ async function monitorWebChannel(verbose, listenerFactory = attachWebInboxToSock
 							groupHistoryLimit,
 							groupHistories,
 							groupMemberNames,
-							echoTracker,
 							backgroundTasks: connectionLocal.backgroundTasks,
 							replyResolver: activeReplyResolver,
 							replyLogger,
 							baseMentionConfig,
-							account
+							account,
+							buildContext: pluginChannelRuntime?.inbound.buildContext,
+							dispatchReplyFromConfig: pluginChannelRuntime?.reply?.dispatchReplyFromConfig
 						});
 						return await (listenerFactory ?? attachWebInboxToSocket)({
 							cfg,
@@ -4394,11 +4391,10 @@ async function monitorWebChannel(verbose, listenerFactory = attachWebInboxToSock
 							recentMessageKeys,
 							baileysGroupMetaCache,
 							onMessage: async (msg) => {
-								const admitted = normalizeAdmittedWebInboundMessage(msg);
 								const inboundAt = Date.now();
 								controller.noteInbound(inboundAt);
 								statusController.noteInbound(inboundAt);
-								await onMessage(admitted);
+								await onMessage(msg);
 							},
 							onPendingWorkChanged: (pendingWorkCount, at) => {
 								statusController.noteBusy(pendingWorkCount > 0, at);