@openclaw/discord 2026.7.2-beta.4 → 2026.7.2-beta.7

package/dist/{message-handler-1ui-YxsF.js → message-handler-CeiSulIw.js}

@@ -1,36 +1,26 @@
 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-C_tCQcv3.js";
-import { w as mapGatewayDispatchData } from "./provider-CfiChtjf.js";
-import { f as resolveDiscordMessageChannelId, i as resolveDiscordMessageText, l as hasDiscordMessageStickers } from "./message-utils-ajbkdTVA.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 { GatewayDispatchEvents } from "discord-api-types/v10";
 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 { 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";
 import { createChannelInboundDebouncer, shouldDebounceTextInbound } from "openclaw/plugin-sdk/channel-inbound";
 //#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,
@@ -92,10 +82,8 @@ 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: {
@@ -193,7 +181,7 @@ function applyImplicitReplyBatchGate(ctx, replyToMode, isBatched) {
 }
 //#endregion
 //#region extensions/discord/src/monitor/message-run-queue.ts
-const loadMessageProcessRuntime = createLazyRuntimeModule(() => import("./message-handler.process-REBztvIW.js"));
+const loadMessageProcessRuntime = createLazyRuntimeModule(() => import("./message-handler.process-Dnc_oz9y.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 {
@@ -275,51 +263,10 @@ function createDiscordMessageRunQueue(params) {
 }
 //#endregion
 //#region extensions/discord/src/monitor/message-dispatcher.ts
-const loadMessagePreflightRuntime = createLazyRuntimeModule(() => import("./message-handler.preflight-CAEQvP3t.js"));
+const loadMessagePreflightRuntime = createLazyRuntimeModule(() => import("./message-handler.preflight-DibgQFf2.js"));
 function isNonEmptyString(value) {
 	return typeof value === "string" && value.length > 0;
 }
-function buildFlushIngressLifecycle(entries) {
-	const lifecycles = entries.map((entry) => entry.turnAdoptionLifecycle).filter((lifecycle) => lifecycle !== void 0);
-	const [firstLifecycle] = lifecycles;
-	if (!firstLifecycle) return {
-		lifecycle: void 0,
-		settle: async () => {},
-		abandon: async () => {}
-	};
-	let handedOff = false;
-	const adoptAll = async () => {
-		for (const lifecycle of lifecycles) await lifecycle.onAdopted();
-	};
-	return {
-		lifecycle: {
-			abortSignal: lifecycles.length === 1 ? firstLifecycle.abortSignal : AbortSignal.any(lifecycles.map((lifecycle) => lifecycle.abortSignal)),
-			onAdopted: async () => {
-				handedOff = true;
-				await adoptAll();
-			},
-			onDeferred: () => {
-				handedOff = true;
-				for (const lifecycle of lifecycles) lifecycle.onDeferred();
-			},
-			onAdoptionFinalizing: () => {
-				for (const lifecycle of lifecycles) lifecycle.onAdoptionFinalizing();
-			},
-			onAbandoned: async () => {
-				handedOff = true;
-				for (const lifecycle of lifecycles) await lifecycle.onAbandoned();
-			}
-		},
-		settle: async () => {
-			if (!handedOff) await adoptAll();
-		},
-		abandon: async () => {
-			if (handedOff) return;
-			handedOff = true;
-			for (const lifecycle of lifecycles) await lifecycle.onAbandoned();
-		}
-	};
-}
 function createDiscordMessageDispatcher(params) {
 	const { groupPolicy } = resolveOpenProviderRuntimeGroupPolicy({
 		providerConfigPresent: params.cfg.channels?.discord !== void 0,
@@ -337,7 +284,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;
@@ -361,32 +307,83 @@ 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 = buildFlushIngressLifecycle(entries);
-				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 admissionLifecycle.onAbandoned();
+						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.abandon(abortSignal.reason);
+								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);
@@ -396,77 +393,21 @@ function createDiscordMessageDispatcher(params) {
 							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
+						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];
 						}
-					});
-					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;
-					}
-					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 admissionLifecycle.onAbandoned();
+						throw error;
 					}
-					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)}`));
@@ -521,7 +462,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;

package/dist/message-handler.history-CJOsN9w5.js

@@ -0,0 +1,28 @@
+import { filterSupplementalContextItems } from "openclaw/plugin-sdk/security-runtime";
+//#region extensions/discord/src/monitor/message-handler.history.ts
+function createDiscordHistorySenderProvenance(params) {
+	return Object.freeze({
+		id: params.sender.id,
+		name: params.sender.name,
+		tag: params.sender.tag,
+		memberRoleIds: Object.freeze([...params.memberRoleIds])
+	});
+}
+function filterDiscordHistoryEntriesForContext(params) {
+	if (params.mode === "all") return {
+		entries: [...params.entries],
+		omitted: 0
+	};
+	const filtered = filterSupplementalContextItems({
+		items: params.entries,
+		mode: params.mode,
+		kind: "history",
+		isSenderAllowed: (entry) => Boolean(entry.senderProvenance) && params.isSenderAllowed(entry.senderProvenance)
+	});
+	return {
+		entries: filtered.items,
+		omitted: filtered.omitted
+	};
+}
+//#endregion
+export { filterDiscordHistoryEntriesForContext as n, createDiscordHistorySenderProvenance as t };

package/dist/{message-handler.preflight-CAEQvP3t.js → message-handler.preflight-DibgQFf2.js}

@@ -1,12 +1,13 @@
-import { F as Message, bt as getChannelMessage, d as discord_exports } from "./chunk-BrZocpfs.js";
-import { o as resolveDefaultDiscordAccountId } from "./accounts-D2LKPukU.js";
+import { F as Message, bt as getChannelMessage, d as discord_exports } from "./chunk-DX4jpFQP.js";
+import { o as resolveDefaultDiscordAccountId } from "./accounts-DJTf1LtA.js";
 import { C as resolveTimestampMs, S as resolveDiscordSystemLocation, _ as resolveDiscordShouldRequireMention, a as normalizeDiscordSlug, c as resolveDiscordChannelConfigWithFallback, f as resolveDiscordGuildEntry, i as normalizeDiscordDisplaySlug, n as isDiscordGroupAllowedByPolicy, p as resolveDiscordMemberAccessState, v as resolveGroupDmAllow, x as formatDiscordUserTag } from "./allow-list-DzKrtfah.js";
 import { n as DISCORD_ATTACHMENT_TOTAL_TIMEOUT_MS, t as DISCORD_ATTACHMENT_IDLE_TIMEOUT_MS } from "./timeouts-B9cy6RvQ.js";
-import { r as resolveDiscordConversationIdentity } from "./approval-message-safety-LyND6GR3.js";
-import { f as resolveDiscordChannelInfoSafe, p as resolveDiscordChannelNameSafe } from "./thread-bindings.discord-api-C_tCQcv3.js";
-import { C as handleDiscordDmCommandDecision, M as resolveDiscordTextCommandAccess, S as shouldIgnoreStaleDiscordRouteBinding, b as resolveDiscordConversationRoute, j as resolveDiscordDmCommandAccess, x as resolveDiscordEffectiveRoute, y as buildDiscordRoutePeer } from "./provider-CfiChtjf.js";
-import { d as resolveDiscordChannelInfo, f as resolveDiscordMessageChannelId, i as resolveDiscordMessageText, o as resolveForwardedMediaList, r as resolveDiscordMessageHistoryText, s as resolveMediaList, u as resolveDiscordMessageStickers } from "./message-utils-ajbkdTVA.js";
+import { r as resolveDiscordConversationIdentity } from "./approval-message-safety-DEyKVsAw.js";
+import { f as resolveDiscordChannelInfoSafe, p as resolveDiscordChannelNameSafe } from "./thread-bindings.discord-api-BoDNqamb.js";
+import { C as handleDiscordDmCommandDecision, M as resolveDiscordTextCommandAccess, S as shouldIgnoreStaleDiscordRouteBinding, b as resolveDiscordConversationRoute, j as resolveDiscordDmCommandAccess, x as resolveDiscordEffectiveRoute, y as buildDiscordRoutePeer } from "./provider-DfQJX3z5.js";
+import { d as resolveDiscordChannelInfo, f as resolveDiscordMessageChannelId, i as resolveDiscordMessageText, o as resolveForwardedMediaList, r as resolveDiscordMessageHistoryText, s as resolveMediaList, u as resolveDiscordMessageStickers } from "./message-utils-BgTwT_q7.js";
 import { n as resolveDiscordWebhookId, t as resolveDiscordSenderIdentity } from "./sender-identity-mG_zsdox.js";
+import { t as createDiscordHistorySenderProvenance } from "./message-handler.history-CJOsN9w5.js";
 import { normalizeOptionalString, readStringValue } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { logDebug } from "openclaw/plugin-sdk/logging-core";
 import { MessageReferenceType, MessageType } from "discord-api-types/v10";
@@ -18,14 +19,15 @@ import { isRecentOutboundMessageIdentity } from "openclaw/plugin-sdk/channel-out
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 import { isDangerousNameMatchingEnabled } from "openclaw/plugin-sdk/dangerous-name-runtime";
 import { enqueueSystemEvent } from "openclaw/plugin-sdk/system-event-runtime";
-import { buildMentionRegexes, classifyChannelInboundEvent, implicitMentionKindWhen, logInboundDrop, matchesMentionWithExplicit, recordChannelBotPairLoopAndCheckSuppression, recordDroppedChannelInboundHistory, resolveInboundMentionDecision, resolveUnmentionedGroupInboundPolicy, toInboundMediaFacts } from "openclaw/plugin-sdk/channel-inbound";
+import { buildMentionRegexes, classifyChannelInboundEvent, implicitMentionKindWhen, logInboundDrop, matchesMentionWithExplicit, recordChannelBotPairLoopAndCheckSuppression, resolveInboundMentionDecision, resolveUnmentionedGroupInboundPolicy, toHistoryMediaEntries, toInboundMediaFactsWithMetadata } from "openclaw/plugin-sdk/channel-inbound";
 import { mimeTypeFromFilePath } from "openclaw/plugin-sdk/media-mime";
 import { hasControlCommand } from "openclaw/plugin-sdk/command-detection";
 import { isAbortRequestText } from "openclaw/plugin-sdk/command-primitives-runtime";
 import { shouldHandleTextCommands } from "openclaw/plugin-sdk/command-surface";
+import { createChannelHistoryWindow } from "openclaw/plugin-sdk/reply-history";
 //#region extensions/discord/src/monitor/message-handler.dm-preflight.ts
 const loadConversationRuntime$1 = createLazyRuntimeModule(() => import("openclaw/plugin-sdk/conversation-binding-runtime"));
-const loadDiscordSendRuntime = createLazyRuntimeModule(() => import("./send-CfnXLUXq.js").then((n) => n.t));
+const loadDiscordSendRuntime = createLazyRuntimeModule(() => import("./send-CdkZ6zeW.js").then((n) => n.t));
 function resolveDiscordDmPairingSenderId(sender) {
 	return sender.isPluralKit ? `pk:${sender.id}` : sender.id;
 }
@@ -194,15 +196,20 @@ function shouldHydrateDiscordMessagePayload(params) {
 	if ((params.message.mentionedUsers?.length ?? 0) > 0 || (params.message.mentionedRoles?.length ?? 0) > 0 || params.message.mentionedEveryone) return false;
 	return /<@!?\d+>|<@&\d+>|@everyone|@here/u.test(currentText);
 }
-function hasMissingReferencedMessagePayload(message) {
+function resolveReferencedMessagePayloadState(message) {
 	const reference = message.messageReference;
-	if (!reference?.message_id) return false;
-	if (reference.type != null && reference.type !== MessageReferenceType.Default) return false;
-	if (message.type != null && message.type !== MessageType.Reply) return false;
-	return !Object.hasOwn(readMessageRawData(message), "referenced_message");
+	if (!reference?.message_id) return "complete";
+	if (reference.type != null && reference.type !== MessageReferenceType.Default) return "complete";
+	if (message.type != null && message.type !== MessageType.Reply) return "complete";
+	const rawData = readMessageRawData(message);
+	if (!Object.hasOwn(rawData, "referenced_message")) return "missing";
+	const referenced = rawData.referenced_message;
+	if (referenced == null) return "complete";
+	return typeof referenced === "object" && typeof referenced.id === "string" && referenced.id === reference.message_id ? "complete" : "invalid";
 }
 async function hydrateDiscordReplyReference(params) {
-	if (!hasMissingReferencedMessagePayload(params.message)) return params.message;
+	const payloadState = resolveReferencedMessagePayloadState(params.message);
+	if (payloadState === "complete") return params.message;
 	const reference = params.message.messageReference;
 	const referencedMessageId = reference?.message_id;
 	if (!referencedMessageId) return params.message;
@@ -215,6 +222,10 @@ async function hydrateDiscordReplyReference(params) {
 		});
 	} catch (err) {
 		logVerbose(`discord: failed to hydrate referenced message ${referencedMessageId}: ${String(err)}`);
+		if (payloadState === "invalid") return mergeFetchedDiscordMessage(params.message, {
+			...readMessageRawData(params.message),
+			referenced_message: null
+		});
 		return params.message;
 	}
 }
@@ -445,7 +456,11 @@ function buildDiscordPreflightHistoryEntry(params) {
 		sender: params.senderLabel,
 		body: textForHistory,
 		timestamp: resolveTimestampMs(params.message.timestamp),
-		messageId: params.message.id
+		messageId: params.message.id,
+		senderProvenance: createDiscordHistorySenderProvenance({
+			sender: params.sender,
+			memberRoleIds: params.memberRoleIds
+		})
 	} : void 0;
 }
 //#endregion
@@ -460,17 +475,17 @@ function logDiscordPreflightInboundSummary(params) {
 }
 //#endregion
 //#region extensions/discord/src/monitor/message-handler.preflight-runtime.ts
-const loadPluralKitRuntime = createLazyRuntimeModule(() => import("./pluralkit-CCovPs9s.js").then((n) => n.n));
+const loadPluralKitRuntime = createLazyRuntimeModule(() => import("./pluralkit-CD4B11JB.js").then((n) => n.n));
 const loadPreflightAudioRuntime = createLazyRuntimeModule(() => import("./preflight-audio-BjnQZ5yS.js"));
-const loadSystemEventsRuntime = createLazyRuntimeModule(() => import("./system-events-BSlhBq3u.js"));
-const loadDiscordThreadingRuntime = createLazyRuntimeModule(() => import("./provider-CfiChtjf.js").then((n) => n.E));
+const loadSystemEventsRuntime = createLazyRuntimeModule(() => import("./system-events-DdUqf91B.js"));
+const loadDiscordThreadingRuntime = createLazyRuntimeModule(() => import("./provider-DfQJX3z5.js").then((n) => n.E));
 function isPreflightAborted(abortSignal) {
 	return Boolean(abortSignal?.aborted);
 }
 //#endregion
 //#region extensions/discord/src/monitor/message-handler.preflight-pluralkit.ts
 async function resolveDiscordPreflightPluralKitInfo(params) {
-	if (!params.config?.enabled) return null;
+	if (!params.config?.enabled || !params.webhookId) return null;
 	try {
 		const { fetchPluralKitMessageInfo } = await loadPluralKitRuntime();
 		const info = await fetchPluralKitMessageInfo({
@@ -626,51 +641,31 @@ async function resolveDiscordHistoryMediaForPendingRecord(params) {
 		abortSignal: params.preflight.abortSignal
 	});
 	const stickerStartIndex = Math.max(0, mediaList.length - stickers.length);
-	return toInboundMediaFacts(mediaList, { messageId: params.message.id }).map((media, index) => ({
+	return (await toInboundMediaFactsWithMetadata(mediaList, { messageId: params.message.id })).map((media, index) => ({
 		path: media.path,
 		url: media.url,
 		contentType: media.contentType,
 		kind: index >= stickerStartIndex ? "sticker" : media.kind ?? "image",
+		durationMs: media.durationMs,
+		width: media.width,
+		height: media.height,
 		transcribed: media.transcribed,
 		messageId: media.messageId
 	}));
 }
 async function recordDiscordPendingHistoryEntry(params) {
-	if (params.preflight.historyLimit <= 0) return;
-	await recordDroppedChannelInboundHistory({
-		input: {
-			id: params.message.id,
-			timestamp: params.entry?.timestamp,
-			rawText: params.entry?.body ?? "",
-			textForAgent: params.entry?.body,
-			raw: params.message
-		},
-		admission: {
-			kind: "drop",
-			reason: "discord-preflight",
-			recordHistory: true
-		},
-		preflight: {
-			message: params.entry ? {
-				rawBody: params.entry.body,
-				body: params.entry.body,
-				bodyForAgent: params.entry.body,
-				senderLabel: params.entry.sender,
-				envelopeFrom: params.entry.sender
-			} : void 0,
-			history: {
-				key: params.historyKey,
-				historyMap: params.preflight.guildHistories,
-				limit: params.preflight.historyLimit,
-				recordOnDrop: true,
-				mediaLimit: DISCORD_HISTORY_MEDIA_MAX_ATTACHMENTS,
-				shouldRecord: () => !isPreflightAborted(params.preflight.abortSignal)
-			},
-			media: () => resolveDiscordHistoryMediaForPendingRecord({
-				preflight: params.preflight,
-				message: params.message
-			})
-		}
+	if (!params.entry || params.preflight.historyLimit <= 0) return;
+	await createChannelHistoryWindow({ historyMap: params.preflight.guildHistories }).recordWithMedia({
+		historyKey: params.historyKey,
+		entry: params.entry,
+		limit: params.preflight.historyLimit,
+		mediaLimit: DISCORD_HISTORY_MEDIA_MAX_ATTACHMENTS,
+		messageId: params.message.id,
+		shouldRecord: () => !isPreflightAborted(params.preflight.abortSignal),
+		media: async () => toHistoryMediaEntries(await resolveDiscordHistoryMediaForPendingRecord({
+			preflight: params.preflight,
+			message: params.message
+		}), { messageId: params.message.id })
 	});
 }
 async function preflightDiscordMessage(params) {
@@ -743,6 +738,7 @@ async function preflightDiscordMessage(params) {
 	}
 	const pluralkitInfo = await resolveDiscordPreflightPluralKitInfo({
 		message,
+		webhookId,
 		config: pluralkitConfig,
 		abortSignal: params.abortSignal
 	});
@@ -895,7 +891,9 @@ async function preflightDiscordMessage(params) {
 		isGuildMessage,
 		historyLimit: params.historyLimit,
 		message,
-		senderLabel: sender.label
+		senderLabel: sender.label,
+		sender,
+		memberRoleIds
 	});
 	const threadOwnerId = threadChannel ? resolveDiscordChannelInfoSafe(threadChannel).ownerId ?? channelInfo?.ownerId : void 0;
 	const shouldRequireMentionByConfig = resolveDiscordShouldRequireMention({