@openclaw/slack 2026.7.2-beta.2 → 2026.7.2-beta.4

package/dist/{pipeline.runtime-DofAvTtb.js → pipeline.runtime-5rRYZuX5.js}

@@ -1,20 +1,20 @@
-import { u as resolveSlackReplyToMode } from "./accounts-BOJJiHSr.js";
+import { t as resolveSlackReplyToMode } from "./account-reply-mode-DrUXogvO.js";
 import { i as parseSlackTarget } from "./target-parsing-N6lHogYZ.js";
 import "./targets-KmjP2E8s.js";
-import { A as buildSlackBlocksFallbackText, B as truncateSlackText, I as SLACK_TEXT_LIMIT, P as SLACK_EDIT_TEXT_LIMIT, c as normalizeAllowListLower, d as resolveSlackAllowListMatch, i as formatSlackError, k as normalizeSlackOutboundText, l as normalizeSlackAllowOwnerEntry, q as escapeSlackMrkdwn, v as resolveSlackReplyRenderPlan, w as hasSlackNativeDataBlock } from "./group-policy-85UWiriS.js";
-import { n as isSlackInteractiveRepliesEnabled, t as compileSlackInteractiveReplies } from "./interactive-replies-BilWUdcI.js";
+import { C as hasSlackNativeDataBlock, F as SLACK_TEXT_LIMIT, N as SLACK_EDIT_TEXT_LIMIT, O as normalizeSlackOutboundText, Y as escapeSlackMrkdwn, _ as resolveSlackReplyRenderPlan, c as normalizeSlackAllowOwnerEntry, k as buildSlackBlocksFallbackText, s as normalizeAllowListLower, u as resolveSlackAllowListMatch, z as truncateSlackText } from "./group-policy-CdnQzQBI.js";
+import { n as isSlackInteractiveRepliesEnabled, t as compileSlackInteractiveReplies } from "./interactive-replies-C3ffk6oN.js";
+import { r as formatSlackError } from "./probe-CVRuArHA.js";
 import { n as resolveSlackNativeStreaming, r as resolveSlackStreamingMode, t as mapStreamingModeToSlackLegacyDraftStreamMode } from "./streaming-compat-3_X-21wW.js";
-import { S as buildSlackEditTextPayload, _ as resolveSlackThreadHistory, b as resolveSlackBlocksText, f as removeSlackReaction, l as reactSlackMessage, r as editSlackMessage, t as deleteSlackMessage, v as resolveSlackThreadStarter, x as formatSlackFileReference, y as chooseSlackPrimaryText } from "./actions-BZiuSTIq.js";
-import { c as recordSlackThreadParticipation, l as buildSlackNativeDataDeliveryPlan, r as sendMessageSlack, s as hasSlackThreadParticipationWithPersistence } from "./send-DYp8ca-l.js";
-import { S as updateLastRoute, _ as resolveSlackChatType, b as resolveChannelResetConfig, d as authorizeSlackBotRoomMessage, f as resolveSlackCommandIngress, g as normalizeSlackChannelType, h as parseSlackAssistantThreadMetadata, l as recordInboundSession, m as buildSlackAssistantThreadMetadata, o as authorizeSlackDirectMessage, p as resolveSlackEffectiveAllowFrom, r as resolveSlackRoomContextHints, u as resolveConversationLabel$1, v as readSessionUpdatedAt, w as stripSlackMentionsForCommandDetection, x as resolveStorePath, y as resolveChannelContextVisibilityMode } from "./provider-CmeoUiIM.js";
-import { n as resolveSlackChannelConfig } from "./policy-BVs4LiSa.js";
-import { a as resolveDeliveredSlackReplyThreadTs, i as readSlackReplyBlocks, n as deliverReplies, o as resolveSlackThreadTs, s as emitSlackMessageSentHooks, t as createSlackReplyDeliveryPlan } from "./replies-CJJCp6qz.js";
+import { S as buildSlackEditTextPayload, _ as resolveSlackThreadHistory, b as resolveSlackBlocksText, f as removeSlackReaction, l as reactSlackMessage, r as editSlackMessage, t as deleteSlackMessage, v as resolveSlackThreadStarter, x as formatSlackFileReference, y as chooseSlackPrimaryText } from "./actions-D51foiwR.js";
+import { c as hasSlackThreadParticipationWithPersistence, l as recordSlackThreadParticipation, r as sendMessageSlack, u as buildSlackNativeDataDeliveryPlan } from "./send-BZ1tPv7-.js";
+import { C as stripSlackMentionsForCommandDetection, _ as readSessionUpdatedAt, b as resolveStorePath, d as resolveSlackCommandIngress, f as resolveSlackEffectiveAllowFrom, g as resolveSlackChatType, h as normalizeSlackChannelType, l as resolveConversationLabel$1, m as parseSlackAssistantThreadMetadata, o as authorizeSlackDirectMessage, p as buildSlackAssistantThreadMetadata, r as resolveSlackRoomContextHints, u as authorizeSlackBotRoomMessage, v as resolveChannelContextVisibilityMode, x as updateLastRoute, y as resolveChannelResetConfig } from "./provider-htuIJGFD.js";
+import { n as resolveSlackChannelConfig } from "./policy-C31RYSuT.js";
+import { a as resolveDeliveredSlackReplyThreadTs, i as readSlackReplyBlocks, n as deliverReplies, o as resolveSlackThreadTs, s as emitSlackMessageSentHooks, t as createSlackReplyDeliveryPlan } from "./replies-Cgr2Gli4.js";
 import { asOptionalRecord, normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { resolveAgentRoute, resolveInboundLastRouteSessionKey, resolveThreadSessionKeys } from "openclaw/plugin-sdk/routing";
-import { buildChannelProgressDraftLine, buildChannelProgressDraftLineForEntry, createChannelMessageReplyPipeline, createChannelProgressDraftGate, createDraftStreamLoop, defineFinalizableLivePreviewAdapter, deliverWithFinalizableLivePreviewAdapter, formatChannelProgressDraftText, formatPlanChecklistLines, isChannelProgressDraftWorkToolName, mergeChannelProgressDraftLine, resolveAgentOutboundIdentity, resolveChannelMessageSourceReplyDeliveryMode, resolveChannelProgressDraftConfig, resolveChannelProgressDraftMaxLineChars, resolveChannelProgressDraftMaxLines, resolveChannelProgressDraftRender, resolveChannelStreamingBlockEnabled, resolveChannelStreamingNativeTransport, resolveChannelStreamingPreviewToolProgress, resolveChannelStreamingProgressCommentary, resolveChannelStreamingSuppressDefaultToolProgressMessages } from "openclaw/plugin-sdk/channel-outbound";
+import { buildChannelProgressDraftLine, buildChannelProgressDraftLineForEntry, createChannelMessageReplyPipeline, createChannelProgressDraftCompositor, createChannelProgressReceiptTracker, createDraftStreamLoop, defineFinalizableLivePreviewAdapter, deliverWithFinalizableLivePreviewAdapter, formatChannelProgressDraftText, formatPlanChecklistLines, isChannelProgressDraftWorkToolName, mergeChannelProgressDraftLine, resolveAgentOutboundIdentity, resolveChannelMessageSourceReplyDeliveryMode, resolveChannelProgressDraftConfig, resolveChannelProgressDraftMaxLineChars, resolveChannelProgressDraftMaxLines, resolveChannelProgressDraftRender, resolveChannelStreamingBlockEnabled, resolveChannelStreamingNativeTransport, resolveChannelStreamingPreviewToolProgress, resolveChannelStreamingSuppressDefaultToolProgressMessages } from "openclaw/plugin-sdk/channel-outbound";
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
-import { danger, logVerbose, shouldLogVerbose, sleep } from "openclaw/plugin-sdk/runtime-env";
-import { stripReasoningTagsFromText } from "openclaw/plugin-sdk/text-chunking";
+import { danger, logVerbose, shouldLogVerbose } from "openclaw/plugin-sdk/runtime-env";
 import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import { createHash } from "node:crypto";
 import fs from "node:fs/promises";
@@ -27,9 +27,9 @@ import { createChannelHistoryWindow } from "openclaw/plugin-sdk/reply-history";
 import { resolveHumanDelayConfig } from "openclaw/plugin-sdk/agent-runtime";
 import { mergePairLoopGuardConfig } from "openclaw/plugin-sdk/pair-loop-guard-runtime";
 import { enqueueSystemEvent } from "openclaw/plugin-sdk/system-event-runtime";
-import { buildChannelInboundEventContext, buildMentionRegexes, classifyChannelInboundEvent, dispatchChannelInboundReply, formatInboundEnvelope, hasVisibleInboundReplyDispatch, implicitMentionKindWhen, logInboundDrop, matchesMentionWithExplicit, recordDroppedChannelInboundHistory, resolveEnvelopeFormatOptions, resolveInboundMentionDecision, resolveUnmentionedGroupInboundPolicy, toInboundMediaFacts } from "openclaw/plugin-sdk/channel-inbound";
-import { DEFAULT_TIMING, createStatusReactionController, logAckFailure, logTypingFailure, removeAckReactionAfterReply, resolveAckReaction, shouldAckReaction } from "openclaw/plugin-sdk/channel-feedback";
-import { dispatchReplyWithBufferedBlockDispatcher } from "openclaw/plugin-sdk/reply-runtime";
+import { resolveChannelImplicitMentions } from "openclaw/plugin-sdk/channel-ingress-runtime";
+import { buildChannelInboundEventContext, buildMentionRegexes, classifyChannelInboundEvent, dispatchChannelInboundTurn, formatInboundEnvelope, hasVisibleInboundReplyDispatch, implicitMentionKindWhen, logInboundDrop, matchesMentionWithExplicit, recordDroppedChannelInboundHistory, resolveEnvelopeFormatOptions, resolveInboundMentionDecision, resolveInboundSupplementalSenderAllowed, resolveUnmentionedGroupInboundPolicy, toInboundMediaFacts } from "openclaw/plugin-sdk/channel-inbound";
+import { DEFAULT_TIMING, createStatusReactionController, logAckFailure, logTypingFailure, resolveAckReaction, shouldAckReaction } from "openclaw/plugin-sdk/channel-feedback";
 import { hasControlCommand } from "openclaw/plugin-sdk/command-detection";
 import { isAbortRequestText } from "openclaw/plugin-sdk/command-primitives-runtime";
 import { shouldHandleTextCommands } from "openclaw/plugin-sdk/command-surface";
@@ -216,9 +216,24 @@ function lineTaskStatus(line) {
 function slugTaskIdPart(value) {
 	return value?.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "") || "task";
 }
-function stableTaskIdPart(value) {
+function stableTaskIdPart(value, slugValue = value) {
 	const suffix = createHash("sha256").update(value).digest("hex").slice(0, 8);
-	return `${slugTaskIdPart(value)}_${suffix}`;
+	return `${slugTaskIdPart(slugValue).slice(0, 48)}_${suffix}`;
+}
+function resolveLineTaskIdentity(line) {
+	if (line.id?.trim()) return {
+		id: stableTaskIdPart(line.id),
+		contentDerived: false
+	};
+	return {
+		id: stableTaskIdPart([
+			line.kind,
+			line.toolName,
+			line.label,
+			line.text
+		].join("\0"), line.toolName ?? line.kind ?? line.label),
+		contentDerived: true
+	};
 }
 function buildPlanTasks(params) {
 	if (params.plan) return params.plan.slice(-50).map((entry, index) => ({
@@ -227,11 +242,23 @@ function buildPlanTasks(params) {
 		status: entry.status === "completed" ? "complete" : entry.status
 	}));
 	const maxLineChars = resolveMaxLineChars(params.maxLineChars, DEFAULT_SLACK_PROGRESS_TASK_DETAIL_MAX_CHARS);
-	return params.lines.slice(-50).map((line, index) => ({
-		id: line.id ? stableTaskIdPart(line.id) : `${slugTaskIdPart(line.toolName ?? line.kind ?? line.label)}_${index + 1}`,
-		title: lineTaskTitle(line, maxLineChars),
-		status: lineTaskStatus(line)
-	}));
+	const lines = params.lines.slice(-50);
+	const identities = lines.map(resolveLineTaskIdentity);
+	const contentIdOccurrences = /* @__PURE__ */ new Map();
+	return lines.map((line, index) => {
+		const identity = identities[index];
+		let id = identity.id;
+		if (identity.contentDerived) {
+			const occurrence = (contentIdOccurrences.get(id) ?? 0) + 1;
+			contentIdOccurrences.set(id, occurrence);
+			id = `${id}_${occurrence}`;
+		}
+		return {
+			id,
+			title: lineTaskTitle(line, maxLineChars),
+			status: lineTaskStatus(line)
+		};
+	});
 }
 function resolvePlanTitle(params) {
 	return compactChunkText(params.title?.trim() || params.label?.trim() || params.tasks.at(-1)?.title || SLACK_PROGRESS_PLAN_FALLBACK_TITLE);
@@ -242,7 +269,13 @@ function buildSlackProgressStreamChunks(params) {
 		plan: params.plan,
 		maxLineChars: params.maxLineChars
 	});
-	if (tasks.length === 0) return;
+	if (tasks.length === 0) {
+		const title = params.title?.trim() || params.label?.trim();
+		return title ? [{
+			type: "plan_update",
+			title: compactChunkText(title)
+		}] : void 0;
+	}
 	return [{
 		type: "plan_update",
 		title: resolvePlanTitle({
@@ -710,15 +743,6 @@ function resolveSlackTimestampMs(ts) {
 }
 //#endregion
 //#region extensions/slack/src/monitor/message-handler/dispatch.ts
-const SLACK_REASONING_TAG_RE = /<\s*(\/?)\s*(?:(?:antml:|mm:)?(?:think(?:ing)?|thought)|antthinking)\b[^<>]*>/gi;
-const SLACK_REASONING_LABEL_PREFIX_RE = /^\s*(?:>\s*)?Reasoning:\s*/iu;
-const SLACK_THINKING_LABEL_PREFIX_RE = /^\s*(?:>\s*)?Thinking\.{0,3}(?=\s*(?:\n|_))/iu;
-const SLACK_THREAD_LOADING_MESSAGES = [
-	"Reading the thread...",
-	"Checking context...",
-	"Working through the request...",
-	"Putting it all together..."
-];
 function resolveSlackMessageTimestampMs(message) {
 	return resolveSlackTimestampMs(message.event_ts ?? message.ts);
 }
@@ -820,43 +844,6 @@ function rememberSlackStreamRecipientTeam(params) {
 		if (oldest) cache.delete(oldest);
 	}
 }
-function normalizeSlackReasoningProgressLine(text) {
-	return (extractSlackReasoningTagText(text) || stripReasoningTagsFromText(text, {
-		mode: "strict",
-		trim: "both"
-	})).replace(SLACK_REASONING_LABEL_PREFIX_RE, "").replace(SLACK_THINKING_LABEL_PREFIX_RE, "").split(/\r?\n/u).map((line) => stripSimpleItalicMarkers(line)).filter(Boolean).join(" ").replace(/\s+/g, " ").trim();
-}
-function extractSlackReasoningTagText(text) {
-	if (!text) return "";
-	let result = "";
-	let lastIndex = 0;
-	let inReasoning = false;
-	SLACK_REASONING_TAG_RE.lastIndex = 0;
-	for (const match of text.matchAll(SLACK_REASONING_TAG_RE)) {
-		const index = match.index ?? 0;
-		if (inReasoning) result += text.slice(lastIndex, index);
-		inReasoning = match[1] !== "/";
-		lastIndex = index + match[0].length;
-	}
-	if (inReasoning) result += text.slice(lastIndex);
-	return result.trim();
-}
-function stripSimpleItalicMarkers(line) {
-	const trimmed = line.trim();
-	if (trimmed.length >= 2 && trimmed.startsWith("_") && trimmed.endsWith("_")) return trimmed.slice(1, -1).trim();
-	return trimmed;
-}
-function mergeSlackReasoningProgressText(current, incoming, options) {
-	if (!current) return incoming;
-	const normalizedCurrent = normalizeSlackReasoningProgressLine(current);
-	const normalizedIncoming = normalizeSlackReasoningProgressLine(incoming);
-	if (!normalizedIncoming || normalizedIncoming === normalizedCurrent) return current;
-	if (options?.snapshot === true || isSlackReasoningSnapshotText(incoming) || normalizedIncoming.startsWith(normalizedCurrent)) return incoming;
-	return `${current}${incoming}`;
-}
-function isSlackReasoningSnapshotText(text) {
-	return SLACK_REASONING_LABEL_PREFIX_RE.test(text) || SLACK_THINKING_LABEL_PREFIX_RE.test(text);
-}
 function createSlackEventDeliveryTracker() {
 	const deliveredKeys = /* @__PURE__ */ new Set();
 	return {
@@ -967,36 +954,31 @@ async function dispatchPreparedSlackMessage(prepared) {
 	const incomingThreadTs = message.thread_ts;
 	let didSetStatus = false;
 	const statusReactionsEnabled = prepared.ctxPayload.InboundEventKind !== "room_event" && Boolean(prepared.ackReactionPromise) && Boolean(reactionMessageTs) && cfg.messages?.statusReactions?.enabled === true;
-	const slackStatusAdapter = {
-		setReaction: async (emoji) => {
-			await reactSlackMessage(message.channel, reactionMessageTs ?? "", emoji, {
-				token: ctx.botToken,
-				client: slackClient
-			}).catch((err) => {
-				if (formatErrorMessage(err).includes("already_reacted")) return;
-				throw err;
-			});
-		},
-		removeReaction: async (emoji) => {
-			await removeSlackReaction(message.channel, reactionMessageTs ?? "", emoji, {
-				token: ctx.botToken,
-				client: slackClient
-			}).catch((err) => {
-				if (formatErrorMessage(err).includes("no_reaction")) return;
-				throw err;
-			});
-		}
-	};
-	const statusReactionTiming = {
-		...DEFAULT_TIMING,
-		...cfg.messages?.statusReactions?.timing
-	};
 	const statusReactions = createStatusReactionController({
 		enabled: statusReactionsEnabled,
-		adapter: slackStatusAdapter,
+		adapter: {
+			setReaction: async (emoji) => {
+				await reactSlackMessage(message.channel, reactionMessageTs ?? "", emoji, {
+					token: ctx.botToken,
+					client: slackClient
+				}).catch((err) => {
+					if (formatErrorMessage(err).includes("already_reacted")) return;
+					throw err;
+				});
+			},
+			removeReaction: async (emoji) => {
+				await removeSlackReaction(message.channel, reactionMessageTs ?? "", emoji, {
+					token: ctx.botToken,
+					client: slackClient
+				}).catch((err) => {
+					if (formatErrorMessage(err).includes("no_reaction")) return;
+					throw err;
+				});
+			}
+		},
 		initialEmoji: prepared.ackReactionValue || "eyes",
-		emojis: cfg.messages?.statusReactions?.emojis,
-		timing: cfg.messages?.statusReactions?.timing,
+		emojis: void 0,
+		timing: DEFAULT_TIMING,
 		onError: (err) => {
 			logAckFailure({
 				log: logVerbose,
@@ -1036,7 +1018,6 @@ async function dispatchPreparedSlackMessage(prepared) {
 					channelId: message.channel,
 					threadTs: statusThreadTs,
 					status: "is typing...",
-					loadingMessages: SLACK_THREAD_LOADING_MESSAGES,
 					eventScope: prepared.eventScope
 				});
 				if (typingReaction && message.ts) await reactSlackMessage(message.channel, message.ts, typingReaction, {
@@ -1156,6 +1137,11 @@ async function dispatchPreparedSlackMessage(prepared) {
 			delivery.outcome = "success";
 		}
 	};
+	const acknowledgeStoppedStreamedDeliveries = (session, messageId) => {
+		refreshStreamedAcknowledgements(session);
+		for (const delivery of streamedDeliveries) delivery.acknowledged = true;
+		emitAcknowledgedStreamedDeliveries(messageId);
+	};
 	const emitFailedPendingStreamedDeliveries = (error) => {
 		for (const delivery of streamedDeliveries) {
 			if (delivery.acknowledged || delivery.outcome) continue;
@@ -1209,8 +1195,7 @@ async function dispatchPreparedSlackMessage(prepared) {
 				session,
 				...slackMessageMetadata ? { metadata: slackMessageMetadata } : {}
 			});
-			for (const delivery of streamedDeliveries) delivery.acknowledged = true;
-			emitAcknowledgedStreamedDeliveries(stopResult.messageId);
+			acknowledgeStoppedStreamedDeliveries(session, stopResult.messageId);
 			observedReplyDelivery = true;
 			usedReplyThreadTs ??= session.threadTs;
 			return true;
@@ -1319,6 +1304,24 @@ async function dispatchPreparedSlackMessage(prepared) {
 		rememberDeliveredThreadTs(params.kind, params.session.threadTs);
 		return true;
 	};
+	const appendNativeProgressCompletion = async (isError) => {
+		const session = streamSession;
+		if (isError) nativeProgressTerminalStatus = "error";
+		if (!session || nativeProgressCompletionSent) return;
+		const chunks = buildNativeProgressCompletionChunks(isError ? "error" : "complete");
+		if (!chunks?.length) return;
+		try {
+			await appendSlackStream({
+				session,
+				chunks
+			});
+			nativeProgressCompletionSent = true;
+			observedReplyDelivery ||= session.delivered;
+		} catch (err) {
+			streamFailed = true;
+			runtime.error?.(danger(`slack-stream: native progress completion failed: ${formatSlackError(err)}`));
+		}
+	};
 	const deliverWithStreaming = async (params) => {
 		if (params.payload.isReasoning === true) return;
 		const reply = resolveSendableOutboundReplyParts(params.payload);
@@ -1344,13 +1347,6 @@ async function dispatchPreparedSlackMessage(prepared) {
 				});
 				return;
 			}
-			if (useNativeProgressStreaming && !streamSession) {
-				await deliverNormally({
-					payload: params.payload,
-					kind: params.kind
-				});
-				return;
-			}
 			if (!streamSession) {
 				const streamThreadTs = replyPlan.nextThreadTs();
 				plannedThreadTs = streamThreadTs;
@@ -1411,40 +1407,12 @@ async function dispatchPreparedSlackMessage(prepared) {
 				logVerbose("slack-stream: suppressed duplicate append payload");
 				return;
 			}
-			const completionChunks = useNativeProgressStreaming && !nativeProgressCompletionSent && (previewToolProgressLines.length > 0 || Boolean(latestPlan?.length) || Boolean(latestPlanExplanation) || [...nativeTaskState.values()].some((task) => task.status !== "complete" && task.status !== "error")) ? reconcileSlackNativeTaskChunks({
-				previousTasks: nativeTaskState,
-				chunks: buildSlackProgressStreamCompletionChunks({
-					title: resolveNativeProgressTitle(),
-					lines: resolveNativeProgressLines(),
-					plan: resolveNativeProgressPlan(),
-					maxLineChars: progressDraftMaxLineChars,
-					finalInProgressStatus: params.payload.isError ? "error" : "complete"
-				})
-			}).chunks : void 0;
-			if (useNativeProgressStreaming) {
-				if (completionChunks?.length) {
-					await appendSlackStream({
-						session: streamSession,
-						chunks: completionChunks
-					});
-					nativeProgressCompletionSent = true;
-					if (streamSession.delivered) observedReplyDelivery = true;
-				}
-				await deliverNormally({
-					payload: params.payload,
-					kind: params.kind,
-					forcedThreadTs: streamSession.threadTs
-				});
-				return;
-			}
 			if (text) recordStreamedDelivery(params.kind, text);
 			await appendSlackStream({
 				session: streamSession,
-				text: "\n" + text,
-				chunks: completionChunks
+				text: "\n" + text
 			});
 			refreshStreamedAcknowledgements(streamSession);
-			if (completionChunks?.length) nativeProgressCompletionSent = true;
 			if (streamSession.delivered) {
 				observedReplyDelivery = true;
 				if (params.kind === "final") observedFinalReplyDelivery = true;
@@ -1491,13 +1459,59 @@ async function dispatchPreparedSlackMessage(prepared) {
 			await deliverNormally({
 				payload: params.payload,
 				kind: params.kind,
-				forcedThreadTs: streamSession?.threadTs ?? plannedThreadTs
+				forcedThreadTs: streamSession?.threadTs ?? nativeProgressStreamThreadTs ?? plannedThreadTs
 			});
 		}
 	};
 	let draftPreviewCommitted = false;
 	const deliverSlackPayload = async (payload, info) => {
 		if (payload.isReasoning === true) return { visibleReplySent: false };
+		if (info.kind === "final" && slackStreaming.mode === "progress" && streamMode === "status_final") {
+			const hadProgressDraft = progressDraft.hasStarted;
+			progressDraft.markFinalReplyStarted();
+			if (useNativeProgressStreaming) {
+				await waitForNativeProgressStreamStart();
+				const finalThreadTs = streamSession?.threadTs ?? nativeProgressStreamThreadTs;
+				await deliverNormally({
+					payload,
+					kind: info.kind,
+					forcedThreadTs: finalThreadTs
+				});
+				await appendNativeProgressCompletion(payload.isError === true);
+				progressDraft.markFinalReplyDelivered();
+				if (!payload.isError && hadProgressDraft && streamSession) pendingNativeProgressReceipt = progressReceipt.buildSummaryLine();
+				return;
+			}
+			if (hadProgressDraft) try {
+				await draftStream?.flush();
+			} catch (err) {
+				logVerbose(`slack: progress draft flush before final failed (${formatSlackError(err)})`);
+			}
+			const receiptChannelId = hadProgressDraft ? draftStream?.channelId() : void 0;
+			const receiptMessageId = hadProgressDraft ? draftStream?.messageId() : void 0;
+			const draftThreadTs = hadProgressDraft ? usedReplyThreadTs ?? statusThreadTs : void 0;
+			await deliverNormally({
+				payload,
+				kind: info.kind,
+				...draftThreadTs ? { forcedThreadTs: draftThreadTs } : {}
+			});
+			progressDraft.markFinalReplyDelivered();
+			if (!payload.isError && receiptChannelId && receiptMessageId && !progressReceiptCollapsed) await collapseProgressReceipt({
+				channelId: receiptChannelId,
+				messageId: receiptMessageId,
+				text: progressReceipt.buildSummaryLine(),
+				threadTs: usedReplyThreadTs ?? statusThreadTs
+			});
+			return;
+		}
+		if (useNativeProgressStreaming) {
+			await deliverNormally({
+				payload,
+				kind: info.kind,
+				forcedThreadTs: streamSession?.threadTs ?? nativeProgressStreamThreadTs
+			});
+			return;
+		}
 		if (useStreaming) {
 			await deliverWithStreaming({
 				payload,
@@ -1688,8 +1702,6 @@ async function dispatchPreparedSlackMessage(prepared) {
 	const useNativeProgressStreaming = useStreaming && slackStreaming.mode === "progress";
 	const progressDraftActive = Boolean(draftStream) || useNativeProgressStreaming;
 	const previewToolProgressEnabled = progressDraftActive && resolveChannelStreamingPreviewToolProgress(account.config);
-	const commentaryProgressEnabled = progressDraftActive && resolveChannelStreamingProgressCommentary(account.config);
-	const commentaryDraftEnabled = progressDraftActive && (slackStreaming.mode === "progress" ? resolveChannelStreamingProgressCommentary(account.config, previewToolProgressEnabled) : previewToolProgressEnabled);
 	let shouldYieldDraftProgress = () => false;
 	const suppressDefaultToolProgressMessages = resolveChannelStreamingSuppressDefaultToolProgressMessages(account.config, {
 		draftStreamActive: Boolean(draftStream) || useNativeProgressStreaming,
@@ -1697,46 +1709,20 @@ async function dispatchPreparedSlackMessage(prepared) {
 		previewStreamingEnabled
 	});
 	let previewToolProgressSuppressed = false;
-	let previewToolProgressLines = [];
-	let lastNonEmptyPreviewToolProgressLines = [];
-	let latestPlan;
-	let latestPlanExplanation;
+	let legacyPreviewToolProgressLines = [];
 	let nativeTaskState = /* @__PURE__ */ new Map();
 	let appendRenderedText = "";
 	let appendSourceText = "";
-	let reasoningProgressRawText = "";
-	let statusUpdateCount = 0;
 	let nativeProgressCompletionSent = false;
+	let nativeProgressTerminalStatus = "complete";
 	let nativeProgressChunkKey;
+	const progressReceipt = createChannelProgressReceiptTracker();
+	let progressReceiptCollapsed = false;
+	let pendingNativeProgressReceipt;
 	const progressSeed = `${account.accountId}:${message.channel}`;
 	const useRichProgressDraft = streamMode === "status_final" && resolveChannelProgressDraftRender(account.config) === "rich";
 	const explicitProgressTitle = resolveExplicitSlackProgressTitle(account.config);
 	const progressDraftMaxLineChars = resolveChannelProgressDraftMaxLineChars(account.config);
-	const renderProgressDraft = () => {
-		if (!draftStream || streamMode !== "status_final") return;
-		const progressLines = previewToolProgressLines.length === 0 ? lastNonEmptyPreviewToolProgressLines : previewToolProgressLines;
-		const previewText = formatChannelProgressDraftText({
-			entry: account.config,
-			lines: progressLines,
-			seed: progressSeed,
-			formatLine: escapeSlackMrkdwn,
-			narration: latestPlanExplanation,
-			plan: latestPlan
-		});
-		if (!previewText) return;
-		const richProgressBlocks = useRichProgressDraft ? buildSlackProgressDraftBlocks({
-			title: explicitProgressTitle,
-			lines: progressLines,
-			plan: latestPlan,
-			narration: latestPlanExplanation,
-			maxLineChars: resolveChannelProgressDraftMaxLineChars(account.config)
-		}) : void 0;
-		draftStream.update(useRichProgressDraft && richProgressBlocks ? {
-			text: previewText,
-			blocks: richProgressBlocks
-		} : previewText);
-		hasStreamedMessage = true;
-	};
 	const waitForNativeProgressStreamStart = async () => {
 		if (streamSession || !nativeProgressStreamStartPromise) return true;
 		try {
@@ -1747,26 +1733,40 @@ async function dispatchPreparedSlackMessage(prepared) {
 		}
 		return !streamFailed;
 	};
-	const resolveNativeProgressPlan = () => latestPlan?.length ? latestPlan : void 0;
-	const resolveNativeProgressLines = () => {
-		if (latestPlan?.length || !latestPlanExplanation) return previewToolProgressLines;
+	const resolveStructuredProgressLines = (lines) => lines.map((line) => {
+		if (typeof line !== "string") return line;
+		const reasoning = line.startsWith("🧠 ");
+		const text = line.replace(/^(?:🧠|💬)\s+/u, "").replace(/^_(.*)_$/su, "$1").trim();
+		return {
+			...reasoning ? { id: "reasoning" } : {},
+			kind: "item",
+			text,
+			label: reasoning ? "Reasoning" : "Update",
+			prefix: false
+		};
+	});
+	const resolveNativeProgressPlan = (snapshot) => snapshot.plan?.length ? snapshot.plan : void 0;
+	const resolveNativeProgressLines = (snapshot) => {
+		const lines = resolveStructuredProgressLines(snapshot.lines);
+		if (snapshot.plan?.length || !snapshot.planExplanation) return lines;
 		const explanationLine = buildChannelProgressDraftLine({
 			event: "plan",
 			phase: "update",
-			explanation: latestPlanExplanation
+			explanation: snapshot.planExplanation
 		});
-		return explanationLine ? [...previewToolProgressLines, explanationLine] : previewToolProgressLines;
+		return explanationLine ? [...lines, explanationLine] : lines;
 	};
-	const resolveNativeProgressTitle = () => explicitProgressTitle && latestPlanExplanation ? `${explicitProgressTitle} — ${latestPlanExplanation}` : explicitProgressTitle ?? latestPlanExplanation;
-	const buildNativeProgressChunks = () => streamSession ? buildSlackProgressStreamUpdateChunks({
-		title: resolveNativeProgressTitle(),
-		lines: resolveNativeProgressLines(),
-		plan: resolveNativeProgressPlan(),
+	const combineProgressHeadlineAndExplanation = (headline, explanation) => headline && explanation && headline !== explanation ? `${headline} — ${explanation}` : headline ?? explanation;
+	const resolveNativeProgressTitle = (snapshot) => combineProgressHeadlineAndExplanation(explicitProgressTitle ?? snapshot.statusHeadline, snapshot.planExplanation);
+	const buildNativeProgressChunks = (snapshot) => streamSession ? buildSlackProgressStreamUpdateChunks({
+		title: resolveNativeProgressTitle(snapshot),
+		lines: resolveNativeProgressLines(snapshot),
+		plan: resolveNativeProgressPlan(snapshot),
 		maxLineChars: progressDraftMaxLineChars
 	}) : buildSlackProgressStreamStartChunks({
-		title: resolveNativeProgressTitle(),
-		lines: resolveNativeProgressLines(),
-		plan: resolveNativeProgressPlan(),
+		title: resolveNativeProgressTitle(snapshot),
+		lines: resolveNativeProgressLines(snapshot),
+		plan: resolveNativeProgressPlan(snapshot),
 		maxLineChars: progressDraftMaxLineChars
 	});
 	const markNativeProgressDelivered = (session, threadTs) => {
@@ -1824,12 +1824,14 @@ async function dispatchPreparedSlackMessage(prepared) {
 		nativeProgressChunkKey = chunkKey;
 	};
 	const updateNativeProgressStream = async () => {
+		const snapshot = progressDraft.getSnapshot();
+		const progressLines = resolveNativeProgressLines(snapshot);
 		const hasRetirableNativeTasks = [...nativeTaskState.values()].some((task) => task.status !== "complete" && task.status !== "error");
-		if (!useNativeProgressStreaming || streamFailed || previewToolProgressLines.length === 0 && !latestPlan?.length && !latestPlanExplanation && !hasRetirableNativeTasks) return;
+		if (!useNativeProgressStreaming || streamFailed || progressLines.length === 0 && !snapshot.plan?.length && !snapshot.statusHeadline && !explicitProgressTitle && !hasRetirableNativeTasks) return;
 		if (!await waitForNativeProgressStreamStart()) return;
 		const reconciled = reconcileSlackNativeTaskChunks({
 			previousTasks: nativeTaskState,
-			chunks: buildNativeProgressChunks()
+			chunks: buildNativeProgressChunks(snapshot)
 		});
 		const chunks = reconciled.chunks;
 		if (!chunks?.length) return;
@@ -1844,85 +1846,154 @@ async function dispatchPreparedSlackMessage(prepared) {
 			streamFailed = true;
 		}
 	};
-	const progressDraftGate = createChannelProgressDraftGate({ onStart: useNativeProgressStreaming ? updateNativeProgressStream : renderProgressDraft });
-	const pushPlanProgress = async (steps, explanation) => {
-		if (previewToolProgressSuppressed) return;
-		latestPlan = steps ? steps.map((entry) => ({ ...entry })) : void 0;
-		latestPlanExplanation = explanation?.replace(/\s+/g, " ").trim() || void 0;
-		if (!draftStream && !useNativeProgressStreaming) return;
-		if (streamMode !== "status_final" && !useNativeProgressStreaming) {
-			const text = formatChannelProgressDraftText({
-				entry: account.config,
-				lines: previewToolProgressLines,
-				seed: progressSeed,
-				formatLine: escapeSlackMrkdwn,
-				narration: latestPlanExplanation,
-				plan: latestPlan
+	const resetProgressTurnState = () => {
+		progressReceipt.reset();
+		progressReceiptCollapsed = false;
+		pendingNativeProgressReceipt = void 0;
+	};
+	const collapseProgressReceipt = async (params) => {
+		const { botToken: token } = ctx;
+		try {
+			await finalizeSlackPreviewEdit({
+				client: slackClient,
+				token,
+				accountId: account.accountId,
+				...params
 			});
-			if (text) {
-				draftStream?.update(text);
-				hasStreamedMessage = true;
+			progressReceiptCollapsed = true;
+		} catch (err) {
+			logVerbose(`slack: progress receipt edit failed (${formatSlackError(err)})`);
+		}
+	};
+	const progressDraft = createChannelProgressDraftCompositor({
+		entry: account.config,
+		mode: slackStreaming.mode,
+		active: progressDraftActive && streamMode === "status_final",
+		seed: progressSeed,
+		formatLine: escapeSlackMrkdwn,
+		reasoningLinePrefix: "🧠 ",
+		commentaryLinePrefix: "💬 ",
+		reasoningGate: previewToolProgressEnabled,
+		commentaryItalics: false,
+		updateOnLineChange: useNativeProgressStreaming || useRichProgressDraft,
+		update: async (previewText, options) => {
+			if (useNativeProgressStreaming) {
+				await updateNativeProgressStream();
+				return;
 			}
-			return;
+			if (!draftStream) return;
+			const snapshot = progressDraft.getSnapshot();
+			const structuredLines = resolveStructuredProgressLines(options?.lines ?? snapshot.lines);
+			const richNarration = combineProgressHeadlineAndExplanation(snapshot.statusHeadline, snapshot.planExplanation);
+			const richProgressBlocks = useRichProgressDraft ? buildSlackProgressDraftBlocks({
+				title: explicitProgressTitle,
+				lines: structuredLines,
+				plan: snapshot.plan,
+				narration: richNarration,
+				maxLineChars: progressDraftMaxLineChars
+			}) : void 0;
+			draftStream.update(useRichProgressDraft && richProgressBlocks ? {
+				text: previewText,
+				blocks: richProgressBlocks
+			} : previewText);
+			hasStreamedMessage = true;
+			if (options?.flush) await draftStream.flush();
 		}
-		const alreadyStarted = progressDraftGate.hasStarted;
-		await progressDraftGate.startNow();
-		if (alreadyStarted && progressDraftGate.hasStarted) await refreshStartedProgressDraft();
+	});
+	const commentaryProgressEnabled = progressDraft.commentaryProgressEnabled;
+	const buildNativeProgressCompletionChunks = (finalInProgressStatus) => {
+		const snapshot = progressDraft.getSnapshot();
+		const lines = resolveNativeProgressLines(snapshot);
+		const hasRetirableNativeTasks = [...nativeTaskState.values()].some((task) => task.status !== "complete" && task.status !== "error");
+		if (lines.length === 0 && !snapshot.plan?.length && !hasRetirableNativeTasks) return;
+		return reconcileSlackNativeTaskChunks({
+			previousTasks: nativeTaskState,
+			chunks: buildSlackProgressStreamCompletionChunks({
+				title: resolveNativeProgressTitle(snapshot),
+				lines,
+				plan: resolveNativeProgressPlan(snapshot),
+				maxLineChars: progressDraftMaxLineChars,
+				finalInProgressStatus
+			})
+		}).chunks;
 	};
-	const refreshStartedProgressDraft = async () => {
-		if (useNativeProgressStreaming) await updateNativeProgressStream();
-		else renderProgressDraft();
+	const finishNativeProgressTurn = async (completionChunks) => {
+		if (nativeProgressStreamStartPromise) await nativeProgressStreamStartPromise.catch(() => null);
+		const session = streamSession;
+		if (session && !session.stopped) try {
+			if (completionChunks?.length) nativeProgressCompletionSent = true;
+			const stopResult = await stopSlackStream({
+				session,
+				...completionChunks?.length ? { chunks: completionChunks } : {},
+				...slackMessageMetadata ? { metadata: slackMessageMetadata } : {}
+			});
+			acknowledgeStoppedStreamedDeliveries(session, stopResult?.messageId);
+			if (pendingNativeProgressReceipt && stopResult?.messageId) await collapseProgressReceipt({
+				channelId: session.channel,
+				messageId: stopResult.messageId,
+				text: pendingNativeProgressReceipt,
+				threadTs: session.threadTs
+			});
+		} catch (err) {
+			const error = formatSlackError(err);
+			emitAcknowledgedStreamedDeliveries();
+			emitFailedPendingStreamedDeliveries(error);
+			logVerbose(`slack-stream: failed to rotate native progress stream (${error})`);
+		}
+		streamSession = null;
+		nativeProgressStreamStartPromise = null;
+		nativeProgressStreamThreadTs = void 0;
+		streamFailed = false;
 	};
-	const pushPreviewProgress = async (line, options) => {
-		const lane = options?.lane ?? "tool";
-		const progressEnabled = lane === "commentary" ? commentaryDraftEnabled : previewToolProgressEnabled;
-		if (!draftStream && !useNativeProgressStreaming) return;
-		if (lane === "commentary" && commentaryProgressEnabled && shouldYieldDraftProgress()) return;
-		if (options?.toolName !== void 0 && !isChannelProgressDraftWorkToolName(options.toolName)) return;
-		const normalized = line?.text.replace(/\s+/g, " ").trim();
-		if (!line || !normalized) {
-			if (streamMode !== "status_final") return;
-			const alreadyStarted = progressDraftGate.hasStarted;
-			const progressActive = await progressDraftGate.noteWork();
-			if ((alreadyStarted || progressActive) && progressDraftGate.hasStarted) await refreshStartedProgressDraft();
+	const pushPlanProgress = async (steps, explanation) => {
+		if (streamMode === "status_final") {
+			await progressDraft.pushPlanProgress(steps, { explanation });
 			return;
 		}
-		if (streamMode !== "status_final") {
-			if (!progressEnabled || previewToolProgressSuppressed) return;
-			const nextLines = mergeChannelProgressDraftLine(previewToolProgressLines, line, { maxLines: resolveChannelProgressDraftMaxLines(account.config) });
-			if (nextLines === previewToolProgressLines) return;
-			previewToolProgressLines = nextLines;
-			draftStream?.update(formatChannelProgressDraftText({
-				entry: account.config,
-				lines: previewToolProgressLines,
-				seed: progressSeed,
-				formatLine: escapeSlackMrkdwn
-			}));
+		if (previewToolProgressSuppressed || !draftStream) return;
+		const text = formatChannelProgressDraftText({
+			entry: account.config,
+			lines: legacyPreviewToolProgressLines,
+			seed: progressSeed,
+			formatLine: escapeSlackMrkdwn,
+			narration: explanation,
+			plan: steps
+		});
+		if (text) {
+			draftStream.update(text);
 			hasStreamedMessage = true;
-			return;
-		}
-		if (progressEnabled && !previewToolProgressSuppressed) {
-			previewToolProgressLines = mergeChannelProgressDraftLine(previewToolProgressLines, line, { maxLines: resolveChannelProgressDraftMaxLines(account.config) });
-			if (previewToolProgressLines.length > 0) lastNonEmptyPreviewToolProgressLines = previewToolProgressLines;
 		}
-		if (useNativeProgressStreaming) {
-			if (progressDraftGate.hasStarted) await updateNativeProgressStream();
-			else {
-				await progressDraftGate.startNow();
-				if (progressDraftGate.hasStarted) await updateNativeProgressStream();
+	};
+	const pushPreviewProgress = async (line, options) => {
+		if (!draftStream && !useNativeProgressStreaming) return;
+		if (options?.toolName !== void 0 && !isChannelProgressDraftWorkToolName(options.toolName)) return;
+		const normalized = line?.text.replace(/\s+/g, " ").trim();
+		if (streamMode === "status_final") {
+			if (!line || !normalized) {
+				await progressDraft.noteActivity();
+				return;
 			}
+			await progressDraft.pushToolProgress(line, options);
 			return;
 		}
-		const alreadyStarted = progressDraftGate.hasStarted;
-		const progressActive = await progressDraftGate.noteWork();
-		if ((alreadyStarted || progressActive) && progressDraftGate.hasStarted) await refreshStartedProgressDraft();
+		if (!line || !normalized || !draftStream || !previewToolProgressEnabled || previewToolProgressSuppressed) return;
+		const nextLines = mergeChannelProgressDraftLine(legacyPreviewToolProgressLines, line, { maxLines: resolveChannelProgressDraftMaxLines(account.config) });
+		if (nextLines === legacyPreviewToolProgressLines) return;
+		legacyPreviewToolProgressLines = nextLines;
+		draftStream.update(formatChannelProgressDraftText({
+			entry: account.config,
+			lines: legacyPreviewToolProgressLines,
+			seed: progressSeed,
+			formatLine: escapeSlackMrkdwn
+		}));
+		hasStreamedMessage = true;
 	};
 	const updateDraftFromPartial = (text) => {
 		const trimmed = text?.trimEnd();
 		if (!trimmed) return;
 		if (streamMode === "append") {
 			previewToolProgressSuppressed = true;
-			previewToolProgressLines = [];
+			legacyPreviewToolProgressLines = [];
 			const next = applyAppendOnlyStreamUpdate({
 				incoming: trimmed,
 				rendered: appendRenderedText,
@@ -1935,74 +2006,86 @@ async function dispatchPreparedSlackMessage(prepared) {
 			hasStreamedMessage = true;
 			return;
 		}
-		if (streamMode === "status_final") {
-			if (!progressDraftGate.hasStarted) return;
-			statusUpdateCount += 1;
-			if (statusUpdateCount > 1 && statusUpdateCount % 4 !== 0) return;
-			renderProgressDraft();
-			return;
-		}
+		if (streamMode === "status_final") return;
 		previewToolProgressSuppressed = true;
-		previewToolProgressLines = [];
+		legacyPreviewToolProgressLines = [];
 		draftStream?.update(trimmed);
 		hasStreamedMessage = true;
 	};
 	const pushReasoningProgress = async (payload) => {
 		if (!payload?.text) return;
-		reasoningProgressRawText = mergeSlackReasoningProgressText(reasoningProgressRawText, payload.text, { snapshot: payload.isReasoningSnapshot === true });
-		const normalized = normalizeSlackReasoningProgressLine(reasoningProgressRawText);
-		if (!normalized) return;
-		await pushPreviewProgress({
-			id: "reasoning",
-			kind: "item",
-			text: normalized,
-			label: "Reasoning"
-		});
+		if (streamMode !== "status_final") {
+			const normalized = progressDraft.mergeReasoningProgress(payload.text, { snapshot: payload.isReasoningSnapshot === true }).replace(/^_(.*)_$/su, "$1").trim();
+			if (!normalized) return;
+			await pushPreviewProgress({
+				id: "reasoning",
+				kind: "item",
+				text: normalized,
+				label: "Reasoning"
+			});
+			return;
+		}
+		progressReceipt.noteReasoning();
+		await progressDraft.pushReasoningProgress(payload.text, { snapshot: payload.isReasoningSnapshot === true });
 	};
 	const resetDraftDeliveryState = () => {
 		hasStreamedMessage = false;
 		appendRenderedText = "";
 		appendSourceText = "";
-		statusUpdateCount = 0;
 	};
 	const resetDraftProgressState = () => {
-		reasoningProgressRawText = "";
+		progressDraft.resetReasoningProgress();
 		previewToolProgressSuppressed = false;
-		previewToolProgressLines = [];
+		legacyPreviewToolProgressLines = [];
+	};
+	const beginNewProgressTurn = async (options) => {
+		const completionChunks = useNativeProgressStreaming && !nativeProgressCompletionSent ? buildNativeProgressCompletionChunks(nativeProgressTerminalStatus) : void 0;
+		if (!progressDraft.beginNewTurn(options)) return false;
+		if (useNativeProgressStreaming) await finishNativeProgressTurn(completionChunks);
+		else draftStream?.forceNewMessage();
+		resetProgressTurnState();
+		nativeTaskState = /* @__PURE__ */ new Map();
+		nativeProgressCompletionSent = false;
+		nativeProgressTerminalStatus = "complete";
+		nativeProgressChunkKey = void 0;
+		draftPreviewCommitted = false;
+		observedFinalReplyDelivery = false;
+		deliveryTracker = createSlackEventDeliveryTracker();
+		progressReceiptCollapsed = false;
+		return true;
 	};
-	const onDraftBoundary = !shouldUseDraftStream ? void 0 : async () => {
-		if (hasStreamedMessage && streamMode !== "status_final") {
-			draftStream?.forceNewMessage();
-			resetDraftDeliveryState();
+	const onDraftBoundary = !shouldUseDraftStream && !useNativeProgressStreaming ? void 0 : async () => {
+		if (streamMode === "status_final") {
+			await beginNewProgressTurn();
+			return;
 		}
+		if (hasStreamedMessage) draftStream?.forceNewMessage();
+		resetDraftDeliveryState();
 		resetDraftProgressState();
 	};
-	const onQueuedFollowupAdmitted = !shouldUseDraftStream ? void 0 : async () => {
+	const onQueuedFollowupAdmitted = !shouldUseDraftStream && !useNativeProgressStreaming ? void 0 : async () => {
 		await draftStream?.flush();
-		draftStream?.forceNewMessage();
 		draftPreviewCommitted = false;
 		observedFinalReplyDelivery = false;
+		if (streamMode === "status_final") await beginNewProgressTurn({ force: true });
+		else draftStream?.forceNewMessage();
 		deliveryTracker = createSlackEventDeliveryTracker();
 		resetDraftDeliveryState();
 		resetDraftProgressState();
-		latestPlan = void 0;
-		latestPlanExplanation = void 0;
-		nativeTaskState = /* @__PURE__ */ new Map();
 	};
 	let dispatchError;
 	let queuedFinal = false;
 	let counts = {};
 	try {
-		const turnResult = await dispatchChannelInboundReply({
+		const turnResult = await dispatchChannelInboundTurn({
 			cfg,
 			channel: "slack",
 			accountId: route.accountId,
-			agentId: route.agentId,
-			routeSessionKey: route.sessionKey,
-			storePath: prepared.turn.storePath,
+			route: {
+				agentId: route.agentId,
+				sessionKey: route.sessionKey
+			},
 			ctxPayload: prepared.ctxPayload,
-			recordInboundSession,
-			dispatchReplyWithBufferedBlockDispatcher,
 			dispatcherOptions: {
 				...replyPipeline,
 				humanDelay: resolveHumanDelayConfig(cfg, route.agentId)
@@ -2015,6 +2098,7 @@ async function dispatchPreparedSlackMessage(prepared) {
 			history: prepared.turn.history,
 			botLoopProtection: resolveSlackBotLoopProtection(prepared),
 			replyOptions: {
+				...prepared.turnAdoptionLifecycle ? { turnAdoptionLifecycle: prepared.turnAdoptionLifecycle } : {},
 				skillFilter: prepared.channelConfig?.skills,
 				sourceReplyDeliveryMode,
 				suppressTyping: suppressRoomEventTyping ? true : void 0,
@@ -2023,6 +2107,8 @@ async function dispatchPreparedSlackMessage(prepared) {
 				onModelSelected,
 				suppressDefaultToolProgressMessages: suppressDefaultToolProgressMessages ? true : void 0,
 				commentaryProgressEnabled: commentaryProgressEnabled ? true : void 0,
+				progressPreambleEnabled: progressDraftActive && slackStreaming.mode === "progress" ? true : void 0,
+				commentaryPayloadsEnabled: commentaryProgressEnabled ? true : void 0,
 				onVerboseProgressVisibility: commentaryProgressEnabled ? (isActive) => {
 					shouldYieldDraftProgress = isActive;
 				} : void 0,
@@ -2032,7 +2118,10 @@ async function dispatchPreparedSlackMessage(prepared) {
 					updateDraftFromPartial(payload.text);
 				},
 				onAssistantMessageStart: onDraftBoundary,
-				onReasoningEnd: onDraftBoundary,
+				onReasoningEnd: async () => {
+					progressReceipt.closeReasoning();
+					await onDraftBoundary?.();
+				},
 				onQueuedFollowupAdmitted,
 				onReasoningStream: statusReactionsEnabled || previewToolProgressEnabled ? async (payload) => {
 					await pushReasoningProgress(payload);
@@ -2041,6 +2130,7 @@ async function dispatchPreparedSlackMessage(prepared) {
 				} : void 0,
 				onToolStart: async (payload) => {
 					if (statusReactionsEnabled) await statusReactions.setTool(payload.name);
+					if (payload.phase === "start") progressReceipt.noteToolCall(payload.name);
 					await pushPreviewProgress(buildChannelProgressDraftLineForEntry(account.config, {
 						event: "tool",
 						itemId: payload.itemId,
@@ -2051,6 +2141,14 @@ async function dispatchPreparedSlackMessage(prepared) {
 					}, payload.detailMode ? { detailMode: payload.detailMode } : void 0), { toolName: payload.name });
 				},
 				onItemEvent: async (payload) => {
+					if (streamMode === "status_final" && payload.kind === "preamble") {
+						if (shouldYieldDraftProgress()) return;
+						await progressDraft.pushPreambleHeadline(payload.progressText, { itemId: payload.itemId });
+						if (commentaryProgressEnabled) {
+							if (await progressDraft.pushCommentaryProgress(payload.progressText, { itemId: payload.itemId })) progressReceipt.noteCommentary(payload.itemId, payload.progressText);
+						}
+						return;
+					}
 					await pushPreviewProgress(buildChannelProgressDraftLineForEntry(account.config, {
 						event: "item",
 						itemId: payload.itemId,
@@ -2063,11 +2161,11 @@ async function dispatchPreparedSlackMessage(prepared) {
 						summary: payload.summary,
 						progressText: payload.progressText,
 						meta: payload.meta
-					}), payload.kind === "preamble" ? { lane: "commentary" } : void 0);
+					}));
 				},
 				onPlanUpdate: async (payload) => {
 					if (payload.phase !== "update") return;
-					await pushPlanProgress(payload.planSteps, payload.explanation);
+					await pushPlanProgress(payload.steps, payload.explanation);
 				},
 				onApprovalEvent: async (payload) => {
 					if (payload.phase !== "requested") return;
@@ -2118,30 +2216,26 @@ async function dispatchPreparedSlackMessage(prepared) {
 	} catch (err) {
 		dispatchError = err;
 	} finally {
-		progressDraftGate.cancel();
+		progressDraft.cancel();
 		await draftStream?.discardPending();
 	}
 	let streamFallbackDelivered = false;
 	const finalStream = streamSession;
 	if (finalStream && !finalStream.stopped) try {
-		const completionChunks = useNativeProgressStreaming && !nativeProgressCompletionSent && (previewToolProgressLines.length > 0 || Boolean(latestPlan?.length) || Boolean(latestPlanExplanation) || [...nativeTaskState.values()].some((task) => task.status !== "complete" && task.status !== "error")) ? reconcileSlackNativeTaskChunks({
-			previousTasks: nativeTaskState,
-			chunks: buildSlackProgressStreamCompletionChunks({
-				title: resolveNativeProgressTitle(),
-				lines: resolveNativeProgressLines(),
-				plan: resolveNativeProgressPlan(),
-				maxLineChars: progressDraftMaxLineChars,
-				finalInProgressStatus: dispatchError ? "error" : "complete"
-			})
-		}).chunks : void 0;
+		const completionChunks = useNativeProgressStreaming && !nativeProgressCompletionSent ? buildNativeProgressCompletionChunks(dispatchError ? "error" : nativeProgressTerminalStatus) : void 0;
 		if (completionChunks?.length) nativeProgressCompletionSent = true;
 		const stopResult = await stopSlackStream({
 			session: finalStream,
 			...completionChunks?.length ? { chunks: completionChunks } : {},
 			...slackMessageMetadata ? { metadata: slackMessageMetadata } : {}
 		});
-		for (const delivery of streamedDeliveries) delivery.acknowledged = true;
-		emitAcknowledgedStreamedDeliveries(stopResult?.messageId);
+		acknowledgeStoppedStreamedDeliveries(finalStream, stopResult?.messageId);
+		if (pendingNativeProgressReceipt && stopResult?.messageId && !progressReceiptCollapsed) await collapseProgressReceipt({
+			channelId: finalStream.channel,
+			messageId: stopResult.messageId,
+			text: pendingNativeProgressReceipt,
+			threadTs: finalStream.threadTs
+		});
 	} catch (err) {
 		if (err instanceof SlackStreamNotDeliveredError) {
 			streamFallbackDelivered = await deliverPendingStreamFallback(finalStream, err);
@@ -2174,19 +2268,10 @@ async function dispatchPreparedSlackMessage(prepared) {
 		observedReplyDelivery,
 		fallbackDelivered: streamFallbackDelivered
 	});
-	if (statusReactionsEnabled) if (dispatchError) {
-		await statusReactions.setError();
-		if (ctx.removeAckAfterReply) (async () => {
-			await sleep(statusReactionTiming.errorHoldMs);
-			if (anyReplyDelivered) await statusReactions.clear();
-		})();
-	} else if (anyReplyDelivered) {
+	if (statusReactionsEnabled) if (dispatchError) await statusReactions.setError();
+	else if (anyReplyDelivered) {
 		await statusReactions.setDone();
-		if (ctx.removeAckAfterReply) (async () => {
-			await sleep(statusReactionTiming.doneHoldMs);
-			await statusReactions.clear();
-		})();
-		else statusReactions.restoreInitial();
+		statusReactions.restoreInitial();
 	} else await statusReactions.restoreInitial();
 	const participationThreadTs = usedReplyThreadTs ?? statusThreadTs;
 	if (anyReplyDelivered && participationThreadTs) recordSlackThreadParticipation(account.accountId, message.channel, participationThreadTs, {
@@ -2202,23 +2287,6 @@ async function dispatchPreparedSlackMessage(prepared) {
 		const finalCount = counts.final;
 		logVerbose(`slack: delivered ${finalCount} reply${finalCount === 1 ? "" : "ies"} to ${prepared.replyTarget}`);
 	}
-	if (!statusReactionsEnabled) removeAckReactionAfterReply({
-		removeAfterReply: ctx.removeAckAfterReply && anyReplyDelivered,
-		ackReactionPromise: prepared.ackReactionPromise,
-		ackReactionValue: prepared.ackReactionValue,
-		remove: () => removeSlackReaction(message.channel, prepared.ackReactionMessageTs ?? "", prepared.ackReactionValue, {
-			token: ctx.botToken,
-			client: slackClient
-		}),
-		onError: (err) => {
-			logAckFailure({
-				log: logVerbose,
-				channel: "slack",
-				target: `${message.channel}/${message.ts}`,
-				error: err
-			});
-		}
-	});
 }
 function toLintErrorObject(value, fallbackMessage) {
 	if (value instanceof Error) return value;
@@ -2228,6 +2296,51 @@ function toLintErrorObject(value, fallbackMessage) {
 	return error;
 }
 //#endregion
+//#region extensions/slack/src/agent-context.ts
+function asRecord(value) {
+	return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function trimmedString(value) {
+	return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function normalizeEntity(value) {
+	const entity = asRecord(value);
+	const type = trimmedString(entity?.type);
+	if (!entity || !type) return;
+	const teamId = trimmedString(entity.team_id);
+	if (type === "slack#/types/channel_id" || type === "slack#/types/canvas_id" || type === "slack#/types/list_id") {
+		const entityValue = trimmedString(entity.value);
+		return entityValue ? {
+			type,
+			value: entityValue,
+			...teamId ? { team_id: teamId } : {}
+		} : void 0;
+	}
+	if (type !== "slack#/types/message_context") return;
+	const message = asRecord(entity.value);
+	const channelId = trimmedString(message?.channel_id);
+	const messageTs = trimmedString(message?.message_ts);
+	return channelId && messageTs ? {
+		type,
+		value: {
+			channel_id: channelId,
+			message_ts: messageTs
+		},
+		...teamId ? { team_id: teamId } : {}
+	} : void 0;
+}
+function isSlackAppContext(value) {
+	return Boolean(asRecord(value));
+}
+function normalizeSlackAppContextEntities(value) {
+	const context = asRecord(value);
+	if (!Array.isArray(context?.entities)) return [];
+	return context.entities.flatMap((entity) => {
+		const normalized = normalizeEntity(entity);
+		return normalized ? [normalized] : [];
+	});
+}
+//#endregion
 //#region extensions/slack/src/monitor/message-handler/preflight-audio.ts
 const SLACK_DEFAULT_ECHO_TRANSCRIPT_FORMAT = "📝 \"{transcript}\"";
 const loadSlackPreflightAudioRuntime = createLazyRuntimeModule(() => import("./preflight-audio.runtime-D5Bgags0.js"));
@@ -2267,8 +2380,7 @@ async function resolveSlackPreflightAudioTranscript(params) {
 		const { transcribeFirstAudio } = await loadSlackPreflightAudioRuntime();
 		const transcript = await transcribeFirstAudio({
 			ctx: {
-				MediaPaths: params.media.map((entry) => entry.path),
-				MediaTypes: params.media.map((entry) => entry.contentType ?? ""),
+				media: [...params.media],
 				Provider: "slack",
 				Surface: "slack",
 				OriginatingChannel: "slack",
@@ -2321,7 +2433,7 @@ async function discardSlackPreflightMedia(media) {
 const SLACK_MENTION_RESOLUTION_CONCURRENCY = 4;
 const SLACK_MENTION_RESOLUTION_MAX_LOOKUPS_PER_MESSAGE = 20;
 const SLACK_USER_MENTION_RE$1 = /<@([A-Z0-9]+)(?:\|[^>]+)?>/gi;
-const loadSlackMediaModule$1 = createLazyRuntimeModule(() => import("./actions-BZiuSTIq.js").then((n) => n.g));
+const loadSlackMediaModule$1 = createLazyRuntimeModule(() => import("./actions-D51foiwR.js").then((n) => n.g));
 function collectUniqueSlackMentionIds$1(texts) {
 	const seen = /* @__PURE__ */ new Set();
 	const mentionIds = [];
@@ -2600,7 +2712,7 @@ function resolveSlackInitialAgentRoute(params) {
 	};
 }
 function resolveSlackRoutingContext(params) {
-	const { ctx, account, message, isDirectMessage, isGroupDm, isRoom, isRoomish, channelConfig, seedTopLevelRoomThread, assistantThreadTs, eventScope } = params;
+	const { ctx, account, message, isDirectMessage, isGroupDm, isRoom, isRoomish, channelConfig, seedTopLevelRoomThread, assistantThreadTs, agentViewThreadTs, eventScope } = params;
 	let route = resolveSlackInitialAgentRoute({
 		ctx,
 		account,
@@ -2620,7 +2732,7 @@ function resolveSlackRoutingContext(params) {
 	const isThreadReply = threadContext.isThreadReply;
 	const autoThreadId = !isThreadReply && replyToMode === "all" && threadContext.messageTs ? threadContext.messageTs : void 0;
 	const seedCandidateThreadId = threadContext.incomingThreadTs ?? threadContext.messageTs;
-	const routedThreadId = (isDirectMessage ? assistantThreadTs : isRoomish ? isThreadReply && threadTs ? threadTs : void 0 : isThreadReply ? threadTs : autoThreadId) ?? (isRoomish ? !isThreadReply && isRoom && seedTopLevelRoomThread && replyToMode !== "off" && seedCandidateThreadId ? seedCandidateThreadId : void 0 : void 0);
+	const routedThreadId = (isDirectMessage ? assistantThreadTs ?? agentViewThreadTs : isRoomish ? isThreadReply && threadTs ? threadTs : void 0 : isThreadReply ? threadTs : autoThreadId) ?? (isRoomish ? !isThreadReply && isRoom && seedTopLevelRoomThread && replyToMode !== "off" && seedCandidateThreadId ? seedCandidateThreadId : void 0 : void 0);
 	const baseConversationId = resolveSlackBaseConversationId({
 		message,
 		isDirectMessage,
@@ -2743,7 +2855,7 @@ function formatSlackThreadLabelSnippet(text) {
 }
 //#endregion
 //#region extensions/slack/src/monitor/message-handler/prepare-thread-context.ts
-const loadSlackMediaModule = createLazyRuntimeModule(() => import("./actions-BZiuSTIq.js").then((n) => n.g));
+const loadSlackMediaModule = createLazyRuntimeModule(() => import("./actions-D51foiwR.js").then((n) => n.g));
 const SLACK_THREAD_CONTEXT_USER_LOOKUP_CONCURRENCY = 4;
 function resolveSlackThreadSessionFreshness(params) {
 	return params.ctx.channelRuntime?.session?.resolveEntryResetFreshness?.({
@@ -2758,14 +2870,21 @@ function resolveSlackThreadSessionFreshness(params) {
 	});
 }
 function isSlackThreadContextSenderAllowed(params) {
-	if (params.allowFromLower.length === 0 || params.botId) return true;
-	if (!params.userId) return false;
-	return resolveSlackAllowListMatch({
-		allowList: params.allowFromLower,
-		id: params.userId,
-		name: params.userName,
-		allowNameMatching: params.allowNameMatching
-	}).allowed;
+	return resolveInboundSupplementalSenderAllowed({
+		isGroup: true,
+		groupPolicy: params.allowFromLower.length === 0 ? "open" : "allowlist",
+		allowFrom: params.allowFromLower,
+		isSenderAllowed: (allowFrom) => {
+			if (params.botId) return true;
+			if (!params.userId) return false;
+			return resolveSlackAllowListMatch({
+				allowList: allowFrom,
+				id: params.userId,
+				name: params.userName,
+				allowNameMatching: params.allowNameMatching
+			}).allowed;
+		}
+	});
 }
 async function resolveSlackThreadUserMap(params) {
 	const uniqueUserIds = [];
@@ -3389,6 +3508,14 @@ async function prepareSlackMessage(params) {
 	const assistantThreadContext = mergeSlackAssistantThreadContext(messageAssistantThreadContext, cachedAssistantThreadContext ?? restoredAssistantThreadContext);
 	const assistantThreadContextToCache = messageAssistantThreadContext || restoredAssistantThreadContext ? assistantThreadContext : void 0;
 	if (assistantThreadContextToCache) ctx.saveSlackAssistantThreadContext(assistantThreadContextToCache, opts.eventScope);
+	const hasAgentViewMessageSignal = isDirectMessage && !opts.eventScope && !assistantThreadContext && isSlackAppContext(message.app_context);
+	if (hasAgentViewMessageSignal) await ctx.recordSlackAgentView();
+	const managedViewThreadTs = message.thread_ts;
+	const isManagedViewRoot = isDirectMessage && !opts.eventScope && !assistantThreadContext && !message.parent_user_id && Boolean(managedViewThreadTs && message.ts && managedViewThreadTs === message.ts);
+	if (isManagedViewRoot && managedViewThreadTs) await ctx.recordSlackManagedViewThread(message.channel, managedViewThreadTs);
+	const hasManagedViewThread = isDirectMessage && !opts.eventScope && !assistantThreadContext && Boolean(managedViewThreadTs && await ctx.isSlackManagedViewThread(message.channel, managedViewThreadTs));
+	const isAgentViewMessage = isDirectMessage && !opts.eventScope && !assistantThreadContext && (hasAgentViewMessageSignal || isManagedViewRoot || hasManagedViewThread || await ctx.isSlackAgentView());
+	const agentViewThreadTs = isAgentViewMessage ? message.thread_ts ?? message.ts : void 0;
 	const channelReplyToMode = channelConfig?.replyToMode ?? resolveSlackReplyToMode(account, channelChatType);
 	const willImplicitlyThreadReply = isRoom && !channelRequireMention && channelReplyToMode !== "off";
 	const seedTopLevelRoomThreadBySource = opts.source === "app_mention" || opts.wasMentioned === true || explicitlyMentioned || willImplicitlyThreadReply;
@@ -3403,6 +3530,7 @@ async function prepareSlackMessage(params) {
 		channelConfig,
 		seedTopLevelRoomThread: seedTopLevelRoomThreadBySource,
 		assistantThreadTs: assistantThreadContext?.threadTs,
+		agentViewThreadTs,
 		eventScope: opts.eventScope
 	});
 	let mentionCheckTranscript;
@@ -3428,6 +3556,7 @@ async function prepareSlackMessage(params) {
 	const { configuredBinding, configuredBindingSessionKey } = routing;
 	const isAssistantThreadMessage = Boolean(isDirectMessage && messageAssistantThreadContext);
 	const forcedAssistantReplyThreadTs = Boolean(assistantThreadContext?.threadTs && (isThreadReply || isAssistantThreadMessage || replyToMode !== "off")) ? assistantThreadContext?.threadTs : void 0;
+	const forcedReplyThreadTs = agentViewThreadTs ?? forcedAssistantReplyThreadTs;
 	if (runtimeBinding && shouldLogVerbose()) logVerbose(`slack: routed via bound conversation ${runtimeBinding.conversation.conversationId} -> ${runtimeBinding.targetSessionKey}`);
 	if (configuredBinding) {
 		const ensured = await ensureConfiguredBindingRouteReady({
@@ -3458,7 +3587,7 @@ async function prepareSlackMessage(params) {
 		name: void 0
 	});
 	let implicitMentionKinds = [];
-	if (!isDirectMessage && ctx.botUserId && message.thread_ts && !ctx.threadRequireExplicitMention && !wasMentioned) {
+	if (!isDirectMessage && ctx.botUserId && message.thread_ts && !wasMentioned) {
 		const replyToBotKinds = implicitMentionKindWhen("reply_to_bot", message.parent_user_id === ctx.botUserId);
 		implicitMentionKinds = replyToBotKinds.length > 0 ? replyToBotKinds : implicitMentionKindWhen("bot_thread_participant", await hasSlackThreadParticipationWithPersistence({
 			accountId: account.accountId,
@@ -3554,6 +3683,11 @@ async function prepareSlackMessage(params) {
 		surface: "slack"
 	});
 	const shouldRequireMention = isRoom ? channelConfig?.requireMention ?? ctx.defaultRequireMention : false;
+	const implicitMentions = resolveChannelImplicitMentions({
+		cfg,
+		channel: "slack",
+		accountId: account.accountId
+	});
 	if (message["_ambiguousThreadReply"]) {
 		ctx.logger.info({
 			channel: message.channel,
@@ -3586,7 +3720,7 @@ async function prepareSlackMessage(params) {
 		activation: {
 			requireMention: shouldRequireMention,
 			allowTextCommands,
-			...ctx.threadRequireExplicitMention ? { allowedImplicitMentionKinds: [] } : {}
+			implicitMentions
 		}
 	});
 	const senderGate = messageIngress.senderAccess.gate;
@@ -3633,6 +3767,7 @@ async function prepareSlackMessage(params) {
 			channelConfig,
 			seedTopLevelRoomThread: true,
 			assistantThreadTs: assistantThreadContext?.threadTs,
+			agentViewThreadTs,
 			eventScope: opts.eventScope
 		});
 		return seededMentionRouting;
@@ -3684,7 +3819,7 @@ async function prepareSlackMessage(params) {
 		preflightAudioTranscript = void 0;
 		preflightAudioMedia = void 0;
 	}
-	const directThreadRoutedToDmSession = !assistantThreadContext && isDirectMessage && isThreadReply && threadTs && runtimeBinding?.conversation.conversationId !== threadTs;
+	const directThreadRoutedToDmSession = !assistantThreadContext && !agentViewThreadTs && isDirectMessage && isThreadReply && threadTs && runtimeBinding?.conversation.conversationId !== threadTs;
 	const mentionDecision = resolveInboundMentionDecision({
 		facts: {
 			canDetectMention,
@@ -3698,7 +3833,7 @@ async function prepareSlackMessage(params) {
 			allowTextCommands,
 			hasControlCommand: hasControlCommandInMessage,
 			commandAuthorized,
-			...ctx.threadRequireExplicitMention ? { allowedImplicitMentionKinds: [] } : {}
+			implicitMentions
 		}
 	});
 	const effectiveWasMentioned = mentionDecision.effectiveWasMentioned;
@@ -3845,7 +3980,7 @@ async function prepareSlackMessage(params) {
 		previousTimestamp,
 		envelope: envelopeOptions
 	});
-	const dmHistoryContext = isDirectMessage && !isThreadReply && dmHistoryLimit > 0 && !previousTimestamp ? await resolveSlackDmHistoryContext({
+	const dmHistoryContext = isDirectMessage && !assistantThreadContext && !agentViewThreadTs && !isThreadReply && dmHistoryLimit > 0 && !previousTimestamp ? await resolveSlackDmHistoryContext({
 		ctx,
 		channelId: message.channel,
 		currentMessageTs: message.ts,
@@ -3903,7 +4038,8 @@ async function prepareSlackMessage(params) {
 	}) : dmHistoryContext.inboundHistory;
 	const commandBody = textForCommandDetection.trim();
 	const supplementalThreadHistoryBody = directThreadRoutedToDmSession && !threadHistoryBody ? threadStarterBody : threadHistoryBody;
-	const effectiveMessageThreadId = assistantThreadContext?.threadTs ?? threadContext.messageThreadId;
+	const effectiveMessageThreadId = assistantThreadContext?.threadTs ?? agentViewThreadTs ?? threadContext.messageThreadId;
+	const agentContextEntities = isAgentViewMessage ? normalizeSlackAppContextEntities(message.app_context) : [];
 	const ctxPayload = buildChannelInboundEventContext({
 		channel: "slack",
 		accountId: route.accountId,
@@ -3926,6 +4062,7 @@ async function prepareSlackMessage(params) {
 		},
 		route: {
 			agentId: route.agentId,
+			dmScope: route.dmScope,
 			accountId: route.accountId,
 			routeSessionKey: sessionKey,
 			parentSessionKey: threadKeys.parentSessionKey
@@ -3944,6 +4081,7 @@ async function prepareSlackMessage(params) {
 			commandBody,
 			inboundHistory
 		},
+		sessionTranscript: { historyLimit: isRoomish ? ctx.historyLimit : dmHistoryLimit },
 		access: {
 			mentions: {
 				canDetectMention: isRoomish,
@@ -3967,8 +4105,15 @@ async function prepareSlackMessage(params) {
 		extra: {
 			GroupSubject: isRoomish ? roomLabel : void 0,
 			UntrustedContext: untrustedChannelMetadata ? [untrustedChannelMetadata] : void 0,
+			UntrustedStructuredContext: agentContextEntities.length > 0 ? [{
+				label: "Slack active context",
+				source: "slack",
+				type: "active_view",
+				payload: { entities: agentContextEntities }
+			}] : void 0,
 			TransportThreadId: directThreadRoutedToDmSession ? threadContext.messageThreadId : void 0,
 			SlackAssistantThread: assistantThreadContext ? true : void 0,
+			SlackAgentThread: agentViewThreadTs ? true : void 0,
 			SlackAssistantThreadContextChannelId: assistantThreadContext?.channelId,
 			SlackAssistantThreadContextTeamId: assistantThreadContext?.teamId,
 			SlackAssistantThreadContextEnterpriseId: assistantThreadContext?.enterpriseId ?? void 0,
@@ -4058,7 +4203,7 @@ async function prepareSlackMessage(params) {
 			} : void 0
 		},
 		replyToMode,
-		...forcedAssistantReplyThreadTs ? { forcedReplyThreadTs: forcedAssistantReplyThreadTs } : {},
+		...forcedReplyThreadTs ? { forcedReplyThreadTs } : {},
 		...assistantThreadContext ? { slackMessageMetadata: buildSlackAssistantThreadMetadata(assistantThreadContext) } : {},
 		requireMention: shouldRequireMention,
 		isDirectMessage,