@openclaw/matrix 2026.10.5-beta.4 → 2026.10.10-beta.1

package/dist/.setup/idb-persistence-BHTYPRe_.mjs

@@ -0,0 +1,233 @@
+import { t as getMatrixRuntime } from "./runtime-1kn1P6io.mjs";
+import { n as RETIRED_MATRIX_STATE_REMEDIATION } from "./retired-state-DOCruzWd.mjs";
+import { c as writeMatrixIdbSnapshotJson, r as readMatrixIdbSnapshotJson } from "./crypto-state-store-D4wrCvFs.mjs";
+import { t as LogService } from "./logger-CXQnpXCt.mjs";
+import { n as MATRIX_IDB_SNAPSHOT_LOCK_OPTIONS } from "./idb-persistence-lock-Bh3ZLIsE.mjs";
+import { toErrorObject } from "openclaw/plugin-sdk/error-runtime";
+import { asOptionalObjectRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
+import path from "node:path";
+import fs from "node:fs";
+import { withFileLock } from "openclaw/plugin-sdk/file-lock";
+import { IDBFactory, indexedDB } from "fake-indexeddb";
+//#region extensions/matrix/src/matrix/sdk/idb-persistence.ts
+const LEGACY_SNAPSHOT_DIAGNOSTIC = {
+	code: "matrix-idb-snapshot-requires-doctor",
+	message: "Matrix IndexedDB snapshot exists outside the current SQLite state",
+	remediation: RETIRED_MATRIX_STATE_REMEDIATION
+};
+var MatrixIdbSnapshotMigrationRequiredError = class extends Error {
+	constructor() {
+		super(`${LEGACY_SNAPSHOT_DIAGNOSTIC.message}; ${LEGACY_SNAPSHOT_DIAGNOSTIC.remediation}`);
+		this.code = LEGACY_SNAPSHOT_DIAGNOSTIC.code;
+		this.remediation = LEGACY_SNAPSHOT_DIAGNOSTIC.remediation;
+		this.name = "MatrixIdbSnapshotMigrationRequiredError";
+	}
+};
+function isValidIdbIndexSnapshot(value) {
+	const candidate = asOptionalObjectRecord(value);
+	return typeof candidate?.name === "string" && (typeof candidate.keyPath === "string" || Array.isArray(candidate.keyPath) && candidate.keyPath.every((entry) => typeof entry === "string")) && typeof candidate.multiEntry === "boolean" && typeof candidate.unique === "boolean";
+}
+function isValidIdbRecordSnapshot(value) {
+	const candidate = asOptionalObjectRecord(value);
+	return Boolean(candidate && "key" in candidate && "value" in candidate);
+}
+function isValidIdbStoreSnapshot(value) {
+	const candidate = asOptionalObjectRecord(value);
+	const keyPath = candidate?.keyPath;
+	const validKeyPath = keyPath === null || typeof keyPath === "string" || Array.isArray(keyPath) && keyPath.every((entry) => typeof entry === "string");
+	return typeof candidate?.name === "string" && validKeyPath && typeof candidate.autoIncrement === "boolean" && Array.isArray(candidate.indexes) && candidate.indexes.every((entry) => isValidIdbIndexSnapshot(entry)) && Array.isArray(candidate.records) && candidate.records.every((entry) => isValidIdbRecordSnapshot(entry));
+}
+function isValidIdbDatabaseSnapshot(value) {
+	const candidate = asOptionalObjectRecord(value);
+	return typeof candidate?.name === "string" && typeof candidate.version === "number" && Number.isFinite(candidate.version) && candidate.version > 0 && Array.isArray(candidate.stores) && candidate.stores.every((entry) => isValidIdbStoreSnapshot(entry));
+}
+function parseSnapshotPayload(data) {
+	const parsed = JSON.parse(data);
+	if (!Array.isArray(parsed) || parsed.length === 0) return null;
+	if (!parsed.every((entry) => isValidIdbDatabaseSnapshot(entry))) throw new Error("Malformed IndexedDB snapshot payload");
+	return parsed;
+}
+async function validateMatrixIdbSnapshotJson(data) {
+	const snapshot = parseSnapshotPayload(data);
+	if (!snapshot) throw new Error("Malformed IndexedDB snapshot payload");
+	await preflightIndexedDatabases(snapshot);
+}
+function idbReq(req) {
+	return new Promise((resolve, reject) => {
+		req.addEventListener("success", () => resolve(req.result), { once: true });
+		req.addEventListener("error", () => reject(toErrorObject(req.error, "Non-Error rejection")), { once: true });
+	});
+}
+async function dumpIndexedDatabases(databasePrefix) {
+	const idb = indexedDB;
+	const dbList = await idb.databases();
+	const snapshot = [];
+	const expectedPrefix = databasePrefix ? `${databasePrefix}::` : null;
+	for (const { name, version } of dbList) {
+		if (!name || !version) continue;
+		if (expectedPrefix && !name.startsWith(expectedPrefix)) continue;
+		const db = await idbReq(idb.open(name, version));
+		const stores = [];
+		for (const storeName of db.objectStoreNames) {
+			const store = db.transaction(storeName, "readonly").objectStore(storeName);
+			const storeInfo = {
+				name: storeName,
+				keyPath: store.keyPath,
+				autoIncrement: store.autoIncrement,
+				indexes: [],
+				records: []
+			};
+			for (const idxName of store.indexNames) {
+				const idx = store.index(idxName);
+				storeInfo.indexes.push({
+					name: idxName,
+					keyPath: idx.keyPath,
+					multiEntry: idx.multiEntry,
+					unique: idx.unique
+				});
+			}
+			const keys = await idbReq(store.getAllKeys());
+			const values = await idbReq(store.getAll());
+			storeInfo.records = keys.map((k, i) => ({
+				key: k,
+				value: values[i]
+			}));
+			stores.push(storeInfo);
+		}
+		snapshot.push({
+			name,
+			version,
+			stores
+		});
+		db.close();
+	}
+	return snapshot;
+}
+async function clearAccountIndexedDatabases(databasePrefix) {
+	if (!databasePrefix) return;
+	const names = await indexedDB.databases();
+	for (const { name } of names) if (name?.startsWith(`${databasePrefix}::`)) await idbReq(indexedDB.deleteDatabase(name));
+}
+async function restoreIndexedDatabases(snapshot, idb) {
+	for (const dbSnap of snapshot) {
+		const request = idb.open(dbSnap.name, dbSnap.version);
+		request.addEventListener("upgradeneeded", () => {
+			const db = request.result;
+			for (const storeSnap of dbSnap.stores) {
+				const opts = {};
+				if (storeSnap.keyPath !== null) opts.keyPath = storeSnap.keyPath;
+				if (storeSnap.autoIncrement) opts.autoIncrement = true;
+				const store = db.createObjectStore(storeSnap.name, opts);
+				for (const idx of storeSnap.indexes) store.createIndex(idx.name, idx.keyPath, {
+					unique: idx.unique,
+					multiEntry: idx.multiEntry
+				});
+			}
+		});
+		const db = await idbReq(request);
+		try {
+			for (const storeSnap of dbSnap.stores) {
+				if (storeSnap.records.length === 0) continue;
+				const tx = db.transaction(storeSnap.name, "readwrite");
+				await new Promise((resolve, reject) => {
+					let enqueueError;
+					tx.addEventListener("complete", () => resolve(), { once: true });
+					tx.addEventListener("abort", () => reject(enqueueError ?? toErrorObject(tx.error, "IndexedDB restore transaction aborted")), { once: true });
+					try {
+						const store = tx.objectStore(storeSnap.name);
+						for (const rec of storeSnap.records) if (storeSnap.keyPath !== null) store.put(rec.value);
+						else store.put(rec.value, rec.key);
+					} catch (err) {
+						enqueueError = toErrorObject(err, "IndexedDB restore enqueue failed");
+						tx.abort();
+					}
+				});
+			}
+		} finally {
+			db.close();
+		}
+	}
+}
+function resolveDefaultIdbSnapshotPath() {
+	const stateDir = process.env.OPENCLAW_STATE_DIR || path.join(process.env.HOME || "/tmp", ".openclaw");
+	return path.join(stateDir, "matrix", "crypto-idb-snapshot.json");
+}
+async function preflightIndexedDatabases(snapshot, databasePrefix) {
+	const names = /* @__PURE__ */ new Set();
+	for (const { name } of snapshot) {
+		if (names.has(name) || databasePrefix && !name.startsWith(`${databasePrefix}::`)) throw new Error("Malformed IndexedDB snapshot database names");
+		names.add(name);
+	}
+	await restoreIndexedDatabases(snapshot, new IDBFactory());
+}
+async function readCanonicalSnapshot(snapshotPath, stateRuntime) {
+	throwIfLegacySnapshotNeedsDoctor(snapshotPath);
+	const snapshotJson = await readMatrixIdbSnapshotJson(path.dirname(snapshotPath), stateRuntime);
+	if (snapshotJson === null) return null;
+	const snapshot = parseSnapshotPayload(snapshotJson);
+	if (!snapshot) throw new Error("Malformed IndexedDB snapshot payload");
+	return snapshot;
+}
+async function restoreIdbFromDisk(snapshotPath, stateRuntime, databasePrefix) {
+	const resolvedPath = snapshotPath ?? resolveDefaultIdbSnapshotPath();
+	let callbackStarted = false;
+	try {
+		const snapshotStateRuntime = stateRuntime ?? getMatrixRuntime().state;
+		return await withFileLock(resolvedPath, MATRIX_IDB_SNAPSHOT_LOCK_OPTIONS, async () => {
+			callbackStarted = true;
+			const snapshot = await readCanonicalSnapshot(resolvedPath, snapshotStateRuntime);
+			if (snapshot === null) {
+				await clearAccountIndexedDatabases(databasePrefix);
+				return false;
+			}
+			await preflightIndexedDatabases(snapshot, databasePrefix);
+			await clearAccountIndexedDatabases(databasePrefix);
+			await restoreIndexedDatabases(snapshot, indexedDB);
+			LogService.info("IdbPersistence", `Restored ${snapshot.length} IndexedDB database(s) from Matrix SQLite state`);
+			return true;
+		});
+	} catch (err) {
+		if (err instanceof MatrixIdbSnapshotMigrationRequiredError) throw err;
+		if (!callbackStarted && fs.existsSync(resolvedPath)) throwLegacySnapshotMigrationRequired();
+		LogService.warn("IdbPersistence", "Failed to restore IndexedDB snapshot from SQLite:", err);
+		throw err;
+	}
+}
+async function persistIdbToDisk(params) {
+	const snapshotPath = params?.snapshotPath ?? resolveDefaultIdbSnapshotPath();
+	let callbackStarted = false;
+	try {
+		const stateRuntime = params?.stateRuntime ?? getMatrixRuntime().state;
+		fs.mkdirSync(path.dirname(snapshotPath), { recursive: true });
+		const persistedCount = await withFileLock(snapshotPath, MATRIX_IDB_SNAPSHOT_LOCK_OPTIONS, async () => {
+			callbackStarted = true;
+			const storageRootDir = path.dirname(snapshotPath);
+			await readCanonicalSnapshot(snapshotPath, stateRuntime);
+			const snapshot = await dumpIndexedDatabases(params?.databasePrefix);
+			if (params?.abortSignal?.aborted || snapshot.length === 0) return 0;
+			await writeMatrixIdbSnapshotJson({
+				storageRootDir,
+				snapshotJson: JSON.stringify(snapshot),
+				databaseCount: snapshot.length,
+				stateRuntime
+			});
+			return snapshot.length;
+		});
+		if (persistedCount === 0) return;
+		LogService.debug("IdbPersistence", `Persisted ${persistedCount} IndexedDB database(s) to Matrix SQLite state`);
+	} catch (err) {
+		if (err instanceof MatrixIdbSnapshotMigrationRequiredError) throw err;
+		if (!callbackStarted && fs.existsSync(snapshotPath)) throwLegacySnapshotMigrationRequired();
+		LogService.warn("IdbPersistence", "Failed to persist IndexedDB snapshot:", err);
+		if (params?.strict) throw err;
+	}
+}
+function throwIfLegacySnapshotNeedsDoctor(snapshotPath) {
+	if (fs.existsSync(snapshotPath)) throwLegacySnapshotMigrationRequired();
+}
+function throwLegacySnapshotMigrationRequired() {
+	LogService.warn("IdbPersistence", LEGACY_SNAPSHOT_DIAGNOSTIC);
+	throw new MatrixIdbSnapshotMigrationRequiredError();
+}
+//#endregion
+export { persistIdbToDisk, resolveDefaultIdbSnapshotPath, restoreIdbFromDisk, validateMatrixIdbSnapshotJson };

package/dist/.setup/idb-persistence-lock-Bh3ZLIsE.mjs

@@ -0,0 +1,14 @@
+//#region extensions/matrix/src/matrix/sdk/idb-persistence-lock.ts
+const MATRIX_IDB_PERSIST_INTERVAL_MS = 6e4;
+const MATRIX_IDB_SNAPSHOT_LOCK_OPTIONS = {
+	retries: {
+		retries: 18,
+		factor: 2,
+		minTimeout: 50,
+		maxTimeout: 5e3,
+		randomize: true
+	},
+	stale: 3e5
+};
+//#endregion
+export { MATRIX_IDB_SNAPSHOT_LOCK_OPTIONS as n, MATRIX_IDB_PERSIST_INTERVAL_MS as t };

package/dist/.setup/{messages-B1CZqU8u.mjs → messages-_XHVg3do.mjs}

@@ -1,6 +1,6 @@
 import { a as MATRIX_REACTION_EVENT_TYPE } from "./send-currentness-C2rMVVIQ.mjs";
-import { _ as isPollEventType, b as resolvePollReferenceEventId, d as resolveMatrixReplacementContent, g as formatPollResultsAsText, m as buildPollResultsSummary, r as sendMessageMatrix, t as editMessageMatrix, u as resolveMatrixMessageAttachment, v as isPollStartType, y as parsePollStart } from "./send-LCOuTVc1.mjs";
-import { r as withResolvedRoomAction } from "./client-BlTvpEWC.mjs";
+import { _ as isPollEventType, b as resolvePollReferenceEventId, d as resolveMatrixReplacementContent, g as formatPollResultsAsText, m as buildPollResultsSummary, t as editMessageMatrix, u as resolveMatrixMessageAttachment, v as isPollStartType, y as parsePollStart } from "./send-BprM-Wmx.mjs";
+import { r as withResolvedRoomAction } from "./client-BKiiI29H.mjs";
 import { n as isMatrixNotFoundError } from "./errors-Bw4EHwKX.mjs";
 import { asNullableObjectRecord, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/matrix/src/matrix/poll-summary.ts
@@ -168,21 +168,6 @@ function resolveLatestMatrixReplacements(events) {
 		replacements
 	};
 }
-async function sendMatrixMessage(to, content, opts = {}) {
-	if (!opts.cfg) throw new Error("Matrix message actions require a resolved runtime config.");
-	return await sendMessageMatrix(to, content, {
-		cfg: opts.cfg,
-		mediaUrl: opts.mediaUrl,
-		...opts.mediaAccess ? { mediaAccess: opts.mediaAccess } : {},
-		mediaLocalRoots: opts.mediaLocalRoots,
-		replyToId: opts.replyToId,
-		threadId: opts.threadId,
-		audioAsVoice: opts.audioAsVoice,
-		accountId: opts.accountId ?? void 0,
-		client: opts.client,
-		timeoutMs: opts.timeoutMs
-	});
-}
 async function editMatrixMessage(roomId, messageId, content, opts = {}) {
 	if (!opts.cfg) throw new Error("Matrix message actions require a resolved runtime config.");
 	if (!content.trim()) throw new Error("Matrix edit requires content");
@@ -306,4 +291,4 @@ async function isMatrixPollRootThreaded(params) {
 	return hydratedRoot ? isMatrixThreadEvent(hydratedRoot) : false;
 }
 //#endregion
-export { sendMatrixMessage as a, EventType as c, readMatrixMessages as i, resolveMatrixActionLimit as l, editMatrixMessage as n, fetchEventSummary as o, readMatrixMessage as r, readPinnedEvents as s, deleteMatrixMessage as t, fetchMatrixPollSnapshot as u };
+export { fetchEventSummary as a, resolveMatrixActionLimit as c, readMatrixMessages as i, fetchMatrixPollSnapshot as l, editMatrixMessage as n, readPinnedEvents as o, readMatrixMessage as r, EventType as s, deleteMatrixMessage as t };

package/dist/.setup/{monitor-Dk_fQL1k.mjs → monitor-DRUSJ_Ev.mjs}

@@ -1,22 +1,23 @@
 import { t as getMatrixRuntime } from "./runtime-1kn1P6io.mjs";
 import { a as resolveMatrixAccountConfig, i as resolveMatrixAccountAllowlistConfig } from "./account-config-CRsKoMqJ.mjs";
-import { h as resolveConfiguredMatrixBotUserIds } from "./setup-core-CKnNTfgD.mjs";
-import { a as resolveMatrixThreadRouting, i as resolveMatrixInboundRoute, n as resolveMatrixStoredSessionMeta, o as resolveMatrixRoomConfig } from "./channel-BcwGspPw.mjs";
-import { a as resolveMatrixAllowListMatch, i as normalizeMatrixUserId, r as normalizeMatrixAllowList } from "./channel.setup-CwuYD_CT.mjs";
+import { h as resolveConfiguredMatrixBotUserIds } from "./setup-core-DcCk1_Tv.mjs";
+import { a as resolveMatrixThreadRouting, i as resolveMatrixInboundRouteAsync, n as resolveMatrixStoredSessionMeta, o as resolveMatrixRoomConfig } from "./channel-Dw4_imdd.mjs";
+import { a as resolveMatrixAllowListMatch, i as normalizeMatrixUserId, r as normalizeMatrixAllowList } from "./channel.setup-Be8TYKMA.mjs";
 import { n as isMatrixQualifiedUserId, r as isMatrixRoomId, t as isMatrixInviteAutoJoinTarget } from "./target-ids-HhcaKX1n.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-B3wYhx_M.mjs";
-import { _ as isPollEventType, c as formatMatrixMessageText, d as resolveMatrixReplacementContent, h as formatPollAsText, l as isLikelyBareFilename, r as sendMessageMatrix, u as resolveMatrixMessageAttachment, v as isPollStartType, w as setBoundedMap, y as parsePollStart } from "./send-LCOuTVc1.mjs";
-import { t as createMatrixThreadBindingManager } from "./thread-bindings-CT4P-OSZ.mjs";
-import { i as readMatrixMessages, u as fetchMatrixPollSnapshot } from "./messages-B1CZqU8u.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-vPPbaxNp.mjs";
+import { _ as isPollEventType, c as formatMatrixMessageText, d as resolveMatrixReplacementContent, h as formatPollAsText, l as isLikelyBareFilename, r as sendMessageMatrix, u as resolveMatrixMessageAttachment, v as isPollStartType, w as setBoundedMap, y as parsePollStart } from "./send-BprM-Wmx.mjs";
+import { t as createMatrixThreadBindingManager } from "./thread-bindings-rrwQAS6R.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-C4Gibhzl.mjs";
+import { i as readMatrixMessages, l as fetchMatrixPollSnapshot } from "./messages-_XHVg3do.mjs";
 import { i as isMatrixMediaSizeLimitError, r as MatrixMediaSizeLimitError } from "./http-client-ByR4STVQ.mjs";
-import { n as prepareMatrixReplyPayload, r as resolveMatrixExtraContent } from "./outbound-LR3SqPIq.mjs";
-import { t as resolveMatrixTargets } from "./resolve-targets-BVVbbvP6.mjs";
+import { n as prepareMatrixReplyPayload, r as resolveMatrixExtraContent } from "./outbound-D5Z_4FBg.mjs";
+import { t as resolveMatrixTargets } from "./resolve-targets-BJ5sIKeM.mjs";
 import { t as formatMatrixEncryptedEventDisabledWarning } from "./encryption-guidance-D5_IsDIy.mjs";
 import { createMatrixInboundEventDeduper } from "./inbound-dedupe-C-EBGY0B.mjs";
 import { a as isMatrixAccessTokenInvalidatedError, d as isMatrixDisconnectedSyncState, f as isMatrixReadySyncState, p as isMatrixTerminalSyncState } from "./client-support-D-xHScuo.mjs";
-import { r as getMatrixRoomInfo, t as createMatrixRoomInfoResolver } from "./room-info-9Uqlpt1V.mjs";
+import { r as getMatrixRoomInfo, t as createMatrixRoomInfoResolver } from "./room-info-BE7bbX_c.mjs";
+import { channelBlockedPatch, channelReadyPatch, channelStoppedPatch, createTransportActivityStatusPatch } from "openclaw/plugin-sdk/gateway-runtime";
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 import { createChannelDeliveryAccumulator, createChannelProgressDraftCompositor, createLivePreviewLifecycle, createPreviewMessageReceipt, createReplyPrefixOptions, createTypingCallbacks, logTypingFailure, resolveChannelStreamingBlockEnabled, waitUntilAbort } from "openclaw/plugin-sdk/channel-outbound";
 import { extractErrorCode, formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
@@ -27,7 +28,7 @@ import { addAllowlistUserEntriesFromConfigEntry, buildAllowlistResolutionSummary
 import { normalizeStringEntries as normalizeStringEntries$1 } from "openclaw/plugin-sdk/string-normalization-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 { getSessionEntryAsync, 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";
@@ -49,7 +50,6 @@ import { createChannelPreflightAudio, formatAudioTranscriptForAgent } from "open
 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;
@@ -1260,14 +1260,14 @@ function registerMatrixMonitorEvents(params) {
 				accountId: auth.accountId,
 				conversationId: roomId,
 				deliverTo: `room:${roomId}`,
-				route: resolveMatrixInboundRoute({
+				route: (await resolveMatrixInboundRouteAsync({
 					cfg,
 					accountId: auth.accountId,
 					roomId,
 					senderId: auth.userId,
 					isDirectMessage: false,
 					resolveAgentRoute
-				}).route,
+				})).route,
 				roomAllowed,
 				resolveRoomContext: async ({ messageLimit }) => {
 					const info = await getMatrixRoomInfo(roomId, options);
@@ -1510,11 +1510,11 @@ function markTrackedRoomIfFirst(set, roomId) {
 	}
 	return true;
 }
-function resolveMatrixSharedDmContextNotice(params) {
+async 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({
+		const currentSession = resolveMatrixStoredSessionMeta(await getSessionEntryAsync({
 			storePath: params.storePath,
 			sessionKey: params.sessionKey
 		}));
@@ -1574,11 +1574,11 @@ function formatMatrixToolProgressMarkdownCode(text) {
 }
 //#endregion
 //#region extensions/matrix/src/matrix/monitor/handler-runtime.ts
-const loadMatrixSendModule = createLazyRuntimeModule(() => import("./send-LCOuTVc1.mjs").then((n) => n.s));
+const loadMatrixSendModule = createLazyRuntimeModule(() => import("./send-BprM-Wmx.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-CTSvOlXO.mjs"));
-const loadMatrixDraftStream = createLazyRuntimeModule(() => import("./draft-stream-Bdrh7dRt.mjs"));
+const loadMatrixReactionEvents = createLazyRuntimeModule(() => import("./reaction-events-BG9spedG.mjs"));
+const loadMatrixDraftStream = createLazyRuntimeModule(() => import("./draft-stream-DYf0th1n.mjs"));
 async function matrixTextWouldActivateMentions(client, text) {
 	const { resolveMatrixMentionsForBody } = await loadMatrixSendModule();
 	const mentions = await resolveMatrixMentionsForBody({
@@ -1645,7 +1645,7 @@ async function resolveMatrixInboundContext(config) {
 		route: _route
 	});
 	const sharedDmNoticeSessionKey = threadTarget ? _route.mainSessionKey || _route.sessionKey : _route.sessionKey;
-	const sharedDmContextNotice = isDirectMessage ? hasExplicitSessionBinding ? null : resolveMatrixSharedDmContextNotice({
+	const sharedDmContextNotice = isDirectMessage ? hasExplicitSessionBinding ? null : await resolveMatrixSharedDmContextNotice({
 		storePath,
 		sessionKey: sharedDmNoticeSessionKey,
 		roomId,
@@ -1736,6 +1736,7 @@ async function resolveMatrixInboundContext(config) {
 		},
 		sessionTranscript: { historyLimit: isRoom ? historyLimit : 0 },
 		access: {
+			toolPolicy: isRoom ? roomConfig?.tools ?? {} : void 0,
 			...isRoom ? { mentions: {
 				canDetectMention: true,
 				wasMentioned,
@@ -1745,6 +1746,7 @@ async function resolveMatrixInboundContext(config) {
 		},
 		extra: {
 			GroupSubject: isRoom ? roomName ?? roomId : void 0,
+			GroupChannel: isRoom ? roomId : void 0,
 			GroupId: isRoom ? roomId : void 0,
 			...locationPayload?.context,
 			CommandSource: "text",
@@ -1942,7 +1944,6 @@ function createRoomHistoryTracker(maxQueueSize = DEFAULT_MAX_QUEUE_SIZE, maxRoom
 	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);
@@ -1953,7 +1954,6 @@ function createRoomHistoryTracker(maxQueueSize = DEFAULT_MAX_QUEUE_SIZE, maxRoom
 		return {
 			entries: [],
 			baseIndex: 0,
-			generation: nextQueueGeneration++,
 			preparedTriggers: /* @__PURE__ */ new Map()
 		};
 	}
@@ -2006,10 +2006,7 @@ function createRoomHistoryTracker(maxQueueSize = DEFAULT_MAX_QUEUE_SIZE, maxRoom
 			queue.entries.splice(0, overflow);
 			queue.baseIndex += overflow;
 		}
-		return {
-			snapshotIdx: queue.baseIndex + queue.entries.length,
-			queueGeneration: queue.generation
-		};
+		return { snapshotIdx: queue.baseIndex + queue.entries.length };
 	}
 	function wmKey(agentId, roomId, threadRootId) {
 		return JSON.stringify({
@@ -2055,7 +2052,7 @@ function createRoomHistoryTracker(maxQueueSize = DEFAULT_MAX_QUEUE_SIZE, maxRoom
 		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;
+			if (rel < 0 || rel >= queue.entries.length) slot = void 0;
 		}
 		const retryKey = preparedTriggerKey(agentId, entry.messageId);
 		if (retryKey) {
@@ -2068,17 +2065,14 @@ function createRoomHistoryTracker(maxQueueSize = DEFAULT_MAX_QUEUE_SIZE, maxRoom
 		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)
+			...slot ? { snapshotIdx: slot.slotIdx + 1 } : 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;
+		if (!queue) return;
 		const rel = slot.slotIdx - queue.baseIndex;
 		if (rel < 0 || rel >= queue.entries.length) return;
 		queue.entries[rel] = entry;
@@ -2116,7 +2110,6 @@ function createRoomHistoryTracker(maxQueueSize = DEFAULT_MAX_QUEUE_SIZE, maxRoom
 				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);
@@ -2562,7 +2555,7 @@ async function resolveMatrixIngressContent(config) {
 			return null;
 		}
 	};
-	const { route: _route, configuredBinding: _configuredBinding, runtimeBindingId: _runtimeBindingId } = resolveMatrixInboundRoute({
+	const { route: _route, configuredBinding: _configuredBinding, runtimeBindingId: _runtimeBindingId } = await resolveMatrixInboundRouteAsync({
 		cfg,
 		accountId,
 		roomId,
@@ -2758,7 +2751,7 @@ async function resolveMatrixIngressContent(config) {
 	}
 	if (_runtimeBindingId) {
 		const { getSessionBindingService } = await loadSessionBindingRuntime();
-		getSessionBindingService().touch(_runtimeBindingId, eventTs ?? void 0, {
+		await getSessionBindingService().touchAsync(_runtimeBindingId, eventTs ?? void 0, {
 			channel: "matrix",
 			accountId
 		});
@@ -3603,10 +3596,10 @@ function shouldPromoteRecentInviteRoom(params) {
 //#endregion
 //#region extensions/matrix/src/matrix/monitor/startup.ts
 const loadMatrixStartupMaintenanceDeps = createLazyRuntimeModule(() => Promise.all([
-	import("./setup-core-CKnNTfgD.mjs").then((n) => n.f),
+	import("./setup-core-DcCk1_Tv.mjs").then((n) => n.f),
 	import("./device-health-Be60VF1w.mjs").then((n) => n.t),
-	import("./setup-core-CKnNTfgD.mjs").then((n) => n.u),
-	import("./startup-verification-CgfUb4yJ.mjs")
+	import("./setup-core-DcCk1_Tv.mjs").then((n) => n.u),
+	import("./startup-verification-UU8DUvi4.mjs")
 ]).then(([configUpdateModule, deviceHealthModule, profileModule, startupVerificationModule]) => ({
 	updateMatrixAccountConfig: configUpdateModule.updateMatrixAccountConfig,
 	summarizeMatrixDeviceHealth: deviceHealthModule.summarizeMatrixDeviceHealth,
@@ -3811,7 +3804,6 @@ function createMatrixMonitorSyncLifecycle(params) {
 	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);

package/dist/.setup/{onboarding-CrSexor_.mjs → onboarding-CK9Ksgio.mjs}

@@ -1,7 +1,7 @@
 import { i as __exportAll } from "./doctor-contract-CsTNmbMa.mjs";
 import { i as requiresExplicitMatrixDefaultAccount, u as resolveMatrixEnvAuthReadiness } from "./account-selection-Bs_jCAaG.mjs";
 import { a as resolveMatrixAccountConfig } from "./account-config-CRsKoMqJ.mjs";
-import { a as createMatrixSetupDmPolicy, g as resolveDefaultMatrixAccountId, m as listMatrixAccountIds, n as finishMatrixSetupAfterConfigWrite, o as moveSingleMatrixAccountConfigToNamedAccount, p as updateMatrixAccountConfig, v as resolveMatrixAccountAsync } from "./setup-core-CKnNTfgD.mjs";
+import { a as createMatrixSetupDmPolicy, g as resolveDefaultMatrixAccountId, m as listMatrixAccountIds, n as finishMatrixSetupAfterConfigWrite, o as moveSingleMatrixAccountConfigToNamedAccount, p as updateMatrixAccountConfig, v as resolveMatrixAccountAsync } from "./setup-core-DcCk1_Tv.mjs";
 import { r as isMatrixRoomId, t as isMatrixInviteAutoJoinTarget } from "./target-ids-HhcaKX1n.mjs";
 import { n as validateMatrixHomeserverUrl, t as resolveValidatedMatrixHomeserverUrl } from "./url-validation-CF6pG6eE.mjs";
 import { n as ensureMatrixSdkInstalled, r as isMatrixSdkAvailable } from "./deps-L_1bUAGL.mjs";
@@ -87,7 +87,7 @@ async function promptMatrixAllowFrom(params) {
 			pending.push(part);
 		}
 		if (pending.length > 0) {
-			const { resolveMatrixTargets } = await import("./resolve-targets-BVVbbvP6.mjs").then((n) => n.n);
+			const { resolveMatrixTargets } = await import("./resolve-targets-BJ5sIKeM.mjs").then((n) => n.n);
 			const results = await resolveMatrixTargets({
 				cfg,
 				accountId,
@@ -204,7 +204,7 @@ async function configureMatrixAccessPrompts(params) {
 						resolvedIds.push(cleaned);
 						continue;
 					}
-					const { listMatrixDirectoryGroupsLive } = await import("./directory-live-B1WbfSHo.mjs").then((n) => n.t);
+					const { listMatrixDirectoryGroupsLive } = await import("./directory-live-BpSz-FQB.mjs").then((n) => n.t);
 					const matches = await listMatrixDirectoryGroupsLive({
 						cfg: next,
 						accountId: params.accountId,

package/dist/.setup/{outbound-LR3SqPIq.mjs → outbound-D5Z_4FBg.mjs}

@@ -1,5 +1,5 @@
-import { r as matrixPresentationCapabilities } from "./channel-BcwGspPw.mjs";
-import { i as sendPollMatrix, r as sendMessageMatrix } from "./send-LCOuTVc1.mjs";
+import { r as matrixPresentationCapabilities } from "./channel-Dw4_imdd.mjs";
+import { i as sendPollMatrix, r as sendMessageMatrix } from "./send-BprM-Wmx.mjs";
 import { createMessageReceiptFromOutboundResults, createReplyToFanout, resolveOutboundSendDep } from "openclaw/plugin-sdk/channel-outbound";
 import { asOptionalRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { chunkTextForOutbound } from "openclaw/plugin-sdk/text-chunking";
@@ -122,50 +122,42 @@ const matrixOutbound = {
 			deliveryQueueId,
 			signal,
 			assertDirectAdapterHandoff,
-			onPlatformSendDispatch
+			onPlatformSendDispatch,
+			audioAsVoice: payload.audioAsVoice ?? audioAsVoice,
+			onDeliveryResult: resolveMatrixDeliveryProgress(onDeliveryResult)
 		};
+		const sendPart = (text, index, mediaUrl) => send(to, text, {
+			...sendOptions,
+			mediaUrl,
+			replyToId: resolveReplyToId(),
+			deliveryPartIndex: index,
+			deliveryPartCount: urls.length || 1,
+			extraContent: index === 0 ? resolveMatrixExtraContent(payload) : void 0
+		});
 		if (urls.length > 0) {
 			const sentResults = [];
-			const lastResult = await sendPayloadMediaSequence({
+			await sendPayloadMediaSequence({
 				text: payloadText,
 				mediaUrls: urls,
-				send: async ({ text, mediaUrl, index, isFirst }) => await send(to, text, {
-					...sendOptions,
-					mediaUrl,
-					replyToId: resolveReplyToId(),
-					audioAsVoice: payload.audioAsVoice ?? audioAsVoice,
-					deliveryPartIndex: index,
-					deliveryPartCount: urls.length,
-					extraContent: isFirst ? resolveMatrixExtraContent(payload) : void 0,
-					onDeliveryResult: resolveMatrixDeliveryProgress(onDeliveryResult)
-				}),
+				send: ({ text, mediaUrl, index }) => sendPart(text, index, mediaUrl),
 				onResult: (result) => {
 					sentResults.push(result);
 				}
 			});
-			if (lastResult !== void 0) {
-				const receipt = createMessageReceiptFromOutboundResults({ results: sentResults });
-				receipt.parts = receipt.parts.map((part, index) => ({
-					...part,
-					index
-				}));
-				return attachChannelToResult("matrix", toMatrixOutboundResult({
-					...lastResult,
-					primaryMessageId: receipt.primaryPlatformMessageId,
-					receipt,
-					content: sentResults.map((result) => result.content).join("\n")
-				}));
-			}
+			const lastResult = sentResults.at(-1);
+			const receipt = createMessageReceiptFromOutboundResults({ results: sentResults });
+			receipt.parts = receipt.parts.map((part, index) => ({
+				...part,
+				index
+			}));
+			return attachChannelToResult("matrix", toMatrixOutboundResult({
+				...lastResult,
+				primaryMessageId: receipt.primaryPlatformMessageId,
+				receipt,
+				content: sentResults.map((result) => result.content).join("\n")
+			}));
 		}
-		const result = await send(to, payloadText, {
-			...sendOptions,
-			replyToId: resolveReplyToId(),
-			audioAsVoice: payload.audioAsVoice ?? audioAsVoice,
-			deliveryPartIndex: 0,
-			deliveryPartCount: 1,
-			extraContent: resolveMatrixExtraContent(payload),
-			onDeliveryResult: resolveMatrixDeliveryProgress(onDeliveryResult)
-		});
+		const result = await sendPart(payloadText, 0);
 		return attachChannelToResult("matrix", toMatrixOutboundResult(result));
 	},
 	sendText: (ctx) => sendMatrixOutbound(ctx),

package/dist/.setup/{profile-update-C7bjaGR6.mjs → profile-update--Pf3jCXD.mjs}

@@ -1,7 +1,7 @@
 import { t as getMatrixRuntime } from "./runtime-1kn1P6io.mjs";
-import { d as syncMatrixOwnProfile, p as updateMatrixAccountConfig } from "./setup-core-CKnNTfgD.mjs";
+import { d as syncMatrixOwnProfile, p as updateMatrixAccountConfig } from "./setup-core-DcCk1_Tv.mjs";
 import { n as resolveMatrixConfigPath } from "./config-paths-CnREYb1Y.mjs";
-import { n as withResolvedActionClient } from "./client-BlTvpEWC.mjs";
+import { n as withResolvedActionClient } from "./client-BKiiI29H.mjs";
 import { normalizeAccountId } from "openclaw/plugin-sdk/account-id";
 //#region extensions/matrix/src/matrix/actions/profile.ts
 async function updateMatrixOwnProfile(opts = {}) {