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

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

@@ -1,2082 +1,2235 @@
-import { u as resolveSlackReplyToMode } from "./accounts-DQEbYKh9.js";
+import { t as resolveSlackReplyToMode } from "./account-reply-mode-DrUXogvO.js";
 import { i as parseSlackTarget } from "./target-parsing-N6lHogYZ.js";
 import "./targets-KmjP2E8s.js";
-import { C as hasSlackNativeDataBlock, F as SLACK_TEXT_LIMIT, N as SLACK_EDIT_TEXT_LIMIT, O as normalizeSlackOutboundText, Y as escapeSlackMrkdwn, _ as resolveSlackReplyRenderPlan, c as normalizeSlackAllowOwnerEntry, k as buildSlackBlocksFallbackText, s as normalizeAllowListLower, u as resolveSlackAllowListMatch, z as truncateSlackText } from "./group-policy-Bw-65m3V.js";
-import { n as isSlackInteractiveRepliesEnabled, t as compileSlackInteractiveReplies } from "./interactive-replies-Dm_t2R9S.js";
-import { r as formatSlackError } from "./probe-Borhn9PQ.js";
+import { A as normalizeSlackOutboundText, C as hasSlackNativeDataBlock, F as SLACK_EDIT_TEXT_LIMIT, L as SLACK_TEXT_LIMIT, V as truncateSlackText, Z as escapeSlackMrkdwn, _ as resolveSlackReplyRenderPlan, c as normalizeSlackAllowOwnerEntry, j as buildSlackBlocksFallbackText, s as normalizeAllowListLower, u as resolveSlackAllowListMatch } from "./group-policy-CthIXE2T.js";
+import { r as formatSlackError } from "./probe-BhQTDVBQ.js";
 import { n as resolveSlackNativeStreaming, r as resolveSlackStreamingMode, t as mapStreamingModeToSlackLegacyDraftStreamMode } from "./streaming-compat-3_X-21wW.js";
-import { S as buildSlackEditTextPayload, _ as resolveSlackThreadHistory, b as resolveSlackBlocksText, f as removeSlackReaction, l as reactSlackMessage, r as editSlackMessage, t as deleteSlackMessage, v as resolveSlackThreadStarter, x as formatSlackFileReference, y as chooseSlackPrimaryText } from "./actions-CF0tUY5q.js";
-import { c as hasSlackThreadParticipationWithPersistence, l as recordSlackThreadParticipation, r as sendMessageSlack, u as buildSlackNativeDataDeliveryPlan } from "./send-KuTDky7i.js";
-import { C as stripSlackMentionsForCommandDetection, _ as readSessionUpdatedAt, b as resolveStorePath, d as resolveSlackCommandIngress, f as resolveSlackEffectiveAllowFrom, g as resolveSlackChatType, h as normalizeSlackChannelType, l as resolveConversationLabel$1, m as parseSlackAssistantThreadMetadata, o as authorizeSlackDirectMessage, p as buildSlackAssistantThreadMetadata, r as resolveSlackRoomContextHints, u as authorizeSlackBotRoomMessage, v as resolveChannelContextVisibilityMode, x as updateLastRoute, y as resolveChannelResetConfig } from "./provider-B-HVL5ZE.js";
-import { n as resolveSlackChannelConfig } from "./policy-b_dOPDCq.js";
-import { a as resolveDeliveredSlackReplyThreadTs, i as readSlackReplyBlocks, n as deliverReplies, o as resolveSlackThreadTs, s as emitSlackMessageSentHooks, t as createSlackReplyDeliveryPlan } from "./replies-B4bOdrYb.js";
+import { S as buildSlackEditTextPayload, _ as resolveSlackThreadHistory, b as resolveSlackBlocksText, f as removeSlackReaction, l as reactSlackMessage, r as editSlackMessage, t as deleteSlackMessage, v as resolveSlackThreadStarter, x as formatSlackFileReference, y as chooseSlackPrimaryText } from "./actions-BkOaiDSX.js";
+import { c as hasSlackThreadParticipationWithPersistence, l as recordSlackThreadParticipation, r as sendMessageSlack, u as buildSlackNativeDataDeliveryPlan } from "./send-2IoDXPeB.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-PSppCU_K.js";
+import { n as resolveSlackChannelConfig } from "./policy-DVg6FyMP.js";
+import { a as resolveDeliveredSlackReplyThreadTs, i as readSlackReplyBlocks, n as deliverReplies, o as resolveSlackThreadTs, s as emitSlackMessageSentHooks, t as createSlackReplyDeliveryPlan } from "./replies-BkPPM2Ri.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 { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
-import { danger, logVerbose, shouldLogVerbose, sleep } from "openclaw/plugin-sdk/runtime-env";
+import { danger, logVerbose, shouldLogVerbose } from "openclaw/plugin-sdk/runtime-env";
 import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import { createHash } from "node:crypto";
 import fs from "node:fs/promises";
-import { formatErrorMessage } from "openclaw/plugin-sdk/error-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 { filterSupplementalContextItems, resolvePinnedMainDmOwnerFromAllowlist, shouldIncludeSupplementalContext } from "openclaw/plugin-sdk/security-runtime";
 import { ensureConfiguredBindingRouteReady, resolveConfiguredBindingRoute, resolveRuntimeConversationBindingRoute } from "openclaw/plugin-sdk/conversation-runtime";
 import { createChannelHistoryWindow } from "openclaw/plugin-sdk/reply-history";
-import { resolveHumanDelayConfig } from "openclaw/plugin-sdk/agent-runtime";
+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 { resolveChannelImplicitMentions } from "openclaw/plugin-sdk/channel-ingress-runtime";
 import { buildChannelInboundEventContext, buildMentionRegexes, classifyChannelInboundEvent, dispatchChannelInboundTurn, formatInboundEnvelope, hasVisibleInboundReplyDispatch, implicitMentionKindWhen, logInboundDrop, matchesMentionWithExplicit, recordDroppedChannelInboundHistory, resolveEnvelopeFormatOptions, resolveInboundMentionDecision, resolveInboundSupplementalSenderAllowed, resolveUnmentionedGroupInboundPolicy, toInboundMediaFacts } from "openclaw/plugin-sdk/channel-inbound";
-import { DEFAULT_TIMING, createStatusReactionController, logAckFailure, logTypingFailure, removeAckReactionAfterReply, resolveAckReaction, shouldAckReaction } from "openclaw/plugin-sdk/channel-feedback";
+import { 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";
-//#region extensions/slack/src/draft-stream.ts
-const DEFAULT_THROTTLE_MS = 1e3;
-function createSlackDraftStream(params) {
-	const maxChars = Math.min(params.maxChars ?? 8e3, SLACK_TEXT_LIMIT);
-	const throttleMs = Math.max(250, params.throttleMs ?? DEFAULT_THROTTLE_MS);
-	const send = params.send ?? sendMessageSlack;
-	const edit = params.edit ?? editSlackMessage;
-	const remove = params.remove ?? deleteSlackMessage;
-	let streamMessageId;
-	let streamChannelId;
-	let lastSentKey = "";
-	let pendingUpdate;
-	let stopped = false;
-	const normalizeUpdate = (update) => typeof update === "string" ? { text: update } : update;
-	const sendOrEditStreamMessage = async (text) => {
-		if (stopped) return;
-		const trimmed = text.trimEnd();
-		if (!trimmed) return;
-		if (trimmed.length > maxChars) {
-			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 sentKey = `${trimmed}\n${blocks ? JSON.stringify(blocks) : ""}`;
-		if (sentKey === lastSentKey) return;
-		lastSentKey = sentKey;
-		try {
-			if (streamChannelId && streamMessageId) {
-				await edit(streamChannelId, streamMessageId, trimmed, {
-					cfg: params.cfg,
-					token: params.token,
-					accountId: params.accountId,
-					...params.eventScope ? { client: params.eventScope.client } : {},
-					...blocks ? { blocks } : {}
-				});
-				return;
-			}
-			const sent = await send(params.target, trimmed, {
-				cfg: params.cfg,
-				token: params.token,
-				accountId: params.accountId,
-				threadTs: params.resolveThreadTs?.(),
-				identity: params.identity,
-				...params.eventScope ? {
-					client: params.eventScope.client,
-					enterpriseEventScope: params.eventScope
-				} : {},
-				...params.metadata ? { metadata: params.metadata } : {},
-				...blocks ? { blocks } : {}
-			});
-			streamChannelId = sent.channelId || streamChannelId;
-			streamMessageId = sent.messageId || streamMessageId;
-			if (!streamChannelId || !streamMessageId) {
-				stopped = true;
-				params.warn?.("slack stream preview stopped (missing identifiers from sendMessage)");
-				return;
-			}
-			params.onMessageSent?.();
-		} catch (err) {
-			stopped = true;
-			params.warn?.(`slack stream preview failed: ${formatSlackError(err)}`);
-		}
-	};
-	const loop = createDraftStreamLoop({
-		throttleMs,
-		isStopped: () => stopped,
-		sendOrEditStreamMessage
+//#region extensions/slack/src/streaming.ts
+/**
+* Thrown when Slack definitively rejects a stream flush/finalize while text
+* remains buffered locally by the Slack SDK. Carries the pending text so the
+* caller can deliver it via the normal Slack reply path.
+*/
+var SlackStreamNotDeliveredError = class extends Error {
+	constructor(pendingText, slackCode) {
+		super(`slack-stream: finalize failed with ${slackCode} before buffered text reached Slack (${pendingText.length} chars pending)`);
+		this.name = "SlackStreamNotDeliveredError";
+		this.pendingText = pendingText;
+		this.slackCode = slackCode;
+	}
+};
+/**
+* Start a new Slack text stream.
+*
+* Returns a {@link SlackStreamSession} that should be passed to
+* {@link appendSlackStream} and {@link stopSlackStream}.
+*
+* The first chunk of text can optionally be included via `text`.
+*/
+async function startSlackStream(params) {
+	const { client, channel, threadTs, text, chunks, taskDisplayMode, teamId, userId, identity } = params;
+	const identityPayload = identity?.iconUrl ? {
+		...identity.username ? { username: identity.username } : {},
+		icon_url: identity.iconUrl
+	} : identity?.iconEmoji ? {
+		...identity.username ? { username: identity.username } : {},
+		icon_emoji: identity.iconEmoji
+	} : identity?.username ? { username: identity.username } : {};
+	logVerbose(`slack-stream: starting stream in ${channel} thread=${threadTs}${teamId ? ` team=${teamId}` : ""}${userId ? ` user=${userId}` : ""}`);
+	const streamer = client.chatStream({
+		channel,
+		thread_ts: threadTs,
+		...taskDisplayMode ? { task_display_mode: taskDisplayMode } : {},
+		...teamId ? { recipient_team_id: teamId } : {},
+		...userId ? { recipient_user_id: userId } : {},
+		...identityPayload
 	});
-	const stop = () => {
-		stopped = true;
-		loop.stop();
-	};
-	const discardPending = async () => {
-		stop();
-		await loop.waitForInFlight();
+	const session = {
+		streamer,
+		channel,
+		threadTs,
+		stopped: false,
+		delivered: false,
+		pendingText: ""
 	};
-	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;
+	if (text || chunks?.length) {
+		if (text) session.pendingText += text;
 		try {
-			await remove(channelId, messageId, {
-				token: params.token,
-				accountId: params.accountId,
-				...params.eventScope ? { client: params.eventScope.client } : {}
+			const result = await streamer.append({
+				...text ? { markdown_text: text } : {},
+				...chunks?.length ? { chunks } : {}
 			});
+			if (result) {
+				session.delivered = true;
+				session.pendingText = "";
+			}
+			logVerbose(`slack-stream: appended initial payload (${text?.length ?? 0} chars, ${chunks?.length ?? 0} chunks, ${result ? "flushed" : "buffered"})`);
 		} catch (err) {
-			params.warn?.(`slack stream preview cleanup failed: ${formatSlackError(err)}`);
+			if (isBenignSlackFinalizeError(err) && session.pendingText) throw new SlackStreamNotDeliveredError(session.pendingText, extractSlackErrorCode(err) ?? "unknown");
+			throw err;
 		}
-	};
-	const forceNewMessage = () => {
-		streamMessageId = void 0;
-		streamChannelId = void 0;
-		lastSentKey = "";
-		pendingUpdate = void 0;
-		loop.resetPending();
-	};
-	params.log?.(`slack stream preview ready (maxChars=${maxChars}, throttleMs=${throttleMs})`);
-	return {
-		update: (update) => {
-			const normalized = normalizeUpdate(update);
-			pendingUpdate = update;
-			loop.update(normalized.text);
-		},
-		flush: loop.flush,
-		clear,
-		discardPending,
-		seal: discardPending,
-		stop,
-		forceNewMessage,
-		messageId: () => streamMessageId,
-		channelId: () => streamChannelId
-	};
-}
-//#endregion
-//#region extensions/slack/src/progress-blocks.ts
-const SLACK_PROGRESS_FIELD_MAX = 1800;
-const DEFAULT_SLACK_PROGRESS_DETAIL_MAX_CHARS = 120;
-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";
-function field(text) {
-	return {
-		type: "mrkdwn",
-		text: truncateSlackText(text, SLACK_PROGRESS_FIELD_MAX)
-	};
-}
-function resolveMaxLineChars(value, fallback) {
-	return value && value > 0 ? Math.floor(value) : fallback;
-}
-function compactDetail(value, maxChars) {
-	const normalized = value.replace(/\s+/g, " ").trim();
-	const chars = Array.from(normalized);
-	if (chars.length <= maxChars) return normalized;
-	if (maxChars <= 1) return "…";
-	const keepStart = Math.max(1, Math.ceil((maxChars - 1) * .45));
-	const keepEnd = Math.max(1, maxChars - keepStart - 1);
-	return `${chars.slice(0, keepStart).join("").trimEnd()}…${chars.slice(-keepEnd).join("").trimStart()}`;
-}
-function compactTitle(value) {
-	return truncateSlackText(value.replace(/\s+/g, " ").trim(), SLACK_PROGRESS_TASK_TITLE_MAX);
-}
-function compactChunkText(value) {
-	return truncateSlackText(value.replace(/\s+/g, " ").trim(), SLACK_PROGRESS_CHUNK_TEXT_MAX);
-}
-function lineDetailParts(line) {
-	return [line.detail, line.status && line.status !== "completed" && !line.detail?.includes(line.status) ? line.status : void 0].map((part) => part?.trim()).filter((part) => Boolean(part));
-}
-function legacyLineTitle(line) {
-	return `${line.icon ?? "•"} *${escapeSlackMrkdwn(line.label)}*`;
-}
-function legacyLineDetail(line, maxChars) {
-	const detail = lineDetailParts(line).join(" · ");
-	return detail ? escapeSlackMrkdwn(compactDetail(detail, maxChars)) : "—";
-}
-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();
-	const fallback = line.text.replace(/\s+/g, " ").trim();
-	if (detail) return compactTitle(`${label} — ${compactDetail(detail, maxLineChars)}`);
-	if (fallback && fallback !== label) return compactTitle(fallback);
-	return compactTitle(label);
+	}
+	return session;
 }
-function lineTaskStatus(line) {
-	const normalized = line.status?.replace(/\s+/g, " ").trim().toLowerCase();
-	if (!normalized) return "in_progress";
-	if (normalized === "complete" || normalized === "completed" || normalized === "done" || normalized === "ok" || normalized === "success" || normalized === "succeeded" || normalized === "successful" || normalized === "exit 0") return "complete";
-	if (normalized === "error" || normalized === "failed" || normalized === "failure" || normalized.startsWith("exit ")) return normalized === "exit 0" ? "complete" : "error";
-	return "in_progress";
+/**
+* Append markdown text to an active Slack stream.
+*/
+async function appendSlackStream(params) {
+	const { session, text, chunks } = params;
+	if (session.stopped) {
+		logVerbose("slack-stream: attempted to append to a stopped stream, ignoring");
+		return;
+	}
+	if (!text && !chunks?.length) return;
+	if (text) session.pendingText += text;
+	try {
+		const result = await session.streamer.append({
+			...text ? { markdown_text: text } : {},
+			...chunks?.length ? { chunks } : {}
+		});
+		if (result) {
+			session.delivered = true;
+			session.pendingText = "";
+		}
+		logVerbose(`slack-stream: appended ${text?.length ?? 0} chars, ${chunks?.length ?? 0} chunks (${result ? "flushed" : "buffered"})`);
+	} catch (err) {
+		if (isBenignSlackFinalizeError(err) && session.pendingText) throw new SlackStreamNotDeliveredError(session.pendingText, extractSlackErrorCode(err) ?? "unknown");
+		throw err;
+	}
 }
-function slugTaskIdPart(value) {
-	return value?.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "") || "task";
-}
-function stableTaskIdPart(value, slugValue = value) {
-	const suffix = createHash("sha256").update(value).digest("hex").slice(0, 8);
-	return `${slugTaskIdPart(slugValue).slice(0, 48)}_${suffix}`;
-}
-function resolveLineTaskIdentity(line) {
-	if (line.id?.trim()) return {
-		id: stableTaskIdPart(line.id),
-		contentDerived: false
-	};
-	return {
-		id: stableTaskIdPart([
-			line.kind,
-			line.toolName,
-			line.label,
-			line.text
-		].join("\0"), line.toolName ?? line.kind ?? line.label),
-		contentDerived: true
-	};
-}
-function buildPlanTasks(params) {
-	if (params.plan) return params.plan.slice(-50).map((entry, index) => ({
-		id: `plan_step_${index + 1}`,
-		title: compactTitle(entry.step),
-		status: entry.status === "completed" ? "complete" : entry.status
-	}));
-	const maxLineChars = resolveMaxLineChars(params.maxLineChars, DEFAULT_SLACK_PROGRESS_TASK_DETAIL_MAX_CHARS);
-	const lines = params.lines.slice(-50);
-	const identities = lines.map(resolveLineTaskIdentity);
-	const contentIdOccurrences = /* @__PURE__ */ new Map();
-	return lines.map((line, index) => {
-		const identity = identities[index];
-		let id = identity.id;
-		if (identity.contentDerived) {
-			const occurrence = (contentIdOccurrences.get(id) ?? 0) + 1;
-			contentIdOccurrences.set(id, occurrence);
-			id = `${id}_${occurrence}`;
+/**
+* Stop (finalize) a Slack stream.
+*
+* After calling this the stream message becomes a normal Slack message.
+* Optionally include final text 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
+* {@link SlackStreamNotDeliveredError} carrying that pending text so the caller
+* can deliver it through the normal Slack reply path. Ambiguous failures
+* propagate unchanged because Slack may have committed the request.
+*
+* If Slack responds with a known benign finalize error (see
+* {@link BENIGN_SLACK_FINALIZE_ERROR_CODES}) after prior `append` calls already
+* landed, the error is swallowed and the session is marked stopped - the
+* already-delivered text stays visible.
+*
+* Errors without buffered text propagate unchanged.
+*
+* On success, returns the finalized message's Slack `ts` (when reported) so the
+* caller can emit the `message_sent` hook with a populated `messageId`.
+*/
+async function stopSlackStream(params) {
+	const { session, text, 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)` : ""}`);
+	try {
+		const stopResponse = await session.streamer.stop(text || chunks?.length || metadata ? {
+			...text ? { markdown_text: text } : {},
+			...chunks?.length ? { chunks } : {},
+			...metadata ? { metadata } : {}
+		} : void 0);
+		session.delivered = true;
+		session.pendingText = "";
+		logVerbose("slack-stream: stream stopped");
+		const messageId = stopResponse?.ts ?? stopResponse?.message?.ts;
+		return messageId ? { messageId } : {};
+	} catch (err) {
+		const code = extractSlackErrorCode(err) ?? "unknown";
+		const benignFinalizeError = isBenignSlackFinalizeError(err);
+		if (session.pendingText && (benignFinalizeError || code === "missing_scope")) throw new SlackStreamNotDeliveredError(session.pendingText, code);
+		if (benignFinalizeError) {
+			if (session.delivered) {
+				logVerbose(`slack-stream: finalize rejected by Slack (${code}); prior appends delivered, treating stream as stopped`);
+				return {};
+			}
 		}
-		return {
-			id,
-			title: lineTaskTitle(line, maxLineChars),
-			status: lineTaskStatus(line)
-		};
-	});
-}
-function resolvePlanTitle(params) {
-	return compactChunkText(params.title?.trim() || params.label?.trim() || params.tasks.at(-1)?.title || SLACK_PROGRESS_PLAN_FALLBACK_TITLE);
-}
-function buildSlackProgressStreamChunks(params) {
-	const tasks = buildPlanTasks({
-		lines: params.lines,
-		plan: params.plan,
-		maxLineChars: params.maxLineChars
-	});
-	if (tasks.length === 0) {
-		const title = params.title?.trim() || params.label?.trim();
-		return title ? [{
-			type: "plan_update",
-			title: compactChunkText(title)
-		}] : void 0;
+		throw err;
 	}
-	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();
-	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 ? [{
-			type: "section",
-			text: field(`*${escapeSlackMrkdwn(label)}*`)
-		}] : [],
-		...narration ? [{
-			type: "section",
-			text: field(`_${escapeSlackMrkdwn(narration)}_`)
-		}] : [],
-		...planLines.length > 0 ? [{
-			type: "section",
-			text: field(planLines.map((line) => escapeSlackMrkdwn(line)).join("\n"))
-		}] : []
-	].slice(0, 50);
-	const lineBudget = Math.max(0, 50 - headBlocks.length);
-	const renderedBlocks = [...headBlocks, ...params.lines.slice(-lineBudget).map((line) => ({
-		type: "section",
-		fields: [field(legacyLineTitle(line)), field(legacyLineDetail(line, maxLineChars))]
-	}))];
-	return renderedBlocks.length ? renderedBlocks : void 0;
 }
 /**
-* Slack native streams key task rows by persistent id with no removal chunk.
-* When the task source switches representation (tool lines <-> typed plan) or
-* a snapshot drops ids, previously emitted non-terminal rows must receive a
-* final update or they linger in_progress forever.
+* Slack API error codes that indicate `chat.stopStream` (or the
+* `chat.startStream` call the SDK issues inside `stop()` when the buffer
+* never flushed) cannot finalize the stream for the current recipient or
+* team. Either the caller falls back to a normal message (see
+* {@link SlackStreamNotDeliveredError}) or, if prior appends already
+* delivered text, the error is logged verbosely and swallowed.
 */
-function reconcileSlackNativeTaskChunks(params) {
-	const nextTasks = /* @__PURE__ */ new Map();
-	for (const chunk of params.chunks ?? []) if (chunk.type === "task_update") nextTasks.set(chunk.id, {
-		title: chunk.title,
-		status: chunk.status
-	});
-	const terminalized = [...params.previousTasks].filter(([id, task]) => !nextTasks.has(id) && task.status !== "complete" && task.status !== "error").map(([id, task]) => {
-		const entry = {
-			title: task.title,
-			status: "complete"
-		};
-		nextTasks.set(id, entry);
-		return {
-			type: "task_update",
-			id,
-			title: task.title,
-			status: "complete"
-		};
-	});
-	for (const [id, task] of params.previousTasks) if (!nextTasks.has(id)) nextTasks.set(id, task);
-	return {
-		chunks: params.chunks?.length ? [...params.chunks, ...terminalized] : terminalized.length ? terminalized : params.chunks,
-		tasks: nextTasks
-	};
+const BENIGN_SLACK_FINALIZE_ERROR_CODES = /* @__PURE__ */ new Set([
+	"user_not_found",
+	"team_not_found",
+	"missing_recipient_user_id",
+	"method_not_supported_for_channel_type"
+]);
+function isBenignSlackFinalizeError(err) {
+	const code = extractSlackErrorCode(err);
+	return code !== void 0 && BENIGN_SLACK_FINALIZE_ERROR_CODES.has(code);
 }
-function buildSlackProgressStreamStartChunks(params) {
-	return buildSlackProgressStreamChunks(params);
+function extractSlackErrorCode(err) {
+	if (!err || typeof err !== "object") return;
+	const record = err;
+	if (record.data && typeof record.data === "object") {
+		const inner = record.data.error;
+		if (typeof inner === "string") return inner;
+	}
+	return (typeof record.message === "string" ? record.message : "").match(/An API error occurred:\s*([a-z_][a-z0-9_]*)/i)?.[1];
 }
-function buildSlackProgressStreamUpdateChunks(params) {
-	return buildSlackProgressStreamChunks(params);
+function markSlackStreamFallbackDelivered(session) {
+	const nativeStreamWasStarted = session.delivered;
+	session.pendingText = "";
+	session.streamer.buffer = "";
+	session.stopped = !nativeStreamWasStarted;
 }
-function buildSlackProgressStreamCompletionChunks(params) {
-	return buildSlackProgressStreamChunks({
-		...params,
-		completeInProgress: true
+//#endregion
+//#region extensions/slack/src/monitor/message-handler/timestamp.ts
+const SLACK_TIMESTAMP_RE = /^\d+(?:\.\d+)?$/;
+const MAX_SAFE_SLACK_TIMESTAMP_SECONDS = Number.MAX_SAFE_INTEGER / 1e3;
+function resolveSlackTimestampMs(ts) {
+	const trimmed = ts?.trim();
+	if (!trimmed || !SLACK_TIMESTAMP_RE.test(trimmed)) return;
+	const seconds = asFiniteNumberInRange(parseStrictFiniteNumber(trimmed), {
+		min: 0,
+		max: MAX_SAFE_SLACK_TIMESTAMP_SECONDS
 	});
+	return seconds === void 0 ? void 0 : Math.round(seconds * 1e3);
 }
 //#endregion
-//#region extensions/slack/src/stream-mode.ts
-function resolveSlackStreamingConfig(params) {
-	const mode = resolveSlackStreamingMode(params);
+//#region extensions/slack/src/monitor/message-handler/dispatch-helpers.ts
+function resolveSlackMessageTimestampMs(message) {
+	return resolveSlackTimestampMs(message.event_ts ?? message.ts);
+}
+function resolveSlackBotLoopProtection(prepared) {
+	const senderBotId = prepared.message.bot_id;
+	if (!senderBotId) return;
+	const receiverBotId = prepared.ctx.botId || prepared.ctx.botUserId;
+	if (!receiverBotId || senderBotId === prepared.ctx.botId || prepared.message.user === prepared.ctx.botUserId) return;
 	return {
-		mode,
-		nativeStreaming: resolveSlackNativeStreaming(params),
-		draftMode: mapStreamingModeToSlackLegacyDraftStreamMode(mode)
+		scopeId: prepared.route.accountId,
+		conversationId: prepared.message.channel,
+		senderId: senderBotId,
+		receiverId: receiverBotId,
+		config: mergePairLoopGuardConfig(prepared.account.config.botLoopProtection, prepared.channelConfig?.botLoopProtection),
+		defaultsConfig: prepared.ctx.cfg.channels?.defaults?.botLoopProtection,
+		defaultEnabled: true,
+		nowMs: resolveSlackMessageTimestampMs(prepared.message)
 	};
 }
-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 isSlackStreamingEnabled(params) {
+	if (params.mode === "partial") return params.nativeStreaming;
+	if (params.mode === "progress") return params.nativeStreaming && params.nativeProgressTaskCards === true;
+	return false;
 }
-//#endregion
-//#region extensions/slack/src/streaming.ts
-/**
-* Thrown when Slack definitively rejects a stream flush/finalize while text
-* remains buffered locally by the Slack SDK. Carries the pending text so the
-* caller can deliver it via the normal Slack reply path.
-*/
-var SlackStreamNotDeliveredError = class extends Error {
-	constructor(pendingText, slackCode) {
-		super(`slack-stream: finalize failed with ${slackCode} before buffered text reached Slack (${pendingText.length} chars pending)`);
-		this.name = "SlackStreamNotDeliveredError";
-		this.pendingText = pendingText;
-		this.slackCode = slackCode;
-	}
-};
-/**
-* Start a new Slack text stream.
-*
-* Returns a {@link SlackStreamSession} that should be passed to
-* {@link appendSlackStream} and {@link stopSlackStream}.
-*
-* The first chunk of text can optionally be included via `text`.
-*/
-async function startSlackStream(params) {
-	const { client, channel, threadTs, text, chunks, taskDisplayMode, teamId, userId, identity } = params;
-	const identityPayload = identity?.iconUrl ? {
-		...identity.username ? { username: identity.username } : {},
-		icon_url: identity.iconUrl
-	} : identity?.iconEmoji ? {
-		...identity.username ? { username: identity.username } : {},
-		icon_emoji: identity.iconEmoji
-	} : identity?.username ? { username: identity.username } : {};
-	logVerbose(`slack-stream: starting stream in ${channel} thread=${threadTs}${teamId ? ` team=${teamId}` : ""}${userId ? ` user=${userId}` : ""}`);
-	const streamer = client.chatStream({
-		channel,
-		thread_ts: threadTs,
-		...taskDisplayMode ? { task_display_mode: taskDisplayMode } : {},
-		...teamId ? { recipient_team_id: teamId } : {},
-		...userId ? { recipient_user_id: userId } : {},
-		...identityPayload
+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;
+}
+function resolveExplicitSlackProgressTitle(entry) {
+	const label = resolveChannelProgressDraftConfig(entry).label;
+	if (typeof label !== "string") return;
+	const trimmed = label.trim();
+	return trimmed && trimmed.toLowerCase() !== "auto" ? trimmed : void 0;
+}
+function resolveSlackNativeProgressTaskCards(entry) {
+	const streaming = entry?.streaming;
+	if (!streaming || typeof streaming !== "object" || Array.isArray(streaming)) return false;
+	const progressConfig = streaming.progress;
+	return Boolean(progressConfig) && typeof progressConfig === "object" && !Array.isArray(progressConfig) && progressConfig.nativeTaskCards === true;
+}
+function resolveSlackStreamingThreadHint(params) {
+	return resolveSlackThreadTs({
+		replyToMode: params.replyToMode,
+		incomingThreadTs: params.incomingThreadTs,
+		messageTs: params.messageTs,
+		hasReplied: false,
+		isThreadReply: params.isThreadReply
 	});
-	const session = {
-		streamer,
-		channel,
-		threadTs,
-		stopped: false,
-		delivered: false,
-		pendingText: ""
-	};
-	if (text || chunks?.length) {
-		if (text) session.pendingText += text;
-		try {
-			const result = await streamer.append({
-				...text ? { markdown_text: text } : {},
-				...chunks?.length ? { chunks } : {}
-			});
-			if (result) {
-				session.delivered = true;
-				session.pendingText = "";
-			}
-			logVerbose(`slack-stream: appended initial payload (${text?.length ?? 0} chars, ${chunks?.length ?? 0} chunks, ${result ? "flushed" : "buffered"})`);
-		} catch (err) {
-			if (isBenignSlackFinalizeError(err) && session.pendingText) throw new SlackStreamNotDeliveredError(session.pendingText, extractSlackErrorCode(err) ?? "unknown");
-			throw err;
-		}
+}
+const SLACK_STREAM_RECIPIENT_TEAM_CACHE_MAX = 2e3;
+const slackStreamRecipientTeamCaches = /* @__PURE__ */ new WeakMap();
+function getSlackStreamRecipientTeamCache(client) {
+	const existing = slackStreamRecipientTeamCaches.get(client);
+	if (existing) return existing;
+	const cache = /* @__PURE__ */ new Map();
+	slackStreamRecipientTeamCaches.set(client, cache);
+	return cache;
+}
+function buildSlackEventDeliveryKey(params) {
+	const reply = resolveSendableOutboundReplyParts(params.payload, { text: params.textOverride });
+	const renderPlan = resolveSlackReplyRenderPlan(params.payload, params.textOverride ?? params.payload.text);
+	const plannedBlocks = renderPlan.mode === "single" ? renderPlan.blocks : renderPlan.blockPart?.blocks;
+	const slackBlocks = readSlackReplyBlocks(params.payload) ?? plannedBlocks;
+	const renderedText = renderPlan.mode === "single" ? renderPlan.text : renderPlan.fallbackText;
+	if (!reply.hasContent && !slackBlocks?.length && !renderedText.trim()) return null;
+	return JSON.stringify({
+		kind: params.kind,
+		threadTs: params.threadTs ?? "",
+		replyToId: params.payload.replyToId ?? null,
+		text: renderedText || reply.trimmedText,
+		mediaUrls: reply.mediaUrls,
+		blocks: slackBlocks ?? null
+	});
+}
+function readSlackStreamRecipientTeamCache(params) {
+	if (!params.fallbackTeamId || !params.userId) return;
+	const cacheKey = `${params.fallbackTeamId}:${params.userId}`;
+	const cache = getSlackStreamRecipientTeamCache(params.client);
+	const cached = cache.get(cacheKey);
+	if (!cached) return;
+	cache.delete(cacheKey);
+	cache.set(cacheKey, cached);
+	return cached;
+}
+function rememberSlackStreamRecipientTeam(params) {
+	if (!params.fallbackTeamId || !params.userId) return;
+	const cacheKey = `${params.fallbackTeamId}:${params.userId}`;
+	const cache = getSlackStreamRecipientTeamCache(params.client);
+	if (cache.has(cacheKey)) cache.delete(cacheKey);
+	cache.set(cacheKey, params.teamId);
+	if (cache.size > SLACK_STREAM_RECIPIENT_TEAM_CACHE_MAX) {
+		const oldest = cache.keys().next().value;
+		if (oldest) cache.delete(oldest);
 	}
-	return session;
 }
-/**
-* Append markdown text to an active Slack stream.
-*/
-async function appendSlackStream(params) {
-	const { session, text, chunks } = params;
-	if (session.stopped) {
-		logVerbose("slack-stream: attempted to append to a stopped stream, ignoring");
-		return;
+function createSlackEventDeliveryTracker() {
+	const deliveredKeys = /* @__PURE__ */ new Set();
+	return {
+		hasDelivered(params) {
+			const key = buildSlackEventDeliveryKey(params);
+			return key ? deliveredKeys.has(key) : false;
+		},
+		markDelivered(params) {
+			const key = buildSlackEventDeliveryKey(params);
+			if (key) deliveredKeys.add(key);
+		}
+	};
+}
+function shouldUseStreaming(params) {
+	if (!params.streamingEnabled) return false;
+	if (!params.threadTs) {
+		logVerbose("slack-stream: streaming disabled — no reply thread target available");
+		return false;
 	}
-	if (!text && !chunks?.length) return;
-	if (text) session.pendingText += text;
-	try {
-		const result = await session.streamer.append({
-			...text ? { markdown_text: text } : {},
-			...chunks?.length ? { chunks } : {}
+	return true;
+}
+async function resolveSlackStreamRecipientTeamId(params) {
+	const cachedTeamId = readSlackStreamRecipientTeamCache(params);
+	if (cachedTeamId) return cachedTeamId;
+	if (params.userId) try {
+		const info = await params.client.users.info({
+			token: params.token,
+			user: params.userId
 		});
-		if (result) {
-			session.delivered = true;
-			session.pendingText = "";
+		const teamId = info.user?.team_id ?? info.user?.profile?.team;
+		if (teamId) {
+			rememberSlackStreamRecipientTeam({
+				...params,
+				teamId
+			});
+			return teamId;
 		}
-		logVerbose(`slack-stream: appended ${text?.length ?? 0} chars, ${chunks?.length ?? 0} chunks (${result ? "flushed" : "buffered"})`);
 	} catch (err) {
-		if (isBenignSlackFinalizeError(err) && session.pendingText) throw new SlackStreamNotDeliveredError(session.pendingText, extractSlackErrorCode(err) ?? "unknown");
-		throw err;
+		logVerbose(`slack-stream: users.info team lookup failed (${formatErrorMessage(err)})`);
 	}
+	return params.fallbackTeamId;
 }
-/**
-* Stop (finalize) a Slack stream.
-*
-* After calling this the stream message becomes a normal Slack message.
-* Optionally include final text 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
-* {@link SlackStreamNotDeliveredError} carrying that pending text so the caller
-* can deliver it through the normal Slack reply path. Ambiguous failures
-* propagate unchanged because Slack may have committed the request.
-*
-* If Slack responds with a known benign finalize error (see
-* {@link BENIGN_SLACK_FINALIZE_ERROR_CODES}) after prior `append` calls already
-* landed, the error is swallowed and the session is marked stopped - the
-* already-delivered text stays visible.
-*
-* Errors without buffered text propagate unchanged.
-*
-* On success, returns the finalized message's Slack `ts` (when reported) so the
-* caller can emit the `message_sent` hook with a populated `messageId`.
-*/
-async function stopSlackStream(params) {
-	const { session, text, 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)` : ""}`);
-	try {
-		const stopResponse = await session.streamer.stop(text || chunks?.length || metadata ? {
-			...text ? { markdown_text: text } : {},
-			...chunks?.length ? { chunks } : {},
-			...metadata ? { metadata } : {}
-		} : void 0);
-		session.delivered = true;
-		session.pendingText = "";
-		logVerbose("slack-stream: stream stopped");
-		const messageId = stopResponse?.ts ?? stopResponse?.message?.ts;
-		return messageId ? { messageId } : {};
-	} catch (err) {
-		const code = extractSlackErrorCode(err) ?? "unknown";
-		const benignFinalizeError = isBenignSlackFinalizeError(err);
-		if (session.pendingText && (benignFinalizeError || code === "missing_scope")) throw new SlackStreamNotDeliveredError(session.pendingText, code);
-		if (benignFinalizeError) {
-			if (session.delivered) {
-				logVerbose(`slack-stream: finalize rejected by Slack (${code}); prior appends delivered, treating stream as stopped`);
-				return {};
+//#endregion
+//#region extensions/slack/src/draft-stream.ts
+const DEFAULT_THROTTLE_MS = 1e3;
+function createSlackDraftStream(params) {
+	const maxChars = Math.min(params.maxChars ?? 8e3, SLACK_TEXT_LIMIT);
+	const throttleMs = Math.max(250, params.throttleMs ?? DEFAULT_THROTTLE_MS);
+	const send = params.send ?? sendMessageSlack;
+	const edit = params.edit ?? editSlackMessage;
+	const remove = params.remove ?? deleteSlackMessage;
+	let streamMessageId;
+	let streamChannelId;
+	let lastSentKey = "";
+	let pendingUpdate;
+	let stopped = false;
+	const normalizeUpdate = (update) => typeof update === "string" ? { text: update } : update;
+	const sendOrEditStreamMessage = async (text) => {
+		if (stopped) return;
+		const trimmed = text.trimEnd();
+		if (!trimmed) return;
+		if (trimmed.length > maxChars) {
+			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 sentKey = `${trimmed}\n${blocks ? JSON.stringify(blocks) : ""}`;
+		if (sentKey === lastSentKey) return;
+		lastSentKey = sentKey;
+		try {
+			if (streamChannelId && streamMessageId) {
+				await edit(streamChannelId, streamMessageId, trimmed, {
+					cfg: params.cfg,
+					token: params.token,
+					accountId: params.accountId,
+					...params.eventScope ? { client: params.eventScope.client } : {},
+					...blocks ? { blocks } : {}
+				});
+				return;
+			}
+			const sent = await send(params.target, trimmed, {
+				cfg: params.cfg,
+				token: params.token,
+				accountId: params.accountId,
+				threadTs: params.resolveThreadTs?.(),
+				identity: params.identity,
+				...params.eventScope ? {
+					client: params.eventScope.client,
+					enterpriseEventScope: params.eventScope
+				} : {},
+				...params.metadata ? { metadata: params.metadata } : {},
+				...blocks ? { blocks } : {}
+			});
+			streamChannelId = sent.channelId || streamChannelId;
+			streamMessageId = sent.messageId || streamMessageId;
+			if (!streamChannelId || !streamMessageId) {
+				stopped = true;
+				params.warn?.("slack stream preview stopped (missing identifiers from sendMessage)");
+				return;
 			}
+			params.onMessageSent?.();
+		} catch (err) {
+			stopped = true;
+			params.warn?.(`slack stream preview failed: ${formatSlackError(err)}`);
 		}
-		throw err;
-	}
-}
-/**
-* Slack API error codes that indicate `chat.stopStream` (or the
-* `chat.startStream` call the SDK issues inside `stop()` when the buffer
-* never flushed) cannot finalize the stream for the current recipient or
-* team. Either the caller falls back to a normal message (see
-* {@link SlackStreamNotDeliveredError}) or, if prior appends already
-* delivered text, the error is logged verbosely and swallowed.
-*/
-const BENIGN_SLACK_FINALIZE_ERROR_CODES = /* @__PURE__ */ new Set([
-	"user_not_found",
-	"team_not_found",
-	"missing_recipient_user_id",
-	"method_not_supported_for_channel_type"
-]);
-function isBenignSlackFinalizeError(err) {
-	const code = extractSlackErrorCode(err);
-	return code !== void 0 && BENIGN_SLACK_FINALIZE_ERROR_CODES.has(code);
-}
-function extractSlackErrorCode(err) {
-	if (!err || typeof err !== "object") return;
-	const record = err;
-	if (record.data && typeof record.data === "object") {
-		const inner = record.data.error;
-		if (typeof inner === "string") return inner;
-	}
-	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;
-	session.pendingText = "";
-	session.streamer.buffer = "";
-	session.stopped = !nativeStreamWasStarted;
-}
-//#endregion
-//#region extensions/slack/src/threading.ts
-function resolveSlackThreadContext(params) {
-	const incomingThreadTs = params.message.thread_ts;
-	const eventTs = params.message.event_ts;
-	const messageTs = params.message.ts ?? eventTs;
-	const hasThreadTs = typeof incomingThreadTs === "string" && incomingThreadTs.length > 0;
-	const isThreadReply = hasThreadTs && (incomingThreadTs !== messageTs || Boolean(params.message.parent_user_id));
-	const replyToId = isThreadReply ? incomingThreadTs : void 0;
-	const isAssistantDmThreadRoot = hasThreadTs && !isThreadReply && params.isDirectMessage === true;
+	};
+	const loop = createDraftStreamLoop({
+		throttleMs,
+		isStopped: () => stopped,
+		sendOrEditStreamMessage
+	});
+	const stop = () => {
+		stopped = true;
+		loop.stop();
+	};
+	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;
+		try {
+			await remove(channelId, messageId, {
+				token: params.token,
+				accountId: params.accountId,
+				...params.eventScope ? { client: params.eventScope.client } : {}
+			});
+		} catch (err) {
+			params.warn?.(`slack stream preview cleanup failed: ${formatSlackError(err)}`);
+		}
+	};
+	const forceNewMessage = () => {
+		streamMessageId = void 0;
+		streamChannelId = void 0;
+		lastSentKey = "";
+		pendingUpdate = void 0;
+		loop.resetPending();
+	};
+	params.log?.(`slack stream preview ready (maxChars=${maxChars}, throttleMs=${throttleMs})`);
 	return {
-		incomingThreadTs,
-		messageTs,
-		isThreadReply,
-		replyToId,
-		messageThreadId: isThreadReply || isAssistantDmThreadRoot ? incomingThreadTs : params.replyToMode === "all" ? messageTs : void 0
+		update: (update) => {
+			const normalized = normalizeUpdate(update);
+			pendingUpdate = update;
+			loop.update(normalized.text);
+		},
+		flush: loop.flush,
+		clear,
+		discardPending,
+		seal: discardPending,
+		stop,
+		forceNewMessage,
+		messageId: () => streamMessageId,
+		channelId: () => streamChannelId
 	};
 }
-/**
-* Resolves Slack thread targeting for replies and status indicators.
-*
-* @returns replyThreadTs - Thread timestamp for reply messages
-* @returns statusThreadTs - Thread timestamp for status indicators (typing, etc.)
-* @returns isThreadReply - true if this is a genuine user reply in a thread,
-*                          false if thread_ts comes from a bot status message (e.g. typing indicator)
-*/
-function resolveSlackThreadTargets(params) {
-	const { incomingThreadTs, messageTs, isThreadReply } = resolveSlackThreadContext(params);
-	const replyThreadTs = isThreadReply ? incomingThreadTs : params.replyToMode === "all" ? messageTs : void 0;
+//#endregion
+//#region extensions/slack/src/progress-blocks.ts
+const SLACK_PROGRESS_FIELD_MAX = 1800;
+const DEFAULT_SLACK_PROGRESS_DETAIL_MAX_CHARS = 120;
+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";
+function field(text) {
 	return {
-		replyThreadTs,
-		statusThreadTs: replyThreadTs,
-		isThreadReply
+		type: "mrkdwn",
+		text: truncateSlackText(text, SLACK_PROGRESS_FIELD_MAX)
 	};
 }
-//#endregion
-//#region extensions/slack/src/monitor/message-handler/preview-finalize.ts
-function buildExpectedSlackEditText(params) {
-	const trimmedText = params.text.trim();
-	if (trimmedText) return normalizeSlackOutboundText(trimmedText);
-	if (params.blocks?.length) return normalizeSlackOutboundText(buildSlackBlocksFallbackText(params.blocks));
-	return " ";
+function resolveMaxLineChars(value, fallback) {
+	return value && value > 0 ? Math.floor(value) : fallback;
 }
-function buildAcceptedSlackEditTexts(params) {
-	const expected = buildExpectedSlackEditText(params);
-	const texts = /* @__PURE__ */ new Set([
-		expected,
-		normalizeSlackOutboundText(truncateSlackText(expected, SLACK_EDIT_TEXT_LIMIT)),
-		normalizeSlackOutboundText(buildSlackEditTextPayload(params.text, params.blocks))
-	]);
-	if (params.blocks?.length && hasSlackNativeDataBlock(params.blocks)) {
-		const fallbackPlan = buildSlackNativeDataDeliveryPlan({
-			baseText: params.text,
-			blocks: params.blocks
-		});
-		for (const message of fallbackPlan.fallbackMessages) texts.add(normalizeSlackOutboundText(message.text));
-	}
-	return texts;
+function compactDetail(value, maxChars) {
+	const normalized = value.replace(/\s+/g, " ").trim();
+	const chars = Array.from(normalized);
+	if (chars.length <= maxChars) return normalized;
+	if (maxChars <= 1) return "…";
+	const keepStart = Math.max(1, Math.ceil((maxChars - 1) * .45));
+	const keepEnd = Math.max(1, maxChars - keepStart - 1);
+	return `${chars.slice(0, keepStart).join("").trimEnd()}…${chars.slice(-keepEnd).join("").trimStart()}`;
 }
-function blocksMatch(expected, actual) {
-	if (!expected?.length) return !actual?.length;
-	if (!actual?.length) {
-		if (!hasSlackNativeDataBlock(expected)) return false;
-		return buildSlackNativeDataDeliveryPlan({ blocks: expected }).fallbackMessages.every((message) => !message.blocks?.length);
-	}
-	if (JSON.stringify(expected) === JSON.stringify(actual)) return true;
-	if (!hasSlackNativeDataBlock(expected)) return false;
-	try {
-		const fallbackPlan = buildSlackNativeDataDeliveryPlan({ blocks: expected });
-		const fallbackBlocks = fallbackPlan.fallbackMessages.flatMap((message) => message.blocks ?? []);
-		if (JSON.stringify(fallbackBlocks) === JSON.stringify(actual)) return true;
-		const fallbackText = fallbackPlan.fallbackMessages.map((message) => message.text).filter(Boolean).join("\n\n");
-		return normalizeSlackOutboundText(buildSlackBlocksFallbackText(actual)) === normalizeSlackOutboundText(fallbackText);
-	} catch {
-		return false;
-	}
-}
-async function readSlackMessageAfterEditError(params) {
-	if (params.threadTs) return ((await params.client.conversations.replies({
-		token: params.token,
-		channel: params.channelId,
-		ts: params.threadTs,
-		latest: params.messageId,
-		inclusive: true,
-		limit: 100
-	})).messages ?? []).find((message) => message?.ts === params.messageId) ?? null;
-	const message = (await params.client.conversations.history({
-		token: params.token,
-		channel: params.channelId,
-		latest: params.messageId,
-		oldest: params.messageId,
-		inclusive: true,
-		limit: 1
-	})).messages?.[0];
-	if (!message?.ts || message.ts !== params.messageId) return null;
-	return message;
-}
-async function didSlackPreviewEditApplyAfterError(params) {
-	const readback = await readSlackMessageAfterEditError(params);
-	if (!readback) return false;
-	const expectedText = buildExpectedSlackEditText({
-		text: params.text,
-		blocks: params.blocks
-	});
-	const acceptedTexts = buildAcceptedSlackEditTexts({
-		text: params.text,
-		blocks: params.blocks
-	});
-	const actualText = normalizeSlackOutboundText((readback.text ?? "").trim());
-	if (params.blocks?.length) return acceptedTexts.has(actualText) && blocksMatch(params.blocks, readback.blocks);
-	return actualText === expectedText;
-}
-async function finalizeSlackPreviewEdit(params) {
-	try {
-		await editSlackMessage(params.channelId, params.messageId, params.text, {
-			token: params.token,
-			accountId: params.accountId,
-			client: params.client,
-			...params.blocks?.length ? { blocks: params.blocks } : {}
-		});
-	} catch (err) {
-		try {
-			if (await didSlackPreviewEditApplyAfterError({
-				client: params.client,
-				token: params.token,
-				channelId: params.channelId,
-				messageId: params.messageId,
-				text: params.text,
-				blocks: params.blocks,
-				threadTs: params.threadTs
-			})) {
-				logVerbose(`slack: preview final edit response failed but readback matched message ${params.channelId}/${params.messageId}; suppressing duplicate fallback send`);
-				return;
-			}
-		} catch (readbackErr) {
-			logVerbose(`slack: preview final edit readback failed (${String(readbackErr)})`);
-		}
-		throw err;
-	}
+function compactTitle(value) {
+	return truncateSlackText(value.replace(/\s+/g, " ").trim(), SLACK_PROGRESS_TASK_TITLE_MAX);
 }
-//#endregion
-//#region extensions/slack/src/monitor/message-handler/timestamp.ts
-const SLACK_TIMESTAMP_RE = /^\d+(?:\.\d+)?$/;
-const MAX_SAFE_SLACK_TIMESTAMP_SECONDS = Number.MAX_SAFE_INTEGER / 1e3;
-function resolveSlackTimestampMs(ts) {
-	const trimmed = ts?.trim();
-	if (!trimmed || !SLACK_TIMESTAMP_RE.test(trimmed)) return;
-	const seconds = asFiniteNumberInRange(parseStrictFiniteNumber(trimmed), {
-		min: 0,
-		max: MAX_SAFE_SLACK_TIMESTAMP_SECONDS
-	});
-	return seconds === void 0 ? void 0 : Math.round(seconds * 1e3);
+function compactChunkText(value) {
+	return truncateSlackText(value.replace(/\s+/g, " ").trim(), SLACK_PROGRESS_CHUNK_TEXT_MAX);
 }
-//#endregion
-//#region extensions/slack/src/monitor/message-handler/dispatch.ts
-function resolveSlackMessageTimestampMs(message) {
-	return resolveSlackTimestampMs(message.event_ts ?? message.ts);
+function lineDetailParts(line) {
+	return [line.detail, line.status && line.status !== "completed" && !line.detail?.includes(line.status) ? line.status : void 0].map((part) => part?.trim()).filter((part) => Boolean(part));
 }
-function resolveSlackBotLoopProtection(prepared) {
-	const senderBotId = prepared.message.bot_id;
-	if (!senderBotId) return;
-	const receiverBotId = prepared.ctx.botId || prepared.ctx.botUserId;
-	if (!receiverBotId || senderBotId === prepared.ctx.botId || prepared.message.user === prepared.ctx.botUserId) return;
-	return {
-		scopeId: prepared.route.accountId,
-		conversationId: prepared.message.channel,
-		senderId: senderBotId,
-		receiverId: receiverBotId,
-		config: mergePairLoopGuardConfig(prepared.account.config.botLoopProtection, prepared.channelConfig?.botLoopProtection),
-		defaultsConfig: prepared.ctx.cfg.channels?.defaults?.botLoopProtection,
-		defaultEnabled: true,
-		nowMs: resolveSlackMessageTimestampMs(prepared.message)
-	};
+function legacyLineTitle(line) {
+	return `${line.icon ?? "•"} *${escapeSlackMrkdwn(line.label)}*`;
 }
-function isSlackStreamingEnabled(params) {
-	if (params.mode === "partial") return params.nativeStreaming;
-	if (params.mode === "progress") return params.nativeStreaming && params.nativeProgressTaskCards === true;
-	return false;
+function legacyLineDetail(line, maxChars) {
+	const detail = lineDetailParts(line).join(" · ");
+	return detail ? escapeSlackMrkdwn(compactDetail(detail, maxChars)) : "—";
 }
-function shouldEnableSlackPreviewStreaming(params) {
-	return params.mode !== "off";
+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();
+	const fallback = line.text.replace(/\s+/g, " ").trim();
+	if (detail) return compactTitle(`${label} — ${compactDetail(detail, maxLineChars)}`);
+	if (fallback && fallback !== label) return compactTitle(fallback);
+	return compactTitle(label);
 }
-function shouldInitializeSlackDraftStream(params) {
-	return params.previewStreamingEnabled && !params.useStreaming;
+function lineTaskStatus(line) {
+	const normalized = line.status?.replace(/\s+/g, " ").trim().toLowerCase();
+	if (!normalized) return "in_progress";
+	if (normalized === "complete" || normalized === "completed" || normalized === "done" || normalized === "ok" || normalized === "success" || normalized === "succeeded" || normalized === "successful" || normalized === "exit 0") return "complete";
+	if (normalized === "error" || normalized === "failed" || normalized === "failure" || normalized.startsWith("exit ")) return normalized === "exit 0" ? "complete" : "error";
+	return "in_progress";
 }
-function resolveSlackDisableBlockStreaming(params) {
-	if (params.useStreaming || params.shouldUseDraftStream) return true;
-	return typeof params.blockStreamingEnabled === "boolean" ? !params.blockStreamingEnabled : void 0;
+function slugTaskIdPart(value) {
+	return value?.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "") || "task";
 }
-function resolveExplicitSlackProgressTitle(entry) {
-	const label = resolveChannelProgressDraftConfig(entry).label;
-	if (typeof label !== "string") return;
-	const trimmed = label.trim();
-	return trimmed && trimmed.toLowerCase() !== "auto" ? trimmed : void 0;
+function stableTaskIdPart(value, slugValue = value) {
+	const suffix = createHash("sha256").update(value).digest("hex").slice(0, 8);
+	return `${slugTaskIdPart(slugValue).slice(0, 48)}_${suffix}`;
 }
-function resolveSlackNativeProgressTaskCards(entry) {
-	const streaming = entry?.streaming;
-	if (!streaming || typeof streaming !== "object" || Array.isArray(streaming)) return false;
-	const progressConfig = streaming.progress;
-	return Boolean(progressConfig) && typeof progressConfig === "object" && !Array.isArray(progressConfig) && progressConfig.nativeTaskCards === true;
+function resolveLineTaskIdentity(line) {
+	if (line.id?.trim()) return {
+		id: stableTaskIdPart(line.id),
+		contentDerived: false
+	};
+	return {
+		id: stableTaskIdPart([
+			line.kind,
+			line.toolName,
+			line.label,
+			line.text
+		].join("\0"), line.toolName ?? line.kind ?? line.label),
+		contentDerived: true
+	};
 }
-function resolveSlackStreamingThreadHint(params) {
-	return resolveSlackThreadTs({
-		replyToMode: params.replyToMode,
-		incomingThreadTs: params.incomingThreadTs,
-		messageTs: params.messageTs,
-		hasReplied: false,
-		isThreadReply: params.isThreadReply
+function buildPlanTasks(params) {
+	if (params.plan) return params.plan.slice(-50).map((entry, index) => ({
+		id: `plan_step_${index + 1}`,
+		title: compactTitle(entry.step),
+		status: entry.status === "completed" ? "complete" : entry.status
+	}));
+	const maxLineChars = resolveMaxLineChars(params.maxLineChars, DEFAULT_SLACK_PROGRESS_TASK_DETAIL_MAX_CHARS);
+	const lines = params.lines.slice(-50);
+	const identities = lines.map(resolveLineTaskIdentity);
+	const contentIdOccurrences = /* @__PURE__ */ new Map();
+	return lines.map((line, index) => {
+		const identity = identities[index];
+		let id = identity.id;
+		if (identity.contentDerived) {
+			const occurrence = (contentIdOccurrences.get(id) ?? 0) + 1;
+			contentIdOccurrences.set(id, occurrence);
+			id = `${id}_${occurrence}`;
+		}
+		return {
+			id,
+			title: lineTaskTitle(line, maxLineChars),
+			status: lineTaskStatus(line)
+		};
 	});
 }
-const SLACK_STREAM_RECIPIENT_TEAM_CACHE_MAX = 2e3;
-const slackStreamRecipientTeamCaches = /* @__PURE__ */ new WeakMap();
-function getSlackStreamRecipientTeamCache(client) {
-	const existing = slackStreamRecipientTeamCaches.get(client);
-	if (existing) return existing;
-	const cache = /* @__PURE__ */ new Map();
-	slackStreamRecipientTeamCaches.set(client, cache);
-	return cache;
+function resolvePlanTitle(params) {
+	return compactChunkText(params.title?.trim() || params.label?.trim() || params.tasks.at(-1)?.title || SLACK_PROGRESS_PLAN_FALLBACK_TITLE);
 }
-function buildSlackEventDeliveryKey(params) {
-	const reply = resolveSendableOutboundReplyParts(params.payload, { text: params.textOverride });
-	const renderPlan = resolveSlackReplyRenderPlan(params.payload, params.textOverride ?? params.payload.text);
-	const plannedBlocks = renderPlan.mode === "single" ? renderPlan.blocks : renderPlan.blockPart?.blocks;
-	const slackBlocks = readSlackReplyBlocks(params.payload) ?? plannedBlocks;
-	const renderedText = renderPlan.mode === "single" ? renderPlan.text : renderPlan.fallbackText;
-	if (!reply.hasContent && !slackBlocks?.length && !renderedText.trim()) return null;
-	return JSON.stringify({
-		kind: params.kind,
-		threadTs: params.threadTs ?? "",
-		replyToId: params.payload.replyToId ?? null,
-		text: renderedText || reply.trimmedText,
-		mediaUrls: reply.mediaUrls,
-		blocks: slackBlocks ?? null
+function buildSlackProgressStreamChunks(params) {
+	const tasks = buildPlanTasks({
+		lines: params.lines,
+		plan: params.plan,
+		maxLineChars: params.maxLineChars
 	});
-}
-function readSlackStreamRecipientTeamCache(params) {
-	if (!params.fallbackTeamId || !params.userId) return;
-	const cacheKey = `${params.fallbackTeamId}:${params.userId}`;
-	const cache = getSlackStreamRecipientTeamCache(params.client);
-	const cached = cache.get(cacheKey);
-	if (!cached) return;
-	cache.delete(cacheKey);
-	cache.set(cacheKey, cached);
-	return cached;
-}
-function rememberSlackStreamRecipientTeam(params) {
-	if (!params.fallbackTeamId || !params.userId) return;
-	const cacheKey = `${params.fallbackTeamId}:${params.userId}`;
-	const cache = getSlackStreamRecipientTeamCache(params.client);
-	if (cache.has(cacheKey)) cache.delete(cacheKey);
-	cache.set(cacheKey, params.teamId);
-	if (cache.size > SLACK_STREAM_RECIPIENT_TEAM_CACHE_MAX) {
-		const oldest = cache.keys().next().value;
-		if (oldest) cache.delete(oldest);
+	if (tasks.length === 0) {
+		const title = params.title?.trim() || params.label?.trim();
+		return title ? [{
+			type: "plan_update",
+			title: compactChunkText(title)
+		}] : void 0;
 	}
-}
-function createSlackEventDeliveryTracker() {
-	const deliveredKeys = /* @__PURE__ */ new Set();
-	return {
-		hasDelivered(params) {
-			const key = buildSlackEventDeliveryKey(params);
-			return key ? deliveredKeys.has(key) : false;
-		},
-		markDelivered(params) {
-			const key = buildSlackEventDeliveryKey(params);
-			if (key) deliveredKeys.add(key);
-		}
+	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();
+	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 ? [{
+			type: "section",
+			text: field(`*${escapeSlackMrkdwn(label)}*`)
+		}] : [],
+		...narration ? [{
+			type: "section",
+			text: field(`_${escapeSlackMrkdwn(narration)}_`)
+		}] : [],
+		...planLines.length > 0 ? [{
+			type: "section",
+			text: field(planLines.map((line) => escapeSlackMrkdwn(line)).join("\n"))
+		}] : []
+	].slice(0, 50);
+	const lineBudget = Math.max(0, 50 - headBlocks.length);
+	const renderedBlocks = [...headBlocks, ...params.lines.slice(-lineBudget).map((line) => ({
+		type: "section",
+		fields: [field(legacyLineTitle(line)), field(legacyLineDetail(line, maxLineChars))]
+	}))];
+	return renderedBlocks.length ? renderedBlocks : void 0;
+}
+/**
+* Slack native streams key task rows by persistent id with no removal chunk.
+* When the task source switches representation (tool lines <-> typed plan) or
+* a snapshot drops ids, previously emitted non-terminal rows must receive a
+* final update or they linger in_progress forever.
+*/
+function reconcileSlackNativeTaskChunks(params) {
+	const nextTasks = /* @__PURE__ */ new Map();
+	for (const chunk of params.chunks ?? []) if (chunk.type === "task_update") nextTasks.set(chunk.id, {
+		title: chunk.title,
+		status: chunk.status
+	});
+	const terminalized = [...params.previousTasks].filter(([id, task]) => !nextTasks.has(id) && task.status !== "complete" && task.status !== "error").map(([id, task]) => {
+		const entry = {
+			title: task.title,
+			status: "complete"
+		};
+		nextTasks.set(id, entry);
+		return {
+			type: "task_update",
+			id,
+			title: task.title,
+			status: "complete"
+		};
+	});
+	for (const [id, task] of params.previousTasks) if (!nextTasks.has(id)) nextTasks.set(id, task);
+	return {
+		chunks: params.chunks?.length ? [...params.chunks, ...terminalized] : terminalized.length ? terminalized : params.chunks,
+		tasks: nextTasks
 	};
 }
-function shouldUseStreaming(params) {
-	if (!params.streamingEnabled) return false;
-	if (!params.threadTs) {
-		logVerbose("slack-stream: streaming disabled — no reply thread target available");
+function buildSlackProgressStreamStartChunks(params) {
+	return buildSlackProgressStreamChunks(params);
+}
+function buildSlackProgressStreamUpdateChunks(params) {
+	return buildSlackProgressStreamChunks(params);
+}
+function buildSlackProgressStreamCompletionChunks(params) {
+	return buildSlackProgressStreamChunks({
+		...params,
+		completeInProgress: true
+	});
+}
+//#endregion
+//#region extensions/slack/src/stream-mode.ts
+function resolveSlackStreamingConfig(params) {
+	const mode = resolveSlackStreamingMode(params);
+	return {
+		mode,
+		nativeStreaming: resolveSlackNativeStreaming(params),
+		draftMode: mapStreamingModeToSlackLegacyDraftStreamMode(mode)
+	};
+}
+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
+	};
+}
+//#endregion
+//#region extensions/slack/src/monitor/message-handler/preview-finalize.ts
+function buildExpectedSlackEditText(params) {
+	const trimmedText = params.text.trim();
+	if (trimmedText) return normalizeSlackOutboundText(trimmedText);
+	if (params.blocks?.length) return normalizeSlackOutboundText(buildSlackBlocksFallbackText(params.blocks));
+	return " ";
+}
+function buildAcceptedSlackEditTexts(params) {
+	const expected = buildExpectedSlackEditText(params);
+	const texts = /* @__PURE__ */ new Set([
+		expected,
+		normalizeSlackOutboundText(truncateSlackText(expected, SLACK_EDIT_TEXT_LIMIT)),
+		normalizeSlackOutboundText(buildSlackEditTextPayload(params.text, params.blocks))
+	]);
+	if (params.blocks?.length && hasSlackNativeDataBlock(params.blocks)) {
+		const fallbackPlan = buildSlackNativeDataDeliveryPlan({
+			baseText: params.text,
+			blocks: params.blocks
+		});
+		for (const message of fallbackPlan.fallbackMessages) texts.add(normalizeSlackOutboundText(message.text));
+	}
+	return texts;
+}
+function blocksMatch(expected, actual) {
+	if (!expected?.length) return !actual?.length;
+	if (!actual?.length) {
+		if (!hasSlackNativeDataBlock(expected)) return false;
+		return buildSlackNativeDataDeliveryPlan({ blocks: expected }).fallbackMessages.every((message) => !message.blocks?.length);
+	}
+	if (JSON.stringify(expected) === JSON.stringify(actual)) return true;
+	if (!hasSlackNativeDataBlock(expected)) return false;
+	try {
+		const fallbackPlan = buildSlackNativeDataDeliveryPlan({ blocks: expected });
+		const fallbackBlocks = fallbackPlan.fallbackMessages.flatMap((message) => message.blocks ?? []);
+		if (JSON.stringify(fallbackBlocks) === JSON.stringify(actual)) return true;
+		const fallbackText = fallbackPlan.fallbackMessages.map((message) => message.text).filter(Boolean).join("\n\n");
+		return normalizeSlackOutboundText(buildSlackBlocksFallbackText(actual)) === normalizeSlackOutboundText(fallbackText);
+	} catch {
 		return false;
 	}
-	return true;
 }
-async function resolveSlackStreamRecipientTeamId(params) {
-	const cachedTeamId = readSlackStreamRecipientTeamCache(params);
-	if (cachedTeamId) return cachedTeamId;
-	if (params.userId) try {
-		const info = await params.client.users.info({
+async function readSlackMessageAfterEditError(params) {
+	if (params.threadTs) return ((await params.client.conversations.replies({
+		token: params.token,
+		channel: params.channelId,
+		ts: params.threadTs,
+		latest: params.messageId,
+		inclusive: true,
+		limit: 100
+	})).messages ?? []).find((message) => message?.ts === params.messageId) ?? null;
+	const message = (await params.client.conversations.history({
+		token: params.token,
+		channel: params.channelId,
+		latest: params.messageId,
+		oldest: params.messageId,
+		inclusive: true,
+		limit: 1
+	})).messages?.[0];
+	if (!message?.ts || message.ts !== params.messageId) return null;
+	return message;
+}
+async function didSlackPreviewEditApplyAfterError(params) {
+	const readback = await readSlackMessageAfterEditError(params);
+	if (!readback) return false;
+	const expectedText = buildExpectedSlackEditText({
+		text: params.text,
+		blocks: params.blocks
+	});
+	const acceptedTexts = buildAcceptedSlackEditTexts({
+		text: params.text,
+		blocks: params.blocks
+	});
+	const actualText = normalizeSlackOutboundText((readback.text ?? "").trim());
+	if (params.blocks?.length) return acceptedTexts.has(actualText) && blocksMatch(params.blocks, readback.blocks);
+	return actualText === expectedText;
+}
+async function finalizeSlackPreviewEdit(params) {
+	try {
+		await editSlackMessage(params.channelId, params.messageId, params.text, {
 			token: params.token,
-			user: params.userId
+			accountId: params.accountId,
+			client: params.client,
+			...params.blocks?.length ? { blocks: params.blocks } : {}
 		});
-		const teamId = info.user?.team_id ?? info.user?.profile?.team;
-		if (teamId) {
-			rememberSlackStreamRecipientTeam({
-				...params,
-				teamId
-			});
-			return teamId;
-		}
 	} catch (err) {
-		logVerbose(`slack-stream: users.info team lookup failed (${formatErrorMessage(err)})`);
+		try {
+			if (await didSlackPreviewEditApplyAfterError({
+				client: params.client,
+				token: params.token,
+				channelId: params.channelId,
+				messageId: params.messageId,
+				text: params.text,
+				blocks: params.blocks,
+				threadTs: params.threadTs
+			})) {
+				logVerbose(`slack: preview final edit response failed but readback matched message ${params.channelId}/${params.messageId}; suppressing duplicate fallback send`);
+				return;
+			}
+		} catch (readbackErr) {
+			logVerbose(`slack: preview final edit readback failed (${String(readbackErr)})`);
+		}
+		throw err;
 	}
-	return params.fallbackTeamId;
 }
-async function dispatchPreparedSlackMessage(prepared) {
-	const { ctx, account, message, route } = prepared;
-	const slackClient = prepared.eventScope?.client ?? ctx.app.client;
-	const slackStreamFallbackTeamId = prepared.eventScope?.teamId ?? ctx.teamId;
-	const cfg = ctx.cfg;
-	const runtime = ctx.runtime;
-	const outboundIdentity = resolveAgentOutboundIdentity(cfg, route.agentId);
-	const slackIdentity = outboundIdentity ? {
-		username: outboundIdentity.name,
-		iconUrl: outboundIdentity.avatarUrl,
-		iconEmoji: outboundIdentity.emoji
-	} : prepared.relayIdentity;
-	if (prepared.isDirectMessage) {
-		const sessionCfg = cfg.session;
-		const storePath = resolveStorePath(sessionCfg?.store, { agentId: route.agentId });
-		const pinnedMainDmOwner = resolvePinnedMainDmOwnerFromAllowlist({
-			dmScope: cfg.session?.dmScope,
-			allowFrom: ctx.allowFrom,
-			normalizeEntry: normalizeSlackAllowOwnerEntry
-		});
-		const senderRecipient = normalizeOptionalLowercaseString(message.user);
-		const inboundLastRouteSessionKey = resolveInboundLastRouteSessionKey({
-			route,
-			sessionKey: prepared.ctxPayload.SessionKey ?? route.sessionKey
-		});
-		if (inboundLastRouteSessionKey === route.mainSessionKey && pinnedMainDmOwner && senderRecipient && normalizeOptionalLowercaseString(pinnedMainDmOwner) !== senderRecipient) logVerbose(`slack: skip main-session last route for ${senderRecipient} (pinned owner ${pinnedMainDmOwner})`);
-		else await updateLastRoute({
-			storePath,
-			sessionKey: inboundLastRouteSessionKey,
-			deliveryContext: {
-				channel: "slack",
-				to: `user:${message.user}`,
-				accountId: route.accountId,
-				threadId: prepared.ctxPayload.MessageThreadId ?? prepared.ctxPayload.TransportThreadId
-			},
-			ctx: prepared.ctxPayload
+//#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
 		});
+		return true;
+	} catch (err) {
+		logVerbose(`slack: progress receipt edit failed (${formatSlackError(err)})`);
+		return false;
 	}
-	const threadTargets = resolveSlackThreadTargets({
-		message,
-		replyToMode: prepared.replyToMode
+}
+//#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
+		};
 	});
-	const forcedReplyThreadTs = prepared.forcedReplyThreadTs;
-	const slackMessageMetadata = prepared.slackMessageMetadata;
-	const statusThreadTs = forcedReplyThreadTs ?? threadTargets.statusThreadTs;
-	const isThreadReply = threadTargets.isThreadReply;
-	const replyDeliveryMode = forcedReplyThreadTs ? "off" : prepared.replyToMode;
-	const sourceReplyDeliveryMode = resolveChannelMessageSourceReplyDeliveryMode({
-		cfg,
-		ctx: prepared.ctxPayload
+}
+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
 	});
-	const sourceRepliesAreToolOnly = sourceReplyDeliveryMode === "message_tool_only";
-	const suppressRoomEventTyping = prepared.ctxPayload.InboundEventKind === "room_event";
-	const messageSentHookTarget = prepared.ctxPayload.OriginatingTo ?? prepared.ctxPayload.To ?? prepared.replyTarget;
-	const messageSentHookContext = {
-		sessionKeyForInternalHooks: prepared.ctxPayload.SessionKey ?? route.sessionKey,
-		isGroup: prepared.isRoomish,
-		groupId: prepared.isRoomish ? message.channel : void 0
-	};
-	const messageSentDeliveryHookContext = {
-		...messageSentHookContext,
-		messageSentHookTarget
+	return explanationLine ? [...lines, explanationLine] : lines;
+}
+function combineProgressHeadlineAndExplanation(headline, explanation) {
+	return headline && explanation && headline !== explanation ? `${headline} — ${explanation}` : headline ?? explanation;
+}
+function buildNativeProgressChunks(params) {
+	const input = {
+		title: params.title,
+		lines: resolveNativeProgressLines(params.snapshot),
+		plan: resolveNativeProgressPlan(params.snapshot),
+		maxLineChars: params.maxLineChars
 	};
-	const reactionMessageTs = prepared.ackReactionMessageTs;
-	const messageTs = message.ts ?? message.event_ts;
-	const incomingThreadTs = message.thread_ts;
-	let didSetStatus = false;
-	const statusReactionsEnabled = prepared.ctxPayload.InboundEventKind !== "room_event" && Boolean(prepared.ackReactionPromise) && Boolean(reactionMessageTs) && cfg.messages?.statusReactions?.enabled === true;
-	const slackStatusAdapter = {
-		setReaction: async (emoji) => {
-			await reactSlackMessage(message.channel, reactionMessageTs ?? "", emoji, {
-				token: ctx.botToken,
-				client: slackClient
-			}).catch((err) => {
-				if (formatErrorMessage(err).includes("already_reacted")) return;
-				throw err;
-			});
+	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, message, prepared, replyPlan, runtime, slackClient, slackIdentity, slackMessageMetadata, slackStreaming, slackStreamFallbackTeamId, shouldUseDraftStream, useStreaming, previewStreamingEnabled } = setup;
+	const draftStream = shouldUseDraftStream ? createSlackDraftStream({
+		target: prepared.replyTarget,
+		cfg,
+		token: ctx.botToken,
+		accountId: account.accountId,
+		...prepared.eventScope ? { eventScope: prepared.eventScope } : {},
+		identity: slackIdentity,
+		...slackMessageMetadata ? { metadata: slackMessageMetadata } : {},
+		maxChars: Math.min(ctx.textLimit, SLACK_TEXT_LIMIT),
+		resolveThreadTs: () => {
+			const ts = replyPlan.peekThreadTs();
+			if (ts) delivery.usedReplyThreadTs ??= ts;
+			return ts;
 		},
-		removeReaction: async (emoji) => {
-			await removeSlackReaction(message.channel, reactionMessageTs ?? "", emoji, {
-				token: ctx.botToken,
-				client: slackClient
-			}).catch((err) => {
-				if (formatErrorMessage(err).includes("no_reaction")) return;
-				throw err;
-			});
+		log: logVerbose,
+		warn: logVerbose
+	}) : void 0;
+	let hasStreamedMessage = false;
+	const streamMode = slackStreaming.draftMode;
+	const useNativeProgressStreaming = useStreaming && slackStreaming.mode === "progress";
+	const progressDraftActive = Boolean(draftStream) || useNativeProgressStreaming;
+	const previewToolProgressEnabled = progressDraftActive && resolveChannelStreamingPreviewToolProgress(account.config);
+	let shouldYieldDraftProgress = () => false;
+	const suppressDefaultToolProgressMessages = resolveChannelStreamingSuppressDefaultToolProgressMessages(account.config, {
+		draftStreamActive: Boolean(draftStream) || useNativeProgressStreaming,
+		previewToolProgressEnabled,
+		previewStreamingEnabled
+	});
+	let previewToolProgressSuppressed = false;
+	let legacyPreviewToolProgressLines = [];
+	let nativeTaskState = /* @__PURE__ */ new Map();
+	let appendRenderedText = "";
+	let appendSourceText = "";
+	let nativeProgressCompletionSent = false;
+	let nativeProgressTerminalStatus = "complete";
+	let nativeProgressChunkKey;
+	const progressReceipt = createChannelProgressReceiptTracker();
+	let progressReceiptCollapsed = false;
+	let pendingNativeProgressReceipt;
+	const progressSeed = `${account.accountId}:${message.channel}`;
+	const useRichProgressDraft = streamMode === "status_final" && resolveChannelProgressDraftRender(account.config) === "rich";
+	const explicitProgressTitle = resolveExplicitSlackProgressTitle(account.config);
+	const progressDraftMaxLineChars = resolveChannelProgressDraftMaxLineChars(account.config);
+	const waitForNativeProgressStreamStart = async () => {
+		if (delivery.streamSession || !delivery.nativeProgressStreamStartPromise) return true;
+		try {
+			await delivery.nativeProgressStreamStartPromise;
+		} catch {
+			delivery.streamFailed = true;
+			return false;
 		}
+		return !delivery.streamFailed;
 	};
-	const statusReactionTiming = {
-		...DEFAULT_TIMING,
-		...cfg.messages?.statusReactions?.timing
-	};
-	const statusReactions = createStatusReactionController({
-		enabled: statusReactionsEnabled,
-		adapter: slackStatusAdapter,
-		initialEmoji: prepared.ackReactionValue || "eyes",
-		emojis: cfg.messages?.statusReactions?.emojis,
-		timing: cfg.messages?.statusReactions?.timing,
-		onError: (err) => {
-			logAckFailure({
-				log: logVerbose,
-				channel: "slack",
-				target: `${message.channel}/${message.ts}`,
-				error: err
+	const appendNativeProgressCompletion = async (isError) => {
+		const session = delivery.streamSession;
+		if (isError) nativeProgressTerminalStatus = "error";
+		if (!session || nativeProgressCompletionSent) return;
+		const chunks = buildNativeProgressCompletionChunks(isError ? "error" : "complete");
+		if (!chunks?.length) return;
+		try {
+			await appendSlackStream({
+				session,
+				chunks
 			});
+			nativeProgressCompletionSent = true;
+			delivery.observedReplyDelivery ||= session.delivered;
+		} catch (err) {
+			delivery.streamFailed = true;
+			runtime.error?.(danger(`slack-stream: native progress completion failed: ${formatSlackError(err)}`));
 		}
+	};
+	const buildNativeProgressChunks$1 = (snapshot) => buildNativeProgressChunks({
+		snapshot,
+		streamStarted: Boolean(delivery.streamSession),
+		title: combineProgressHeadlineAndExplanation(explicitProgressTitle ?? snapshot.statusHeadline, snapshot.planExplanation),
+		maxLineChars: progressDraftMaxLineChars
 	});
-	if (statusReactionsEnabled) statusReactions.setQueued();
-	const hasRepliedRef = { value: false };
-	const replyPlan = createSlackReplyDeliveryPlan({
-		replyToMode: replyDeliveryMode,
-		incomingThreadTs: forcedReplyThreadTs ?? incomingThreadTs,
-		messageTs,
-		hasRepliedRef,
-		isThreadReply: Boolean(forcedReplyThreadTs) || isThreadReply
-	});
-	const typingTarget = statusThreadTs ? `${message.channel}/${statusThreadTs}` : message.channel;
-	const typingReaction = ctx.typingReaction;
-	const { onModelSelected, ...replyPipeline } = createChannelMessageReplyPipeline({
-		cfg,
-		agentId: route.agentId,
-		channel: "slack",
-		accountId: route.accountId,
-		transformReplyPayload: (payload) => {
-			if (payload.isReasoning === true) return null;
-			return isSlackInteractiveRepliesEnabled({
-				cfg,
-				accountId: route.accountId
-			}) ? compileSlackInteractiveReplies(payload) : payload;
-		},
-		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)}`);
-				});
-			},
-			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)}`);
-				});
-			},
-			onStartError: (err) => {
-				logTypingFailure({
-					log: (messageValue) => runtime.error?.(danger(messageValue)),
-					channel: "slack",
-					action: "start",
-					target: typingTarget,
-					error: err
-				});
-			},
-			onStopError: (err) => {
-				logTypingFailure({
-					log: (messageLocal) => runtime.error?.(danger(messageLocal)),
-					channel: "slack",
-					action: "stop",
-					target: typingTarget,
-					error: err
-				});
-			}
+	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 slackStreaming = resolveSlackStreamingConfig({
-		streaming: account.config.streaming,
-		nativeStreaming: resolveChannelStreamingNativeTransport(account.config)
-	});
-	const streamThreadHint = forcedReplyThreadTs ?? resolveSlackStreamingThreadHint({
-		replyToMode: replyDeliveryMode,
-		incomingThreadTs,
-		messageTs,
-		isThreadReply
-	});
-	const previewStreamingEnabled = !sourceRepliesAreToolOnly && shouldEnableSlackPreviewStreaming({ mode: slackStreaming.mode });
-	const hasSlackCustomIdentity = Boolean(slackIdentity?.username || slackIdentity?.iconUrl || slackIdentity?.iconEmoji);
-	const useStreaming = shouldUseStreaming({
-		streamingEnabled: !sourceRepliesAreToolOnly && isSlackStreamingEnabled({
-			mode: slackStreaming.mode,
-			nativeStreaming: slackStreaming.nativeStreaming,
-			nativeProgressTaskCards: resolveSlackNativeProgressTaskCards(account.config)
-		}),
-		threadTs: streamThreadHint
-	});
-	const shouldUseDraftStream = !hasSlackCustomIdentity && shouldInitializeSlackDraftStream({
-		previewStreamingEnabled,
-		useStreaming
-	});
-	const blockStreamingEnabled = resolveChannelStreamingBlockEnabled(account.config);
-	const disableBlockStreaming = sourceRepliesAreToolOnly ? true : resolveSlackDisableBlockStreaming({
-		useStreaming,
-		shouldUseDraftStream,
-		blockStreamingEnabled
-	});
-	let streamSession = null;
-	let nativeProgressStreamStartPromise = null;
-	let nativeProgressStreamThreadTs;
-	let streamFailed = false;
-	let usedReplyThreadTs;
-	let usedBlockReplyThreadTs;
-	let observedReplyDelivery = false;
-	let 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;
 	};
-	const recordStreamedDelivery = (kind, content) => {
-		const delivery = {
-			kind,
-			content,
-			acknowledged: false
-		};
-		streamedDeliveries.push(delivery);
-		return delivery;
-	};
-	const rememberStreamedDelivery = (kind, content, session) => {
-		recordStreamedDelivery(kind, content);
-		refreshStreamedAcknowledgements(session);
-	};
-	const emitAcknowledgedStreamedDeliveries = (messageId) => {
-		for (const delivery of streamedDeliveries) {
-			if (!delivery.acknowledged || delivery.outcome) continue;
-			emitSlackMessageSentHooks({
-				...messageSentHookContext,
-				to: messageSentHookTarget,
-				accountId: account.accountId,
-				content: delivery.content,
-				success: true,
-				...messageId ? { messageId } : {}
+	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.outcome = "success";
+			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 acknowledgeStoppedStreamedDeliveries = (session, messageId) => {
-		refreshStreamedAcknowledgements(session);
-		for (const delivery of streamedDeliveries) delivery.acknowledged = true;
-		emitAcknowledgedStreamedDeliveries(messageId);
+	const appendNativeProgressStream = async (chunks, chunkKey) => {
+		if (!delivery.streamSession) return;
+		await appendSlackStream({
+			session: delivery.streamSession,
+			chunks
+		});
+		markNativeProgressDelivered(delivery.streamSession);
+		nativeProgressChunkKey = chunkKey;
 	};
-	const emitFailedPendingStreamedDeliveries = (error) => {
-		for (const delivery of streamedDeliveries) {
-			if (delivery.acknowledged || delivery.outcome) continue;
-			emitSlackMessageSentHooks({
-				...messageSentHookContext,
-				to: messageSentHookTarget,
-				accountId: account.accountId,
-				content: delivery.content,
-				success: false,
-				error
-			});
-			delivery.outcome = "failure";
+	const updateNativeProgressStream = async () => {
+		const snapshot = progressDraft.getSnapshot();
+		const progressLines = resolveNativeProgressLines(snapshot);
+		const hasRetirableNativeTasks = [...nativeTaskState.values()].some((task) => task.status !== "complete" && task.status !== "error");
+		if (!useNativeProgressStreaming || delivery.streamFailed || progressLines.length === 0 && !snapshot.plan?.length && !snapshot.statusHeadline && !explicitProgressTitle && !hasRetirableNativeTasks) return;
+		if (!await waitForNativeProgressStreamStart()) return;
+		const reconciled = reconcileSlackNativeTaskChunks({
+			previousTasks: nativeTaskState,
+			chunks: buildNativeProgressChunks$1(snapshot)
+		});
+		const chunks = reconciled.chunks;
+		if (!chunks?.length) return;
+		const chunkKey = JSON.stringify(chunks);
+		if (chunkKey === nativeProgressChunkKey) return;
+		try {
+			if (!delivery.streamSession) await startNativeProgressStream(chunks, chunkKey);
+			else await appendNativeProgressStream(chunks, chunkKey);
+			nativeTaskState = reconciled.tasks;
+		} catch (err) {
+			runtime.error?.(danger(`slack-stream: native progress stream failed: ${formatSlackError(err)}, falling back`));
+			delivery.streamFailed = true;
 		}
 	};
-	const emitSuccessfulPendingStreamedDeliveries = (messageId) => {
-		for (const delivery of streamedDeliveries) {
-			if (delivery.acknowledged || delivery.outcome) continue;
-			emitSlackMessageSentHooks({
-				...messageSentHookContext,
-				to: messageSentHookTarget,
-				accountId: account.accountId,
-				content: delivery.content,
-				success: true,
-				...messageId ? { messageId } : {}
-			});
-			delivery.outcome = "success";
-		}
+	const resetProgressTurnState = () => {
+		progressReceipt.reset();
+		progressReceiptCollapsed = false;
+		pendingNativeProgressReceipt = void 0;
 	};
-	let deliveryTracker = createSlackEventDeliveryTracker();
-	const markPreviewPayloadDelivered = (params) => {
-		deliveryTracker.markDelivered(params);
-		const nextThreadTs = replyPlan.peekThreadTs();
-		if (nextThreadTs !== params.threadTs) deliveryTracker.markDelivered({
-			...params,
-			threadTs: nextThreadTs
+	const collapseProgressReceipt = async (params) => {
+		progressReceiptCollapsed = await collapseSlackProgressReceipt({
+			setup,
+			edit: params
 		});
 	};
-	const resolveDeliveryThreadTs = (params) => {
-		const plannedThreadTs = params.forcedThreadTs ? void 0 : replyPlan.nextThreadTs();
-		return params.forcedThreadTs ?? plannedThreadTs ?? (params.kind === "block" ? usedBlockReplyThreadTs : void 0);
-	};
-	const rememberDeliveredThreadTs = (kind, deliveredThreadTs) => {
-		if (!deliveredThreadTs) return;
-		usedReplyThreadTs ??= deliveredThreadTs;
-		if (kind === "block") usedBlockReplyThreadTs = deliveredThreadTs;
+	const progressDraft = createChannelProgressDraftCompositor({
+		entry: account.config,
+		mode: slackStreaming.mode,
+		active: progressDraftActive && streamMode === "status_final",
+		seed: progressSeed,
+		formatLine: escapeSlackMrkdwn,
+		reasoningLinePrefix: "🧠 ",
+		commentaryLinePrefix: "💬 ",
+		reasoningGate: previewToolProgressEnabled,
+		commentaryItalics: false,
+		updateOnLineChange: useNativeProgressStreaming || useRichProgressDraft,
+		update: async (previewText, options) => {
+			if (useNativeProgressStreaming) {
+				await updateNativeProgressStream();
+				return;
+			}
+			if (!draftStream) return;
+			const snapshot = progressDraft.getSnapshot();
+			const structuredLines = resolveStructuredProgressLines(options?.lines ?? snapshot.lines);
+			const richNarration = combineProgressHeadlineAndExplanation(snapshot.statusHeadline, snapshot.planExplanation);
+			const richProgressBlocks = useRichProgressDraft ? buildSlackProgressDraftBlocks({
+				title: explicitProgressTitle,
+				lines: structuredLines,
+				plan: snapshot.plan,
+				narration: richNarration,
+				maxLineChars: progressDraftMaxLineChars
+			}) : void 0;
+			draftStream.update(useRichProgressDraft && richProgressBlocks ? {
+				text: previewText,
+				blocks: richProgressBlocks
+			} : previewText);
+			hasStreamedMessage = true;
+			if (options?.flush) await draftStream.flush();
+		}
+	});
+	const commentaryProgressEnabled = progressDraft.commentaryProgressEnabled;
+	const buildNativeProgressCompletionChunks = (finalInProgressStatus) => {
+		const snapshot = progressDraft.getSnapshot();
+		const lines = resolveNativeProgressLines(snapshot);
+		const hasRetirableNativeTasks = [...nativeTaskState.values()].some((task) => task.status !== "complete" && task.status !== "error");
+		if (lines.length === 0 && !snapshot.plan?.length && !hasRetirableNativeTasks) return;
+		return reconcileSlackNativeTaskChunks({
+			previousTasks: nativeTaskState,
+			chunks: buildSlackProgressStreamCompletionChunks({
+				title: resolveNativeProgressTitle(snapshot),
+				lines,
+				plan: resolveNativeProgressPlan(snapshot),
+				maxLineChars: progressDraftMaxLineChars,
+				finalInProgressStatus
+			})
+		}).chunks;
 	};
-	const deliverPendingStreamFallback = async (session, err) => {
-		let fallbackError = err;
-		if (!session.stopped) try {
+	const finishNativeProgressTurn = async (completionChunks) => {
+		if (delivery.nativeProgressStreamStartPromise) await delivery.nativeProgressStreamStartPromise.catch(() => null);
+		const session = delivery.streamSession;
+		if (session && !session.stopped) try {
+			if (completionChunks?.length) nativeProgressCompletionSent = true;
 			const stopResult = await stopSlackStream({
 				session,
+				...completionChunks?.length ? { chunks: completionChunks } : {},
 				...slackMessageMetadata ? { metadata: slackMessageMetadata } : {}
 			});
-			acknowledgeStoppedStreamedDeliveries(session, stopResult.messageId);
-			observedReplyDelivery = true;
-			usedReplyThreadTs ??= session.threadTs;
-			return true;
-		} catch (stopErr) {
-			if (stopErr instanceof SlackStreamNotDeliveredError) fallbackError = stopErr;
-			else runtime.error?.(danger(`slack-stream: failed to finalize buffered text before fallback: ${formatSlackError(stopErr)}`));
-		}
-		emitAcknowledgedStreamedDeliveries();
-		const fallbackText = fallbackError.pendingText.trim();
-		if (!fallbackText) return false;
-		try {
-			await deliverReplies({
-				cfg: ctx.cfg,
-				replies: [{ text: fallbackText }],
-				target: prepared.replyTarget,
-				token: ctx.botToken,
-				accountId: account.accountId,
-				runtime,
-				textLimit: ctx.textLimit,
-				mediaMaxBytes: ctx.mediaMaxBytes,
-				replyThreadTs: session.threadTs,
-				replyToMode: replyDeliveryMode,
-				...slackIdentity ? { identity: slackIdentity } : {},
-				...slackMessageMetadata ? { metadata: slackMessageMetadata } : {},
-				...messageSentDeliveryHookContext,
-				deferMessageSentHooks: true,
-				...prepared.eventScope ? { eventScope: prepared.eventScope } : {}
+			delivery.acknowledgeStoppedStreamedDeliveries(session, stopResult?.messageId);
+			if (pendingNativeProgressReceipt && stopResult?.messageId) await collapseProgressReceipt({
+				channelId: session.channel,
+				messageId: stopResult.messageId,
+				text: pendingNativeProgressReceipt,
+				threadTs: session.threadTs
 			});
-			markSlackStreamFallbackDelivered(session);
-			if (!session.stopped) try {
-				await stopSlackStream({
-					session,
-					...slackMessageMetadata ? { metadata: slackMessageMetadata } : {}
-				});
-			} catch (finalizeErr) {
-				runtime.error?.(danger(`slack-stream: failed to finalize native stream after fallback delivery: ${formatSlackError(finalizeErr)}`));
-			}
-			emitSuccessfulPendingStreamedDeliveries();
-			observedReplyDelivery = true;
-			usedReplyThreadTs ??= session.threadTs;
-			logVerbose(`slack-stream: streamed delivery failed (${fallbackError.slackCode}); delivered ${fallbackText.length} chars via deliverReplies fallback`);
-			return true;
-		} catch (postErr) {
-			emitFailedPendingStreamedDeliveries(formatErrorMessage(postErr));
-			runtime.error?.(danger(`slack-stream: fallback deliverReplies failed after ${fallbackError.slackCode}: ${formatErrorMessage(postErr)}`));
-			return false;
+		} catch (err) {
+			const error = formatSlackError(err);
+			delivery.emitAcknowledgedStreamedDeliveries();
+			delivery.emitFailedPendingStreamedDeliveries(error);
+			logVerbose(`slack-stream: failed to rotate native progress stream (${error})`);
 		}
+		delivery.streamSession = null;
+		delivery.nativeProgressStreamStartPromise = null;
+		delivery.nativeProgressStreamThreadTs = void 0;
+		delivery.streamFailed = false;
 	};
-	const deliverNormally = async (params) => {
-		if (params.payload.isReasoning === true) return;
-		const replyThreadTs = resolveDeliveryThreadTs(params);
-		const deliveryReplyThreadTs = replyDeliveryMode === "off" && !forcedReplyThreadTs && !isThreadReply ? void 0 : replyThreadTs;
-		if (deliveryTracker.hasDelivered({
-			kind: params.kind,
-			payload: params.payload,
-			threadTs: deliveryReplyThreadTs
-		})) {
-			logVerbose("slack: suppressed duplicate normal delivery within the same turn");
-			return deliveryReplyThreadTs;
+	const pushPlanProgress = async (steps, explanation) => {
+		if (streamMode === "status_final") {
+			await progressDraft.pushPlanProgress(steps, { explanation });
+			return;
 		}
-		await deliverReplies({
-			cfg: ctx.cfg,
-			replies: [params.payload],
-			target: prepared.replyTarget,
-			token: ctx.botToken,
-			accountId: account.accountId,
-			runtime,
-			textLimit: ctx.textLimit,
-			mediaMaxBytes: ctx.mediaMaxBytes,
-			replyThreadTs: deliveryReplyThreadTs,
-			replyToMode: replyDeliveryMode,
-			...slackIdentity ? { identity: slackIdentity } : {},
-			...slackMessageMetadata ? { metadata: slackMessageMetadata } : {},
-			...messageSentDeliveryHookContext,
-			...prepared.eventScope ? { eventScope: prepared.eventScope } : {}
-		});
-		observedReplyDelivery = true;
-		if (params.kind === "final") observedFinalReplyDelivery = true;
-		const deliveredThreadTs = resolveDeliveredSlackReplyThreadTs({
-			replyToMode: replyDeliveryMode,
-			payloadReplyToId: params.payload.replyToId,
-			replyThreadTs: deliveryReplyThreadTs
-		});
-		rememberDeliveredThreadTs(params.kind, deliveredThreadTs);
-		replyPlan.markSent();
-		deliveryTracker.markDelivered({
-			kind: params.kind,
-			payload: params.payload,
-			threadTs: deliveryReplyThreadTs
+		if (previewToolProgressSuppressed || !draftStream) return;
+		const text = formatChannelProgressDraftText({
+			entry: account.config,
+			lines: legacyPreviewToolProgressLines,
+			seed: progressSeed,
+			formatLine: escapeSlackMrkdwn,
+			narration: explanation,
+			plan: steps
 		});
-		return deliveryReplyThreadTs;
-	};
-	const deliverBufferedStreamFallback = async (params) => {
-		if (!await deliverPendingStreamFallback(params.session, params.err)) {
-			streamedFailuresOwnedByDispatcher[params.kind] += 1;
-			return false;
+		if (text) {
+			draftStream.update(text);
+			hasStreamedMessage = true;
 		}
-		replyPlan.markSent();
-		if (params.kind === "final") observedFinalReplyDelivery = true;
-		deliveryTracker.markDelivered({
-			kind: params.kind,
-			payload: params.payload,
-			threadTs: params.session.threadTs,
-			textOverride: params.textOverride
-		});
-		rememberDeliveredThreadTs(params.kind, params.session.threadTs);
-		return true;
 	};
-	const appendNativeProgressCompletion = async (isError) => {
-		const session = streamSession;
-		if (isError) nativeProgressTerminalStatus = "error";
-		if (!session || nativeProgressCompletionSent) return;
-		const chunks = buildNativeProgressCompletionChunks(isError ? "error" : "complete");
-		if (!chunks?.length) return;
-		try {
-			await appendSlackStream({
-				session,
-				chunks
-			});
-			nativeProgressCompletionSent = true;
-			observedReplyDelivery ||= session.delivered;
-		} catch (err) {
-			streamFailed = true;
-			runtime.error?.(danger(`slack-stream: native progress completion failed: ${formatSlackError(err)}`));
+	const pushPreviewProgress = async (line, options) => {
+		if (!draftStream && !useNativeProgressStreaming) return;
+		if (options?.toolName !== void 0 && !isChannelProgressDraftWorkToolName(options.toolName)) return;
+		const normalized = line?.text.replace(/\s+/g, " ").trim();
+		if (streamMode === "status_final") {
+			if (!line || !normalized) {
+				await progressDraft.noteActivity();
+				return;
+			}
+			await progressDraft.pushToolProgress(line, options);
+			return;
 		}
+		if (!line || !normalized || !draftStream || !previewToolProgressEnabled || previewToolProgressSuppressed) return;
+		const nextLines = mergeChannelProgressDraftLine(legacyPreviewToolProgressLines, line, { maxLines: resolveChannelProgressDraftMaxLines(account.config) });
+		if (nextLines === legacyPreviewToolProgressLines) return;
+		legacyPreviewToolProgressLines = nextLines;
+		draftStream.update(formatChannelProgressDraftText({
+			entry: account.config,
+			lines: legacyPreviewToolProgressLines,
+			seed: progressSeed,
+			formatLine: escapeSlackMrkdwn
+		}));
+		hasStreamedMessage = true;
 	};
-	const 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 (streamFailed || reply.hasMedia || renderPlan.mode === "split" || Boolean(plannedBlocks?.length) || readSlackReplyBlocks(params.payload)?.length || !reply.hasText) {
-			await deliverNormally({
-				payload: params.payload,
-				kind: params.kind,
-				forcedThreadTs: streamSession?.threadTs ?? nativeProgressStreamThreadTs
+	const updateDraftFromPartial = (text) => {
+		const trimmed = text?.trimEnd();
+		if (!trimmed) return;
+		if (streamMode === "append") {
+			previewToolProgressSuppressed = true;
+			legacyPreviewToolProgressLines = [];
+			const next = applyAppendOnlyStreamUpdate({
+				incoming: trimmed,
+				rendered: appendRenderedText,
+				source: appendSourceText
 			});
+			appendRenderedText = next.rendered;
+			appendSourceText = next.source;
+			if (!next.changed) return;
+			draftStream?.update(next.rendered);
+			hasStreamedMessage = true;
 			return;
 		}
-		const text = reply.trimmedText;
-		let plannedThreadTs;
-		try {
-			if (!streamSession && nativeProgressStreamStartPromise) await nativeProgressStreamStartPromise;
-			if (streamFailed) {
-				await deliverNormally({
-					payload: params.payload,
-					kind: params.kind,
-					forcedThreadTs: streamSession?.threadTs ?? nativeProgressStreamThreadTs
-				});
-				return;
-			}
-			if (!streamSession) {
-				const streamThreadTs = replyPlan.nextThreadTs();
-				plannedThreadTs = streamThreadTs;
-				if (!streamThreadTs) {
-					logVerbose("slack-stream: no reply thread target for stream start, falling back to normal delivery");
-					streamFailed = true;
-					await deliverNormally({
-						payload: params.payload,
-						kind: params.kind
-					});
-					return;
-				}
-				if (deliveryTracker.hasDelivered({
-					kind: params.kind,
-					payload: params.payload,
-					threadTs: streamThreadTs,
-					textOverride: text
-				})) {
-					logVerbose("slack-stream: suppressed duplicate stream start payload");
-					return;
-				}
-				streamSession = await startSlackStream({
-					client: slackClient,
-					channel: message.channel,
-					threadTs: streamThreadTs,
-					text,
-					...slackIdentity ? { identity: slackIdentity } : {},
-					teamId: await resolveSlackStreamRecipientTeamId({
-						client: slackClient,
-						token: ctx.botToken,
-						userId: message.user,
-						fallbackTeamId: slackStreamFallbackTeamId
-					}),
-					userId: message.user
-				});
-				refreshStreamedAcknowledgements(streamSession);
-				if (streamSession.delivered) {
-					observedReplyDelivery = true;
-					if (params.kind === "final") observedFinalReplyDelivery = true;
-				}
-				if (text) rememberStreamedDelivery(params.kind, text, streamSession);
-				rememberDeliveredThreadTs(params.kind, streamThreadTs);
-				replyPlan.markSent();
-				deliveryTracker.markDelivered({
-					kind: params.kind,
-					payload: params.payload,
-					threadTs: streamThreadTs,
-					textOverride: text
-				});
-				return;
-			}
-			if (deliveryTracker.hasDelivered({
-				kind: params.kind,
-				payload: params.payload,
-				threadTs: streamSession.threadTs,
-				textOverride: text
-			})) {
-				logVerbose("slack-stream: suppressed duplicate append payload");
-				return;
-			}
-			if (text) recordStreamedDelivery(params.kind, text);
-			await appendSlackStream({
-				session: streamSession,
-				text: "\n" + text
-			});
-			refreshStreamedAcknowledgements(streamSession);
-			if (streamSession.delivered) {
-				observedReplyDelivery = true;
-				if (params.kind === "final") observedFinalReplyDelivery = true;
-			}
-			deliveryTracker.markDelivered({
-				kind: params.kind,
-				payload: params.payload,
-				threadTs: streamSession.threadTs,
-				textOverride: text
-			});
-		} catch (err) {
-			if (err instanceof SlackStreamNotDeliveredError) {
-				streamFailed = true;
-				if (streamSession) {
-					if (await deliverBufferedStreamFallback({
-						session: streamSession,
-						err,
-						payload: params.payload,
-						kind: params.kind,
-						textOverride: text
-					})) return;
-					throw err;
-				}
-				await deliverNormally({
-					payload: params.payload,
-					kind: params.kind,
-					forcedThreadTs: plannedThreadTs
-				});
-				return;
-			}
-			runtime.error?.(danger(`slack-stream: streaming API call failed: ${formatSlackError(err)}, falling back`));
-			streamFailed = true;
-			if (streamSession && streamSession.pendingText) {
-				const bufferedFallbackErr = new SlackStreamNotDeliveredError(streamSession.pendingText, "unknown");
-				if (await deliverBufferedStreamFallback({
-					session: streamSession,
-					err: bufferedFallbackErr,
-					payload: params.payload,
-					kind: params.kind,
-					textOverride: text
-				})) return;
-				throw err;
-			}
-			await deliverNormally({
-				payload: params.payload,
-				kind: params.kind,
-				forcedThreadTs: streamSession?.threadTs ?? nativeProgressStreamThreadTs ?? plannedThreadTs
-			});
-		}
+		if (streamMode === "status_final") return;
+		previewToolProgressSuppressed = true;
+		legacyPreviewToolProgressLines = [];
+		draftStream?.update(trimmed);
+		hasStreamedMessage = true;
 	};
-	let draftPreviewCommitted = false;
-	const deliverSlackPayload = async (payload, info) => {
-		if (payload.isReasoning === true) return { visibleReplySent: false };
-		if (info.kind === "final" && slackStreaming.mode === "progress" && streamMode === "status_final") {
-			const hadProgressDraft = progressDraft.hasStarted;
-			progressDraft.markFinalReplyStarted();
-			if (useNativeProgressStreaming) {
-				await waitForNativeProgressStreamStart();
-				const finalThreadTs = streamSession?.threadTs ?? nativeProgressStreamThreadTs;
-				await deliverNormally({
-					payload,
-					kind: info.kind,
-					forcedThreadTs: finalThreadTs
-				});
-				await appendNativeProgressCompletion(payload.isError === true);
-				progressDraft.markFinalReplyDelivered();
-				if (!payload.isError && hadProgressDraft && streamSession) pendingNativeProgressReceipt = progressReceipt.buildSummaryLine();
-				return;
-			}
-			if (hadProgressDraft) try {
-				await draftStream?.flush();
-			} catch (err) {
-				logVerbose(`slack: progress draft flush before final failed (${formatSlackError(err)})`);
-			}
-			const receiptChannelId = hadProgressDraft ? draftStream?.channelId() : void 0;
-			const receiptMessageId = hadProgressDraft ? draftStream?.messageId() : void 0;
-			const draftThreadTs = hadProgressDraft ? usedReplyThreadTs ?? statusThreadTs : void 0;
-			await deliverNormally({
-				payload,
-				kind: info.kind,
-				...draftThreadTs ? { forcedThreadTs: draftThreadTs } : {}
-			});
-			progressDraft.markFinalReplyDelivered();
-			if (!payload.isError && receiptChannelId && receiptMessageId && !progressReceiptCollapsed) await collapseProgressReceipt({
-				channelId: receiptChannelId,
-				messageId: receiptMessageId,
-				text: progressReceipt.buildSummaryLine(),
-				threadTs: usedReplyThreadTs ?? statusThreadTs
+	const pushReasoningProgress = async (payload) => {
+		if (!payload?.text) return;
+		if (streamMode !== "status_final") {
+			const normalized = progressDraft.mergeReasoningProgress(payload.text, { snapshot: payload.isReasoningSnapshot === true }).replace(/^_(.*)_$/su, "$1").trim();
+			if (!normalized) return;
+			await pushPreviewProgress({
+				id: "reasoning",
+				kind: "item",
+				text: normalized,
+				label: "Reasoning"
 			});
 			return;
 		}
-		if (useNativeProgressStreaming) {
-			await deliverNormally({
-				payload,
-				kind: info.kind,
-				forcedThreadTs: streamSession?.threadTs ?? nativeProgressStreamThreadTs
-			});
-			return;
-		}
-		if (useStreaming) {
-			await deliverWithStreaming({
-				payload,
-				kind: info.kind
-			});
-			return;
-		}
-		const reply = resolveSendableOutboundReplyParts(payload);
-		const ttsSupplement = getReplyPayloadTtsSupplement(payload);
-		const replySourceText = payload.text ?? ttsSupplement?.spokenText;
-		const replyRenderPlan = resolveSlackReplyRenderPlan(payload, replySourceText);
-		const slackBlocks = replyRenderPlan.mode === "single" ? replyRenderPlan.blocks : replyRenderPlan.blockPart?.blocks;
-		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 shouldRestoreTtsSupplementTextForPreviewFallback = Boolean(ttsSupplement) && ttsSupplement?.visibleTextAlreadyDelivered !== true && Boolean(draftStream) && !draftPreviewCommitted && !observedFinalReplyDelivery && previewStreamingEnabled && !payload.text?.trim();
-		if (info.kind === "final" && ttsSupplement && draftStream && !draftPreviewCommitted && !observedFinalReplyDelivery && previewStreamingEnabled && !payload.isError && !requiresSeparateFallbackDelivery && trimmedFinalText.length > 0) {
-			const channelId = draftStream.channelId();
-			const messageId = draftStream.messageId();
-			if (channelId && messageId) {
-				const finalThreadTs = 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 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 = true;
-				observedFinalReplyDelivery = true;
-				observedReplyDelivery = true;
-				replyPlan.markSent();
-				await deliverNormally({
-					payload: buildTtsSupplementMediaPayload(payload),
-					kind: info.kind,
-					forcedThreadTs: finalThreadTs
+		progressReceipt.noteReasoning();
+		await progressDraft.pushReasoningProgress(payload.text, { snapshot: payload.isReasoningSnapshot === true });
+	};
+	const resetDraftDeliveryState = () => {
+		hasStreamedMessage = false;
+		appendRenderedText = "";
+		appendSourceText = "";
+	};
+	const resetDraftProgressState = () => {
+		progressDraft.resetReasoningProgress();
+		previewToolProgressSuppressed = false;
+		legacyPreviewToolProgressLines = [];
+	};
+	const beginNewProgressTurn = async (options) => {
+		const completionChunks = useNativeProgressStreaming && !nativeProgressCompletionSent ? buildNativeProgressCompletionChunks(nativeProgressTerminalStatus) : void 0;
+		if (!progressDraft.beginNewTurn(options)) return false;
+		if (useNativeProgressStreaming) await finishNativeProgressTurn(completionChunks);
+		else draftStream?.forceNewMessage();
+		resetProgressTurnState();
+		nativeTaskState = /* @__PURE__ */ new Map();
+		nativeProgressCompletionSent = false;
+		nativeProgressTerminalStatus = "complete";
+		nativeProgressChunkKey = void 0;
+		resetPreviewDeliveryState();
+		delivery.resetDeliveryTracker();
+		progressReceiptCollapsed = false;
+		return true;
+	};
+	return {
+		draftStream,
+		streamMode,
+		useNativeProgressStreaming,
+		progressDraftActive,
+		previewToolProgressEnabled,
+		suppressDefaultToolProgressMessages,
+		progressDraft,
+		commentaryProgressEnabled,
+		progressReceipt,
+		get progressReceiptCollapsed() {
+			return progressReceiptCollapsed;
+		},
+		get pendingNativeProgressReceipt() {
+			return pendingNativeProgressReceipt;
+		},
+		set pendingNativeProgressReceipt(value) {
+			pendingNativeProgressReceipt = value;
+		},
+		get nativeProgressCompletionSent() {
+			return nativeProgressCompletionSent;
+		},
+		set nativeProgressCompletionSent(value) {
+			nativeProgressCompletionSent = value;
+		},
+		get nativeProgressTerminalStatus() {
+			return nativeProgressTerminalStatus;
+		},
+		appendNativeProgressCompletion,
+		beginNewProgressTurn,
+		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();
+		},
+		pushPlanProgress,
+		pushPreviewProgress,
+		pushReasoningProgress,
+		updateDraftFromPartial,
+		waitForNativeProgressStreamStart,
+		setShouldYieldDraftProgress: (value) => {
+			shouldYieldDraftProgress = value;
+		},
+		shouldYieldDraftProgress: () => shouldYieldDraftProgress()
+	};
+}
+//#endregion
+//#region extensions/slack/src/threading.ts
+function resolveSlackThreadContext(params) {
+	const incomingThreadTs = params.message.thread_ts;
+	const eventTs = params.message.event_ts;
+	const messageTs = params.message.ts ?? eventTs;
+	const hasThreadTs = typeof incomingThreadTs === "string" && incomingThreadTs.length > 0;
+	const isThreadReply = hasThreadTs && (incomingThreadTs !== messageTs || Boolean(params.message.parent_user_id));
+	const replyToId = isThreadReply ? incomingThreadTs : void 0;
+	const isAssistantDmThreadRoot = hasThreadTs && !isThreadReply && params.isDirectMessage === true;
+	return {
+		incomingThreadTs,
+		messageTs,
+		isThreadReply,
+		replyToId,
+		messageThreadId: isThreadReply || isAssistantDmThreadRoot ? incomingThreadTs : params.replyToMode === "all" ? messageTs : void 0
+	};
+}
+/**
+* Resolves Slack thread targeting for replies and status indicators.
+*
+* @returns replyThreadTs - Thread timestamp for reply messages
+* @returns statusThreadTs - Thread timestamp for status indicators (typing, etc.)
+* @returns isThreadReply - true if this is a genuine user reply in a thread,
+*                          false if thread_ts comes from a bot status message (e.g. typing indicator)
+*/
+function resolveSlackThreadTargets(params) {
+	const { incomingThreadTs, messageTs, isThreadReply } = resolveSlackThreadContext(params);
+	const replyThreadTs = isThreadReply ? incomingThreadTs : params.replyToMode === "all" ? messageTs : void 0;
+	return {
+		replyThreadTs,
+		statusThreadTs: replyThreadTs,
+		isThreadReply
+	};
+}
+//#endregion
+//#region extensions/slack/src/monitor/message-handler/dispatch-setup.ts
+async function createSlackDispatchSetup(prepared) {
+	const { ctx, account, message, route } = prepared;
+	const slackClient = prepared.eventScope?.client ?? ctx.app.client;
+	const slackStreamFallbackTeamId = prepared.eventScope?.teamId ?? ctx.teamId;
+	const cfg = ctx.cfg;
+	const runtime = ctx.runtime;
+	const outboundIdentity = resolveAgentOutboundIdentity(cfg, route.agentId);
+	const slackIdentity = outboundIdentity ? {
+		username: outboundIdentity.name,
+		iconUrl: outboundIdentity.avatarUrl,
+		iconEmoji: outboundIdentity.emoji
+	} : prepared.relayIdentity;
+	if (prepared.isDirectMessage) {
+		const sessionCfg = cfg.session;
+		const storePath = resolveStorePath(sessionCfg?.store, { agentId: route.agentId });
+		const pinnedMainDmOwner = resolvePinnedMainDmOwnerFromAllowlist({
+			dmScope: cfg.session?.dmScope,
+			allowFrom: ctx.allowFrom,
+			normalizeEntry: normalizeSlackAllowOwnerEntry
+		});
+		const senderRecipient = normalizeOptionalLowercaseString(message.user);
+		const inboundLastRouteSessionKey = resolveInboundLastRouteSessionKey({
+			route,
+			sessionKey: prepared.ctxPayload.SessionKey ?? route.sessionKey
+		});
+		if (inboundLastRouteSessionKey === route.mainSessionKey && pinnedMainDmOwner && senderRecipient && normalizeOptionalLowercaseString(pinnedMainDmOwner) !== senderRecipient) logVerbose(`slack: skip main-session last route for ${senderRecipient} (pinned owner ${pinnedMainDmOwner})`);
+		else await updateLastRoute({
+			storePath,
+			sessionKey: inboundLastRouteSessionKey,
+			deliveryContext: {
+				channel: "slack",
+				to: `user:${message.user}`,
+				accountId: route.accountId,
+				threadId: prepared.ctxPayload.MessageThreadId ?? prepared.ctxPayload.TransportThreadId
+			},
+			ctx: prepared.ctxPayload
+		});
+	}
+	const threadTargets = resolveSlackThreadTargets({
+		message,
+		replyToMode: prepared.replyToMode
+	});
+	const forcedReplyThreadTs = prepared.forcedReplyThreadTs;
+	const slackMessageMetadata = prepared.slackMessageMetadata;
+	const statusThreadTs = forcedReplyThreadTs ?? threadTargets.statusThreadTs;
+	const isThreadReply = threadTargets.isThreadReply;
+	const replyDeliveryMode = forcedReplyThreadTs ? "off" : prepared.replyToMode;
+	const sourceReplyDeliveryMode = resolveChannelMessageSourceReplyDeliveryMode({
+		cfg,
+		ctx: prepared.ctxPayload
+	});
+	const sourceRepliesAreToolOnly = sourceReplyDeliveryMode === "message_tool_only";
+	const suppressRoomEventTyping = prepared.ctxPayload.InboundEventKind === "room_event";
+	const messageSentHookTarget = prepared.ctxPayload.OriginatingTo ?? prepared.ctxPayload.To ?? prepared.replyTarget;
+	const messageSentHookContext = {
+		sessionKeyForInternalHooks: prepared.ctxPayload.SessionKey ?? route.sessionKey,
+		isGroup: prepared.isRoomish,
+		groupId: prepared.isRoomish ? message.channel : void 0
+	};
+	const messageSentDeliveryHookContext = {
+		...messageSentHookContext,
+		messageSentHookTarget
+	};
+	const reactionMessageTs = prepared.ackReactionMessageTs;
+	const messageTs = message.ts ?? message.event_ts;
+	const incomingThreadTs = message.thread_ts;
+	let didSetStatus = false;
+	const statusReactionsEnabled = prepared.ctxPayload.InboundEventKind !== "room_event" && Boolean(prepared.ackReactionPromise) && Boolean(reactionMessageTs) && cfg.messages?.statusReactions?.enabled === true;
+	const statusReactions = createStatusReactionController({
+		enabled: statusReactionsEnabled,
+		adapter: {
+			setReaction: async (emoji) => {
+				await reactSlackMessage(message.channel, reactionMessageTs ?? "", emoji, {
+					token: ctx.botToken,
+					client: slackClient
+				}).catch((err) => {
+					if (formatErrorMessage(err).includes("already_reacted")) return;
+					throw err;
 				});
-				markPreviewPayloadDelivered({
-					kind: info.kind,
-					payload,
-					threadTs: finalThreadTs
+			},
+			removeReaction: async (emoji) => {
+				await removeSlackReaction(message.channel, reactionMessageTs ?? "", emoji, {
+					token: ctx.botToken,
+					client: slackClient
+				}).catch((err) => {
+					if (formatErrorMessage(err).includes("no_reaction")) return;
+					throw err;
 				});
-				return;
 			}
+		},
+		initialEmoji: prepared.ackReactionValue || "eyes",
+		emojis: void 0,
+		timing: DEFAULT_TIMING,
+		onError: (err) => {
+			logAckFailure({
+				log: logVerbose,
+				channel: "slack",
+				target: `${message.channel}/${message.ts}`,
+				error: err
+			});
 		}
-		await deliverWithFinalizableLivePreviewAdapter({
-			kind: info.kind,
-			payload,
-			adapter: defineFinalizableLivePreviewAdapter({
-				draft: draftStream && !draftPreviewCommitted && !observedFinalReplyDelivery ? {
-					flush: draftStream.flush,
-					clear: draftStream.clear,
-					discardPending: draftStream.discardPending,
-					seal: draftStream.seal,
-					id: () => {
-						const channelId = draftStream.channelId();
-						const messageId = draftStream.messageId();
-						return channelId && messageId ? {
-							channelId,
-							messageId
-						} : void 0;
-					}
-				} : void 0,
-				buildFinalEdit: () => {
-					if (!previewStreamingEnabled || reply.hasMedia && !ttsSupplement || payload.isError || requiresSeparateFallbackDelivery || trimmedFinalText.length === 0 && !slackBlocks?.length) return;
-					return {
-						text: previewFinalText,
-						blocks: slackBlocks,
-						threadTs: usedReplyThreadTs ?? statusThreadTs
-					};
-				},
-				editFinal: async (preview, edit) => {
-					if (deliveryTracker.hasDelivered({
-						kind: info.kind,
-						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) emitSlackMessageSentHooks({
-						...messageSentHookContext,
-						to: messageSentHookTarget,
-						accountId: account.accountId,
-						content: trimmedFinalText,
-						success: true,
-						messageId: preview.messageId
-					});
-					draftPreviewCommitted = true;
-					observedFinalReplyDelivery = true;
-				},
-				onPreviewFinalized: (_preview) => {
-					draftPreviewCommitted = true;
-					observedFinalReplyDelivery = true;
-					const finalThreadTs = usedReplyThreadTs ?? statusThreadTs;
-					observedReplyDelivery = true;
-					replyPlan.markSent();
-					if (!ttsSupplement) markPreviewPayloadDelivered({
-						kind: info.kind,
-						payload,
-						threadTs: finalThreadTs
-					});
-				},
-				buildSupplementalPayload: () => ttsSupplement ? buildTtsSupplementMediaPayload(payload) : void 0,
-				deliverSupplemental: async (supplementalPayload) => {
-					const previewThreadTs = usedReplyThreadTs ?? statusThreadTs;
-					const supplementalThreadTs = await deliverNormally({
-						payload: supplementalPayload,
-						kind: info.kind,
-						forcedThreadTs: previewThreadTs
-					});
-					markPreviewPayloadDelivered({
-						kind: info.kind,
-						payload,
-						threadTs: supplementalThreadTs
-					});
-				},
-				logPreviewEditFailure: (err) => {
-					logVerbose(`slack: preview final edit failed; falling back to standard send (${formatSlackError(err)})`);
-				}
-			}),
-			deliverNormally: async () => {
-				await deliverNormally({
-					payload: shouldRestoreTtsSupplementTextForPreviewFallback ? {
-						...payload,
-						text: ttsSupplement?.spokenText
-					} : payload,
-					kind: info.kind
+	});
+	if (statusReactionsEnabled) statusReactions.setQueued();
+	const hasRepliedRef = { value: false };
+	const replyPlan = createSlackReplyDeliveryPlan({
+		replyToMode: replyDeliveryMode,
+		incomingThreadTs: forcedReplyThreadTs ?? incomingThreadTs,
+		messageTs,
+		hasRepliedRef,
+		isThreadReply: Boolean(forcedReplyThreadTs) || isThreadReply
+	});
+	const typingTarget = statusThreadTs ? `${message.channel}/${statusThreadTs}` : message.channel;
+	const typingReaction = ctx.typingReaction;
+	const { onModelSelected, ...replyPipeline } = createChannelMessageReplyPipeline({
+		cfg,
+		agentId: route.agentId,
+		channel: "slack",
+		accountId: route.accountId,
+		transformReplyPayload: (payload) => {
+			if (payload.isReasoning === true) return null;
+			return payload;
+		},
+		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)}`);
+				});
+			},
+			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)}`);
+				});
+			},
+			onStartError: (err) => {
+				logTypingFailure({
+					log: (messageValue) => runtime.error?.(danger(messageValue)),
+					channel: "slack",
+					action: "start",
+					target: typingTarget,
+					error: err
+				});
+			},
+			onStopError: (err) => {
+				logTypingFailure({
+					log: (messageLocal) => runtime.error?.(danger(messageLocal)),
+					channel: "slack",
+					action: "stop",
+					target: typingTarget,
+					error: err
 				});
 			}
-		});
+		}
+	});
+	const slackStreaming = resolveSlackStreamingConfig({
+		streaming: account.config.streaming,
+		nativeStreaming: resolveChannelStreamingNativeTransport(account.config)
+	});
+	const streamThreadHint = forcedReplyThreadTs ?? resolveSlackStreamingThreadHint({
+		replyToMode: replyDeliveryMode,
+		incomingThreadTs,
+		messageTs,
+		isThreadReply
+	});
+	const previewStreamingEnabled = !sourceRepliesAreToolOnly && shouldEnableSlackPreviewStreaming({ mode: slackStreaming.mode });
+	const hasSlackCustomIdentity = Boolean(slackIdentity?.username || slackIdentity?.iconUrl || slackIdentity?.iconEmoji);
+	const useStreaming = shouldUseStreaming({
+		streamingEnabled: !sourceRepliesAreToolOnly && isSlackStreamingEnabled({
+			mode: slackStreaming.mode,
+			nativeStreaming: slackStreaming.nativeStreaming,
+			nativeProgressTaskCards: resolveSlackNativeProgressTaskCards(account.config)
+		}),
+		threadTs: streamThreadHint
+	});
+	const shouldUseDraftStream = !hasSlackCustomIdentity && shouldInitializeSlackDraftStream({
+		previewStreamingEnabled,
+		useStreaming
+	});
+	const blockStreamingEnabled = resolveChannelStreamingBlockEnabled(account.config);
+	const disableBlockStreaming = sourceRepliesAreToolOnly ? true : resolveSlackDisableBlockStreaming({
+		useStreaming,
+		shouldUseDraftStream,
+		blockStreamingEnabled
+	});
+	const onSlackDeliveryError = (err, info) => {
+		runtime.error?.(danger(`slack ${info.kind} reply failed: ${formatSlackError(err)}`));
+		replyPipeline.typingCallbacks?.onIdle?.();
+	};
+	return {
+		prepared,
+		ctx,
+		account,
+		message,
+		route,
+		slackClient,
+		slackStreamFallbackTeamId,
+		cfg,
+		runtime,
+		slackIdentity,
+		forcedReplyThreadTs,
+		slackMessageMetadata,
+		statusThreadTs,
+		isThreadReply,
+		replyDeliveryMode,
+		sourceReplyDeliveryMode,
+		sourceRepliesAreToolOnly,
+		suppressRoomEventTyping,
+		messageSentHookTarget,
+		messageSentHookContext,
+		messageSentDeliveryHookContext,
+		incomingThreadTs,
+		messageTs,
+		statusReactionsEnabled,
+		statusReactions,
+		hasRepliedRef,
+		replyPlan,
+		onModelSelected,
+		replyPipeline,
+		slackStreaming,
+		streamThreadHint,
+		previewStreamingEnabled,
+		shouldUseDraftStream,
+		disableBlockStreaming,
+		useStreaming,
+		onSlackDeliveryError
 	};
-	const onSlackDeliveryError = (err, info) => {
-		runtime.error?.(danger(`slack ${info.kind} reply failed: ${formatSlackError(err)}`));
-		replyPipeline.typingCallbacks?.onIdle?.();
+}
+//#endregion
+//#region extensions/slack/src/monitor/message-handler/dispatch-streaming.ts
+function createSlackStreamingDeliveryRuntime(setup) {
+	const { account, ctx, forcedReplyThreadTs, isThreadReply, message, messageSentDeliveryHookContext, messageSentHookContext, messageSentHookTarget, prepared, replyDeliveryMode, replyPlan, runtime, slackClient, slackIdentity, slackMessageMetadata, slackStreamFallbackTeamId } = setup;
+	const state = {
+		streamSession: null,
+		nativeProgressStreamStartPromise: null,
+		nativeProgressStreamThreadTs: void 0,
+		streamFailed: false,
+		usedReplyThreadTs: void 0,
+		usedBlockReplyThreadTs: void 0,
+		observedReplyDelivery: false,
+		observedFinalReplyDelivery: false
 	};
-	const draftStream = shouldUseDraftStream ? createSlackDraftStream({
-		target: prepared.replyTarget,
-		cfg,
-		token: ctx.botToken,
-		accountId: account.accountId,
-		...prepared.eventScope ? { eventScope: prepared.eventScope } : {},
-		identity: slackIdentity,
-		...slackMessageMetadata ? { metadata: slackMessageMetadata } : {},
-		maxChars: Math.min(ctx.textLimit, SLACK_TEXT_LIMIT),
-		resolveThreadTs: () => {
-			const ts = replyPlan.peekThreadTs();
-			if (ts) usedReplyThreadTs ??= ts;
-			return ts;
-		},
-		log: logVerbose,
-		warn: logVerbose
-	}) : void 0;
-	let hasStreamedMessage = false;
-	const streamMode = slackStreaming.draftMode;
-	const useNativeProgressStreaming = useStreaming && slackStreaming.mode === "progress";
-	const progressDraftActive = Boolean(draftStream) || useNativeProgressStreaming;
-	const previewToolProgressEnabled = progressDraftActive && resolveChannelStreamingPreviewToolProgress(account.config);
-	let shouldYieldDraftProgress = () => false;
-	const suppressDefaultToolProgressMessages = resolveChannelStreamingSuppressDefaultToolProgressMessages(account.config, {
-		draftStreamActive: Boolean(draftStream) || useNativeProgressStreaming,
-		previewToolProgressEnabled,
-		previewStreamingEnabled
-	});
-	let previewToolProgressSuppressed = false;
-	let legacyPreviewToolProgressLines = [];
-	let nativeTaskState = /* @__PURE__ */ new Map();
-	let appendRenderedText = "";
-	let appendSourceText = "";
-	let nativeProgressCompletionSent = false;
-	let nativeProgressTerminalStatus = "complete";
-	let nativeProgressChunkKey;
-	const progressReceipt = createChannelProgressReceiptTracker();
-	let progressReceiptCollapsed = false;
-	let pendingNativeProgressReceipt;
-	const progressSeed = `${account.accountId}:${message.channel}`;
-	const useRichProgressDraft = streamMode === "status_final" && resolveChannelProgressDraftRender(account.config) === "rich";
-	const explicitProgressTitle = resolveExplicitSlackProgressTitle(account.config);
-	const progressDraftMaxLineChars = resolveChannelProgressDraftMaxLineChars(account.config);
-	const waitForNativeProgressStreamStart = async () => {
-		if (streamSession || !nativeProgressStreamStartPromise) return true;
-		try {
-			await nativeProgressStreamStartPromise;
-		} catch {
-			streamFailed = true;
-			return false;
-		}
-		return !streamFailed;
+	const streamedDeliveries = [];
+	const streamedFailuresOwnedByDispatcher = {
+		tool: 0,
+		block: 0,
+		final: 0
 	};
-	const resolveStructuredProgressLines = (lines) => lines.map((line) => {
-		if (typeof line !== "string") return line;
-		const reasoning = line.startsWith("🧠 ");
-		const text = line.replace(/^(?:🧠|💬)\s+/u, "").replace(/^_(.*)_$/su, "$1").trim();
-		return {
-			...reasoning ? { id: "reasoning" } : {},
-			kind: "item",
-			text,
-			label: reasoning ? "Reasoning" : "Update",
-			prefix: false
+	const refreshStreamedAcknowledgements = (session) => {
+		if (session.pendingText.length === 0) for (const delivery of streamedDeliveries) delivery.acknowledged = true;
+	};
+	const recordStreamedDelivery = (kind, content) => {
+		const delivery = {
+			kind,
+			content,
+			acknowledged: false
 		};
-	});
-	const resolveNativeProgressPlan = (snapshot) => snapshot.plan?.length ? snapshot.plan : void 0;
-	const resolveNativeProgressLines = (snapshot) => {
-		const lines = resolveStructuredProgressLines(snapshot.lines);
-		if (snapshot.plan?.length || !snapshot.planExplanation) return lines;
-		const explanationLine = buildChannelProgressDraftLine({
-			event: "plan",
-			phase: "update",
-			explanation: snapshot.planExplanation
-		});
-		return explanationLine ? [...lines, explanationLine] : lines;
+		streamedDeliveries.push(delivery);
+		return delivery;
 	};
-	const combineProgressHeadlineAndExplanation = (headline, explanation) => headline && explanation && headline !== explanation ? `${headline} — ${explanation}` : headline ?? explanation;
-	const resolveNativeProgressTitle = (snapshot) => combineProgressHeadlineAndExplanation(explicitProgressTitle ?? snapshot.statusHeadline, snapshot.planExplanation);
-	const buildNativeProgressChunks = (snapshot) => streamSession ? buildSlackProgressStreamUpdateChunks({
-		title: resolveNativeProgressTitle(snapshot),
-		lines: resolveNativeProgressLines(snapshot),
-		plan: resolveNativeProgressPlan(snapshot),
-		maxLineChars: progressDraftMaxLineChars
-	}) : buildSlackProgressStreamStartChunks({
-		title: resolveNativeProgressTitle(snapshot),
-		lines: resolveNativeProgressLines(snapshot),
-		plan: resolveNativeProgressPlan(snapshot),
-		maxLineChars: progressDraftMaxLineChars
-	});
-	const markNativeProgressDelivered = (session, threadTs) => {
-		if (session.delivered) observedReplyDelivery = true;
-		if (threadTs) {
-			usedReplyThreadTs ??= threadTs;
-			rememberDeliveredThreadTs("block", threadTs);
+	const rememberStreamedDelivery = (kind, content, session) => {
+		recordStreamedDelivery(kind, content);
+		refreshStreamedAcknowledgements(session);
+	};
+	const emitAcknowledgedStreamedDeliveries = (messageId) => {
+		for (const delivery of streamedDeliveries) {
+			if (!delivery.acknowledged || delivery.outcome) continue;
+			emitSlackMessageSentHooks({
+				...messageSentHookContext,
+				to: messageSentHookTarget,
+				accountId: account.accountId,
+				content: delivery.content,
+				success: true,
+				...messageId ? { messageId } : {}
+			});
+			delivery.outcome = "success";
 		}
 	};
-	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");
-			streamFailed = true;
-			return;
+	const acknowledgeStoppedStreamedDeliveries = (session, messageId) => {
+		refreshStreamedAcknowledgements(session);
+		for (const delivery of streamedDeliveries) delivery.acknowledged = true;
+		emitAcknowledgedStreamedDeliveries(messageId);
+	};
+	const emitFailedPendingStreamedDeliveries = (error) => {
+		for (const delivery of streamedDeliveries) {
+			if (delivery.acknowledged || delivery.outcome) continue;
+			emitSlackMessageSentHooks({
+				...messageSentHookContext,
+				to: messageSentHookTarget,
+				accountId: account.accountId,
+				content: delivery.content,
+				success: false,
+				error
+			});
+			delivery.outcome = "failure";
 		}
-		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
+	};
+	const emitSuccessfulPendingStreamedDeliveries = (messageId) => {
+		for (const delivery of streamedDeliveries) {
+			if (delivery.acknowledged || delivery.outcome) continue;
+			emitSlackMessageSentHooks({
+				...messageSentHookContext,
+				to: messageSentHookTarget,
+				accountId: account.accountId,
+				content: delivery.content,
+				success: true,
+				...messageId ? { messageId } : {}
 			});
-			streamSession = session;
-			return session;
-		})();
-		nativeProgressStreamStartPromise = startPromise;
-		let startedSession;
+			delivery.outcome = "success";
+		}
+	};
+	let deliveryTracker = createSlackEventDeliveryTracker();
+	const markPreviewPayloadDelivered = (params) => {
+		deliveryTracker.markDelivered(params);
+		const nextThreadTs = replyPlan.peekThreadTs();
+		if (nextThreadTs !== params.threadTs) deliveryTracker.markDelivered({
+			...params,
+			threadTs: nextThreadTs
+		});
+	};
+	const resolveDeliveryThreadTs = (params) => {
+		const plannedThreadTs = params.forcedThreadTs ? void 0 : replyPlan.nextThreadTs();
+		return params.forcedThreadTs ?? plannedThreadTs ?? (params.kind === "block" ? state.usedBlockReplyThreadTs : void 0);
+	};
+	const rememberDeliveredThreadTs = (kind, deliveredThreadTs) => {
+		if (!deliveredThreadTs) return;
+		state.usedReplyThreadTs ??= deliveredThreadTs;
+		if (kind === "block") state.usedBlockReplyThreadTs = deliveredThreadTs;
+	};
+	const deliverPendingStreamFallback = async (session, err) => {
+		let fallbackError = err;
+		if (!session.stopped) try {
+			const stopResult = await stopSlackStream({
+				session,
+				...slackMessageMetadata ? { metadata: slackMessageMetadata } : {}
+			});
+			acknowledgeStoppedStreamedDeliveries(session, stopResult.messageId);
+			state.observedReplyDelivery = true;
+			state.usedReplyThreadTs ??= session.threadTs;
+			return true;
+		} catch (stopErr) {
+			if (stopErr instanceof SlackStreamNotDeliveredError) fallbackError = stopErr;
+			else runtime.error?.(danger(`slack-stream: failed to finalize buffered text before fallback: ${formatSlackError(stopErr)}`));
+		}
+		emitAcknowledgedStreamedDeliveries();
+		const fallbackText = fallbackError.pendingText.trim();
+		if (!fallbackText) return false;
 		try {
-			startedSession = await startPromise;
-		} finally {
-			if (nativeProgressStreamStartPromise === startPromise) nativeProgressStreamStartPromise = null;
+			await deliverReplies({
+				cfg: ctx.cfg,
+				replies: [{ text: fallbackText }],
+				target: prepared.replyTarget,
+				token: ctx.botToken,
+				accountId: account.accountId,
+				runtime,
+				textLimit: ctx.textLimit,
+				mediaMaxBytes: ctx.mediaMaxBytes,
+				replyThreadTs: session.threadTs,
+				replyToMode: replyDeliveryMode,
+				...slackIdentity ? { identity: slackIdentity } : {},
+				...slackMessageMetadata ? { metadata: slackMessageMetadata } : {},
+				...messageSentDeliveryHookContext,
+				deferMessageSentHooks: true,
+				...prepared.eventScope ? { eventScope: prepared.eventScope } : {}
+			});
+			markSlackStreamFallbackDelivered(session);
+			if (!session.stopped) try {
+				await stopSlackStream({
+					session,
+					...slackMessageMetadata ? { metadata: slackMessageMetadata } : {}
+				});
+			} catch (finalizeErr) {
+				runtime.error?.(danger(`slack-stream: failed to finalize native stream after fallback delivery: ${formatSlackError(finalizeErr)}`));
+			}
+			emitSuccessfulPendingStreamedDeliveries();
+			state.observedReplyDelivery = true;
+			state.usedReplyThreadTs ??= session.threadTs;
+			logVerbose(`slack-stream: streamed delivery failed (${fallbackError.slackCode}); delivered ${fallbackText.length} chars via deliverReplies fallback`);
+			return true;
+		} catch (postErr) {
+			emitFailedPendingStreamedDeliveries(formatErrorMessage(postErr));
+			runtime.error?.(danger(`slack-stream: fallback deliverReplies failed after ${fallbackError.slackCode}: ${formatErrorMessage(postErr)}`));
+			return false;
 		}
-		if (startedSession) markNativeProgressDelivered(startedSession, streamThreadTs);
-		nativeProgressChunkKey = chunkKey;
+	};
+	const deliverNormally = async (params) => {
+		if (params.payload.isReasoning === true) return;
+		const replyThreadTs = resolveDeliveryThreadTs(params);
+		const deliveryReplyThreadTs = replyDeliveryMode === "off" && !forcedReplyThreadTs && !isThreadReply ? void 0 : replyThreadTs;
+		if (deliveryTracker.hasDelivered({
+			kind: params.kind,
+			payload: params.payload,
+			threadTs: deliveryReplyThreadTs
+		})) {
+			logVerbose("slack: suppressed duplicate normal delivery within the same turn");
+			return deliveryReplyThreadTs;
+		}
+		await deliverReplies({
+			cfg: ctx.cfg,
+			replies: [params.payload],
+			target: prepared.replyTarget,
+			token: ctx.botToken,
+			accountId: account.accountId,
+			runtime,
+			textLimit: ctx.textLimit,
+			mediaMaxBytes: ctx.mediaMaxBytes,
+			replyThreadTs: deliveryReplyThreadTs,
+			replyToMode: replyDeliveryMode,
+			...slackIdentity ? { identity: slackIdentity } : {},
+			...slackMessageMetadata ? { metadata: slackMessageMetadata } : {},
+			...messageSentDeliveryHookContext,
+			...prepared.eventScope ? { eventScope: prepared.eventScope } : {}
+		});
+		state.observedReplyDelivery = true;
+		if (params.kind === "final") state.observedFinalReplyDelivery = true;
+		const deliveredThreadTs = resolveDeliveredSlackReplyThreadTs({
+			replyToMode: replyDeliveryMode,
+			payloadReplyToId: params.payload.replyToId,
+			replyThreadTs: deliveryReplyThreadTs
+		});
+		rememberDeliveredThreadTs(params.kind, deliveredThreadTs);
 		replyPlan.markSent();
-	};
-	const appendNativeProgressStream = async (chunks, chunkKey) => {
-		if (!streamSession) return;
-		await appendSlackStream({
-			session: streamSession,
-			chunks
+		deliveryTracker.markDelivered({
+			kind: params.kind,
+			payload: params.payload,
+			threadTs: deliveryReplyThreadTs
 		});
-		markNativeProgressDelivered(streamSession);
-		nativeProgressChunkKey = chunkKey;
+		return deliveryReplyThreadTs;
 	};
-	const updateNativeProgressStream = async () => {
-		const snapshot = progressDraft.getSnapshot();
-		const progressLines = resolveNativeProgressLines(snapshot);
-		const hasRetirableNativeTasks = [...nativeTaskState.values()].some((task) => task.status !== "complete" && task.status !== "error");
-		if (!useNativeProgressStreaming || streamFailed || progressLines.length === 0 && !snapshot.plan?.length && !snapshot.statusHeadline && !explicitProgressTitle && !hasRetirableNativeTasks) return;
-		if (!await waitForNativeProgressStreamStart()) return;
-		const reconciled = reconcileSlackNativeTaskChunks({
-			previousTasks: nativeTaskState,
-			chunks: buildNativeProgressChunks(snapshot)
-		});
-		const chunks = reconciled.chunks;
-		if (!chunks?.length) return;
-		const chunkKey = JSON.stringify(chunks);
-		if (chunkKey === nativeProgressChunkKey) return;
-		try {
-			if (!streamSession) await startNativeProgressStream(chunks, chunkKey);
-			else await appendNativeProgressStream(chunks, chunkKey);
-			nativeTaskState = reconciled.tasks;
-		} catch (err) {
-			runtime.error?.(danger(`slack-stream: native progress stream failed: ${formatSlackError(err)}, falling back`));
-			streamFailed = true;
+	const deliverBufferedStreamFallback = async (params) => {
+		if (!await deliverPendingStreamFallback(params.session, params.err)) {
+			streamedFailuresOwnedByDispatcher[params.kind] += 1;
+			return false;
 		}
+		replyPlan.markSent();
+		if (params.kind === "final") state.observedFinalReplyDelivery = true;
+		deliveryTracker.markDelivered({
+			kind: params.kind,
+			payload: params.payload,
+			threadTs: params.session.threadTs,
+			textOverride: params.textOverride
+		});
+		rememberDeliveredThreadTs(params.kind, params.session.threadTs);
+		return true;
 	};
-	const resetProgressTurnState = () => {
-		progressReceipt.reset();
-		progressReceiptCollapsed = false;
-		pendingNativeProgressReceipt = void 0;
-	};
-	const collapseProgressReceipt = async (params) => {
-		const { botToken: token } = ctx;
-		try {
-			await finalizeSlackPreviewEdit({
-				client: slackClient,
-				token,
-				accountId: account.accountId,
-				...params
+	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) {
+			await deliverNormally({
+				payload: params.payload,
+				kind: params.kind,
+				forcedThreadTs: state.streamSession?.threadTs ?? state.nativeProgressStreamThreadTs
 			});
-			progressReceiptCollapsed = true;
-		} catch (err) {
-			logVerbose(`slack: progress receipt edit failed (${formatSlackError(err)})`);
+			return;
 		}
-	};
-	const progressDraft = createChannelProgressDraftCompositor({
-		entry: account.config,
-		mode: slackStreaming.mode,
-		active: progressDraftActive && streamMode === "status_final",
-		seed: progressSeed,
-		formatLine: escapeSlackMrkdwn,
-		reasoningLinePrefix: "🧠 ",
-		commentaryLinePrefix: "💬 ",
-		reasoningGate: previewToolProgressEnabled,
-		commentaryItalics: false,
-		updateOnLineChange: useNativeProgressStreaming || useRichProgressDraft,
-		update: async (previewText, options) => {
-			if (useNativeProgressStreaming) {
-				await updateNativeProgressStream();
+		const text = reply.trimmedText;
+		let plannedThreadTs;
+		try {
+			if (!state.streamSession && state.nativeProgressStreamStartPromise) await state.nativeProgressStreamStartPromise;
+			if (state.streamFailed) {
+				await deliverNormally({
+					payload: params.payload,
+					kind: params.kind,
+					forcedThreadTs: state.streamSession?.threadTs ?? state.nativeProgressStreamThreadTs
+				});
 				return;
 			}
-			if (!draftStream) return;
-			const snapshot = progressDraft.getSnapshot();
-			const structuredLines = resolveStructuredProgressLines(options?.lines ?? snapshot.lines);
-			const richNarration = combineProgressHeadlineAndExplanation(snapshot.statusHeadline, snapshot.planExplanation);
-			const richProgressBlocks = useRichProgressDraft ? buildSlackProgressDraftBlocks({
-				title: explicitProgressTitle,
-				lines: structuredLines,
-				plan: snapshot.plan,
-				narration: richNarration,
-				maxLineChars: progressDraftMaxLineChars
-			}) : void 0;
-			draftStream.update(useRichProgressDraft && richProgressBlocks ? {
-				text: previewText,
-				blocks: richProgressBlocks
-			} : previewText);
-			hasStreamedMessage = true;
-			if (options?.flush) await draftStream.flush();
-		}
-	});
-	const commentaryProgressEnabled = progressDraft.commentaryProgressEnabled;
-	const buildNativeProgressCompletionChunks = (finalInProgressStatus) => {
-		const snapshot = progressDraft.getSnapshot();
-		const lines = resolveNativeProgressLines(snapshot);
-		const hasRetirableNativeTasks = [...nativeTaskState.values()].some((task) => task.status !== "complete" && task.status !== "error");
-		if (lines.length === 0 && !snapshot.plan?.length && !hasRetirableNativeTasks) return;
-		return reconcileSlackNativeTaskChunks({
-			previousTasks: nativeTaskState,
-			chunks: buildSlackProgressStreamCompletionChunks({
-				title: resolveNativeProgressTitle(snapshot),
-				lines,
-				plan: resolveNativeProgressPlan(snapshot),
-				maxLineChars: progressDraftMaxLineChars,
-				finalInProgressStatus
-			})
-		}).chunks;
-	};
-	const finishNativeProgressTurn = async (completionChunks) => {
-		if (nativeProgressStreamStartPromise) await nativeProgressStreamStartPromise.catch(() => null);
-		const session = streamSession;
-		if (session && !session.stopped) try {
-			if (completionChunks?.length) nativeProgressCompletionSent = true;
-			const stopResult = await stopSlackStream({
-				session,
-				...completionChunks?.length ? { chunks: completionChunks } : {},
-				...slackMessageMetadata ? { metadata: slackMessageMetadata } : {}
+			if (!state.streamSession) {
+				const streamThreadTs = replyPlan.nextThreadTs();
+				plannedThreadTs = streamThreadTs;
+				if (!streamThreadTs) {
+					logVerbose("slack-stream: no reply thread target for stream start, falling back to normal delivery");
+					state.streamFailed = true;
+					await deliverNormally({
+						payload: params.payload,
+						kind: params.kind
+					});
+					return;
+				}
+				if (deliveryTracker.hasDelivered({
+					kind: params.kind,
+					payload: params.payload,
+					threadTs: streamThreadTs,
+					textOverride: text
+				})) {
+					logVerbose("slack-stream: suppressed duplicate stream start payload");
+					return;
+				}
+				state.streamSession = await startSlackStream({
+					client: slackClient,
+					channel: message.channel,
+					threadTs: streamThreadTs,
+					text,
+					...slackIdentity ? { identity: slackIdentity } : {},
+					teamId: await resolveSlackStreamRecipientTeamId({
+						client: slackClient,
+						token: ctx.botToken,
+						userId: message.user,
+						fallbackTeamId: slackStreamFallbackTeamId
+					}),
+					userId: message.user
+				});
+				refreshStreamedAcknowledgements(state.streamSession);
+				if (state.streamSession.delivered) {
+					state.observedReplyDelivery = true;
+					if (params.kind === "final") state.observedFinalReplyDelivery = true;
+				}
+				if (text) rememberStreamedDelivery(params.kind, text, state.streamSession);
+				rememberDeliveredThreadTs(params.kind, streamThreadTs);
+				replyPlan.markSent();
+				deliveryTracker.markDelivered({
+					kind: params.kind,
+					payload: params.payload,
+					threadTs: streamThreadTs,
+					textOverride: text
+				});
+				return;
+			}
+			if (deliveryTracker.hasDelivered({
+				kind: params.kind,
+				payload: params.payload,
+				threadTs: state.streamSession.threadTs,
+				textOverride: text
+			})) {
+				logVerbose("slack-stream: suppressed duplicate append payload");
+				return;
+			}
+			if (text) recordStreamedDelivery(params.kind, text);
+			await appendSlackStream({
+				session: state.streamSession,
+				text: "\n" + text
 			});
-			acknowledgeStoppedStreamedDeliveries(session, stopResult?.messageId);
-			if (pendingNativeProgressReceipt && stopResult?.messageId) await collapseProgressReceipt({
-				channelId: session.channel,
-				messageId: stopResult.messageId,
-				text: pendingNativeProgressReceipt,
-				threadTs: session.threadTs
+			refreshStreamedAcknowledgements(state.streamSession);
+			if (state.streamSession.delivered) {
+				state.observedReplyDelivery = true;
+				if (params.kind === "final") state.observedFinalReplyDelivery = true;
+			}
+			deliveryTracker.markDelivered({
+				kind: params.kind,
+				payload: params.payload,
+				threadTs: state.streamSession.threadTs,
+				textOverride: text
 			});
 		} catch (err) {
-			const error = formatSlackError(err);
-			emitAcknowledgedStreamedDeliveries();
-			emitFailedPendingStreamedDeliveries(error);
-			logVerbose(`slack-stream: failed to rotate native progress stream (${error})`);
+			if (err instanceof SlackStreamNotDeliveredError) {
+				state.streamFailed = true;
+				if (state.streamSession) {
+					if (await deliverBufferedStreamFallback({
+						session: state.streamSession,
+						err,
+						payload: params.payload,
+						kind: params.kind,
+						textOverride: text
+					})) return;
+					throw err;
+				}
+				await deliverNormally({
+					payload: params.payload,
+					kind: params.kind,
+					forcedThreadTs: plannedThreadTs
+				});
+				return;
+			}
+			runtime.error?.(danger(`slack-stream: streaming API call failed: ${formatSlackError(err)}, falling back`));
+			state.streamFailed = true;
+			if (state.streamSession && state.streamSession.pendingText) {
+				const bufferedFallbackErr = new SlackStreamNotDeliveredError(state.streamSession.pendingText, "unknown");
+				if (await deliverBufferedStreamFallback({
+					session: state.streamSession,
+					err: bufferedFallbackErr,
+					payload: params.payload,
+					kind: params.kind,
+					textOverride: text
+				})) return;
+				throw err;
+			}
+			await deliverNormally({
+				payload: params.payload,
+				kind: params.kind,
+				forcedThreadTs: state.streamSession?.threadTs ?? state.nativeProgressStreamThreadTs ?? plannedThreadTs
+			});
 		}
-		streamSession = null;
-		nativeProgressStreamStartPromise = null;
-		nativeProgressStreamThreadTs = void 0;
-		streamFailed = false;
 	};
-	const pushPlanProgress = async (steps, explanation) => {
-		if (streamMode === "status_final") {
-			await progressDraft.pushPlanProgress(steps, { explanation });
-			return;
-		}
-		if (previewToolProgressSuppressed || !draftStream) return;
-		const text = formatChannelProgressDraftText({
-			entry: account.config,
-			lines: legacyPreviewToolProgressLines,
-			seed: progressSeed,
-			formatLine: escapeSlackMrkdwn,
-			narration: explanation,
-			plan: steps
-		});
-		if (text) {
-			draftStream.update(text);
-			hasStreamedMessage = true;
+	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;
 	};
-	const pushPreviewProgress = async (line, options) => {
-		if (!draftStream && !useNativeProgressStreaming) return;
-		if (options?.toolName !== void 0 && !isChannelProgressDraftWorkToolName(options.toolName)) return;
-		const normalized = line?.text.replace(/\s+/g, " ").trim();
-		if (streamMode === "status_final") {
-			if (!line || !normalized) {
-				await progressDraft.noteActivity();
+	return Object.assign(state, {
+		acknowledgeStoppedStreamedDeliveries,
+		deliverNormally,
+		deliverPendingStreamFallback,
+		deliverWithStreaming,
+		emitAcknowledgedStreamedDeliveries,
+		emitFailedPendingStreamedDeliveries,
+		hasDelivered: (params) => deliveryTracker.hasDelivered(params),
+		markPreviewPayloadDelivered,
+		rememberDeliveredThreadTs,
+		reconcileCounts,
+		resetDeliveryTracker: () => {
+			deliveryTracker = createSlackEventDeliveryTracker();
+		}
+	});
+}
+//#endregion
+//#region extensions/slack/src/monitor/message-handler/dispatch.ts
+async function dispatchPreparedSlackMessage(prepared) {
+	const setup = await createSlackDispatchSetup(prepared);
+	const { account, cfg, ctx, disableBlockStreaming, hasRepliedRef, message, messageSentHookContext, messageSentHookTarget, onModelSelected, onSlackDeliveryError, previewStreamingEnabled, replyPipeline, replyPlan, route, runtime, slackClient, slackMessageMetadata, slackStreaming, sourceReplyDeliveryMode, statusReactions, statusReactionsEnabled, statusThreadTs, suppressRoomEventTyping, useStreaming } = setup;
+	const delivery = createSlackStreamingDeliveryRuntime(setup);
+	const draftPreviewCommitted = { value: false };
+	const progress = createSlackProgressRuntime({
+		setup,
+		delivery,
+		resetPreviewDeliveryState: () => {
+			draftPreviewCommitted.value = false;
+			delivery.observedFinalReplyDelivery = false;
+		}
+	});
+	const draftStream = progress.draftStream;
+	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 (progress.useNativeProgressStreaming) {
+				await progress.waitForNativeProgressStreamStart();
+				const finalThreadTs = delivery.streamSession?.threadTs ?? delivery.nativeProgressStreamThreadTs;
+				await delivery.deliverNormally({
+					payload,
+					kind: info.kind,
+					forcedThreadTs: finalThreadTs
+				});
+				await progress.appendNativeProgressCompletion(payload.isError === true);
+				progress.progressDraft.markFinalReplyDelivered();
+				if (!payload.isError && hadProgressDraft && delivery.streamSession) progress.pendingNativeProgressReceipt = progress.progressReceipt.buildSummaryLine();
 				return;
 			}
-			await progressDraft.pushToolProgress(line, options);
+			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 (!line || !normalized || !draftStream || !previewToolProgressEnabled || previewToolProgressSuppressed) return;
-		const nextLines = mergeChannelProgressDraftLine(legacyPreviewToolProgressLines, line, { maxLines: resolveChannelProgressDraftMaxLines(account.config) });
-		if (nextLines === legacyPreviewToolProgressLines) return;
-		legacyPreviewToolProgressLines = nextLines;
-		draftStream.update(formatChannelProgressDraftText({
-			entry: account.config,
-			lines: legacyPreviewToolProgressLines,
-			seed: progressSeed,
-			formatLine: escapeSlackMrkdwn
-		}));
-		hasStreamedMessage = true;
-	};
-	const updateDraftFromPartial = (text) => {
-		const trimmed = text?.trimEnd();
-		if (!trimmed) return;
-		if (streamMode === "append") {
-			previewToolProgressSuppressed = true;
-			legacyPreviewToolProgressLines = [];
-			const next = applyAppendOnlyStreamUpdate({
-				incoming: trimmed,
-				rendered: appendRenderedText,
-				source: appendSourceText
+		if (progress.useNativeProgressStreaming) {
+			await delivery.deliverNormally({
+				payload,
+				kind: info.kind,
+				forcedThreadTs: delivery.streamSession?.threadTs ?? delivery.nativeProgressStreamThreadTs
 			});
-			appendRenderedText = next.rendered;
-			appendSourceText = next.source;
-			if (!next.changed) return;
-			draftStream?.update(next.rendered);
-			hasStreamedMessage = true;
 			return;
 		}
-		if (streamMode === "status_final") return;
-		previewToolProgressSuppressed = true;
-		legacyPreviewToolProgressLines = [];
-		draftStream?.update(trimmed);
-		hasStreamedMessage = true;
-	};
-	const pushReasoningProgress = async (payload) => {
-		if (!payload?.text) return;
-		if (streamMode !== "status_final") {
-			const normalized = progressDraft.mergeReasoningProgress(payload.text, { snapshot: payload.isReasoningSnapshot === true }).replace(/^_(.*)_$/su, "$1").trim();
-			if (!normalized) return;
-			await pushPreviewProgress({
-				id: "reasoning",
-				kind: "item",
-				text: normalized,
-				label: "Reasoning"
+		if (useStreaming) {
+			await delivery.deliverWithStreaming({
+				payload,
+				kind: info.kind
 			});
 			return;
 		}
-		progressReceipt.noteReasoning();
-		await progressDraft.pushReasoningProgress(payload.text, { snapshot: payload.isReasoningSnapshot === true });
-	};
-	const resetDraftDeliveryState = () => {
-		hasStreamedMessage = false;
-		appendRenderedText = "";
-		appendSourceText = "";
-	};
-	const resetDraftProgressState = () => {
-		progressDraft.resetReasoningProgress();
-		previewToolProgressSuppressed = false;
-		legacyPreviewToolProgressLines = [];
-	};
-	const beginNewProgressTurn = async (options) => {
-		const completionChunks = useNativeProgressStreaming && !nativeProgressCompletionSent ? buildNativeProgressCompletionChunks(nativeProgressTerminalStatus) : void 0;
-		if (!progressDraft.beginNewTurn(options)) return false;
-		if (useNativeProgressStreaming) await finishNativeProgressTurn(completionChunks);
-		else draftStream?.forceNewMessage();
-		resetProgressTurnState();
-		nativeTaskState = /* @__PURE__ */ new Map();
-		nativeProgressCompletionSent = false;
-		nativeProgressTerminalStatus = "complete";
-		nativeProgressChunkKey = void 0;
-		draftPreviewCommitted = false;
-		observedFinalReplyDelivery = false;
-		deliveryTracker = createSlackEventDeliveryTracker();
-		progressReceiptCollapsed = false;
-		return true;
-	};
-	const onDraftBoundary = !shouldUseDraftStream && !useNativeProgressStreaming ? void 0 : async () => {
-		if (streamMode === "status_final") {
-			await beginNewProgressTurn();
-			return;
+		const reply = resolveSendableOutboundReplyParts(payload);
+		const ttsSupplement = getReplyPayloadTtsSupplement(payload);
+		const replySourceText = payload.text ?? ttsSupplement?.spokenText;
+		const replyRenderPlan = resolveSlackReplyRenderPlan(payload, replySourceText);
+		const slackBlocks = replyRenderPlan.mode === "single" ? replyRenderPlan.blocks : replyRenderPlan.blockPart?.blocks;
+		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 shouldRestoreTtsSupplementTextForPreviewFallback = Boolean(ttsSupplement) && ttsSupplement?.visibleTextAlreadyDelivered !== true && Boolean(draftStream) && !draftPreviewCommitted.value && !delivery.observedFinalReplyDelivery && previewStreamingEnabled && !payload.text?.trim();
+		if (info.kind === "final" && ttsSupplement && draftStream && !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;
+			}
 		}
-		if (hasStreamedMessage) draftStream?.forceNewMessage();
-		resetDraftDeliveryState();
-		resetDraftProgressState();
-	};
-	const onQueuedFollowupAdmitted = !shouldUseDraftStream && !useNativeProgressStreaming ? void 0 : async () => {
-		await draftStream?.flush();
-		draftPreviewCommitted = false;
-		observedFinalReplyDelivery = false;
-		if (streamMode === "status_final") await beginNewProgressTurn({ force: true });
-		else draftStream?.forceNewMessage();
-		deliveryTracker = createSlackEventDeliveryTracker();
-		resetDraftDeliveryState();
-		resetDraftProgressState();
+		await deliverWithFinalizableLivePreviewAdapter({
+			kind: info.kind,
+			payload,
+			adapter: defineFinalizableLivePreviewAdapter({
+				draft: draftStream && !draftPreviewCommitted.value && !delivery.observedFinalReplyDelivery ? {
+					flush: draftStream.flush,
+					clear: draftStream.clear,
+					discardPending: draftStream.discardPending,
+					seal: draftStream.seal,
+					id: () => {
+						const channelId = draftStream.channelId();
+						const messageId = draftStream.messageId();
+						return channelId && messageId ? {
+							channelId,
+							messageId
+						} : void 0;
+					}
+				} : void 0,
+				buildFinalEdit: () => {
+					if (!previewStreamingEnabled || reply.hasMedia && !ttsSupplement || payload.isError || requiresSeparateFallbackDelivery || trimmedFinalText.length === 0 && !slackBlocks?.length) return;
+					return {
+						text: previewFinalText,
+						blocks: slackBlocks,
+						threadTs: delivery.usedReplyThreadTs ?? statusThreadTs
+					};
+				},
+				editFinal: async (preview, edit) => {
+					if (delivery.hasDelivered({
+						kind: info.kind,
+						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) emitSlackMessageSentHooks({
+						...messageSentHookContext,
+						to: messageSentHookTarget,
+						accountId: account.accountId,
+						content: trimmedFinalText,
+						success: true,
+						messageId: preview.messageId
+					});
+					draftPreviewCommitted.value = true;
+					delivery.observedFinalReplyDelivery = true;
+				},
+				onPreviewFinalized: (_preview) => {
+					draftPreviewCommitted.value = true;
+					delivery.observedFinalReplyDelivery = true;
+					const finalThreadTs = delivery.usedReplyThreadTs ?? statusThreadTs;
+					delivery.observedReplyDelivery = true;
+					replyPlan.markSent();
+					if (!ttsSupplement) delivery.markPreviewPayloadDelivered({
+						kind: info.kind,
+						payload,
+						threadTs: finalThreadTs
+					});
+				},
+				buildSupplementalPayload: () => ttsSupplement ? buildTtsSupplementMediaPayload(payload) : void 0,
+				deliverSupplemental: async (supplementalPayload) => {
+					const previewThreadTs = delivery.usedReplyThreadTs ?? statusThreadTs;
+					const supplementalThreadTs = await delivery.deliverNormally({
+						payload: supplementalPayload,
+						kind: info.kind,
+						forcedThreadTs: previewThreadTs
+					});
+					delivery.markPreviewPayloadDelivered({
+						kind: info.kind,
+						payload,
+						threadTs: supplementalThreadTs
+					});
+				},
+				logPreviewEditFailure: (err) => {
+					logVerbose(`slack: preview final edit failed; falling back to standard send (${formatSlackError(err)})`);
+				}
+			}),
+			deliverNormally: async () => {
+				await delivery.deliverNormally({
+					payload: shouldRestoreTtsSupplementTextForPreviewFallback ? {
+						...payload,
+						text: ttsSupplement?.spokenText
+					} : payload,
+					kind: info.kind
+				});
+			}
+		});
 	};
 	let dispatchError;
 	let queuedFinal = false;
@@ -2110,33 +2263,33 @@ async function dispatchPreparedSlackMessage(prepared) {
 				hasRepliedRef,
 				disableBlockStreaming,
 				onModelSelected,
-				suppressDefaultToolProgressMessages: suppressDefaultToolProgressMessages ? true : void 0,
-				commentaryProgressEnabled: commentaryProgressEnabled ? true : void 0,
-				progressPreambleEnabled: progressDraftActive && slackStreaming.mode === "progress" ? true : void 0,
-				commentaryPayloadsEnabled: commentaryProgressEnabled ? true : void 0,
-				onVerboseProgressVisibility: commentaryProgressEnabled ? (isActive) => {
-					shouldYieldDraftProgress = isActive;
+				suppressDefaultToolProgressMessages: progress.suppressDefaultToolProgressMessages ? true : void 0,
+				commentaryProgressEnabled: progress.commentaryProgressEnabled ? true : void 0,
+				progressPreambleEnabled: progress.progressDraftActive && slackStreaming.mode === "progress" ? true : void 0,
+				commentaryPayloadsEnabled: progress.commentaryProgressEnabled ? true : 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) => {
-					updateDraftFromPartial(payload.text);
+					progress.updateDraftFromPartial(payload.text);
 				},
-				onAssistantMessageStart: onDraftBoundary,
+				onAssistantMessageStart: progress.onDraftBoundary,
 				onReasoningEnd: async () => {
-					progressReceipt.closeReasoning();
-					await onDraftBoundary?.();
+					progress.progressReceipt.closeReasoning();
+					await progress.onDraftBoundary?.();
 				},
-				onQueuedFollowupAdmitted,
-				onReasoningStream: statusReactionsEnabled || previewToolProgressEnabled ? async (payload) => {
-					await pushReasoningProgress(payload);
+				onQueuedFollowupAdmitted: progress.onQueuedFollowupAdmitted,
+				onReasoningStream: statusReactionsEnabled || progress.previewToolProgressEnabled ? async (payload) => {
+					await progress.pushReasoningProgress(payload);
 					if (!statusReactionsEnabled) return;
 					await statusReactions.setThinking();
 				} : void 0,
 				onToolStart: async (payload) => {
 					if (statusReactionsEnabled) await statusReactions.setTool(payload.name);
-					if (payload.phase === "start") progressReceipt.noteToolCall(payload.name);
-					await pushPreviewProgress(buildChannelProgressDraftLineForEntry(account.config, {
+					if (payload.phase === "start") progress.progressReceipt.noteToolCall(payload.name);
+					await progress.pushPreviewProgress(buildChannelProgressDraftLineForEntry(account.config, {
 						event: "tool",
 						itemId: payload.itemId,
 						toolCallId: payload.toolCallId,
@@ -2146,15 +2299,15 @@ async function dispatchPreparedSlackMessage(prepared) {
 					}, payload.detailMode ? { detailMode: payload.detailMode } : void 0), { toolName: payload.name });
 				},
 				onItemEvent: async (payload) => {
-					if (streamMode === "status_final" && payload.kind === "preamble") {
-						if (shouldYieldDraftProgress()) return;
-						await progressDraft.pushPreambleHeadline(payload.progressText, { itemId: payload.itemId });
-						if (commentaryProgressEnabled) {
-							if (await progressDraft.pushCommentaryProgress(payload.progressText, { itemId: payload.itemId })) progressReceipt.noteCommentary(payload.itemId, payload.progressText);
+					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;
 					}
-					await pushPreviewProgress(buildChannelProgressDraftLineForEntry(account.config, {
+					await progress.pushPreviewProgress(buildChannelProgressDraftLineForEntry(account.config, {
 						event: "item",
 						itemId: payload.itemId,
 						toolCallId: payload.toolCallId,
@@ -2170,11 +2323,11 @@ async function dispatchPreparedSlackMessage(prepared) {
 				},
 				onPlanUpdate: async (payload) => {
 					if (payload.phase !== "update") return;
-					await pushPlanProgress(payload.steps, payload.explanation);
+					await progress.pushPlanProgress(payload.steps, payload.explanation);
 				},
 				onApprovalEvent: async (payload) => {
 					if (payload.phase !== "requested") return;
-					await pushPreviewProgress(buildChannelProgressDraftLine({
+					await progress.pushPreviewProgress(buildChannelProgressDraftLine({
 						event: "approval",
 						phase: payload.phase,
 						title: payload.title,
@@ -2185,7 +2338,7 @@ async function dispatchPreparedSlackMessage(prepared) {
 				},
 				onCommandOutput: async (payload) => {
 					if (payload.phase !== "end") return;
-					await pushPreviewProgress(buildChannelProgressDraftLine({
+					await progress.pushPreviewProgress(buildChannelProgressDraftLine({
 						event: "command-output",
 						itemId: payload.itemId,
 						toolCallId: payload.toolCallId,
@@ -2198,7 +2351,7 @@ async function dispatchPreparedSlackMessage(prepared) {
 				},
 				onPatchSummary: async (payload) => {
 					if (payload.phase !== "end") return;
-					await pushPreviewProgress(buildChannelProgressDraftLine({
+					await progress.pushPreviewProgress(buildChannelProgressDraftLine({
 						event: "patch",
 						itemId: payload.itemId,
 						toolCallId: payload.toolCallId,
@@ -2221,79 +2374,59 @@ async function dispatchPreparedSlackMessage(prepared) {
 	} catch (err) {
 		dispatchError = err;
 	} finally {
-		progressDraft.cancel();
+		progress.progressDraft.cancel();
 		await draftStream?.discardPending();
 	}
 	let streamFallbackDelivered = false;
-	const finalStream = streamSession;
+	const finalStream = delivery.streamSession;
 	if (finalStream && !finalStream.stopped) try {
-		const completionChunks = useNativeProgressStreaming && !nativeProgressCompletionSent ? buildNativeProgressCompletionChunks(dispatchError ? "error" : nativeProgressTerminalStatus) : void 0;
-		if (completionChunks?.length) nativeProgressCompletionSent = true;
+		const completionChunks = progress.useNativeProgressStreaming && !progress.nativeProgressCompletionSent ? progress.buildNativeProgressCompletionChunks(dispatchError ? "error" : progress.nativeProgressTerminalStatus) : void 0;
+		if (completionChunks?.length) progress.nativeProgressCompletionSent = true;
 		const stopResult = await stopSlackStream({
 			session: finalStream,
 			...completionChunks?.length ? { chunks: completionChunks } : {},
 			...slackMessageMetadata ? { metadata: slackMessageMetadata } : {}
 		});
-		acknowledgeStoppedStreamedDeliveries(finalStream, stopResult?.messageId);
-		if (pendingNativeProgressReceipt && stopResult?.messageId && !progressReceiptCollapsed) await collapseProgressReceipt({
+		delivery.acknowledgeStoppedStreamedDeliveries(finalStream, stopResult?.messageId);
+		if (progress.pendingNativeProgressReceipt && stopResult?.messageId && !progress.progressReceiptCollapsed) await progress.collapseProgressReceipt({
 			channelId: finalStream.channel,
 			messageId: stopResult.messageId,
-			text: pendingNativeProgressReceipt,
+			text: progress.pendingNativeProgressReceipt,
 			threadTs: finalStream.threadTs
 		});
 	} catch (err) {
 		if (err instanceof SlackStreamNotDeliveredError) {
-			streamFallbackDelivered = await deliverPendingStreamFallback(finalStream, err);
+			streamFallbackDelivered = await delivery.deliverPendingStreamFallback(finalStream, err);
 			if (!streamFallbackDelivered) dispatchError ??= err;
 		} else {
 			const error = formatSlackError(err);
-			emitAcknowledgedStreamedDeliveries();
-			emitFailedPendingStreamedDeliveries(error);
+			delivery.emitAcknowledgedStreamedDeliveries();
+			delivery.emitFailedPendingStreamedDeliveries(error);
 			runtime.error?.(danger(`slack-stream: failed to stop stream: ${error}`));
 			if (!finalStream.delivered) dispatchError ??= err;
 		}
 	}
-	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) counts = {
-			...counts,
-			[kind]: Math.max(0, (counts[kind] ?? 0) - additionalFailedStreamed)
-		};
-	}
+	counts = delivery.reconcileCounts(counts);
 	queuedFinal = queuedFinal && (counts.final ?? 0) > 0;
 	const anyReplyDelivered = hasVisibleInboundReplyDispatch({
 		queuedFinal,
 		counts
 	}, {
-		observedReplyDelivery,
+		observedReplyDelivery: delivery.observedReplyDelivery,
 		fallbackDelivered: streamFallbackDelivered
 	});
-	if (statusReactionsEnabled) if (dispatchError) {
-		await statusReactions.setError();
-		if (ctx.removeAckAfterReply) (async () => {
-			await sleep(statusReactionTiming.errorHoldMs);
-			if (anyReplyDelivered) await statusReactions.clear();
-		})();
-	} else if (anyReplyDelivered) {
+	if (statusReactionsEnabled) if (dispatchError) await statusReactions.setError();
+	else if (anyReplyDelivered) {
 		await statusReactions.setDone();
-		if (ctx.removeAckAfterReply) (async () => {
-			await sleep(statusReactionTiming.doneHoldMs);
-			await statusReactions.clear();
-		})();
-		else statusReactions.restoreInitial();
+		statusReactions.restoreInitial();
 	} else await statusReactions.restoreInitial();
-	const participationThreadTs = usedReplyThreadTs ?? statusThreadTs;
+	const participationThreadTs = delivery.usedReplyThreadTs ?? statusThreadTs;
 	if (anyReplyDelivered && participationThreadTs) recordSlackThreadParticipation(account.accountId, message.channel, participationThreadTs, {
 		agentId: route.agentId,
 		...prepared.eventScope ? { teamId: prepared.eventScope.teamId } : {}
 	});
-	if (dispatchError) throw toLintErrorObject(dispatchError, "Slack dispatch failed");
-	if (!anyReplyDelivered && !draftPreviewCommitted) {
+	if (dispatchError) throw toErrorObject(dispatchError, "Slack dispatch failed");
+	if (!anyReplyDelivered && !draftPreviewCommitted.value) {
 		await draftStream?.clear();
 		return;
 	}
@@ -2301,30 +2434,51 @@ async function dispatchPreparedSlackMessage(prepared) {
 		const finalCount = counts.final;
 		logVerbose(`slack: delivered ${finalCount} reply${finalCount === 1 ? "" : "ies"} to ${prepared.replyTarget}`);
 	}
-	if (!statusReactionsEnabled) removeAckReactionAfterReply({
-		removeAfterReply: ctx.removeAckAfterReply && anyReplyDelivered,
-		ackReactionPromise: prepared.ackReactionPromise,
-		ackReactionValue: prepared.ackReactionValue,
-		remove: () => removeSlackReaction(message.channel, prepared.ackReactionMessageTs ?? "", prepared.ackReactionValue, {
-			token: ctx.botToken,
-			client: slackClient
-		}),
-		onError: (err) => {
-			logAckFailure({
-				log: logVerbose,
-				channel: "slack",
-				target: `${message.channel}/${message.ts}`,
-				error: err
-			});
-		}
-	});
 }
-function toLintErrorObject(value, fallbackMessage) {
-	if (value instanceof Error) return value;
-	if (typeof value === "string") return new Error(value);
-	const error = new Error(fallbackMessage, { cause: value });
-	if (typeof value === "object" && value !== null || typeof value === "function") Object.assign(error, value);
-	return error;
+//#endregion
+//#region extensions/slack/src/agent-context.ts
+function asRecord(value) {
+	return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function trimmedString(value) {
+	return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function normalizeEntity(value) {
+	const entity = asRecord(value);
+	const type = trimmedString(entity?.type);
+	if (!entity || !type) return;
+	const teamId = trimmedString(entity.team_id);
+	if (type === "slack#/types/channel_id" || type === "slack#/types/canvas_id" || type === "slack#/types/list_id") {
+		const entityValue = trimmedString(entity.value);
+		return entityValue ? {
+			type,
+			value: entityValue,
+			...teamId ? { team_id: teamId } : {}
+		} : void 0;
+	}
+	if (type !== "slack#/types/message_context") return;
+	const message = asRecord(entity.value);
+	const channelId = trimmedString(message?.channel_id);
+	const messageTs = trimmedString(message?.message_ts);
+	return channelId && messageTs ? {
+		type,
+		value: {
+			channel_id: channelId,
+			message_ts: messageTs
+		},
+		...teamId ? { team_id: teamId } : {}
+	} : void 0;
+}
+function isSlackAppContext(value) {
+	return Boolean(asRecord(value));
+}
+function normalizeSlackAppContextEntities(value) {
+	const context = asRecord(value);
+	if (!Array.isArray(context?.entities)) return [];
+	return context.entities.flatMap((entity) => {
+		const normalized = normalizeEntity(entity);
+		return normalized ? [normalized] : [];
+	});
 }
 //#endregion
 //#region extensions/slack/src/monitor/message-handler/preflight-audio.ts
@@ -2366,8 +2520,7 @@ async function resolveSlackPreflightAudioTranscript(params) {
 		const { transcribeFirstAudio } = await loadSlackPreflightAudioRuntime();
 		const transcript = await transcribeFirstAudio({
 			ctx: {
-				MediaPaths: params.media.map((entry) => entry.path),
-				MediaTypes: params.media.map((entry) => entry.contentType ?? ""),
+				media: [...params.media],
 				Provider: "slack",
 				Surface: "slack",
 				OriginatingChannel: "slack",
@@ -2420,7 +2573,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-CF0tUY5q.js").then((n) => n.g));
+const loadSlackMediaModule$1 = createLazyRuntimeModule(() => import("./actions-BkOaiDSX.js").then((n) => n.g));
 function collectUniqueSlackMentionIds$1(texts) {
 	const seen = /* @__PURE__ */ new Set();
 	const mentionIds = [];
@@ -2699,7 +2852,7 @@ function resolveSlackInitialAgentRoute(params) {
 	};
 }
 function resolveSlackRoutingContext(params) {
-	const { ctx, account, message, isDirectMessage, isGroupDm, isRoom, isRoomish, channelConfig, seedTopLevelRoomThread, assistantThreadTs, eventScope } = params;
+	const { ctx, account, message, isDirectMessage, isGroupDm, isRoom, isRoomish, channelConfig, seedTopLevelRoomThread, assistantThreadTs, agentViewThreadTs, eventScope } = params;
 	let route = resolveSlackInitialAgentRoute({
 		ctx,
 		account,
@@ -2719,7 +2872,7 @@ function resolveSlackRoutingContext(params) {
 	const isThreadReply = threadContext.isThreadReply;
 	const autoThreadId = !isThreadReply && replyToMode === "all" && threadContext.messageTs ? threadContext.messageTs : void 0;
 	const seedCandidateThreadId = threadContext.incomingThreadTs ?? threadContext.messageTs;
-	const routedThreadId = (isDirectMessage ? assistantThreadTs : isRoomish ? isThreadReply && threadTs ? threadTs : void 0 : isThreadReply ? threadTs : autoThreadId) ?? (isRoomish ? !isThreadReply && isRoom && seedTopLevelRoomThread && replyToMode !== "off" && seedCandidateThreadId ? seedCandidateThreadId : void 0 : void 0);
+	const routedThreadId = (isDirectMessage ? assistantThreadTs ?? agentViewThreadTs : isRoomish ? isThreadReply && threadTs ? threadTs : void 0 : isThreadReply ? threadTs : autoThreadId) ?? (isRoomish ? !isThreadReply && isRoom && seedTopLevelRoomThread && replyToMode !== "off" && seedCandidateThreadId ? seedCandidateThreadId : void 0 : void 0);
 	const baseConversationId = resolveSlackBaseConversationId({
 		message,
 		isDirectMessage,
@@ -2842,10 +2995,11 @@ function formatSlackThreadLabelSnippet(text) {
 }
 //#endregion
 //#region extensions/slack/src/monitor/message-handler/prepare-thread-context.ts
-const loadSlackMediaModule = createLazyRuntimeModule(() => import("./actions-CF0tUY5q.js").then((n) => n.g));
+const loadSlackMediaModule = createLazyRuntimeModule(() => import("./actions-BkOaiDSX.js").then((n) => n.g));
 const SLACK_THREAD_CONTEXT_USER_LOOKUP_CONCURRENCY = 4;
 function resolveSlackThreadSessionFreshness(params) {
 	return params.ctx.channelRuntime?.session?.resolveEntryResetFreshness?.({
+		defaultAgentId: resolveDefaultAgentId(params.ctx.cfg),
 		storePath: params.storePath,
 		sessionKey: params.sessionKey,
 		sessionCfg: params.ctx.cfg.session,
@@ -3495,6 +3649,14 @@ async function prepareSlackMessage(params) {
 	const assistantThreadContext = mergeSlackAssistantThreadContext(messageAssistantThreadContext, cachedAssistantThreadContext ?? restoredAssistantThreadContext);
 	const assistantThreadContextToCache = messageAssistantThreadContext || restoredAssistantThreadContext ? assistantThreadContext : void 0;
 	if (assistantThreadContextToCache) ctx.saveSlackAssistantThreadContext(assistantThreadContextToCache, opts.eventScope);
+	const hasAgentViewMessageSignal = isDirectMessage && !opts.eventScope && !assistantThreadContext && isSlackAppContext(message.app_context);
+	if (hasAgentViewMessageSignal) await ctx.recordSlackAgentView();
+	const managedViewThreadTs = message.thread_ts;
+	const isManagedViewRoot = isDirectMessage && !opts.eventScope && !assistantThreadContext && !message.parent_user_id && Boolean(managedViewThreadTs && message.ts && managedViewThreadTs === message.ts);
+	if (isManagedViewRoot && managedViewThreadTs) await ctx.recordSlackManagedViewThread(message.channel, managedViewThreadTs);
+	const hasManagedViewThread = isDirectMessage && !opts.eventScope && !assistantThreadContext && Boolean(managedViewThreadTs && await ctx.isSlackManagedViewThread(message.channel, managedViewThreadTs));
+	const isAgentViewMessage = isDirectMessage && !opts.eventScope && !assistantThreadContext && (hasAgentViewMessageSignal || isManagedViewRoot || hasManagedViewThread || await ctx.isSlackAgentView());
+	const agentViewThreadTs = isAgentViewMessage ? message.thread_ts ?? message.ts : void 0;
 	const channelReplyToMode = channelConfig?.replyToMode ?? resolveSlackReplyToMode(account, channelChatType);
 	const willImplicitlyThreadReply = isRoom && !channelRequireMention && channelReplyToMode !== "off";
 	const seedTopLevelRoomThreadBySource = opts.source === "app_mention" || opts.wasMentioned === true || explicitlyMentioned || willImplicitlyThreadReply;
@@ -3509,6 +3671,7 @@ async function prepareSlackMessage(params) {
 		channelConfig,
 		seedTopLevelRoomThread: seedTopLevelRoomThreadBySource,
 		assistantThreadTs: assistantThreadContext?.threadTs,
+		agentViewThreadTs,
 		eventScope: opts.eventScope
 	});
 	let mentionCheckTranscript;
@@ -3534,6 +3697,7 @@ async function prepareSlackMessage(params) {
 	const { configuredBinding, configuredBindingSessionKey } = routing;
 	const isAssistantThreadMessage = Boolean(isDirectMessage && messageAssistantThreadContext);
 	const forcedAssistantReplyThreadTs = Boolean(assistantThreadContext?.threadTs && (isThreadReply || isAssistantThreadMessage || replyToMode !== "off")) ? assistantThreadContext?.threadTs : void 0;
+	const forcedReplyThreadTs = agentViewThreadTs ?? forcedAssistantReplyThreadTs;
 	if (runtimeBinding && shouldLogVerbose()) logVerbose(`slack: routed via bound conversation ${runtimeBinding.conversation.conversationId} -> ${runtimeBinding.targetSessionKey}`);
 	if (configuredBinding) {
 		const ensured = await ensureConfiguredBindingRouteReady({
@@ -3744,6 +3908,7 @@ async function prepareSlackMessage(params) {
 			channelConfig,
 			seedTopLevelRoomThread: true,
 			assistantThreadTs: assistantThreadContext?.threadTs,
+			agentViewThreadTs,
 			eventScope: opts.eventScope
 		});
 		return seededMentionRouting;
@@ -3795,7 +3960,7 @@ async function prepareSlackMessage(params) {
 		preflightAudioTranscript = void 0;
 		preflightAudioMedia = void 0;
 	}
-	const directThreadRoutedToDmSession = !assistantThreadContext && isDirectMessage && isThreadReply && threadTs && runtimeBinding?.conversation.conversationId !== threadTs;
+	const directThreadRoutedToDmSession = !assistantThreadContext && !agentViewThreadTs && isDirectMessage && isThreadReply && threadTs && runtimeBinding?.conversation.conversationId !== threadTs;
 	const mentionDecision = resolveInboundMentionDecision({
 		facts: {
 			canDetectMention,
@@ -3956,7 +4121,7 @@ async function prepareSlackMessage(params) {
 		previousTimestamp,
 		envelope: envelopeOptions
 	});
-	const dmHistoryContext = isDirectMessage && !isThreadReply && dmHistoryLimit > 0 && !previousTimestamp ? await resolveSlackDmHistoryContext({
+	const dmHistoryContext = isDirectMessage && !assistantThreadContext && !agentViewThreadTs && !isThreadReply && dmHistoryLimit > 0 && !previousTimestamp ? await resolveSlackDmHistoryContext({
 		ctx,
 		channelId: message.channel,
 		currentMessageTs: message.ts,
@@ -3983,7 +4148,7 @@ async function prepareSlackMessage(params) {
 		})
 	});
 	const slackTo = isDirectMessage ? `user:${message.user}` : `channel:${message.channel}`;
-	const { untrustedChannelMetadata, groupSystemPrompt } = resolveSlackRoomContextHints({
+	const { channelMetadata, groupSystemPrompt } = resolveSlackRoomContextHints({
 		isRoomish,
 		channelInfo,
 		channelConfig
@@ -4014,7 +4179,8 @@ async function prepareSlackMessage(params) {
 	}) : dmHistoryContext.inboundHistory;
 	const commandBody = textForCommandDetection.trim();
 	const supplementalThreadHistoryBody = directThreadRoutedToDmSession && !threadHistoryBody ? threadStarterBody : threadHistoryBody;
-	const effectiveMessageThreadId = assistantThreadContext?.threadTs ?? threadContext.messageThreadId;
+	const effectiveMessageThreadId = assistantThreadContext?.threadTs ?? agentViewThreadTs ?? threadContext.messageThreadId;
+	const agentContextEntities = isAgentViewMessage ? normalizeSlackAppContextEntities(message.app_context) : [];
 	const ctxPayload = buildChannelInboundEventContext({
 		channel: "slack",
 		accountId: route.accountId,
@@ -4056,6 +4222,7 @@ async function prepareSlackMessage(params) {
 			commandBody,
 			inboundHistory
 		},
+		sessionTranscript: { historyLimit: isRoomish ? ctx.historyLimit : dmHistoryLimit },
 		access: {
 			mentions: {
 				canDetectMention: isRoomish,
@@ -4078,9 +4245,16 @@ async function prepareSlackMessage(params) {
 		},
 		extra: {
 			GroupSubject: isRoomish ? roomLabel : void 0,
-			UntrustedContext: untrustedChannelMetadata ? [untrustedChannelMetadata] : void 0,
+			ChannelPromptContext: channelMetadata ? [channelMetadata] : void 0,
+			ChannelStructuredContext: agentContextEntities.length > 0 ? [{
+				label: "Slack active context",
+				source: "slack",
+				type: "active_view",
+				payload: { entities: agentContextEntities }
+			}] : void 0,
 			TransportThreadId: directThreadRoutedToDmSession ? threadContext.messageThreadId : void 0,
 			SlackAssistantThread: assistantThreadContext ? true : void 0,
+			SlackAgentThread: agentViewThreadTs ? true : void 0,
 			SlackAssistantThreadContextChannelId: assistantThreadContext?.channelId,
 			SlackAssistantThreadContextTeamId: assistantThreadContext?.teamId,
 			SlackAssistantThreadContextEnterpriseId: assistantThreadContext?.enterpriseId ?? void 0,
@@ -4170,7 +4344,7 @@ async function prepareSlackMessage(params) {
 			} : void 0
 		},
 		replyToMode,
-		...forcedAssistantReplyThreadTs ? { forcedReplyThreadTs: forcedAssistantReplyThreadTs } : {},
+		...forcedReplyThreadTs ? { forcedReplyThreadTs } : {},
 		...assistantThreadContext ? { slackMessageMetadata: buildSlackAssistantThreadMetadata(assistantThreadContext) } : {},
 		requireMention: shouldRequireMention,
 		isDirectMessage,