@openclaw/slack 2026.7.2-beta.1 → 2026.7.2-beta.3

package/dist/{pipeline.runtime-f0eJJoJL.js → pipeline.runtime-CTvokbty.js}

@@ -1,20 +1,20 @@
-import { u as resolveSlackReplyToMode } from "./accounts-BOJJiHSr.js";
+import { u as resolveSlackReplyToMode } from "./accounts-DQEbYKh9.js";
 import { i as parseSlackTarget } from "./target-parsing-N6lHogYZ.js";
 import "./targets-KmjP2E8s.js";
-import { C as hasSlackNativeDataBlock, F as SLACK_TEXT_LIMIT, K as escapeSlackMrkdwn, N as SLACK_EDIT_TEXT_LIMIT, O as normalizeSlackOutboundText, _ as resolveSlackReplyRenderPlan, c as normalizeSlackAllowOwnerEntry, k as buildSlackBlocksFallbackText, r as formatSlackError, s as normalizeAllowListLower, u as resolveSlackAllowListMatch, z as truncateSlackText } from "./group-policy-C-b2ZnSl.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-Bw-65m3V.js";
+import { n as isSlackInteractiveRepliesEnabled, t as compileSlackInteractiveReplies } from "./interactive-replies-Dm_t2R9S.js";
+import { r as formatSlackError } from "./probe-Borhn9PQ.js";
 import { n as resolveSlackNativeStreaming, r as resolveSlackStreamingMode, t as mapStreamingModeToSlackLegacyDraftStreamMode } from "./streaming-compat-3_X-21wW.js";
-import { C as buildSlackEditTextPayload, S as formatSlackFileReference, _ as resolveSlackThreadHistory, b as resolveSlackBlocksText, f as removeSlackReaction, l as reactSlackMessage, r as editSlackMessage, t as deleteSlackMessage, v as resolveSlackThreadStarter, y as chooseSlackPrimaryText } from "./actions-DkTcWmpT.js";
-import { c as recordSlackThreadParticipation, l as buildSlackNativeDataDeliveryPlan, r as sendMessageSlack, s as hasSlackThreadParticipationWithPersistence } from "./send-NEfJ0GvM.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-Ds-y-imP.js";
-import { n as resolveSlackChannelConfig } from "./policy-f8b0edSi.js";
-import { a as resolveDeliveredSlackReplyThreadTs, i as readSlackReplyBlocks, n as deliverReplies, o as resolveSlackThreadTs, s as emitSlackMessageSentHooks, t as createSlackReplyDeliveryPlan } from "./replies-BMvf3ihj.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-CF0tUY5q.js";
+import { c as hasSlackThreadParticipationWithPersistence, l as recordSlackThreadParticipation, r as sendMessageSlack, u as buildSlackNativeDataDeliveryPlan } from "./send-KuTDky7i.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-B-HVL5ZE.js";
+import { n as resolveSlackChannelConfig } from "./policy-b_dOPDCq.js";
+import { a as resolveDeliveredSlackReplyThreadTs, i as readSlackReplyBlocks, n as deliverReplies, o as resolveSlackThreadTs, s as emitSlackMessageSentHooks, t as createSlackReplyDeliveryPlan } from "./replies-B4bOdrYb.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, 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 { 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 { 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, removeAckReactionAfterReply, resolveAckReaction, shouldAckReaction } from "openclaw/plugin-sdk/channel-feedback";
-import { dispatchReplyWithBufferedBlockDispatcher } from "openclaw/plugin-sdk/reply-runtime";
 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,17 +216,49 @@ 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) {
-	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)
+	if (params.plan) return params.plan.slice(-50).map((entry, index) => ({
+		id: `plan_step_${index + 1}`,
+		title: compactTitle(entry.step),
+		status: entry.status === "completed" ? "complete" : entry.status
 	}));
+	const maxLineChars = resolveMaxLineChars(params.maxLineChars, DEFAULT_SLACK_PROGRESS_TASK_DETAIL_MAX_CHARS);
+	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);
@@ -234,9 +266,16 @@ function resolvePlanTitle(params) {
 function buildSlackProgressStreamChunks(params) {
 	const tasks = buildPlanTasks({
 		lines: params.lines,
+		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({
@@ -254,15 +293,63 @@ function buildSlackProgressStreamChunks(params) {
 function buildSlackProgressDraftBlocks(params) {
 	const label = params.label?.trim() || params.title?.trim();
 	const maxLineChars = resolveMaxLineChars(params.maxLineChars, DEFAULT_SLACK_PROGRESS_DETAIL_MAX_CHARS);
-	const renderedBlocks = [...label ? [{
-		type: "section",
-		text: field(`*${escapeSlackMrkdwn(label)}*`)
-	}] : [], ...params.lines.map((line) => ({
+	const planLines = formatPlanChecklistLines(params.plan ?? [], {
+		maxLines: 50,
+		maxLineChars
+	});
+	const narration = params.narration?.replace(/\s+/g, " ").trim();
+	const headBlocks = [
+		...label ? [{
+			type: "section",
+			text: field(`*${escapeSlackMrkdwn(label)}*`)
+		}] : [],
+		...narration ? [{
+			type: "section",
+			text: field(`_${escapeSlackMrkdwn(narration)}_`)
+		}] : [],
+		...planLines.length > 0 ? [{
+			type: "section",
+			text: field(planLines.map((line) => escapeSlackMrkdwn(line)).join("\n"))
+		}] : []
+	].slice(0, 50);
+	const lineBudget = Math.max(0, 50 - headBlocks.length);
+	const renderedBlocks = [...headBlocks, ...params.lines.slice(-lineBudget).map((line) => ({
 		type: "section",
 		fields: [field(legacyLineTitle(line)), field(legacyLineDetail(line, maxLineChars))]
-	}))].slice(-50);
+	}))];
 	return renderedBlocks.length ? renderedBlocks : void 0;
 }
+/**
+* Slack native streams key task rows by persistent id with no removal chunk.
+* When the task source switches representation (tool lines <-> typed plan) or
+* a snapshot drops ids, previously emitted non-terminal rows must receive a
+* final update or they linger in_progress forever.
+*/
+function reconcileSlackNativeTaskChunks(params) {
+	const nextTasks = /* @__PURE__ */ new Map();
+	for (const chunk of params.chunks ?? []) if (chunk.type === "task_update") nextTasks.set(chunk.id, {
+		title: chunk.title,
+		status: chunk.status
+	});
+	const terminalized = [...params.previousTasks].filter(([id, task]) => !nextTasks.has(id) && task.status !== "complete" && task.status !== "error").map(([id, task]) => {
+		const entry = {
+			title: task.title,
+			status: "complete"
+		};
+		nextTasks.set(id, entry);
+		return {
+			type: "task_update",
+			id,
+			title: task.title,
+			status: "complete"
+		};
+	});
+	for (const [id, task] of params.previousTasks) if (!nextTasks.has(id)) nextTasks.set(id, task);
+	return {
+		chunks: params.chunks?.length ? [...params.chunks, ...terminalized] : terminalized.length ? terminalized : params.chunks,
+		tasks: nextTasks
+	};
+}
 function buildSlackProgressStreamStartChunks(params) {
 	return buildSlackProgressStreamChunks(params);
 }
@@ -656,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);
 }
@@ -766,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 {
@@ -982,7 +1023,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, {
@@ -1102,6 +1142,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;
@@ -1130,7 +1175,7 @@ async function dispatchPreparedSlackMessage(prepared) {
 			delivery.outcome = "success";
 		}
 	};
-	const deliveryTracker = createSlackEventDeliveryTracker();
+	let deliveryTracker = createSlackEventDeliveryTracker();
 	const markPreviewPayloadDelivered = (params) => {
 		deliveryTracker.markDelivered(params);
 		const nextThreadTs = replyPlan.peekThreadTs();
@@ -1155,8 +1200,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;
@@ -1265,6 +1309,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);
@@ -1290,13 +1352,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;
@@ -1357,36 +1412,12 @@ async function dispatchPreparedSlackMessage(prepared) {
 				logVerbose("slack-stream: suppressed duplicate append payload");
 				return;
 			}
-			const completionChunks = useNativeProgressStreaming && !nativeProgressCompletionSent && previewToolProgressLines.length > 0 ? buildSlackProgressStreamCompletionChunks({
-				title: explicitProgressTitle,
-				lines: previewToolProgressLines,
-				maxLineChars: progressDraftMaxLineChars,
-				finalInProgressStatus: params.payload.isError ? "error" : "complete"
-			}) : 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;
@@ -1433,13 +1464,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,
@@ -1630,8 +1707,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,
@@ -1639,39 +1714,20 @@ async function dispatchPreparedSlackMessage(prepared) {
 		previewStreamingEnabled
 	});
 	let previewToolProgressSuppressed = false;
-	let previewToolProgressLines = [];
-	let lastNonEmptyPreviewToolProgressLines = [];
+	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
-		});
-		if (!previewText) return;
-		const richProgressBlocks = useRichProgressDraft ? buildSlackProgressDraftBlocks({
-			title: explicitProgressTitle,
-			lines: progressLines,
-			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 {
@@ -1682,13 +1738,40 @@ async function dispatchPreparedSlackMessage(prepared) {
 		}
 		return !streamFailed;
 	};
-	const buildNativeProgressChunks = () => streamSession ? buildSlackProgressStreamUpdateChunks({
-		title: explicitProgressTitle,
-		lines: 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: snapshot.planExplanation
+		});
+		return explanationLine ? [...lines, explanationLine] : lines;
+	};
+	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: explicitProgressTitle,
-		lines: previewToolProgressLines,
+		title: resolveNativeProgressTitle(snapshot),
+		lines: resolveNativeProgressLines(snapshot),
+		plan: resolveNativeProgressPlan(snapshot),
 		maxLineChars: progressDraftMaxLineChars
 	});
 	const markNativeProgressDelivered = (session, threadTs) => {
@@ -1746,78 +1829,176 @@ async function dispatchPreparedSlackMessage(prepared) {
 		nativeProgressChunkKey = chunkKey;
 	};
 	const updateNativeProgressStream = async () => {
-		if (!useNativeProgressStreaming || streamFailed || previewToolProgressLines.length === 0) return;
+		const snapshot = progressDraft.getSnapshot();
+		const progressLines = resolveNativeProgressLines(snapshot);
+		const hasRetirableNativeTasks = [...nativeTaskState.values()].some((task) => task.status !== "complete" && task.status !== "error");
+		if (!useNativeProgressStreaming || streamFailed || progressLines.length === 0 && !snapshot.plan?.length && !snapshot.statusHeadline && !explicitProgressTitle && !hasRetirableNativeTasks) return;
 		if (!await waitForNativeProgressStreamStart()) return;
-		const chunks = buildNativeProgressChunks();
+		const reconciled = reconcileSlackNativeTaskChunks({
+			previousTasks: nativeTaskState,
+			chunks: buildNativeProgressChunks(snapshot)
+		});
+		const chunks = reconciled.chunks;
 		if (!chunks?.length) return;
 		const chunkKey = JSON.stringify(chunks);
 		if (chunkKey === nativeProgressChunkKey) return;
 		try {
-			if (!streamSession) {
-				await startNativeProgressStream(chunks, chunkKey);
-				return;
-			}
-			await appendNativeProgressStream(chunks, chunkKey);
+			if (!streamSession) await startNativeProgressStream(chunks, chunkKey);
+			else await appendNativeProgressStream(chunks, chunkKey);
+			nativeTaskState = reconciled.tasks;
 		} catch (err) {
 			runtime.error?.(danger(`slack-stream: native progress stream failed: ${formatSlackError(err)}, falling back`));
 			streamFailed = true;
 		}
 	};
-	const progressDraftGate = createChannelProgressDraftGate({ onStart: useNativeProgressStreaming ? updateNativeProgressStream : renderProgressDraft });
-	const refreshStartedProgressDraft = async () => {
-		if (useNativeProgressStreaming) await updateNativeProgressStream();
-		else renderProgressDraft();
+	const resetProgressTurnState = () => {
+		progressReceipt.reset();
+		progressReceiptCollapsed = false;
+		pendingNativeProgressReceipt = void 0;
 	};
-	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();
-			return;
+	const collapseProgressReceipt = async (params) => {
+		const { botToken: token } = ctx;
+		try {
+			await finalizeSlackPreviewEdit({
+				client: slackClient,
+				token,
+				accountId: account.accountId,
+				...params
+			});
+			progressReceiptCollapsed = true;
+		} catch (err) {
+			logVerbose(`slack: progress receipt edit failed (${formatSlackError(err)})`);
 		}
-		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
-			}));
+	};
+	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;
+			}
+			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 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 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 pushPlanProgress = async (steps, explanation) => {
+		if (streamMode === "status_final") {
+			await progressDraft.pushPlanProgress(steps, { explanation });
 			return;
 		}
-		if (progressEnabled && !previewToolProgressSuppressed) {
-			previewToolProgressLines = mergeChannelProgressDraftLine(previewToolProgressLines, line, { maxLines: resolveChannelProgressDraftMaxLines(account.config) });
-			if (previewToolProgressLines.length > 0) lastNonEmptyPreviewToolProgressLines = previewToolProgressLines;
+		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;
 		}
-		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,
@@ -1830,56 +2011,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"
-		});
-	};
-	const onDraftBoundary = !shouldUseDraftStream ? void 0 : async () => {
-		if (hasStreamedMessage && streamMode !== "status_final") {
-			draftStream?.forceNewMessage();
-			hasStreamedMessage = false;
-			appendRenderedText = "";
-			appendSourceText = "";
-			statusUpdateCount = 0;
+		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;
 		}
-		reasoningProgressRawText = "";
+		progressReceipt.noteReasoning();
+		await progressDraft.pushReasoningProgress(payload.text, { snapshot: payload.isReasoningSnapshot === true });
+	};
+	const resetDraftDeliveryState = () => {
+		hasStreamedMessage = false;
+		appendRenderedText = "";
+		appendSourceText = "";
+	};
+	const resetDraftProgressState = () => {
+		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 && !useNativeProgressStreaming ? void 0 : async () => {
+		if (streamMode === "status_final") {
+			await beginNewProgressTurn();
+			return;
+		}
+		if (hasStreamedMessage) draftStream?.forceNewMessage();
+		resetDraftDeliveryState();
+		resetDraftProgressState();
+	};
+	const onQueuedFollowupAdmitted = !shouldUseDraftStream && !useNativeProgressStreaming ? void 0 : async () => {
+		await draftStream?.flush();
+		draftPreviewCommitted = false;
+		observedFinalReplyDelivery = false;
+		if (streamMode === "status_final") await beginNewProgressTurn({ force: true });
+		else draftStream?.forceNewMessage();
+		deliveryTracker = createSlackEventDeliveryTracker();
+		resetDraftDeliveryState();
+		resetDraftProgressState();
 	};
 	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)
@@ -1892,6 +2103,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,
@@ -1900,6 +2112,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,
@@ -1909,7 +2123,11 @@ 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);
 					if (!statusReactionsEnabled) return;
@@ -1917,6 +2135,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,
@@ -1927,6 +2146,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,
@@ -1939,17 +2166,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 pushPreviewProgress(buildChannelProgressDraftLine({
-						event: "plan",
-						phase: payload.phase,
-						title: payload.title,
-						explanation: payload.explanation,
-						steps: payload.steps
-					}));
+					await pushPlanProgress(payload.steps, payload.explanation);
 				},
 				onApprovalEvent: async (payload) => {
 					if (payload.phase !== "requested") return;
@@ -2000,26 +2221,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 ? buildSlackProgressStreamCompletionChunks({
-			title: explicitProgressTitle,
-			lines: previewToolProgressLines,
-			maxLineChars: progressDraftMaxLineChars,
-			finalInProgressStatus: dispatchError ? "error" : "complete"
-		}) : 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);
@@ -2199,7 +2420,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-DkTcWmpT.js").then((n) => n.g));
+const loadSlackMediaModule$1 = createLazyRuntimeModule(() => import("./actions-CF0tUY5q.js").then((n) => n.g));
 function collectUniqueSlackMentionIds$1(texts) {
 	const seen = /* @__PURE__ */ new Set();
 	const mentionIds = [];
@@ -2621,7 +2842,7 @@ function formatSlackThreadLabelSnippet(text) {
 }
 //#endregion
 //#region extensions/slack/src/monitor/message-handler/prepare-thread-context.ts
-const loadSlackMediaModule = createLazyRuntimeModule(() => import("./actions-DkTcWmpT.js").then((n) => n.g));
+const loadSlackMediaModule = createLazyRuntimeModule(() => import("./actions-CF0tUY5q.js").then((n) => n.g));
 const SLACK_THREAD_CONTEXT_USER_LOOKUP_CONCURRENCY = 4;
 function resolveSlackThreadSessionFreshness(params) {
 	return params.ctx.channelRuntime?.session?.resolveEntryResetFreshness?.({
@@ -2636,14 +2857,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 = [];
@@ -3336,7 +3564,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,
@@ -3432,6 +3660,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,
@@ -3464,7 +3697,7 @@ async function prepareSlackMessage(params) {
 		activation: {
 			requireMention: shouldRequireMention,
 			allowTextCommands,
-			...ctx.threadRequireExplicitMention ? { allowedImplicitMentionKinds: [] } : {}
+			implicitMentions
 		}
 	});
 	const senderGate = messageIngress.senderAccess.gate;
@@ -3576,7 +3809,7 @@ async function prepareSlackMessage(params) {
 			allowTextCommands,
 			hasControlCommand: hasControlCommandInMessage,
 			commandAuthorized,
-			...ctx.threadRequireExplicitMention ? { allowedImplicitMentionKinds: [] } : {}
+			implicitMentions
 		}
 	});
 	const effectiveWasMentioned = mentionDecision.effectiveWasMentioned;
@@ -3804,6 +4037,7 @@ async function prepareSlackMessage(params) {
 		},
 		route: {
 			agentId: route.agentId,
+			dmScope: route.dmScope,
 			accountId: route.accountId,
 			routeSessionKey: sessionKey,
 			parentSessionKey: threadKeys.parentSessionKey