@openclaw/slack 2026.5.27-beta.1 → 2026.5.28-beta.1

package/dist/{prepare-Bl5WcC3f.js → pipeline.runtime-XK36f1W3.js}

@@ -1,36 +1,1790 @@
-import { l as resolveSlackReplyToMode } from "./accounts-BnLQ3fe2.js";
+import { l as resolveSlackReplyToMode } from "./accounts-f6Xcv9Vi.js";
 import { r as parseSlackTarget } from "./target-parsing-C7eeWg7M.js";
 import "./targets-nUqxHGgg.js";
-import { i as normalizeSlackAllowOwnerEntry, o as resolveSlackAllowListMatch, r as normalizeAllowListLower } from "./allow-list-B1lkGjwl.js";
-import { i as hasSlackThreadParticipationWithPersistence, t as sendMessageSlack } from "./send-DvfE8LVm.js";
-import { _ as resolveSlackThreadStarter, g as resolveSlackThreadHistory, l as reactSlackMessage, y as formatSlackFileReference } from "./actions-1o9nMIY8.js";
+import { b as truncateSlackText, f as normalizeAllowListLower, h as resolveSlackAllowListMatch, p as normalizeSlackAllowOwnerEntry, s as SLACK_TEXT_LIMIT } from "./thread-ts-NSVqWybn.js";
+import { n as isSlackInteractiveRepliesEnabled, t as compileSlackInteractiveReplies } from "./interactive-replies-DrBq4Mld.js";
+import { n as resolveSlackNativeStreaming, r as resolveSlackStreamingMode, t as mapStreamingModeToSlackLegacyDraftStreamMode } from "./streaming-compat-DjlgH-Be.js";
+import { a as recordSlackThreadParticipation, i as hasSlackThreadParticipationWithPersistence, s as normalizeSlackOutboundText, t as sendMessageSlack } from "./send-BURYyCXI.js";
+import { _ as resolveSlackThreadStarter, b as buildSlackEditTextPayload, f as removeSlackReaction, g as resolveSlackThreadHistory, l as reactSlackMessage, r as editSlackMessage, t as deleteSlackMessage, y as formatSlackFileReference } from "./actions-zfVWcIY6.js";
 import { t as formatSlackError } from "./errors-CZtmv-h0.js";
-import { C as resolveStorePath, O as stripSlackMentionsForCommandDetection, b as resolveChannelContextVisibilityMode, c as authorizeSlackBotRoomMessage, d as resolveSlackEffectiveAllowFrom, f as buildSlackAssistantThreadMetadata, g as resolveSlackChatType, h as normalizeSlackChannelType, m as parseSlackAssistantThreadMetadata, n as authorizeSlackDirectMessage, o as resolveConversationLabel$1, t as resolveSlackRoomContextHints, u as resolveSlackCommandIngress, y as readSessionUpdatedAt } from "./room-context-BmNTBiw5.js";
-import { n as resolveSlackChannelConfig } from "./policy-pu8tsF8_.js";
-import "./send.runtime-Dv6ajTGK.js";
-import { asOptionalRecord, normalizeLowercaseStringOrEmpty, normalizeOptionalString, readStringValue } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { _ as resolveStorePath, a as escapeSlackMrkdwn, b as stripSlackMentionsForCommandDetection, c as authorizeSlackBotRoomMessage, d as buildSlackAssistantThreadMetadata, f as parseSlackAssistantThreadMetadata, g as resolveChannelContextVisibilityMode, h as readSessionUpdatedAt, i as authorizeSlackDirectMessage, l as resolveSlackCommandIngress, m as resolveSlackChatType, o as recordInboundSession, p as normalizeSlackChannelType, r as resolveSlackRoomContextHints, s as resolveConversationLabel$1, u as resolveSlackEffectiveAllowFrom, v as updateLastRoute } from "./provider-CfZypaNV.js";
+import { n as resolveSlackChannelConfig } from "./policy-BBDU-PQK.js";
+import { a as resolveDeliveredSlackReplyThreadTs, i as readSlackReplyBlocks, n as deliverReplies, o as resolveSlackThreadTs, t as createSlackReplyDeliveryPlan } from "./replies-DkmWK7JW.js";
+import { asOptionalRecord, normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeOptionalString, readStringValue } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { resolveAgentRoute, resolveInboundLastRouteSessionKey, resolveThreadSessionKeys } from "openclaw/plugin-sdk/routing";
-import { resolveChannelMessageSourceReplyDeliveryMode } from "openclaw/plugin-sdk/channel-outbound";
-import { logVerbose, shouldLogVerbose } from "openclaw/plugin-sdk/runtime-env";
+import { buildChannelProgressDraftLine, buildChannelProgressDraftLineForEntry, createChannelMessageReplyPipeline, createChannelProgressDraftGate, createDraftStreamLoop, defineFinalizableLivePreviewAdapter, deliverWithFinalizableLivePreviewAdapter, formatChannelProgressDraftText, isChannelProgressDraftWorkToolName, mergeChannelProgressDraftLine, resolveAgentOutboundIdentity, resolveChannelMessageSourceReplyDeliveryMode, resolveChannelProgressDraftConfig, resolveChannelProgressDraftMaxLineChars, resolveChannelProgressDraftMaxLines, resolveChannelProgressDraftRender, resolveChannelStreamingBlockEnabled, resolveChannelStreamingNativeTransport, resolveChannelStreamingPreviewToolProgress, resolveChannelStreamingSuppressDefaultToolProgressMessages } from "openclaw/plugin-sdk/channel-outbound";
+import { createHash } from "node:crypto";
+import { danger, logVerbose, shouldLogVerbose, sleep } from "openclaw/plugin-sdk/runtime-env";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
+import { buildTtsSupplementMediaPayload, getReplyPayloadTtsSupplement, resolveSendableOutboundReplyParts } from "openclaw/plugin-sdk/reply-payload";
 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 { mergePairLoopGuardConfig } from "openclaw/plugin-sdk/pair-loop-guard-runtime";
 import { enqueueSystemEvent } from "openclaw/plugin-sdk/system-event-runtime";
-import { buildChannelInboundEventContext, buildMentionRegexes, classifyChannelInboundEvent, formatInboundEnvelope, implicitMentionKindWhen, logInboundDrop, matchesMentionWithExplicit, recordDroppedChannelInboundHistory, resolveEnvelopeFormatOptions, resolveUnmentionedGroupInboundPolicy, toInboundMediaFacts } from "openclaw/plugin-sdk/channel-inbound";
+import { buildChannelInboundEventContext, buildMentionRegexes, classifyChannelInboundEvent, dispatchChannelInboundReply, formatInboundEnvelope, hasVisibleInboundReplyDispatch, implicitMentionKindWhen, logInboundDrop, matchesMentionWithExplicit, recordDroppedChannelInboundHistory, resolveEnvelopeFormatOptions, resolveUnmentionedGroupInboundPolicy, toInboundMediaFacts } from "openclaw/plugin-sdk/channel-inbound";
 import { filterSupplementalContextItems, resolvePinnedMainDmOwnerFromAllowlist, shouldIncludeSupplementalContext } from "openclaw/plugin-sdk/security-runtime";
-import { resolveAckReaction, shouldAckReaction } from "openclaw/plugin-sdk/channel-feedback";
+import { DEFAULT_TIMING, createStatusReactionController, logAckFailure, logTypingFailure, removeAckReactionAfterReply, resolveAckReaction, shouldAckReaction } from "openclaw/plugin-sdk/channel-feedback";
+import { dispatchReplyWithBufferedBlockDispatcher } from "openclaw/plugin-sdk/reply-runtime";
 import { hasControlCommand } from "openclaw/plugin-sdk/command-detection";
 import { isAbortRequestText } from "openclaw/plugin-sdk/command-primitives-runtime";
 import { shouldHandleTextCommands } from "openclaw/plugin-sdk/command-surface";
 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,
+					...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.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
+	});
+	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
+			});
+		} 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 {
+		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.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(" · ");
+	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 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 slugTaskIdPart(value) {
+	return value?.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "") || "task";
+}
+function stableTaskIdPart(value) {
+	const suffix = createHash("sha256").update(value).digest("hex").slice(0, 8);
+	return `${slugTaskIdPart(value)}_${suffix}`;
+}
+function buildPlanTasks(params) {
+	const maxLineChars = resolveMaxLineChars(params.maxLineChars, DEFAULT_SLACK_PROGRESS_TASK_DETAIL_MAX_CHARS);
+	return params.lines.slice(-50).map((line, index) => ({
+		id: line.id ? stableTaskIdPart(line.id) : `${slugTaskIdPart(line.toolName ?? line.kind ?? line.label)}_${index + 1}`,
+		title: lineTaskTitle(line, maxLineChars),
+		status: lineTaskStatus(line)
+	}));
+}
+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,
+		maxLineChars: params.maxLineChars
+	});
+	if (tasks.length === 0) return;
+	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 renderedBlocks = [...label ? [{
+		type: "section",
+		text: field(`*${escapeSlackMrkdwn(label)}*`)
+	}] : [], ...params.lines.map((line) => ({
+		type: "section",
+		fields: [field(legacyLineTitle(line)), field(legacyLineDetail(line, maxLineChars))]
+	}))].slice(-50);
+	return renderedBlocks.length ? renderedBlocks : void 0;
+}
+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/streaming.ts
+/**
+* Thrown when Slack rejects a stream flush/finalize with a recipient-resolution
+* error (see {@link BENIGN_SLACK_FINALIZE_ERROR_CODES}) while text is still
+* only 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 any 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 } = params;
+	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 } : {}
+	});
+	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;
+		}
+	}
+	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;
+	}
+	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;
+	}
+}
+/**
+* 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 known benign finalize error
+* (see {@link BENIGN_SLACK_FINALIZE_ERROR_CODES}) AND any prior `append`
+* has already landed on Slack, the error is swallowed and the session is
+* marked stopped - the already-delivered text stays visible.
+*
+* If the same benign error fires while text is still only buffered locally
+* (e.g. short replies that never exceeded the SDK's buffer_size), this
+* function throws a {@link SlackStreamNotDeliveredError} carrying that pending
+* text so the caller can deliver it through the normal Slack reply path.
+*
+* All other errors propagate unchanged.
+*/
+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 {
+		await session.streamer.stop(text || chunks?.length || metadata ? {
+			...text ? { markdown_text: text } : {},
+			...chunks?.length ? { chunks } : {},
+			...metadata ? { metadata } : {}
+		} : void 0);
+		session.delivered = true;
+		session.pendingText = "";
+	} catch (err) {
+		if (isBenignSlackFinalizeError(err)) {
+			const code = extractSlackErrorCode(err) ?? "unknown";
+			if (session.pendingText) throw new SlackStreamNotDeliveredError(session.pendingText, code);
+			if (session.delivered) {
+				logVerbose(`slack-stream: finalize rejected by Slack (${code}); prior appends delivered, treating stream as stopped`);
+				return;
+			}
+		}
+		throw err;
+	}
+	logVerbose("slack-stream: stream stopped");
+}
+/**
+* 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 = new Set([
+	"user_not_found",
+	"team_not_found",
+	"missing_recipient_user_id"
+]);
+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 hadNativeDelivery = session.delivered;
+	session.pendingText = "";
+	session.delivered = true;
+	if (!hadNativeDelivery) session.stopped = true;
+}
+//#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 isThreadReply = typeof incomingThreadTs === "string" && incomingThreadTs.length > 0 && (incomingThreadTs !== messageTs || Boolean(params.message.parent_user_id));
+	return {
+		incomingThreadTs,
+		messageTs,
+		isThreadReply,
+		replyToId: incomingThreadTs ?? messageTs,
+		messageThreadId: isThreadReply ? 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/preview-finalize.ts
+function buildExpectedSlackEditText(params) {
+	return buildSlackEditTextPayload(params.text, params.blocks);
+}
+function blocksMatch(expected, actual) {
+	if (!expected?.length) return !actual?.length;
+	if (!actual?.length) return false;
+	return JSON.stringify(expected) === JSON.stringify(actual);
+}
+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 actualText = normalizeSlackOutboundText((readback.text ?? "").trim());
+	if (params.blocks?.length) return actualText === expectedText && 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 } : {}
+		});
+		return;
+	} 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;
+	}
+}
+//#endregion
+//#region extensions/slack/src/monitor/message-handler/dispatch.ts
+const UNICODE_TO_SLACK = {
+	"👀": "eyes",
+	"🤔": "thinking_face",
+	"🔥": "fire",
+	"👨‍💻": "male-technologist",
+	"👨💻": "male-technologist",
+	"👩‍💻": "female-technologist",
+	"⚡": "zap",
+	"🌐": "globe_with_meridians",
+	"✅": "white_check_mark",
+	"👍": "thumbsup",
+	"❌": "x",
+	"😱": "scream",
+	"🥱": "yawning_face",
+	"😨": "fearful",
+	"⏳": "hourglass_flowing_sand",
+	"⚠️": "warning",
+	"✍": "writing_hand",
+	"🗜️": "compression",
+	"🗜": "compression",
+	"🧠": "brain",
+	"🛠️": "hammer_and_wrench",
+	"💻": "computer"
+};
+function resolveSlackMessageTimestampMs(message) {
+	const ts = message.event_ts ?? message.ts;
+	if (!ts) return;
+	const parsed = Number(ts);
+	return Number.isFinite(parsed) ? Math.trunc(parsed * 1e3) : void 0;
+}
+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 toSlackEmojiName(emoji) {
+	let trimmed = emoji.trim();
+	while (trimmed.startsWith(":")) trimmed = trimmed.slice(1);
+	while (trimmed.endsWith(":")) trimmed = trimmed.slice(0, -1);
+	return UNICODE_TO_SLACK[trimmed] ?? trimmed;
+}
+function isSlackStreamingEnabled(params) {
+	if (params.mode === "partial") return params.nativeStreaming;
+	if (params.mode === "progress") return params.nativeStreaming && params.nativeProgressTaskCards === true;
+	return false;
+}
+function shouldEnableSlackPreviewStreaming(params) {
+	return params.mode !== "off";
+}
+function shouldInitializeSlackDraftStream(params) {
+	return params.previewStreamingEnabled && !params.useStreaming;
+}
+function resolveSlackDisableBlockStreaming(params) {
+	if (params.useStreaming || params.shouldUseDraftStream) return true;
+	return typeof params.blockStreamingEnabled === "boolean" ? !params.blockStreamingEnabled : void 0;
+}
+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 SLACK_STREAM_RECIPIENT_TEAM_CACHE_MAX = 2e3;
+const slackStreamRecipientTeamCache = /* @__PURE__ */ new Map();
+function buildSlackEventDeliveryKey(params) {
+	const reply = resolveSendableOutboundReplyParts(params.payload, { text: params.textOverride });
+	const slackBlocks = readSlackReplyBlocks(params.payload);
+	if (!reply.hasContent && !slackBlocks?.length) return null;
+	return JSON.stringify({
+		kind: params.kind,
+		threadTs: params.threadTs ?? "",
+		replyToId: params.payload.replyToId ?? null,
+		text: reply.trimmedText,
+		mediaUrls: reply.mediaUrls,
+		blocks: slackBlocks ?? null
+	});
+}
+function readSlackStreamRecipientTeamCache(params) {
+	if (!params.fallbackTeamId || !params.userId) return;
+	const cacheKey = `${params.fallbackTeamId}:${params.userId}`;
+	const cached = slackStreamRecipientTeamCache.get(cacheKey);
+	if (!cached) return;
+	slackStreamRecipientTeamCache.delete(cacheKey);
+	slackStreamRecipientTeamCache.set(cacheKey, cached);
+	return cached;
+}
+function rememberSlackStreamRecipientTeam(params) {
+	if (!params.fallbackTeamId || !params.userId) return;
+	const cacheKey = `${params.fallbackTeamId}:${params.userId}`;
+	if (slackStreamRecipientTeamCache.has(cacheKey)) slackStreamRecipientTeamCache.delete(cacheKey);
+	slackStreamRecipientTeamCache.set(cacheKey, params.teamId);
+	if (slackStreamRecipientTeamCache.size > SLACK_STREAM_RECIPIENT_TEAM_CACHE_MAX) {
+		const oldest = slackStreamRecipientTeamCache.keys().next().value;
+		if (oldest) slackStreamRecipientTeamCache.delete(oldest);
+	}
+}
+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;
+	}
+	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
+		});
+		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)})`);
+	}
+	return params.fallbackTeamId;
+}
+async function dispatchPreparedSlackMessage(prepared) {
+	const { ctx, account, message, route } = prepared;
+	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
+	} : void 0;
+	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 reactionMessageTs = prepared.ackReactionMessageTs;
+	const messageTs = message.ts ?? message.event_ts;
+	const incomingThreadTs = message.thread_ts;
+	let didSetStatus = false;
+	const statusReactionsEnabled = Boolean(prepared.ackReactionPromise) && Boolean(reactionMessageTs) && cfg.messages?.statusReactions?.enabled !== false;
+	const slackStatusAdapter = {
+		setReaction: async (emoji) => {
+			await reactSlackMessage(message.channel, reactionMessageTs ?? "", toSlackEmojiName(emoji), {
+				token: ctx.botToken,
+				client: ctx.app.client
+			}).catch((err) => {
+				if (formatErrorMessage(err).includes("already_reacted")) return;
+				throw err;
+			});
+		},
+		removeReaction: async (emoji) => {
+			await removeSlackReaction(message.channel, reactionMessageTs ?? "", toSlackEmojiName(emoji), {
+				token: ctx.botToken,
+				client: ctx.app.client
+			}).catch((err) => {
+				if (formatErrorMessage(err).includes("no_reaction")) return;
+				throw err;
+			});
+		}
+	};
+	const statusReactionTiming = {
+		...DEFAULT_TIMING,
+		...cfg.messages?.statusReactions?.timing
+	};
+	const statusReactions = createStatusReactionController({
+		enabled: statusReactionsEnabled,
+		adapter: slackStatusAdapter,
+		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
+			});
+		}
+	});
+	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..."
+				});
+				if (typingReaction && message.ts) await reactSlackMessage(message.channel, message.ts, typingReaction, {
+					token: ctx.botToken,
+					client: ctx.app.client
+				}).catch(() => {});
+			},
+			stop: async () => {
+				if (!didSetStatus) return;
+				didSetStatus = false;
+				await ctx.setSlackThreadStatus({
+					channelId: message.channel,
+					threadTs: statusThreadTs,
+					status: ""
+				});
+				if (typingReaction && message.ts) await removeSlackReaction(message.channel, message.ts, typingReaction, {
+					token: ctx.botToken,
+					client: ctx.app.client
+				}).catch(() => {});
+			},
+			onStartError: (err) => {
+				logTypingFailure({
+					log: (message) => runtime.error?.(danger(message)),
+					channel: "slack",
+					action: "start",
+					target: typingTarget,
+					error: err
+				});
+			},
+			onStopError: (err) => {
+				logTypingFailure({
+					log: (message) => runtime.error?.(danger(message)),
+					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 useStreaming = shouldUseStreaming({
+		streamingEnabled: !sourceRepliesAreToolOnly && isSlackStreamingEnabled({
+			mode: slackStreaming.mode,
+			nativeStreaming: slackStreaming.nativeStreaming,
+			nativeProgressTaskCards: resolveSlackNativeProgressTaskCards(account.config)
+		}),
+		threadTs: streamThreadHint
+	});
+	const shouldUseDraftStream = 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 deliveryTracker = createSlackEventDeliveryTracker();
+	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 deliverPendingStreamFallback = async (session, err) => {
+		const fallbackText = err.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,
+				replyThreadTs: session.threadTs,
+				replyToMode: replyDeliveryMode,
+				...slackIdentity ? { identity: slackIdentity } : {},
+				...slackMessageMetadata ? { metadata: slackMessageMetadata } : {}
+			});
+			markSlackStreamFallbackDelivered(session);
+			observedReplyDelivery = true;
+			usedReplyThreadTs ??= session.threadTs;
+			logVerbose(`slack-stream: streamed delivery failed (${err.slackCode}); delivered ${fallbackText.length} chars via deliverReplies fallback`);
+			return true;
+		} catch (postErr) {
+			runtime.error?.(danger(`slack-stream: fallback deliverReplies failed after ${err.slackCode}: ${formatErrorMessage(postErr)}`));
+			return false;
+		}
+	};
+	const deliverNormally = async (params) => {
+		if (params.payload.isReasoning === true) return;
+		const replyThreadTs = resolveDeliveryThreadTs(params);
+		if (deliveryTracker.hasDelivered({
+			kind: params.kind,
+			payload: params.payload,
+			threadTs: replyThreadTs
+		})) {
+			logVerbose("slack: suppressed duplicate normal delivery within the same turn");
+			return;
+		}
+		await deliverReplies({
+			cfg: ctx.cfg,
+			replies: [params.payload],
+			target: prepared.replyTarget,
+			token: ctx.botToken,
+			accountId: account.accountId,
+			runtime,
+			textLimit: ctx.textLimit,
+			replyThreadTs,
+			replyToMode: replyDeliveryMode,
+			...slackIdentity ? { identity: slackIdentity } : {},
+			...slackMessageMetadata ? { metadata: slackMessageMetadata } : {}
+		});
+		observedReplyDelivery = true;
+		if (params.kind === "final") observedFinalReplyDelivery = true;
+		const deliveredThreadTs = resolveDeliveredSlackReplyThreadTs({
+			replyToMode: replyDeliveryMode,
+			payloadReplyToId: params.payload.replyToId,
+			replyThreadTs
+		});
+		rememberDeliveredThreadTs(params.kind, deliveredThreadTs);
+		replyPlan.markSent();
+		deliveryTracker.markDelivered({
+			kind: params.kind,
+			payload: params.payload,
+			threadTs: replyThreadTs
+		});
+	};
+	const deliverBufferedStreamFallback = async (params) => {
+		if (!await deliverPendingStreamFallback(params.session, params.err)) return false;
+		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 deliverWithStreaming = async (params) => {
+		if (params.payload.isReasoning === true) return;
+		const reply = resolveSendableOutboundReplyParts(params.payload);
+		if (streamFailed || reply.hasMedia || readSlackReplyBlocks(params.payload)?.length || !reply.hasText) {
+			await deliverNormally({
+				payload: params.payload,
+				kind: params.kind,
+				forcedThreadTs: streamSession?.threadTs ?? nativeProgressStreamThreadTs
+			});
+			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 (useNativeProgressStreaming && !streamSession) {
+				await deliverNormally({
+					payload: params.payload,
+					kind: params.kind
+				});
+				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: ctx.app.client,
+					channel: message.channel,
+					threadTs: streamThreadTs,
+					text,
+					teamId: await resolveSlackStreamRecipientTeamId({
+						client: ctx.app.client,
+						token: ctx.botToken,
+						userId: message.user,
+						fallbackTeamId: ctx.teamId
+					}),
+					userId: message.user
+				});
+				if (streamSession.delivered) {
+					observedReplyDelivery = true;
+					if (params.kind === "final") observedFinalReplyDelivery = true;
+				}
+				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;
+			}
+			const completionChunks = useNativeProgressStreaming && !nativeProgressCompletionSent && previewToolProgressLines.length > 0 ? buildSlackProgressStreamCompletionChunks({
+				title: explicitProgressTitle,
+				lines: previewToolProgressLines,
+				maxLineChars: progressDraftMaxLineChars,
+				finalInProgressStatus: params.payload.isError ? "error" : "complete"
+			}) : void 0;
+			if (useNativeProgressStreaming) {
+				if (completionChunks?.length) {
+					await appendSlackStream({
+						session: streamSession,
+						chunks: completionChunks
+					});
+					nativeProgressCompletionSent = true;
+					if (streamSession.delivered) observedReplyDelivery = true;
+				}
+				await deliverNormally({
+					payload: params.payload,
+					kind: params.kind,
+					forcedThreadTs: streamSession.threadTs
+				});
+				return;
+			}
+			await appendSlackStream({
+				session: streamSession,
+				text: "\n" + text,
+				chunks: completionChunks
+			});
+			if (completionChunks?.length) nativeProgressCompletionSent = true;
+			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;
+			}
+			await deliverNormally({
+				payload: params.payload,
+				kind: params.kind,
+				forcedThreadTs: streamSession?.threadTs ?? plannedThreadTs
+			});
+		}
+	};
+	let draftPreviewCommitted = false;
+	const deliverSlackPayload = async (payload, info) => {
+		if (payload.isReasoning === true) return { visibleReplySent: false };
+		if (useStreaming) {
+			await deliverWithStreaming({
+				payload,
+				kind: info.kind
+			});
+			return;
+		}
+		const reply = resolveSendableOutboundReplyParts(payload);
+		const slackBlocks = readSlackReplyBlocks(payload);
+		const ttsSupplement = getReplyPayloadTtsSupplement(payload);
+		const trimmedFinalText = (payload.text ?? ttsSupplement?.spokenText ?? "").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 && 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: ctx.app.client,
+						token: ctx.botToken,
+						accountId: account.accountId,
+						channelId,
+						messageId,
+						text: normalizeSlackOutboundText(trimmedFinalText),
+						...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: trimmedFinalText
+							},
+							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
+				});
+				deliveryTracker.markDelivered({
+					kind: info.kind,
+					payload,
+					threadTs: finalThreadTs
+				});
+				return;
+			}
+		}
+		if ((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 || trimmedFinalText.length === 0 && !slackBlocks?.length) return;
+					return {
+						text: normalizeSlackOutboundText(trimmedFinalText),
+						blocks: slackBlocks,
+						threadTs: usedReplyThreadTs ?? statusThreadTs
+					};
+				},
+				editFinal: async (preview, edit) => {
+					if (deliveryTracker.hasDelivered({
+						kind: info.kind,
+						payload,
+						threadTs: edit.threadTs
+					})) return;
+					await finalizeSlackPreviewEdit({
+						client: ctx.app.client,
+						token: ctx.botToken,
+						accountId: account.accountId,
+						channelId: preview.channelId,
+						messageId: preview.messageId,
+						text: edit.text,
+						...edit.blocks?.length ? { blocks: edit.blocks } : {},
+						threadTs: edit.threadTs
+					});
+					draftPreviewCommitted = true;
+					observedFinalReplyDelivery = true;
+				},
+				onPreviewFinalized: (_preview) => {
+					draftPreviewCommitted = true;
+					observedFinalReplyDelivery = true;
+					const finalThreadTs = usedReplyThreadTs ?? statusThreadTs;
+					observedReplyDelivery = true;
+					replyPlan.markSent();
+					deliveryTracker.markDelivered({
+						kind: info.kind,
+						payload,
+						threadTs: finalThreadTs
+					});
+				},
+				buildSupplementalPayload: () => ttsSupplement ? buildTtsSupplementMediaPayload(payload) : void 0,
+				deliverSupplemental: async (supplementalPayload) => {
+					await deliverNormally({
+						payload: supplementalPayload,
+						kind: info.kind
+					});
+				},
+				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
+				});
+			}
+		})).kind === "preview-finalized") return;
+	};
+	const onSlackDeliveryError = (err, info) => {
+		runtime.error?.(danger(`slack ${info.kind} reply failed: ${formatSlackError(err)}`));
+		replyPipeline.typingCallbacks?.onIdle?.();
+	};
+	const draftStream = shouldUseDraftStream ? createSlackDraftStream({
+		target: prepared.replyTarget,
+		cfg,
+		token: ctx.botToken,
+		accountId: account.accountId,
+		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 previewToolProgressEnabled = (Boolean(draftStream) || useNativeProgressStreaming) && resolveChannelStreamingPreviewToolProgress(account.config);
+	const suppressDefaultToolProgressMessages = resolveChannelStreamingSuppressDefaultToolProgressMessages(account.config, {
+		draftStreamActive: Boolean(draftStream) || useNativeProgressStreaming,
+		previewToolProgressEnabled,
+		previewStreamingEnabled
+	});
+	let previewToolProgressSuppressed = false;
+	let previewToolProgressLines = [];
+	let lastNonEmptyPreviewToolProgressLines = [];
+	let appendRenderedText = "";
+	let appendSourceText = "";
+	let statusUpdateCount = 0;
+	let nativeProgressCompletionSent = false;
+	let nativeProgressChunkKey;
+	const progressSeed = `${account.accountId}:${message.channel}`;
+	const useRichProgressDraft = streamMode === "status_final" && resolveChannelProgressDraftRender(account.config) === "rich";
+	const explicitProgressTitle = resolveExplicitSlackProgressTitle(account.config);
+	const progressDraftMaxLineChars = resolveChannelProgressDraftMaxLineChars(account.config);
+	const renderProgressDraft = () => {
+		if (!draftStream || streamMode !== "status_final") return;
+		const progressLines = useRichProgressDraft && previewToolProgressLines.length === 0 ? lastNonEmptyPreviewToolProgressLines : previewToolProgressLines;
+		const previewText = formatChannelProgressDraftText({
+			entry: account.config,
+			lines: progressLines,
+			seed: progressSeed,
+			formatLine: escapeSlackMrkdwn
+		});
+		if (!previewText) return;
+		const richProgressBlocks = useRichProgressDraft ? buildSlackProgressDraftBlocks({
+			title: explicitProgressTitle,
+			lines: progressLines,
+			maxLineChars: resolveChannelProgressDraftMaxLineChars(account.config)
+		}) : void 0;
+		draftStream.update(useRichProgressDraft && richProgressBlocks ? {
+			text: previewText,
+			blocks: richProgressBlocks
+		} : previewText);
+		hasStreamedMessage = true;
+	};
+	const waitForNativeProgressStreamStart = async () => {
+		if (streamSession || !nativeProgressStreamStartPromise) return true;
+		try {
+			await nativeProgressStreamStartPromise;
+		} catch {
+			streamFailed = true;
+			return false;
+		}
+		return !streamFailed;
+	};
+	const buildNativeProgressChunks = () => streamSession ? buildSlackProgressStreamUpdateChunks({
+		title: explicitProgressTitle,
+		lines: previewToolProgressLines,
+		maxLineChars: progressDraftMaxLineChars
+	}) : buildSlackProgressStreamStartChunks({
+		title: explicitProgressTitle,
+		lines: previewToolProgressLines,
+		maxLineChars: progressDraftMaxLineChars
+	});
+	const markNativeProgressDelivered = (session, threadTs) => {
+		if (session.delivered) observedReplyDelivery = true;
+		if (threadTs) {
+			usedReplyThreadTs ??= threadTs;
+			rememberDeliveredThreadTs("block", threadTs);
+		}
+	};
+	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;
+		}
+		nativeProgressStreamThreadTs = streamThreadTs;
+		const startPromise = (async () => {
+			const session = await startSlackStream({
+				client: ctx.app.client,
+				channel: message.channel,
+				threadTs: streamThreadTs,
+				chunks,
+				taskDisplayMode: "plan",
+				teamId: await resolveSlackStreamRecipientTeamId({
+					client: ctx.app.client,
+					token: ctx.botToken,
+					userId: message.user,
+					fallbackTeamId: ctx.teamId
+				}),
+				userId: message.user
+			});
+			streamSession = session;
+			return session;
+		})();
+		nativeProgressStreamStartPromise = startPromise;
+		let startedSession = null;
+		try {
+			startedSession = await startPromise;
+		} finally {
+			if (nativeProgressStreamStartPromise === startPromise) nativeProgressStreamStartPromise = null;
+		}
+		if (startedSession) markNativeProgressDelivered(startedSession, streamThreadTs);
+		nativeProgressChunkKey = chunkKey;
+		replyPlan.markSent();
+	};
+	const appendNativeProgressStream = async (chunks, chunkKey) => {
+		if (!streamSession) return;
+		await appendSlackStream({
+			session: streamSession,
+			chunks
+		});
+		markNativeProgressDelivered(streamSession);
+		nativeProgressChunkKey = chunkKey;
+	};
+	const updateNativeProgressStream = async () => {
+		if (!useNativeProgressStreaming || streamFailed || previewToolProgressLines.length === 0) return;
+		if (!await waitForNativeProgressStreamStart()) return;
+		const chunks = buildNativeProgressChunks();
+		if (!chunks?.length) return;
+		const chunkKey = JSON.stringify(chunks);
+		if (chunkKey === nativeProgressChunkKey) return;
+		try {
+			if (!streamSession) {
+				await startNativeProgressStream(chunks, chunkKey);
+				return;
+			}
+			await appendNativeProgressStream(chunks, chunkKey);
+		} catch (err) {
+			runtime.error?.(danger(`slack-stream: native progress stream failed: ${formatSlackError(err)}, falling back`));
+			streamFailed = true;
+		}
+	};
+	const progressDraftGate = createChannelProgressDraftGate({ onStart: useNativeProgressStreaming ? updateNativeProgressStream : renderProgressDraft });
+	const refreshStartedProgressDraft = async () => {
+		if (useNativeProgressStreaming) await updateNativeProgressStream();
+		else renderProgressDraft();
+	};
+	const pushPreviewToolProgress = 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 (!line || !normalized) {
+			if (streamMode !== "status_final") return;
+			const alreadyStarted = progressDraftGate.hasStarted;
+			await progressDraftGate.noteWork();
+			if (alreadyStarted && progressDraftGate.hasStarted) await refreshStartedProgressDraft();
+			return;
+		}
+		if (streamMode !== "status_final") {
+			if (!previewToolProgressEnabled || previewToolProgressSuppressed) return;
+			const nextLines = mergeChannelProgressDraftLine(previewToolProgressLines, line, { maxLines: resolveChannelProgressDraftMaxLines(account.config) });
+			if (nextLines === previewToolProgressLines) return;
+			previewToolProgressLines = nextLines;
+			draftStream?.update(formatChannelProgressDraftText({
+				entry: account.config,
+				lines: previewToolProgressLines,
+				seed: progressSeed,
+				formatLine: escapeSlackMrkdwn
+			}));
+			hasStreamedMessage = true;
+			return;
+		}
+		if (previewToolProgressEnabled && !previewToolProgressSuppressed) {
+			previewToolProgressLines = mergeChannelProgressDraftLine(previewToolProgressLines, line, { maxLines: resolveChannelProgressDraftMaxLines(account.config) });
+			if (previewToolProgressLines.length > 0) lastNonEmptyPreviewToolProgressLines = previewToolProgressLines;
+		}
+		if (useNativeProgressStreaming) {
+			if (progressDraftGate.hasStarted) await updateNativeProgressStream();
+			else await progressDraftGate.startNow();
+			return;
+		}
+		const alreadyStarted = progressDraftGate.hasStarted;
+		await progressDraftGate.noteWork();
+		if (alreadyStarted && progressDraftGate.hasStarted) await refreshStartedProgressDraft();
+	};
+	const updateDraftFromPartial = (text) => {
+		const trimmed = text?.trimEnd();
+		if (!trimmed) return;
+		if (streamMode === "append") {
+			previewToolProgressSuppressed = true;
+			previewToolProgressLines = [];
+			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;
+		}
+		if (streamMode === "status_final") {
+			if (!progressDraftGate.hasStarted) return;
+			statusUpdateCount += 1;
+			if (statusUpdateCount > 1 && statusUpdateCount % 4 !== 0) return;
+			renderProgressDraft();
+			return;
+		}
+		previewToolProgressSuppressed = true;
+		previewToolProgressLines = [];
+		draftStream?.update(trimmed);
+		hasStreamedMessage = true;
+	};
+	const onDraftBoundary = !shouldUseDraftStream ? void 0 : async () => {
+		if (hasStreamedMessage) {
+			draftStream?.forceNewMessage();
+			hasStreamedMessage = false;
+			appendRenderedText = "";
+			appendSourceText = "";
+			statusUpdateCount = 0;
+		}
+		previewToolProgressSuppressed = false;
+		previewToolProgressLines = [];
+	};
+	let dispatchError;
+	let queuedFinal = false;
+	let counts = {};
+	try {
+		const turnResult = await dispatchChannelInboundReply({
+			cfg,
+			channel: "slack",
+			accountId: route.accountId,
+			agentId: route.agentId,
+			routeSessionKey: route.sessionKey,
+			storePath: prepared.turn.storePath,
+			ctxPayload: prepared.ctxPayload,
+			recordInboundSession,
+			dispatchReplyWithBufferedBlockDispatcher,
+			dispatcherOptions: {
+				...replyPipeline,
+				humanDelay: resolveHumanDelayConfig(cfg, route.agentId)
+			},
+			delivery: {
+				deliver: deliverSlackPayload,
+				onError: onSlackDeliveryError
+			},
+			record: prepared.turn.record,
+			history: prepared.turn.history,
+			botLoopProtection: resolveSlackBotLoopProtection(prepared),
+			replyOptions: {
+				skillFilter: prepared.channelConfig?.skills,
+				sourceReplyDeliveryMode,
+				hasRepliedRef,
+				disableBlockStreaming,
+				onModelSelected,
+				suppressDefaultToolProgressMessages: suppressDefaultToolProgressMessages ? true : void 0,
+				onPartialReply: useStreaming ? void 0 : !previewStreamingEnabled ? void 0 : async (payload) => {
+					updateDraftFromPartial(payload.text);
+				},
+				onAssistantMessageStart: onDraftBoundary,
+				onReasoningEnd: onDraftBoundary,
+				onReasoningStream: statusReactionsEnabled ? async () => {
+					await statusReactions.setThinking();
+				} : void 0,
+				onToolStart: async (payload) => {
+					if (statusReactionsEnabled) await statusReactions.setTool(payload.name);
+					await pushPreviewToolProgress(buildChannelProgressDraftLineForEntry(account.config, {
+						event: "tool",
+						itemId: payload.itemId,
+						toolCallId: payload.toolCallId,
+						name: payload.name,
+						phase: payload.phase,
+						args: payload.args
+					}, payload.detailMode ? { detailMode: payload.detailMode } : void 0), { toolName: payload.name });
+				},
+				onItemEvent: async (payload) => {
+					await pushPreviewToolProgress(buildChannelProgressDraftLineForEntry(account.config, {
+						event: "item",
+						itemId: payload.itemId,
+						itemKind: payload.kind,
+						title: payload.title,
+						name: payload.name,
+						phase: payload.phase,
+						status: payload.status,
+						summary: payload.summary,
+						progressText: payload.progressText,
+						meta: payload.meta
+					}));
+				},
+				onPlanUpdate: async (payload) => {
+					if (payload.phase !== "update") return;
+					await pushPreviewToolProgress(buildChannelProgressDraftLine({
+						event: "plan",
+						phase: payload.phase,
+						title: payload.title,
+						explanation: payload.explanation,
+						steps: payload.steps
+					}));
+				},
+				onApprovalEvent: async (payload) => {
+					if (payload.phase !== "requested") return;
+					await pushPreviewToolProgress(buildChannelProgressDraftLine({
+						event: "approval",
+						phase: payload.phase,
+						title: payload.title,
+						command: payload.command,
+						reason: payload.reason,
+						message: payload.message
+					}));
+				},
+				onCommandOutput: async (payload) => {
+					if (payload.phase !== "end") return;
+					await pushPreviewToolProgress(buildChannelProgressDraftLine({
+						event: "command-output",
+						itemId: payload.itemId,
+						toolCallId: payload.toolCallId,
+						phase: payload.phase,
+						title: payload.title,
+						name: payload.name,
+						status: payload.status,
+						exitCode: payload.exitCode
+					}));
+				},
+				onPatchSummary: async (payload) => {
+					if (payload.phase !== "end") return;
+					await pushPreviewToolProgress(buildChannelProgressDraftLine({
+						event: "patch",
+						itemId: payload.itemId,
+						toolCallId: payload.toolCallId,
+						phase: payload.phase,
+						title: payload.title,
+						name: payload.name,
+						added: payload.added,
+						modified: payload.modified,
+						deleted: payload.deleted,
+						summary: payload.summary
+					}));
+				}
+			}
+		});
+		if (turnResult.dispatched) {
+			const result = turnResult.dispatchResult;
+			queuedFinal = result.queuedFinal;
+			counts = result.counts;
+		}
+	} catch (err) {
+		dispatchError = err;
+	} finally {
+		progressDraftGate.cancel();
+		await draftStream?.discardPending();
+	}
+	let streamFallbackDelivered = false;
+	const finalStream = streamSession;
+	if (finalStream && !finalStream.stopped) try {
+		const completionChunks = useNativeProgressStreaming && !nativeProgressCompletionSent && previewToolProgressLines.length > 0 ? buildSlackProgressStreamCompletionChunks({
+			title: explicitProgressTitle,
+			lines: previewToolProgressLines,
+			maxLineChars: progressDraftMaxLineChars,
+			finalInProgressStatus: dispatchError ? "error" : "complete"
+		}) : void 0;
+		if (completionChunks?.length) nativeProgressCompletionSent = true;
+		await stopSlackStream({
+			session: finalStream,
+			...completionChunks?.length ? { chunks: completionChunks } : {},
+			...slackMessageMetadata ? { metadata: slackMessageMetadata } : {}
+		});
+	} catch (err) {
+		if (err instanceof SlackStreamNotDeliveredError) streamFallbackDelivered = await deliverPendingStreamFallback(finalStream, err);
+		else runtime.error?.(danger(`slack-stream: failed to stop stream: ${formatSlackError(err)}`));
+	}
+	const anyReplyDelivered = hasVisibleInboundReplyDispatch({
+		queuedFinal,
+		counts
+	}, {
+		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) {
+		await statusReactions.setDone();
+		if (ctx.removeAckAfterReply) (async () => {
+			await sleep(statusReactionTiming.doneHoldMs);
+			await statusReactions.clear();
+		})();
+		else statusReactions.restoreInitial();
+	} else await statusReactions.restoreInitial();
+	if (dispatchError) throw dispatchError;
+	const participationThreadTs = usedReplyThreadTs ?? statusThreadTs;
+	if (anyReplyDelivered && participationThreadTs) recordSlackThreadParticipation(account.accountId, message.channel, participationThreadTs, { agentId: route.agentId });
+	if (!anyReplyDelivered && !draftPreviewCommitted) {
+		await draftStream?.clear();
+		return;
+	}
+	if (shouldLogVerbose()) {
+		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: ctx.app.client
+		}),
+		onError: (err) => {
+			logAckFailure({
+				log: logVerbose,
+				channel: "slack",
+				target: `${message.channel}/${message.ts}`,
+				error: err
+			});
+		}
+	});
+}
+//#endregion
 //#region extensions/slack/src/monitor/message-handler/prepare-content.ts
 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;
 let slackMediaModulePromise$1;
 function loadSlackMediaModule$1() {
-	slackMediaModulePromise$1 ??= import("./actions-1o9nMIY8.js").then((n) => n.h);
+	slackMediaModulePromise$1 ??= import("./actions-zfVWcIY6.js").then((n) => n.h);
 	return slackMediaModulePromise$1;
 }
 function collectUniqueSlackMentionIds$1(texts) {
@@ -336,38 +2090,6 @@ async function resolveSlackDmHistoryContext(params) {
 	}
 }
 //#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 isThreadReply = typeof incomingThreadTs === "string" && incomingThreadTs.length > 0 && (incomingThreadTs !== messageTs || Boolean(params.message.parent_user_id));
-	return {
-		incomingThreadTs,
-		messageTs,
-		isThreadReply,
-		replyToId: incomingThreadTs ?? messageTs,
-		messageThreadId: isThreadReply ? 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/prepare-routing.ts
 const slackRouteBindingConfigCache = /* @__PURE__ */ new WeakMap();
 function slackTargetDefaultKindForPeer(kind) {
@@ -575,7 +2297,7 @@ function formatSlackBotStarterThreadLabel(params) {
 //#region extensions/slack/src/monitor/message-handler/prepare-thread-context.ts
 let slackMediaModulePromise;
 function loadSlackMediaModule() {
-	slackMediaModulePromise ??= import("./actions-1o9nMIY8.js").then((n) => n.h);
+	slackMediaModulePromise ??= import("./actions-zfVWcIY6.js").then((n) => n.h);
 	return slackMediaModulePromise;
 }
 const SLACK_THREAD_CONTEXT_USER_LOOKUP_CONCURRENCY = 4;
@@ -1710,4 +3432,4 @@ async function prepareSlackMessage(params) {
 	};
 }
 //#endregion
-export { resolveSlackThreadTargets as n, prepareSlackMessage as t };
+export { dispatchPreparedSlackMessage, prepareSlackMessage };