@openclaw/discord 2026.9.5 → 2026.9.7

package/dist/.setup/{message-handler.process-Dz1xvuQU.mjs → message-handler.process-BNFFuChn.mjs}

@@ -1,37 +1,38 @@
-import { ft as editChannelMessage, st as createChannelMessage, t as discord_exports, ut as deleteChannelMessage } from "./discord-BXpHW-cu.mjs";
-import { C as resolveTimestampMs, i as normalizeDiscordAllowList, o as normalizeDiscordSlug } from "./channel-type-DKnjV1XW.mjs";
-import { p as resolveDiscordMaxLinesPerMessage } from "./accounts-CwJQoLjM.mjs";
-import { b as resolveDiscordChannelId, o as chunkDiscordTextWithMode } from "./retry-DBfcEgmO.mjs";
-import { F as createDiscordRuntimeAccountContext, P as createDiscordRestClient, d as resolveDiscordTargetChannelId, k as resolveDiscordMessageFlags } from "./send.shared-Zwx6BxQ5.mjs";
-import { a as discordTextHasBroadcastMention } from "./send.outbound-D0hQ7s50.mjs";
-import { D as resolveDiscordMessageStickers, b as resolveDiscordMessageText, h as resolveDiscordThreadStarter, p as resolveDiscordAutoThreadReplyPlan, w as resolveReferencedReplyMediaList, x as formatDiscordMediaText } from "./transcripts-source-CuWYgayu.mjs";
-import { a as removeReactionDiscord, f as editMessageDiscord, r as reactMessageDiscord } from "./send-CKDczUNL.mjs";
+import { C as withDiscordRequestAuthority, D as Message, Mt as getGuildMember, ct as createChannelMessage, dt as deleteChannelMessage, pt as editChannelMessage, t as discord_exports, vt as listChannelMessages } from "./discord-0xJYfdDD.mjs";
+import { i as normalizeDiscordAllowList, o as normalizeDiscordSlug, w as resolveTimestampMs } from "./channel-type-DRCrEMss.mjs";
+import { p as resolveDiscordMaxLinesPerMessage } from "./accounts-ChaMcixG.mjs";
+import { o as chunkDiscordTextWithMode, x as resolveDiscordChannelId } from "./retry-pz_cSha2.mjs";
+import { N as createDiscordRestClient, O as resolveDiscordMessageFlags, P as createDiscordRuntimeAccountContext, u as resolveDiscordTargetChannelId } from "./send.shared-DGFkbkQR.mjs";
+import { a as discordTextHasBroadcastMention } from "./send.outbound-BISKnb-a.mjs";
+import { C as resolveReferencedReplyMediaList, E as resolveDiscordMessageStickers, O as resolveDiscordReferencedReplyMessageId, _ as resolveDiscordMessageHistoryText, b as formatDiscordMediaText, f as resolveDiscordAutoThreadReplyPlan, m as resolveDiscordThreadStarter, y as resolveDiscordMessageText } from "./transcripts-source-p8EV179h.mjs";
+import { a as removeReactionDiscord, r as reactMessageDiscord } from "./send-CrfEI6Bs.mjs";
 import { n as DISCORD_ATTACHMENT_TOTAL_TIMEOUT_MS, t as DISCORD_ATTACHMENT_IDLE_TIMEOUT_MS } from "./timeouts-D86uWLt_.mjs";
-import "./targets-D1mAB5yO.mjs";
-import { b as discordInboundEventDelivery, h as resolveDiscordConversationIdentity, u as buildDiscordRoutePeer } from "./outbound-session-route-CqWbuMOm.mjs";
-import { t as DISCORD_TEXT_CHUNK_LIMIT } from "./outbound-adapter-C8v79z9Z.mjs";
-import { a as formatDiscordReplySkip, c as buildGuildLabel, g as createDiscordSupplementalContextAccessChecker, h as buildDiscordInboundAccessContext, i as formatDiscordReplyDeliveryFailure, l as resolveReplyContext, o as sanitizeDiscordFrontChannelReplyPayloads, r as deliverDiscordReply, s as buildDirectLabel } from "./provider-72zIvN-i.mjs";
-import { n as resolveDiscordWebhookId } from "./sender-identity-0Ymgvmaj.mjs";
+import "./targets-0KUcEIYx.mjs";
+import { b as discordInboundEventDelivery, h as resolveDiscordConversationIdentity, u as buildDiscordRoutePeer } from "./outbound-session-route-zVGxxceg.mjs";
+import { t as DISCORD_TEXT_CHUNK_LIMIT } from "./outbound-adapter-BobT-kse.mjs";
+import { T as createDiscordSupplementalContextAccessChecker, a as formatDiscordReplySkip, c as buildGuildLabel, i as formatDiscordReplyDeliveryFailure, l as resolveReplyContext, o as sanitizeDiscordFrontChannelReplyPayloads, r as deliverDiscordReply, s as buildDirectLabel, w as buildDiscordInboundAccessContext } from "./provider-B_G5hASF.mjs";
+import { n as resolveDiscordWebhookId, t as resolveDiscordSenderIdentity } from "./sender-identity-B9X5Vb9R.mjs";
 import { t as beginDiscordActiveTurnThreadRoute } from "./active-turn-thread-route-fmHl1HNd.mjs";
-import { n as filterDiscordHistoryEntriesForContext, t as createDiscordHistorySenderProvenance } from "./message-handler.history-CJOsN9w5.mjs";
-import { t as sendTyping } from "./typing-BKZL5fGj.mjs";
-import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";
+import { a as createDiscordHistorySenderProvenance, h as shouldIgnoreBoundThreadWebhookMessage, l as isBoundThreadBotSystemMessage, o as filterDiscordHistoryEntriesForContext, s as resolveDiscordHistoryMediaIds, t as resolveDiscordPreflightPluralKitInfo } from "./message-handler.preflight-pluralkit-CWLUBVcx.mjs";
+import { t as sendTyping } from "./typing-BiHCzBRu.mjs";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { buildAgentSessionKey, resolveThreadSessionKeys } from "openclaw/plugin-sdk/routing";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { getReplyPayloadTtsSupplement, isReplyPayloadNonTerminalToolErrorWarning, resolveSendableOutboundReplyParts } from "openclaw/plugin-sdk/reply-payload";
 import { danger, logVerbose, shouldLogVerbose, sleepWithAbort } from "openclaw/plugin-sdk/runtime-env";
 import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import { resolveChunkMode } from "openclaw/plugin-sdk/reply-chunking";
 import { resolveMarkdownTableMode } from "openclaw/plugin-sdk/markdown-table-runtime";
-import { convertMarkdownTables, stripInlineDirectiveTagsForDelivery, stripReasoningTagsFromText } from "openclaw/plugin-sdk/text-chunking";
-import { bindIngressLifecycleToReplyOptions, createChannelMessageReplyPipeline, createChannelProgressDraftCompositor, createFinalizableDraftStreamControlsForState, createTypingCallbacks, defineFinalizableLivePreviewAdapter, deliverWithFinalizableLivePreviewAdapter, resolveChannelDraftStreamingChunking, resolveChannelMessageSourceReplyDeliveryMode, resolveChannelPreviewStreamMode, resolveChannelStreamingBlockEnabled, resolveChannelStreamingPreviewCommandText, resolveChannelStreamingProgressNarration, resolveTranscriptBackedChannelFinalText } from "openclaw/plugin-sdk/channel-outbound";
+import { stripInlineDirectiveTagsForDelivery, stripReasoningTagsFromText } from "openclaw/plugin-sdk/text-chunking";
+import { resolveBatchedReplyThreadingPolicy } from "openclaw/plugin-sdk/reply-reference";
+import { bindIngressLifecycleToReplyOptions, createChannelMessageReplyPipeline, createChannelProgressDraftCompositor, createFinalizableDraftLifecycle, createLivePreviewLifecycle, createTypingCallbacks, isRecentOutboundMessageIdentity, resolveChannelDraftStreamingChunking, resolveChannelMessageSourceReplyDeliveryMode, resolveChannelPreviewStreamMode, resolveChannelStreamingBlockEnabled, resolveChannelStreamingPreviewCommandText, resolveChannelStreamingProgressNarration, resolveTranscriptBackedChannelFinalText } from "openclaw/plugin-sdk/channel-outbound";
 import { getAgentScopedMediaLocalRoots } from "openclaw/plugin-sdk/media-runtime";
 import { buildChannelInboundEventContext, createCommandTurnContext, dispatchChannelInboundTurn, formatInboundEnvelope, formatInboundMediaUnavailableText, getGroupThreadDeliverySession, hasFinalInboundReplyDispatch, readAgentRunTerminalOutcome, resolveEnvelopeFormatOptions, toHistoryMediaEntries, toInboundMediaFactsWithMetadata } from "openclaw/plugin-sdk/channel-inbound";
 import { evaluateSupplementalContextVisibility } from "openclaw/plugin-sdk/security-runtime";
-import { resolvePinnedMainDmOwnerFromAllowlist } from "openclaw/plugin-sdk/conversation-runtime";
+import { resolvePinnedMainDmOwnerFromAllowlist as resolvePinnedMainDmOwnerFromAllowlist$1 } from "openclaw/plugin-sdk/conversation-runtime";
 import { resolveAgentConfig } from "openclaw/plugin-sdk/agent-scope-runtime";
-import { EmbeddedBlockChunker, resolveAckReaction, resolveAgentConfig as resolveAgentConfig$1, resolveHumanDelayConfig } from "openclaw/plugin-sdk/agent-runtime";
 import { isDangerousNameMatchingEnabled } from "openclaw/plugin-sdk/dangerous-name-runtime";
+import { EmbeddedBlockChunker, resolveAckReaction, resolveAgentConfig as resolveAgentConfig$1, resolveHumanDelayConfig } from "openclaw/plugin-sdk/agent-runtime";
 import { getSessionEntry, readSessionUpdatedAt, resolveStorePath } from "openclaw/plugin-sdk/session-store-runtime";
 import { getGlobalHookRunner } from "openclaw/plugin-sdk/plugin-runtime";
 import { buildHistoryContextFromEntries, buildInboundHistoryFromEntries, createChannelHistoryWindow } from "openclaw/plugin-sdk/reply-history";
@@ -39,6 +40,114 @@ import { resolveChannelContextVisibilityMode } from "openclaw/plugin-sdk/context
 import { formatAudioTranscriptForAgent } from "openclaw/plugin-sdk/media-understanding-runtime";
 import { createStatusReactionController, logAckFailure, logTypingFailure, shouldAckReaction } from "openclaw/plugin-sdk/channel-feedback";
 import { readLatestAssistantTextByIdentity } from "openclaw/plugin-sdk/session-transcript-runtime";
+//#region extensions/discord/src/monitor/message-handler.recent-history.ts
+/** Fetch a physical recent window, never walking older pages to refill filtered rows. */
+async function recoverDiscordChannelHistory(params) {
+	const { ctx, isCurrent } = params;
+	if (ctx.historyLimit <= 0 || !isCurrent()) return [];
+	const excludedIds = /* @__PURE__ */ new Set([ctx.message.id, ...ctx.sourceMessageIds ?? []]);
+	if (ctx.canonicalMessageId) excludedIds.add(ctx.canonicalMessageId);
+	let remaining = ctx.historyLimit + excludedIds.size - 1;
+	let before = ctx.message.id;
+	const triggerTimestamp = resolveTimestampMs(ctx.message.timestamp);
+	const guildId = ctx.data.guild?.id ?? ctx.data.guild_id;
+	const cachedMedia = new Map((ctx.guildHistories.get(ctx.messageChannelId) ?? []).map((entry) => [entry.messageId, entry]));
+	const members = /* @__PURE__ */ new Map();
+	const roleAllowList = ctx.channelConfig?.roles ?? ctx.guildInfo?.roles ?? [];
+	const entries = [];
+	try {
+		while (remaining > 0 && isCurrent()) {
+			const limit = Math.min(100, remaining);
+			const page = await listChannelMessages(ctx.client.rest, ctx.messageChannelId, {
+				before,
+				limit
+			});
+			if (!isCurrent()) return [];
+			const window = page.slice(0, limit);
+			remaining -= window.length;
+			for (const raw of window) {
+				const row = raw;
+				const timestamp = resolveTimestampMs(row.timestamp);
+				if (row.channel_id !== ctx.messageChannelId || row.guild_id && row.guild_id !== guildId || excludedIds.has(row.id) || /^\d+$/u.test(row.id) && /^\d+$/u.test(ctx.message.id) && BigInt(row.id) >= BigInt(ctx.message.id) || timestamp === void 0 || triggerTimestamp !== void 0 && timestamp > triggerTimestamp || params.sessionStartedAt !== void 0 && timestamp < params.sessionStartedAt || row.type === discord_exports.MessageType.ChatInputCommand || row.type === discord_exports.MessageType.ContextMenuCommand || row.author.id === ctx.botUserId) continue;
+				excludedIds.add(row.id);
+				const message = new Message(ctx.client, row);
+				let body = resolveDiscordMessageHistoryText(message, { includeForwarded: true });
+				if (!body || isRecentOutboundMessageIdentity({
+					channel: "discord",
+					accountId: ctx.accountId,
+					conversationId: ctx.messageChannelId,
+					messageId: row.id,
+					...row.webhook_id ? { sourceId: row.webhook_id } : {}
+				}) || shouldIgnoreBoundThreadWebhookMessage({
+					threadId: ctx.messageChannelId,
+					webhookId: message.webhookId,
+					threadBinding: ctx.threadBinding
+				}) || isBoundThreadBotSystemMessage({
+					isBoundThreadSession: Boolean(ctx.threadBinding && ctx.threadChannel),
+					isBotAuthor: Boolean(row.author.bot),
+					text: body
+				})) continue;
+				const needsPluralKitLookup = Boolean(ctx.discordConfig?.pluralkit?.enabled && message.webhookId);
+				const pluralkitInfo = needsPluralKitLookup ? await resolveDiscordPreflightPluralKitInfo({
+					message,
+					webhookId: message.webhookId,
+					config: ctx.discordConfig?.pluralkit,
+					abortSignal: ctx.abortSignal
+				}) : null;
+				if (needsPluralKitLookup && !isCurrent()) return [];
+				const sender = resolveDiscordSenderIdentity({
+					author: message.author,
+					member: row.member,
+					pluralkitInfo
+				});
+				let member = row.member;
+				if (params.mode !== "all" && roleAllowList.length > 0 && !member && guildId && !params.isSenderAllowed({
+					...sender,
+					memberRoleIds: []
+				})) {
+					member = members.get(row.author.id);
+					if (!member) {
+						member = await getGuildMember(ctx.client.rest, guildId, row.author.id);
+						if (!isCurrent()) return [];
+						members.set(row.author.id, member);
+					}
+				}
+				const senderProvenance = createDiscordHistorySenderProvenance({
+					sender,
+					memberRoleIds: member?.roles ?? []
+				});
+				const mediaIds = resolveDiscordHistoryMediaIds(message);
+				const cached = cachedMedia.get(row.id);
+				const media = mediaIds.length > 0 && cached?.mediaIds?.length === mediaIds.length && cached.mediaIds.every((id, index) => id === mediaIds[index]) ? cached.media : void 0;
+				if (mediaIds.length > (media?.length ?? 0)) body = formatInboundMediaUnavailableText({
+					body,
+					notice: "[discord historical attachment unavailable]"
+				});
+				entries.push({
+					sender: sender.label,
+					body,
+					timestamp,
+					messageId: row.id,
+					senderProvenance,
+					...media?.length ? { media } : {}
+				});
+			}
+			const nextBefore = window.at(-1)?.id;
+			if (window.length < limit || !nextBefore || nextBefore === before || /^\d+$/u.test(nextBefore) && /^\d+$/u.test(before) && BigInt(nextBefore) >= BigInt(before)) break;
+			before = nextBefore;
+		}
+		if (!isCurrent()) return [];
+		return filterDiscordHistoryEntriesForContext({
+			entries: entries.toReversed(),
+			mode: params.mode,
+			isSenderAllowed: params.isSenderAllowed
+		}).entries.slice(-ctx.historyLimit);
+	} catch (error) {
+		ctx.runtime.error(danger(`discord: recent history omitted for ${ctx.messageChannelId}: ${String(error)}`));
+		return [];
+	}
+}
+//#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.";
@@ -74,6 +183,7 @@ function normalizeDiscordDmOwnerEntry(entry) {
 async function buildDiscordMessageProcessContext(params) {
 	const { ctx, text, mediaList } = params;
 	const { cfg, discordConfig, accountId, runtime, botUserId, mediaMaxBytes, discordRestFetch, abortSignal, guildHistories, historyLimit, replyToMode, message, author, sender, canonicalMessageId, data, client, channelInfo, channelName, messageChannelId, isGuildMessage, isDirectMessage, isGroupDm, baseText, preflightAudioTranscript, threadChannel, threadParentId, threadParentName, threadParentType, threadName, displayChannelSlug, guildInfo, guildSlug, memberRoleIds, channelConfig, baseSessionKey, boundSessionKey, route, commandAuthorized, hasControlCommand, resolveChannelIngress } = ctx;
+	if (abortSignal?.aborted || ctx.isPolicyCurrent?.() === false) return null;
 	const fromLabel = isDirectMessage ? buildDirectLabel(author) : buildGuildLabel({
 		guild: data.guild ?? void 0,
 		channelName: channelName ?? messageChannelId,
@@ -100,7 +210,7 @@ async function buildDiscordMessageProcessContext(params) {
 		isGuild: isGuildMessage,
 		channelTopic: channelInfo?.topic
 	});
-	const pinnedMainDmOwner = isDirectMessage ? resolvePinnedMainDmOwnerFromAllowlist({
+	const pinnedMainDmOwner = isDirectMessage ? resolvePinnedMainDmOwnerFromAllowlist$1({
 		dmScope: cfg.session?.dmScope,
 		allowFrom: channelConfig?.users ?? guildInfo?.users,
 		normalizeEntry: normalizeDiscordDmOwnerEntry
@@ -119,10 +229,28 @@ async function buildDiscordMessageProcessContext(params) {
 	});
 	const storePath = resolveStorePath(cfg.session?.store, { agentId: route.agentId });
 	const envelopeOptions = resolveEnvelopeFormatOptions(cfg);
-	const previousTimestamp = readSessionUpdatedAt({
+	const routeSession = getSessionEntry({
+		agentId: route.agentId,
 		storePath,
-		sessionKey: route.sessionKey
+		sessionKey: route.sessionKey,
+		readConsistency: "latest"
 	});
+	const previousTimestamp = routeSession?.updatedAt;
+	const shouldIncludeChannelHistory = !isDirectMessage && (ctx.inboundEventKind === "room_event" || !(isGuildMessage && channelConfig?.autoThread && !threadChannel));
+	const recoversHistory = shouldIncludeChannelHistory && isGuildMessage && historyLimit > 0;
+	const historySessionScope = {
+		agentId: route.agentId,
+		storePath,
+		sessionKey: boundSessionKey ?? route.sessionKey,
+		readConsistency: "latest"
+	};
+	const historySession = recoversHistory ? historySessionScope.sessionKey === route.sessionKey ? routeSession : getSessionEntry(historySessionScope) : void 0;
+	const isHistoryCurrent = () => {
+		if (abortSignal?.aborted || ctx.isPolicyCurrent?.() === false) return false;
+		if (!recoversHistory) return true;
+		const current = getSessionEntry(historySessionScope);
+		return current?.sessionId === historySession?.sessionId && current?.lifecycleRevision === historySession?.lifecycleRevision && current?.sessionStartedAt === historySession?.sessionStartedAt && current?.updatedAt === 0 === (historySession?.updatedAt === 0);
+	};
 	const channelHistory = createChannelHistoryWindow({ historyMap: guildHistories });
 	let visibleChannelHistory;
 	const unavailableMediaCount = mediaList.filter((media) => !media.path).length;
@@ -142,20 +270,26 @@ async function buildDiscordMessageProcessContext(params) {
 		previousTimestamp,
 		envelope: envelopeOptions
 	});
-	const shouldIncludeChannelHistory = !isDirectMessage && (ctx.inboundEventKind === "room_event" || !(isGuildMessage && channelConfig?.autoThread && !threadChannel));
 	if (shouldIncludeChannelHistory) {
 		removeDiscordReplayHistoryEntry(guildHistories, messageChannelId, message.id);
 		if (historyLimit > 0) {
-			const filteredHistory = filterDiscordHistoryEntriesForContext({
-				entries: guildHistories.get(messageChannelId) ?? [],
+			if (isGuildMessage) visibleChannelHistory = historySession?.updatedAt === 0 ? [] : await recoverDiscordChannelHistory({
+				ctx,
+				sessionStartedAt: historySession?.sessionStartedAt,
+				isCurrent: isHistoryCurrent,
 				mode: contextVisibilityMode,
 				isSenderAllowed: isSupplementalContextSenderAllowed
 			});
-			visibleChannelHistory = filteredHistory.entries;
-			if (filteredHistory.omitted > 0) logVerbose(`discord: omit ${filteredHistory.omitted} pending history entries (mode=${contextVisibilityMode})`);
+			else visibleChannelHistory = filterDiscordHistoryEntriesForContext({
+				entries: guildHistories.get(messageChannelId) ?? [],
+				mode: contextVisibilityMode,
+				isSenderAllowed: isSupplementalContextSenderAllowed
+			}).entries.slice(-historyLimit);
+			if (!isHistoryCurrent()) return null;
 			combinedBody = buildHistoryContextFromEntries({
 				entries: visibleChannelHistory,
 				currentMessage: combinedBody,
+				historyKind: isGuildMessage ? "recent" : "pending",
 				formatEntry: (entry) => formatInboundEnvelope({
 					channel: "Discord",
 					from: fromLabel,
@@ -176,12 +310,6 @@ async function buildDiscordMessageProcessContext(params) {
 		tag: replyContext.senderTag,
 		memberRoleIds: replyContext.memberRoleIds
 	}) : true;
-	const replyVisible = evaluateSupplementalContextVisibility({
-		mode: contextVisibilityMode,
-		kind: "quote",
-		senderAllowed: replySenderAllowed
-	}).include;
-	if (replyContext && !replyVisible && isGuildMessage) logVerbose(`discord: drop reply context (mode=${contextVisibilityMode})`);
 	if (forumContextLine) combinedBody = `${combinedBody}\n${forumContextLine}`;
 	let threadStarterBody;
 	let threadLabel;
@@ -197,6 +325,7 @@ async function buildDiscordMessageProcessContext(params) {
 				parentType: threadParentType,
 				resolveTimestampMs
 			});
+			if (!isHistoryCurrent()) return null;
 			if (starter?.text) {
 				if (evaluateSupplementalContextVisibility({
 					mode: contextVisibilityMode,
@@ -235,6 +364,7 @@ async function buildDiscordMessageProcessContext(params) {
 		parentSessionKey,
 		useSuffix: false
 	});
+	if (!isHistoryCurrent()) return null;
 	const replyPlan = await resolveDiscordAutoThreadReplyPlan({
 		client,
 		message,
@@ -255,6 +385,7 @@ async function buildDiscordMessageProcessContext(params) {
 		groupScope: route.groupScope,
 		threadParentInheritanceEnabled
 	});
+	if (!isHistoryCurrent()) return null;
 	const deliverTarget = replyPlan.deliverTarget;
 	const replyTarget = replyPlan.replyTarget;
 	const replyReference = replyPlan.replyReference;
@@ -284,12 +415,15 @@ async function buildDiscordMessageProcessContext(params) {
 	const channelIngress = await resolveChannelIngress({
 		agentId: route.agentId,
 		sessionKey: effectiveSessionKey,
+		nativeChannelId: messageChannelId,
 		messageId: canonicalMessageId ?? message.id,
 		inboundEventKind: ctx.inboundEventKind
 	}, {
 		parentId: conversationParentId,
 		threadId: threadChannel?.id ?? autoThreadContext?.createdThreadId ?? void 0
 	});
+	if (!isHistoryCurrent()) return null;
+	const batchMessageIds = ctx.sourceMessageIds && ctx.sourceMessageIds.length > 1 ? [...ctx.sourceMessageIds] : void 0;
 	const ctxPayload = await (ctx.buildContext ?? buildChannelInboundEventContext)({
 		channelIngress,
 		channel: "discord",
@@ -326,9 +460,7 @@ async function buildDiscordMessageProcessContext(params) {
 			threadId: threadChannel?.id ?? autoThreadContext?.createdThreadId ?? void 0
 		},
 		route: {
-			agentId: route.agentId,
-			dmScope: route.dmScope,
-			accountId: route.accountId,
+			...route,
 			routeSessionKey: route.sessionKey,
 			dispatchSessionKey: effectiveSessionKey,
 			parentSessionKey: autoThreadContext?.ParentSessionKey ?? threadKeys.parentSessionKey,
@@ -336,6 +468,7 @@ async function buildDiscordMessageProcessContext(params) {
 		},
 		reply: {
 			to: effectiveTo,
+			replyToId: resolveDiscordReferencedReplyMessageId(message) ?? void 0,
 			...originatingTo !== effectiveTo ? { originatingTo } : {}
 		},
 		message: {
@@ -346,7 +479,10 @@ async function buildDiscordMessageProcessContext(params) {
 			commandBody: baseText,
 			inboundHistory
 		},
-		sessionTranscript: { historyLimit: shouldIncludeChannelHistory ? historyLimit : 0 },
+		sessionTranscript: {
+			historyLimit: shouldIncludeChannelHistory ? historyLimit : 0,
+			historyKind: isGuildMessage ? "recent" : "pending"
+		},
 		access: {
 			mentions: {
 				canDetectMention: ctx.canDetectMention,
@@ -363,7 +499,7 @@ async function buildDiscordMessageProcessContext(params) {
 		}),
 		media: await toInboundMediaFactsWithMetadata(mediaList, { transcribed: (_media, index) => index === preflightAudioIndex }),
 		supplemental: {
-			quote: replyContext && replyVisible ? {
+			quote: replyContext ? {
 				id: replyContext.id,
 				body: replyContext.body,
 				sender: replyContext.sender,
@@ -388,6 +524,10 @@ async function buildDiscordMessageProcessContext(params) {
 			groupSystemPrompt: isGuildMessage ? groupSystemPrompt : void 0
 		},
 		extra: {
+			MessageSids: batchMessageIds,
+			MessageSidFirst: batchMessageIds?.[0],
+			MessageSidLast: batchMessageIds?.at(-1),
+			ReplyThreading: resolveBatchedReplyThreadingPolicy(replyToMode, batchMessageIds !== void 0),
 			GroupThread: ctx.groupThread,
 			...preflightAudioTranscript !== void 0 ? { Transcript: preflightAudioTranscript } : {},
 			GroupSubject: isDirectMessage ? void 0 : groupChannel,
@@ -397,6 +537,7 @@ async function buildDiscordMessageProcessContext(params) {
 			OwnerAllowFrom: ownerAllowFrom
 		}
 	});
+	if (!isHistoryCurrent()) return null;
 	const persistedSessionKey = ctxPayload.SessionKey ?? route.sessionKey;
 	if (ctx.inboundEventKind === "room_event" && shouldIncludeChannelHistory) {
 		const historyText = [text, formatDiscordMediaText({
@@ -411,6 +552,7 @@ async function buildDiscordMessageProcessContext(params) {
 				body: historyText,
 				timestamp: resolveTimestampMs(message.timestamp),
 				messageId: message.id,
+				mediaIds: resolveDiscordHistoryMediaIds(message),
 				senderProvenance: createDiscordHistorySenderProvenance({
 					sender,
 					memberRoleIds
@@ -494,6 +636,7 @@ function createDiscordMessageProgressRuntime(params) {
 		onQueuedFollowupAdmitted: draftPreview.draftStream ? () => {
 			if (draftPreview.handleQueuedFollowupAdmitted()) params.onTurnReset();
 		} : void 0,
+		onQueuedFollowupSettled: draftPreview.draftStream ? () => draftPreview.cleanup() : 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,
@@ -524,10 +667,7 @@ function createDiscordMessageProgressRuntime(params) {
 			return await draftPreview.pushToolEvent(payload);
 		},
 		onItemEvent: async (payload) => {
-			if (payload.kind === "preamble") {
-				if (shouldYieldDraftCommentary()) return;
-				return await draftPreview.pushPreambleItemEvent(payload);
-			}
+			if (payload.kind === "preamble" && shouldYieldDraftCommentary()) return;
 			return await draftPreview.pushItemEvent(payload);
 		},
 		onPlanUpdate: async (payload) => {
@@ -540,12 +680,6 @@ function createDiscordMessageProgressRuntime(params) {
 		onApprovalEvent: async (payload) => {
 			return await draftPreview.pushApprovalEvent(payload);
 		},
-		onCommandOutput: async (payload) => {
-			return await draftPreview.pushCommandOutputEvent(payload);
-		},
-		onPatchSummary: async (payload) => {
-			return await draftPreview.pushPatchEvent(payload);
-		},
 		onCompactionStart: async () => {
 			if (!abortSignal?.aborted) await params.reactions.controller.setCompacting();
 			return false;
@@ -597,13 +731,6 @@ function queueInitialDiscordAckReaction(params) {
 }
 //#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, canDetectMention, effectiveWasMentioned, shouldBypassMention, route } = ctx;
@@ -645,10 +772,10 @@ function createDiscordMessageReactionRuntime(params) {
 	});
 	let statusReactionTarget = `${messageChannelId}/${message.id}`;
 	let statusReactionsActive = statusReactionsEnabled;
-	let statusReactions = createStatusReactionController({
-		enabled: statusReactionsEnabled,
-		adapter: discordAdapter,
-		initialEmoji: ackReaction,
+	const createController = (enabled, adapter, initialEmoji) => createStatusReactionController({
+		enabled,
+		adapter,
+		initialEmoji,
 		presentation: "acknowledgement",
 		onError: (err) => {
 			logAckFailure({
@@ -659,8 +786,9 @@ function createDiscordMessageReactionRuntime(params) {
 			});
 		}
 	});
+	let statusReactions = createController(statusReactionsEnabled, discordAdapter, ackReaction);
 	const resolveTrackedReactionChannelId = async (args) => {
-		const target = readToolStringArg(args, "channelId") ?? readToolStringArg(args, "channel_id") ?? readToolStringArg(args, "to");
+		const target = normalizeOptionalString(args.channelId) ?? normalizeOptionalString(args.channel_id) ?? normalizeOptionalString(args.to);
 		if (!target) return messageChannelId;
 		try {
 			return resolveDiscordChannelId(target);
@@ -675,11 +803,11 @@ function createDiscordMessageReactionRuntime(params) {
 	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;
+		if (normalizeOptionalString(args.action)?.toLowerCase() !== "react") return;
+		if (!(args.trackToolCalls === true || args.track_tool_calls === true)) return;
+		const emoji = normalizeOptionalString(args.emoji);
+		if (!emoji || args.remove === true) return;
+		const trackedMessageId = normalizeOptionalString(args.messageId) ?? normalizeOptionalString(args.message_id) ?? message.id;
 		let trackedChannelId;
 		try {
 			trackedChannelId = await resolveTrackedReactionChannelId(args);
@@ -687,31 +815,18 @@ function createDiscordMessageReactionRuntime(params) {
 			logAckFailure({
 				log: logVerbose,
 				channel: "discord",
-				target: `${readToolStringArg(args, "to") ?? readToolStringArg(args, "channelId") ?? messageChannelId}/${trackedMessageId}`,
+				target: `${normalizeOptionalString(args.to) ?? normalizeOptionalString(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,
-			presentation: "acknowledgement",
-			onError: (err) => {
-				logAckFailure({
-					log: logVerbose,
-					channel: "discord",
-					target: statusReactionTarget,
-					error: err
-				});
-			}
-		});
+		statusReactions = createController(true, createDiscordAckReactionAdapter({
+			channelId: trackedChannelId,
+			messageId: trackedMessageId,
+			reactionContext: ackReactionContext
+		}), emoji);
 		statusReactionsActive = true;
 		statusReactions.setQueued();
 	};
@@ -719,7 +834,6 @@ function createDiscordMessageReactionRuntime(params) {
 	const queueInitialAckReactionAfterRecord = () => {
 		if (initialAckReactionQueued) return;
 		initialAckReactionQueued = true;
-		if (statusReactionsEnabled) statusReactionsActive = true;
 		queueInitialDiscordAckReaction({
 			enabled: statusReactionsEnabled,
 			shouldSendAckReaction,
@@ -776,14 +890,14 @@ function createDiscordDraftStream(params) {
 		stopped: false,
 		final: false
 	};
-	let streamMessageId;
+	let streamMessage;
 	let lastSentText = "";
 	let streamGeneration = 0;
 	let activeCreateGeneration;
 	let discardActiveCreate = false;
-	let pendingCleanupMessages = [];
 	const sendOrEditStreamMessage = async ({ text, complete }) => {
 		const generation = streamGeneration;
+		const targetChannelId = channelId;
 		if (streamState.stopped && !streamState.final) return false;
 		const trimmed = text.trimEnd();
 		if (!trimmed) return false;
@@ -793,17 +907,18 @@ function createDiscordDraftStream(params) {
 			return false;
 		}
 		if (trimmed === lastSentText) return true;
-		if (streamMessageId === void 0 && minInitialChars != null && !streamState.final && !complete) {
+		if (streamMessage === void 0 && minInitialChars != null && !streamState.final && !complete) {
 			if (trimmed.length < minInitialChars) return false;
 		}
-		lastSentText = trimmed;
 		try {
-			if (streamMessageId !== void 0) {
-				await editChannelMessage(rest, channelId, streamMessageId, { body: {
-					content: trimmed,
-					allowed_mentions: DISCORD_PREVIEW_ALLOWED_MENTIONS,
-					...flags ? { flags } : {}
-				} });
+			const body = {
+				content: trimmed,
+				allowed_mentions: DISCORD_PREVIEW_ALLOWED_MENTIONS,
+				...flags ? { flags } : {}
+			};
+			if (streamMessage !== void 0) {
+				await editChannelMessage(rest, streamMessage.channelId, streamMessage.messageId, { body });
+				if (generation === streamGeneration) lastSentText = trimmed;
 				return true;
 			}
 			const replyToMessageId = resolveReplyToMessageId()?.trim();
@@ -812,20 +927,17 @@ function createDiscordDraftStream(params) {
 				fail_if_not_exists: false
 			} : void 0;
 			activeCreateGeneration = generation;
-			const sentMessageId = (await createChannelMessage(rest, channelId, { body: {
-				content: trimmed,
-				allowed_mentions: DISCORD_PREVIEW_ALLOWED_MENTIONS,
-				...flags ? { flags } : {},
+			const sentMessageId = (await createChannelMessage(rest, targetChannelId, { body: {
+				...body,
 				...messageReference ? { message_reference: messageReference } : {}
 			} }))?.id;
 			const shouldDiscardStaleCreate = activeCreateGeneration === generation && discardActiveCreate;
 			activeCreateGeneration = void 0;
 			discardActiveCreate = false;
 			if (generation !== streamGeneration) {
-				if (shouldDiscardStaleCreate && typeof sentMessageId === "string" && sentMessageId) await deleteCleanupMessage({
-					channelId,
-					messageId: sentMessageId,
-					warnPrefix: "discord stale stream preview cleanup failed"
+				if (shouldDiscardStaleCreate && typeof sentMessageId === "string" && sentMessageId) await lifecycle.retire({
+					channelId: targetChannelId,
+					messageId: sentMessageId
 				});
 				return true;
 			}
@@ -834,7 +946,11 @@ function createDiscordDraftStream(params) {
 				params.warn?.("discord stream preview stopped (missing message id from send)");
 				return false;
 			}
-			streamMessageId = sentMessageId;
+			streamMessage = {
+				channelId: targetChannelId,
+				messageId: sentMessageId
+			};
+			lastSentText = trimmed;
 			return true;
 		} catch (err) {
 			if (activeCreateGeneration === generation) {
@@ -847,7 +963,12 @@ function createDiscordDraftStream(params) {
 			return false;
 		}
 	};
-	const { loop, update: updateDraft, stop, discardPending, seal } = createFinalizableDraftStreamControlsForState({
+	const clearMessageId = () => {
+		streamMessage = void 0;
+		lastSentText = "";
+		loop.resetThrottleWindow();
+	};
+	const lifecycle = createFinalizableDraftLifecycle({
 		throttleMs,
 		coalesceInFlight: true,
 		state: streamState,
@@ -856,8 +977,15 @@ function createDiscordDraftStream(params) {
 			text: "",
 			complete: false
 		},
-		isEmpty: (value) => !value.text
+		isEmpty: (value) => !value.text,
+		readMessageId: () => streamMessage,
+		clearMessageId,
+		isValidMessageId: (value) => value !== void 0,
+		deleteMessage: (message) => deleteChannelMessage(rest, message.channelId, message.messageId),
+		warn: params.warn,
+		warnPrefix: "discord stream preview cleanup failed"
 	});
+	const { loop, update: updateDraft, stop, discardPending, seal } = lifecycle;
 	const update = (text, options) => updateDraft({
 		text,
 		complete: options?.complete === true
@@ -867,35 +995,21 @@ function createDiscordDraftStream(params) {
 		streamGeneration += 1;
 		streamState.stopped = false;
 		streamState.final = false;
-		streamMessageId = void 0;
+		streamMessage = void 0;
 		lastSentText = "";
 		loop.resetPending();
 		loop.resetThrottleWindow();
 	};
-	const deleteCleanupMessage = async (message) => {
-		try {
-			await deleteChannelMessage(rest, message.channelId, message.messageId);
-		} catch (err) {
-			pendingCleanupMessages.push(message);
-			params.warn?.(`${message.warnPrefix}: ${formatErrorMessage(err)}`);
-		}
-	};
-	const cleanupPendingMessages = async () => {
-		const pending = pendingCleanupMessages;
-		pendingCleanupMessages = [];
-		for (const message of pending) await deleteCleanupMessage(message);
-	};
 	const retarget = async (nextChannelId) => {
 		const normalized = nextChannelId.trim();
 		if (!normalized || normalized === channelId) return;
 		await loop.waitForInFlight();
 		const pending = loop.takePending();
-		const previousChannelId = channelId;
-		const previousMessageId = streamMessageId;
+		const previousMessage = streamMessage;
 		const previousText = pending.text || lastSentText;
 		streamGeneration += 1;
 		channelId = normalized;
-		streamMessageId = void 0;
+		streamMessage = void 0;
 		lastSentText = "";
 		streamState.stopped = false;
 		streamState.final = false;
@@ -904,49 +1018,40 @@ function createDiscordDraftStream(params) {
 			update(previousText, { complete: pending.text ? pending.complete : true });
 			await loop.flush();
 		}
-		if (previousMessageId) {
-			const stale = {
-				channelId: previousChannelId,
-				messageId: previousMessageId,
-				warnPrefix: "discord stream preview retarget cleanup failed"
-			};
-			if (!streamMessageId) {
-				pendingCleanupMessages.push(stale);
+		if (previousMessage) {
+			if (!streamMessage) {
+				await lifecycle.retire(previousMessage, { defer: true });
 				throw new Error("discord stream preview retarget replacement failed");
 			}
-			await deleteCleanupMessage(stale);
+			await lifecycle.retire(previousMessage);
 		}
 	};
-	const deleteCurrentMessage = async () => {
-		loop.resetPending();
-		await loop.waitForInFlight();
-		const currentMessage = streamMessageId ? {
-			channelId,
-			messageId: streamMessageId,
-			warnPrefix: "discord stream preview cleanup failed"
-		} : void 0;
-		streamMessageId = void 0;
-		lastSentText = "";
-		loop.resetThrottleWindow();
-		if (!currentMessage) return;
-		await deleteCleanupMessage(currentMessage);
-	};
-	const clear = async () => {
-		await discardPending();
-		await deleteCurrentMessage();
+	const retireCurrentMessage = async (stopForClear) => {
+		const generation = streamGeneration;
+		await stopForClear();
+		if (generation !== streamGeneration) return;
+		const message = streamMessage;
+		clearMessageId();
+		if (message) await lifecycle.retire(message);
 	};
 	params.log?.(`discord stream preview ready (maxChars=${maxChars}, throttleMs=${throttleMs})`);
 	return {
 		update,
 		flush: loop.flush,
-		messageId: () => streamMessageId,
-		clear,
-		deleteCurrentMessage,
+		messageId: () => streamMessage?.messageId,
+		lastDeliveredText: () => lastSentText,
+		clear: () => retireCurrentMessage(discardPending),
+		deleteCurrentMessage: () => retireCurrentMessage(async () => {
+			loop.resetPending();
+			await loop.waitForInFlight();
+		}),
 		discardPending,
 		seal,
 		stop,
 		retarget,
-		cleanupPendingMessages,
+		cleanupPendingMessages: async () => {
+			await lifecycle.cleanupPending();
+		},
 		forceNewMessage
 	};
 }
@@ -985,15 +1090,12 @@ function createDiscordDraftPreviewController(params) {
 	let lastPartialText = "";
 	let draftText = "";
 	let hasStreamedAssistantText = false;
-	let finalizedViaPreviewMessage = false;
-	let finalReplyError;
-	let progressDraftStartedBeforeFinal = false;
-	let progressDraftCollapsed = false;
 	let progressNarratorLifecycle;
 	const narrationProgressEnabled = Boolean(draftStream) && discordStreamMode === "progress" && resolveChannelStreamingProgressNarration(params.discordConfig);
 	const narrationHideCommandText = narrationProgressEnabled && resolveChannelStreamingPreviewCommandText(params.discordConfig) === "status";
 	const progressSeed = `${params.accountId}:${params.deliverChannelId}`;
 	const progressDraft = createChannelProgressDraftCompositor({
+		preparedItems: true,
 		entry: params.discordConfig,
 		mode: discordStreamMode,
 		active: Boolean(draftStream),
@@ -1019,6 +1121,44 @@ function createDiscordDraftPreviewController(params) {
 		isEmptyLine: isEmptyDiscordProgressLine,
 		shouldStartNow: shouldStartDiscordProgressDraftNow
 	});
+	const freezeProgress = () => {
+		progressDraft.markFinalReplyStarted();
+		progressNarratorLifecycle?.stopTurn();
+	};
+	const flush = async () => {
+		if (!draftStream) return;
+		if (draftChunker?.hasBuffered()) {
+			draftChunker.drain({
+				force: true,
+				emit: (chunk) => {
+					draftText += chunk;
+				}
+			});
+			draftChunker.reset();
+			if (draftText) draftStream.update(draftText);
+		}
+		await draftStream.flush();
+	};
+	const lifecycle = createLivePreviewLifecycle({
+		draft: draftStream ? {
+			flush,
+			id: draftStream.messageId,
+			seal: draftStream.seal,
+			discardPending: draftStream.discardPending,
+			clear: draftStream.clear
+		} : void 0,
+		retainOnError: true,
+		cleanupUndelivered: true,
+		onFinalStarted: () => {
+			freezeProgress();
+			params.onFinalReplyStart?.();
+		},
+		onFinalDelivered: () => {
+			progressDraft.markFinalReplyDelivered();
+			params.onFinalReplyDelivered?.();
+		},
+		onCleanupFailure: (err) => params.log(`discord: draft cleanup failed: ${String(err)}`)
+	});
 	const resetProgressState = () => {
 		lastPartialText = "";
 		draftText = "";
@@ -1036,10 +1176,7 @@ function createDiscordDraftPreviewController(params) {
 		const beganNewTurn = progressDraft.beginNewTurn(options);
 		if (!beganNewTurn) progressDraft.beginAssistantMessage();
 		if (beganNewTurn) {
-			progressDraftCollapsed = false;
-			progressDraftStartedBeforeFinal = false;
-			finalReplyError = void 0;
-			finalizedViaPreviewMessage = false;
+			lifecycle.reset();
 			progressNarratorLifecycle?.beginTurn();
 		}
 		if (discordStreamMode === "progress") {
@@ -1049,6 +1186,7 @@ function createDiscordDraftPreviewController(params) {
 	};
 	return {
 		draftStream,
+		lifecycle,
 		narrationProgressEnabled,
 		narrationHideCommandText,
 		commentaryProgressEnabled: progressDraft.commentaryProgressEnabled,
@@ -1056,36 +1194,48 @@ function createDiscordDraftPreviewController(params) {
 		get isProgressMode() {
 			return discordStreamMode === "progress";
 		},
-		get hasProgressDraftStarted() {
-			return progressDraft.hasStarted;
-		},
 		get isProgressDraftVisible() {
 			return progressDraft.isVisible;
 		},
-		get hasProgressDraftToCollapse() {
-			return !progressDraftCollapsed && (progressDraft.hasStarted || progressDraftStartedBeforeFinal);
-		},
-		markProgressDraftCollapsed() {
-			progressDraftCollapsed = true;
-			progressDraftStartedBeforeFinal = false;
-		},
-		get finalizedViaPreviewMessage() {
-			return finalizedViaPreviewMessage;
-		},
-		setProgressNarratorLifecycle(lifecycle) {
-			progressNarratorLifecycle = lifecycle;
-		},
-		markFinalReplyStarted() {
-			progressDraftStartedBeforeFinal ||= progressDraft.hasStarted;
-			progressDraft.markFinalReplyStarted();
-			progressNarratorLifecycle?.stopTurn();
-		},
-		markFinalReplyDelivered(isError = false) {
-			finalReplyError = isError;
-			progressDraft.markFinalReplyDelivered();
+		setProgressNarratorLifecycle(narratorLifecycle) {
+			progressNarratorLifecycle = narratorLifecycle;
 		},
-		markPreviewFinalized() {
-			finalizedViaPreviewMessage = true;
+		freezeProgress,
+		async adoptProgressContinuation(payload, info, target) {
+			const adopt = info.adoptProgressContinuation;
+			if (!draftStream || discordStreamMode !== "progress" || !adopt || info.kind !== "final" || payload.isError || payload.isCommentary || resolveSendableOutboundReplyParts(payload).hasMedia || payload.interactive !== void 0 || payload.presentation !== void 0 || payload.channelData !== void 0) return false;
+			const snapshot = progressDraft.getSnapshot();
+			if (!snapshot.statusHeadline && !snapshot.plan?.length && !snapshot.lines.length) return false;
+			const assertCurrent = () => {
+				params.abortSignal?.throwIfAborted();
+				info.assertPlatformSendAuthorized?.();
+			};
+			return await withDiscordRequestAuthority(assertCurrent, async () => {
+				assertCurrent();
+				freezeProgress();
+				const text = progressDraft.getText().trimEnd();
+				draftStream.update(text, { complete: true });
+				await draftStream.flush();
+				assertCurrent();
+				const messageId = draftStream.messageId();
+				if (!messageId || !text || draftStream.lastDeliveredText() !== text) return false;
+				if (!await adopt({
+					channel: "discord",
+					accountId: params.accountId,
+					...target,
+					messageId,
+					text,
+					snapshot
+				})) return false;
+				if (draftStream.messageId() === messageId) {
+					lifecycle.retainPreview();
+					draftStream.forceNewMessage();
+					progressDraft.markFinalReplyDelivered();
+					resetProgressState();
+					await draftStream.discardPending();
+				}
+				return true;
+			});
 		},
 		async retarget(channelId) {
 			await draftStream?.retarget(channelId);
@@ -1094,43 +1244,18 @@ function createDiscordDraftPreviewController(params) {
 			if (!draftStream || discordStreamMode !== "progress") return false;
 			const progressText = lastPartialText.trimEnd();
 			if (!progressText) return false;
+			lifecycle.retainPreview();
 			draftStream.update(progressText);
 			await draftStream.stop();
-			if (!draftStream.messageId()) return false;
-			finalizedViaPreviewMessage = true;
-			return true;
+			return Boolean(draftStream.messageId());
 		},
 		disableBlockStreamingForDraft: draftStream ? true : void 0,
 		pushToolEvent: progressDraft.pushToolEvent,
-		pushItemEvent: progressDraft.pushItemEvent,
+		pushItemEvent: progressDraft.pushItemEvent.bind(progressDraft),
 		pushApprovalEvent: progressDraft.pushApprovalEvent.bind(progressDraft),
-		pushCommandOutputEvent: progressDraft.pushCommandOutputEvent,
-		pushPatchEvent: progressDraft.pushPatchEvent,
 		pushPlanProgress: progressDraft.pushPlanProgress.bind(progressDraft),
 		pushReasoningProgress: progressDraft.pushReasoningProgress.bind(progressDraft),
 		pushNarrationProgress: progressDraft.pushNarrationProgress.bind(progressDraft),
-		async pushPreambleItemEvent(payload) {
-			const headlineAccepted = await progressDraft.pushPreambleHeadline(payload.progressText, { itemId: payload.itemId });
-			if (!progressDraft.commentaryProgressEnabled) return headlineAccepted;
-			const commentaryAccepted = await progressDraft.pushCommentaryProgress(payload.progressText, { itemId: payload.itemId });
-			return headlineAccepted || commentaryAccepted;
-		},
-		resolvePreviewFinalText(text) {
-			if (typeof text !== "string") return;
-			const formatted = convertMarkdownTables(stripInlineDirectiveTagsForDelivery(text).text, params.tableMode);
-			const chunks = chunkDiscordTextWithMode(formatted, {
-				maxChars: draftMaxChars,
-				maxLines: params.maxLinesPerMessage,
-				chunkMode: params.chunkMode
-			});
-			if (!chunks.length && formatted) chunks.push(formatted);
-			if (chunks.length !== 1) return;
-			const trimmed = expectDefined(chunks.at(0), "single Discord preview chunk").trim();
-			if (!trimmed) return;
-			const currentPreviewText = discordStreamMode === "block" ? draftText : lastPartialText;
-			if (currentPreviewText && currentPreviewText.startsWith(trimmed) && trimmed.length < currentPreviewText.length) return;
-			return trimmed;
-		},
 		updateFromPartial(text) {
 			if (!draftStream || !text) return;
 			const cleaned = stripInlineDirectiveTagsForDelivery(stripReasoningTagsFromText(text, {
@@ -1177,25 +1302,11 @@ function createDiscordDraftPreviewController(params) {
 		handleQueuedFollowupAdmitted() {
 			return beginNewProgressTurn({ force: true });
 		},
-		async flush() {
-			if (!draftStream) return;
-			if (draftChunker?.hasBuffered()) {
-				draftChunker.drain({
-					force: true,
-					emit: (chunk) => {
-						draftText += chunk;
-					}
-				});
-				draftChunker.reset();
-				if (draftText) draftStream.update(draftText);
-			}
-			await draftStream.flush();
-		},
-		async cleanup({ finalDeliveryFailed = false } = {}) {
+		flush,
+		async cleanup({ failed = false } = {}) {
 			try {
 				progressDraft.cancel();
-				if (finalReplyError !== false) await draftStream?.discardPending();
-				if (!(discordStreamMode === "progress" && finalDeliveryFailed) && finalReplyError !== true && !finalizedViaPreviewMessage && draftStream?.messageId()) await draftStream.clear();
+				await lifecycle.cleanup({ failed });
 				await draftStream?.cleanupPendingMessages();
 			} catch (err) {
 				params.log(`discord: draft cleanup failed: ${String(err)}`);
@@ -1260,7 +1371,7 @@ function createDiscordBeforePayloadDelivery(params) {
 		}
 		if (payload.isReasoning || payload.isCommentary) return payload;
 		if (params.draftPreview.draftStream && params.draftPreview.isProgressMode && info.kind === "block" && !resolveSendableOutboundReplyParts(payload).hasMedia && !payload.isError) return null;
-		if (info.kind === "final" && !params.isFallbackOnlyToolWarningFinal(payload)) params.draftPreview.markFinalReplyStarted();
+		if (info.kind === "final" && !params.isFallbackOnlyToolWarningFinal(payload)) params.draftPreview.freezeProgress();
 		return payload;
 	};
 }
@@ -1268,13 +1379,13 @@ 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;
+	const deliverChannelId = deliverTarget.startsWith("channel:") ? deliverTarget.slice(8) : messageChannelId;
 	let typingFeedback;
 	const getTypingFeedback = () => typingFeedback ??= createDiscordReplyTypingFeedback({
 		cfg,
 		token,
 		accountId,
-		channelId: typingChannelId,
+		channelId: deliverChannelId,
 		rest: params.feedbackRest,
 		log: logVerbose,
 		keepaliveIntervalMs: params.shouldDisableCoreTypingKeepalive ? void 0 : 0
@@ -1338,7 +1449,6 @@ function createDiscordMessageReplyRuntime(params) {
 			return;
 		}
 	};
-	const deliverChannelId = deliverTarget.startsWith("channel:") ? deliverTarget.slice(8) : messageChannelId;
 	return {
 		replyPipeline,
 		onModelSelected,
@@ -1348,20 +1458,19 @@ function createDiscordMessageReplyRuntime(params) {
 		beginQueuedDeliveryCorrelation: beginDeliveryCorrelation,
 		endDeliveryCorrelation,
 		resolveCurrentTurnTranscriptFinalText,
-		deliverChannelId,
 		draftPreview: createDiscordDraftPreviewController({
 			groupThread: Boolean(ctxPayload.GroupThread),
 			cfg,
 			discordConfig,
 			accountId,
+			abortSignal: ctx.abortSignal,
 			sourceRepliesAreToolOnly: params.sourceRepliesAreToolOnly,
 			textLimit,
 			deliveryRest: params.deliveryRest,
 			deliverChannelId,
 			replyReference,
-			tableMode,
-			maxLinesPerMessage,
-			chunkMode,
+			onFinalReplyStart: params.onFinalReplyStart,
+			onFinalReplyDelivered: params.onFinalReplyDelivered,
 			log: logVerbose
 		}),
 		resolvedBlockStreamingEnabled: resolveChannelStreamingBlockEnabled(discordConfig)
@@ -1412,15 +1521,22 @@ function isFallbackOnlyToolWarningFinal(payload) {
 }
 async function processDiscordMessage(ctx, observer) {
 	const dispatchStartedAt = Date.now();
-	const { cfg, accountId, token, runtime, textLimit, replyToMode, message, messageChannelId, isGuildMessage, isDirectMessage, isGroupDm, messageText, threadBindings, route, abortSignal, turnAdoptionLifecycle, preparedMedia: mediaList } = ctx;
-	if (abortSignal?.aborted) return;
+	const { cfg, accountId, token, runtime, textLimit, replyToMode, message, messageChannelId, isGuildMessage, isDirectMessage, isGroupDm, messageText, threadBindings, route, abortSignal, isPolicyCurrent, turnAdoptionLifecycle, preparedMedia: mediaList } = ctx;
+	if (abortSignal?.aborted || isPolicyCurrent?.() === false) 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 });
+	if (boundThreadId && typeof threadBindings.touchThread === "function") {
+		try {
+			await threadBindings.touchThread({ threadId: boundThreadId });
+		} catch (error) {
+			runtime.error(danger(`discord: failed to refresh thread binding activity (${boundThreadId}): ${String(error)}`));
+		}
+		if (abortSignal?.aborted || isPolicyCurrent?.() === false) return;
+	}
 	const sourceReplyDeliveryMode = resolveChannelMessageSourceReplyDeliveryMode({
 		cfg,
 		ctx: {
@@ -1460,7 +1576,7 @@ async function processDiscordMessage(ctx, observer) {
 		createdThreadId: replyPlan.createdThreadId,
 		sessionKey: persistedSessionKey
 	});
-	const { replyPipeline, onModelSelected, tableMode, maxLinesPerMessage, chunkMode, beginQueuedDeliveryCorrelation, endDeliveryCorrelation, resolveCurrentTurnTranscriptFinalText, deliverChannelId: initialDeliverChannelId, draftPreview, resolvedBlockStreamingEnabled } = createDiscordMessageReplyRuntime({
+	const { replyPipeline, onModelSelected, tableMode, maxLinesPerMessage, chunkMode, beginQueuedDeliveryCorrelation, endDeliveryCorrelation, resolveCurrentTurnTranscriptFinalText, draftPreview, resolvedBlockStreamingEnabled } = createDiscordMessageReplyRuntime({
 		ctx,
 		processContext: {
 			...processContext,
@@ -1471,40 +1587,29 @@ async function processDiscordMessage(ctx, observer) {
 		isRoomEvent,
 		dispatchStartedAt,
 		feedbackRest: reactions.feedbackRest,
-		deliveryRest: reactions.deliveryRest
+		deliveryRest: reactions.deliveryRest,
+		onFinalReplyStart: observer?.onFinalReplyStart,
+		onFinalReplyDelivered: observer?.onFinalReplyDelivered
 	});
-	let deliverChannelId = initialDeliverChannelId;
+	let deliverThreadId = ctxPayload.MessageThreadId;
 	activeThreadRoute.bindThreadAdoption(async (threadId) => {
 		deliverTarget = `channel:${threadId}`;
-		deliverChannelId = threadId;
+		deliverThreadId = threadId;
 		await draftPreview.retarget(threadId);
 	});
-	let finalReplyStartNotified = false;
-	const notifyFinalReplyStart = () => {
-		if (finalReplyStartNotified) return;
-		finalReplyStartNotified = true;
-		draftPreview.markFinalReplyStarted();
-		observer?.onFinalReplyStart?.();
+	const { lifecycle } = draftPreview;
+	const observeFinalDelivery = async () => {
+		if (lifecycle.finalSucceeded) return;
+		draftPreview.freezeProgress();
+		const retainedProgress = activeThreadRoute.threadReplyDelivered && !lifecycle.previewFinalized ? draftPreview.finalizeProgressDraft().catch((error) => {
+			logVerbose(`discord: failed to finalize adopted thread progress (${String(error)})`);
+		}) : void 0;
+		await lifecycle.observeDelivery({ visibleReplySent: true });
+		await retainedProgress;
 	};
-	let userFacingFinalDelivered = false;
-	let userFacingFinalDeliveryFailed = false;
 	let pendingToolWarningFinal;
-	const markFinalReplyDelivered = (isError = false) => {
-		draftPreview.markFinalReplyDelivered(isError);
-		if (!isError) {
-			userFacingFinalDelivered = true;
-			userFacingFinalDeliveryFailed = false;
-			pendingToolWarningFinal = void 0;
-			observer?.onFinalReplyDelivered?.();
-		}
-	};
-	let clearProgressDraftAfterFinalDelivery = false;
 	const resetDeliveryState = () => {
-		finalReplyStartNotified = false;
-		userFacingFinalDelivered = false;
-		userFacingFinalDeliveryFailed = false;
 		pendingToolWarningFinal = void 0;
-		clearProgressDraftAfterFinalDelivery = false;
 	};
 	const progress = createDiscordMessageProgressRuntime({
 		ctx,
@@ -1544,7 +1649,6 @@ async function processDiscordMessage(ctx, observer) {
 			token,
 			accountId,
 			rest: reactions.deliveryRest,
-			runtime,
 			replyToMode,
 			textLimit,
 			maxLinesPerMessage,
@@ -1589,14 +1693,14 @@ async function processDiscordMessage(ctx, observer) {
 			return result;
 		}
 		if (isFinal && !options?.allowFallbackOnlyToolWarning && isFallbackOnlyToolWarningFinal(payload)) {
-			if (!userFacingFinalDelivered && (!finalReplyStartNotified || userFacingFinalDeliveryFailed)) pendingToolWarningFinal = {
+			if (!lifecycle.finalSucceeded && !lifecycle.previewFinalized && (!lifecycle.finalStarted || lifecycle.finalFailed)) pendingToolWarningFinal = {
 				payload,
 				info,
 				deliverySession
 			};
 			return { visibleReplySent: false };
 		}
-		if (isFinal) draftPreview.markFinalReplyStarted();
+		if (isFinal) draftPreview.freezeProgress();
 		const finalText = isFinal && !ctxPayload.GroupThread && typeof payload.text === "string" ? await resolveTranscriptBackedChannelFinalText({
 			payload,
 			finalText: payload.text,
@@ -1616,104 +1720,56 @@ async function processDiscordMessage(ctx, observer) {
 			}));
 			return { visibleReplySent: false };
 		}
+		if (await draftPreview.adoptProgressContinuation(deliverablePayload, info, {
+			to: isDirectMessage ? ctxPayload.OriginatingTo ?? ctxPayload.To ?? deliverTarget : deliverTarget,
+			threadId: deliverThreadId
+		})) {
+			replyReference.markSent();
+			return { visibleReplySent: true };
+		}
 		if (isFinal && !replyLifecycleStarted && !isRoomEvent && configuredTypingMode !== "never") await onDiscordReplyStart();
 		const draftStream = draftPreview.draftStream;
 		if (draftStream && draftPreview.isProgressMode && info.kind === "block" && !deliverablePayload.isCommentary && !options?.allowProgressBlock) {
 			if (!resolveSendableOutboundReplyParts(deliverablePayload).hasMedia && !deliverablePayload.isError) return { visibleReplySent: false };
 		}
-		if (draftStream && isFinal && draftPreview.isProgressMode && !deliverablePayload.isError && draftPreview.hasProgressDraftToCollapse && draftStream) {
-			await draftPreview.flush();
-			clearProgressDraftAfterFinalDelivery = true;
-		}
-		if (draftStream && isFinal && !draftPreview.isProgressMode && !deliverablePayload.isError) {
-			const ttsSupplement = getReplyPayloadTtsSupplement(deliverablePayload);
-			if ((await deliverWithFinalizableLivePreviewAdapter({
-				kind: info.kind,
-				payload: deliverablePayload,
-				adapter: defineFinalizableLivePreviewAdapter({
-					draft: {
-						flush: () => draftPreview.flush(),
-						clear: () => draftStream.clear(),
-						discardPending: () => draftStream.discardPending(),
-						seal: () => draftStream.seal(),
-						id: draftStream.messageId
-					},
-					buildFinalEdit: () => {},
-					editFinal: async (previewMessageId, edit) => {
-						if (abortSignal?.aborted) throw new Error("process aborted");
-						notifyFinalReplyStart();
-						await editMessageDiscord(deliverChannelId, previewMessageId, edit, {
-							cfg,
-							accountId,
-							rest: reactions.deliveryRest
-						});
-					},
-					onPreviewFinalized: () => {
-						markFinalReplyDelivered();
-						draftPreview.markPreviewFinalized();
-						replyReference.markSent();
-					},
-					logPreviewEditFailure: (err) => {
-						logVerbose(`discord: preview final edit failed; falling back to standard send (${String(err)})`);
-					}
-				}),
-				deliverNormally: async () => {
-					if (abortSignal?.aborted) return false;
-					const fallbackPayload = ttsSupplement && ttsSupplement.visibleTextAlreadyDelivered !== true && !deliverablePayload.text?.trim() ? {
-						...deliverablePayload,
-						text: ttsSupplement.spokenText
-					} : deliverablePayload;
-					const allowedMentions = discordTextHasBroadcastMention(fallbackPayload.text ?? "") ? TARGETED_ONLY_ALLOWED_MENTIONS : void 0;
-					const replyToId = replyReference.use();
-					notifyFinalReplyStart();
-					return (await deliverDiscordReply({
-						...deliveryOptions,
-						replies: [fallbackPayload],
+		let deliveryResult = { visibleReplySent: false };
+		await lifecycle.deliver({
+			kind: info.kind,
+			payload: deliverablePayload,
+			isError: deliverablePayload.isError === true,
+			deliverNormally: async () => {
+				if (abortSignal?.aborted) {
+					logVerbose(formatDiscordReplySkip({
+						kind: info.kind,
+						reason: "aborted before delivery",
 						target: deliverTarget,
-						replyToId,
-						allowedMentions,
-						kind: info.kind
-					})).visibleReplySent;
-				},
-				onNormalDelivered: () => {
-					markFinalReplyDelivered();
-					replyReference.markSent();
+						sessionKey: ctxPayload.SessionKey
+					}));
+					return deliveryResult;
 				}
-			})).kind !== "normal-skipped") return { visibleReplySent: true };
-		}
-		if (abortSignal?.aborted) {
-			logVerbose(formatDiscordReplySkip({
-				kind: info.kind,
-				reason: "aborted before delivery",
-				target: deliverTarget,
-				sessionKey: ctxPayload.SessionKey
-			}));
-			return { visibleReplySent: false };
-		}
-		const replyToId = replyReference.use();
-		if (isFinal) notifyFinalReplyStart();
-		const result = await deliverDiscordReply({
-			...deliveryOptions,
-			replies: [deliverablePayload],
-			target: deliverTarget,
-			replyToId,
-			kind: info.kind
+				const freshPreviewFinal = draftStream && isFinal && !draftPreview.isProgressMode && !deliverablePayload.isError;
+				const ttsSupplement = freshPreviewFinal ? getReplyPayloadTtsSupplement(deliverablePayload) : void 0;
+				const finalPayload = ttsSupplement && ttsSupplement.visibleTextAlreadyDelivered !== true && !deliverablePayload.text?.trim() ? {
+					...deliverablePayload,
+					text: ttsSupplement.spokenText
+				} : deliverablePayload;
+				const allowedMentions = freshPreviewFinal && discordTextHasBroadcastMention(finalPayload.text ?? "") ? TARGETED_ONLY_ALLOWED_MENTIONS : void 0;
+				deliveryResult = await deliverDiscordReply({
+					...deliveryOptions,
+					replies: [finalPayload],
+					target: deliverTarget,
+					replyToId: replyReference.use(),
+					allowedMentions,
+					kind: info.kind
+				});
+				return deliveryResult;
+			},
+			onNormalDelivered: () => replyReference.markSent()
 		});
-		if (!result.visibleReplySent) return result;
-		replyReference.markSent();
-		if (isFinal) {
-			markFinalReplyDelivered(deliverablePayload.isError === true);
-			if (deliverablePayload.isError !== true && clearProgressDraftAfterFinalDelivery) {
-				clearProgressDraftAfterFinalDelivery = false;
-				draftPreview.markProgressDraftCollapsed();
-				await draftStream?.discardPending();
-				await draftStream?.clear();
-			}
-		}
-		return result;
+		return deliveryResult;
 	};
 	const onDiscordDeliveryError = (err, info) => {
-		if (info.kind === "final" && finalReplyStartNotified && !userFacingFinalDelivered) userFacingFinalDeliveryFailed = true;
+		if (info.kind === "final") lifecycle.observeFailure();
 		runtime.error(danger(formatDiscordReplyDeliveryFailure({
 			kind: info.kind,
 			err,
@@ -1725,7 +1781,7 @@ async function processDiscordMessage(ctx, observer) {
 	let dispatchError = false;
 	let dispatchAborted = false;
 	const deliverPendingToolWarningFinalIfNeeded = async () => {
-		if (!pendingToolWarningFinal || userFacingFinalDelivered || abortSignal?.aborted) return;
+		if (!pendingToolWarningFinal || lifecycle.finalSucceeded || lifecycle.previewFinalized || abortSignal?.aborted) return;
 		const pending = pendingToolWarningFinal;
 		pendingToolWarningFinal = void 0;
 		try {
@@ -1740,7 +1796,7 @@ async function processDiscordMessage(ctx, observer) {
 		}
 	};
 	try {
-		if (abortSignal?.aborted) {
+		if (abortSignal?.aborted || isPolicyCurrent?.() === false) {
 			dispatchAborted = true;
 			return;
 		}
@@ -1795,6 +1851,7 @@ async function processDiscordMessage(ctx, observer) {
 				disableBlockStreaming: sourceRepliesAreToolOnly ? true : draftPreview.disableBlockStreamingForDraft ?? (typeof resolvedBlockStreamingEnabled === "boolean" ? !resolvedBlockStreamingEnabled : void 0),
 				onPartialReply: draftPreview.draftStream && !draftPreview.isProgressMode ? (payload) => draftPreview.updateFromPartial(payload.text) : void 0,
 				...progress.replyOptions,
+				onObservedReplyDelivery: observeFinalDelivery,
 				onModelSelected
 			}
 		});
@@ -1804,15 +1861,7 @@ async function processDiscordMessage(ctx, observer) {
 			dispatchAborted = true;
 			return;
 		}
-		if (activeThreadRoute.threadReplyDelivered && !userFacingFinalDelivered) {
-			draftPreview.markFinalReplyStarted();
-			if (draftPreview.hasProgressDraftToCollapse) try {
-				await draftPreview.finalizeProgressDraft();
-			} catch (error) {
-				logVerbose(`discord: failed to finalize adopted thread progress (${String(error)})`);
-			}
-			markFinalReplyDelivered();
-		}
+		if (activeThreadRoute.threadReplyDelivered) await observeFinalDelivery();
 	} catch (err) {
 		if (abortSignal?.aborted) {
 			dispatchAborted = true;
@@ -1832,10 +1881,10 @@ async function processDiscordMessage(ctx, observer) {
 	} finally {
 		activeThreadRoute.end();
 		endDeliveryCorrelation();
-		await draftPreview.cleanup({ finalDeliveryFailed: userFacingFinalDeliveryFailed });
 		dispatchError ||= readAgentRunTerminalOutcome(dispatchResult) === "failed";
 		const finalReceipt = dispatchResult?.settledReceipt?.counts.final;
 		const finalDeliveryFailed = (finalReceipt?.failedBeforeSend ?? 0) + (finalReceipt?.failedAfterSend ?? 0) > 0;
+		await draftPreview.cleanup({ failed: finalDeliveryFailed || dispatchError });
 		await reactions.finish({
 			dispatchAborted,
 			dispatchError,
@@ -1851,4 +1900,4 @@ async function processDiscordMessage(ctx, observer) {
 	}
 }
 //#endregion
-export { formatDiscordReplySkip, processDiscordMessage };
+export { processDiscordMessage };