@wednesdayai/whatsapp 0.4.10

package/dist/index.js

@@ -0,0 +1,3678 @@
+import { C as listWhatsAppAccountIds, E as resolveWhatsAppAuthDir, S as stopActiveWebListener, T as resolveWhatsAppAccount$1, _ as webAuthExists, a as waitForWebLogin, b as getActiveWebListener, c as formatError, d as getBaileys, f as getWebAuthAgeMs, g as waitForWebCredsSaveQueue, h as readWebSelfId, i as tryCanonicalWhatsAppAuthDir, l as getStatusCode, m as logoutWeb, o as closeWaSocket, p as logWebSelfId, r as startWebLoginWithQr, s as createWaSocket, t as closeActiveWebLoginsForAuthDir, u as waitForWaConnection, v as getWhatsAppRuntime, w as resolveDefaultWhatsAppAccountId, x as setActiveWebListener, y as setWhatsAppRuntime } from "./login-qr-B5goEXCP.js";
+import { DEFAULT_ACCOUNT_ID, DEFAULT_GROUP_HISTORY_LIMIT, DEFAULT_MAIN_KEY, ToolAuthorizationError, Type, WhatsAppConfigSchema, applyAccountNameToChannelSection, buildAgentMainSessionKey, buildAgentSessionKey, buildChannelConfigSchema, buildGroupHistoryKey, buildHistoryContextFromEntries, buildMentionRegexes, buildPairingReply, chunkMarkdownTextWithMode, computeBackoff, convertMarkdownTables, createActionGate, createDedupeCache, createInboundDebouncer, createReplyPrefixOptions, createSubsystemLogger, danger, defaultRuntime, dispatchReplyWithBufferedBlockDispatcher, emptyPluginConfigSchema, enqueueSystemEvent, escapeRegExp, finalizeInboundContext, formatCliCommand, formatDocsLink, formatDurationPrecise, formatInboundEnvelope, formatLocationText, formatPairingApproveHint, getAgentScopedMediaLocalRoots, getChildLogger, getReplyFromConfig, hasControlCommand, info, isSelfChatMode, jidToE164, jsonResult, loadConfig, loadSessionStore, loadWebMedia, logInfo, logVerbose, markdownToWhatsApp, mergeWhatsAppConfig, migrateBaseNameToDefaultAccount, missingTargetError, normalizeAccountId, normalizeAgentId, normalizeAllowFromEntries, normalizeE164, normalizeGroupActivation, normalizeMentionText, parseActivationCommand, pathExists, readChannelAllowFromStoreSync, readReactionParams, readStoreAllowFromForDmPolicy, readStringParam, recordChannelActivity, recordPendingHistoryEntryIfEnabled, recordSessionMetaFromInbound, registerUnhandledRejectionHandler, resolveAccountIdForConfigure, resolveAgentRoute, resolveAllowlistProviderRuntimeGroupPolicy, resolveChannelGroupPolicy, resolveChannelGroupRequireMention, resolveChunkMode, resolveChunkNewlinePacking, resolveDefaultGroupPolicy, resolveDmGroupAccessWithCommandGate, resolveDmGroupAccessWithLists, resolveGroupSessionKey, resolveIdentityNamePrefix, resolveInboundDebounceMs, resolveInboundSessionEnvelopeContext, resolveJidToE164, resolveMarkdownTableMode, resolveMentionGating, resolveMessagePrefix, resolveOnboardingAccountId, resolveOpenProviderRuntimeGroupPolicy, resolvePinnedMainDmOwnerFromAllowlist, resolveStorePath, resolveTextChunkLimit, resolveWhatsAppAccount, resolveWhatsAppGroupRequireMention, resolveWhatsAppGroupToolPolicy, saveMediaBuffer, shouldAckReactionForWhatsApp, shouldComputeCommandAuthorized, shouldLogVerbose, sleep, sleepWithAbort, splitOnboardingEntries, success, toLocationContext, toWhatsappJid, transcribeFirstAudio, updateLastRoute, upsertChannelPairingRequest, waitForever, warnMissingProviderGroupPolicyFallbackOnce } from "openclaw/plugin-sdk";
+import path from "node:path";
+import { createHash, randomUUID } from "node:crypto";
+import { escapeRegExp as escapeRegExp$1 } from "openclaw/plugin-sdk/escape-regexp";
+
+//#region src/outbound.ts
+function redactIdentifier(value, len = 12) {
+	const trimmed = value?.trim();
+	if (!trimmed) return "-";
+	return `sha256:${createHash("sha256").update(trimmed).digest("hex").slice(0, len)}`;
+}
+const FENCE_PLACEHOLDER = "\0FENCE";
+const INLINE_CODE_PLACEHOLDER = "\0CODE";
+function markdownToWhatsApp$1(text) {
+	if (!text) return text;
+	const fences = [];
+	let result = text.replace(/```[\s\S]*?```/g, (match) => {
+		fences.push(match);
+		return `${FENCE_PLACEHOLDER}${fences.length - 1}`;
+	});
+	const inlineCodes = [];
+	result = result.replace(/`[^`\n]+`/g, (match) => {
+		inlineCodes.push(match);
+		return `${INLINE_CODE_PLACEHOLDER}${inlineCodes.length - 1}`;
+	});
+	result = result.replace(/\*\*(.+?)\*\*/g, "*$1*");
+	result = result.replace(/__(.+?)__/g, "*$1*");
+	result = result.replace(/~~(.+?)~~/g, "~$1~");
+	result = result.replace(new RegExp(`${escapeRegExp(INLINE_CODE_PLACEHOLDER)}(\\d+)`, "g"), (_, idx) => inlineCodes[Number(idx)] ?? "");
+	return result.replace(new RegExp(`${escapeRegExp(FENCE_PLACEHOLDER)}(\\d+)`, "g"), (_, idx) => fences[Number(idx)] ?? "");
+}
+function toWhatsappJid$1(number) {
+	const withoutPrefix = number.replace(/^whatsapp:/, "").trim();
+	if (withoutPrefix.includes("@")) return withoutPrefix;
+	return `${normalizeE164(withoutPrefix).replace(/\D/g, "")}@s.whatsapp.net`;
+}
+function normalizePollInput(input, options = {}) {
+	const question = input.question.trim();
+	if (!question) throw new Error("Poll question is required");
+	const cleaned = input.options.map((option) => option.trim()).filter(Boolean);
+	if (cleaned.length < 2) throw new Error("Poll requires at least 2 options");
+	if (options.maxOptions !== void 0 && cleaned.length > options.maxOptions) throw new Error(`Poll supports at most ${options.maxOptions} options`);
+	const maxSelections = typeof input.maxSelections === "number" && Number.isFinite(input.maxSelections) ? Math.floor(input.maxSelections) : 1;
+	if (maxSelections < 1) throw new Error("maxSelections must be at least 1");
+	if (maxSelections > cleaned.length) throw new Error("maxSelections cannot exceed option count");
+	const durationSeconds = typeof input.durationSeconds === "number" && Number.isFinite(input.durationSeconds) ? Math.floor(input.durationSeconds) : void 0;
+	if (durationSeconds !== void 0 && durationSeconds < 1) throw new Error("durationSeconds must be at least 1");
+	const durationHours = typeof input.durationHours === "number" && Number.isFinite(input.durationHours) ? Math.floor(input.durationHours) : void 0;
+	if (durationHours !== void 0 && durationHours < 1) throw new Error("durationHours must be at least 1");
+	if (durationSeconds !== void 0 && durationHours !== void 0) throw new Error("durationSeconds and durationHours are mutually exclusive");
+	return {
+		question,
+		options: cleaned,
+		maxSelections,
+		durationSeconds,
+		durationHours
+	};
+}
+function resolveWebAccountId(accountId) {
+	return (accountId ?? "").trim() || DEFAULT_ACCOUNT_ID;
+}
+function requireActiveWebListener(accountId) {
+	const id = resolveWebAccountId(accountId);
+	const listener = getActiveWebListener(id);
+	if (!listener) throw new Error(`No active WhatsApp Web listener (account: ${id}). Start the gateway, then link WhatsApp with: ${formatCliCommand(`openclaw channels login --channel whatsapp --account ${id}`)}.`);
+	return {
+		accountId: id,
+		listener
+	};
+}
+async function sendMessageWhatsApp(to, body, options) {
+	let text = body;
+	const correlationId = randomUUID();
+	const startedAt = Date.now();
+	const { listener: active, accountId: resolvedAccountId } = requireActiveWebListener(options.accountId);
+	const cfg = getWhatsAppRuntime().config.loadConfig();
+	const tableMode = getWhatsAppRuntime().channel.text.resolveMarkdownTableMode({
+		cfg,
+		channel: "whatsapp",
+		accountId: resolvedAccountId ?? options.accountId
+	});
+	text = getWhatsAppRuntime().channel.text.convertMarkdownTables(text ?? "", tableMode);
+	text = markdownToWhatsApp$1(text);
+	const redactedTo = redactIdentifier(to);
+	const logger = getChildLogger({
+		module: "whatsapp-outbound",
+		correlationId,
+		to: redactedTo
+	});
+	try {
+		const jid = toWhatsappJid$1(to);
+		const redactedJid = redactIdentifier(jid);
+		let mediaBuffer;
+		let mediaType;
+		let documentFileName;
+		if (options.mediaUrl) {
+			const media = await loadWebMedia(options.mediaUrl, { localRoots: options.mediaLocalRoots });
+			const caption = text || void 0;
+			mediaBuffer = media.buffer;
+			mediaType = media.contentType;
+			if (media.kind === "audio") mediaType = media.contentType === "audio/ogg" ? "audio/ogg; codecs=opus" : media.contentType ?? "application/octet-stream";
+			else if (media.kind === "video" || media.kind === "image") text = caption ?? "";
+			else {
+				text = caption ?? "";
+				documentFileName = media.fileName;
+			}
+		}
+		logger.info({
+			jid: redactedJid,
+			hasMedia: Boolean(options.mediaUrl)
+		}, "sending message");
+		active.sendComposingTo(to).catch((err) => {
+			logger.warn({
+				err: String(err),
+				jid: redactedJid
+			}, "failed to send composing presence");
+		});
+		const accountId = Boolean(options.accountId?.trim()) ? resolvedAccountId : void 0;
+		const sendOptions = options.gifPlayback || accountId || documentFileName ? {
+			...options.gifPlayback ? { gifPlayback: true } : {},
+			...documentFileName ? { fileName: documentFileName } : {},
+			accountId
+		} : void 0;
+		const messageId = (sendOptions ? await active.sendMessage(to, text, mediaBuffer, mediaType, sendOptions) : await active.sendMessage(to, text, mediaBuffer, mediaType))?.messageId ?? "unknown";
+		logger.info({
+			jid: redactedJid,
+			messageId,
+			durationMs: Date.now() - startedAt
+		}, "sent message");
+		return {
+			messageId,
+			toJid: jid
+		};
+	} catch (err) {
+		logger.error({
+			err: String(err),
+			to: redactedTo,
+			hasMedia: Boolean(options.mediaUrl)
+		}, "failed to send via WhatsApp session");
+		throw err;
+	}
+}
+async function sendReactionWhatsApp(chatJid, messageId, emoji, options) {
+	const correlationId = randomUUID();
+	const { listener: active } = requireActiveWebListener(options.accountId);
+	const redactedChatJid = redactIdentifier(chatJid);
+	const logger = getChildLogger({
+		module: "whatsapp-outbound",
+		correlationId,
+		chatJid: redactedChatJid,
+		messageId
+	});
+	try {
+		const jid = toWhatsappJid$1(chatJid);
+		logger.info({
+			chatJid: redactIdentifier(jid),
+			messageId,
+			emoji
+		}, "sending reaction");
+		await active.sendReaction(chatJid, messageId, emoji, options.fromMe ?? false, options.participant);
+		logger.info({
+			chatJid: redactIdentifier(jid),
+			messageId,
+			emoji
+		}, "sent reaction");
+	} catch (err) {
+		logger.error({
+			err: String(err),
+			chatJid: redactedChatJid,
+			messageId,
+			emoji
+		}, "failed to send reaction via WhatsApp session");
+		throw err;
+	}
+}
+async function sendPollWhatsApp(to, poll, options) {
+	const correlationId = randomUUID();
+	const startedAt = Date.now();
+	const { listener: active } = requireActiveWebListener(options.accountId);
+	const redactedTo = redactIdentifier(to);
+	const logger = getChildLogger({
+		module: "whatsapp-outbound",
+		correlationId,
+		to: redactedTo
+	});
+	try {
+		const jid = toWhatsappJid$1(to);
+		const normalized = normalizePollInput(poll, { maxOptions: 12 });
+		logger.info({
+			jid: redactIdentifier(jid),
+			optionCount: normalized.options.length,
+			maxSelections: normalized.maxSelections
+		}, "sending poll");
+		const messageId = (await active.sendPoll(to, normalized))?.messageId ?? "unknown";
+		logger.info({
+			jid: redactIdentifier(jid),
+			messageId,
+			durationMs: Date.now() - startedAt
+		}, "sent poll");
+		return {
+			messageId,
+			toJid: jid
+		};
+	} catch (err) {
+		logger.error({
+			err: String(err),
+			to: redactedTo
+		}, "failed to send poll via WhatsApp session");
+		throw err;
+	}
+}
+
+//#endregion
+//#region src/normalize.ts
+const WHATSAPP_USER_JID_RE = /^(\d+)(?::\d+)?@s\.whatsapp\.net$/i;
+const WHATSAPP_LID_RE = /^(\d+)@lid$/i;
+function stripWhatsAppTargetPrefixes(value) {
+	let candidate = value.trim();
+	for (;;) {
+		const before = candidate;
+		candidate = candidate.replace(/^whatsapp:/i, "").trim();
+		if (candidate === before) return candidate;
+	}
+}
+function isWhatsAppGroupJid(value) {
+	const candidate = stripWhatsAppTargetPrefixes(value);
+	if (!candidate.toLowerCase().endsWith("@g.us")) return false;
+	const localPart = candidate.slice(0, candidate.length - 5);
+	if (!localPart || localPart.includes("@")) return false;
+	return /^(?=.*\d)[0-9a-z]+(?:-[0-9a-z]+)*$/i.test(localPart);
+}
+function isWhatsAppUserTarget(value) {
+	const candidate = stripWhatsAppTargetPrefixes(value);
+	return WHATSAPP_USER_JID_RE.test(candidate) || WHATSAPP_LID_RE.test(candidate);
+}
+function extractUserJidPhone(jid) {
+	const userMatch = jid.match(WHATSAPP_USER_JID_RE);
+	if (userMatch) return userMatch[1];
+	const lidMatch = jid.match(WHATSAPP_LID_RE);
+	if (lidMatch) return lidMatch[1];
+	return null;
+}
+function normalizeWhatsAppTarget(value) {
+	const candidate = stripWhatsAppTargetPrefixes(value);
+	if (!candidate) return null;
+	if (isWhatsAppGroupJid(candidate)) return `${candidate.slice(0, candidate.length - 5)}@g.us`;
+	if (isWhatsAppUserTarget(candidate)) {
+		const phone = extractUserJidPhone(candidate);
+		if (!phone) return null;
+		const normalized = normalizeE164(phone);
+		return normalized.length > 1 ? normalized : null;
+	}
+	if (candidate.includes("@")) return null;
+	const normalized = normalizeE164(candidate);
+	return normalized.length > 1 ? normalized : null;
+}
+
+//#endregion
+//#region src/resolve-outbound-target.ts
+function resolveWhatsAppOutboundTarget(params) {
+	const trimmed = params.to?.trim() ?? "";
+	const allowListRaw = (params.allowFrom ?? []).map((entry) => String(entry).trim()).filter(Boolean);
+	const hasWildcard = allowListRaw.includes("*");
+	const allowList = allowListRaw.filter((entry) => entry !== "*").map((entry) => normalizeWhatsAppTarget(entry)).filter((entry) => Boolean(entry));
+	if (trimmed) {
+		const normalizedTo = normalizeWhatsAppTarget(trimmed);
+		if (!normalizedTo) return {
+			ok: false,
+			error: missingTargetError("WhatsApp", "<E.164|group JID>")
+		};
+		if (isWhatsAppGroupJid(normalizedTo)) return {
+			ok: true,
+			to: normalizedTo
+		};
+		if (hasWildcard || allowList.length === 0) return {
+			ok: true,
+			to: normalizedTo
+		};
+		if (allowList.includes(normalizedTo)) return {
+			ok: true,
+			to: normalizedTo
+		};
+		return {
+			ok: false,
+			error: missingTargetError("WhatsApp", "<E.164|group JID>")
+		};
+	}
+	return {
+		ok: false,
+		error: missingTargetError("WhatsApp", "<E.164|group JID>")
+	};
+}
+
+//#endregion
+//#region src/actions.ts
+function resolveAuthorizedWhatsAppOutboundTarget(params) {
+	const account = resolveWhatsAppAccount$1({
+		cfg: params.cfg,
+		accountId: params.accountId
+	});
+	const resolution = resolveWhatsAppOutboundTarget({
+		to: params.chatJid,
+		allowFrom: account.allowFrom ?? [],
+		mode: "implicit"
+	});
+	if (!resolution.ok) throw new ToolAuthorizationError(`WhatsApp ${params.actionLabel} blocked: chatJid "${params.chatJid}" is not in the configured allowFrom list for account "${account.accountId}".`);
+	return {
+		to: resolution.to,
+		accountId: account.accountId
+	};
+}
+async function handleWhatsAppAction(params, cfg) {
+	const action = readStringParam(params, "action", { required: true });
+	const isActionEnabled = createActionGate(cfg.channels?.whatsapp?.actions);
+	if (action === "react") {
+		if (!isActionEnabled("reactions")) throw new Error("WhatsApp reactions are disabled.");
+		const chatJid = readStringParam(params, "chatJid", { required: true });
+		const messageId = readStringParam(params, "messageId", { required: true });
+		const { emoji, remove, isEmpty } = readReactionParams(params, { removeErrorMessage: "Emoji is required to remove a WhatsApp reaction." });
+		const participant = readStringParam(params, "participant");
+		const accountId = readStringParam(params, "accountId");
+		const fromMeRaw = params.fromMe;
+		const fromMe = typeof fromMeRaw === "boolean" ? fromMeRaw : void 0;
+		const resolved = resolveAuthorizedWhatsAppOutboundTarget({
+			cfg,
+			chatJid,
+			accountId,
+			actionLabel: "reaction"
+		});
+		const resolvedEmoji = remove ? "" : emoji;
+		await sendReactionWhatsApp(resolved.to, messageId, resolvedEmoji, {
+			verbose: false,
+			fromMe,
+			participant: participant ?? void 0,
+			accountId: resolved.accountId
+		});
+		if (!remove && !isEmpty) return jsonResult({
+			ok: true,
+			added: emoji
+		});
+		return jsonResult({
+			ok: true,
+			removed: true
+		});
+	}
+	throw new Error(`Unsupported WhatsApp action: ${action}`);
+}
+
+//#endregion
+//#region src/agent-tools-login.ts
+function createWhatsAppLoginTool() {
+	return {
+		label: "WhatsApp Login",
+		name: "whatsapp_login",
+		ownerOnly: true,
+		description: "Generate a WhatsApp QR code for linking, or wait for the scan to complete.",
+		parameters: Type.Object({
+			action: Type.Unsafe({
+				type: "string",
+				enum: ["start", "wait"]
+			}),
+			timeoutMs: Type.Optional(Type.Number()),
+			force: Type.Optional(Type.Boolean())
+		}),
+		execute: async (_toolCallId, args) => {
+			const { startWebLoginWithQr, waitForWebLogin } = await import("./login-qr-B5goEXCP.js").then((n) => n.n);
+			if ((args?.action ?? "start") === "wait") {
+				const result = await waitForWebLogin({ timeoutMs: typeof args.timeoutMs === "number" ? args.timeoutMs : void 0 });
+				return {
+					content: [{
+						type: "text",
+						text: result.message
+					}],
+					details: { connected: result.connected }
+				};
+			}
+			const result = await startWebLoginWithQr({
+				timeoutMs: typeof args.timeoutMs === "number" ? args.timeoutMs : void 0,
+				force: typeof args.force === "boolean" ? args.force : false
+			});
+			if (!result.qrDataUrl) return {
+				content: [{
+					type: "text",
+					text: result.message
+				}],
+				details: { qr: false }
+			};
+			return {
+				content: [{
+					type: "text",
+					text: [
+						result.message,
+						"",
+						"Open WhatsApp -> Linked Devices and scan:",
+						"",
+						`![whatsapp-qr](${result.qrDataUrl})`
+					].join("\n")
+				}],
+				details: { qr: true }
+			};
+		}
+	};
+}
+
+//#endregion
+//#region src/targets.ts
+function trimMessagingTarget(raw) {
+	return raw.trim() || void 0;
+}
+function looksLikeHandleOrPhoneTarget(params) {
+	const trimmed = params.raw.trim();
+	if (!trimmed) return false;
+	if (params.prefixPattern.test(trimmed)) return true;
+	if (trimmed.includes("@")) return true;
+	return (params.phonePattern ?? /^\+?\d{3,}$/).test(trimmed);
+}
+function normalizeWhatsAppMessagingTarget(raw) {
+	const trimmed = trimMessagingTarget(raw);
+	if (!trimmed) return;
+	return normalizeWhatsAppTarget(trimmed) ?? void 0;
+}
+function normalizeWhatsAppAllowFromEntries(allowFrom) {
+	return allowFrom.map((entry) => String(entry).trim()).filter((entry) => Boolean(entry)).map((entry) => entry === "*" ? entry : normalizeWhatsAppTarget(entry)).filter((entry) => Boolean(entry));
+}
+function looksLikeWhatsAppTargetId(raw) {
+	return looksLikeHandleOrPhoneTarget({
+		raw,
+		prefixPattern: /^whatsapp:/i
+	});
+}
+
+//#endregion
+//#region src/config.ts
+function resolveWhatsAppConfigAllowFrom(params) {
+	return resolveWhatsAppAccount$1(params).allowFrom ?? [];
+}
+function formatWhatsAppConfigAllowFromEntries(allowFrom) {
+	return normalizeWhatsAppAllowFromEntries(allowFrom);
+}
+function resolveWhatsAppConfigDefaultTo(params) {
+	const root = params.cfg.channels?.whatsapp;
+	const normalized = normalizeAccountId(params.accountId);
+	return ((root?.accounts?.[normalized])?.defaultTo ?? root?.defaultTo)?.trim() || void 0;
+}
+
+//#endregion
+//#region src/directory.ts
+function resolveDirectoryQuery(query) {
+	return query?.trim().toLowerCase() || "";
+}
+function resolveDirectoryLimit(limit) {
+	return typeof limit === "number" && limit > 0 ? limit : void 0;
+}
+function applyDirectoryQueryAndLimit(ids, params) {
+	const q = resolveDirectoryQuery(params.query);
+	const limit = resolveDirectoryLimit(params.limit);
+	const filtered = ids.filter((id) => q ? id.toLowerCase().includes(q) : true);
+	return typeof limit === "number" ? filtered.slice(0, limit) : filtered;
+}
+function toDirectoryEntries(kind, ids) {
+	return ids.map((id) => ({
+		kind,
+		id
+	}));
+}
+async function listWhatsAppDirectoryPeersFromConfig(params) {
+	return toDirectoryEntries("user", applyDirectoryQueryAndLimit((resolveWhatsAppAccount$1({
+		cfg: params.cfg,
+		accountId: params.accountId
+	}).allowFrom ?? []).map((entry) => String(entry).trim()).filter((entry) => Boolean(entry) && entry !== "*").map((entry) => normalizeWhatsAppTarget(entry) ?? "").filter(Boolean).filter((id) => !isWhatsAppGroupJid(id)), params));
+}
+async function listWhatsAppDirectoryGroupsFromConfig(params) {
+	const account = resolveWhatsAppAccount$1({
+		cfg: params.cfg,
+		accountId: params.accountId
+	});
+	return toDirectoryEntries("group", applyDirectoryQueryAndLimit(Object.keys(account.groups ?? {}).map((id) => id.trim()).filter((id) => Boolean(id) && id !== "*"), params));
+}
+
+//#endregion
+//#region src/loggers.ts
+function makeLoggers() {
+	const whatsappLog = createSubsystemLogger("gateway/channels/whatsapp");
+	return {
+		whatsappLog,
+		whatsappInboundLog: whatsappLog.child("inbound"),
+		whatsappOutboundLog: whatsappLog.child("outbound"),
+		whatsappHeartbeatLog: whatsappLog.child("heartbeat")
+	};
+}
+let _loggers;
+function getLoggers() {
+	_loggers ??= makeLoggers();
+	return _loggers;
+}
+const whatsappLog = new Proxy({}, { get(_t, prop) {
+	return Reflect.get(getLoggers().whatsappLog, prop);
+} });
+const whatsappInboundLog = new Proxy({}, { get(_t, prop) {
+	return Reflect.get(getLoggers().whatsappInboundLog, prop);
+} });
+const whatsappOutboundLog = new Proxy({}, { get(_t, prop) {
+	return Reflect.get(getLoggers().whatsappOutboundLog, prop);
+} });
+const whatsappHeartbeatLog = new Proxy({}, { get(_t, prop) {
+	return Reflect.get(getLoggers().whatsappHeartbeatLog, prop);
+} });
+
+//#endregion
+//#region src/heartbeat.ts
+function isWhatsAppChannel(raw) {
+	return (raw ?? "").trim().toLowerCase() === "whatsapp";
+}
+function getSessionRecipients(cfg, loadSessionStore, resolveStorePath) {
+	if ((cfg.session?.scope ?? "per-sender") === "global") return [];
+	const store = loadSessionStore(resolveStorePath(cfg.session?.store));
+	const isGroupKey = (key) => key.includes(":group:") || key.includes(":channel:") || key.includes("@g.us");
+	const isCronKey = (key) => key.startsWith("cron:");
+	const recipients = Object.entries(store).filter(([key]) => key !== "global" && key !== "unknown").filter(([key]) => !isGroupKey(key) && !isCronKey(key)).map(([_, entry]) => ({
+		to: isWhatsAppChannel(entry?.lastChannel) && entry?.lastTo ? normalizeE164(entry.lastTo) : "",
+		updatedAt: entry?.updatedAt ?? 0
+	})).filter(({ to }) => to.length > 1).toSorted((a, b) => b.updatedAt - a.updatedAt);
+	const seen = /* @__PURE__ */ new Set();
+	return recipients.filter((r) => {
+		if (seen.has(r.to)) return false;
+		seen.add(r.to);
+		return true;
+	});
+}
+function resolveWhatsAppHeartbeatRecipients(cfg, opts = {}, deps = {}) {
+	const loadSessionStore$1 = deps.loadSessionStore ?? loadSessionStore;
+	const resolveStorePath$1 = deps.resolveStorePath ?? resolveStorePath;
+	const readChannelAllowFromStoreSync$1 = deps.readChannelAllowFromStoreSync ?? readChannelAllowFromStoreSync;
+	if (opts.to) return {
+		recipients: [normalizeE164(opts.to)],
+		source: "flag"
+	};
+	const sessionRecipients = getSessionRecipients(cfg, loadSessionStore$1, resolveStorePath$1);
+	const configuredAllowFromRaw = Array.isArray(cfg.channels?.whatsapp?.allowFrom) && cfg.channels.whatsapp.allowFrom.length > 0 ? cfg.channels.whatsapp.allowFrom : [];
+	if (configuredAllowFromRaw.includes("*")) whatsappHeartbeatLog.warn("whatsapp heartbeat allowFrom contains wildcard '*' — wildcard is NOT supported for broadcast heartbeat delivery and will be ignored; list specific JIDs to deliver to those recipients");
+	const configuredAllowFrom = configuredAllowFromRaw.filter((v) => v !== "*").map(normalizeE164);
+	const storeAllowFrom = readChannelAllowFromStoreSync$1("whatsapp", process.env, DEFAULT_ACCOUNT_ID).map(normalizeE164);
+	const unique = (list) => [...new Set(list.filter(Boolean))];
+	const allowFrom = unique([...configuredAllowFrom, ...storeAllowFrom]);
+	if (opts.all) return {
+		recipients: unique([...sessionRecipients.map((s) => s.to), ...allowFrom]),
+		source: "all"
+	};
+	if (allowFrom.length > 0) {
+		const allowSet = new Set(allowFrom);
+		const authorizedSessionRecipients = sessionRecipients.map((entry) => entry.to).filter((recipient) => allowSet.has(recipient));
+		if (authorizedSessionRecipients.length === 1) return {
+			recipients: [authorizedSessionRecipients[0]],
+			source: "session-single"
+		};
+		if (authorizedSessionRecipients.length > 1) return {
+			recipients: authorizedSessionRecipients,
+			source: "session-ambiguous"
+		};
+		return {
+			recipients: allowFrom,
+			source: "allowFrom"
+		};
+	}
+	if (sessionRecipients.length === 1) return {
+		recipients: [sessionRecipients[0].to],
+		source: "session-single"
+	};
+	if (sessionRecipients.length > 1) return {
+		recipients: sessionRecipients.map((s) => s.to),
+		source: "session-ambiguous"
+	};
+	return {
+		recipients: allowFrom,
+		source: "allowFrom"
+	};
+}
+
+//#endregion
+//#region src/login.ts
+async function closeSocketWithRetry(socket) {
+	try {
+		await closeWaSocket(socket);
+	} catch {
+		await closeWaSocket(socket);
+	}
+}
+async function loginWeb(verbose, waitForConnection, runtime = defaultRuntime, accountId, cfg) {
+	const { DisconnectReason } = await getBaileys();
+	const wait = waitForConnection ?? waitForWaConnection;
+	const account = resolveWhatsAppAccount$1({
+		cfg: cfg ?? getWhatsAppRuntime().config.loadConfig(),
+		accountId
+	});
+	const sock = await createWaSocket(true, verbose, { authDir: account.authDir });
+	const clearLoggedOutSession = async (socket, cause) => {
+		await closeSocketWithRetry(socket);
+		await logoutWeb({
+			authDir: account.authDir,
+			isLegacyAuthDir: account.isLegacyAuthDir,
+			runtime
+		});
+		runtime.log(danger(`WhatsApp reported the session is logged out. Cleared cached web session; please rerun ${formatCliCommand("openclaw channels login")} and scan the QR again.`));
+		throw new Error("Session logged out; cache cleared. Re-run login.", { cause });
+	};
+	logInfo("Waiting for WhatsApp connection...", runtime);
+	try {
+		await wait(sock);
+		await waitForWebCredsSaveQueue(account.authDir);
+		runtime.log(success("Linked! Credentials saved for future sends."));
+	} catch (err) {
+		const code = getStatusCode(err);
+		if (code === 515) {
+			runtime.log(info("WhatsApp asked for a restart after pairing (code 515); creds are saved. Restarting connection once..."));
+			try {
+				await closeSocketWithRetry(sock);
+			} catch {}
+			const retry = await createWaSocket(false, verbose, { authDir: account.authDir });
+			try {
+				await wait(retry);
+				await waitForWebCredsSaveQueue(account.authDir);
+				runtime.log(success("Linked after restart; web session ready."));
+				return;
+			} catch (retryErr) {
+				if (getStatusCode(retryErr) === DisconnectReason.loggedOut) await clearLoggedOutSession(retry, retryErr);
+				throw retryErr;
+			} finally {
+				await closeSocketWithRetry(retry);
+			}
+		}
+		if (code === DisconnectReason.loggedOut) await clearLoggedOutSession(sock, err);
+		const formatted = formatError(err);
+		runtime.log(danger(`WhatsApp Web connection ended before fully opening. ${formatted}`));
+		throw new Error(formatted, { cause: err });
+	} finally {
+		await closeSocketWithRetry(sock);
+	}
+}
+
+//#endregion
+//#region src/constants.ts
+const DEFAULT_WEB_MEDIA_BYTES = 5 * 1024 * 1024;
+
+//#endregion
+//#region src/inbound/access-control.ts
+let _log;
+function getLog() {
+	_log ??= createSubsystemLogger("whatsapp/inbound/access-control");
+	return _log;
+}
+const PAIRING_REPLY_HISTORY_GRACE_MS = 3e4;
+const MIN_E164_DIGITS = 7;
+function isValidE164(normalized) {
+	if (!normalized) return false;
+	return normalized.replace(/\D/g, "").length >= MIN_E164_DIGITS;
+}
+function resolveWhatsAppRuntimeGroupPolicy(params) {
+	return resolveOpenProviderRuntimeGroupPolicy({
+		providerConfigPresent: params.providerConfigPresent,
+		groupPolicy: params.groupPolicy,
+		defaultGroupPolicy: params.defaultGroupPolicy
+	});
+}
+async function checkInboundAccessControl(params) {
+	const cfg = loadConfig();
+	const account = resolveWhatsAppAccount({
+		cfg,
+		accountId: params.accountId
+	});
+	const dmPolicy = account.dmPolicy ?? "pairing";
+	const configuredAllowFrom = account.allowFrom ?? [];
+	const storeAllowFrom = await readStoreAllowFromForDmPolicy({
+		provider: "whatsapp",
+		accountId: account.accountId,
+		dmPolicy
+	});
+	const defaultAllowFrom = configuredAllowFrom.length === 0 && params.selfE164 ? [params.selfE164] : [];
+	const dmAllowFrom = configuredAllowFrom.length > 0 ? configuredAllowFrom : defaultAllowFrom;
+	const groupAllowFrom = account.groupAllowFrom ?? (configuredAllowFrom.length > 0 ? configuredAllowFrom : void 0);
+	const isSamePhone = params.from === params.selfE164;
+	const isSelfChat = account.selfChatMode ?? isSelfChatMode(params.selfE164, configuredAllowFrom);
+	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;
+	const defaultGroupPolicy = resolveDefaultGroupPolicy(cfg);
+	const { groupPolicy, providerMissingFallbackApplied } = resolveWhatsAppRuntimeGroupPolicy({
+		providerConfigPresent: cfg.channels?.whatsapp !== void 0,
+		groupPolicy: account.groupPolicy,
+		defaultGroupPolicy
+	});
+	warnMissingProviderGroupPolicyFallbackOnce({
+		providerMissingFallbackApplied,
+		providerKey: "whatsapp",
+		accountId: account.accountId,
+		log: (message) => logVerbose(message)
+	});
+	const rawNormalizedDmSender = normalizeE164(params.from);
+	if (!isValidE164(rawNormalizedDmSender)) {
+		getLog().warn("jid.resolution.failed", { rawJid: params.from });
+		return {
+			allowed: false,
+			shouldMarkRead: false,
+			isSelfChat,
+			resolvedAccountId: account.accountId
+		};
+	}
+	const normalizedDmSender = rawNormalizedDmSender;
+	const rawNormalizedGroupSender = typeof params.senderE164 === "string" ? normalizeE164(params.senderE164) : null;
+	if (params.group && params.senderE164 && !isValidE164(rawNormalizedGroupSender)) getLog().warn("jid.resolution.failed", { rawJid: params.senderE164 });
+	const normalizedGroupSender = isValidE164(rawNormalizedGroupSender) ? rawNormalizedGroupSender : null;
+	const access = resolveDmGroupAccessWithLists({
+		isGroup: params.group,
+		dmPolicy,
+		groupPolicy,
+		allowFrom: params.group ? configuredAllowFrom : dmAllowFrom,
+		groupAllowFrom,
+		storeAllowFrom,
+		isSenderAllowed: (allowEntries) => {
+			if (allowEntries.includes("*")) return true;
+			const normalizedEntrySet = new Set(allowEntries.map((entry) => normalizeE164(String(entry))).filter((entry) => isValidE164(entry)));
+			if (!params.group && isSamePhone) return true;
+			return params.group ? Boolean(normalizedGroupSender && normalizedEntrySet.has(normalizedGroupSender)) : normalizedEntrySet.has(normalizedDmSender);
+		}
+	});
+	if (params.group && access.decision !== "allow") {
+		if (access.reason === "groupPolicy=disabled") logVerbose("Blocked group message (groupPolicy: disabled)");
+		else if (access.reason === "groupPolicy=allowlist (empty allowlist)") logVerbose("Blocked group message (groupPolicy: allowlist, no groupAllowFrom)");
+		else logVerbose(`Blocked group message from ${params.senderE164 ?? "unknown sender"} (groupPolicy: allowlist)`);
+		return {
+			allowed: false,
+			shouldMarkRead: false,
+			isSelfChat,
+			resolvedAccountId: account.accountId
+		};
+	}
+	if (!params.group) {
+		if (params.isFromMe && !isSamePhone) {
+			logVerbose("Skipping outbound DM (fromMe); no pairing reply needed.");
+			return {
+				allowed: false,
+				shouldMarkRead: false,
+				isSelfChat,
+				resolvedAccountId: account.accountId
+			};
+		}
+		if (access.decision === "block" && access.reason === "dmPolicy=disabled") {
+			logVerbose("Blocked dm (dmPolicy: disabled)");
+			return {
+				allowed: false,
+				shouldMarkRead: false,
+				isSelfChat,
+				resolvedAccountId: account.accountId
+			};
+		}
+		if (access.decision === "pairing" && !isSamePhone) {
+			const candidate = params.from;
+			if (suppressPairingReply) logVerbose(`Skipping pairing reply for historical DM from ${candidate}.`);
+			else {
+				const { code, created } = await upsertChannelPairingRequest({
+					channel: "whatsapp",
+					id: candidate,
+					accountId: account.accountId,
+					meta: { name: (params.pushName ?? "").trim() || void 0 }
+				});
+				if (created) {
+					logVerbose(`whatsapp pairing request sender=${candidate} name=${params.pushName ?? "unknown"}`);
+					try {
+						await params.sock.sendMessage(params.remoteJid, { text: buildPairingReply({
+							channel: "whatsapp",
+							idLine: `Your WhatsApp phone number: ${candidate}`,
+							code
+						}) });
+					} catch (err) {
+						logVerbose(`whatsapp pairing reply failed for ${candidate}: ${String(err)}`);
+					}
+				}
+			}
+			return {
+				allowed: false,
+				shouldMarkRead: false,
+				isSelfChat,
+				resolvedAccountId: account.accountId
+			};
+		}
+		if (access.decision !== "allow") {
+			logVerbose(`Blocked unauthorized sender ${params.from} (dmPolicy=${dmPolicy})`);
+			return {
+				allowed: false,
+				shouldMarkRead: false,
+				isSelfChat,
+				resolvedAccountId: account.accountId
+			};
+		}
+	}
+	return {
+		allowed: true,
+		shouldMarkRead: true,
+		isSelfChat,
+		resolvedAccountId: account.accountId
+	};
+}
+
+//#endregion
+//#region src/inbound/dedupe.ts
+const RECENT_WEB_MESSAGE_TTL_MS = 20 * 6e4;
+const RECENT_WEB_MESSAGE_MAX = 5e3;
+function createInboundDedupeCache() {
+	const cache = createDedupeCache({
+		ttlMs: RECENT_WEB_MESSAGE_TTL_MS,
+		maxSize: RECENT_WEB_MESSAGE_MAX
+	});
+	return { isRecent: (key) => cache.check(key) };
+}
+
+//#endregion
+//#region src/vcard.ts
+const ALLOWED_VCARD_KEYS = new Set([
+	"FN",
+	"N",
+	"TEL"
+]);
+function parseVcard(vcard) {
+	if (!vcard) return { phones: [] };
+	const lines = vcard.split(/\r?\n/);
+	let nameFromN;
+	let nameFromFn;
+	const phones = [];
+	for (const rawLine of lines) {
+		const line = rawLine.trim();
+		if (!line) continue;
+		const colonIndex = line.indexOf(":");
+		if (colonIndex === -1) continue;
+		const key = line.slice(0, colonIndex).toUpperCase();
+		const rawValue = line.slice(colonIndex + 1).trim();
+		if (!rawValue) continue;
+		const baseKey = normalizeVcardKey(key);
+		if (!baseKey || !ALLOWED_VCARD_KEYS.has(baseKey)) continue;
+		const value = cleanVcardValue(rawValue);
+		if (!value) continue;
+		if (baseKey === "FN" && !nameFromFn) {
+			nameFromFn = normalizeVcardName(value);
+			continue;
+		}
+		if (baseKey === "N" && !nameFromN) {
+			nameFromN = normalizeVcardName(value);
+			continue;
+		}
+		if (baseKey === "TEL") {
+			const phone = normalizeVcardPhone(value);
+			if (phone) phones.push(phone);
+		}
+	}
+	return {
+		name: nameFromFn ?? nameFromN,
+		phones
+	};
+}
+function normalizeVcardKey(key) {
+	const [primary] = key.split(";");
+	if (!primary) return;
+	const segments = primary.split(".");
+	return segments[segments.length - 1] || void 0;
+}
+function cleanVcardValue(value) {
+	return value.replace(/\\n/gi, " ").replace(/\\,/g, ",").replace(/\\;/g, ";").trim();
+}
+function normalizeVcardName(value) {
+	return value.replace(/;/g, " ").replace(/\s+/g, " ").trim();
+}
+function normalizeVcardPhone(value) {
+	const trimmed = value.trim();
+	if (!trimmed) return "";
+	if (trimmed.toLowerCase().startsWith("tel:")) return trimmed.slice(4).trim();
+	return trimmed;
+}
+
+//#endregion
+//#region src/inbound/extract.ts
+function unwrapMessage$1(message, utils) {
+	return utils.normalizeMessageContent(message);
+}
+function extractContextInfo(message, utils) {
+	if (!message) return;
+	const contentType = utils.getContentType(message);
+	const candidate = contentType ? message[contentType] : void 0;
+	const contextInfo = candidate && typeof candidate === "object" && "contextInfo" in candidate ? candidate.contextInfo : void 0;
+	if (contextInfo) return contextInfo;
+	const fallback = message.extendedTextMessage?.contextInfo ?? message.imageMessage?.contextInfo ?? message.videoMessage?.contextInfo ?? message.documentMessage?.contextInfo ?? message.audioMessage?.contextInfo ?? message.stickerMessage?.contextInfo ?? message.buttonsResponseMessage?.contextInfo ?? message.listResponseMessage?.contextInfo ?? message.templateButtonReplyMessage?.contextInfo ?? message.interactiveResponseMessage?.contextInfo ?? message.buttonsMessage?.contextInfo ?? message.listMessage?.contextInfo;
+	if (fallback) return fallback;
+	for (const value of Object.values(message)) {
+		if (!value || typeof value !== "object") continue;
+		if (!("contextInfo" in value)) continue;
+		const candidateContext = value.contextInfo;
+		if (candidateContext) return candidateContext;
+	}
+}
+function extractMentionedJids(utils, rawMessage) {
+	const message = unwrapMessage$1(rawMessage, utils);
+	if (!message) return;
+	const flattened = [
+		message.extendedTextMessage?.contextInfo?.mentionedJid,
+		message.extendedTextMessage?.contextInfo?.quotedMessage?.extendedTextMessage?.contextInfo?.mentionedJid,
+		message.imageMessage?.contextInfo?.mentionedJid,
+		message.videoMessage?.contextInfo?.mentionedJid,
+		message.documentMessage?.contextInfo?.mentionedJid,
+		message.audioMessage?.contextInfo?.mentionedJid,
+		message.stickerMessage?.contextInfo?.mentionedJid,
+		message.buttonsResponseMessage?.contextInfo?.mentionedJid,
+		message.listResponseMessage?.contextInfo?.mentionedJid
+	].flatMap((arr) => arr ?? []).filter(Boolean);
+	if (flattened.length === 0) return;
+	return Array.from(new Set(flattened));
+}
+function extractText(utils, rawMessage) {
+	const message = unwrapMessage$1(rawMessage, utils);
+	if (!message) return;
+	const extracted = utils.extractMessageContent(message);
+	const candidates = [message, extracted && extracted !== message ? extracted : void 0];
+	for (const candidate of candidates) {
+		if (!candidate) continue;
+		if (typeof candidate.conversation === "string" && candidate.conversation.trim()) return candidate.conversation.trim();
+		const extended = candidate.extendedTextMessage?.text;
+		if (extended?.trim()) return extended.trim();
+		const caption = candidate.imageMessage?.caption ?? candidate.videoMessage?.caption ?? candidate.documentMessage?.caption;
+		if (caption?.trim()) return caption.trim();
+	}
+	const contactPlaceholder = extractContactPlaceholder(utils, message) ?? (extracted && extracted !== message ? extractContactPlaceholder(utils, extracted) : void 0);
+	if (contactPlaceholder) return contactPlaceholder;
+}
+function extractMediaPlaceholder(utils, rawMessage) {
+	const message = unwrapMessage$1(rawMessage, utils);
+	if (!message) return;
+	if (message.imageMessage) return "<media:image>";
+	if (message.videoMessage) return "<media:video>";
+	if (message.audioMessage) return "<media:audio>";
+	if (message.documentMessage) return "<media:document>";
+	if (message.stickerMessage) return "<media:sticker>";
+}
+function extractContactPlaceholder(utils, rawMessage) {
+	const message = unwrapMessage$1(rawMessage, utils);
+	if (!message) return;
+	const contact = message.contactMessage ?? void 0;
+	if (contact) {
+		const { name, phones } = describeContact({
+			displayName: contact.displayName,
+			vcard: contact.vcard
+		});
+		return formatContactPlaceholder(name, phones);
+	}
+	const contactsArray = message.contactsArrayMessage?.contacts ?? void 0;
+	if (!contactsArray || contactsArray.length === 0) return;
+	return formatContactsPlaceholder(contactsArray.map((entry) => describeContact({
+		displayName: entry.displayName,
+		vcard: entry.vcard
+	})).map((entry) => formatContactLabel(entry.name, entry.phones)).filter((value) => Boolean(value)), contactsArray.length);
+}
+function describeContact(input) {
+	const displayName = (input.displayName ?? "").trim();
+	const parsed = parseVcard(input.vcard ?? void 0);
+	return {
+		name: displayName || parsed.name,
+		phones: parsed.phones
+	};
+}
+function formatContactPlaceholder(name, phones) {
+	const label = formatContactLabel(name, phones);
+	if (!label) return "<contact>";
+	return `<contact: ${label}>`;
+}
+function formatContactsPlaceholder(labels, total) {
+	const cleaned = labels.map((label) => label.trim()).filter(Boolean);
+	if (cleaned.length === 0) return `<contacts: ${total} ${total === 1 ? "contact" : "contacts"}>`;
+	const remaining = Math.max(total - cleaned.length, 0);
+	const suffix = remaining > 0 ? ` +${remaining} more` : "";
+	return `<contacts: ${cleaned.join(", ")}${suffix}>`;
+}
+function formatContactLabel(name, phones) {
+	const parts = [name, formatPhoneList(phones)].filter((value) => Boolean(value));
+	if (parts.length === 0) return;
+	return parts.join(", ");
+}
+function formatPhoneList(phones) {
+	const cleaned = phones?.map((phone) => phone.trim()).filter(Boolean) ?? [];
+	if (cleaned.length === 0) return;
+	const { shown, remaining } = summarizeList(cleaned, cleaned.length, 1);
+	const [primary] = shown;
+	if (!primary) return;
+	if (remaining === 0) return primary;
+	return `${primary} (+${remaining} more)`;
+}
+function summarizeList(values, total, maxShown) {
+	const shown = values.slice(0, maxShown);
+	return {
+		shown,
+		remaining: Math.max(total - shown.length, 0)
+	};
+}
+function extractLocationData(utils, rawMessage) {
+	const message = unwrapMessage$1(rawMessage, utils);
+	if (!message) return null;
+	const live = message.liveLocationMessage ?? void 0;
+	if (live) {
+		const latitudeRaw = live.degreesLatitude;
+		const longitudeRaw = live.degreesLongitude;
+		if (latitudeRaw != null && longitudeRaw != null) {
+			const latitude = Number(latitudeRaw);
+			const longitude = Number(longitudeRaw);
+			if (Number.isFinite(latitude) && Number.isFinite(longitude)) return {
+				latitude,
+				longitude,
+				accuracy: live.accuracyInMeters ?? void 0,
+				caption: live.caption ?? void 0,
+				source: "live",
+				isLive: true
+			};
+		}
+	}
+	const location = message.locationMessage ?? void 0;
+	if (location) {
+		const latitudeRaw = location.degreesLatitude;
+		const longitudeRaw = location.degreesLongitude;
+		if (latitudeRaw != null && longitudeRaw != null) {
+			const latitude = Number(latitudeRaw);
+			const longitude = Number(longitudeRaw);
+			if (Number.isFinite(latitude) && Number.isFinite(longitude)) {
+				const isLive = Boolean(location.isLive);
+				return {
+					latitude,
+					longitude,
+					accuracy: location.accuracyInMeters ?? void 0,
+					name: location.name ?? void 0,
+					address: location.address ?? void 0,
+					caption: location.comment ?? void 0,
+					source: isLive ? "live" : location.name || location.address ? "place" : "pin",
+					isLive
+				};
+			}
+		}
+	}
+	return null;
+}
+function describeReplyContext(utils, rawMessage) {
+	const message = unwrapMessage$1(rawMessage, utils);
+	if (!message) return null;
+	const contextInfo = extractContextInfo(message, utils);
+	const quoted = utils.normalizeMessageContent(contextInfo?.quotedMessage);
+	if (!quoted) return null;
+	const location = extractLocationData(utils, quoted);
+	const locationText = location ? formatLocationText(location) : void 0;
+	let body = [extractText(utils, quoted), locationText].filter(Boolean).join("\n").trim();
+	if (!body) body = extractMediaPlaceholder(utils, quoted);
+	if (!body) {
+		const quotedType = quoted ? utils.getContentType(quoted) : void 0;
+		logVerbose(`Quoted message missing extractable body${quotedType ? ` (type ${quotedType})` : ""}`);
+		return null;
+	}
+	const senderJid = contextInfo?.participant ?? void 0;
+	const senderE164 = senderJid ? jidToE164(senderJid) ?? senderJid : void 0;
+	const sender = senderE164 ?? "unknown sender";
+	return {
+		id: contextInfo?.stanzaId ? String(contextInfo.stanzaId) : void 0,
+		body,
+		sender,
+		senderJid,
+		senderE164
+	};
+}
+
+//#endregion
+//#region src/inbound/media.ts
+function unwrapMessage(message, normalizeMessageContent) {
+	return normalizeMessageContent(message);
+}
+function resolveMediaMimetype(message) {
+	const explicit = message.imageMessage?.mimetype ?? message.videoMessage?.mimetype ?? message.documentMessage?.mimetype ?? message.audioMessage?.mimetype ?? message.stickerMessage?.mimetype ?? void 0;
+	if (explicit) return explicit;
+	if (message.audioMessage) return "audio/ogg; codecs=opus";
+	if (message.imageMessage) return "image/jpeg";
+	if (message.videoMessage) return "video/mp4";
+	if (message.stickerMessage) return "image/webp";
+}
+async function downloadInboundMedia(msg, sock) {
+	const { downloadMediaMessage, normalizeMessageContent } = await getBaileys();
+	const message = unwrapMessage(msg.message, normalizeMessageContent);
+	if (!message) return;
+	const mimetype = resolveMediaMimetype(message);
+	const fileName = message.documentMessage?.fileName ?? void 0;
+	if (!message.imageMessage && !message.videoMessage && !message.documentMessage && !message.audioMessage && !message.stickerMessage) return;
+	try {
+		return {
+			buffer: await downloadMediaMessage(msg, "buffer", {}, {
+				reuploadRequest: sock.updateMediaMessage,
+				logger: sock.logger
+			}),
+			mimetype,
+			fileName
+		};
+	} catch (err) {
+		logVerbose(`downloadMediaMessage failed: ${String(err)}`);
+		return;
+	}
+}
+
+//#endregion
+//#region src/inbound/send-api.ts
+function recordWhatsAppOutbound(accountId) {
+	recordChannelActivity({
+		channel: "whatsapp",
+		accountId,
+		direction: "outbound"
+	});
+}
+function resolveOutboundMessageId(result) {
+	return typeof result === "object" && result && "key" in result ? String(result.key?.id ?? "unknown") : "unknown";
+}
+function createWebSendApi(params) {
+	return {
+		sendMessage: async (to, text, mediaBuffer, mediaType, sendOptions) => {
+			const jid = toWhatsappJid(to);
+			let payload;
+			if (mediaBuffer && mediaType) if (mediaType.startsWith("image/")) payload = {
+				image: mediaBuffer,
+				caption: text || void 0,
+				mimetype: mediaType
+			};
+			else if (mediaType.startsWith("audio/")) payload = {
+				audio: mediaBuffer,
+				ptt: true,
+				mimetype: mediaType
+			};
+			else if (mediaType.startsWith("video/")) {
+				const gifPlayback = sendOptions?.gifPlayback;
+				payload = {
+					video: mediaBuffer,
+					caption: text || void 0,
+					mimetype: mediaType,
+					...gifPlayback ? { gifPlayback: true } : {}
+				};
+			} else payload = {
+				document: mediaBuffer,
+				fileName: sendOptions?.fileName?.trim() || "file",
+				caption: text || void 0,
+				mimetype: mediaType
+			};
+			else payload = { text };
+			const result = await params.sock.sendMessage(jid, payload);
+			recordWhatsAppOutbound(sendOptions?.accountId ?? params.defaultAccountId);
+			if (mediaBuffer && mediaType?.startsWith("audio/") && text) await params.sock.sendMessage(jid, { text });
+			return { messageId: resolveOutboundMessageId(result) };
+		},
+		sendPoll: async (to, poll) => {
+			const jid = toWhatsappJid(to);
+			const result = await params.sock.sendMessage(jid, { poll: {
+				name: poll.question,
+				values: poll.options,
+				selectableCount: poll.maxSelections ?? 1
+			} });
+			recordWhatsAppOutbound(params.defaultAccountId);
+			return { messageId: resolveOutboundMessageId(result) };
+		},
+		sendReaction: async (chatJid, messageId, emoji, fromMe, participant) => {
+			const jid = toWhatsappJid(chatJid);
+			await params.sock.sendMessage(jid, { react: {
+				text: emoji,
+				key: {
+					remoteJid: jid,
+					id: messageId,
+					fromMe,
+					participant: participant ? toWhatsappJid(participant) : void 0
+				}
+			} });
+		},
+		sendComposingTo: async (to) => {
+			const jid = toWhatsappJid(to);
+			await params.sock.sendPresenceUpdate("composing", jid);
+		}
+	};
+}
+
+//#endregion
+//#region src/inbound/monitor.ts
+async function monitorWebInbox(options) {
+	const { isJidGroup, DisconnectReason, extractMessageContent, getContentType, normalizeMessageContent } = await getBaileys();
+	const messageUtils = {
+		extractMessageContent,
+		getContentType,
+		normalizeMessageContent
+	};
+	const inboundLogger = getChildLogger({ module: "web-inbound" });
+	const inboundConsoleLog = createSubsystemLogger("gateway/channels/whatsapp").child("inbound");
+	const sock = await createWaSocket(false, options.verbose, { authDir: options.authDir });
+	try {
+		await waitForWaConnection(sock);
+	} catch (err) {
+		try {
+			await closeWaSocket(sock);
+		} catch (closeErr) {
+			logVerbose(`Socket close failed after connection error: ${String(closeErr)}`);
+		}
+		throw err;
+	}
+	const connectedAtMs = Date.now();
+	const dedupeCache = createInboundDedupeCache();
+	let onCloseResolve = null;
+	const onClose = new Promise((resolve) => {
+		onCloseResolve = resolve;
+	});
+	const resolveClose = (reason) => {
+		if (!onCloseResolve) return;
+		const resolver = onCloseResolve;
+		onCloseResolve = null;
+		resolver(reason);
+	};
+	try {
+		await sock.sendPresenceUpdate("available");
+		if (shouldLogVerbose()) logVerbose("Sent global 'available' presence on connect");
+	} catch (err) {
+		logVerbose(`Failed to send 'available' presence on connect: ${String(err)}`);
+	}
+	const selfJid = sock.user?.id;
+	const selfE164 = selfJid ? await resolveJidToE164(selfJid, { authDir: options.authDir }) ?? null : null;
+	const debouncer = createInboundDebouncer({
+		debounceMs: options.debounceMs ?? 0,
+		buildKey: (msg) => {
+			const senderKey = msg.chatType === "group" ? msg.senderJid ?? msg.senderE164 ?? msg.senderName ?? msg.from : msg.from;
+			if (!senderKey) return null;
+			const conversationKey = msg.chatType === "group" ? msg.chatId : msg.from;
+			return `${msg.accountId}:${conversationKey}:${senderKey}`;
+		},
+		shouldDebounce: options.shouldDebounce,
+		onFlush: async (entries) => {
+			const last = entries.at(-1);
+			if (!last) return;
+			if (entries.length === 1) {
+				await options.onMessage(last);
+				return;
+			}
+			const mentioned = /* @__PURE__ */ new Set();
+			for (const entry of entries) for (const jid of entry.mentionedJids ?? []) mentioned.add(jid);
+			const combinedBody = entries.map((entry) => entry.body).filter(Boolean).join("\n");
+			const combinedMessage = {
+				...last,
+				body: combinedBody,
+				mentionedJids: mentioned.size > 0 ? Array.from(mentioned) : void 0
+			};
+			await options.onMessage(combinedMessage);
+		},
+		onError: (err) => {
+			inboundLogger.error("failed handling inbound web message", { error: String(err) });
+			inboundConsoleLog.error(`Failed handling inbound web message: ${String(err)}`);
+		}
+	});
+	const groupMetaCache = /* @__PURE__ */ new Map();
+	const GROUP_META_TTL_MS = 300 * 1e3;
+	const lidLookup = sock.signalRepository?.lidMapping;
+	const resolveInboundJid = async (jid) => resolveJidToE164(jid, {
+		authDir: options.authDir,
+		lidLookup
+	}) ?? null;
+	const getGroupMeta = async (jid) => {
+		const cached = groupMetaCache.get(jid);
+		if (cached && cached.expires > Date.now()) return cached;
+		try {
+			const meta = await sock.groupMetadata(jid);
+			const participants = (await Promise.all(meta.participants?.map(async (p) => {
+				return await resolveInboundJid(p.id) ?? p.id;
+			}) ?? [])).filter(Boolean) ?? [];
+			const entry = {
+				subject: meta.subject,
+				participants,
+				expires: Date.now() + GROUP_META_TTL_MS
+			};
+			groupMetaCache.set(jid, entry);
+			return entry;
+		} catch (err) {
+			logVerbose(`Failed to fetch group metadata for ${jid}: ${String(err)}`);
+			return { expires: Date.now() + GROUP_META_TTL_MS };
+		}
+	};
+	const normalizeInboundMessage = async (msg) => {
+		const id = msg.key?.id ?? void 0;
+		const remoteJid = msg.key?.remoteJid;
+		if (!remoteJid) return null;
+		if (remoteJid.endsWith("@status") || remoteJid.endsWith("@broadcast")) return null;
+		const group = isJidGroup(remoteJid) === true;
+		if (id) {
+			const dedupeKey = `${options.accountId}:${remoteJid}:${id}`;
+			if (dedupeCache.isRecent(dedupeKey)) return null;
+		}
+		const participantJid = msg.key?.participant ?? void 0;
+		const from = group ? remoteJid : await resolveInboundJid(remoteJid);
+		if (!from) return null;
+		const senderE164 = group ? participantJid ? await resolveInboundJid(participantJid) : null : from;
+		let groupSubject;
+		let groupParticipants;
+		if (group) {
+			const meta = await getGroupMeta(remoteJid);
+			groupSubject = meta.subject;
+			groupParticipants = meta.participants;
+		}
+		const messageTimestampMs = msg.messageTimestamp ? Number(msg.messageTimestamp) * 1e3 : void 0;
+		const access = await checkInboundAccessControl({
+			accountId: options.accountId,
+			from,
+			selfE164,
+			senderE164,
+			group,
+			pushName: msg.pushName ?? void 0,
+			isFromMe: Boolean(msg.key?.fromMe),
+			messageTimestampMs,
+			connectedAtMs,
+			sock: { sendMessage: (jid, content) => sock.sendMessage(jid, content) },
+			remoteJid
+		});
+		if (!access.allowed) return null;
+		return {
+			id,
+			remoteJid,
+			group,
+			participantJid,
+			from,
+			senderE164,
+			groupSubject,
+			groupParticipants,
+			messageTimestampMs,
+			access
+		};
+	};
+	const maybeMarkInboundAsRead = async (inbound) => {
+		const { id, remoteJid, participantJid, access } = inbound;
+		if (id && !access.isSelfChat && options.sendReadReceipts !== false) try {
+			await sock.readMessages([{
+				remoteJid,
+				id,
+				participant: participantJid,
+				fromMe: false
+			}]);
+			if (shouldLogVerbose()) logVerbose(`Marked message ${id} as read for ${remoteJid}${participantJid ? ` (participant ${participantJid})` : ""}`);
+		} catch (err) {
+			logVerbose(`Failed to mark message ${id} read: ${String(err)}`);
+		}
+		else if (id && access.isSelfChat && shouldLogVerbose()) logVerbose(`Self-chat mode: skipping read receipt for ${id}`);
+	};
+	const enrichInboundMessage = async (msg) => {
+		const location = extractLocationData(messageUtils, msg.message ?? void 0);
+		const locationText = location ? formatLocationText(location) : void 0;
+		let body = extractText(messageUtils, msg.message ?? void 0);
+		if (locationText) body = [body, locationText].filter(Boolean).join("\n").trim();
+		if (!body) {
+			body = extractMediaPlaceholder(messageUtils, msg.message ?? void 0);
+			if (!body) return null;
+		}
+		const replyContext = describeReplyContext(messageUtils, msg.message);
+		let mediaPath;
+		let mediaType;
+		let mediaFileName;
+		try {
+			const inboundMedia = await downloadInboundMedia(msg, sock);
+			if (inboundMedia) {
+				const maxBytes = (typeof options.mediaMaxMb === "number" && options.mediaMaxMb > 0 ? options.mediaMaxMb : 50) * 1024 * 1024;
+				const saved = await saveMediaBuffer(inboundMedia.buffer, inboundMedia.mimetype, "inbound", maxBytes, inboundMedia.fileName);
+				mediaPath = saved.path;
+				mediaType = saved.contentType ?? inboundMedia.mimetype;
+				mediaFileName = inboundMedia.fileName;
+			}
+		} catch (err) {
+			logVerbose(`Inbound media download failed: ${String(err)}`);
+		}
+		return {
+			body,
+			location: location ?? void 0,
+			replyContext,
+			mediaPath,
+			mediaType,
+			mediaFileName
+		};
+	};
+	const enqueueInboundMessage = async (msg, inbound, enriched) => {
+		const chatJid = inbound.remoteJid;
+		const sendComposing = async () => {
+			try {
+				await sock.sendPresenceUpdate("composing", chatJid);
+			} catch (err) {
+				logVerbose(`Presence update failed: ${String(err)}`);
+			}
+		};
+		const reply = async (text) => {
+			await sock.sendMessage(chatJid, { text });
+		};
+		const sendMedia = async (payload) => {
+			await sock.sendMessage(chatJid, payload);
+		};
+		const timestamp = inbound.messageTimestampMs;
+		const mentionedJids = extractMentionedJids(messageUtils, msg.message);
+		const senderName = msg.pushName ?? void 0;
+		inboundLogger.info("inbound message", {
+			from: inbound.from,
+			to: selfE164 ?? "me",
+			body: enriched.body,
+			mediaPath: enriched.mediaPath,
+			mediaType: enriched.mediaType,
+			mediaFileName: enriched.mediaFileName,
+			timestamp
+		});
+		const inboundMessage = {
+			id: inbound.id,
+			from: inbound.from,
+			conversationId: inbound.from,
+			to: selfE164 ?? "me",
+			accountId: inbound.access.resolvedAccountId,
+			body: enriched.body,
+			pushName: senderName,
+			timestamp,
+			chatType: inbound.group ? "group" : "direct",
+			chatId: inbound.remoteJid,
+			senderJid: inbound.participantJid,
+			senderE164: inbound.senderE164 ?? void 0,
+			senderName,
+			replyToId: enriched.replyContext?.id,
+			replyToBody: enriched.replyContext?.body,
+			replyToSender: enriched.replyContext?.sender,
+			replyToSenderJid: enriched.replyContext?.senderJid,
+			replyToSenderE164: enriched.replyContext?.senderE164,
+			groupSubject: inbound.groupSubject,
+			groupParticipants: inbound.groupParticipants,
+			mentionedJids: mentionedJids ?? void 0,
+			selfJid,
+			selfE164,
+			fromMe: Boolean(msg.key?.fromMe),
+			location: enriched.location ?? void 0,
+			sendComposing,
+			reply,
+			sendMedia,
+			mediaPath: enriched.mediaPath,
+			mediaType: enriched.mediaType,
+			mediaFileName: enriched.mediaFileName
+		};
+		try {
+			Promise.resolve(debouncer.enqueue(inboundMessage)).catch((err) => {
+				inboundLogger.error("failed handling inbound web message", { error: String(err) });
+				inboundConsoleLog.error(`Failed handling inbound web message: ${String(err)}`);
+			});
+		} catch (err) {
+			inboundLogger.error("failed handling inbound web message", { error: String(err) });
+			inboundConsoleLog.error(`Failed handling inbound web message: ${String(err)}`);
+		}
+	};
+	const handleMessagesUpsert = async (upsert) => {
+		if (upsert.type !== "notify" && upsert.type !== "append") return;
+		for (const msg of upsert.messages ?? []) {
+			recordChannelActivity({
+				channel: "whatsapp",
+				accountId: options.accountId,
+				direction: "inbound"
+			});
+			const inbound = await normalizeInboundMessage(msg);
+			if (!inbound) continue;
+			await maybeMarkInboundAsRead(inbound);
+			if (upsert.type === "append") continue;
+			const enriched = await enrichInboundMessage(msg);
+			if (!enriched) continue;
+			if (enriched.body === "<media:audio>" && enriched.mediaPath && enriched.mediaType?.startsWith("audio/")) try {
+				const cfg = loadConfig();
+				const audioConfig = cfg.tools?.media?.audio;
+				if (audioConfig && audioConfig.enabled !== false) {
+					const transcript = await transcribeFirstAudio({
+						ctx: {
+							MediaPaths: [enriched.mediaPath],
+							MediaTypes: enriched.mediaType ? [enriched.mediaType] : void 0
+						},
+						cfg,
+						agentDir: void 0
+					});
+					if (transcript) {
+						enriched.body = transcript;
+						enriched.mediaPath = void 0;
+						logVerbose(`whatsapp: transcribed voice note (${transcript.length} chars)`);
+					}
+				}
+			} catch (err) {
+				logVerbose(`whatsapp: voice note transcription failed: ${String(err)}`);
+			}
+			await enqueueInboundMessage(msg, inbound, enriched);
+		}
+	};
+	sock.ev.on("messages.upsert", handleMessagesUpsert);
+	const handleConnectionUpdate = (update) => {
+		try {
+			if (update.connection === "close") {
+				const status = getStatusCode(update.lastDisconnect?.error);
+				resolveClose({
+					status,
+					isLoggedOut: status === DisconnectReason.loggedOut,
+					error: update.lastDisconnect?.error
+				});
+			}
+		} catch (err) {
+			inboundLogger.error("connection.update handler error", { error: String(err) });
+			resolveClose({
+				status: void 0,
+				isLoggedOut: false,
+				error: err
+			});
+		}
+	};
+	sock.ev.on("connection.update", handleConnectionUpdate);
+	return {
+		close: async () => {
+			try {
+				const ev = sock.ev;
+				const messagesUpsertHandler = handleMessagesUpsert;
+				const connectionUpdateHandler = handleConnectionUpdate;
+				if (typeof ev.off === "function") {
+					ev.off("messages.upsert", messagesUpsertHandler);
+					ev.off("connection.update", connectionUpdateHandler);
+				} else if (typeof ev.removeListener === "function") {
+					ev.removeListener("messages.upsert", messagesUpsertHandler);
+					ev.removeListener("connection.update", connectionUpdateHandler);
+				}
+				try {
+					await closeWaSocket(sock);
+				} catch (err) {
+					logVerbose(`Socket close failed: ${String(err)}; retrying once`);
+					await closeWaSocket(sock);
+				}
+			} catch (err) {
+				logVerbose(`Socket close failed: ${String(err)}`);
+				throw err;
+			}
+		},
+		onClose,
+		signalClose: (reason) => {
+			resolveClose(reason ?? {
+				status: void 0,
+				isLoggedOut: false,
+				error: "closed"
+			});
+		},
+		...createWebSendApi({
+			sock: {
+				sendMessage: (jid, content) => sock.sendMessage(jid, content),
+				sendPresenceUpdate: (presence, jid) => sock.sendPresenceUpdate(presence, jid)
+			},
+			defaultAccountId: options.accountId
+		})
+	};
+}
+
+//#endregion
+//#region src/mentions.ts
+function buildMentionConfig(cfg, agentId) {
+	return {
+		mentionRegexes: buildMentionRegexes(cfg, agentId),
+		allowFrom: cfg.channels?.whatsapp?.allowFrom
+	};
+}
+function resolveMentionTargets(msg, authDir) {
+	const jidOptions = authDir ? { authDir } : void 0;
+	return {
+		normalizedMentions: msg.mentionedJids?.length ? msg.mentionedJids.map((jid) => jidToE164(jid, jidOptions) ?? jid).filter(Boolean) : [],
+		selfE164: msg.selfE164 ?? (msg.selfJid ? jidToE164(msg.selfJid, jidOptions) : null),
+		selfJid: msg.selfJid ? msg.selfJid.replace(/:\\d+/, "") : null
+	};
+}
+function isBotMentionedFromTargets(msg, mentionCfg, targets) {
+	const clean = (text) => normalizeMentionText(text);
+	const isSelfChat = isSelfChatMode(targets.selfE164, mentionCfg.allowFrom);
+	const hasMentions = (msg.mentionedJids?.length ?? 0) > 0;
+	if (hasMentions && !isSelfChat) {
+		if (targets.selfE164 && targets.normalizedMentions.includes(targets.selfE164)) return true;
+		if (targets.selfJid) {
+			if (targets.normalizedMentions.includes(targets.selfJid)) return true;
+		}
+		return false;
+	} else if (hasMentions && isSelfChat) {}
+	const bodyClean = clean(msg.body);
+	if (mentionCfg.mentionRegexes.some((re) => re.test(bodyClean))) return true;
+	if (targets.selfE164) {
+		const selfDigits = targets.selfE164.replace(/\D/g, "");
+		if (selfDigits) {
+			if (bodyClean.replace(/[^\d]/g, "").includes(selfDigits)) return true;
+			const bodyNoSpace = msg.body.replace(/[\s-]/g, "");
+			if (new RegExp(`\\+?${selfDigits}`, "i").test(bodyNoSpace)) return true;
+		}
+	}
+	return false;
+}
+function debugMention(msg, mentionCfg, authDir) {
+	const mentionTargets = resolveMentionTargets(msg, authDir);
+	return {
+		wasMentioned: isBotMentionedFromTargets(msg, mentionCfg, mentionTargets),
+		details: {
+			from: msg.from,
+			body: msg.body,
+			bodyClean: normalizeMentionText(msg.body),
+			mentionedJids: msg.mentionedJids ?? null,
+			normalizedMentionedJids: mentionTargets.normalizedMentions.length ? mentionTargets.normalizedMentions : null,
+			selfJid: msg.selfJid ?? null,
+			selfJidBare: mentionTargets.selfJid,
+			selfE164: msg.selfE164 ?? null,
+			resolvedSelfE164: mentionTargets.selfE164
+		}
+	};
+}
+function resolveOwnerList(mentionCfg, selfE164) {
+	const allowFrom = mentionCfg.allowFrom;
+	return (Array.isArray(allowFrom) && allowFrom.length > 0 ? allowFrom : selfE164 ? [selfE164] : []).filter((entry) => Boolean(entry && entry !== "*")).map((entry) => normalizeE164(entry)).filter((entry) => Boolean(entry));
+}
+
+//#endregion
+//#region src/monitor/echo.ts
+function createEchoTracker(params) {
+	const recentlySent = /* @__PURE__ */ new Set();
+	const maxItems = Math.max(1, params.maxItems ?? 100);
+	const buildCombinedKey = (p) => `combined:${p.sessionKey}:${p.combinedBody}`;
+	const trim = () => {
+		while (recentlySent.size > maxItems) {
+			const firstKey = recentlySent.values().next().value;
+			if (!firstKey) break;
+			recentlySent.delete(firstKey);
+		}
+	};
+	const rememberText = (text, opts) => {
+		if (!text) return;
+		recentlySent.add(text);
+		if (opts.combinedBody && opts.combinedBodySessionKey) recentlySent.add(buildCombinedKey({
+			sessionKey: opts.combinedBodySessionKey,
+			combinedBody: opts.combinedBody
+		}));
+		if (opts.logVerboseMessage) params.logVerbose?.(`Added to echo detection set (size now: ${recentlySent.size}): ${text.substring(0, 50)}...`);
+		trim();
+	};
+	return {
+		rememberText,
+		has: (key) => recentlySent.has(key),
+		forget: (key) => {
+			recentlySent.delete(key);
+		},
+		buildCombinedKey
+	};
+}
+
+//#endregion
+//#region src/monitor/broadcast.ts
+let _whatsappInboundLog$1;
+function getInboundLog$1() {
+	_whatsappInboundLog$1 ??= createSubsystemLogger("gateway/channels/whatsapp").child("inbound");
+	return _whatsappInboundLog$1;
+}
+async function maybeBroadcastMessage(params) {
+	const broadcastAgents = params.cfg.broadcast?.[params.peerId];
+	if (!broadcastAgents || !Array.isArray(broadcastAgents)) return false;
+	if (broadcastAgents.length === 0) return false;
+	const strategy = params.cfg.broadcast?.strategy || "parallel";
+	getInboundLog$1().info(`Broadcasting message to ${broadcastAgents.length} agents (${strategy})`);
+	const agentIds = params.cfg.agents?.list?.map((agent) => normalizeAgentId(agent.id));
+	const hasKnownAgents = (agentIds?.length ?? 0) > 0;
+	const groupHistorySnapshot = params.msg.chatType === "group" ? params.groupHistories.get(params.groupHistoryKey) ?? [] : void 0;
+	const processForAgent = async (agentId) => {
+		const normalizedAgentId = normalizeAgentId(agentId);
+		if (hasKnownAgents && !agentIds?.includes(normalizedAgentId)) {
+			getInboundLog$1().warn(`Broadcast agent ${agentId} not found in agents.list; skipping`);
+			return false;
+		}
+		const agentRoute = {
+			...params.route,
+			agentId: normalizedAgentId,
+			sessionKey: buildAgentSessionKey({
+				agentId: normalizedAgentId,
+				channel: "whatsapp",
+				accountId: params.route.accountId,
+				peer: {
+					kind: params.msg.chatType === "group" ? "group" : "direct",
+					id: params.peerId
+				},
+				dmScope: params.cfg.session?.dmScope,
+				identityLinks: params.cfg.session?.identityLinks
+			}),
+			mainSessionKey: buildAgentMainSessionKey({
+				agentId: normalizedAgentId,
+				mainKey: DEFAULT_MAIN_KEY
+			})
+		};
+		try {
+			return await params.processMessage(params.msg, agentRoute, params.groupHistoryKey, {
+				groupHistory: groupHistorySnapshot,
+				suppressGroupHistoryClear: true
+			});
+		} catch (err) {
+			getInboundLog$1().error(`Broadcast agent ${agentId} failed: ${formatError(err)}`);
+			return false;
+		}
+	};
+	if (strategy === "sequential") for (const agentId of broadcastAgents) await processForAgent(agentId);
+	else await Promise.allSettled(broadcastAgents.map(processForAgent));
+	if (params.msg.chatType === "group") params.groupHistories.set(params.groupHistoryKey, []);
+	return true;
+}
+
+//#endregion
+//#region src/monitor/commands.ts
+function stripMentionsForCommand(text, mentionRegexes, selfE164) {
+	let result = text;
+	for (const re of mentionRegexes) result = result.replace(re, " ");
+	if (selfE164) {
+		const digits = selfE164.replace(/\D/g, "");
+		if (digits) {
+			const pattern = new RegExp(`\\+?${digits}`, "g");
+			result = result.replace(pattern, " ");
+		}
+	}
+	return result.replace(/\s+/g, " ").trim();
+}
+
+//#endregion
+//#region src/monitor/group-activation.ts
+function resolveGroupPolicyFor(cfg, conversationId) {
+	const groupId = resolveGroupSessionKey({
+		From: conversationId,
+		ChatType: "group",
+		Provider: "whatsapp"
+	})?.id;
+	const whatsappCfg = cfg.channels?.whatsapp;
+	const hasGroupAllowFrom = Boolean(whatsappCfg?.groupAllowFrom?.length || whatsappCfg?.allowFrom?.length);
+	return resolveChannelGroupPolicy({
+		cfg,
+		channel: "whatsapp",
+		groupId: groupId ?? conversationId,
+		hasGroupAllowFrom
+	});
+}
+function resolveGroupRequireMentionFor(cfg, conversationId) {
+	const groupId = resolveGroupSessionKey({
+		From: conversationId,
+		ChatType: "group",
+		Provider: "whatsapp"
+	})?.id;
+	return resolveChannelGroupRequireMention({
+		cfg,
+		channel: "whatsapp",
+		groupId: groupId ?? conversationId
+	});
+}
+function resolveGroupActivationFor(params) {
+	const entry = loadSessionStore(resolveStorePath(params.cfg.session?.store, { agentId: params.agentId }))[params.sessionKey];
+	const defaultActivation = !resolveGroupRequireMentionFor(params.cfg, params.conversationId) ? "always" : "mention";
+	return normalizeGroupActivation(entry?.groupActivation) ?? defaultActivation;
+}
+
+//#endregion
+//#region src/monitor/group-members.ts
+function appendNormalizedUnique(entries, seen, ordered) {
+	for (const entry of entries) {
+		const normalized = normalizeE164(entry) ?? entry;
+		if (!normalized || seen.has(normalized)) continue;
+		seen.add(normalized);
+		ordered.push(normalized);
+	}
+}
+function noteGroupMember(groupMemberNames, conversationId, e164, name) {
+	if (!e164 || !name) return;
+	const key = normalizeE164(e164) ?? e164;
+	if (!key) return;
+	let roster = groupMemberNames.get(conversationId);
+	if (!roster) {
+		roster = /* @__PURE__ */ new Map();
+		groupMemberNames.set(conversationId, roster);
+	}
+	roster.set(key, name);
+}
+function formatGroupMembers(params) {
+	const { participants, roster, fallbackE164 } = params;
+	const seen = /* @__PURE__ */ new Set();
+	const ordered = [];
+	if (participants?.length) appendNormalizedUnique(participants, seen, ordered);
+	if (roster) appendNormalizedUnique(roster.keys(), seen, ordered);
+	if (ordered.length === 0 && fallbackE164) {
+		const normalized = normalizeE164(fallbackE164) ?? fallbackE164;
+		if (normalized) ordered.push(normalized);
+	}
+	if (ordered.length === 0) return;
+	return ordered.map((entry) => {
+		const name = roster?.get(entry);
+		return name ? `${name} (${entry})` : entry;
+	}).join(", ");
+}
+
+//#endregion
+//#region src/monitor/group-gating.ts
+function isOwnerSender(baseMentionConfig, msg) {
+	const sender = normalizeE164(msg.senderE164 ?? "");
+	if (!sender) return false;
+	return resolveOwnerList(baseMentionConfig, msg.selfE164 ?? void 0).includes(sender);
+}
+function recordPendingGroupHistoryEntry(params) {
+	const sender = params.msg.senderName && params.msg.senderE164 ? `${params.msg.senderName} (${params.msg.senderE164})` : params.msg.senderName ?? params.msg.senderE164 ?? "Unknown";
+	recordPendingHistoryEntryIfEnabled({
+		historyMap: params.groupHistories,
+		historyKey: params.groupHistoryKey,
+		limit: params.groupHistoryLimit,
+		entry: {
+			sender,
+			body: params.msg.body,
+			timestamp: params.msg.timestamp,
+			id: params.msg.id,
+			senderJid: params.msg.senderJid
+		}
+	});
+}
+function skipGroupMessageAndStoreHistory(params, verboseMessage) {
+	params.logVerbose(verboseMessage);
+	recordPendingGroupHistoryEntry({
+		msg: params.msg,
+		groupHistories: params.groupHistories,
+		groupHistoryKey: params.groupHistoryKey,
+		groupHistoryLimit: params.groupHistoryLimit
+	});
+	return { shouldProcess: false };
+}
+function applyGroupGating(params) {
+	const groupPolicy = resolveGroupPolicyFor(params.cfg, params.conversationId);
+	if (groupPolicy.allowlistEnabled && !groupPolicy.allowed) {
+		params.logVerbose(`Skipping group message ${params.conversationId} (not in allowlist)`);
+		return { shouldProcess: false };
+	}
+	noteGroupMember(params.groupMemberNames, params.groupHistoryKey, params.msg.senderE164, params.msg.senderName);
+	const mentionConfig = buildMentionConfig(params.cfg, params.agentId);
+	const commandBody = stripMentionsForCommand(params.msg.body, mentionConfig.mentionRegexes, params.msg.selfE164);
+	const activationCommand = parseActivationCommand(commandBody);
+	const owner = isOwnerSender(params.baseMentionConfig, params.msg);
+	const shouldBypassMention = owner && hasControlCommand(commandBody, params.cfg);
+	if (activationCommand.hasCommand && !owner) return skipGroupMessageAndStoreHistory(params, `Ignoring /activation from non-owner in group ${params.conversationId}`);
+	const mentionDebug = debugMention(params.msg, mentionConfig, params.authDir);
+	params.replyLogger.debug({
+		conversationId: params.conversationId,
+		wasMentioned: mentionDebug.wasMentioned,
+		...mentionDebug.details
+	}, "group mention debug");
+	const wasMentioned = mentionDebug.wasMentioned;
+	const requireMention = resolveGroupActivationFor({
+		cfg: params.cfg,
+		agentId: params.agentId,
+		sessionKey: params.sessionKey,
+		conversationId: params.conversationId
+	}) !== "always";
+	const selfJid = params.msg.selfJid?.replace(/:\d+/, "");
+	const replySenderJid = params.msg.replyToSenderJid?.replace(/:\d+/, "");
+	const selfE164 = params.msg.selfE164 ? normalizeE164(params.msg.selfE164) : null;
+	const replySenderE164 = params.msg.replyToSenderE164 ? normalizeE164(params.msg.replyToSenderE164) : null;
+	const mentionGate = resolveMentionGating({
+		requireMention,
+		canDetectMention: true,
+		wasMentioned,
+		implicitMention: Boolean(selfJid && replySenderJid && selfJid === replySenderJid || selfE164 && replySenderE164 && selfE164 === replySenderE164),
+		shouldBypassMention
+	});
+	params.msg.wasMentioned = mentionGate.effectiveWasMentioned;
+	if (!shouldBypassMention && requireMention && mentionGate.shouldSkip) return skipGroupMessageAndStoreHistory(params, `Group message stored for context (no mention detected) in ${params.conversationId}: ${params.msg.body}`);
+	return { shouldProcess: true };
+}
+
+//#endregion
+//#region src/monitor/last-route.ts
+function trackBackgroundTask(backgroundTasks, task) {
+	backgroundTasks.add(task);
+	task.finally(() => {
+		backgroundTasks.delete(task);
+	});
+}
+function updateLastRouteInBackground(params) {
+	const storePath = resolveStorePath(params.cfg.session?.store, { agentId: params.storeAgentId });
+	const task = updateLastRoute({
+		storePath,
+		sessionKey: params.sessionKey,
+		deliveryContext: {
+			channel: params.channel,
+			to: params.to,
+			accountId: params.accountId
+		},
+		ctx: params.ctx
+	}).catch((err) => {
+		params.warn({
+			error: formatError(err),
+			storePath,
+			sessionKey: params.sessionKey,
+			to: params.to
+		}, "failed updating last route");
+	});
+	trackBackgroundTask(params.backgroundTasks, task);
+}
+
+//#endregion
+//#region src/monitor/peer.ts
+function resolvePeerId(msg) {
+	if (msg.chatType === "group") return msg.conversationId ?? msg.from;
+	if (msg.senderE164) return normalizeE164(msg.senderE164) ?? msg.senderE164;
+	if (msg.from.includes("@")) return jidToE164(msg.from) ?? msg.from;
+	return normalizeE164(msg.from) ?? msg.from;
+}
+
+//#endregion
+//#region src/reconnect.ts
+const DEFAULT_HEARTBEAT_SECONDS = 60;
+const DEFAULT_RECONNECT_POLICY = {
+	initialMs: 2e3,
+	maxMs: 6e4,
+	factor: 1.8,
+	jitter: .25,
+	maxAttempts: 0
+};
+function clamp(value, min, max) {
+	return Math.min(Math.max(value, min), max);
+}
+function resolveHeartbeatSeconds(cfg, overrideSeconds) {
+	const cfgAny = cfg;
+	const candidate = overrideSeconds ?? (cfgAny.channels?.whatsapp)?.heartbeatSeconds ?? cfgAny.web?.heartbeatSeconds;
+	if (typeof candidate === "number" && candidate > 0) return candidate;
+	return DEFAULT_HEARTBEAT_SECONDS;
+}
+function resolveReconnectPolicy(cfg, overrides) {
+	const cfgAny = cfg;
+	const reconnectOverrides = (cfgAny.channels?.whatsapp)?.reconnect ?? cfgAny.web?.reconnect ?? {};
+	const merged = {
+		...DEFAULT_RECONNECT_POLICY,
+		...reconnectOverrides,
+		...overrides ?? {}
+	};
+	merged.initialMs = Math.max(250, merged.initialMs);
+	merged.maxMs = Math.max(merged.initialMs, merged.maxMs);
+	merged.factor = clamp(merged.factor, 1.1, 10);
+	merged.jitter = clamp(merged.jitter, 0, 1);
+	merged.maxAttempts = Math.max(0, Math.floor(merged.maxAttempts));
+	return merged;
+}
+function newConnectionId() {
+	return randomUUID();
+}
+
+//#endregion
+//#region src/util.ts
+function elide(text, limit = 400) {
+	if (!text) return text;
+	if (text.length <= limit) return text;
+	return `${text.slice(0, limit)}… (truncated ${text.length - limit} chars)`;
+}
+function isLikelyWhatsAppCryptoError(reason) {
+	const formatReason = (value) => {
+		if (value == null) return "";
+		if (typeof value === "string") return value;
+		if (value instanceof Error) return `${value.message}\n${value.stack ?? ""}`;
+		if (typeof value === "object") try {
+			return JSON.stringify(value);
+		} catch {
+			return Object.prototype.toString.call(value);
+		}
+		if (typeof value === "number") return String(value);
+		if (typeof value === "boolean") return String(value);
+		if (typeof value === "bigint") return String(value);
+		if (typeof value === "symbol") return value.description ?? value.toString();
+		if (typeof value === "function") return value.name ? `[function ${value.name}]` : "[function]";
+		return Object.prototype.toString.call(value);
+	};
+	const haystack = (reason instanceof Error ? `${reason.message}\n${reason.stack ?? ""}` : formatReason(reason)).toLowerCase();
+	if (!(haystack.includes("unsupported state or unable to authenticate data") || haystack.includes("bad mac"))) return false;
+	return haystack.includes("@whiskeysockets/baileys") || haystack.includes("baileys") || haystack.includes("noise-handler") || haystack.includes("aesdecryptgcm");
+}
+
+//#endregion
+//#region src/deliver-reply.ts
+let _whatsappOutboundLog$1;
+function getOutboundLog$1() {
+	_whatsappOutboundLog$1 ??= createSubsystemLogger("gateway/channels/whatsapp").child("outbound");
+	return _whatsappOutboundLog$1;
+}
+const REASONING_PREFIX = "reasoning:";
+function shouldSuppressReasoningReply(payload) {
+	if (payload.isReasoning === true) return true;
+	const text = payload.text;
+	if (typeof text !== "string") return false;
+	return text.trimStart().toLowerCase().startsWith(REASONING_PREFIX);
+}
+async function deliverWebReply(params) {
+	const { replyResult, msg, maxMediaBytes, textLimit, replyLogger, connectionId, skipLog } = params;
+	const replyStarted = Date.now();
+	if (shouldSuppressReasoningReply(replyResult)) {
+		getOutboundLog$1().debug(`Suppressed reasoning payload to ${msg.from}`);
+		return;
+	}
+	const tableMode = params.tableMode ?? "code";
+	const chunkMode = params.chunkMode ?? "length";
+	const pack = params.pack;
+	const textChunks = chunkMarkdownTextWithMode(markdownToWhatsApp(convertMarkdownTables(replyResult.text || "", tableMode)), textLimit, chunkMode, { pack });
+	const mediaList = replyResult.mediaUrls?.length ? replyResult.mediaUrls : replyResult.mediaUrl ? [replyResult.mediaUrl] : [];
+	const sendWithRetry = async (fn, label, maxAttempts = 3) => {
+		let lastErr;
+		for (let attempt = 1; attempt <= maxAttempts; attempt++) try {
+			return await fn();
+		} catch (err) {
+			lastErr = err;
+			const errText = formatError(err);
+			const isLast = attempt === maxAttempts;
+			if (!/closed|reset|timed\s*out|disconnect/i.test(errText) || isLast) throw err;
+			const backoffMs = 500 * attempt;
+			logVerbose(`Retrying ${label} to ${msg.from} after failure (${attempt}/${maxAttempts - 1}) in ${backoffMs}ms: ${errText}`);
+			await sleep(backoffMs);
+		}
+		throw lastErr;
+	};
+	if (mediaList.length === 0 && textChunks.length) {
+		const totalChunks = textChunks.length;
+		for (const [index, chunk] of textChunks.entries()) {
+			const chunkStarted = Date.now();
+			await sendWithRetry(() => msg.reply(chunk), "text");
+			if (!skipLog) {
+				const durationMs = Date.now() - chunkStarted;
+				getOutboundLog$1().debug(`Sent chunk ${index + 1}/${totalChunks} to ${msg.from} (${durationMs.toFixed(0)}ms)`);
+			}
+		}
+		replyLogger.info({
+			correlationId: msg.id ?? newConnectionId(),
+			connectionId: connectionId ?? null,
+			to: msg.from,
+			from: msg.to,
+			text: elide(replyResult.text, 240),
+			mediaUrl: null,
+			mediaSizeBytes: null,
+			mediaKind: null,
+			durationMs: Date.now() - replyStarted
+		}, "auto-reply sent (text)");
+		return;
+	}
+	const remainingText = [...textChunks];
+	for (const [index, mediaUrl] of mediaList.entries()) {
+		const caption = index === 0 ? remainingText.shift() || void 0 : void 0;
+		try {
+			const media = await loadWebMedia(mediaUrl, {
+				maxBytes: maxMediaBytes,
+				localRoots: params.mediaLocalRoots
+			});
+			if (shouldLogVerbose()) {
+				logVerbose(`Web auto-reply media size: ${(media.buffer.length / (1024 * 1024)).toFixed(2)}MB`);
+				logVerbose(`Web auto-reply media source: ${mediaUrl} (kind ${media.kind})`);
+			}
+			if (media.kind === "image") await sendWithRetry(() => msg.sendMedia({
+				image: media.buffer,
+				caption,
+				mimetype: media.contentType
+			}), "media:image");
+			else if (media.kind === "audio") {
+				await sendWithRetry(() => msg.sendMedia({
+					audio: media.buffer,
+					ptt: true,
+					mimetype: media.contentType
+				}), "media:audio");
+				if (caption) await sendWithRetry(() => msg.reply(caption), "text");
+			} else if (media.kind === "video") await sendWithRetry(() => msg.sendMedia({
+				video: media.buffer,
+				caption,
+				mimetype: media.contentType
+			}), "media:video");
+			else {
+				const fileName = media.fileName ?? mediaUrl.split("/").pop() ?? "file";
+				const mimetype = media.contentType ?? "application/octet-stream";
+				await sendWithRetry(() => msg.sendMedia({
+					document: media.buffer,
+					fileName,
+					caption,
+					mimetype
+				}), "media:document");
+			}
+			getOutboundLog$1().info(`Sent media reply to ${msg.from} (${(media.buffer.length / (1024 * 1024)).toFixed(2)}MB)`);
+			replyLogger.info({
+				correlationId: msg.id ?? newConnectionId(),
+				connectionId: connectionId ?? null,
+				to: msg.from,
+				from: msg.to,
+				text: caption ?? null,
+				mediaUrl,
+				mediaSizeBytes: media.buffer.length,
+				mediaKind: media.kind,
+				durationMs: Date.now() - replyStarted
+			}, "auto-reply sent (media)");
+		} catch (err) {
+			getOutboundLog$1().error(`Failed sending web media to ${msg.from}: ${formatError(err)}`);
+			replyLogger.warn({
+				err,
+				mediaUrl
+			}, "failed to send web media reply");
+			if (index === 0) {
+				const warning = err instanceof Error ? `⚠️ Media failed: ${err.message}` : "⚠️ Media failed.";
+				const fallbackText = [remainingText.shift() ?? caption ?? "", warning].filter(Boolean).join("\n");
+				if (fallbackText) {
+					getOutboundLog$1().warn(`Media skipped; sent text-only to ${msg.from}`);
+					await msg.reply(fallbackText);
+				}
+			}
+		}
+	}
+	for (const chunk of remainingText) await msg.reply(chunk);
+}
+
+//#endregion
+//#region src/monitor/ack-reaction.ts
+function maybeSendAckReaction(params) {
+	if (!params.msg.id) return;
+	const ackConfig = params.cfg.channels?.whatsapp?.ackReaction;
+	const emoji = (ackConfig?.emoji ?? "").trim();
+	const directEnabled = ackConfig?.direct ?? true;
+	const groupMode = ackConfig?.group ?? "mentions";
+	const conversationIdForCheck = params.msg.conversationId ?? params.msg.from;
+	const activation = params.msg.chatType === "group" ? resolveGroupActivationFor({
+		cfg: params.cfg,
+		agentId: params.agentId,
+		sessionKey: params.sessionKey,
+		conversationId: conversationIdForCheck
+	}) : null;
+	const shouldSendReaction = () => shouldAckReactionForWhatsApp({
+		emoji,
+		isDirect: params.msg.chatType === "direct",
+		isGroup: params.msg.chatType === "group",
+		directEnabled,
+		groupMode,
+		wasMentioned: params.msg.wasMentioned === true,
+		groupActivated: activation === "always"
+	});
+	if (!shouldSendReaction()) return;
+	params.info({
+		chatId: params.msg.chatId,
+		messageId: params.msg.id,
+		emoji
+	}, "sending ack reaction");
+	sendReactionWhatsApp(params.msg.chatId, params.msg.id, emoji, {
+		verbose: params.verbose,
+		fromMe: false,
+		participant: params.msg.senderJid,
+		accountId: params.accountId
+	}).catch((err) => {
+		params.warn({
+			error: formatError(err),
+			chatId: params.msg.chatId,
+			messageId: params.msg.id
+		}, "failed to send ack reaction");
+		logVerbose(`WhatsApp ack reaction failed for chat ${params.msg.chatId}: ${formatError(err)}`);
+	});
+}
+
+//#endregion
+//#region src/monitor/message-line.ts
+function formatReplyContext(msg) {
+	if (!msg.replyToBody) return null;
+	return `[Replying to ${msg.replyToSender ?? "unknown sender"}${msg.replyToId ? ` id:${msg.replyToId}` : ""}]\n${msg.replyToBody}\n[/Replying]`;
+}
+function buildInboundLine(params) {
+	const { cfg, msg, agentId, previousTimestamp, envelope } = params;
+	const messagePrefix = resolveMessagePrefix(cfg, agentId, {
+		configured: cfg.channels?.whatsapp?.messagePrefix,
+		hasAllowFrom: (cfg.channels?.whatsapp?.allowFrom?.length ?? 0) > 0
+	});
+	const prefixStr = messagePrefix ? `${messagePrefix} ` : "";
+	const replyContext = formatReplyContext(msg);
+	const baseLine = `${prefixStr}${msg.body}${replyContext ? `\n\n${replyContext}` : ""}`;
+	return formatInboundEnvelope({
+		channel: "WhatsApp",
+		from: msg.chatType === "group" ? msg.from : msg.from?.replace(/^whatsapp:/, ""),
+		timestamp: msg.timestamp,
+		body: baseLine,
+		chatType: msg.chatType,
+		sender: {
+			name: msg.senderName,
+			e164: msg.senderE164,
+			id: msg.senderJid
+		},
+		previousTimestamp,
+		envelope,
+		fromMe: msg.fromMe
+	});
+}
+
+//#endregion
+//#region src/monitor/process-message.ts
+let _whatsappInboundLog;
+let _whatsappOutboundLog;
+function getInboundLog() {
+	_whatsappInboundLog ??= createSubsystemLogger("gateway/channels/whatsapp").child("inbound");
+	return _whatsappInboundLog;
+}
+function getOutboundLog() {
+	_whatsappOutboundLog ??= createSubsystemLogger("gateway/channels/whatsapp").child("outbound");
+	return _whatsappOutboundLog;
+}
+async function resolveWhatsAppCommandAuthorized(params) {
+	const useAccessGroups = params.cfg.commands?.useAccessGroups !== false;
+	if (!useAccessGroups) return true;
+	const isGroup = params.msg.chatType === "group";
+	const senderE164 = normalizeE164(isGroup ? params.msg.senderE164 ?? "" : params.msg.senderE164 ?? params.msg.from ?? "");
+	if (!senderE164) return false;
+	const account = resolveWhatsAppAccount$1({
+		cfg: params.cfg,
+		accountId: params.msg.accountId
+	});
+	const dmPolicy = account.dmPolicy ?? "pairing";
+	const groupPolicy = account.groupPolicy ?? "allowlist";
+	const configuredAllowFrom = account.allowFrom ?? [];
+	const configuredGroupAllowFrom = account.groupAllowFrom ?? (configuredAllowFrom.length > 0 ? configuredAllowFrom : void 0);
+	const storeAllowFrom = isGroup ? [] : await readStoreAllowFromForDmPolicy({
+		provider: "whatsapp",
+		accountId: params.msg.accountId,
+		dmPolicy
+	});
+	return resolveDmGroupAccessWithCommandGate({
+		isGroup,
+		dmPolicy,
+		groupPolicy,
+		allowFrom: configuredAllowFrom.length > 0 ? configuredAllowFrom : params.msg.selfE164 ? [params.msg.selfE164] : [],
+		groupAllowFrom: configuredGroupAllowFrom,
+		storeAllowFrom,
+		isSenderAllowed: (allowEntries) => {
+			if (allowEntries.includes("*")) return true;
+			return allowEntries.map((entry) => normalizeE164(String(entry))).filter((entry) => Boolean(entry)).includes(senderE164);
+		},
+		command: {
+			useAccessGroups,
+			allowTextCommands: true,
+			hasControlCommand: true
+		}
+	}).commandAuthorized;
+}
+function resolvePinnedMainDmRecipient(params) {
+	const account = resolveWhatsAppAccount$1({
+		cfg: params.cfg,
+		accountId: params.msg.accountId
+	});
+	return resolvePinnedMainDmOwnerFromAllowlist({
+		dmScope: params.cfg.session?.dmScope,
+		allowFrom: account.allowFrom,
+		normalizeEntry: (entry) => normalizeE164(entry)
+	});
+}
+async function processMessage(params) {
+	const conversationId = params.msg.conversationId ?? params.msg.from;
+	const { storePath, envelopeOptions, previousTimestamp } = resolveInboundSessionEnvelopeContext({
+		cfg: params.cfg,
+		agentId: params.route.agentId,
+		sessionKey: params.route.sessionKey
+	});
+	let combinedBody = buildInboundLine({
+		cfg: params.cfg,
+		msg: params.msg,
+		agentId: params.route.agentId,
+		previousTimestamp,
+		envelope: envelopeOptions
+	});
+	let shouldClearGroupHistory = false;
+	if (params.msg.chatType === "group") {
+		const history = params.groupHistory ?? params.groupHistories.get(params.groupHistoryKey) ?? [];
+		if (history.length > 0) combinedBody = buildHistoryContextFromEntries({
+			entries: history.map((m) => ({
+				sender: m.sender,
+				body: m.body,
+				timestamp: m.timestamp
+			})),
+			currentMessage: combinedBody,
+			excludeLast: false,
+			formatEntry: (entry) => {
+				return formatInboundEnvelope({
+					channel: "WhatsApp",
+					from: conversationId,
+					timestamp: entry.timestamp,
+					body: entry.body,
+					chatType: "group",
+					senderLabel: entry.sender,
+					envelope: envelopeOptions
+				});
+			}
+		});
+		shouldClearGroupHistory = !(params.suppressGroupHistoryClear ?? false);
+	}
+	const combinedEchoKey = params.buildCombinedEchoKey({
+		sessionKey: params.route.sessionKey,
+		combinedBody
+	});
+	if (params.echoHas(combinedEchoKey)) {
+		logVerbose("Skipping auto-reply: detected echo for combined message");
+		params.echoForget(combinedEchoKey);
+		return false;
+	}
+	maybeSendAckReaction({
+		cfg: params.cfg,
+		msg: params.msg,
+		agentId: params.route.agentId,
+		sessionKey: params.route.sessionKey,
+		conversationId,
+		verbose: params.verbose,
+		accountId: params.route.accountId,
+		info: params.replyLogger.info.bind(params.replyLogger),
+		warn: params.replyLogger.warn.bind(params.replyLogger)
+	});
+	const correlationId = params.msg.id ?? newConnectionId();
+	params.replyLogger.info({
+		connectionId: params.connectionId,
+		correlationId,
+		from: params.msg.chatType === "group" ? conversationId : params.msg.from,
+		to: params.msg.to,
+		body: elide(combinedBody, 240),
+		mediaType: params.msg.mediaType ?? null,
+		mediaPath: params.msg.mediaPath ?? null
+	}, "inbound web message");
+	const fromDisplay = params.msg.chatType === "group" ? conversationId : params.msg.from;
+	const kindLabel = params.msg.mediaType ? `, ${params.msg.mediaType}` : "";
+	getInboundLog().info(`Inbound message ${fromDisplay} -> ${params.msg.to} (${params.msg.chatType}${kindLabel}, ${combinedBody.length} chars)`);
+	if (shouldLogVerbose()) getInboundLog().debug(`Inbound body: ${elide(combinedBody, 400)}`);
+	const dmRouteTarget = params.msg.chatType !== "group" ? (() => {
+		if (params.msg.senderE164) return normalizeE164(params.msg.senderE164);
+		if (params.msg.from.includes("@")) return jidToE164(params.msg.from);
+		return normalizeE164(params.msg.from);
+	})() : void 0;
+	const textLimit = params.maxMediaTextChunkLimit ?? resolveTextChunkLimit(params.cfg, "whatsapp");
+	const chunkMode = resolveChunkMode(params.cfg, "whatsapp", params.route.accountId);
+	const pack = resolveChunkNewlinePacking(params.cfg, "whatsapp", params.route.accountId);
+	const tableMode = resolveMarkdownTableMode({
+		cfg: params.cfg,
+		channel: "whatsapp",
+		accountId: params.route.accountId
+	});
+	const mediaLocalRoots = getAgentScopedMediaLocalRoots(params.cfg, params.route.agentId);
+	let didLogHeartbeatStrip = false;
+	let didSendReply = false;
+	const commandAuthorized = shouldComputeCommandAuthorized(params.msg.body, params.cfg) ? await resolveWhatsAppCommandAuthorized({
+		cfg: params.cfg,
+		msg: params.msg
+	}) : void 0;
+	const configuredResponsePrefix = params.cfg.messages?.responsePrefix;
+	const { onModelSelected, ...prefixOptions } = createReplyPrefixOptions({
+		cfg: params.cfg,
+		agentId: params.route.agentId,
+		channel: "whatsapp",
+		accountId: params.route.accountId
+	});
+	const isSelfChat = params.msg.chatType !== "group" && Boolean(params.msg.selfE164) && normalizeE164(params.msg.from) === normalizeE164(params.msg.selfE164 ?? "");
+	const responsePrefix = prefixOptions.responsePrefix ?? (configuredResponsePrefix === void 0 && isSelfChat ? resolveIdentityNamePrefix(params.cfg, params.route.agentId) ?? "[openclaw]" : void 0);
+	const inboundHistory = params.msg.chatType === "group" ? (params.groupHistory ?? params.groupHistories.get(params.groupHistoryKey) ?? []).map((entry) => ({
+		sender: entry.sender,
+		body: entry.body,
+		timestamp: entry.timestamp
+	})) : void 0;
+	const ctxPayload = finalizeInboundContext({
+		Body: combinedBody,
+		BodyForAgent: params.msg.body,
+		InboundHistory: inboundHistory,
+		RawBody: params.msg.body,
+		CommandBody: params.msg.body,
+		From: params.msg.from,
+		To: params.msg.to,
+		SessionKey: params.route.sessionKey,
+		AccountId: params.route.accountId,
+		MessageSid: params.msg.id,
+		ReplyToId: params.msg.replyToId,
+		ReplyToBody: params.msg.replyToBody,
+		ReplyToSender: params.msg.replyToSender,
+		MediaPath: params.msg.mediaPath,
+		MediaUrl: params.msg.mediaUrl,
+		MediaType: params.msg.mediaType,
+		ChatType: params.msg.chatType,
+		ConversationLabel: params.msg.chatType === "group" ? conversationId : params.msg.from,
+		GroupSubject: params.msg.groupSubject,
+		GroupMembers: formatGroupMembers({
+			participants: params.msg.groupParticipants,
+			roster: params.groupMemberNames.get(params.groupHistoryKey),
+			fallbackE164: params.msg.senderE164
+		}),
+		SenderName: params.msg.senderName,
+		SenderId: params.msg.senderJid?.trim() || params.msg.senderE164,
+		SenderE164: params.msg.senderE164,
+		CommandAuthorized: commandAuthorized,
+		WasMentioned: params.msg.wasMentioned,
+		...params.msg.location ? toLocationContext(params.msg.location) : {},
+		Provider: "whatsapp",
+		Surface: "whatsapp",
+		OriginatingChannel: "whatsapp",
+		OriginatingTo: params.msg.from
+	});
+	const pinnedMainDmRecipient = resolvePinnedMainDmRecipient({
+		cfg: params.cfg,
+		msg: params.msg
+	});
+	const shouldUpdateMainLastRoute = !pinnedMainDmRecipient || pinnedMainDmRecipient === dmRouteTarget;
+	if (dmRouteTarget && params.route.sessionKey === params.route.mainSessionKey && shouldUpdateMainLastRoute) updateLastRouteInBackground({
+		cfg: params.cfg,
+		backgroundTasks: params.backgroundTasks,
+		storeAgentId: params.route.agentId,
+		sessionKey: params.route.mainSessionKey,
+		channel: "whatsapp",
+		to: dmRouteTarget,
+		accountId: params.route.accountId,
+		ctx: ctxPayload,
+		warn: params.replyLogger.warn.bind(params.replyLogger)
+	});
+	else if (dmRouteTarget && params.route.sessionKey === params.route.mainSessionKey && pinnedMainDmRecipient) logVerbose(`Skipping main-session last route update for ${dmRouteTarget} (pinned owner ${pinnedMainDmRecipient})`);
+	const metaTask = recordSessionMetaFromInbound({
+		storePath,
+		sessionKey: params.route.sessionKey,
+		ctx: ctxPayload
+	}).catch((err) => {
+		params.replyLogger.warn({
+			error: formatError(err),
+			storePath,
+			sessionKey: params.route.sessionKey
+		}, "failed updating session meta");
+	});
+	trackBackgroundTask(params.backgroundTasks, metaTask);
+	const { queuedFinal } = await dispatchReplyWithBufferedBlockDispatcher({
+		ctx: ctxPayload,
+		cfg: params.cfg,
+		replyResolver: params.replyResolver,
+		dispatcherOptions: {
+			...prefixOptions,
+			responsePrefix,
+			onHeartbeatStrip: () => {
+				if (!didLogHeartbeatStrip) {
+					didLogHeartbeatStrip = true;
+					logVerbose("Stripped stray HEARTBEAT_OK token from web reply");
+				}
+			},
+			deliver: async (payload, info) => {
+				if (info.kind !== "final") return;
+				await deliverWebReply({
+					replyResult: payload,
+					msg: params.msg,
+					mediaLocalRoots,
+					maxMediaBytes: params.maxMediaBytes,
+					textLimit,
+					chunkMode,
+					pack,
+					replyLogger: params.replyLogger,
+					connectionId: params.connectionId,
+					skipLog: false,
+					tableMode
+				});
+				didSendReply = true;
+				const shouldLog = payload.text ? true : void 0;
+				params.rememberSentText(payload.text, {
+					combinedBody,
+					combinedBodySessionKey: params.route.sessionKey,
+					logVerboseMessage: shouldLog
+				});
+				const fromDisplay = params.msg.chatType === "group" ? conversationId : params.msg.from ?? "unknown";
+				const hasMedia = Boolean(payload.mediaUrl || payload.mediaUrls?.length);
+				getOutboundLog().info(`Auto-replied to ${fromDisplay}${hasMedia ? " (media)" : ""}`);
+				if (shouldLogVerbose()) {
+					const preview = payload.text != null ? elide(payload.text, 400) : "<media>";
+					getOutboundLog().debug(`Reply body: ${preview}${hasMedia ? " (media)" : ""}`);
+				}
+			},
+			onError: (err, info) => {
+				const label = info.kind === "tool" ? "tool update" : info.kind === "block" ? "block update" : "auto-reply";
+				getOutboundLog().error(`Failed sending web ${label} to ${params.msg.from ?? conversationId}: ${formatError(err)}`);
+			},
+			onReplyStart: params.msg.sendComposing
+		},
+		replyOptions: {
+			disableBlockStreaming: true,
+			onModelSelected
+		}
+	});
+	if (!queuedFinal) {
+		if (shouldClearGroupHistory) params.groupHistories.set(params.groupHistoryKey, []);
+		logVerbose("Skipping auto-reply: silent token or no text/media returned from resolver");
+		return false;
+	}
+	if (shouldClearGroupHistory) params.groupHistories.set(params.groupHistoryKey, []);
+	return didSendReply;
+}
+
+//#endregion
+//#region src/monitor/on-message.ts
+function createWebOnMessageHandler(params) {
+	const processForRoute = async (msg, route, groupHistoryKey, opts) => processMessage({
+		cfg: params.cfg,
+		msg,
+		route,
+		groupHistoryKey,
+		groupHistories: params.groupHistories,
+		groupMemberNames: params.groupMemberNames,
+		connectionId: params.connectionId,
+		verbose: params.verbose,
+		maxMediaBytes: params.maxMediaBytes,
+		replyResolver: params.replyResolver,
+		replyLogger: params.replyLogger,
+		backgroundTasks: params.backgroundTasks,
+		rememberSentText: params.echoTracker.rememberText,
+		echoHas: params.echoTracker.has,
+		echoForget: params.echoTracker.forget,
+		buildCombinedEchoKey: params.echoTracker.buildCombinedKey,
+		groupHistory: opts?.groupHistory,
+		suppressGroupHistoryClear: opts?.suppressGroupHistoryClear
+	});
+	return async (msg) => {
+		const conversationId = msg.conversationId ?? msg.from;
+		const peerId = resolvePeerId(msg);
+		const route = resolveAgentRoute({
+			cfg: loadConfig(),
+			channel: "whatsapp",
+			accountId: msg.accountId,
+			peer: {
+				kind: msg.chatType === "group" ? "group" : "direct",
+				id: peerId
+			}
+		});
+		const groupHistoryKey = msg.chatType === "group" ? buildGroupHistoryKey({
+			channel: "whatsapp",
+			accountId: route.accountId,
+			peerKind: "group",
+			peerId
+		}) : route.sessionKey;
+		if (msg.from === msg.to) logVerbose(`\u{1F4F1} Same-phone mode detected (from === to: ${msg.from})`);
+		if (params.echoTracker.has(msg.body)) {
+			logVerbose("Skipping auto-reply: detected echo (message matches recently sent text)");
+			params.echoTracker.forget(msg.body);
+			return;
+		}
+		if (msg.chatType === "group") {
+			const metaCtx = {
+				From: msg.from,
+				To: msg.to,
+				SessionKey: route.sessionKey,
+				AccountId: route.accountId,
+				ChatType: msg.chatType,
+				ConversationLabel: conversationId,
+				GroupSubject: msg.groupSubject,
+				SenderName: msg.senderName,
+				SenderId: msg.senderJid?.trim() || msg.senderE164,
+				SenderE164: msg.senderE164,
+				Provider: "whatsapp",
+				Surface: "whatsapp",
+				OriginatingChannel: "whatsapp",
+				OriginatingTo: conversationId
+			};
+			updateLastRouteInBackground({
+				cfg: params.cfg,
+				backgroundTasks: params.backgroundTasks,
+				storeAgentId: route.agentId,
+				sessionKey: route.sessionKey,
+				channel: "whatsapp",
+				to: conversationId,
+				accountId: route.accountId,
+				ctx: metaCtx,
+				warn: params.replyLogger.warn.bind(params.replyLogger)
+			});
+			if (!applyGroupGating({
+				cfg: params.cfg,
+				msg,
+				conversationId,
+				groupHistoryKey,
+				agentId: route.agentId,
+				sessionKey: route.sessionKey,
+				baseMentionConfig: params.baseMentionConfig,
+				authDir: params.account.authDir,
+				groupHistories: params.groupHistories,
+				groupHistoryLimit: params.groupHistoryLimit,
+				groupMemberNames: params.groupMemberNames,
+				logVerbose,
+				replyLogger: params.replyLogger
+			}).shouldProcess) return;
+		} else if (!msg.senderE164 && peerId && peerId.startsWith("+")) msg.senderE164 = normalizeE164(peerId) ?? msg.senderE164;
+		if (await maybeBroadcastMessage({
+			cfg: params.cfg,
+			msg,
+			peerId,
+			route,
+			groupHistoryKey,
+			groupHistories: params.groupHistories,
+			processMessage: processForRoute
+		})) return;
+		await processForRoute(msg, route, groupHistoryKey);
+	};
+}
+
+//#endregion
+//#region src/monitor.ts
+function isNonRetryableWebCloseStatus(statusCode) {
+	return statusCode === 440;
+}
+async function monitorWebChannel(verbose, listenerFactory = monitorWebInbox, keepAlive = true, replyResolver = getReplyFromConfig, runtime = defaultRuntime, abortSignal, tuning = {}) {
+	const runId = newConnectionId();
+	const replyLogger = getChildLogger({
+		module: "web-auto-reply",
+		runId
+	});
+	const heartbeatLogger = getChildLogger({
+		module: "web-heartbeat",
+		runId
+	});
+	const reconnectLogger = getChildLogger({
+		module: "web-reconnect",
+		runId
+	});
+	const status = {
+		running: true,
+		connected: false,
+		reconnectAttempts: 0,
+		lastConnectedAt: null,
+		lastDisconnect: null,
+		lastMessageAt: null,
+		lastEventAt: null,
+		lastError: null
+	};
+	const emitStatus = () => {
+		tuning.statusSink?.({
+			...status,
+			lastDisconnect: status.lastDisconnect ? { ...status.lastDisconnect } : null
+		});
+	};
+	emitStatus();
+	const baseCfg = loadConfig();
+	const account = resolveWhatsAppAccount({
+		cfg: baseCfg,
+		accountId: tuning.accountId
+	});
+	const cfg = {
+		...baseCfg,
+		channels: {
+			...baseCfg.channels,
+			whatsapp: {
+				...baseCfg.channels?.whatsapp,
+				ackReaction: account.ackReaction,
+				messagePrefix: account.messagePrefix,
+				allowFrom: account.allowFrom,
+				groupAllowFrom: account.groupAllowFrom,
+				groupPolicy: account.groupPolicy,
+				textChunkLimit: account.textChunkLimit,
+				chunkMode: account.chunkMode,
+				mediaMaxMb: account.mediaMaxMb,
+				blockStreaming: account.blockStreaming,
+				groups: account.groups
+			}
+		}
+	};
+	const configuredMaxMb = cfg.agents?.defaults?.mediaMaxMb;
+	const maxMediaBytes = typeof configuredMaxMb === "number" && configuredMaxMb > 0 ? configuredMaxMb * 1024 * 1024 : DEFAULT_WEB_MEDIA_BYTES;
+	const heartbeatSeconds = resolveHeartbeatSeconds(cfg, tuning.heartbeatSeconds);
+	const reconnectPolicy = resolveReconnectPolicy(cfg, tuning.reconnect);
+	const baseMentionConfig = buildMentionConfig(cfg);
+	const groupHistoryLimit = cfg.channels?.whatsapp?.accounts?.[tuning.accountId ?? ""]?.historyLimit ?? cfg.channels?.whatsapp?.historyLimit ?? cfg.messages?.groupChat?.historyLimit ?? DEFAULT_GROUP_HISTORY_LIMIT ?? 20;
+	const groupHistories = /* @__PURE__ */ new Map();
+	const groupMemberNames = /* @__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 abortPromise = abortSignal && new Promise((resolve) => abortSignal.addEventListener("abort", () => resolve("aborted"), { once: true }));
+	const currentMaxListeners = process.getMaxListeners?.() ?? 10;
+	if (process.setMaxListeners && currentMaxListeners < 50) process.setMaxListeners(50);
+	let sigintStop = false;
+	const handleSigint = () => {
+		sigintStop = true;
+	};
+	process.once("SIGINT", handleSigint);
+	let reconnectAttempts = 0;
+	try {
+		while (true) {
+			if (stopRequested()) break;
+			const connectionId = newConnectionId();
+			const startedAt = Date.now();
+			let heartbeat = null;
+			let watchdogTimer = null;
+			let lastMessageAt = null;
+			let handledMessages = 0;
+			let unregisterUnhandled = null;
+			let isClosing = false;
+			const MESSAGE_TIMEOUT_MS = tuning.messageTimeoutMs ?? 1800 * 1e3;
+			const WATCHDOG_CHECK_MS = tuning.watchdogCheckMs ?? 60 * 1e3;
+			const backgroundTasks = /* @__PURE__ */ new Set();
+			const onMessage = createWebOnMessageHandler({
+				cfg,
+				verbose,
+				connectionId,
+				maxMediaBytes,
+				groupHistoryLimit,
+				groupHistories,
+				groupMemberNames,
+				echoTracker,
+				backgroundTasks,
+				replyResolver: replyResolver ?? getReplyFromConfig,
+				replyLogger,
+				baseMentionConfig,
+				account
+			});
+			const inboundDebounceMs = resolveInboundDebounceMs({
+				cfg,
+				channel: "whatsapp"
+			});
+			const shouldDebounce = (msg) => {
+				if (msg.mediaPath || msg.mediaType) return false;
+				if (msg.location) return false;
+				if (msg.replyToId || msg.replyToBody) return false;
+				return !hasControlCommand(msg.body, cfg);
+			};
+			const listener = await (listenerFactory ?? monitorWebInbox)({
+				verbose,
+				accountId: account.accountId,
+				authDir: account.authDir,
+				mediaMaxMb: account.mediaMaxMb,
+				sendReadReceipts: account.sendReadReceipts,
+				debounceMs: inboundDebounceMs,
+				shouldDebounce,
+				onMessage: async (msg) => {
+					handledMessages += 1;
+					lastMessageAt = Date.now();
+					status.lastMessageAt = lastMessageAt;
+					status.lastEventAt = lastMessageAt;
+					emitStatus();
+					await onMessage(msg);
+				}
+			});
+			status.connected = true;
+			status.lastConnectedAt = Date.now();
+			status.lastEventAt = status.lastConnectedAt;
+			status.lastError = null;
+			emitStatus();
+			const { e164: selfE164 } = readWebSelfId(account.authDir);
+			const connectRoute = resolveAgentRoute({
+				cfg,
+				channel: "whatsapp",
+				accountId: account.accountId
+			});
+			enqueueSystemEvent(`WhatsApp gateway connected${selfE164 ? ` as ${selfE164}` : ""}.`, { sessionKey: connectRoute.sessionKey });
+			setActiveWebListener(account.accountId, listener);
+			unregisterUnhandled = registerUnhandledRejectionHandler((reason) => {
+				if (!isLikelyWhatsAppCryptoError(reason)) return false;
+				const errorStr = formatError(reason);
+				reconnectLogger.warn("web reconnect: unhandled rejection from WhatsApp socket; forcing reconnect", {
+					connectionId,
+					error: errorStr
+				});
+				listener.signalClose?.({
+					status: 499,
+					isLoggedOut: false,
+					error: reason
+				});
+				return true;
+			});
+			const closeListener = async () => {
+				isClosing = true;
+				if (unregisterUnhandled) {
+					unregisterUnhandled();
+					unregisterUnhandled = null;
+				}
+				if (heartbeat) clearInterval(heartbeat);
+				if (watchdogTimer) clearInterval(watchdogTimer);
+				if (backgroundTasks.size > 0) {
+					const drainTimeout = new Promise((r) => setTimeout(r, 1e4).unref());
+					await Promise.race([Promise.allSettled(backgroundTasks), drainTimeout]);
+					backgroundTasks.clear();
+				}
+				setActiveWebListener(account.accountId, null);
+				try {
+					await listener.close();
+				} catch (err) {
+					if (getActiveWebListener(account.accountId) === null) setActiveWebListener(account.accountId, listener);
+					logVerbose(`Socket close failed: ${formatError(err)}`);
+					throw err;
+				}
+			};
+			if (keepAlive) {
+				heartbeat = setInterval(() => {
+					const authAgeMs = getWebAuthAgeMs(account.authDir);
+					const minutesSinceLastMessage = lastMessageAt ? Math.floor((Date.now() - lastMessageAt) / 6e4) : null;
+					const logData = {
+						connectionId,
+						reconnectAttempts,
+						messagesHandled: handledMessages,
+						lastMessageAt,
+						authAgeMs,
+						uptimeMs: Date.now() - startedAt,
+						...minutesSinceLastMessage !== null && minutesSinceLastMessage > 30 ? { minutesSinceLastMessage } : {}
+					};
+					if (minutesSinceLastMessage && minutesSinceLastMessage > 30) heartbeatLogger.warn("⚠️ web gateway heartbeat - no messages in 30+ minutes", logData);
+					else heartbeatLogger.info("web gateway heartbeat", logData);
+				}, heartbeatSeconds * 1e3);
+				watchdogTimer = setInterval(() => {
+					if (isClosing) return;
+					if (!lastMessageAt) return;
+					const timeSinceLastMessage = Date.now() - lastMessageAt;
+					if (timeSinceLastMessage <= MESSAGE_TIMEOUT_MS) return;
+					const minutesSinceLastMessage = Math.floor(timeSinceLastMessage / 6e4);
+					heartbeatLogger.warn("Message timeout detected - forcing reconnect", {
+						connectionId,
+						minutesSinceLastMessage,
+						lastMessageAt: new Date(lastMessageAt),
+						messagesHandled: handledMessages
+					});
+					whatsappHeartbeatLog.warn(`No messages received in ${minutesSinceLastMessage}m - restarting connection`);
+					closeListener().catch((err) => {
+						logVerbose(`Close listener failed: ${formatError(err)}`);
+					});
+				}, WATCHDOG_CHECK_MS);
+			}
+			whatsappLog.info("Listening for personal WhatsApp inbound messages.");
+			if (process.stdout.isTTY || process.stderr.isTTY) whatsappLog.raw("Ctrl+C to stop.");
+			if (!keepAlive) {
+				await closeListener();
+				process.removeListener("SIGINT", handleSigint);
+				return;
+			}
+			const reason = await Promise.race([listener.onClose?.catch((err) => {
+				reconnectLogger.error("listener.onClose rejected", { error: formatError(err) });
+				return {
+					status: 500,
+					isLoggedOut: false,
+					error: err
+				};
+			}) ?? waitForever(), abortPromise ?? waitForever()]);
+			if (Date.now() - startedAt > Math.max(heartbeatSeconds * 1e3, 300 * 1e3)) reconnectAttempts = 0;
+			status.reconnectAttempts = reconnectAttempts;
+			emitStatus();
+			if (stopRequested() || sigintStop || reason === "aborted") {
+				await closeListener();
+				break;
+			}
+			const statusCode = (typeof reason === "object" && reason && "status" in reason ? reason.status : void 0) ?? "unknown";
+			const loggedOut = typeof reason === "object" && reason && "isLoggedOut" in reason && reason.isLoggedOut;
+			const errorStr = formatError(reason);
+			status.connected = false;
+			status.lastEventAt = Date.now();
+			status.lastDisconnect = {
+				at: status.lastEventAt,
+				status: typeof statusCode === "number" ? statusCode : void 0,
+				error: errorStr,
+				loggedOut: Boolean(loggedOut)
+			};
+			status.lastError = errorStr;
+			status.reconnectAttempts = reconnectAttempts;
+			emitStatus();
+			reconnectLogger.info("web reconnect: connection closed", {
+				connectionId,
+				status: statusCode,
+				loggedOut,
+				reconnectAttempts,
+				error: errorStr
+			});
+			enqueueSystemEvent(`WhatsApp gateway disconnected (status ${statusCode ?? "unknown"})`, { sessionKey: connectRoute.sessionKey });
+			if (loggedOut) {
+				runtime.error(`WhatsApp session logged out. Run \`${formatCliCommand("openclaw channels login --channel web")}\` to relink.`);
+				await closeListener();
+				break;
+			}
+			if (isNonRetryableWebCloseStatus(statusCode)) {
+				reconnectLogger.warn("web reconnect: non-retryable close status; stopping monitor", {
+					connectionId,
+					status: statusCode,
+					error: errorStr
+				});
+				runtime.error(`WhatsApp Web connection closed (status ${statusCode}: session conflict). Resolve conflicting WhatsApp Web sessions, then relink with \`${formatCliCommand("openclaw channels login --channel web")}\`. Stopping web monitoring.`);
+				await closeListener();
+				break;
+			}
+			reconnectAttempts += 1;
+			status.reconnectAttempts = reconnectAttempts;
+			emitStatus();
+			if (reconnectPolicy.maxAttempts > 0 && reconnectAttempts >= reconnectPolicy.maxAttempts) {
+				reconnectLogger.warn("web reconnect: max attempts reached; continuing in degraded mode", {
+					connectionId,
+					status: statusCode,
+					reconnectAttempts,
+					maxAttempts: reconnectPolicy.maxAttempts
+				});
+				runtime.error(`WhatsApp Web reconnect: max attempts reached (${reconnectAttempts}/${reconnectPolicy.maxAttempts}). Stopping web monitoring.`);
+				await closeListener();
+				break;
+			}
+			const delay = computeBackoff(reconnectPolicy, reconnectAttempts);
+			reconnectLogger.info("web reconnect: scheduling retry", {
+				connectionId,
+				status: statusCode,
+				reconnectAttempts,
+				maxAttempts: reconnectPolicy.maxAttempts || "unlimited",
+				delayMs: delay
+			});
+			runtime.error(`WhatsApp Web connection closed (status ${statusCode}). Retry ${reconnectAttempts}/${reconnectPolicy.maxAttempts || "∞"} in ${formatDurationPrecise(delay)}… (${errorStr})`);
+			try {
+				await closeListener();
+			} catch (closeErr) {
+				logVerbose(`Socket close failed on reconnect: ${formatError(closeErr)}`);
+			}
+			try {
+				await sleep(delay, abortSignal);
+			} catch {
+				break;
+			}
+		}
+	} finally {
+		status.running = false;
+		status.connected = false;
+		status.lastEventAt = Date.now();
+		emitStatus();
+		process.removeListener("SIGINT", handleSigint);
+	}
+}
+
+//#endregion
+//#region src/onboarding.ts
+const channel = "whatsapp";
+function setWhatsAppDmPolicy(cfg, dmPolicy) {
+	return mergeWhatsAppConfig(cfg, { dmPolicy });
+}
+function setWhatsAppAllowFrom(cfg, allowFrom) {
+	return mergeWhatsAppConfig(cfg, { allowFrom }, { unsetOnUndefined: ["allowFrom"] });
+}
+function setWhatsAppSelfChatMode(cfg, selfChatMode) {
+	return mergeWhatsAppConfig(cfg, { selfChatMode });
+}
+async function detectWhatsAppLinked(cfg, accountId) {
+	const { authDir } = resolveWhatsAppAuthDir({
+		cfg,
+		accountId
+	});
+	return await pathExists(path.join(authDir, "creds.json"));
+}
+async function promptWhatsAppOwnerAllowFrom(params) {
+	const { prompter, existingAllowFrom } = params;
+	await prompter.note("We need the sender/owner number so WednesdayAI can allowlist you.", "WhatsApp number");
+	const entry = await prompter.text({
+		message: "Your personal WhatsApp number (the phone you will message from)",
+		placeholder: "+15555550123",
+		initialValue: existingAllowFrom[0],
+		validate: (value) => {
+			const raw = String(value ?? "").trim();
+			if (!raw) return "Required";
+			if (!normalizeE164(raw)) return `Invalid number: ${raw}`;
+		}
+	});
+	const normalized = normalizeE164(String(entry).trim());
+	if (!normalized) throw new Error("Invalid WhatsApp owner number (expected E.164 after validation).");
+	return {
+		normalized,
+		allowFrom: normalizeAllowFromEntries([...existingAllowFrom.filter((item) => item !== "*"), normalized], normalizeE164)
+	};
+}
+async function applyWhatsAppOwnerAllowlist(params) {
+	const { normalized, allowFrom } = await promptWhatsAppOwnerAllowFrom({
+		prompter: params.prompter,
+		existingAllowFrom: params.existingAllowFrom
+	});
+	let next = setWhatsAppSelfChatMode(params.cfg, true);
+	next = setWhatsAppDmPolicy(next, "allowlist");
+	next = setWhatsAppAllowFrom(next, allowFrom);
+	await params.prompter.note([...params.messageLines, `- allowFrom includes ${normalized}`].join("\n"), params.title);
+	return next;
+}
+function parseWhatsAppAllowFromEntries(raw) {
+	const parts = splitOnboardingEntries(raw);
+	if (parts.length === 0) return { entries: [] };
+	const entries = [];
+	for (const part of parts) {
+		if (part === "*") {
+			entries.push("*");
+			continue;
+		}
+		const normalized = normalizeE164(part);
+		if (!normalized) return {
+			entries: [],
+			invalidEntry: part
+		};
+		entries.push(normalized);
+	}
+	return { entries: normalizeAllowFromEntries(entries, normalizeE164) };
+}
+async function promptWhatsAppAllowFrom(cfg, _runtime, prompter, options) {
+	const existingPolicy = cfg.channels?.whatsapp?.dmPolicy ?? "pairing";
+	const existingAllowFrom = cfg.channels?.whatsapp?.allowFrom ?? [];
+	const existingLabel = existingAllowFrom.length > 0 ? existingAllowFrom.join(", ") : "unset";
+	if (options?.forceAllowlist) return await applyWhatsAppOwnerAllowlist({
+		cfg,
+		prompter,
+		existingAllowFrom,
+		title: "WhatsApp allowlist",
+		messageLines: ["Allowlist mode enabled."]
+	});
+	await prompter.note([
+		"WhatsApp direct chats are gated by `channels.whatsapp.dmPolicy` + `channels.whatsapp.allowFrom`.",
+		"- pairing (default): unknown senders get a pairing code; owner approves",
+		"- allowlist: unknown senders are blocked",
+		"- open: public inbound DMs (requires allowFrom to include \"*\")",
+		"- disabled: ignore WhatsApp DMs",
+		"",
+		`Current: dmPolicy=${existingPolicy}, allowFrom=${existingLabel}`,
+		`Docs: ${formatDocsLink("/whatsapp", "whatsapp")}`
+	].join("\n"), "WhatsApp DM access");
+	if (await prompter.select({
+		message: "WhatsApp phone setup",
+		options: [{
+			value: "personal",
+			label: "This is my personal phone number"
+		}, {
+			value: "separate",
+			label: "Separate phone just for WednesdayAI"
+		}]
+	}) === "personal") return await applyWhatsAppOwnerAllowlist({
+		cfg,
+		prompter,
+		existingAllowFrom,
+		title: "WhatsApp personal phone",
+		messageLines: ["Personal phone mode enabled.", "- dmPolicy set to allowlist (pairing skipped)"]
+	});
+	const policy = await prompter.select({
+		message: "WhatsApp DM policy",
+		options: [
+			{
+				value: "pairing",
+				label: "Pairing (recommended)"
+			},
+			{
+				value: "allowlist",
+				label: "Allowlist only (block unknown senders)"
+			},
+			{
+				value: "open",
+				label: "Open (public inbound DMs)"
+			},
+			{
+				value: "disabled",
+				label: "Disabled (ignore WhatsApp DMs)"
+			}
+		]
+	});
+	let next = setWhatsAppSelfChatMode(cfg, false);
+	next = setWhatsAppDmPolicy(next, policy);
+	if (policy === "open") {
+		const allowFrom = normalizeAllowFromEntries(["*", ...existingAllowFrom], normalizeE164);
+		next = setWhatsAppAllowFrom(next, allowFrom.length > 0 ? allowFrom : ["*"]);
+		return next;
+	}
+	if (policy === "disabled") return next;
+	const allowOptions = existingAllowFrom.length > 0 ? [
+		{
+			value: "keep",
+			label: "Keep current allowFrom"
+		},
+		{
+			value: "unset",
+			label: "Unset allowFrom (use pairing approvals only)"
+		},
+		{
+			value: "list",
+			label: "Set allowFrom to specific numbers"
+		}
+	] : [{
+		value: "unset",
+		label: "Unset allowFrom (default)"
+	}, {
+		value: "list",
+		label: "Set allowFrom to specific numbers"
+	}];
+	const mode = await prompter.select({
+		message: "WhatsApp allowFrom (optional pre-allowlist)",
+		options: allowOptions.map((opt) => ({
+			value: opt.value,
+			label: opt.label
+		}))
+	});
+	if (mode === "keep") {} else if (mode === "unset") next = setWhatsAppAllowFrom(next, void 0);
+	else {
+		const allowRaw = await prompter.text({
+			message: "Allowed sender numbers (comma-separated, E.164)",
+			placeholder: "+15555550123, +447700900123",
+			validate: (value) => {
+				const raw = String(value ?? "").trim();
+				if (!raw) return "Required";
+				const parsed = parseWhatsAppAllowFromEntries(raw);
+				if (parsed.entries.length === 0 && !parsed.invalidEntry) return "Required";
+				if (parsed.invalidEntry) return `Invalid number: ${parsed.invalidEntry}`;
+			}
+		});
+		const parsed = parseWhatsAppAllowFromEntries(String(allowRaw));
+		next = setWhatsAppAllowFrom(next, parsed.entries);
+	}
+	return next;
+}
+const whatsappOnboardingAdapter = {
+	channel,
+	getStatus: async ({ cfg, accountOverrides }) => {
+		const defaultAccountId = resolveDefaultWhatsAppAccountId(cfg);
+		const accountId = resolveOnboardingAccountId({
+			accountId: accountOverrides.whatsapp,
+			defaultAccountId
+		});
+		const linked = await detectWhatsAppLinked(cfg, accountId);
+		return {
+			channel,
+			configured: linked,
+			statusLines: [`WhatsApp (${accountId === DEFAULT_ACCOUNT_ID ? "default" : accountId}): ${linked ? "linked" : "not linked"}`],
+			selectionHint: linked ? "linked" : "not linked",
+			quickstartScore: linked ? 5 : 4
+		};
+	},
+	configure: async ({ cfg, runtime, prompter, options, accountOverrides, shouldPromptAccountIds, forceAllowFrom }) => {
+		const accountId = await resolveAccountIdForConfigure({
+			cfg,
+			prompter,
+			label: "WhatsApp",
+			accountOverride: accountOverrides.whatsapp,
+			shouldPromptAccountIds: Boolean(shouldPromptAccountIds || options?.promptWhatsAppAccountId),
+			listAccountIds: listWhatsAppAccountIds,
+			defaultAccountId: resolveDefaultWhatsAppAccountId(cfg)
+		});
+		let next = cfg;
+		if (accountId !== DEFAULT_ACCOUNT_ID) next = {
+			...next,
+			channels: {
+				...next.channels,
+				whatsapp: {
+					...next.channels?.whatsapp,
+					accounts: {
+						...next.channels?.whatsapp?.accounts,
+						[accountId]: {
+							...next.channels?.whatsapp?.accounts?.[accountId],
+							enabled: next.channels?.whatsapp?.accounts?.[accountId]?.enabled ?? true
+						}
+					}
+				}
+			}
+		};
+		const linked = await detectWhatsAppLinked(next, accountId);
+		const { authDir } = resolveWhatsAppAuthDir({
+			cfg: next,
+			accountId
+		});
+		if (!linked) await prompter.note([
+			"Scan the QR with WhatsApp on your phone.",
+			`Credentials are stored under ${authDir}/ for future runs.`,
+			`Docs: ${formatDocsLink("/whatsapp", "whatsapp")}`
+		].join("\n"), "WhatsApp linking");
+		if (await prompter.confirm({
+			message: linked ? "WhatsApp already linked. Re-link now?" : "Link WhatsApp now (QR)?",
+			initialValue: !linked
+		})) try {
+			await loginWeb(false, void 0, runtime, accountId);
+		} catch (err) {
+			runtime.error(`WhatsApp login failed: ${String(err)}`);
+			await prompter.note(`Docs: ${formatDocsLink("/whatsapp", "whatsapp")}`, "WhatsApp help");
+		}
+		else if (!linked) await prompter.note(`Run \`${formatCliCommand("openclaw channels login")}\` later to link WhatsApp.`, "WhatsApp");
+		next = await promptWhatsAppAllowFrom(next, runtime, prompter, { forceAllowlist: forceAllowFrom });
+		return {
+			cfg: next,
+			accountId
+		};
+	},
+	onAccountRecorded: (accountId, options) => {
+		options?.onWhatsAppAccountId?.(accountId);
+	}
+};
+
+//#endregion
+//#region src/outbound-adapter.ts
+function stripWhatsAppLeadingBlankLines(text) {
+	return text.replace(/^(?:[ \t]*\r?\n)+/, "");
+}
+function createWhatsAppOutboundBase(deps) {
+	return {
+		deliveryMode: "gateway",
+		chunker: deps.chunker,
+		chunkerMode: "text",
+		textChunkLimit: 4e3,
+		pollMaxOptions: 12,
+		resolveTarget: deps.resolveTarget,
+		sendText: async ({ to, text, accountId, deps: callDeps, gifPlayback }) => {
+			return {
+				channel: "whatsapp",
+				...await (callDeps?.sendWhatsApp ?? deps.sendMessageWhatsApp)(to, text, {
+					verbose: false,
+					accountId: accountId ?? void 0,
+					gifPlayback
+				})
+			};
+		},
+		sendMedia: async ({ to, text, mediaUrl, mediaLocalRoots, accountId, deps: callDeps, gifPlayback }) => {
+			return {
+				channel: "whatsapp",
+				...await (callDeps?.sendWhatsApp ?? deps.sendMessageWhatsApp)(to, text, {
+					verbose: false,
+					mediaUrl,
+					mediaLocalRoots,
+					accountId: accountId ?? void 0,
+					gifPlayback
+				})
+			};
+		},
+		sendPoll: async ({ to, poll, accountId }) => await deps.sendPollWhatsApp(to, poll, {
+			verbose: deps.shouldLogVerbose(),
+			accountId: accountId ?? void 0
+		}),
+		normalizePayload: ({ payload }) => ({
+			...payload,
+			text: stripWhatsAppLeadingBlankLines(payload.text ?? "")
+		})
+	};
+}
+const whatsappOutbound = createWhatsAppOutboundBase({
+	chunker: (text, limit) => getWhatsAppRuntime().channel.text.chunkText(text, limit),
+	sendMessageWhatsApp,
+	sendPollWhatsApp,
+	shouldLogVerbose: () => getWhatsAppRuntime().logging.shouldLogVerbose(),
+	resolveTarget: ({ to, allowFrom, mode }) => resolveWhatsAppOutboundTarget({
+		to,
+		allowFrom,
+		mode
+	})
+});
+
+//#endregion
+//#region src/shared.ts
+const WHATSAPP_GROUP_INTRO_HINT = "WhatsApp IDs: SenderId is the participant JID (group participant id).";
+function resolveWhatsAppGroupIntroHint() {
+	return WHATSAPP_GROUP_INTRO_HINT;
+}
+function resolveWhatsAppMentionStripPatterns(ctx) {
+	const selfE164 = (ctx.To ?? "").replace(/^whatsapp:/, "");
+	if (!selfE164) return [];
+	const escaped = escapeRegExp$1(selfE164);
+	return [escaped, `@${escaped}`];
+}
+
+//#endregion
+//#region src/status.ts
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asString(value) {
+	return typeof value === "string" ? value.trim() : "";
+}
+function readWhatsAppAccountStatus(value) {
+	if (!isRecord(value)) return null;
+	return {
+		accountId: value.accountId,
+		enabled: value.enabled,
+		linked: value.linked,
+		connected: value.connected,
+		running: value.running,
+		reconnectAttempts: value.reconnectAttempts,
+		lastError: value.lastError
+	};
+}
+function resolveAccountId(account) {
+	return typeof account.accountId === "string" && account.accountId.trim() ? account.accountId.trim() : "default";
+}
+function collectWhatsAppStatusIssues(accounts) {
+	const issues = [];
+	for (const rawAccount of accounts) {
+		const account = readWhatsAppAccountStatus(rawAccount);
+		if (!account || account.enabled === false) continue;
+		const accountId = resolveAccountId(account);
+		const linked = account.linked === true;
+		const running = account.running === true;
+		const connected = account.connected === true;
+		const reconnectAttempts = typeof account.reconnectAttempts === "number" ? account.reconnectAttempts : null;
+		const lastError = asString(account.lastError);
+		if (!linked) {
+			issues.push({
+				channel: "whatsapp",
+				accountId,
+				kind: "auth",
+				message: "Not linked (no WhatsApp Web session).",
+				fix: `Run: ${formatCliCommand("openclaw channels login")} (scan QR on the gateway host).`
+			});
+			continue;
+		}
+		if (running && !connected) issues.push({
+			channel: "whatsapp",
+			accountId,
+			kind: "runtime",
+			message: `Linked but disconnected${reconnectAttempts != null ? ` (reconnectAttempts=${reconnectAttempts})` : ""}${lastError ? `: ${lastError}` : "."}`,
+			fix: `Run: ${formatCliCommand("openclaw doctor")} (or restart the gateway). If it persists, relink via channels login and check logs.`
+		});
+	}
+	return issues;
+}
+
+//#endregion
+//#region src/channel.ts
+const meta = {
+	id: "whatsapp",
+	label: "WhatsApp",
+	selectionLabel: "WhatsApp (QR link)",
+	detailLabel: "WhatsApp Web",
+	docsPath: "/channels/whatsapp",
+	docsLabel: "whatsapp",
+	blurb: "works with your own number; recommend a separate phone + eSIM.",
+	systemImage: "message"
+};
+const whatsappPlugin = {
+	id: "whatsapp",
+	meta: {
+		...meta,
+		showConfigured: false,
+		quickstartAllowFrom: true,
+		forceAccountBinding: true,
+		preferSessionLookupForAnnounceTarget: true
+	},
+	onboarding: whatsappOnboardingAdapter,
+	agentTools: () => [createWhatsAppLoginTool()],
+	pairing: { idLabel: "whatsappSenderId" },
+	capabilities: {
+		chatTypes: ["direct", "group"],
+		polls: true,
+		reactions: true,
+		media: true
+	},
+	reload: {
+		configPrefixes: ["web"],
+		noopPrefixes: ["channels.whatsapp"]
+	},
+	gatewayMethods: ["web.login.start", "web.login.wait"],
+	configSchema: buildChannelConfigSchema(WhatsAppConfigSchema),
+	config: {
+		listAccountIds: (cfg) => listWhatsAppAccountIds(cfg),
+		resolveAccount: (cfg, accountId) => resolveWhatsAppAccount$1({
+			cfg,
+			accountId
+		}),
+		defaultAccountId: (cfg) => resolveDefaultWhatsAppAccountId(cfg),
+		setAccountEnabled: ({ cfg, accountId, enabled }) => {
+			const accountKey = accountId || DEFAULT_ACCOUNT_ID;
+			const accounts = { ...cfg.channels?.whatsapp?.accounts };
+			const existing = accounts[accountKey] ?? {};
+			return {
+				...cfg,
+				channels: {
+					...cfg.channels,
+					whatsapp: {
+						...cfg.channels?.whatsapp,
+						accounts: {
+							...accounts,
+							[accountKey]: {
+								...existing,
+								enabled
+							}
+						}
+					}
+				}
+			};
+		},
+		deleteAccount: ({ cfg, accountId }) => {
+			const accountKey = accountId || DEFAULT_ACCOUNT_ID;
+			const accounts = { ...cfg.channels?.whatsapp?.accounts };
+			delete accounts[accountKey];
+			return {
+				...cfg,
+				channels: {
+					...cfg.channels,
+					whatsapp: {
+						...cfg.channels?.whatsapp,
+						accounts: Object.keys(accounts).length ? accounts : void 0
+					}
+				}
+			};
+		},
+		isEnabled: (account, cfg) => account.enabled && cfg.web?.enabled !== false,
+		disabledReason: () => "disabled",
+		isConfigured: async (account) => await webAuthExists(account.authDir),
+		unconfiguredReason: () => "not linked",
+		describeAccount: (account) => ({
+			accountId: account.accountId,
+			name: account.name,
+			enabled: account.enabled,
+			configured: Boolean(account.authDir),
+			linked: Boolean(account.authDir),
+			dmPolicy: account.dmPolicy,
+			allowFrom: account.allowFrom
+		}),
+		resolveAllowFrom: ({ cfg, accountId }) => resolveWhatsAppConfigAllowFrom({
+			cfg,
+			accountId
+		}),
+		formatAllowFrom: ({ allowFrom }) => formatWhatsAppConfigAllowFromEntries(allowFrom),
+		resolveDefaultTo: ({ cfg, accountId }) => resolveWhatsAppConfigDefaultTo({
+			cfg,
+			accountId
+		})
+	},
+	security: {
+		resolveDmPolicy: ({ cfg, accountId, account }) => {
+			const resolvedAccountId = accountId ?? account.accountId ?? DEFAULT_ACCOUNT_ID;
+			const basePath = Boolean(cfg.channels?.whatsapp?.accounts?.[resolvedAccountId]) ? `channels.whatsapp.accounts.${resolvedAccountId}.` : "channels.whatsapp.";
+			return {
+				policy: account.dmPolicy ?? "pairing",
+				allowFrom: account.allowFrom ?? [],
+				policyPath: `${basePath}dmPolicy`,
+				allowFromPath: basePath,
+				approveHint: formatPairingApproveHint("whatsapp"),
+				normalizeEntry: (raw) => normalizeE164(raw)
+			};
+		},
+		collectWarnings: ({ account, cfg }) => {
+			const defaultGroupPolicy = resolveDefaultGroupPolicy(cfg);
+			const { groupPolicy } = resolveAllowlistProviderRuntimeGroupPolicy({
+				providerConfigPresent: cfg.channels?.whatsapp !== void 0,
+				groupPolicy: account.groupPolicy,
+				defaultGroupPolicy
+			});
+			if (groupPolicy !== "open") return [];
+			if (Boolean(account.groups) && Object.keys(account.groups ?? {}).length > 0) return [`- WhatsApp groups: groupPolicy="open" allows any member in allowed groups to trigger (mention-gated). Set channels.whatsapp.groupPolicy="allowlist" + channels.whatsapp.groupAllowFrom to restrict senders.`];
+			return [`- WhatsApp groups: groupPolicy="open" with no channels.whatsapp.groups allowlist; any group can add + ping (mention-gated). Set channels.whatsapp.groupPolicy="allowlist" + channels.whatsapp.groupAllowFrom or configure channels.whatsapp.groups.`];
+		}
+	},
+	setup: {
+		resolveAccountId: ({ accountId }) => normalizeAccountId(accountId),
+		applyAccountName: ({ cfg, accountId, name }) => applyAccountNameToChannelSection({
+			cfg,
+			channelKey: "whatsapp",
+			accountId,
+			name,
+			alwaysUseAccounts: true
+		}),
+		applyAccountConfig: ({ cfg, accountId, input }) => {
+			const next = migrateBaseNameToDefaultAccount({
+				cfg: applyAccountNameToChannelSection({
+					cfg,
+					channelKey: "whatsapp",
+					accountId,
+					name: input.name,
+					alwaysUseAccounts: true
+				}),
+				channelKey: "whatsapp",
+				alwaysUseAccounts: true
+			});
+			const entry = {
+				...next.channels?.whatsapp?.accounts?.[accountId],
+				...input.authDir ? { authDir: input.authDir } : {},
+				enabled: true
+			};
+			return {
+				...next,
+				channels: {
+					...next.channels,
+					whatsapp: {
+						...next.channels?.whatsapp,
+						accounts: {
+							...next.channels?.whatsapp?.accounts,
+							[accountId]: entry
+						}
+					}
+				}
+			};
+		}
+	},
+	groups: {
+		resolveRequireMention: resolveWhatsAppGroupRequireMention,
+		resolveToolPolicy: resolveWhatsAppGroupToolPolicy,
+		resolveGroupIntroHint: resolveWhatsAppGroupIntroHint
+	},
+	mentions: { stripPatterns: ({ ctx }) => resolveWhatsAppMentionStripPatterns(ctx) },
+	threading: { buildToolContext: ({ context, hasRepliedRef }) => {
+		return {
+			currentChannelId: context.From?.trim() || context.To?.trim() || void 0,
+			currentThreadTs: context.ReplyToId,
+			hasRepliedRef
+		};
+	} },
+	commands: {
+		enforceOwnerForCommands: true,
+		skipWhenConfigEmpty: true
+	},
+	messaging: {
+		normalizeTarget: normalizeWhatsAppMessagingTarget,
+		targetResolver: {
+			looksLikeId: looksLikeWhatsAppTargetId,
+			hint: "<E.164|group JID>"
+		}
+	},
+	directory: {
+		self: async ({ cfg, accountId }) => {
+			const account = resolveWhatsAppAccount$1({
+				cfg,
+				accountId
+			});
+			const { e164, jid } = readWebSelfId(account.authDir);
+			const id = e164 ?? jid;
+			if (!id) return null;
+			return {
+				kind: "user",
+				id,
+				name: account.name,
+				raw: {
+					e164,
+					jid
+				}
+			};
+		},
+		listPeers: async (params) => listWhatsAppDirectoryPeersFromConfig(params),
+		listGroups: async (params) => listWhatsAppDirectoryGroupsFromConfig(params)
+	},
+	actions: {
+		listActions: ({ cfg }) => {
+			if (!cfg.channels?.whatsapp) return [];
+			const gate = createActionGate(cfg.channels.whatsapp.actions);
+			const actions = /* @__PURE__ */ new Set();
+			if (gate("reactions")) actions.add("react");
+			if (gate("polls")) actions.add("poll");
+			return Array.from(actions);
+		},
+		supportsAction: ({ action }) => action === "react",
+		handleAction: async ({ action, params, cfg, accountId }) => {
+			if (action !== "react") throw new Error(`Action ${action} is not supported for provider ${meta.id}.`);
+			const messageId = readStringParam(params, "messageId", { required: true });
+			const emoji = readStringParam(params, "emoji", { allowEmpty: true });
+			const remove = typeof params.remove === "boolean" ? params.remove : void 0;
+			return await handleWhatsAppAction({
+				action: "react",
+				chatJid: readStringParam(params, "chatJid") ?? readStringParam(params, "to", { required: true }),
+				messageId,
+				emoji,
+				remove,
+				participant: readStringParam(params, "participant"),
+				accountId: accountId ?? void 0,
+				fromMe: typeof params.fromMe === "boolean" ? params.fromMe : void 0
+			}, cfg);
+		}
+	},
+	outbound: whatsappOutbound,
+	auth: { login: async ({ cfg, accountId, runtime, verbose }) => {
+		const resolvedAccountId = accountId?.trim() || resolveDefaultWhatsAppAccountId(cfg);
+		await loginWeb(Boolean(verbose), void 0, runtime, resolvedAccountId, cfg);
+	} },
+	heartbeat: {
+		checkReady: async ({ cfg, accountId, deps }) => {
+			if (cfg.web?.enabled === false) return {
+				ok: false,
+				reason: "whatsapp-disabled"
+			};
+			const account = resolveWhatsAppAccount$1({
+				cfg,
+				accountId
+			});
+			if (!await (deps?.webAuthExists ?? webAuthExists)(account.authDir)) return {
+				ok: false,
+				reason: "whatsapp-not-linked"
+			};
+			if (!(deps?.hasActiveWebListener ? deps.hasActiveWebListener() : Boolean(getActiveWebListener()))) return {
+				ok: false,
+				reason: "whatsapp-not-running"
+			};
+			return {
+				ok: true,
+				reason: "ok"
+			};
+		},
+		resolveRecipients: ({ cfg, opts }) => resolveWhatsAppHeartbeatRecipients(cfg, opts)
+	},
+	status: {
+		defaultRuntime: {
+			accountId: DEFAULT_ACCOUNT_ID,
+			running: false,
+			connected: false,
+			reconnectAttempts: 0,
+			lastConnectedAt: null,
+			lastDisconnect: null,
+			lastMessageAt: null,
+			lastEventAt: null,
+			lastError: null
+		},
+		collectStatusIssues: collectWhatsAppStatusIssues,
+		buildChannelSummary: async ({ account, snapshot }) => {
+			const authDir = account.authDir;
+			const linked = typeof snapshot.linked === "boolean" ? snapshot.linked : authDir ? await webAuthExists(authDir) : false;
+			return {
+				configured: linked,
+				linked,
+				authAgeMs: linked && authDir ? getWebAuthAgeMs(authDir) : null,
+				self: linked && authDir ? readWebSelfId(authDir) : {
+					e164: null,
+					jid: null
+				},
+				running: snapshot.running ?? false,
+				connected: snapshot.connected ?? false,
+				lastConnectedAt: snapshot.lastConnectedAt ?? null,
+				lastDisconnect: snapshot.lastDisconnect ?? null,
+				reconnectAttempts: snapshot.reconnectAttempts,
+				lastMessageAt: snapshot.lastMessageAt ?? null,
+				lastEventAt: snapshot.lastEventAt ?? null,
+				lastError: snapshot.lastError ?? null
+			};
+		},
+		buildAccountSnapshot: async ({ account, runtime }) => {
+			const linked = await webAuthExists(account.authDir);
+			return {
+				accountId: account.accountId,
+				name: account.name,
+				enabled: account.enabled,
+				configured: true,
+				linked,
+				running: runtime?.running ?? false,
+				connected: runtime?.connected ?? false,
+				reconnectAttempts: runtime?.reconnectAttempts,
+				lastConnectedAt: runtime?.lastConnectedAt ?? null,
+				lastDisconnect: runtime?.lastDisconnect ?? null,
+				lastMessageAt: runtime?.lastMessageAt ?? null,
+				lastEventAt: runtime?.lastEventAt ?? null,
+				lastError: runtime?.lastError ?? null,
+				dmPolicy: account.dmPolicy,
+				allowFrom: account.allowFrom
+			};
+		},
+		resolveAccountState: ({ configured }) => configured ? "linked" : "not linked",
+		logSelfId: ({ account, runtime, includeChannelPrefix }) => {
+			logWebSelfId(account.authDir, runtime, includeChannelPrefix);
+		}
+	},
+	gateway: {
+		startAccount: async (ctx) => {
+			const account = ctx.account;
+			const { e164, jid } = readWebSelfId(account.authDir);
+			const identity = e164 ? e164 : jid ? `jid ${jid}` : "unknown";
+			ctx.log?.info(`[${account.accountId}] starting provider (${identity})`);
+			return monitorWebChannel(getWhatsAppRuntime().logging.shouldLogVerbose(), void 0, true, void 0, ctx.runtime, ctx.abortSignal, {
+				statusSink: (next) => ctx.setStatus({
+					accountId: ctx.accountId,
+					...next
+				}),
+				accountId: account.accountId
+			});
+		},
+		loginWithQrStart: async ({ accountId, force, timeoutMs, verbose }) => await startWebLoginWithQr({
+			accountId,
+			force,
+			timeoutMs,
+			verbose
+		}),
+		loginWithQrWait: async ({ accountId, timeoutMs }) => await waitForWebLogin({
+			accountId,
+			timeoutMs
+		}),
+		logoutAccount: async ({ account, cfg, runtime }) => {
+			const { DisconnectReason } = await getBaileys();
+			await closeActiveWebLoginsForAuthDir(account.authDir);
+			const targetAuthDir = tryCanonicalWhatsAppAuthDir(account.authDir);
+			const listenerAccountIds = new Set([account.accountId]);
+			if (targetAuthDir) {
+				for (const candidate of listWhatsAppAccountIds(cfg)) if (tryCanonicalWhatsAppAuthDir(resolveWhatsAppAccount$1({
+					cfg,
+					accountId: candidate
+				}).authDir) === targetAuthDir) listenerAccountIds.add(candidate);
+			}
+			await Promise.all([...listenerAccountIds].map(async (accountId) => await stopActiveWebListener(accountId, {
+				status: DisconnectReason.loggedOut,
+				isLoggedOut: true,
+				error: "logout"
+			})));
+			const cleared = await logoutWeb({
+				authDir: account.authDir,
+				isLegacyAuthDir: account.isLegacyAuthDir,
+				runtime
+			});
+			return {
+				cleared,
+				loggedOut: cleared
+			};
+		}
+	}
+};
+
+//#endregion
+//#region index.ts
+const plugin = {
+	id: "whatsapp",
+	name: "WhatsApp",
+	description: "WhatsApp channel plugin",
+	configSchema: emptyPluginConfigSchema(),
+	register(api) {
+		setWhatsAppRuntime(api.runtime);
+		api.registerChannel({ plugin: whatsappPlugin });
+	}
+};
+
+//#endregion
+export { plugin as default };