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

package/dist/{monitor-BqkJ4MpT.js → monitor-DD8bXohk.js}

@@ -1,18 +1,20 @@
-import { a as resolveWhatsAppAccount, s as resolveWhatsAppMediaMaxBytes } from "./accounts-DgViSyJx.js";
-import { a as normalizeWhatsAppOutboundPayload, c as prepareWhatsAppOutboundMedia, d as maybeResolveWhatsAppApprovalReaction, g as resolveWhatsAppReactionLevel, l as sendWhatsAppOutboundWithRetry, r as sendReactionWhatsApp, s as normalizeWhatsAppPayloadTextPreservingIndentation } from "./send-i8Xk5mBQ.js";
+import { a as resolveWhatsAppAccount, s as resolveWhatsAppMediaMaxBytes } from "./accounts-4YgwroRU.js";
+import { a as normalizeWhatsAppOutboundPayload, c as prepareWhatsAppOutboundMedia, d as maybeResolveWhatsAppApprovalReaction, g as resolveWhatsAppReactionLevel, l as sendWhatsAppOutboundWithRetry, r as sendReactionWhatsApp, s as normalizeWhatsAppPayloadTextPreservingIndentation } from "./send-C5CpFcBG.js";
 import { n as getWhatsAppRuntime } from "./runtime-BfAdAEYT.js";
-import { n as getStatusCode, r as getRegisteredWhatsAppConnectionController, t as formatError } from "./session-errors-CbsoQqoy.js";
-import { a as resolveWhatsAppSocketTiming, i as resolveWhatsAppSocketOperationTimeoutMs, n as createWhatsAppSocketOperationTimeoutAdapter, o as withWhatsAppSocketOperationTimeout, r as isWhatsAppSocketOperationTimeoutError } from "./socket-timing-DvMNkIge.js";
-import { d as markdownToWhatsApp, f as resolveEquivalentWhatsAppDirectChatJids, l as isSelfChatMode, n as normalizeE164, p as resolveJidToE164, t as convertMarkdownTables$1, u as jidToE164 } from "./text-runtime-C88QkuU9.js";
-import { n as cacheInboundMessageMeta, r as lookupInboundMessageMeta, t as buildQuotedMessageOptions } from "./quoted-message-CpA_ujXK.js";
-import { g as readWebSelfId, o as getWebAuthAgeMs, r as WhatsAppAuthUnstableError, v as readWebSelfIdentityForDecision } from "./auth-store-ECx4h57q.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-CmsTmkKR.js";
+import { t as getRegisteredWhatsAppConnectionController } from "./connection-controller-registry-TSX_udJp.js";
+import { n as getStatusCode, t as formatError } from "./session-errors-BAj9D2La.js";
+import { a as resolveWhatsAppSocketTiming, i as resolveWhatsAppSocketOperationTimeoutMs, n as createWhatsAppSocketOperationTimeoutAdapter, o as withWhatsAppSocketOperationTimeout, r as isWhatsAppSocketOperationTimeoutError } from "./socket-timing-DhbVFjah.js";
+import { a as resolveEquivalentWhatsAppDirectChatJids, c as toWhatsappJidWithLid, i as markdownToWhatsApp, n as isSelfChatMode, o as resolveJidToE164, r as jidToE164, s as toWhatsappJid } from "./targets-runtime-C-GiVn6Y.js";
+import { n as normalizeE164, t as convertMarkdownTables$1 } from "./text-runtime-DdX6-mC_.js";
+import { a as cacheInboundMessageMeta, i as buildQuotedMessageOptions, n as resolveWhatsAppGroupSessionRoute, o as lookupInboundMessageMeta, r as resolveWhatsAppLegacyGroupSessionKey } from "./group-session-key-BhC1RQOE.js";
+import { g as readWebSelfId, o as getWebAuthAgeMs, r as WhatsAppAuthUnstableError, v as readWebSelfIdentityForDecision } from "./auth-store-Db-wfApd.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-Dqft3mFA.js";
 import { n as resolveWhatsAppGroupsConfigPath } from "./group-config-path-BGyzT9Lg.js";
-import { c as requireWhatsAppInboundAdmission, i as resolveWhatsAppInboundPolicy, l as resolveWhatsAppGroupConversationId, o as buildDeprecatedFlatWhatsAppInboundAdmission, r as resolveWhatsAppCommandAuthorized, s as requireAdmittedWhatsAppInboundMessage, t as checkInboundAccessControl } from "./access-control-88UPniDc.js";
-import { _ as extractLocationData, a as mayContainWhatsAppOutboundMention, b as extractText, c as DisconnectReason, d as normalizeMessageContent, f as resolveInboundMediaMimetype, g as extractExternalAdReplyContext, h as extractContextInfo, i as addWhatsAppOutboundMentionsToContent, l as downloadMediaMessage, m as extractContactContext, n as listWhatsAppSendResultMessageIds, o as resolveWhatsAppOutboundMentions, p as describeReplyContext, r as normalizeWhatsAppSendResult, s as addWhatsAppImagePreviewFields, t as createWebSendApi, u as isJidGroup, v as extractMediaPlaceholder, x as hasInboundUserContent, y as extractMentionedJids } from "./send-api-DndiBJhN.js";
-import { r as waitForWaConnection, t as createWaSocket } from "./session-WU4SVP8f.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-DYE5dXna.js";
+import { _ as extractLocationData, a as mayContainWhatsAppOutboundMention, b as extractText, c as DisconnectReason, d as normalizeMessageContent, f as resolveInboundMediaMimetype, g as extractExternalAdReplyContext, h as extractContextInfo, i as addWhatsAppOutboundMentionsToContent, l as downloadMediaMessage, m as extractContactContext, n as listWhatsAppSendResultMessageIds, o as resolveWhatsAppOutboundMentions, p as describeReplyContext, r as normalizeWhatsAppSendResult, s as addWhatsAppImagePreviewFields, t as createWebSendApi, u as isJidGroup, v as extractMediaPlaceholder, x as hasInboundUserContent, y as extractMentionedJids } from "./send-api-DLlXl8CH.js";
+import { r as waitForWaConnection, t as createWaSocket } from "./session-DriaHt7V.js";
 import { t as BufferJSON } from "./session.runtime-CyooSQvj.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-u-tfAFhJ.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-DkbrFSIn.js";
 import { resolveAccountEntry } from "openclaw/plugin-sdk/account-core";
 import { normalizeLowercaseStringOrEmpty, normalizeStringEntries, uniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { createChannelMessageReplyPipeline, createDurableInboundReceiveJournalFromQueue, createMessageReceiptFromOutboundResults, deliverInboundReplyWithMessageSendContext, resolveChannelMessageSourceReplyDeliveryMode } from "openclaw/plugin-sdk/channel-outbound";
@@ -29,10 +31,10 @@ import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import { LocalMediaAccessError, getDefaultLocalRoots, loadWebMedia as loadWebMedia$1, loadWebMediaRaw, optimizeImageToJpeg, optimizeImageToPng } from "openclaw/plugin-sdk/web-media";
 import { chunkMarkdownTextWithMode } from "openclaw/plugin-sdk/reply-chunking";
 import { isReasoningReplyPayload, resolveSendableOutboundReplyParts, sendMediaWithLeadingCaption } from "openclaw/plugin-sdk/reply-payload";
-import { DEFAULT_ACCOUNT_ID as DEFAULT_ACCOUNT_ID$1, DEFAULT_MAIN_KEY, buildAgentMainSessionKey, buildAgentSessionKey, buildGroupHistoryKey, deriveLastRoutePolicy, normalizeAccountId as normalizeAccountId$1, normalizeAgentId, resolveAgentRoute, resolveInboundLastRouteSessionKey, resolveThreadSessionKeys } from "openclaw/plugin-sdk/routing";
+import { DEFAULT_ACCOUNT_ID as DEFAULT_ACCOUNT_ID$1, DEFAULT_MAIN_KEY, buildAgentMainSessionKey, buildAgentSessionKey, buildGroupHistoryKey, deriveLastRoutePolicy, normalizeAccountId as normalizeAccountId$1, normalizeAgentId, resolveAgentRoute, resolveInboundLastRouteSessionKey } from "openclaw/plugin-sdk/routing";
 import { recordInboundSession } from "openclaw/plugin-sdk/conversation-runtime";
 import { getSessionEntry, patchSessionEntry, resolveStorePath, resolveStorePath as resolveStorePath$1, updateLastRoute } from "openclaw/plugin-sdk/session-store-runtime";
-import { buildChannelInboundEventContext, filterChannelInboundQuoteContext, formatInboundEnvelope, formatInboundEnvelope as formatInboundEnvelope$1, formatLocationText, hasVisibleInboundReplyDispatch, resolveInboundSessionEnvelopeContext, runChannelInboundEvent, toInboundMediaFacts, toLocationContext } from "openclaw/plugin-sdk/channel-inbound";
+import { buildChannelInboundEventContext, filterChannelInboundQuoteContext, formatInboundEnvelope, formatInboundEnvelope as formatInboundEnvelope$1, formatInboundMediaUnavailableText, formatLocationText, hasVisibleInboundReplyDispatch, resolveInboundSessionEnvelopeContext, runChannelInboundEvent, toInboundMediaFacts, toLocationContext } from "openclaw/plugin-sdk/channel-inbound";
 import { saveMediaStream } from "openclaw/plugin-sdk/media-store";
 import { recordChannelActivity } from "openclaw/plugin-sdk/channel-activity-runtime";
 import { createHash } from "node:crypto";
@@ -45,6 +47,7 @@ import { drainPendingDeliveries } from "openclaw/plugin-sdk/delivery-queue-runti
 import { DEFAULT_GROUP_HISTORY_LIMIT, buildHistoryContextFromEntries, buildInboundHistoryFromEntries, createChannelHistoryWindow } from "openclaw/plugin-sdk/reply-history";
 import { enqueueSystemEvent } from "openclaw/plugin-sdk/system-event-runtime";
 import { createClaimableDedupe } from "openclaw/plugin-sdk/persistent-dedupe";
+import { collectErrorGraphCandidates, formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { getRuntimeConfig as getRuntimeConfig$1, getRuntimeConfigSourceSnapshot } from "openclaw/plugin-sdk/runtime-config-snapshot";
 import { resolveChannelContextVisibilityMode } from "openclaw/plugin-sdk/context-visibility-runtime";
 import { buildMentionRegexes, implicitMentionKindWhen, normalizeMentionText, resolveInboundMentionDecision } from "openclaw/plugin-sdk/channel-mention-gating";
@@ -55,6 +58,94 @@ import { normalizeGroupActivation, parseActivationCommand } from "openclaw/plugi
 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";
+//#region extensions/whatsapp/src/inbound/dedupe.ts
+const WHATSAPP_INBOUND_DEDUPE_TTL_MS = 20 * 6e4;
+const RECENT_WEB_MESSAGE_MAX = 5e3;
+const RECENT_OUTBOUND_MESSAGE_TTL_MS = 20 * 6e4;
+const RECENT_OUTBOUND_MESSAGE_MAX = 5e3;
+const claimableInboundMessages = createClaimableDedupe({
+	ttlMs: WHATSAPP_INBOUND_DEDUPE_TTL_MS,
+	memoryMaxSize: RECENT_WEB_MESSAGE_MAX
+});
+const recentOutboundMessages = createRecentMessageCache({
+	ttlMs: RECENT_OUTBOUND_MESSAGE_TTL_MS,
+	maxSize: RECENT_OUTBOUND_MESSAGE_MAX
+});
+function createRecentMessageCache(options) {
+	const ttlMs = Math.max(0, options.ttlMs);
+	const maxSize = Math.max(0, Math.floor(options.maxSize));
+	const cache = /* @__PURE__ */ new Map();
+	const prune = (now) => {
+		if (ttlMs > 0) {
+			const cutoff = now - ttlMs;
+			for (const [key, timestamp] of cache) if (timestamp < cutoff) cache.delete(key);
+		}
+		while (cache.size > maxSize) {
+			const oldest = cache.keys().next().value;
+			if (!oldest) break;
+			cache.delete(oldest);
+		}
+	};
+	const peek = (key, now = Date.now()) => {
+		if (!key) return false;
+		const timestamp = cache.get(key);
+		if (timestamp === void 0) return false;
+		if (ttlMs > 0 && now - timestamp >= ttlMs) {
+			cache.delete(key);
+			return false;
+		}
+		return true;
+	};
+	return {
+		check: (key, now = Date.now()) => {
+			if (!key) return false;
+			const existed = peek(key, now);
+			cache.delete(key);
+			cache.set(key, now);
+			prune(now);
+			return existed;
+		},
+		peek,
+		clear: () => cache.clear()
+	};
+}
+var WhatsAppRetryableInboundError = class extends Error {
+	constructor(message, options) {
+		super(message, options);
+		this.name = "WhatsAppRetryableInboundError";
+	}
+};
+function buildMessageKey(params) {
+	const accountId = params.accountId.trim();
+	const remoteJid = params.remoteJid.trim();
+	const messageId = params.messageId.trim();
+	if (!accountId || !remoteJid || !messageId || messageId === "unknown") return null;
+	return `${accountId}:${remoteJid}:${messageId}`;
+}
+function resetWebInboundDedupe() {
+	claimableInboundMessages.clearMemory();
+	recentOutboundMessages.clear();
+}
+async function claimRecentInboundMessageDelivery(key) {
+	return (await claimableInboundMessages.claim(key)).kind;
+}
+async function commitRecentInboundMessage(key) {
+	await claimableInboundMessages.commit(key);
+}
+function releaseRecentInboundMessage(key, error) {
+	claimableInboundMessages.release(key, { error });
+}
+function rememberRecentOutboundMessage(params) {
+	const key = buildMessageKey(params);
+	if (!key) return;
+	recentOutboundMessages.check(key);
+}
+function isRecentOutboundMessage(params) {
+	const key = buildMessageKey(params);
+	if (!key) return false;
+	return recentOutboundMessages.peek(key);
+}
+//#endregion
 //#region extensions/whatsapp/src/inbound/message-aliases.ts
 function normalizeQuoteSender(sender) {
 	if (!sender?.displayName && !sender?.jid && !sender?.e164) return;
@@ -379,94 +470,6 @@ function normalizeWebInboundMessage(msg) {
 	return normalizeLegacyFlatWebInboundMessage(msg);
 }
 //#endregion
-//#region extensions/whatsapp/src/inbound/dedupe.ts
-const RECENT_WEB_MESSAGE_TTL_MS = 20 * 6e4;
-const RECENT_WEB_MESSAGE_MAX = 5e3;
-const RECENT_OUTBOUND_MESSAGE_TTL_MS = 20 * 6e4;
-const RECENT_OUTBOUND_MESSAGE_MAX = 5e3;
-const claimableInboundMessages = createClaimableDedupe({
-	ttlMs: RECENT_WEB_MESSAGE_TTL_MS,
-	memoryMaxSize: RECENT_WEB_MESSAGE_MAX
-});
-const recentOutboundMessages = createRecentMessageCache({
-	ttlMs: RECENT_OUTBOUND_MESSAGE_TTL_MS,
-	maxSize: RECENT_OUTBOUND_MESSAGE_MAX
-});
-function createRecentMessageCache(options) {
-	const ttlMs = Math.max(0, options.ttlMs);
-	const maxSize = Math.max(0, Math.floor(options.maxSize));
-	const cache = /* @__PURE__ */ new Map();
-	const prune = (now) => {
-		if (ttlMs > 0) {
-			const cutoff = now - ttlMs;
-			for (const [key, timestamp] of cache) if (timestamp < cutoff) cache.delete(key);
-		}
-		while (cache.size > maxSize) {
-			const oldest = cache.keys().next().value;
-			if (!oldest) break;
-			cache.delete(oldest);
-		}
-	};
-	const peek = (key, now = Date.now()) => {
-		if (!key) return false;
-		const timestamp = cache.get(key);
-		if (timestamp === void 0) return false;
-		if (ttlMs > 0 && now - timestamp >= ttlMs) {
-			cache.delete(key);
-			return false;
-		}
-		return true;
-	};
-	return {
-		check: (key, now = Date.now()) => {
-			if (!key) return false;
-			const existed = peek(key, now);
-			cache.delete(key);
-			cache.set(key, now);
-			prune(now);
-			return existed;
-		},
-		peek,
-		clear: () => cache.clear()
-	};
-}
-var WhatsAppRetryableInboundError = class extends Error {
-	constructor(message, options) {
-		super(message, options);
-		this.name = "WhatsAppRetryableInboundError";
-	}
-};
-function buildMessageKey(params) {
-	const accountId = params.accountId.trim();
-	const remoteJid = params.remoteJid.trim();
-	const messageId = params.messageId.trim();
-	if (!accountId || !remoteJid || !messageId || messageId === "unknown") return null;
-	return `${accountId}:${remoteJid}:${messageId}`;
-}
-function resetWebInboundDedupe() {
-	claimableInboundMessages.clearMemory();
-	recentOutboundMessages.clear();
-}
-async function claimRecentInboundMessageDelivery(key) {
-	return (await claimableInboundMessages.claim(key)).kind;
-}
-async function commitRecentInboundMessage(key) {
-	await claimableInboundMessages.commit(key);
-}
-function releaseRecentInboundMessage(key, error) {
-	claimableInboundMessages.release(key, { error });
-}
-function rememberRecentOutboundMessage(params) {
-	const key = buildMessageKey(params);
-	if (!key) return;
-	recentOutboundMessages.check(key);
-}
-function isRecentOutboundMessage(params) {
-	const key = buildMessageKey(params);
-	if (!key) return false;
-	return recentOutboundMessages.peek(key);
-}
-//#endregion
 //#region extensions/whatsapp/src/inbound/durable-receive.ts
 const WHATSAPP_DURABLE_INBOUND_PENDING_MAX_ENTRIES = 450;
 const WHATSAPP_DURABLE_INBOUND_COMPLETED_MAX_ENTRIES = 450;
@@ -538,23 +541,17 @@ async function downloadInboundMedia(msg, sock, maxBytes = 50 * 1024 * 1024) {
 	const mimetype = resolveInboundMediaMimetype(message);
 	const fileName = message.documentMessage?.fileName ?? void 0;
 	if (!message.imageMessage && !message.videoMessage && !message.documentMessage && !message.audioMessage && !message.stickerMessage) return;
-	try {
-		return {
-			saved: await saveMediaStream(await downloadMediaMessage(msg, "stream", {}, {
-				reuploadRequest: sock.updateMediaMessage,
-				logger: sock.logger
-			}), mimetype, "inbound", maxBytes, fileName).catch((err) => {
-				if (err instanceof Error && /Media exceeds/i.test(err.message)) throw new WhatsAppInboundMediaLimitExceededError(maxBytes);
-				throw err;
-			}),
-			mimetype,
-			fileName
-		};
-	} catch (err) {
-		if (err instanceof WhatsAppInboundMediaLimitExceededError) throw err;
-		logVerbose(`downloadMediaMessage failed: ${String(err)}`);
-		return;
-	}
+	return {
+		saved: await saveMediaStream(await downloadMediaMessage(msg, "stream", {}, {
+			reuploadRequest: sock.updateMediaMessage,
+			logger: sock.logger
+		}), mimetype, "inbound", maxBytes, fileName).catch((err) => {
+			if (err instanceof Error && /Media exceeds/i.test(err.message)) throw new WhatsAppInboundMediaLimitExceededError(maxBytes);
+			throw err;
+		}),
+		mimetype,
+		fileName
+	};
 }
 async function downloadQuotedInboundMedia(msg, sock, maxBytes = 50 * 1024 * 1024) {
 	const contextInfo = extractContextInfo(unwrapMessage(msg.message));
@@ -578,6 +575,12 @@ const RECONNECT_IN_PROGRESS_ERROR = "no active socket - reconnection in progress
 const GROUP_META_TTL_MS = 300 * 1e3;
 const BAILEYS_MESSAGE_TTL_MS = 600 * 1e3;
 const INBOUND_CLOSE_DRAIN_TIMEOUT_MS = 5e3;
+const REPLY_SESSION_INIT_CONFLICT_MESSAGE_RE = /reply session initialization conflicted for \S+/u;
+function resolveRetryableWhatsAppInboundError(error) {
+	if (error instanceof WhatsAppRetryableInboundError) return error;
+	if (!collectErrorGraphCandidates(error, (current) => [current.cause, current.error]).some((candidate) => REPLY_SESSION_INIT_CONFLICT_MESSAGE_RE.test(formatErrorMessage(candidate)))) return null;
+	return new WhatsAppRetryableInboundError(formatErrorMessage(error), { cause: error });
+}
 function resolveGroupMetadataExpiresAt(nowRaw = Date.now()) {
 	const now = asDateTimestampMs(nowRaw);
 	return now === void 0 ? void 0 : resolveExpiresAtMsFromDurationMs(GROUP_META_TTL_MS, { nowMs: now });
@@ -645,6 +648,18 @@ function logWhatsAppVerbose(enabled, message) {
 function isGroupJid(jid) {
 	return (typeof isJidGroup === "function" ? isJidGroup(jid) : jid.endsWith("@g.us")) === true;
 }
+function isDirectUserJid(jid) {
+	return /^(\d+)(?::\d+)?@(s\.whatsapp\.net|c\.us|lid|hosted|hosted\.lid)$/i.test(jid.trim());
+}
+function getActiveReachoutTimelock(state) {
+	if (state?.isActive !== true) return;
+	const endsAt = state.timeEnforcementEnds?.getTime();
+	return endsAt === void 0 || !Number.isFinite(endsAt) || endsAt > Date.now() ? state : void 0;
+}
+function formatReachoutTimelockError(state) {
+	const details = [state.enforcementType ? `type=${state.enforcementType}` : void 0, state.timeEnforcementEnds instanceof Date && Number.isFinite(state.timeEnforcementEnds.getTime()) ? `until=${state.timeEnforcementEnds.toISOString()}` : void 0].filter(Boolean);
+	return `WhatsApp reachout timelock is active; direct messages are temporarily blocked${details.length ? ` (${details.join(", ")})` : ""}`;
+}
 function recordAcceptedInboundActivity(accountId) {
 	recordChannelActivity({
 		channel: "whatsapp",
@@ -728,9 +743,10 @@ async function attachWebInboxToSocket(options) {
 		const dedupeKeys = uniqueStrings(entries.map((entry) => entry.dedupeKey).filter(isNonEmptyString));
 		const durableEntries = entries.filter((entry) => isNonEmptyString(entry.durableId));
 		const readReceiptEntries = entries.filter((entry) => Boolean(entry.readReceipt));
-		if (error instanceof WhatsAppRetryableInboundError) {
-			dedupeKeys.forEach((dedupeKey) => releaseRecentInboundMessage(dedupeKey, error));
-			await Promise.all(durableEntries.map((entry) => durableInboundJournal.release(entry.durableId, { lastError: formatError(error) })));
+		const retryableError = resolveRetryableWhatsAppInboundError(error);
+		if (retryableError) {
+			dedupeKeys.forEach((dedupeKey) => releaseRecentInboundMessage(dedupeKey, retryableError));
+			await Promise.all(durableEntries.map((entry) => durableInboundJournal.release(entry.durableId, { lastError: formatError(retryableError) })));
 			return;
 		}
 		await Promise.all([...dedupeKeys.map((dedupeKey) => commitRecentInboundMessage(dedupeKey)), ...durableEntries.map((entry) => durableInboundJournal.complete(entry.durableId, entry.readReceipt ? { metadata: { readReceipt: entry.readReceipt } } : void 0))]);
@@ -760,6 +776,7 @@ async function attachWebInboxToSocket(options) {
 					const mentioned = /* @__PURE__ */ new Set();
 					for (const entry of orderedEntries) for (const jid of entry.group?.mentions?.jids ?? []) mentioned.add(jid);
 					const combinedBody = orderedEntries.map((entry) => entry.payload.body).filter(Boolean).join("\n");
+					const combinedCommandBody = orderedEntries.map((entry) => entry.payload.commandBody ?? entry.payload.body).filter(Boolean).join("\n");
 					const combinedMentions = mentioned.size > 0 ? {
 						...last.group?.mentions,
 						jids: Array.from(mentioned)
@@ -772,7 +789,8 @@ async function attachWebInboxToSocket(options) {
 						...last,
 						payload: {
 							...last.payload,
-							body: combinedBody
+							body: combinedBody,
+							commandBody: combinedCommandBody
 						},
 						group: combinedGroup,
 						event: {
@@ -824,18 +842,71 @@ async function attachWebInboxToSocket(options) {
 			remoteJid,
 			messageId
 		});
-		rememberBaileysMessage(remoteJid, messageId, typeof result === "object" && result && "message" in result ? result.message : void 0);
+		const message = typeof result === "object" && result && "message" in result ? result.message : void 0;
+		rememberBaileysMessage(remoteJid, messageId, message);
+		cacheInboundMessageMeta(options.accountId, remoteJid, messageId, {
+			fromMe: true,
+			body: extractText(message ?? void 0)
+		});
 	};
 	const trackLateAcceptedSend = (jid, promise) => {
 		promise.then((result) => {
 			rememberOutboundMessage(jid, result);
 		}, () => {});
 	};
+	let reachoutTimeLock;
+	let reachoutTimeLockFetch;
+	let reachoutTimeLockVersion = 0;
+	let verifiedSendReady;
+	const rememberReachoutTimeLock = (state) => {
+		reachoutTimeLock = state;
+		reachoutTimeLockVersion += 1;
+		verifiedSendReady = void 0;
+	};
+	const fetchReachoutTimeLock = async (currentSock) => {
+		if (typeof currentSock.fetchAccountReachoutTimelock !== "function") return;
+		if (!reachoutTimeLockFetch) reachoutTimeLockFetch = currentSock.fetchAccountReachoutTimelock().then((state) => {
+			rememberReachoutTimeLock(state);
+			return state;
+		}).catch((err) => {
+			logWhatsAppVerbose(options.verbose, `Failed fetching WhatsApp reachout timelock before send: ${formatError(err)}`);
+		}).finally(() => {
+			reachoutTimeLockFetch = void 0;
+		});
+		return await reachoutTimeLockFetch;
+	};
+	const rememberVerifiedSendReady = (jid, currentSock) => {
+		verifiedSendReady = {
+			jid,
+			sock: currentSock,
+			reachoutTimeLockVersion
+		};
+	};
+	const consumeVerifiedSendReady = (jid, currentSock) => {
+		if (verifiedSendReady?.jid !== jid || verifiedSendReady.sock !== currentSock || verifiedSendReady.reachoutTimeLockVersion !== reachoutTimeLockVersion) return false;
+		verifiedSendReady = void 0;
+		return true;
+	};
+	const assertCanSendToJid = async (jid, currentSock, readinessOptions) => {
+		if (!isDirectUserJid(jid)) return;
+		if (readinessOptions?.useVerifiedReady && consumeVerifiedSendReady(jid, currentSock)) return;
+		const state = getActiveReachoutTimelock(reachoutTimeLock) ?? await fetchReachoutTimeLock(currentSock);
+		const activeState = getActiveReachoutTimelock(state);
+		if (activeState) throw new Error(formatReachoutTimelockError(activeState));
+		if (readinessOptions?.rememberReady && state) rememberVerifiedSendReady(jid, currentSock);
+	};
+	const assertCanSendTo = async (to) => {
+		const currentSock = getCurrentSock();
+		if (!currentSock) throw new Error(RECONNECT_IN_PROGRESS_ERROR);
+		const jid = options.authDir ? toWhatsappJidWithLid(to, { authDir: options.authDir }) : toWhatsappJid(to);
+		await assertCanSendToJid(jid, currentSock, { rememberReady: true });
+	};
 	const sendTrackedMessage = async (jid, content, sendOptions) => {
 		let lastErr = /* @__PURE__ */ new Error(RECONNECT_IN_PROGRESS_ERROR);
 		for (let attempt = 1;; attempt++) {
 			const currentSock = getCurrentSock();
 			if (currentSock) try {
+				await assertCanSendToJid(jid, currentSock, { useVerifiedReady: true });
 				const result = await createWhatsAppSocketOperationTimeoutAdapter(currentSock, sendOperationTimeoutMs, { onSendMessageTimeout: ({ jid: timedOutJid, promise }) => {
 					trackLateAcceptedSend(timedOutJid, promise);
 				} }).sendMessage(jid, content, sendOptions);
@@ -1047,7 +1118,9 @@ async function attachWebInboxToSocket(options) {
 		if (upsertType !== "append") return false;
 		const APPEND_RECENT_GRACE_MS = 6e4;
 		const msgTsSeconds = parseWhatsAppTimestampSeconds(msg.messageTimestamp);
-		return (msgTsSeconds !== void 0 ? msgTsSeconds * 1e3 : 0) < connectedAtMs - APPEND_RECENT_GRACE_MS;
+		const msgTsMs = msgTsSeconds !== void 0 ? msgTsSeconds * 1e3 : 0;
+		const nowMs = Date.now();
+		return msgTsMs < (options.appendReplyWindow && nowMs <= options.appendReplyWindow.untilMs ? Math.max(options.appendReplyWindow.afterMs, nowMs - options.appendReplyWindow.maxAgeMs) : connectedAtMs - APPEND_RECENT_GRACE_MS);
 	};
 	const processDurableInboundMessage = async (msg, upsertType, receiveOrder, stored) => {
 		const inbound = await normalizeInboundMessage(msg);
@@ -1117,12 +1190,14 @@ async function attachWebInboxToSocket(options) {
 		const locationText = location ? formatLocationText(location) : void 0;
 		const contactContext = extractContactContext(msg.message ?? void 0);
 		const externalAdReplyContext = extractExternalAdReplyContext(msg.message ?? void 0);
+		const mediaPlaceholder = extractMediaPlaceholder(msg.message ?? void 0);
 		let body = extractText(msg.message ?? void 0);
 		if (locationText) body = [body, locationText].filter(Boolean).join("\n").trim();
 		if (!body) {
-			body = extractMediaPlaceholder(msg.message ?? void 0);
+			body = mediaPlaceholder;
 			if (!body) return null;
 		}
+		const commandBody = body;
 		const replyContext = describeReplyContext(msg.message);
 		let mediaPath;
 		let mediaType;
@@ -1136,12 +1211,26 @@ async function attachWebInboxToSocket(options) {
 		};
 		try {
 			await saveInboundMedia(await downloadInboundMedia(msg, sock, maxBytes));
-			if (!mediaPath && replyContext) await saveInboundMedia(await downloadQuotedInboundMedia(msg, sock, maxBytes));
 		} catch (err) {
 			logWhatsAppVerbose(options.verbose, `Inbound media download failed: ${String(err)}`);
+			body = formatInboundMediaUnavailableText({
+				body,
+				mediaPlaceholder,
+				notice: "[whatsapp attachment unavailable]"
+			});
+		}
+		if (!mediaPath && replyContext) try {
+			await saveInboundMedia(await downloadQuotedInboundMedia(msg, sock, maxBytes));
+		} catch (err) {
+			logWhatsAppVerbose(options.verbose, `Quoted media download failed: ${String(err)}`);
+			body = formatInboundMediaUnavailableText({
+				body,
+				notice: "[whatsapp quoted attachment unavailable]"
+			});
 		}
 		return {
 			body,
+			commandBody,
 			location: location ?? void 0,
 			contactContext,
 			externalAdReplyContext,
@@ -1154,8 +1243,10 @@ async function attachWebInboxToSocket(options) {
 	const enqueueInboundMessage = async (msg, inbound, enriched, durable) => {
 		const chatJid = inbound.remoteJid;
 		const sendComposing = async () => {
-			if (!getCurrentSock()) return;
+			const currentSock = getCurrentSock();
+			if (!currentSock) return;
 			try {
+				await assertCanSendToJid(chatJid, currentSock);
 				await sendApiSocketOperations.sendPresenceUpdate("composing", chatJid);
 			} catch (err) {
 				logWhatsAppVerbose(options.verbose, `Presence update failed: ${String(err)}`);
@@ -1166,7 +1257,8 @@ async function attachWebInboxToSocket(options) {
 			return normalizeWhatsAppSendResult(await sendTrackedMessage(chatJid, addWhatsAppOutboundMentionsToContent({ text: resolved.text }, resolved.mentionedJids), optionsResult), "text");
 		};
 		const sendMedia = async (payload, optionsValue) => {
-			return normalizeWhatsAppSendResult(await sendTrackedMessage(chatJid, await applyOutboundMentionsToContent(chatJid, await addWhatsAppImagePreviewFields(payload)), optionsValue), "media");
+			const previewPayload = await addWhatsAppImagePreviewFields(payload);
+			return normalizeWhatsAppSendResult(await sendTrackedMessage(chatJid, await applyOutboundMentionsToContent(chatJid, previewPayload), optionsValue), "media");
 		};
 		const timestamp = inbound.messageTimestampMs;
 		const mentionedJids = extractMentionedJids(msg.message);
@@ -1210,6 +1302,7 @@ async function attachWebInboxToSocket(options) {
 			},
 			payload: {
 				body: enriched.body,
+				commandBody: enriched.commandBody,
 				location: enriched.location ?? void 0,
 				untrustedStructuredContext: untrustedStructuredContext.length > 0 ? untrustedStructuredContext : void 0,
 				media
@@ -1340,6 +1433,7 @@ async function attachWebInboxToSocket(options) {
 	};
 	const handleConnectionUpdate = (update) => {
 		try {
+			if ("reachoutTimeLock" in update) rememberReachoutTimeLock(update.reachoutTimeLock);
 			if (update.connection === "close") {
 				if (options.socketRef?.current === sock) options.socketRef.current = null;
 				const status = getStatusCode(update.lastDisconnect?.error);
@@ -1452,6 +1546,7 @@ async function attachWebInboxToSocket(options) {
 				error: "closed"
 			});
 		},
+		assertSendReady: assertCanSendTo,
 		sendComposingTo: sendApi.sendComposingTo,
 		sendMessage: sendApi.sendMessage,
 		sendPoll: sendApi.sendPoll,
@@ -1597,6 +1692,7 @@ function createWebChannelStatusController(statusSink) {
 			}
 			status.lastError = null;
 			status.healthState = "healthy";
+			status.terminalDisconnect = void 0;
 			emit();
 		},
 		noteInbound(at = Date.now()) {
@@ -1648,6 +1744,7 @@ function createWebChannelStatusController(statusSink) {
 			status.running = false;
 			status.connected = false;
 			status.lastEventAt = at;
+			status.terminalDisconnect = status.healthState === "logged-out" || status.healthState === "conflict";
 			if (!isTerminalHealthState(status.healthState)) status.healthState = "stopped";
 			emit();
 		}
@@ -1697,28 +1794,6 @@ function formatWhatsAppInboundListeningLog(account) {
 	return `Listening for WhatsApp inbound messages (DM + ${explicitGroupCount} configured ${explicitGroupCount === 1 ? "group" : "groups"}).`;
 }
 //#endregion
-//#region extensions/whatsapp/src/group-session-key.ts
-function resolveWhatsAppGroupAccountThreadId(accountId) {
-	return `whatsapp-account-${normalizeAccountId$1(accountId)}`;
-}
-function resolveWhatsAppLegacyGroupSessionKey(params) {
-	const accountId = normalizeAccountId$1(params.accountId);
-	if (!accountId || accountId === DEFAULT_ACCOUNT_ID$1 || !params.sessionKey.includes(":group:")) return null;
-	const suffix = `:thread:${resolveWhatsAppGroupAccountThreadId(accountId)}`;
-	return params.sessionKey.endsWith(suffix) ? params.sessionKey.slice(0, -suffix.length) : null;
-}
-function resolveWhatsAppGroupSessionRoute(route) {
-	if (route.accountId === DEFAULT_ACCOUNT_ID$1 || !route.sessionKey.includes(":group:")) return route;
-	const scopedSession = resolveThreadSessionKeys({
-		baseSessionKey: route.sessionKey,
-		threadId: resolveWhatsAppGroupAccountThreadId(route.accountId)
-	});
-	return {
-		...route,
-		sessionKey: scopedSession.sessionKey
-	};
-}
-//#endregion
 //#region extensions/whatsapp/src/auto-reply/monitor/ack-emoji.ts
 const DEFAULT_WHATSAPP_ACK_REACTION = "👀";
 function resolveWhatsAppAckEmoji(params) {
@@ -2057,7 +2132,13 @@ async function applyGroupGating(params) {
 			...params.msg.payload,
 			body: params.mentionText
 		}
-	} : params.msg;
+	} : {
+		...params.msg,
+		payload: {
+			...params.msg.payload,
+			body: params.msg.payload.commandBody ?? params.msg.payload.body
+		}
+	};
 	const commandBody = stripMentionsForCommand(mentionMsg.payload.body, mentionConfig.mentionRegexes, self.e164);
 	const activationCommand = parseActivationCommand(commandBody);
 	const owner = isOwnerSender(baseMentionConfig, params.msg, params.authDir);
@@ -2261,9 +2342,10 @@ async function deliverWebReply(params) {
 		if (result) sendResults.push(result);
 	};
 	const finishDelivery = () => {
+		const receipt = createWhatsAppReplyDeliveryReceipt(sendResults);
 		return {
 			results: sendResults,
-			receipt: createWhatsAppReplyDeliveryReceipt(sendResults),
+			receipt,
 			providerAccepted: sendResults.some((result) => result.providerAccepted)
 		};
 	};
@@ -3251,13 +3333,14 @@ async function processMessage(params) {
 	whatsappInboundLog.info(`Inbound message ${fromDisplay} -> ${params.msg.platform.recipientJid} (${conversationKind}${kindLabel}, ${combinedBody.length} chars)`);
 	if (shouldLogVerbose$1()) whatsappInboundLog.debug(`Inbound body: ${elide(combinedBody, 400)}`);
 	const sender = getSenderIdentity(params.msg);
+	const commandBody = params.msg.payload.commandBody ?? params.msg.payload.body;
 	const dmRouteTarget = resolveWhatsAppDmRouteTarget({
 		msg: params.msg,
 		senderE164: sender.e164 ?? void 0,
 		normalizeE164
 	});
-	const shouldCheckCommandAuth = shouldComputeCommandAuthorized(params.msg.payload.body, params.cfg);
-	const isTextCommand = isControlCommandMessage$1(params.msg.payload.body, params.cfg);
+	const shouldCheckCommandAuth = shouldComputeCommandAuthorized(commandBody, params.cfg);
+	const isTextCommand = isControlCommandMessage$1(commandBody, params.cfg);
 	const commandAuthorized = shouldCheckCommandAuth ? await resolveWhatsAppCommandAuthorized({
 		cfg: params.cfg,
 		msg: params.msg,
@@ -3268,12 +3351,12 @@ async function processMessage(params) {
 		kind: "text-slash",
 		source: "text",
 		authorized: Boolean(commandAuthorized),
-		body: params.msg.payload.body
+		body: commandBody
 	} : {
 		kind: "normal",
 		source: "message",
 		authorized: false,
-		body: params.msg.payload.body
+		body: commandBody
 	};
 	const { onModelSelected, ...replyPipeline } = createChannelMessageReplyPipeline({
 		cfg: params.cfg,
@@ -3298,14 +3381,14 @@ async function processMessage(params) {
 	const ctxPayload = await buildWhatsAppInboundContext({
 		bodyForAgent: msgForAgent.payload.body,
 		combinedBody,
-		commandBody: params.msg.payload.body,
+		commandBody,
 		commandAuthorized,
 		commandTurn,
 		groupHistory: visibleGroupHistory,
 		groupMemberRoster: params.groupMemberNames.get(params.groupHistoryKey),
 		groupSystemPrompt: conversationSystemPrompt,
 		msg: params.msg,
-		rawBody: params.msg.payload.body,
+		rawBody: commandBody,
 		route: params.route,
 		sender: {
 			id: getPrimaryIdentityId(sender) ?? void 0,
@@ -3811,6 +3894,7 @@ async function monitorWebChannel(verbose, listenerFactory = attachWebInboxToSock
 	process.once("SIGINT", handleSigint);
 	const transportTimeoutMs = tuning.transportTimeoutMs ?? DEFAULT_TRANSPORT_TIMEOUT_MS;
 	const messageTimeoutMs = tuning.messageTimeoutMs ?? 1800 * 1e3;
+	const reconnectCatchUpWindowMs = Math.min(Math.max(messageTimeoutMs, 6e4), WHATSAPP_INBOUND_DEDUPE_TTL_MS);
 	const watchdogCheckMs = tuning.watchdogCheckMs ?? 60 * 1e3;
 	const controller = new WhatsAppConnectionController({
 		accountId: account.accountId,
@@ -3847,7 +3931,7 @@ async function monitorWebChannel(verbose, listenerFactory = attachWebInboxToSock
 				if (normalized.payload.media?.path || normalized.payload.media?.type) return false;
 				if (normalized.payload.location) return false;
 				if (normalized.quote?.id || normalized.quote?.body) return false;
-				return !isControlCommandMessage(normalized.payload.body, cfg);
+				return !isControlCommandMessage(normalized.payload.commandBody ?? normalized.payload.body, cfg);
 			};
 			let connection;
 			try {
@@ -3886,6 +3970,11 @@ async function monitorWebChannel(verbose, listenerFactory = attachWebInboxToSock
 							sendReadReceipts: account.sendReadReceipts,
 							socketTiming,
 							debounceMs: inboundDebounceMs,
+							appendReplyWindow: connectionLocal.openedAfterRecentInbound ? {
+								afterMs: connectionLocal.startedAt - reconnectCatchUpWindowMs,
+								untilMs: connectionLocal.startedAt + reconnectCatchUpWindowMs,
+								maxAgeMs: reconnectCatchUpWindowMs
+							} : void 0,
 							shouldDebounce,
 							socketRef: controller.socketRef,
 							shouldRetryDisconnect: () => !sigintStop && controller.shouldRetryDisconnect(),