@openclaw/matrix 2026.9.6 → 2026.9.8

package/dist/.setup/monitor-BBg5qgov.mjs

@@ -0,0 +1,4352 @@
+import { t as getMatrixRuntime } from "./runtime-1kn1P6io.mjs";
+import { a as resolveMatrixAccountConfig, i as resolveMatrixAccountAllowlistConfig } from "./account-config-CRsKoMqJ.mjs";
+import { n as resolveConfiguredMatrixBotUserIds } from "./accounts-WkgrIxMt.mjs";
+import { a as resolveMatrixThreadRouting, i as resolveMatrixInboundRoute, n as resolveMatrixStoredSessionMeta, o as resolveMatrixRoomConfig } from "./channel-DXenXmj0.mjs";
+import { a as resolveMatrixAllowListMatch, i as normalizeMatrixUserId, r as normalizeMatrixAllowList } from "./channel.setup-DWfLaXqT.mjs";
+import { n as isMatrixRoomId, t as isMatrixQualifiedUserId } from "./target-ids-Nwx7cMVE.mjs";
+import { a as MATRIX_REACTION_EVENT_TYPE } from "./send-currentness-C2rMVVIQ.mjs";
+import { c as isStrictDirectMembership, f as resolveMatrixReplyToEventId, h as MATRIX_OPENCLAW_FINALIZED_PREVIEW_KEY, i as promoteMatrixDirectRoomCandidate, p as resolveMatrixThreadRootId, s as hasDirectMatrixMemberFlag, u as readJoinedMatrixMembers, v as RelationType } from "./direct-management-Cn2t8n1V.mjs";
+import { D as setBoundedMap, S as parsePollStartContent, _ as formatPollAsText, b as isPollStartType, c as formatMatrixMediaTooLargeText, d as isLikelyBareFilename, l as formatMatrixMediaUnavailableText, p as resolveMatrixReplacementContent, r as sendMessageMatrix, u as formatMatrixMessageText, y as isPollEventType } from "./send-GOF64QRc.mjs";
+import { t as createMatrixThreadBindingManager } from "./thread-bindings-jXu_9cHE.mjs";
+import { i as readMatrixMessages, u as fetchMatrixPollSnapshot } from "./messages-Buz27pi5.mjs";
+import { a as isMatrixStartupAbortError, c as getMatrixMonitorTaskSignal, d as resolveMatrixAuthContext, l as backfillMatrixAuthDeviceIdAfterStartup, n as acquireSharedMatrixClient, o as throwIfMatrixStartupAborted, s as createMatrixMonitorTaskRunner, u as resolveMatrixAuth } from "./client-Ccv77kwh.mjs";
+import { i as isMatrixMediaSizeLimitError, r as MatrixMediaSizeLimitError } from "./http-client-C1XvVD3K.mjs";
+import { n as prepareMatrixReplyPayload, r as resolveMatrixExtraContent } from "./outbound-C9vBijaH.mjs";
+import { t as resolveMatrixTargets } from "./resolve-targets-BFq3q4c9.mjs";
+import { t as formatMatrixEncryptedEventDisabledWarning } from "./encryption-guidance-B6797jNA.mjs";
+import { createMatrixInboundEventDeduper } from "./inbound-dedupe-BGrMrTTu.mjs";
+import { a as isMatrixAccessTokenInvalidatedError, d as isMatrixDisconnectedSyncState, f as isMatrixReadySyncState, p as isMatrixTerminalSyncState } from "./client-support-Bn9Bk0-H.mjs";
+import { r as getMatrixRoomInfo, t as createMatrixRoomInfoResolver } from "./room-info-BbTGRJcR.mjs";
+import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
+import { createChannelProgressDraftCompositor, createLivePreviewLifecycle, createPreviewMessageReceipt, createReplyPrefixOptions, createTypingCallbacks, logTypingFailure, resolveChannelStreamingBlockEnabled, waitUntilAbort } from "openclaw/plugin-sdk/channel-outbound";
+import { normalizeLowercaseStringOrEmpty, normalizeNullableString, normalizeOptionalString, normalizeStringifiedEntries, normalizeUniqueTrimmedStringList, readStringValue, uniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { stripReasoningTagsFromText } from "openclaw/plugin-sdk/text-chunking";
+import { CHANNEL_APPROVAL_NATIVE_RUNTIME_CONTEXT_CAPABILITY } from "openclaw/plugin-sdk/approval-handler-adapter-runtime";
+import { addAllowlistUserEntriesFromConfigEntry, buildAllowlistResolutionSummary, canonicalizeAllowlistWithResolvedIds, patchAllowlistUsersInConfigEntries, summarizeMapping } from "openclaw/plugin-sdk/allow-from";
+import { normalizeStringEntries as normalizeStringEntries$1 } from "openclaw/plugin-sdk/string-normalization-runtime";
+import { extractErrorCode, formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
+import { isFutureDateTimestampMs, parseStrictFiniteNumber, resolveExpiresAtMsFromDurationMs, resolveOptionalIntegerOption, resolvePromptHistoryLimit } from "openclaw/plugin-sdk/number-runtime";
+import { resolveAgentRoute, resolveInboundLastRouteSessionKey } from "openclaw/plugin-sdk/routing";
+import { getSessionEntry, resolveStorePath } from "openclaw/plugin-sdk/session-store-runtime";
+import { KeyedAsyncQueue } from "openclaw/plugin-sdk/keyed-async-queue";
+import { escapeRegExp, sliceUtf16Safe, truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
+import { buildTtsSupplementMediaPayload, getReplyPayloadTtsSupplement, resolveSendableOutboundReplyParts } from "openclaw/plugin-sdk/reply-payload";
+import { format } from "node:util";
+import { resolvePinnedMainDmOwnerFromAllowlist } from "openclaw/plugin-sdk/security-runtime";
+import { registerChannelRuntimeContext } from "openclaw/plugin-sdk/channel-runtime-context";
+import { GROUP_POLICY_BLOCKED_LABEL, resolveAllowlistProviderRuntimeGroupPolicy, resolveDefaultGroupPolicy, warnMissingProviderGroupPolicyFallbackOnce } from "openclaw/plugin-sdk/runtime-group-policy";
+import { resolveThreadBindingIdleTimeoutMsForChannel, resolveThreadBindingMaxAgeMsForChannel } from "openclaw/plugin-sdk/thread-bindings-runtime";
+import { isDangerousNameMatchingEnabled } from "openclaw/plugin-sdk/dangerous-name-runtime";
+import { reportChannelRoomJoin } from "openclaw/plugin-sdk/channel-join-intro-runtime";
+import { defineStableChannelIngressIdentity } from "openclaw/plugin-sdk/channel-ingress-runtime";
+import { resolveHumanDelayConfig } from "openclaw/plugin-sdk/agent-runtime";
+import { createAcceptedChannelDeliveryResult, createChannelInboundEnvelopeBuilder, createChannelPartialDeliveryError, formatLocationText, hasFinalInboundReplyDispatch, isChannelPartialDeliveryError, logInboundDrop, resolveInboundMentionDecision, resolveInboundReplyDispatchCounts, toInboundMediaFactsWithMetadata, toLocationContext } from "openclaw/plugin-sdk/channel-inbound";
+import { getAgentScopedMediaLocalRoots } from "openclaw/plugin-sdk/media-local-roots";
+import { getGlobalHookRunner } from "openclaw/plugin-sdk/plugin-runtime";
+import { evaluateSupplementalContextVisibility, resolveChannelContextVisibilityMode } from "openclaw/plugin-sdk/context-visibility-runtime";
+import { resolveAckReaction } from "openclaw/plugin-sdk/channel-feedback";
+import { createChannelPreflightAudio, formatAudioTranscriptForAgent } from "openclaw/plugin-sdk/media-understanding-runtime";
+import { mergePairLoopGuardConfig } from "openclaw/plugin-sdk/pair-loop-guard-runtime";
+import { buildInboundHistoryFromEntries } from "openclaw/plugin-sdk/reply-history";
+import { decodeHtmlEntities } from "openclaw/plugin-sdk/html-entity-runtime";
+import { channelBlockedPatch, channelReadyPatch, channelStoppedPatch, createTransportActivityStatusPatch } from "openclaw/plugin-sdk/gateway-runtime";
+//#region extensions/matrix/src/matrix/monitor/auto-join.ts
+function registerMatrixAutoJoin(params) {
+	const { client, accountConfig, runtime } = params;
+	const core = getMatrixRuntime();
+	const logVerbose = (message) => {
+		if (!core.logging.shouldLogVerbose()) return;
+		runtime.log?.(message);
+	};
+	const autoJoin = accountConfig.autoJoin ?? "off";
+	const rawAllowlist = normalizeStringifiedEntries(accountConfig.autoJoinAllowlist ?? []);
+	const autoJoinAllowlist = new Set(rawAllowlist);
+	const allowedRoomIds = new Set(rawAllowlist.filter((entry) => entry.startsWith("!")));
+	const allowedAliases = rawAllowlist.filter((entry) => entry.startsWith("#"));
+	const resolvedAliasRoomIds = /* @__PURE__ */ new Map();
+	if (autoJoin === "off") return () => {};
+	if (autoJoin === "always") logVerbose("matrix: auto-join enabled for all invites");
+	else logVerbose("matrix: auto-join enabled for allowlist invites");
+	const resolveAllowedAliasRoomId = async (alias) => {
+		if (resolvedAliasRoomIds.has(alias)) return resolvedAliasRoomIds.get(alias) ?? null;
+		const resolved = await params.client.resolveRoom(alias);
+		if (resolved) resolvedAliasRoomIds.set(alias, resolved);
+		return resolved;
+	};
+	const resolveAllowedAliasRoomIds = async () => {
+		return (await Promise.all(allowedAliases.map(async (alias) => {
+			try {
+				return await resolveAllowedAliasRoomId(alias);
+			} catch (err) {
+				runtime.error?.(`matrix: failed resolving allowlisted alias ${alias}: ${String(err)}`);
+				return null;
+			}
+		}))).filter((roomId) => Boolean(roomId));
+	};
+	const onInvite = (roomId, _inviteEvent) => {
+		params.runDetachedTask(`auto-join invite handler room=${roomId}`, async () => {
+			if (autoJoin === "allowlist") {
+				const allowedAliasRoomIds = await resolveAllowedAliasRoomIds();
+				if (!(autoJoinAllowlist.has("*") || allowedRoomIds.has(roomId) || allowedAliasRoomIds.some((resolvedRoomId) => resolvedRoomId === roomId))) {
+					logVerbose(`matrix: invite ignored (not in allowlist) room=${roomId}`);
+					return;
+				}
+			}
+			try {
+				await client.joinRoom(roomId);
+				logVerbose(`matrix: joined room ${roomId}`);
+			} catch (err) {
+				runtime.error?.(`matrix: failed to join room ${roomId}: ${String(err)}`);
+			}
+		});
+	};
+	client.on("room.invite", onInvite);
+	return () => {
+		client.off("room.invite", onInvite);
+	};
+}
+//#endregion
+//#region extensions/matrix/src/matrix/monitor/config.ts
+function normalizeMatrixUserLookupEntry(raw) {
+	return raw.replace(/^matrix:/i, "").replace(/^user:/i, "").trim();
+}
+function normalizeMatrixRoomLookupEntry(raw) {
+	return raw.replace(/^matrix:/i, "").replace(/^(room|channel):/i, "").trim();
+}
+function filterResolvedMatrixAllowlistEntries(entries) {
+	return entries.filter((entry) => {
+		const trimmed = entry.trim();
+		if (!trimmed) return false;
+		if (trimmed === "*") return true;
+		return isMatrixQualifiedUserId(normalizeMatrixUserLookupEntry(trimmed));
+	});
+}
+function filterFailClosedMatrixAllowlistEntries(entries) {
+	return entries.filter((entry) => entry.trim().length > 0);
+}
+function listResolvedMatrixAllowlistEntries(params) {
+	const resolvedEntries = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const entry of params.entries) {
+		const input = String(entry).trim();
+		if (!input || seen.has(input)) continue;
+		seen.add(input);
+		const resolved = params.resolvedMap.get(input);
+		if (!resolved?.resolved || !resolved.id) continue;
+		const id = normalizeMatrixUserId(resolved.id);
+		if (isMatrixQualifiedUserId(id)) resolvedEntries.push({
+			input,
+			id
+		});
+	}
+	return resolvedEntries;
+}
+function isMatrixDangerousNameMatchingEnabled(params) {
+	return isDangerousNameMatchingEnabled(resolveMatrixAccountConfig({
+		cfg: params.cfg,
+		accountId: params.accountId
+	}));
+}
+function addUniqueMatrixAllowlistEntry(params) {
+	const trimmed = params.entry.trim();
+	if (!trimmed) return;
+	const key = normalizeMatrixUserId(trimmed);
+	if (params.seen.has(key)) return;
+	params.seen.add(key);
+	params.entries.push(trimmed);
+}
+function logMatrixAllowlistResolution(params) {
+	const { label, resolution, allowNameMatching, runtime } = params;
+	summarizeMapping(label, allowNameMatching ? resolution.mapping : [], resolution.unresolved, runtime);
+	if (resolution.unresolved.length > 0) {
+		const nameMatchingHint = allowNameMatching ? "" : " To match Matrix display names, set channels.matrix.dangerouslyAllowNameMatching=true.";
+		runtime.log?.(`${label} entries must be full Matrix IDs (example: @user:server). Unresolved entries will not match any sender.${nameMatchingHint}`);
+	}
+}
+async function resolveMatrixMonitorUserEntries(params) {
+	const directMatches = [];
+	const pending = [];
+	for (const entry of params.entries) {
+		const input = String(entry).trim();
+		if (!input) continue;
+		const query = normalizeMatrixUserLookupEntry(input);
+		if (!query || query === "*") continue;
+		if (isMatrixQualifiedUserId(query)) {
+			directMatches.push({
+				input,
+				resolved: true,
+				id: normalizeMatrixUserId(query)
+			});
+			continue;
+		}
+		if (params.allowNameMatching) pending.push({
+			input,
+			query
+		});
+		else directMatches.push({
+			input,
+			resolved: false
+		});
+	}
+	(pending.length === 0 ? [] : await params.resolveTargets({
+		cfg: params.cfg,
+		accountId: params.accountId,
+		inputs: pending.map((entry) => entry.query),
+		kind: "user",
+		runtime: params.runtime
+	})).forEach((entry, index) => {
+		const source = pending[index];
+		if (!source) return;
+		directMatches.push({
+			input: source.input,
+			resolved: entry.resolved,
+			id: entry.id ? normalizeMatrixUserId(entry.id) : void 0
+		});
+	});
+	return buildAllowlistResolutionSummary(directMatches);
+}
+async function resolveMatrixMonitorUserAllowlist(params) {
+	const allowList = (params.list ?? []).map(String);
+	if (allowList.length === 0) return {
+		entries: allowList,
+		resolvedEntries: []
+	};
+	const allowNameMatching = isMatrixDangerousNameMatchingEnabled(params);
+	const resolution = await resolveMatrixMonitorUserEntries({
+		cfg: params.cfg,
+		accountId: params.accountId,
+		entries: allowList,
+		runtime: params.runtime,
+		resolveTargets: params.resolveTargets,
+		allowNameMatching
+	});
+	const canonicalized = canonicalizeAllowlistWithResolvedIds({
+		existing: allowList,
+		resolvedMap: resolution.resolvedMap,
+		entryKey: normalizeMatrixUserId
+	});
+	logMatrixAllowlistResolution({
+		label: params.label,
+		resolution,
+		allowNameMatching,
+		runtime: params.runtime
+	});
+	return {
+		entries: params.failClosedOnUnresolved ? filterFailClosedMatrixAllowlistEntries(canonicalized) : filterResolvedMatrixAllowlistEntries(canonicalized),
+		resolvedEntries: listResolvedMatrixAllowlistEntries({
+			entries: allowList,
+			resolvedMap: resolution.resolvedMap
+		})
+	};
+}
+async function resolveMatrixMonitorLiveUserAllowlist(params) {
+	const liveEntries = normalizeStringEntries$1(params.entries);
+	if (liveEntries.length === 0) return [];
+	const allowNameMatching = isMatrixDangerousNameMatchingEnabled({
+		cfg: params.cfg,
+		accountId: params.accountId
+	});
+	const effective = [];
+	const seen = /* @__PURE__ */ new Set();
+	const startupByInput = new Map((params.startupResolvedEntries ?? []).map((entry) => [entry.input, entry.id]));
+	const pending = [];
+	for (const entry of liveEntries) {
+		const query = normalizeMatrixUserLookupEntry(entry);
+		if (entry === "*") {
+			addUniqueMatrixAllowlistEntry({
+				entries: effective,
+				seen,
+				entry
+			});
+			continue;
+		}
+		if (isMatrixQualifiedUserId(query)) {
+			addUniqueMatrixAllowlistEntry({
+				entries: effective,
+				seen,
+				entry: normalizeMatrixUserId(query)
+			});
+			continue;
+		}
+		const startupId = startupByInput.get(entry);
+		if (allowNameMatching && startupId) {
+			addUniqueMatrixAllowlistEntry({
+				entries: effective,
+				seen,
+				entry: startupId
+			});
+			continue;
+		}
+		if (allowNameMatching) {
+			pending.push(entry);
+			continue;
+		}
+		if (params.failClosedOnUnresolved) addUniqueMatrixAllowlistEntry({
+			entries: effective,
+			seen,
+			entry
+		});
+	}
+	if (pending.length === 0) return effective;
+	const resolution = await resolveMatrixMonitorUserEntries({
+		cfg: params.cfg,
+		accountId: params.accountId,
+		entries: pending,
+		runtime: params.runtime,
+		resolveTargets: params.resolveTargets ?? resolveMatrixTargets,
+		allowNameMatching
+	});
+	const canonicalized = canonicalizeAllowlistWithResolvedIds({
+		existing: pending,
+		resolvedMap: resolution.resolvedMap,
+		entryKey: normalizeMatrixUserId
+	});
+	const resolvedEntries = params.failClosedOnUnresolved ? filterFailClosedMatrixAllowlistEntries(canonicalized) : filterResolvedMatrixAllowlistEntries(canonicalized);
+	for (const entry of resolvedEntries) addUniqueMatrixAllowlistEntry({
+		entries: effective,
+		seen,
+		entry
+	});
+	return effective;
+}
+async function resolveMatrixMonitorRoomsConfig(params) {
+	const roomsConfig = params.roomsConfig;
+	if (!roomsConfig || Object.keys(roomsConfig).length === 0) return roomsConfig;
+	const mapping = [];
+	const unresolved = [];
+	const nextRooms = {};
+	const allowNameMatching = isMatrixDangerousNameMatchingEnabled({
+		cfg: params.cfg,
+		accountId: params.accountId
+	});
+	if (roomsConfig["*"]) nextRooms["*"] = roomsConfig["*"];
+	const pending = [];
+	for (const [entry, roomConfig] of Object.entries(roomsConfig)) {
+		if (entry === "*") continue;
+		const input = entry.trim();
+		if (!input) continue;
+		const cleaned = normalizeMatrixRoomLookupEntry(input);
+		if (!cleaned) {
+			unresolved.push(entry);
+			continue;
+		}
+		if (isMatrixRoomId(cleaned)) {
+			if (!nextRooms[cleaned]) nextRooms[cleaned] = roomConfig;
+			if (cleaned !== input) mapping.push(`${input}→${cleaned}`);
+			continue;
+		}
+		if (!cleaned.startsWith("#") && !allowNameMatching) {
+			unresolved.push(input);
+			continue;
+		}
+		pending.push({
+			input,
+			query: cleaned,
+			config: roomConfig
+		});
+	}
+	if (pending.length > 0) (await params.resolveTargets({
+		cfg: params.cfg,
+		accountId: params.accountId,
+		inputs: pending.map((entry) => entry.query),
+		kind: "group",
+		runtime: params.runtime
+	})).forEach((entry, index) => {
+		const source = pending[index];
+		if (!source) return;
+		if (entry.resolved && entry.id) {
+			const roomKey = normalizeMatrixRoomLookupEntry(entry.id);
+			if (!nextRooms[roomKey]) nextRooms[roomKey] = source.config;
+			mapping.push(`${source.input}→${roomKey}`);
+		} else unresolved.push(source.input);
+	});
+	summarizeMapping("matrix rooms", mapping, unresolved, params.runtime);
+	if (unresolved.length > 0) params.runtime.log?.("matrix rooms must be room IDs or aliases (example: !room:server, the suffixless !room form on room version 12+, or #alias:server). Unresolved entries are ignored.");
+	const roomUsers = /* @__PURE__ */ new Set();
+	for (const roomConfig of Object.values(nextRooms)) addAllowlistUserEntriesFromConfigEntry(roomUsers, roomConfig);
+	if (roomUsers.size === 0) return nextRooms;
+	const resolution = await resolveMatrixMonitorUserEntries({
+		cfg: params.cfg,
+		accountId: params.accountId,
+		entries: Array.from(roomUsers),
+		runtime: params.runtime,
+		resolveTargets: params.resolveTargets,
+		allowNameMatching
+	});
+	logMatrixAllowlistResolution({
+		label: "matrix room users",
+		resolution,
+		allowNameMatching,
+		runtime: params.runtime
+	});
+	return patchAllowlistUsersInConfigEntries({
+		entries: nextRooms,
+		resolvedMap: resolution.resolvedMap,
+		strategy: "canonicalize",
+		entryKey: normalizeMatrixUserId
+	});
+}
+async function resolveMatrixMonitorConfig(params) {
+	const resolveTargets = params.resolveTargets ?? resolveMatrixTargets;
+	const [allowFrom, groupAllowFrom, roomsConfig] = await Promise.all([
+		resolveMatrixMonitorUserAllowlist({
+			cfg: params.cfg,
+			accountId: params.accountId,
+			label: "matrix dm allowlist",
+			list: params.allowFrom,
+			runtime: params.runtime,
+			resolveTargets
+		}),
+		resolveMatrixMonitorUserAllowlist({
+			cfg: params.cfg,
+			accountId: params.accountId,
+			label: "matrix group allowlist",
+			list: params.groupAllowFrom,
+			failClosedOnUnresolved: true,
+			runtime: params.runtime,
+			resolveTargets
+		}),
+		resolveMatrixMonitorRoomsConfig({
+			cfg: params.cfg,
+			accountId: params.accountId,
+			roomsConfig: params.roomsConfig,
+			runtime: params.runtime,
+			resolveTargets
+		})
+	]);
+	return {
+		allowFrom: allowFrom.entries,
+		allowFromResolvedEntries: allowFrom.resolvedEntries,
+		groupAllowFrom: groupAllowFrom.entries,
+		groupAllowFromResolvedEntries: groupAllowFrom.resolvedEntries,
+		roomsConfig
+	};
+}
+//#endregion
+//#region extensions/matrix/src/matrix/monitor/direct.ts
+const DM_CACHE_TTL_MS = 3e4;
+const RECENT_INVITE_TTL_MS = 3e4;
+const MAX_DM_ROOMS = 1024;
+const MAX_DM_MEMBER_FLAGS = 2048;
+function createDirectRoomTracker(client, opts = {}) {
+	const log = opts.log ?? (() => {});
+	let lastDmUpdateMs = 0;
+	let hasSeededDmCache = false;
+	let cachedSelfUserId = null;
+	const joinedMembersCache = /* @__PURE__ */ new Map();
+	const directMemberFlagCache = /* @__PURE__ */ new Map();
+	const recentInviteCandidates = /* @__PURE__ */ new Map();
+	const locallyPromotedDirectRooms = /* @__PURE__ */ new Map();
+	const ensureSelfUserId = async () => {
+		if (cachedSelfUserId) return cachedSelfUserId;
+		try {
+			cachedSelfUserId = await client.getUserId();
+		} catch {
+			cachedSelfUserId = null;
+		}
+		return cachedSelfUserId;
+	};
+	const refreshDmCache = async () => {
+		const now = Date.now();
+		if (now - lastDmUpdateMs < DM_CACHE_TTL_MS) return;
+		lastDmUpdateMs = now;
+		hasSeededDmCache = await client.dms.update() || hasSeededDmCache;
+	};
+	const resolveJoinedMembers = async (roomId) => {
+		const cached = joinedMembersCache.get(roomId);
+		const now = Date.now();
+		if (cached && now - cached.ts < DM_CACHE_TTL_MS) return cached.members;
+		try {
+			const normalized = await readJoinedMatrixMembers(client, roomId);
+			if (!normalized) throw new Error("membership unavailable");
+			setBoundedMap(joinedMembersCache, roomId, {
+				members: normalized,
+				ts: now
+			}, MAX_DM_ROOMS);
+			return normalized;
+		} catch (err) {
+			log(`matrix: dm member lookup failed room=${roomId} (${String(err)})`);
+			return null;
+		}
+	};
+	const resolveDirectMemberFlag = async (roomId, userId) => {
+		const normalizedUserId = userId?.trim();
+		if (!normalizedUserId) return null;
+		const cacheKey = `${roomId}\n${normalizedUserId}`;
+		const cached = directMemberFlagCache.get(cacheKey);
+		const now = Date.now();
+		if (cached && now - cached.ts < DM_CACHE_TTL_MS) return cached.isDirect;
+		const isDirect = await hasDirectMatrixMemberFlag(client, roomId, normalizedUserId);
+		setBoundedMap(directMemberFlagCache, cacheKey, {
+			isDirect,
+			ts: now
+		}, MAX_DM_MEMBER_FLAGS);
+		return isDirect;
+	};
+	const hasRecentInviteCandidate = (roomId, remoteUserId) => {
+		const normalizedRemoteUserId = remoteUserId?.trim();
+		if (!normalizedRemoteUserId) return false;
+		const cached = recentInviteCandidates.get(roomId);
+		if (!cached) return false;
+		if (Date.now() - cached.ts >= RECENT_INVITE_TTL_MS) {
+			recentInviteCandidates.delete(roomId);
+			return false;
+		}
+		return cached.remoteUserId === normalizedRemoteUserId;
+	};
+	const canPromoteRecentInvite = async (roomId) => {
+		try {
+			return await opts.canPromoteRecentInvite?.(roomId) ?? true;
+		} catch (err) {
+			log(`matrix: recent invite promotion veto failed room=${roomId} (${String(err)})`);
+			return false;
+		}
+	};
+	const canPromoteUnmappedStrictRoom = async (roomId) => {
+		try {
+			return await opts.canPromoteUnmappedStrictRoom?.(roomId) ?? false;
+		} catch (err) {
+			log(`matrix: unmapped strict room promotion veto failed room=${roomId} (${String(err)})`);
+			return false;
+		}
+	};
+	const shouldKeepLocallyPromotedDirectRoom = async (roomId) => {
+		try {
+			return await opts.shouldKeepLocallyPromotedDirectRoom?.(roomId);
+		} catch (err) {
+			log(`matrix: local promotion keep-check failed room=${roomId} (${String(err)})`);
+			return;
+		}
+	};
+	const isExplicitlyConfiguredRoom = async (roomId) => {
+		try {
+			return await opts.isExplicitlyConfiguredRoom?.(roomId) ?? false;
+		} catch (err) {
+			log(`matrix: configured room check failed room=${roomId} (${String(err)})`);
+			return true;
+		}
+	};
+	const hasLocallyPromotedDirectRoom = (roomId, remoteUserId) => {
+		const normalizedRemoteUserId = remoteUserId?.trim();
+		if (!normalizedRemoteUserId) return false;
+		return locallyPromotedDirectRooms.get(roomId)?.remoteUserId === normalizedRemoteUserId;
+	};
+	const rememberLocallyPromotedDirectRoom = (roomId, remoteUserId) => {
+		const normalizedRemoteUserId = remoteUserId.trim();
+		if (!normalizedRemoteUserId) return;
+		setBoundedMap(locallyPromotedDirectRooms, roomId, { remoteUserId: normalizedRemoteUserId }, MAX_DM_ROOMS);
+	};
+	return {
+		invalidateRoom: (roomId) => {
+			joinedMembersCache.delete(roomId);
+			for (const key of directMemberFlagCache.keys()) if (key.startsWith(`${roomId}\n`)) directMemberFlagCache.delete(key);
+			lastDmUpdateMs = 0;
+			log(`matrix: invalidated dm cache room=${roomId}`);
+		},
+		rememberInvite: (roomId, remoteUserId) => {
+			const normalizedRemoteUserId = remoteUserId.trim();
+			if (!normalizedRemoteUserId) return;
+			setBoundedMap(recentInviteCandidates, roomId, {
+				remoteUserId: normalizedRemoteUserId,
+				ts: Date.now()
+			}, MAX_DM_ROOMS);
+			log(`matrix: remembered invite candidate room=${roomId} sender=${normalizedRemoteUserId}`);
+		},
+		isDirectMessage: async (params) => {
+			const { roomId, senderId } = params;
+			if (await isExplicitlyConfiguredRoom(roomId)) {
+				log(`matrix: dm rejected via explicit room config room=${roomId}`);
+				return false;
+			}
+			const selfUserId = params.selfUserId ?? await ensureSelfUserId();
+			const joinedMembers = params.joinedMembers ?? await resolveJoinedMembers(roomId);
+			const strictDirectMembership = isStrictDirectMembership({
+				selfUserId,
+				remoteUserId: senderId,
+				joinedMembers
+			});
+			try {
+				await refreshDmCache();
+			} catch (err) {
+				log(`matrix: dm cache refresh failed (${String(err)})`);
+			}
+			if (client.dms.isDm(roomId)) {
+				if (strictDirectMembership) {
+					log(`matrix: dm detected via m.direct room=${roomId}`);
+					return true;
+				}
+				log(`matrix: ignoring stale m.direct classification room=${roomId}`);
+			}
+			if (strictDirectMembership) {
+				const directViaSelf = await resolveDirectMemberFlag(roomId, selfUserId);
+				if (directViaSelf === true) {
+					log(`matrix: dm detected via member state room=${roomId}`);
+					return true;
+				}
+				if (directViaSelf === false) {
+					log(`matrix: dm rejected via member state room=${roomId}`);
+					return false;
+				}
+				if (!hasSeededDmCache) {
+					log(`matrix: dm detected via exact 2-member fallback before dm cache seed room=${roomId}`);
+					return true;
+				}
+				if (hasLocallyPromotedDirectRoom(roomId, senderId)) {
+					if (await shouldKeepLocallyPromotedDirectRoom(roomId) !== false) {
+						log(`matrix: dm detected via local promotion room=${roomId}`);
+						return true;
+					}
+					locallyPromotedDirectRooms.delete(roomId);
+					log(`matrix: local promotion cleared room=${roomId}`);
+				}
+				const promoteDirectRoom = async (source) => {
+					const promotion = await promoteMatrixDirectRoomCandidate({
+						client,
+						remoteUserId: senderId ?? "",
+						roomId,
+						selfUserId
+					});
+					if (promotion.classifyAsDirect) {
+						rememberLocallyPromotedDirectRoom(roomId, senderId ?? "");
+						log(`matrix: dm detected via ${source} room=${roomId} reason=${promotion.reason} repaired=${String(promotion.repaired)}`);
+					}
+					return promotion.classifyAsDirect;
+				};
+				if (hasRecentInviteCandidate(roomId, senderId) && await canPromoteRecentInvite(roomId) && await promoteDirectRoom("recent invite")) return true;
+				if (await canPromoteUnmappedStrictRoom(roomId) && await promoteDirectRoom("per-room strict fallback")) return true;
+			}
+			log(`matrix: dm check room=${roomId} result=group members=${joinedMembers?.length ?? "unknown"}`);
+			return false;
+		}
+	};
+}
+//#endregion
+//#region extensions/matrix/src/matrix/monitor/types.ts
+const EventType = {
+	RoomMessage: "m.room.message",
+	RoomMessageEncrypted: "m.room.encrypted",
+	RoomMember: "m.room.member",
+	Location: "m.location",
+	Reaction: MATRIX_REACTION_EVENT_TYPE
+};
+//#endregion
+//#region extensions/matrix/src/matrix/monitor/access-state.ts
+function normalizeMatrixEntry(raw) {
+	return normalizeMatrixAllowList([raw ?? ""])[0] ?? null;
+}
+const matrixIngressIdentity = defineStableChannelIngressIdentity({
+	key: "sender-id",
+	normalize: normalizeMatrixEntry,
+	matchEntry({ subject, entry }) {
+		const senderId = subject.identifiers[0]?.value;
+		return entry.value === "*" || resolveMatrixAllowListMatch({
+			allowList: [entry.value],
+			userId: senderId ?? ""
+		}).allowed;
+	}
+});
+function resolveMatrixGroupIngress(params) {
+	if (params.groupPolicy === "disabled") return {
+		groupPolicy: "disabled",
+		groupAllowFrom: []
+	};
+	if (params.effectiveRoomUsers.length > 0) return {
+		groupPolicy: "allowlist",
+		groupAllowFrom: params.effectiveRoomUsers
+	};
+	if (params.groupPolicy === "allowlist" && params.effectiveGroupAllowFrom.length > 0) return {
+		groupPolicy: "allowlist",
+		groupAllowFrom: params.effectiveGroupAllowFrom
+	};
+	return {
+		groupPolicy: "open",
+		groupAllowFrom: []
+	};
+}
+async function resolveMatrixMonitorAccessState(params) {
+	const dmPolicy = params.dmPolicy ?? "pairing";
+	const groupPolicy = params.groupPolicy ?? "open";
+	const effectiveGroupAllowFrom = normalizeMatrixAllowList(params.groupAllowFrom);
+	const effectiveRoomUsers = normalizeMatrixAllowList(params.roomUsers);
+	const groupIngress = resolveMatrixGroupIngress({
+		groupPolicy,
+		effectiveGroupAllowFrom,
+		effectiveRoomUsers
+	});
+	const accountId = params.accountId ?? "default";
+	const eventKind = params.eventKind ?? "message";
+	const ingress = getMatrixRuntime().channel.inbound.ingress.createResolver({
+		channelId: "matrix",
+		accountId,
+		identity: matrixIngressIdentity,
+		readStoreAllowFrom: async () => params.storeAllowFrom
+	});
+	const resolveMessageIngress = async (contextBinding, conversation) => await ingress.message({
+		subject: { stableId: params.senderId },
+		conversation: conversation ?? {
+			kind: params.isRoom ? "channel" : "direct",
+			id: params.conversationId ?? (params.isRoom ? "matrix-room" : "matrix-dm")
+		},
+		...contextBinding ? { contextBinding } : {},
+		event: {
+			kind: eventKind,
+			authMode: "inbound",
+			mayPair: params.isRoom ? false : eventKind === "message"
+		},
+		dmPolicy,
+		groupPolicy: params.isRoom ? groupIngress.groupPolicy : "disabled",
+		policy: { groupAllowFromFallbackToAllowFrom: false },
+		allowFrom: params.allowFrom,
+		...params.isRoom ? { groupAllowFrom: groupIngress.groupAllowFrom } : {}
+	});
+	return {
+		effectiveGroupAllowFrom,
+		effectiveRoomUsers,
+		messageIngress: await resolveMessageIngress(),
+		accountId,
+		senderId: params.senderId,
+		isRoom: params.isRoom,
+		resolveMessageIngress
+	};
+}
+async function resolveMatrixMonitorCommandAccess(state, params) {
+	const commandAllowFrom = state.isRoom ? [] : state.messageIngress.senderAccess.effectiveAllowFrom;
+	const commandGroupAllowFrom = state.effectiveRoomUsers.length > 0 ? state.effectiveRoomUsers : state.effectiveGroupAllowFrom;
+	return (await getMatrixRuntime().channel.inbound.ingress.createResolver({
+		channelId: "matrix",
+		accountId: state.accountId,
+		identity: matrixIngressIdentity
+	}).command({
+		subject: { stableId: state.senderId },
+		conversation: {
+			kind: state.isRoom ? "group" : "direct",
+			id: state.isRoom ? "matrix-room" : "matrix-dm"
+		},
+		dmPolicy: "allowlist",
+		groupPolicy: "allowlist",
+		policy: { groupAllowFromFallbackToAllowFrom: false },
+		allowFrom: commandAllowFrom,
+		groupAllowFrom: commandGroupAllowFrom,
+		command: {
+			useAccessGroups: params.useAccessGroups,
+			allowTextCommands: params.allowTextCommands,
+			hasControlCommand: params.hasControlCommand,
+			groupOwnerAllowFrom: "none",
+			commandGroupAllowFromFallbackToAllowFrom: false
+		}
+	})).commandAccess;
+}
+//#endregion
+//#region extensions/matrix/src/matrix/monitor/verification-utils.ts
+const VERIFICATION_EVENT_PREFIX = "m.key.verification.";
+const VERIFICATION_REQUEST_MSGTYPE = "m.key.verification.request";
+const VERIFICATION_NOTICE_PREFIXES = [
+	"Matrix verification request received from ",
+	"Matrix verification is ready with ",
+	"Matrix verification started with ",
+	"Matrix verification completed with ",
+	"Matrix verification cancelled by ",
+	"Matrix verification SAS with "
+];
+function trimMaybeString(input) {
+	return normalizeOptionalString(input) ?? "";
+}
+function isMatrixVerificationEventType(type) {
+	return trimMaybeString(type).startsWith(VERIFICATION_EVENT_PREFIX);
+}
+function isMatrixVerificationRequestMsgType(msgtype) {
+	return trimMaybeString(msgtype) === VERIFICATION_REQUEST_MSGTYPE;
+}
+function isMatrixVerificationNoticeBody(body) {
+	const text = trimMaybeString(body);
+	return VERIFICATION_NOTICE_PREFIXES.some((prefix) => text.startsWith(prefix));
+}
+function isMatrixVerificationRoomMessage(content) {
+	return isMatrixVerificationRequestMsgType(content.msgtype) || trimMaybeString(content.msgtype) === "m.notice" && isMatrixVerificationNoticeBody(content.body);
+}
+const matrixVerificationConstants = {
+	eventPrefix: VERIFICATION_EVENT_PREFIX,
+	requestMsgtype: VERIFICATION_REQUEST_MSGTYPE
+};
+//#endregion
+//#region extensions/matrix/src/matrix/monitor/verification-events.ts
+const MAX_TRACKED_VERIFICATION_EVENTS = 1024;
+const SAS_NOTICE_RETRY_DELAY_MS = 750;
+const VERIFICATION_EVENT_STARTUP_GRACE_MS = 3e4;
+const loadMatrixDirectRoomDeps = createLazyRuntimeModule(() => Promise.all([import("./direct-management-Cn2t8n1V.mjs").then((n) => n.t), import("./direct-management-Cn2t8n1V.mjs").then((n) => n.o)]).then(([directManagementModule, directRoomModule]) => ({
+	inspectMatrixDirectRooms: directManagementModule.inspectMatrixDirectRooms,
+	isStrictDirectRoom: directRoomModule.isStrictDirectRoom
+})));
+function readVerificationSignal(event) {
+	const type = normalizeNullableString(event?.type) ?? "";
+	const content = event?.content ?? {};
+	const msgtype = normalizeNullableString(content.msgtype) ?? "";
+	const relatedEventId = normalizeNullableString(content["m.relates_to"]?.event_id);
+	const transactionId = normalizeNullableString(content.transaction_id);
+	if (type === EventType.RoomMessage && isMatrixVerificationRequestMsgType(msgtype)) return {
+		stage: "request",
+		flowId: normalizeNullableString(event.event_id) ?? transactionId ?? relatedEventId
+	};
+	if (!isMatrixVerificationEventType(type)) return null;
+	const flowId = transactionId ?? relatedEventId ?? normalizeNullableString(event.event_id);
+	if (type === `${matrixVerificationConstants.eventPrefix}request`) return {
+		stage: "request",
+		flowId
+	};
+	if (type === `${matrixVerificationConstants.eventPrefix}ready`) return {
+		stage: "ready",
+		flowId
+	};
+	if (type === "m.key.verification.start") return {
+		stage: "start",
+		flowId
+	};
+	if (type === "m.key.verification.cancel") return {
+		stage: "cancel",
+		flowId
+	};
+	if (type === "m.key.verification.done") return {
+		stage: "done",
+		flowId
+	};
+	return {
+		stage: "other",
+		flowId
+	};
+}
+function formatVerificationStageNotice(params) {
+	const { stage, senderId, event } = params;
+	const content = event.content;
+	switch (stage) {
+		case "request": return `Matrix verification request received from ${senderId}. Open "Verify by emoji" in your Matrix client to continue.`;
+		case "ready": return `Matrix verification is ready with ${senderId}. Choose "Verify by emoji" to reveal the emoji sequence.`;
+		case "start": return `Matrix verification started with ${senderId}.`;
+		case "done": return `Matrix verification completed with ${senderId}.`;
+		case "cancel": {
+			const code = normalizeNullableString(content.code);
+			const reason = normalizeNullableString(content.reason);
+			if (code && reason) return `Matrix verification cancelled by ${senderId} (${code}: ${reason}).`;
+			if (reason) return `Matrix verification cancelled by ${senderId} (${reason}).`;
+			return `Matrix verification cancelled by ${senderId}.`;
+		}
+		default: return null;
+	}
+}
+function formatVerificationSasNotice(summary) {
+	const sas = summary.sas;
+	if (!sas) return null;
+	const emojiLine = Array.isArray(sas.emoji) && sas.emoji.length > 0 ? `SAS emoji: ${sas.emoji.map(([emoji, name]) => `${normalizeNullableString(emoji) ?? "?"} ${normalizeNullableString(name) ?? "?"}`).join(" | ")}` : null;
+	const decimalLine = Array.isArray(sas.decimal) && sas.decimal.length === 3 ? `SAS decimal: ${sas.decimal.join(" ")}` : null;
+	if (!emojiLine && !decimalLine) return null;
+	const lines = [`Matrix verification SAS with ${summary.otherUserId}:`];
+	if (emojiLine) lines.push(emojiLine);
+	if (decimalLine) lines.push(decimalLine);
+	lines.push("If both sides match, choose 'They match' in your Matrix app.");
+	return lines.join("\n");
+}
+function resolveVerificationFlowCandidates(params) {
+	const { event, flowId } = params;
+	const content = event.content;
+	return normalizeUniqueTrimmedStringList([
+		flowId,
+		event.event_id,
+		content.transaction_id,
+		content["m.relates_to"]?.event_id
+	]);
+}
+function resolveSummaryRecency(summary) {
+	const ts = Date.parse(summary.updatedAt ?? "");
+	return Number.isFinite(ts) ? ts : 0;
+}
+function isActiveVerificationSummary(summary) {
+	if (summary.completed) return false;
+	if (summary.phaseName === "cancelled" || summary.phaseName === "done") return false;
+	if (typeof summary.phase === "number" && summary.phase >= 4) return false;
+	return true;
+}
+async function resolveVerificationSummaryForSignal(client, params) {
+	if (!client.crypto) return null;
+	await client.crypto.ensureVerificationDmTracked({
+		roomId: params.roomId,
+		userId: params.senderId
+	}).catch(() => null);
+	const list = await client.crypto.listVerifications();
+	if (list.length === 0) return null;
+	const candidates = resolveVerificationFlowCandidates({
+		event: params.event,
+		flowId: params.flowId
+	});
+	const byTransactionId = list.find((entry) => candidates.some((candidate) => entry.transactionId === candidate));
+	if (byTransactionId) return byTransactionId;
+	const { inspectMatrixDirectRooms, isStrictDirectRoom } = await loadMatrixDirectRoomDeps();
+	const inspection = await inspectMatrixDirectRooms({
+		client,
+		remoteUserId: params.senderId
+	}).catch(() => null);
+	const activeRoomId = normalizeNullableString(inspection?.activeRoomId);
+	if (activeRoomId) {
+		if (activeRoomId !== params.roomId) return null;
+	} else if (!await isStrictDirectRoom({
+		client,
+		roomId: params.roomId,
+		remoteUserId: params.senderId
+	})) return null;
+	const activeByUser = list.filter((entry) => entry.otherUserId === params.senderId && isActiveVerificationSummary(entry)).toSorted((a, b) => resolveSummaryRecency(b) - resolveSummaryRecency(a));
+	const activeInRoom = activeByUser.filter((entry) => {
+		return normalizeNullableString(entry.roomId) === params.roomId;
+	});
+	if (activeInRoom.length > 0) return activeInRoom[0] ?? null;
+	return activeByUser[0] ?? null;
+}
+async function resolveVerificationSasNoticeForSignal(client, params) {
+	const summary = await resolveVerificationSummaryForSignal(client, params);
+	const immediateNotice = summary && isActiveVerificationSummary(summary) ? formatVerificationSasNotice(summary) : null;
+	if (immediateNotice || params.stage !== "ready" && params.stage !== "start") return {
+		summary,
+		sasNotice: immediateNotice
+	};
+	await new Promise((resolve) => {
+		setTimeout(resolve, params.sasNoticeRetryDelayMs ?? SAS_NOTICE_RETRY_DELAY_MS);
+	});
+	const retriedSummary = await resolveVerificationSummaryForSignal(client, params);
+	return {
+		summary: retriedSummary,
+		sasNotice: retriedSummary && isActiveVerificationSummary(retriedSummary) ? formatVerificationSasNotice(retriedSummary) : null
+	};
+}
+function trackBounded(set, value) {
+	if (!value || set.has(value)) return false;
+	set.add(value);
+	if (set.size > MAX_TRACKED_VERIFICATION_EVENTS) {
+		const oldest = set.values().next().value;
+		if (typeof oldest === "string") set.delete(oldest);
+	}
+	return true;
+}
+async function sendVerificationNotice(params) {
+	const roomId = normalizeNullableString(params.roomId);
+	if (!roomId) return;
+	try {
+		await params.client.sendMessage(roomId, {
+			msgtype: "m.notice",
+			body: params.body
+		});
+	} catch (err) {
+		params.logVerboseMessage(`matrix: failed sending verification notice room=${roomId}: ${String(err)}`);
+	}
+}
+async function isVerificationNoticeAuthorized(params) {
+	if (!params.dmEnabled || params.dmPolicy === "disabled") {
+		params.logVerboseMessage(`matrix: blocked verification sender ${params.senderId} (dmPolicy=${params.dmPolicy}, dmEnabled=${String(params.dmEnabled)})`);
+		return false;
+	}
+	const storeAllowFrom = params.dmPolicy !== "allowlist" && params.dmPolicy !== "open" ? await params.readStoreAllowFrom() : [];
+	if ((await resolveMatrixMonitorAccessState({
+		allowFrom: params.allowFrom,
+		storeAllowFrom,
+		dmPolicy: params.dmPolicy,
+		groupPolicy: "open",
+		groupAllowFrom: [],
+		roomUsers: [],
+		senderId: params.senderId,
+		isRoom: false
+	})).messageIngress.senderAccess.decision === "allow") return true;
+	params.logVerboseMessage(`matrix: blocked verification sender ${params.senderId} (dmPolicy=${params.dmPolicy})`);
+	return false;
+}
+function createMatrixVerificationEventRouter(params) {
+	const routerStartedAtMs = Date.now();
+	const routedVerificationEvents = /* @__PURE__ */ new Set();
+	const routedVerificationSasFingerprints = /* @__PURE__ */ new Set();
+	const routedVerificationStageNotices = /* @__PURE__ */ new Set();
+	const verificationFlowRooms = /* @__PURE__ */ new Map();
+	const verificationUserRooms = /* @__PURE__ */ new Map();
+	async function resolveActiveDirectRoomId(remoteUserId) {
+		const { inspectMatrixDirectRooms } = await loadMatrixDirectRoomDeps();
+		const inspection = await inspectMatrixDirectRooms({
+			client: params.client,
+			remoteUserId
+		}).catch(() => null);
+		return normalizeNullableString(inspection?.activeRoomId);
+	}
+	function shouldEmitVerificationEventNotice(event) {
+		const eventTs = typeof event.origin_server_ts === "number" && Number.isFinite(event.origin_server_ts) ? event.origin_server_ts : null;
+		if (eventTs === null) return true;
+		return eventTs >= routerStartedAtMs - VERIFICATION_EVENT_STARTUP_GRACE_MS;
+	}
+	function rememberVerificationRoom(roomId, event, flowId) {
+		for (const candidate of resolveVerificationFlowCandidates({
+			event,
+			flowId
+		})) setBoundedMap(verificationFlowRooms, candidate, roomId, MAX_TRACKED_VERIFICATION_EVENTS);
+	}
+	function rememberVerificationUserRoom(remoteUserId, roomId) {
+		const normalizedUserId = normalizeNullableString(remoteUserId);
+		const normalizedRoomId = normalizeNullableString(roomId);
+		if (!normalizedUserId || !normalizedRoomId) return;
+		verificationUserRooms.delete(normalizedUserId);
+		setBoundedMap(verificationUserRooms, normalizedUserId, normalizedRoomId, MAX_TRACKED_VERIFICATION_EVENTS);
+	}
+	async function resolveSummaryRoomId(summary) {
+		const mappedRoomId = normalizeNullableString(summary.roomId) ?? normalizeNullableString(summary.transactionId ? verificationFlowRooms.get(summary.transactionId) : null) ?? normalizeNullableString(verificationFlowRooms.get(summary.id));
+		if (mappedRoomId) return mappedRoomId;
+		const remoteUserId = normalizeNullableString(summary.otherUserId);
+		if (!remoteUserId) return null;
+		const recentRoomId = normalizeNullableString(verificationUserRooms.get(remoteUserId));
+		const activeRoomId = await resolveActiveDirectRoomId(remoteUserId);
+		if (recentRoomId && activeRoomId && recentRoomId === activeRoomId) return recentRoomId;
+		if (activeRoomId) return activeRoomId;
+		if (recentRoomId && await (await loadMatrixDirectRoomDeps()).isStrictDirectRoom({
+			client: params.client,
+			roomId: recentRoomId,
+			remoteUserId
+		})) return recentRoomId;
+		return null;
+	}
+	async function routeVerificationSummary(summary) {
+		const roomId = await resolveSummaryRoomId(summary);
+		if (!roomId || !isActiveVerificationSummary(summary)) return;
+		if (!await (await loadMatrixDirectRoomDeps()).isStrictDirectRoom({
+			client: params.client,
+			roomId,
+			remoteUserId: summary.otherUserId
+		})) {
+			params.logVerboseMessage(`matrix: ignoring verification summary outside strict DM room=${roomId} sender=${summary.otherUserId}`);
+			return;
+		}
+		if (!await isVerificationNoticeAuthorized({
+			senderId: summary.otherUserId,
+			allowFrom: params.allowFrom,
+			dmEnabled: params.dmEnabled,
+			dmPolicy: params.dmPolicy,
+			readStoreAllowFrom: params.readStoreAllowFrom,
+			logVerboseMessage: params.logVerboseMessage
+		})) return;
+		const sasNotice = formatVerificationSasNotice(summary);
+		if (!sasNotice) return;
+		const sasFingerprint = `${summary.id}:${JSON.stringify(summary.sas)}`;
+		if (!trackBounded(routedVerificationSasFingerprints, sasFingerprint)) return;
+		await sendVerificationNotice({
+			client: params.client,
+			roomId,
+			body: sasNotice,
+			logVerboseMessage: params.logVerboseMessage
+		});
+	}
+	function routeVerificationEvent(roomId, event) {
+		const senderId = normalizeNullableString(event?.sender);
+		if (!senderId) return false;
+		const signal = readVerificationSignal(event);
+		if (!signal) return false;
+		rememberVerificationRoom(roomId, event, signal.flowId);
+		const routeTask = async () => {
+			if (!shouldEmitVerificationEventNotice(event)) {
+				params.logVerboseMessage(`matrix: ignoring historical verification event room=${roomId} id=${event.event_id ?? "unknown"} type=${event.type ?? "unknown"}`);
+				return;
+			}
+			const flowId = signal.flowId;
+			const sourceFingerprint = normalizeNullableString(event?.event_id) ?? `${senderId}:${event.type}:${flowId ?? "none"}`;
+			if (!await (await loadMatrixDirectRoomDeps()).isStrictDirectRoom({
+				client: params.client,
+				roomId,
+				remoteUserId: senderId
+			})) {
+				params.logVerboseMessage(`matrix: ignoring verification event outside strict DM room=${roomId} sender=${senderId}`);
+				return;
+			}
+			if (!await isVerificationNoticeAuthorized({
+				senderId,
+				allowFrom: params.allowFrom,
+				dmEnabled: params.dmEnabled,
+				dmPolicy: params.dmPolicy,
+				readStoreAllowFrom: params.readStoreAllowFrom,
+				logVerboseMessage: params.logVerboseMessage
+			})) return;
+			rememberVerificationUserRoom(senderId, roomId);
+			if (!trackBounded(routedVerificationEvents, sourceFingerprint)) return;
+			const stageNotice = formatVerificationStageNotice({
+				stage: signal.stage,
+				senderId,
+				event
+			});
+			const { summary, sasNotice } = await resolveVerificationSasNoticeForSignal(params.client, {
+				roomId,
+				event,
+				senderId,
+				flowId,
+				stage: signal.stage,
+				sasNoticeRetryDelayMs: params.sasNoticeRetryDelayMs
+			}).catch(() => ({
+				summary: null,
+				sasNotice: null
+			}));
+			const notices = [];
+			if (stageNotice) {
+				const stageKey = `${roomId}:${senderId}:${flowId ?? sourceFingerprint}:${signal.stage}`;
+				if (trackBounded(routedVerificationStageNotices, stageKey)) notices.push(stageNotice);
+			}
+			if (summary && sasNotice) {
+				const sasFingerprint = `${summary.id}:${JSON.stringify(summary.sas)}`;
+				if (trackBounded(routedVerificationSasFingerprints, sasFingerprint)) notices.push(sasNotice);
+			}
+			if (notices.length === 0) return;
+			for (const body of notices) await sendVerificationNotice({
+				client: params.client,
+				roomId,
+				body,
+				logVerboseMessage: params.logVerboseMessage
+			});
+		};
+		if (params.runDetachedTask) params.runDetachedTask(`verification event handler room=${roomId} id=${event.event_id ?? "unknown"}`, routeTask);
+		else routeTask().catch((err) => {
+			params.logVerboseMessage(`matrix: failed routing verification event: ${String(err)}`);
+		});
+		return true;
+	}
+	return {
+		routeVerificationEvent,
+		routeVerificationSummary
+	};
+}
+//#endregion
+//#region extensions/matrix/src/matrix/monitor/events.ts
+const MATRIX_POST_HEALTHY_SYNC_DECRYPT_FAILURE_WINDOW_MS = 12e4;
+const MATRIX_POST_HEALTHY_SYNC_DECRYPT_FAILURE_THRESHOLD = 3;
+const MATRIX_POST_HEALTHY_SYNC_DECRYPT_FAILURE_SAMPLE_LIMIT = 3;
+function formatMatrixPostHealthySyncDecryptionHint(accountId) {
+	return `matrix: repeated fresh encrypted messages are still failing to decrypt after Matrix resumed healthy sync. This device may still be missing new room keys. Check 'openclaw matrix verify status --verbose --account ${accountId}' and 'openclaw matrix devices list --account ${accountId}'.`;
+}
+function isFreshPostHealthySyncDecryptFailure(params) {
+	const { event, healthySyncSinceMs, graceMs = 0, nowMs } = params;
+	if (typeof healthySyncSinceMs !== "number" || !Number.isFinite(healthySyncSinceMs)) return false;
+	const eventTs = event.origin_server_ts;
+	if (!Number.isFinite(eventTs) || eventTs <= 0) return false;
+	if (eventTs < healthySyncSinceMs + graceMs) return false;
+	if (eventTs > nowMs + 6e4) return false;
+	return true;
+}
+function createMatrixPostHealthySyncDecryptFailureTracker(params) {
+	let observations = [];
+	let warningEmitted = false;
+	let trackedHealthySyncSinceMs;
+	const resetObservations = () => {
+		observations = [];
+		warningEmitted = false;
+	};
+	const pruneObservations = (nowMs) => {
+		observations = observations.filter((entry) => nowMs - entry.eventTs <= MATRIX_POST_HEALTHY_SYNC_DECRYPT_FAILURE_WINDOW_MS);
+		if (observations.length === 0) warningEmitted = false;
+	};
+	return { recordFailure(roomId, event, error) {
+		const nowMs = Date.now();
+		const healthySyncSinceMs = params.getHealthySyncSinceMs?.();
+		if (healthySyncSinceMs !== trackedHealthySyncSinceMs) {
+			trackedHealthySyncSinceMs = healthySyncSinceMs;
+			resetObservations();
+		}
+		if (!isFreshPostHealthySyncDecryptFailure({
+			event,
+			healthySyncSinceMs,
+			graceMs: params.startupGraceMs,
+			nowMs
+		})) return {
+			freshAfterHealthySync: false,
+			failureCount: 0
+		};
+		pruneObservations(nowMs);
+		const key = `${roomId}|${event.event_id}`;
+		if (!observations.some((entry) => entry.key === key)) observations.push({
+			key,
+			roomId,
+			eventId: event.event_id,
+			sender: typeof event.sender === "string" ? event.sender : null,
+			eventTs: event.origin_server_ts,
+			error: error.message
+		});
+		const failureCount = observations.length;
+		if (warningEmitted || failureCount < MATRIX_POST_HEALTHY_SYNC_DECRYPT_FAILURE_THRESHOLD) return {
+			freshAfterHealthySync: true,
+			failureCount
+		};
+		warningEmitted = true;
+		const rooms = uniqueStrings(observations.map((entry) => entry.roomId)).slice(0, MATRIX_POST_HEALTHY_SYNC_DECRYPT_FAILURE_SAMPLE_LIMIT);
+		const senders = uniqueStrings(observations.map((entry) => entry.sender).filter((sender) => Boolean(sender))).slice(0, MATRIX_POST_HEALTHY_SYNC_DECRYPT_FAILURE_SAMPLE_LIMIT);
+		const eventIds = observations.slice(-3).map((entry) => entry.eventId);
+		const latestError = observations.at(-1)?.error ?? error.message;
+		return {
+			freshAfterHealthySync: true,
+			failureCount,
+			warning: {
+				rooms,
+				roomCount: new Set(observations.map((entry) => entry.roomId)).size,
+				senders,
+				senderCount: new Set(observations.map((entry) => entry.sender).filter(Boolean)).size,
+				eventIds,
+				latestError,
+				windowMs: MATRIX_POST_HEALTHY_SYNC_DECRYPT_FAILURE_WINDOW_MS
+			}
+		};
+	} };
+}
+function formatMatrixSelfDecryptionHint(accountId) {
+	return `matrix: failed to decrypt a message from this same Matrix user. This usually means another Matrix device did not share the room key, or another OpenClaw runtime is using the same account. Check 'openclaw matrix verify status --verbose --account ${accountId}' and 'openclaw matrix devices list --account ${accountId}'.`;
+}
+async function resolveMatrixSelfUserId(client, logVerboseMessage) {
+	if (typeof client.getUserId !== "function") return null;
+	try {
+		return await client.getUserId() ?? null;
+	} catch (err) {
+		logVerboseMessage(`matrix: failed resolving self user id for decrypt warning: ${String(err)}`);
+		return null;
+	}
+}
+function registerMatrixMonitorEvents(params) {
+	const { cfg, client, auth, allowFrom, dmEnabled, dmPolicy, readStoreAllowFrom, directTracker, invalidateMemberDisplayName, logVerboseMessage, warnedEncryptedRooms, warnedCryptoMissingRooms, logger, startupGraceMs, getHealthySyncSinceMs, formatNativeDependencyHint, onRoomMessage, runDetachedTask, sasNoticeRetryDelayMs } = params;
+	const postHealthySyncDecryptFailureTracker = createMatrixPostHealthySyncDecryptFailureTracker({
+		getHealthySyncSinceMs,
+		startupGraceMs
+	});
+	const { routeVerificationEvent, routeVerificationSummary } = createMatrixVerificationEventRouter({
+		client,
+		allowFrom,
+		dmEnabled,
+		dmPolicy,
+		readStoreAllowFrom,
+		logVerboseMessage,
+		runDetachedTask,
+		sasNoticeRetryDelayMs
+	});
+	const runMonitorTask = (label, task) => {
+		if (runDetachedTask) return runDetachedTask(label, task);
+		return Promise.resolve().then(task).catch((error) => {
+			logVerboseMessage(`matrix: ${label} failed (${String(error)})`);
+		});
+	};
+	const onRoomMessageEvent = (roomId, event) => {
+		if (routeVerificationEvent(roomId, event)) return;
+		runMonitorTask(`room message handler room=${roomId} id=${event.event_id ?? "unknown"}`, async () => {
+			await onRoomMessage(roomId, event);
+		});
+	};
+	const onEncryptedEvent = (roomId, event) => {
+		const eventId = event?.event_id ?? "unknown";
+		const eventType = event?.type ?? "unknown";
+		logVerboseMessage(`matrix: encrypted event room=${roomId} type=${eventType} id=${eventId}`);
+	};
+	const onDecryptedEvent = (roomId, event) => {
+		const eventId = event?.event_id ?? "unknown";
+		const eventType = event?.type ?? "unknown";
+		logVerboseMessage(`matrix: decrypted event room=${roomId} type=${eventType} id=${eventId}`);
+		if (routeVerificationEvent(roomId, event)) return;
+		if (eventType !== EventType.RoomMessage) return;
+		runMonitorTask(`decrypted room message handler room=${roomId} id=${event.event_id ?? "unknown"}`, async () => {
+			await onRoomMessage(roomId, event);
+		});
+	};
+	const onFailedDecryption = (roomId, event, error) => {
+		runMonitorTask(`failed decryption handler room=${roomId} id=${event.event_id ?? "unknown"}`, async () => {
+			const failureState = postHealthySyncDecryptFailureTracker.recordFailure(roomId, event, error);
+			const selfUserId = await resolveMatrixSelfUserId(client, logVerboseMessage);
+			const sender = typeof event.sender === "string" ? event.sender : null;
+			const senderMatchesOwnUser = Boolean(selfUserId && sender && selfUserId === sender);
+			logger.warn(failureState.freshAfterHealthySync ? "Failed to decrypt fresh post-healthy-sync message" : "Failed to decrypt message", {
+				roomId,
+				eventId: event.event_id,
+				sender,
+				senderMatchesOwnUser,
+				error: error.message,
+				freshAfterHealthySync: failureState.freshAfterHealthySync,
+				...failureState.freshAfterHealthySync ? { postHealthySyncFailureCount: failureState.failureCount } : {}
+			});
+			if (failureState.warning) logger.warn(formatMatrixPostHealthySyncDecryptionHint(auth.accountId), {
+				roomId,
+				eventId: event.event_id,
+				failureCount: failureState.failureCount,
+				roomCount: failureState.warning.roomCount,
+				rooms: failureState.warning.rooms,
+				senderCount: failureState.warning.senderCount,
+				senders: failureState.warning.senders,
+				sampleEventIds: failureState.warning.eventIds,
+				latestError: failureState.warning.latestError,
+				windowMs: failureState.warning.windowMs
+			});
+			if (senderMatchesOwnUser) logger.warn(formatMatrixSelfDecryptionHint(auth.accountId), {
+				roomId,
+				eventId: event.event_id,
+				sender
+			});
+			logVerboseMessage(`matrix: failed decrypt room=${roomId} id=${event.event_id ?? "unknown"} freshAfterHealthySync=${String(failureState.freshAfterHealthySync)} error=${error.message}`);
+		});
+	};
+	const onVerificationSummary = (summary) => {
+		runMonitorTask("verification summary handler", async () => {
+			await routeVerificationSummary(summary);
+		});
+	};
+	const onInvite = (roomId, event) => {
+		directTracker?.invalidateRoom(roomId);
+		const eventId = event?.event_id ?? "unknown";
+		const sender = event?.sender ?? "unknown";
+		const invitee = normalizeOptionalString(event?.state_key) ?? "";
+		const senderIsInvitee = Boolean(invitee) && (normalizeOptionalString(event?.sender) ?? "") === invitee;
+		const isDirect = (event?.content)?.is_direct === true;
+		const rememberedSender = normalizeOptionalString(event?.sender);
+		if (rememberedSender && !senderIsInvitee) directTracker?.rememberInvite?.(roomId, rememberedSender);
+		logVerboseMessage(`matrix: invite room=${roomId} sender=${sender} direct=${String(isDirect)} id=${eventId}`);
+	};
+	const onJoin = (roomId, event) => {
+		directTracker?.invalidateRoom(roomId);
+		const eventId = event?.event_id ?? "unknown";
+		logVerboseMessage(`matrix: join room=${roomId} id=${eventId}`);
+		if (event.membershipProvenance !== "transition" || event.state_key !== auth.userId) return;
+		runMonitorTask(`join introduction room=${roomId}`, async () => {
+			const members = await readJoinedMatrixMembers(client, roomId);
+			const remoteUserId = members?.find((member) => member !== auth.userId);
+			if (!members?.includes(auth.userId) || !remoteUserId || await directTracker.isDirectMessage({
+				roomId,
+				senderId: remoteUserId,
+				selfUserId: auth.userId,
+				joinedMembers: members
+			})) return;
+			const roomInfo = await params.getRoomInfo(roomId, { includeAliases: params.needsRoomAliasesForConfig });
+			const roomConfig = resolveMatrixRoomConfig({
+				rooms: params.roomsConfig,
+				roomId,
+				aliases: [roomInfo.canonicalAlias ?? "", ...roomInfo.altAliases].filter(Boolean)
+			});
+			const roomAllowed = (!params.needsRoomAliasesForConfig || roomInfo.aliasesResolved) && params.groupPolicy !== "disabled" && (roomConfig.config ? roomConfig.allowed : params.groupPolicy === "open");
+			const options = {
+				cfg,
+				accountId: auth.accountId,
+				client
+			};
+			await reportChannelRoomJoin({
+				cfg,
+				channel: "matrix",
+				accountId: auth.accountId,
+				conversationId: roomId,
+				deliverTo: `room:${roomId}`,
+				route: resolveMatrixInboundRoute({
+					cfg,
+					accountId: auth.accountId,
+					roomId,
+					senderId: auth.userId,
+					isDirectMessage: false,
+					resolveAgentRoute
+				}).route,
+				roomAllowed,
+				resolveRoomContext: async ({ messageLimit }) => {
+					const info = await getMatrixRoomInfo(roomId, options);
+					const context = {
+						title: info.name ?? void 0,
+						purpose: info.topic ?? void 0
+					};
+					try {
+						const { messages } = await readMatrixMessages(roomId, {
+							...options,
+							limit: messageLimit
+						});
+						return {
+							...context,
+							recentMessages: messages.toReversed().flatMap(({ sender, body }) => body?.trim() ? [{
+								sender,
+								text: body
+							}] : [])
+						};
+					} catch {
+						return context;
+					}
+				}
+			});
+		});
+	};
+	const onRoomEvent = (roomId, event) => {
+		const eventType = event?.type ?? "unknown";
+		if (eventType === EventType.RoomMessageEncrypted) {
+			logVerboseMessage(`matrix: encrypted raw event room=${roomId} id=${event?.event_id ?? "unknown"}`);
+			if (auth.encryption !== true && !warnedEncryptedRooms.has(roomId)) {
+				warnedEncryptedRooms.add(roomId);
+				const warning = formatMatrixEncryptedEventDisabledWarning(cfg, auth.accountId);
+				logger.warn(warning, { roomId });
+			}
+			if (auth.encryption === true && !client.crypto && !warnedCryptoMissingRooms.has(roomId)) {
+				warnedCryptoMissingRooms.add(roomId);
+				const warning = `matrix: encryption enabled but crypto is unavailable; ${formatNativeDependencyHint({
+					packageName: "@matrix-org/matrix-sdk-crypto-nodejs",
+					manager: "pnpm",
+					downloadCommand: "node node_modules/@matrix-org/matrix-sdk-crypto-nodejs/download-lib.js"
+				})}`;
+				logger.warn(warning, { roomId });
+			}
+			return;
+		}
+		if (eventType === EventType.RoomMember) {
+			directTracker?.invalidateRoom(roomId);
+			const membership = (event?.content)?.membership;
+			const stateKey = event.state_key ?? "";
+			if (stateKey) invalidateMemberDisplayName?.(roomId, stateKey);
+			logVerboseMessage(`matrix: member event room=${roomId} stateKey=${stateKey} membership=${membership ?? "unknown"}`);
+		}
+		if (eventType === EventType.Reaction) {
+			runMonitorTask(`reaction handler room=${roomId} id=${event.event_id ?? "unknown"}`, async () => {
+				await onRoomMessage(roomId, event);
+			});
+			return;
+		}
+		routeVerificationEvent(roomId, event);
+	};
+	client.on("room.message", onRoomMessageEvent);
+	client.on("room.encrypted_event", onEncryptedEvent);
+	client.on("room.decrypted_event", onDecryptedEvent);
+	client.on("room.failed_decryption", onFailedDecryption);
+	client.on("verification.summary", onVerificationSummary);
+	client.on("room.invite", onInvite);
+	client.on("room.join", onJoin);
+	client.on("room.event", onRoomEvent);
+	return () => {
+		client.off("room.message", onRoomMessageEvent);
+		client.off("room.encrypted_event", onEncryptedEvent);
+		client.off("room.decrypted_event", onDecryptedEvent);
+		client.off("room.failed_decryption", onFailedDecryption);
+		client.off("verification.summary", onVerificationSummary);
+		client.off("room.invite", onInvite);
+		client.off("room.join", onJoin);
+		client.off("room.event", onRoomEvent);
+	};
+}
+//#endregion
+//#region extensions/matrix/src/matrix/monitor/context-summary.ts
+const MAX_CONTEXT_BODY_LENGTH = 500;
+function truncateMatrixContextBody(value) {
+	if (value.length <= MAX_CONTEXT_BODY_LENGTH) return value;
+	return `${sliceUtf16Safe(value, 0, 497)}...`;
+}
+function summarizeMatrixMessageContextEvent(event) {
+	if (isPollStartType(event.type)) {
+		const pollSummary = parsePollStartContent(event.content);
+		if (pollSummary) return formatPollAsText(pollSummary);
+	}
+	const content = resolveMatrixReplacementContent(event) ?? event.content;
+	return formatMatrixMessageText({
+		body: readStringValue(content.body),
+		filename: readStringValue(content.filename),
+		msgtype: normalizeOptionalString(content.msgtype)
+	});
+}
+//#endregion
+//#region extensions/matrix/src/matrix/monitor/event-context.ts
+function createMatrixEventContextResolver(params) {
+	const cache = /* @__PURE__ */ new Map();
+	const isThread = params.kind === "thread";
+	return async (input) => {
+		const cacheKey = `${input.roomId}:${input.eventId}`;
+		const cached = cache.get(cacheKey);
+		if (cached) {
+			if (!isThread) {
+				cache.delete(cacheKey);
+				cache.set(cacheKey, cached);
+			}
+			return cached;
+		}
+		const event = await params.client.getEvent(input.roomId, input.eventId).catch((err) => {
+			params.logVerboseMessage(`matrix: failed resolving ${isThread ? "thread root" : "reply context"} room=${input.roomId} id=${input.eventId}: ${String(err)}`);
+			return null;
+		});
+		if (!event || isThread && (event.event_id !== input.eventId || event.room_id && event.room_id !== input.roomId)) return isThread ? { threadStarterBody: `Matrix thread root ${input.eventId}` } : {};
+		const context = {};
+		if (isThread || !event.unsigned?.redacted_because) {
+			const body = summarizeMatrixMessageContextEvent(event);
+			let summary = body ? truncateMatrixContextBody(body) : void 0;
+			if (isThread && !summary) {
+				const msgtype = normalizeOptionalString(event.content.msgtype);
+				const eventType = normalizeOptionalString(event.type);
+				summary = msgtype ? `Matrix ${msgtype} message` : eventType ? `Matrix ${eventType} event` : void 0;
+			}
+			if (isThread || summary) {
+				const senderId = normalizeOptionalString(event.sender);
+				const senderName = senderId && await params.getMemberDisplayName(input.roomId, senderId).catch(() => void 0);
+				Object.assign(context, {
+					summary,
+					senderId,
+					senderLabel: senderName ?? senderId
+				});
+				if (isThread) {
+					const lines = [`Matrix thread root ${input.eventId} from ${senderName ?? senderId ?? "unknown sender"}:`];
+					if (summary) lines.push(summary);
+					context.threadStarterBody = lines.join("\n");
+				}
+			}
+		}
+		setBoundedMap(cache, cacheKey, context, 256);
+		return context;
+	};
+}
+//#endregion
+//#region extensions/matrix/src/matrix/monitor/ack-config.ts
+function resolveMatrixAckReactionConfig(params) {
+	const matrixConfig = params.cfg.channels?.matrix;
+	const accountConfig = resolveMatrixAccountConfig({
+		cfg: params.cfg,
+		accountId: params.accountId
+	});
+	return {
+		ackReaction: resolveAckReaction(params.cfg, params.agentId, {
+			channel: "matrix",
+			accountId: params.accountId ?? void 0
+		}).trim(),
+		ackReactionScope: accountConfig.ackReactionScope ?? matrixConfig?.ackReactionScope ?? params.cfg.messages?.ackReactionScope ?? "group-mentions"
+	};
+}
+//#endregion
+//#region extensions/matrix/src/matrix/monitor/preflight-audio.ts
+function isMatrixAudioContent(params) {
+	if (params.msgtype === "m.audio") return true;
+	if (params.msgtype === "m.file" && typeof params.mimetype === "string") return params.mimetype.toLowerCase().startsWith("audio/");
+	return false;
+}
+const matrixPreflightAudio = createChannelPreflightAudio({
+	channel: "matrix",
+	isAudio: isMatrixAudioContent
+});
+async function resolveMatrixPreflightAudioTranscript(params) {
+	return await matrixPreflightAudio.resolve({
+		request: {
+			ctx: {
+				media: [{
+					path: params.mediaPath,
+					contentType: params.mediaContentType
+				}],
+				Provider: "matrix",
+				Surface: "matrix",
+				OriginatingChannel: "matrix",
+				OriginatingTo: params.originatingTo,
+				AccountId: params.accountId,
+				MessageThreadId: params.messageThreadId,
+				ChatType: params.chatType,
+				SessionKey: params.sessionKey
+			},
+			cfg: params.cfg
+		},
+		abortSignal: params.abortSignal
+	});
+}
+//#endregion
+//#region extensions/matrix/src/matrix/monitor/handler-helpers.ts
+const MATRIX_TOOL_PROGRESS_MAX_CHARS = 300;
+const MAX_TRACKED_SHARED_DM_CONTEXT_NOTICES = 512;
+function resolveMatrixMentionPrecheckText(params) {
+	if (params.locationText?.trim()) return params.locationText.trim();
+	if (typeof params.content.body === "string" && params.content.body.trim()) return params.content.body.trim();
+	if (isPollStartType(params.eventType)) {
+		const parsed = parsePollStartContent(params.content);
+		if (parsed) return formatPollAsText(parsed);
+	}
+	return "";
+}
+function hasBundledMatrixReplacementRelation(event) {
+	const relations = event.unsigned?.["m.relations"];
+	if (!relations || typeof relations !== "object") return false;
+	return relations[RelationType.Replace] !== void 0;
+}
+function resolveMatrixInboundBodyText(params) {
+	if (params.mediaPlaceholder) return params.rawBody || params.mediaPlaceholder;
+	if (!params.mediaDownloadFailed || !params.hadMediaUrl) return params.rawBody;
+	if (params.mediaSizeLimitExceeded) return formatMatrixMediaTooLargeText({
+		body: params.rawBody,
+		filename: params.filename,
+		msgtype: params.msgtype
+	});
+	return formatMatrixMediaUnavailableText({
+		body: params.rawBody,
+		filename: params.filename,
+		msgtype: params.msgtype
+	});
+}
+function markTrackedRoomIfFirst(set, roomId) {
+	if (set.has(roomId)) return false;
+	set.add(roomId);
+	if (set.size > MAX_TRACKED_SHARED_DM_CONTEXT_NOTICES) {
+		const oldest = set.keys().next().value;
+		if (typeof oldest === "string") set.delete(oldest);
+	}
+	return true;
+}
+function resolveMatrixSharedDmContextNotice(params) {
+	if ((params.dmSessionScope ?? "per-user") === "per-room") return null;
+	if (params.sentRooms.has(params.roomId)) return null;
+	try {
+		const currentSession = resolveMatrixStoredSessionMeta(getSessionEntry({
+			storePath: params.storePath,
+			sessionKey: params.sessionKey
+		}));
+		if (!currentSession) return null;
+		if (currentSession.channel && currentSession.channel !== "matrix") return null;
+		if (currentSession.accountId && currentSession.accountId !== params.accountId) return null;
+		if (!currentSession.directUserId) return null;
+		if (!currentSession.roomId || currentSession.roomId === params.roomId) return null;
+		return ["This Matrix DM is sharing a session with another Matrix DM room.", "Set channels.matrix.dm.sessionScope to per-room to isolate each Matrix DM room."].join(" ");
+	} catch (err) {
+		params.logVerboseMessage(`matrix: failed checking shared DM session notice room=${params.roomId} (${String(err)})`);
+		return null;
+	}
+}
+function resolveMatrixPendingHistoryText(params) {
+	if (!params.mediaUrl) return params.mentionPrecheckText;
+	const body = typeof params.content.body === "string" ? params.content.body : void 0;
+	const filename = typeof params.content.filename === "string" ? params.content.filename : void 0;
+	const msgtype = typeof params.content.msgtype === "string" ? params.content.msgtype : void 0;
+	return formatMatrixMessageText({
+		body,
+		filename,
+		msgtype
+	}) ?? params.mentionPrecheckText;
+}
+function resolveMatrixInboundMediaContent(content) {
+	const file = content.file && typeof content.file === "object" ? content.file : void 0;
+	const info = content.info && typeof content.info === "object" ? content.info : void 0;
+	const body = normalizeOptionalString(content.body);
+	return {
+		url: normalizeOptionalString(content.url) ?? normalizeOptionalString(file?.url),
+		file,
+		body: body ?? "",
+		contentType: info?.mimetype,
+		sizeBytes: typeof info?.size === "number" ? info.size : void 0,
+		originalFilename: normalizeOptionalString(content.filename) ?? body
+	};
+}
+function isMatrixAudioMediaEnabled(cfg) {
+	return cfg.tools?.media?.audio?.enabled !== false;
+}
+function shouldDeferMatrixAudioPreflightForRoomIngress(params) {
+	if (!isMatrixAudioMediaEnabled(params.cfg)) return false;
+	const mediaContent = resolveMatrixInboundMediaContent(params.content);
+	return mediaContent.url?.startsWith("mxc://") === true && isMatrixAudioContent({
+		msgtype: typeof params.content.msgtype === "string" ? params.content.msgtype : void 0,
+		mimetype: mediaContent.contentType
+	});
+}
+function resolveMatrixAllowBotsMode(value) {
+	if (value === true) return "all";
+	if (value === "mentions") return "mentions";
+	return "off";
+}
+function formatMatrixToolProgressMarkdownCode(text) {
+	return `\`${(text.length <= MATRIX_TOOL_PROGRESS_MAX_CHARS ? text : `${truncateUtf16Safe(text, 299).trimEnd()}...`).replaceAll("`", "'")}\``;
+}
+//#endregion
+//#region extensions/matrix/src/matrix/monitor/handler-runtime.ts
+const loadMatrixSendModule = createLazyRuntimeModule(() => import("./send-GOF64QRc.mjs").then((n) => n.s));
+const loadAcpBindingRuntime = createLazyRuntimeModule(() => import("openclaw/plugin-sdk/acp-binding-runtime"));
+const loadSessionBindingRuntime = createLazyRuntimeModule(() => import("openclaw/plugin-sdk/session-binding-runtime"));
+const loadMatrixReactionEvents = createLazyRuntimeModule(() => import("./reaction-events-mnzc_JvP.mjs"));
+const loadMatrixDraftStream = createLazyRuntimeModule(() => import("./draft-stream-CdVMstpR.mjs"));
+async function matrixTextWouldActivateMentions(client, text) {
+	const { resolveMatrixMentionsForBody } = await loadMatrixSendModule();
+	const mentions = await resolveMatrixMentionsForBody({
+		client,
+		body: text
+	});
+	return mentions.room === true || (mentions.user_ids?.length ?? 0) > 0;
+}
+//#endregion
+//#region extensions/matrix/src/matrix/monitor/handler-context.ts
+async function resolveMatrixInboundContext(config) {
+	const { handler, ingress, roomId, event, eventTs, resolveThreadContext, resolveReplyContext, senderId, sharedDmContextNoticeRooms } = config;
+	const { client, core, accountId, runtime, logVerboseMessage, groupPolicy, getRoomInfo, historyLimit, dmSessionScope, resolveStorePath: resolveStorePathImpl, createChannelInboundEnvelopeBuilder: createChannelInboundEnvelopeBuilderImpl, finalizeInboundContext } = handler;
+	const { cfg, resolveMessageIngress, route: _route, isDirectMessage, isRoom, effectiveRoomUsers, effectiveGroupAllowFrom, threadRootId, thread, senderName, bodyText, commandBodyText, roomConfig, messageId, inboundHistory, wasMentioned, effectiveWasMentioned, shouldBypassMention, canDetectMention, shouldRequireMention, commandAuthorized, locationPayload, media, preflightAudioTranscript, hasExplicitSessionBinding } = ingress;
+	const contextVisibilityMode = resolveChannelContextVisibilityMode({
+		cfg,
+		channel: "matrix",
+		accountId
+	});
+	const replyToEventId = resolveMatrixReplyToEventId(event.content);
+	const threadTarget = thread.threadId;
+	const isRoomContextSenderAllowed = (contextSenderId) => {
+		if (!isRoom || !contextSenderId) return true;
+		if (effectiveRoomUsers.length > 0) return resolveMatrixAllowListMatch({
+			allowList: effectiveRoomUsers,
+			userId: contextSenderId
+		}).allowed;
+		if (groupPolicy === "allowlist" && effectiveGroupAllowFrom.length > 0) return resolveMatrixAllowListMatch({
+			allowList: effectiveGroupAllowFrom,
+			userId: contextSenderId
+		}).allowed;
+		return true;
+	};
+	const shouldIncludeRoomContextSender = (kind, contextSenderId) => evaluateSupplementalContextVisibility({
+		mode: contextVisibilityMode,
+		kind,
+		senderAllowed: isRoomContextSenderAllowed(contextSenderId)
+	}).include;
+	let threadContext = ingress.threadContext ?? (threadRootId ? await resolveThreadContext({
+		roomId,
+		eventId: threadRootId
+	}) : void 0);
+	if (threadContext?.senderId && !shouldIncludeRoomContextSender("thread", threadContext.senderId)) {
+		logVerboseMessage(`matrix: drop thread root context (mode=${contextVisibilityMode})`);
+		threadContext = void 0;
+	}
+	let replyContext;
+	if (replyToEventId && replyToEventId === threadRootId && threadContext?.summary) replyContext = {
+		summary: threadContext.summary,
+		senderLabel: threadContext.senderLabel,
+		senderId: threadContext.senderId
+	};
+	else replyContext = replyToEventId ? await resolveReplyContext({
+		roomId,
+		eventId: replyToEventId
+	}) : void 0;
+	const replySenderAllowed = !replyContext?.senderId || isRoomContextSenderAllowed(replyContext.senderId);
+	const roomName = (isRoom ? await getRoomInfo(roomId) : void 0)?.name;
+	const envelopeFrom = isDirectMessage ? senderName : roomName ?? roomId;
+	const textWithId = `${bodyText}\n[matrix event id: ${messageId} room: ${roomId}]`;
+	const storePath = resolveStorePathImpl(cfg.session?.store, { agentId: _route.agentId });
+	const buildEnvelope = createChannelInboundEnvelopeBuilderImpl({
+		cfg,
+		route: _route
+	});
+	const sharedDmNoticeSessionKey = threadTarget ? _route.mainSessionKey || _route.sessionKey : _route.sessionKey;
+	const sharedDmContextNotice = isDirectMessage ? hasExplicitSessionBinding ? null : resolveMatrixSharedDmContextNotice({
+		storePath,
+		sessionKey: sharedDmNoticeSessionKey,
+		roomId,
+		accountId: _route.accountId,
+		dmSessionScope,
+		sentRooms: sharedDmContextNoticeRooms,
+		logVerboseMessage
+	}) : null;
+	const body = buildEnvelope({
+		channel: "Matrix",
+		from: envelopeFrom,
+		timestamp: eventTs ?? void 0,
+		body: textWithId
+	});
+	const groupSystemPrompt = normalizeOptionalString(roomConfig?.systemPrompt);
+	const quoteHidden = Boolean(replyContext && !evaluateSupplementalContextVisibility({
+		mode: contextVisibilityMode,
+		kind: "quote",
+		senderAllowed: replySenderAllowed
+	}).include);
+	const channelIngress = await resolveMessageIngress({
+		agentId: _route.agentId,
+		sessionKey: _route.sessionKey,
+		nativeChannelId: roomId,
+		messageId,
+		inboundEventKind: "user_request"
+	}, {
+		kind: isDirectMessage ? "direct" : "channel",
+		id: roomId,
+		threadId: threadTarget
+	});
+	const ctxPayload = core.channel.inbound.buildContext({
+		channelIngress,
+		channel: "matrix",
+		contextVisibility: contextVisibilityMode,
+		finalize: finalizeInboundContext,
+		supplemental: {
+			quote: replyContext ? {
+				id: threadTarget ? void 0 : replyToEventId ?? void 0,
+				body: replyContext.summary,
+				sender: replyContext.senderLabel,
+				senderAllowed: replySenderAllowed
+			} : void 0,
+			thread: {
+				starterBody: threadContext?.threadStarterBody,
+				senderAllowed: threadContext ? true : void 0
+			},
+			groupSystemPrompt: isRoom ? groupSystemPrompt : void 0
+		},
+		media: await toInboundMediaFactsWithMetadata(media ? [{
+			path: media.path,
+			url: media.path,
+			contentType: media.contentType,
+			transcribed: preflightAudioTranscript !== void 0
+		}] : void 0),
+		messageId,
+		timestamp: eventTs ?? void 0,
+		from: isDirectMessage ? `matrix:${senderId}` : `matrix:channel:${roomId}`,
+		sender: {
+			id: senderId,
+			name: senderName,
+			username: senderId.split(":")[0]?.replace(/^@/, "")
+		},
+		conversation: {
+			kind: isDirectMessage ? "direct" : "channel",
+			id: roomId,
+			label: envelopeFrom,
+			nativeChannelId: roomId,
+			threadId: threadTarget
+		},
+		route: {
+			..._route,
+			routeSessionKey: _route.sessionKey,
+			parentSessionKey: threadTarget && _route.matchedBy !== "binding.channel" ? _route.mainSessionKey : void 0
+		},
+		reply: {
+			to: `room:${roomId}`,
+			replyToId: threadTarget ? void 0 : replyToEventId ?? void 0,
+			messageThreadId: threadTarget,
+			nativeChannelId: roomId
+		},
+		message: {
+			body,
+			rawBody: bodyText,
+			commandBody: commandBodyText,
+			bodyForAgent: bodyText,
+			inboundHistory: inboundHistory && inboundHistory.length > 0 ? inboundHistory : void 0
+		},
+		sessionTranscript: { historyLimit: isRoom ? historyLimit : 0 },
+		access: {
+			...isRoom ? { mentions: {
+				canDetectMention: true,
+				wasMentioned,
+				requireMention: shouldRequireMention
+			} } : {},
+			commands: { authorized: commandAuthorized }
+		},
+		extra: {
+			GroupSubject: isRoom ? roomName ?? roomId : void 0,
+			GroupId: isRoom ? roomId : void 0,
+			...locationPayload?.context,
+			CommandSource: "text",
+			NativeDirectUserId: isDirectMessage ? senderId : void 0
+		}
+	});
+	if (quoteHidden) logVerboseMessage(`matrix: drop reply context (mode=${contextVisibilityMode})`);
+	logVerboseMessage(`matrix inbound: room=${roomId} from=${senderId} preview="${truncateUtf16Safe(bodyText, 200).replace(/\n/g, "\\n")}"`);
+	const replyTarget = ctxPayload.To;
+	if (!replyTarget) {
+		runtime.error?.("matrix: missing reply target");
+		return null;
+	}
+	const { ackReaction, ackReactionScope: ackScope } = resolveMatrixAckReactionConfig({
+		cfg,
+		agentId: _route.agentId,
+		accountId
+	});
+	if (Boolean(ackReaction && core.channel.reactions.shouldAckReaction({
+		scope: ackScope,
+		isDirect: isDirectMessage,
+		isGroup: isRoom,
+		isMentionableGroup: isRoom,
+		canDetectMention,
+		effectiveWasMentioned,
+		shouldBypassMention
+	})) && messageId) loadMatrixSendModule().then(({ reactMatrixMessage }) => reactMatrixMessage(roomId, messageId, ackReaction, { client })).catch((err) => {
+		logVerboseMessage(`matrix react failed for room ${roomId}: ${String(err)}`);
+	});
+	if (messageId) loadMatrixSendModule().then(({ sendReadReceiptMatrix }) => sendReadReceiptMatrix(roomId, messageId, client)).catch((err) => {
+		logVerboseMessage(`matrix: read receipt failed room=${roomId} id=${messageId}: ${String(err)}`);
+	});
+	return {
+		replyToEventId,
+		threadTarget,
+		storePath,
+		ctxPayload,
+		replyTarget,
+		sharedDmContextNotice
+	};
+}
+//#endregion
+//#region extensions/matrix/src/matrix/monitor/handler-draft-controller.ts
+async function createMatrixDraftController(params) {
+	const { streaming, previewToolProgressEnabled, replyToMode, messageId, threadTarget, accountConfig, cfg, accountId, roomId, client, logVerboseMessage } = params;
+	const draftStreamingEnabled = streaming !== "off";
+	const quietDraftStreaming = streaming === "quiet" || streaming === "progress";
+	const progressDraftStreaming = streaming === "progress";
+	const draftReplyToId = replyToMode !== "off" && !threadTarget ? messageId : void 0;
+	const draftStream = draftStreamingEnabled ? await loadMatrixDraftStream().then(({ createMatrixDraftStream }) => createMatrixDraftStream({
+		roomId,
+		client,
+		cfg,
+		mode: quietDraftStreaming ? "quiet" : "partial",
+		threadId: threadTarget,
+		replyToId: draftReplyToId,
+		preserveReplyId: replyToMode === "all",
+		accountId,
+		log: logVerboseMessage
+	})) : void 0;
+	const shouldSuppressDefaultToolProgressMessages = Boolean(draftStream) && (previewToolProgressEnabled || progressDraftStreaming);
+	let currentDraftMessageGeneration = 0;
+	let currentDraftBlockOffset = 0;
+	let latestDraftFullText = "";
+	const pendingDraftBoundaries = [];
+	const latestQueuedDraftBoundaryOffsets = /* @__PURE__ */ new Map();
+	let currentDraftReplyToId = draftReplyToId;
+	const progressConfigEntry = accountConfig ?? cfg.channels?.matrix;
+	const progressSeed = `${accountId}:${roomId}`;
+	const progressDraft = createChannelProgressDraftCompositor({
+		preparedItems: true,
+		entry: progressConfigEntry,
+		mode: streaming === "quiet" ? "partial" : streaming,
+		active: Boolean(draftStream),
+		seed: progressSeed,
+		formatLine: formatMatrixToolProgressMarkdownCode,
+		update: async (text, options) => {
+			const previewText = text.replace(/^• /gmu, "- ");
+			if (!draftStream) return false;
+			draftStream.update(previewText);
+			if (options?.flush) await draftStream.flush();
+			return Boolean(draftStream.eventId());
+		},
+		deleteCurrent: () => draftStream?.deleteCurrentMessage()
+	});
+	const previewLifecycle = createLivePreviewLifecycle({
+		draft: draftStream ? {
+			flush: draftStream.flush,
+			id: draftStream.eventId,
+			seal: draftStream.seal,
+			discardPending: draftStream.discardPending,
+			clear: draftStream.clear
+		} : void 0,
+		cleanupUndelivered: true,
+		onFinalStarted: () => progressDraft.markFinalReplyStarted(),
+		onFinalDelivered: () => progressDraft.markFinalReplyDelivered(),
+		onCleanupFailure: (err) => logVerboseMessage(`matrix draft preview cleanup failed: ${String(err)}`)
+	});
+	const buildPreviewToolProgressReplyOptions = () => {
+		if (!shouldSuppressDefaultToolProgressMessages) return {};
+		return {
+			suppressDefaultToolProgressMessages: true,
+			progressPreambleEnabled: true,
+			commentaryProgressEnabled: progressDraft.commentaryProgressEnabled,
+			onToolStart: progressDraft.pushToolEvent,
+			onItemEvent: progressDraft.pushItemEvent,
+			onPlanUpdate: async (payload) => {
+				if (payload.phase !== "update") return false;
+				return await progressDraft.pushPlanProgress(payload.steps, {
+					explanation: payload.explanation,
+					explanationFormat: payload.explanationFormat
+				});
+			},
+			onApprovalEvent: (payload) => progressDraft.pushApprovalEvent(payload)
+		};
+	};
+	const updateDraftFromLatestFullText = () => {
+		const nextDraftBoundaryOffset = pendingDraftBoundaries.find((boundary) => boundary.messageGeneration === currentDraftMessageGeneration)?.endOffset;
+		const blockText = latestDraftFullText.slice(currentDraftBlockOffset, nextDraftBoundaryOffset);
+		if (blockText) draftStream?.update(blockText);
+	};
+	const queueDraftBlockBoundary = (payload, context) => {
+		const payloadTextLength = payload.text?.length ?? 0;
+		const messageGeneration = context?.assistantMessageIndex ?? currentDraftMessageGeneration;
+		const nextDraftBoundaryOffset = (latestQueuedDraftBoundaryOffsets.get(messageGeneration) ?? 0) + payloadTextLength;
+		latestQueuedDraftBoundaryOffsets.set(messageGeneration, nextDraftBoundaryOffset);
+		pendingDraftBoundaries.push({
+			messageGeneration,
+			endOffset: nextDraftBoundaryOffset
+		});
+	};
+	const advanceDraftBlockBoundary = (options) => {
+		const completedBoundary = pendingDraftBoundaries.shift();
+		if (completedBoundary) {
+			if (!pendingDraftBoundaries.some((entry) => entry.messageGeneration === completedBoundary.messageGeneration)) latestQueuedDraftBoundaryOffsets.delete(completedBoundary.messageGeneration);
+			if (completedBoundary.messageGeneration === currentDraftMessageGeneration) currentDraftBlockOffset = completedBoundary.endOffset;
+			return;
+		}
+		if (options?.fallbackToLatestEnd) currentDraftBlockOffset = latestDraftFullText.length;
+	};
+	const resetDraftBlockOffsets = () => {
+		currentDraftMessageGeneration += 1;
+		currentDraftBlockOffset = 0;
+		latestDraftFullText = "";
+	};
+	const resetDraftDeliveryState = async () => {
+		await draftStream?.discardPending();
+		draftStream?.reset();
+		previewLifecycle.reset();
+		currentDraftMessageGeneration = 0;
+		currentDraftBlockOffset = 0;
+		latestDraftFullText = "";
+		pendingDraftBoundaries.length = 0;
+		latestQueuedDraftBoundaryOffsets.clear();
+		currentDraftReplyToId = draftReplyToId;
+		progressDraft.beginNewTurn({ force: true });
+	};
+	return {
+		draftStream,
+		previewLifecycle,
+		cancelProgressDraft: () => progressDraft.cancel(),
+		buildPreviewToolProgressReplyOptions,
+		queueDraftBlockBoundary,
+		advanceDraftBlockBoundary,
+		resetDraftBlockOffsets,
+		beginAssistantMessage: () => progressDraft.beginAssistantMessage(),
+		resetDraftDeliveryState,
+		updateDraftFromLatestFullText,
+		beginDraftGeneration: () => {
+			previewLifecycle.reset();
+			progressDraft.beginNewTurn({ force: true });
+		},
+		currentReplyToId: () => currentDraftReplyToId,
+		resetReplyToIdForNextBlock: () => {
+			currentDraftReplyToId = replyToMode === "all" ? draftReplyToId : void 0;
+		},
+		onPartialReply: (text) => {
+			if (progressDraftStreaming) return false;
+			latestDraftFullText = text;
+			if (text.trim()) progressDraft.resetActivity({ suppressed: true });
+			updateDraftFromLatestFullText();
+			return false;
+		}
+	};
+}
+//#endregion
+//#region extensions/matrix/src/matrix/monitor/room-history.ts
+/** Maximum entries retained per room (hard cap to bound memory). */
+const DEFAULT_MAX_QUEUE_SIZE = 200;
+/** Maximum number of rooms to retain queues for (FIFO eviction beyond this). */
+const DEFAULT_MAX_ROOM_QUEUES = 1e3;
+/** Maximum number of (agentId, roomId) watermark entries to retain. */
+const MAX_WATERMARK_ENTRIES = 5e3;
+/** Maximum prepared trigger snapshots retained per room for retry reuse. */
+const MAX_PREPARED_TRIGGER_ENTRIES = 500;
+/** Maximum thread queues retained per room (FIFO eviction beyond this). */
+const MAX_THREAD_QUEUES_PER_ROOM = 200;
+function createRoomHistoryTracker(maxQueueSize = DEFAULT_MAX_QUEUE_SIZE, maxRoomQueues = DEFAULT_MAX_ROOM_QUEUES, maxWatermarkEntries = MAX_WATERMARK_ENTRIES, maxPreparedTriggerEntries = MAX_PREPARED_TRIGGER_ENTRIES) {
+	const roomQueues = /* @__PURE__ */ new Map();
+	/** Maps `{agentId, roomId, scope}` → absolute consumed-up-to index */
+	const agentWatermarks = /* @__PURE__ */ new Map();
+	let nextQueueGeneration = 1;
+	function clearWatermarks(roomId, threadRootId) {
+		for (const key of agentWatermarks.keys()) {
+			const parsed = JSON.parse(key);
+			if (parsed?.roomId === roomId && (threadRootId === void 0 || parsed.scope === threadRootId)) agentWatermarks.delete(key);
+		}
+	}
+	function createHistoryQueue() {
+		return {
+			entries: [],
+			baseIndex: 0,
+			generation: nextQueueGeneration++,
+			preparedTriggers: /* @__PURE__ */ new Map()
+		};
+	}
+	function getOrCreateQueue(roomId) {
+		let queue = roomQueues.get(roomId);
+		if (!queue) {
+			queue = {
+				...createHistoryQueue(),
+				threadQueues: /* @__PURE__ */ new Map()
+			};
+			roomQueues.set(roomId, queue);
+			if (roomQueues.size > maxRoomQueues) {
+				const oldest = roomQueues.keys().next().value;
+				if (oldest !== void 0) {
+					roomQueues.delete(oldest);
+					clearWatermarks(oldest);
+				}
+			}
+		}
+		return queue;
+	}
+	function getOrCreateThreadQueue(roomId, roomQueue, threadRootId) {
+		let queue = roomQueue.threadQueues.get(threadRootId);
+		if (!queue) {
+			queue = createHistoryQueue();
+			roomQueue.threadQueues.set(threadRootId, queue);
+			if (roomQueue.threadQueues.size > MAX_THREAD_QUEUES_PER_ROOM) {
+				const oldest = roomQueue.threadQueues.keys().next().value;
+				if (oldest !== void 0) {
+					roomQueue.threadQueues.delete(oldest);
+					clearWatermarks(roomId, oldest);
+				}
+			}
+		}
+		return queue;
+	}
+	function getScopedQueue(roomId, threadRootId) {
+		const roomQueue = getOrCreateQueue(roomId);
+		return threadRootId ? getOrCreateThreadQueue(roomId, roomQueue, threadRootId) : roomQueue;
+	}
+	function findScopedQueue(roomId, threadRootId) {
+		const roomQueue = roomQueues.get(roomId);
+		if (!roomQueue) return;
+		return threadRootId ? roomQueue.threadQueues.get(threadRootId) : roomQueue;
+	}
+	function appendToQueue(queue, entry) {
+		queue.entries.push(entry);
+		if (queue.entries.length > maxQueueSize) {
+			const overflow = queue.entries.length - maxQueueSize;
+			queue.entries.splice(0, overflow);
+			queue.baseIndex += overflow;
+		}
+		return {
+			snapshotIdx: queue.baseIndex + queue.entries.length,
+			queueGeneration: queue.generation
+		};
+	}
+	function wmKey(agentId, roomId, threadRootId) {
+		return JSON.stringify({
+			agentId,
+			roomId,
+			scope: threadRootId ?? "main"
+		});
+	}
+	function preparedTriggerKey(agentId, messageId) {
+		if (!messageId?.trim()) return null;
+		return `${agentId}:${messageId.trim()}`;
+	}
+	function rememberWatermark(key, snapshotIdx) {
+		const nextSnapshotIdx = Math.max(agentWatermarks.get(key) ?? 0, snapshotIdx);
+		if (agentWatermarks.has(key)) agentWatermarks.delete(key);
+		setBoundedMap(agentWatermarks, key, nextSnapshotIdx, maxWatermarkEntries);
+	}
+	function markConsumedAfterReservedGap(queue, key, firstReservedRel, snapshotIdx) {
+		const endRel = Math.min(snapshotIdx - queue.baseIndex, queue.entries.length);
+		for (let rel = firstReservedRel + 1; rel < endRel; rel += 1) {
+			const entry = queue.entries[rel];
+			if (!entry || entry.reserved || entry.discarded) continue;
+			entry.consumedBy ??= /* @__PURE__ */ new Set();
+			entry.consumedBy.add(key);
+		}
+	}
+	function rememberPreparedTrigger(queue, retryKey, prepared) {
+		if (queue.preparedTriggers.has(retryKey)) queue.preparedTriggers.delete(retryKey);
+		setBoundedMap(queue.preparedTriggers, retryKey, prepared, maxPreparedTriggerEntries);
+		return prepared;
+	}
+	function computePendingHistory(queue, agentId, roomId, limit, endAbsExclusive = queue.baseIndex + queue.entries.length, startAbsOverride, threadRootId) {
+		if (limit <= 0 || queue.entries.length === 0) return [];
+		const key = wmKey(agentId, roomId, threadRootId);
+		const wm = startAbsOverride ?? agentWatermarks.get(key) ?? 0;
+		const startRel = Math.max(wm, queue.baseIndex) - queue.baseIndex;
+		const endRel = Math.max(startRel, Math.min(endAbsExclusive - queue.baseIndex, queue.entries.length));
+		const available = queue.entries.slice(startRel, endRel).filter((entry) => !entry.discarded && !entry.reserved && !entry.consumedBy?.has(key));
+		return available.length > limit ? available.slice(-limit) : available;
+	}
+	function prepareTrigger(agentId, roomId, limit, entry, threadRootId, reservedSlot) {
+		let slot = reservedSlot;
+		const queue = getScopedQueue(roomId, threadRootId);
+		if (slot) {
+			const rel = slot.slotIdx - queue.baseIndex;
+			if (queue.generation !== slot.queueGeneration || rel < 0 || rel >= queue.entries.length) slot = void 0;
+		}
+		const retryKey = preparedTriggerKey(agentId, entry.messageId);
+		if (retryKey) {
+			const prepared = queue.preparedTriggers.get(retryKey);
+			if (prepared) {
+				if (slot) discardPending(roomId, slot, threadRootId);
+				return rememberPreparedTrigger(queue, retryKey, prepared);
+			}
+		}
+		if (slot) queue.entries[slot.slotIdx - queue.baseIndex] = entry;
+		const prepared = {
+			history: computePendingHistory(queue, agentId, roomId, limit, slot?.slotIdx, slot?.watermarkIdx, threadRootId),
+			...slot ? {
+				snapshotIdx: slot.slotIdx + 1,
+				queueGeneration: queue.generation
+			} : appendToQueue(queue, entry)
+		};
+		if (retryKey) return rememberPreparedTrigger(queue, retryKey, prepared);
+		return prepared;
+	}
+	function finalizePending(roomId, slot, entry, threadRootId) {
+		const queue = findScopedQueue(roomId, threadRootId);
+		if (!queue || queue.generation !== slot.queueGeneration) return;
+		const rel = slot.slotIdx - queue.baseIndex;
+		if (rel < 0 || rel >= queue.entries.length) return;
+		queue.entries[rel] = entry;
+	}
+	function discardPending(roomId, slot, threadRootId) {
+		finalizePending(roomId, slot, {
+			sender: "",
+			body: "",
+			messageId: void 0,
+			discarded: true
+		}, threadRootId);
+	}
+	return {
+		recordPending(roomId, entry, threadRootId) {
+			appendToQueue(getScopedQueue(roomId, threadRootId), entry);
+		},
+		reservePending(agentId, roomId, entry, threadRootId) {
+			const snapshot = appendToQueue(getScopedQueue(roomId, threadRootId), {
+				...entry,
+				reserved: true
+			});
+			return {
+				...snapshot,
+				slotIdx: snapshot.snapshotIdx - 1,
+				watermarkIdx: agentWatermarks.get(wmKey(agentId, roomId, threadRootId)) ?? 0
+			};
+		},
+		finalizePending,
+		discardPending,
+		prepareTrigger,
+		consumeHistory(agentId, roomId, snapshot, messageId, threadRootId) {
+			const key = wmKey(agentId, roomId, threadRootId);
+			const queue = findScopedQueue(roomId, threadRootId);
+			if (!queue) {
+				agentWatermarks.delete(key);
+				return;
+			}
+			if (queue.generation !== snapshot.queueGeneration) return;
+			const firstReservedRel = queue.entries.findIndex((entry, index) => entry.reserved === true && queue.baseIndex + index < snapshot.snapshotIdx);
+			if (firstReservedRel >= 0) markConsumedAfterReservedGap(queue, key, firstReservedRel, snapshot.snapshotIdx);
+			rememberWatermark(key, firstReservedRel >= 0 ? queue.baseIndex + firstReservedRel : snapshot.snapshotIdx);
+			const retryKey = preparedTriggerKey(agentId, messageId);
+			if (retryKey) queue.preparedTriggers.delete(retryKey);
+		}
+	};
+}
+//#endregion
+//#region extensions/matrix/src/matrix/monitor/handler-ingress-access.ts
+async function resolveMatrixIngressAccess(config) {
+	const { handler, params: paramsLocal, roomId, event, eventTs, senderId, isReactionEvent, readStoreAllowFrom, shouldSendPairingReply, resolveLiveAccountAllowlists, roomHistoryTracker, commitInboundEventIfClaimed } = config;
+	const { core, cfg, accountId, accountConfig, client, logVerboseMessage, groupPolicy, dmEnabled, dmPolicy, dmThreadReplies, threadReplies, roomsConfig, accountAllowBots, configuredBotUserIds, needsRoomAliasesForConfig, getRoomInfo, getMemberDisplayName } = handler;
+	const content = paramsLocal.content;
+	const isDirectMessage = paramsLocal.isDirectMessage;
+	const isRoom = !isDirectMessage;
+	const { audioPreflightMode, locationPayload, reservedHistorySlot, selfUserId } = paramsLocal;
+	const messageId = event.event_id ?? "";
+	const threadRootId = resolveMatrixThreadRootId(content);
+	const thread = resolveMatrixThreadRouting({
+		isDirectMessage,
+		threadReplies,
+		dmThreadReplies,
+		messageId,
+		threadRootId
+	});
+	const historyThreadId = threadRootId ? thread.threadId : void 0;
+	let reservedHistorySlotConsumed = false;
+	const discardReservedHistorySlot = () => {
+		if (reservedHistorySlot && !reservedHistorySlotConsumed) {
+			roomHistoryTracker.discardPending(roomId, reservedHistorySlot, historyThreadId);
+			reservedHistorySlotConsumed = true;
+		}
+	};
+	const markReservedHistorySlotConsumed = () => {
+		reservedHistorySlotConsumed = true;
+	};
+	const commitInboundEventIfClaimedAndDiscardReserved = async () => {
+		discardReservedHistorySlot();
+		await commitInboundEventIfClaimed();
+	};
+	if (isRoom && groupPolicy === "disabled") {
+		await commitInboundEventIfClaimedAndDiscardReserved();
+		return;
+	}
+	const roomInfoForConfig = isRoom && needsRoomAliasesForConfig ? await getRoomInfo(roomId, { includeAliases: true }) : void 0;
+	const roomAliasesForConfig = roomInfoForConfig ? [roomInfoForConfig.canonicalAlias ?? "", ...roomInfoForConfig.altAliases].filter(Boolean) : [];
+	const roomConfigInfo = isRoom ? resolveMatrixRoomConfig({
+		rooms: roomsConfig,
+		roomId,
+		aliases: roomAliasesForConfig
+	}) : void 0;
+	const roomConfig = roomConfigInfo?.config;
+	const allowBotsMode = resolveMatrixAllowBotsMode(roomConfig?.allowBots ?? accountAllowBots);
+	const isConfiguredBotSender = configuredBotUserIds.has(senderId);
+	const roomMatchMeta = roomConfigInfo ? `matchKey=${roomConfigInfo.matchKey ?? "none"} matchSource=${roomConfigInfo.matchSource ?? "none"}` : "matchKey=none matchSource=none";
+	if (isConfiguredBotSender && allowBotsMode === "off") {
+		logVerboseMessage(`matrix: drop configured bot sender=${senderId} (allowBots=false${isDirectMessage ? "" : `, ${roomMatchMeta}`})`);
+		await commitInboundEventIfClaimedAndDiscardReserved();
+		return;
+	}
+	const botLoopProtection = isConfiguredBotSender && senderId !== selfUserId ? {
+		scopeId: accountId,
+		conversationId: roomId,
+		senderId,
+		receiverId: selfUserId,
+		config: mergePairLoopGuardConfig(accountConfig?.botLoopProtection, roomConfig?.botLoopProtection),
+		defaultsConfig: cfg.channels?.defaults?.botLoopProtection,
+		defaultEnabled: true,
+		nowMs: eventTs ?? void 0
+	} : void 0;
+	if (isRoom && roomConfig && !roomConfigInfo?.allowed) {
+		logVerboseMessage(`matrix: room disabled room=${roomId} (${roomMatchMeta})`);
+		await commitInboundEventIfClaimedAndDiscardReserved();
+		return;
+	}
+	if (isRoom && groupPolicy === "allowlist") {
+		if (!roomConfigInfo?.allowlistConfigured) {
+			logVerboseMessage(`matrix: drop room message (no allowlist, ${roomMatchMeta})`);
+			await commitInboundEventIfClaimedAndDiscardReserved();
+			return;
+		}
+		if (!roomConfig) {
+			logVerboseMessage(`matrix: drop room message (not in allowlist, ${roomMatchMeta})`);
+			await commitInboundEventIfClaimedAndDiscardReserved();
+			return;
+		}
+	}
+	let senderNamePromise = null;
+	const getSenderName = async () => {
+		senderNamePromise ??= getMemberDisplayName(roomId, senderId).catch(() => senderId);
+		return await senderNamePromise;
+	};
+	const storeAllowFrom = isDirectMessage && dmPolicy !== "allowlist" && dmPolicy !== "open" ? await readStoreAllowFrom() : [];
+	const roomUsers = roomConfig?.users ?? [];
+	const { liveCfg, liveDmAllowFrom, liveGroupAllowFrom } = await resolveLiveAccountAllowlists();
+	const accessState = await resolveMatrixMonitorAccessState({
+		allowFrom: liveDmAllowFrom,
+		storeAllowFrom,
+		dmPolicy,
+		groupPolicy,
+		groupAllowFrom: liveGroupAllowFrom,
+		roomUsers,
+		senderId,
+		isRoom,
+		conversationId: roomId,
+		accountId,
+		eventKind: isReactionEvent ? "reaction" : "message"
+	});
+	const { effectiveGroupAllowFrom, effectiveRoomUsers, messageIngress } = accessState;
+	const ingressDecision = messageIngress.ingress;
+	if (isDirectMessage) {
+		if (!dmEnabled || dmPolicy === "disabled") {
+			await commitInboundEventIfClaimedAndDiscardReserved();
+			return;
+		}
+		const senderReason = messageIngress.senderAccess.reasonCode;
+		if (ingressDecision.decision !== "allow") {
+			if (ingressDecision.admission === "pairing-required") {
+				const senderName = await getSenderName();
+				const { code, created } = await core.channel.pairing.upsertPairingRequest({
+					channel: "matrix",
+					id: senderId,
+					accountId,
+					meta: { name: senderName }
+				});
+				if (shouldSendPairingReply(senderId, created)) {
+					const pairingReply = core.channel.pairing.buildPairingReply({
+						channel: "matrix",
+						idLine: `Your Matrix user id: ${senderId}`,
+						code
+					});
+					logVerboseMessage(created ? `matrix pairing request sender=${senderId} name=${senderName ?? "unknown"} (reason=${senderReason})` : `matrix pairing reminder sender=${senderId} name=${senderName ?? "unknown"} (reason=${senderReason})`);
+					try {
+						const { sendMessageMatrix } = await loadMatrixSendModule();
+						await sendMessageMatrix(`room:${roomId}`, created ? pairingReply : `${pairingReply}\n\nPairing request is still pending approval. Reusing existing code.`, {
+							client,
+							cfg,
+							accountId
+						});
+						await commitInboundEventIfClaimed();
+					} catch (err) {
+						logVerboseMessage(`matrix pairing reply failed for ${senderId}: ${String(err)}`);
+						discardReservedHistorySlot();
+						return;
+					}
+				} else {
+					logVerboseMessage(`matrix pairing reminder suppressed sender=${senderId} (cooldown)`);
+					await commitInboundEventIfClaimedAndDiscardReserved();
+				}
+			}
+			if (isReactionEvent || dmPolicy !== "pairing") {
+				logVerboseMessage(`matrix: blocked ${isReactionEvent ? "reaction" : "dm"} sender ${senderId} (dmPolicy=${dmPolicy}, reason=${senderReason})`);
+				await commitInboundEventIfClaimedAndDiscardReserved();
+			}
+			return;
+		}
+	}
+	if (isRoom && ingressDecision.decision !== "allow") {
+		logVerboseMessage(`matrix: blocked sender ${senderId} (ingress=${ingressDecision.reasonCode}, ${roomMatchMeta})`);
+		await commitInboundEventIfClaimedAndDiscardReserved();
+		return;
+	}
+	if (isRoom) logVerboseMessage(`matrix: allow room ${roomId} (${roomMatchMeta})`);
+	if (isReactionEvent) {
+		const senderName = await getSenderName();
+		const { handleInboundMatrixReaction } = await loadMatrixReactionEvents();
+		await handleInboundMatrixReaction({
+			client,
+			core,
+			cfg,
+			accountId,
+			roomId,
+			event,
+			senderId,
+			senderLabel: senderName,
+			selfUserId,
+			isDirectMessage,
+			logVerboseMessage
+		});
+		await commitInboundEventIfClaimedAndDiscardReserved();
+		return;
+	}
+	return {
+		cfg: liveCfg,
+		liveDmAllowFrom,
+		content,
+		messageId,
+		audioPreflightMode,
+		isDirectMessage,
+		isRoom,
+		locationPayload,
+		reservedHistorySlot,
+		threadRootId,
+		thread,
+		historyThreadId,
+		discardReservedHistorySlot,
+		markReservedHistorySlotConsumed,
+		commitInboundEventIfClaimedAndDiscardReserved,
+		roomConfig,
+		allowBotsMode,
+		isConfiguredBotSender,
+		selfUserId,
+		botLoopProtection,
+		roomMatchMeta,
+		getSenderName,
+		accessState,
+		effectiveGroupAllowFrom,
+		effectiveRoomUsers
+	};
+}
+//#endregion
+//#region src/channels/mention-gating.ts
+function resolveBotThreadMentionPolicy(params) {
+	if (!params.isBotOwnedThread || params.requireMentionInBotThreads === void 0) return {
+		requireMention: params.requireMention,
+		implicitMentionKinds: params.implicitMentionKinds
+	};
+	return {
+		requireMention: params.requireMentionInBotThreads,
+		implicitMentionKinds: params.requireMentionInBotThreads ? params.implicitMentionKinds?.filter((kind) => kind === "native") : params.implicitMentionKinds
+	};
+}
+//#endregion
+//#region extensions/matrix/src/matrix/monitor/media.ts
+const MATRIX_MEDIA_DOWNLOAD_IDLE_TIMEOUT_MS = 3e4;
+async function downloadMatrixMedia(params) {
+	if (typeof params.sizeBytes === "number" && params.sizeBytes > params.maxBytes) throw new MatrixMediaSizeLimitError();
+	const options = {
+		maxBytes: params.maxBytes,
+		readIdleTimeoutMs: MATRIX_MEDIA_DOWNLOAD_IDLE_TIMEOUT_MS
+	};
+	let buffer;
+	if (params.file) {
+		if (!params.client.crypto) throw new Error("Cannot decrypt media: crypto not enabled");
+		buffer = await params.client.crypto.decryptMedia(params.file, options);
+		if (buffer.byteLength > params.maxBytes) throw new MatrixMediaSizeLimitError();
+	} else try {
+		buffer = await params.client.downloadContent(params.mxcUrl, options);
+	} catch (err) {
+		if (isMatrixMediaSizeLimitError(err)) throw err;
+		throw new Error(`Matrix media download failed: ${String(err)}`, { cause: err });
+	}
+	const saved = await getMatrixRuntime().channel.media.saveMediaBuffer(buffer, params.contentType, "inbound", params.maxBytes, params.originalFilename);
+	return {
+		path: saved.path,
+		contentType: saved.contentType,
+		placeholder: "[matrix media]"
+	};
+}
+//#endregion
+//#region extensions/matrix/src/matrix/monitor/mentions.ts
+const MATRIX_HTML_ENTITY_RE = /&(?:#x?[0-9a-f]+|amp|apos|gt|lt|nbsp|quot);/gi;
+function decodeVisibleHtmlEntities(value) {
+	return value.replace(MATRIX_HTML_ENTITY_RE, (entity) => {
+		const decoded = decodeHtmlEntities(entity.startsWith("&#") ? entity : entity.toLowerCase());
+		return decoded === "\xA0" ? " " : decoded;
+	});
+}
+function normalizeVisibleMentionText(value) {
+	return normalizeLowercaseStringOrEmpty(decodeVisibleHtmlEntities(value.replace(/<[^>]+>/g, " ").replace(/[\u200b-\u200f\u202a-\u202e\u2060-\u206f]/g, "")).replace(/\s+/g, " "));
+}
+function extractVisibleMentionText(value) {
+	return normalizeVisibleMentionText(value ?? "");
+}
+function resolveMatrixUserLocalpart(userId) {
+	const trimmed = userId.trim();
+	if (!trimmed.startsWith("@")) return null;
+	const colonIndex = trimmed.indexOf(":");
+	if (colonIndex <= 1) return null;
+	return trimmed.slice(1, colonIndex).trim() || null;
+}
+function hasVisibleNativeMatrixUserMention(text, userId) {
+	const localpart = resolveMatrixUserLocalpart(userId);
+	if (!text || !localpart) return false;
+	return new RegExp(String.raw`(?:^|\p{White_Space})(?:${escapeRegExp(userId)}(?=$|\p{White_Space}|:\p{White_Space}|[,!?;](?=$|\p{White_Space}))|${escapeRegExp(`@${localpart}`)}(?=$|\p{White_Space}|:\p{White_Space}))`, "u").test(text);
+}
+function resolveMatrixMentionPrefixCandidates(params) {
+	const candidates = [];
+	const seen = /* @__PURE__ */ new Set();
+	const append = (candidate) => {
+		const trimmed = candidate?.trim();
+		if (!trimmed) return;
+		const normalized = normalizeLowercaseStringOrEmpty(trimmed);
+		if (seen.has(normalized)) return;
+		seen.add(normalized);
+		candidates.push(trimmed);
+	};
+	append(params.userId);
+	const localpart = params.userId ? resolveMatrixUserLocalpart(params.userId) : null;
+	append(localpart ? `@${localpart}` : null);
+	append(params.displayName);
+	append(params.displayName ? `@${params.displayName}` : null);
+	append(params.displayName ? `@[${params.displayName}]` : null);
+	return candidates;
+}
+function stripMatchedMatrixMentionPrefix(text, pattern) {
+	const match = text.match(pattern);
+	if (!match) return null;
+	return text.slice(match[0].length).trimStart();
+}
+function stripNativeMatrixMentionPrefix(text, candidate) {
+	return stripMatchedMatrixMentionPrefix(text, new RegExp(`^\\s*${escapeRegExp(candidate)}(?:\\s*[:,])?(?:\\s+|$)`, "i"));
+}
+function stripRegexMatrixMentionPrefix(text, pattern) {
+	const flags = pattern.flags.replace(/[gy]/g, "");
+	return stripMatchedMatrixMentionPrefix(text, new RegExp(`^\\s*(?:${pattern.source})(?:\\s*[:,])?(?:\\s+|$)`, flags));
+}
+function stripMatrixMentionPrefix(params) {
+	const text = params.text;
+	if (!text) return text;
+	for (const candidate of resolveMatrixMentionPrefixCandidates(params)) {
+		const stripped = stripNativeMatrixMentionPrefix(text, candidate);
+		if (stripped !== null) return stripped;
+	}
+	for (const pattern of params.mentionRegexes ?? []) {
+		const stripped = stripRegexMatrixMentionPrefix(text, pattern);
+		if (stripped !== null) return stripped;
+	}
+	return text;
+}
+function isVisibleMentionLabel(params) {
+	const cleaned = extractVisibleMentionText(params.text);
+	if (!cleaned) return false;
+	if (params.mentionRegexes.some((pattern) => pattern.test(cleaned))) return true;
+	const localpart = resolveMatrixUserLocalpart(params.userId);
+	return [
+		extractVisibleMentionText(params.userId),
+		localpart ? extractVisibleMentionText(localpart) : null,
+		localpart ? extractVisibleMentionText(`@${localpart}`) : null,
+		params.displayName ? extractVisibleMentionText(params.displayName) : null,
+		params.displayName ? extractVisibleMentionText(`@${params.displayName}`) : null,
+		params.displayName ? extractVisibleMentionText(`@[${params.displayName}]`) : null
+	].filter((value) => Boolean(value)).includes(cleaned);
+}
+function hasVisibleRoomMention(value) {
+	const cleaned = extractVisibleMentionText(value);
+	return /(^|[^a-z0-9_])@room\b/i.test(cleaned);
+}
+/**
+* Check if formatted_body contains a matrix.to link whose visible label still
+* looks like a real mention for the given user. Do not trust href alone, since
+* senders can hide arbitrary matrix.to links behind unrelated link text.
+* Many Matrix clients (including Element) use HTML links in formatted_body instead of
+* or in addition to the m.mentions field.
+*/
+function checkFormattedBodyMention(params) {
+	if (!params.formattedBody || !params.userId) return false;
+	for (const match of params.formattedBody.matchAll(/<a\b[^>]*href=(["'])(https:\/\/matrix\.to\/#[^"']+)\1[^>]*>(.*?)<\/a>/gis)) {
+		const href = match[2];
+		const visibleLabel = match[3] ?? "";
+		if (!href) continue;
+		try {
+			const parsed = new URL(href);
+			if (decodeURIComponent(parsed.hash.replace(/^#\/?/, "").trim()) !== params.userId.trim()) continue;
+			if (isVisibleMentionLabel({
+				text: visibleLabel,
+				userId: params.userId,
+				mentionRegexes: params.mentionRegexes,
+				displayName: params.displayName
+			})) return true;
+		} catch {
+			continue;
+		}
+	}
+	return false;
+}
+function resolveMentions(params) {
+	const mentions = params.content["m.mentions"];
+	const mentionedUsers = Array.isArray(mentions?.user_ids) ? new Set(mentions.user_ids) : /* @__PURE__ */ new Set();
+	const textMentioned = getMatrixRuntime().channel.mentions.matchesMentionPatterns(params.text ?? "", params.mentionRegexes);
+	const visibleRoomMention = hasVisibleRoomMention(params.text) || hasVisibleRoomMention(params.content.formatted_body);
+	const mentionedInFormattedBody = params.userId ? checkFormattedBodyMention({
+		formattedBody: params.content.formatted_body,
+		userId: params.userId,
+		displayName: params.displayName,
+		mentionRegexes: params.mentionRegexes
+	}) : false;
+	const metadataBackedUserMention = Boolean(params.userId && mentionedUsers.has(params.userId) && (mentionedInFormattedBody || textMentioned || hasVisibleNativeMatrixUserMention(params.text, params.userId)));
+	const metadataBackedRoomMention = Boolean(mentions?.room) && visibleRoomMention;
+	const explicitMention = mentionedInFormattedBody || metadataBackedUserMention || metadataBackedRoomMention;
+	return {
+		wasMentioned: explicitMention || textMentioned || visibleRoomMention,
+		hasExplicitMention: explicitMention
+	};
+}
+//#endregion
+//#region extensions/matrix/src/matrix/monitor/handler-ingress-content.ts
+async function resolveMatrixIngressContent(config) {
+	const { handler, params: paramsLocal, access, roomId, event, eventType, isPollEvent, eventTs, senderId, roomHistoryTracker, resolveThreadContext, commitInboundEventIfClaimed } = config;
+	const { client, core, accountId, accountConfig, logger, logVerboseMessage, historyLimit, mediaMaxBytes, dmSessionScope, getMemberDisplayName } = handler;
+	const { cfg, liveDmAllowFrom, content: accessContent, messageId, audioPreflightMode, isDirectMessage, isRoom, locationPayload, reservedHistorySlot, threadRootId, thread, historyThreadId, discardReservedHistorySlot, markReservedHistorySlotConsumed, commitInboundEventIfClaimedAndDiscardReserved, roomConfig, allowBotsMode, isConfiguredBotSender, selfUserId, botLoopProtection, roomMatchMeta, getSenderName, accessState, effectiveGroupAllowFrom, effectiveRoomUsers } = access;
+	const { resolveMessageIngress } = accessState;
+	let content = accessContent;
+	let pollSnapshotPromise = null;
+	const getPollSnapshot = async () => {
+		if (!isPollEvent) return null;
+		pollSnapshotPromise ??= fetchMatrixPollSnapshot(client, roomId, event).catch((err) => {
+			logVerboseMessage(`matrix: failed resolving poll snapshot room=${roomId} id=${event.event_id ?? "unknown"}: ${String(err)}`);
+			return null;
+		});
+		return await pollSnapshotPromise;
+	};
+	const mentionPrecheckText = resolveMatrixMentionPrecheckText({
+		eventType,
+		content,
+		locationText: locationPayload?.text
+	});
+	let mediaContent = resolveMatrixInboundMediaContent(content);
+	const mediaUrl = mediaContent.url;
+	const pendingHistoryText = resolveMatrixPendingHistoryText({
+		mentionPrecheckText,
+		content,
+		mediaUrl
+	});
+	const pendingHistoryPollText = !pendingHistoryText && isPollEvent && historyLimit > 0 ? (await getPollSnapshot())?.text : "";
+	if (!mentionPrecheckText && !mediaUrl && !isPollEvent) {
+		await commitInboundEventIfClaimedAndDiscardReserved();
+		return;
+	}
+	let preflightMedia = null;
+	let mediaDownloadFailed = false;
+	let mediaSizeLimitExceeded = false;
+	let preflightAudioTranscript;
+	const downloadMedia = async (mxcUrl) => {
+		try {
+			return await downloadMatrixMedia({
+				client,
+				mxcUrl,
+				contentType: mediaContent.contentType,
+				sizeBytes: mediaContent.sizeBytes,
+				maxBytes: mediaMaxBytes,
+				file: mediaContent.file,
+				originalFilename: mediaContent.originalFilename
+			});
+		} catch (err) {
+			mediaDownloadFailed = true;
+			mediaSizeLimitExceeded = isMatrixMediaSizeLimitError(err);
+			const errorText = formatErrorMessage(err);
+			logVerboseMessage(`matrix: media download failed room=${roomId} id=${event.event_id ?? "unknown"} type=${content.msgtype} error=${errorText}`);
+			logger.warn("matrix media download failed", {
+				roomId,
+				eventId: event.event_id,
+				msgtype: content.msgtype,
+				encrypted: Boolean(mediaContent.file),
+				error: errorText
+			});
+			return null;
+		}
+	};
+	const { route: _route, configuredBinding: _configuredBinding, runtimeBindingId: _runtimeBindingId } = resolveMatrixInboundRoute({
+		cfg,
+		accountId,
+		roomId,
+		senderId,
+		isDirectMessage,
+		dmSessionScope,
+		threadId: thread.threadId,
+		resolveAgentRoute: core.channel.routing.resolveAgentRoute
+	});
+	const hasExplicitSessionBinding = _configuredBinding !== null || _runtimeBindingId !== null;
+	const preflightAudioMediaUrl = mediaUrl?.startsWith("mxc://") ? mediaUrl : void 0;
+	const shouldRunMatrixAudioPreflight = isMatrixAudioContent({
+		msgtype: typeof content.msgtype === "string" ? content.msgtype : void 0,
+		mimetype: mediaContent.contentType
+	}) && isMatrixAudioMediaEnabled(cfg) && preflightAudioMediaUrl !== void 0;
+	if (shouldRunMatrixAudioPreflight && audioPreflightMode === "defer" && isRoom && historyLimit > 0 && !reservedHistorySlot) {
+		const reserved = roomHistoryTracker.reservePending(_route.agentId, roomId, {
+			sender: senderId,
+			body: pendingHistoryText,
+			timestamp: eventTs ?? void 0,
+			messageId
+		}, historyThreadId);
+		return { deferredPrefix: {
+			...paramsLocal,
+			audioPreflightMode: "run",
+			reservedHistorySlot: reserved
+		} };
+	}
+	if (shouldRunMatrixAudioPreflight) {
+		preflightMedia = await downloadMedia(preflightAudioMediaUrl);
+		if (preflightMedia) preflightAudioTranscript = await resolveMatrixPreflightAudioTranscript({
+			mediaPath: preflightMedia.path,
+			mediaContentType: preflightMedia.contentType,
+			cfg,
+			accountId,
+			chatType: isDirectMessage ? "direct" : "channel",
+			originatingTo: `room:${roomId}`,
+			messageThreadId: thread.threadId,
+			sessionKey: _route.sessionKey
+		});
+	}
+	const agentMentionRegexes = core.channel.mentions.buildMentionRegexes(cfg, _route.agentId, {
+		provider: "matrix",
+		conversationId: roomId,
+		providerPolicy: accountConfig?.mentionPatterns
+	});
+	const selfDisplayName = content.formatted_body ? await getMemberDisplayName(roomId, selfUserId).catch(() => void 0) : void 0;
+	const mentionPrecheckTextWithTranscript = preflightAudioTranscript ? [mentionPrecheckText, preflightAudioTranscript].filter(Boolean).join("\n").trim() : mentionPrecheckText;
+	const { wasMentioned, hasExplicitMention } = resolveMentions({
+		content,
+		userId: selfUserId,
+		displayName: selfDisplayName,
+		text: mentionPrecheckTextWithTranscript,
+		mentionRegexes: agentMentionRegexes
+	});
+	if (isConfiguredBotSender && allowBotsMode === "mentions" && !isDirectMessage && !wasMentioned) {
+		logVerboseMessage(`matrix: drop configured bot sender=${senderId} (allowBots=mentions, missing mention, ${roomMatchMeta})`);
+		await commitInboundEventIfClaimedAndDiscardReserved();
+		return;
+	}
+	const allowTextCommands = core.channel.commands.shouldHandleTextCommands({
+		cfg,
+		surface: "matrix"
+	});
+	const commandCheckText = stripMatrixMentionPrefix({
+		text: mentionPrecheckText,
+		userId: selfUserId,
+		displayName: selfDisplayName,
+		mentionRegexes: agentMentionRegexes
+	});
+	const hasControlCommandInMessage = core.channel.text.hasControlCommand(commandCheckText, cfg);
+	const commandAccess = await resolveMatrixMonitorCommandAccess(accessState, {
+		useAccessGroups: true,
+		allowTextCommands,
+		hasControlCommand: hasControlCommandInMessage
+	});
+	const commandAuthorized = commandAccess.authorized;
+	if (isRoom && commandAccess.shouldBlockControlCommand) {
+		logInboundDrop({
+			log: logVerboseMessage,
+			channel: "matrix",
+			reason: "control command (unauthorized)",
+			target: senderId
+		});
+		await commitInboundEventIfClaimedAndDiscardReserved();
+		return;
+	}
+	const configuredRequireMention = isRoom ? roomConfig?.autoReply === true ? false : roomConfig?.autoReply === false ? true : typeof roomConfig?.requireMention === "boolean" ? roomConfig?.requireMention : true : false;
+	const requireMentionInBotThreads = roomConfig?.requireMentionInBotThreads ?? accountConfig?.requireMentionInBotThreads;
+	const threadContext = isRoom && threadRootId && requireMentionInBotThreads !== void 0 ? await resolveThreadContext({
+		roomId,
+		eventId: threadRootId
+	}) : void 0;
+	const { requireMention: shouldRequireMention } = resolveBotThreadMentionPolicy({
+		isBotOwnedThread: threadContext?.senderId === selfUserId,
+		requireMentionInBotThreads,
+		requireMention: configuredRequireMention
+	});
+	const mentionDecision = resolveInboundMentionDecision({
+		facts: {
+			canDetectMention: true,
+			wasMentioned,
+			hasAnyMention: hasExplicitMention
+		},
+		policy: {
+			isGroup: isRoom,
+			requireMention: shouldRequireMention,
+			allowTextCommands,
+			hasControlCommand: hasControlCommandInMessage,
+			commandAuthorized
+		}
+	});
+	const { effectiveWasMentioned, shouldBypassMention } = mentionDecision;
+	const canDetectMention = agentMentionRegexes.length > 0 || hasExplicitMention;
+	if (mentionDecision.shouldSkip) {
+		const pendingHistoryBody = preflightAudioTranscript ? formatAudioTranscriptForAgent(preflightAudioTranscript) : pendingHistoryText || pendingHistoryPollText;
+		if (historyLimit > 0 && pendingHistoryBody) {
+			const pendingEntry = {
+				sender: senderId,
+				body: pendingHistoryBody,
+				timestamp: eventTs ?? void 0,
+				messageId
+			};
+			if (reservedHistorySlot) {
+				roomHistoryTracker.finalizePending(roomId, reservedHistorySlot, pendingEntry, historyThreadId);
+				markReservedHistorySlotConsumed();
+			} else roomHistoryTracker.recordPending(roomId, pendingEntry, historyThreadId);
+		}
+		logger.info("skipping room message", {
+			roomId,
+			reason: "no-mention"
+		});
+		await commitInboundEventIfClaimed();
+		return;
+	}
+	if (preflightAudioTranscript) await matrixPreflightAudio.send({
+		transcript: preflightAudioTranscript,
+		cfg,
+		accountId,
+		originatingTo: `room:${roomId}`,
+		messageThreadId: thread.threadId
+	});
+	if (isPollEvent) {
+		const pollSnapshot = await getPollSnapshot();
+		if (!pollSnapshot) {
+			discardReservedHistorySlot();
+			return;
+		}
+		content = {
+			msgtype: "m.text",
+			body: pollSnapshot.text
+		};
+		mediaContent = resolveMatrixInboundMediaContent(content);
+	}
+	let media = preflightMedia;
+	const finalMediaUrl = mediaContent.url;
+	if (!media && !mediaDownloadFailed && finalMediaUrl?.startsWith("mxc://")) media = await downloadMedia(finalMediaUrl);
+	let bodyText = resolveMatrixInboundBodyText({
+		rawBody: locationPayload?.text ?? mediaContent.body,
+		filename: typeof content.filename === "string" ? content.filename : void 0,
+		mediaPlaceholder: media?.placeholder,
+		msgtype: content.msgtype,
+		hadMediaUrl: Boolean(finalMediaUrl),
+		mediaDownloadFailed,
+		mediaSizeLimitExceeded
+	});
+	if (preflightMedia && bodyText && bodyText !== preflightMedia.placeholder && isLikelyBareFilename(bodyText)) bodyText = preflightMedia.placeholder;
+	if (preflightAudioTranscript) {
+		const transcriptBody = formatAudioTranscriptForAgent(preflightAudioTranscript);
+		bodyText = !bodyText || bodyText === media?.placeholder ? transcriptBody : `${bodyText}\n${transcriptBody}`;
+	}
+	if (!bodyText) {
+		await commitInboundEventIfClaimedAndDiscardReserved();
+		return;
+	}
+	const commandBodyText = hasControlCommandInMessage ? commandCheckText : bodyText;
+	const senderName = await getSenderName();
+	if (_configuredBinding) {
+		const { ensureConfiguredAcpBindingReady } = await loadAcpBindingRuntime();
+		if (!(await ensureConfiguredAcpBindingReady({
+			cfg,
+			configuredBinding: _configuredBinding
+		})).ok) {
+			logInboundDrop({
+				log: logVerboseMessage,
+				channel: "matrix",
+				reason: "configured ACP binding unavailable",
+				target: _configuredBinding.spec.conversationId
+			});
+			discardReservedHistorySlot();
+			return;
+		}
+	}
+	if (_runtimeBindingId) {
+		const { getSessionBindingService } = await loadSessionBindingRuntime();
+		getSessionBindingService().touch(_runtimeBindingId, eventTs ?? void 0, {
+			channel: "matrix",
+			accountId
+		});
+	}
+	const preparedTrigger = isRoom && historyLimit > 0 ? roomHistoryTracker.prepareTrigger(_route.agentId, roomId, historyLimit, {
+		sender: senderName,
+		body: bodyText,
+		timestamp: eventTs ?? void 0,
+		messageId
+	}, historyThreadId, reservedHistorySlot) : void 0;
+	if (reservedHistorySlot && preparedTrigger) markReservedHistorySlotConsumed();
+	return {
+		cfg,
+		liveDmAllowFrom,
+		resolveMessageIngress,
+		route: _route,
+		hasExplicitSessionBinding,
+		roomConfig,
+		isDirectMessage,
+		isRoom,
+		shouldRequireMention,
+		wasMentioned,
+		effectiveWasMentioned,
+		shouldBypassMention,
+		canDetectMention,
+		commandAuthorized,
+		inboundHistory: preparedTrigger ? buildInboundHistoryFromEntries({
+			entries: preparedTrigger.history,
+			limit: historyLimit
+		}) : void 0,
+		senderName,
+		bodyText,
+		commandBodyText,
+		media,
+		preflightAudioTranscript,
+		locationPayload,
+		messageId,
+		triggerSnapshot: preparedTrigger,
+		threadRootId,
+		threadContext,
+		thread,
+		botLoopProtection,
+		effectiveGroupAllowFrom,
+		effectiveRoomUsers
+	};
+}
+//#endregion
+//#region extensions/matrix/src/matrix/monitor/location.ts
+function decodeGeoUriParamValue(value) {
+	try {
+		return decodeURIComponent(value);
+	} catch {
+		return value;
+	}
+}
+function parseGeoUri(value) {
+	const trimmed = value.trim();
+	if (!trimmed) return null;
+	if (!normalizeLowercaseStringOrEmpty(trimmed).startsWith("geo:")) return null;
+	const [coordsPart, ...paramParts] = trimmed.slice(4).split(";");
+	if (!coordsPart) return null;
+	const coords = coordsPart.split(",");
+	if (coords.length < 2) return null;
+	const latitude = parseStrictFiniteNumber(coords[0] ?? "");
+	const longitude = parseStrictFiniteNumber(coords[1] ?? "");
+	if (latitude === void 0 || longitude === void 0) return null;
+	const params = /* @__PURE__ */ new Map();
+	for (const part of paramParts) {
+		const segment = part.trim();
+		if (!segment) continue;
+		const eqIndex = segment.indexOf("=");
+		const rawKey = eqIndex === -1 ? segment : segment.slice(0, eqIndex);
+		const rawValue = eqIndex === -1 ? "" : segment.slice(eqIndex + 1);
+		const key = normalizeLowercaseStringOrEmpty(rawKey);
+		if (!key) continue;
+		const valuePart = rawValue.trim();
+		params.set(key, valuePart ? decodeGeoUriParamValue(valuePart) : "");
+	}
+	const accuracyRaw = params.get("u");
+	return {
+		latitude,
+		longitude,
+		accuracy: accuracyRaw ? parseStrictFiniteNumber(accuracyRaw) : void 0
+	};
+}
+function resolveMatrixLocation(params) {
+	const { eventType, content } = params;
+	if (!(eventType === EventType.Location || eventType === EventType.RoomMessage && content.msgtype === EventType.Location)) return null;
+	const geoUri = normalizeOptionalString(content.geo_uri) ?? "";
+	if (!geoUri) return null;
+	const parsed = parseGeoUri(geoUri);
+	if (!parsed) return null;
+	const caption = normalizeOptionalString(content.body) ?? "";
+	const location = {
+		latitude: parsed.latitude,
+		longitude: parsed.longitude,
+		accuracy: parsed.accuracy,
+		caption: caption || void 0,
+		source: "pin",
+		isLive: false
+	};
+	return {
+		text: formatLocationText(location),
+		context: toLocationContext(location)
+	};
+}
+//#endregion
+//#region extensions/matrix/src/matrix/monitor/handler-ingress-prefix.ts
+async function readMatrixIngressPrefix(config) {
+	const { client, senderId, dropPreStartupMessages, eventTs, eventAge, startupMs, startupGraceMs, event, eventType, eventId, inboundDeduper, roomId, logVerboseMessage, directTracker, claimInboundReplay } = config;
+	const selfUserId = await client.getUserId();
+	if (senderId === selfUserId) return;
+	if (dropPreStartupMessages) {
+		if (typeof eventTs === "number" && eventTs < startupMs - startupGraceMs) return;
+		if (typeof eventTs !== "number" && typeof eventAge === "number" && eventAge > startupGraceMs) return;
+	}
+	const content = event.content;
+	if (eventType === EventType.RoomMessage && isMatrixVerificationRoomMessage({
+		msgtype: content.msgtype,
+		body: content.body
+	})) {
+		logVerboseMessage(`matrix: skip verification/system room message room=${roomId}`);
+		return;
+	}
+	const locationPayload = resolveMatrixLocation({
+		eventType,
+		content
+	});
+	const relates = content["m.relates_to"];
+	if (relates && "rel_type" in relates && relates.rel_type === RelationType.Replace) return;
+	if (hasBundledMatrixReplacementRelation(event)) return;
+	if (eventId && inboundDeduper) {
+		const claim = await inboundDeduper.claim({
+			roomId,
+			eventId
+		});
+		if (claim.kind === "claimed") claimInboundReplay(claim.handle);
+		else if (claim.kind !== "invalid") {
+			logVerboseMessage(`matrix: skip duplicate inbound event room=${roomId} id=${eventId}`);
+			return;
+		}
+	}
+	return {
+		content,
+		isDirectMessage: await directTracker.isDirectMessage({
+			roomId,
+			senderId,
+			selfUserId
+		}),
+		locationPayload,
+		selfUserId
+	};
+}
+//#endregion
+//#region extensions/matrix/src/matrix/monitor/replies.ts
+function joinMatrixVisibleContent(contents) {
+	return contents.filter((content) => Boolean(content)).join("\n");
+}
+function mergeMatrixReplyDeliveryResults(results) {
+	const single = results.length === 1 ? results[0] : void 0;
+	if (single?.visibleReplySent) return single;
+	const visibleResults = results.filter((result) => result.visibleReplySent);
+	if (visibleResults.length === 0) return {
+		visibleReplySent: false,
+		suppression: { reason: "no_visible_result" }
+	};
+	const content = joinMatrixVisibleContent(visibleResults.map((result) => result.content));
+	if (visibleResults.some((result) => result.receipt || result.messageIds?.length)) return createAcceptedChannelDeliveryResult({
+		deliveryResults: visibleResults,
+		content
+	});
+	return {
+		visibleReplySent: true,
+		content
+	};
+}
+function toMatrixPartialDeliveryError(error, settled) {
+	const failedPartial = isChannelPartialDeliveryError(error) ? error.deliveryResult : void 0;
+	const merged = mergeMatrixReplyDeliveryResults([...settled, ...failedPartial ? [failedPartial] : []]);
+	return merged.visibleReplySent ? createChannelPartialDeliveryError(error, {
+		...merged,
+		visibleReplySent: true
+	}) : error;
+}
+function createMatrixReplyDeliveryResult(results) {
+	if (results.length === 0) return mergeMatrixReplyDeliveryResults([]);
+	return createAcceptedChannelDeliveryResult({
+		results: results.map((result) => ({ receipt: result.receipt })),
+		content: joinMatrixVisibleContent(results.map((result) => result.content))
+	});
+}
+function resolveVisibleMatrixReplyText(text) {
+	if (typeof text !== "string") return;
+	const trimmedStart = text.trimStart();
+	if (!trimmedStart) return text;
+	if (normalizeLowercaseStringOrEmpty(trimmedStart).startsWith("reasoning:")) return;
+	const visibleText = stripReasoningTagsFromText(text, {
+		mode: "strict",
+		trim: "none"
+	});
+	return visibleText.trim() ? visibleText : void 0;
+}
+async function deliverMatrixReplies(params) {
+	const core = getMatrixRuntime();
+	const logVerbose = (message) => {
+		if (core.logging.shouldLogVerbose()) params.runtime.log?.(message);
+	};
+	const hasRepliedRef = params.hasRepliedRef ?? { value: false };
+	const acceptedResults = [];
+	try {
+		for (const reply of params.replies) {
+			const visibleText = resolveVisibleMatrixReplyText(reply.text);
+			const { hasMedia, hasText, mediaUrls } = resolveSendableOutboundReplyParts(reply);
+			if (reply.isReasoning === true || !hasMedia && reply.text && visibleText === void 0) {
+				logVerbose("matrix reply suppressed as reasoning-only");
+				continue;
+			}
+			if (!hasText && !hasMedia) {
+				if (reply?.audioAsVoice) {
+					logVerbose("matrix reply has audioAsVoice without media/text; skipping");
+					continue;
+				}
+				params.runtime.error?.("matrix reply missing text/media");
+				continue;
+			}
+			const explicitReplyToId = reply.replyToTag || reply.replyToCurrent ? reply.replyToId?.trim() : void 0;
+			const rawText = visibleText ?? "";
+			const replyToIdForReply = explicitReplyToId || (!params.threadId && params.replyToMode !== "off" && (params.replyToMode === "all" || !hasRepliedRef.value) ? (reply.replyToId ?? params.replyToId)?.trim() : void 0);
+			const fallbackReplyToId = params.threadId ? (reply.replyToId ?? params.replyToId)?.trim() : void 0;
+			const onDeliveryResult = (result) => {
+				acceptedResults.push(result);
+				if (replyToIdForReply) hasRepliedRef.value = true;
+			};
+			const extraContent = resolveMatrixExtraContent(reply);
+			const targets = mediaUrls.length > 0 ? mediaUrls : [void 0];
+			for (const [index, mediaUrl] of targets.entries()) await sendMessageMatrix(params.roomId, index === 0 ? rawText : "", {
+				client: params.client,
+				cfg: params.cfg,
+				...mediaUrl !== void 0 ? {
+					mediaUrl,
+					mediaLocalRoots: params.mediaLocalRoots,
+					audioAsVoice: reply.audioAsVoice
+				} : {},
+				replyToId: replyToIdForReply,
+				fallbackReplyToId,
+				threadId: params.threadId,
+				accountId: params.accountId,
+				extraContent: index === 0 ? extraContent : void 0,
+				onDeliveryResult
+			});
+		}
+	} catch (error) {
+		throw toMatrixPartialDeliveryError(error, [createMatrixReplyDeliveryResult(acceptedResults)]);
+	}
+	return createMatrixReplyDeliveryResult(acceptedResults);
+}
+//#endregion
+//#region extensions/matrix/src/matrix/monitor/handler-reply-dispatcher.ts
+function createMatrixReplyDispatcher(config) {
+	const { cfg, prefixOptions, humanDelay, typingCallbacks, streaming, draftStream, draftController, client, roomId, runtime, replyToMode, threadTarget, replyToEventId, accountId, mediaLocalRoots, logVerboseMessage } = config;
+	const quietDraftStreaming = streaming === "quiet" || streaming === "progress";
+	const hasRepliedRef = { value: false };
+	const deliverPayload = (reply) => deliverMatrixReplies({
+		cfg,
+		replies: [reply],
+		roomId,
+		client,
+		runtime,
+		replyToMode,
+		hasRepliedRef,
+		threadId: threadTarget,
+		replyToId: threadTarget ?? replyToEventId ?? void 0,
+		accountId,
+		mediaLocalRoots
+	});
+	const { previewLifecycle } = draftController;
+	let nonFinalReplyDeliveryFailed = false;
+	const beginNextBlockDraft = () => {
+		draftController.beginDraftGeneration();
+		draftController.advanceDraftBlockBoundary({ fallbackToLatestEnd: true });
+		draftStream?.reset();
+		draftController.resetReplyToIdForNextBlock();
+		draftController.updateDraftFromLatestFullText();
+	};
+	return {
+		turnDispatcherOptions: {
+			...prefixOptions,
+			humanDelay,
+			onReplyStart: typingCallbacks.onReplyStart,
+			onIdle: typingCallbacks.onIdle
+		},
+		deliverReply: async (payload, info) => {
+			const createDraftReceipt = (id) => createPreviewMessageReceipt({
+				id,
+				...threadTarget ? { threadId: threadTarget } : {},
+				...draftController.currentReplyToId() ? { replyToId: draftController.currentReplyToId() } : {}
+			});
+			const createDraftDeliveryResult = (id, content) => {
+				const receipt = createDraftReceipt(id);
+				return {
+					messageIds: receipt.platformMessageIds,
+					receipt,
+					visibleReplySent: true,
+					content
+				};
+			};
+			const settlesPreview = Boolean(draftStream) && info.kind !== "tool" && !payload.isCompactionNotice;
+			const ttsSupplement = getReplyPayloadTtsSupplement(payload);
+			const fallbackPayload = settlesPreview && ttsSupplement && ttsSupplement.visibleTextAlreadyDelivered !== true && !payload.text?.trim() ? {
+				...payload,
+				text: ttsSupplement.spokenText
+			} : payload;
+			const { hasMedia } = resolveSendableOutboundReplyParts(payload);
+			const payloadText = payload.text ?? ttsSupplement?.spokenText;
+			const payloadReplyMismatch = (!threadTarget && replyToMode !== "off" || payload.replyToTag || payload.replyToCurrent) && normalizeOptionalString(payload.replyToId) !== draftController.currentReplyToId();
+			let retainedDraftDelivery;
+			let deliveryResult;
+			try {
+				deliveryResult = (await previewLifecycle.deliver({
+					kind: payload.isCompactionNotice ? "tool" : info.kind === "block" ? "final" : info.kind,
+					payload,
+					isError: payload.isError,
+					adapter: draftStream ? {
+						buildFinalEdit: () => payloadText?.trim() && !payload.isError && !payloadReplyMismatch && !draftStream.mustDeliverFinalNormally() ? { text: payloadText } : void 0,
+						editFinal: async (draftEventId, edit) => {
+							if (draftStream.mustDeliverFinalNormally() || await matrixTextWouldActivateMentions(client, edit.text)) return { visibleReplySent: false };
+							const { editMessageMatrix, prepareMatrixSingleText } = await loadMatrixSendModule();
+							const presentationContent = hasMedia ? void 0 : resolveMatrixExtraContent(payload);
+							const extraContent = {
+								...quietDraftStreaming ? { [MATRIX_OPENCLAW_FINALIZED_PREVIEW_KEY]: true } : {},
+								...presentationContent
+							};
+							if (!quietDraftStreaming && !presentationContent && draftStream.matchesPreparedText(edit.text)) {
+								if (!await draftStream.finalizeLive()) return { visibleReplySent: false };
+							} else await editMessageMatrix(roomId, draftEventId, edit.text, {
+								client,
+								cfg,
+								threadId: threadTarget,
+								accountId,
+								...Object.keys(extraContent).length > 0 ? { extraContent } : {}
+							});
+							return createDraftDeliveryResult(draftEventId, prepareMatrixSingleText(edit.text, {
+								cfg,
+								accountId,
+								preserveWhitespace: true
+							}).convertedText);
+						},
+						createPreviewReceipt: createDraftReceipt,
+						buildSupplementalPayload: () => hasMedia ? ttsSupplement ? buildTtsSupplementMediaPayload(payload) : {
+							...payload,
+							text: void 0
+						} : void 0,
+						deliverSupplemental: deliverPayload,
+						logPreviewEditFailure: (err) => {
+							logVerboseMessage(`matrix: preview final edit failed: ${String(err)}`);
+						}
+					} : void 0,
+					deliverNormally: async (normalPayload) => {
+						if (settlesPreview && !previewLifecycle.previewFinalized && (hasMedia || payloadText?.trim() || payload.isError || payloadReplyMismatch || draftStream?.mustDeliverFinalNormally())) {
+							const id = draftStream?.eventId();
+							const content = draftStream?.content();
+							if (id && content) retainedDraftDelivery = createDraftDeliveryResult(id, content);
+						}
+						return await deliverPayload(normalPayload === payload ? fallbackPayload : normalPayload);
+					}
+				})).deliveryResult;
+			} catch (error) {
+				if (retainedDraftDelivery) previewLifecycle.retainPreview();
+				throw toMatrixPartialDeliveryError(error, retainedDraftDelivery ? [retainedDraftDelivery] : []);
+			}
+			if (retainedDraftDelivery && !deliveryResult?.visibleReplySent) previewLifecycle.retainPreview();
+			const mergedDelivery = mergeMatrixReplyDeliveryResults([retainedDraftDelivery?.messageIds?.includes(draftStream?.eventId() ?? "") ? retainedDraftDelivery : void 0, deliveryResult].filter((result) => result !== void 0));
+			if (info.kind === "block") {
+				beginNextBlockDraft();
+				await typingCallbacks.onReplyStart();
+			}
+			return mergedDelivery;
+		},
+		onReplyError: (err, info) => {
+			if (info.kind === "final") previewLifecycle.observeFailure();
+			else nonFinalReplyDeliveryFailed = true;
+			if (info.kind === "block") beginNextBlockDraft();
+			runtime.error?.(`matrix ${info.kind} reply failed: ${String(err)}`);
+		},
+		nonFinalReplyDeliveryFailed: () => nonFinalReplyDeliveryFailed
+	};
+}
+//#endregion
+//#region extensions/matrix/src/matrix/monitor/handler-state.ts
+const ALLOW_FROM_STORE_CACHE_TTL_MS = 3e4;
+const PAIRING_REPLY_COOLDOWN_MS = 3e5;
+const MAX_TRACKED_PAIRING_REPLY_SENDERS = 512;
+function createMatrixHandlerState(config) {
+	const { core, accountId, runtime, allowFromResolvedEntries, groupAllowFromResolvedEntries, resolveLiveUserAllowlist } = config;
+	let cachedStoreAllowFrom = null;
+	const liveAllowlistCache = /* @__PURE__ */ new Map();
+	const resolveCachedLiveAllowlist = async (paramsValue) => {
+		const accountConfigLocal = resolveMatrixAccountConfig({
+			cfg: paramsValue.cfg,
+			accountId
+		});
+		const signature = JSON.stringify({
+			entries: (paramsValue.entries ?? []).map((entry) => String(entry).trim()),
+			failClosedOnUnresolved: paramsValue.failClosedOnUnresolved === true,
+			dangerouslyAllowNameMatching: isDangerousNameMatchingEnabled(accountConfigLocal)
+		});
+		const cached = liveAllowlistCache.get(paramsValue.scope);
+		if (cached?.signature === signature) return cached.entries;
+		const entries = await resolveLiveUserAllowlist({
+			cfg: paramsValue.cfg,
+			accountId,
+			entries: paramsValue.entries,
+			failClosedOnUnresolved: paramsValue.failClosedOnUnresolved,
+			startupResolvedEntries: paramsValue.startupResolvedEntries,
+			runtime
+		});
+		liveAllowlistCache.set(paramsValue.scope, {
+			signature,
+			entries
+		});
+		return entries;
+	};
+	const pairingReplySentAtMsBySender = /* @__PURE__ */ new Map();
+	const resolveLiveAccountAllowlists = async () => {
+		const liveCfg = core.config.current();
+		const liveAccountAllowlists = resolveMatrixAccountAllowlistConfig({
+			cfg: liveCfg,
+			accountId
+		});
+		return {
+			liveCfg,
+			liveDmAllowFrom: await resolveCachedLiveAllowlist({
+				cfg: liveCfg,
+				entries: liveAccountAllowlists.dmAllowFrom,
+				startupResolvedEntries: allowFromResolvedEntries,
+				scope: "dm"
+			}),
+			liveGroupAllowFrom: await resolveCachedLiveAllowlist({
+				cfg: liveCfg,
+				entries: liveAccountAllowlists.groupAllowFrom,
+				failClosedOnUnresolved: true,
+				startupResolvedEntries: groupAllowFromResolvedEntries,
+				scope: "group"
+			})
+		};
+	};
+	const readStoreAllowFrom = async () => {
+		const now = Date.now();
+		if (cachedStoreAllowFrom && isFutureDateTimestampMs(cachedStoreAllowFrom.expiresAtMs, { nowMs: now })) return cachedStoreAllowFrom.value;
+		cachedStoreAllowFrom = null;
+		const value = await core.channel.pairing.readAllowFromStore({
+			channel: "matrix",
+			env: process.env,
+			accountId
+		}).catch(() => []);
+		const expiresAtMs = resolveExpiresAtMsFromDurationMs(ALLOW_FROM_STORE_CACHE_TTL_MS, { nowMs: now });
+		cachedStoreAllowFrom = expiresAtMs === void 0 ? null : {
+			value,
+			expiresAtMs
+		};
+		return value;
+	};
+	const shouldSendPairingReply = (senderId, created) => {
+		const now = Date.now();
+		if (created) {
+			pairingReplySentAtMsBySender.set(senderId, now);
+			return true;
+		}
+		const lastSentAtMs = pairingReplySentAtMsBySender.get(senderId);
+		if (typeof lastSentAtMs === "number" && now - lastSentAtMs < PAIRING_REPLY_COOLDOWN_MS) return false;
+		pairingReplySentAtMsBySender.set(senderId, now);
+		if (pairingReplySentAtMsBySender.size > MAX_TRACKED_PAIRING_REPLY_SENDERS) {
+			const oldestSender = pairingReplySentAtMsBySender.keys().next().value;
+			if (typeof oldestSender === "string") pairingReplySentAtMsBySender.delete(oldestSender);
+		}
+		return true;
+	};
+	return {
+		resolveLiveAccountAllowlists,
+		readStoreAllowFrom,
+		shouldSendPairingReply
+	};
+}
+//#endregion
+//#region extensions/matrix/src/matrix/monitor/handler.ts
+const SESSION_RESTART_RECOVERY_TOMBSTONE_ERROR_CODE = "SESSION_RESTART_RECOVERY_TOMBSTONE";
+const RESTART_RECOVERY_TOMBSTONE_NOTICE = "This session ended during gateway restart recovery and cannot accept more messages. Send /new or /reset to start a replacement session.";
+function createMatrixRoomMessageHandler(params) {
+	const { client, core, cfg: startupConfig, accountId, runtime, logger, logVerboseMessage, allowFromResolvedEntries = [], groupAllowFromResolvedEntries = [], configuredBotUserIds = /* @__PURE__ */ new Set(), replyToMode, streaming, previewToolProgressEnabled, blockStreamingEnabled, historyLimit, startupMs, startupGraceMs, dropPreStartupMessages, inboundDeduper, directTracker, getMemberDisplayName, resolveLiveUserAllowlist = resolveMatrixMonitorLiveUserAllowlist, resolveStorePath: resolveStorePathImpl = resolveStorePath, createChannelInboundEnvelopeBuilder: createChannelInboundEnvelopeBuilderImpl = createChannelInboundEnvelopeBuilder, resolveHumanDelayConfig: resolveHumanDelayConfigImpl = resolveHumanDelayConfig } = params;
+	const handlerConfig = {
+		...params,
+		allowFromResolvedEntries,
+		groupAllowFromResolvedEntries,
+		configuredBotUserIds,
+		resolveLiveUserAllowlist,
+		resolveStorePath: resolveStorePathImpl,
+		createChannelInboundEnvelopeBuilder: createChannelInboundEnvelopeBuilderImpl,
+		resolveHumanDelayConfig: resolveHumanDelayConfigImpl
+	};
+	const handlerState = createMatrixHandlerState({
+		core,
+		accountId,
+		runtime,
+		allowFromResolvedEntries,
+		groupAllowFromResolvedEntries,
+		resolveLiveUserAllowlist
+	});
+	const resolveThreadContext = createMatrixEventContextResolver({
+		kind: "thread",
+		client,
+		getMemberDisplayName,
+		logVerboseMessage
+	});
+	const resolveReplyContext = createMatrixEventContextResolver({
+		kind: "reply",
+		client,
+		getMemberDisplayName,
+		logVerboseMessage
+	});
+	const roomHistoryTracker = createRoomHistoryTracker();
+	const roomIngressQueue = new KeyedAsyncQueue();
+	const sharedDmContextNoticeRooms = /* @__PURE__ */ new Set();
+	return async (roomId, event) => {
+		const eventId = typeof event.event_id === "string" ? event.event_id.trim() : "";
+		let inboundReplayClaim;
+		let draftControllerRef;
+		try {
+			const eventType = event.type;
+			if (eventType === EventType.RoomMessageEncrypted) return;
+			const isPollEvent = isPollEventType(eventType);
+			const isReactionEvent = eventType === EventType.Reaction;
+			const locationContent = event.content;
+			const isLocationEvent = eventType === EventType.Location || eventType === EventType.RoomMessage && locationContent.msgtype === EventType.Location;
+			if (eventType !== EventType.RoomMessage && !isPollEvent && !isLocationEvent && !isReactionEvent) return;
+			logVerboseMessage(`matrix: inbound event room=${roomId} type=${eventType} id=${event.event_id ?? "unknown"}`);
+			if (event.unsigned?.redacted_because) return;
+			const senderId = event.sender;
+			if (!senderId) return;
+			const eventTs = event.origin_server_ts;
+			const eventAge = event.unsigned?.age;
+			const commitInboundEventIfClaimed = async () => {
+				const claim = inboundReplayClaim;
+				if (!claim) return;
+				await claim.commit();
+				if (inboundReplayClaim === claim) inboundReplayClaim = void 0;
+			};
+			const readIngressPrefix = () => readMatrixIngressPrefix({
+				client,
+				senderId,
+				dropPreStartupMessages,
+				eventTs: eventTs ?? void 0,
+				eventAge: eventAge ?? void 0,
+				startupMs,
+				startupGraceMs,
+				event,
+				eventType,
+				eventId,
+				inboundDeduper,
+				roomId,
+				logVerboseMessage,
+				directTracker,
+				claimInboundReplay: (handle) => {
+					inboundReplayClaim = handle;
+				}
+			});
+			const continueIngress = async (paramsLocal) => {
+				const access = await resolveMatrixIngressAccess({
+					handler: handlerConfig,
+					params: paramsLocal,
+					roomId,
+					event,
+					eventTs: eventTs ?? void 0,
+					senderId,
+					isReactionEvent,
+					readStoreAllowFrom: handlerState.readStoreAllowFrom,
+					shouldSendPairingReply: handlerState.shouldSendPairingReply,
+					resolveLiveAccountAllowlists: handlerState.resolveLiveAccountAllowlists,
+					roomHistoryTracker,
+					commitInboundEventIfClaimed
+				});
+				if (!access) return;
+				return await resolveMatrixIngressContent({
+					handler: handlerConfig,
+					params: paramsLocal,
+					access,
+					roomId,
+					event,
+					eventType,
+					isPollEvent,
+					eventTs: eventTs ?? void 0,
+					senderId,
+					roomHistoryTracker,
+					resolveThreadContext,
+					commitInboundEventIfClaimed
+				});
+			};
+			const ingressResult = historyLimit > 0 ? await roomIngressQueue.enqueue(roomId, async () => {
+				const prefix = await readIngressPrefix();
+				if (!prefix) return;
+				if (prefix.isDirectMessage) return { deferredPrefix: prefix };
+				const result = await continueIngress({
+					...prefix,
+					audioPreflightMode: shouldDeferMatrixAudioPreflightForRoomIngress({
+						content: prefix.content,
+						cfg: startupConfig
+					}) ? "defer" : "run"
+				});
+				return result && "deferredPrefix" in result ? { deferredPrefix: result.deferredPrefix } : { ingressResult: result };
+			}) : void 0;
+			const resolvedIngressResult = historyLimit > 0 ? ingressResult?.deferredPrefix ? await continueIngress(ingressResult.deferredPrefix) : ingressResult?.ingressResult : await (async () => {
+				const prefix = await readIngressPrefix();
+				if (!prefix) return;
+				return await continueIngress(prefix);
+			})();
+			if (!resolvedIngressResult) return;
+			if ("deferredPrefix" in resolvedIngressResult) return;
+			const { cfg, liveDmAllowFrom, route: _route, roomConfig, isDirectMessage, isRoom, bodyText, messageId, triggerSnapshot, threadRootId, thread, botLoopProtection } = resolvedIngressResult;
+			const inboundContext = await resolveMatrixInboundContext({
+				handler: handlerConfig,
+				ingress: resolvedIngressResult,
+				roomId,
+				event,
+				eventTs: eventTs ?? void 0,
+				resolveThreadContext,
+				resolveReplyContext,
+				senderId,
+				sharedDmContextNoticeRooms
+			});
+			if (!inboundContext) return;
+			const { replyToEventId, threadTarget, storePath, ctxPayload, replyTarget, sharedDmContextNotice } = inboundContext;
+			const mediaLocalRoots = getAgentScopedMediaLocalRoots(cfg, _route.agentId);
+			const { onModelSelected, ...prefixOptions } = createReplyPrefixOptions({
+				cfg,
+				agentId: _route.agentId,
+				channel: "matrix",
+				accountId: _route.accountId
+			});
+			const typingCallbacks = createTypingCallbacks({
+				start: async () => {
+					const { sendTypingMatrix } = await loadMatrixSendModule();
+					await sendTypingMatrix(roomId, true, { client });
+				},
+				stop: async () => {
+					const { sendTypingMatrix } = await loadMatrixSendModule();
+					await sendTypingMatrix(roomId, false, { client });
+				},
+				onStartError: (err) => {
+					logTypingFailure({
+						log: logVerboseMessage,
+						channel: "matrix",
+						action: "start",
+						target: roomId,
+						error: err
+					});
+				},
+				onStopError: (err) => {
+					logTypingFailure({
+						log: logVerboseMessage,
+						channel: "matrix",
+						action: "stop",
+						target: roomId,
+						error: err
+					});
+				}
+			});
+			const hookRunner = getGlobalHookRunner();
+			const allowProviderPreview = !((hookRunner?.hasHooks("reply_payload_sending") ?? false) || (hookRunner?.hasHooks("message_sending") ?? false));
+			const draftController = await createMatrixDraftController({
+				streaming: allowProviderPreview ? streaming : "off",
+				previewToolProgressEnabled: allowProviderPreview && previewToolProgressEnabled,
+				replyToMode,
+				messageId,
+				threadTarget,
+				accountConfig: params.accountConfig,
+				cfg,
+				accountId: _route.accountId,
+				roomId,
+				client,
+				logVerboseMessage
+			});
+			const { draftStream } = draftController;
+			draftControllerRef = draftController;
+			const replyDispatcher = createMatrixReplyDispatcher({
+				cfg,
+				prefixOptions,
+				humanDelay: resolveHumanDelayConfigImpl(cfg, _route.agentId),
+				typingCallbacks,
+				streaming,
+				draftStream,
+				draftController,
+				client,
+				roomId,
+				runtime,
+				replyToMode,
+				threadTarget,
+				replyToEventId: replyToEventId ?? void 0,
+				accountId: _route.accountId,
+				mediaLocalRoots,
+				logVerboseMessage
+			});
+			const { deliverReply, onReplyError, turnDispatcherOptions } = replyDispatcher;
+			const pinnedMainDmOwner = isDirectMessage ? resolvePinnedMainDmOwnerFromAllowlist({
+				dmScope: cfg.session?.dmScope,
+				allowFrom: liveDmAllowFrom,
+				normalizeEntry: normalizeMatrixUserId
+			}) : null;
+			const inboundLastRouteSessionKey = resolveInboundLastRouteSessionKey({
+				route: _route,
+				sessionKey: _route.sessionKey
+			});
+			const replayClaimAtDispatch = inboundReplayClaim;
+			const turnAdoptionLifecycle = replayClaimAtDispatch ? {
+				admission: "exclusive",
+				onDeferred: () => {
+					if (inboundReplayClaim !== replayClaimAtDispatch) return false;
+					inboundReplayClaim = void 0;
+				},
+				onAdopted: async () => {
+					if (inboundReplayClaim === replayClaimAtDispatch) inboundReplayClaim = void 0;
+					await replayClaimAtDispatch.commit();
+				},
+				onAbandoned: () => {
+					if (inboundReplayClaim === replayClaimAtDispatch) inboundReplayClaim = void 0;
+					replayClaimAtDispatch.release();
+				}
+			} : void 0;
+			const turnResultPromise = core.channel.inbound.run({
+				channel: "matrix",
+				accountId: _route.accountId,
+				raw: event,
+				...turnAdoptionLifecycle ? { turnAdoptionLifecycle } : {},
+				adapter: {
+					ingest: () => ({
+						id: messageId,
+						rawText: bodyText,
+						textForAgent: ctxPayload.BodyForAgent,
+						textForCommands: ctxPayload.CommandBody,
+						raw: event
+					}),
+					resolveTurn: () => ({
+						cfg,
+						channel: "matrix",
+						accountId: _route.accountId,
+						route: {
+							agentId: _route.agentId,
+							sessionKey: _route.sessionKey
+						},
+						ctxPayload,
+						botLoopProtection,
+						record: {
+							updateLastRoute: isDirectMessage ? {
+								sessionKey: inboundLastRouteSessionKey,
+								channel: "matrix",
+								to: `room:${roomId}`,
+								accountId: _route.accountId,
+								mainDmOwnerPin: inboundLastRouteSessionKey === _route.mainSessionKey && pinnedMainDmOwner ? {
+									ownerRecipient: pinnedMainDmOwner,
+									senderRecipient: normalizeMatrixUserId(senderId),
+									onSkip: ({ ownerRecipient, senderRecipient }) => {
+										logVerboseMessage(`matrix: skip main-session last route for ${senderRecipient} (pinned owner ${ownerRecipient})`);
+									}
+								} : void 0
+							} : void 0,
+							onRecordError: (err) => {
+								logger.warn("failed updating session meta", {
+									error: String(err),
+									storePath,
+									sessionKey: ctxPayload.SessionKey ?? _route.sessionKey
+								});
+							}
+						},
+						afterRecord: async () => {
+							if (sharedDmContextNotice && markTrackedRoomIfFirst(sharedDmContextNoticeRooms, roomId)) try {
+								await client.sendMessage(roomId, {
+									msgtype: "m.notice",
+									body: sharedDmContextNotice
+								});
+							} catch (err) {
+								logVerboseMessage(`matrix: failed sending shared DM session notice room=${roomId}: ${String(err)}`);
+							}
+						},
+						delivery: {
+							observeMessageSent: true,
+							preparePayload: prepareMatrixReplyPayload,
+							deliver: deliverReply,
+							onError: (err, info) => onReplyError(err, info)
+						},
+						dispatcherOptions: {
+							...turnDispatcherOptions,
+							onSettled: () => draftController.cancelProgressDraft()
+						},
+						replyOptions: {
+							skillFilter: roomConfig?.skills,
+							disableBlockStreaming: !blockStreamingEnabled,
+							onPartialReply: draftStream ? (payload) => draftController.onPartialReply(payload.text ?? "") : void 0,
+							onBlockReplyQueued: draftStream ? (payload, context) => {
+								if (payload.isCompactionNotice === true) return false;
+								draftController.queueDraftBlockBoundary(payload, context);
+								return false;
+							} : void 0,
+							onAssistantMessageStart: draftStream ? () => {
+								draftController.resetDraftBlockOffsets();
+								draftController.beginAssistantMessage();
+								return false;
+							} : void 0,
+							onQueuedFollowupAdmitted: draftStream ? draftController.resetDraftDeliveryState : void 0,
+							...draftController.buildPreviewToolProgressReplyOptions(),
+							onObservedReplyDelivery: draftStream ? () => draftController.previewLifecycle.observeDelivery({ visibleReplySent: true }) : void 0,
+							onModelSelected
+						}
+					})
+				}
+			});
+			let turnResult;
+			try {
+				turnResult = await turnResultPromise;
+			} catch (err) {
+				if (extractErrorCode(err) !== SESSION_RESTART_RECOVERY_TOMBSTONE_ERROR_CODE) throw err;
+				try {
+					const { sendMessageMatrix } = await loadMatrixSendModule();
+					await sendMessageMatrix(roomId, RESTART_RECOVERY_TOMBSTONE_NOTICE, {
+						cfg,
+						client,
+						accountId: _route.accountId,
+						replyToId: threadTarget || replyToMode === "off" ? void 0 : messageId,
+						fallbackReplyToId: threadTarget,
+						threadId: threadTarget,
+						deliveryQueueId: `matrix:restart-recovery-tombstone:${_route.accountId}:${roomId}:${eventId}`,
+						deliveryPartIndex: 0,
+						deliveryPartCount: 1,
+						extraContent: { msgtype: "m.notice" }
+					});
+					await commitInboundEventIfClaimed();
+				} catch (noticeError) {
+					runtime.error?.(`matrix: failed completing restart-recovery tombstone notice room=${roomId} id=${eventId || "unknown"}: ${String(noticeError)}`);
+				}
+				return;
+			}
+			if (!turnResult.dispatched) {
+				if (turnResult.admission.kind === "drop" && turnResult.admission.reason === "bot-loop-protection") await commitInboundEventIfClaimed();
+				return;
+			}
+			const { dispatchResult } = turnResult;
+			const { queuedFinal } = dispatchResult;
+			if (draftController.previewLifecycle.finalFailed) {
+				logVerboseMessage(`matrix: final reply delivery failed room=${roomId} id=${messageId}; keeping replay committed`);
+				await commitInboundEventIfClaimed();
+				return;
+			}
+			if (!queuedFinal && replyDispatcher.nonFinalReplyDeliveryFailed()) {
+				logVerboseMessage(`matrix: non-final reply delivery failed room=${roomId} id=${messageId}; keeping replay committed`);
+				await commitInboundEventIfClaimed();
+				return;
+			}
+			if (isRoom && triggerSnapshot) roomHistoryTracker.consumeHistory(_route.agentId, roomId, triggerSnapshot, messageId, threadRootId ? thread.threadId : void 0);
+			if (!hasFinalInboundReplyDispatch(dispatchResult)) {
+				await commitInboundEventIfClaimed();
+				return;
+			}
+			const finalCount = resolveInboundReplyDispatchCounts(dispatchResult).final;
+			logVerboseMessage(`matrix: delivered ${finalCount} reply${finalCount === 1 ? "" : "ies"} to ${replyTarget}`);
+			await commitInboundEventIfClaimed();
+		} catch (err) {
+			const draftController = draftControllerRef;
+			if (draftController?.draftStream?.eventId()) draftController.previewLifecycle.retainPreview();
+			runtime.error?.(`matrix handler failed: ${String(err)}`);
+		} finally {
+			const draftStream = draftControllerRef?.draftStream;
+			if (draftStream) {
+				await draftStream.stop().catch(() => void 0);
+				await draftControllerRef?.previewLifecycle.cleanup();
+				await draftStream.cleanupPending();
+			}
+			inboundReplayClaim?.release();
+		}
+	};
+}
+//#endregion
+//#region extensions/matrix/src/matrix/monitor/recent-invite.ts
+function shouldPromoteRecentInviteRoom(params) {
+	if (!params.roomInfo.nameResolved || !params.roomInfo.aliasesResolved) return false;
+	const roomAliases = [params.roomInfo.canonicalAlias ?? "", ...params.roomInfo.altAliases].filter(Boolean);
+	if ((params.roomInfo.name?.trim() ?? "") || roomAliases.length > 0) return false;
+	return resolveMatrixRoomConfig({
+		rooms: params.rooms,
+		roomId: params.roomId,
+		aliases: roomAliases
+	}).matchSource === void 0;
+}
+//#endregion
+//#region extensions/matrix/src/matrix/monitor/startup.ts
+const loadMatrixStartupMaintenanceDeps = createLazyRuntimeModule(() => Promise.all([
+	import("./config-update-5m1Un5gJ.mjs").then((n) => n.t),
+	import("./device-health-U-yoVjPw.mjs").then((n) => n.t),
+	import("./profile-B3DD2jYa.mjs").then((n) => n.n),
+	import("./startup-verification-Aiy_xVdI.mjs")
+]).then(([configUpdateModule, deviceHealthModule, profileModule, startupVerificationModule]) => ({
+	updateMatrixAccountConfig: configUpdateModule.updateMatrixAccountConfig,
+	summarizeMatrixDeviceHealth: deviceHealthModule.summarizeMatrixDeviceHealth,
+	syncMatrixOwnProfile: profileModule.syncMatrixOwnProfile,
+	ensureMatrixStartupVerification: startupVerificationModule.ensureMatrixStartupVerification
+})));
+async function runMatrixStartupMaintenance(params, deps) {
+	const runtimeDeps = deps ?? await loadMatrixStartupMaintenanceDeps();
+	throwIfMatrixStartupAborted(params.abortSignal);
+	try {
+		const profileSync = await runtimeDeps.syncMatrixOwnProfile({
+			client: params.client,
+			userId: params.auth.userId,
+			displayName: params.accountConfig.name,
+			avatarUrl: params.accountConfig.avatarUrl,
+			loadAvatarFromUrl: params.loadWebMedia
+		});
+		throwIfMatrixStartupAborted(params.abortSignal);
+		if (profileSync.displayNameUpdated) params.logger.info(`matrix: profile display name updated for ${params.auth.userId}`);
+		if (profileSync.avatarUpdated) params.logger.info(`matrix: profile avatar updated for ${params.auth.userId}`);
+		if (profileSync.convertedAvatarFromHttp && profileSync.resolvedAvatarUrl && params.accountConfig.avatarUrl !== profileSync.resolvedAvatarUrl) {
+			const latestCfg = params.getRuntimeConfig();
+			const updatedCfg = runtimeDeps.updateMatrixAccountConfig(latestCfg, params.accountId, { avatarUrl: profileSync.resolvedAvatarUrl });
+			await params.replaceConfigFile(updatedCfg);
+			throwIfMatrixStartupAborted(params.abortSignal);
+			params.logVerboseMessage(`matrix: persisted converted avatar URL for account ${params.accountId} (${profileSync.resolvedAvatarUrl})`);
+		}
+	} catch (err) {
+		if (isMatrixStartupAbortError(err)) throw err;
+		params.logger.warn("matrix: failed to sync profile from config", { error: String(err) });
+	}
+	if (!(params.auth.encryption && params.client.crypto)) return;
+	try {
+		throwIfMatrixStartupAborted(params.abortSignal);
+		const deviceHealth = runtimeDeps.summarizeMatrixDeviceHealth(await params.client.listOwnDevices());
+		if (deviceHealth.staleOpenClawDevices.length > 0) params.logger.warn(`matrix: stale OpenClaw devices detected for ${params.auth.userId}: ${deviceHealth.staleOpenClawDevices.map((device) => device.deviceId).join(", ")}. Run 'openclaw matrix devices prune-stale --account ${params.effectiveAccountId}' to keep encrypted-room trust healthy.`);
+	} catch (err) {
+		if (isMatrixStartupAbortError(err)) throw err;
+		params.logger.debug?.("Failed to inspect matrix device hygiene (non-fatal)", { error: String(err) });
+	}
+	try {
+		throwIfMatrixStartupAborted(params.abortSignal);
+		const startupVerification = await runtimeDeps.ensureMatrixStartupVerification({
+			client: params.client,
+			auth: params.auth,
+			accountConfig: params.accountConfig,
+			env: params.env
+		});
+		throwIfMatrixStartupAborted(params.abortSignal);
+		if (startupVerification.kind === "verified") params.logger.info("matrix: device is verified by its owner and ready for encrypted rooms");
+		else if (startupVerification.kind === "disabled" || startupVerification.kind === "cooldown" || startupVerification.kind === "pending" || startupVerification.kind === "request-failed") {
+			params.logger.info("matrix: device not verified — run 'openclaw matrix verify device <key>' to enable E2EE");
+			if (startupVerification.kind === "pending") params.logger.info("matrix: startup verification request is already pending; finish it in another Matrix client");
+			else if (startupVerification.kind === "cooldown") params.logVerboseMessage(`matrix: skipped startup verification request due to cooldown (retryAfterMs=${startupVerification.retryAfterMs ?? 0})`);
+			else if (startupVerification.kind === "request-failed") params.logger.debug?.("Matrix startup verification request failed (non-fatal)", { error: startupVerification.error ?? "unknown" });
+		} else if (startupVerification.kind === "requested") params.logger.info("matrix: device not verified — requested verification in another Matrix client");
+	} catch (err) {
+		if (isMatrixStartupAbortError(err)) throw err;
+		params.logger.debug?.("Failed to resolve matrix verification status (non-fatal)", { error: String(err) });
+	}
+}
+//#endregion
+//#region extensions/matrix/src/matrix/monitor/status.ts
+function cloneLastDisconnect(value) {
+	if (!value || typeof value === "string") return value ?? null;
+	return { ...value };
+}
+function formatSyncError(error) {
+	if (!error) return null;
+	if (error instanceof Error) return error.message || error.name || "unknown";
+	return formatErrorMessage(error);
+}
+function createMatrixMonitorStatusController(params) {
+	const status = {
+		accountId: params.accountId,
+		...params.baseUrl ? { baseUrl: params.baseUrl } : {},
+		connected: false,
+		lastConnectedAt: null,
+		lastDisconnect: null,
+		lastError: null,
+		healthState: "starting",
+		lifecycle: "starting"
+	};
+	const emit = () => {
+		params.statusSink?.({
+			...status,
+			lastDisconnect: cloneLastDisconnect(status.lastDisconnect)
+		});
+	};
+	const noteConnected = (at = Date.now(), options) => {
+		const lastConnectedAt = status.connected === true ? status.lastConnectedAt ?? at : at;
+		Object.assign(status, channelReadyPatch({
+			lastConnectedAt,
+			lastEventAt: at,
+			lastDisconnect: null,
+			healthState: "healthy"
+		}));
+		if (options?.transportActivity) Object.assign(status, createTransportActivityStatusPatch(at));
+		emit();
+	};
+	const noteDisconnected = (paramsLocal) => {
+		const at = paramsLocal.at ?? Date.now();
+		const tokenInvalidated = isMatrixAccessTokenInvalidatedError(paramsLocal.error);
+		if (status.lifecycle === "blocked" && status.terminalDisconnect === true && !tokenInvalidated) {
+			status.connected = false;
+			status.lastEventAt = at;
+			emit();
+			return;
+		}
+		const error = formatSyncError(paramsLocal.error);
+		status.connected = false;
+		status.lastEventAt = at;
+		status.lastDisconnect = {
+			at,
+			...error ? { error } : {}
+		};
+		status.healthState = paramsLocal.state.toLowerCase();
+		if (tokenInvalidated) Object.assign(status, channelBlockedPatch(error ?? "Matrix access token invalidated"));
+		else {
+			status.lastError = error;
+			status.lifecycle = "recovering";
+			status.terminalDisconnect = void 0;
+		}
+		emit();
+	};
+	emit();
+	return {
+		noteSyncState(state, error, at = Date.now()) {
+			if (isMatrixReadySyncState(state)) {
+				noteConnected(at, { transportActivity: state === "SYNCING" });
+				return;
+			}
+			if (isMatrixDisconnectedSyncState(state)) {
+				noteDisconnected({
+					state,
+					at,
+					error
+				});
+				return;
+			}
+			status.lastEventAt = at;
+			status.healthState = state.toLowerCase();
+			emit();
+		},
+		noteUnexpectedError(error, at = Date.now()) {
+			noteDisconnected({
+				state: "ERROR",
+				at,
+				error
+			});
+		},
+		markStopped(at = Date.now()) {
+			if (status.lifecycle !== "blocked" && status.healthState !== "error") Object.assign(status, channelStoppedPatch({
+				lastEventAt: at,
+				healthState: "stopped"
+			}));
+			else {
+				status.connected = false;
+				status.lastEventAt = at;
+			}
+			emit();
+		}
+	};
+}
+//#endregion
+//#region extensions/matrix/src/matrix/monitor/sync-lifecycle.ts
+function formatSyncLifecycleError(state, error) {
+	if (error instanceof Error) return error;
+	const message = typeof error === "string" && error.trim() ? error.trim() : void 0;
+	if (state === "STOPPED") return new Error(message ?? "Matrix sync stopped unexpectedly");
+	return new Error(message ?? `Matrix sync entered ${state} unexpectedly`);
+}
+function createMatrixMonitorSyncLifecycle(params) {
+	let fatalError = null;
+	let resolveFatalWait = null;
+	let rejectFatalWait = null;
+	const settleFatal = (error) => {
+		if (fatalError) return;
+		fatalError = error;
+		rejectFatalWait?.(error);
+		resolveFatalWait = null;
+		rejectFatalWait = null;
+	};
+	const onSyncState = (state, _prevState, error) => {
+		if (isMatrixTerminalSyncState(state) && !params.isStopping?.()) {
+			const fatalErrorLocal = formatSyncLifecycleError(state, error);
+			params.statusController.noteUnexpectedError(fatalErrorLocal);
+			settleFatal(fatalErrorLocal);
+			return;
+		}
+		if (fatalError) return;
+		if (params.isStopping?.() && !isMatrixTerminalSyncState(state)) return;
+		params.statusController.noteSyncState(state, error);
+	};
+	const onUnexpectedError = (error) => {
+		if (params.isStopping?.()) return;
+		params.statusController.noteUnexpectedError(error);
+		settleFatal(error);
+	};
+	params.client.on("sync.state", onSyncState);
+	params.client.on("sync.unexpected_error", onUnexpectedError);
+	return {
+		async waitForFatalStop() {
+			if (fatalError) throw fatalError;
+			if (resolveFatalWait || rejectFatalWait) throw new Error("Matrix fatal-stop wait already in progress");
+			await new Promise((resolve, reject) => {
+				resolveFatalWait = resolve;
+				rejectFatalWait = (error) => reject(error);
+			});
+		},
+		dispose() {
+			resolveFatalWait?.();
+			resolveFatalWait = null;
+			rejectFatalWait = null;
+			params.client.off("sync.state", onSyncState);
+			params.client.off("sync.unexpected_error", onUnexpectedError);
+		}
+	};
+}
+//#endregion
+//#region extensions/matrix/src/matrix/monitor/index.ts
+function resolveMatrixStreamingMode(streaming) {
+	const mode = streaming?.mode;
+	if (mode === "partial" || mode === "quiet" || mode === "progress") return mode;
+	return "off";
+}
+function resolveMatrixPreviewToolProgressEnabled(streaming) {
+	const mode = resolveMatrixStreamingMode(streaming);
+	if (mode === "off") return false;
+	if (mode === "progress") return streaming?.progress?.toolProgress ?? streaming?.preview?.toolProgress ?? false;
+	return streaming?.preview?.toolProgress ?? true;
+}
+const DEFAULT_MEDIA_MAX_MB = 20;
+async function monitorMatrixProvider(opts = {}) {
+	if (opts.abortSignal?.aborted) return;
+	const core = getMatrixRuntime();
+	let cfg = core.config.current();
+	if (cfg.channels?.["matrix"]?.enabled === false) return;
+	const logger = core.logging.getChildLogger({ module: "matrix-auto-reply" });
+	const runtime = opts.runtime ?? {
+		log: (...args) => {
+			logger.info(format(...args));
+		},
+		error: (...args) => {
+			logger.error(format(...args));
+		},
+		exit: (code) => {
+			throw new Error(`exit ${code}`);
+		}
+	};
+	const logVerboseMessage = (message) => {
+		if (!core.logging.shouldLogVerbose()) return;
+		logger.debug?.(message);
+	};
+	const effectiveAccountId = resolveMatrixAuthContext({
+		cfg,
+		accountId: opts.accountId
+	}).accountId;
+	const accountConfig = resolveMatrixAccountConfig({
+		cfg,
+		accountId: effectiveAccountId
+	});
+	const allowlistOnly = accountConfig.allowlistOnly === true;
+	const accountAllowBots = accountConfig.allowBots;
+	let roomsConfig = accountConfig.groups ?? accountConfig.rooms;
+	let needsRoomAliasesForConfig = false;
+	const initialAllowFrom = (accountConfig.dm?.allowFrom ?? []).map(String);
+	const initialGroupAllowFrom = (accountConfig.groupAllowFrom ?? []).map(String);
+	const { allowFrom, allowFromResolvedEntries, groupAllowFrom, groupAllowFromResolvedEntries, roomsConfig: resolvedRoomsConfig } = await resolveMatrixMonitorConfig({
+		cfg,
+		accountId: effectiveAccountId,
+		allowFrom: initialAllowFrom,
+		groupAllowFrom: initialGroupAllowFrom,
+		roomsConfig,
+		runtime
+	});
+	roomsConfig = resolvedRoomsConfig;
+	needsRoomAliasesForConfig = Boolean(roomsConfig && Object.keys(roomsConfig).some((key) => key.trim().startsWith("#")));
+	cfg = {
+		...cfg,
+		channels: {
+			...cfg.channels,
+			matrix: {
+				...cfg.channels?.["matrix"],
+				dm: {
+					...cfg.channels?.["matrix"]?.dm,
+					allowFrom
+				},
+				groupAllowFrom,
+				...roomsConfig ? { groups: roomsConfig } : {}
+			}
+		}
+	};
+	const auth = await resolveMatrixAuth({
+		cfg,
+		accountId: effectiveAccountId
+	});
+	if (opts.abortSignal?.aborted) return;
+	const configuredBotUserIds = await resolveConfiguredMatrixBotUserIds({
+		cfg,
+		accountId: effectiveAccountId,
+		abortSignal: opts.abortSignal
+	});
+	if (opts.abortSignal?.aborted) return;
+	const resolvedInitialSyncLimit = resolveOptionalIntegerOption(opts.initialSyncLimit, { min: 0 }) ?? auth.initialSyncLimit;
+	const authWithLimit = resolvedInitialSyncLimit === auth.initialSyncLimit ? auth : {
+		...auth,
+		initialSyncLimit: resolvedInitialSyncLimit
+	};
+	const statusController = createMatrixMonitorStatusController({
+		accountId: auth.accountId,
+		baseUrl: auth.homeserver,
+		statusSink: opts.setStatus
+	});
+	let cleanedUp = false;
+	let cleanupPromise = null;
+	let client = null;
+	let clientLease = null;
+	let monitorLifecycleSignal = opts.abortSignal;
+	let threadBindingManager = null;
+	const monitorTaskRunner = createMatrixMonitorTaskRunner({
+		logger,
+		logVerboseMessage
+	});
+	let disposeAutoJoin = () => {};
+	let disposeMonitorEvents = () => {};
+	let syncLifecycle = null;
+	let monitorSetupClosed = false;
+	const cleanup = (mode = "persist") => {
+		if (cleanupPromise) return cleanupPromise;
+		cleanedUp = true;
+		cleanupPromise = (async () => {
+			try {
+				await clientLease?.release({ mode });
+			} finally {
+				statusController.markStopped();
+			}
+		})();
+		return cleanupPromise;
+	};
+	const defaultGroupPolicy = resolveDefaultGroupPolicy(cfg);
+	const { groupPolicy: groupPolicyRaw, providerMissingFallbackApplied } = resolveAllowlistProviderRuntimeGroupPolicy({
+		providerConfigPresent: cfg.channels?.["matrix"] !== void 0,
+		groupPolicy: accountConfig.groupPolicy,
+		defaultGroupPolicy
+	});
+	warnMissingProviderGroupPolicyFallbackOnce({
+		providerMissingFallbackApplied,
+		providerKey: "matrix",
+		accountId: effectiveAccountId,
+		blockedLabel: GROUP_POLICY_BLOCKED_LABEL.room,
+		log: (message) => logVerboseMessage(message)
+	});
+	const groupPolicy = allowlistOnly && groupPolicyRaw === "open" ? "allowlist" : groupPolicyRaw;
+	const replyToMode = opts.replyToMode ?? accountConfig.replyToMode ?? "off";
+	const threadReplies = accountConfig.threadReplies ?? "inbound";
+	const dmThreadReplies = accountConfig.dm?.threadReplies;
+	const threadBindingIdleTimeoutMs = resolveThreadBindingIdleTimeoutMsForChannel({
+		cfg,
+		channel: "matrix",
+		accountId: effectiveAccountId
+	});
+	const threadBindingMaxAgeMs = resolveThreadBindingMaxAgeMsForChannel({
+		cfg,
+		channel: "matrix",
+		accountId: effectiveAccountId
+	});
+	const dmConfig = accountConfig.dm;
+	const dmEnabled = dmConfig?.enabled ?? true;
+	const dmPolicyRaw = dmConfig?.policy ?? "pairing";
+	const dmPolicy = allowlistOnly && dmPolicyRaw !== "disabled" ? "allowlist" : dmPolicyRaw;
+	const dmSessionScope = dmConfig?.sessionScope ?? "per-user";
+	const historyLimit = resolvePromptHistoryLimit(accountConfig.historyLimit ?? cfg.messages?.groupChat?.historyLimit, 0);
+	const mediaMaxMb = opts.mediaMaxMb ?? accountConfig.mediaMaxMb ?? DEFAULT_MEDIA_MAX_MB;
+	const mediaMaxBytes = Math.max(1, mediaMaxMb) * 1024 * 1024;
+	const streaming = resolveMatrixStreamingMode(accountConfig.streaming);
+	const previewToolProgressEnabled = resolveMatrixPreviewToolProgressEnabled(accountConfig.streaming);
+	const blockStreamingEnabled = resolveChannelStreamingBlockEnabled(accountConfig) === true;
+	const startupMs = Date.now();
+	const startupGraceMs = 0;
+	const warnedEncryptedRooms = /* @__PURE__ */ new Set();
+	const warnedCryptoMissingRooms = /* @__PURE__ */ new Set();
+	let healthySyncSinceMs;
+	const noteSyncHealthState = (state, at = Date.now()) => {
+		if (isMatrixReadySyncState(state)) {
+			healthySyncSinceMs ??= at;
+			return;
+		}
+		if (isMatrixDisconnectedSyncState(state)) healthySyncSinceMs = void 0;
+	};
+	const onSyncState = (state) => {
+		noteSyncHealthState(state);
+	};
+	const monitorRetirement = {
+		closeTaskAdmission: () => {
+			monitorSetupClosed = true;
+			monitorTaskRunner.close();
+		},
+		detachListeners: () => {
+			disposeAutoJoin();
+			disposeMonitorEvents();
+			client?.off("sync.state", onSyncState);
+			syncLifecycle?.dispose();
+		},
+		waitForTasks: monitorTaskRunner.waitForIdle,
+		cleanup: () => threadBindingManager?.stop()
+	};
+	try {
+		clientLease = await acquireSharedMatrixClient({
+			cfg,
+			auth: authWithLimit,
+			startClient: false,
+			accountId: auth.accountId,
+			abortSignal: opts.abortSignal,
+			role: "monitor"
+		});
+		client = clientLease.client;
+		monitorLifecycleSignal = opts.abortSignal ? AbortSignal.any([opts.abortSignal, clientLease.abortSignal]) : clientLease.abortSignal;
+		clientLease.registerMonitorRetirement(monitorRetirement);
+		const inboundDeduper = createMatrixInboundEventDeduper({
+			auth,
+			env: process.env
+		});
+		syncLifecycle = createMatrixMonitorSyncLifecycle({
+			client,
+			statusController,
+			isStopping: () => cleanedUp || monitorLifecycleSignal?.aborted === true
+		});
+		client.on("sync.state", onSyncState);
+		const dropPreStartupMessages = !client.hasPersistedSyncState();
+		const { getRoomInfo, getMemberDisplayName, invalidateMemberDisplayName } = createMatrixRoomInfoResolver(client);
+		const isExplicitlyConfiguredRoom = async (roomId) => {
+			const roomInfoForConfig = needsRoomAliasesForConfig ? await getRoomInfo(roomId, { includeAliases: true }) : void 0;
+			const aliases = roomInfoForConfig ? [roomInfoForConfig.canonicalAlias ?? "", ...roomInfoForConfig.altAliases].filter(Boolean) : [];
+			return resolveMatrixRoomConfig({
+				rooms: roomsConfig,
+				roomId,
+				aliases
+			}).matchSource === "direct";
+		};
+		const canPromoteRecentInvite = async (roomId) => shouldPromoteRecentInviteRoom({
+			roomId,
+			roomInfo: await getRoomInfo(roomId, { includeAliases: true }),
+			rooms: roomsConfig
+		});
+		const directTracker = createDirectRoomTracker(client, {
+			log: logVerboseMessage,
+			isExplicitlyConfiguredRoom,
+			canPromoteRecentInvite,
+			canPromoteUnmappedStrictRoom: dmSessionScope === "per-room" ? canPromoteRecentInvite : void 0,
+			shouldKeepLocallyPromotedDirectRoom: async (roomId) => {
+				try {
+					const roomInfo = await getRoomInfo(roomId, { includeAliases: true });
+					if (!roomInfo.nameResolved || !roomInfo.aliasesResolved) return;
+					return shouldPromoteRecentInviteRoom({
+						roomId,
+						roomInfo,
+						rooms: roomsConfig
+					});
+				} catch (err) {
+					logVerboseMessage(`matrix: local promotion revalidation failed room=${roomId} (${String(err)})`);
+					return;
+				}
+			}
+		});
+		disposeAutoJoin = registerMatrixAutoJoin({
+			client,
+			accountConfig,
+			runtime,
+			runDetachedTask: monitorTaskRunner.runDetachedTask
+		});
+		const handleRoomMessage = createMatrixRoomMessageHandler({
+			client,
+			core,
+			cfg,
+			accountId: effectiveAccountId,
+			accountConfig,
+			runtime,
+			logger,
+			logVerboseMessage,
+			allowFrom,
+			allowFromResolvedEntries,
+			groupAllowFrom,
+			groupAllowFromResolvedEntries,
+			roomsConfig,
+			accountAllowBots,
+			configuredBotUserIds,
+			groupPolicy,
+			replyToMode,
+			threadReplies,
+			dmThreadReplies,
+			dmSessionScope,
+			streaming,
+			previewToolProgressEnabled,
+			blockStreamingEnabled,
+			dmEnabled,
+			dmPolicy,
+			mediaMaxBytes,
+			historyLimit,
+			startupMs,
+			startupGraceMs,
+			dropPreStartupMessages,
+			inboundDeduper,
+			directTracker,
+			getRoomInfo,
+			getMemberDisplayName,
+			needsRoomAliasesForConfig
+		});
+		const createdThreadBindingManager = await createMatrixThreadBindingManager({
+			cfg,
+			accountId: effectiveAccountId,
+			auth,
+			client,
+			env: process.env,
+			idleTimeoutMs: threadBindingIdleTimeoutMs,
+			maxAgeMs: threadBindingMaxAgeMs,
+			logVerboseMessage
+		});
+		if (monitorSetupClosed) {
+			await createdThreadBindingManager.stop();
+			await cleanup("stop");
+			return;
+		}
+		threadBindingManager = createdThreadBindingManager;
+		logVerboseMessage(`matrix: thread bindings ready account=${threadBindingManager.accountId} idleMs=${threadBindingIdleTimeoutMs} maxAgeMs=${threadBindingMaxAgeMs}`);
+		disposeMonitorEvents = registerMatrixMonitorEvents({
+			cfg,
+			client,
+			auth,
+			allowFrom,
+			dmEnabled,
+			dmPolicy,
+			readStoreAllowFrom: async () => await core.channel.pairing.readAllowFromStore({
+				channel: "matrix",
+				env: process.env,
+				accountId: effectiveAccountId
+			}).catch(() => []),
+			directTracker,
+			groupPolicy,
+			roomsConfig,
+			needsRoomAliasesForConfig,
+			getRoomInfo,
+			invalidateMemberDisplayName,
+			logVerboseMessage,
+			warnedEncryptedRooms,
+			warnedCryptoMissingRooms,
+			logger,
+			startupGraceMs,
+			getHealthySyncSinceMs: () => healthySyncSinceMs,
+			formatNativeDependencyHint: core.system.formatNativeDependencyHint,
+			onRoomMessage: handleRoomMessage,
+			runDetachedTask: monitorTaskRunner.runDetachedTask
+		});
+		logVerboseMessage("matrix: starting client");
+		await clientLease.start(monitorLifecycleSignal);
+		if (monitorSetupClosed) {
+			await cleanup("stop");
+			return;
+		}
+		logVerboseMessage("matrix: client started");
+		logger.info(`matrix: logged in as ${auth.userId}`);
+		monitorTaskRunner.runDetachedTask("deviceId backfill", async () => {
+			const taskSignal = getMatrixMonitorTaskSignal();
+			await backfillMatrixAuthDeviceIdAfterStartup({
+				auth,
+				env: process.env,
+				abortSignal: taskSignal && monitorLifecycleSignal ? AbortSignal.any([taskSignal, monitorLifecycleSignal]) : taskSignal ?? monitorLifecycleSignal
+			});
+		});
+		registerChannelRuntimeContext({
+			channelRuntime: opts.channelRuntime,
+			channelId: "matrix",
+			accountId: effectiveAccountId,
+			capability: CHANNEL_APPROVAL_NATIVE_RUNTIME_CONTEXT_CAPABILITY,
+			context: { client },
+			abortSignal: monitorLifecycleSignal
+		});
+		await runMatrixStartupMaintenance({
+			client,
+			auth,
+			accountId: effectiveAccountId,
+			effectiveAccountId,
+			accountConfig,
+			logger,
+			logVerboseMessage,
+			getRuntimeConfig: () => core.config.current(),
+			replaceConfigFile: async (nextCfg) => {
+				await core.config.replaceConfigFile({
+					nextConfig: nextCfg,
+					afterWrite: { mode: "auto" }
+				});
+			},
+			loadWebMedia: async (url, maxBytes) => await core.media.loadWebMedia(url, maxBytes),
+			env: process.env,
+			abortSignal: monitorLifecycleSignal
+		});
+		if (monitorSetupClosed) {
+			await cleanup("stop");
+			return;
+		}
+		await Promise.race([waitUntilAbort(monitorLifecycleSignal, async () => {
+			try {
+				logVerboseMessage("matrix: stopping client");
+				await cleanup();
+			} catch (err) {
+				logger.warn("matrix: failed during monitor shutdown cleanup", { error: String(err) });
+			}
+		}), syncLifecycle.waitForFatalStop()]);
+		await cleanup();
+	} catch (err) {
+		if (monitorSetupClosed) {
+			await cleanup("stop");
+			return;
+		}
+		if (monitorLifecycleSignal?.aborted === true && isMatrixStartupAbortError(err)) {
+			await cleanup("stop");
+			return;
+		}
+		statusController.noteUnexpectedError(err);
+		await cleanup();
+		throw err;
+	}
+}
+//#endregion
+export { monitorMatrixProvider };