@openclaw/slack 2026.7.2-beta.7 → 2026.8.1-beta.3

package/dist/{pipeline.runtime-DgtmuYCP.js → pipeline.runtime-Bbfd5VFW.js}

@@ -1,41 +1,44 @@
-import { t as resolveSlackReplyToMode } from "./account-reply-mode-DrUXogvO.js";
-import { i as parseSlackTarget } from "./target-parsing-N6lHogYZ.js";
-import "./targets-KmjP2E8s.js";
-import { $ as escapeSlackMrkdwn, A as normalizeSlackOutboundText, C as hasSlackNativeDataBlock, F as SLACK_EDIT_TEXT_MAX_BYTES, H as truncateSlackText, L as SLACK_TEXT_LIMIT, U as truncateSlackTextByUtf8Bytes, _ as resolveSlackReplyRenderPlan, c as normalizeSlackAllowOwnerEntry, j as buildSlackBlocksFallbackText, s as normalizeAllowListLower, u as resolveSlackAllowListMatch } from "./group-policy-NQZti9t-.js";
-import { r as formatSlackError } from "./probe-CgDsSops.js";
-import { n as resolveSlackNativeStreaming, r as resolveSlackStreamingMode, t as mapStreamingModeToSlackLegacyDraftStreamMode } from "./streaming-compat-3_X-21wW.js";
-import { _ as resolveSlackThreadHistory, b as buildSlackEditTextPayload, f as removeSlackReaction, l as reactSlackMessage, r as editSlackMessage, t as deleteSlackMessage, v as resolveSlackThreadStarter, y as formatSlackFileReference } from "./actions-D3NuJvva.js";
-import { a as resolveSlackMessageText } from "./block-text-DkHaoGem.js";
-import { c as hasSlackThreadParticipationWithPersistence, l as recordSlackThreadParticipation, r as sendMessageSlack, u as buildSlackNativeDataDeliveryPlan } from "./send-DsLeZpST.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-DmRizMZt.js";
-import { n as resolveSlackChannelConfig } from "./policy-PRysPn23.js";
-import { a as resolveDeliveredSlackReplyThreadTs, i as readSlackReplyBlocks, n as deliverReplies, o as resolveSlackThreadTs, s as emitSlackMessageSentHooks, t as createSlackReplyDeliveryPlan } from "./replies-4s_Vq_z9.js";
+import { n as resolveSlackConversationBindingRoute, r as resolveSlackReplyToMode, t as normalizeSlackRouteBindingConfig } from "./conversation-binding-route-DFVLUdYF.js";
+import { n as formatSlackTarget } from "./target-parsing-BnMD2ZqZ.js";
+import { B as SLACK_EDIT_TEXT_MAX_BYTES, F as normalizeSlackOutboundText, I as buildSlackBlocksFallbackText, J as truncateSlackText, O as hasSlackNativeDataBlock, S as resolveSlackReplyRenderPlan, U as SLACK_TEXT_LIMIT, Y as truncateSlackTextByUtf8Bytes, a as qualifySlackConversationId, ct as escapeSlackMrkdwn, d as normalizeSlackAllowOwnerEntry, et as SLACK_SESSION_LINK_ACTION_ID, o as qualifySlackRoutePeerId, p as resolveSlackAllowListMatch, q as countSlackTextUtf8Bytes, s as resolveSlackEnterpriseMainDmSessionKey, u as normalizeAllowListLower } from "./group-policy-DyfB_ZIE.js";
+import { r as formatSlackError } from "./probe-BVA65leh.js";
+import { n as resolveSlackStreamingMode, t as resolveSlackNativeStreaming } from "./streaming-compat-B-e0mqM0.js";
+import { b as formatSlackFileReferenceList, i as editSlackRenderedMessage, p as removeSlackReaction, r as editSlackMessage, t as deleteSlackMessage, u as reactSlackMessage, v as logVerbose$1, x as buildSlackEditTextPayload, y as formatSlackFileReference } from "./actions-DFk0ANVB.js";
+import { a as hasSlackTableBlock, c as resolveSlackMessageText$1, o as isSlackUnfurlAttachment, s as resolveSlackBlocksText } from "./slack-client-kind-BXyOOICI.js";
+import { c as hasSlackThreadFailureNotice, d as recordSlackThreadFailureNotice, f as recordSlackThreadParticipation, l as hasSlackThreadParticipation, m as buildSlackNativeDataDeliveryPlan, o as clearSlackThreadFailureNotice, r as sendMessageSlack, u as hasSlackThreadParticipationWithPersistence } from "./send-CtnOxKCc.js";
+import { S as updateLastRoute, _ as parseSlackAssistantThreadMetadata, b as resolveChannelResetConfig, c as resolveConversationLabel$1, d as resolveSlackEffectiveAllowFrom, g as buildSlackAssistantThreadMetadata, h as resolveSlackChatType, l as authorizeSlackBotRoomMessage, m as normalizeSlackChannelType, o as authorizeSlackDirectMessage, r as resolveSlackRoomContextHints, s as trackSlackDraftMessage, u as resolveSlackCommandIngress, v as readSessionUpdatedAt, w as stripSlackMentionsForCommandDetection, x as resolveStorePath, y as resolveChannelContextVisibilityMode } from "./provider-CUUiwsg2.js";
+import { n as resolveSlackChannelConfig } from "./policy-BKXSxrIS.js";
+import { a as resolveDeliveredSlackReplyThreadTs, i as readSlackReplyBlocks, n as deliverReplies, o as resolveSlackThreadTs, s as emitSlackMessageSentHooks, t as createSlackReplyDeliveryPlan } from "./replies-SnWyXcsL.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, 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 { buildChannelProgressDraftLine, buildChannelProgressDraftLineForEntry, createChannelMessageReplyPipeline, createChannelProgressDraftCompositor, createChannelProgressWorkCounter, createFinalizableDraftStreamControlsForState, defineFinalizableLivePreviewAdapter, deliverWithFinalizableLivePreviewAdapter, formatChannelProgressDraftText, formatPlanChecklistLines, isChannelProgressDraftWorkToolName, resolveAgentOutboundIdentity, resolveChannelMessageSourceReplyDeliveryMode, resolveChannelProgressDraftConfig, resolveChannelProgressDraftMaxLineChars, resolveChannelStreamingBlockEnabled, resolveChannelStreamingPreviewToolProgress, resolveChannelStreamingSuppressDefaultToolProgressMessages } from "openclaw/plugin-sdk/channel-outbound";
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 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 { pruneMapToMaxSize } from "openclaw/plugin-sdk/collection-runtime";
+import { ensureConfiguredBindingRouteReady } from "openclaw/plugin-sdk/conversation-runtime";
 import fs from "node:fs/promises";
+import { runTasksWithConcurrency } from "openclaw/plugin-sdk/concurrency-runtime";
 import { formatErrorMessage, toErrorObject } from "openclaw/plugin-sdk/error-runtime";
-import { asDateTimestampMs, asFiniteNumberInRange, parseStrictFiniteNumber, resolveExpiresAtMsFromDurationMs } from "openclaw/plugin-sdk/number-runtime";
-import { buildTtsSupplementMediaPayload, getReplyPayloadTtsSupplement, resolveSendableOutboundReplyParts } from "openclaw/plugin-sdk/reply-payload";
+import { buildTtsSupplementMediaPayload, getReplyPayloadTtsSupplement, isReplyPayloadNonTerminalToolErrorWarning, resolveSendableOutboundReplyParts } from "openclaw/plugin-sdk/reply-payload";
 import { filterSupplementalContextItems, resolvePinnedMainDmOwnerFromAllowlist, shouldIncludeSupplementalContext } from "openclaw/plugin-sdk/security-runtime";
-import { ensureConfiguredBindingRouteReady, resolveConfiguredBindingRoute, resolveRuntimeConversationBindingRoute } from "openclaw/plugin-sdk/conversation-runtime";
+import { mimeTypeFromFilePath } from "openclaw/plugin-sdk/media-mime";
 import { createChannelHistoryWindow } from "openclaw/plugin-sdk/reply-history";
-import { resolveDefaultAgentId, 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 { getGlobalHookRunner } from "openclaw/plugin-sdk/plugin-runtime";
+import { enqueueRoutedSystemEvent } from "openclaw/plugin-sdk/system-event-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, toInboundMediaFactsWithMetadata } from "openclaw/plugin-sdk/channel-inbound";
+import { asDateTimestampMs, asFiniteNumberInRange, parseStrictFiniteNumber, resolveExpiresAtMsFromDurationMs } from "openclaw/plugin-sdk/number-runtime";
+import { getGlobalHookRunner } from "openclaw/plugin-sdk/plugin-runtime";
+import { buildChannelInboundEventContext, buildMentionRegexes, classifyChannelInboundEvent, dispatchChannelInboundTurn, formatInboundEnvelope, formatInboundMediaUnavailableText, hasVisibleInboundReplyDispatch, implicitMentionKindWhen, logInboundDrop, matchesMentionWithExplicit, readAgentRunTerminalOutcome, recordDroppedChannelInboundHistory, resolveEnvelopeFormatOptions, resolveInboundMentionDecision, resolveInboundReplyDispatchCounts, resolveInboundSupplementalSenderAllowed, resolveUnmentionedGroupInboundPolicy, toInboundMediaFactsWithMetadata } from "openclaw/plugin-sdk/channel-inbound";
+import { resolveHumanDelayConfig } from "openclaw/plugin-sdk/agent-runtime";
+import { resolveGatewayPublicOrigin } from "openclaw/plugin-sdk/config-contracts";
+import { buildControlUiSessionPath } from "openclaw/plugin-sdk/session-discussion";
 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";
-import { mimeTypeFromFilePath } from "openclaw/plugin-sdk/media-mime";
-import { runTasksWithConcurrency } from "openclaw/plugin-sdk/concurrency-runtime";
+import { createChannelPreflightAudio, formatAudioTranscriptForAgent } from "openclaw/plugin-sdk/media-understanding-runtime";
 //#region extensions/slack/src/streaming.ts
 /**
 * Thrown when Slack definitively rejects a stream flush/finalize while text
@@ -133,7 +136,7 @@ async function appendSlackStream(params) {
 * Stop (finalize) a Slack stream.
 *
 * After calling this the stream message becomes a normal Slack message.
-* Optionally include final text to append before stopping.
+* Optionally include final chunks to append before stopping.
 *
 * If Slack's `chat.stopStream` responds with a definitive recipient/channel
 * rejection while text is still buffered locally, this function throws a
@@ -152,17 +155,15 @@ async function appendSlackStream(params) {
 * caller can emit the `message_sent` hook with a populated `messageId`.
 */
 async function stopSlackStream(params) {
-	const { session, text, chunks, metadata } = params;
+	const { session, chunks, metadata } = params;
 	if (session.stopped) {
 		logVerbose("slack-stream: stream already stopped, ignoring duplicate stop");
 		return {};
 	}
 	session.stopped = true;
-	if (text) session.pendingText += text;
-	logVerbose(`slack-stream: stopping stream in ${session.channel} thread=${session.threadTs}${text ? ` (final text: ${text.length} chars)` : ""}`);
+	logVerbose(`slack-stream: stopping stream in ${session.channel} thread=${session.threadTs}`);
 	try {
-		const stopResponse = await session.streamer.stop(text || chunks?.length || metadata ? {
-			...text ? { markdown_text: text } : {},
+		const stopResponse = await session.streamer.stop(chunks?.length || metadata ? {
 			...chunks?.length ? { chunks } : {},
 			...metadata ? { metadata } : {}
 		} : void 0);
@@ -212,7 +213,7 @@ function extractSlackErrorCode(err) {
 	return (typeof record.message === "string" ? record.message : "").match(/An API error occurred:\s*([a-z_][a-z0-9_]*)/i)?.[1];
 }
 function markSlackStreamFallbackDelivered(session) {
-	const nativeStreamWasStarted = session.delivered;
+	const nativeStreamWasStarted = session.delivered || Boolean(session.streamer.ts);
 	session.pendingText = "";
 	session.streamer.buffer = "";
 	session.stopped = !nativeStreamWasStarted;
@@ -256,12 +257,6 @@ function isSlackStreamingEnabled(params) {
 	if (params.mode === "progress") return params.nativeStreaming && params.nativeProgressTaskCards === true;
 	return false;
 }
-function shouldEnableSlackPreviewStreaming(params) {
-	return params.mode !== "off";
-}
-function shouldInitializeSlackDraftStream(params) {
-	return params.previewStreamingEnabled && !params.useStreaming;
-}
 function resolveSlackDisableBlockStreaming(params) {
 	if (params.useStreaming || params.shouldUseDraftStream) return true;
 	return typeof params.blockStreamingEnabled === "boolean" ? !params.blockStreamingEnabled : void 0;
@@ -272,11 +267,16 @@ function resolveExplicitSlackProgressTitle(entry) {
 	const trimmed = label.trim();
 	return trimmed && trimmed.toLowerCase() !== "auto" ? trimmed : void 0;
 }
+function resolveSlackProgressStyle(entry) {
+	return entry?.streaming?.progress?.style === "compact" ? "compact" : "card";
+}
 function resolveSlackNativeProgressTaskCards(entry) {
+	if (resolveSlackProgressStyle(entry) === "compact") return false;
 	const streaming = entry?.streaming;
-	if (!streaming || typeof streaming !== "object" || Array.isArray(streaming)) return false;
+	if (!streaming || typeof streaming !== "object" || Array.isArray(streaming)) return true;
 	const progressConfig = streaming.progress;
-	return Boolean(progressConfig) && typeof progressConfig === "object" && !Array.isArray(progressConfig) && progressConfig.nativeTaskCards === true;
+	if (!progressConfig || typeof progressConfig !== "object" || Array.isArray(progressConfig)) return true;
+	return progressConfig.nativeTaskCards !== false;
 }
 function resolveSlackStreamingThreadHint(params) {
 	return resolveSlackThreadTs({
@@ -386,21 +386,27 @@ function createSlackDraftStream(params) {
 	const remove = params.remove ?? deleteSlackMessage;
 	let streamMessageId;
 	let streamChannelId;
+	let untrackConversationBoundary;
+	let lastVisibleUpdate;
 	let lastSentKey = "";
-	let pendingUpdate;
-	let stopped = false;
+	const detachedMessages = [];
+	const finalizedMessageIds = /* @__PURE__ */ new Set();
+	const streamState = {
+		stopped: false,
+		final: false
+	};
 	const normalizeUpdate = (update) => typeof update === "string" ? { text: update } : update;
-	const sendOrEditStreamMessage = async (text) => {
-		if (stopped) return;
-		const trimmed = text.trimEnd();
+	const sendOrEditStreamMessage = async (pending) => {
+		if (streamState.stopped) return;
+		const update = normalizeUpdate(pending);
+		const trimmed = update.text.trimEnd();
 		if (!trimmed) return;
 		if (trimmed.length > maxChars) {
-			stopped = true;
+			streamState.stopped = true;
 			params.warn?.(`slack stream preview stopped (text length ${trimmed.length} > ${maxChars})`);
 			return;
 		}
-		const update = normalizeUpdate(pendingUpdate ?? text);
-		const blocks = update.text === text ? update.blocks : void 0;
+		const blocks = update.blocks;
 		const sentKey = `${trimmed}\n${blocks ? JSON.stringify(blocks) : ""}`;
 		if (sentKey === lastSentKey) return;
 		lastSentKey = sentKey;
@@ -413,56 +419,73 @@ function createSlackDraftStream(params) {
 					...params.eventScope ? { client: params.eventScope.client } : {},
 					...blocks ? { blocks } : {}
 				});
+				lastVisibleUpdate = {
+					text: trimmed,
+					...blocks ? { blocks } : {}
+				};
 				return;
 			}
+			const threadTs = params.resolveThreadTs?.();
+			const pendingBoundary = params.conversationChannelId ? trackSlackDraftMessage({
+				accountId: params.accountId,
+				teamId: params.eventScope?.teamId,
+				channelId: params.conversationChannelId,
+				threadTs,
+				onInterveningMessage: forceNewMessage
+			}) : void 0;
+			untrackConversationBoundary = pendingBoundary?.stop;
 			const sent = await send(params.target, trimmed, {
 				cfg: params.cfg,
 				token: params.token,
 				accountId: params.accountId,
-				threadTs: params.resolveThreadTs?.(),
+				threadTs,
 				identity: params.identity,
-				...params.eventScope ? {
-					client: params.eventScope.client,
-					enterpriseEventScope: params.eventScope
-				} : {},
+				eventScope: params.eventScope,
 				...params.metadata ? { metadata: params.metadata } : {},
 				...blocks ? { blocks } : {}
 			});
 			streamChannelId = sent.channelId || streamChannelId;
 			streamMessageId = sent.messageId || streamMessageId;
 			if (!streamChannelId || !streamMessageId) {
-				stopped = true;
+				stopTrackingConversationBoundary();
+				streamState.stopped = true;
 				params.warn?.("slack stream preview stopped (missing identifiers from sendMessage)");
 				return;
 			}
-			params.onMessageSent?.();
+			lastVisibleUpdate = {
+				text: trimmed,
+				...blocks ? { blocks } : {}
+			};
+			if (pendingBoundary && params.conversationChannelId === streamChannelId) pendingBoundary.setMessageTs(streamMessageId);
+			else {
+				stopTrackingConversationBoundary();
+				untrackConversationBoundary = trackSlackDraftMessage({
+					accountId: params.accountId,
+					teamId: params.eventScope?.teamId,
+					channelId: streamChannelId,
+					threadTs,
+					messageTs: streamMessageId,
+					onInterveningMessage: forceNewMessage
+				}).stop;
+			}
 		} catch (err) {
-			stopped = true;
+			stopTrackingConversationBoundary();
+			streamState.stopped = true;
 			params.warn?.(`slack stream preview failed: ${formatSlackError(err)}`);
 		}
 	};
-	const loop = createDraftStreamLoop({
+	const { loop, update, discardPending, seal } = createFinalizableDraftStreamControlsForState({
 		throttleMs,
-		isStopped: () => stopped,
-		sendOrEditStreamMessage
+		state: streamState,
+		sendOrEditStreamMessage,
+		emptyValue: "",
+		isEmpty: (value) => !normalizeUpdate(value).text.trim()
 	});
-	const stop = () => {
-		stopped = true;
-		loop.stop();
+	const stopTrackingConversationBoundary = () => {
+		untrackConversationBoundary?.();
+		untrackConversationBoundary = void 0;
 	};
-	const discardPending = async () => {
-		stop();
-		await loop.waitForInFlight();
-	};
-	const clear = async () => {
-		await discardPending();
-		const channelId = streamChannelId;
-		const messageId = streamMessageId;
-		streamChannelId = void 0;
-		streamMessageId = void 0;
-		lastSentKey = "";
-		pendingUpdate = void 0;
-		if (!channelId || !messageId) return;
+	const removeMessage = async (channelId, messageId) => {
 		try {
 			await remove(channelId, messageId, {
 				token: params.token,
@@ -473,31 +496,131 @@ function createSlackDraftStream(params) {
 			params.warn?.(`slack stream preview cleanup failed: ${formatSlackError(err)}`);
 		}
 	};
+	const clear = async () => {
+		stopTrackingConversationBoundary();
+		await discardPending();
+		const channelId = streamChannelId;
+		const messageId = streamMessageId;
+		streamChannelId = void 0;
+		streamMessageId = void 0;
+		lastVisibleUpdate = void 0;
+		lastSentKey = "";
+		if (!channelId || !messageId) return;
+		await removeMessage(channelId, messageId);
+	};
 	const forceNewMessage = () => {
+		stopTrackingConversationBoundary();
+		streamState.stopped = false;
+		streamState.final = false;
+		if (streamChannelId && streamMessageId && !finalizedMessageIds.has(streamMessageId)) detachedMessages.push({
+			channelId: streamChannelId,
+			messageId: streamMessageId
+		});
 		streamMessageId = void 0;
 		streamChannelId = void 0;
+		lastVisibleUpdate = void 0;
 		lastSentKey = "";
-		pendingUpdate = void 0;
 		loop.resetPending();
 	};
+	const dropDetachedMessages = async () => {
+		let message;
+		while ((message = detachedMessages.shift()) !== void 0) {
+			const { channelId, messageId } = message;
+			await removeMessage(channelId, messageId);
+		}
+	};
+	const discardPendingAndStopTracking = async () => {
+		stopTrackingConversationBoundary();
+		await discardPending();
+	};
+	const finalizeMessage = async (messageId, editFinal) => {
+		const channelId = streamChannelId;
+		const previousUpdate = lastVisibleUpdate;
+		if (!channelId || streamMessageId !== messageId || !previousUpdate) return false;
+		await editFinal();
+		if (streamChannelId === channelId && streamMessageId === messageId) {
+			finalizedMessageIds.add(messageId);
+			stopTrackingConversationBoundary();
+			return true;
+		}
+		try {
+			await edit(channelId, messageId, previousUpdate.text, {
+				cfg: params.cfg,
+				token: params.token,
+				accountId: params.accountId,
+				...params.eventScope ? { client: params.eventScope.client } : {},
+				...previousUpdate.blocks ? { blocks: previousUpdate.blocks } : {}
+			});
+		} catch (err) {
+			params.warn?.(`slack stream preview restore failed: ${formatSlackError(err)}`);
+		}
+		return false;
+	};
 	params.log?.(`slack stream preview ready (maxChars=${maxChars}, throttleMs=${throttleMs})`);
 	return {
-		update: (update) => {
-			const normalized = normalizeUpdate(update);
-			pendingUpdate = update;
-			loop.update(normalized.text);
-		},
+		update,
 		flush: loop.flush,
 		clear,
-		discardPending,
-		seal: discardPending,
-		stop,
+		discardPending: discardPendingAndStopTracking,
+		seal,
 		forceNewMessage,
+		dropDetachedMessages,
+		finalizeMessage,
 		messageId: () => streamMessageId,
 		channelId: () => streamChannelId
 	};
 }
 //#endregion
+//#region extensions/slack/src/stream-mode.ts
+function resolveSlackStreamingConfig(params) {
+	return {
+		mode: resolveSlackStreamingMode(params),
+		nativeStreaming: resolveSlackNativeStreaming(params)
+	};
+}
+function applyAppendOnlyStreamUpdate(params) {
+	const incoming = params.incoming.trimEnd();
+	if (!incoming) return {
+		rendered: params.rendered,
+		source: params.source,
+		changed: false
+	};
+	if (!params.rendered) return {
+		rendered: incoming,
+		source: incoming,
+		changed: true
+	};
+	if (incoming === params.source) return {
+		rendered: params.rendered,
+		source: params.source,
+		changed: false
+	};
+	if (incoming.startsWith(params.rendered)) return {
+		rendered: incoming,
+		source: incoming,
+		changed: incoming !== params.rendered
+	};
+	if (incoming.startsWith(params.source)) {
+		const delta = incoming.slice(params.source.length);
+		return {
+			rendered: `${params.rendered}${delta}`,
+			source: incoming,
+			changed: delta.length > 0
+		};
+	}
+	if (params.source.startsWith(incoming)) return {
+		rendered: params.rendered,
+		source: params.source,
+		changed: false
+	};
+	const separator = params.separator ?? (params.rendered.endsWith("\n") ? "" : "\n");
+	return {
+		rendered: `${params.rendered}${separator}${incoming}`,
+		source: incoming,
+		changed: true
+	};
+}
+//#endregion
 //#region extensions/slack/src/progress-blocks.ts
 const SLACK_PROGRESS_FIELD_MAX = 1800;
 const DEFAULT_SLACK_PROGRESS_DETAIL_MAX_CHARS = 120;
@@ -505,6 +628,14 @@ const DEFAULT_SLACK_PROGRESS_TASK_DETAIL_MAX_CHARS = 48;
 const SLACK_PROGRESS_CHUNK_TEXT_MAX = 256;
 const SLACK_PROGRESS_TASK_TITLE_MAX = 120;
 const SLACK_PROGRESS_PLAN_FALLBACK_TITLE = "Thinking";
+const SLACK_PROGRESS_LINE_DELTA_RE = /(?:^|\s)\+(\d+)\s+[−-](\d+)(?=\s|$)/u;
+function buildSessionSources(url) {
+	return [{
+		type: "url_source",
+		url,
+		text: "Open in OpenClaw"
+	}];
+}
 function field(text) {
 	return {
 		type: "mrkdwn",
@@ -535,18 +666,31 @@ function lineDetailParts(line) {
 function legacyLineTitle(line) {
 	return `${line.icon ?? "•"} *${escapeSlackMrkdwn(line.label)}*`;
 }
+function isAuthoredProgressLine(line) {
+	return line.id === "reasoning" || line.id?.startsWith("commentary:") === true;
+}
 function legacyLineDetail(line, maxChars) {
 	const detail = lineDetailParts(line).join(" · ");
-	return detail ? escapeSlackMrkdwn(compactDetail(detail, maxChars)) : "—";
+	if (detail) return escapeSlackMrkdwn(compactDetail(detail, maxChars));
+	if (isAuthoredProgressLine(line)) return normalizeSlackOutboundText(compactDetail(line.text.replace(/^(?:🧠|💬)\s+/u, ""), maxChars));
+	return "—";
 }
-function lineTaskTitle(line, maxLineChars) {
-	const label = line.label.replace(/\s+/g, " ").trim() || line.toolName || line.kind || "Update";
-	const detail = lineDetailParts(line).join(" · ") || line.status?.trim();
+function lineTaskTitle(line) {
+	const label = (line.kind === "command-output" ? line.toolName : void 0) || line.label.replace(/\s+/g, " ").trim() || line.toolName || line.kind || "Update";
 	const fallback = line.text.replace(/\s+/g, " ").trim();
-	if (detail) return compactTitle(`${label} — ${compactDetail(detail, maxLineChars)}`);
-	if (fallback && fallback !== label) return compactTitle(fallback);
+	if (fallback && fallback !== label) return compactTitle(lineDetailParts(line).length > 0 || line.status ? label : fallback);
 	return compactTitle(label);
 }
+function lineTaskDetails(line, maxLineChars) {
+	const detail = line.detail?.replace(SLACK_PROGRESS_LINE_DELTA_RE, "").replace(/\s+·\s*$/u, "").trim();
+	return detail && detail !== line.status?.trim() ? compactDetail(detail, maxLineChars) : void 0;
+}
+function lineTaskOutput(line) {
+	const match = line.detail ? SLACK_PROGRESS_LINE_DELTA_RE.exec(line.detail) : null;
+	if (match) return `+${match[1]} −${match[2]}`;
+	const status = line.status?.replace(/\s+/g, " ").trim();
+	return status && lineTaskStatus(line) === "error" ? status : void 0;
+}
 function lineTaskStatus(line) {
 	const normalized = line.status?.replace(/\s+/g, " ").trim().toLowerCase();
 	if (!normalized) return "in_progress";
@@ -594,15 +738,20 @@ function buildPlanTasks(params) {
 			contentIdOccurrences.set(id, occurrence);
 			id = `${id}_${occurrence}`;
 		}
-		return {
+		const details = lineTaskDetails(line, maxLineChars);
+		const output = lineTaskOutput(line);
+		const task = {
 			id,
-			title: lineTaskTitle(line, maxLineChars),
+			title: lineTaskTitle(line),
 			status: lineTaskStatus(line)
 		};
+		if (details) task.details = details;
+		if (output) task.output = output;
+		return task;
 	});
 }
 function resolvePlanTitle(params) {
-	return compactChunkText(params.title?.trim() || params.label?.trim() || params.tasks.at(-1)?.title || SLACK_PROGRESS_PLAN_FALLBACK_TITLE);
+	return compactChunkText(params.title?.trim() || params.label?.trim() || (params.tasks.at(-1)?.details ? `${params.tasks.at(-1)?.title} — ${params.tasks.at(-1)?.details}` : params.tasks.at(-1)?.title) || SLACK_PROGRESS_PLAN_FALLBACK_TITLE);
 }
 function buildSlackProgressStreamChunks(params) {
 	const tasks = buildPlanTasks({
@@ -612,38 +761,91 @@ function buildSlackProgressStreamChunks(params) {
 	});
 	if (tasks.length === 0) {
 		const title = params.title?.trim() || params.label?.trim();
-		return title ? [{
+		if (!title) return;
+		if (!params.sessionUrl && !params.diffStat) return [{
 			type: "plan_update",
 			title: compactChunkText(title)
-		}] : void 0;
+		}];
+		return [{
+			type: "plan_update",
+			title: compactChunkText(title)
+		}, {
+			type: "task_update",
+			id: "openclaw_summary",
+			title: "Completed",
+			status: "complete",
+			...formatTaskDiffOutput(params.diffStat) ? { output: formatTaskDiffOutput(params.diffStat) } : {},
+			...params.sessionUrl ? { sources: buildSessionSources(params.sessionUrl) } : {}
+		}];
 	}
+	const title = resolvePlanTitle({
+		label: params.label,
+		title: params.title,
+		tasks
+	});
+	const finalTaskIndex = tasks.length - 1;
+	const diffOutput = formatTaskDiffOutput(params.diffStat);
+	const taskChunks = tasks.map((task, index) => {
+		const chunk = {
+			type: "task_update",
+			id: task.id,
+			title: task.title,
+			status: task.status === "in_progress" ? params.finalInProgressStatus ?? (params.completeInProgress ? "complete" : task.status) : task.status
+		};
+		if (task.details) chunk.details = task.details;
+		if (task.output) chunk.output = task.output;
+		if (index === finalTaskIndex && diffOutput) chunk.output = [task.output, diffOutput].filter(Boolean).join(" · ");
+		if (index === finalTaskIndex && params.sessionUrl) chunk.sources = buildSessionSources(params.sessionUrl);
+		return chunk;
+	});
 	return [{
 		type: "plan_update",
-		title: resolvePlanTitle({
-			label: params.label,
-			title: params.title,
-			tasks
-		})
-	}, ...tasks.map((task) => ({
-		type: "task_update",
-		id: task.id,
-		title: task.title,
-		status: task.status === "in_progress" ? params.finalInProgressStatus ?? (params.completeInProgress ? "complete" : task.status) : task.status
-	}))];
-}
-function buildSlackProgressDraftBlocks(params) {
-	const label = params.label?.trim() || params.title?.trim();
+		title
+	}, ...taskChunks];
+}
+function formatDiffStat(diffStat) {
+	if (!diffStat || diffStat.files === 0 && diffStat.added === 0 && diffStat.removed === 0) return;
+	return [
+		`📝 ${diffStat.files} files`,
+		...diffStat.added > 0 ? [`+${diffStat.added}`] : [],
+		...diffStat.removed > 0 ? [`−${diffStat.removed}`] : []
+	].join(" ");
+}
+function formatTaskDiffOutput(diffStat) {
+	return diffStat && (diffStat.added > 0 || diffStat.removed > 0) ? `+${diffStat.added} −${diffStat.removed}` : void 0;
+}
+function buildActivityText(lines, maxLineChars) {
+	const rendered = [];
+	let length = 0;
+	for (const line of lines.slice(-50).toReversed()) {
+		const row = `${legacyLineTitle(line)} — ${legacyLineDetail(line, maxLineChars)}`;
+		const nextLength = length + row.length + (rendered.length > 0 ? 1 : 0);
+		if (nextLength > SLACK_PROGRESS_FIELD_MAX) break;
+		rendered.push(row);
+		length = nextLength;
+	}
+	return rendered.toReversed().join("\n");
+}
+function buildSlackProgressCardBlocks(params) {
 	const maxLineChars = resolveMaxLineChars(params.maxLineChars, DEFAULT_SLACK_PROGRESS_DETAIL_MAX_CHARS);
 	const planLines = formatPlanChecklistLines(params.plan ?? [], {
 		maxLines: 50,
 		maxLineChars
 	});
 	const narration = params.narration?.replace(/\s+/g, " ").trim();
-	const headBlocks = [
-		...label ? [{
+	const activityText = buildActivityText(params.lines, maxLineChars);
+	const diffStat = formatDiffStat(params.diffStat);
+	const workingFooter = [
+		...params.toolCalls && params.toolCalls > 0 ? [`🛠️ ${params.toolCalls} tools`] : [],
+		...diffStat ? [diffStat] : [],
+		...params.elapsedSeconds && params.elapsedSeconds > 0 ? [`⏱ ${params.elapsedSeconds}s`] : []
+	].join(" · ");
+	const footer = params.state === "working" ? workingFooter : diffStat;
+	return [
+		{
 			type: "section",
-			text: field(`*${escapeSlackMrkdwn(label)}*`)
-		}] : [],
+			text: field(`${params.state === "working" ? "🔄" : params.state === "success" ? "✅" : "❌"} *${escapeSlackMrkdwn(params.title.trim() || "Working")}*`)
+		},
 		...narration ? [{
 			type: "section",
 			text: field(`_${escapeSlackMrkdwn(narration)}_`)
@@ -651,52 +853,131 @@ function buildSlackProgressDraftBlocks(params) {
 		...planLines.length > 0 ? [{
 			type: "section",
 			text: field(planLines.map((line) => escapeSlackMrkdwn(line)).join("\n"))
+		}] : [],
+		...activityText ? [{
+			type: "section",
+			text: field(activityText)
+		}] : [],
+		...footer ? [{
+			type: "context",
+			elements: [field(footer)]
+		}] : [],
+		...params.state !== "working" && params.sessionUrl ? [{
+			type: "actions",
+			elements: [{
+				type: "button",
+				action_id: SLACK_SESSION_LINK_ACTION_ID,
+				text: {
+					type: "plain_text",
+					text: "Open in OpenClaw"
+				},
+				url: params.sessionUrl
+			}]
 		}] : []
 	].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))]
-	}))];
-	return renderedBlocks.length ? renderedBlocks : void 0;
+}
+const EMPTY_SLACK_NATIVE_STREAM_SNAPSHOT = { tasks: /* @__PURE__ */ new Map() };
+const SLACK_TASK_FIELD_SEPARATOR = " · ";
+function resolveTaskFieldDelta(previous, incoming) {
+	if (!incoming) return {
+		field: previous,
+		delta: void 0
+	};
+	if (previous?.rendered.includes(incoming)) return {
+		field: {
+			rendered: previous.rendered,
+			source: incoming
+		},
+		delta: void 0
+	};
+	const next = applyAppendOnlyStreamUpdate({
+		incoming,
+		rendered: previous?.rendered ?? "",
+		source: previous?.source ?? "",
+		separator: SLACK_TASK_FIELD_SEPARATOR
+	});
+	const delta = next.changed ? next.rendered.slice(previous?.rendered.length ?? 0) : void 0;
+	return {
+		field: {
+			rendered: next.rendered,
+			source: next.source
+		},
+		delta
+	};
 }
 /**
-* 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.
+* Turns a full task snapshot into the delta Slack must receive. Native streams
+* key rows by persistent id with no removal chunk: unchanged rows are omitted,
+* changed rows carry only their unsent field text, and rows that dropped out
+* (plan shrinks, tool-line <-> plan source switches) get a final complete
+* 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"
+	let planTitle = params.previous.planTitle;
+	const emitted = [];
+	for (const chunk of params.chunks ?? []) {
+		if (chunk.type === "plan_update") {
+			if (chunk.title !== planTitle) {
+				planTitle = chunk.title;
+				emitted.push(chunk);
+			}
+			continue;
+		}
+		if (chunk.type !== "task_update") {
+			emitted.push(chunk);
+			continue;
+		}
+		const previousRow = params.previous.tasks.get(chunk.id);
+		const status = chunk.status;
+		const details = resolveTaskFieldDelta(previousRow?.details, chunk.details);
+		const output = resolveTaskFieldDelta(previousRow?.output, chunk.output);
+		const sourcesChanged = Boolean(chunk.sources) && !previousRow?.sourcesSent;
+		const row = {
+			title: chunk.title,
+			status
 		};
-		nextTasks.set(id, entry);
-		return {
+		if (details.field) row.details = details.field;
+		if (output.field) row.output = output.field;
+		if (sourcesChanged || previousRow?.sourcesSent) row.sourcesSent = true;
+		nextTasks.set(chunk.id, row);
+		if (!(!previousRow || previousRow.title !== chunk.title || previousRow.status !== status || Boolean(details.delta) || Boolean(output.delta) || sourcesChanged)) continue;
+		const update = {
+			type: "task_update",
+			id: chunk.id,
+			title: chunk.title,
+			status
+		};
+		if (details.delta) update.details = details.delta;
+		if (output.delta) update.output = output.delta;
+		if (sourcesChanged) update.sources = chunk.sources;
+		emitted.push(update);
+	}
+	for (const [id, row] of params.previous.tasks) {
+		if (nextTasks.has(id)) continue;
+		if (row.status === "complete" || row.status === "error") {
+			nextTasks.set(id, row);
+			continue;
+		}
+		nextTasks.set(id, {
+			...row,
+			status: "complete"
+		});
+		emitted.push({
 			type: "task_update",
 			id,
-			title: task.title,
+			title: row.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
+		chunks: emitted.length > 0 ? emitted : void 0,
+		snapshot: {
+			...planTitle ? { planTitle } : {},
+			tasks: nextTasks
+		}
 	};
 }
-function buildSlackProgressStreamStartChunks(params) {
-	return buildSlackProgressStreamChunks(params);
-}
-function buildSlackProgressStreamUpdateChunks(params) {
-	return buildSlackProgressStreamChunks(params);
-}
 function buildSlackProgressStreamCompletionChunks(params) {
 	return buildSlackProgressStreamChunks({
 		...params,
@@ -704,48 +985,48 @@ function buildSlackProgressStreamCompletionChunks(params) {
 	});
 }
 //#endregion
-//#region extensions/slack/src/stream-mode.ts
-function resolveSlackStreamingConfig(params) {
-	const mode = resolveSlackStreamingMode(params);
-	return {
-		mode,
-		nativeStreaming: resolveSlackNativeStreaming(params),
-		draftMode: mapStreamingModeToSlackLegacyDraftStreamMode(mode)
-	};
+//#region extensions/slack/src/monitor/message-handler/dispatch-progress-render.ts
+function resolveStructuredProgressLines(lines) {
+	return 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
+		};
+	});
 }
-function applyAppendOnlyStreamUpdate(params) {
-	const incoming = params.incoming.trimEnd();
-	if (!incoming) return {
-		rendered: params.rendered,
-		source: params.source,
-		changed: false
-	};
-	if (!params.rendered) return {
-		rendered: incoming,
-		source: incoming,
-		changed: true
-	};
-	if (incoming === params.source) return {
-		rendered: params.rendered,
-		source: params.source,
-		changed: false
-	};
-	if (incoming.startsWith(params.source) || incoming.startsWith(params.rendered)) return {
-		rendered: incoming,
-		source: incoming,
-		changed: incoming !== params.rendered
-	};
-	if (params.source.startsWith(incoming)) return {
-		rendered: params.rendered,
-		source: params.source,
-		changed: false
-	};
-	const separator = params.rendered.endsWith("\n") ? "" : "\n";
-	return {
-		rendered: `${params.rendered}${separator}${incoming}`,
-		source: incoming,
-		changed: true
-	};
+function resolveNativeProgressPlan(snapshot) {
+	return snapshot.plan?.length ? snapshot.plan : void 0;
+}
+function resolveNativeProgressLines(snapshot) {
+	const lines = resolveStructuredProgressLines(snapshot.lines).filter((line) => line.id !== "reasoning" && line.id?.startsWith("commentary:") !== true);
+	if (snapshot.plan?.length || !snapshot.planExplanation) return lines;
+	const explanationLine = buildChannelProgressDraftLine({
+		event: "plan",
+		phase: "update",
+		explanation: snapshot.planExplanation
+	});
+	return explanationLine ? [...lines, explanationLine] : lines;
+}
+function resolveNativeProgressNarration(snapshot) {
+	const paragraphs = resolveStructuredProgressLines(snapshot.lines).filter((line) => line.id === "reasoning" || line.id?.startsWith("commentary:") === true).map((line) => line.text.trim()).filter((text, index, values) => Boolean(text) && values.indexOf(text) === index);
+	return paragraphs.length > 0 ? paragraphs.join("\n\n") : void 0;
+}
+function combineProgressHeadlineAndExplanation(headline, explanation) {
+	return headline && explanation && headline !== explanation ? `${headline} — ${explanation}` : headline ?? explanation;
+}
+function buildNativeProgressChunks(params) {
+	return buildSlackProgressStreamChunks({
+		title: params.title,
+		lines: resolveNativeProgressLines(params.snapshot),
+		plan: resolveNativeProgressPlan(params.snapshot),
+		maxLineChars: params.maxLineChars
+	});
 }
 //#endregion
 //#region extensions/slack/src/monitor/message-handler/preview-finalize.ts
@@ -795,8 +1076,9 @@ async function readSlackMessageAfterEditError(params) {
 		channel: params.channelId,
 		ts: params.threadTs,
 		latest: params.messageId,
+		oldest: params.messageId,
 		inclusive: true,
-		limit: 100
+		limit: 1
 	})).messages ?? []).find((message) => message?.ts === params.messageId) ?? null;
 	const message = (await params.client.conversations.history({
 		token: params.token,
@@ -826,7 +1108,7 @@ async function didSlackPreviewEditApplyAfterError(params) {
 }
 async function finalizeSlackPreviewEdit(params) {
 	try {
-		await editSlackMessage(params.channelId, params.messageId, params.text, {
+		await editSlackRenderedMessage(params.channelId, params.messageId, params.text, {
 			token: params.token,
 			accountId: params.accountId,
 			client: params.client,
@@ -853,74 +1135,196 @@ async function finalizeSlackPreviewEdit(params) {
 	}
 }
 //#endregion
-//#region extensions/slack/src/monitor/message-handler/dispatch-progress-io.ts
-async function collapseSlackProgressReceipt(params) {
-	const { account, ctx, slackClient } = params.setup;
-	try {
-		await finalizeSlackPreviewEdit({
-			client: slackClient,
-			token: ctx.botToken,
-			accountId: account.accountId,
-			...params.edit
+//#region extensions/slack/src/monitor/message-handler/dispatch-progress-card.ts
+function createSlackDraftProgressCardRuntime(params) {
+	const { account, cfg, ctx, prepared, slackClient } = params.setup;
+	let latestFallbackText = "";
+	let finalStatus;
+	const resolveSessionUrl = () => {
+		if (cfg.gateway?.controlUi?.enabled === false) return;
+		const publicOrigin = resolveGatewayPublicOrigin(cfg);
+		if (!publicOrigin) return;
+		const url = new URL(publicOrigin);
+		const path = buildControlUiSessionPath({
+			namespace: "chat",
+			sessionKey: prepared.route.sessionKey,
+			fallbackAgentId: prepared.route.agentId,
+			basePath: cfg.gateway?.controlUi?.basePath
 		});
-		return true;
-	} catch (err) {
-		logVerbose(`slack: progress receipt edit failed (${formatSlackError(err)})`);
-		return false;
-	}
-}
-//#endregion
-//#region extensions/slack/src/monitor/message-handler/dispatch-progress-render.ts
-function resolveStructuredProgressLines(lines) {
-	return 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
-		};
-	});
-}
-function resolveNativeProgressPlan(snapshot) {
-	return snapshot.plan?.length ? snapshot.plan : void 0;
-}
-function 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
+		if (!path) return;
+		url.pathname = path;
+		return url.toString();
+	};
+	const resolveText = (snapshot) => latestFallbackText || formatChannelProgressDraftText({
+		entry: account.config,
+		lines: [...snapshot.lines],
+		seed: params.progressSeed,
+		formatLine: formatSlackProgressDraftLine,
+		narration: snapshot.statusHeadline,
+		plan: snapshot.plan
 	});
-	return explanationLine ? [...lines, explanationLine] : lines;
+	const resolvePresentation = (snapshot, state) => {
+		const title = params.explicitTitle ?? snapshot.statusHeadline ?? "Working";
+		return buildSlackProgressCardBlocks({
+			state,
+			title,
+			narration: params.explicitTitle ? combineProgressHeadlineAndExplanation(snapshot.statusHeadline, snapshot.planExplanation) : snapshot.planExplanation && snapshot.planExplanation !== title ? snapshot.planExplanation : void 0,
+			plan: snapshot.plan,
+			lines: resolveStructuredProgressLines(snapshot.lines),
+			maxLineChars: params.maxLineChars,
+			diffStat: snapshot.diffStat,
+			...state === "working" ? {
+				toolCalls: params.progressWorkCounter.toolCalls,
+				elapsedSeconds: params.progressWorkCounter.elapsedSeconds
+			} : { sessionUrl: resolveSessionUrl() }
+		});
+	};
+	const finalize = async (status, snapshot = params.getSnapshot(), fallbackText = resolveText(snapshot)) => {
+		if (!params.draftStream || !params.enabled) return false;
+		await params.draftStream.dropDetachedMessages();
+		const terminalStatus = finalStatus === "error" || status === "error" ? "error" : "success";
+		if (finalStatus === terminalStatus) return true;
+		await params.draftStream.flush();
+		const channelId = params.draftStream.channelId();
+		const messageId = params.draftStream.messageId();
+		if (!channelId || !messageId) return false;
+		await params.draftStream.seal();
+		try {
+			const finalized = await params.draftStream.finalizeMessage(messageId, async () => {
+				await finalizeSlackPreviewEdit({
+					client: slackClient,
+					token: ctx.botToken,
+					accountId: account.accountId,
+					channelId,
+					messageId,
+					text: fallbackText,
+					blocks: resolvePresentation(snapshot, terminalStatus),
+					threadTs: params.getThreadTs()
+				});
+			});
+			if (finalized) finalStatus = terminalStatus;
+			return finalized;
+		} catch (err) {
+			logVerbose(`slack: progress card final edit failed (${formatSlackError(err)})`);
+			return false;
+		}
+	};
+	return {
+		resolveSessionUrl,
+		resolveText,
+		resolvePresentation,
+		finalize,
+		get hasTerminalized() {
+			return finalStatus !== void 0;
+		},
+		setFallbackText(text) {
+			latestFallbackText = text;
+		},
+		reset() {
+			latestFallbackText = "";
+			finalStatus = void 0;
+		}
+	};
 }
-function combineProgressHeadlineAndExplanation(headline, explanation) {
-	return headline && explanation && headline !== explanation ? `${headline} — ${explanation}` : headline ?? explanation;
+function formatSlackProgressDraftLine(line) {
+	if (/^(?:🧠|💬)\s/u.test(line)) return line;
+	const italicCommentary = /^_(.*)_$/su.exec(line);
+	if (!italicCommentary) return escapeSlackMrkdwn(line);
+	return `_${italicCommentary[1].split(/(`[^`\n]+`)/u).map((segment, index) => {
+		if (index % 2 === 0) return escapeSlackMrkdwn(segment);
+		return `\`${segment.slice(1, -1).replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;")}\``;
+	}).join("")}_`;
 }
-function buildNativeProgressChunks(params) {
-	const input = {
-		title: params.title,
-		lines: resolveNativeProgressLines(params.snapshot),
-		plan: resolveNativeProgressPlan(params.snapshot),
-		maxLineChars: params.maxLineChars
+//#endregion
+//#region extensions/slack/src/monitor/message-handler/dispatch-progress-native.ts
+function createSlackNativeProgressTransport(params) {
+	const { ctx, message, replyPlan, slackClient, slackIdentity, slackStreamFallbackTeamId } = params.setup;
+	const { delivery } = params;
+	const markDelivered = (threadTs) => {
+		if (!delivery.streamSession?.delivered) return false;
+		delivery.observedReplyDelivery = true;
+		if (threadTs) {
+			delivery.usedReplyThreadTs ??= threadTs;
+			delivery.rememberDeliveredThreadTs("block", threadTs);
+		}
+		return true;
+	};
+	const waitForStart = async () => {
+		if (delivery.streamSession || !delivery.nativeProgressStreamStartPromise) return true;
+		try {
+			await delivery.nativeProgressStreamStartPromise;
+		} catch {
+			delivery.streamFailed = true;
+			return false;
+		}
+		return !delivery.streamFailed;
+	};
+	const start = async (update) => {
+		const streamThreadTs = replyPlan.nextThreadTs();
+		if (!streamThreadTs) {
+			logVerbose("slack-stream: no reply thread target for native progress stream start, falling back");
+			delivery.streamFailed = true;
+			return false;
+		}
+		delivery.nativeProgressStreamThreadTs = streamThreadTs;
+		const startPromise = (async () => {
+			const session = await startSlackStream({
+				client: slackClient,
+				channel: message.channel,
+				threadTs: streamThreadTs,
+				...update.text ? { text: update.text } : {},
+				...update.chunks?.length ? { chunks: update.chunks } : {},
+				taskDisplayMode: "plan",
+				...slackIdentity ? { identity: slackIdentity } : {},
+				teamId: await resolveSlackStreamRecipientTeamId({
+					client: slackClient,
+					token: ctx.botToken,
+					userId: message.user,
+					fallbackTeamId: slackStreamFallbackTeamId
+				}),
+				userId: message.user
+			});
+			delivery.streamSession = session;
+			return session;
+		})();
+		delivery.nativeProgressStreamStartPromise = startPromise;
+		try {
+			if (!await startPromise) return false;
+			const delivered = markDelivered(streamThreadTs);
+			return update.chunks?.length ? delivered : true;
+		} finally {
+			if (delivery.nativeProgressStreamStartPromise === startPromise) delivery.nativeProgressStreamStartPromise = null;
+		}
+	};
+	const append = async (update) => {
+		const session = delivery.streamSession;
+		if (!session) return false;
+		await appendSlackStream({
+			session,
+			...update.text ? { text: update.text } : {},
+			...update.chunks?.length ? { chunks: update.chunks } : {}
+		});
+		const delivered = markDelivered(delivery.nativeProgressStreamThreadTs);
+		return update.chunks?.length ? delivered : true;
+	};
+	return {
+		append,
+		start,
+		waitForStart
 	};
-	return params.streamStarted ? buildSlackProgressStreamUpdateChunks(input) : buildSlackProgressStreamStartChunks(input);
 }
 //#endregion
 //#region extensions/slack/src/monitor/message-handler/dispatch-progress.ts
 function createSlackProgressRuntime(runtimeParams) {
 	const { setup, delivery, resetPreviewDeliveryState } = runtimeParams;
-	const { account, cfg, ctx, hasSlackCustomIdentity, message, prepared, replyPlan, runtime, slackClient, slackIdentity, slackMessageMetadata, slackStreaming, slackStreamFallbackTeamId, shouldUseDraftStream, useStreaming, previewStreamingEnabled } = setup;
+	const { account, cfg, ctx, hasSlackCustomIdentity, message, prepared, replyPlan, runtime, slackClient, slackIdentity, slackMessageMetadata, slackStreaming, shouldUseDraftStream, useStreaming, previewStreamingEnabled } = setup;
 	const draftStream = shouldUseDraftStream ? createSlackDraftStream({
 		target: prepared.replyTarget,
 		cfg,
 		token: ctx.botToken,
 		accountId: account.accountId,
-		...prepared.eventScope ? { eventScope: prepared.eventScope } : {},
+		conversationChannelId: message.channel,
+		eventScope: prepared.eventScope,
 		...!hasSlackCustomIdentity && slackIdentity ? { identity: slackIdentity } : {},
 		...slackMessageMetadata ? { metadata: slackMessageMetadata } : {},
 		maxChars: Math.min(ctx.textLimit, SLACK_TEXT_LIMIT),
@@ -933,40 +1337,61 @@ function createSlackProgressRuntime(runtimeParams) {
 		warn: logVerbose
 	}) : void 0;
 	let hasStreamedMessage = false;
-	const streamMode = slackStreaming.draftMode;
+	const isProgressMode = slackStreaming.mode === "progress";
 	const useNativeProgressStreaming = useStreaming && slackStreaming.mode === "progress";
 	const progressDraftActive = Boolean(draftStream) || useNativeProgressStreaming;
 	const previewToolProgressEnabled = progressDraftActive && resolveChannelStreamingPreviewToolProgress(account.config, true, slackStreaming.mode);
 	let shouldYieldDraftProgress = () => false;
 	const suppressDefaultToolProgressMessages = resolveChannelStreamingSuppressDefaultToolProgressMessages(account.config, {
 		draftStreamActive: Boolean(draftStream) || useNativeProgressStreaming,
+		mode: slackStreaming.mode,
 		previewToolProgressEnabled,
 		previewStreamingEnabled
 	});
 	let previewToolProgressSuppressed = false;
-	let legacyPreviewToolProgressLines = [];
-	let nativeTaskState = /* @__PURE__ */ new Map();
+	let nativeStreamSnapshot = EMPTY_SLACK_NATIVE_STREAM_SNAPSHOT;
 	let appendRenderedText = "";
 	let appendSourceText = "";
 	let nativeProgressCompletionSent = false;
 	let nativeProgressTerminalStatus = "complete";
-	let nativeProgressChunkKey;
-	const progressReceipt = createChannelProgressReceiptTracker();
-	let progressReceiptCollapsed = false;
-	let pendingNativeProgressReceipt;
+	let nativeNarrationRenderedText = "";
+	let nativeNarrationSourceText = "";
+	let nativeStreamOrder = Promise.resolve();
+	const withNativeStreamOrder = (task) => {
+		const run = nativeStreamOrder.then(task, task);
+		nativeStreamOrder = run.catch(() => void 0);
+		return run;
+	};
+	const progressWorkCounter = createChannelProgressWorkCounter();
 	const progressSeed = `${account.accountId}:${message.channel}`;
-	const useRichProgressDraft = streamMode === "status_final" && resolveChannelProgressDraftRender(account.config) === "rich";
+	const slackProgressStyle = resolveSlackProgressStyle(account.config);
+	const useDraftProgressCard = Boolean(draftStream) && isProgressMode && slackProgressStyle === "card";
 	const explicitProgressTitle = resolveExplicitSlackProgressTitle(account.config);
 	const progressDraftMaxLineChars = resolveChannelProgressDraftMaxLineChars(account.config);
-	const waitForNativeProgressStreamStart = async () => {
-		if (delivery.streamSession || !delivery.nativeProgressStreamStartPromise) return true;
-		try {
-			await delivery.nativeProgressStreamStartPromise;
-		} catch {
-			delivery.streamFailed = true;
-			return false;
-		}
-		return !delivery.streamFailed;
+	const progressCard = createSlackDraftProgressCardRuntime({
+		setup: {
+			account,
+			cfg,
+			ctx,
+			prepared,
+			slackClient
+		},
+		draftStream,
+		enabled: useDraftProgressCard,
+		progressWorkCounter,
+		progressSeed,
+		explicitTitle: explicitProgressTitle,
+		maxLineChars: progressDraftMaxLineChars,
+		getSnapshot: () => progressDraft.getSnapshot(),
+		getThreadTs: () => delivery.usedReplyThreadTs
+	});
+	const nativeTransport = createSlackNativeProgressTransport({
+		setup,
+		delivery
+	});
+	const dropDetachedProgressCards = async () => {
+		if (!useDraftProgressCard) return;
+		await draftStream?.dropDetachedMessages();
 	};
 	const appendNativeProgressCompletion = async (isError) => {
 		const session = delivery.streamSession;
@@ -986,150 +1411,151 @@ function createSlackProgressRuntime(runtimeParams) {
 			runtime.error?.(danger(`slack-stream: native progress completion failed: ${formatSlackError(err)}`));
 		}
 	};
+	const resolveNativeProgressTitle = (snapshot) => combineProgressHeadlineAndExplanation(explicitProgressTitle ?? snapshot.statusHeadline, snapshot.planExplanation);
 	const buildNativeProgressChunks$1 = (snapshot) => buildNativeProgressChunks({
 		snapshot,
-		streamStarted: Boolean(delivery.streamSession),
-		title: combineProgressHeadlineAndExplanation(explicitProgressTitle ?? snapshot.statusHeadline, snapshot.planExplanation),
+		title: resolveNativeProgressTitle(snapshot),
 		maxLineChars: progressDraftMaxLineChars
 	});
-	const resolveNativeProgressTitle = (snapshot) => combineProgressHeadlineAndExplanation(explicitProgressTitle ?? snapshot.statusHeadline, snapshot.planExplanation);
-	const markNativeProgressDelivered = (session, threadTs) => {
-		if (session.delivered) delivery.observedReplyDelivery = true;
-		if (threadTs) {
-			delivery.usedReplyThreadTs ??= threadTs;
-			delivery.rememberDeliveredThreadTs("block", threadTs);
-		}
+	const normalizeProgressText = (text) => text?.replace(/\s+/gu, " ").trim() ?? "";
+	const isRenderedAsProgressTitle = (text) => {
+		const candidate = normalizeProgressText(text);
+		if (!candidate) return false;
+		const title = normalizeProgressText(resolveNativeProgressTitle(progressDraft.getSnapshot()));
+		return title.length > 0 && title.includes(candidate);
 	};
-	const startNativeProgressStream = async (chunks, chunkKey) => {
-		const streamThreadTs = replyPlan.nextThreadTs();
-		if (!streamThreadTs) {
-			logVerbose("slack-stream: no reply thread target for native progress stream start, falling back");
-			delivery.streamFailed = true;
-			return;
-		}
-		delivery.nativeProgressStreamThreadTs = streamThreadTs;
-		const startPromise = (async () => {
-			const session = await startSlackStream({
-				client: slackClient,
-				channel: message.channel,
-				threadTs: streamThreadTs,
-				chunks,
-				taskDisplayMode: "plan",
-				...slackIdentity ? { identity: slackIdentity } : {},
-				teamId: await resolveSlackStreamRecipientTeamId({
-					client: slackClient,
-					token: ctx.botToken,
-					userId: message.user,
-					fallbackTeamId: slackStreamFallbackTeamId
-				}),
-				userId: message.user
-			});
-			delivery.streamSession = session;
-			return session;
-		})();
-		delivery.nativeProgressStreamStartPromise = startPromise;
-		let startedSession;
-		try {
-			startedSession = await startPromise;
-		} finally {
-			if (delivery.nativeProgressStreamStartPromise === startPromise) delivery.nativeProgressStreamStartPromise = null;
-		}
-		if (startedSession) markNativeProgressDelivered(startedSession, streamThreadTs);
-		nativeProgressChunkKey = chunkKey;
-		replyPlan.markSent();
-	};
-	const appendNativeProgressStream = async (chunks, chunkKey) => {
-		if (!delivery.streamSession) return;
-		await appendSlackStream({
-			session: delivery.streamSession,
-			chunks
+	const resolveNarrationUpdate = (incoming) => {
+		const next = applyAppendOnlyStreamUpdate({
+			incoming: incoming ?? "",
+			rendered: nativeNarrationRenderedText,
+			source: nativeNarrationSourceText
 		});
-		markNativeProgressDelivered(delivery.streamSession);
-		nativeProgressChunkKey = chunkKey;
+		return {
+			next,
+			delta: next.changed ? next.rendered.slice(nativeNarrationRenderedText.length) : ""
+		};
 	};
-	const updateNativeProgressStream = async () => {
+	const updateNativeProgressStream = () => withNativeStreamOrder(updateNativeProgressStreamNow);
+	const updateNativeProgressStreamNow = async () => {
 		const snapshot = progressDraft.getSnapshot();
 		const progressLines = resolveNativeProgressLines(snapshot);
-		const hasRetirableNativeTasks = [...nativeTaskState.values()].some((task) => task.status !== "complete" && task.status !== "error");
-		if (!useNativeProgressStreaming || delivery.streamFailed || progressLines.length === 0 && !snapshot.plan?.length && !snapshot.statusHeadline && !explicitProgressTitle && !hasRetirableNativeTasks) return;
-		if (!await waitForNativeProgressStreamStart()) return;
+		const narrationUpdate = resolveNarrationUpdate(resolveNativeProgressNarration(snapshot));
+		const hasRetirableNativeTasks = [...nativeStreamSnapshot.tasks.values()].some((task) => task.status !== "complete" && task.status !== "error");
+		if (!useNativeProgressStreaming || delivery.streamFailed || progressLines.length === 0 && !snapshot.plan?.length && !snapshot.statusHeadline && !explicitProgressTitle && !hasRetirableNativeTasks && !narrationUpdate.delta) return false;
+		if (!await nativeTransport.waitForStart()) return false;
 		const reconciled = reconcileSlackNativeTaskChunks({
-			previousTasks: nativeTaskState,
+			previous: nativeStreamSnapshot,
 			chunks: buildNativeProgressChunks$1(snapshot)
 		});
 		const chunks = reconciled.chunks;
-		if (!chunks?.length) return;
-		const chunkKey = JSON.stringify(chunks);
-		if (chunkKey === nativeProgressChunkKey) return;
+		if (!chunks?.length && !narrationUpdate.delta) return false;
 		try {
-			if (!delivery.streamSession) await startNativeProgressStream(chunks, chunkKey);
-			else await appendNativeProgressStream(chunks, chunkKey);
-			nativeTaskState = reconciled.tasks;
+			const hadSession = Boolean(delivery.streamSession);
+			const streamUpdate = {
+				...narrationUpdate.delta ? { text: narrationUpdate.delta } : {},
+				...chunks?.length ? { chunks } : {}
+			};
+			if (!(hadSession ? await nativeTransport.append(streamUpdate) : await nativeTransport.start(streamUpdate))) return false;
+			if (!hadSession) replyPlan.markSent();
+			if (narrationUpdate.next.changed) {
+				nativeNarrationRenderedText = narrationUpdate.next.rendered;
+				nativeNarrationSourceText = narrationUpdate.next.source;
+			}
+			if (chunks?.length) nativeStreamSnapshot = reconciled.snapshot;
+			return true;
 		} catch (err) {
 			runtime.error?.(danger(`slack-stream: native progress stream failed: ${formatSlackError(err)}, falling back`));
 			delivery.streamFailed = true;
+			return false;
 		}
 	};
-	const resetProgressTurnState = () => {
-		progressReceipt.reset();
-		progressReceiptCollapsed = false;
-		pendingNativeProgressReceipt = void 0;
-	};
-	const collapseProgressReceipt = async (params) => {
-		progressReceiptCollapsed = await collapseSlackProgressReceipt({
-			setup,
-			edit: params
+	const appendNativeNarration = (payload, kind) => withNativeStreamOrder(() => appendNativeNarrationNow(payload, kind));
+	const appendNativeNarrationNow = async (payload, kind) => {
+		if (isRenderedAsProgressTitle(payload.text)) return false;
+		const narrationUpdate = resolveNarrationUpdate(payload.text?.trimEnd());
+		if (!narrationUpdate.delta) return false;
+		await delivery.deliverWithStreaming({
+			payload,
+			kind,
+			streamText: narrationUpdate.delta,
+			appendSeparator: false,
+			taskDisplayMode: "plan"
 		});
+		if (!delivery.streamFailed) {
+			nativeNarrationRenderedText = narrationUpdate.next.rendered;
+			nativeNarrationSourceText = narrationUpdate.next.source;
+		}
+		return true;
+	};
+	const resetProgressTurnState = () => {
+		progressWorkCounter.reset();
+		nativeNarrationRenderedText = "";
+		nativeNarrationSourceText = "";
 	};
 	const progressDraft = createChannelProgressDraftCompositor({
 		entry: account.config,
 		mode: slackStreaming.mode,
-		active: progressDraftActive && streamMode === "status_final",
+		active: progressDraftActive,
 		seed: progressSeed,
-		formatLine: escapeSlackMrkdwn,
+		formatLine: formatSlackProgressDraftLine,
 		reasoningLinePrefix: "🧠 ",
-		commentaryLinePrefix: "💬 ",
+		commentaryLinePrefix: "",
 		reasoningGate: previewToolProgressEnabled,
-		commentaryItalics: false,
-		updateOnLineChange: useNativeProgressStreaming || useRichProgressDraft,
+		commentaryItalics: true,
+		buildProgressEventLine: (input, options) => input.event === "tool" || input.event === "item" || input.event === "command-output" ? buildChannelProgressDraftLineForEntry(account.config, input, options) : buildChannelProgressDraftLine(input, options),
+		updateOnLineChange: useNativeProgressStreaming || useDraftProgressCard,
 		update: async (previewText, options) => {
-			if (useNativeProgressStreaming) {
-				await updateNativeProgressStream();
-				return;
-			}
-			if (!draftStream) return;
+			if (useNativeProgressStreaming) return await updateNativeProgressStream();
+			if (!draftStream) return false;
 			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 ? {
+			progressCard.setFallbackText(previewText);
+			draftStream.update(useDraftProgressCard ? {
 				text: previewText,
-				blocks: richProgressBlocks
+				blocks: progressCard.resolvePresentation(snapshot, "working")
 			} : previewText);
 			hasStreamedMessage = true;
 			if (options?.flush) await draftStream.flush();
+			return Boolean(draftStream.messageId() && draftStream.channelId());
 		}
 	});
 	const commentaryProgressEnabled = progressDraft.commentaryProgressEnabled;
+	const deliverNativeFinal = (payload, kind) => withNativeStreamOrder(() => deliverNativeFinalNow(payload, kind));
+	const deliverNativeFinalNow = async (payload, kind) => {
+		progressDraft.markFinalReplyStarted();
+		const streamReady = await nativeTransport.waitForStart();
+		const finalThreadTs = delivery.streamSession?.threadTs ?? delivery.nativeProgressStreamThreadTs;
+		if (payload.isError !== true && streamReady && Boolean(delivery.streamSession) && delivery.isStreamingEligible(payload, { maxTextBytes: 4e3 })) {
+			await appendNativeProgressCompletion(false);
+			await delivery.deliverWithStreaming({
+				payload,
+				kind
+			});
+		} else {
+			await delivery.deliverNormally({
+				payload,
+				kind,
+				forcedThreadTs: finalThreadTs
+			});
+			await appendNativeProgressCompletion(payload.isError === true);
+		}
+		progressDraft.markFinalReplyDelivered();
+	};
 	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;
+		const sessionUrl = progressCard.resolveSessionUrl();
+		const hasRetirableNativeTasks = [...nativeStreamSnapshot.tasks.values()].some((task) => task.status !== "complete" && task.status !== "error");
+		if (lines.length === 0 && !snapshot.plan?.length && !hasRetirableNativeTasks && !snapshot.diffStat && !sessionUrl) return;
 		return reconcileSlackNativeTaskChunks({
-			previousTasks: nativeTaskState,
+			previous: nativeStreamSnapshot,
 			chunks: buildSlackProgressStreamCompletionChunks({
-				title: resolveNativeProgressTitle(snapshot),
+				title: resolveNativeProgressTitle(snapshot) ?? (lines.length === 0 && !snapshot.plan?.length ? "Working" : void 0),
 				lines,
 				plan: resolveNativeProgressPlan(snapshot),
 				maxLineChars: progressDraftMaxLineChars,
-				finalInProgressStatus
+				finalInProgressStatus,
+				diffStat: snapshot.diffStat,
+				sessionUrl
 			})
 		}).chunks;
 	};
@@ -1144,12 +1570,6 @@ function createSlackProgressRuntime(runtimeParams) {
 				...slackMessageMetadata ? { metadata: slackMessageMetadata } : {}
 			});
 			delivery.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);
 			delivery.emitAcknowledgedStreamedDeliveries();
@@ -1162,16 +1582,16 @@ function createSlackProgressRuntime(runtimeParams) {
 		delivery.streamFailed = false;
 	};
 	const pushPlanProgress = async (steps, explanation) => {
-		if (streamMode === "status_final") {
-			await progressDraft.pushPlanProgress(steps, { explanation });
-			return;
+		if (isProgressMode) {
+			if (slackProgressStyle === "compact") return false;
+			return await progressDraft.pushPlanProgress(steps, { explanation });
 		}
-		if (previewToolProgressSuppressed || !draftStream) return;
+		if (previewToolProgressSuppressed || !draftStream) return false;
 		const text = formatChannelProgressDraftText({
 			entry: account.config,
-			lines: legacyPreviewToolProgressLines,
+			lines: [...progressDraft.getSnapshot().lines],
 			seed: progressSeed,
-			formatLine: escapeSlackMrkdwn,
+			formatLine: formatSlackProgressDraftLine,
 			narration: explanation,
 			plan: steps
 		});
@@ -1179,37 +1599,25 @@ function createSlackProgressRuntime(runtimeParams) {
 			draftStream.update(text);
 			hasStreamedMessage = true;
 		}
+		return false;
 	};
 	const pushPreviewProgress = async (line, options) => {
-		if (!draftStream && !useNativeProgressStreaming) return;
-		if (options?.toolName !== void 0 && !isChannelProgressDraftWorkToolName(options.toolName)) return;
+		if (!draftStream && !useNativeProgressStreaming) return false;
+		if (options?.toolName !== void 0 && !isChannelProgressDraftWorkToolName(options.toolName)) return false;
 		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;
+		if (isProgressMode) {
+			if (!line || !normalized) return await progressDraft.noteActivity();
+			return await progressDraft.pushToolProgress(line, options);
 		}
-		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;
+		if (!line || !normalized || !draftStream || !previewToolProgressEnabled) return false;
+		return await progressDraft.pushToolProgress(line, options);
 	};
 	const updateDraftFromPartial = (text) => {
 		const trimmed = text?.trimEnd();
-		if (!trimmed) return;
-		if (streamMode === "append") {
+		if (!trimmed) return false;
+		if (slackStreaming.mode === "block") {
 			previewToolProgressSuppressed = true;
-			legacyPreviewToolProgressLines = [];
+			progressDraft.suppress();
 			const next = applyAppendOnlyStreamUpdate({
 				incoming: trimmed,
 				rendered: appendRenderedText,
@@ -1217,32 +1625,33 @@ function createSlackProgressRuntime(runtimeParams) {
 			});
 			appendRenderedText = next.rendered;
 			appendSourceText = next.source;
-			if (!next.changed) return;
+			if (!next.changed) return false;
 			draftStream?.update(next.rendered);
 			hasStreamedMessage = true;
-			return;
+			return false;
 		}
-		if (streamMode === "status_final") return;
+		if (isProgressMode) return false;
 		previewToolProgressSuppressed = true;
-		legacyPreviewToolProgressLines = [];
+		progressDraft.suppress();
 		draftStream?.update(trimmed);
 		hasStreamedMessage = true;
+		return false;
 	};
 	const pushReasoningProgress = async (payload) => {
-		if (!payload?.text) return;
-		if (streamMode !== "status_final") {
+		if (!payload?.text) return false;
+		if (!isProgressMode) {
 			const normalized = progressDraft.mergeReasoningProgress(payload.text, { snapshot: payload.isReasoningSnapshot === true }).replace(/^_(.*)_$/su, "$1").trim();
-			if (!normalized) return;
-			await pushPreviewProgress({
+			if (!normalized) return false;
+			const visible = await pushPreviewProgress({
 				id: "reasoning",
 				kind: "item",
 				text: normalized,
 				label: "Reasoning"
 			});
-			return;
+			progressDraft.mergeReasoningProgress(normalized, { snapshot: true });
+			return visible;
 		}
-		progressReceipt.noteReasoning();
-		await progressDraft.pushReasoningProgress(payload.text, { snapshot: payload.isReasoningSnapshot === true });
+		return await progressDraft.pushReasoningProgress(payload.text, { snapshot: payload.isReasoningSnapshot === true });
 	};
 	const resetDraftDeliveryState = () => {
 		hasStreamedMessage = false;
@@ -1250,44 +1659,62 @@ function createSlackProgressRuntime(runtimeParams) {
 		appendSourceText = "";
 	};
 	const resetDraftProgressState = () => {
-		progressDraft.resetReasoningProgress();
 		previewToolProgressSuppressed = false;
-		legacyPreviewToolProgressLines = [];
+		progressDraft.reset();
 	};
 	const beginNewProgressTurn = async (options) => {
+		const priorSnapshot = progressDraft.getSnapshot();
+		const priorFallbackText = progressCard.resolveText(priorSnapshot);
 		const completionChunks = useNativeProgressStreaming && !nativeProgressCompletionSent ? buildNativeProgressCompletionChunks(nativeProgressTerminalStatus) : void 0;
 		if (!progressDraft.beginNewTurn(options)) return false;
 		if (useNativeProgressStreaming) await finishNativeProgressTurn(completionChunks);
-		else draftStream?.forceNewMessage();
+		else {
+			await progressCard.finalize("success", priorSnapshot, priorFallbackText);
+			draftStream?.forceNewMessage();
+			await dropDetachedProgressCards();
+		}
 		resetProgressTurnState();
-		nativeTaskState = /* @__PURE__ */ new Map();
+		nativeStreamSnapshot = EMPTY_SLACK_NATIVE_STREAM_SNAPSHOT;
 		nativeProgressCompletionSent = false;
 		nativeProgressTerminalStatus = "complete";
-		nativeProgressChunkKey = void 0;
+		progressCard.reset();
 		resetPreviewDeliveryState();
 		delivery.resetDeliveryTracker();
-		progressReceiptCollapsed = false;
 		return true;
 	};
+	const onDraftBoundary = !shouldUseDraftStream && !useNativeProgressStreaming ? void 0 : async () => {
+		if (isProgressMode) {
+			await beginNewProgressTurn();
+			return;
+		}
+		if (hasStreamedMessage) draftStream?.forceNewMessage();
+		resetDraftDeliveryState();
+		resetDraftProgressState();
+	};
+	const onQueuedFollowupAdmitted = !shouldUseDraftStream && !useNativeProgressStreaming ? void 0 : async () => {
+		await draftStream?.flush();
+		resetPreviewDeliveryState();
+		if (isProgressMode) await beginNewProgressTurn({ force: true });
+		else draftStream?.forceNewMessage();
+		delivery.resetDeliveryTracker();
+		resetDraftDeliveryState();
+		resetDraftProgressState();
+	};
+	const onQueuedFollowupSettled = !useDraftProgressCard ? void 0 : async () => {
+		if (!progressCard.hasTerminalized) await draftStream?.clear();
+		await dropDetachedProgressCards();
+	};
 	return {
 		draftStream,
-		streamMode,
+		isProgressMode,
+		useDraftProgressCard,
 		useNativeProgressStreaming,
 		progressDraftActive,
 		previewToolProgressEnabled,
 		suppressDefaultToolProgressMessages,
 		progressDraft,
 		commentaryProgressEnabled,
-		progressReceipt,
-		get progressReceiptCollapsed() {
-			return progressReceiptCollapsed;
-		},
-		get pendingNativeProgressReceipt() {
-			return pendingNativeProgressReceipt;
-		},
-		set pendingNativeProgressReceipt(value) {
-			pendingNativeProgressReceipt = value;
-		},
+		progressWorkCounter,
 		get nativeProgressCompletionSent() {
 			return nativeProgressCompletionSent;
 		},
@@ -1297,33 +1724,17 @@ function createSlackProgressRuntime(runtimeParams) {
 		get nativeProgressTerminalStatus() {
 			return nativeProgressTerminalStatus;
 		},
-		appendNativeProgressCompletion,
-		beginNewProgressTurn,
+		appendNativeNarration,
 		buildNativeProgressCompletionChunks,
-		collapseProgressReceipt,
-		onDraftBoundary: !shouldUseDraftStream && !useNativeProgressStreaming ? void 0 : async () => {
-			if (streamMode === "status_final") {
-				await beginNewProgressTurn();
-				return;
-			}
-			if (hasStreamedMessage) draftStream?.forceNewMessage();
-			resetDraftDeliveryState();
-			resetDraftProgressState();
-		},
-		onQueuedFollowupAdmitted: !shouldUseDraftStream && !useNativeProgressStreaming ? void 0 : async () => {
-			await draftStream?.flush();
-			resetPreviewDeliveryState();
-			if (streamMode === "status_final") await beginNewProgressTurn({ force: true });
-			else draftStream?.forceNewMessage();
-			delivery.resetDeliveryTracker();
-			resetDraftDeliveryState();
-			resetDraftProgressState();
-		},
+		deliverNativeFinal,
+		dropDetachedProgressCards,
+		finalizeDraftProgressCard: progressCard.finalize,
+		onDraftBoundary,
+		onQueuedFollowupAdmitted,
+		onQueuedFollowupSettled,
 		pushPlanProgress,
-		pushPreviewProgress,
 		pushReasoningProgress,
 		updateDraftFromPartial,
-		waitForNativeProgressStreamStart,
 		setShouldYieldDraftProgress: (value) => {
 			shouldYieldDraftProgress = value;
 		},
@@ -1398,7 +1809,7 @@ async function createSlackDispatchSetup(prepared) {
 			sessionKey: inboundLastRouteSessionKey,
 			deliveryContext: {
 				channel: "slack",
-				to: `user:${message.user}`,
+				to: prepared.ctxPayload.OriginatingTo ?? prepared.ctxPayload.To ?? `user:${message.user}`,
 				accountId: route.accountId,
 				threadId: prepared.ctxPayload.MessageThreadId ?? prepared.ctxPayload.TransportThreadId
 			},
@@ -1434,6 +1845,7 @@ async function createSlackDispatchSetup(prepared) {
 	const messageTs = message.ts ?? message.event_ts;
 	const incomingThreadTs = message.thread_ts;
 	let didSetStatus = false;
+	let didAddTypingReaction = false;
 	const statusReactionsEnabled = prepared.ctxPayload.InboundEventKind !== "room_event" && Boolean(prepared.ackReactionPromise) && Boolean(reactionMessageTs) && cfg.messages?.statusReactions?.enabled === true;
 	const statusReactions = createStatusReactionController({
 		enabled: statusReactionsEnabled,
@@ -1480,6 +1892,7 @@ async function createSlackDispatchSetup(prepared) {
 	});
 	const typingTarget = statusThreadTs ? `${message.channel}/${statusThreadTs}` : message.channel;
 	const typingReaction = ctx.typingReaction;
+	const threadStatusGate = { hasVisibleOutput: () => false };
 	const { onModelSelected, ...replyPipeline } = createChannelMessageReplyPipeline({
 		cfg,
 		agentId: route.agentId,
@@ -1491,35 +1904,44 @@ async function createSlackDispatchSetup(prepared) {
 		},
 		typing: {
 			start: async () => {
-				didSetStatus = true;
-				await ctx.setSlackThreadStatus({
-					channelId: message.channel,
-					threadTs: statusThreadTs,
-					status: "is typing...",
-					eventScope: prepared.eventScope
-				});
-				if (typingReaction && message.ts) await reactSlackMessage(message.channel, message.ts, typingReaction, {
-					token: ctx.botToken,
-					client: slackClient
-				}).catch((err) => {
-					logVerbose(`slack send: typing reaction failed: ${formatSlackError(err)}`);
-				});
+				if (!threadStatusGate.hasVisibleOutput()) {
+					didSetStatus = true;
+					await ctx.setSlackThreadStatus({
+						channelId: message.channel,
+						threadTs: statusThreadTs,
+						status: "is typing...",
+						eventScope: prepared.eventScope
+					});
+				}
+				if (typingReaction && message.ts) {
+					didAddTypingReaction = true;
+					await reactSlackMessage(message.channel, message.ts, typingReaction, {
+						token: ctx.botToken,
+						client: slackClient
+					}).catch((err) => {
+						logVerbose(`slack send: typing reaction failed: ${formatSlackError(err)}`);
+					});
+				}
 			},
 			stop: async () => {
-				if (!didSetStatus) return;
-				didSetStatus = false;
-				await ctx.setSlackThreadStatus({
-					channelId: message.channel,
-					threadTs: statusThreadTs,
-					status: "",
-					eventScope: prepared.eventScope
-				});
-				if (typingReaction && message.ts) await removeSlackReaction(message.channel, message.ts, typingReaction, {
-					token: ctx.botToken,
-					client: slackClient
-				}).catch((err) => {
-					logVerbose(`slack send: typing reaction removal failed: ${formatSlackError(err)}`);
-				});
+				if (didSetStatus) {
+					didSetStatus = false;
+					await ctx.setSlackThreadStatus({
+						channelId: message.channel,
+						threadTs: statusThreadTs,
+						status: "",
+						eventScope: prepared.eventScope
+					});
+				}
+				if (didAddTypingReaction && typingReaction && message.ts) {
+					didAddTypingReaction = false;
+					await removeSlackReaction(message.channel, message.ts, typingReaction, {
+						token: ctx.botToken,
+						client: slackClient
+					}).catch((err) => {
+						logVerbose(`slack send: typing reaction removal failed: ${formatSlackError(err)}`);
+					});
+				}
 			},
 			onStartError: (err) => {
 				logTypingFailure({
@@ -1541,10 +1963,7 @@ async function createSlackDispatchSetup(prepared) {
 			}
 		}
 	});
-	const slackStreaming = resolveSlackStreamingConfig({
-		streaming: account.config.streaming,
-		nativeStreaming: resolveChannelStreamingNativeTransport(account.config)
-	});
+	const slackStreaming = resolveSlackStreamingConfig({ streaming: account.config.streaming });
 	const streamThreadHint = forcedReplyThreadTs ?? resolveSlackStreamingThreadHint({
 		replyToMode: replyDeliveryMode,
 		incomingThreadTs,
@@ -1553,7 +1972,7 @@ async function createSlackDispatchSetup(prepared) {
 	});
 	const hookRunner = getGlobalHookRunner();
 	const allowPreHookProviderStreaming = !((hookRunner?.hasHooks("reply_payload_sending") ?? false) || (hookRunner?.hasHooks("message_sending") ?? false));
-	const previewStreamingEnabled = allowPreHookProviderStreaming && !sourceRepliesAreToolOnly && shouldEnableSlackPreviewStreaming({ mode: slackStreaming.mode });
+	const previewStreamingEnabled = allowPreHookProviderStreaming && !sourceRepliesAreToolOnly && slackStreaming.mode !== "off";
 	const hasSlackCustomIdentity = Boolean(slackIdentity?.username || slackIdentity?.iconUrl || slackIdentity?.iconEmoji);
 	const useStreaming = shouldUseStreaming({
 		streamingEnabled: !sourceRepliesAreToolOnly && (allowPreHookProviderStreaming || slackStreaming.mode !== "progress") && isSlackStreamingEnabled({
@@ -1563,10 +1982,7 @@ async function createSlackDispatchSetup(prepared) {
 		}),
 		threadTs: streamThreadHint
 	});
-	const shouldUseDraftStream = shouldInitializeSlackDraftStream({
-		previewStreamingEnabled,
-		useStreaming
-	});
+	const shouldUseDraftStream = previewStreamingEnabled && !useStreaming;
 	const blockStreamingEnabled = resolveChannelStreamingBlockEnabled(account.config);
 	const disableBlockStreaming = sourceRepliesAreToolOnly ? true : resolveSlackDisableBlockStreaming({
 		useStreaming,
@@ -1604,6 +2020,7 @@ async function createSlackDispatchSetup(prepared) {
 		statusReactionsEnabled,
 		statusReactions,
 		hasRepliedRef,
+		threadStatusGate,
 		replyPlan,
 		onModelSelected,
 		replyPipeline,
@@ -1632,11 +2049,6 @@ function createSlackStreamingDeliveryRuntime(setup) {
 		observedFinalReplyDelivery: false
 	};
 	const streamedDeliveries = [];
-	const streamedFailuresOwnedByDispatcher = {
-		tool: 0,
-		block: 0,
-		final: 0
-	};
 	const refreshStreamedAcknowledgements = (session) => {
 		if (session.pendingText.length === 0) for (const delivery of streamedDeliveries) delivery.acknowledged = true;
 	};
@@ -1752,7 +2164,7 @@ function createSlackStreamingDeliveryRuntime(setup) {
 				...slackMessageMetadata ? { metadata: slackMessageMetadata } : {},
 				...messageSentDeliveryHookContext,
 				deferMessageSentHooks: true,
-				...prepared.eventScope ? { eventScope: prepared.eventScope } : {}
+				eventScope: prepared.eventScope
 			});
 			markSlackStreamFallbackDelivered(session);
 			if (!session.stopped) try {
@@ -1800,7 +2212,7 @@ function createSlackStreamingDeliveryRuntime(setup) {
 			...slackIdentity ? { identity: slackIdentity } : {},
 			...slackMessageMetadata ? { metadata: slackMessageMetadata } : {},
 			...messageSentDeliveryHookContext,
-			...prepared.eventScope ? { eventScope: prepared.eventScope } : {}
+			eventScope: prepared.eventScope
 		});
 		state.observedReplyDelivery = true;
 		if (params.kind === "final") state.observedFinalReplyDelivery = true;
@@ -1819,10 +2231,7 @@ function createSlackStreamingDeliveryRuntime(setup) {
 		return deliveryReplyThreadTs;
 	};
 	const deliverBufferedStreamFallback = async (params) => {
-		if (!await deliverPendingStreamFallback(params.session, params.err)) {
-			streamedFailuresOwnedByDispatcher[params.kind] += 1;
-			return false;
-		}
+		if (!await deliverPendingStreamFallback(params.session, params.err)) return false;
 		replyPlan.markSent();
 		if (params.kind === "final") state.observedFinalReplyDelivery = true;
 		deliveryTracker.markDelivered({
@@ -1834,12 +2243,16 @@ function createSlackStreamingDeliveryRuntime(setup) {
 		rememberDeliveredThreadTs(params.kind, params.session.threadTs);
 		return true;
 	};
+	const isStreamingEligible = (payload, options) => {
+		const reply = resolveSendableOutboundReplyParts(payload);
+		const renderPlan = resolveSlackReplyRenderPlan(payload);
+		const plannedBlocks = renderPlan.mode === "single" ? renderPlan.blocks : renderPlan.blockPart?.blocks;
+		return !state.streamFailed && !reply.hasMedia && renderPlan.mode !== "split" && !plannedBlocks?.length && !readSlackReplyBlocks(payload)?.length && reply.hasText && (!options?.maxTextBytes || countSlackTextUtf8Bytes(reply.trimmedText) <= options.maxTextBytes);
+	};
 	const deliverWithStreaming = async (params) => {
 		if (params.payload.isReasoning === true) return;
 		const reply = resolveSendableOutboundReplyParts(params.payload);
-		const renderPlan = resolveSlackReplyRenderPlan(params.payload);
-		const plannedBlocks = renderPlan.mode === "single" ? renderPlan.blocks : renderPlan.blockPart?.blocks;
-		if (state.streamFailed || reply.hasMedia || renderPlan.mode === "split" || Boolean(plannedBlocks?.length) || readSlackReplyBlocks(params.payload)?.length || !reply.hasText) {
+		if (!isStreamingEligible(params.payload)) {
 			await deliverNormally({
 				payload: params.payload,
 				kind: params.kind,
@@ -1847,7 +2260,8 @@ function createSlackStreamingDeliveryRuntime(setup) {
 			});
 			return;
 		}
-		const text = reply.trimmedText;
+		const text = params.streamText ?? reply.trimmedText;
+		const hookContent = reply.trimmedText;
 		let plannedThreadTs;
 		try {
 			if (!state.streamSession && state.nativeProgressStreamStartPromise) await state.nativeProgressStreamStartPromise;
@@ -1885,6 +2299,7 @@ function createSlackStreamingDeliveryRuntime(setup) {
 					channel: message.channel,
 					threadTs: streamThreadTs,
 					text,
+					...params.taskDisplayMode ? { taskDisplayMode: params.taskDisplayMode } : {},
 					...slackIdentity ? { identity: slackIdentity } : {},
 					teamId: await resolveSlackStreamRecipientTeamId({
 						client: slackClient,
@@ -1899,7 +2314,7 @@ function createSlackStreamingDeliveryRuntime(setup) {
 					state.observedReplyDelivery = true;
 					if (params.kind === "final") state.observedFinalReplyDelivery = true;
 				}
-				if (text) rememberStreamedDelivery(params.kind, text, state.streamSession);
+				if (hookContent) rememberStreamedDelivery(params.kind, hookContent, state.streamSession);
 				rememberDeliveredThreadTs(params.kind, streamThreadTs);
 				replyPlan.markSent();
 				deliveryTracker.markDelivered({
@@ -1919,13 +2334,13 @@ function createSlackStreamingDeliveryRuntime(setup) {
 				logVerbose("slack-stream: suppressed duplicate append payload");
 				return;
 			}
-			if (text) recordStreamedDelivery(params.kind, text);
+			if (hookContent) recordStreamedDelivery(params.kind, hookContent);
 			await appendSlackStream({
 				session: state.streamSession,
-				text: "\n" + text
+				text: `${params.appendSeparator === false ? "" : "\n"}${text}`
 			});
 			refreshStreamedAcknowledgements(state.streamSession);
-			if (state.streamSession.delivered) {
+			if (state.streamSession.delivered && state.streamSession.pendingText.length === 0) {
 				state.observedReplyDelivery = true;
 				if (params.kind === "final") state.observedFinalReplyDelivery = true;
 			}
@@ -1975,23 +2390,6 @@ function createSlackStreamingDeliveryRuntime(setup) {
 			});
 		}
 	};
-	const reconcileCounts = (counts) => {
-		const next = { ...counts };
-		let changed = false;
-		for (const kind of [
-			"tool",
-			"block",
-			"final"
-		]) {
-			const failedStreamedCount = streamedDeliveries.filter((delivery) => delivery.kind === kind && delivery.outcome === "failure").length;
-			const additionalFailedStreamed = Math.max(0, failedStreamedCount - streamedFailuresOwnedByDispatcher[kind]);
-			if (additionalFailedStreamed > 0) {
-				next[kind] = Math.max(0, (next[kind] ?? 0) - additionalFailedStreamed);
-				changed = true;
-			}
-		}
-		return changed ? next : counts;
-	};
 	return Object.assign(state, {
 		acknowledgeStoppedStreamedDeliveries,
 		deliverNormally,
@@ -2000,9 +2398,9 @@ function createSlackStreamingDeliveryRuntime(setup) {
 		emitAcknowledgedStreamedDeliveries,
 		emitFailedPendingStreamedDeliveries,
 		hasDelivered: (params) => deliveryTracker.hasDelivered(params),
+		isStreamingEligible,
 		markPreviewPayloadDelivered,
 		rememberDeliveredThreadTs,
-		reconcileCounts,
 		resetDeliveryTracker: () => {
 			deliveryTracker = createSlackEventDeliveryTracker();
 		}
@@ -2024,47 +2422,66 @@ async function dispatchPreparedSlackMessage(prepared) {
 		}
 	});
 	const draftStream = progress.draftStream;
+	setup.threadStatusGate.hasVisibleOutput = () => delivery.observedReplyDelivery || draftPreviewCommitted.value || Boolean(draftStream?.messageId());
+	const failureNoticeThreadTs = message.thread_ts;
+	const failureNoticeTeamId = prepared.eventScope?.teamId;
+	let sawTerminalFailurePayload = false;
+	let pendingFailureNotice;
+	const filterPassiveThreadFailure = (payload) => {
+		if (payload.isError !== true || prepared.ctxPayload.ChatType !== "channel" || isReplyPayloadNonTerminalToolErrorWarning(payload)) return payload;
+		sawTerminalFailurePayload = true;
+		if (delivery.observedReplyDelivery || draftPreviewCommitted.value) return payload;
+		const explicitlyAddressed = prepared.ctxPayload.ExplicitlyMentionedBot === true || prepared.ctxPayload.MentionSource === "explicit_bot" || prepared.ctxPayload.MentionSource === "subteam" || prepared.ctxPayload.MentionSource === "mention_pattern" || prepared.ctxPayload.MentionSource === "command_bypass" || prepared.ctxPayload.CommandTurn?.kind !== void 0 && prepared.ctxPayload.CommandTurn.kind !== "normal" && prepared.ctxPayload.CommandTurn.authorized;
+		const noticeThreadTs = failureNoticeThreadTs ?? (explicitlyAddressed ? statusThreadTs : void 0);
+		const notice = {
+			accountId: account.accountId,
+			channelId: message.channel,
+			...noticeThreadTs ? { threadTs: noticeThreadTs } : {},
+			failureText: payload.text ?? "",
+			...failureNoticeTeamId ? { teamId: failureNoticeTeamId } : {}
+		};
+		if (failureNoticeThreadTs && !explicitlyAddressed && prepared.ctxPayload.MentionSource !== "implicit_thread" && !hasSlackThreadParticipation(notice.accountId, notice.channelId, failureNoticeThreadTs, failureNoticeTeamId)) {
+			logVerbose("slack: suppressed passive failure before thread participation");
+			return null;
+		}
+		if (!explicitlyAddressed && hasSlackThreadFailureNotice(notice)) {
+			logVerbose("slack: suppressed repeated passive channel or thread failure");
+			return null;
+		}
+		pendingFailureNotice = notice;
+		return payload;
+	};
 	const deliverSlackPayload = async (payload, info) => {
 		if (payload.isReasoning === true) return { visibleReplySent: false };
-		if (info.kind === "final" && slackStreaming.mode === "progress" && progress.streamMode === "status_final") {
-			const hadProgressDraft = progress.progressDraft.hasStarted;
-			progress.progressDraft.markFinalReplyStarted();
+		if (info.kind === "final" && slackStreaming.mode === "progress" && progress.isProgressMode) {
 			if (progress.useNativeProgressStreaming) {
-				await progress.waitForNativeProgressStreamStart();
-				const finalThreadTs = delivery.streamSession?.threadTs ?? delivery.nativeProgressStreamThreadTs;
+				await progress.deliverNativeFinal(payload, info.kind);
+				return;
+			}
+			progress.progressDraft.markFinalReplyStarted();
+			if (progress.useDraftProgressCard) {
 				await delivery.deliverNormally({
 					payload,
 					kind: info.kind,
-					forcedThreadTs: finalThreadTs
+					forcedThreadTs: delivery.usedReplyThreadTs
 				});
-				await progress.appendNativeProgressCompletion(payload.isError === true);
+				if (!await progress.finalizeDraftProgressCard(payload.isError === true ? "error" : "success")) await draftStream?.clear();
 				progress.progressDraft.markFinalReplyDelivered();
-				if (!payload.isError && hadProgressDraft && delivery.streamSession) progress.pendingNativeProgressReceipt = progress.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 ? delivery.usedReplyThreadTs ?? statusThreadTs : void 0;
-			await delivery.deliverNormally({
-				payload,
-				kind: info.kind,
-				...draftThreadTs ? { forcedThreadTs: draftThreadTs } : {}
-			});
-			progress.progressDraft.markFinalReplyDelivered();
-			if (!payload.isError && receiptChannelId && receiptMessageId && !progress.progressReceiptCollapsed) await progress.collapseProgressReceipt({
-				channelId: receiptChannelId,
-				messageId: receiptMessageId,
-				text: progress.progressReceipt.buildSummaryLine(),
-				threadTs: delivery.usedReplyThreadTs ?? statusThreadTs
-			});
-			return;
 		}
 		if (progress.useNativeProgressStreaming) {
+			if (info.kind !== "final" && payload.isError !== true) {
+				if (!delivery.isStreamingEligible(payload)) {
+					await delivery.deliverNormally({
+						payload,
+						kind: info.kind,
+						forcedThreadTs: delivery.streamSession?.threadTs ?? delivery.nativeProgressStreamThreadTs
+					});
+					return;
+				}
+				return await progress.appendNativeNarration(payload, info.kind) ? void 0 : { visibleReplySent: false };
+			}
 			await delivery.deliverNormally({
 				payload,
 				kind: info.kind,
@@ -2087,61 +2504,9 @@ async function dispatchPreparedSlackMessage(prepared) {
 		const requiresSeparateFallbackDelivery = replyRenderPlan.mode === "split";
 		const trimmedFinalText = replyRenderPlan.mode === "single" ? replyRenderPlan.text.trim() : replyRenderPlan.fallbackText.trim();
 		const previewFinalText = replyRenderPlan.mode === "single" && replyRenderPlan.textIsSlackMrkdwn ? trimmedFinalText : normalizeSlackOutboundText((replySourceText ?? "").trim());
+		const previewFinalTextFitsEdit = countSlackTextUtf8Bytes(previewFinalText) <= SLACK_EDIT_TEXT_MAX_BYTES;
 		const shouldRestoreTtsSupplementTextForPreviewFallback = Boolean(ttsSupplement) && ttsSupplement?.visibleTextAlreadyDelivered !== true && Boolean(draftStream) && !draftPreviewCommitted.value && !delivery.observedFinalReplyDelivery && previewStreamingEnabled && !payload.text?.trim();
-		if (info.kind === "final" && ttsSupplement && draftStream && !hasSlackCustomIdentity && !draftPreviewCommitted.value && !delivery.observedFinalReplyDelivery && previewStreamingEnabled && !payload.isError && !requiresSeparateFallbackDelivery && trimmedFinalText.length > 0) {
-			const channelId = draftStream.channelId();
-			const messageId = draftStream.messageId();
-			if (channelId && messageId) {
-				const finalThreadTs = delivery.usedReplyThreadTs ?? statusThreadTs;
-				await draftStream.flush();
-				await draftStream.seal();
-				try {
-					await finalizeSlackPreviewEdit({
-						client: slackClient,
-						token: ctx.botToken,
-						accountId: account.accountId,
-						channelId,
-						messageId,
-						text: previewFinalText,
-						...slackBlocks?.length ? { blocks: slackBlocks } : {},
-						threadTs: finalThreadTs
-					});
-				} catch (err) {
-					logVerbose(`slack: preview final edit failed; falling back to standard send (${formatSlackError(err)})`);
-					await draftStream.discardPending();
-					let delivered = false;
-					try {
-						await delivery.deliverNormally({
-							payload: payload.text?.trim() ? payload : {
-								...payload,
-								text: ttsSupplement.spokenText
-							},
-							kind: info.kind,
-							forcedThreadTs: finalThreadTs
-						});
-						delivered = true;
-					} finally {
-						if (delivered) await draftStream.clear();
-					}
-					return;
-				}
-				draftPreviewCommitted.value = true;
-				delivery.observedFinalReplyDelivery = true;
-				delivery.observedReplyDelivery = true;
-				replyPlan.markSent();
-				await delivery.deliverNormally({
-					payload: buildTtsSupplementMediaPayload(payload),
-					kind: info.kind,
-					forcedThreadTs: finalThreadTs
-				});
-				delivery.markPreviewPayloadDelivered({
-					kind: info.kind,
-					payload,
-					threadTs: finalThreadTs
-				});
-				return;
-			}
-		}
+		let ttsPreviewFinalization;
 		await deliverWithFinalizableLivePreviewAdapter({
 			kind: info.kind,
 			payload,
@@ -2161,7 +2526,7 @@ async function dispatchPreparedSlackMessage(prepared) {
 					}
 				} : void 0,
 				buildFinalEdit: () => {
-					if (hasSlackCustomIdentity || !previewStreamingEnabled || reply.hasMedia && !ttsSupplement || payload.isError || requiresSeparateFallbackDelivery || trimmedFinalText.length === 0 && !slackBlocks?.length) return;
+					if (hasSlackCustomIdentity || !previewStreamingEnabled || reply.hasMedia && !ttsSupplement || payload.isError || requiresSeparateFallbackDelivery || !previewFinalTextFitsEdit || trimmedFinalText.length === 0 && !slackBlocks?.length) return;
 					return {
 						text: previewFinalText,
 						blocks: slackBlocks,
@@ -2174,16 +2539,19 @@ async function dispatchPreparedSlackMessage(prepared) {
 						payload,
 						threadTs: edit.threadTs
 					})) return;
-					await finalizeSlackPreviewEdit({
-						client: slackClient,
-						token: ctx.botToken,
-						accountId: account.accountId,
-						channelId: preview.channelId,
-						messageId: preview.messageId,
-						text: edit.text,
-						...edit.blocks?.length ? { blocks: edit.blocks } : {},
-						threadTs: edit.threadTs
-					});
+					if (ttsSupplement) ttsPreviewFinalization = { threadTs: edit.threadTs };
+					if (!await draftStream?.finalizeMessage(preview.messageId, async () => {
+						await finalizeSlackPreviewEdit({
+							client: slackClient,
+							token: ctx.botToken,
+							accountId: account.accountId,
+							channelId: preview.channelId,
+							messageId: preview.messageId,
+							text: edit.text,
+							...edit.blocks?.length ? { blocks: edit.blocks } : {},
+							threadTs: edit.threadTs
+						});
+					})) throw new Error("Slack preview moved below a newer conversation message");
 					if (!ttsSupplement) emitSlackMessageSentHooks({
 						...messageSentHookContext,
 						to: messageSentHookTarget,
@@ -2227,18 +2595,20 @@ async function dispatchPreparedSlackMessage(prepared) {
 			}),
 			deliverNormally: async () => {
 				await delivery.deliverNormally({
-					payload: shouldRestoreTtsSupplementTextForPreviewFallback ? {
+					payload: shouldRestoreTtsSupplementTextForPreviewFallback || ttsPreviewFinalization && !payload.text?.trim() ? {
 						...payload,
 						text: ttsSupplement?.spokenText
 					} : payload,
-					kind: info.kind
+					kind: info.kind,
+					...ttsPreviewFinalization?.threadTs ? { forcedThreadTs: ttsPreviewFinalization.threadTs } : {}
 				});
 			}
 		});
+		if (info.kind === "final") progress.progressDraft.markFinalReplyDelivered();
 	};
 	let dispatchError;
-	let queuedFinal = false;
-	let counts = {};
+	let agentRunFailed = false;
+	let settledDispatchResult;
 	try {
 		const turnResult = await dispatchChannelInboundTurn({
 			cfg,
@@ -2251,6 +2621,10 @@ async function dispatchPreparedSlackMessage(prepared) {
 			ctxPayload: prepared.ctxPayload,
 			dispatcherOptions: {
 				...replyPipeline,
+				transformReplyPayload: (payload) => {
+					const transformed = replyPipeline.transformReplyPayload ? replyPipeline.transformReplyPayload(payload) : payload;
+					return transformed ? filterPassiveThreadFailure(transformed) : null;
+				},
 				humanDelay: resolveHumanDelayConfig(cfg, route.agentId)
 			},
 			delivery: {
@@ -2272,120 +2646,82 @@ async function dispatchPreparedSlackMessage(prepared) {
 				commentaryProgressEnabled: progress.commentaryProgressEnabled ? true : void 0,
 				progressPreambleEnabled: progress.progressDraftActive && slackStreaming.mode === "progress" ? true : void 0,
 				commentaryPayloadsEnabled: progress.commentaryProgressEnabled ? true : void 0,
+				shouldDeliverCommentaryPayloads: progress.commentaryProgressEnabled ? progress.shouldYieldDraftProgress : void 0,
 				onVerboseProgressVisibility: progress.commentaryProgressEnabled ? (isActive) => {
 					progress.setShouldYieldDraftProgress(isActive);
 				} : void 0,
 				allowProgressCallbacksWhenSourceDeliverySuppressed: sourceReplyDeliveryMode === "message_tool_only" && statusReactionsEnabled ? true : void 0,
 				allowToolLifecycleWhenProgressHidden: statusReactionsEnabled ? true : void 0,
 				onPartialReply: useStreaming ? void 0 : !previewStreamingEnabled ? void 0 : async (payload) => {
-					progress.updateDraftFromPartial(payload.text);
+					return progress.updateDraftFromPartial(payload.text);
 				},
-				onAssistantMessageStart: progress.onDraftBoundary,
+				onAssistantMessageStart: progress.onDraftBoundary ? async () => {
+					await progress.onDraftBoundary?.();
+					return false;
+				} : void 0,
 				onReasoningEnd: async () => {
-					progress.progressReceipt.closeReasoning();
 					await progress.onDraftBoundary?.();
+					return false;
 				},
 				onQueuedFollowupAdmitted: progress.onQueuedFollowupAdmitted,
+				onQueuedFollowupSettled: progress.onQueuedFollowupSettled,
 				onReasoningStream: statusReactionsEnabled || progress.previewToolProgressEnabled ? async (payload) => {
-					await progress.pushReasoningProgress(payload);
-					if (!statusReactionsEnabled) return;
+					const visible = await progress.pushReasoningProgress(payload);
+					if (!statusReactionsEnabled) return visible;
 					await statusReactions.setThinking();
+					return visible;
 				} : void 0,
 				onToolStart: async (payload) => {
 					if (statusReactionsEnabled) await statusReactions.setTool(payload.name);
-					if (payload.phase === "start") progress.progressReceipt.noteToolCall(payload.name);
-					await progress.pushPreviewProgress(buildChannelProgressDraftLineForEntry(account.config, {
-						event: "tool",
-						itemId: payload.itemId,
-						toolCallId: payload.toolCallId,
-						name: payload.name,
-						phase: payload.phase,
-						args: payload.args
-					}, payload.detailMode ? { detailMode: payload.detailMode } : void 0), { toolName: payload.name });
+					if (payload.phase === "start") progress.progressWorkCounter.noteToolCall(payload.name);
+					return await progress.progressDraft.pushToolEvent(payload);
 				},
 				onItemEvent: async (payload) => {
-					if (progress.streamMode === "status_final" && payload.kind === "preamble") {
-						if (progress.shouldYieldDraftProgress()) return;
-						await progress.progressDraft.pushPreambleHeadline(payload.progressText, { itemId: payload.itemId });
-						if (progress.commentaryProgressEnabled) {
-							if (await progress.progressDraft.pushCommentaryProgress(payload.progressText, { itemId: payload.itemId })) progress.progressReceipt.noteCommentary(payload.itemId, payload.progressText);
-						}
-						return;
+					if (progress.isProgressMode && payload.kind === "preamble") {
+						if (progress.shouldYieldDraftProgress()) return false;
+						const headlineVisible = await progress.progressDraft.pushPreambleHeadline(payload.progressText, { itemId: payload.itemId });
+						if (progress.commentaryProgressEnabled) return await progress.progressDraft.pushCommentaryProgress(payload.progressText, { itemId: payload.itemId }) || headlineVisible;
+						return headlineVisible;
 					}
-					await progress.pushPreviewProgress(buildChannelProgressDraftLineForEntry(account.config, {
-						event: "item",
-						itemId: payload.itemId,
-						toolCallId: payload.toolCallId,
-						itemKind: payload.kind,
-						title: payload.title,
-						name: payload.name,
-						phase: payload.phase,
-						status: payload.status,
-						summary: payload.summary,
-						progressText: payload.progressText,
-						meta: payload.meta
-					}));
+					return await progress.progressDraft.pushItemEvent(payload);
 				},
 				onPlanUpdate: async (payload) => {
-					if (payload.phase !== "update") return;
-					await progress.pushPlanProgress(payload.steps, payload.explanation);
+					if (payload.phase !== "update") return false;
+					return await progress.pushPlanProgress(payload.steps, payload.explanation);
 				},
 				onApprovalEvent: async (payload) => {
-					if (payload.phase !== "requested") return;
-					await progress.pushPreviewProgress(buildChannelProgressDraftLine({
-						event: "approval",
-						phase: payload.phase,
-						title: payload.title,
-						command: payload.command,
-						reason: payload.reason,
-						message: payload.message
-					}));
+					return await progress.progressDraft.pushApprovalEvent(payload);
 				},
 				onCommandOutput: async (payload) => {
-					if (payload.phase !== "end") return;
-					await progress.pushPreviewProgress(buildChannelProgressDraftLine({
-						event: "command-output",
-						itemId: payload.itemId,
-						toolCallId: payload.toolCallId,
-						phase: payload.phase,
-						title: payload.title,
-						name: payload.name,
-						status: payload.status,
-						exitCode: payload.exitCode
-					}));
+					return await progress.progressDraft.pushCommandOutputEvent(payload);
 				},
 				onPatchSummary: async (payload) => {
-					if (payload.phase !== "end") return;
-					await progress.pushPreviewProgress(buildChannelProgressDraftLine({
-						event: "patch",
-						itemId: payload.itemId,
-						toolCallId: payload.toolCallId,
-						phase: payload.phase,
-						title: payload.title,
-						name: payload.name,
-						added: payload.added,
-						modified: payload.modified,
-						deleted: payload.deleted,
-						summary: payload.summary
-					}));
+					return await progress.progressDraft.pushPatchEvent(payload);
 				}
 			}
 		});
 		if (turnResult.dispatched) {
 			const result = turnResult.dispatchResult;
-			queuedFinal = result.queuedFinal;
-			counts = result.counts;
+			settledDispatchResult = result;
+			const agentRunOutcome = readAgentRunTerminalOutcome(result);
+			agentRunFailed = agentRunOutcome === "failed";
+			if (agentRunOutcome === "completed" && !sawTerminalFailurePayload && prepared.ctxPayload.ChatType === "channel") clearSlackThreadFailureNotice({
+				accountId: account.accountId,
+				channelId: message.channel,
+				...failureNoticeThreadTs ? { threadTs: failureNoticeThreadTs } : {},
+				...failureNoticeTeamId ? { teamId: failureNoticeTeamId } : {}
+			});
 		}
 	} catch (err) {
 		dispatchError = err;
 	} finally {
 		progress.progressDraft.cancel();
-		await draftStream?.discardPending();
+		if (!progress.useDraftProgressCard) await draftStream?.discardPending();
 	}
 	let streamFallbackDelivered = false;
 	const finalStream = delivery.streamSession;
 	if (finalStream && !finalStream.stopped) try {
-		const completionChunks = progress.useNativeProgressStreaming && !progress.nativeProgressCompletionSent ? progress.buildNativeProgressCompletionChunks(dispatchError ? "error" : progress.nativeProgressTerminalStatus) : void 0;
+		const completionChunks = progress.useNativeProgressStreaming && !progress.nativeProgressCompletionSent ? progress.buildNativeProgressCompletionChunks(dispatchError || agentRunFailed ? "error" : progress.nativeProgressTerminalStatus) : void 0;
 		if (completionChunks?.length) progress.nativeProgressCompletionSent = true;
 		const stopResult = await stopSlackStream({
 			session: finalStream,
@@ -2393,12 +2729,6 @@ async function dispatchPreparedSlackMessage(prepared) {
 			...slackMessageMetadata ? { metadata: slackMessageMetadata } : {}
 		});
 		delivery.acknowledgeStoppedStreamedDeliveries(finalStream, stopResult?.messageId);
-		if (progress.pendingNativeProgressReceipt && stopResult?.messageId && !progress.progressReceiptCollapsed) await progress.collapseProgressReceipt({
-			channelId: finalStream.channel,
-			messageId: stopResult.messageId,
-			text: progress.pendingNativeProgressReceipt,
-			threadTs: finalStream.threadTs
-		});
 	} catch (err) {
 		if (err instanceof SlackStreamNotDeliveredError) {
 			streamFallbackDelivered = await delivery.deliverPendingStreamFallback(finalStream, err);
@@ -2411,50 +2741,45 @@ async function dispatchPreparedSlackMessage(prepared) {
 			if (!finalStream.delivered) dispatchError ??= err;
 		}
 	}
-	counts = delivery.reconcileCounts(counts);
-	queuedFinal = queuedFinal && (counts.final ?? 0) > 0;
-	const anyReplyDelivered = hasVisibleInboundReplyDispatch({
-		queuedFinal,
-		counts
-	}, {
+	const anyReplyDelivered = hasVisibleInboundReplyDispatch(settledDispatchResult, {
 		observedReplyDelivery: delivery.observedReplyDelivery,
 		fallbackDelivered: streamFallbackDelivered
 	});
-	if (statusReactionsEnabled) if (dispatchError) await statusReactions.setError();
-	else if (anyReplyDelivered) {
+	if (pendingFailureNotice && anyReplyDelivered) recordSlackThreadFailureNotice(pendingFailureNotice);
+	if (dispatchError || agentRunFailed) await progress.finalizeDraftProgressCard("error");
+	await progress.dropDetachedProgressCards();
+	if (statusReactionsEnabled) if (dispatchError || agentRunFailed) {
+		await statusReactions.setError();
+		statusReactions.restoreInitial();
+	} else if (anyReplyDelivered) {
 		await statusReactions.setDone();
 		statusReactions.restoreInitial();
 	} else await statusReactions.restoreInitial();
 	const participationThreadTs = delivery.usedReplyThreadTs ?? statusThreadTs;
 	if (anyReplyDelivered && participationThreadTs) recordSlackThreadParticipation(account.accountId, message.channel, participationThreadTs, {
 		agentId: route.agentId,
-		...prepared.eventScope ? { teamId: prepared.eventScope.teamId } : {}
+		teamId: prepared.eventScope?.teamId
 	});
 	if (dispatchError) throw toErrorObject(dispatchError, "Slack dispatch failed");
-	if (!anyReplyDelivered && !draftPreviewCommitted.value) {
+	if (!anyReplyDelivered && !draftPreviewCommitted.value && !(agentRunFailed && progress.useDraftProgressCard)) {
 		await draftStream?.clear();
+		await draftStream?.dropDetachedMessages();
 		return;
 	}
 	if (shouldLogVerbose()) {
-		const finalCount = counts.final;
+		const finalCount = resolveInboundReplyDispatchCounts(settledDispatchResult).final;
 		logVerbose(`slack: delivered ${finalCount} reply${finalCount === 1 ? "" : "ies"} to ${prepared.replyTarget}`);
 	}
 }
 //#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);
+	const entity = asOptionalRecord(value);
+	const type = normalizeOptionalString(entity?.type);
 	if (!entity || !type) return;
-	const teamId = trimmedString(entity.team_id);
+	const teamId = normalizeOptionalString(entity.team_id);
 	if (type === "slack#/types/channel_id" || type === "slack#/types/canvas_id" || type === "slack#/types/list_id") {
-		const entityValue = trimmedString(entity.value);
+		const entityValue = normalizeOptionalString(entity.value);
 		return entityValue ? {
 			type,
 			value: entityValue,
@@ -2462,9 +2787,9 @@ function normalizeEntity(value) {
 		} : 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);
+	const message = asOptionalRecord(entity.value);
+	const channelId = normalizeOptionalString(message?.channel_id);
+	const messageTs = normalizeOptionalString(message?.message_ts);
 	return channelId && messageTs ? {
 		type,
 		value: {
@@ -2475,10 +2800,10 @@ function normalizeEntity(value) {
 	} : void 0;
 }
 function isSlackAppContext(value) {
-	return Boolean(asRecord(value));
+	return Boolean(asOptionalRecord(value));
 }
 function normalizeSlackAppContextEntities(value) {
-	const context = asRecord(value);
+	const context = asOptionalRecord(value);
 	if (!Array.isArray(context?.entities)) return [];
 	return context.entities.flatMap((entity) => {
 		const normalized = normalizeEntity(entity);
@@ -2486,89 +2811,194 @@ function normalizeSlackAppContextEntities(value) {
 	});
 }
 //#endregion
+//#region extensions/slack/src/monitor/thread.ts
+const THREAD_STARTER_CACHE = /* @__PURE__ */ new Map();
+const THREAD_STARTER_CACHE_TTL_MS = 360 * 6e4;
+const THREAD_STARTER_CACHE_MAX = 2e3;
+function evictThreadStarterCache() {
+	const now = asDateTimestampMs(Date.now());
+	if (now === void 0) {
+		THREAD_STARTER_CACHE.clear();
+		return;
+	}
+	for (const [cacheKey, entry] of THREAD_STARTER_CACHE.entries()) if (asDateTimestampMs(entry.expiresAt) === void 0 || entry.expiresAt <= now) THREAD_STARTER_CACHE.delete(cacheKey);
+	pruneMapToMaxSize(THREAD_STARTER_CACHE, THREAD_STARTER_CACHE_MAX);
+}
+function formatSlackFilePlaceholder(files) {
+	return `[attached: ${formatSlackFileReferenceList(files)}]`;
+}
+function pushUniqueText(parts, value, options = {}) {
+	const text = options.preserveWhitespace ? typeof value === "string" && value.trim().length > 0 ? value : void 0 : normalizeOptionalString(value);
+	if (text && !parts.includes(text)) parts.push(text);
+}
+function resolveSlackBlocksFallbackText(blocks) {
+	return resolveSlackBlocksText(blocks)?.text;
+}
+function resolveSlackAttachmentFallbackText(attachments) {
+	if (!Array.isArray(attachments) || attachments.length === 0) return;
+	const parts = [];
+	for (const attachment of attachments) {
+		const excludeTableBlocks = isSlackUnfurlAttachment(attachment);
+		const fallbackBlocks = (blocks) => excludeTableBlocks ? blocks?.filter((block) => !hasSlackTableBlock([block])) : blocks;
+		pushUniqueText(parts, attachment.pretext);
+		pushUniqueText(parts, attachment.title);
+		pushUniqueText(parts, attachment.text);
+		if (!(hasSlackTableBlock(attachment.blocks) && normalizeOptionalString(attachment.fallback) === "[no preview available]")) pushUniqueText(parts, attachment.fallback);
+		for (const field of attachment.fields ?? []) {
+			pushUniqueText(parts, field.title);
+			pushUniqueText(parts, field.value);
+		}
+		pushUniqueText(parts, resolveSlackBlocksFallbackText(fallbackBlocks(attachment.blocks)), { preserveWhitespace: true });
+		pushUniqueText(parts, resolveSlackBlocksFallbackText(fallbackBlocks(attachment.message_blocks)), { preserveWhitespace: true });
+	}
+	return parts.length > 0 ? parts.join("\n") : void 0;
+}
+function resolveSlackMessageText(message) {
+	const messageText = normalizeOptionalString(message.text) ?? resolveSlackAttachmentFallbackText(message.attachments);
+	return resolveSlackMessageText$1({
+		...message,
+		text: messageText
+	}, { preserveMessageTextWhitespace: true });
+}
+async function resolveSlackThreadStarter(params) {
+	evictThreadStarterCache();
+	const cacheKey = JSON.stringify([
+		params.workspaceScope.accountId,
+		params.workspaceScope.teamId,
+		params.channelId,
+		params.threadTs
+	]);
+	const cached = THREAD_STARTER_CACHE.get(cacheKey);
+	if (cached) {
+		const now = asDateTimestampMs(Date.now());
+		if (now !== void 0 && cached.expiresAt > now) return cached.value;
+		THREAD_STARTER_CACHE.delete(cacheKey);
+	}
+	try {
+		const message = (await params.client.conversations.replies({
+			channel: params.channelId,
+			ts: params.threadTs,
+			limit: 1,
+			inclusive: true
+		}))?.messages?.[0];
+		const text = message ? resolveSlackMessageText(message) : void 0;
+		const files = message?.files?.length ? message.files : void 0;
+		if (!message || !text && !files) return null;
+		const starter = {
+			text: text || formatSlackFilePlaceholder(files),
+			userId: message.user,
+			botId: message.bot_id,
+			ts: message.ts,
+			files
+		};
+		const expiresAt = resolveExpiresAtMsFromDurationMs(THREAD_STARTER_CACHE_TTL_MS);
+		if (expiresAt !== void 0) {
+			if (THREAD_STARTER_CACHE.has(cacheKey)) THREAD_STARTER_CACHE.delete(cacheKey);
+			THREAD_STARTER_CACHE.set(cacheKey, {
+				value: starter,
+				expiresAt
+			});
+			evictThreadStarterCache();
+		}
+		return starter;
+	} catch (err) {
+		logVerbose$1(`slack thread starter fetch failed channel=${params.channelId} ts=${params.threadTs}: ${formatErrorMessage(err)}`);
+		return null;
+	}
+}
+const SLACK_THREAD_HISTORY_MAX_PAGES = 3;
+/**
+* Fetches the most recent messages in a Slack thread (excluding the current message).
+* Used to populate thread context when a new thread session starts.
+*
+* Uses cursor pagination and keeps only the latest N retained messages when the full
+* thread fits in the bounded fetch window.
+*/
+async function resolveSlackThreadHistory(params) {
+	const maxMessages = params.limit ?? 20;
+	if (!Number.isFinite(maxMessages) || maxMessages <= 0) return [];
+	const fetchLimit = 200;
+	const retained = [];
+	let cursor;
+	let pagesFetched = 0;
+	try {
+		do {
+			pagesFetched += 1;
+			const response = await params.client.conversations.replies({
+				channel: params.channelId,
+				ts: params.threadTs,
+				limit: fetchLimit,
+				inclusive: true,
+				...cursor ? { cursor } : {}
+			});
+			for (const msg of response.messages ?? []) {
+				const text = resolveSlackMessageText(msg);
+				if (!text && !msg.files?.length) continue;
+				if (params.currentMessageTs && msg.ts === params.currentMessageTs) continue;
+				retained.push([msg, text]);
+			}
+			if (retained.length > maxMessages) retained.splice(0, retained.length - maxMessages);
+			const next = response.response_metadata?.next_cursor;
+			cursor = typeof next === "string" && next.trim().length > 0 ? next.trim() : void 0;
+		} while (cursor && pagesFetched < SLACK_THREAD_HISTORY_MAX_PAGES);
+		if (cursor) {
+			logVerbose$1(`slack thread history capped channel=${params.channelId} ts=${params.threadTs} pages=${SLACK_THREAD_HISTORY_MAX_PAGES}`);
+			return [];
+		}
+		return retained.map(([message, text]) => ({
+			text: text ?? formatSlackFilePlaceholder(message.files),
+			userId: message.user,
+			botId: message.bot_id,
+			ts: message.ts,
+			files: message.files
+		}));
+	} catch (err) {
+		logVerbose$1(`slack thread history fetch failed channel=${params.channelId} ts=${params.threadTs}: ${formatErrorMessage(err)}`);
+		return [];
+	}
+}
+//#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"));
 function isSlackAudioFile(file) {
 	if (file.subtype === "slack_audio") return true;
 	if ((file.mimetype?.split(";")[0]?.trim().toLowerCase())?.startsWith("audio/")) return true;
 	return Boolean(mimeTypeFromFilePath(file.name)?.startsWith("audio/"));
 }
+const slackPreflightAudio = createChannelPreflightAudio({
+	channel: "slack",
+	isAudio: isSlackAudioFile
+});
 function findCaptionlessSlackAudioFile(message) {
 	if (message.text?.trim()) return;
 	return message.files?.slice(0, 8).find(isSlackAudioFile);
 }
 function formatSlackAudioTranscriptForAgent(params) {
-	return [`[Audio transcript (machine-generated, untrusted)]: ${JSON.stringify(params.transcript)}`, params.rawBody].filter(Boolean).join("\n");
-}
-function suppressSlackPreflightAudioEcho(cfg) {
-	const audio = cfg.tools?.media?.audio;
-	if (!audio?.echoTranscript) return cfg;
-	return {
-		...cfg,
-		tools: {
-			...cfg.tools,
-			media: {
-				...cfg.tools?.media,
-				audio: {
-					...audio,
-					echoTranscript: false
-				}
-			}
-		}
-	};
+	return [formatAudioTranscriptForAgent(params.transcript), params.rawBody].filter(Boolean).join("\n");
 }
 async function resolveSlackPreflightAudioTranscript(params) {
 	const mediaIndex = params.media.findIndex((entry) => entry.contentType?.toLowerCase().startsWith("audio/"));
 	if (mediaIndex < 0) return null;
-	try {
-		const { transcribeFirstAudio } = await loadSlackPreflightAudioRuntime();
-		const transcript = await transcribeFirstAudio({
-			ctx: {
-				media: [...params.media],
-				Provider: "slack",
-				Surface: "slack",
-				OriginatingChannel: "slack",
-				OriginatingTo: params.originatingTo,
-				AccountId: params.accountId,
-				MessageThreadId: params.messageThreadId,
-				ChatType: "channel",
-				SessionKey: params.sessionKey
-			},
-			cfg: suppressSlackPreflightAudioEcho(params.cfg)
-		});
-		return transcript ? {
-			transcript,
-			mediaIndex
-		} : null;
-	} catch (err) {
-		logVerbose(`slack: audio preflight transcription failed: ${String(err)}`);
-		return null;
-	}
-}
-function formatSlackAudioTranscriptEcho(transcript, format) {
-	return format.replace("{transcript}", () => transcript);
+	const transcript = await slackPreflightAudio.resolve({ request: {
+		ctx: {
+			media: [...params.media],
+			Provider: "slack",
+			Surface: "slack",
+			OriginatingChannel: "slack",
+			OriginatingTo: params.originatingTo,
+			AccountId: params.accountId,
+			MessageThreadId: params.messageThreadId,
+			ChatType: "channel",
+			SessionKey: params.sessionKey
+		},
+		cfg: params.cfg
+	} });
+	return transcript ? {
+		transcript,
+		mediaIndex
+	} : null;
 }
 async function sendSlackPreflightAudioTranscriptEcho(params) {
-	const audio = params.cfg.tools?.media?.audio;
-	if (!audio?.echoTranscript) return;
-	const text = formatSlackAudioTranscriptEcho(params.transcript, audio.echoFormat ?? SLACK_DEFAULT_ECHO_TRANSCRIPT_FORMAT);
-	try {
-		const { sendDurableMessageBatch } = await loadSlackPreflightAudioRuntime();
-		const send = await sendDurableMessageBatch({
-			cfg: params.cfg,
-			channel: "slack",
-			to: params.originatingTo,
-			accountId: params.accountId,
-			threadId: params.messageThreadId,
-			payloads: [{ text }],
-			bestEffort: true,
-			durability: "best_effort"
-		});
-		if (send.status === "failed") throw send.error;
-	} catch (err) {
-		logVerbose(`slack: audio transcript echo failed: ${String(err)}`);
-	}
+	await slackPreflightAudio.send(params);
 }
 async function discardSlackPreflightMedia(media) {
 	await Promise.allSettled((media ?? []).map((entry) => fs.rm(entry.path, { force: true })));
@@ -2578,7 +3008,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-D3NuJvva.js").then((n) => n.g));
+const loadSlackMediaModule$1 = createLazyRuntimeModule(() => import("./actions-DFk0ANVB.js").then((n) => n._));
 function collectUniqueSlackMentionIds$1(texts) {
 	const seen = /* @__PURE__ */ new Set();
 	const mentionIds = [];
@@ -2639,7 +3069,14 @@ async function resolveSlackMessageContent(params) {
 	const mergedMedia = [...media ?? [], ...attachmentContent?.media ?? []];
 	const effectiveDirectMedia = mergedMedia.length > 0 ? mergedMedia : null;
 	const mediaPlaceholder = effectiveDirectMedia ? effectiveDirectMedia.map((item) => item.placeholder).join(" ") : void 0;
-	const fallbackFiles = ownFiles ?? [];
+	const fallbackFileIds = /* @__PURE__ */ new Set();
+	const fallbackFiles = [...ownFiles ?? [], ...attachmentContent?.files ?? []].filter((file) => {
+		const fileId = normalizeOptionalString(file.id);
+		if (!fileId) return true;
+		if (fallbackFileIds.has(fileId)) return false;
+		fallbackFileIds.add(fileId);
+		return true;
+	});
 	const fileOnlyFallback = !mediaPlaceholder && fallbackFiles.length > 0 ? fallbackFiles.slice(0, 8).map((file) => formatSlackFileReference(file)).join(", ") : void 0;
 	const fileOnlyPlaceholder = fileOnlyFallback ? `[Slack file: ${fileOnlyFallback}]` : void 0;
 	let botAttachmentText;
@@ -2652,7 +3089,7 @@ async function resolveSlackMessageContent(params) {
 		botAttachmentText = botAttachmentTextParts.length > 0 ? botAttachmentTextParts.join("\n") : void 0;
 	}
 	const textParts = [
-		resolveSlackMessageText(params.message),
+		resolveSlackMessageText$1(params.message),
 		attachmentContent?.text,
 		botAttachmentText
 	];
@@ -2678,13 +3115,18 @@ async function resolveSlackMessageContent(params) {
 			renderedMentions.set(result.userId, result.rendered);
 		}
 	}
-	const rawBody = [
+	let rawBody = [
 		renderSlackUserMentions(textParts[0], renderedMentions),
 		renderSlackUserMentions(textParts[1], renderedMentions),
 		renderSlackUserMentions(textParts[2], renderedMentions),
 		mediaPlaceholder,
 		fileOnlyPlaceholder
 	].filter(Boolean).join("\n") || "";
+	const unavailableImageCount = attachmentContent?.unavailableImageCount ?? 0;
+	if (unavailableImageCount > 0) rawBody = formatInboundMediaUnavailableText({
+		body: rawBody,
+		notice: `[slack ${unavailableImageCount > 1 ? `${unavailableImageCount} forwarded images` : "forwarded image"} unavailable]`
+	});
 	if (!rawBody) return null;
 	return {
 		rawBody,
@@ -2765,68 +3207,8 @@ async function resolveSlackDmHistoryContext(params) {
 }
 //#endregion
 //#region extensions/slack/src/monitor/message-handler/prepare-routing.ts
-const slackRouteBindingConfigCache = /* @__PURE__ */ new WeakMap();
-function slackTargetDefaultKindForPeer(kind) {
-	return kind === "direct" ? "user" : "channel";
-}
-function slackTargetKindMatchesPeer(peerKind, targetKind) {
-	if (targetKind === "user") return peerKind === "direct";
-	return peerKind === "channel" || peerKind === "group";
-}
-function normalizeSlackRouteBindingPeer(peer) {
-	const rawId = peer.id.trim();
-	if (!rawId || rawId === "*") return peer;
-	const target = (() => {
-		try {
-			return parseSlackTarget(rawId, { defaultKind: slackTargetDefaultKindForPeer(peer.kind) });
-		} catch {
-			return;
-		}
-	})();
-	if (!target || !slackTargetKindMatchesPeer(peer.kind, target.kind) || target.id === peer.id) return peer;
-	return {
-		...peer,
-		id: target.id
-	};
-}
-function normalizeSlackRouteBindingConfig(cfg) {
-	const bindings = cfg.bindings;
-	const cached = slackRouteBindingConfigCache.get(cfg);
-	if (cached && cached.bindingsRef === bindings) return cached.normalizedCfg;
-	if (!Array.isArray(bindings)) return cfg;
-	let changed = false;
-	const normalizedBindings = bindings.map((binding) => {
-		if (binding.type === "acp" || binding.match.channel.trim().toLowerCase() !== "slack") return binding;
-		const peer = binding.match.peer;
-		if (!peer) return binding;
-		const normalizedPeer = normalizeSlackRouteBindingPeer(peer);
-		if (normalizedPeer === peer) return binding;
-		changed = true;
-		return {
-			...binding,
-			match: {
-				...binding.match,
-				peer: normalizedPeer
-			}
-		};
-	});
-	const normalizedCfg = changed ? {
-		...cfg,
-		bindings: normalizedBindings
-	} : cfg;
-	slackRouteBindingConfigCache.set(cfg, {
-		bindingsRef: bindings,
-		normalizedCfg
-	});
-	return normalizedCfg;
-}
 function resolveSlackBaseConversationId(params) {
-	const raw = params.isDirectMessage ? `user:${params.message.user ?? "unknown"}` : params.message.channel;
-	return params.eventScope ? `team:${encodeURIComponent(params.eventScope.teamId)}:${raw}` : raw;
-}
-function qualifySlackPeerId(params) {
-	if (!params.eventScope) return params.id;
-	return `team:${encodeURIComponent(params.eventScope.teamId)}:${params.kind}:${encodeURIComponent(params.id)}`;
+	return qualifySlackConversationId(params.isDirectMessage ? `user:${params.message.user ?? "unknown"}` : params.message.channel, params.eventScope);
 }
 function resolveSlackInitialAgentRoute(params) {
 	const route = resolveAgentRoute({
@@ -2836,7 +3218,7 @@ function resolveSlackInitialAgentRoute(params) {
 		teamId: params.eventScope?.teamId || params.ctx.teamId || void 0,
 		peer: {
 			kind: params.isDirectMessage ? "direct" : params.isRoom ? "channel" : "group",
-			id: qualifySlackPeerId({
+			id: qualifySlackRoutePeerId({
 				id: params.isDirectMessage ? params.message.user ?? "unknown" : params.message.channel,
 				kind: params.isDirectMessage ? "user" : "channel",
 				eventScope: params.eventScope
@@ -2844,8 +3226,11 @@ function resolveSlackInitialAgentRoute(params) {
 		}
 	});
 	if (!params.eventScope || !params.isDirectMessage || route.dmScope !== "main") return route;
-	const partition = `account:${encodeURIComponent(params.account.accountId).toLowerCase()}:team:${encodeURIComponent(params.eventScope.teamId).toLowerCase()}`;
-	const sessionKey = `${route.sessionKey}:${partition}`;
+	const sessionKey = resolveSlackEnterpriseMainDmSessionKey({
+		baseSessionKey: route.sessionKey,
+		accountId: params.account.accountId,
+		eventScope: params.eventScope
+	});
 	return {
 		...route,
 		sessionKey,
@@ -2880,44 +3265,18 @@ function resolveSlackRoutingContext(params) {
 		eventScope
 	});
 	const runtimeBindingThreadId = routedThreadId ?? (isDirectMessage && isThreadReply ? threadTs : void 0);
-	const boundThreadRoute = !eventScope && runtimeBindingThreadId ? resolveRuntimeConversationBindingRoute({
-		route,
-		conversation: {
-			channel: "slack",
-			accountId: account.accountId,
-			conversationId: runtimeBindingThreadId,
-			parentConversationId: baseConversationId
-		}
-	}) : null;
-	const runtimeRoute = eventScope ? {
-		route,
-		bindingRecord: null,
-		boundSessionKey: void 0
-	} : boundThreadRoute?.boundSessionKey || boundThreadRoute?.bindingRecord ? boundThreadRoute : resolveRuntimeConversationBindingRoute({
+	const bindingRoute = resolveSlackConversationBindingRoute({
+		cfg: ctx.cfg,
 		route,
-		conversation: {
-			channel: "slack",
-			accountId: account.accountId,
-			conversationId: baseConversationId
-		}
+		accountId: account.accountId,
+		baseConversationId,
+		runtimeBindingThreadId,
+		bindingsEnabled: !eventScope
 	});
-	let configuredBinding = null;
-	let configuredBindingSessionKey = "";
-	if (runtimeRoute.boundSessionKey || runtimeRoute.bindingRecord) route = runtimeRoute.route;
-	else if (!eventScope) {
-		const configuredRoute = resolveConfiguredBindingRoute({
-			cfg: ctx.cfg,
-			route,
-			conversation: {
-				channel: "slack",
-				accountId: account.accountId,
-				conversationId: baseConversationId
-			}
-		});
-		configuredBinding = configuredRoute.bindingResolution;
-		configuredBindingSessionKey = configuredRoute.boundSessionKey ?? "";
-		route = configuredRoute.route;
-	}
+	const runtimeRoute = bindingRoute.runtimeRoute;
+	const configuredBinding = bindingRoute.configuredRoute?.bindingResolution ?? null;
+	const configuredBindingSessionKey = bindingRoute.configuredRoute?.boundSessionKey ?? "";
+	route = bindingRoute.route;
 	const threadKeys = runtimeRoute.boundSessionKey || configuredBindingSessionKey ? {
 		sessionKey: route.sessionKey,
 		parentSessionKey: void 0
@@ -2953,8 +3312,12 @@ function isSlackThreadAuthorCurrentBot(params) {
 	return false;
 }
 function resolveSlackThreadHistoryFilterPolicy(params) {
-	if (!params.includeBotStarterAsRootContext || !params.starterTs) return {};
-	return { retainCurrentBotRootTs: params.starterTs };
+	if (params.retainCurrentBotHistory) return { currentBot: "all" };
+	if (!params.includeBotStarterAsRootContext || !params.starterTs) return { currentBot: "omit" };
+	return {
+		currentBot: "root-only",
+		rootTs: params.starterTs
+	};
 }
 function applySlackThreadHistoryFilterPolicy(params) {
 	const kept = [];
@@ -2967,7 +3330,7 @@ function applySlackThreadHistoryFilterPolicy(params) {
 			kept.push(entry);
 			continue;
 		}
-		if (params.policy.retainCurrentBotRootTs && entry.ts === params.policy.retainCurrentBotRootTs) kept.push(entry);
+		if (params.policy.currentBot === "all" || params.policy.currentBot === "root-only" && entry.ts === params.policy.rootTs) kept.push(entry);
 		else omittedCurrentBot += 1;
 	}
 	return {
@@ -2996,11 +3359,11 @@ function formatSlackThreadLabelSnippet(text) {
 }
 //#endregion
 //#region extensions/slack/src/monitor/message-handler/prepare-thread-context.ts
-const loadSlackMediaModule = createLazyRuntimeModule(() => import("./actions-D3NuJvva.js").then((n) => n.g));
+const loadSlackMediaModule = createLazyRuntimeModule(() => import("./actions-DFk0ANVB.js").then((n) => n._));
 const SLACK_THREAD_CONTEXT_USER_LOOKUP_CONCURRENCY = 4;
 function resolveSlackThreadSessionFreshness(params) {
 	return params.ctx.channelRuntime?.session?.resolveEntryResetFreshness?.({
-		defaultAgentId: resolveDefaultAgentId(params.ctx.cfg),
+		agentId: params.agentId,
 		storePath: params.storePath,
 		sessionKey: params.sessionKey,
 		sessionCfg: params.ctx.cfg.session,
@@ -3066,6 +3429,7 @@ async function resolveSlackThreadContextData(params) {
 	let threadStarterMedia = null;
 	const threadSessionFreshness = params.isThreadReply && params.threadTs ? resolveSlackThreadSessionFreshness({
 		ctx: params.ctx,
+		agentId: params.agentId,
 		storePath: params.storePath,
 		sessionKey: params.sessionKey
 	}) : void 0;
@@ -3073,7 +3437,9 @@ async function resolveSlackThreadContextData(params) {
 		storePath: params.storePath,
 		sessionKey: params.sessionKey
 	}) : void 0;
-	const shouldSeedInitialThreadContext = Boolean(params.isThreadReply && params.threadTs && (threadSessionFreshness ? threadSessionFreshness.state !== "fresh" : threadSessionPreviousTimestamp === void 0));
+	const isMissingThreadSession = threadSessionFreshness ? threadSessionFreshness.state === "missing" : threadSessionPreviousTimestamp === void 0;
+	const isOutboundOnlyThreadSession = threadSessionFreshness !== void 0 && threadSessionFreshness.state !== "missing" && threadSessionFreshness.entry.lastInteractionAt === void 0 && threadSessionFreshness.entry.updatedAt !== 0;
+	const shouldSeedInitialThreadContext = Boolean(params.isThreadReply && params.threadTs && (threadSessionFreshness ? threadSessionFreshness.state !== "fresh" || isOutboundOnlyThreadSession : threadSessionPreviousTimestamp === void 0));
 	const shouldLoadInitialThreadHistory = shouldSeedInitialThreadContext || params.forceInitialHistory === true;
 	if (!params.isThreadReply || !params.threadTs) return {
 		threadStarterBody,
@@ -3151,7 +3517,8 @@ async function resolveSlackThreadContextData(params) {
 				history: threadHistoryWithBotRoot,
 				policy: resolveSlackThreadHistoryFilterPolicy({
 					includeBotStarterAsRootContext,
-					starterTs: currentBotRootTs
+					starterTs: currentBotRootTs,
+					retainCurrentBotHistory: params.isGroupDm && (isMissingThreadSession || isOutboundOnlyThreadSession)
 				}),
 				identity: botIdentity
 			});
@@ -3298,6 +3665,13 @@ const SLACK_HISTORY_MEDIA_MAX_ATTACHMENTS = 4;
 const SLACK_HISTORY_MEDIA_MAX_BYTES = 10 * 1024 * 1024;
 const SLACK_HISTORY_MEDIA_IDLE_TIMEOUT_MS = 1e3;
 const SLACK_HISTORY_MEDIA_TOTAL_TIMEOUT_MS = 3e3;
+const SLACK_CHANNEL_ACCESS_DOCS_URL = "https://docs.openclaw.ai/channels/slack#access-control-and-routing";
+function resolveSlackGroupSessionSubject(params) {
+	const channelName = normalizeOptionalString(params.channelName);
+	const workspaceName = normalizeOptionalString(params.workspaceName);
+	if (channelName && workspaceName) return `${workspaceName} #${channelName}`;
+	return `Slack Channel (Workspace ID: ${params.workspaceId}, Channel ID: ${params.channelId})`;
+}
 function recordString(record, key) {
 	return normalizeOptionalString(record?.[key]);
 }
@@ -3504,6 +3878,8 @@ async function resolveSlackConversationContext(params) {
 	const isRoom = resolvedChannelType === "channel" || resolvedChannelType === "group";
 	const isRoomish = isRoom || isGroupDm;
 	const channelConfig = isRoom ? resolveSlackChannelConfig({
+		teamId: params.eventScope?.teamId ?? ctx.teamId,
+		allowUnscoped: ctx.installationIdentity?.kind !== "enterprise",
 		channelId: message.channel,
 		channelName,
 		channels: ctx.channelsConfig,
@@ -3545,14 +3921,38 @@ async function authorizeSlackInboundMessage(params) {
 		return null;
 	}
 	if (!ctx.isChannelAllowed({
+		teamId: params.eventScope?.teamId ?? ctx.teamId,
 		channelId: message.channel,
 		channelName,
 		channelType: resolvedChannelType
 	})) {
+		if (conversation.isRoom && ctx.groupPolicy === "allowlist" && params.explicitBotMention && !isBotMessage && message.user) {
+			let subject = "This OpenClaw bot";
+			if (ctx.botUserId) try {
+				const botName = normalizeOptionalString((await ctx.resolveUserName(ctx.botUserId, params.eventScope))?.name);
+				if (botName) subject = escapeSlackMrkdwn(botName);
+			} catch (error) {
+				logVerbose(`slack allowlist denial bot-name lookup failed: ${formatSlackError(error)}`);
+			}
+			try {
+				await (params.eventScope?.client ?? ctx.app.client).chat.postEphemeral({
+					token: ctx.botToken,
+					channel: message.channel,
+					user: message.user,
+					text: `${subject} can’t reply here because this channel isn’t in its OpenClaw channel allowlist. Ask the OpenClaw owner to allow this channel. <${SLACK_CHANNEL_ACCESS_DOCS_URL}|Learn how to configure Slack channel access.>`
+				});
+				params.onVisibleDrop?.();
+			} catch (error) {
+				ctx.runtime.error?.(`slack allowlist denial notice failed for channel ${message.channel}: ${formatSlackError(error)}`);
+			}
+		}
 		logVerbose("slack: drop message (channel not allowed)");
 		return null;
 	}
-	const allowFromLower = await resolveSlackEffectiveAllowFrom(ctx, { includePairingStore: isDirectMessage });
+	const allowFromLower = await resolveSlackEffectiveAllowFrom(ctx, {
+		includePairingStore: isDirectMessage,
+		eventScope: params.eventScope
+	});
 	if (isDirectMessage) {
 		const directUserId = message.user;
 		if (!directUserId) {
@@ -3563,6 +3963,7 @@ async function authorizeSlackInboundMessage(params) {
 			ctx,
 			accountId: account.accountId,
 			senderId: directUserId,
+			eventScope: params.eventScope,
 			allowFromLower,
 			resolveSenderName: (userId) => ctx.resolveUserName(userId, params.eventScope),
 			sendPairingReply: async (text) => {
@@ -3570,7 +3971,8 @@ async function authorizeSlackInboundMessage(params) {
 					cfg: ctx.cfg,
 					token: ctx.botToken,
 					client: params.eventScope?.client ?? ctx.app.client,
-					accountId: account.accountId
+					accountId: account.accountId,
+					eventScope: params.eventScope
 				});
 			},
 			onDisabled: () => {
@@ -3590,10 +3992,10 @@ async function authorizeSlackInboundMessage(params) {
 async function prepareSlackMessage(params) {
 	const { ctx, account, message, opts } = params;
 	const slackClient = opts.eventScope?.client ?? ctx.app.client;
-	const threadStarterWorkspaceScope = opts.eventScope ? {
+	const threadStarterWorkspaceScope = {
 		accountId: account.accountId,
-		teamId: opts.eventScope.teamId
-	} : void 0;
+		teamId: opts.eventScope?.teamId ?? ctx.teamId
+	};
 	const cfg = ctx.cfg;
 	const conversation = await resolveSlackConversationContext({
 		ctx,
@@ -3602,16 +4004,20 @@ async function prepareSlackMessage(params) {
 		eventScope: opts.eventScope
 	});
 	const { channelInfo, channelName, isDirectMessage, isGroupDm, isRoom, isRoomish, channelConfig, allowBotsMode, isBotMessage } = conversation;
+	const messageText = message.text ?? "";
+	const mentionMetadata = collectSlackMentionMetadata(messageText);
+	const normalizedBotUserId = normalizeSlackId(ctx.botUserId);
 	const authorization = await authorizeSlackInboundMessage({
 		ctx,
 		account,
 		message,
 		conversation,
-		eventScope: opts.eventScope
+		explicitBotMention: opts.source === "app_mention" || Boolean(normalizedBotUserId && mentionMetadata.mentionedUserIds.includes(normalizedBotUserId)),
+		eventScope: opts.eventScope,
+		onVisibleDrop: opts.onVisibleDrop
 	});
 	if (!authorization) return null;
 	const { senderId, allowFromLower } = authorization;
-	const messageText = message.text ?? "";
 	let resolvedSenderName = normalizeOptionalString(message.username);
 	const resolveSenderName = async () => {
 		if (resolvedSenderName) return resolvedSenderName;
@@ -3625,7 +4031,6 @@ async function prepareSlackMessage(params) {
 		resolvedSenderName = message.user ?? message.bot_id ?? "unknown";
 		return resolvedSenderName;
 	};
-	const mentionMetadata = collectSlackMentionMetadata(messageText);
 	const { mentionedUserIds, mentionedSubteamIds, hasAnyMention } = mentionMetadata;
 	const messageAssistantThreadContext = resolveSlackMessageAssistantThreadContext(message);
 	const assistantContextLookupChannelId = messageAssistantThreadContext?.assistantChannelId ?? message.channel;
@@ -3688,7 +4093,11 @@ async function prepareSlackMessage(params) {
 	}));
 	const buildPolicyMentionRegexes = (agentId) => resolveCachedMentionRegexes(ctx, agentId, {
 		provider: "slack",
-		conversationId: message.channel,
+		conversationId: formatSlackTarget({
+			teamId: opts.eventScope?.teamId,
+			kind: "channel",
+			id: message.channel
+		}),
 		providerPolicy: account.config.mentionPatterns
 	});
 	let mentionRegexes = buildPolicyMentionRegexes(routing.route.agentId);
@@ -3729,13 +4138,13 @@ async function prepareSlackMessage(params) {
 		name: void 0
 	});
 	let implicitMentionKinds = [];
-	if (!isDirectMessage && ctx.botUserId && message.thread_ts && !wasMentioned) {
-		const replyToBotKinds = implicitMentionKindWhen("reply_to_bot", message.parent_user_id === ctx.botUserId);
+	if (!isDirectMessage && message.thread_ts && !wasMentioned) {
+		const replyToBotKinds = implicitMentionKindWhen("reply_to_bot", Boolean(ctx.botUserId && message.parent_user_id === ctx.botUserId));
 		implicitMentionKinds = replyToBotKinds.length > 0 ? replyToBotKinds : implicitMentionKindWhen("bot_thread_participant", await hasSlackThreadParticipationWithPersistence({
 			accountId: account.accountId,
 			channelId: message.channel,
 			threadTs: message.thread_ts,
-			...opts.eventScope ? { teamId: opts.eventScope.teamId } : {}
+			teamId: opts.eventScope?.teamId
 		}));
 	}
 	const recordDroppedHistory = async (reason) => {
@@ -3843,12 +4252,14 @@ async function prepareSlackMessage(params) {
 	const hasControlCommandInMessage = hasControlCommand(textForCommandDetection, cfg);
 	const hasAbortRequest = isAbortRequestText(textForCommandDetection);
 	const channelUsersAllowlistConfigured = isRoom && Array.isArray(channelConfig?.users) && channelConfig.users.length > 0;
-	const messageIngress = await resolveSlackCommandIngress({
+	const resolveMessageIngress = async (contextBinding, threadId) => await resolveSlackCommandIngress({
 		ctx,
+		teamId: opts.eventScope?.teamId ?? ctx.teamId,
 		senderId,
 		senderName: senderNameForAuth,
 		channelType: conversation.resolvedChannelType ?? "channel",
 		channelId: message.channel,
+		threadId,
 		ownerAllowFromLower: allowFromLower,
 		channelUsers: isRoom ? channelConfig?.users : void 0,
 		allowTextCommands,
@@ -3863,8 +4274,10 @@ async function prepareSlackMessage(params) {
 			requireMention: shouldRequireMention,
 			allowTextCommands,
 			implicitMentions
-		}
+		},
+		contextBinding
 	});
+	let messageIngress = await resolveMessageIngress();
 	const senderGate = messageIngress.senderAccess.gate;
 	if (isRoomish && senderGate?.allowed === false) {
 		logVerbose(`Blocked unauthorized slack sender ${senderId} (not in sender allowlist)`);
@@ -3885,6 +4298,18 @@ async function prepareSlackMessage(params) {
 		channel: "slack",
 		accountId: account.accountId
 	});
+	const preflightChannelTarget = formatSlackTarget({
+		teamId: opts.eventScope?.teamId,
+		kind: "channel",
+		id: message.channel,
+		explicitKind: true
+	});
+	const replyRouteTarget = formatSlackTarget({
+		teamId: opts.eventScope?.teamId,
+		kind: isDirectMessage ? "user" : "channel",
+		id: isDirectMessage ? senderId : message.channel,
+		explicitKind: true
+	});
 	const commandAuthorized = messageIngress.commandAccess.authorized;
 	if (isRoomish && messageIngress.commandAccess.shouldBlockControlCommand) {
 		logInboundDrop({
@@ -3931,7 +4356,7 @@ async function prepareSlackMessage(params) {
 			media: preflightMedia,
 			cfg,
 			accountId: account.accountId,
-			originatingTo: `channel:${message.channel}`,
+			originatingTo: preflightChannelTarget,
 			sessionKey: preflightRouting.sessionKey,
 			messageThreadId: preflightRouting.threadContext.messageThreadId
 		}) : null;
@@ -4076,14 +4501,23 @@ async function prepareSlackMessage(params) {
 		return false;
 	}) : statusReactionsWillHandle ? Promise.resolve(true) : null;
 	const roomLabel = channelName ? `#${channelName}` : `#${message.channel}`;
+	const workspaceId = opts.eventScope?.teamId || ctx.teamId;
+	const workspaceName = ctx.installationIdentity?.kind === "workspace" && ctx.installationIdentity.teamId === workspaceId ? ctx.installationIdentity.teamName : void 0;
+	const groupSessionSubject = isRoomish ? resolveSlackGroupSessionSubject({
+		channelId: message.channel,
+		channelName,
+		workspaceId,
+		workspaceName
+	}) : void 0;
 	const senderName = await resolveSenderName();
+	const conversationAvatar = isDirectMessage && message.user ? ctx.resolveUserAvatar(message.user, opts.eventScope) : void 0;
 	const preview = truncateUtf16Safe(bodyForAgent.replace(/\s+/g, " "), 160);
 	const inboundLabel = isDirectMessage ? `Slack DM from ${senderName}` : `Slack message in ${roomLabel} from ${senderName}`;
 	const slackFrom = isDirectMessage ? `slack:${message.user}` : isRoom ? `slack:channel:${message.channel}` : `slack:group:${message.channel}`;
-	enqueueSystemEvent(inboundLabel, {
-		sessionKey,
-		contextKey: `slack:message:${message.channel}:${message.ts ?? "unknown"}`
-	});
+	enqueueRoutedSystemEvent(inboundLabel, {
+		...route,
+		sessionKey
+	}, { contextKey: `slack:message:${message.channel}:${message.ts ?? "unknown"}` });
 	const envelopeFrom = resolveConversationLabel$1({
 		ChatType: chatType,
 		SenderName: senderName,
@@ -4147,7 +4581,6 @@ async function prepareSlackMessage(params) {
 			envelope: envelopeOptions
 		})
 	});
-	const slackTo = isDirectMessage ? `user:${message.user}` : `channel:${message.channel}`;
 	const { channelMetadata, groupSystemPrompt } = resolveSlackRoomContextHints({
 		isRoomish,
 		channelInfo,
@@ -4155,8 +4588,10 @@ async function prepareSlackMessage(params) {
 	});
 	const { threadStarterBody, threadHistoryBody, shouldSeedInitialThreadContext, threadLabel, threadStarterMedia } = await resolveSlackThreadContextData({
 		ctx,
+		agentId: route.agentId,
 		account,
 		message,
+		isGroupDm,
 		isThreadReply,
 		threadTs,
 		threadStarter,
@@ -4180,8 +4615,20 @@ async function prepareSlackMessage(params) {
 	const commandBody = textForCommandDetection.trim();
 	const supplementalThreadHistoryBody = directThreadRoutedToDmSession && !threadHistoryBody ? threadStarterBody : threadHistoryBody;
 	const effectiveMessageThreadId = assistantThreadContext?.threadTs ?? agentViewThreadTs ?? threadContext.messageThreadId;
+	const boundMessageThreadId = directThreadRoutedToDmSession ? void 0 : effectiveMessageThreadId;
+	messageIngress = await resolveMessageIngress({
+		agentId: route.agentId,
+		sessionKey,
+		messageId: threadContext.messageTs,
+		inboundEventKind
+	}, boundMessageThreadId);
+	if (messageIngress.ingress.admission !== "dispatch") {
+		logVerbose(`Blocked slack sender ${senderId} after final route binding`);
+		return null;
+	}
 	const agentContextEntities = isAgentViewMessage ? normalizeSlackAppContextEntities(message.app_context) : [];
-	const ctxPayload = buildChannelInboundEventContext({
+	const ctxPayload = (ctx.buildContext ?? buildChannelInboundEventContext)({
+		channelIngress: messageIngress,
 		channel: "slack",
 		accountId: route.accountId,
 		messageId: threadContext.messageTs,
@@ -4196,22 +4643,32 @@ async function prepareSlackMessage(params) {
 		conversation: {
 			kind: chatType,
 			id: message.channel,
+			routePeer: {
+				kind: chatType,
+				id: qualifySlackRoutePeerId({
+					id: isDirectMessage ? message.user ?? "unknown" : message.channel,
+					kind: isDirectMessage ? "user" : "channel",
+					eventScope: opts.eventScope
+				})
+			},
 			label: envelopeFrom,
 			spaceId: opts.eventScope?.teamId || ctx.teamId || void 0,
-			threadId: directThreadRoutedToDmSession ? void 0 : effectiveMessageThreadId,
-			nativeChannelId: message.channel
+			threadId: boundMessageThreadId,
+			nativeChannelId: message.channel,
+			avatar: conversationAvatar
 		},
 		route: {
 			agentId: route.agentId,
 			dmScope: route.dmScope,
 			accountId: route.accountId,
-			routeSessionKey: sessionKey,
+			routeSessionKey: route.sessionKey,
+			dispatchSessionKey: sessionKey,
 			parentSessionKey: threadKeys.parentSessionKey
 		},
 		reply: {
-			to: slackTo,
+			to: replyRouteTarget,
 			replyToId: threadContext.replyToId,
-			messageThreadId: directThreadRoutedToDmSession ? void 0 : effectiveMessageThreadId,
+			messageThreadId: boundMessageThreadId,
 			nativeChannelId: message.channel
 		},
 		message: {
@@ -4244,7 +4701,7 @@ async function prepareSlackMessage(params) {
 			groupSystemPrompt
 		},
 		extra: {
-			GroupSubject: isRoomish ? roomLabel : void 0,
+			GroupSubject: groupSessionSubject,
 			ChannelPromptContext: channelMetadata ? [channelMetadata] : void 0,
 			ChannelStructuredContext: agentContextEntities.length > 0 ? [{
 				label: "Slack active context",
@@ -4284,16 +4741,16 @@ async function prepareSlackMessage(params) {
 	});
 	const pinnedMainDmOwner = isDirectMessage ? resolvePinnedMainDmOwnerFromAllowlist({
 		dmScope: cfg.session?.dmScope,
-		allowFrom: ctx.allowFrom,
+		allowFrom: allowFromLower,
 		normalizeEntry: normalizeSlackAllowOwnerEntry
 	}) : null;
-	const replyTarget = isDirectMessage ? `channel:${message.channel}` : ctxPayload.To ?? void 0;
+	const replyTarget = `channel:${message.channel}`;
 	if (!replyTarget) return null;
 	if (preflightAudioTranscript) await sendSlackPreflightAudioTranscriptEcho({
 		transcript: preflightAudioTranscript,
 		cfg,
 		accountId: account.accountId,
-		originatingTo: `channel:${message.channel}`,
+		originatingTo: preflightChannelTarget,
 		messageThreadId: threadContext.messageThreadId
 	});
 	if (shouldLogVerbose()) logVerbose(`slack inbound: account=${route.accountId} agent=${route.agentId} channel=${message.channel} message_ts=${message.ts ?? "unknown"} thread_ts=${effectiveMessageThreadId ?? "none"} from=${slackFrom} chat=${chatType} chars=${rawBody.length}`);
@@ -4306,7 +4763,7 @@ async function prepareSlackMessage(params) {
 		account,
 		message,
 		...opts.relayIdentity ? { relayIdentity: opts.relayIdentity } : {},
-		...opts.eventScope ? { eventScope: opts.eventScope } : {},
+		eventScope: opts.eventScope,
 		route,
 		channelConfig,
 		replyTarget,
@@ -4314,13 +4771,13 @@ async function prepareSlackMessage(params) {
 		turn: {
 			storePath,
 			record: {
-				updateLastRoute: isDirectMessage ? {
+				updateLastRoute: isDirectMessage || opts.eventScope ? {
 					sessionKey: updateLastRouteSessionKey,
 					channel: "slack",
-					to: `user:${message.user}`,
+					to: replyRouteTarget,
 					accountId: route.accountId,
 					threadId: effectiveMessageThreadId,
-					mainDmOwnerPin: updateLastRouteSessionKey === route.mainSessionKey && pinnedMainDmOwner && message.user ? {
+					mainDmOwnerPin: isDirectMessage && updateLastRouteSessionKey === route.mainSessionKey && pinnedMainDmOwner && message.user ? {
 						ownerRecipient: pinnedMainDmOwner,
 						senderRecipient: normalizeLowercaseStringOrEmpty(message.user),
 						onSkip: ({ ownerRecipient, senderRecipient }) => {