@openclaw/discord 2026.7.1 → 2026.7.2-beta.2

package/dist/{message-handler.process-Cjf30P_B.js → message-handler.process-ClgKz8I5.js}

@@ -1,37 +1,37 @@
-import { d as discord_exports, dt as createChannelMessage, gt as editChannelMessage, mt as deleteChannelMessage, qt as resolveDiscordChannelId, u as chunkDiscordTextWithMode } from "./send.receipt-BpBQED_5.js";
-import { f as resolveDiscordMaxLinesPerMessage } from "./accounts-P19jm1lf.js";
-import { I as createDiscordRestClient, L as createDiscordRuntimeAccountContext, _ as resolveDiscordMessageFlags, d as resolveDiscordTargetChannelId } from "./send.shared-wAwMhHDN.js";
-import { S as resolveTimestampMs, a as normalizeDiscordSlug, r as normalizeDiscordAllowList } from "./allow-list-C-MqM-B_.js";
-import { a as removeReactionDiscord, f as editMessageDiscord, r as reactMessageDiscord } from "./send-iJ0B4bAX.js";
-import { i as discordTextHasBroadcastMention } from "./send.outbound-Bj61Q3a0.js";
-import "./targets-69w7c3vU.js";
-import { t as resolveDiscordConversationIdentity } from "./conversation-identity-DWC5d8Sy.js";
+import { bt as editChannelMessage, f as resolveDiscordChannelId, ht as createChannelMessage, p as discord_exports, t as chunkDiscordTextWithMode, vt as deleteChannelMessage } from "./chunk-CHpY_lsO.js";
+import { f as resolveDiscordMaxLinesPerMessage } from "./accounts-CMd4nzLB.js";
+import { C as resolveTimestampMs, a as normalizeDiscordSlug, r as normalizeDiscordAllowList } from "./allow-list-B7qOH5xu.js";
+import { F as createDiscordRestClient, I as createDiscordRuntimeAccountContext, _ as resolveDiscordMessageFlags, d as resolveDiscordTargetChannelId } from "./send.shared-XuOTO1dW.js";
+import { i as discordTextHasBroadcastMention } from "./send.outbound-Cvulb-k_.js";
+import { a as removeReactionDiscord, f as editMessageDiscord, r as reactMessageDiscord } from "./send-JJzVo_sK.js";
+import { n as DISCORD_ATTACHMENT_TOTAL_TIMEOUT_MS, t as DISCORD_ATTACHMENT_IDLE_TIMEOUT_MS } from "./timeouts-D5lWili0.js";
+import "./targets-fjJt3PYG.js";
+import { t as resolveDiscordConversationIdentity } from "./conversation-identity-BPcbhCAH.js";
 import { t as beginDiscordInboundEventDeliveryCorrelation } from "./inbound-event-delivery-CEPlt2uz.js";
-import { n as DISCORD_ATTACHMENT_TOTAL_TIMEOUT_MS, t as DISCORD_ATTACHMENT_IDLE_TIMEOUT_MS } from "./timeouts-C5TBc_9x.js";
-import { t as DISCORD_TEXT_CHUNK_LIMIT } from "./outbound-adapter-82RWi_SR.js";
-import { t as resolveDiscordPreviewStreamMode } from "./preview-streaming-DXT8oJdo.js";
-import { C as resolveDiscordAutoThreadReplyPlan, T as resolveDiscordThreadStarter, a as buildGuildLabel, h as createDiscordSupplementalContextAccessChecker, i as buildDirectLabel, m as buildDiscordInboundAccessContext, n as deliverDiscordReply, o as resolveReplyContext, r as sanitizeDiscordFrontChannelReplyPayloads } from "./provider-BkfbC9FQ.js";
-import { r as resolveDiscordMessageText, s as resolveReferencedReplyMediaList } from "./message-utils-B_3yA5bN.js";
-import { n as createDiscordReplyTypingFeedback } from "./message-handler-DcgvugZt.js";
-import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
+import { t as DISCORD_TEXT_CHUNK_LIMIT } from "./outbound-adapter-ByoXsR-V.js";
+import { D as resolveDiscordThreadStarter, T as resolveDiscordAutoThreadReplyPlan, _ as createDiscordSupplementalContextAccessChecker, a as buildDirectLabel, g as buildDiscordInboundAccessContext, i as sanitizeDiscordFrontChannelReplyPayloads, n as deliverDiscordReply, o as buildGuildLabel, r as formatDiscordReplyDeliveryFailure, s as resolveReplyContext } from "./provider-PRlF_lZm.js";
+import { r as resolveDiscordMessageText, s as resolveReferencedReplyMediaList } from "./message-utils-BU3gc01v.js";
+import { n as DiscordRetryableInboundError } from "./message-handler-DExaghWK.js";
+import { t as sendTyping } from "./typing-CKd2NMWG.js";
 import { buildAgentSessionKey, resolveThreadSessionKeys } from "openclaw/plugin-sdk/routing";
-import { MessageFlags } from "discord-api-types/v10";
-import { evaluateSupplementalContextVisibility } from "openclaw/plugin-sdk/security-runtime";
+import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
-import { getAgentScopedMediaLocalRoots } from "openclaw/plugin-sdk/media-runtime";
-import { getReplyPayloadTtsSupplement, isReplyPayloadNonTerminalToolErrorWarning, resolveSendableOutboundReplyParts } from "openclaw/plugin-sdk/reply-payload";
-import { resolveChunkMode } from "openclaw/plugin-sdk/reply-chunking";
-import { danger, logVerbose, shouldLogVerbose, sleep } from "openclaw/plugin-sdk/runtime-env";
+import { isDangerousNameMatchingEnabled } from "openclaw/plugin-sdk/dangerous-name-runtime";
+import { danger, logVerbose, shouldLogVerbose, sleep, sleepWithAbort } from "openclaw/plugin-sdk/runtime-env";
 import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import { resolveMarkdownTableMode } from "openclaw/plugin-sdk/markdown-table-runtime";
+import { resolveChunkMode } from "openclaw/plugin-sdk/reply-chunking";
 import { convertMarkdownTables, stripInlineDirectiveTagsForDelivery, stripReasoningTagsFromText } from "openclaw/plugin-sdk/text-chunking";
-import { buildChannelProgressDraftLine, buildChannelProgressDraftLineForEntry, createChannelMessageReplyPipeline, createChannelProgressDraftCompositor, createFinalizableDraftLifecycle, defineFinalizableLivePreviewAdapter, deliverWithFinalizableLivePreviewAdapter, isChannelProgressDraftWorkToolName, resolveChannelDraftStreamingChunking, resolveChannelMessageSourceReplyDeliveryMode, resolveChannelStreamingBlockEnabled, resolveChannelStreamingPreviewToolProgress, resolveChannelStreamingSuppressDefaultToolProgressMessages, resolveTranscriptBackedChannelFinalText } from "openclaw/plugin-sdk/channel-outbound";
+import { buildChannelProgressDraftLine, buildChannelProgressDraftLineForEntry, createChannelMessageReplyPipeline, createChannelProgressDraftCompositor, createFinalizableDraftLifecycle, createTypingCallbacks, defineFinalizableLivePreviewAdapter, deliverWithFinalizableLivePreviewAdapter, isChannelProgressDraftWorkToolName, resolveChannelDraftStreamingChunking, resolveChannelMessageSourceReplyDeliveryMode, resolveChannelPreviewStreamMode, resolveChannelProgressDraftConfig, resolveChannelStreamingBlockEnabled, resolveChannelStreamingPreviewCommandText, resolveChannelStreamingPreviewToolProgress, resolveChannelStreamingProgressNarration, resolveChannelStreamingSuppressDefaultToolProgressMessages, resolveTranscriptBackedChannelFinalText } from "openclaw/plugin-sdk/channel-outbound";
+import { getAgentScopedMediaLocalRoots } from "openclaw/plugin-sdk/media-runtime";
+import { getReplyPayloadTtsSupplement, isReplyPayloadNonTerminalToolErrorWarning, resolveSendableOutboundReplyParts } from "openclaw/plugin-sdk/reply-payload";
+import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
+import { evaluateSupplementalContextVisibility } from "openclaw/plugin-sdk/security-runtime";
 import { recordInboundSession, resolvePinnedMainDmOwnerFromAllowlist } from "openclaw/plugin-sdk/conversation-runtime";
 import { EmbeddedBlockChunker, resolveAckReaction, resolveHumanDelayConfig } from "openclaw/plugin-sdk/agent-runtime";
-import { isDangerousNameMatchingEnabled } from "openclaw/plugin-sdk/dangerous-name-runtime";
 import { getSessionEntry, readSessionUpdatedAt, resolveStorePath } from "openclaw/plugin-sdk/session-store-runtime";
 import { buildChannelInboundEventContext, dispatchChannelInboundReply, formatInboundEnvelope, hasFinalInboundReplyDispatch, resolveEnvelopeFormatOptions, toHistoryMediaEntries, toInboundMediaFacts } from "openclaw/plugin-sdk/channel-inbound";
-import { DEFAULT_TIMING, createStatusReactionController, logAckFailure, shouldAckReaction } from "openclaw/plugin-sdk/channel-feedback";
+import { DEFAULT_TIMING, createStatusReactionController, logAckFailure, logTypingFailure, shouldAckReaction } from "openclaw/plugin-sdk/channel-feedback";
 import { createChannelHistoryWindow } from "openclaw/plugin-sdk/reply-history";
 import { readLatestAssistantTextByIdentity } from "openclaw/plugin-sdk/session-transcript-runtime";
 import { resolveChannelContextVisibilityMode } from "openclaw/plugin-sdk/context-visibility-runtime";
@@ -71,6 +71,63 @@ function queueInitialDiscordAckReaction(params) {
 	});
 }
 //#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_INIT_CONFLICT_RETRY_DELAYS_MS = [
+	250,
+	1e3,
+	2500
+];
+const DISCORD_SESSION_CONFLICT_FAILURE_TEXT = "⚠️ Couldn't process this message because the session stayed busy. Please try again in a moment.";
+function isReplySessionInitConflictError(error) {
+	const message = error instanceof Error ? error.message : String(error);
+	return REPLY_SESSION_INIT_CONFLICT_MESSAGE_RE.test(message);
+}
+var DiscordReplySessionConflictExhaustedError = class extends DiscordRetryableInboundError {
+	constructor(message, options) {
+		super(message, options);
+		this.name = "DiscordReplySessionConflictExhaustedError";
+	}
+};
+async function dispatchDiscordReplyWithSessionConflictRetry(params) {
+	for (let retryIndex = 0;; retryIndex += 1) try {
+		return await params.dispatch();
+	} catch (error) {
+		if (!isReplySessionInitConflictError(error)) throw error;
+		const delayMs = DISCORD_SESSION_INIT_CONFLICT_RETRY_DELAYS_MS[retryIndex];
+		if (delayMs === void 0) throw new DiscordReplySessionConflictExhaustedError(`discord: reply session init conflict persisted after shared and channel retries: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+		params.onRetry?.(retryIndex + 1, delayMs);
+		await sleepWithAbort(delayMs, params.abortSignal);
+	}
+}
+function withDiscordSessionRetry(dispatch, abortSignal) {
+	return (dispatchParams) => dispatchDiscordReplyWithSessionConflictRetry({
+		dispatch: () => dispatch(dispatchParams),
+		abortSignal,
+		onRetry: (attempt, delayMs) => {
+			logVerbose(`discord: reply session init conflict; retrying dispatch ${attempt} after ${delayMs}ms`);
+		}
+	});
+}
+async function completeDiscordSessionConflict(error, deliver, onDeliveryError) {
+	if (!(error instanceof DiscordReplySessionConflictExhaustedError)) return false;
+	try {
+		await deliver({
+			text: DISCORD_SESSION_CONFLICT_FAILURE_TEXT,
+			isError: true
+		}, { kind: "final" });
+		return true;
+	} catch (deliveryError) {
+		onDeliveryError(deliveryError, { kind: "final" });
+		return false;
+	}
+}
+function removeDiscordReplayHistoryEntry(historyMap, historyKey, messageId) {
+	const history = historyMap.get(historyKey);
+	if (!history) return;
+	for (let index = history.length - 1; index >= 0; index -= 1) if (history[index]?.messageId === messageId) history.splice(index, 1);
+}
+//#endregion
 //#region extensions/discord/src/monitor/message-handler.context.ts
 function normalizeDiscordDmOwnerEntry(entry) {
 	const candidate = normalizeDiscordAllowList([entry], [
@@ -98,7 +155,6 @@ async function buildDiscordMessageProcessContext(params) {
 	const threadParentInheritanceEnabled = discordConfig?.thread?.inheritParent ?? false;
 	const forumContextLine = Boolean(threadChannelId && isForumParent && forumParentSlug) && message.id === threadChannelId ? `[Forum parent: #${forumParentSlug}]` : null;
 	const groupChannel = isGuildMessage && displayChannelSlug ? `#${displayChannelSlug}` : void 0;
-	const groupSubject = isDirectMessage ? void 0 : groupChannel;
 	const senderName = sender.isPluralKit ? sender.name ?? author.username : data.member?.nickname ?? author.globalName ?? author.username;
 	const senderUsername = sender.isPluralKit ? sender.tag ?? sender.name ?? author.username : author.username;
 	const { groupSystemPrompt, ownerAllowFrom, untrustedContext } = buildDiscordInboundAccessContext({
@@ -136,7 +192,6 @@ async function buildDiscordMessageProcessContext(params) {
 		sessionKey: route.sessionKey
 	});
 	const channelHistory = createChannelHistoryWindow({ historyMap: guildHistories });
-	const isRoomEvent = ctx.inboundEventKind === "room_event";
 	let combinedBody = formatInboundEnvelope({
 		channel: "Discord",
 		from: fromLabel,
@@ -147,21 +202,24 @@ async function buildDiscordMessageProcessContext(params) {
 		previousTimestamp,
 		envelope: envelopeOptions
 	});
-	const shouldIncludeChannelHistory = !isDirectMessage && (isRoomEvent || !(isGuildMessage && channelConfig?.autoThread && !threadChannel));
-	if (shouldIncludeChannelHistory) combinedBody = channelHistory.buildPendingContext({
-		historyKey: messageChannelId,
-		limit: historyLimit,
-		currentMessage: combinedBody,
-		formatEntry: (entry) => formatInboundEnvelope({
-			channel: "Discord",
-			from: fromLabel,
-			timestamp: entry.timestamp,
-			body: `${entry.body} [id:${entry.messageId ?? "unknown"} channel:${messageChannelId}]`,
-			chatType: "channel",
-			senderLabel: entry.sender,
-			envelope: envelopeOptions
-		})
-	});
+	const shouldIncludeChannelHistory = !isDirectMessage && (ctx.inboundEventKind === "room_event" || !(isGuildMessage && channelConfig?.autoThread && !threadChannel));
+	if (shouldIncludeChannelHistory) {
+		removeDiscordReplayHistoryEntry(guildHistories, messageChannelId, message.id);
+		combinedBody = channelHistory.buildPendingContext({
+			historyKey: messageChannelId,
+			limit: historyLimit,
+			currentMessage: combinedBody,
+			formatEntry: (entry) => formatInboundEnvelope({
+				channel: "Discord",
+				from: fromLabel,
+				timestamp: entry.timestamp,
+				body: `${entry.body} [id:${entry.messageId ?? "unknown"} channel:${messageChannelId}]`,
+				chatType: "channel",
+				senderLabel: entry.sender,
+				envelope: envelopeOptions
+			})
+		});
+	}
 	const replyContext = resolveReplyContext(message, resolveDiscordMessageText);
 	const replySenderAllowed = replyContext ? isSupplementalContextSenderAllowed({
 		id: replyContext.senderId,
@@ -228,7 +286,7 @@ async function buildDiscordMessageProcessContext(params) {
 		message,
 		messageChannelId,
 		isGuildMessage,
-		channelConfig: isRoomEvent ? null : channelConfig,
+		channelConfig: ctx.inboundEventKind === "room_event" ? null : channelConfig,
 		threadChannel,
 		channelType: channelInfo?.type,
 		channelName: channelInfo?.name,
@@ -287,6 +345,7 @@ async function buildDiscordMessageProcessContext(params) {
 		conversation: {
 			kind: isDirectMessage ? "direct" : "channel",
 			id: messageChannelId,
+			nativeChannelId: messageChannelId,
 			label: fromLabel,
 			spaceId: isGuildMessage ? (guildInfo?.id ?? guildSlug) || void 0 : void 0,
 			parentId: threadChannel ? threadParentId : void 0,
@@ -356,7 +415,7 @@ async function buildDiscordMessageProcessContext(params) {
 		},
 		extra: {
 			...preflightAudioTranscript !== void 0 ? { Transcript: preflightAudioTranscript } : {},
-			GroupSubject: groupSubject,
+			GroupSubject: isDirectMessage ? void 0 : groupChannel,
 			GroupChannel: groupChannel,
 			...isGuildMessage ? { GroupRequireMention: ctx.groupRequireMention } : {},
 			UntrustedStructuredContext: untrustedContext,
@@ -364,7 +423,7 @@ async function buildDiscordMessageProcessContext(params) {
 		}
 	});
 	const persistedSessionKey = ctxPayload.SessionKey ?? route.sessionKey;
-	if (isRoomEvent && shouldIncludeChannelHistory) await channelHistory.recordWithMedia({
+	if (ctx.inboundEventKind === "room_event" && shouldIncludeChannelHistory) await channelHistory.recordWithMedia({
 		historyKey: messageChannelId,
 		limit: historyLimit,
 		entry: {
@@ -435,7 +494,11 @@ function createDiscordDraftStream(params) {
 	};
 	let streamMessageId;
 	let lastSentText = "";
+	let streamGeneration = 0;
+	let activeCreateGeneration;
+	let discardActiveCreate = false;
 	const sendOrEditStreamMessage = async (text) => {
+		const generation = streamGeneration;
 		if (streamState.stopped && !streamState.final) return false;
 		const trimmed = text.trimEnd();
 		if (!trimmed) return false;
@@ -463,12 +526,24 @@ function createDiscordDraftStream(params) {
 				message_id: replyToMessageId,
 				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 } : {},
 				...messageReference ? { message_reference: messageReference } : {}
 			} }))?.id;
+			const shouldDiscardStaleCreate = activeCreateGeneration === generation && discardActiveCreate;
+			activeCreateGeneration = void 0;
+			discardActiveCreate = false;
+			if (generation !== streamGeneration) {
+				if (shouldDiscardStaleCreate && typeof sentMessageId === "string" && sentMessageId) try {
+					await deleteChannelMessage(rest, channelId, sentMessageId);
+				} catch (err) {
+					params.warn?.(`discord stale stream preview cleanup failed: ${formatErrorMessage(err)}`);
+				}
+				return true;
+			}
 			if (typeof sentMessageId !== "string" || !sentMessageId) {
 				streamState.stopped = true;
 				params.warn?.("discord stream preview stopped (missing message id from send)");
@@ -477,6 +552,11 @@ function createDiscordDraftStream(params) {
 			streamMessageId = sentMessageId;
 			return true;
 		} catch (err) {
+			if (activeCreateGeneration === generation) {
+				activeCreateGeneration = void 0;
+				discardActiveCreate = false;
+			}
+			if (generation !== streamGeneration) return true;
 			streamState.stopped = true;
 			params.warn?.(`discord stream preview failed: ${formatErrorMessage(err)}`);
 			return false;
@@ -501,10 +581,15 @@ function createDiscordDraftStream(params) {
 		warn: params.warn,
 		warnPrefix: "discord stream preview cleanup failed"
 	});
-	const forceNewMessage = () => {
+	const forceNewMessage = (mode = "preserve") => {
+		if (mode === "discard" && activeCreateGeneration !== void 0) discardActiveCreate = true;
+		streamGeneration += 1;
+		streamState.stopped = false;
+		streamState.final = false;
 		streamMessageId = void 0;
 		lastSentText = "";
 		loop.resetPending();
+		loop.resetThrottleWindow();
 	};
 	const deleteCurrentMessage = async () => {
 		loop.resetPending();
@@ -534,6 +619,12 @@ function createDiscordDraftStream(params) {
 	};
 }
 //#endregion
+//#region extensions/discord/src/preview-streaming.ts
+function resolveDiscordPreviewStreamMode(params = {}) {
+	if (params.streaming === void 0) return "progress";
+	return resolveChannelPreviewStreamMode(params, "off");
+}
+//#endregion
 //#region extensions/discord/src/monitor/message-handler.draft-preview.ts
 function createDiscordDraftPreviewController(params) {
 	const discordStreamMode = resolveDiscordPreviewStreamMode(params.discordConfig);
@@ -560,7 +651,14 @@ function createDiscordDraftPreviewController(params) {
 	let finalizedViaPreviewMessage = false;
 	let finalReplyDelivered = false;
 	let progressDraftStartedBeforeFinal = false;
-	const previewToolProgressEnabled = Boolean(draftStream) && resolveChannelStreamingPreviewToolProgress(params.discordConfig);
+	let progressDraftCollapsed = false;
+	let progressNarratorLifecycle;
+	const progressConfig = resolveChannelProgressDraftConfig(params.discordConfig);
+	const progressHasExplicitLabel = progressConfig.label !== void 0 || progressConfig.labels !== void 0;
+	const progressToolDefault = progressConfig.toolProgress ?? progressHasExplicitLabel;
+	const previewToolProgressEnabled = Boolean(draftStream) && resolveChannelStreamingPreviewToolProgress(params.discordConfig, discordStreamMode === "progress" ? progressToolDefault : true);
+	const narrationProgressEnabled = Boolean(draftStream) && discordStreamMode === "progress" && resolveChannelStreamingProgressNarration(params.discordConfig);
+	const narrationHideCommandText = narrationProgressEnabled && resolveChannelStreamingPreviewCommandText(params.discordConfig) === "status";
 	const suppressDefaultToolProgressMessages = Boolean(draftStream) && resolveChannelStreamingSuppressDefaultToolProgressMessages(params.discordConfig, {
 		draftStreamActive: true,
 		previewToolProgressEnabled
@@ -573,7 +671,7 @@ function createDiscordDraftPreviewController(params) {
 		seed: progressSeed,
 		reasoningLinePrefix: "🧠 ",
 		commentaryLinePrefix: "💬 ",
-		reasoningGate: true,
+		reasoningGate: previewToolProgressEnabled,
 		commentaryItalics: false,
 		update: async (previewText, options) => {
 			lastPartialText = previewText;
@@ -605,23 +703,42 @@ function createDiscordDraftPreviewController(params) {
 		}
 		resetProgressState();
 	};
+	const pushPreambleHeadline = async (text, options) => {
+		if (discordStreamMode === "progress") await progressDraft.pushPreambleHeadline(text, options);
+	};
 	return {
 		draftStream,
 		previewToolProgressEnabled,
+		narrationProgressEnabled,
+		narrationHideCommandText,
 		commentaryProgressEnabled: progressDraft.commentaryProgressEnabled,
 		suppressDefaultToolProgressMessages,
 		get isProgressMode() {
 			return discordStreamMode === "progress";
 		},
 		get hasProgressDraftStarted() {
-			return progressDraft.hasStarted || progressDraftStartedBeforeFinal;
+			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() {
 			finalReplyDelivered = true;
@@ -634,9 +751,21 @@ function createDiscordDraftPreviewController(params) {
 		async pushToolProgress(line, options) {
 			await progressDraft.pushToolProgress(line, options);
 		},
+		async pushPlanProgress(steps, options) {
+			await progressDraft.pushPlanProgress(steps, options);
+		},
 		async pushReasoningProgress(text, options) {
 			await progressDraft.pushReasoningProgress(text, options);
 		},
+		async pushNarrationProgress(text) {
+			await progressDraft.pushNarrationProgress(text);
+		},
+		pushPreambleHeadline,
+		async pushPreambleItemEvent(payload, noteCommentary) {
+			await pushPreambleHeadline(payload.progressText, { itemId: payload.itemId });
+			if (!progressDraft.commentaryProgressEnabled) return;
+			if (await progressDraft.pushCommentaryProgress(payload.progressText, { itemId: payload.itemId })) noteCommentary(payload.itemId, payload.progressText);
+		},
 		async pushCommentaryProgress(text, options) {
 			await progressDraft.pushCommentaryProgress(text, options);
 		},
@@ -650,7 +779,7 @@ function createDiscordDraftPreviewController(params) {
 			});
 			if (!chunks.length && formatted) chunks.push(formatted);
 			if (chunks.length !== 1) return;
-			const trimmed = chunks[0].trim();
+			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;
@@ -696,9 +825,20 @@ function createDiscordDraftPreviewController(params) {
 			});
 		},
 		handleAssistantMessageBoundary() {
-			progressDraft.beginNewTurn();
-			if (discordStreamMode === "progress") return;
+			const beganNewTurn = progressDraft.beginNewTurn();
+			if (beganNewTurn) {
+				progressDraftCollapsed = false;
+				progressDraftStartedBeforeFinal = false;
+				finalReplyDelivered = false;
+				finalizedViaPreviewMessage = false;
+				progressNarratorLifecycle?.beginTurn();
+			}
+			if (discordStreamMode === "progress") {
+				if (beganNewTurn) draftStream?.forceNewMessage("discard");
+				return beganNewTurn;
+			}
 			forceNewMessageIfNeeded();
+			return beganNewTurn;
 		},
 		async flush() {
 			if (!draftStream) return;
@@ -718,7 +858,7 @@ function createDiscordDraftPreviewController(params) {
 			try {
 				progressDraft.cancel();
 				if (!finalReplyDelivered) await draftStream?.discardPending();
-				if (!finalReplyDelivered && !finalizedViaPreviewMessage && draftStream?.messageId()) await draftStream.clear();
+				if (!finalizedViaPreviewMessage && draftStream?.messageId()) await draftStream.clear();
 			} catch (err) {
 				params.log(`discord: draft cleanup failed: ${String(err)}`);
 			}
@@ -733,20 +873,45 @@ function shouldStartDiscordProgressDraftNow(line) {
 	return typeof line === "object" && line?.kind === "patch" && Boolean(line.detail);
 }
 //#endregion
+//#region extensions/discord/src/monitor/reply-typing-feedback.ts
+const DISCORD_REPLY_TYPING_MAX_DURATION_MS = 20 * 6e4;
+function createDiscordReplyTypingFeedback(params) {
+	const rest = params.rest ?? createDiscordRestClient({
+		cfg: params.cfg,
+		token: params.token,
+		accountId: params.accountId
+	}).rest;
+	return createTypingCallbacks({
+		start: () => sendTyping({
+			rest,
+			channelId: params.channelId
+		}),
+		onStartError: (err) => {
+			logTypingFailure({
+				log: params.log,
+				channel: "discord",
+				target: params.channelId,
+				error: err
+			});
+		},
+		keepaliveIntervalMs: params.keepaliveIntervalMs,
+		maxDurationMs: params.maxDurationMs ?? DISCORD_REPLY_TYPING_MAX_DURATION_MS
+	});
+}
+//#endregion
 //#region extensions/discord/src/monitor/message-handler.process.ts
 const loadReplyRuntime = createLazyRuntimeModule(() => import("openclaw/plugin-sdk/reply-runtime"));
 const TARGETED_ONLY_ALLOWED_MENTIONS = { parse: ["users", "roles"] };
 function isProcessAborted(abortSignal) {
 	return Boolean(abortSignal?.aborted);
 }
-function formatDiscordReplyDeliveryFailure(params) {
-	const context = [`target=${params.target}`, params.sessionKey ? `session=${params.sessionKey}` : void 0].filter(Boolean).join(" ");
-	return `discord ${params.kind} reply failed (${context}): ${String(params.err)}`;
-}
 function isFallbackOnlyToolWarningFinal(payload) {
 	if (payload.isError !== true || !isReplyPayloadNonTerminalToolErrorWarning(payload)) return false;
 	return !resolveSendableOutboundReplyParts(payload).hasMedia;
 }
+function isFailedProgress(payload) {
+	return payload.phase === "error" || payload.status === "failed" || payload.status === "error" || typeof payload.exitCode === "number" && payload.exitCode !== 0;
+}
 function formatDiscordReplySkip(params) {
 	const context = [`target=${params.target}`, params.sessionKey ? `session=${params.sessionKey}` : void 0].filter(Boolean).join(" ");
 	return `discord ${params.kind} reply skipped (${params.reason}): ${context}`;
@@ -759,15 +924,11 @@ function readToolBooleanArg(args, key) {
 	return args[key] === true;
 }
 async function processDiscordMessage(ctx, observer) {
-	try {
-		await processDiscordMessageInner(ctx, observer);
-	} finally {
-		ctx.replyTypingFeedback?.onCleanup?.();
-	}
+	await processDiscordMessageInner(ctx, observer);
 }
 async function processDiscordMessageInner(ctx, observer) {
 	const dispatchStartedAt = Date.now();
-	const { cfg, discordConfig, accountId, token, runtime, guildHistories, historyLimit, textLimit, replyToMode, ackReactionScope, message, messageChannelId, isGuildMessage, isDirectMessage, isGroupDm, messageText, shouldRequireMention, canDetectMention, effectiveWasMentioned, shouldBypassMention, channelConfig, threadBindings, route, abortSignal, replyTypingFeedback, preparedMedia: mediaList } = ctx;
+	const { cfg, discordConfig, accountId, token, runtime, guildHistories, historyLimit, textLimit, replyToMode, ackReactionScope, message, messageChannelId, isGuildMessage, isDirectMessage, isGroupDm, messageText, shouldRequireMention, canDetectMention, effectiveWasMentioned, shouldBypassMention, channelConfig, threadBindings, route, abortSignal, preparedMedia: mediaList } = ctx;
 	if (isProcessAborted(abortSignal)) return;
 	const text = messageText;
 	if (!text) {
@@ -776,7 +937,7 @@ async function processDiscordMessageInner(ctx, observer) {
 	}
 	const boundThreadId = ctx.threadBinding?.conversation?.conversationId?.trim();
 	if (boundThreadId && typeof threadBindings.touchThread === "function") threadBindings.touchThread({ threadId: boundThreadId });
-	const { dispatchReplyWithBufferedBlockDispatcher } = await loadReplyRuntime();
+	const { dispatchReplyWithBufferedBlockDispatcher: dispatchReply } = await loadReplyRuntime();
 	const sourceReplyDeliveryMode = resolveChannelMessageSourceReplyDeliveryMode({
 		cfg,
 		ctx: {
@@ -787,7 +948,7 @@ async function processDiscordMessageInner(ctx, observer) {
 	const sourceRepliesAreToolOnly = sourceReplyDeliveryMode === "message_tool_only";
 	const configuredTypingMode = cfg.session?.typingMode ?? cfg.agents?.defaults?.typingMode;
 	const configuredTypingInterval = cfg.agents?.defaults?.typingIntervalSeconds ?? cfg.session?.typingIntervalSeconds;
-	const shouldDisableCoreTypingKeepalive = Boolean(replyTypingFeedback) || sourceRepliesAreToolOnly && configuredTypingMode === void 0 && configuredTypingInterval === void 0;
+	const shouldDisableCoreTypingKeepalive = sourceRepliesAreToolOnly && configuredTypingMode === void 0 && configuredTypingInterval === void 0;
 	const ackReaction = resolveAckReaction(cfg, route.agentId, {
 		channel: "discord",
 		accountId
@@ -934,7 +1095,8 @@ async function processDiscordMessageInner(ctx, observer) {
 		sessionKey: persistedSessionKey
 	});
 	const typingChannelId = deliverTarget.startsWith("channel:") ? deliverTarget.slice(8) : messageChannelId;
-	const typingFeedback = replyTypingFeedback ?? createDiscordReplyTypingFeedback({
+	let typingFeedback;
+	const getTypingFeedback = () => typingFeedback ??= createDiscordReplyTypingFeedback({
 		cfg,
 		token,
 		accountId,
@@ -943,14 +1105,16 @@ async function processDiscordMessageInner(ctx, observer) {
 		log: logVerbose,
 		keepaliveIntervalMs: shouldDisableCoreTypingKeepalive ? void 0 : 0
 	});
-	if (replyTypingFeedback) replyTypingFeedback.restartForDispatch(typingChannelId);
-	else typingFeedback.updateChannelId(typingChannelId);
 	const { onModelSelected, ...replyPipeline } = createChannelMessageReplyPipeline({
 		cfg,
 		agentId: route.agentId,
 		channel: "discord",
 		accountId: route.accountId,
-		typingCallbacks: typingFeedback
+		typingCallbacks: {
+			onReplyStart: () => getTypingFeedback().onReplyStart(),
+			onIdle: () => typingFeedback?.onIdle?.(),
+			onCleanup: () => typingFeedback?.onCleanup?.()
+		}
 	});
 	const tableMode = resolveMarkdownTableMode({
 		cfg,
@@ -1016,7 +1180,6 @@ async function processDiscordMessageInner(ctx, observer) {
 		log: logVerbose
 	});
 	let shouldYieldDraftProgress = () => false;
-	const finalPreviewFlags = discordConfig?.suppressEmbeds ?? true ? MessageFlags.SuppressEmbeds : void 0;
 	let finalReplyStartNotified = false;
 	const notifyFinalReplyStart = () => {
 		if (finalReplyStartNotified) return;
@@ -1061,11 +1224,12 @@ async function processDiscordMessageInner(ctx, observer) {
 	})();
 	const reasoningDurableEnabled = reasoningLevel === "on";
 	const reasoningWindowEnabled = reasoningLevel === "stream";
-	const progressTurnStartedAt = Date.now();
+	let progressTurnStartedAt = Date.now();
 	let progressReasoningSteps = 0;
 	let progressToolCalls = 0;
 	let progressCommentaryNotes = 0;
-	let persistentReasoningDelivered = false;
+	let progressReceiptLine;
+	let clearProgressDraftAfterFinalDelivery = false;
 	const seenCommentaryIds = /* @__PURE__ */ new Set();
 	let lastCommentaryNoteText = "";
 	const noteWindowCommentary = (itemId, noteText) => {
@@ -1089,6 +1253,24 @@ async function processDiscordMessageInner(ctx, observer) {
 			progressReasoningSteps += 1;
 		}
 	};
+	const resetProgressTurnState = () => {
+		finalReplyStartNotified = false;
+		userFacingFinalDelivered = false;
+		userFacingFinalDeliveryFailed = false;
+		pendingToolWarningFinal = void 0;
+		progressTurnStartedAt = Date.now();
+		progressReasoningSteps = 0;
+		progressToolCalls = 0;
+		progressCommentaryNotes = 0;
+		progressReceiptLine = void 0;
+		clearProgressDraftAfterFinalDelivery = false;
+		seenCommentaryIds.clear();
+		lastCommentaryNoteText = "";
+		windowReasoningOpen = false;
+	};
+	const handleAssistantMessageBoundary = () => {
+		if (draftPreview.handleAssistantMessageBoundary()) resetProgressTurnState();
+	};
 	const buildProgressSummaryLine = () => {
 		closePendingWindowThought();
 		const seconds = Math.max(1, Math.round((Date.now() - progressTurnStartedAt) / 1e3));
@@ -1099,6 +1281,13 @@ async function processDiscordMessageInner(ctx, observer) {
 			`⏱️ ${seconds}s`
 		].join(" · ")}`;
 	};
+	let replyLifecycleStarted = false;
+	const onDiscordReplyStart = async () => {
+		if (isProcessAborted(abortSignal)) return;
+		replyLifecycleStarted = true;
+		await replyPipeline.typingCallbacks?.onReplyStart();
+		await statusReactions.setThinking();
+	};
 	const beforeDiscordPayloadDelivery = (payload, info) => {
 		if (isProcessAborted(abortSignal)) {
 			logVerbose(formatDiscordReplySkip({
@@ -1161,7 +1350,6 @@ async function processDiscordMessageInner(ctx, observer) {
 				kind: "block"
 			});
 			replyReference.markSent();
-			persistentReasoningDelivered = true;
 			return { visibleReplySent: true };
 		}
 		if (isFinal && !options?.allowFallbackOnlyToolWarning && isFallbackOnlyToolWarningFinal(payload)) {
@@ -1189,55 +1377,15 @@ async function processDiscordMessageInner(ctx, observer) {
 			}));
 			return { visibleReplySent: false };
 		}
+		if (isFinal && !replyLifecycleStarted && !isRoomEvent && configuredTypingMode !== "never") await onDiscordReplyStart();
 		const draftStream = draftPreview.draftStream;
 		if (draftStream && draftPreview.isProgressMode && info.kind === "block") {
 			if (!resolveSendableOutboundReplyParts(deliverablePayload).hasMedia && !deliverablePayload.isError) return { visibleReplySent: false };
 		}
-		if (draftStream && isFinal && draftPreview.isProgressMode && draftPreview.hasProgressDraftStarted && !deliverablePayload.isError && draftStream) {
+		if (draftStream && isFinal && draftPreview.isProgressMode && !deliverablePayload.isError && draftPreview.hasProgressDraftToCollapse && draftStream) {
 			await draftPreview.flush();
-			if (persistentReasoningDelivered) {
-				await draftStream.clear();
-				await deliverDiscordReply({
-					cfg,
-					replies: [{ text: buildProgressSummaryLine() }],
-					target: deliverTarget,
-					token,
-					accountId,
-					rest: deliveryRest,
-					runtime,
-					replyToId: replyReference.use(),
-					replyToMode,
-					textLimit,
-					maxLinesPerMessage,
-					tableMode,
-					chunkMode,
-					sessionKey: ctxPayload.SessionKey,
-					threadBindings,
-					mediaLocalRoots,
-					kind: "block"
-				});
-				replyReference.markSent();
-				draftPreview.markPreviewFinalized();
-			} else {
-				const draftId = draftStream.messageId();
-				if (draftId !== void 0) {
-					await draftStream.seal();
-					try {
-						await editMessageDiscord(deliverChannelId, draftId, {
-							content: buildProgressSummaryLine(),
-							...finalPreviewFlags ? { flags: finalPreviewFlags } : {}
-						}, {
-							cfg,
-							accountId,
-							rest: deliveryRest
-						});
-						draftPreview.markPreviewFinalized();
-					} catch (err) {
-						logVerbose(`discord: progress draft summary edit failed; clearing draft (${String(err)})`);
-						await draftStream.clear();
-					}
-				}
-			}
+			progressReceiptLine = buildProgressSummaryLine();
+			clearProgressDraftAfterFinalDelivery = true;
 		}
 		if (draftStream && isFinal && !draftPreview.isProgressMode && !deliverablePayload.isError) {
 			const ttsSupplement = getReplyPayloadTtsSupplement(deliverablePayload);
@@ -1319,9 +1467,14 @@ async function processDiscordMessageInner(ctx, observer) {
 		}
 		const replyToId = replyReference.use();
 		if (isFinal) notifyFinalReplyStart();
+		const receiptLine = isFinal && deliverablePayload.isError !== true ? progressReceiptLine : void 0;
+		const payloadForDelivery = receiptLine ? {
+			...deliverablePayload,
+			text: deliverablePayload.text?.trim() ? `${deliverablePayload.text.trimEnd()}\n${receiptLine}` : receiptLine
+		} : deliverablePayload;
 		await deliverDiscordReply({
 			cfg,
-			replies: [deliverablePayload],
+			replies: [payloadForDelivery],
 			target: deliverTarget,
 			token,
 			accountId,
@@ -1339,7 +1492,18 @@ async function processDiscordMessageInner(ctx, observer) {
 			kind: info.kind
 		});
 		replyReference.markSent();
-		if (isFinal && deliverablePayload.isError !== true) markUserFacingFinalDelivered();
+		if (isFinal && deliverablePayload.isError !== true) {
+			if (receiptLine) {
+				progressReceiptLine = void 0;
+				draftPreview.markProgressDraftCollapsed();
+			}
+			markUserFacingFinalDelivered();
+			if (clearProgressDraftAfterFinalDelivery) {
+				clearProgressDraftAfterFinalDelivery = false;
+				await draftStream?.discardPending();
+				await draftStream?.clear();
+			}
+		}
 		return { visibleReplySent: true };
 	};
 	const onDiscordDeliveryError = (err, info) => {
@@ -1351,11 +1515,6 @@ async function processDiscordMessageInner(ctx, observer) {
 			sessionKey: ctxPayload.SessionKey
 		})));
 	};
-	const onDiscordReplyStart = async () => {
-		if (isProcessAborted(abortSignal)) return;
-		await replyPipeline.typingCallbacks?.onReplyStart();
-		await statusReactions.setThinking();
-	};
 	const resolvedBlockStreamingEnabled = resolveChannelStreamingBlockEnabled(discordConfig);
 	let dispatchResult = null;
 	let dispatchError = false;
@@ -1387,7 +1546,7 @@ async function processDiscordMessageInner(ctx, observer) {
 			ctxPayload,
 			recordInboundSession,
 			afterRecord: queueInitialAckReactionAfterRecord,
-			dispatchReplyWithBufferedBlockDispatcher,
+			dispatchReplyWithBufferedBlockDispatcher: withDiscordSessionRetry(dispatchReply, abortSignal),
 			dispatcherOptions: {
 				...replyPipeline,
 				humanDelay: resolveHumanDelayConfig(cfg, route.agentId),
@@ -1416,20 +1575,28 @@ async function processDiscordMessageInner(ctx, observer) {
 				allowProgressCallbacksWhenSourceDeliverySuppressed: sourceRepliesAreToolOnly && draftPreview.draftStream && draftPreview.isProgressMode ? true : void 0,
 				disableBlockStreaming: sourceRepliesAreToolOnly ? true : draftPreview.disableBlockStreamingForDraft ?? (typeof resolvedBlockStreamingEnabled === "boolean" ? !resolvedBlockStreamingEnabled : void 0),
 				onPartialReply: draftPreview.draftStream && !draftPreview.isProgressMode ? (payload) => draftPreview.updateFromPartial(payload.text) : void 0,
-				onAssistantMessageStart: draftPreview.draftStream ? () => draftPreview.handleAssistantMessageBoundary() : void 0,
+				onAssistantMessageStart: draftPreview.draftStream ? handleAssistantMessageBoundary : void 0,
 				onReasoningEnd: draftPreview.draftStream ? () => {
 					closePendingWindowThought();
-					return draftPreview.handleAssistantMessageBoundary();
+					handleAssistantMessageBoundary();
 				} : void 0,
 				onModelSelected,
 				suppressDefaultToolProgressMessages: sourceRepliesAreToolOnly && statusReactionsExplicitlyEnabled || draftPreview.suppressDefaultToolProgressMessages ? true : void 0,
 				allowToolLifecycleWhenProgressHidden: statusReactionsEnabled ? true : void 0,
 				commentaryProgressEnabled: draftPreview.isProgressMode ? draftPreview.commentaryProgressEnabled : void 0,
+				progressPreambleEnabled: draftPreview.draftStream && draftPreview.isProgressMode ? true : void 0,
 				commentaryPayloadsEnabled: draftPreview.isProgressMode ? draftPreview.commentaryProgressEnabled : void 0,
 				reasoningPayloadsEnabled: reasoningDurableEnabled,
 				onVerboseProgressVisibility: (isActive) => {
 					shouldYieldDraftProgress = isActive;
 				},
+				onNarrationUpdate: draftPreview.narrationProgressEnabled ? async (payload) => {
+					if (isProcessAborted(abortSignal) || shouldYieldDraftProgress()) return;
+					await draftPreview.pushNarrationProgress(payload.text);
+				} : void 0,
+				onProgressNarratorLifecycle: draftPreview.narrationProgressEnabled ? (lifecycle) => draftPreview.setProgressNarratorLifecycle(lifecycle) : void 0,
+				isProgressDraftVisible: draftPreview.narrationProgressEnabled ? () => draftPreview.isProgressDraftVisible : void 0,
+				narrationHideCommandText: draftPreview.narrationHideCommandText ? true : void 0,
 				onReasoningStream: async (payload) => {
 					if (payload?.requiresReasoningProgressOptIn === true && !reasoningWindowEnabled) return;
 					if (payload?.text) windowReasoningOpen = true;
@@ -1454,13 +1621,10 @@ async function processDiscordMessageInner(ctx, observer) {
 					}, payload.detailMode ? { detailMode: payload.detailMode } : void 0), { toolName: payload.name });
 				},
 				onItemEvent: async (payload) => {
+					if (isFailedProgress(payload)) return false;
 					if (payload.kind === "preamble") {
 						if (shouldYieldDraftProgress()) return;
-						if (draftPreview.commentaryProgressEnabled && payload.progressText) {
-							noteWindowCommentary(payload.itemId, payload.progressText);
-							await draftPreview.pushCommentaryProgress(payload.progressText, { itemId: payload.itemId });
-						}
-						return;
+						return await draftPreview.pushPreambleItemEvent(payload, noteWindowCommentary);
 					}
 					if (shouldYieldDraftProgress()) return;
 					await draftPreview.pushToolProgress(buildChannelProgressDraftLineForEntry(discordConfig, {
@@ -1479,13 +1643,7 @@ async function processDiscordMessageInner(ctx, observer) {
 				},
 				onPlanUpdate: async (payload) => {
 					if (payload.phase !== "update") return;
-					await draftPreview.pushToolProgress(buildChannelProgressDraftLine({
-						event: "plan",
-						phase: payload.phase,
-						title: payload.title,
-						explanation: payload.explanation,
-						steps: payload.steps
-					}));
+					await draftPreview.pushPlanProgress(payload.planSteps, { explanation: payload.explanation });
 				},
 				onApprovalEvent: async (payload) => {
 					if (payload.phase !== "requested") return;
@@ -1499,6 +1657,7 @@ async function processDiscordMessageInner(ctx, observer) {
 					}));
 				},
 				onCommandOutput: async (payload) => {
+					if (isFailedProgress(payload)) return false;
 					if (payload.phase !== "end") return;
 					if (shouldYieldDraftProgress()) return;
 					await draftPreview.pushToolProgress(buildChannelProgressDraftLine({
@@ -1551,6 +1710,7 @@ async function processDiscordMessageInner(ctx, observer) {
 			return;
 		}
 		dispatchError = true;
+		if (await completeDiscordSessionConflict(err, deliverDiscordPayload, onDiscordDeliveryError)) return;
 		throw err;
 	} finally {
 		endDiscordInboundEventDeliveryCorrelation();