@openclaw/discord 2026.9.5 → 2026.9.6

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

@@ -1,21 +1,20 @@
-import { ft as editChannelMessage, st as createChannelMessage, t as discord_exports, ut as deleteChannelMessage } from "./discord-BXpHW-cu.mjs";
+import { C as withDiscordRequestAuthority, D as Message, _t as listChannelMessages, ft as editChannelMessage, jt as getGuildMember, 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 { b as resolveDiscordChannelId, o as chunkDiscordTextWithMode } from "./retry-BEYkDy0P.mjs";
+import { F as createDiscordRuntimeAccountContext, P as createDiscordRestClient, d as resolveDiscordTargetChannelId, k as resolveDiscordMessageFlags } from "./send.shared-VNvWfX2T.mjs";
+import { a as discordTextHasBroadcastMention } from "./send.outbound-QTyuFupn.mjs";
+import { O as resolveDiscordMessageStickers, S as formatDiscordMediaText, T as resolveReferencedReplyMediaList, b as resolveDiscordMessageMentionDocuments, g as resolveDiscordThreadStarter, m as resolveDiscordAutoThreadReplyPlan, x as resolveDiscordMessageText, y as resolveDiscordMessageHistoryText } from "./transcripts-source-DVegW0WI.mjs";
+import { a as removeReactionDiscord, r as reactMessageDiscord } from "./send-CIBzvXjS.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-CvemhN3i.mjs";
+import { b as discordInboundEventDelivery, h as resolveDiscordConversationIdentity, u as buildDiscordRoutePeer } from "./outbound-session-route-VulUE0yV.mjs";
+import { t as DISCORD_TEXT_CHUNK_LIMIT } from "./outbound-adapter-ClIgmu4F.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-iOf73HW-.mjs";
+import { n as resolveDiscordWebhookId, t as resolveDiscordSenderIdentity } from "./sender-identity-0Ymgvmaj.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 { a as createDiscordHistorySenderProvenance, c as hasRawDiscordUserMention, d as matchesActiveDiscordMentionPatterns, h as shouldIgnoreBoundThreadWebhookMessage, l as isBoundThreadBotSystemMessage, o as filterDiscordHistoryEntriesForContext, s as resolveDiscordHistoryMediaIds, t as resolveDiscordPreflightPluralKitInfo } from "./message-handler.preflight-pluralkit-8Xji34AF.mjs";
 import { t as sendTyping } from "./typing-BKZL5fGj.mjs";
-import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { buildAgentSessionKey, resolveThreadSessionKeys } from "openclaw/plugin-sdk/routing";
 import { getReplyPayloadTtsSupplement, isReplyPayloadNonTerminalToolErrorWarning, resolveSendableOutboundReplyParts } from "openclaw/plugin-sdk/reply-payload";
@@ -23,15 +22,15 @@ import { danger, logVerbose, shouldLogVerbose, sleepWithAbort } from "openclaw/p
 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 { 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 { buildChannelInboundEventContext, buildMentionRegexes, 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 { 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 +38,127 @@ 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 mentionRegexes = ctx.discordConfig?.allowBots === "mentions" ? buildMentionRegexes(ctx.cfg, ctx.route.agentId, {
+		provider: "discord",
+		conversationId: ctx.messageChannelId,
+		providerPolicy: ctx.discordConfig.mentionPatterns
+	}) : [];
+	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
+				});
+				if (row.author.bot && !sender.isPluralKit) {
+					const allowBots = ctx.discordConfig?.allowBots;
+					if (!allowBots) continue;
+					if (allowBots === "mentions") {
+						const documents = resolveDiscordMessageMentionDocuments(message);
+						if (!(row.mentions.some((user) => user.id === ctx.botUserId) && (row.type !== discord_exports.MessageType.Reply || documents.some((text) => hasRawDiscordUserMention(text, ctx.botUserId)))) && !documents.some((text) => matchesActiveDiscordMentionPatterns(text, mentionRegexes))) continue;
+					}
+				}
+				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 +194,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,
@@ -119,10 +240,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 +281,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 +321,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 +336,7 @@ async function buildDiscordMessageProcessContext(params) {
 				parentType: threadParentType,
 				resolveTimestampMs
 			});
+			if (!isHistoryCurrent()) return null;
 			if (starter?.text) {
 				if (evaluateSupplementalContextVisibility({
 					mode: contextVisibilityMode,
@@ -235,6 +375,7 @@ async function buildDiscordMessageProcessContext(params) {
 		parentSessionKey,
 		useSuffix: false
 	});
+	if (!isHistoryCurrent()) return null;
 	const replyPlan = await resolveDiscordAutoThreadReplyPlan({
 		client,
 		message,
@@ -255,6 +396,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,16 +426,19 @@ 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 ctxPayload = await (ctx.buildContext ?? buildChannelInboundEventContext)({
 		channelIngress,
 		channel: "discord",
 		resolveSupplementalMedia: true,
+		suppressSelfQuoteBody: false,
 		contextVisibility: contextVisibilityMode,
 		accountId: route.accountId,
 		messageId: canonicalMessageId ?? message.id,
@@ -326,9 +471,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,
@@ -346,7 +489,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 +509,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,
@@ -397,6 +543,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 +558,7 @@ async function buildDiscordMessageProcessContext(params) {
 				body: historyText,
 				timestamp: resolveTimestampMs(message.timestamp),
 				messageId: message.id,
+				mediaIds: resolveDiscordHistoryMediaIds(message),
 				senderProvenance: createDiscordHistorySenderProvenance({
 					sender,
 					memberRoleIds
@@ -524,10 +672,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 +685,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;
@@ -776,14 +915,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 +932,17 @@ 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: {
+			if (streamMessage !== void 0) {
+				await editChannelMessage(rest, streamMessage.channelId, streamMessage.messageId, { body: {
 					content: trimmed,
 					allowed_mentions: DISCORD_PREVIEW_ALLOWED_MENTIONS,
 					...flags ? { flags } : {}
 				} });
+				if (generation === streamGeneration) lastSentText = trimmed;
 				return true;
 			}
 			const replyToMessageId = resolveReplyToMessageId()?.trim();
@@ -812,7 +951,7 @@ function createDiscordDraftStream(params) {
 				fail_if_not_exists: false
 			} : void 0;
 			activeCreateGeneration = generation;
-			const sentMessageId = (await createChannelMessage(rest, channelId, { body: {
+			const sentMessageId = (await createChannelMessage(rest, targetChannelId, { body: {
 				content: trimmed,
 				allowed_mentions: DISCORD_PREVIEW_ALLOWED_MENTIONS,
 				...flags ? { flags } : {},
@@ -822,10 +961,9 @@ function createDiscordDraftStream(params) {
 			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 +972,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 +989,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 +1003,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 +1021,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 +1044,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 +1116,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 +1147,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 +1202,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 +1212,7 @@ function createDiscordDraftPreviewController(params) {
 	};
 	return {
 		draftStream,
+		lifecycle,
 		narrationProgressEnabled,
 		narrationHideCommandText,
 		commentaryProgressEnabled: progressDraft.commentaryProgressEnabled,
@@ -1056,36 +1220,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 +1270,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 +1328,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 +1397,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;
 	};
 }
@@ -1348,20 +1485,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)
@@ -1460,7 +1596,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 +1607,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,
@@ -1589,14 +1714,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 +1741,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 +1802,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 {
@@ -1795,6 +1872,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 +1882,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 +1902,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,