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

package/dist/{monitor-CfkaUSL2.js → monitor-BCe5Mm-1.js}

@@ -1,53 +1,58 @@
-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 { _ as resolveWhatsAppReactionLevel, a as normalizeWhatsAppOutboundPayload, c as prepareWhatsAppOutboundMedia, d as mergeWhatsAppAcceptedSendError, f as normalizeWhatsAppSendResult, h as withWhatsAppLogicalDeliveryActivity, m as rememberWhatsAppPartialSend, p as rememberWhatsAppAcceptedSend, r as sendReactionWhatsApp, s as normalizeWhatsAppPayloadTextPreservingIndentation, u as listWhatsAppSendResultMessageIds } from "./send-prK8F7Vj.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-B_DQIdzp.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-09FojDO2.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 { a as addWhatsAppImagePreviewFields, c as extractContextInfo, d as extractMediaKind, f as extractMentionedJids, g as resolveInboundMediaMimetype, 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-DimZST3E.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-CUyZgGpf.js";
+import { n as maybeResolveWhatsAppApprovalReaction } from "./approval-reactions-CmtJCxe_.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";
@@ -57,6 +62,241 @@ 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/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 buildDeprecatedFlatWhatsAppInboundAdmission(msg) {
+	const conversationId = msg.conversationId || msg.from;
+	if (!conversationId || !msg.accountId || !msg.chatType) throw new Error("WhatsApp legacy flat inbound messages must include deprecated top-level admission fields.");
+	const accountId = msg.accountId;
+	const admitted = msg.accessControlPassed !== false;
+	const platformSender = msg.platform?.sender;
+	const senderE164 = platformSender?.e164 ?? msg.platform?.senderE164 ?? msg.senderE164;
+	const senderJid = platformSender?.jid ?? msg.platform?.senderJid ?? msg.senderJid;
+	const senderName = platformSender?.name ?? msg.platform?.senderName ?? msg.senderName;
+	const senderId = msg.chatType === "group" ? senderE164 ?? senderJid ?? senderName ?? conversationId : senderE164 ?? conversationId;
+	const reasonCode = admitted ? msg.chatType === "group" ? "group_policy_allowed" : "dm_policy_allowlisted" : "no_policy_match";
+	return buildWhatsAppInboundAdmission({
+		policy: {
+			account: {
+				accountId,
+				enabled: true,
+				sendReadReceipts: true
+			},
+			isSelfChat: false,
+			isSamePhone: () => false
+		},
+		access: {
+			ingress: {
+				admission: admitted ? "dispatch" : "drop",
+				decision: admitted ? "allow" : "block",
+				decisiveGateId: "legacy-flat-compat",
+				reasonCode
+			},
+			senderAccess: {
+				allowed: admitted,
+				decision: admitted ? "allow" : "block",
+				reasonCode,
+				providerMissingFallbackApplied: false
+			},
+			commandAccess: {
+				requested: false,
+				authorized: false,
+				shouldBlockControlCommand: false,
+				reasonCode: "command_authorized"
+			},
+			activationAccess: {
+				ran: false,
+				allowed: admitted,
+				shouldSkip: !admitted,
+				reasonCode: admitted ? "activation_allowed" : "activation_skipped"
+			}
+		},
+		isGroup: msg.chatType === "group",
+		conversationId,
+		senderId
+	});
+}
+function requireWhatsAppInboundAdmission(params) {
+	if (!params.admission) throw new Error("WhatsApp inbound message is missing admission facts");
+	return params.admission;
+}
+function requireAdmittedWhatsAppInboundMessage(msg) {
+	requireWhatsAppInboundAdmission(msg);
+	return msg;
+}
+//#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) {
@@ -625,10 +865,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 +891,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: []
 		};
@@ -898,27 +1142,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);
 	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 +1167,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,6 +1186,32 @@ 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);
@@ -972,6 +1242,13 @@ async function enrichWhatsAppInboundMessage(params) {
 	try {
 		await saveInboundMedia(await downloadInboundMedia(msg, sock, maxBytes));
 	} 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 +1260,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,
@@ -1004,6 +1288,112 @@ async function enrichWhatsAppInboundMessage(params) {
 	};
 }
 //#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
 //#region extensions/whatsapp/src/inbound/dedupe.ts
 const recentOutboundMessages = createDedupeCache({
 	ttlMs: 20 * 6e4,
@@ -1011,7 +1401,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 +1424,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 +1442,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 +1452,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 +1526,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;
@@ -1634,7 +2038,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 +2164,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,
@@ -1868,7 +2275,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 +2339,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 +2371,8 @@ function createWebChannelStatusController(statusSink) {
 		lastError: null,
 		busy: false,
 		lastRunActivityAt: null,
-		healthState: "starting"
+		healthState: "starting",
+		lifecycle: "starting"
 	};
 	const emit = () => {
 		statusSink?.(cloneStatus(status));
@@ -1964,16 +2381,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 +2399,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 +2414,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 +2446,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 +2560,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 +2568,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 +2585,7 @@ async function resolveWhatsAppReactionEligibility(params) {
 		emoji,
 		reactionOptions: {
 			verbose: params.verbose,
-			fromMe: false,
+			fromMe: params.msg.platform.fromMe === true,
 			...participant ? { participant } : {},
 			accountId,
 			cfg: params.cfg
@@ -2299,6 +2700,11 @@ async function maybeBroadcastMessage(params) {
 	return true;
 }
 //#endregion
+//#region extensions/whatsapp/src/auto-reply/monitor/audio-transcript.ts
+function formatWhatsAppAudioTranscriptForAgent(transcript) {
+	return `[Audio transcript (machine-generated, untrusted)]: ${JSON.stringify(transcript)}`;
+}
+//#endregion
 //#region extensions/whatsapp/src/auto-reply/monitor/commands.ts
 function stripMentionsForCommand(text, mentionRegexes, selfE164) {
 	let result = text;
@@ -2375,7 +2781,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 +2901,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 : formatWhatsAppAudioTranscriptForAgent(params.mentionText);
+		return skipGroupMessageAndStoreHistory(params, `Group message stored for context (no mention detected) in ${conversationId}: ${mentionMsg.payload.body}`, pendingHistoryBody);
 	}
 	return { shouldProcess: true };
 }
@@ -2571,7 +2978,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 +3113,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 +3129,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 +3176,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 +3185,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 +3194,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 +3217,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 +3238,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 +3261,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 +3277,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 +3285,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 +3378,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 +3440,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 +3565,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 +3591,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 +3604,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 +3657,8 @@ async function prepareWhatsAppInboundContext(params) {
 	};
 	const projected = projectPreparedChannelInbound({
 		inbound,
-		control
+		control,
+		buildContext: params.buildContext ?? buildChannelInboundEventContext
 	});
 	return {
 		inbound,
@@ -3271,13 +3717,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 +3763,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 +3880,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 +3908,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 +3922,9 @@ 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 normalizedAgentId = normalizeAgentId(agentId);
+	const identityName = cfg.agents?.list?.find((agent) => normalizeAgentId(agent.id ?? "") === normalizedAgentId)?.identity?.name?.trim();
 	return identityName ? `[${identityName}]` : void 0;
 }
 function resolveMessagePrefix(cfg, agentId, opts) {
@@ -3660,7 +4092,7 @@ async function processMessage(params) {
 		...params.msg,
 		payload: {
 			...params.msg.payload,
-			body: audioTranscript
+			body: formatWhatsAppAudioTranscriptForAgent(audioTranscript)
 		}
 	} : params.msg;
 	const visibleReplyTo = resolveVisibleWhatsAppReplyContext({
@@ -3711,15 +4143,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 +4226,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 +4301,6 @@ async function processMessage(params) {
 					maxMediaTextChunkLimit: params.maxMediaTextChunkLimit,
 					inbound,
 					onModelSelected,
-					rememberSentText: params.rememberSentText,
 					replyLogger: params.replyLogger,
 					replyPipeline: {
 						...replyPipeline,
@@ -3973,10 +4396,7 @@ 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
 		};
 		if (opts?.groupHistory !== void 0) processParams.groupHistory = opts.groupHistory;
 		if (opts?.suppressGroupHistoryClear !== void 0) processParams.suppressGroupHistoryClear = opts.suppressGroupHistoryClear;
@@ -4012,11 +4432,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 +4707,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;
@@ -4362,12 +4773,12 @@ async function monitorWebChannel(verbose, listenerFactory = attachWebInboxToSock
 							groupHistoryLimit,
 							groupHistories,
 							groupMemberNames,
-							echoTracker,
 							backgroundTasks: connectionLocal.backgroundTasks,
 							replyResolver: activeReplyResolver,
 							replyLogger,
 							baseMentionConfig,
-							account
+							account,
+							buildContext: tuning.channelRuntime?.inbound.buildContext
 						});
 						return await (listenerFactory ?? attachWebInboxToSocket)({
 							cfg,