@openclaw/discord 2026.7.2-beta.3 → 2026.7.2-beta.5

package/dist/{message-handler.process-BK0mjFJH.js → message-handler.process-W9QxWA1g.js}

@@ -1,22 +1,24 @@
-import { d as discord_exports, gt as deleteChannelMessage, pt as createChannelMessage, t as chunkDiscordTextWithMode, u as resolveDiscordChannelId, vt as editChannelMessage } from "./chunk-CWzmeWf_.js";
-import { f as resolveDiscordMaxLinesPerMessage } from "./accounts-CMd4nzLB.js";
-import { F as createDiscordRestClient, I as createDiscordRuntimeAccountContext, _ as resolveDiscordMessageFlags, d as resolveDiscordTargetChannelId } from "./send.shared-Dber6X57.js";
+import { d as discord_exports, gt as deleteChannelMessage, pt as createChannelMessage, t as chunkDiscordTextWithMode, u as resolveDiscordChannelId, vt as editChannelMessage } from "./chunk-CMVEczdm.js";
+import { f as resolveDiscordMaxLinesPerMessage } from "./accounts-DJTf1LtA.js";
+import { F as createDiscordRestClient, I as createDiscordRuntimeAccountContext, _ as resolveDiscordMessageFlags, d as resolveDiscordTargetChannelId } from "./send.shared-BRGI9T9F.js";
 import { C as resolveTimestampMs, a as normalizeDiscordSlug, r as normalizeDiscordAllowList } from "./allow-list-DzKrtfah.js";
-import { i as discordTextHasBroadcastMention } from "./send.outbound-C1SfX20w.js";
-import { s as editMessageDiscord } from "./send-CSRxNNgq.js";
+import { i as discordTextHasBroadcastMention } from "./send.outbound-1t1CryCK.js";
+import { s as editMessageDiscord } from "./send-C_PfNVFH.js";
 import { n as DISCORD_ATTACHMENT_TOTAL_TIMEOUT_MS, t as DISCORD_ATTACHMENT_IDLE_TIMEOUT_MS } from "./timeouts-B9cy6RvQ.js";
-import { i as removeReactionDiscord, n as reactMessageDiscord } from "./send.reactions-Cj4ugX3F.js";
-import "./targets-BjEMIe8t.js";
-import { r as resolveDiscordConversationIdentity } from "./approval-message-safety-DrLlgIPz.js";
+import { i as removeReactionDiscord, n as reactMessageDiscord } from "./send.reactions-gesJG-Yp.js";
+import "./targets-DqNz_mmW.js";
+import { r as resolveDiscordConversationIdentity } from "./approval-message-safety-yjFtfJcK.js";
 import { t as beginDiscordInboundEventDeliveryCorrelation } from "./inbound-event-delivery-CEPlt2uz.js";
-import { t as DISCORD_TEXT_CHUNK_LIMIT } from "./outbound-adapter-B2_oa-zV.js";
-import { E as resolveDiscordAutoThreadReplyPlan, O as resolveDiscordThreadStarter, _ as createDiscordSupplementalContextAccessChecker, a as buildDirectLabel, g as buildDiscordInboundAccessContext, i as sanitizeDiscordFrontChannelReplyPayloads, n as deliverDiscordReply, o as buildGuildLabel, r as formatDiscordReplyDeliveryFailure, s as resolveReplyContext } from "./provider-HW0G-2l6.js";
-import { r as resolveDiscordMessageText, s as resolveReferencedReplyMediaList } from "./message-utils-Cfe6CZ6N.js";
-import { t as sendTyping } from "./typing-wxtm1NlF.js";
+import { t as DISCORD_TEXT_CHUNK_LIMIT } from "./outbound-adapter-kse7KV--.js";
+import { D as resolveDiscordAutoThreadReplyPlan, _ as buildDiscordInboundAccessContext, a as sanitizeDiscordFrontChannelReplyPayloads, c as resolveReplyContext, i as formatDiscordReplySkip, k as resolveDiscordThreadStarter, n as deliverDiscordReply, o as buildDirectLabel, r as formatDiscordReplyDeliveryFailure, s as buildGuildLabel, v as createDiscordSupplementalContextAccessChecker } from "./provider-Ca5Gua1B.js";
+import { a as formatDiscordMediaText, c as resolveReferencedReplyMediaList, i as resolveDiscordMessageText, u as resolveDiscordMessageStickers } from "./message-utils-DSxXsDcG.js";
+import { n as resolveDiscordWebhookId } from "./sender-identity-mG_zsdox.js";
+import { n as filterDiscordHistoryEntriesForContext, t as createDiscordHistorySenderProvenance } from "./message-handler.history-CJOsN9w5.js";
+import { t as sendTyping } from "./typing-eAhz8LT2.js";
 import { buildAgentSessionKey, resolveThreadSessionKeys } from "openclaw/plugin-sdk/routing";
 import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
-import { danger, logVerbose, shouldLogVerbose, sleep, sleepWithAbort } from "openclaw/plugin-sdk/runtime-env";
+import { danger, logVerbose, shouldLogVerbose, sleepWithAbort } from "openclaw/plugin-sdk/runtime-env";
 import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import { resolveMarkdownTableMode } from "openclaw/plugin-sdk/markdown-table-runtime";
 import { resolveChunkMode } from "openclaw/plugin-sdk/reply-chunking";
@@ -26,50 +28,14 @@ import { getAgentScopedMediaLocalRoots } from "openclaw/plugin-sdk/media-runtime
 import { getReplyPayloadTtsSupplement, isReplyPayloadNonTerminalToolErrorWarning, resolveSendableOutboundReplyParts } from "openclaw/plugin-sdk/reply-payload";
 import { evaluateSupplementalContextVisibility } from "openclaw/plugin-sdk/security-runtime";
 import { resolvePinnedMainDmOwnerFromAllowlist } from "openclaw/plugin-sdk/conversation-runtime";
-import { EmbeddedBlockChunker, resolveAckReaction, resolveHumanDelayConfig } from "openclaw/plugin-sdk/agent-runtime";
+import { EmbeddedBlockChunker, resolveAckReaction, resolveAgentConfig, resolveHumanDelayConfig } from "openclaw/plugin-sdk/agent-runtime";
 import { isDangerousNameMatchingEnabled } from "openclaw/plugin-sdk/dangerous-name-runtime";
-import { getSessionEntry, readSessionUpdatedAt, resolveStorePath } from "openclaw/plugin-sdk/session-store-runtime";
 import { buildChannelInboundEventContext, dispatchChannelInboundTurn, formatInboundEnvelope, hasFinalInboundReplyDispatch, resolveEnvelopeFormatOptions, toHistoryMediaEntries, toInboundMediaFacts } from "openclaw/plugin-sdk/channel-inbound";
+import { getSessionEntry, readSessionUpdatedAt, resolveStorePath } from "openclaw/plugin-sdk/session-store-runtime";
+import { buildHistoryContextFromEntries, buildInboundHistoryFromEntries, createChannelHistoryWindow } from "openclaw/plugin-sdk/reply-history";
+import { resolveChannelContextVisibilityMode } from "openclaw/plugin-sdk/context-visibility-runtime";
 import { DEFAULT_TIMING, createStatusReactionController, logAckFailure, logTypingFailure, shouldAckReaction } from "openclaw/plugin-sdk/channel-feedback";
-import { createChannelHistoryWindow } from "openclaw/plugin-sdk/reply-history";
 import { readLatestAssistantTextByIdentity } from "openclaw/plugin-sdk/session-transcript-runtime";
-import { resolveChannelContextVisibilityMode } from "openclaw/plugin-sdk/context-visibility-runtime";
-//#region extensions/discord/src/monitor/ack-reactions.ts
-function createDiscordAckReactionContext(params) {
-	return {
-		rest: params.rest,
-		...createDiscordRuntimeAccountContext({
-			cfg: params.cfg,
-			accountId: params.accountId
-		})
-	};
-}
-function createDiscordAckReactionAdapter(params) {
-	return {
-		setReaction: async (emoji) => {
-			await reactMessageDiscord(params.channelId, params.messageId, emoji, params.reactionContext);
-		},
-		removeReaction: async (emoji) => {
-			await removeReactionDiscord(params.channelId, params.messageId, emoji, params.reactionContext);
-		}
-	};
-}
-function queueInitialDiscordAckReaction(params) {
-	if (params.enabled) {
-		params.statusReactions.setQueued();
-		return;
-	}
-	if (!params.shouldSendAckReaction || !params.ackReaction) return;
-	params.reactionAdapter.setReaction(params.ackReaction).catch((err) => {
-		logAckFailure({
-			log: logVerbose,
-			channel: "discord",
-			target: params.target,
-			error: err
-		});
-	});
-}
-//#endregion
 //#region extensions/discord/src/monitor/message-handler.retry.ts
 const REPLY_SESSION_INIT_CONFLICT_MESSAGE_RE = /^reply session initialization conflicted for \S+$/u;
 const DISCORD_SESSION_CONFLICT_FAILURE_TEXT = "⚠️ Couldn't process this message because the session stayed busy. Please try again in a moment.";
@@ -125,7 +91,7 @@ async function buildDiscordMessageProcessContext(params) {
 	const groupChannel = isGuildMessage && displayChannelSlug ? `#${displayChannelSlug}` : void 0;
 	const senderName = sender.isPluralKit ? sender.name ?? author.username : data.member?.nickname ?? author.globalName ?? author.username;
 	const senderUsername = sender.isPluralKit ? sender.tag ?? sender.name ?? author.username : author.username;
-	const { groupSystemPrompt, ownerAllowFrom, untrustedContext } = buildDiscordInboundAccessContext({
+	const { groupSystemPrompt, ownerAllowFrom, channelStructuredContext } = buildDiscordInboundAccessContext({
 		channelConfig,
 		guildInfo,
 		sender: {
@@ -160,6 +126,7 @@ async function buildDiscordMessageProcessContext(params) {
 		sessionKey: route.sessionKey
 	});
 	const channelHistory = createChannelHistoryWindow({ historyMap: guildHistories });
+	let visibleChannelHistory;
 	let combinedBody = formatInboundEnvelope({
 		channel: "Discord",
 		from: fromLabel,
@@ -173,20 +140,29 @@ async function buildDiscordMessageProcessContext(params) {
 	const shouldIncludeChannelHistory = !isDirectMessage && (ctx.inboundEventKind === "room_event" || !(isGuildMessage && channelConfig?.autoThread && !threadChannel));
 	if (shouldIncludeChannelHistory) {
 		removeDiscordReplayHistoryEntry(guildHistories, messageChannelId, message.id);
-		combinedBody = channelHistory.buildPendingContext({
-			historyKey: messageChannelId,
-			limit: historyLimit,
-			currentMessage: combinedBody,
-			formatEntry: (entry) => formatInboundEnvelope({
-				channel: "Discord",
-				from: fromLabel,
-				timestamp: entry.timestamp,
-				body: `${entry.body} [id:${entry.messageId ?? "unknown"} channel:${messageChannelId}]`,
-				chatType: "channel",
-				senderLabel: entry.sender,
-				envelope: envelopeOptions
-			})
-		});
+		if (historyLimit > 0) {
+			const filteredHistory = filterDiscordHistoryEntriesForContext({
+				entries: guildHistories.get(messageChannelId) ?? [],
+				mode: contextVisibilityMode,
+				isSenderAllowed: isSupplementalContextSenderAllowed
+			});
+			visibleChannelHistory = filteredHistory.entries;
+			if (filteredHistory.omitted > 0) logVerbose(`discord: omit ${filteredHistory.omitted} pending history entries (mode=${contextVisibilityMode})`);
+			combinedBody = buildHistoryContextFromEntries({
+				entries: visibleChannelHistory,
+				currentMessage: combinedBody,
+				formatEntry: (entry) => formatInboundEnvelope({
+					channel: "Discord",
+					from: fromLabel,
+					timestamp: entry.timestamp,
+					body: `${entry.body} [id:${entry.messageId ?? "unknown"} channel:${messageChannelId}]`,
+					chatType: "channel",
+					senderLabel: entry.sender,
+					envelope: envelopeOptions
+				}),
+				excludeLast: false
+			});
+		}
 	}
 	const replyContext = resolveReplyContext(message, resolveDiscordMessageText);
 	const replySenderAllowed = replyContext ? isSupplementalContextSenderAllowed({
@@ -282,8 +258,8 @@ async function buildDiscordMessageProcessContext(params) {
 		return null;
 	}
 	const lastRouteTo = dmConversationTarget ?? effectiveTo;
-	const inboundHistory = shouldIncludeChannelHistory ? channelHistory.buildInboundHistory({
-		historyKey: messageChannelId,
+	const inboundHistory = shouldIncludeChannelHistory ? buildInboundHistoryFromEntries({
+		entries: visibleChannelHistory ?? [],
 		limit: historyLimit
 	}) : void 0;
 	const originatingTo = autoThreadContext?.OriginatingTo ?? dmConversationTarget ?? replyTarget;
@@ -340,6 +316,7 @@ async function buildDiscordMessageProcessContext(params) {
 			commandBody: preflightAudioTranscript ?? baseText,
 			inboundHistory
 		},
+		sessionTranscript: { historyLimit: shouldIncludeChannelHistory ? historyLimit : 0 },
 		access: {
 			mentions: {
 				canDetectMention: ctx.canDetectMention,
@@ -387,23 +364,33 @@ async function buildDiscordMessageProcessContext(params) {
 			GroupSubject: isDirectMessage ? void 0 : groupChannel,
 			GroupChannel: groupChannel,
 			...isGuildMessage ? { GroupRequireMention: ctx.groupRequireMention } : {},
-			UntrustedStructuredContext: untrustedContext,
+			ChannelStructuredContext: channelStructuredContext,
 			OwnerAllowFrom: ownerAllowFrom
 		}
 	});
 	const persistedSessionKey = ctxPayload.SessionKey ?? route.sessionKey;
-	if (ctx.inboundEventKind === "room_event" && shouldIncludeChannelHistory) await channelHistory.recordWithMedia({
-		historyKey: messageChannelId,
-		limit: historyLimit,
-		entry: {
-			sender: senderName,
-			body: text,
-			timestamp: resolveTimestampMs(message.timestamp),
+	if (ctx.inboundEventKind === "room_event" && shouldIncludeChannelHistory) {
+		const historyText = [text, formatDiscordMediaText({
+			attachments: message.attachments ?? void 0,
+			stickers: resolveDiscordMessageStickers(message)
+		})].filter(Boolean).join("\n");
+		await channelHistory.recordWithMedia({
+			historyKey: messageChannelId,
+			limit: historyLimit,
+			entry: {
+				sender: senderName,
+				body: historyText,
+				timestamp: resolveTimestampMs(message.timestamp),
+				messageId: message.id,
+				senderProvenance: createDiscordHistorySenderProvenance({
+					sender,
+					memberRoleIds
+				})
+			},
+			media: toHistoryMediaEntries(mediaList, { messageId: message.id }),
 			messageId: message.id
-		},
-		media: toHistoryMediaEntries(mediaList, { messageId: message.id }),
-		messageId: message.id
-	});
+		});
+	}
 	if (shouldLogVerbose()) {
 		const preview = truncateUtf16Safe(combinedBody, 200).replace(/\n/g, "\\n");
 		logVerbose(`discord inbound: channel=${messageChannelId} deliver=${deliverTarget} from=${ctxPayload.From} preview="${preview}"`);
@@ -439,6 +426,410 @@ async function buildDiscordMessageProcessContext(params) {
 	};
 }
 //#endregion
+//#region extensions/discord/src/monitor/message-handler.process-progress.ts
+function isProcessAborted$1(abortSignal) {
+	return Boolean(abortSignal?.aborted);
+}
+function isFailedProgress(payload) {
+	return payload.phase === "error" || payload.status === "failed" || payload.status === "error" || typeof payload.exitCode === "number" && payload.exitCode !== 0;
+}
+function createDiscordMessageProgressRuntime(params) {
+	const { ctx, draftPreview } = params;
+	const { cfg, discordConfig, route, abortSignal } = ctx;
+	const reasoningLevel = (() => {
+		const normalizedAgentId = (route.agentId ?? "").trim().toLowerCase() || "main";
+		const cfgDefault = cfg.agents?.list?.find((entry) => ((entry?.id ?? "").trim().toLowerCase() || "main") === normalizedAgentId)?.reasoningDefault ?? cfg.agents?.defaults?.reasoningDefault;
+		const configDefault = cfgDefault === "on" || cfgDefault === "stream" ? cfgDefault : "off";
+		if (!params.sessionKey) return configDefault;
+		try {
+			const storePath = resolveStorePath(cfg.session?.store, { agentId: route.agentId });
+			const level = getSessionEntry({
+				agentId: route.agentId,
+				sessionKey: params.sessionKey,
+				storePath
+			})?.reasoningLevel;
+			if (level === "on" || level === "stream" || level === "off") return level;
+		} catch {
+			return "off";
+		}
+		return configDefault;
+	})();
+	const reasoningDurableEnabled = reasoningLevel === "on";
+	const reasoningWindowEnabled = reasoningLevel === "stream";
+	let shouldYieldDraftProgress = () => false;
+	let progressTurnStartedAt = Date.now();
+	let progressReasoningSteps = 0;
+	let progressToolCalls = 0;
+	let progressCommentaryNotes = 0;
+	const seenCommentaryIds = /* @__PURE__ */ new Set();
+	let lastCommentaryNoteText = "";
+	const noteWindowCommentary = (itemId, noteText) => {
+		const trimmed = noteText?.trim();
+		if (!trimmed) return;
+		if (itemId) {
+			if (seenCommentaryIds.has(itemId)) return;
+			seenCommentaryIds.add(itemId);
+			progressCommentaryNotes += 1;
+			return;
+		}
+		if (trimmed !== lastCommentaryNoteText) {
+			lastCommentaryNoteText = trimmed;
+			progressCommentaryNotes += 1;
+		}
+	};
+	let windowReasoningOpen = false;
+	const closePendingWindowThought = () => {
+		if (windowReasoningOpen) {
+			windowReasoningOpen = false;
+			progressReasoningSteps += 1;
+		}
+	};
+	const resetTurnState = () => {
+		progressTurnStartedAt = Date.now();
+		progressReasoningSteps = 0;
+		progressToolCalls = 0;
+		progressCommentaryNotes = 0;
+		seenCommentaryIds.clear();
+		lastCommentaryNoteText = "";
+		windowReasoningOpen = false;
+	};
+	const handleAssistantMessageBoundary = () => {
+		if (draftPreview.handleAssistantMessageBoundary()) {
+			resetTurnState();
+			params.onTurnReset();
+		}
+	};
+	const buildProgressSummaryLine = () => {
+		closePendingWindowThought();
+		const seconds = Math.max(1, Math.round((Date.now() - progressTurnStartedAt) / 1e3));
+		return `-# ${[
+			...progressReasoningSteps > 0 ? [`🧠 ${progressReasoningSteps} thought${progressReasoningSteps === 1 ? "" : "s"}`] : [],
+			...progressCommentaryNotes > 0 ? [`💬 ${progressCommentaryNotes} note${progressCommentaryNotes === 1 ? "" : "s"}`] : [],
+			...progressToolCalls > 0 ? [`🛠️ ${progressToolCalls} tool call${progressToolCalls === 1 ? "" : "s"}`] : [],
+			`⏱️ ${seconds}s`
+		].join(" · ")}`;
+	};
+	return {
+		replyOptions: {
+			onAssistantMessageStart: draftPreview.draftStream ? handleAssistantMessageBoundary : void 0,
+			onReasoningEnd: draftPreview.draftStream ? () => {
+				closePendingWindowThought();
+				handleAssistantMessageBoundary();
+			} : void 0,
+			suppressDefaultToolProgressMessages: params.sourceRepliesAreToolOnly && params.reactions.statusReactionsExplicitlyEnabled || draftPreview.suppressDefaultToolProgressMessages ? true : void 0,
+			allowToolLifecycleWhenProgressHidden: params.reactions.statusReactionsEnabled ? true : void 0,
+			commentaryProgressEnabled: draftPreview.isProgressMode ? draftPreview.commentaryProgressEnabled : void 0,
+			progressPreambleEnabled: draftPreview.draftStream && draftPreview.isProgressMode ? true : void 0,
+			commentaryPayloadsEnabled: draftPreview.isProgressMode ? draftPreview.commentaryProgressEnabled : void 0,
+			reasoningPayloadsEnabled: reasoningDurableEnabled,
+			onVerboseProgressVisibility: (isActive) => {
+				shouldYieldDraftProgress = isActive;
+			},
+			onNarrationUpdate: draftPreview.narrationProgressEnabled ? async (payload) => {
+				if (isProcessAborted$1(abortSignal) || shouldYieldDraftProgress()) return;
+				await draftPreview.pushNarrationProgress(payload.text);
+			} : void 0,
+			onProgressNarratorLifecycle: draftPreview.narrationProgressEnabled ? (lifecycle) => draftPreview.setProgressNarratorLifecycle(lifecycle) : void 0,
+			isProgressDraftVisible: draftPreview.narrationProgressEnabled ? () => draftPreview.isProgressDraftVisible : void 0,
+			narrationHideCommandText: draftPreview.narrationHideCommandText ? true : void 0,
+			onReasoningStream: async (payload) => {
+				if (payload?.requiresReasoningProgressOptIn === true && !reasoningWindowEnabled) return;
+				if (payload?.text) windowReasoningOpen = true;
+				await params.reactions.controller.setThinking();
+				await draftPreview.pushReasoningProgress(payload?.text, { snapshot: payload?.isReasoningSnapshot === true });
+			},
+			streamReasoningInNonStreamModes: reasoningWindowEnabled,
+			onToolStart: async (payload) => {
+				if (isProcessAborted$1(abortSignal)) return;
+				await params.reactions.maybeBindToToolReaction(payload);
+				await params.reactions.controller.setTool(payload.name);
+				if (payload.phase === "start") closePendingWindowThought();
+				if (shouldYieldDraftProgress()) return;
+				if (payload.phase === "start" && isChannelProgressDraftWorkToolName(payload.name)) progressToolCalls += 1;
+				await draftPreview.pushToolProgress(buildChannelProgressDraftLineForEntry(discordConfig, {
+					event: "tool",
+					itemId: payload.itemId,
+					toolCallId: payload.toolCallId,
+					name: payload.name,
+					phase: payload.phase,
+					args: payload.args
+				}, payload.detailMode ? { detailMode: payload.detailMode } : void 0), { toolName: payload.name });
+			},
+			onItemEvent: async (payload) => {
+				if (isFailedProgress(payload)) return false;
+				if (payload.kind === "preamble") {
+					if (shouldYieldDraftProgress()) return;
+					return await draftPreview.pushPreambleItemEvent(payload, noteWindowCommentary);
+				}
+				if (shouldYieldDraftProgress()) return;
+				await draftPreview.pushToolProgress(buildChannelProgressDraftLineForEntry(discordConfig, {
+					event: "item",
+					itemId: payload.itemId,
+					toolCallId: payload.toolCallId,
+					itemKind: payload.kind,
+					title: payload.title,
+					name: payload.name,
+					phase: payload.phase,
+					status: payload.status,
+					summary: payload.summary,
+					progressText: payload.progressText,
+					meta: payload.meta
+				}));
+			},
+			onPlanUpdate: async (payload) => {
+				if (payload.phase === "update") await draftPreview.pushPlanProgress(payload.steps, { explanation: payload.explanation });
+			},
+			onApprovalEvent: async (payload) => {
+				if (payload.phase === "requested") await draftPreview.pushToolProgress(buildChannelProgressDraftLine({
+					event: "approval",
+					phase: payload.phase,
+					title: payload.title,
+					command: payload.command,
+					reason: payload.reason,
+					message: payload.message
+				}));
+			},
+			onCommandOutput: async (payload) => {
+				if (isFailedProgress(payload)) return false;
+				if (payload.phase !== "end" || shouldYieldDraftProgress()) return;
+				await draftPreview.pushToolProgress(buildChannelProgressDraftLine({
+					event: "command-output",
+					itemId: payload.itemId,
+					toolCallId: payload.toolCallId,
+					phase: payload.phase,
+					title: payload.title,
+					name: payload.name,
+					status: payload.status,
+					exitCode: payload.exitCode
+				}));
+			},
+			onPatchSummary: async (payload) => {
+				if (payload.phase !== "end" || shouldYieldDraftProgress()) return;
+				await draftPreview.pushToolProgress(buildChannelProgressDraftLine({
+					event: "patch",
+					itemId: payload.itemId,
+					toolCallId: payload.toolCallId,
+					phase: payload.phase,
+					title: payload.title,
+					name: payload.name,
+					added: payload.added,
+					modified: payload.modified,
+					deleted: payload.deleted,
+					summary: payload.summary
+				}));
+			},
+			onCompactionStart: async () => {
+				if (!isProcessAborted$1(abortSignal)) await params.reactions.controller.setCompacting();
+			},
+			onCompactionEnd: async () => {
+				if (!isProcessAborted$1(abortSignal)) {
+					params.reactions.controller.cancelPending();
+					await params.reactions.controller.setThinking();
+				}
+			}
+		},
+		buildProgressSummaryLine
+	};
+}
+//#endregion
+//#region extensions/discord/src/monitor/ack-reactions.ts
+function createDiscordAckReactionContext(params) {
+	return {
+		rest: params.rest,
+		...createDiscordRuntimeAccountContext({
+			cfg: params.cfg,
+			accountId: params.accountId
+		})
+	};
+}
+function createDiscordAckReactionAdapter(params) {
+	return {
+		setReaction: async (emoji) => {
+			await reactMessageDiscord(params.channelId, params.messageId, emoji, params.reactionContext);
+		},
+		removeReaction: async (emoji) => {
+			await removeReactionDiscord(params.channelId, params.messageId, emoji, params.reactionContext);
+		}
+	};
+}
+function queueInitialDiscordAckReaction(params) {
+	if (params.enabled) {
+		params.statusReactions.setQueued();
+		return;
+	}
+	if (!params.shouldSendAckReaction || !params.ackReaction) return;
+	params.reactionAdapter.setReaction(params.ackReaction).catch((err) => {
+		logAckFailure({
+			log: logVerbose,
+			channel: "discord",
+			target: params.target,
+			error: err
+		});
+	});
+}
+//#endregion
+//#region extensions/discord/src/monitor/message-handler.process-reactions.ts
+function readToolStringArg(args, key) {
+	const value = args[key];
+	return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function readToolBooleanArg(args, key) {
+	return args[key] === true;
+}
+function createDiscordMessageReactionRuntime(params) {
+	const { ctx } = params;
+	const { cfg, accountId, token, ackReactionScope, message, messageChannelId, isGuildMessage, isDirectMessage, isGroupDm, shouldRequireMention, canDetectMention, effectiveWasMentioned, shouldBypassMention, route } = ctx;
+	const ackReaction = resolveAckReaction(cfg, route.agentId, {
+		channel: "discord",
+		accountId
+	});
+	const shouldSendAckReaction = Boolean(ackReaction && shouldAckReaction({
+		scope: ackReactionScope,
+		inboundEventKind: ctx.inboundEventKind,
+		isDirect: isDirectMessage,
+		isGroup: isGuildMessage || isGroupDm,
+		isMentionableGroup: isGuildMessage,
+		requireMention: shouldRequireMention,
+		canDetectMention,
+		effectiveWasMentioned,
+		shouldBypassMention
+	}));
+	const statusReactionsExplicitlyEnabled = cfg.messages?.statusReactions?.enabled === true;
+	const statusReactionsEnabled = !params.isRoomEvent && shouldSendAckReaction && cfg.messages?.statusReactions?.enabled !== false && (!params.sourceRepliesAreToolOnly || statusReactionsExplicitlyEnabled);
+	const feedbackRest = createDiscordRestClient({
+		cfg,
+		token,
+		accountId
+	}).rest;
+	const deliveryRest = createDiscordRestClient({
+		cfg,
+		token,
+		accountId
+	}).rest;
+	const ackReactionContext = createDiscordAckReactionContext({
+		rest: feedbackRest,
+		cfg,
+		accountId
+	});
+	const discordAdapter = createDiscordAckReactionAdapter({
+		channelId: messageChannelId,
+		messageId: message.id,
+		reactionContext: ackReactionContext
+	});
+	const statusReactionTiming = DEFAULT_TIMING;
+	let statusReactionTarget = `${messageChannelId}/${message.id}`;
+	let statusReactionsActive = statusReactionsEnabled;
+	let statusReactions = createStatusReactionController({
+		enabled: statusReactionsEnabled,
+		adapter: discordAdapter,
+		initialEmoji: ackReaction,
+		emojis: void 0,
+		timing: statusReactionTiming,
+		onError: (err) => {
+			logAckFailure({
+				log: logVerbose,
+				channel: "discord",
+				target: statusReactionTarget,
+				error: err
+			});
+		}
+	});
+	const resolveTrackedReactionChannelId = async (args) => {
+		const target = readToolStringArg(args, "channelId") ?? readToolStringArg(args, "channel_id") ?? readToolStringArg(args, "to");
+		if (!target) return messageChannelId;
+		try {
+			return resolveDiscordChannelId(target);
+		} catch {
+			return (await resolveDiscordTargetChannelId(target, {
+				cfg,
+				token,
+				accountId
+			})).channelId;
+		}
+	};
+	const maybeBindToToolReaction = async (payload) => {
+		if (params.sourceRepliesAreToolOnly || cfg.messages?.statusReactions?.enabled === false || payload.phase !== "start" || payload.name !== "message" || !payload.args) return;
+		const args = payload.args;
+		if (readToolStringArg(args, "action")?.toLowerCase() !== "react") return;
+		if (!(readToolBooleanArg(args, "trackToolCalls") || readToolBooleanArg(args, "track_tool_calls"))) return;
+		const emoji = readToolStringArg(args, "emoji");
+		if (!emoji || readToolBooleanArg(args, "remove")) return;
+		const trackedMessageId = readToolStringArg(args, "messageId") ?? readToolStringArg(args, "message_id") ?? message.id;
+		let trackedChannelId;
+		try {
+			trackedChannelId = await resolveTrackedReactionChannelId(args);
+		} catch (err) {
+			logAckFailure({
+				log: logVerbose,
+				channel: "discord",
+				target: `${readToolStringArg(args, "to") ?? readToolStringArg(args, "channelId") ?? messageChannelId}/${trackedMessageId}`,
+				error: err
+			});
+			return;
+		}
+		statusReactionTarget = `${trackedChannelId}/${trackedMessageId}`;
+		if (statusReactionsActive) statusReactions.clear();
+		statusReactions = createStatusReactionController({
+			enabled: true,
+			adapter: createDiscordAckReactionAdapter({
+				channelId: trackedChannelId,
+				messageId: trackedMessageId,
+				reactionContext: ackReactionContext
+			}),
+			initialEmoji: emoji,
+			emojis: void 0,
+			timing: statusReactionTiming,
+			onError: (err) => {
+				logAckFailure({
+					log: logVerbose,
+					channel: "discord",
+					target: statusReactionTarget,
+					error: err
+				});
+			}
+		});
+		statusReactionsActive = true;
+		statusReactions.setQueued();
+	};
+	let initialAckReactionQueued = false;
+	const queueInitialAckReactionAfterRecord = () => {
+		if (initialAckReactionQueued) return;
+		initialAckReactionQueued = true;
+		if (statusReactionsEnabled) statusReactionsActive = true;
+		queueInitialDiscordAckReaction({
+			enabled: statusReactionsEnabled,
+			shouldSendAckReaction,
+			ackReaction,
+			statusReactions,
+			reactionAdapter: discordAdapter,
+			target: `${messageChannelId}/${message.id}`
+		});
+	};
+	const finish = async (result) => {
+		if (statusReactionsActive) {
+			if (result.dispatchAborted) {
+				statusReactions.restoreInitial();
+				return;
+			}
+			if (result.dispatchError || result.finalDeliveryFailed) await statusReactions.setError();
+			else await statusReactions.setDone();
+			statusReactions.restoreInitial();
+		}
+	};
+	return {
+		feedbackRest,
+		deliveryRest,
+		statusReactionsExplicitlyEnabled,
+		statusReactionsEnabled,
+		get controller() {
+			return statusReactions;
+		},
+		maybeBindToToolReaction,
+		queueInitialAckReactionAfterRecord,
+		finish
+	};
+}
+//#endregion
 //#region extensions/discord/src/draft-chunking.ts
 function resolveDiscordDraftStreamingChunking(cfg, accountId) {
 	return resolveChannelDraftStreamingChunking(cfg, "discord", accountId, { fallbackLimit: DISCORD_TEXT_CHUNK_LIMIT });
@@ -827,240 +1218,52 @@ function createDiscordDraftPreviewController(params) {
 			try {
 				progressDraft.cancel();
 				if (!finalReplyDelivered) await draftStream?.discardPending();
-				if (!finalizedViaPreviewMessage && draftStream?.messageId()) await draftStream.clear();
-			} catch (err) {
-				params.log(`discord: draft cleanup failed: ${String(err)}`);
-			}
-		}
-	};
-}
-function isEmptyDiscordProgressLine(line) {
-	if (!line || typeof line === "string") return false;
-	return line.toolName === "apply_patch" && !line.detail && !line.status;
-}
-function shouldStartDiscordProgressDraftNow(line) {
-	return typeof line === "object" && line?.kind === "patch" && Boolean(line.detail);
-}
-//#endregion
-//#region extensions/discord/src/monitor/reply-typing-feedback.ts
-const DISCORD_REPLY_TYPING_MAX_DURATION_MS = 20 * 6e4;
-function createDiscordReplyTypingFeedback(params) {
-	const rest = params.rest ?? createDiscordRestClient({
-		cfg: params.cfg,
-		token: params.token,
-		accountId: params.accountId
-	}).rest;
-	return createTypingCallbacks({
-		start: () => sendTyping({
-			rest,
-			channelId: params.channelId
-		}),
-		onStartError: (err) => {
-			logTypingFailure({
-				log: params.log,
-				channel: "discord",
-				target: params.channelId,
-				error: err
-			});
-		},
-		keepaliveIntervalMs: params.keepaliveIntervalMs,
-		maxDurationMs: params.maxDurationMs ?? DISCORD_REPLY_TYPING_MAX_DURATION_MS
-	});
-}
-//#endregion
-//#region extensions/discord/src/monitor/message-handler.process.ts
-const TARGETED_ONLY_ALLOWED_MENTIONS = { parse: ["users", "roles"] };
-function isProcessAborted(abortSignal) {
-	return Boolean(abortSignal?.aborted);
-}
-function isFallbackOnlyToolWarningFinal(payload) {
-	if (payload.isError !== true || !isReplyPayloadNonTerminalToolErrorWarning(payload)) return false;
-	return !resolveSendableOutboundReplyParts(payload).hasMedia;
-}
-function isFailedProgress(payload) {
-	return payload.phase === "error" || payload.status === "failed" || payload.status === "error" || typeof payload.exitCode === "number" && payload.exitCode !== 0;
-}
-function formatDiscordReplySkip(params) {
-	const context = [`target=${params.target}`, params.sessionKey ? `session=${params.sessionKey}` : void 0].filter(Boolean).join(" ");
-	return `discord ${params.kind} reply skipped (${params.reason}): ${context}`;
-}
-function readToolStringArg(args, key) {
-	const value = args[key];
-	return typeof value === "string" && value.trim() ? value.trim() : void 0;
-}
-function readToolBooleanArg(args, key) {
-	return args[key] === true;
-}
-async function processDiscordMessage(ctx, observer) {
-	await processDiscordMessageInner(ctx, observer);
-}
-async function processDiscordMessageInner(ctx, observer) {
-	const dispatchStartedAt = Date.now();
-	const { cfg, discordConfig, accountId, token, runtime, guildHistories, historyLimit, textLimit, replyToMode, ackReactionScope, message, messageChannelId, isGuildMessage, isDirectMessage, isGroupDm, messageText, shouldRequireMention, canDetectMention, effectiveWasMentioned, shouldBypassMention, channelConfig, threadBindings, route, abortSignal, turnAdoptionLifecycle, preparedMedia: mediaList } = ctx;
-	if (isProcessAborted(abortSignal)) return;
-	const text = messageText;
-	if (!text) {
-		logVerbose("discord: drop message " + message.id + " (empty content)");
-		return;
-	}
-	const boundThreadId = ctx.threadBinding?.conversation?.conversationId?.trim();
-	if (boundThreadId && typeof threadBindings.touchThread === "function") threadBindings.touchThread({ threadId: boundThreadId });
-	const sourceReplyDeliveryMode = resolveChannelMessageSourceReplyDeliveryMode({
-		cfg,
-		ctx: {
-			ChatType: isDirectMessage ? "direct" : isGroupDm ? "group" : isGuildMessage ? "channel" : void 0,
-			InboundEventKind: ctx.inboundEventKind
-		}
-	});
-	const sourceRepliesAreToolOnly = sourceReplyDeliveryMode === "message_tool_only";
-	const configuredTypingMode = cfg.session?.typingMode ?? cfg.agents?.defaults?.typingMode;
-	const configuredTypingInterval = cfg.agents?.defaults?.typingIntervalSeconds ?? cfg.session?.typingIntervalSeconds;
-	const shouldDisableCoreTypingKeepalive = sourceRepliesAreToolOnly && configuredTypingMode === void 0 && configuredTypingInterval === void 0;
-	const ackReaction = resolveAckReaction(cfg, route.agentId, {
-		channel: "discord",
-		accountId
-	});
-	const removeAckAfterReply = cfg.messages?.removeAckAfterReply ?? false;
-	const mediaLocalRoots = getAgentScopedMediaLocalRoots(cfg, route.agentId);
-	const isRoomEvent = ctx.inboundEventKind === "room_event";
-	const shouldAckReaction$1 = () => Boolean(ackReaction && shouldAckReaction({
-		scope: ackReactionScope,
-		inboundEventKind: ctx.inboundEventKind,
-		isDirect: isDirectMessage,
-		isGroup: isGuildMessage || isGroupDm,
-		isMentionableGroup: isGuildMessage,
-		requireMention: shouldRequireMention,
-		canDetectMention,
-		effectiveWasMentioned,
-		shouldBypassMention
-	}));
-	const shouldSendAckReaction = shouldAckReaction$1();
-	const statusReactionsExplicitlyEnabled = cfg.messages?.statusReactions?.enabled === true;
-	const statusReactionsEnabled = !isRoomEvent && shouldSendAckReaction && cfg.messages?.statusReactions?.enabled !== false && (!sourceRepliesAreToolOnly || statusReactionsExplicitlyEnabled);
-	const feedbackRest = createDiscordRestClient({
-		cfg,
-		token,
-		accountId
-	}).rest;
-	const deliveryRest = createDiscordRestClient({
-		cfg,
-		token,
-		accountId
-	}).rest;
-	const ackReactionContext = createDiscordAckReactionContext({
-		rest: feedbackRest,
-		cfg,
-		accountId
-	});
-	const discordAdapter = createDiscordAckReactionAdapter({
-		channelId: messageChannelId,
-		messageId: message.id,
-		reactionContext: ackReactionContext
-	});
-	const statusReactionTiming = {
-		...DEFAULT_TIMING,
-		...cfg.messages?.statusReactions?.timing
-	};
-	let statusReactionTarget = `${messageChannelId}/${message.id}`;
-	let statusReactionsActive = statusReactionsEnabled;
-	let statusReactions = createStatusReactionController({
-		enabled: statusReactionsEnabled,
-		adapter: discordAdapter,
-		initialEmoji: ackReaction,
-		emojis: cfg.messages?.statusReactions?.emojis,
-		timing: statusReactionTiming,
-		onError: (err) => {
-			logAckFailure({
-				log: logVerbose,
-				channel: "discord",
-				target: statusReactionTarget,
-				error: err
-			});
-		}
-	});
-	const resolveTrackedReactionChannelId = async (args) => {
-		const target = readToolStringArg(args, "channelId") ?? readToolStringArg(args, "channel_id") ?? readToolStringArg(args, "to");
-		if (!target) return messageChannelId;
-		try {
-			return resolveDiscordChannelId(target);
-		} catch {
-			return (await resolveDiscordTargetChannelId(target, {
-				cfg,
-				token,
-				accountId
-			})).channelId;
+				if (!finalizedViaPreviewMessage && draftStream?.messageId()) await draftStream.clear();
+			} catch (err) {
+				params.log(`discord: draft cleanup failed: ${String(err)}`);
+			}
 		}
 	};
-	const maybeBindStatusReactionsToToolReaction = async (payload) => {
-		if (sourceRepliesAreToolOnly || cfg.messages?.statusReactions?.enabled === false || payload.phase !== "start" || payload.name !== "message" || !payload.args) return;
-		const args = payload.args;
-		if (readToolStringArg(args, "action")?.toLowerCase() !== "react") return;
-		if (!(readToolBooleanArg(args, "trackToolCalls") || readToolBooleanArg(args, "track_tool_calls"))) return;
-		const emoji = readToolStringArg(args, "emoji");
-		const remove = readToolBooleanArg(args, "remove");
-		if (!emoji || remove) return;
-		const trackedMessageId = readToolStringArg(args, "messageId") ?? readToolStringArg(args, "message_id") ?? message.id;
-		let trackedChannelId;
-		try {
-			trackedChannelId = await resolveTrackedReactionChannelId(args);
-		} catch (err) {
-			logAckFailure({
-				log: logVerbose,
+}
+function isEmptyDiscordProgressLine(line) {
+	if (!line || typeof line === "string") return false;
+	return line.toolName === "apply_patch" && !line.detail && !line.status;
+}
+function shouldStartDiscordProgressDraftNow(line) {
+	return typeof line === "object" && line?.kind === "patch" && Boolean(line.detail);
+}
+//#endregion
+//#region extensions/discord/src/monitor/reply-typing-feedback.ts
+const DISCORD_REPLY_TYPING_MAX_DURATION_MS = 20 * 6e4;
+function createDiscordReplyTypingFeedback(params) {
+	const rest = params.rest ?? createDiscordRestClient({
+		cfg: params.cfg,
+		token: params.token,
+		accountId: params.accountId
+	}).rest;
+	return createTypingCallbacks({
+		start: () => sendTyping({
+			rest,
+			channelId: params.channelId
+		}),
+		onStartError: (err) => {
+			logTypingFailure({
+				log: params.log,
 				channel: "discord",
-				target: `${readToolStringArg(args, "to") ?? readToolStringArg(args, "channelId") ?? messageChannelId}/${trackedMessageId}`,
+				target: params.channelId,
 				error: err
 			});
-			return;
-		}
-		statusReactionTarget = `${trackedChannelId}/${trackedMessageId}`;
-		if (statusReactionsActive) statusReactions.clear();
-		statusReactions = createStatusReactionController({
-			enabled: true,
-			adapter: createDiscordAckReactionAdapter({
-				channelId: trackedChannelId,
-				messageId: trackedMessageId,
-				reactionContext: ackReactionContext
-			}),
-			initialEmoji: emoji,
-			emojis: cfg.messages?.statusReactions?.emojis,
-			timing: statusReactionTiming,
-			onError: (err) => {
-				logAckFailure({
-					log: logVerbose,
-					channel: "discord",
-					target: statusReactionTarget,
-					error: err
-				});
-			}
-		});
-		statusReactionsActive = true;
-		statusReactions.setQueued();
-	};
-	let initialAckReactionQueued = false;
-	const queueInitialAckReactionAfterRecord = () => {
-		if (initialAckReactionQueued) return;
-		initialAckReactionQueued = true;
-		if (statusReactionsEnabled) statusReactionsActive = true;
-		queueInitialDiscordAckReaction({
-			enabled: statusReactionsEnabled,
-			shouldSendAckReaction,
-			ackReaction,
-			statusReactions,
-			reactionAdapter: discordAdapter,
-			target: `${messageChannelId}/${message.id}`
-		});
-	};
-	const processContext = await buildDiscordMessageProcessContext({
-		ctx,
-		text,
-		mediaList
-	});
-	if (!processContext) return;
-	const { ctxPayload, persistedSessionKey, turn, replyPlan, deliverTarget, replyTarget, replyReference } = processContext;
-	observer?.onReplyPlanResolved?.({
-		createdThreadId: replyPlan.createdThreadId,
-		sessionKey: persistedSessionKey
+		},
+		keepaliveIntervalMs: params.keepaliveIntervalMs,
+		maxDurationMs: params.maxDurationMs ?? DISCORD_REPLY_TYPING_MAX_DURATION_MS
 	});
+}
+//#endregion
+//#region extensions/discord/src/monitor/message-handler.process-reply-runtime.ts
+function createDiscordMessageReplyRuntime(params) {
+	const { ctx, processContext } = params;
+	const { cfg, discordConfig, accountId, token, guildHistories, historyLimit, textLimit, messageChannelId, isDirectMessage, route } = ctx;
+	const { ctxPayload, deliverTarget, replyReference } = processContext;
 	const typingChannelId = deliverTarget.startsWith("channel:") ? deliverTarget.slice(8) : messageChannelId;
 	let typingFeedback;
 	const getTypingFeedback = () => typingFeedback ??= createDiscordReplyTypingFeedback({
@@ -1068,9 +1271,9 @@ async function processDiscordMessageInner(ctx, observer) {
 		token,
 		accountId,
 		channelId: typingChannelId,
-		rest: feedbackRest,
+		rest: params.feedbackRest,
 		log: logVerbose,
-		keepaliveIntervalMs: shouldDisableCoreTypingKeepalive ? void 0 : 0
+		keepaliveIntervalMs: params.shouldDisableCoreTypingKeepalive ? void 0 : 0
 	});
 	const { onModelSelected, ...replyPipeline } = createChannelMessageReplyPipeline({
 		cfg,
@@ -1101,12 +1304,12 @@ async function processDiscordMessageInner(ctx, observer) {
 			limit: historyLimit
 		});
 	};
-	const beginDeliveryCorrelation = () => isRoomEvent ? beginDiscordInboundEventDeliveryCorrelation(ctxPayload.SessionKey, {
+	const beginDeliveryCorrelation = () => params.isRoomEvent ? beginDiscordInboundEventDeliveryCorrelation(ctxPayload.SessionKey, {
 		outboundTo: messageChannelId,
 		outboundAccountId: route.accountId,
 		markInboundEventDelivered: clearGroupHistory
 	}, { inboundEventKind: ctxPayload.InboundEventKind }) : () => {};
-	const endDiscordInboundEventDeliveryCorrelation = beginDeliveryCorrelation();
+	const endDeliveryCorrelation = beginDeliveryCorrelation();
 	const resolveCurrentTurnTranscriptFinalText = async () => {
 		const sessionKey = ctxPayload.SessionKey;
 		if (!sessionKey) return;
@@ -1124,7 +1327,7 @@ async function processDiscordMessageInner(ctx, observer) {
 				sessionKey,
 				storePath
 			});
-			if (!latest?.timestamp || latest.timestamp < dispatchStartedAt) return;
+			if (!latest?.timestamp || latest.timestamp < params.dispatchStartedAt) return;
 			return latest.text;
 		} catch (err) {
 			logVerbose(`discord transcript final candidate lookup failed: ${String(err)}`);
@@ -1132,21 +1335,96 @@ async function processDiscordMessageInner(ctx, observer) {
 		}
 	};
 	const deliverChannelId = deliverTarget.startsWith("channel:") ? deliverTarget.slice(8) : messageChannelId;
-	const draftPreview = createDiscordDraftPreviewController({
-		cfg,
-		discordConfig,
-		accountId,
-		sourceRepliesAreToolOnly,
-		textLimit,
-		deliveryRest,
-		deliverChannelId,
-		replyReference,
+	return {
+		replyPipeline,
+		onModelSelected,
 		tableMode,
 		maxLinesPerMessage,
 		chunkMode,
-		log: logVerbose
+		beginQueuedDeliveryCorrelation: beginDeliveryCorrelation,
+		endDeliveryCorrelation,
+		resolveCurrentTurnTranscriptFinalText,
+		deliverChannelId,
+		draftPreview: createDiscordDraftPreviewController({
+			cfg,
+			discordConfig,
+			accountId,
+			sourceRepliesAreToolOnly: params.sourceRepliesAreToolOnly,
+			textLimit,
+			deliveryRest: params.deliveryRest,
+			deliverChannelId,
+			replyReference,
+			tableMode,
+			maxLinesPerMessage,
+			chunkMode,
+			log: logVerbose
+		}),
+		resolvedBlockStreamingEnabled: resolveChannelStreamingBlockEnabled(discordConfig)
+	};
+}
+//#endregion
+//#region extensions/discord/src/monitor/message-handler.process.ts
+const TARGETED_ONLY_ALLOWED_MENTIONS = { parse: ["users", "roles"] };
+function isProcessAborted(abortSignal) {
+	return Boolean(abortSignal?.aborted);
+}
+function isFallbackOnlyToolWarningFinal(payload) {
+	if (payload.isError !== true || !isReplyPayloadNonTerminalToolErrorWarning(payload)) return false;
+	return !resolveSendableOutboundReplyParts(payload).hasMedia;
+}
+async function processDiscordMessage(ctx, observer) {
+	await processDiscordMessageInner(ctx, observer);
+}
+async function processDiscordMessageInner(ctx, observer) {
+	const dispatchStartedAt = Date.now();
+	const { cfg, accountId, token, runtime, guildHistories, historyLimit, textLimit, replyToMode, message, messageChannelId, isGuildMessage, isDirectMessage, isGroupDm, messageText, channelConfig, threadBindings, route, abortSignal, turnAdoptionLifecycle, preparedMedia: mediaList } = ctx;
+	if (isProcessAborted(abortSignal)) return;
+	const text = messageText;
+	if (!text && mediaList.length === 0) {
+		logVerbose("discord: drop message " + message.id + " (empty content)");
+		return;
+	}
+	const boundThreadId = ctx.threadBinding?.conversation?.conversationId?.trim();
+	if (boundThreadId && typeof threadBindings.touchThread === "function") threadBindings.touchThread({ threadId: boundThreadId });
+	const sourceReplyDeliveryMode = resolveChannelMessageSourceReplyDeliveryMode({
+		cfg,
+		ctx: {
+			ChatType: isDirectMessage ? "direct" : isGroupDm ? "group" : isGuildMessage ? "channel" : void 0,
+			InboundEventKind: ctx.inboundEventKind
+		}
+	});
+	const sourceRepliesAreToolOnly = sourceReplyDeliveryMode === "message_tool_only";
+	const configuredTypingMode = resolveAgentConfig(cfg, route.agentId)?.typingMode ?? cfg.agents?.defaults?.typingMode;
+	const configuredTypingInterval = cfg.agents?.defaults?.typingIntervalSeconds;
+	const shouldDisableCoreTypingKeepalive = sourceRepliesAreToolOnly && configuredTypingMode === void 0 && configuredTypingInterval === void 0;
+	const mediaLocalRoots = getAgentScopedMediaLocalRoots(cfg, route.agentId);
+	const isRoomEvent = ctx.inboundEventKind === "room_event";
+	const reactions = createDiscordMessageReactionRuntime({
+		ctx,
+		sourceRepliesAreToolOnly,
+		isRoomEvent
+	});
+	const processContext = await buildDiscordMessageProcessContext({
+		ctx,
+		text,
+		mediaList
+	});
+	if (!processContext) return;
+	const { ctxPayload, persistedSessionKey, turn, replyPlan, deliverTarget, replyTarget, replyReference } = processContext;
+	observer?.onReplyPlanResolved?.({
+		createdThreadId: replyPlan.createdThreadId,
+		sessionKey: persistedSessionKey
+	});
+	const { replyPipeline, onModelSelected, tableMode, maxLinesPerMessage, chunkMode, beginQueuedDeliveryCorrelation, endDeliveryCorrelation, resolveCurrentTurnTranscriptFinalText, deliverChannelId, draftPreview, resolvedBlockStreamingEnabled } = createDiscordMessageReplyRuntime({
+		ctx,
+		processContext,
+		sourceRepliesAreToolOnly,
+		shouldDisableCoreTypingKeepalive,
+		isRoomEvent,
+		dispatchStartedAt,
+		feedbackRest: reactions.feedbackRest,
+		deliveryRest: reactions.deliveryRest
 	});
-	let shouldYieldDraftProgress = () => false;
 	let finalReplyStartNotified = false;
 	const notifyFinalReplyStart = () => {
 		if (finalReplyStartNotified) return;
@@ -1170,90 +1448,30 @@ async function processDiscordMessageInner(ctx, observer) {
 		lines[0] = `🧠 ${lines[0]}`;
 		return lines.map((line) => `> ${line}`).join("\n");
 	};
-	const reasoningLevel = (() => {
-		const normalizedAgentId = (route.agentId ?? "").trim().toLowerCase() || "main";
-		const cfgDefault = cfg.agents?.list?.find((entry) => ((entry?.id ?? "").trim().toLowerCase() || "main") === normalizedAgentId)?.reasoningDefault ?? cfg.agents?.defaults?.reasoningDefault;
-		const configDefault = cfgDefault === "on" || cfgDefault === "stream" ? cfgDefault : "off";
-		const sessionKey = ctxPayload.SessionKey;
-		if (!sessionKey) return configDefault;
-		try {
-			const storePath = resolveStorePath(cfg.session?.store, { agentId: route.agentId });
-			const level = getSessionEntry({
-				agentId: route.agentId,
-				sessionKey,
-				storePath
-			})?.reasoningLevel;
-			if (level === "on" || level === "stream" || level === "off") return level;
-		} catch {
-			return "off";
-		}
-		return configDefault;
-	})();
-	const reasoningDurableEnabled = reasoningLevel === "on";
-	const reasoningWindowEnabled = reasoningLevel === "stream";
-	let progressTurnStartedAt = Date.now();
-	let progressReasoningSteps = 0;
-	let progressToolCalls = 0;
-	let progressCommentaryNotes = 0;
 	let progressReceiptLine;
 	let clearProgressDraftAfterFinalDelivery = false;
-	const seenCommentaryIds = /* @__PURE__ */ new Set();
-	let lastCommentaryNoteText = "";
-	const noteWindowCommentary = (itemId, noteText) => {
-		const trimmed = noteText?.trim();
-		if (!trimmed) return;
-		if (itemId) {
-			if (seenCommentaryIds.has(itemId)) return;
-			seenCommentaryIds.add(itemId);
-			progressCommentaryNotes += 1;
-			return;
-		}
-		if (trimmed !== lastCommentaryNoteText) {
-			lastCommentaryNoteText = trimmed;
-			progressCommentaryNotes += 1;
-		}
-	};
-	let windowReasoningOpen = false;
-	const closePendingWindowThought = () => {
-		if (windowReasoningOpen) {
-			windowReasoningOpen = false;
-			progressReasoningSteps += 1;
-		}
-	};
-	const resetProgressTurnState = () => {
+	const resetDeliveryState = () => {
 		finalReplyStartNotified = false;
 		userFacingFinalDelivered = false;
 		userFacingFinalDeliveryFailed = false;
 		pendingToolWarningFinal = void 0;
-		progressTurnStartedAt = Date.now();
-		progressReasoningSteps = 0;
-		progressToolCalls = 0;
-		progressCommentaryNotes = 0;
 		progressReceiptLine = void 0;
 		clearProgressDraftAfterFinalDelivery = false;
-		seenCommentaryIds.clear();
-		lastCommentaryNoteText = "";
-		windowReasoningOpen = false;
-	};
-	const handleAssistantMessageBoundary = () => {
-		if (draftPreview.handleAssistantMessageBoundary()) resetProgressTurnState();
-	};
-	const buildProgressSummaryLine = () => {
-		closePendingWindowThought();
-		const seconds = Math.max(1, Math.round((Date.now() - progressTurnStartedAt) / 1e3));
-		return `-# ${[
-			...progressReasoningSteps > 0 ? [`🧠 ${progressReasoningSteps} thought${progressReasoningSteps === 1 ? "" : "s"}`] : [],
-			...progressCommentaryNotes > 0 ? [`💬 ${progressCommentaryNotes} note${progressCommentaryNotes === 1 ? "" : "s"}`] : [],
-			...progressToolCalls > 0 ? [`🛠️ ${progressToolCalls} tool call${progressToolCalls === 1 ? "" : "s"}`] : [],
-			`⏱️ ${seconds}s`
-		].join(" · ")}`;
 	};
+	const progress = createDiscordMessageProgressRuntime({
+		ctx,
+		sessionKey: ctxPayload.SessionKey,
+		sourceRepliesAreToolOnly,
+		draftPreview,
+		reactions,
+		onTurnReset: resetDeliveryState
+	});
 	let replyLifecycleStarted = false;
 	const onDiscordReplyStart = async () => {
 		if (isProcessAborted(abortSignal)) return;
 		replyLifecycleStarted = true;
 		await replyPipeline.typingCallbacks?.onReplyStart();
-		await statusReactions.setThinking();
+		await reactions.controller.setThinking();
 	};
 	const beforeDiscordPayloadDelivery = (payload, info) => {
 		if (isProcessAborted(abortSignal)) {
@@ -1297,13 +1515,13 @@ async function processDiscordMessageInner(ctx, observer) {
 				isReasoning: void 0
 			}));
 			if (!replies.length) return { visibleReplySent: false };
-			await deliverDiscordReply({
+			const result = await deliverDiscordReply({
 				cfg,
 				replies,
 				target: deliverTarget,
 				token,
 				accountId,
-				rest: deliveryRest,
+				rest: reactions.deliveryRest,
 				runtime,
 				replyToId: replyReference.use(),
 				replyToMode,
@@ -1316,8 +1534,8 @@ async function processDiscordMessageInner(ctx, observer) {
 				mediaLocalRoots,
 				kind: "block"
 			});
-			replyReference.markSent();
-			return { visibleReplySent: true };
+			if (result.visibleReplySent) replyReference.markSent();
+			return result;
 		}
 		if (isFinal && !options?.allowFallbackOnlyToolWarning && isFallbackOnlyToolWarningFinal(payload)) {
 			if (!userFacingFinalDelivered && (!finalReplyStartNotified || userFacingFinalDeliveryFailed)) pendingToolWarningFinal = {
@@ -1351,7 +1569,7 @@ async function processDiscordMessageInner(ctx, observer) {
 		}
 		if (draftStream && isFinal && draftPreview.isProgressMode && !deliverablePayload.isError && draftPreview.hasProgressDraftToCollapse && draftStream) {
 			await draftPreview.flush();
-			progressReceiptLine = buildProgressSummaryLine();
+			progressReceiptLine = progress.buildProgressSummaryLine();
 			clearProgressDraftAfterFinalDelivery = true;
 		}
 		if (draftStream && isFinal && !draftPreview.isProgressMode && !deliverablePayload.isError) {
@@ -1374,7 +1592,7 @@ async function processDiscordMessageInner(ctx, observer) {
 						await editMessageDiscord(deliverChannelId, previewMessageId, edit, {
 							cfg,
 							accountId,
-							rest: deliveryRest
+							rest: reactions.deliveryRest
 						});
 					},
 					onPreviewFinalized: () => {
@@ -1395,13 +1613,13 @@ async function processDiscordMessageInner(ctx, observer) {
 					const allowedMentions = discordTextHasBroadcastMention(fallbackPayload.text ?? "") ? TARGETED_ONLY_ALLOWED_MENTIONS : void 0;
 					const replyToId = replyReference.use();
 					notifyFinalReplyStart();
-					await deliverDiscordReply({
+					return (await deliverDiscordReply({
 						cfg,
 						replies: [fallbackPayload],
 						target: deliverTarget,
 						token,
 						accountId,
-						rest: deliveryRest,
+						rest: reactions.deliveryRest,
 						runtime,
 						replyToId,
 						replyToMode,
@@ -1414,8 +1632,7 @@ async function processDiscordMessageInner(ctx, observer) {
 						mediaLocalRoots,
 						allowedMentions,
 						kind: info.kind
-					});
-					return true;
+					})).visibleReplySent;
 				},
 				onNormalDelivered: () => {
 					markUserFacingFinalDelivered();
@@ -1439,13 +1656,13 @@ async function processDiscordMessageInner(ctx, observer) {
 			...deliverablePayload,
 			text: deliverablePayload.text?.trim() ? `${deliverablePayload.text.trimEnd()}\n${receiptLine}` : receiptLine
 		} : deliverablePayload;
-		await deliverDiscordReply({
+		const result = await deliverDiscordReply({
 			cfg,
 			replies: [payloadForDelivery],
 			target: deliverTarget,
 			token,
 			accountId,
-			rest: deliveryRest,
+			rest: reactions.deliveryRest,
 			runtime,
 			replyToId,
 			replyToMode,
@@ -1458,6 +1675,7 @@ async function processDiscordMessageInner(ctx, observer) {
 			mediaLocalRoots,
 			kind: info.kind
 		});
+		if (!result.visibleReplySent) return result;
 		replyReference.markSent();
 		if (isFinal && deliverablePayload.isError !== true) {
 			if (receiptLine) {
@@ -1471,7 +1689,7 @@ async function processDiscordMessageInner(ctx, observer) {
 				await draftStream?.clear();
 			}
 		}
-		return { visibleReplySent: true };
+		return result;
 	};
 	const onDiscordDeliveryError = (err, info) => {
 		if (info.kind === "final" && finalReplyStartNotified && !userFacingFinalDelivered) userFacingFinalDeliveryFailed = true;
@@ -1482,7 +1700,6 @@ async function processDiscordMessageInner(ctx, observer) {
 			sessionKey: ctxPayload.SessionKey
 		})));
 	};
-	const resolvedBlockStreamingEnabled = resolveChannelStreamingBlockEnabled(discordConfig);
 	let dispatchResult = null;
 	let dispatchError = false;
 	let dispatchAborted = false;
@@ -1507,12 +1724,13 @@ async function processDiscordMessageInner(ctx, observer) {
 			cfg,
 			channel: "discord",
 			accountId: route.accountId,
+			outboundEchoSourceId: resolveDiscordWebhookId(message) ?? void 0,
 			route: {
 				agentId: route.agentId,
 				sessionKey: persistedSessionKey
 			},
 			ctxPayload,
-			afterRecord: queueInitialAckReactionAfterRecord,
+			afterRecord: reactions.queueInitialAckReactionAfterRecord,
 			sessionInitRetry: {
 				delaysMs: [
 					250,
@@ -1530,7 +1748,7 @@ async function processDiscordMessageInner(ctx, observer) {
 				onFreshSettledDelivery: deliverPendingToolWarningFinalIfNeeded
 			},
 			delivery: {
-				deliver: deliverDiscordPayload,
+				deliverWithProviderMessageSending: deliverDiscordPayload,
 				onError: onDiscordDeliveryError
 			},
 			record: turn.record,
@@ -1546,132 +1764,13 @@ async function processDiscordMessageInner(ctx, observer) {
 				skillFilter: channelConfig?.skills,
 				sourceReplyDeliveryMode,
 				typingKeepalive: shouldDisableCoreTypingKeepalive ? false : void 0,
-				queuedDeliveryCorrelations: isRoomEvent ? [{ begin: beginDeliveryCorrelation }] : void 0,
+				queuedDeliveryCorrelations: isRoomEvent ? [{ begin: beginQueuedDeliveryCorrelation }] : void 0,
 				suppressTyping: isRoomEvent ? true : void 0,
 				allowProgressCallbacksWhenSourceDeliverySuppressed: sourceRepliesAreToolOnly && draftPreview.draftStream && draftPreview.isProgressMode ? true : void 0,
 				disableBlockStreaming: sourceRepliesAreToolOnly ? true : draftPreview.disableBlockStreamingForDraft ?? (typeof resolvedBlockStreamingEnabled === "boolean" ? !resolvedBlockStreamingEnabled : void 0),
 				onPartialReply: draftPreview.draftStream && !draftPreview.isProgressMode ? (payload) => draftPreview.updateFromPartial(payload.text) : void 0,
-				onAssistantMessageStart: draftPreview.draftStream ? handleAssistantMessageBoundary : void 0,
-				onReasoningEnd: draftPreview.draftStream ? () => {
-					closePendingWindowThought();
-					handleAssistantMessageBoundary();
-				} : void 0,
-				onModelSelected,
-				suppressDefaultToolProgressMessages: sourceRepliesAreToolOnly && statusReactionsExplicitlyEnabled || draftPreview.suppressDefaultToolProgressMessages ? true : void 0,
-				allowToolLifecycleWhenProgressHidden: statusReactionsEnabled ? true : void 0,
-				commentaryProgressEnabled: draftPreview.isProgressMode ? draftPreview.commentaryProgressEnabled : void 0,
-				progressPreambleEnabled: draftPreview.draftStream && draftPreview.isProgressMode ? true : void 0,
-				commentaryPayloadsEnabled: draftPreview.isProgressMode ? draftPreview.commentaryProgressEnabled : void 0,
-				reasoningPayloadsEnabled: reasoningDurableEnabled,
-				onVerboseProgressVisibility: (isActive) => {
-					shouldYieldDraftProgress = isActive;
-				},
-				onNarrationUpdate: draftPreview.narrationProgressEnabled ? async (payload) => {
-					if (isProcessAborted(abortSignal) || shouldYieldDraftProgress()) return;
-					await draftPreview.pushNarrationProgress(payload.text);
-				} : void 0,
-				onProgressNarratorLifecycle: draftPreview.narrationProgressEnabled ? (lifecycle) => draftPreview.setProgressNarratorLifecycle(lifecycle) : void 0,
-				isProgressDraftVisible: draftPreview.narrationProgressEnabled ? () => draftPreview.isProgressDraftVisible : void 0,
-				narrationHideCommandText: draftPreview.narrationHideCommandText ? true : void 0,
-				onReasoningStream: async (payload) => {
-					if (payload?.requiresReasoningProgressOptIn === true && !reasoningWindowEnabled) return;
-					if (payload?.text) windowReasoningOpen = true;
-					await statusReactions.setThinking();
-					await draftPreview.pushReasoningProgress(payload?.text, { snapshot: payload?.isReasoningSnapshot === true });
-				},
-				streamReasoningInNonStreamModes: reasoningWindowEnabled,
-				onToolStart: async (payload) => {
-					if (isProcessAborted(abortSignal)) return;
-					await maybeBindStatusReactionsToToolReaction(payload);
-					await statusReactions.setTool(payload.name);
-					if (payload.phase === "start") closePendingWindowThought();
-					if (shouldYieldDraftProgress()) return;
-					if (payload.phase === "start" && isChannelProgressDraftWorkToolName(payload.name)) progressToolCalls += 1;
-					await draftPreview.pushToolProgress(buildChannelProgressDraftLineForEntry(discordConfig, {
-						event: "tool",
-						itemId: payload.itemId,
-						toolCallId: payload.toolCallId,
-						name: payload.name,
-						phase: payload.phase,
-						args: payload.args
-					}, payload.detailMode ? { detailMode: payload.detailMode } : void 0), { toolName: payload.name });
-				},
-				onItemEvent: async (payload) => {
-					if (isFailedProgress(payload)) return false;
-					if (payload.kind === "preamble") {
-						if (shouldYieldDraftProgress()) return;
-						return await draftPreview.pushPreambleItemEvent(payload, noteWindowCommentary);
-					}
-					if (shouldYieldDraftProgress()) return;
-					await draftPreview.pushToolProgress(buildChannelProgressDraftLineForEntry(discordConfig, {
-						event: "item",
-						itemId: payload.itemId,
-						toolCallId: payload.toolCallId,
-						itemKind: payload.kind,
-						title: payload.title,
-						name: payload.name,
-						phase: payload.phase,
-						status: payload.status,
-						summary: payload.summary,
-						progressText: payload.progressText,
-						meta: payload.meta
-					}));
-				},
-				onPlanUpdate: async (payload) => {
-					if (payload.phase !== "update") return;
-					await draftPreview.pushPlanProgress(payload.steps, { explanation: payload.explanation });
-				},
-				onApprovalEvent: async (payload) => {
-					if (payload.phase !== "requested") return;
-					await draftPreview.pushToolProgress(buildChannelProgressDraftLine({
-						event: "approval",
-						phase: payload.phase,
-						title: payload.title,
-						command: payload.command,
-						reason: payload.reason,
-						message: payload.message
-					}));
-				},
-				onCommandOutput: async (payload) => {
-					if (isFailedProgress(payload)) return false;
-					if (payload.phase !== "end") return;
-					if (shouldYieldDraftProgress()) return;
-					await draftPreview.pushToolProgress(buildChannelProgressDraftLine({
-						event: "command-output",
-						itemId: payload.itemId,
-						toolCallId: payload.toolCallId,
-						phase: payload.phase,
-						title: payload.title,
-						name: payload.name,
-						status: payload.status,
-						exitCode: payload.exitCode
-					}));
-				},
-				onPatchSummary: async (payload) => {
-					if (payload.phase !== "end") return;
-					if (shouldYieldDraftProgress()) return;
-					await draftPreview.pushToolProgress(buildChannelProgressDraftLine({
-						event: "patch",
-						itemId: payload.itemId,
-						toolCallId: payload.toolCallId,
-						phase: payload.phase,
-						title: payload.title,
-						name: payload.name,
-						added: payload.added,
-						modified: payload.modified,
-						deleted: payload.deleted,
-						summary: payload.summary
-					}));
-				},
-				onCompactionStart: async () => {
-					if (isProcessAborted(abortSignal)) return;
-					await statusReactions.setCompacting();
-				},
-				onCompactionEnd: async () => {
-					if (isProcessAborted(abortSignal)) return;
-					statusReactions.cancelPending();
-					await statusReactions.setThinking();
-				}
+				...progress.replyOptions,
+				onModelSelected
 			}
 		});
 		if (!preparedResult.dispatched) return;
@@ -1689,27 +1788,13 @@ async function processDiscordMessageInner(ctx, observer) {
 		if (await completeDiscordSessionConflict(err, deliverDiscordPayload, onDiscordDeliveryError)) return;
 		throw err;
 	} finally {
-		endDiscordInboundEventDeliveryCorrelation();
+		endDeliveryCorrelation();
 		await draftPreview.cleanup();
 		const finalDeliveryFailed = (dispatchResult?.failedCounts?.final ?? 0) > 0;
-		if (statusReactionsActive) if (dispatchAborted) if (removeAckAfterReply) statusReactions.clear();
-		else statusReactions.restoreInitial();
-		else {
-			if (dispatchError || finalDeliveryFailed) await statusReactions.setError();
-			else await statusReactions.setDone();
-			if (removeAckAfterReply) (async () => {
-				await sleep(dispatchError || finalDeliveryFailed ? statusReactionTiming.errorHoldMs : statusReactionTiming.doneHoldMs);
-				await statusReactions.clear();
-			})();
-			else statusReactions.restoreInitial();
-		}
-		else if (shouldSendAckReaction && ackReaction && removeAckAfterReply) removeReactionDiscord(messageChannelId, message.id, ackReaction, ackReactionContext).catch((err) => {
-			logAckFailure({
-				log: logVerbose,
-				channel: "discord",
-				target: `${messageChannelId}/${message.id}`,
-				error: err
-			});
+		await reactions.finish({
+			dispatchAborted,
+			dispatchError,
+			finalDeliveryFailed
 		});
 	}
 	if (dispatchAborted) return;