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

package/dist/{config-schema-DtnhNYd-.js → config-schema-CG9goLWp.js}

@@ -1,12 +1,12 @@
 import { a as resolveMatrixAccountConfig } from "./account-config-BZWN9tGS.js";
-import { g as resolveMatrixAccount, h as resolveDefaultMatrixAccountId, p as listMatrixAccountIds } from "./setup-core-BGgbrdaJ.js";
+import { g as resolveMatrixAccount, h as resolveDefaultMatrixAccountId, p as listMatrixAccountIds } from "./setup-core-DlmTyIP0.js";
 import { adaptScopedAccountAccessor, createScopedChannelConfigAdapter } from "openclaw/plugin-sdk/channel-config-helpers";
+import { createChannelConfigUiHints } from "openclaw/plugin-sdk/channel-core";
 import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { DEFAULT_ACCOUNT_ID as DEFAULT_ACCOUNT_ID$1 } from "openclaw/plugin-sdk/account-id";
 import { resolveAllowlistMatchByCandidates } from "openclaw/plugin-sdk/allow-from";
 import { normalizeStringEntries as normalizeStringEntries$1 } from "openclaw/plugin-sdk/string-normalization-runtime";
-import { buildChannelConfigSchema } from "openclaw/plugin-sdk/channel-config-primitives";
-import { AllowFromListSchema, ContextVisibilityModeSchema, GroupPolicySchema, MarkdownConfigSchema, MentionPatternsPolicySchema, ToolPolicySchema, buildNestedDmConfigSchema } from "openclaw/plugin-sdk/channel-config-schema";
+import { AllowFromListSchema, BlockStreamingCoalesceSchema, ContextVisibilityModeSchema, GroupPolicySchema, MarkdownConfigSchema, MentionPatternsPolicySchema, ToolPolicySchema, buildChannelConfigSchema, buildNestedDmConfigSchema } from "openclaw/plugin-sdk/channel-config-schema";
 import { buildSecretInputSchema } from "openclaw/plugin-sdk/secret-input";
 import { z } from "zod";
 //#region extensions/matrix/src/matrix/monitor/allowlist.ts
@@ -102,22 +102,14 @@ const matrixConfigAdapter = createScopedChannelConfigAdapter({
 //#endregion
 //#region extensions/matrix/src/config-ui-hints.ts
 const matrixChannelConfigUiHints = {
-	mentionPatterns: {
-		label: "Matrix Mention Pattern Policy",
-		help: "Scopes configured groupChat mentionPatterns to selected Matrix room IDs. Native Matrix mention evidence still triggers even when regex patterns are denied."
-	},
-	"mentionPatterns.mode": {
-		label: "Matrix Mention Pattern Mode",
-		help: "\"allow\" enables configured regex mention patterns unless denyIn matches; \"deny\" disables them unless allowIn matches."
-	},
-	"mentionPatterns.allowIn": {
-		label: "Matrix Mention Pattern Allowlist",
-		help: "Matrix room IDs where configured regex mention patterns are enabled when mode is deny."
-	},
-	"mentionPatterns.denyIn": {
-		label: "Matrix Mention Pattern Denylist",
-		help: "Matrix room IDs where configured regex mention patterns are disabled. Native mention evidence still triggers."
-	},
+	...createChannelConfigUiHints({
+		channelLabel: "Matrix",
+		mentionPatterns: {
+			targetDescription: "Matrix room IDs",
+			policyNote: "Native Matrix mention evidence still triggers even when regex patterns are denied.",
+			denyNote: "Native mention evidence still triggers."
+		}
+	}),
 	allowBots: {
 		label: "Matrix Allow Bot Messages",
 		help: "Allow messages from other configured Matrix bot accounts to trigger replies (default: false). Set \"mentions\" to require a visible room mention."
@@ -146,30 +138,10 @@ const matrixChannelConfigUiHints = {
 		label: "Matrix Display Name Matching",
 		help: "Compatibility opt-in for resolving Matrix display names and joined room names in allowlists. Prefer full @user:server IDs and room IDs or aliases because names are mutable."
 	},
-	"streaming.progress.label": {
-		label: "Matrix Progress Label",
-		help: "Initial progress draft title. Use \"auto\" for built-in single-word labels, a custom string, or false to hide the title."
-	},
-	"streaming.progress.labels": {
-		label: "Matrix Progress Label Pool",
-		help: "Candidate labels for streaming.progress.label=\"auto\". Leave unset to use OpenClaw built-in progress labels."
-	},
-	"streaming.progress.maxLines": {
-		label: "Matrix Progress Max Lines",
-		help: "Maximum number of compact progress lines to keep below the draft label (default: 8)."
-	},
-	"streaming.progress.maxLineChars": {
-		label: "Matrix Progress Max Line Chars",
-		help: "Maximum characters per compact progress line before truncation (default: 120). Prose cuts at word boundaries; commands and paths keep useful suffixes."
-	},
-	"streaming.progress.toolProgress": {
-		label: "Matrix Progress Tool Lines",
-		help: "Show compact tool/progress lines in progress draft mode (default: true). Set false to keep only the label until final delivery."
-	},
-	"streaming.progress.commandText": {
-		label: "Matrix Progress Command Text",
-		help: "Command/exec detail in progress draft lines: \"raw\" preserves released behavior; \"status\" shows only the tool label."
-	}
+	...createChannelConfigUiHints({
+		channelLabel: "Matrix",
+		progress: {}
+	})
 };
 //#endregion
 //#region extensions/matrix/src/config-schema.ts
@@ -228,6 +200,11 @@ const matrixStreamingSchema = z.object({
 		"progress",
 		"off"
 	]).optional(),
+	chunkMode: z.enum(["length", "newline"]).optional(),
+	block: z.object({
+		enabled: z.boolean().optional(),
+		coalesce: BlockStreamingCoalesceSchema.optional()
+	}).strict().optional(),
 	progress: z.object({
 		label: z.union([z.string(), z.literal(false)]).optional(),
 		labels: z.array(z.string()).optional(),
@@ -261,17 +238,7 @@ const MatrixChannelConfigSchema = buildChannelConfigSchema(z.object({
 	groupPolicy: GroupPolicySchema.optional(),
 	mentionPatterns: MentionPatternsPolicySchema.optional(),
 	contextVisibility: ContextVisibilityModeSchema.optional(),
-	blockStreaming: z.boolean().optional(),
-	streaming: z.union([
-		z.enum([
-			"partial",
-			"quiet",
-			"progress",
-			"off"
-		]),
-		z.boolean(),
-		matrixStreamingSchema
-	]).optional(),
+	streaming: matrixStreamingSchema.optional(),
 	replyToMode: z.enum([
 		"off",
 		"first",
@@ -284,7 +251,6 @@ const MatrixChannelConfigSchema = buildChannelConfigSchema(z.object({
 		"always"
 	]).optional(),
 	textChunkLimit: z.number().optional(),
-	chunkMode: z.enum(["length", "newline"]).optional(),
 	responsePrefix: z.string().optional(),
 	ackReaction: z.string().optional(),
 	ackReactionScope: z.enum([

package/dist/contract-api.js

@@ -1,3 +1,3 @@
-import { d as resolveSingleAccountPromotionTarget, f as singleAccountKeysToMove, n as matrixSetupAdapter, u as namedAccountPromotionKeys } from "./setup-core-BGgbrdaJ.js";
-import { n as matrixOnboardingAdapter } from "./setup-surface-iJ6pd-t5.js";
+import { d as resolveSingleAccountPromotionTarget, f as singleAccountKeysToMove, n as matrixSetupAdapter, u as namedAccountPromotionKeys } from "./setup-core-DlmTyIP0.js";
+import { n as matrixOnboardingAdapter } from "./setup-surface-2SS94JV0.js";
 export { matrixSetupAdapter, matrixOnboardingAdapter as matrixSetupWizard, namedAccountPromotionKeys, resolveSingleAccountPromotionTarget, singleAccountKeysToMove };

package/dist/{create-client-CNakT7zF.js → create-client-D9z9RjCM.js}

@@ -1,14 +1,14 @@
 import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
 import { t as resolveValidatedMatrixHomeserverUrl } from "./url-validation-GRHde6lq.js";
-import { d as writeStorageMeta, l as resolveMatrixStoragePaths, r as maybeMigrateLegacyStorage } from "./storage-CQdyKcGg.js";
-import "./shared-DkFfq7mH.js";
+import { d as writeStorageMeta, l as resolveMatrixStoragePaths, r as maybeMigrateLegacyStorage } from "./storage-BtSOar8T.js";
+import "./shared-DgvN5rBx.js";
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import fs from "node:fs";
 import { ssrfPolicyFromDangerouslyAllowPrivateNetwork } from "openclaw/plugin-sdk/ssrf-runtime";
 //#region extensions/matrix/src/matrix/client/create-client.ts
 var create_client_exports = /* @__PURE__ */ __exportAll({ createMatrixClient: () => createMatrixClient });
-const loadMatrixCreateClientRuntimeDeps = createLazyRuntimeModule(() => Promise.all([import("./sdk-AZYVl34z.js"), import("./logging-QH-48Gr6.js")]).then(([sdkModule, loggingModule]) => ({
+const loadMatrixCreateClientRuntimeDeps = createLazyRuntimeModule(() => Promise.all([import("./sdk-CI8E2TKg.js"), import("./logging-CFJrbDAN.js")]).then(([sdkModule, loggingModule]) => ({
 	MatrixClient: sdkModule.MatrixClient,
 	ensureMatrixSdkLoggingConfigured: loggingModule.ensureMatrixSdkLoggingConfigured
 })));

package/dist/{credentials-Ds9V1mn2.js → credentials-DnhsLAuR.js}

@@ -1,4 +1,4 @@
-import { a as resolveMatrixCredentialsDir, i as loadMatrixCredentials, n as credentialsMatchConfig, o as resolveMatrixCredentialsPath, t as clearMatrixCredentials } from "./credentials-read-BlkvsNFg.js";
+import { a as resolveMatrixCredentialsDir, i as loadMatrixCredentials, n as credentialsMatchConfig, o as resolveMatrixCredentialsPath, t as clearMatrixCredentials } from "./credentials-read-BtS-HRT5.js";
 import { t as createAsyncLock } from "./async-lock-BcLS4KOc.js";
 import { writeJsonFileAtomically } from "openclaw/plugin-sdk/json-store";
 //#region extensions/matrix/src/matrix/credentials.ts

package/dist/{credentials-read-BlkvsNFg.js → credentials-read-BtS-HRT5.js}

@@ -1,7 +1,7 @@
 import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { a as resolveMatrixDefaultOrOnlyAccountId, n as requiresExplicitMatrixDefaultAccount } from "./account-selection-5e4mHR1m.js";
-import { t as getMatrixRuntime } from "./runtime-6S3DNFNv.js";
-import { a as resolveMatrixCredentialsPath$1, r as resolveMatrixCredentialsDir$1 } from "./storage-paths-BWo_ZEMC.js";
+import { a as resolveMatrixDefaultOrOnlyAccountId, n as requiresExplicitMatrixDefaultAccount } from "./account-selection-Bz00QTmQ.js";
+import { t as getMatrixRuntime } from "./runtime-CveSqMOP.js";
+import { a as resolveMatrixCredentialsPath$1, r as resolveMatrixCredentialsDir$1 } from "./storage-paths-B4_I9iqO.js";
 import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "openclaw/plugin-sdk/account-id";
 import fs from "node:fs";
 import os from "node:os";

package/dist/{credentials-write.runtime-CTqqxcut.js → credentials-write.runtime-J_EUt5WP.js}

@@ -1,6 +1,6 @@
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 //#region extensions/matrix/src/matrix/credentials-write.runtime.ts
-const loadMatrixCredentialsRuntime = createLazyRuntimeModule(() => import("./credentials-Ds9V1mn2.js"));
+const loadMatrixCredentialsRuntime = createLazyRuntimeModule(() => import("./credentials-DnhsLAuR.js"));
 async function saveMatrixCredentials(...args) {
 	return (await loadMatrixCredentialsRuntime()).saveMatrixCredentials(...args);
 }

package/dist/{crypto-runtime-B74cTS6A.js → crypto-runtime-BHcxauC4.js}

@@ -1,54 +1,47 @@
 import { t as formatMatrixErrorMessage } from "./errors-C47hvAF8.js";
-import { t as ensureMatrixCryptoRuntime } from "./deps-CdjHvnmh.js";
-import { n as LogService, r as noop } from "./logger-D0GCSDQq.js";
-import { i as restoreIdbFromDisk, n as persistIdbToDisk } from "./idb-persistence-BHm97th-.js";
-import { n as isRepairableSecretStorageAccessError } from "./recovery-key-store-DSeLFvNx.js";
+import { t as ensureMatrixCryptoRuntime } from "./deps-DDbghaZH.js";
+import { n as LogService, r as noop } from "./logger-BMClpI5b.js";
+import { i as restoreIdbFromDisk, n as persistIdbToDisk } from "./idb-persistence-iUZoHZkp.js";
+import { n as isRepairableSecretStorageAccessError } from "./recovery-key-store-Bx0zTJcB.js";
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 import { resolveDateTimestampMs, resolveTimestampMsToIsoString } from "openclaw/plugin-sdk/number-runtime";
 import { MatrixEventEvent } from "matrix-js-sdk/lib/matrix.js";
+import { IDBDatabase } from "fake-indexeddb";
 import { setTimeout as setTimeout$1 } from "node:timers/promises";
 import { VerificationMethod } from "matrix-js-sdk/lib/types.js";
 import "fake-indexeddb/auto";
 import { CryptoEvent } from "matrix-js-sdk/lib/crypto-api/CryptoEvent.js";
 import { DecryptionFailureCode } from "matrix-js-sdk/lib/crypto-api/index.js";
 import { VerificationPhase, VerificationRequestEvent, VerifierEvent } from "matrix-js-sdk/lib/crypto-api/verification.js";
+import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";
 //#region extensions/matrix/src/matrix/sdk/fake-indexeddb-prune.ts
 const MATRIX_CRYPTO_DATABASE_SUFFIXES = ["::matrix-sdk-crypto", "::matrix-sdk-crypto-meta"];
 const PRUNER_INSTALLED = Symbol.for("openclaw.matrix.fakeIndexedDbTransactionPruner");
-function getRawDatabase(value) {
-	if (!value || typeof value !== "object") return;
-	const rawDatabase = value["_rawDatabase"];
-	if (!rawDatabase || typeof rawDatabase !== "object") return;
-	return rawDatabase;
-}
 function isMatrixCryptoDatabase(rawDatabase) {
-	if (!rawDatabase || !Array.isArray(rawDatabase.transactions)) return false;
-	const databaseName = rawDatabase.name;
-	return typeof databaseName === "string" && MATRIX_CRYPTO_DATABASE_SUFFIXES.some((suffix) => databaseName.endsWith(suffix));
+	return MATRIX_CRYPTO_DATABASE_SUFFIXES.some((suffix) => rawDatabase.name.endsWith(suffix));
 }
 function pruneFinishedFakeIndexedDbTransactions(rawDatabase) {
-	const matrixRawDatabase = rawDatabase;
-	if (!isMatrixCryptoDatabase(matrixRawDatabase)) return 0;
-	const transactions = matrixRawDatabase.transactions;
-	const activeTransactions = transactions.filter((transaction) => transaction?.["_state"] !== "finished");
+	if (!isMatrixCryptoDatabase(rawDatabase)) return 0;
+	const transactions = rawDatabase.transactions;
+	const activeTransactions = transactions.filter((transaction) => transaction["_state"] !== "finished");
 	const removed = transactions.length - activeTransactions.length;
 	if (removed > 0) transactions.splice(0, transactions.length, ...activeTransactions);
 	return removed;
 }
 function installFakeIndexedDbTransactionPruner() {
-	const databasePrototype = globalThis.IDBDatabase?.prototype;
-	const originalTransaction = databasePrototype?.transaction;
-	if (!databasePrototype || typeof originalTransaction !== "function" || databasePrototype[PRUNER_INSTALLED]) return;
+	const databasePrototype = IDBDatabase.prototype;
+	if (databasePrototype[PRUNER_INSTALLED]) return;
 	Object.defineProperty(databasePrototype, PRUNER_INSTALLED, {
 		configurable: false,
 		enumerable: false,
 		value: true
 	});
+	const originalTransaction = Object.getOwnPropertyDescriptor(databasePrototype, "transaction")?.value;
 	databasePrototype.transaction = function patchedMatrixFakeIndexedDbTransaction(...args) {
-		pruneFinishedFakeIndexedDbTransactions(getRawDatabase(this));
+		const rawDatabase = this["_rawDatabase"];
+		pruneFinishedFakeIndexedDbTransactions(rawDatabase);
 		const transaction = originalTransaction.apply(this, args);
-		const rawDatabase = getRawDatabase(transaction?.db) ?? getRawDatabase(this);
-		if (isMatrixCryptoDatabase(rawDatabase) && typeof transaction?.addEventListener === "function") {
+		if (isMatrixCryptoDatabase(rawDatabase)) {
 			const prune = () => {
 				pruneFinishedFakeIndexedDbTransactions(rawDatabase);
 			};
@@ -464,21 +457,15 @@ function createMatrixCryptoFacade(deps) {
 const MATRIX_DECRYPT_RETRY_BASE_DELAY_MS = 1500;
 const MATRIX_DECRYPT_RETRY_MAX_DELAY_MS = 3e4;
 const MATRIX_DECRYPT_RETRY_MAX_ATTEMPTS = 8;
+const MATRIX_DECRYPT_EXHAUSTED_RETRY_TTL_MS = 60 * 6e4;
+const MATRIX_DECRYPT_EXHAUSTED_RETRY_MAX_ENTRIES = 512;
 function resolveDecryptRetryKey(roomId, eventId) {
 	if (!roomId || !eventId) return null;
 	return `${roomId}|${eventId}`;
 }
-function isDecryptionFailure(event) {
-	return typeof event.isDecryptionFailure === "function" && event.isDecryptionFailure();
-}
-function getDecryptionFailureReason(event) {
-	const reason = event.decryptionFailureReason;
-	return typeof reason === "string" && reason in DecryptionFailureCode ? reason : null;
-}
 function shouldRetryDecryptionFailure(event) {
-	if (!isDecryptionFailure(event)) return false;
-	const reason = getDecryptionFailureReason(event);
-	if (!reason) return true;
+	if (!event.isDecryptionFailure()) return false;
+	const reason = event.decryptionFailureReason;
 	return reason === DecryptionFailureCode.MEGOLM_UNKNOWN_INBOUND_SESSION_ID || reason === DecryptionFailureCode.OLM_UNKNOWN_MESSAGE_INDEX || reason === DecryptionFailureCode.UNKNOWN_ERROR;
 }
 var MatrixDecryptBridge = class {
@@ -488,10 +475,11 @@ var MatrixDecryptBridge = class {
 		this.decryptedMessageDedupe = /* @__PURE__ */ new Map();
 		this.decryptRetries = /* @__PURE__ */ new Map();
 		this.failedDecryptionsNotified = /* @__PURE__ */ new Set();
-		this.exhaustedDecryptRetries = /* @__PURE__ */ new Set();
+		this.exhaustedDecryptRetries = /* @__PURE__ */ new Map();
 		this.activeRetryRuns = 0;
 		this.retryIdleResolvers = /* @__PURE__ */ new Set();
 		this.cryptoRetrySignalsBound = false;
+		this.stopped = false;
 	}
 	shouldEmitUnencryptedMessage(roomId, eventId) {
 		if (!eventId) return true;
@@ -501,6 +489,7 @@ var MatrixDecryptBridge = class {
 		return false;
 	}
 	attachEncryptedEvent(event, roomId) {
+		if (this.stopped) return;
 		if (this.trackedEncryptedEvents.has(event)) return;
 		this.trackedEncryptedEvents.add(event);
 		event.on(MatrixEventEvent.Decrypted, (decryptedEvent, err) => {
@@ -520,7 +509,21 @@ var MatrixDecryptBridge = class {
 			});
 		}
 	}
-	retryPendingNow(reason) {
+	retryPendingNow(reason, options) {
+		if (this.stopped) return;
+		if (options?.includeExhausted) {
+			this.pruneExhaustedDecryptRetries(Date.now());
+			for (const [retryKey, state] of this.exhaustedDecryptRetries) {
+				if (this.decryptRetries.has(retryKey)) continue;
+				this.exhaustedDecryptRetries.delete(retryKey);
+				this.decryptRetries.set(retryKey, {
+					...state,
+					attempts: 0,
+					inFlight: false,
+					timer: null
+				});
+			}
+		}
 		const pending = Array.from(this.decryptRetries.entries());
 		if (pending.length === 0) return;
 		LogService.debug("MatrixClientLite", `Retrying pending decryptions due to ${reason}`);
@@ -536,14 +539,14 @@ var MatrixDecryptBridge = class {
 	bindCryptoRetrySignals(crypto) {
 		if (!crypto || this.cryptoRetrySignalsBound) return;
 		this.cryptoRetrySignalsBound = true;
-		const trigger = (reason) => {
-			this.retryPendingNow(reason);
+		const trigger = (reason, options) => {
+			this.retryPendingNow(reason, options);
 		};
 		crypto.on(CryptoEvent.KeyBackupDecryptionKeyCached, () => {
-			trigger("crypto.keyBackupDecryptionKeyCached");
+			trigger("crypto.keyBackupDecryptionKeyCached", { includeExhausted: true });
 		});
 		crypto.on(CryptoEvent.RehydrationCompleted, () => {
-			trigger("dehydration.RehydrationCompleted");
+			trigger("dehydration.RehydrationCompleted", { includeExhausted: true });
 		});
 		crypto.on(CryptoEvent.DevicesUpdated, () => {
 			trigger("crypto.devicesUpdated");
@@ -553,7 +556,9 @@ var MatrixDecryptBridge = class {
 		});
 	}
 	stop() {
+		this.stopped = true;
 		for (const retryKey of this.decryptRetries.keys()) this.clearDecryptRetry(retryKey);
+		this.exhaustedDecryptRetries.clear();
 	}
 	async drainPendingDecryptions(reason) {
 		for (let attempts = 0; attempts < MATRIX_DECRYPT_RETRY_MAX_ATTEMPTS; attempts += 1) {
@@ -564,6 +569,7 @@ var MatrixDecryptBridge = class {
 		}
 	}
 	handleEncryptedEventDecrypted(params) {
+		if (this.stopped) return;
 		const decryptedRoomId = params.decryptedEvent.getRoomId() || params.roomId;
 		const decryptedRaw = this.deps.toRaw(params.decryptedEvent);
 		const retryEventId = decryptedRaw.event_id || params.encryptedEvent.getId() || "";
@@ -578,7 +584,7 @@ var MatrixDecryptBridge = class {
 			else if (retryKey) this.clearDecryptRetry(retryKey);
 			return;
 		}
-		if (isDecryptionFailure(params.decryptedEvent)) {
+		if (params.decryptedEvent.isDecryptionFailure()) {
 			this.emitFailedDecryptionOnce(retryKey, decryptedRoomId, decryptedRaw, /* @__PURE__ */ new Error("Matrix event failed to decrypt"));
 			if (shouldRetryDecryptionFailure(params.decryptedEvent)) this.scheduleDecryptRetry({
 				event: params.encryptedEvent,
@@ -601,6 +607,7 @@ var MatrixDecryptBridge = class {
 		this.deps.emitFailedDecryption(roomId, event, error);
 	}
 	scheduleDecryptRetry(params) {
+		if (this.stopped) return;
 		const retryKey = resolveDecryptRetryKey(params.roomId, params.eventId);
 		if (!retryKey) return;
 		const existing = this.decryptRetries.get(retryKey);
@@ -611,7 +618,17 @@ var MatrixDecryptBridge = class {
 			const retry = this.decryptRetries.get(retryKey);
 			if (retry?.timer) clearTimeout(retry.timer);
 			this.decryptRetries.delete(retryKey);
-			this.exhaustedDecryptRetries.add(retryKey);
+			const exhaustedAt = Date.now();
+			this.exhaustedDecryptRetries.set(retryKey, {
+				event: params.event,
+				roomId: params.roomId,
+				eventId: params.eventId,
+				attempts: attempts - 1,
+				inFlight: false,
+				timer: null,
+				exhaustedAt
+			});
+			this.pruneExhaustedDecryptRetries(exhaustedAt);
 			LogService.debug("MatrixClientLite", `Giving up decryption retry for ${params.eventId} in ${params.roomId} after ${attempts - 1} attempts`);
 			return;
 		}
@@ -635,21 +652,26 @@ var MatrixDecryptBridge = class {
 		state.inFlight = true;
 		state.timer = null;
 		this.activeRetryRuns += 1;
-		if (!(typeof this.deps.client.decryptEventIfNeeded === "function")) {
+		const retryEvent = state.event;
+		const retryCrypto = this.deps.client.getCrypto?.();
+		const canAttemptDecryption = retryCrypto !== void 0 && retryCrypto !== null && typeof retryEvent.attemptDecryption === "function";
+		if (!(canAttemptDecryption || typeof this.deps.client.decryptEventIfNeeded === "function")) {
 			this.clearDecryptRetry(retryKey);
 			this.activeRetryRuns = Math.max(0, this.activeRetryRuns - 1);
 			this.resolveRetryIdleIfNeeded();
 			return;
 		}
 		try {
-			await this.deps.client.decryptEventIfNeeded?.(state.event, { isRetry: true });
+			if (canAttemptDecryption) await retryEvent.attemptDecryption?.(retryCrypto, { isRetry: true });
+			else await this.deps.client.decryptEventIfNeeded?.(state.event, { isRetry: true });
 		} catch {} finally {
 			state.inFlight = false;
 			this.activeRetryRuns = Math.max(0, this.activeRetryRuns - 1);
 			this.resolveRetryIdleIfNeeded();
 		}
 		if (this.decryptRetries.get(retryKey) !== state) return;
-		if (isDecryptionFailure(state.event)) {
+		if (this.stopped) return;
+		if (state.event.isDecryptionFailure()) {
 			if (!shouldRetryDecryptionFailure(state.event)) {
 				this.clearDecryptRetry(retryKey);
 				return;
@@ -670,6 +692,14 @@ var MatrixDecryptBridge = class {
 		this.exhaustedDecryptRetries.delete(retryKey);
 		this.failedDecryptionsNotified.delete(retryKey);
 	}
+	pruneExhaustedDecryptRetries(now) {
+		for (const [retryKey, state] of this.exhaustedDecryptRetries) if (now - state.exhaustedAt > MATRIX_DECRYPT_EXHAUSTED_RETRY_TTL_MS) this.exhaustedDecryptRetries.delete(retryKey);
+		while (this.exhaustedDecryptRetries.size > MATRIX_DECRYPT_EXHAUSTED_RETRY_MAX_ENTRIES) {
+			const oldest = this.exhaustedDecryptRetries.keys().next().value;
+			if (oldest === void 0) break;
+			this.exhaustedDecryptRetries.delete(oldest);
+		}
+	}
 	rememberDecryptedMessage(roomId, eventId) {
 		if (!eventId) return;
 		const now = Date.now();
@@ -837,7 +867,7 @@ var MatrixVerificationManager = class {
 		const transactionMatches = Array.from(this.verificationSessions.values()).filter((session) => {
 			return this.readRequestValue(session.request, () => session.request.transactionId?.trim(), "") === id;
 		});
-		if (transactionMatches.length === 1) return transactionMatches[0];
+		if (transactionMatches.length === 1) return expectDefined(transactionMatches[0], "single Matrix verification session");
 		if (transactionMatches.length > 1) throw new Error(`Matrix verification request id is ambiguous for transaction ${id}; use the verification id instead`);
 		throw new Error(`Matrix verification request not found: ${id}`);
 	}

package/dist/{deps-CdjHvnmh.js → deps-DDbghaZH.js}

@@ -2,7 +2,7 @@ import { createRequire } from "node:module";
 import fs from "node:fs";
 import path from "node:path";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
-import { spawn } from "node:child_process";
+import { runCommandWithTimeout } from "openclaw/plugin-sdk/process-runtime";
 //#region extensions/matrix/src/matrix/deps.ts
 const REQUIRED_MATRIX_PACKAGES = [
 	"matrix-js-sdk",
@@ -11,7 +11,6 @@ const REQUIRED_MATRIX_PACKAGES = [
 ];
 const MIN_MATRIX_CRYPTO_NATIVE_BINDING_BYTES = 1e6;
 const MATRIX_COMMAND_OUTPUT_TAIL_BYTES = 64 * 1024;
-const MATRIX_STREAM_ERROR_KILL_GRACE_MS = 1e3;
 function resolveMissingMatrixPackages(resolveFn) {
 	const resolve = resolveFn ?? defaultResolveFn;
 	return REQUIRED_MATRIX_PACKAGES.filter((pkg) => {
@@ -30,99 +29,33 @@ function buildMatrixDepsMissingMessage(missing) {
 	return [`Matrix plugin dependencies are missing: ${missing.join(", ")}.`, "Repair this plugin with `openclaw plugins update matrix` or run `openclaw doctor --fix`."].join(" ");
 }
 let defaultMatrixCryptoRuntimeEnsurePromise = null;
-function appendBoundedOutputTail(current, chunk) {
-	const chunkBuffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-	if (chunkBuffer.byteLength >= 65536) return chunkBuffer.subarray(chunkBuffer.byteLength - MATRIX_COMMAND_OUTPUT_TAIL_BYTES).toString("utf8");
-	const currentBuffer = Buffer.from(current);
-	if (currentBuffer.byteLength + chunkBuffer.byteLength <= 65536) return `${current}${chunkBuffer.toString("utf8")}`;
-	const currentTailBytes = MATRIX_COMMAND_OUTPUT_TAIL_BYTES - chunkBuffer.byteLength;
-	const currentTail = currentBuffer.subarray(currentBuffer.byteLength - currentTailBytes);
-	return Buffer.concat([currentTail, chunkBuffer], MATRIX_COMMAND_OUTPUT_TAIL_BYTES).toString("utf8");
-}
 async function runFixedCommandWithTimeout(params) {
-	return await new Promise((resolve) => {
-		const [command, ...args] = params.argv;
-		if (!command) {
-			resolve({
-				code: 1,
-				stdout: "",
-				stderr: "command is required"
-			});
-			return;
-		}
-		const proc = spawn(command, args, {
+	if (!params.argv[0]) return {
+		code: 1,
+		stdout: "",
+		stderr: "command is required"
+	};
+	try {
+		const result = await runCommandWithTimeout(params.argv, {
 			cwd: params.cwd,
-			env: {
-				...process.env,
-				...params.env
-			},
-			stdio: [
-				"ignore",
-				"pipe",
-				"pipe"
-			]
+			env: params.env,
+			killProcessTree: true,
+			maxOutputBytes: MATRIX_COMMAND_OUTPUT_TAIL_BYTES,
+			outputCapture: "tail",
+			timeoutMs: params.timeoutMs
 		});
-		let stdout = "";
-		let stderr = "";
-		let settled = false;
-		let timer = null;
-		let streamKillTimer = null;
-		let streamErrorMessage = null;
-		const killChildOnExit = () => {
-			if (!settled && proc.exitCode === null) proc.kill("SIGTERM");
+		return {
+			code: result.termination === "timeout" ? 124 : result.code ?? 1,
+			stdout: result.stdout,
+			stderr: result.stderr || (result.termination === "timeout" ? `command timed out after ${params.timeoutMs}ms` : "")
 		};
-		const finalize = (result) => {
-			if (settled) return;
-			settled = true;
-			if (timer) clearTimeout(timer);
-			if (streamKillTimer) clearTimeout(streamKillTimer);
-			process.off("exit", killChildOnExit);
-			resolve(result);
-		};
-		process.once("exit", killChildOnExit);
-		proc.stdout?.on("data", (chunk) => {
-			stdout = appendBoundedOutputTail(stdout, chunk);
-		});
-		proc.stderr?.on("data", (chunk) => {
-			stderr = appendBoundedOutputTail(stderr, chunk);
-		});
-		const failReadableStream = (streamName) => (error) => {
-			if (settled || streamErrorMessage) return;
-			streamErrorMessage = `${streamName} stream failed: ${formatErrorMessage(error)}`;
-			if (proc.exitCode === null) proc.kill("SIGTERM");
-			streamKillTimer = setTimeout(() => {
-				if (!settled && proc.exitCode === null) proc.kill("SIGKILL");
-			}, MATRIX_STREAM_ERROR_KILL_GRACE_MS);
-			streamKillTimer.unref?.();
+	} catch (error) {
+		return {
+			code: 1,
+			stdout: "",
+			stderr: error instanceof Error ? error.message : String(error)
 		};
-		proc.stdout?.on("error", failReadableStream("stdout"));
-		proc.stderr?.on("error", failReadableStream("stderr"));
-		timer = setTimeout(() => {
-			proc.kill("SIGKILL");
-			if (streamErrorMessage) return;
-			finalize({
-				code: 124,
-				stdout,
-				stderr: stderr || `command timed out after ${params.timeoutMs}ms`
-			});
-		}, params.timeoutMs);
-		proc.on("error", (err) => {
-			if (streamErrorMessage) return;
-			finalize({
-				code: 1,
-				stdout,
-				stderr: err.message
-			});
-		});
-		proc.on("close", (code) => {
-			const streamErrorStderr = streamErrorMessage ? stderr ? appendBoundedOutputTail(stderr, `\n${streamErrorMessage}`) : streamErrorMessage : stderr;
-			finalize({
-				code: streamErrorMessage ? 1 : code ?? 1,
-				stdout,
-				stderr: streamErrorStderr
-			});
-		});
-	});
+	}
 }
 function defaultRequireFn(id) {
 	return createRequire(import.meta.url)(id);

package/dist/{directory-live-Ufd4qSpX.js → directory-live-DPy2aaPF.js}

@@ -1,8 +1,8 @@
 import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
 import { n as normalizeMatrixMessagingTarget, t as isMatrixQualifiedUserId } from "./target-ids-B-5aQxwn.js";
-import { f as resolveMatrixAuth } from "./shared-DkFfq7mH.js";
-import "./client-tgnlQJk4.js";
-import { t as MatrixAuthedHttpClient } from "./http-client-nSmFiVgk.js";
+import { f as resolveMatrixAuth } from "./shared-DgvN5rBx.js";
+import "./client-DP0nmFxK.js";
+import { t as MatrixAuthedHttpClient } from "./http-client-W4TJQM6r.js";
 import { normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/matrix/src/directory-live.ts
 var directory_live_exports = /* @__PURE__ */ __exportAll({

package/dist/doctor-BGTs609f.js

@@ -0,0 +1,64 @@
+import { n as normalizeCompatibilityConfig, t as legacyConfigRules } from "./doctor-contract-D2qTLe-C.js";
+import { detectPluginInstallPathIssue, formatPluginInstallPathIssue, removePluginFromConfig } from "openclaw/plugin-sdk/runtime-doctor";
+//#region extensions/matrix/src/doctor.ts
+async function collectMatrixInstallPathWarnings(cfg) {
+	const issue = await detectPluginInstallPathIssue({
+		pluginId: "matrix",
+		install: cfg.plugins?.installs?.matrix
+	});
+	if (!issue) return [];
+	return formatPluginInstallPathIssue({
+		issue,
+		pluginLabel: "Matrix",
+		defaultInstallCommand: "openclaw plugins install @openclaw/matrix"
+	}).map((entry) => `- ${entry}`);
+}
+async function cleanStaleMatrixPluginConfig(cfg) {
+	const issue = await detectPluginInstallPathIssue({
+		pluginId: "matrix",
+		install: cfg.plugins?.installs?.matrix
+	});
+	if (!issue || issue.kind !== "missing-path") return {
+		config: cfg,
+		changes: []
+	};
+	const { config, actions } = removePluginFromConfig(cfg, "matrix");
+	const removed = [];
+	if (actions.install) removed.push("install record");
+	if (actions.loadPath) removed.push("load path");
+	if (actions.entry) removed.push("plugin entry");
+	if (actions.allowlist) removed.push("allowlist entry");
+	if (removed.length === 0) return {
+		config: cfg,
+		changes: []
+	};
+	return {
+		config,
+		changes: [`Removed stale Matrix plugin references (${removed.join(", ")}). The previous install path no longer exists: ${issue.path}`]
+	};
+}
+async function runMatrixDoctorSequence(params) {
+	const warningNotes = [];
+	const installWarnings = await collectMatrixInstallPathWarnings(params.cfg);
+	if (installWarnings.length > 0) warningNotes.push(installWarnings.join("\n"));
+	return {
+		changeNotes: [],
+		warningNotes
+	};
+}
+const matrixDoctor = {
+	dmAllowFromMode: "nestedOnly",
+	groupModel: "sender",
+	groupAllowFromFallbackToAllowFrom: false,
+	warnOnEmptyGroupSenderAllowlist: true,
+	legacyConfigRules,
+	normalizeCompatibilityConfig,
+	runConfigSequence: async ({ cfg, env, shouldRepair }) => await runMatrixDoctorSequence({
+		cfg,
+		env,
+		shouldRepair
+	}),
+	cleanStaleConfig: async ({ cfg }) => await cleanStaleMatrixPluginConfig(cfg)
+};
+//#endregion
+export { cleanStaleMatrixPluginConfig, collectMatrixInstallPathWarnings, matrixDoctor, runMatrixDoctorSequence };