@openclaw/discord 2026.7.2-beta.5 → 2026.8.1-beta.2

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-aeV8HNgV.js";
+import { n as normalizeCompatibilityConfig, t as legacyConfigRules } from "./doctor-contract-DLa-BTiU.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 path from "node:path";
+import { definePluginDoctorMigrationFromPlans } from "openclaw/plugin-sdk/runtime-doctor-migrations";
+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-D14y2JtA.js → handle-action.guild-admin-BNVTUISF.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-BZm4_qXV.js";
+import { c as readDiscordChannelMoveParams, n as isDiscordModerationAction, o as readDiscordChannelCreateParams, r as readDiscordModerationCommand, s as readDiscordChannelEditParams, t as handleDiscordAction } from "./runtime-DGsSyDTS.js";
 import "./action-runtime-api.js";
-import { n as isTrustedRequesterGuildAdminAction } from "./channel-actions-BweII8kV.js";
+import { n as isTrustedRequesterGuildAdminAction } from "./channel-actions-5s_hjYKd.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,6 +1,6 @@
-import { t as registerDiscordActivities } from "./activities-api-CHnz7E7t.js";
+import { t as registerDiscordActivities } from "./activities-api-DS7vpdtp.js";
 import { registerDiscordSubagentHooks } from "./subagent-hooks-api.js";
-import { t as discordVoiceTranscriptsSourceProvider } from "./transcripts-source-BW2VfPX0.js";
+import { t as discordVoiceTranscriptsSourceProvider } from "./transcripts-source-CfFMexGt.js";
 import "./transcripts-source-api.js";
 import { defineBundledChannelEntry } from "openclaw/plugin-sdk/channel-entry-contract";
 //#region extensions/discord/index.ts
@@ -24,6 +24,8 @@ var discord_default = defineBundledChannelEntry({
 	registerFull(api) {
 		registerDiscordActivities(api);
 		registerDiscordSubagentHooks(api);
+	},
+	registerCapabilities(api) {
 		api.registerTranscriptSourceProvider(discordVoiceTranscriptsSourceProvider);
 	}
 });

package/dist/{message-handler-CxjL-a-8.js → message-handler-Unk_f10F.js}

@@ -1,11 +1,13 @@
 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-DOCKdVgx.js";
-import { w as mapGatewayDispatchData } from "./provider-Ca5Gua1B.js";
-import { f as resolveDiscordMessageChannelId, i as resolveDiscordMessageText, l as hasDiscordMessageStickers } from "./message-utils-DSxXsDcG.js";
+import { c as resolveDiscordChannelInfoSafe, d as resolveDiscordChannelParentSafe, l as resolveDiscordChannelNameSafe, s as resolveDiscordChannelIdSafe } from "./thread-bindings.manager-DCIH6WDC.js";
+import { w as mapGatewayDispatchData } from "./provider-DvSNb-2v.js";
+import { f as resolveDiscordMessageChannelId, i as resolveDiscordMessageText, l as hasDiscordMessageStickers } from "./message-utils-BSCPVgy0.js";
+import { normalizeNullableString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { GatewayDispatchEvents } from "discord-api-types/v10";
+import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { danger } from "openclaw/plugin-sdk/runtime-env";
 import { resolveBatchedReplyThreadingPolicy } from "openclaw/plugin-sdk/reply-reference";
-import { createChannelIngressMonitor, createChannelRunQueue } from "openclaw/plugin-sdk/channel-outbound";
+import { DEFAULT_INGRESS_RETRY_MAX_ATTEMPTS, createChannelIngressError, createChannelIngressMonitor, createChannelRunQueue } from "openclaw/plugin-sdk/channel-outbound";
 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";
@@ -13,25 +15,13 @@ import { createChannelInboundDebouncer, shouldDebounceTextInbound } from "opencl
 //#region extensions/discord/src/monitor/ingress.ts
 const DISCORD_INGRESS_PAYLOAD_VERSION = 1;
 const DISCORD_INGRESS_DRAIN_INTERVAL_MS = 1e3;
-const DISCORD_INGRESS_COMPLETED_TTL_MS = 720 * 60 * 6e4;
-const DISCORD_INGRESS_COMPLETED_MAX_ENTRIES = 5e3;
-const DISCORD_INGRESS_FAILED_TTL_MS = 720 * 60 * 6e4;
-const DISCORD_INGRESS_FAILED_MAX_ENTRIES = 5e3;
-var DiscordIngressPayloadError = class extends Error {
-	constructor(message, options) {
-		super(message, options);
-		this.name = "DiscordIngressPayloadError";
-	}
-};
-function nonEmptyString(value) {
-	return typeof value === "string" && value.trim() ? value.trim() : null;
-}
+const DiscordIngressPayloadError = createChannelIngressError("DiscordIngressPayloadError");
 function inspectDiscordMessage(rawMessage) {
 	if (!rawMessage || typeof rawMessage !== "object" || Array.isArray(rawMessage)) throw new DiscordIngressPayloadError("Discord MESSAGE_CREATE payload must be an object");
 	const candidate = rawMessage;
-	const eventId = nonEmptyString(candidate.id);
+	const eventId = normalizeNullableString(candidate.id);
 	if (!eventId) throw new DiscordIngressPayloadError("Discord MESSAGE_CREATE payload is missing its snowflake");
-	const channelId = nonEmptyString(candidate.channel_id);
+	const channelId = normalizeNullableString(candidate.channel_id);
 	if (!channelId) throw new DiscordIngressPayloadError("Discord MESSAGE_CREATE payload is missing channel_id");
 	return {
 		eventId,
@@ -54,9 +44,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();
@@ -93,13 +80,15 @@ function createDiscordIngressMonitor(params) {
 		pollIntervalMs: DISCORD_INGRESS_DRAIN_INTERVAL_MS,
 		retention: {
 			pruneIntervalMs: 0,
-			completedTtlMs: DISCORD_INGRESS_COMPLETED_TTL_MS,
-			completedMaxEntries: DISCORD_INGRESS_COMPLETED_MAX_ENTRIES,
-			failedTtlMs: DISCORD_INGRESS_FAILED_TTL_MS,
-			failedMaxEntries: DISCORD_INGRESS_FAILED_MAX_ENTRIES
+			completedMaxEntries: 5e3,
+			failedMaxEntries: 5e3
 		},
 		appendRetryDelaysMs: [0],
 		drain: {
+			retryPolicy: {
+				maxAttempts: DEFAULT_INGRESS_RETRY_MAX_ATTEMPTS,
+				deadLetterMinAgeMs: 0
+			},
 			resolveNonRetryableFailure: (error) => {
 				if (error instanceof DiscordIngressPayloadError) return {
 					reason: "invalid-event",
@@ -107,13 +96,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) => {
@@ -125,18 +114,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,
@@ -194,20 +175,21 @@ function applyImplicitReplyBatchGate(ctx, replyToMode, isBatched) {
 }
 //#endregion
 //#region extensions/discord/src/monitor/message-run-queue.ts
-const loadMessageProcessRuntime = createLazyRuntimeModule(() => import("./message-handler.process-W9QxWA1g.js"));
+const loadMessageProcessRuntime = createLazyRuntimeModule(() => import("./message-handler.process-DWQ6UHHu.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();
@@ -245,6 +227,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();
 				}
@@ -254,7 +240,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({
@@ -276,7 +262,7 @@ function createDiscordMessageRunQueue(params) {
 }
 //#endregion
 //#region extensions/discord/src/monitor/message-dispatcher.ts
-const loadMessagePreflightRuntime = createLazyRuntimeModule(() => import("./message-handler.preflight-D-5zBjwh.js"));
+const loadMessagePreflightRuntime = createLazyRuntimeModule(() => import("./message-handler.preflight-C9zecxR9.js"));
 function isNonEmptyString(value) {
 	return typeof value === "string" && value.length > 0;
 }
@@ -297,7 +283,6 @@ function createDiscordMessageDispatcher(params) {
 	const dispatcherShutdown = new AbortController();
 	const pendingDebounceEntries = /* @__PURE__ */ new Set();
 	const pendingCancellationSettlements = /* @__PURE__ */ new Set();
-	const activeDebounceFlushes = /* @__PURE__ */ new Set();
 	const resolveDebounceKey = (entry) => {
 		const message = entry.data.message;
 		const authorId = entry.data.author?.id;
@@ -321,112 +306,110 @@ function createDiscordMessageDispatcher(params) {
 				hasMedia: message.attachments && message.attachments.length > 0 || hasDiscordMessageStickers(message)
 			});
 		},
-		onFlush: async (entries) => {
-			let resolveTrackedFlush;
-			const trackedFlush = new Promise((resolve) => {
-				resolveTrackedFlush = resolve;
-			});
-			activeDebounceFlushes.add(trackedFlush);
-			try {
-				for (const entry of entries) pendingDebounceEntries.delete(entry);
-				const last = entries.at(-1);
-				if (!last) return;
-				const ingress = fanInChannelIngressLifecycles(entries.map((entry) => entry.turnAdoptionLifecycle));
-				const abortSignal = last.abortSignal;
-				if (abortSignal?.aborted) {
-					await ingress.abandon(abortSignal.reason);
-					return;
-				}
-				try {
-					if (entries.length === 1) {
+		onFlush: (entries, createFlush) => {
+			const ingress = fanInChannelIngressLifecycles(entries.map((entry) => entry.turnAdoptionLifecycle));
+			return createFlush({
+				lifecycle: ingress.lifecycle,
+				dispatch: async (admissionLifecycle) => {
+					for (const entry of entries) pendingDebounceEntries.delete(entry);
+					const last = entries.at(-1);
+					if (!last) return;
+					const abortSignal = last.abortSignal;
+					if (abortSignal?.aborted) {
+						await ingress.cancel();
+						return;
+					}
+					try {
+						if (entries.length === 1) {
+							const ctx = await (preflightDiscordMessageImpl ?? (await loadMessagePreflightRuntime()).preflightDiscordMessage)({
+								...params,
+								ackReactionScope,
+								groupPolicy,
+								abortSignal,
+								data: last.data,
+								client: last.client,
+								turnAdoptionLifecycle: admissionLifecycle
+							});
+							if (abortSignal?.aborted) {
+								await ingress.cancel();
+								return;
+							}
+							if (!ctx) {
+								await ingress.settle();
+								return;
+							}
+							applyImplicitReplyBatchGate(ctx, params.replyToMode, false);
+							messageRunQueue.enqueue(buildDiscordInboundJob(ctx, { ingressSettlement: ingress }));
+							return;
+						}
+						const combinedBaseText = entries.map((entry) => resolveDiscordMessageText(entry.data.message, { includeForwarded: false })).filter(Boolean).join("\n");
+						const syntheticMessage = Object.create(Object.getPrototypeOf(last.data.message), {
+							...Object.getOwnPropertyDescriptors(last.data.message),
+							content: {
+								value: combinedBaseText,
+								enumerable: true,
+								configurable: true
+							},
+							attachments: {
+								value: [],
+								enumerable: true,
+								configurable: true
+							},
+							message_snapshots: {
+								value: last.data.message.message_snapshots,
+								enumerable: true,
+								configurable: true
+							},
+							messageSnapshots: {
+								value: last.data.message.messageSnapshots,
+								enumerable: true,
+								configurable: true
+							},
+							rawData: {
+								value: { ...last.data.message.rawData },
+								enumerable: true,
+								configurable: true
+							}
+						});
+						const syntheticData = {
+							...last.data,
+							message: syntheticMessage
+						};
 						const ctx = await (preflightDiscordMessageImpl ?? (await loadMessagePreflightRuntime()).preflightDiscordMessage)({
 							...params,
 							ackReactionScope,
 							groupPolicy,
 							abortSignal,
-							data: last.data,
+							data: syntheticData,
 							client: last.client,
-							turnAdoptionLifecycle: ingress.lifecycle
+							turnAdoptionLifecycle: admissionLifecycle
 						});
 						if (abortSignal?.aborted) {
-							await ingress.abandon(abortSignal.reason);
+							await ingress.cancel();
 							return;
 						}
 						if (!ctx) {
 							await ingress.settle();
 							return;
 						}
-						applyImplicitReplyBatchGate(ctx, params.replyToMode, false);
+						applyImplicitReplyBatchGate(ctx, params.replyToMode, true);
+						const ids = entries.map((entry) => entry.data.message?.id).filter(isNonEmptyString);
+						if (ids.length > 0) {
+							const ctxBatch = ctx;
+							ctxBatch.MessageSids = ids;
+							ctxBatch.MessageSidFirst = ids[0];
+							ctxBatch.MessageSidLast = ids[ids.length - 1];
+						}
 						messageRunQueue.enqueue(buildDiscordInboundJob(ctx, { ingressSettlement: ingress }));
-						return;
-					}
-					const combinedBaseText = entries.map((entry) => resolveDiscordMessageText(entry.data.message, { includeForwarded: false })).filter(Boolean).join("\n");
-					const syntheticMessage = Object.create(Object.getPrototypeOf(last.data.message), {
-						...Object.getOwnPropertyDescriptors(last.data.message),
-						content: {
-							value: combinedBaseText,
-							enumerable: true,
-							configurable: true
-						},
-						attachments: {
-							value: [],
-							enumerable: true,
-							configurable: true
-						},
-						message_snapshots: {
-							value: last.data.message.message_snapshots,
-							enumerable: true,
-							configurable: true
-						},
-						messageSnapshots: {
-							value: last.data.message.messageSnapshots,
-							enumerable: true,
-							configurable: true
-						},
-						rawData: {
-							value: { ...last.data.message.rawData },
-							enumerable: true,
-							configurable: true
+					} catch (error) {
+						if (abortSignal?.aborted) {
+							await ingress.cancel();
+							return;
 						}
-					});
-					const syntheticData = {
-						...last.data,
-						message: syntheticMessage
-					};
-					const ctx = await (preflightDiscordMessageImpl ?? (await loadMessagePreflightRuntime()).preflightDiscordMessage)({
-						...params,
-						ackReactionScope,
-						groupPolicy,
-						abortSignal,
-						data: syntheticData,
-						client: last.client,
-						turnAdoptionLifecycle: ingress.lifecycle
-					});
-					if (abortSignal?.aborted) {
-						await ingress.abandon(abortSignal.reason);
-						return;
-					}
-					if (!ctx) {
-						await ingress.settle();
-						return;
+						throw error;
 					}
-					applyImplicitReplyBatchGate(ctx, params.replyToMode, true);
-					const ids = entries.map((entry) => entry.data.message?.id).filter(isNonEmptyString);
-					if (ids.length > 0) {
-						const ctxBatch = ctx;
-						ctxBatch.MessageSids = ids;
-						ctxBatch.MessageSidFirst = ids[0];
-						ctxBatch.MessageSidLast = ids[ids.length - 1];
-					}
-					messageRunQueue.enqueue(buildDiscordInboundJob(ctx, { ingressSettlement: ingress }));
-				} catch (error) {
-					await ingress.abandon(error);
-					throw error;
 				}
-			} finally {
-				activeDebounceFlushes.delete(trackedFlush);
-				resolveTrackedFlush();
-			}
+			});
 		},
 		onError: (err) => {
 			params.runtime.error(danger(`discord debounce flush failed: ${String(err)}`));
@@ -434,7 +417,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);
@@ -445,10 +428,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 = {
@@ -481,7 +471,7 @@ function createDiscordMessageDispatcher(params) {
 		for (const key of pendingKeys) debouncer.cancelKey(key);
 		pendingDebounceEntries.clear();
 		await Promise.allSettled(pendingCancellationSettlements);
-		await Promise.allSettled(activeDebounceFlushes);
+		await debouncer.drain();
 		await messageRunQueue.deactivate();
 	};
 	return handler;