@openclaw/matrix 2026.7.1-beta.6 → 2026.7.2-beta.1

package/dist/{doctor-contract-BAja_fmb.js → doctor-contract-D2qTLe-C.js}

@@ -1,6 +1,66 @@
-import { o as isRecord } from "./account-selection-5e4mHR1m.js";
+import { t as isRecord } from "./record-shared-CvzjvHRn.js";
+import { defineChannelAliasMigration } from "openclaw/plugin-sdk/runtime-doctor";
 import { hasLegacyFlatAllowPrivateNetworkAlias, migrateLegacyFlatAllowPrivateNetworkAlias } from "openclaw/plugin-sdk/ssrf-runtime";
 //#region extensions/matrix/src/doctor-contract.ts
+function parseMatrixStreamingMode(value) {
+	if (typeof value !== "string") return null;
+	const normalized = value.trim().toLowerCase();
+	return normalized === "partial" || normalized === "quiet" || normalized === "progress" || normalized === "off" ? normalized : null;
+}
+const streamingAliasMigration = defineChannelAliasMigration({
+	channelId: "matrix",
+	streaming: {
+		defaultMode: "off",
+		resolveMode: (entry) => {
+			const streaming = isRecord(entry.streaming) ? entry.streaming : null;
+			const parsed = parseMatrixStreamingMode(streaming ? streaming.mode : entry.streaming);
+			if (parsed) return parsed;
+			return entry.streaming === true ? "partial" : "off";
+		}
+	},
+	accountStreamingReplacesRoot: true
+});
+function stripMatrixJunkStreamMode(cfg, changes) {
+	const channels = isRecord(cfg.channels) ? cfg.channels : null;
+	const matrix = isRecord(channels?.matrix) ? channels.matrix : null;
+	if (!matrix) return cfg;
+	let updated = matrix;
+	let changed = false;
+	if (updated.streamMode !== void 0) {
+		const { streamMode: _streamMode, ...rest } = updated;
+		updated = rest;
+		changes.push("Removed channels.matrix.streamMode (never read by the Matrix runtime).");
+		changed = true;
+	}
+	const accounts = isRecord(updated.accounts) ? updated.accounts : null;
+	if (accounts) {
+		let accountsChanged = false;
+		const nextAccounts = { ...accounts };
+		for (const [accountId, accountValue] of Object.entries(accounts)) {
+			const account = isRecord(accountValue) ? accountValue : null;
+			if (!account || account.streamMode === void 0) continue;
+			const { streamMode: _streamMode, ...rest } = account;
+			nextAccounts[accountId] = rest;
+			changes.push(`Removed channels.matrix.accounts.${accountId}.streamMode (never read by the Matrix runtime).`);
+			accountsChanged = true;
+		}
+		if (accountsChanged) {
+			updated = {
+				...updated,
+				accounts: nextAccounts
+			};
+			changed = true;
+		}
+	}
+	if (!changed) return cfg;
+	return {
+		...cfg,
+		channels: {
+			...channels,
+			matrix: updated
+		}
+	};
+}
 function hasLegacyMatrixRoomAllowAlias(value) {
 	const room = isRecord(value) ? value : null;
 	return Boolean(room && typeof room.allow === "boolean");
@@ -73,6 +133,7 @@ function normalizeMatrixRoomAllowAliases(params) {
 	};
 }
 const legacyConfigRules = [
+	...streamingAliasMigration.legacyConfigRules,
 	{
 		path: ["channels", "matrix"],
 		message: "channels.matrix.allowPrivateNetwork is legacy; use channels.matrix.network.dangerouslyAllowPrivateNetwork instead. Run \"openclaw doctor --fix\".",
@@ -130,15 +191,20 @@ const legacyConfigRules = [
 	}
 ];
 function normalizeCompatibilityConfig({ cfg }) {
-	const channels = isRecord(cfg.channels) ? cfg.channels : null;
+	const changes = [];
+	const withoutJunkStreamMode = stripMatrixJunkStreamMode(cfg, changes);
+	const aliases = streamingAliasMigration.normalizeChannelConfig({
+		cfg: withoutJunkStreamMode,
+		changes
+	});
+	const channels = isRecord(aliases.config.channels) ? aliases.config.channels : null;
 	const matrix = isRecord(channels?.matrix) ? channels.matrix : null;
 	if (!matrix) return {
 		config: cfg,
 		changes: []
 	};
-	const changes = [];
 	let updatedMatrix = matrix;
-	let changed = false;
+	let changed = aliases.config !== cfg;
 	const topLevelPrivateNetwork = migrateLegacyFlatAllowPrivateNetworkAlias({
 		entry: updatedMatrix,
 		pathPrefix: "channels.matrix",
@@ -233,9 +299,9 @@ function normalizeCompatibilityConfig({ cfg }) {
 	};
 	return {
 		config: {
-			...cfg,
+			...aliases.config,
 			channels: {
-				...cfg.channels,
+				...aliases.config.channels,
 				matrix: updatedMatrix
 			}
 		},

package/dist/doctor-contract-api.js

@@ -1,11 +1,201 @@
-import { n as normalizeCompatibilityConfig, t as legacyConfigRules } from "./doctor-contract-BAja_fmb.js";
-import { D as writeMatrixRecoveryKeyStateToStore, S as writeMatrixIdbSnapshotJsonToStore, a as hasMatrixLegacyCryptoMigrationStateInStore, d as openMatrixLegacyCryptoMigrationStoreOptions, f as openMatrixRecoveryKeyStoreOptions, h as readLegacyMatrixRecoveryKeyState, i as hasMatrixIdbSnapshotStateInStore, n as MATRIX_LEGACY_CRYPTO_MIGRATION_FILENAME, o as hasMatrixRecoveryKeyStateInStore, p as readLegacyMatrixLegacyCryptoMigrationState, r as MATRIX_RECOVERY_KEY_FILENAME, t as MATRIX_IDB_SNAPSHOT_FILENAME, u as openMatrixIdbSnapshotStoreOptions, w as writeMatrixLegacyCryptoMigrationStateToStore } from "./crypto-state-store-Jy3qwhdy.js";
-import { a as openMatrixStorageMetaStoreOptions, i as normalizeMatrixStorageMetadata, n as hasMatrixStorageMetaStateInStore, u as writeMatrixStorageMetaStateToStore } from "./storage-CQdyKcGg.js";
-import { a as readLegacyMatrixSyncCacheState, i as openMatrixSyncCacheStoreOptions, o as writeMatrixSyncCacheStateToStore, r as hasMatrixSyncCacheStateInStore } from "./file-sync-store-DVm0ACml.js";
-import { r as readLegacyMatrixIdbSnapshotState } from "./idb-persistence-BHm97th-.js";
+import { t as isRecord } from "./record-shared-CvzjvHRn.js";
+import { n as normalizeCompatibilityConfig, t as legacyConfigRules } from "./doctor-contract-D2qTLe-C.js";
+import { O as writeMatrixIdbSnapshotJsonToStore, S as readLegacyMatrixLegacyCryptoMigrationState, _ as hasMatrixRecoveryKeyStateInStore, a as openMatrixStorageMetaStoreOptions, b as openMatrixLegacyCryptoMigrationStoreOptions, f as MATRIX_IDB_SNAPSHOT_FILENAME, g as hasMatrixLegacyCryptoMigrationStateInStore, h as hasMatrixIdbSnapshotStateInStore, i as normalizeMatrixStorageMetadata, j as writeMatrixRecoveryKeyStateToStore, k as writeMatrixLegacyCryptoMigrationStateToStore, m as MATRIX_RECOVERY_KEY_FILENAME, n as hasMatrixStorageMetaStateInStore, p as MATRIX_LEGACY_CRYPTO_MIGRATION_FILENAME, u as writeMatrixStorageMetaStateToStore, w as readLegacyMatrixRecoveryKeyState, x as openMatrixRecoveryKeyStoreOptions, y as openMatrixIdbSnapshotStoreOptions } from "./storage-BtSOar8T.js";
+import { a as readLegacyMatrixSyncCacheState, i as openMatrixSyncCacheStoreOptions, o as writeMatrixSyncCacheStateToStore, r as hasMatrixSyncCacheStateInStore } from "./file-sync-store-Cxb0ckyX.js";
+import { a as resolveMatrixInboundDedupeStateNamespace, n as MATRIX_INBOUND_DEDUPE_TTL_MS, r as buildMatrixInboundDedupeEventKey } from "./inbound-dedupe-DcMs0YXL.js";
+import { r as readLegacyMatrixIdbSnapshotState } from "./idb-persistence-iUZoHZkp.js";
 import path from "node:path";
+import { createHash } from "node:crypto";
+import { archiveLegacyStateSource } from "openclaw/plugin-sdk/runtime-doctor";
 import fs from "node:fs/promises";
-import { legacyStateFileExists } from "openclaw/plugin-sdk/runtime-doctor";
+import { createPersistentDedupeImportEntry } from "openclaw/plugin-sdk/persistent-dedupe";
+//#region extensions/matrix/src/matrix/monitor/inbound-dedupe-migration.ts
+const LEGACY_SQLITE_NAMESPACE = "inbound-dedupe";
+const LEGACY_SQLITE_MAX_ENTRIES = 2e4;
+const LEGACY_MARKERS_NAMESPACE = "inbound-dedupe-migrations";
+const LEGACY_MARKERS_MAX_ENTRIES = 1e3;
+const LEGACY_JSON_VERSION = 1;
+const STORAGE_META_FILENAME = "storage-meta.json";
+const MATRIX_LEGACY_INBOUND_DEDUPE_FILENAME = "inbound-dedupe.json";
+async function collectMatrixInboundDedupeSources(stateDir) {
+	const matrixRoot = path.join(stateDir, "matrix");
+	const sqliteRoots = /* @__PURE__ */ new Set();
+	const jsonRoots = /* @__PURE__ */ new Set();
+	async function visit(dir) {
+		let entries;
+		try {
+			entries = await fs.readdir(dir, { withFileTypes: true });
+		} catch {
+			return;
+		}
+		for (const entry of entries) {
+			const entryPath = path.join(dir, entry.name);
+			if (entry.isFile()) {
+				if (entry.name === "openclaw.sqlite" && path.basename(dir) === "state") sqliteRoots.add(path.dirname(dir));
+				else if (entry.name === "inbound-dedupe.json") jsonRoots.add(dir);
+				continue;
+			}
+			if (entry.isDirectory()) await visit(entryPath);
+		}
+	}
+	await visit(matrixRoot);
+	const matrixRootResolved = path.resolve(matrixRoot);
+	const isAccountRoot = (root) => path.resolve(root) !== matrixRootResolved;
+	return {
+		sqliteRoots: [...sqliteRoots].filter(isAccountRoot).toSorted(),
+		jsonRoots: [...jsonRoots].filter(isAccountRoot).toSorted()
+	};
+}
+function openLegacySqliteStore(io, storageRootDir) {
+	return io.context.openPluginStateKeyedStore({
+		namespace: LEGACY_SQLITE_NAMESPACE,
+		maxEntries: LEGACY_SQLITE_MAX_ENTRIES,
+		env: {
+			...io.env,
+			OPENCLAW_STATE_DIR: storageRootDir
+		}
+	});
+}
+function openLegacyMarkersStore(io, storageRootDir) {
+	return io.context.openPluginStateKeyedStore({
+		namespace: LEGACY_MARKERS_NAMESPACE,
+		maxEntries: LEGACY_MARKERS_MAX_ENTRIES,
+		env: {
+			...io.env,
+			OPENCLAW_STATE_DIR: storageRootDir
+		}
+	});
+}
+function normalizeLegacyTimestamp(raw) {
+	if (typeof raw !== "number" || !Number.isFinite(raw)) return null;
+	return Math.max(0, Math.floor(raw));
+}
+function parseLegacySqliteRow(row) {
+	const value = isRecord(row.value) ? row.value : {};
+	const roomId = typeof value.roomId === "string" ? value.roomId.trim() : "";
+	const eventId = typeof value.eventId === "string" ? value.eventId.trim() : "";
+	const ts = normalizeLegacyTimestamp(value.ts);
+	const separator = row.key.lastIndexOf(":");
+	if (!roomId || !eventId || ts === null || separator <= 0) return null;
+	const accountId = row.key.slice(0, separator);
+	const digest = createHash("sha256").update(accountId).update("\0").update(roomId).update("\0").update(eventId).digest("hex");
+	if (row.key.slice(separator + 1) !== digest) return null;
+	return {
+		accountId,
+		roomId,
+		eventId,
+		ts
+	};
+}
+/** Reads one storage root's legacy SQLite dedupe rows; throws on store errors. */
+async function readLegacyInboundDedupeSqliteSource(io, storageRootDir) {
+	const rows = await openLegacySqliteStore(io, storageRootDir).entries();
+	const markerRows = await openLegacyMarkersStore(io, storageRootDir).entries();
+	const markers = [];
+	for (const row of rows) {
+		const marker = parseLegacySqliteRow(row);
+		if (marker) markers.push(marker);
+	}
+	return {
+		markers,
+		legacyRowCount: rows.length + markerRows.length
+	};
+}
+/** Clears one storage root's retired legacy dedupe namespaces after import. */
+async function retireLegacyInboundDedupeSqliteRows(io, storageRootDir) {
+	await openLegacySqliteStore(io, storageRootDir).clear();
+	await openLegacyMarkersStore(io, storageRootDir).clear();
+}
+async function resolveJsonRootAccountId(storageRootDir) {
+	for (const filename of [STORAGE_META_FILENAME, `${STORAGE_META_FILENAME}.migrated`]) try {
+		const metadata = normalizeMatrixStorageMetadata(JSON.parse(await fs.readFile(path.join(storageRootDir, filename), "utf8")));
+		if (metadata?.accountId) return metadata.accountId;
+	} catch {}
+	return "default";
+}
+/**
+* Reads one storage root's legacy inbound-dedupe.json markers. Throws on file
+* read errors so a transiently unreadable file is never retired unread, and
+* returns null for malformed content so the caller can archive it explicitly.
+*/
+async function readLegacyInboundDedupeJsonSource(storageRootDir) {
+	const jsonPath = path.join(storageRootDir, MATRIX_LEGACY_INBOUND_DEDUPE_FILENAME);
+	const raw = await fs.readFile(jsonPath, "utf8");
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		return null;
+	}
+	if (!isRecord(parsed) || parsed.version !== LEGACY_JSON_VERSION || !Array.isArray(parsed.entries)) return null;
+	const accountId = await resolveJsonRootAccountId(storageRootDir);
+	const markers = [];
+	for (const entry of parsed.entries) {
+		if (!isRecord(entry) || typeof entry.key !== "string") continue;
+		const separator = entry.key.indexOf("|");
+		if (separator <= 0) continue;
+		const roomId = entry.key.slice(0, separator).trim();
+		const eventId = entry.key.slice(separator + 1).trim();
+		const ts = normalizeLegacyTimestamp(entry.ts);
+		if (!roomId || !eventId || ts === null) continue;
+		markers.push({
+			accountId,
+			roomId,
+			eventId,
+			ts
+		});
+	}
+	return markers;
+}
+/**
+* Imports the globally newest legacy markers into the claimable-dedupe store.
+* Never exceeds capacity: eviction is by row creation time, so letting fresh
+* imports overflow the namespace would evict the newer rows the runtime
+* committed since the upgrade. Throws on store errors so the caller keeps the
+* legacy sources for the next doctor attempt.
+*/
+async function importNewestInboundDedupeMarkers(params) {
+	const now = params.now ?? Date.now();
+	const stateMaxEntries = params.stateMaxEntries ?? 2e4;
+	const newestByKey = /* @__PURE__ */ new Map();
+	for (const marker of params.markers) {
+		const key = buildMatrixInboundDedupeEventKey(marker);
+		if (!key) continue;
+		const existing = newestByKey.get(key);
+		if (!existing || marker.ts > existing.ts) newestByKey.set(key, {
+			...marker,
+			key
+		});
+	}
+	const markers = [...newestByKey.values()].toSorted((left, right) => right.ts - left.ts);
+	const store = params.io.context.openPluginStateKeyedStore({
+		namespace: resolveMatrixInboundDedupeStateNamespace(),
+		maxEntries: stateMaxEntries,
+		defaultTtlMs: MATRIX_INBOUND_DEDUPE_TTL_MS,
+		env: params.io.env
+	});
+	let capacity = Math.max(0, stateMaxEntries - (await store.entries()).length);
+	let imported = 0;
+	for (const marker of markers) {
+		if (capacity <= 0) break;
+		const remainingTtlMs = MATRIX_INBOUND_DEDUPE_TTL_MS - (now - marker.ts);
+		if (remainingTtlMs <= 0) continue;
+		const entry = createPersistentDedupeImportEntry({
+			key: marker.key,
+			seenAt: marker.ts,
+			ttlMs: Math.max(1, Math.floor(remainingTtlMs))
+		});
+		if (await store.registerIfAbsent(entry.key, entry.value, { ttlMs: entry.ttlMs ?? 2592e6 })) {
+			imported += 1;
+			capacity -= 1;
+		}
+	}
+	return {
+		imported,
+		total: markers.length
+	};
+}
+//#endregion
 //#region extensions/matrix/doctor-contract-api.ts
 const MATRIX_SYNC_CACHE_FILENAME = "bot-storage.json";
 const MATRIX_STORAGE_META_FILENAME = "storage-meta.json";
@@ -42,34 +232,107 @@ async function readLegacyMatrixStorageMetadata(storageRootDir) {
 	}
 }
 async function archiveLegacySyncCache(params) {
-	const sourcePath = path.join(params.storageRootDir, MATRIX_SYNC_CACHE_FILENAME);
-	const archivedPath = `${sourcePath}.migrated`;
-	if (await legacyStateFileExists(archivedPath)) {
-		params.warnings.push(`Left migrated Matrix sync cache in place because ${archivedPath} already exists`);
-		return;
-	}
-	try {
-		await fs.rename(sourcePath, archivedPath);
-		params.changes.push(`Archived Matrix sync cache legacy source -> ${archivedPath}`);
-	} catch (err) {
-		params.warnings.push(`Failed archiving Matrix sync cache legacy source: ${String(err)}`);
-	}
+	await archiveLegacyMatrixStateFile({
+		...params,
+		filename: MATRIX_SYNC_CACHE_FILENAME,
+		label: "Matrix sync cache"
+	});
 }
 async function archiveLegacyMatrixStateFile(params) {
-	const sourcePath = path.join(params.storageRootDir, params.filename);
-	const archivedPath = `${sourcePath}.migrated`;
-	if (await legacyStateFileExists(archivedPath)) {
-		params.warnings.push(`Left migrated ${params.label} in place because ${archivedPath} already exists`);
-		return;
-	}
-	try {
-		await fs.rename(sourcePath, archivedPath);
-		params.changes.push(`Archived ${params.label} legacy source -> ${archivedPath}`);
-	} catch (err) {
-		params.warnings.push(`Failed archiving ${params.label} legacy source: ${String(err)}`);
-	}
+	const warningCount = params.warnings.length;
+	await archiveLegacyStateSource({
+		filePath: path.join(params.storageRootDir, params.filename),
+		label: params.label,
+		changes: params.changes,
+		warnings: params.warnings
+	});
+	if (params.notice && params.warnings.length === warningCount) params.notices?.push(params.notice);
 }
 const stateMigrations = [
+	{
+		id: "matrix-inbound-dedupe-to-claimable-dedupe",
+		label: "Matrix inbound dedupe markers",
+		async detectLegacyState(params) {
+			const io = {
+				context: params.context,
+				env: params.env
+			};
+			const preview = [];
+			const sources = await collectMatrixInboundDedupeSources(params.stateDir);
+			for (const storageRootDir of sources.sqliteRoots) {
+				try {
+					if ((await readLegacyInboundDedupeSqliteSource(io, storageRootDir)).legacyRowCount === 0) continue;
+				} catch {
+					continue;
+				}
+				preview.push(`Matrix inbound dedupe rows can migrate to the claimable dedupe store: ${storageRootDir}`);
+			}
+			for (const storageRootDir of sources.jsonRoots) preview.push(`Matrix inbound dedupe JSON can migrate to the claimable dedupe store: ${path.join(storageRootDir, MATRIX_LEGACY_INBOUND_DEDUPE_FILENAME)}`);
+			return preview.length > 0 ? { preview } : null;
+		},
+		async migrateLegacyState(params) {
+			const io = {
+				context: params.context,
+				env: params.env
+			};
+			const changes = [];
+			const warnings = [];
+			const sources = await collectMatrixInboundDedupeSources(params.stateDir);
+			const gathered = [];
+			const sqliteRootsToRetire = [];
+			for (const storageRootDir of sources.sqliteRoots) try {
+				const source = await readLegacyInboundDedupeSqliteSource(io, storageRootDir);
+				if (source.legacyRowCount === 0) continue;
+				gathered.push(...source.markers);
+				sqliteRootsToRetire.push(storageRootDir);
+			} catch (err) {
+				warnings.push(`Failed reading Matrix inbound dedupe rows for ${storageRootDir}: ${String(err)}; left legacy rows in place`);
+			}
+			const jsonRootsToRetire = [];
+			for (const storageRootDir of sources.jsonRoots) try {
+				const markers = await readLegacyInboundDedupeJsonSource(storageRootDir);
+				if (markers === null) warnings.push(`Matrix inbound dedupe JSON for ${storageRootDir} is malformed; archived without import`);
+				else gathered.push(...markers);
+				jsonRootsToRetire.push(storageRootDir);
+			} catch (err) {
+				warnings.push(`Failed reading Matrix inbound dedupe JSON for ${storageRootDir}: ${String(err)}; left legacy file in place`);
+			}
+			if (sqliteRootsToRetire.length + jsonRootsToRetire.length === 0) return {
+				changes,
+				warnings
+			};
+			try {
+				const result = await importNewestInboundDedupeMarkers({
+					io,
+					markers: gathered
+				});
+				changes.push(`Migrated Matrix inbound dedupe markers to the claimable dedupe store (${result.imported} of ${result.total} entries)`);
+			} catch (err) {
+				warnings.push(`Failed importing Matrix inbound dedupe markers: ${String(err)}; left legacy sources in place`);
+				return {
+					changes,
+					warnings
+				};
+			}
+			for (const storageRootDir of sqliteRootsToRetire) try {
+				await retireLegacyInboundDedupeSqliteRows(io, storageRootDir);
+				changes.push(`Retired Matrix inbound dedupe rows for ${storageRootDir}`);
+			} catch (err) {
+				warnings.push(`Failed retiring Matrix inbound dedupe rows for ${storageRootDir}: ${String(err)}`);
+			}
+			for (const storageRootDir of jsonRootsToRetire) await archiveLegacyMatrixStateFile({
+				storageRootDir,
+				filename: MATRIX_LEGACY_INBOUND_DEDUPE_FILENAME,
+				label: "Matrix inbound dedupe",
+				changes,
+				warnings
+			});
+			return {
+				changes,
+				warnings
+			};
+		}
+	},
 	{
 		id: "matrix-storage-meta-json-to-plugin-state",
 		label: "Matrix storage metadata",
@@ -84,18 +347,20 @@ const stateMigrations = [
 		async migrateLegacyState(params) {
 			const changes = [];
 			const warnings = [];
+			const notices = [];
 			for (const storageRootDir of await collectLegacyMatrixStateRoots(params.stateDir, MATRIX_STORAGE_META_FILENAME)) {
 				const payload = await readLegacyMatrixStorageMetadata(storageRootDir);
 				if (!payload) continue;
 				const store = params.context.openPluginStateKeyedStore(openMatrixStorageMetaStoreOptions(storageRootDir));
 				if (await hasMatrixStorageMetaStateInStore({ store })) {
-					warnings.push(`Skipped Matrix storage metadata import for ${storageRootDir} because SQLite already has metadata`);
 					await archiveLegacyMatrixStateFile({
 						storageRootDir,
 						filename: MATRIX_STORAGE_META_FILENAME,
 						label: "Matrix storage metadata",
 						changes,
-						warnings
+						warnings,
+						notices,
+						notice: `Kept existing Matrix storage metadata in SQLite and archived the legacy source for ${storageRootDir}`
 					});
 					continue;
 				}
@@ -114,7 +379,8 @@ const stateMigrations = [
 			}
 			return {
 				changes,
-				warnings
+				warnings,
+				...notices.length > 0 ? { notices } : {}
 			};
 		}
 	},
@@ -132,6 +398,7 @@ const stateMigrations = [
 		async migrateLegacyState(params) {
 			const changes = [];
 			const warnings = [];
+			const notices = [];
 			for (const storageRootDir of await collectLegacySyncCacheRoots(params.stateDir)) {
 				const persisted = await readLegacyMatrixSyncCacheState(storageRootDir);
 				if (!persisted) continue;
@@ -140,11 +407,12 @@ const stateMigrations = [
 					storageRootDir,
 					store
 				})) {
-					warnings.push(`Skipped Matrix sync cache import for ${storageRootDir} because SQLite already has sync cache state`);
 					await archiveLegacySyncCache({
 						storageRootDir,
 						changes,
-						warnings
+						warnings,
+						notices,
+						notice: `Kept existing Matrix sync cache in SQLite and archived the legacy source for ${storageRootDir}`
 					});
 					continue;
 				}
@@ -162,7 +430,8 @@ const stateMigrations = [
 			}
 			return {
 				changes,
-				warnings
+				warnings,
+				...notices.length > 0 ? { notices } : {}
 			};
 		}
 	},
@@ -180,18 +449,20 @@ const stateMigrations = [
 		async migrateLegacyState(params) {
 			const changes = [];
 			const warnings = [];
+			const notices = [];
 			for (const storageRootDir of await collectLegacyMatrixStateRoots(params.stateDir, MATRIX_RECOVERY_KEY_FILENAME)) {
 				const payload = readLegacyMatrixRecoveryKeyState(storageRootDir);
 				if (!payload) continue;
 				const store = params.context.openPluginStateKeyedStore(openMatrixRecoveryKeyStoreOptions(storageRootDir));
 				if (await hasMatrixRecoveryKeyStateInStore({ store })) {
-					warnings.push(`Skipped Matrix recovery-key import for ${storageRootDir} because SQLite already has recovery-key state`);
 					await archiveLegacyMatrixStateFile({
 						storageRootDir,
 						filename: MATRIX_RECOVERY_KEY_FILENAME,
 						label: "Matrix recovery key",
 						changes,
-						warnings
+						warnings,
+						notices,
+						notice: `Kept existing Matrix recovery key in SQLite and archived the legacy source for ${storageRootDir}`
 					});
 					continue;
 				}
@@ -210,7 +481,8 @@ const stateMigrations = [
 			}
 			return {
 				changes,
-				warnings
+				warnings,
+				...notices.length > 0 ? { notices } : {}
 			};
 		}
 	},
@@ -228,18 +500,20 @@ const stateMigrations = [
 		async migrateLegacyState(params) {
 			const changes = [];
 			const warnings = [];
+			const notices = [];
 			for (const storageRootDir of await collectLegacyMatrixStateRoots(params.stateDir, MATRIX_IDB_SNAPSHOT_FILENAME)) {
 				const snapshot = await readLegacyMatrixIdbSnapshotState(storageRootDir);
 				if (!snapshot) continue;
 				const store = params.context.openPluginStateKeyedStore(openMatrixIdbSnapshotStoreOptions(storageRootDir));
 				if (await hasMatrixIdbSnapshotStateInStore({ store })) {
-					warnings.push(`Skipped Matrix IndexedDB snapshot import for ${storageRootDir} because SQLite already has snapshot state`);
 					await archiveLegacyMatrixStateFile({
 						storageRootDir,
 						filename: MATRIX_IDB_SNAPSHOT_FILENAME,
 						label: "Matrix IndexedDB snapshot",
 						changes,
-						warnings
+						warnings,
+						notices,
+						notice: `Kept existing Matrix IndexedDB snapshot in SQLite and archived the legacy source for ${storageRootDir}`
 					});
 					continue;
 				}
@@ -259,7 +533,8 @@ const stateMigrations = [
 			}
 			return {
 				changes,
-				warnings
+				warnings,
+				...notices.length > 0 ? { notices } : {}
 			};
 		}
 	},
@@ -277,18 +552,20 @@ const stateMigrations = [
 		async migrateLegacyState(params) {
 			const changes = [];
 			const warnings = [];
+			const notices = [];
 			for (const storageRootDir of await collectLegacyMatrixStateRoots(params.stateDir, MATRIX_LEGACY_CRYPTO_MIGRATION_FILENAME)) {
 				const state = readLegacyMatrixLegacyCryptoMigrationState(storageRootDir);
 				if (!state) continue;
 				const store = params.context.openPluginStateKeyedStore(openMatrixLegacyCryptoMigrationStoreOptions(storageRootDir));
 				if (await hasMatrixLegacyCryptoMigrationStateInStore({ store })) {
-					warnings.push(`Skipped Matrix legacy crypto migration import for ${storageRootDir} because SQLite already has migration state`);
 					await archiveLegacyMatrixStateFile({
 						storageRootDir,
 						filename: MATRIX_LEGACY_CRYPTO_MIGRATION_FILENAME,
 						label: "Matrix legacy crypto migration",
 						changes,
-						warnings
+						warnings,
+						notices,
+						notice: `Kept existing Matrix legacy crypto migration in SQLite and archived the legacy source for ${storageRootDir}`
 					});
 					continue;
 				}
@@ -307,7 +584,8 @@ const stateMigrations = [
 			}
 			return {
 				changes,
-				warnings
+				warnings,
+				...notices.length > 0 ? { notices } : {}
 			};
 		}
 	}

package/dist/{draft-stream-D4EH25gv.js → draft-stream-De7uikGn.js}

@@ -1,4 +1,4 @@
-import { n as editMessageMatrix, r as prepareMatrixSingleText, s as sendSingleTextMessageMatrix, y as MsgType } from "./send-D92v6Yy0.js";
+import { n as editMessageMatrix, r as prepareMatrixSingleText, s as sendSingleTextMessageMatrix, y as MsgType } from "./send-C7xuGWpv.js";
 import { createDraftStreamLoop } from "openclaw/plugin-sdk/channel-outbound";
 //#region extensions/matrix/src/matrix/draft-stream.ts
 const DEFAULT_THROTTLE_MS = 1e3;

package/dist/{encryption-guidance-D8walY04.js → encryption-guidance-BFfgq7c7.js}

@@ -1,4 +1,4 @@
-import { a as resolveMatrixDefaultOrOnlyAccountId } from "./account-selection-5e4mHR1m.js";
+import { a as resolveMatrixDefaultOrOnlyAccountId } from "./account-selection-Bz00QTmQ.js";
 import { t as resolveMatrixConfigFieldPath } from "./config-paths-CnREYb1Y.js";
 import { normalizeOptionalAccountId } from "openclaw/plugin-sdk/account-id";
 //#region extensions/matrix/src/matrix/encryption-guidance.ts

package/dist/{env-auth-DIzOApj0.js → env-auth-CQsYbz-p.js}

@@ -1,4 +1,4 @@
-import { t as getMatrixScopedEnvVarNames } from "./env-vars-KzaYveuy.js";
+import { t as getMatrixScopedEnvVarNames } from "./env-vars-B0NxQnPk.js";
 import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "openclaw/plugin-sdk/account-id";
 //#region extensions/matrix/src/matrix/client/env-auth.ts
 function cleanEnv(value) {

package/dist/{env-vars-KzaYveuy.js → env-vars-B0NxQnPk.js}

@@ -54,7 +54,9 @@ function listMatrixEnvAccountIds(env = process.env) {
 	for (const key of Object.keys(env)) {
 		const match = MATRIX_SCOPED_ENV_RE.exec(key);
 		if (!match) continue;
-		const accountId = decodeMatrixEnvAccountToken(match[1]);
+		const encodedAccountId = match[1];
+		if (!encodedAccountId) continue;
+		const accountId = decodeMatrixEnvAccountToken(encodedAccountId);
 		if (accountId) ids.add(accountId);
 	}
 	return Array.from(ids).toSorted((a, b) => a.localeCompare(b));

package/dist/{exec-approval-resolver-f9j6staN.js → exec-approval-resolver-BCgqRtZS.js}

@@ -2,9 +2,10 @@ import { isApprovalNotFoundError } from "openclaw/plugin-sdk/error-runtime";
 import { resolveApprovalOverGateway } from "openclaw/plugin-sdk/approval-gateway-runtime";
 //#region extensions/matrix/src/exec-approval-resolver.ts
 async function resolveMatrixApproval(params) {
-	await resolveApprovalOverGateway({
+	return await resolveApprovalOverGateway({
 		cfg: params.cfg,
 		approvalId: params.approvalId,
+		approvalKind: params.approvalKind,
 		decision: params.decision,
 		senderId: params.senderId,
 		gatewayUrl: params.gatewayUrl,

package/dist/{file-sync-store-DVm0ACml.js → file-sync-store-Cxb0ckyX.js}

@@ -1,10 +1,9 @@
 import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { o as isRecord } from "./account-selection-5e4mHR1m.js";
-import { t as getMatrixRuntime } from "./runtime-6S3DNFNv.js";
-import { O as resolveMatrixSqliteStateEnv } from "./crypto-state-store-Jy3qwhdy.js";
-import { t as claimCurrentTokenStorageState } from "./storage-CQdyKcGg.js";
+import { t as isRecord } from "./record-shared-CvzjvHRn.js";
+import { t as getMatrixRuntime } from "./runtime-CveSqMOP.js";
+import { M as resolveMatrixSqliteStateEnv, t as claimCurrentTokenStorageState } from "./storage-BtSOar8T.js";
 import { t as createAsyncLock } from "./async-lock-BcLS4KOc.js";
-import { n as LogService } from "./logger-D0GCSDQq.js";
+import { n as LogService } from "./logger-BMClpI5b.js";
 import path from "node:path";
 import { createHash, randomUUID } from "node:crypto";
 import fs from "node:fs/promises";