@openclaw/slack 2026.8.1-beta.2 → 2026.8.1

package/dist/{pipeline.runtime-BvYsM5JO.js → pipeline.runtime-Bd22U0ga.js}

@@ -1,35 +1,37 @@
-import { t as resolveSlackReplyToMode } from "./account-reply-mode-DrUXogvO.js";
-import { a as parseSlackTarget, n as formatSlackTarget } from "./target-parsing-BnMD2ZqZ.js";
-import "./targets-Cx5W_n3W.js";
-import { B as SLACK_TEXT_LIMIT, G as truncateSlackText, K as truncateSlackTextByUtf8Bytes, L as SLACK_EDIT_TEXT_MAX_BYTES, M as normalizeSlackOutboundText, N as buildSlackBlocksFallbackText, T as hasSlackNativeDataBlock, W as countSlackTextUtf8Bytes, Z as SLACK_SESSION_LINK_ACTION_ID, at as escapeSlackMrkdwn, c as normalizeSlackAllowOwnerEntry, s as normalizeAllowListLower, u as resolveSlackAllowListMatch, y as resolveSlackReplyRenderPlan } from "./group-policy-c4RP9bjc.js";
-import { r as formatSlackError } from "./probe-HoEg_WxB.js";
+import { n as resolveSlackConversationBindingRoute, r as resolveSlackReplyToMode, t as normalizeSlackRouteBindingConfig } from "./conversation-binding-route-DFVLUdYF.js";
+import { n as formatSlackTarget } from "./target-parsing-BnMD2ZqZ.js";
+import { I as countSlackTextUtf8Bytes, L as truncateSlackText, M as SLACK_TEXT_LIMIT, Q as normalizeSlackOutboundText, R as truncateSlackTextByUtf8Bytes, T as buildSlackBlocksFallbackText, U as SLACK_SESSION_LINK_ACTION_ID, a as qualifySlackConversationId, b as hasSlackNativeDataBlock, et as escapeSlackMrkdwn, k as SLACK_EDIT_TEXT_MAX_BYTES, m as resolveSlackReplyRenderPlan, o as qualifySlackRoutePeerId, s as resolveSlackEnterpriseMainDmSessionKey } from "./group-policy-BdwszjYn.js";
+import { f as resolveSlackAllowListMatch, l as normalizeAllowListLower, o as formatSlackError, u as normalizeSlackAllowOwnerEntry } from "./probe-0usmAb0i.js";
 import { n as resolveSlackStreamingMode, t as resolveSlackNativeStreaming } from "./streaming-compat-B-e0mqM0.js";
-import { b as formatSlackFileReference, i as editSlackRenderedMessage, p as removeSlackReaction, r as editSlackMessage, t as deleteSlackMessage, u as reactSlackMessage, v as resolveSlackThreadHistory, x as buildSlackEditTextPayload, y as resolveSlackThreadStarter } from "./actions-BTDXwwE3.js";
-import { a as resolveSlackMessageText } from "./block-text-YtiNkqmx.js";
-import { c as hasSlackThreadFailureNotice, d as recordSlackThreadFailureNotice, f as recordSlackThreadParticipation, l as hasSlackThreadParticipation, o as clearSlackThreadFailureNotice, p as buildSlackNativeDataDeliveryPlan, r as sendMessageSlack, u as hasSlackThreadParticipationWithPersistence } from "./send-Nor0iBwY.js";
-import { C as resolveChannelResetConfig, D as stripSlackMentionsForCommandDetection, S as resolveChannelContextVisibilityMode, T as updateLastRoute, _ as normalizeSlackChannelType, b as parseSlackAssistantThreadMetadata, c as resolveConversationLabel$1, d as resolveSlackEffectiveAllowFrom, g as resolveSlackEnterpriseMainDmSessionKey, h as qualifySlackRoutePeerId, l as authorizeSlackBotRoomMessage, m as qualifySlackConversationId, o as authorizeSlackDirectMessage, r as resolveSlackRoomContextHints, s as trackSlackDraftMessage, u as resolveSlackCommandIngress, v as resolveSlackChatType, w as resolveStorePath, x as readSessionUpdatedAt, y as buildSlackAssistantThreadMetadata } from "./provider-CDNvBXUi.js";
-import { n as resolveSlackChannelConfig } from "./policy-TapwbeaT.js";
-import { a as resolveDeliveredSlackReplyThreadTs, i as readSlackReplyBlocks, n as deliverReplies, o as resolveSlackThreadTs, s as emitSlackMessageSentHooks, t as createSlackReplyDeliveryPlan } from "./replies-CeOfv82I.js";
+import { D as resolveSlackMessageText$1, E as resolveSlackBlocksText, O as buildSlackEditTextPayload, S as formatSlackFileReferenceList, T as isSlackUnfurlAttachment, a as editSlackRenderedMessage, d as reactSlackMessage, i as editSlackMessage, m as removeSlackReaction, n as deleteSlackMessage, v as logVerbose$1, w as hasSlackTableBlock, x as formatSlackFileReference } from "./actions-BI7JkfVm.js";
+import { c as hasSlackThreadFailureNotice, d as recordSlackThreadFailureNotice, f as recordSlackThreadParticipation, l as hasSlackThreadParticipation, m as buildSlackNativeDataDeliveryPlan, o as clearSlackThreadFailureNotice, r as sendMessageSlack, u as hasSlackThreadParticipationWithPersistence } from "./send-DS9ICrBI.js";
+import { C as resolveStorePath, E as stripSlackMentionsForCommandDetection, S as resolveChannelResetConfig, _ as resolveSlackChatType, b as readSessionUpdatedAt, c as resolveSlackThreadTargets, d as authorizeSlackBotRoomMessage, f as resolveSlackCommandIngress, g as normalizeSlackChannelType, l as trackSlackDraftMessage, o as authorizeSlackDirectMessage, p as resolveSlackEffectiveAllowFrom, r as resolveSlackRoomContextHints, s as resolveSlackThreadContext, u as resolveConversationLabel$1, v as buildSlackAssistantThreadMetadata, w as updateLastRoute, x as resolveChannelContextVisibilityMode, y as parseSlackAssistantThreadMetadata } from "./provider-CN_8hFv2.js";
+import { n as resolveSlackChannelConfig } from "./policy-CtQVbde1.js";
+import { a as resolveDeliveredSlackReplyThreadTs, c as emitSlackMessageSentHooks, i as readSlackReplyBlocks, n as deliverReplies, o as resolveSlackThreadTs, s as sanitizeSlackMonitorReplyPayload, t as createSlackReplyDeliveryPlan } from "./replies-BSiRQOJ1.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, createFinalizableDraftStreamControlsForState, defineFinalizableLivePreviewAdapter, deliverWithFinalizableLivePreviewAdapter, formatChannelProgressDraftText, formatPlanChecklistLines, isChannelProgressDraftWorkToolName, resolveAgentOutboundIdentity, resolveChannelMessageSourceReplyDeliveryMode, resolveChannelProgressDraftConfig, resolveChannelProgressDraftMaxLineChars, resolveChannelStreamingBlockEnabled, resolveChannelStreamingPreviewToolProgress, resolveChannelStreamingSuppressDefaultToolProgressMessages } from "openclaw/plugin-sdk/channel-outbound";
+import { buildChannelProgressDraftLine, buildChannelProgressDraftLineForEntry, createChannelMessageReplyPipeline, createChannelProgressDraftCompositor, createChannelProgressWorkCounter, createFinalizableDraftStreamControlsForState, defineFinalizableLivePreviewAdapter, deliverWithFinalizableLivePreviewAdapter, formatChannelProgressDraftText, formatPlanChecklistLines, isChannelProgressDraftWorkToolName, resolveAgentOutboundIdentity, resolveChannelMessageSourceReplyDeliveryMode, resolveChannelProgressDraftConfig, resolveChannelProgressDraftMaxLineChars, resolveChannelStreamingBlockEnabled, resolveChannelStreamingPreviewToolProgress, resolveChannelStreamingSuppressDefaultToolProgressMessages } from "openclaw/plugin-sdk/channel-outbound";
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 import { danger, logVerbose, shouldLogVerbose } from "openclaw/plugin-sdk/runtime-env";
+import { sanitizeAssistantVisibleText } from "openclaw/plugin-sdk/text-chunking";
+import { resolveMarkdownTableMode } from "openclaw/plugin-sdk/markdown-table-runtime";
+import { buildTtsSupplementMediaPayload, getReplyPayloadTtsSupplement, isReplyPayloadNonTerminalToolErrorWarning, resolveSendableOutboundReplyParts } from "openclaw/plugin-sdk/reply-payload";
 import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import { createHash } from "node:crypto";
+import { pruneMapToMaxSize } from "openclaw/plugin-sdk/collection-runtime";
+import { ensureConfiguredBindingRouteReady } from "openclaw/plugin-sdk/conversation-runtime";
+import { resolveChannelImplicitMentions } from "openclaw/plugin-sdk/channel-ingress-runtime";
 import fs from "node:fs/promises";
+import { runTasksWithConcurrency } from "openclaw/plugin-sdk/concurrency-runtime";
 import { formatErrorMessage, toErrorObject } from "openclaw/plugin-sdk/error-runtime";
-import { asDateTimestampMs, asFiniteNumberInRange, parseStrictFiniteNumber, resolveExpiresAtMsFromDurationMs } from "openclaw/plugin-sdk/number-runtime";
-import { buildTtsSupplementMediaPayload, getReplyPayloadTtsSupplement, isReplyPayloadNonTerminalToolErrorWarning, resolveSendableOutboundReplyParts } from "openclaw/plugin-sdk/reply-payload";
 import { filterSupplementalContextItems, resolvePinnedMainDmOwnerFromAllowlist, shouldIncludeSupplementalContext } from "openclaw/plugin-sdk/security-runtime";
 import { mimeTypeFromFilePath } from "openclaw/plugin-sdk/media-mime";
-import { ensureConfiguredBindingRouteReady, resolveConfiguredBindingRoute, resolveRuntimeConversationBindingRoute } from "openclaw/plugin-sdk/conversation-runtime";
 import { createChannelHistoryWindow } from "openclaw/plugin-sdk/reply-history";
 import { mergePairLoopGuardConfig } from "openclaw/plugin-sdk/pair-loop-guard-runtime";
 import { enqueueRoutedSystemEvent } from "openclaw/plugin-sdk/system-event-runtime";
-import { resolveChannelImplicitMentions } from "openclaw/plugin-sdk/channel-ingress-runtime";
+import { asDateTimestampMs, asFiniteNumberInRange, parseStrictFiniteNumber, resolveExpiresAtMsFromDurationMs } from "openclaw/plugin-sdk/number-runtime";
 import { getGlobalHookRunner } from "openclaw/plugin-sdk/plugin-runtime";
-import { buildChannelInboundEventContext, buildMentionRegexes, classifyChannelInboundEvent, dispatchChannelInboundTurn, formatInboundEnvelope, formatInboundMediaUnavailableText, hasVisibleInboundReplyDispatch, implicitMentionKindWhen, logInboundDrop, matchesMentionWithExplicit, readAgentRunTerminalOutcome, recordDroppedChannelInboundHistory, resolveEnvelopeFormatOptions, resolveInboundMentionDecision, resolveInboundSupplementalSenderAllowed, resolveUnmentionedGroupInboundPolicy, toInboundMediaFactsWithMetadata } from "openclaw/plugin-sdk/channel-inbound";
+import { buildChannelInboundEventContext, buildMentionRegexes, classifyChannelInboundEvent, dispatchChannelInboundTurn, formatInboundEnvelope, formatInboundMediaUnavailableText, hasVisibleInboundReplyDispatch, implicitMentionKindWhen, logInboundDrop, matchesMentionWithExplicit, readAgentRunTerminalOutcome, recordDroppedChannelInboundHistory, resolveEnvelopeFormatOptions, resolveInboundMentionDecision, resolveInboundReplyDispatchCounts, resolveInboundSupplementalSenderAllowed, resolveUnmentionedGroupInboundPolicy, toInboundMediaFactsWithMetadata } from "openclaw/plugin-sdk/channel-inbound";
 import { resolveHumanDelayConfig } from "openclaw/plugin-sdk/agent-runtime";
 import { resolveGatewayPublicOrigin } from "openclaw/plugin-sdk/config-contracts";
 import { buildControlUiSessionPath } from "openclaw/plugin-sdk/session-discussion";
@@ -37,8 +39,7 @@ import { DEFAULT_TIMING, createStatusReactionController, logAckFailure, logTypin
 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 { createChannelPreflightAudio } from "openclaw/plugin-sdk/media-understanding-runtime";
-import { runTasksWithConcurrency } from "openclaw/plugin-sdk/concurrency-runtime";
+import { createChannelPreflightAudio, formatAudioTranscriptForAgent } from "openclaw/plugin-sdk/media-understanding-runtime";
 //#region extensions/slack/src/streaming.ts
 /**
 * Thrown when Slack definitively rejects a stream flush/finalize while text
@@ -267,7 +268,11 @@ function resolveExplicitSlackProgressTitle(entry) {
 	const trimmed = label.trim();
 	return trimmed && trimmed.toLowerCase() !== "auto" ? trimmed : void 0;
 }
+function resolveSlackProgressStyle(entry) {
+	return entry?.streaming?.progress?.style === "compact" ? "compact" : "card";
+}
 function resolveSlackNativeProgressTaskCards(entry) {
+	if (resolveSlackProgressStyle(entry) === "compact") return false;
 	const streaming = entry?.streaming;
 	if (!streaming || typeof streaming !== "object" || Array.isArray(streaming)) return true;
 	const progressConfig = streaming.progress;
@@ -380,12 +385,12 @@ function createSlackDraftStream(params) {
 	const send = params.send ?? sendMessageSlack;
 	const edit = params.edit ?? editSlackMessage;
 	const remove = params.remove ?? deleteSlackMessage;
-	let streamMessageId;
-	let streamChannelId;
+	let streamMessage;
 	let untrackConversationBoundary;
 	let lastVisibleUpdate;
 	let lastSentKey = "";
-	const detachedMessages = [];
+	const pendingCleanupMessages = [];
+	let cleanupTail = Promise.resolve();
 	const finalizedMessageIds = /* @__PURE__ */ new Set();
 	const streamState = {
 		stopped: false,
@@ -407,8 +412,8 @@ function createSlackDraftStream(params) {
 		if (sentKey === lastSentKey) return;
 		lastSentKey = sentKey;
 		try {
-			if (streamChannelId && streamMessageId) {
-				await edit(streamChannelId, streamMessageId, trimmed, {
+			if (streamMessage) {
+				await edit(streamMessage.channelId, streamMessage.messageId, trimmed, {
 					cfg: params.cfg,
 					token: params.token,
 					accountId: params.accountId,
@@ -440,27 +445,29 @@ function createSlackDraftStream(params) {
 				...params.metadata ? { metadata: params.metadata } : {},
 				...blocks ? { blocks } : {}
 			});
-			streamChannelId = sent.channelId || streamChannelId;
-			streamMessageId = sent.messageId || streamMessageId;
-			if (!streamChannelId || !streamMessageId) {
+			if (!sent.channelId || !sent.messageId) {
 				stopTrackingConversationBoundary();
 				streamState.stopped = true;
 				params.warn?.("slack stream preview stopped (missing identifiers from sendMessage)");
 				return;
 			}
+			streamMessage = {
+				channelId: sent.channelId,
+				messageId: sent.messageId
+			};
 			lastVisibleUpdate = {
 				text: trimmed,
 				...blocks ? { blocks } : {}
 			};
-			if (pendingBoundary && params.conversationChannelId === streamChannelId) pendingBoundary.setMessageTs(streamMessageId);
+			if (pendingBoundary && params.conversationChannelId === streamMessage.channelId) pendingBoundary.setMessageTs(streamMessage.messageId);
 			else {
 				stopTrackingConversationBoundary();
 				untrackConversationBoundary = trackSlackDraftMessage({
 					accountId: params.accountId,
 					teamId: params.eventScope?.teamId,
-					channelId: streamChannelId,
+					channelId: streamMessage.channelId,
 					threadTs,
-					messageTs: streamMessageId,
+					messageTs: streamMessage.messageId,
 					onInterveningMessage: forceNewMessage
 				}).stop;
 			}
@@ -481,60 +488,58 @@ function createSlackDraftStream(params) {
 		untrackConversationBoundary?.();
 		untrackConversationBoundary = void 0;
 	};
-	const removeMessage = async (channelId, messageId) => {
-		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 dropDetachedMessages = () => {
+		cleanupTail = cleanupTail.then(async () => {
+			for (let index = 0; index < pendingCleanupMessages.length;) {
+				const message = pendingCleanupMessages[index];
+				if (!message) return;
+				try {
+					await remove(message.channelId, message.messageId, {
+						token: params.token,
+						accountId: params.accountId,
+						...params.eventScope ? { client: params.eventScope.client } : {}
+					});
+					pendingCleanupMessages.splice(index, 1);
+				} catch (err) {
+					params.warn?.(`slack stream preview cleanup failed: ${formatSlackError(err)}`);
+					index += 1;
+				}
+			}
+		});
+		return cleanupTail;
 	};
 	const clear = async () => {
 		stopTrackingConversationBoundary();
 		await discardPending();
-		const channelId = streamChannelId;
-		const messageId = streamMessageId;
-		streamChannelId = void 0;
-		streamMessageId = void 0;
+		if (streamMessage) {
+			pendingCleanupMessages.push(streamMessage);
+			streamMessage = void 0;
+		}
 		lastVisibleUpdate = void 0;
 		lastSentKey = "";
-		if (!channelId || !messageId) return;
-		await removeMessage(channelId, messageId);
+		await dropDetachedMessages();
 	};
 	const forceNewMessage = () => {
 		stopTrackingConversationBoundary();
 		streamState.stopped = false;
 		streamState.final = false;
-		if (streamChannelId && streamMessageId && !finalizedMessageIds.has(streamMessageId)) detachedMessages.push({
-			channelId: streamChannelId,
-			messageId: streamMessageId
-		});
-		streamMessageId = void 0;
-		streamChannelId = void 0;
+		if (streamMessage && !finalizedMessageIds.has(streamMessage.messageId)) pendingCleanupMessages.push(streamMessage);
+		streamMessage = void 0;
 		lastVisibleUpdate = void 0;
 		lastSentKey = "";
 		loop.resetPending();
 	};
-	const dropDetachedMessages = async () => {
-		let message;
-		while ((message = detachedMessages.shift()) !== void 0) {
-			const { channelId, messageId } = message;
-			await removeMessage(channelId, messageId);
-		}
-	};
 	const discardPendingAndStopTracking = async () => {
 		stopTrackingConversationBoundary();
 		await discardPending();
 	};
 	const finalizeMessage = async (messageId, editFinal) => {
-		const channelId = streamChannelId;
+		const currentMessage = streamMessage;
 		const previousUpdate = lastVisibleUpdate;
-		if (!channelId || streamMessageId !== messageId || !previousUpdate) return false;
+		if (!currentMessage || currentMessage.messageId !== messageId || !previousUpdate) return false;
+		const { channelId } = currentMessage;
 		await editFinal();
-		if (streamChannelId === channelId && streamMessageId === messageId) {
+		if (streamMessage?.channelId === channelId && streamMessage.messageId === messageId) {
 			finalizedMessageIds.add(messageId);
 			stopTrackingConversationBoundary();
 			return true;
@@ -562,8 +567,58 @@ function createSlackDraftStream(params) {
 		forceNewMessage,
 		dropDetachedMessages,
 		finalizeMessage,
-		messageId: () => streamMessageId,
-		channelId: () => streamChannelId
+		messageId: () => streamMessage?.messageId,
+		channelId: () => streamMessage?.channelId
+	};
+}
+//#endregion
+//#region extensions/slack/src/stream-mode.ts
+function resolveSlackStreamingConfig(params) {
+	return {
+		mode: resolveSlackStreamingMode(params),
+		nativeStreaming: resolveSlackNativeStreaming(params)
+	};
+}
+function applyAppendOnlyStreamUpdate(params) {
+	const incoming = params.incoming.trimEnd();
+	if (!incoming) return {
+		rendered: params.rendered,
+		source: params.source,
+		changed: false
+	};
+	if (!params.rendered) return {
+		rendered: incoming,
+		source: incoming,
+		changed: true
+	};
+	if (incoming === params.source) return {
+		rendered: params.rendered,
+		source: params.source,
+		changed: false
+	};
+	if (incoming.startsWith(params.rendered)) return {
+		rendered: incoming,
+		source: incoming,
+		changed: incoming !== params.rendered
+	};
+	if (incoming.startsWith(params.source)) {
+		const delta = incoming.slice(params.source.length);
+		return {
+			rendered: `${params.rendered}${delta}`,
+			source: incoming,
+			changed: delta.length > 0
+		};
+	}
+	if (params.source.startsWith(incoming)) return {
+		rendered: params.rendered,
+		source: params.source,
+		changed: false
+	};
+	const separator = params.separator ?? (params.rendered.endsWith("\n") ? "" : "\n");
+	return {
+		rendered: `${params.rendered}${separator}${incoming}`,
+		source: incoming,
+		changed: true
 	};
 }
 //#endregion
@@ -628,12 +683,14 @@ function lineTaskTitle(line) {
 	return compactTitle(label);
 }
 function lineTaskDetails(line, maxLineChars) {
-	const detail = (lineDetailParts(line).join(" · ") || line.status?.trim())?.replace(SLACK_PROGRESS_LINE_DELTA_RE, "").replace(/\s+·\s*$/u, "").trim();
-	return detail ? compactDetail(detail, maxLineChars) : void 0;
+	const detail = line.detail?.replace(SLACK_PROGRESS_LINE_DELTA_RE, "").replace(/\s+·\s*$/u, "").trim();
+	return detail && detail !== line.status?.trim() ? compactDetail(detail, maxLineChars) : void 0;
 }
 function lineTaskOutput(line) {
-	const match = SLACK_PROGRESS_LINE_DELTA_RE.exec(lineDetailParts(line).join(" · "));
-	return match ? `+${match[1]} −${match[2]}` : void 0;
+	const match = line.detail ? SLACK_PROGRESS_LINE_DELTA_RE.exec(line.detail) : null;
+	if (match) return `+${match[1]} −${match[2]}`;
+	const status = line.status?.replace(/\s+/g, " ").trim();
+	return status && lineTaskStatus(line) === "error" ? status : void 0;
 }
 function lineTaskStatus(line) {
 	const normalized = line.status?.replace(/\s+/g, " ").trim().toLowerCase();
@@ -738,7 +795,7 @@ function buildSlackProgressStreamChunks(params) {
 		};
 		if (task.details) chunk.details = task.details;
 		if (task.output) chunk.output = task.output;
-		if (index === finalTaskIndex && diffOutput) chunk.output = diffOutput;
+		if (index === finalTaskIndex && diffOutput) chunk.output = [task.output, diffOutput].filter(Boolean).join(" · ");
 		if (index === finalTaskIndex && params.sessionUrl) chunk.sources = buildSessionSources(params.sessionUrl);
 		return chunk;
 	});
@@ -784,8 +841,7 @@ function buildSlackProgressCardBlocks(params) {
 		...diffStat ? [diffStat] : [],
 		...params.elapsedSeconds && params.elapsedSeconds > 0 ? [`⏱ ${params.elapsedSeconds}s`] : []
 	].join(" · ");
-	const terminalFooter = [params.receiptSummary?.trim(), diffStat].filter(Boolean).join(" · ");
-	const footer = params.state === "working" ? workingFooter : terminalFooter;
+	const footer = params.state === "working" ? workingFooter : diffStat;
 	return [
 		{
 			type: "section",
@@ -821,35 +877,106 @@ function buildSlackProgressCardBlocks(params) {
 		}] : []
 	].slice(0, 50);
 }
+const EMPTY_SLACK_NATIVE_STREAM_SNAPSHOT = { tasks: /* @__PURE__ */ new Map() };
+const SLACK_TASK_FIELD_SEPARATOR = " · ";
+function resolveTaskFieldDelta(previous, incoming) {
+	if (!incoming) return {
+		field: previous,
+		delta: void 0
+	};
+	if (previous?.rendered.includes(incoming)) return {
+		field: {
+			rendered: previous.rendered,
+			source: incoming
+		},
+		delta: void 0
+	};
+	const next = applyAppendOnlyStreamUpdate({
+		incoming,
+		rendered: previous?.rendered ?? "",
+		source: previous?.source ?? "",
+		separator: SLACK_TASK_FIELD_SEPARATOR
+	});
+	const delta = next.changed ? next.rendered.slice(previous?.rendered.length ?? 0) : void 0;
+	return {
+		field: {
+			rendered: next.rendered,
+			source: next.source
+		},
+		delta
+	};
+}
 /**
-* Slack native streams key task rows by persistent id with no removal chunk.
-* When the task source switches representation (tool lines <-> typed plan) or
-* a snapshot drops ids, previously emitted non-terminal rows must receive a
-* final update or they linger in_progress forever.
+* Turns a full task snapshot into the delta Slack must receive. Native streams
+* key rows by persistent id with no removal chunk: unchanged rows are omitted,
+* changed rows carry only their unsent field text, and rows that dropped out
+* (plan shrinks, tool-line <-> plan source switches) get a final complete
+* update or they linger in_progress forever.
 */
 function reconcileSlackNativeTaskChunks(params) {
 	const nextTasks = /* @__PURE__ */ new Map();
-	for (const chunk of params.chunks ?? []) if (chunk.type === "task_update") nextTasks.set(chunk.id, {
-		title: chunk.title,
-		status: chunk.status
-	});
-	const terminalized = [...params.previousTasks].filter(([id, task]) => !nextTasks.has(id) && task.status !== "complete" && task.status !== "error").map(([id, task]) => {
-		const entry = {
-			title: task.title,
-			status: "complete"
+	let planTitle = params.previous.planTitle;
+	const emitted = [];
+	for (const chunk of params.chunks ?? []) {
+		if (chunk.type === "plan_update") {
+			if (chunk.title !== planTitle) {
+				planTitle = chunk.title;
+				emitted.push(chunk);
+			}
+			continue;
+		}
+		if (chunk.type !== "task_update") {
+			emitted.push(chunk);
+			continue;
+		}
+		const previousRow = params.previous.tasks.get(chunk.id);
+		const status = chunk.status;
+		const details = resolveTaskFieldDelta(previousRow?.details, chunk.details);
+		const output = resolveTaskFieldDelta(previousRow?.output, chunk.output);
+		const sourcesChanged = Boolean(chunk.sources) && !previousRow?.sourcesSent;
+		const row = {
+			title: chunk.title,
+			status
 		};
-		nextTasks.set(id, entry);
-		return {
+		if (details.field) row.details = details.field;
+		if (output.field) row.output = output.field;
+		if (sourcesChanged || previousRow?.sourcesSent) row.sourcesSent = true;
+		nextTasks.set(chunk.id, row);
+		if (!(!previousRow || previousRow.title !== chunk.title || previousRow.status !== status || Boolean(details.delta) || Boolean(output.delta) || sourcesChanged)) continue;
+		const update = {
+			type: "task_update",
+			id: chunk.id,
+			title: chunk.title,
+			status
+		};
+		if (details.delta) update.details = details.delta;
+		if (output.delta) update.output = output.delta;
+		if (sourcesChanged) update.sources = chunk.sources;
+		emitted.push(update);
+	}
+	for (const [id, row] of params.previous.tasks) {
+		if (nextTasks.has(id)) continue;
+		if (row.status === "complete" || row.status === "error") {
+			nextTasks.set(id, row);
+			continue;
+		}
+		nextTasks.set(id, {
+			...row,
+			status: "complete"
+		});
+		emitted.push({
 			type: "task_update",
 			id,
-			title: task.title,
+			title: row.title,
 			status: "complete"
-		};
-	});
-	for (const [id, task] of params.previousTasks) if (!nextTasks.has(id)) nextTasks.set(id, task);
+		});
+	}
 	return {
-		chunks: params.chunks?.length ? [...params.chunks, ...terminalized] : terminalized.length ? terminalized : params.chunks,
-		tasks: nextTasks
+		chunks: emitted.length > 0 ? emitted : void 0,
+		snapshot: {
+			...planTitle ? { planTitle } : {},
+			tasks: nextTasks
+		}
 	};
 }
 function buildSlackProgressStreamCompletionChunks(params) {
@@ -859,56 +986,6 @@ function buildSlackProgressStreamCompletionChunks(params) {
 	});
 }
 //#endregion
-//#region extensions/slack/src/stream-mode.ts
-function resolveSlackStreamingConfig(params) {
-	return {
-		mode: resolveSlackStreamingMode(params),
-		nativeStreaming: resolveSlackNativeStreaming(params)
-	};
-}
-function applyAppendOnlyStreamUpdate(params) {
-	const incoming = params.incoming.trimEnd();
-	if (!incoming) return {
-		rendered: params.rendered,
-		source: params.source,
-		changed: false
-	};
-	if (!params.rendered) return {
-		rendered: incoming,
-		source: incoming,
-		changed: true
-	};
-	if (incoming === params.source) return {
-		rendered: params.rendered,
-		source: params.source,
-		changed: false
-	};
-	if (incoming.startsWith(params.rendered)) return {
-		rendered: incoming,
-		source: incoming,
-		changed: incoming !== params.rendered
-	};
-	if (incoming.startsWith(params.source)) {
-		const delta = incoming.slice(params.source.length);
-		return {
-			rendered: `${params.rendered}${delta}`,
-			source: incoming,
-			changed: delta.length > 0
-		};
-	}
-	if (params.source.startsWith(incoming)) return {
-		rendered: params.rendered,
-		source: params.source,
-		changed: false
-	};
-	const separator = params.rendered.endsWith("\n") ? "" : "\n";
-	return {
-		rendered: `${params.rendered}${separator}${incoming}`,
-		source: incoming,
-		changed: true
-	};
-}
-//#endregion
 //#region extensions/slack/src/monitor/message-handler/dispatch-progress-render.ts
 function resolveStructuredProgressLines(lines) {
 	return lines.map((line) => {
@@ -1098,12 +1175,9 @@ function createSlackDraftProgressCardRuntime(params) {
 			maxLineChars: params.maxLineChars,
 			diffStat: snapshot.diffStat,
 			...state === "working" ? {
-				toolCalls: params.progressReceipt.toolCalls,
-				elapsedSeconds: params.progressReceipt.elapsedSeconds
-			} : {
-				receiptSummary: params.progressReceipt.buildSummaryLine(),
-				sessionUrl: resolveSessionUrl()
-			}
+				toolCalls: params.progressWorkCounter.toolCalls,
+				elapsedSeconds: params.progressWorkCounter.elapsedSeconds
+			} : { sessionUrl: resolveSessionUrl() }
 		});
 	};
 	const finalize = async (status, snapshot = params.getSnapshot(), fallbackText = resolveText(snapshot)) => {
@@ -1263,7 +1337,7 @@ function createSlackProgressRuntime(runtimeParams) {
 		log: logVerbose,
 		warn: logVerbose
 	}) : void 0;
-	let hasStreamedMessage = false;
+	let hasStreamedAnswer = false;
 	const isProgressMode = slackStreaming.mode === "progress";
 	const useNativeProgressStreaming = useStreaming && slackStreaming.mode === "progress";
 	const progressDraftActive = Boolean(draftStream) || useNativeProgressStreaming;
@@ -1276,12 +1350,11 @@ function createSlackProgressRuntime(runtimeParams) {
 		previewStreamingEnabled
 	});
 	let previewToolProgressSuppressed = false;
-	let nativeTaskState = /* @__PURE__ */ new Map();
+	let nativeStreamSnapshot = EMPTY_SLACK_NATIVE_STREAM_SNAPSHOT;
 	let appendRenderedText = "";
 	let appendSourceText = "";
 	let nativeProgressCompletionSent = false;
 	let nativeProgressTerminalStatus = "complete";
-	let nativeProgressChunkKey;
 	let nativeNarrationRenderedText = "";
 	let nativeNarrationSourceText = "";
 	let nativeStreamOrder = Promise.resolve();
@@ -1290,9 +1363,10 @@ function createSlackProgressRuntime(runtimeParams) {
 		nativeStreamOrder = run.catch(() => void 0);
 		return run;
 	};
-	const progressReceipt = createChannelProgressReceiptTracker();
+	const progressWorkCounter = createChannelProgressWorkCounter();
 	const progressSeed = `${account.accountId}:${message.channel}`;
-	const useDraftProgressCard = Boolean(draftStream) && isProgressMode;
+	const slackProgressStyle = resolveSlackProgressStyle(account.config);
+	const useDraftProgressCard = Boolean(draftStream) && isProgressMode && slackProgressStyle === "card";
 	const explicitProgressTitle = resolveExplicitSlackProgressTitle(account.config);
 	const progressDraftMaxLineChars = resolveChannelProgressDraftMaxLineChars(account.config);
 	const progressCard = createSlackDraftProgressCardRuntime({
@@ -1305,7 +1379,7 @@ function createSlackProgressRuntime(runtimeParams) {
 		},
 		draftStream,
 		enabled: useDraftProgressCard,
-		progressReceipt,
+		progressWorkCounter,
 		progressSeed,
 		explicitTitle: explicitProgressTitle,
 		maxLineChars: progressDraftMaxLineChars,
@@ -1367,16 +1441,14 @@ function createSlackProgressRuntime(runtimeParams) {
 		const snapshot = progressDraft.getSnapshot();
 		const progressLines = resolveNativeProgressLines(snapshot);
 		const narrationUpdate = resolveNarrationUpdate(resolveNativeProgressNarration(snapshot));
-		const hasRetirableNativeTasks = [...nativeTaskState.values()].some((task) => task.status !== "complete" && task.status !== "error");
+		const hasRetirableNativeTasks = [...nativeStreamSnapshot.tasks.values()].some((task) => task.status !== "complete" && task.status !== "error");
 		if (!useNativeProgressStreaming || delivery.streamFailed || progressLines.length === 0 && !snapshot.plan?.length && !snapshot.statusHeadline && !explicitProgressTitle && !hasRetirableNativeTasks && !narrationUpdate.delta) return false;
 		if (!await nativeTransport.waitForStart()) return false;
 		const reconciled = reconcileSlackNativeTaskChunks({
-			previousTasks: nativeTaskState,
+			previous: nativeStreamSnapshot,
 			chunks: buildNativeProgressChunks$1(snapshot)
 		});
-		const chunkKey = JSON.stringify(reconciled.chunks ?? []);
-		const taskChunksChanged = chunkKey !== nativeProgressChunkKey;
-		const chunks = taskChunksChanged ? reconciled.chunks : void 0;
+		const chunks = reconciled.chunks;
 		if (!chunks?.length && !narrationUpdate.delta) return false;
 		try {
 			const hadSession = Boolean(delivery.streamSession);
@@ -1390,10 +1462,7 @@ function createSlackProgressRuntime(runtimeParams) {
 				nativeNarrationRenderedText = narrationUpdate.next.rendered;
 				nativeNarrationSourceText = narrationUpdate.next.source;
 			}
-			if (taskChunksChanged) {
-				nativeProgressChunkKey = chunkKey;
-				nativeTaskState = reconciled.tasks;
-			}
+			if (chunks?.length) nativeStreamSnapshot = reconciled.snapshot;
 			return true;
 		} catch (err) {
 			runtime.error?.(danger(`slack-stream: native progress stream failed: ${formatSlackError(err)}, falling back`));
@@ -1420,7 +1489,7 @@ function createSlackProgressRuntime(runtimeParams) {
 		return true;
 	};
 	const resetProgressTurnState = () => {
-		progressReceipt.reset();
+		progressWorkCounter.reset();
 		nativeNarrationRenderedText = "";
 		nativeNarrationSourceText = "";
 	};
@@ -1445,7 +1514,6 @@ function createSlackProgressRuntime(runtimeParams) {
 				text: previewText,
 				blocks: progressCard.resolvePresentation(snapshot, "working")
 			} : previewText);
-			hasStreamedMessage = true;
 			if (options?.flush) await draftStream.flush();
 			return Boolean(draftStream.messageId() && draftStream.channelId());
 		}
@@ -1476,10 +1544,10 @@ function createSlackProgressRuntime(runtimeParams) {
 		const snapshot = progressDraft.getSnapshot();
 		const lines = resolveNativeProgressLines(snapshot);
 		const sessionUrl = progressCard.resolveSessionUrl();
-		const hasRetirableNativeTasks = [...nativeTaskState.values()].some((task) => task.status !== "complete" && task.status !== "error");
+		const hasRetirableNativeTasks = [...nativeStreamSnapshot.tasks.values()].some((task) => task.status !== "complete" && task.status !== "error");
 		if (lines.length === 0 && !snapshot.plan?.length && !hasRetirableNativeTasks && !snapshot.diffStat && !sessionUrl) return;
 		return reconcileSlackNativeTaskChunks({
-			previousTasks: nativeTaskState,
+			previous: nativeStreamSnapshot,
 			chunks: buildSlackProgressStreamCompletionChunks({
 				title: resolveNativeProgressTitle(snapshot) ?? (lines.length === 0 && !snapshot.plan?.length ? "Working" : void 0),
 				lines,
@@ -1514,7 +1582,10 @@ function createSlackProgressRuntime(runtimeParams) {
 		delivery.streamFailed = false;
 	};
 	const pushPlanProgress = async (steps, explanation) => {
-		if (isProgressMode) return await progressDraft.pushPlanProgress(steps, { explanation });
+		if (isProgressMode) {
+			if (slackProgressStyle === "compact") return false;
+			return await progressDraft.pushPlanProgress(steps, { explanation });
+		}
 		if (previewToolProgressSuppressed || !draftStream) return false;
 		const text = formatChannelProgressDraftText({
 			entry: account.config,
@@ -1524,10 +1595,7 @@ function createSlackProgressRuntime(runtimeParams) {
 			narration: explanation,
 			plan: steps
 		});
-		if (text) {
-			draftStream.update(text);
-			hasStreamedMessage = true;
-		}
+		if (text) draftStream.update(text);
 		return false;
 	};
 	const pushPreviewProgress = async (line, options) => {
@@ -1542,7 +1610,7 @@ function createSlackProgressRuntime(runtimeParams) {
 		return await progressDraft.pushToolProgress(line, options);
 	};
 	const updateDraftFromPartial = (text) => {
-		const trimmed = text?.trimEnd();
+		const trimmed = text && sanitizeAssistantVisibleText(text).trimEnd();
 		if (!trimmed) return false;
 		if (slackStreaming.mode === "block") {
 			previewToolProgressSuppressed = true;
@@ -1556,14 +1624,14 @@ function createSlackProgressRuntime(runtimeParams) {
 			appendSourceText = next.source;
 			if (!next.changed) return false;
 			draftStream?.update(next.rendered);
-			hasStreamedMessage = true;
+			hasStreamedAnswer = true;
 			return false;
 		}
 		if (isProgressMode) return false;
 		previewToolProgressSuppressed = true;
 		progressDraft.suppress();
 		draftStream?.update(trimmed);
-		hasStreamedMessage = true;
+		hasStreamedAnswer = true;
 		return false;
 	};
 	const pushReasoningProgress = async (payload) => {
@@ -1580,11 +1648,10 @@ function createSlackProgressRuntime(runtimeParams) {
 			progressDraft.mergeReasoningProgress(normalized, { snapshot: true });
 			return visible;
 		}
-		progressReceipt.noteReasoning();
 		return await progressDraft.pushReasoningProgress(payload.text, { snapshot: payload.isReasoningSnapshot === true });
 	};
 	const resetDraftDeliveryState = () => {
-		hasStreamedMessage = false;
+		hasStreamedAnswer = false;
 		appendRenderedText = "";
 		appendSourceText = "";
 	};
@@ -1604,10 +1671,9 @@ function createSlackProgressRuntime(runtimeParams) {
 			await dropDetachedProgressCards();
 		}
 		resetProgressTurnState();
-		nativeTaskState = /* @__PURE__ */ new Map();
+		nativeStreamSnapshot = EMPTY_SLACK_NATIVE_STREAM_SNAPSHOT;
 		nativeProgressCompletionSent = false;
 		nativeProgressTerminalStatus = "complete";
-		nativeProgressChunkKey = void 0;
 		progressCard.reset();
 		resetPreviewDeliveryState();
 		delivery.resetDeliveryTracker();
@@ -1618,7 +1684,7 @@ function createSlackProgressRuntime(runtimeParams) {
 			await beginNewProgressTurn();
 			return;
 		}
-		if (hasStreamedMessage) draftStream?.forceNewMessage();
+		if (hasStreamedAnswer) draftStream?.forceNewMessage();
 		resetDraftDeliveryState();
 		resetDraftProgressState();
 	};
@@ -1645,7 +1711,7 @@ function createSlackProgressRuntime(runtimeParams) {
 		suppressDefaultToolProgressMessages,
 		progressDraft,
 		commentaryProgressEnabled,
-		progressReceipt,
+		progressWorkCounter,
 		get nativeProgressCompletionSent() {
 			return nativeProgressCompletionSent;
 		},
@@ -1673,41 +1739,6 @@ function createSlackProgressRuntime(runtimeParams) {
 	};
 }
 //#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;
@@ -1829,10 +1860,7 @@ async function createSlackDispatchSetup(prepared) {
 		agentId: route.agentId,
 		channel: "slack",
 		accountId: route.accountId,
-		transformReplyPayload: (payload) => {
-			if (payload.isReasoning === true) return null;
-			return payload;
-		},
+		transformReplyPayload: sanitizeSlackMonitorReplyPayload,
 		typing: {
 			start: async () => {
 				if (!threadStatusGate.hasVisibleOutput()) {
@@ -1980,11 +2008,6 @@ function createSlackStreamingDeliveryRuntime(setup) {
 		observedFinalReplyDelivery: false
 	};
 	const streamedDeliveries = [];
-	const streamedFailuresOwnedByDispatcher = {
-		tool: 0,
-		block: 0,
-		final: 0
-	};
 	const refreshStreamedAcknowledgements = (session) => {
 		if (session.pendingText.length === 0) for (const delivery of streamedDeliveries) delivery.acknowledged = true;
 	};
@@ -2123,7 +2146,6 @@ function createSlackStreamingDeliveryRuntime(setup) {
 		}
 	};
 	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({
@@ -2167,10 +2189,7 @@ function createSlackStreamingDeliveryRuntime(setup) {
 		return deliveryReplyThreadTs;
 	};
 	const deliverBufferedStreamFallback = async (params) => {
-		if (!await deliverPendingStreamFallback(params.session, params.err)) {
-			streamedFailuresOwnedByDispatcher[params.kind] += 1;
-			return false;
-		}
+		if (!await deliverPendingStreamFallback(params.session, params.err)) return false;
 		replyPlan.markSent();
 		if (params.kind === "final") state.observedFinalReplyDelivery = true;
 		deliveryTracker.markDelivered({
@@ -2189,7 +2208,6 @@ function createSlackStreamingDeliveryRuntime(setup) {
 		return !state.streamFailed && !reply.hasMedia && renderPlan.mode !== "split" && !plannedBlocks?.length && !readSlackReplyBlocks(payload)?.length && reply.hasText && (!options?.maxTextBytes || countSlackTextUtf8Bytes(reply.trimmedText) <= options.maxTextBytes);
 	};
 	const deliverWithStreaming = async (params) => {
-		if (params.payload.isReasoning === true) return;
 		const reply = resolveSendableOutboundReplyParts(params.payload);
 		if (!isStreamingEligible(params.payload)) {
 			await deliverNormally({
@@ -2329,23 +2347,6 @@ function createSlackStreamingDeliveryRuntime(setup) {
 			});
 		}
 	};
-	const reconcileCounts = (counts) => {
-		const next = { ...counts };
-		let changed = false;
-		for (const kind of [
-			"tool",
-			"block",
-			"final"
-		]) {
-			const failedStreamedCount = streamedDeliveries.filter((delivery) => delivery.kind === kind && delivery.outcome === "failure").length;
-			const additionalFailedStreamed = Math.max(0, failedStreamedCount - streamedFailuresOwnedByDispatcher[kind]);
-			if (additionalFailedStreamed > 0) {
-				next[kind] = Math.max(0, (next[kind] ?? 0) - additionalFailedStreamed);
-				changed = true;
-			}
-		}
-		return changed ? next : counts;
-	};
 	return Object.assign(state, {
 		acknowledgeStoppedStreamedDeliveries,
 		deliverNormally,
@@ -2357,7 +2358,6 @@ function createSlackStreamingDeliveryRuntime(setup) {
 		isStreamingEligible,
 		markPreviewPayloadDelivered,
 		rememberDeliveredThreadTs,
-		reconcileCounts,
 		resetDeliveryTracker: () => {
 			deliveryTracker = createSlackEventDeliveryTracker();
 		}
@@ -2409,7 +2409,6 @@ async function dispatchPreparedSlackMessage(prepared) {
 		return payload;
 	};
 	const deliverSlackPayload = async (payload, info) => {
-		if (payload.isReasoning === true) return { visibleReplySent: false };
 		if (info.kind === "final" && slackStreaming.mode === "progress" && progress.isProgressMode) {
 			if (progress.useNativeProgressStreaming) {
 				await progress.deliverNativeFinal(payload, info.kind);
@@ -2460,66 +2459,14 @@ async function dispatchPreparedSlackMessage(prepared) {
 		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 previewFinalText = replyRenderPlan.mode === "single" && replyRenderPlan.textIsSlackMrkdwn ? trimmedFinalText : normalizeSlackOutboundText((replySourceText ?? "").trim(), { tableMode: resolveMarkdownTableMode({
+			cfg,
+			channel: "slack",
+			accountId: account.accountId
+		}) });
 		const previewFinalTextFitsEdit = countSlackTextUtf8Bytes(previewFinalText) <= SLACK_EDIT_TEXT_MAX_BYTES;
 		const shouldRestoreTtsSupplementTextForPreviewFallback = Boolean(ttsSupplement) && ttsSupplement?.visibleTextAlreadyDelivered !== true && Boolean(draftStream) && !draftPreviewCommitted.value && !delivery.observedFinalReplyDelivery && previewStreamingEnabled && !payload.text?.trim();
-		if (info.kind === "final" && ttsSupplement && draftStream && !hasSlackCustomIdentity && !draftPreviewCommitted.value && !delivery.observedFinalReplyDelivery && previewStreamingEnabled && !payload.isError && !requiresSeparateFallbackDelivery && previewFinalTextFitsEdit && trimmedFinalText.length > 0) {
-			await draftStream.flush();
-			const channelId = draftStream.channelId();
-			const messageId = draftStream.messageId();
-			if (channelId && messageId) {
-				const finalThreadTs = delivery.usedReplyThreadTs ?? statusThreadTs;
-				await draftStream.seal();
-				try {
-					if (!await draftStream.finalizeMessage(messageId, async () => {
-						await finalizeSlackPreviewEdit({
-							client: slackClient,
-							token: ctx.botToken,
-							accountId: account.accountId,
-							channelId,
-							messageId,
-							text: previewFinalText,
-							...slackBlocks?.length ? { blocks: slackBlocks } : {},
-							threadTs: finalThreadTs
-						});
-					})) throw new Error("Slack preview moved below a newer conversation message");
-				} 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
-				});
-				progress.progressDraft.markFinalReplyDelivered();
-				return;
-			}
-		}
+		let ttsPreviewFinalization;
 		await deliverWithFinalizableLivePreviewAdapter({
 			kind: info.kind,
 			payload,
@@ -2552,6 +2499,7 @@ async function dispatchPreparedSlackMessage(prepared) {
 						payload,
 						threadTs: edit.threadTs
 					})) return;
+					if (ttsSupplement) ttsPreviewFinalization = { threadTs: edit.threadTs };
 					if (!await draftStream?.finalizeMessage(preview.messageId, async () => {
 						await finalizeSlackPreviewEdit({
 							client: slackClient,
@@ -2607,11 +2555,12 @@ async function dispatchPreparedSlackMessage(prepared) {
 			}),
 			deliverNormally: async () => {
 				await delivery.deliverNormally({
-					payload: shouldRestoreTtsSupplementTextForPreviewFallback ? {
+					payload: shouldRestoreTtsSupplementTextForPreviewFallback || ttsPreviewFinalization && !payload.text?.trim() ? {
 						...payload,
 						text: ttsSupplement?.spokenText
 					} : payload,
-					kind: info.kind
+					kind: info.kind,
+					...ttsPreviewFinalization?.threadTs ? { forcedThreadTs: ttsPreviewFinalization.threadTs } : {}
 				});
 			}
 		});
@@ -2619,8 +2568,7 @@ async function dispatchPreparedSlackMessage(prepared) {
 	};
 	let dispatchError;
 	let agentRunFailed = false;
-	let queuedFinal = false;
-	let counts = {};
+	let settledDispatchResult;
 	try {
 		const turnResult = await dispatchChannelInboundTurn({
 			cfg,
@@ -2631,6 +2579,7 @@ async function dispatchPreparedSlackMessage(prepared) {
 				sessionKey: route.sessionKey
 			},
 			ctxPayload: prepared.ctxPayload,
+			dispatchReplyFromConfig: ctx.dispatchReplyFromConfig,
 			dispatcherOptions: {
 				...replyPipeline,
 				transformReplyPayload: (payload) => {
@@ -2672,7 +2621,6 @@ async function dispatchPreparedSlackMessage(prepared) {
 					return false;
 				} : void 0,
 				onReasoningEnd: async () => {
-					progress.progressReceipt.closeReasoning();
 					await progress.onDraftBoundary?.();
 					return false;
 				},
@@ -2686,18 +2634,14 @@ async function dispatchPreparedSlackMessage(prepared) {
 				} : void 0,
 				onToolStart: async (payload) => {
 					if (statusReactionsEnabled) await statusReactions.setTool(payload.name);
-					if (payload.phase === "start") progress.progressReceipt.noteToolCall(payload.name);
+					if (payload.phase === "start") progress.progressWorkCounter.noteToolCall(payload.name);
 					return await progress.progressDraft.pushToolEvent(payload);
 				},
 				onItemEvent: async (payload) => {
 					if (progress.isProgressMode && payload.kind === "preamble") {
 						if (progress.shouldYieldDraftProgress()) return false;
 						const headlineVisible = await progress.progressDraft.pushPreambleHeadline(payload.progressText, { itemId: payload.itemId });
-						if (progress.commentaryProgressEnabled) {
-							const accepted = await progress.progressDraft.pushCommentaryProgress(payload.progressText, { itemId: payload.itemId });
-							if (accepted) progress.progressReceipt.noteCommentary(payload.itemId, payload.progressText);
-							return accepted || headlineVisible;
-						}
+						if (progress.commentaryProgressEnabled) return await progress.progressDraft.pushCommentaryProgress(payload.progressText, { itemId: payload.itemId }) || headlineVisible;
 						return headlineVisible;
 					}
 					return await progress.progressDraft.pushItemEvent(payload);
@@ -2719,8 +2663,7 @@ async function dispatchPreparedSlackMessage(prepared) {
 		});
 		if (turnResult.dispatched) {
 			const result = turnResult.dispatchResult;
-			queuedFinal = result.queuedFinal;
-			counts = result.counts;
+			settledDispatchResult = result;
 			const agentRunOutcome = readAgentRunTerminalOutcome(result);
 			agentRunFailed = agentRunOutcome === "failed";
 			if (agentRunOutcome === "completed" && !sawTerminalFailurePayload && prepared.ctxPayload.ChatType === "channel") clearSlackThreadFailureNotice({
@@ -2759,12 +2702,7 @@ async function dispatchPreparedSlackMessage(prepared) {
 			if (!finalStream.delivered) dispatchError ??= err;
 		}
 	}
-	counts = delivery.reconcileCounts(counts);
-	queuedFinal = queuedFinal && (counts.final ?? 0) > 0;
-	const anyReplyDelivered = hasVisibleInboundReplyDispatch({
-		queuedFinal,
-		counts
-	}, {
+	const anyReplyDelivered = hasVisibleInboundReplyDispatch(settledDispatchResult, {
 		observedReplyDelivery: delivery.observedReplyDelivery,
 		fallbackDelivered: streamFallbackDelivered
 	});
@@ -2786,11 +2724,11 @@ async function dispatchPreparedSlackMessage(prepared) {
 	if (dispatchError) throw toErrorObject(dispatchError, "Slack dispatch failed");
 	if (!anyReplyDelivered && !draftPreviewCommitted.value && !(agentRunFailed && progress.useDraftProgressCard)) {
 		await draftStream?.clear();
-		await progress.dropDetachedProgressCards();
+		await draftStream?.dropDetachedMessages();
 		return;
 	}
 	if (shouldLogVerbose()) {
-		const finalCount = counts.final;
+		const finalCount = resolveInboundReplyDispatchCounts(settledDispatchResult).final;
 		logVerbose(`slack: delivered ${finalCount} reply${finalCount === 1 ? "" : "ies"} to ${prepared.replyTarget}`);
 	}
 }
@@ -2834,6 +2772,153 @@ function normalizeSlackAppContextEntities(value) {
 	});
 }
 //#endregion
+//#region extensions/slack/src/monitor/thread.ts
+const THREAD_STARTER_CACHE = /* @__PURE__ */ new Map();
+const THREAD_STARTER_CACHE_TTL_MS = 360 * 6e4;
+const THREAD_STARTER_CACHE_MAX = 2e3;
+function evictThreadStarterCache() {
+	const now = asDateTimestampMs(Date.now());
+	if (now === void 0) {
+		THREAD_STARTER_CACHE.clear();
+		return;
+	}
+	for (const [cacheKey, entry] of THREAD_STARTER_CACHE.entries()) if (asDateTimestampMs(entry.expiresAt) === void 0 || entry.expiresAt <= now) THREAD_STARTER_CACHE.delete(cacheKey);
+	pruneMapToMaxSize(THREAD_STARTER_CACHE, THREAD_STARTER_CACHE_MAX);
+}
+function formatSlackFilePlaceholder(files) {
+	return `[attached: ${formatSlackFileReferenceList(files)}]`;
+}
+function pushUniqueText(parts, value, options = {}) {
+	const text = options.preserveWhitespace ? typeof value === "string" && value.trim().length > 0 ? value : void 0 : normalizeOptionalString(value);
+	if (text && !parts.includes(text)) parts.push(text);
+}
+function resolveSlackBlocksFallbackText(blocks) {
+	return resolveSlackBlocksText(blocks)?.text;
+}
+function resolveSlackAttachmentFallbackText(attachments) {
+	if (!Array.isArray(attachments) || attachments.length === 0) return;
+	const parts = [];
+	for (const attachment of attachments) {
+		const excludeTableBlocks = isSlackUnfurlAttachment(attachment);
+		const fallbackBlocks = (blocks) => excludeTableBlocks ? blocks?.filter((block) => !hasSlackTableBlock([block])) : blocks;
+		pushUniqueText(parts, attachment.pretext);
+		pushUniqueText(parts, attachment.title);
+		pushUniqueText(parts, attachment.text);
+		if (!(hasSlackTableBlock(attachment.blocks) && normalizeOptionalString(attachment.fallback) === "[no preview available]")) pushUniqueText(parts, attachment.fallback);
+		for (const field of attachment.fields ?? []) {
+			pushUniqueText(parts, field.title);
+			pushUniqueText(parts, field.value);
+		}
+		pushUniqueText(parts, resolveSlackBlocksFallbackText(fallbackBlocks(attachment.blocks)), { preserveWhitespace: true });
+		pushUniqueText(parts, resolveSlackBlocksFallbackText(fallbackBlocks(attachment.message_blocks)), { preserveWhitespace: true });
+	}
+	return parts.length > 0 ? parts.join("\n") : void 0;
+}
+function resolveSlackMessageText(message) {
+	const messageText = normalizeOptionalString(message.text) ?? resolveSlackAttachmentFallbackText(message.attachments);
+	return resolveSlackMessageText$1({
+		...message,
+		text: messageText
+	}, { preserveMessageTextWhitespace: true });
+}
+async function resolveSlackThreadStarter(params) {
+	evictThreadStarterCache();
+	const cacheKey = JSON.stringify([
+		params.workspaceScope.accountId,
+		params.workspaceScope.teamId,
+		params.channelId,
+		params.threadTs
+	]);
+	const cached = THREAD_STARTER_CACHE.get(cacheKey);
+	if (cached) {
+		const now = asDateTimestampMs(Date.now());
+		if (now !== void 0 && cached.expiresAt > now) return cached.value;
+		THREAD_STARTER_CACHE.delete(cacheKey);
+	}
+	try {
+		const message = (await params.client.conversations.replies({
+			channel: params.channelId,
+			ts: params.threadTs,
+			limit: 1,
+			inclusive: true
+		}))?.messages?.[0];
+		const text = message ? resolveSlackMessageText(message) : void 0;
+		const files = message?.files?.length ? message.files : void 0;
+		if (!message || !text && !files) return null;
+		const starter = {
+			text: text || formatSlackFilePlaceholder(files),
+			userId: message.user,
+			botId: message.bot_id,
+			ts: message.ts,
+			files
+		};
+		const expiresAt = resolveExpiresAtMsFromDurationMs(THREAD_STARTER_CACHE_TTL_MS);
+		if (expiresAt !== void 0) {
+			if (THREAD_STARTER_CACHE.has(cacheKey)) THREAD_STARTER_CACHE.delete(cacheKey);
+			THREAD_STARTER_CACHE.set(cacheKey, {
+				value: starter,
+				expiresAt
+			});
+			evictThreadStarterCache();
+		}
+		return starter;
+	} catch (err) {
+		logVerbose$1(`slack thread starter fetch failed channel=${params.channelId} ts=${params.threadTs}: ${formatErrorMessage(err)}`);
+		return null;
+	}
+}
+const SLACK_THREAD_HISTORY_MAX_PAGES = 3;
+/**
+* Fetches the most recent messages in a Slack thread (excluding the current message).
+* Used to populate thread context when a new thread session starts.
+*
+* Uses cursor pagination and keeps only the latest N retained messages when the full
+* thread fits in the bounded fetch window.
+*/
+async function resolveSlackThreadHistory(params) {
+	const maxMessages = params.limit ?? 20;
+	if (!Number.isFinite(maxMessages) || maxMessages <= 0) return [];
+	const fetchLimit = 200;
+	const retained = [];
+	let cursor;
+	let pagesFetched = 0;
+	try {
+		do {
+			pagesFetched += 1;
+			const response = await params.client.conversations.replies({
+				channel: params.channelId,
+				ts: params.threadTs,
+				limit: fetchLimit,
+				inclusive: true,
+				...cursor ? { cursor } : {}
+			});
+			for (const msg of response.messages ?? []) {
+				const text = resolveSlackMessageText(msg);
+				if (!text && !msg.files?.length) continue;
+				if (params.currentMessageTs && msg.ts === params.currentMessageTs) continue;
+				retained.push([msg, text]);
+			}
+			if (retained.length > maxMessages) retained.splice(0, retained.length - maxMessages);
+			const next = response.response_metadata?.next_cursor;
+			cursor = typeof next === "string" && next.trim().length > 0 ? next.trim() : void 0;
+		} while (cursor && pagesFetched < SLACK_THREAD_HISTORY_MAX_PAGES);
+		if (cursor) {
+			logVerbose$1(`slack thread history capped channel=${params.channelId} ts=${params.threadTs} pages=${SLACK_THREAD_HISTORY_MAX_PAGES}`);
+			return [];
+		}
+		return retained.map(([message, text]) => ({
+			text: text ?? formatSlackFilePlaceholder(message.files),
+			userId: message.user,
+			botId: message.bot_id,
+			ts: message.ts,
+			files: message.files
+		}));
+	} catch (err) {
+		logVerbose$1(`slack thread history fetch failed channel=${params.channelId} ts=${params.threadTs}: ${formatErrorMessage(err)}`);
+		return [];
+	}
+}
+//#endregion
 //#region extensions/slack/src/monitor/message-handler/preflight-audio.ts
 function isSlackAudioFile(file) {
 	if (file.subtype === "slack_audio") return true;
@@ -2849,7 +2934,7 @@ function findCaptionlessSlackAudioFile(message) {
 	return message.files?.slice(0, 8).find(isSlackAudioFile);
 }
 function formatSlackAudioTranscriptForAgent(params) {
-	return [`[Audio transcript (machine-generated, untrusted)]: ${JSON.stringify(params.transcript)}`, params.rawBody].filter(Boolean).join("\n");
+	return [formatAudioTranscriptForAgent(params.transcript), params.rawBody].filter(Boolean).join("\n");
 }
 async function resolveSlackPreflightAudioTranscript(params) {
 	const mediaIndex = params.media.findIndex((entry) => entry.contentType?.toLowerCase().startsWith("audio/"));
@@ -2884,7 +2969,24 @@ 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-BTDXwwE3.js").then((n) => n._));
+const MAX_SLACK_UNAVAILABLE_FILE_TEXT_CHARS = 2e3;
+const loadSlackMediaModule$1 = createLazyRuntimeModule(() => import("./actions-BI7JkfVm.js").then((n) => n._));
+function formatSlackUnavailableMedia(params) {
+	let fileReferences = params.files?.map((file) => `${formatSlackFileReference(file)} unavailable (${file.reason})`).join(", ");
+	if (fileReferences && fileReferences.length > MAX_SLACK_UNAVAILABLE_FILE_TEXT_CHARS) fileReferences = `${truncateUtf16Safe(fileReferences, MAX_SLACK_UNAVAILABLE_FILE_TEXT_CHARS)}; … (file references truncated)`;
+	const fileBlock = fileReferences ? `[Slack file: ${fileReferences}]` : void 0;
+	const body = [params.body, fileBlock].filter(Boolean).join("\n");
+	if (params.unavailableMediaCount === 0) return body;
+	const notice = `[slack ${params.unavailableMediaCount > 1 ? `${params.unavailableMediaCount} attachments` : "attachment"} unavailable]`;
+	return params.prependUnavailable ? [
+		notice,
+		fileBlock,
+		params.body
+	].filter(Boolean).join("\n") : formatInboundMediaUnavailableText({
+		body,
+		notice
+	});
+}
 function collectUniqueSlackMentionIds$1(texts) {
 	const seen = /* @__PURE__ */ new Set();
 	const mentionIds = [];
@@ -2922,8 +3024,9 @@ async function resolveSlackMessageContent(params) {
 		isThreadReply: params.isThreadReply,
 		threadStarter: params.threadStarter
 	});
-	const mediaPromise = ownFiles && ownFiles.length > 0 ? loadSlackMediaModule$1().then(({ resolveSlackMedia }) => resolveSlackMedia({
+	const attachmentContent = ownFiles?.length || params.message.attachments?.length ? await loadSlackMediaModule$1().then(({ resolveSlackAttachmentContent }) => resolveSlackAttachmentContent({
 		files: ownFiles,
+		attachments: params.message.attachments,
 		client: params.client,
 		token: params.botToken,
 		maxBytes: params.mediaMaxBytes,
@@ -2931,30 +3034,9 @@ async function resolveSlackMessageContent(params) {
 		totalTimeoutMs: params.mediaTotalTimeoutMs,
 		abortSignal: params.abortSignal,
 		preloadedMedia: params.preloadedMedia
-	})) : Promise.resolve(null);
-	const attachmentContentPromise = params.message.attachments && params.message.attachments.length > 0 ? loadSlackMediaModule$1().then(({ resolveSlackAttachmentContent }) => resolveSlackAttachmentContent({
-		attachments: params.message.attachments,
-		client: params.client,
-		token: params.botToken,
-		maxBytes: params.mediaMaxBytes,
-		readIdleTimeoutMs: params.mediaReadIdleTimeoutMs,
-		totalTimeoutMs: params.mediaTotalTimeoutMs,
-		abortSignal: params.abortSignal
-	})) : Promise.resolve(null);
-	const [media, attachmentContent] = await Promise.all([mediaPromise, attachmentContentPromise]);
-	const mergedMedia = [...media ?? [], ...attachmentContent?.media ?? []];
-	const effectiveDirectMedia = mergedMedia.length > 0 ? mergedMedia : null;
-	const mediaPlaceholder = effectiveDirectMedia ? effectiveDirectMedia.map((item) => item.placeholder).join(" ") : void 0;
-	const fallbackFileIds = /* @__PURE__ */ new Set();
-	const fallbackFiles = [...ownFiles ?? [], ...attachmentContent?.files ?? []].filter((file) => {
-		const fileId = normalizeOptionalString(file.id);
-		if (!fileId) return true;
-		if (fallbackFileIds.has(fileId)) return false;
-		fallbackFileIds.add(fileId);
-		return true;
-	});
-	const fileOnlyFallback = !mediaPlaceholder && fallbackFiles.length > 0 ? fallbackFiles.slice(0, 8).map((file) => formatSlackFileReference(file)).join(", ") : void 0;
-	const fileOnlyPlaceholder = fileOnlyFallback ? `[Slack file: ${fileOnlyFallback}]` : void 0;
+	})) : null;
+	const effectiveDirectMedia = attachmentContent?.media.length ? attachmentContent.media : null;
+	const mediaPlaceholder = effectiveDirectMedia?.map((item) => item.placeholder).join(" ");
 	let botAttachmentText;
 	if (params.isBotMessage && !attachmentContent?.text) {
 		const botAttachmentTextParts = [];
@@ -2965,7 +3047,7 @@ async function resolveSlackMessageContent(params) {
 		botAttachmentText = botAttachmentTextParts.length > 0 ? botAttachmentTextParts.join("\n") : void 0;
 	}
 	const textParts = [
-		resolveSlackMessageText(params.message),
+		resolveSlackMessageText$1(params.message),
 		attachmentContent?.text,
 		botAttachmentText
 	];
@@ -2991,23 +3073,20 @@ async function resolveSlackMessageContent(params) {
 			renderedMentions.set(result.userId, result.rendered);
 		}
 	}
-	let rawBody = [
-		renderSlackUserMentions(textParts[0], renderedMentions),
-		renderSlackUserMentions(textParts[1], renderedMentions),
-		renderSlackUserMentions(textParts[2], renderedMentions),
-		mediaPlaceholder,
-		fileOnlyPlaceholder
-	].filter(Boolean).join("\n") || "";
-	const unavailableImageCount = attachmentContent?.unavailableImageCount ?? 0;
-	if (unavailableImageCount > 0) rawBody = formatInboundMediaUnavailableText({
-		body: rawBody,
-		notice: `[slack ${unavailableImageCount > 1 ? `${unavailableImageCount} forwarded images` : "forwarded image"} unavailable]`
+	const rawBody = formatSlackUnavailableMedia({
+		body: [
+			renderSlackUserMentions(textParts[0], renderedMentions),
+			renderSlackUserMentions(textParts[1], renderedMentions),
+			renderSlackUserMentions(textParts[2], renderedMentions),
+			mediaPlaceholder
+		].filter(Boolean).join("\n") || "",
+		files: attachmentContent?.files,
+		unavailableMediaCount: attachmentContent?.unavailableMediaCount ?? 0
 	});
-	if (!rawBody) return null;
-	return {
+	return rawBody ? {
 		rawBody,
 		effectiveDirectMedia
-	};
+	} : null;
 }
 //#endregion
 //#region extensions/slack/src/monitor/message-handler/prepare-dm-history.ts
@@ -3083,62 +3162,6 @@ async function resolveSlackDmHistoryContext(params) {
 }
 //#endregion
 //#region extensions/slack/src/monitor/message-handler/prepare-routing.ts
-const slackRouteBindingConfigCache = /* @__PURE__ */ new WeakMap();
-function slackTargetDefaultKindForPeer(kind) {
-	return kind === "direct" ? "user" : "channel";
-}
-function slackTargetKindMatchesPeer(peerKind, targetKind) {
-	if (targetKind === "user") return peerKind === "direct";
-	return peerKind === "channel" || peerKind === "group";
-}
-function normalizeSlackRouteBindingPeer(peer) {
-	const rawId = peer.id.trim();
-	if (!rawId || rawId === "*") return peer;
-	const target = (() => {
-		try {
-			return parseSlackTarget(rawId, { defaultKind: slackTargetDefaultKindForPeer(peer.kind) });
-		} catch {
-			return;
-		}
-	})();
-	if (!target || !slackTargetKindMatchesPeer(peer.kind, target.kind)) return peer;
-	const normalizedId = target.teamId ? `team:${target.teamId}:${target.kind}:${target.id}` : target.id;
-	return normalizedId === peer.id ? peer : {
-		...peer,
-		id: normalizedId
-	};
-}
-function normalizeSlackRouteBindingConfig(cfg) {
-	const bindings = cfg.bindings;
-	const cached = slackRouteBindingConfigCache.get(cfg);
-	if (cached && cached.bindingsRef === bindings) return cached.normalizedCfg;
-	if (!Array.isArray(bindings)) return cfg;
-	let changed = false;
-	const normalizedBindings = bindings.map((binding) => {
-		if (binding.type === "acp" || binding.match.channel.trim().toLowerCase() !== "slack") return binding;
-		const peer = binding.match.peer;
-		if (!peer) return binding;
-		const normalizedPeer = normalizeSlackRouteBindingPeer(peer);
-		if (normalizedPeer === peer) return binding;
-		changed = true;
-		return {
-			...binding,
-			match: {
-				...binding.match,
-				peer: normalizedPeer
-			}
-		};
-	});
-	const normalizedCfg = changed ? {
-		...cfg,
-		bindings: normalizedBindings
-	} : cfg;
-	slackRouteBindingConfigCache.set(cfg, {
-		bindingsRef: bindings,
-		normalizedCfg
-	});
-	return normalizedCfg;
-}
 function resolveSlackBaseConversationId(params) {
 	return qualifySlackConversationId(params.isDirectMessage ? `user:${params.message.user ?? "unknown"}` : params.message.channel, params.eventScope);
 }
@@ -3197,44 +3220,18 @@ function resolveSlackRoutingContext(params) {
 		eventScope
 	});
 	const runtimeBindingThreadId = routedThreadId ?? (isDirectMessage && isThreadReply ? threadTs : void 0);
-	const boundThreadRoute = !eventScope && runtimeBindingThreadId ? resolveRuntimeConversationBindingRoute({
-		route,
-		conversation: {
-			channel: "slack",
-			accountId: account.accountId,
-			conversationId: runtimeBindingThreadId,
-			parentConversationId: baseConversationId
-		}
-	}) : null;
-	const runtimeRoute = eventScope ? {
-		route,
-		bindingRecord: null,
-		boundSessionKey: void 0
-	} : boundThreadRoute?.boundSessionKey || boundThreadRoute?.bindingRecord ? boundThreadRoute : resolveRuntimeConversationBindingRoute({
+	const bindingRoute = resolveSlackConversationBindingRoute({
+		cfg: ctx.cfg,
 		route,
-		conversation: {
-			channel: "slack",
-			accountId: account.accountId,
-			conversationId: baseConversationId
-		}
+		accountId: account.accountId,
+		baseConversationId,
+		runtimeBindingThreadId,
+		bindingsEnabled: !eventScope
 	});
-	let configuredBinding = null;
-	let configuredBindingSessionKey = "";
-	if (runtimeRoute.boundSessionKey || runtimeRoute.bindingRecord) route = runtimeRoute.route;
-	else if (!eventScope) {
-		const configuredRoute = resolveConfiguredBindingRoute({
-			cfg: ctx.cfg,
-			route,
-			conversation: {
-				channel: "slack",
-				accountId: account.accountId,
-				conversationId: baseConversationId
-			}
-		});
-		configuredBinding = configuredRoute.bindingResolution;
-		configuredBindingSessionKey = configuredRoute.boundSessionKey ?? "";
-		route = configuredRoute.route;
-	}
+	const runtimeRoute = bindingRoute.runtimeRoute;
+	const configuredBinding = bindingRoute.configuredRoute?.bindingResolution ?? null;
+	const configuredBindingSessionKey = bindingRoute.configuredRoute?.boundSessionKey ?? "";
+	route = bindingRoute.route;
 	const threadKeys = runtimeRoute.boundSessionKey || configuredBindingSessionKey ? {
 		sessionKey: route.sessionKey,
 		parentSessionKey: void 0
@@ -3317,7 +3314,7 @@ function formatSlackThreadLabelSnippet(text) {
 }
 //#endregion
 //#region extensions/slack/src/monitor/message-handler/prepare-thread-context.ts
-const loadSlackMediaModule = createLazyRuntimeModule(() => import("./actions-BTDXwwE3.js").then((n) => n._));
+const loadSlackMediaModule = createLazyRuntimeModule(() => import("./actions-BI7JkfVm.js").then((n) => n._));
 const SLACK_THREAD_CONTEXT_USER_LOOKUP_CONCURRENCY = 4;
 function resolveSlackThreadSessionFreshness(params) {
 	return params.ctx.channelRuntime?.session?.resolveEntryResetFreshness?.({
@@ -3429,13 +3426,20 @@ async function resolveSlackThreadContextData(params) {
 		const snippet = formatSlackThreadLabelSnippet(starter.text);
 		threadLabel = `Slack thread ${params.roomLabel}${snippet ? `: ${snippet}` : ""}`;
 		if (shouldSeedInitialThreadContext && !params.effectiveDirectMedia && starter.files && starter.files.length > 0) {
-			const { resolveSlackMedia } = await loadSlackMediaModule();
-			threadStarterMedia = await resolveSlackMedia({
+			const { resolveSlackAttachmentContent } = await loadSlackMediaModule();
+			const attachmentContent = await resolveSlackAttachmentContent({
 				files: starter.files,
 				client: params.eventScope?.client ?? params.ctx.app.client,
 				token: params.ctx.botToken,
 				maxBytes: params.ctx.mediaMaxBytes
 			});
+			threadStarterMedia = attachmentContent?.media.length ? attachmentContent.media : null;
+			if (attachmentContent) threadStarterBody = formatSlackUnavailableMedia({
+				body: threadStarterBody,
+				files: attachmentContent.files,
+				unavailableMediaCount: attachmentContent.unavailableMediaCount,
+				prependUnavailable: true
+			});
 			if (threadStarterMedia) logVerbose(`slack: hydrated thread starter file ${threadStarterMedia.map((item) => item.placeholder).join(", ")} from root message`);
 		}
 	} else threadLabel = `Slack thread ${params.roomLabel}`;
@@ -3456,14 +3460,20 @@ async function resolveSlackThreadContextData(params) {
 	const threadInitialHistoryLimit = params.account.config?.thread?.initialHistoryLimit ?? 20;
 	if (threadInitialHistoryLimit > 0 && shouldLoadInitialThreadHistory) {
 		const currentBotRootTs = starter?.ts ?? params.threadTs;
+		const threadHistory = await resolveSlackThreadHistory({
+			channelId: params.message.channel,
+			threadTs: params.threadTs,
+			client: params.eventScope?.client ?? params.ctx.app.client,
+			currentMessageTs: params.message.ts,
+			limit: threadInitialHistoryLimit
+		});
+		const enrichedStarter = starter && threadStarterBody && threadStarterBody !== starter.text ? {
+			...starter,
+			text: threadStarterBody,
+			ts: currentBotRootTs
+		} : null;
 		const threadHistoryWithBotRoot = ensureSlackThreadHistoryHasBotRoot({
-			history: await resolveSlackThreadHistory({
-				channelId: params.message.channel,
-				threadTs: params.threadTs,
-				client: params.eventScope?.client ?? params.ctx.app.client,
-				currentMessageTs: params.message.ts,
-				limit: threadInitialHistoryLimit
-			}),
+			history: enrichedStarter && !threadHistory.some((entry) => entry.ts === currentBotRootTs) ? [enrichedStarter, ...threadHistory.length >= threadInitialHistoryLimit ? threadHistory.slice(1) : threadHistory] : threadHistory,
 			includeBotStarterAsRootContext,
 			threadStarter: starter ? {
 				...starter,
@@ -3522,7 +3532,7 @@ async function resolveSlackThreadContextData(params) {
 				});
 				const role = isCurrentBot || isOtherBot || Boolean(historyMsg.botId) ? "assistant" : "user";
 				const msgSenderName = isCurrentBot ? "Bot (this assistant)" : msgUser?.name ?? (historyMsg.botId ? `Bot (${historyMsg.botId})` : "Unknown");
-				const msgWithId = `${historyMsg.text}\n[slack message id: ${historyMsg.ts ?? "unknown"} channel: ${params.message.channel}]`;
+				const msgWithId = `${historyMsg.ts === currentBotRootTs && threadStarterBody ? threadStarterBody : historyMsg.text}\n[slack message id: ${historyMsg.ts ?? "unknown"} channel: ${params.message.channel}]`;
 				historyParts.push(formatInboundEnvelope({
 					channel: "Slack",
 					from: `${msgSenderName} (${role})`,
@@ -4468,6 +4478,7 @@ async function prepareSlackMessage(params) {
 		workspaceName
 	}) : void 0;
 	const senderName = await resolveSenderName();
+	const conversationAvatar = isDirectMessage && message.user ? ctx.resolveUserAvatar(message.user, opts.eventScope) : void 0;
 	const preview = truncateUtf16Safe(bodyForAgent.replace(/\s+/g, " "), 160);
 	const inboundLabel = isDirectMessage ? `Slack DM from ${senderName}` : `Slack message in ${roomLabel} from ${senderName}`;
 	const slackFrom = isDirectMessage ? `slack:${message.user}` : isRoom ? `slack:channel:${message.channel}` : `slack:group:${message.channel}`;
@@ -4600,10 +4611,19 @@ async function prepareSlackMessage(params) {
 		conversation: {
 			kind: chatType,
 			id: message.channel,
+			routePeer: {
+				kind: chatType,
+				id: qualifySlackRoutePeerId({
+					id: isDirectMessage ? message.user ?? "unknown" : message.channel,
+					kind: isDirectMessage ? "user" : "channel",
+					eventScope: opts.eventScope
+				})
+			},
 			label: envelopeFrom,
 			spaceId: opts.eventScope?.teamId || ctx.teamId || void 0,
 			threadId: boundMessageThreadId,
-			nativeChannelId: message.channel
+			nativeChannelId: message.channel,
+			avatar: conversationAvatar
 		},
 		route: {
 			agentId: route.agentId,