@openclaw/discord 2026.7.2-beta.7 → 2026.8.1-beta.3

package/dist/{doctor-Bc4S1qyd.js → doctor-DYY31GrO.js}

@@ -1,11 +1,12 @@
-import { o as resolveDefaultDiscordAccountId } from "./accounts-DJTf1LtA.js";
-import { t as inspectDiscordAccount } from "./account-inspect-SXiCBCgP.js";
-import { r as DISCORD_LEGACY_CONFIG_RULES } from "./shared-CXF1tup1.js";
-import { n as normalizeCompatibilityConfig } from "./doctor-contract-CCFMIDk9.js";
+import { s as resolveDefaultDiscordAccountId } from "./accounts-DNl-oCEw.js";
+import { t as discordVoiceTranscriptsSourceProvider } from "./transcripts-source-DeIMNbRh.js";
+import { t as inspectDiscordAccount } from "./account-inspect-D5xmUpnj.js";
+import { r as DISCORD_LEGACY_CONFIG_RULES } from "./shared-CaAaoksy.js";
+import { n as normalizeCompatibilityConfig } from "./doctor-contract-DsWvKIXF.js";
 import { t as isDiscordMutableAllowEntry } from "./security-doctor-nGgPm65L.js";
-import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";
-import { asObjectRecord, collectChannelAccountScopes, collectProviderDangerousNameMatchingScopes } from "openclaw/plugin-sdk/runtime-doctor";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { asObjectRecord, collectChannelAccountScopes, collectProviderDangerousNameMatchingScopes } from "openclaw/plugin-sdk/runtime-doctor-migrations";
 //#region extensions/discord/src/doctor.ts
 function sanitizeForLog(value) {
 	return value.replace(/\p{Cc}+/gu, " ").trim();
@@ -165,6 +166,22 @@ function collectDiscordMissingEnvTokenWarnings(params) {
 	if (!account.enabled || account.tokenStatus !== "missing" || account.tokenSource !== "none") return [];
 	return ["- channels.discord: default account has no available bot token, and DISCORD_BOT_TOKEN is absent in this doctor environment. After migration, verify DISCORD_BOT_TOKEN is present in the state-dir .env or configure channels.discord.token / channels.discord.accounts.default.token as a SecretRef."];
 }
+function collectDiscordTranscriptsAutoStartWarnings(cfg) {
+	if (cfg.transcripts?.enabled === false || !Array.isArray(cfg.transcripts?.autoStart)) return [];
+	const ownership = discordVoiceTranscriptsSourceProvider.accessControl;
+	if (!ownership) return [];
+	return cfg.transcripts.autoStart.flatMap((entry, index) => {
+		const providerId = normalizeOptionalString(entry.providerId)?.toLowerCase();
+		if (providerId !== discordVoiceTranscriptsSourceProvider.id && !discordVoiceTranscriptsSourceProvider.aliases?.includes(providerId ?? "") || normalizeOptionalString(entry.accountId)) return [];
+		const resolution = ownership.resolveAccountId({
+			cfg,
+			source: entry
+		});
+		if (resolution.ok) return [];
+		const path = `transcripts.autoStart[${index}]`;
+		return [`- ${path} cannot select a Discord voice account: ${resolution.error} Set ${path}.accountId to the intended enabled voice account, or set channels.discord.defaultAccount when one account should be the global default.`];
+	});
+}
 function collectDiscordMutableAllowlistWarnings(cfg) {
 	const hits = [];
 	const addHits = (pathLabel, list) => {
@@ -215,13 +232,17 @@ const discordDoctor = {
 	warnOnEmptyGroupSenderAllowlist: false,
 	legacyConfigRules: DISCORD_LEGACY_CONFIG_RULES,
 	normalizeCompatibilityConfig,
-	collectPreviewWarnings: ({ cfg, doctorFixCommand, env }) => [...collectDiscordMissingEnvTokenWarnings({
-		cfg,
-		env
-	}), ...collectDiscordNumericIdWarnings({
-		hits: scanDiscordNumericIdEntries(cfg),
-		doctorFixCommand
-	})],
+	collectPreviewWarnings: ({ cfg, doctorFixCommand, env }) => [
+		...collectDiscordMissingEnvTokenWarnings({
+			cfg,
+			env
+		}),
+		...collectDiscordNumericIdWarnings({
+			hits: scanDiscordNumericIdEntries(cfg),
+			doctorFixCommand
+		}),
+		...collectDiscordTranscriptsAutoStartWarnings(cfg)
+	],
 	collectMutableAllowlistWarnings: ({ cfg }) => collectDiscordMutableAllowlistWarnings(cfg),
 	repairConfig: ({ cfg, doctorFixCommand }) => maybeRepairDiscordNumericIds(cfg, doctorFixCommand)
 };

package/dist/{doctor-contract-CCFMIDk9.js → doctor-contract-DsWvKIXF.js}

@@ -1,5 +1,5 @@
-import { isSupportedRealtimeVoiceActivationName, normalizeRealtimeVoiceActivationNamePrefix } from "openclaw/plugin-sdk/realtime-voice";
-import { asObjectRecord, defineChannelAliasMigration, defineKeyMoveMigration, hasLegacyAccountStreamingAliases, normalizeChannelAccounts, stripRetiredChannelKeys } from "openclaw/plugin-sdk/runtime-doctor";
+import { asObjectRecord, defineChannelAliasMigration, defineKeyMoveMigration, hasLegacyAccountStreamingAliases, normalizeChannelAccounts, stripRetiredChannelKeys } from "openclaw/plugin-sdk/runtime-doctor-migrations";
+import { isSupportedRealtimeVoiceActivationName, normalizeRealtimeVoiceActivationNamePrefix } from "openclaw/plugin-sdk/realtime-voice-activation";
 //#region extensions/discord/src/doctor-contract.ts
 const LEGACY_TTS_PROVIDER_KEYS = [
 	"openai",
@@ -18,7 +18,6 @@ const streamingAliasMigration = defineChannelAliasMigration({
 	channelId: "discord",
 	streaming: {
 		defaultMode: "off",
-		absentObjectDefault: "progress",
 		includePreviewChunk: true
 	},
 	accountStreamingReplacesRoot: true,

package/dist/doctor-contract-api.js

@@ -1,2 +1,147 @@
-import { n as normalizeCompatibilityConfig, t as legacyConfigRules } from "./doctor-contract-CCFMIDk9.js";
-export { legacyConfigRules, normalizeCompatibilityConfig };
+import { n as DISCORD_COMMAND_DEPLOY_HASH_NAMESPACE, t as DISCORD_COMMAND_DEPLOY_HASH_MAX_ENTRIES } from "./command-deploy-store-DFkBTViB.js";
+import { a as THREAD_BINDINGS_MAX_ENTRIES, d as normalizePersistedBinding, k as toBindingRecordKey, o as THREAD_BINDINGS_NAMESPACE } from "./thread-bindings.state-D8OMdk4O.js";
+import { n as normalizeCompatibilityConfig, t as legacyConfigRules } from "./doctor-contract-DsWvKIXF.js";
+import { i as sanitizeRecentModels, r as preferenceTimestampMs, t as buildPreferenceModelKey } from "./model-picker-preference-primitives-BHT1LkR_.js";
+import { MAX_DATE_TIMESTAMP_MS, timestampMsToIsoString } from "openclaw/plugin-sdk/number-runtime";
+import { definePluginDoctorMigrationFromPlans } from "openclaw/plugin-sdk/runtime-doctor-migrations";
+import path from "node:path";
+import fs from "node:fs";
+//#region extensions/discord/src/monitor/model-picker-preferences-migrations.ts
+const PREFERENCE_MAX_ENTRIES = 2e3;
+const MAX_PLUGIN_STATE_KEY_BYTES = 512;
+const textEncoder = new TextEncoder();
+function fileExists(filePath) {
+	try {
+		return fs.statSync(filePath).isFile();
+	} catch {
+		return false;
+	}
+}
+function readLegacyStore(filePath) {
+	try {
+		const parsed = JSON.parse(fs.readFileSync(filePath, "utf8"));
+		return parsed && typeof parsed === "object" ? parsed : null;
+	} catch {
+		return null;
+	}
+}
+function readLegacyThreadBindingsStore(filePath) {
+	const parsed = JSON.parse(fs.readFileSync(filePath, "utf8"));
+	if (!parsed || typeof parsed !== "object") throw new Error("legacy Discord thread bindings store must be an object");
+	return parsed;
+}
+function normalizeLegacyPreferenceKey(key) {
+	const trimmed = key.trim();
+	if (!trimmed || textEncoder.encode(trimmed).length > MAX_PLUGIN_STATE_KEY_BYTES) return;
+	return trimmed;
+}
+function legacyUpdatedAtForIndex(updatedAt, index, total) {
+	const baseMs = preferenceTimestampMs(updatedAt);
+	return timestampMsToIsoString(Math.min(baseMs + Math.max(0, total), MAX_DATE_TIMESTAMP_MS) - Math.max(0, index)) ?? timestampMsToIsoString(baseMs) ?? timestampMsToIsoString(Math.max(0, total - index)) ?? "1970-01-01T00:00:00.000Z";
+}
+function readFiniteNumberField(entry, key) {
+	const value = entry[key];
+	return typeof value === "number" && Number.isFinite(value) ? Math.floor(value) : void 0;
+}
+function upgradeLegacyThreadBindingShape(rawEntry) {
+	if (!rawEntry || typeof rawEntry !== "object" || Array.isArray(rawEntry)) return rawEntry;
+	const entry = { ...rawEntry };
+	if (entry.targetSessionKey === void 0 && typeof entry.sessionKey === "string") entry.targetSessionKey = entry.sessionKey;
+	delete entry.sessionKey;
+	const expiresAt = readFiniteNumberField(entry, "expiresAt");
+	delete entry.expiresAt;
+	if (entry.idleTimeoutMs === void 0 && entry.maxAgeMs === void 0 && expiresAt !== void 0) {
+		entry.idleTimeoutMs = 0;
+		if (expiresAt <= 0) entry.maxAgeMs = 0;
+		else {
+			const boundAt = readFiniteNumberField(entry, "boundAt") ?? 0;
+			const lastActivityAt = readFiniteNumberField(entry, "lastActivityAt") ?? 0;
+			entry.maxAgeMs = Math.max(1, expiresAt - Math.max(0, boundAt > 0 ? boundAt : lastActivityAt));
+		}
+	}
+	return entry;
+}
+const detectDiscordLegacyStateMigrations = ({ stateDir }) => {
+	const plans = [];
+	const commandDeployCacheSourcePath = path.join(stateDir, "discord", "command-deploy-cache.json");
+	if (fileExists(commandDeployCacheSourcePath)) plans.push({
+		kind: "plugin-state-import",
+		label: "Discord command deployment cache",
+		sourcePath: commandDeployCacheSourcePath,
+		targetPath: `plugin state:${DISCORD_COMMAND_DEPLOY_HASH_NAMESPACE}`,
+		pluginId: "discord",
+		namespace: DISCORD_COMMAND_DEPLOY_HASH_NAMESPACE,
+		maxEntries: DISCORD_COMMAND_DEPLOY_HASH_MAX_ENTRIES,
+		scopeKey: "",
+		cleanupSource: "remove",
+		cleanupWhenEmpty: true,
+		readEntries: () => []
+	});
+	const modelPickerSourcePath = path.join(stateDir, "discord", "model-picker-preferences.json");
+	if (fileExists(modelPickerSourcePath)) plans.push({
+		kind: "plugin-state-import",
+		label: "Discord model picker preferences",
+		sourcePath: modelPickerSourcePath,
+		targetPath: "plugin state:model-picker-preferences",
+		pluginId: "discord",
+		namespace: "model-picker-preferences",
+		maxEntries: PREFERENCE_MAX_ENTRIES,
+		scopeKey: "",
+		cleanupSource: "rename",
+		readEntries: () => {
+			const store = readLegacyStore(modelPickerSourcePath);
+			if (!store || !store.entries || typeof store.entries !== "object") return [];
+			const out = [];
+			for (const [rawKey, rawEntry] of Object.entries(store.entries)) {
+				const scopeKey = normalizeLegacyPreferenceKey(rawKey);
+				if (!scopeKey || !rawEntry || typeof rawEntry !== "object") continue;
+				const recent = sanitizeRecentModels(rawEntry.recent, 10);
+				for (const [index, modelRef] of recent.entries()) out.push({
+					key: buildPreferenceModelKey(scopeKey, modelRef),
+					value: {
+						scopeKey,
+						modelRef,
+						updatedAt: legacyUpdatedAtForIndex(rawEntry.updatedAt, index, recent.length)
+					}
+				});
+			}
+			return out;
+		}
+	});
+	const threadBindingsSourcePath = path.join(stateDir, "discord", "thread-bindings.json");
+	if (fileExists(threadBindingsSourcePath)) plans.push({
+		kind: "plugin-state-import",
+		label: "Discord thread bindings",
+		sourcePath: threadBindingsSourcePath,
+		targetPath: `plugin state:${THREAD_BINDINGS_NAMESPACE}`,
+		pluginId: "discord",
+		namespace: THREAD_BINDINGS_NAMESPACE,
+		maxEntries: THREAD_BINDINGS_MAX_ENTRIES,
+		scopeKey: "",
+		cleanupSource: "rename",
+		cleanupWhenEmpty: true,
+		readEntries: () => {
+			const store = readLegacyThreadBindingsStore(threadBindingsSourcePath);
+			if (store?.version !== 1 || !store.bindings || typeof store.bindings !== "object") throw new Error("legacy Discord thread bindings store must have version 1 bindings");
+			const out = [];
+			for (const [rawKey, rawEntry] of Object.entries(store.bindings)) {
+				const normalized = normalizePersistedBinding(rawKey, upgradeLegacyThreadBindingShape(rawEntry));
+				if (normalized) out.push({
+					key: toBindingRecordKey(normalized),
+					value: normalized
+				});
+			}
+			return out;
+		}
+	});
+	return plans;
+};
+//#endregion
+//#region extensions/discord/doctor-contract-api.ts
+const stateMigrations = [definePluginDoctorMigrationFromPlans({
+	id: "discord-legacy-state",
+	label: "Discord legacy state",
+	resolvePlans: detectDiscordLegacyStateMigrations
+})];
+//#endregion
+export { legacyConfigRules, normalizeCompatibilityConfig, stateMigrations };

package/dist/{handle-action.guild-admin-D6VRRW-C.js → handle-action.guild-admin-6Tvvinsa.js}

@@ -1,6 +1,6 @@
-import { c as readDiscordChannelMoveParams, n as isDiscordModerationAction, o as readDiscordChannelCreateParams, r as readDiscordModerationCommand, s as readDiscordChannelEditParams, t as handleDiscordAction } from "./runtime-_aRC6V2s.js";
+import { c as readDiscordChannelMoveParams, n as isDiscordModerationAction, o as readDiscordChannelCreateParams, r as readDiscordModerationCommand, s as readDiscordChannelEditParams, t as handleDiscordAction } from "./runtime-D71_VFLr.js";
 import "./action-runtime-api.js";
-import { n as isTrustedRequesterGuildAdminAction } from "./channel-actions-uXFTJX3o.js";
+import { n as isTrustedRequesterGuildAdminAction } from "./channel-actions-Dr2QI8Bf.js";
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { readNonNegativeIntegerParam, readPositiveIntegerParam, readStringArrayParam, readStringParam } from "openclaw/plugin-sdk/agent-runtime";
 //#region extensions/discord/src/actions/handle-action.guild-admin.ts
@@ -13,7 +13,7 @@ function senderParam(senderUserId) {
 	return senderUserId ? { senderUserId } : {};
 }
 async function tryHandleDiscordMessageActionGuildAdmin(params) {
-	const { ctx, resolveChannelId, readPolicyOptions } = params;
+	const { ctx, resolveChannelId, readPolicyOptions, actionOptions } = params;
 	const { action, params: actionParams, cfg } = ctx;
 	const accountId = ctx.accountId ?? readStringParam(actionParams, "accountId");
 	const senderUserId = readDiscordRequesterSenderId(ctx);
@@ -284,10 +284,7 @@ async function tryHandleDiscordMessageActionGuildAdmin(params) {
 			content,
 			mediaUrl: mediaUrl ?? void 0,
 			replyTo: replyTo ?? void 0
-		}, cfg, {
-			mediaLocalRoots: ctx.mediaLocalRoots,
-			mediaReadFile: ctx.mediaReadFile
-		});
+		}, cfg, actionOptions);
 	}
 	if (action === "search") {
 		const guildId = readStringParam(actionParams, "guildId");

package/dist/{inbound-event-delivery-CEPlt2uz.js → inbound-event-delivery-De2qxTrP.js}

@@ -1,32 +1,11 @@
 import { asOptionalRecord, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { createInboundEventDeliveryCorrelation } from "openclaw/plugin-sdk/inbound-event-delivery";
 //#region extensions/discord/src/inbound-event-delivery.ts
 const DISCORD_INBOUND_EVENT_DELIVERY_KEY = "__openclawInboundEventDelivery";
-const registry = /* @__PURE__ */ new Map();
 function normalizeDiscordDeliveryTarget(value) {
 	return value.trim().replace(/^discord:/iu, "").replace(/^channel:/iu, "").toLowerCase();
 }
-function resolveDiscordInboundEventDeliveryCorrelationKey(sessionKey, inboundEventKind) {
-	const key = sessionKey?.trim();
-	if (!key) return;
-	return inboundEventKind === "room_event" ? `${key}:room_event` : key;
-}
-function beginDiscordInboundEventDeliveryCorrelation(sessionKey, event, options) {
-	const key = resolveDiscordInboundEventDeliveryCorrelationKey(sessionKey, options?.inboundEventKind);
-	if (!key) return () => {};
-	registry.set(key, event);
-	return () => {
-		if (registry.get(key) === event) registry.delete(key);
-	};
-}
-function notifyDiscordInboundEventOutboundSuccess(params) {
-	const key = resolveDiscordInboundEventDeliveryCorrelationKey(params.sessionKey, params.inboundEventKind);
-	if (!key) return;
-	const event = registry.get(key);
-	if (!event || normalizeDiscordDeliveryTarget(event.outboundTo) !== normalizeDiscordDeliveryTarget(params.to)) return;
-	if (event.outboundAccountId && params.accountId && params.accountId !== event.outboundAccountId) return;
-	registry.delete(key);
-	event.markInboundEventDelivered();
-}
+const discordInboundEventDelivery = createInboundEventDeliveryCorrelation({ targetsMatch: (expected, actual) => normalizeDiscordDeliveryTarget(expected) === normalizeDiscordDeliveryTarget(actual) });
 function withDiscordInboundEventDeliveryMetadata(payload, params) {
 	const sessionKey = params.sessionKey?.trim();
 	if (!sessionKey || params.inboundEventKind !== "room_event") return payload;
@@ -49,7 +28,7 @@ function withDiscordInboundEventDeliveryMetadata(payload, params) {
 function notifyDiscordInboundEventOutboundPayloadSuccess(params) {
 	const metadata = asOptionalRecord(asOptionalRecord(asOptionalRecord(params.payload.channelData)?.discord)?.[DISCORD_INBOUND_EVENT_DELIVERY_KEY]);
 	if (!metadata) return;
-	notifyDiscordInboundEventOutboundSuccess({
+	discordInboundEventDelivery.notify({
 		sessionKey: normalizeOptionalString(metadata.sessionKey),
 		inboundEventKind: normalizeOptionalString(metadata.inboundEventKind),
 		to: params.to,
@@ -57,4 +36,4 @@ function notifyDiscordInboundEventOutboundPayloadSuccess(params) {
 	});
 }
 //#endregion
-export { withDiscordInboundEventDeliveryMetadata as i, notifyDiscordInboundEventOutboundPayloadSuccess as n, notifyDiscordInboundEventOutboundSuccess as r, beginDiscordInboundEventDeliveryCorrelation as t };
+export { notifyDiscordInboundEventOutboundPayloadSuccess as n, withDiscordInboundEventDeliveryMetadata as r, discordInboundEventDelivery as t };

package/dist/index.js

@@ -1,7 +1,6 @@
-import { t as registerDiscordActivities } from "./activities-api-DTKsuDxf.js";
+import { t as registerDiscordActivities } from "./activities-api-KCBAmWxD.js";
 import { registerDiscordSubagentHooks } from "./subagent-hooks-api.js";
-import { t as discordVoiceTranscriptsSourceProvider } from "./transcripts-source-DIKGsTGT.js";
-import "./transcripts-source-api.js";
+import { registerDiscordTranscriptSourceProvider } from "./transcripts-source-api.js";
 import { defineBundledChannelEntry } from "openclaw/plugin-sdk/channel-entry-contract";
 //#region extensions/discord/index.ts
 var discord_default = defineBundledChannelEntry({
@@ -24,7 +23,9 @@ var discord_default = defineBundledChannelEntry({
 	registerFull(api) {
 		registerDiscordActivities(api);
 		registerDiscordSubagentHooks(api);
-		api.registerTranscriptSourceProvider(discordVoiceTranscriptsSourceProvider);
+	},
+	registerCapabilities(api) {
+		registerDiscordTranscriptSourceProvider(api);
 	}
 });
 //#endregion

package/dist/{message-handler-CeiSulIw.js → message-handler-B61q5MOF.js}

@@ -1,12 +1,15 @@
 import { t as getDiscordRuntime } from "./runtime-DgnVQ7zW.js";
-import { d as resolveDiscordChannelIdSafe, f as resolveDiscordChannelInfoSafe, h as resolveDiscordChannelParentSafe, p as resolveDiscordChannelNameSafe } from "./thread-bindings.discord-api-BoDNqamb.js";
-import { w as mapGatewayDispatchData } from "./provider-DfQJX3z5.js";
-import { f as resolveDiscordMessageChannelId, i as resolveDiscordMessageText, l as hasDiscordMessageStickers } from "./message-utils-BgTwT_q7.js";
-import { normalizeNullableString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { c as resolveDiscordChannelInfoSafe, d as resolveDiscordChannelParentSafe, l as resolveDiscordChannelNameSafe, s as resolveDiscordChannelIdSafe } from "./thread-bindings.manager-CngsgErq.js";
+import { _ as mapGatewayDispatchData } from "./provider-DlK_ynqt.js";
+import { i as resolveDiscordMessageText, l as resolveDiscordCdnPolicy, p as resolveDiscordMessageChannelId, u as hasDiscordMessageStickers } from "./message-utils-BXLLnFl6.js";
+import { logDebug } from "openclaw/plugin-sdk/logging-core";
 import { GatewayDispatchEvents } from "discord-api-types/v10";
+import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
+import { normalizeNullableString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { danger } from "openclaw/plugin-sdk/runtime-env";
 import { resolveBatchedReplyThreadingPolicy } from "openclaw/plugin-sdk/reply-reference";
-import { createChannelIngressError, createChannelIngressMonitor, createChannelRunQueue } from "openclaw/plugin-sdk/channel-outbound";
+import { DEFAULT_INGRESS_RETRY_MAX_ATTEMPTS, createChannelIngressError, createChannelIngressMonitor, createChannelRunQueue } from "openclaw/plugin-sdk/channel-outbound";
+import { saveRemoteMedia } from "openclaw/plugin-sdk/media-runtime";
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 import { resolveOpenProviderRuntimeGroupPolicy } from "openclaw/plugin-sdk/runtime-group-policy";
 import { fanInChannelIngressLifecycles } from "openclaw/plugin-sdk/channel-ingress-runtime";
@@ -43,9 +46,6 @@ function decodeDiscordIngressPayload(payload, claimedId) {
 		}
 	};
 }
-function errorText(error) {
-	return error instanceof Error ? error.message : String(error);
-}
 function isDiscordAuthenticationFailure(error) {
 	let current = error;
 	const seen = /* @__PURE__ */ new Set();
@@ -87,6 +87,10 @@ function createDiscordIngressMonitor(params) {
 		},
 		appendRetryDelaysMs: [0],
 		drain: {
+			retryPolicy: {
+				maxAttempts: DEFAULT_INGRESS_RETRY_MAX_ATTEMPTS,
+				deadLetterMinAgeMs: 0
+			},
 			resolveNonRetryableFailure: (error) => {
 				if (error instanceof DiscordIngressPayloadError) return {
 					reason: "invalid-event",
@@ -94,13 +98,13 @@ function createDiscordIngressMonitor(params) {
 				};
 				if (isDiscordAuthenticationFailure(error)) return {
 					reason: "authentication-failed",
-					message: errorText(error)
+					message: formatErrorMessage(error)
 				};
 				return null;
 			},
 			onLog: (message) => params.runtime.error?.(danger(`discord ingress: ${message}`))
 		},
-		onError: (error) => params.runtime.error?.(danger(`discord ingress drain failed: ${errorText(error)}`))
+		onError: (error) => params.runtime.error?.(danger(`discord ingress drain failed: ${formatErrorMessage(error)}`))
 	});
 	return {
 		accept: async (rawMessage) => {
@@ -112,18 +116,10 @@ function createDiscordIngressMonitor(params) {
 }
 //#endregion
 //#region extensions/discord/src/monitor/inbound-job.ts
-function resolveDiscordInboundJobQueueKey(ctx) {
-	const sessionKey = ctx.route.sessionKey?.trim();
-	if (sessionKey) return sessionKey;
-	const baseSessionKey = ctx.baseSessionKey?.trim();
-	if (baseSessionKey) return baseSessionKey;
-	return ctx.messageChannelId;
-}
 function buildDiscordInboundJob(ctx, options) {
 	const { runtime, abortSignal, guildHistories, client, turnAdoptionLifecycle, threadBindings, discordRestFetch, message, data, threadChannel, ...payload } = ctx;
 	const sanitizedMessage = sanitizeDiscordInboundMessage(message);
 	return {
-		queueKey: resolveDiscordInboundJobQueueKey(ctx),
 		payload: {
 			...payload,
 			message: sanitizedMessage,
@@ -173,6 +169,77 @@ function normalizeDiscordThreadChannel(threadChannel) {
 	};
 }
 //#endregion
+//#region extensions/discord/src/monitor/message-avatar.ts
+const DISCORD_AVATAR_MAX_BYTES = 256 * 1024;
+const DISCORD_AVATAR_CACHE_MAX_ENTRIES = 128;
+const DISCORD_GUILD_ICON_TTL_MS = 5 * 6e4;
+function setBoundedEntry(map, key, value) {
+	map.delete(key);
+	map.set(key, value);
+	while (map.size > DISCORD_AVATAR_CACHE_MAX_ENTRIES) {
+		const oldest = map.keys().next().value;
+		if (oldest === void 0) break;
+		map.delete(oldest);
+	}
+}
+function discordAvatarUrl(owner, id, hash) {
+	return `https://cdn.discordapp.com/${owner}/${id}/${hash}.png?size=128`;
+}
+/** Dispatcher-lifetime resolver for eventually available Discord conversation images. */
+function createDiscordAvatarResolver() {
+	const saved = /* @__PURE__ */ new Map();
+	const pending = /* @__PURE__ */ new Set();
+	const guildIcons = /* @__PURE__ */ new Map();
+	const pendingGuilds = /* @__PURE__ */ new Set();
+	const resolveSavedAvatar = (key, url) => {
+		const cached = saved.get(key);
+		if (cached) {
+			saved.delete(key);
+			saved.set(key, cached);
+			return cached;
+		}
+		if (pending.has(key) || pending.size >= DISCORD_AVATAR_CACHE_MAX_ENTRIES) return;
+		pending.add(key);
+		saveRemoteMedia({
+			url,
+			filePathHint: "conversation-avatar.png",
+			maxBytes: DISCORD_AVATAR_MAX_BYTES,
+			ssrfPolicy: resolveDiscordCdnPolicy()
+		}).then((media) => {
+			setBoundedEntry(saved, key, media.path);
+		}).catch((error) => {
+			logDebug(`discord conversation avatar download failed: ${formatErrorMessage(error)}`);
+		}).finally(() => {
+			pending.delete(key);
+		});
+	};
+	const refreshGuildIcon = (client, guildId, conversationId) => {
+		if (pendingGuilds.has(guildId) || pendingGuilds.size >= DISCORD_AVATAR_CACHE_MAX_ENTRIES) return;
+		pendingGuilds.add(guildId);
+		client.fetchGuild(guildId).then((guild) => {
+			const hash = guild.icon ?? null;
+			setBoundedEntry(guildIcons, guildId, {
+				expiresAt: Date.now() + DISCORD_GUILD_ICON_TTL_MS,
+				hash
+			});
+			if (hash) resolveSavedAvatar(`${conversationId}\0${hash}`, discordAvatarUrl("icons", guildId, hash));
+		}).catch((error) => {
+			logDebug(`discord guild icon lookup failed: ${formatErrorMessage(error)}`);
+		}).finally(() => {
+			pendingGuilds.delete(guildId);
+		});
+	};
+	return { resolve(params) {
+		if (!params.guildId) {
+			const hash = params.author.avatar;
+			return hash ? resolveSavedAvatar(`${params.conversationId}\0${hash}`, discordAvatarUrl("avatars", params.author.id, hash)) : void 0;
+		}
+		const guildIcon = guildIcons.get(params.guildId);
+		if (!guildIcon || guildIcon.expiresAt <= Date.now()) refreshGuildIcon(params.client, params.guildId, params.conversationId);
+		return guildIcon?.hash ? resolveSavedAvatar(`${params.conversationId}\0${guildIcon.hash}`, discordAvatarUrl("icons", params.guildId, guildIcon.hash)) : void 0;
+	} };
+}
+//#endregion
 //#region extensions/discord/src/monitor/message-handler.batch-gate.ts
 function applyImplicitReplyBatchGate(ctx, replyToMode, isBatched) {
 	const replyThreading = resolveBatchedReplyThreadingPolicy(replyToMode, isBatched);
@@ -181,20 +248,21 @@ function applyImplicitReplyBatchGate(ctx, replyToMode, isBatched) {
 }
 //#endregion
 //#region extensions/discord/src/monitor/message-run-queue.ts
-const loadMessageProcessRuntime = createLazyRuntimeModule(() => import("./message-handler.process-Dnc_oz9y.js"));
+const loadMessageProcessRuntime = createLazyRuntimeModule(() => import("./message-handler.process--4_712Ec.js"));
 async function processDiscordQueuedMessage(params) {
 	const abortSignal = params.job.runtime.abortSignal && params.lifecycleSignal ? AbortSignal.any([params.job.runtime.abortSignal, params.lifecycleSignal]) : params.job.runtime.abortSignal ?? params.lifecycleSignal;
 	try {
 		await (params.testing?.processDiscordMessage ?? (await loadMessageProcessRuntime()).processDiscordMessage)(materializeDiscordInboundJob(params.job, abortSignal));
-		if (abortSignal?.aborted) await params.job.ingressSettlement?.abandon(abortSignal.reason);
+		if (abortSignal?.aborted) await params.job.ingressSettlement?.cancel();
 		else await params.job.ingressSettlement?.settle();
 	} catch (error) {
-		await params.job.ingressSettlement?.abandon(error);
+		if (abortSignal?.aborted) await params.job.ingressSettlement?.cancel();
+		else await params.job.ingressSettlement?.abandon(error);
 		throw error;
 	}
 }
 async function cleanupSkippedDiscordQueuedMessage(params) {
-	await params.job.ingressSettlement?.abandon(/* @__PURE__ */ new Error("discord queued run skipped before processing"));
+	await params.job.ingressSettlement?.cancel();
 }
 function createDiscordMessageRunQueue(params) {
 	const skippedCleanup = /* @__PURE__ */ new Set();
@@ -232,6 +300,10 @@ function createDiscordMessageRunQueue(params) {
 			const cleanupSkipped = async () => {
 				try {
 					await cleanupSkippedDiscordQueuedMessage({ job });
+				} catch (error) {
+					try {
+						params.runtime.error(danger(`discord queued message cleanup failed: ${String(error)}`));
+					} catch {}
 				} finally {
 					settlePending();
 				}
@@ -241,7 +313,7 @@ function createDiscordMessageRunQueue(params) {
 				return;
 			}
 			skippedCleanup.add(cleanupSkipped);
-			runQueue.enqueue(job.queueKey, async ({ lifecycleSignal }) => {
+			runQueue.enqueue(job.payload.message.id, async ({ lifecycleSignal }) => {
 				skippedCleanup.delete(cleanupSkipped);
 				try {
 					await processDiscordQueuedMessage({
@@ -263,7 +335,7 @@ function createDiscordMessageRunQueue(params) {
 }
 //#endregion
 //#region extensions/discord/src/monitor/message-dispatcher.ts
-const loadMessagePreflightRuntime = createLazyRuntimeModule(() => import("./message-handler.preflight-DibgQFf2.js"));
+const loadMessagePreflightRuntime = createLazyRuntimeModule(() => import("./message-handler.preflight-Bzg_Hawz.js"));
 function isNonEmptyString(value) {
 	return typeof value === "string" && value.length > 0;
 }
@@ -282,6 +354,7 @@ function createDiscordMessageDispatcher(params) {
 		testing: params.testing
 	});
 	const dispatcherShutdown = new AbortController();
+	const avatarResolver = createDiscordAvatarResolver();
 	const pendingDebounceEntries = /* @__PURE__ */ new Set();
 	const pendingCancellationSettlements = /* @__PURE__ */ new Set();
 	const resolveDebounceKey = (entry) => {
@@ -317,13 +390,14 @@ function createDiscordMessageDispatcher(params) {
 					if (!last) return;
 					const abortSignal = last.abortSignal;
 					if (abortSignal?.aborted) {
-						await admissionLifecycle.onAbandoned();
+						await ingress.cancel();
 						return;
 					}
 					try {
 						if (entries.length === 1) {
 							const ctx = await (preflightDiscordMessageImpl ?? (await loadMessagePreflightRuntime()).preflightDiscordMessage)({
 								...params,
+								avatarResolver,
 								ackReactionScope,
 								groupPolicy,
 								abortSignal,
@@ -332,7 +406,7 @@ function createDiscordMessageDispatcher(params) {
 								turnAdoptionLifecycle: admissionLifecycle
 							});
 							if (abortSignal?.aborted) {
-								await ingress.abandon(abortSignal.reason);
+								await ingress.cancel();
 								return;
 							}
 							if (!ctx) {
@@ -378,6 +452,7 @@ function createDiscordMessageDispatcher(params) {
 						};
 						const ctx = await (preflightDiscordMessageImpl ?? (await loadMessagePreflightRuntime()).preflightDiscordMessage)({
 							...params,
+							avatarResolver,
 							ackReactionScope,
 							groupPolicy,
 							abortSignal,
@@ -386,7 +461,7 @@ function createDiscordMessageDispatcher(params) {
 							turnAdoptionLifecycle: admissionLifecycle
 						});
 						if (abortSignal?.aborted) {
-							await ingress.abandon(abortSignal.reason);
+							await ingress.cancel();
 							return;
 						}
 						if (!ctx) {
@@ -403,7 +478,10 @@ function createDiscordMessageDispatcher(params) {
 						}
 						messageRunQueue.enqueue(buildDiscordInboundJob(ctx, { ingressSettlement: ingress }));
 					} catch (error) {
-						await admissionLifecycle.onAbandoned();
+						if (abortSignal?.aborted) {
+							await ingress.cancel();
+							return;
+						}
 						throw error;
 					}
 				}
@@ -415,7 +493,7 @@ function createDiscordMessageDispatcher(params) {
 		onCancel: (entries) => {
 			for (const entry of entries) {
 				pendingDebounceEntries.delete(entry);
-				const settlement = Promise.resolve(entry.turnAdoptionLifecycle?.onAbandoned()).catch((error) => {
+				const settlement = fanInChannelIngressLifecycles([entry.turnAdoptionLifecycle]).cancel().catch((error) => {
 					params.runtime.error(danger(`discord ingress cancellation settlement failed: ${String(error)}`));
 				}).finally(() => {
 					pendingCancellationSettlements.delete(settlement);
@@ -426,10 +504,17 @@ function createDiscordMessageDispatcher(params) {
 	});
 	const dispatchMessage = async (data, client, options) => {
 		try {
-			if (dispatcherShutdown.signal.aborted || options?.abortSignal?.aborted) return {
-				kind: "failed-retryable",
-				error: dispatcherShutdown.signal.aborted ? dispatcherShutdown.signal.reason ?? /* @__PURE__ */ new Error("discord dispatcher shut down") : options?.abortSignal?.reason ?? /* @__PURE__ */ new Error("discord dispatch aborted")
-			};
+			if (dispatcherShutdown.signal.aborted || options?.abortSignal?.aborted) {
+				const reason = dispatcherShutdown.signal.aborted ? dispatcherShutdown.signal.reason ?? /* @__PURE__ */ new Error("discord dispatcher shut down") : options?.abortSignal?.reason ?? /* @__PURE__ */ new Error("discord dispatch aborted");
+				if (options?.turnAdoptionLifecycle) {
+					await fanInChannelIngressLifecycles([options.turnAdoptionLifecycle]).cancel();
+					return { kind: "deferred" };
+				}
+				return {
+					kind: "failed-retryable",
+					error: reason
+				};
+			}
 			const msgAuthorId = data.message?.author?.id ?? data.author?.id;
 			if (params.botUserId && msgAuthorId === params.botUserId) return { kind: "completed" };
 			const entry = {