@openclaw/slack 2026.9.1 → 2026.9.3

package/dist/{pipeline.runtime-BklS_NEj.js → pipeline.runtime-uzM3DH1T.js}

@@ -1,23 +1,24 @@
-import { n as resolveSlackConversationBindingRoute, r as resolveSlackReplyToMode, t as normalizeSlackRouteBindingConfig } from "./conversation-binding-route-Vee8Dgbf.js";
+import { A as countSlackTextUtf8Bytes, C as buildSlackBlocksFallbackText, E as SLACK_EDIT_TEXT_MAX_BYTES, H as SLACK_SESSION_LINK_ACTION_ID, M as truncateSlackTextByUtf8Bytes, Pt as resolveSlackReplyToMode, Y as normalizeSlackOutboundText, c as qualifySlackRoutePeerId, j as truncateSlackText, k as SLACK_TEXT_LIMIT, ot as escapeSlackMrkdwn, v as hasSlackNativeDataBlock } from "./session-status-qYGWV7LP.js";
 import { n as formatSlackTarget } from "./target-parsing-PbxGDbr9.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-BKjMqT-8.js";
-import { C as normalizeAllowListLower, E as resolveSlackAllowListMatch, o as formatSlackError, w as normalizeSlackAllowOwnerEntry } from "./probe-gj5yQgN2.js";
+import { C as normalizeAllowListLower, E as resolveSlackAllowListMatch, o as formatSlackError, w as normalizeSlackAllowOwnerEntry } from "./probe-DJFRGrzY.js";
+import { r as prepareSlackReply, s as resolveSlackReplyRenderPlan } from "./reply-blocks-DcAWH25M.js";
 import { n as resolveSlackReplyThreadTs } from "./thread-ts-CukseRVL.js";
 import { n as resolveSlackStreamingMode, t as resolveSlackNativeStreaming } from "./streaming-compat-B-e0mqM0.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-fh66A6lc.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-Djswy6lf.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-Do50wMWn.js";
-import { n as resolveSlackChannelConfig } from "./policy-D7PKkiet.js";
-import { a as resolveSlackThreadTs, i as readSlackReplyBlocks, n as deliverReplies, o as sanitizeSlackMonitorReplyPayload, s as emitSlackMessageSentHooks, t as createSlackReplyDeliveryPlan } from "./replies-Dc6WVh_Q.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-NBjICINI.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-RcdbbkzS.js";
+import { A as resolveStorePath, C as resolveSlackChatType, D as readSessionUpdatedAt, E as getSessionEntry, N as stripSlackMentionsForCommandDetection, O as resolveChannelContextVisibilityMode, S as normalizeSlackChannelType, T as readSlackAssistantThreadContext, _ as SlackStreamNotDeliveredError, b as startSlackStream, d as resolveSlackRoutingContext, f as registerSlackSessionRun, g as resolveSlackEffectiveAllowFrom, h as resolveSlackCommandIngress, j as updateLastRoute, k as resolveChannelResetConfig, l as authorizeSlackDirectMessage, m as authorizeSlackBotRoomMessage, o as resolveSlackRoomContextHints, p as resolveSlackThreadTargets, r as trackSlackDraftMessage, u as resolveConversationLabel$1, v as appendSlackStream, w as buildSlackAssistantThreadMetadata, x as stopSlackStream, y as markSlackStreamFallbackDelivered } from "./provider-BvuEcGRl.js";
+import { n as resolveSlackChannelConfig } from "./policy-DzUHR8tk.js";
+import { a as resolveSlackThreadTs, i as readSlackReplyBlocks, n as deliverReplies, o as sanitizeSlackMonitorReplyPayload, s as emitSlackMessageSentHooks, t as createSlackReplyDeliveryPlan } from "./replies-DnKtWYw4.js";
 import { asOptionalRecord, normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { resolveAgentRoute, resolveInboundLastRouteSessionKey, resolveThreadSessionKeys } from "openclaw/plugin-sdk/routing";
-import { createChannelMessageReplyPipeline, createChannelProgressDraftCompositor, createDraftStreamLoop, createFinalizableDraftStreamControlsForState, defineFinalizableLivePreviewAdapter, deliverWithFinalizableLivePreviewAdapter, formatChannelProgressDraftText, isChannelProgressDraftWorkToolName, resolveAgentOutboundIdentity, resolveChannelMessageSourceReplyDeliveryMode, resolveChannelProgressDraftConfig, resolveChannelProgressDraftMaxLineChars, resolveChannelStreamingBlockEnabled, resolveChannelStreamingPreviewToolProgress, resolveChannelStreamingSuppressDefaultToolProgressMessages } from "openclaw/plugin-sdk/channel-outbound";
+import { resolveInboundLastRouteSessionKey } from "openclaw/plugin-sdk/routing";
+import { buildChannelProgressDraftLine, createChannelMessageReplyPipeline, createChannelProgressDraftCompositor, createChannelProgressWorkCounter, createDraftStreamLoop, createFinalizableDraftStreamControlsForState, defineFinalizableLivePreviewAdapter, deliverWithFinalizableLivePreviewAdapter, formatChannelProgressDraftDiffStat, formatChannelProgressDraftText, formatPlanChecklistLines, 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 { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 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";
@@ -28,11 +29,11 @@ import { filterSupplementalContextItems, resolvePinnedMainDmOwnerFromAllowlist,
 import { mimeTypeFromFilePath } from "openclaw/plugin-sdk/media-mime";
 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 { asDateTimestampMs, asFiniteNumberInRange, parseStrictFiniteNumber, resolveExpiresAtMsFromDurationMs } from "openclaw/plugin-sdk/number-runtime";
+import { resolveHumanDelayConfig } from "openclaw/plugin-sdk/agent-runtime";
+import { enqueueRoutedSystemEvent } from "openclaw/plugin-sdk/system-event-runtime";
 import { getGlobalHookRunner } from "openclaw/plugin-sdk/plugin-runtime";
 import { buildChannelInboundEventContext, buildMentionRegexes, classifyChannelInboundEvent, dispatchChannelInboundTurn, formatInboundEnvelope, formatInboundMediaUnavailableText, hasVisibleInboundReplyDispatch, implicitMentionKindWhen, matchesMentionWithExplicit, readAgentRunTerminalOutcome, recordDroppedChannelInboundHistory, resolveEnvelopeFormatOptions, resolveInboundMentionDecision, resolveInboundReplyDispatchCounts, resolveInboundSupplementalSenderAllowed, resolveUnmentionedGroupInboundPolicy, toInboundMediaFactsWithMetadata } from "openclaw/plugin-sdk/channel-inbound";
-import { resolveHumanDelayConfig } from "openclaw/plugin-sdk/agent-runtime";
 import { resolveGatewayPublicOrigin } from "openclaw/plugin-sdk/config-contracts";
 import { buildControlUiSessionPath } from "openclaw/plugin-sdk/session-discussion";
 import { createStatusReactionController, logAckFailure, logTypingFailure, resolveAckReaction, shouldAckReaction } from "openclaw/plugin-sdk/channel-feedback";
@@ -40,186 +41,6 @@ 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, 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
-* remains buffered locally by the Slack SDK. Carries the pending text so the
-* caller can deliver it via the normal Slack reply path.
-*/
-var SlackStreamNotDeliveredError = class extends Error {
-	constructor(pendingText, slackCode) {
-		super(`slack-stream: finalize failed with ${slackCode} before buffered text reached Slack (${pendingText.length} chars pending)`);
-		this.name = "SlackStreamNotDeliveredError";
-		this.pendingText = pendingText;
-		this.slackCode = slackCode;
-	}
-};
-/**
-* Start a new Slack text stream.
-*
-* Returns a {@link SlackStreamSession} that should be passed to
-* {@link appendSlackStream} and {@link stopSlackStream}.
-*
-* The first chunk of text can optionally be included via `text`.
-*/
-async function startSlackStream(params) {
-	const { client, channel, threadTs, text, chunks, taskDisplayMode, teamId, userId, identity } = params;
-	const identityPayload = identity?.iconUrl ? {
-		...identity.username ? { username: identity.username } : {},
-		icon_url: identity.iconUrl
-	} : identity?.iconEmoji ? {
-		...identity.username ? { username: identity.username } : {},
-		icon_emoji: identity.iconEmoji
-	} : identity?.username ? { username: identity.username } : {};
-	logVerbose(`slack-stream: starting stream in ${channel} thread=${threadTs}${teamId ? ` team=${teamId}` : ""}${userId ? ` user=${userId}` : ""}`);
-	const streamer = client.chatStream({
-		channel,
-		thread_ts: threadTs,
-		...taskDisplayMode ? { task_display_mode: taskDisplayMode } : {},
-		...teamId ? { recipient_team_id: teamId } : {},
-		...userId ? { recipient_user_id: userId } : {},
-		...identityPayload
-	});
-	const 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 ? { 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 ? { 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 chunks to append before stopping.
-*
-* If Slack's `chat.stopStream` responds with a definitive recipient/channel
-* rejection while text is still buffered locally, this function throws a
-* {@link SlackStreamNotDeliveredError} carrying that pending text so the caller
-* can deliver it through the normal Slack reply path. Ambiguous failures
-* propagate unchanged because Slack may have committed the request.
-*
-* If Slack responds with a known benign finalize error (see
-* {@link BENIGN_SLACK_FINALIZE_ERROR_CODES}) after prior `append` calls already
-* landed, the error is swallowed and the session is marked stopped - the
-* already-delivered text stays visible.
-*
-* Errors without buffered text propagate unchanged.
-*
-* On success, returns the finalized message's Slack `ts` (when reported) so the
-* caller can emit the `message_sent` hook with a populated `messageId`.
-*/
-async function stopSlackStream(params) {
-	const { session, chunks, metadata } = params;
-	if (session.stopped) {
-		logVerbose("slack-stream: stream already stopped, ignoring duplicate stop");
-		return {};
-	}
-	session.stopped = true;
-	logVerbose(`slack-stream: stopping stream in ${session.channel} thread=${session.threadTs}`);
-	try {
-		const stopResponse = await session.streamer.stop(chunks?.length || metadata ? {
-			...chunks?.length ? { chunks } : {},
-			...metadata ? { metadata } : {}
-		} : void 0);
-		session.delivered = true;
-		session.pendingText = "";
-		logVerbose("slack-stream: stream stopped");
-		const messageId = stopResponse?.ts ?? stopResponse?.message?.ts;
-		return messageId ? { messageId } : {};
-	} catch (err) {
-		const code = extractSlackErrorCode(err) ?? "unknown";
-		const benignFinalizeError = isBenignSlackFinalizeError(err);
-		if (session.pendingText && (benignFinalizeError || code === "missing_scope")) throw new SlackStreamNotDeliveredError(session.pendingText, code);
-		if (benignFinalizeError) {
-			if (session.delivered) {
-				logVerbose(`slack-stream: finalize rejected by Slack (${code}); prior appends delivered, treating stream as stopped`);
-				return {};
-			}
-		}
-		throw err;
-	}
-}
-/**
-* Slack API error codes that indicate `chat.stopStream` (or the
-* `chat.startStream` call the SDK issues inside `stop()` when the buffer
-* never flushed) cannot finalize the stream for the current recipient or
-* team. Either the caller falls back to a normal message (see
-* {@link SlackStreamNotDeliveredError}) or, if prior appends already
-* delivered text, the error is logged verbosely and swallowed.
-*/
-const BENIGN_SLACK_FINALIZE_ERROR_CODES = /* @__PURE__ */ new Set([
-	"user_not_found",
-	"team_not_found",
-	"missing_recipient_user_id",
-	"method_not_supported_for_channel_type"
-]);
-function isBenignSlackFinalizeError(err) {
-	const code = extractSlackErrorCode(err);
-	return code !== void 0 && BENIGN_SLACK_FINALIZE_ERROR_CODES.has(code);
-}
-function extractSlackErrorCode(err) {
-	if (!err || typeof err !== "object") return;
-	const record = err;
-	if (record.data && typeof record.data === "object") {
-		const inner = record.data.error;
-		if (typeof inner === "string") return inner;
-	}
-	return (typeof record.message === "string" ? record.message : "").match(/An API error occurred:\s*([a-z_][a-z0-9_]*)/i)?.[1];
-}
-function markSlackStreamFallbackDelivered(session) {
-	const nativeStreamWasStarted = session.delivered || Boolean(session.streamer.ts);
-	session.pendingText = "";
-	session.streamer.buffer = "";
-	session.stopped = !nativeStreamWasStarted;
-}
-//#endregion
 //#region extensions/slack/src/monitor/message-handler/timestamp.ts
 const SLACK_TIMESTAMP_RE = /^\d+(?:\.\d+)?$/;
 const MAX_SAFE_SLACK_TIMESTAMP_SECONDS = Number.MAX_SAFE_INTEGER / 1e3;
@@ -298,9 +119,9 @@ function getSlackStreamRecipientTeamCache(client) {
 	slackStreamRecipientTeamCaches.set(client, cache);
 	return cache;
 }
-function buildSlackEventDeliveryKey(params) {
+function buildSlackEventDeliveryKey(params, preparedReply = prepareSlackReply(params.payload)) {
 	const reply = resolveSendableOutboundReplyParts(params.payload, { text: params.textOverride });
-	const renderPlan = resolveSlackReplyRenderPlan(params.payload, params.textOverride ?? params.payload.text);
+	const renderPlan = preparedReply.resolvePreview(params.textOverride);
 	const plannedBlocks = renderPlan.mode === "single" ? renderPlan.blocks : renderPlan.blockPart?.blocks;
 	const slackBlocks = readSlackReplyBlocks(params.payload) ?? plannedBlocks;
 	const renderedText = renderPlan.mode === "single" ? renderPlan.text : renderPlan.fallbackText;
@@ -338,12 +159,10 @@ function rememberSlackStreamRecipientTeam(params) {
 function createSlackEventDeliveryTracker() {
 	const deliveredKeys = /* @__PURE__ */ new Set();
 	return {
-		hasDelivered(params) {
-			const key = buildSlackEventDeliveryKey(params);
+		hasDelivered(key) {
 			return key ? deliveredKeys.has(key) : false;
 		},
-		markDelivered(params) {
-			const key = buildSlackEventDeliveryKey(params);
+		markDelivered(key) {
 			if (key) deliveredKeys.add(key);
 		}
 	};
@@ -574,11 +393,65 @@ function createSlackDraftStream(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.separator ?? (params.rendered.endsWith("\n") ? "" : "\n");
+	return {
+		rendered: `${params.rendered}${separator}${incoming}`,
+		source: incoming,
+		changed: true
+	};
+}
+//#endregion
 //#region extensions/slack/src/progress-blocks.ts
 const SLACK_PROGRESS_FIELD_MAX = 1800;
 const DEFAULT_SLACK_PROGRESS_DETAIL_MAX_CHARS = 120;
+const DEFAULT_SLACK_PROGRESS_TASK_DETAIL_MAX_CHARS = 48;
 const SLACK_PROGRESS_CHUNK_TEXT_MAX = 256;
 const SLACK_PROGRESS_TASK_TITLE_MAX = 120;
+const SLACK_PROGRESS_PLAN_FALLBACK_TITLE = "Thinking";
+const SLACK_PROGRESS_LINE_DELTA_RE = /(?:^|\s)\+(\d+)\s+[−-](\d+)(?=\s|$)/u;
+const SLACK_ATTENTION_TASK_PREFIX = "openclaw-attention-";
 function buildSessionSources(url) {
 	return [{
 		type: "url_source",
@@ -586,6 +459,12 @@ function buildSessionSources(url) {
 		text: "Open in OpenClaw"
 	}];
 }
+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;
 }
@@ -604,58 +483,140 @@ function compactTitle(value) {
 function compactChunkText(value) {
 	return truncateSlackText(value.replace(/\s+/g, " ").trim(), SLACK_PROGRESS_CHUNK_TEXT_MAX);
 }
-function isAuthoredProgressLine(line) {
-	return line.id === "reasoning" || line.id?.startsWith("commentary:") === true;
-}
-function resolveProgressAttention(lines) {
-	const approval = lines.findLast((line) => line.kind === "approval" && line.status === "requested");
-	if (approval) return {
-		id: "openclaw_attention",
-		title: compactTitle(`Approval required: ${approval.detail || approval.label}`),
-		status: "pending"
-	};
-	const failure = lines.findLast((line) => {
-		const status = line.status?.trim().toLowerCase();
-		return status === "error" || status === "failed" || status === "failure" || status?.startsWith("exit ") && status !== "exit 0";
+function renderProgressCardText(text, enclosingStyle) {
+	return normalizeSlackOutboundText(text, {
+		mentions: "escape",
+		enclosingStyle
 	});
-	if (!failure) return;
-	return {
-		id: "openclaw_attention",
-		title: compactTitle([...new Set([
-			failure.label,
-			failure.detail,
-			failure.status
-		].filter(Boolean))].join(" — ")),
-		status: "error"
-	};
 }
-function buildSlackProgressStreamChunks(params) {
-	const title = compactChunkText(params.title?.trim() || params.label?.trim() || "Working");
-	if (!params.title && !params.label && !params.lines.length && !params.plan?.length && !params.sessionUrl) return;
-	const tasks = params.plan?.length ? params.plan.slice(-50).map((entry, index) => ({
+function lineDetailParts(line) {
+	return [line.detail, line.status && line.status !== "completed" && !line.detail?.includes(line.status) ? line.status : void 0].map((part) => part?.trim()).filter((part) => Boolean(part));
+}
+function activityLineDetail(line, maxChars) {
+	const detail = lineDetailParts(line).join(" · ");
+	if (detail) return escapeSlackMrkdwn(compactDetail(detail, maxChars));
+	const text = line.text.replace(/^(?:🧠|💬)\s+/u, "").trim();
+	return line.kind === "item" && !line.toolName && text && text !== line.label ? renderProgressCardText(compactDetail(text, maxChars)) : "—";
+}
+function lineTaskTitle(line) {
+	const label = line.label.replace(/\s+/g, " ").trim() || line.toolName || line.kind || "Update";
+	const fallback = line.text.replace(/\s+/g, " ").trim();
+	if (fallback && fallback !== label) return compactTitle(lineDetailParts(line).length > 0 || line.status ? label : fallback);
+	return compactTitle(label);
+}
+function lineTaskDetails(line, maxLineChars) {
+	const detail = line.detail?.replace(SLACK_PROGRESS_LINE_DELTA_RE, "").replace(/\s+·\s*$/u, "").trim();
+	return detail && detail !== line.status?.trim() ? compactDetail(detail, maxLineChars) : void 0;
+}
+function lineTaskOutput(line) {
+	const match = line.detail ? SLACK_PROGRESS_LINE_DELTA_RE.exec(line.detail) : null;
+	if (match) return `+${match[1]} −${match[2]}`;
+	const status = line.status?.replace(/\s+/g, " ").trim();
+	return status && lineTaskStatus(line) === "error" ? status : void 0;
+}
+function lineTaskStatus(line) {
+	const normalized = line.status?.replace(/\s+/g, " ").trim().toLowerCase();
+	if (!normalized) return "in_progress";
+	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 "error";
+	return "in_progress";
+}
+function stableTaskIdPart(value, slugValue = value) {
+	const slug = slugValue.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+	const suffix = createHash("sha256").update(value).digest("hex").slice(0, 8);
+	return `${(slug || "task").slice(0, 48)}_${suffix}`;
+}
+function resolveLineTaskIdentity(line, contentIdOccurrences) {
+	if (line.id?.trim()) return stableTaskIdPart(line.id);
+	const id = stableTaskIdPart([
+		line.kind,
+		line.toolName,
+		line.label,
+		line.text
+	].join("\0"), line.toolName ?? line.kind ?? line.label);
+	const occurrence = (contentIdOccurrences.get(id) ?? 0) + 1;
+	contentIdOccurrences.set(id, occurrence);
+	return `${id}_${occurrence}`;
+}
+function buildNativeTasks(params) {
+	const tasks = (params.plan ?? []).map((entry, index) => ({
 		id: `plan_step_${index + 1}`,
 		title: compactTitle(entry.step),
 		status: entry.status === "completed" ? "complete" : entry.status
-	})) : [{
+	}));
+	const maxLineChars = resolveMaxLineChars(params.maxLineChars, DEFAULT_SLACK_PROGRESS_TASK_DETAIL_MAX_CHARS);
+	const contentIdOccurrences = /* @__PURE__ */ new Map();
+	for (const line of params.lines) {
+		const task = {
+			id: resolveLineTaskIdentity(line, contentIdOccurrences),
+			title: lineTaskTitle(line),
+			status: lineTaskStatus(line)
+		};
+		const details = lineTaskDetails(line, maxLineChars);
+		const output = lineTaskOutput(line);
+		if (details) task.details = details;
+		if (output) task.output = output;
+		tasks.push(task);
+	}
+	return tasks;
+}
+function buildProgressAttentionTasks(lines, finalStatus) {
+	const contentIdOccurrences = /* @__PURE__ */ new Map();
+	return lines.flatMap((line) => {
+		const approval = line.kind === "approval";
+		if (approval ? line.status !== "requested" || finalStatus !== void 0 : lineTaskStatus(line) !== "error") return [];
+		const title = approval ? `Approval required: ${line.detail || line.label}` : [...new Set([
+			line.label,
+			line.detail,
+			line.status
+		].filter(Boolean))].join(" — ");
+		const recovered = !approval && finalStatus === "complete";
+		return [{
+			id: `${SLACK_ATTENTION_TASK_PREFIX}${resolveLineTaskIdentity(line, contentIdOccurrences)}`,
+			title: compactTitle(recovered ? `Recovered: ${title}` : title),
+			status: approval ? "pending" : finalStatus ?? "error"
+		}];
+	});
+}
+function formatTaskDiffOutput(diffStat) {
+	return diffStat && (diffStat.added > 0 || diffStat.removed > 0) ? `+${diffStat.added} −${diffStat.removed}` : void 0;
+}
+function buildSlackProgressStreamChunks(params) {
+	const approvals = params.lines.filter((line) => line.kind === "approval");
+	const tasks = buildNativeTasks({
+		lines: params.summaryRow ? [] : params.lines.filter((line) => line.kind !== "approval"),
+		plan: params.plan,
+		maxLineChars: params.maxLineChars
+	});
+	const attention = buildProgressAttentionTasks(params.summaryRow ? params.lines : approvals, params.finalInProgressStatus);
+	const headline = params.title?.trim() || params.label?.trim();
+	const newest = tasks.at(-1);
+	const title = compactChunkText(headline || (newest?.details ? `${newest.title} — ${newest.details}` : newest?.title) || (params.summaryRow ? "Working" : attention.at(-1)?.title) || SLACK_PROGRESS_PLAN_FALLBACK_TITLE);
+	const diffOutput = formatTaskDiffOutput(params.diffStat);
+	if (tasks.length === 0 && (params.summaryRow || params.sessionUrl || diffOutput)) tasks.push({
 		id: "openclaw_summary",
-		title: compactTitle(title),
-		status: "in_progress"
-	}];
-	let attention = resolveProgressAttention(params.lines);
-	if (params.finalInProgressStatus === "error" && !tasks.some((task) => task.status === "in_progress")) attention = {
+		title: params.summaryRow ? compactTitle(title) : "Completed",
+		status: params.finalInProgressStatus ?? (params.summaryRow ? "in_progress" : "complete")
+	});
+	tasks.push(...attention);
+	if (params.finalInProgressStatus === "error" && !tasks.some((task) => task.status === "in_progress" || task.status === "error")) tasks.push({
 		id: "openclaw_attention",
-		title: attention?.status === "error" ? attention.title : "Failed",
+		title: "Failed",
 		status: "error"
-	};
-	if (attention && !(params.finalInProgressStatus && attention.status === "pending")) tasks.push(attention);
+	});
+	if (!headline && tasks.length === 0) return;
 	const finalTaskIndex = tasks.length - 1;
 	const taskChunks = tasks.map((task, index) => {
+		const recovered = params.finalInProgressStatus === "complete" && task.status === "error";
 		const chunk = {
 			type: "task_update",
 			id: task.id,
-			title: task.title,
-			status: task.status === "in_progress" ? params.finalInProgressStatus ?? task.status : task.status
+			title: recovered ? compactTitle(`Recovered: ${task.title}`) : task.title,
+			status: recovered ? "complete" : task.status === "in_progress" ? params.finalInProgressStatus ?? task.status : task.status
 		};
+		if (task.details) chunk.details = task.details;
+		if (task.output) chunk.output = task.output;
+		if (index === finalTaskIndex && diffOutput) chunk.output = [task.output, diffOutput].filter(Boolean).join(" · ");
 		if (index === finalTaskIndex && params.sessionUrl) chunk.sources = buildSessionSources(params.sessionUrl);
 		return chunk;
 	});
@@ -664,30 +625,53 @@ function buildSlackProgressStreamChunks(params) {
 		title
 	}, ...taskChunks];
 }
+function joinRecentProgressRows(rows) {
+	const rendered = [];
+	let length = 0;
+	for (const row of rows.toReversed()) {
+		const nextLength = length + row.length + (rendered.length > 0 ? 1 : 0);
+		if (nextLength > SLACK_PROGRESS_FIELD_MAX) break;
+		rendered.push(row);
+		length = nextLength;
+	}
+	return rendered.toReversed().join("\n");
+}
+function buildActivityText(lines, maxLineChars) {
+	return joinRecentProgressRows(lines.slice(-50).map((line) => {
+		return `${`${line.icon ?? "•"} *${renderProgressCardText(line.label, "bold")}*`} — ${activityLineDetail(line, maxLineChars)}`;
+	}));
+}
 function buildSlackProgressCardBlocks(params) {
 	const maxLineChars = resolveMaxLineChars(params.maxLineChars, DEFAULT_SLACK_PROGRESS_DETAIL_MAX_CHARS);
-	const statusLabels = {
-		completed: "Completed",
-		in_progress: "In progress",
-		pending: "Pending"
-	};
-	const planLines = (params.plan ?? []).slice(-50).map((entry) => `${statusLabels[entry.status]}: ${compactDetail(entry.step, maxLineChars)}`);
+	const planLines = formatPlanChecklistLines(params.plan ?? [], {
+		maxLines: 50,
+		maxLineChars
+	});
 	const narration = params.narration?.replace(/\s+/g, " ").trim();
-	const authoredText = params.lines.filter(isAuthoredProgressLine).map((line) => line.text.trim()).filter((text, index, values) => text && text !== narration && values.indexOf(text) === index).map((text) => normalizeSlackOutboundText(compactDetail(text, maxLineChars))).join("\n");
-	const attention = resolveProgressAttention(params.lines);
+	const diffStat = formatChannelProgressDraftDiffStat(params.diffStat);
+	const workingFooter = [
+		...params.toolCalls && params.toolCalls > 0 ? [`🛠️ ${params.toolCalls} tools`] : [],
+		...diffStat ? [diffStat] : [],
+		...params.elapsedSeconds && params.elapsedSeconds > 0 ? [`⏱ ${params.elapsedSeconds}s`] : []
+	].join(" · ");
+	const footer = params.state === "working" ? workingFooter : diffStat;
+	const icon = params.state === "working" ? "🔄" : params.state === "success" ? "✅" : "❌";
+	const finalStatus = params.state === "working" ? void 0 : params.state === "success" ? "complete" : "error";
+	const attention = buildProgressAttentionTasks(params.lines, finalStatus).map((task) => escapeSlackMrkdwn(task.title));
 	const blocks = [
-		`${params.state === "success" ? "Completed: " : params.state === "error" ? "Failed: " : ""}*${escapeSlackMrkdwn(params.title.trim() || "Working")}*`,
-		narration ? `_${escapeSlackMrkdwn(narration)}_` : "",
-		planLines.map((line) => escapeSlackMrkdwn(line)).join("\n"),
-		authoredText,
-		attention && !(params.state !== "working" && attention.status === "pending") ? escapeSlackMrkdwn(attention.title) : ""
+		`${icon} *${renderProgressCardText(params.title.trim() || "Working", "bold")}*`,
+		narration ? `_${renderProgressCardText(narration, "italic")}_` : "",
+		planLines.map((line) => renderProgressCardText(line)).join("\n"),
+		buildActivityText(params.lines.filter((line) => line.kind !== "approval" && lineTaskStatus(line) !== "error"), maxLineChars),
+		joinRecentProgressRows(attention)
 	].filter(Boolean).map((text) => ({
 		type: "section",
-		text: {
-			type: "mrkdwn",
-			text: truncateSlackText(text, SLACK_PROGRESS_FIELD_MAX)
-		}
+		text: field(text)
 	}));
+	if (footer) blocks.push({
+		type: "context",
+		elements: [field(footer)]
+	});
 	if (params.state !== "working" && params.sessionUrl) blocks.push({
 		type: "actions",
 		elements: [{
@@ -703,11 +687,39 @@ function buildSlackProgressCardBlocks(params) {
 	return blocks.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
+	};
+}
 /**
 * 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 titles/statuses replace in place, and rows that dropped out
-* (plan shrinks, summary <-> plan source switches) get a final complete
+* 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) {
@@ -727,38 +739,46 @@ function reconcileSlackNativeTaskChunks(params) {
 			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
+			status: chunk.status
 		};
+		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 || sourcesChanged)) continue;
+		if (!(!previousRow || previousRow.title !== chunk.title || previousRow.status !== chunk.status || Boolean(details.delta) || Boolean(output.delta) || sourcesChanged)) continue;
 		const update = {
 			type: "task_update",
 			id: chunk.id,
 			title: chunk.title,
-			status
+			status: chunk.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") {
+		const recovered = row.status === "error" && (id.startsWith(SLACK_ATTENTION_TASK_PREFIX) || params.finalStatus === "complete");
+		if (row.status === "complete" || row.status === "error" && !recovered) {
 			nextTasks.set(id, row);
 			continue;
 		}
+		const title = recovered ? compactTitle(`Recovered: ${row.title}`) : row.title;
 		nextTasks.set(id, {
 			...row,
+			title,
 			status: "complete"
 		});
 		emitted.push({
 			type: "task_update",
 			id,
-			title: row.title,
+			title,
 			status: "complete"
 		});
 	}
@@ -771,62 +791,30 @@ function reconcileSlackNativeTaskChunks(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.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.filter((line) => typeof line !== "string");
+	return lines.map((line) => {
+		if (typeof line !== "string") return line;
+		const reasoning = line.startsWith("🧠 ");
+		const text = line.replace(/^(?:🧠|💬)\s+/u, "").replace(/^_(.*)_$/su, "$1").trim();
+		return {
+			...reasoning ? { id: "reasoning" } : {},
+			kind: "item",
+			text,
+			label: reasoning ? "Reasoning" : "Update",
+			prefix: false
+		};
+	});
 }
 function resolveNativeProgressLines(snapshot) {
-	return resolveStructuredProgressLines(snapshot.lines).filter((line) => line.id !== "reasoning" && line.id?.startsWith("commentary:") !== true);
+	const lines = resolveStructuredProgressLines(snapshot.lines).filter((line) => line.id !== "reasoning" && line.id?.startsWith("commentary:") !== true);
+	if (snapshot.plan?.length || !snapshot.planExplanation) return lines;
+	const explanationLine = buildChannelProgressDraftLine({
+		event: "plan",
+		phase: "update",
+		explanation: snapshot.planExplanation
+	});
+	return explanationLine ? [...lines, explanationLine] : lines;
 }
 function resolveNativeProgressNarration(snapshot) {
 	const paragraphs = resolveStructuredProgressLines(snapshot.lines).filter((line) => line.id === "reasoning" || line.id?.startsWith("commentary:") === true).map((line) => line.text.trim()).filter((text, index, values) => Boolean(text) && values.indexOf(text) === index);
@@ -964,24 +952,30 @@ function createSlackDraftProgressCardRuntime(params) {
 		return url.toString();
 	};
 	const resolveText = (snapshot) => latestFallbackText || formatChannelProgressDraftText({
-		presentation: "summary",
 		entry: account.config,
 		lines: [...snapshot.lines],
 		seed: params.progressSeed,
 		formatLine: formatSlackProgressDraftLine,
 		narration: snapshot.statusHeadline,
-		plan: snapshot.plan
+		plan: snapshot.plan,
+		diffStat: snapshot.diffStat
 	});
 	const resolvePresentation = (snapshot, state) => {
 		const title = params.explicitTitle ?? snapshot.statusHeadline ?? "Working";
+		const narration = params.explicitTitle ? combineProgressHeadlineAndExplanation(snapshot.statusHeadline, snapshot.planExplanation) : snapshot.planExplanation && snapshot.planExplanation !== title ? snapshot.planExplanation : void 0;
+		const workCounter = state === "working" ? params.progressWorkCounter : void 0;
+		const sessionUrl = state === "working" ? void 0 : resolveSessionUrl();
 		return buildSlackProgressCardBlocks({
 			state,
 			title,
-			narration: params.explicitTitle ? combineProgressHeadlineAndExplanation(snapshot.statusHeadline, snapshot.planExplanation) : snapshot.planExplanation && snapshot.planExplanation !== title ? snapshot.planExplanation : void 0,
+			narration,
 			plan: snapshot.plan,
 			lines: resolveStructuredProgressLines(snapshot.lines),
 			maxLineChars: params.maxLineChars,
-			...state !== "working" ? { sessionUrl: resolveSessionUrl() } : {}
+			diffStat: snapshot.diffStat,
+			toolCalls: workCounter?.toolCalls,
+			elapsedSeconds: workCounter?.elapsedSeconds,
+			sessionUrl
 		});
 	};
 	const finalize = async (status, snapshot = params.getSnapshot(), fallbackText = resolveText(snapshot)) => {
@@ -1035,10 +1029,10 @@ function formatSlackProgressDraftLine(line) {
 	if (/^(?:🧠|💬)\s/u.test(line)) return line;
 	const italicCommentary = /^_(.*)_$/su.exec(line);
 	if (!italicCommentary) return escapeSlackMrkdwn(line);
-	return `_${italicCommentary[1].split(/(`[^`\n]+`)/u).map((segment, index) => {
-		if (index % 2 === 0) return escapeSlackMrkdwn(segment);
-		return `\`${segment.slice(1, -1).replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;")}\``;
-	}).join("")}_`;
+	return `_${normalizeSlackOutboundText(italicCommentary[1], {
+		mentions: "escape",
+		enclosingStyle: "italic"
+	})}_`;
 }
 //#endregion
 //#region extensions/slack/src/monitor/message-handler/dispatch-progress-native.ts
@@ -1075,6 +1069,7 @@ function createSlackNativeProgressTransport(params) {
 		const startPromise = (async () => {
 			const session = await startSlackStream({
 				client: slackClient,
+				clientOptions: params.setup.slackClientOptions,
 				channel: message.channel,
 				threadTs: streamThreadTs,
 				...update.text ? { text: update.text } : {},
@@ -1145,7 +1140,7 @@ function createSlackProgressRuntime(runtimeParams) {
 	const isProgressMode = slackStreaming.mode === "progress";
 	const useNativeProgressStreaming = useStreaming && slackStreaming.mode === "progress";
 	const progressDraftActive = Boolean(draftStream) || useNativeProgressStreaming;
-	const previewToolProgressEnabled = progressDraftActive && resolveChannelStreamingPreviewToolProgress(account.config, true, slackStreaming.mode);
+	const previewToolProgressEnabled = progressDraftActive && resolveChannelStreamingPreviewToolProgress(account.config, slackStreaming.mode !== "progress", slackStreaming.mode);
 	let shouldYieldDraftProgress = () => false;
 	const suppressDefaultToolProgressMessages = resolveChannelStreamingSuppressDefaultToolProgressMessages(account.config, {
 		draftStreamActive: Boolean(draftStream) || useNativeProgressStreaming,
@@ -1153,7 +1148,6 @@ function createSlackProgressRuntime(runtimeParams) {
 		previewToolProgressEnabled,
 		previewStreamingEnabled
 	});
-	let previewToolProgressSuppressed = false;
 	let nativeStreamSnapshot = EMPTY_SLACK_NATIVE_STREAM_SNAPSHOT;
 	let appendRenderedText = "";
 	let appendSourceText = "";
@@ -1167,6 +1161,7 @@ function createSlackProgressRuntime(runtimeParams) {
 		nativeStreamOrder = run.catch(() => void 0);
 		return run;
 	};
+	const progressWorkCounter = createChannelProgressWorkCounter();
 	const progressSeed = `${account.accountId}:${message.channel}`;
 	const slackProgressStyle = resolveSlackProgressStyle(account.config);
 	const useDraftProgressCard = Boolean(draftStream) && isProgressMode && slackProgressStyle === "card";
@@ -1182,6 +1177,7 @@ function createSlackProgressRuntime(runtimeParams) {
 		},
 		draftStream,
 		enabled: useDraftProgressCard,
+		progressWorkCounter: previewToolProgressEnabled ? progressWorkCounter : void 0,
 		progressSeed,
 		explicitTitle: explicitProgressTitle,
 		maxLineChars: progressDraftMaxLineChars,
@@ -1246,9 +1242,11 @@ function createSlackProgressRuntime(runtimeParams) {
 		const reconciled = reconcileSlackNativeTaskChunks({
 			previous: nativeStreamSnapshot,
 			chunks: buildSlackProgressStreamChunks({
-				title: resolveNativeProgressTitle(snapshot) ?? "Working",
+				title: resolveNativeProgressTitle(snapshot),
 				lines: resolveNativeProgressLines(snapshot),
-				plan: snapshot.plan
+				plan: snapshot.plan,
+				maxLineChars: progressDraftMaxLineChars,
+				summaryRow: !previewToolProgressEnabled
 			})
 		});
 		const chunks = reconciled.chunks;
@@ -1307,18 +1305,17 @@ function createSlackProgressRuntime(runtimeParams) {
 		return true;
 	};
 	const resetProgressTurnState = () => {
+		progressWorkCounter.reset();
 		nativeNarrationRenderedText = "";
 		nativeNarrationSourceText = "";
 	};
 	const progressDraft = createChannelProgressDraftCompositor({
-		presentation: isProgressMode && slackProgressStyle === "card" ? "summary" : void 0,
 		entry: account.config,
 		mode: slackStreaming.mode,
 		active: progressDraftActive,
 		seed: progressSeed,
 		formatLine: formatSlackProgressDraftLine,
 		reasoningLinePrefix: "🧠 ",
-		reasoningGate: previewToolProgressEnabled,
 		updateOnLineChange: useNativeProgressStreaming || useDraftProgressCard,
 		update: async (previewText, options) => {
 			if (useNativeProgressStreaming) {
@@ -1330,7 +1327,7 @@ function createSlackProgressRuntime(runtimeParams) {
 				return priorSnapshot !== nativeStreamSnapshot || priorNarration !== nativeNarrationRenderedText;
 			}
 			if (!draftStream) return false;
-			const snapshot = progressDraft.getSnapshot();
+			const snapshot = options.snapshot;
 			progressCard.setFallbackText(previewText);
 			draftStream.update(useDraftProgressCard ? {
 				text: previewText,
@@ -1338,6 +1335,15 @@ function createSlackProgressRuntime(runtimeParams) {
 			} : previewText);
 			if (options?.flush) await draftStream.flush();
 			return Boolean(draftStream.messageId() && draftStream.channelId());
+		},
+		deleteCurrent: async () => {
+			if (useNativeProgressStreaming) {
+				nativeUpdates.update(true);
+				await nativeUpdates.flush();
+			} else {
+				await draftStream?.clear();
+				draftStream?.forceNewMessage();
+			}
 		}
 	});
 	const commentaryProgressEnabled = progressDraft.commentaryProgressEnabled;
@@ -1372,14 +1378,18 @@ function createSlackProgressRuntime(runtimeParams) {
 		const sessionUrl = progressCard.resolveSessionUrl();
 		const narrationUpdate = resolveNarrationUpdate(resolveNativeProgressNarration(snapshot));
 		const hasRetirableNativeTasks = [...nativeStreamSnapshot.tasks.values()].some((task) => task.status !== "complete" && task.status !== "error");
-		if (lines.length === 0 && !snapshot.plan?.length && !hasRetirableNativeTasks && !narrationUpdate.delta && !sessionUrl) return;
+		if (lines.length === 0 && !snapshot.plan?.length && !hasRetirableNativeTasks && !snapshot.diffStat && !narrationUpdate.delta && !sessionUrl) return;
 		const completion = reconcileSlackNativeTaskChunks({
 			previous: nativeStreamSnapshot,
+			finalStatus: finalInProgressStatus,
 			chunks: buildSlackProgressStreamChunks({
 				title: resolveNativeProgressTitle(snapshot) ?? (lines.length === 0 && !snapshot.plan?.length ? "Working" : void 0),
 				lines,
 				plan: snapshot.plan,
+				maxLineChars: progressDraftMaxLineChars,
+				summaryRow: !previewToolProgressEnabled,
 				finalInProgressStatus,
+				diffStat: snapshot.diffStat,
 				sessionUrl
 			})
 		}).chunks;
@@ -1390,61 +1400,22 @@ function createSlackProgressRuntime(runtimeParams) {
 	};
 	const finishNativeProgressTurn = async (completionChunks) => {
 		if (delivery.nativeProgressStreamStartPromise) await delivery.nativeProgressStreamStartPromise.catch(() => null);
-		const session = delivery.streamSession;
-		if (session && !session.stopped) try {
-			if (completionChunks?.length) nativeProgressCompletionSent = true;
-			const stopResult = await stopSlackStream({
-				session,
-				...completionChunks?.length ? { chunks: completionChunks } : {},
-				...slackMessageMetadata ? { metadata: slackMessageMetadata } : {}
-			});
-			delivery.acknowledgeStoppedStreamedDeliveries(session, stopResult?.messageId);
-		} catch (err) {
-			const error = formatSlackError(err);
-			delivery.emitAcknowledgedStreamedDeliveries();
-			delivery.emitFailedPendingStreamedDeliveries(error);
-			logVerbose(`slack-stream: failed to rotate native progress stream (${error})`);
-		}
+		if (completionChunks?.length) nativeProgressCompletionSent = true;
+		await delivery.finishStream(completionChunks);
 		delivery.streamSession = null;
 		delivery.nativeProgressStreamStartPromise = null;
 		delivery.nativeProgressStreamThreadTs = void 0;
 		delivery.streamFailed = false;
 	};
 	const pushPlanProgress = async (steps, explanation) => {
-		if (!previewToolProgressEnabled) return false;
-		if (isProgressMode) {
-			if (slackProgressStyle === "compact") return false;
-			return await progressDraft.pushPlanProgress(steps, { explanation });
-		}
-		if (previewToolProgressSuppressed || !draftStream) return false;
-		const text = formatChannelProgressDraftText({
-			entry: account.config,
-			lines: [...progressDraft.getSnapshot().lines],
-			seed: progressSeed,
-			formatLine: formatSlackProgressDraftLine,
-			narration: explanation,
-			plan: steps
-		});
-		if (text) draftStream.update(text);
-		return false;
-	};
-	const pushPreviewProgress = async (line, options) => {
-		if (!draftStream && !useNativeProgressStreaming) return false;
-		if (options?.toolName !== void 0 && !isChannelProgressDraftWorkToolName(options.toolName)) return false;
-		const normalized = line?.text.replace(/\s+/g, " ").trim();
-		if (isProgressMode) {
-			if (!line || !normalized) return await progressDraft.noteActivity();
-			return await progressDraft.pushToolProgress(line, options);
-		}
-		if (!line || !normalized || !draftStream || !previewToolProgressEnabled) return false;
-		return await progressDraft.pushToolProgress(line, options);
+		if (isProgressMode && slackProgressStyle === "compact") return false;
+		return await progressDraft.pushPlanProgress(steps, { explanation });
 	};
 	const updateDraftFromPartial = (text) => {
 		const trimmed = text && sanitizeAssistantVisibleText(text).trimEnd();
 		if (!trimmed) return false;
 		if (slackStreaming.mode === "block") {
-			previewToolProgressSuppressed = true;
-			progressDraft.suppress();
+			progressDraft.resetActivity({ suppressed: true });
 			const next = applyAppendOnlyStreamUpdate({
 				incoming: trimmed,
 				rendered: appendRenderedText,
@@ -1458,8 +1429,7 @@ function createSlackProgressRuntime(runtimeParams) {
 			return false;
 		}
 		if (isProgressMode) return false;
-		previewToolProgressSuppressed = true;
-		progressDraft.suppress();
+		progressDraft.resetActivity({ suppressed: true });
 		draftStream?.update(trimmed);
 		hasStreamedAnswer = true;
 		return false;
@@ -1469,7 +1439,7 @@ function createSlackProgressRuntime(runtimeParams) {
 		if (!isProgressMode) {
 			const normalized = progressDraft.mergeReasoningProgress(payload.text, { snapshot: payload.isReasoningSnapshot === true }).replace(/^_(.*)_$/su, "$1").trim();
 			if (!normalized) return false;
-			const visible = await pushPreviewProgress({
+			const visible = await progressDraft.pushToolProgress({
 				id: "reasoning",
 				kind: "item",
 				text: normalized,
@@ -1485,10 +1455,6 @@ function createSlackProgressRuntime(runtimeParams) {
 		appendRenderedText = "";
 		appendSourceText = "";
 	};
-	const resetDraftProgressState = () => {
-		previewToolProgressSuppressed = false;
-		progressDraft.reset();
-	};
 	const beginNewProgressTurn = async (options) => {
 		if (useNativeProgressStreaming) {
 			if (!nativeUpdatesStopped && options?.force !== true) return false;
@@ -1518,11 +1484,12 @@ function createSlackProgressRuntime(runtimeParams) {
 	const onDraftBoundary = !shouldUseDraftStream && !useNativeProgressStreaming ? void 0 : async () => {
 		if (isProgressMode) {
 			await beginNewProgressTurn();
+			progressDraft.beginAssistantMessage();
 			return;
 		}
 		if (hasStreamedAnswer) draftStream?.forceNewMessage();
 		resetDraftDeliveryState();
-		resetDraftProgressState();
+		progressDraft.beginAssistantMessage();
 	};
 	const onQueuedFollowupAdmitted = !shouldUseDraftStream && !useNativeProgressStreaming ? void 0 : async () => {
 		await draftStream?.flush();
@@ -1531,7 +1498,7 @@ function createSlackProgressRuntime(runtimeParams) {
 		else draftStream?.forceNewMessage();
 		delivery.resetDeliveryTracker();
 		resetDraftDeliveryState();
-		resetDraftProgressState();
+		progressDraft.reset();
 	};
 	const onQueuedFollowupSettled = !useDraftProgressCard && !useNativeProgressStreaming ? void 0 : async () => {
 		if (useNativeProgressStreaming) {
@@ -1553,6 +1520,7 @@ function createSlackProgressRuntime(runtimeParams) {
 		previewToolProgressEnabled,
 		suppressDefaultToolProgressMessages,
 		progressDraft,
+		progressWorkCounter,
 		commentaryProgressEnabled,
 		async cancel() {
 			progressDraft.cancel();
@@ -1589,6 +1557,10 @@ function createSlackProgressRuntime(runtimeParams) {
 async function createSlackDispatchSetup(prepared) {
 	const { ctx, account, message, route } = prepared;
 	const slackClient = prepared.eventScope?.client ?? ctx.app.client;
+	const slackClientOptions = {
+		...ctx.app.webClientOptions,
+		...prepared.eventScope ? { teamId: prepared.eventScope.teamId } : {}
+	};
 	const slackStreamFallbackTeamId = prepared.eventScope?.teamId ?? ctx.teamId;
 	const cfg = ctx.cfg;
 	const runtime = ctx.runtime;
@@ -1702,12 +1674,13 @@ async function createSlackDispatchSetup(prepared) {
 		transformReplyPayload: sanitizeSlackMonitorReplyPayload,
 		typing: {
 			start: async () => {
-				if (!threadStatusGate.hasVisibleOutput()) {
+				if (!didSetStatus && !threadStatusGate.hasVisibleOutput()) {
 					didSetStatus = true;
-					await ctx.setSlackThreadStatus({
+					await ctx.setSlackSessionStatus({
 						channelId: message.channel,
 						threadTs: statusThreadTs,
-						status: "is typing...",
+						status: "processing",
+						title: prepared.sessionDisplayName ?? prepared.ctxPayload.ThreadLabel,
 						eventScope: prepared.eventScope
 					});
 				}
@@ -1724,10 +1697,10 @@ async function createSlackDispatchSetup(prepared) {
 			stop: async () => {
 				if (didSetStatus) {
 					didSetStatus = false;
-					await ctx.setSlackThreadStatus({
+					await ctx.setSlackSessionStatus({
 						channelId: message.channel,
 						threadTs: statusThreadTs,
-						status: "",
+						status: "active",
 						eventScope: prepared.eventScope
 					});
 				}
@@ -1782,15 +1755,6 @@ async function createSlackDispatchSetup(prepared) {
 	});
 	const shouldUseDraftStream = previewStreamingEnabled && !useStreaming;
 	const blockStreamingEnabled = resolveChannelStreamingBlockEnabled(account.config);
-	const disableBlockStreaming = sourceRepliesAreToolOnly ? true : resolveSlackDisableBlockStreaming({
-		useStreaming,
-		shouldUseDraftStream,
-		blockStreamingEnabled
-	});
-	const onSlackDeliveryError = (err, info) => {
-		runtime.error?.(danger(`slack ${info.kind} reply failed: ${formatSlackError(err)}`));
-		replyPipeline.typingCallbacks?.onIdle?.();
-	};
 	return {
 		prepared,
 		ctx,
@@ -1798,6 +1762,7 @@ async function createSlackDispatchSetup(prepared) {
 		message,
 		route,
 		slackClient,
+		slackClientOptions,
 		slackStreamFallbackTeamId,
 		cfg,
 		runtime,
@@ -1827,15 +1792,18 @@ async function createSlackDispatchSetup(prepared) {
 		previewStreamingEnabled,
 		hasSlackCustomIdentity,
 		shouldUseDraftStream,
-		disableBlockStreaming,
-		useStreaming,
-		onSlackDeliveryError
+		disableBlockStreaming: sourceRepliesAreToolOnly ? true : resolveSlackDisableBlockStreaming({
+			useStreaming,
+			shouldUseDraftStream,
+			blockStreamingEnabled
+		}),
+		useStreaming
 	};
 }
 //#endregion
 //#region extensions/slack/src/monitor/message-handler/dispatch-streaming.ts
 function createSlackStreamingDeliveryRuntime(setup) {
-	const { account, ctx, forcedReplyThreadTs, isThreadReply, message, messageSentDeliveryHookContext, messageSentHookContext, messageSentHookTarget, prepared, replyDeliveryMode, replyPlan, runtime, slackClient, slackIdentity, slackMessageMetadata, slackStreamFallbackTeamId } = setup;
+	const { account, ctx, forcedReplyThreadTs, isThreadReply, message, messageSentDeliveryHookContext, messageSentHookContext, messageSentHookTarget, prepared, replyDeliveryMode, replyPlan, runtime, slackClient, slackClientOptions, slackIdentity, slackMessageMetadata, slackStreamFallbackTeamId } = setup;
 	const state = {
 		streamSession: null,
 		nativeProgressStreamStartPromise: null,
@@ -1846,78 +1814,24 @@ function createSlackStreamingDeliveryRuntime(setup) {
 		observedReplyDelivery: false,
 		observedFinalReplyDelivery: false
 	};
-	const streamedDeliveries = [];
-	const refreshStreamedAcknowledgements = (session) => {
-		if (session.pendingText.length === 0) for (const delivery of streamedDeliveries) delivery.acknowledged = true;
-	};
-	const recordStreamedDelivery = (kind, content) => {
-		const delivery = {
-			kind,
+	const emitStreamedDelivery = (content, result) => {
+		emitSlackMessageSentHooks({
+			...messageSentHookContext,
+			to: messageSentHookTarget,
+			accountId: account.accountId,
 			content,
-			acknowledged: false
-		};
-		streamedDeliveries.push(delivery);
-		return delivery;
-	};
-	const rememberStreamedDelivery = (kind, content, session) => {
-		recordStreamedDelivery(kind, content);
-		refreshStreamedAcknowledgements(session);
-	};
-	const emitAcknowledgedStreamedDeliveries = (messageId) => {
-		for (const delivery of streamedDeliveries) {
-			if (!delivery.acknowledged || delivery.outcome) continue;
-			emitSlackMessageSentHooks({
-				...messageSentHookContext,
-				to: messageSentHookTarget,
-				accountId: account.accountId,
-				content: delivery.content,
-				success: true,
-				...messageId ? { messageId } : {}
-			});
-			delivery.outcome = "success";
-		}
-	};
-	const acknowledgeStoppedStreamedDeliveries = (session, messageId) => {
-		refreshStreamedAcknowledgements(session);
-		for (const delivery of streamedDeliveries) delivery.acknowledged = true;
-		emitAcknowledgedStreamedDeliveries(messageId);
-	};
-	const emitFailedPendingStreamedDeliveries = (error) => {
-		for (const delivery of streamedDeliveries) {
-			if (delivery.acknowledged || delivery.outcome) continue;
-			emitSlackMessageSentHooks({
-				...messageSentHookContext,
-				to: messageSentHookTarget,
-				accountId: account.accountId,
-				content: delivery.content,
-				success: false,
-				error
-			});
-			delivery.outcome = "failure";
-		}
-	};
-	const emitSuccessfulPendingStreamedDeliveries = (messageId) => {
-		for (const delivery of streamedDeliveries) {
-			if (delivery.acknowledged || delivery.outcome) continue;
-			emitSlackMessageSentHooks({
-				...messageSentHookContext,
-				to: messageSentHookTarget,
-				accountId: account.accountId,
-				content: delivery.content,
-				success: true,
-				...messageId ? { messageId } : {}
-			});
-			delivery.outcome = "success";
-		}
+			...result
+		});
 	};
 	let deliveryTracker = createSlackEventDeliveryTracker();
 	const markPreviewPayloadDelivered = (params) => {
-		deliveryTracker.markDelivered(params);
+		const preparedReply = prepareSlackReply(params.payload);
+		deliveryTracker.markDelivered(buildSlackEventDeliveryKey(params, preparedReply));
 		const nextThreadTs = replyPlan.peekThreadTs();
-		if (nextThreadTs !== params.threadTs) deliveryTracker.markDelivered({
+		if (nextThreadTs !== params.threadTs) deliveryTracker.markDelivered(buildSlackEventDeliveryKey({
 			...params,
 			threadTs: nextThreadTs
-		});
+		}, preparedReply));
 	};
 	const resolveDeliveryThreadTs = (params) => {
 		const plannedThreadTs = params.forcedThreadTs ? void 0 : replyPlan.nextThreadTs();
@@ -1929,75 +1843,90 @@ function createSlackStreamingDeliveryRuntime(setup) {
 		if (kind === "block") state.usedBlockReplyThreadTs = deliveredThreadTs;
 	};
 	const deliverPendingStreamFallback = async (session, err) => {
+		if (session.stoppedBySlack) return;
 		let fallbackError = err;
 		if (!session.stopped) try {
 			const stopResult = await stopSlackStream({
 				session,
 				...slackMessageMetadata ? { metadata: slackMessageMetadata } : {}
 			});
-			acknowledgeStoppedStreamedDeliveries(session, stopResult.messageId);
+			if (session.stoppedBySlack) return;
 			state.observedReplyDelivery = true;
 			state.usedReplyThreadTs ??= session.threadTs;
-			return true;
+			return stopResult;
 		} catch (stopErr) {
 			if (stopErr instanceof SlackStreamNotDeliveredError) fallbackError = stopErr;
-			else runtime.error?.(danger(`slack-stream: failed to finalize buffered text before fallback: ${formatSlackError(stopErr)}`));
+			else throw stopErr;
 		}
-		emitAcknowledgedStreamedDeliveries();
 		const fallbackText = fallbackError.pendingText.trim();
-		if (!fallbackText) return false;
-		try {
-			await deliverReplies({
-				cfg: ctx.cfg,
-				replies: [{ text: fallbackText }],
-				target: prepared.replyTarget,
-				token: ctx.botToken,
-				accountId: account.accountId,
-				runtime,
-				textLimit: ctx.textLimit,
-				mediaMaxBytes: ctx.mediaMaxBytes,
-				replyThreadTs: session.threadTs,
-				replyToMode: replyDeliveryMode,
-				...slackIdentity ? { identity: slackIdentity } : {},
-				...slackMessageMetadata ? { metadata: slackMessageMetadata } : {},
-				...messageSentDeliveryHookContext,
-				deferMessageSentHooks: true,
-				eventScope: prepared.eventScope
+		if (!fallbackText) return;
+		await deliverReplies({
+			cfg: ctx.cfg,
+			replies: [prepareSlackReply({ text: fallbackText })],
+			target: prepared.replyTarget,
+			token: ctx.botToken,
+			accountId: account.accountId,
+			runtime,
+			textLimit: ctx.textLimit,
+			mediaMaxBytes: ctx.mediaMaxBytes,
+			replyThreadTs: session.threadTs,
+			replyToMode: replyDeliveryMode,
+			...slackIdentity ? { identity: slackIdentity } : {},
+			...slackMessageMetadata ? { metadata: slackMessageMetadata } : {},
+			...messageSentDeliveryHookContext,
+			deferMessageSentHooks: true,
+			eventScope: prepared.eventScope
+		});
+		markSlackStreamFallbackDelivered(session);
+		if (!session.stopped) try {
+			await stopSlackStream({
+				session,
+				...slackMessageMetadata ? { metadata: slackMessageMetadata } : {}
 			});
-			markSlackStreamFallbackDelivered(session);
-			if (!session.stopped) try {
+		} catch (finalizeErr) {
+			runtime.error?.(danger(`slack-stream: failed to finalize native stream after fallback delivery: ${formatSlackError(finalizeErr)}`));
+		}
+		state.observedReplyDelivery = true;
+		state.usedReplyThreadTs ??= session.threadTs;
+		logVerbose(`slack-stream: streamed delivery failed (${fallbackError.slackCode}); delivered ${fallbackText.length} chars via deliverReplies fallback`);
+		return {};
+	};
+	const finishStream = async (chunks) => {
+		const session = state.streamSession;
+		if (session && !session.stopped) try {
+			try {
 				await stopSlackStream({
 					session,
+					...chunks?.length ? { chunks } : {},
 					...slackMessageMetadata ? { metadata: slackMessageMetadata } : {}
 				});
-			} catch (finalizeErr) {
-				runtime.error?.(danger(`slack-stream: failed to finalize native stream after fallback delivery: ${formatSlackError(finalizeErr)}`));
+				state.observedReplyDelivery ||= session.delivered;
+			} catch (error) {
+				if (!(error instanceof SlackStreamNotDeliveredError)) throw error;
+				await deliverPendingStreamFallback(session, error);
 			}
-			emitSuccessfulPendingStreamedDeliveries();
-			state.observedReplyDelivery = true;
-			state.usedReplyThreadTs ??= session.threadTs;
-			logVerbose(`slack-stream: streamed delivery failed (${fallbackError.slackCode}); delivered ${fallbackText.length} chars via deliverReplies fallback`);
-			return true;
-		} catch (postErr) {
-			emitFailedPendingStreamedDeliveries(formatErrorMessage(postErr));
-			runtime.error?.(danger(`slack-stream: fallback deliverReplies failed after ${fallbackError.slackCode}: ${formatErrorMessage(postErr)}`));
-			return false;
+		} catch (error) {
+			state.streamFailed = true;
+			runtime.error?.(danger(`slack-stream: failed to stop stream: ${formatSlackError(error)}`));
 		}
 	};
 	const deliverNormally = async (params) => {
+		if (state.streamSession?.stoppedBySlack) return;
 		const replyThreadTs = resolveDeliveryThreadTs(params);
 		const deliveryReplyThreadTs = replyDeliveryMode === "off" && !forcedReplyThreadTs && !isThreadReply ? void 0 : replyThreadTs;
-		if (deliveryTracker.hasDelivered({
+		const preparedReply = prepareSlackReply(params.payload);
+		const deliveryKey = buildSlackEventDeliveryKey({
 			kind: params.kind,
 			payload: params.payload,
 			threadTs: deliveryReplyThreadTs
-		})) {
+		}, preparedReply);
+		if (deliveryTracker.hasDelivered(deliveryKey)) {
 			logVerbose("slack: suppressed duplicate normal delivery within the same turn");
 			return deliveryReplyThreadTs;
 		}
 		await deliverReplies({
 			cfg: ctx.cfg,
-			replies: [params.payload],
+			replies: [preparedReply],
 			target: prepared.replyTarget,
 			token: ctx.botToken,
 			accountId: account.accountId,
@@ -2021,26 +1950,9 @@ function createSlackStreamingDeliveryRuntime(setup) {
 		});
 		rememberDeliveredThreadTs(params.kind, deliveredThreadTs);
 		replyPlan.markSent();
-		deliveryTracker.markDelivered({
-			kind: params.kind,
-			payload: params.payload,
-			threadTs: deliveryReplyThreadTs
-		});
+		deliveryTracker.markDelivered(deliveryKey);
 		return deliveryReplyThreadTs;
 	};
-	const deliverBufferedStreamFallback = async (params) => {
-		if (!await deliverPendingStreamFallback(params.session, params.err)) return false;
-		replyPlan.markSent();
-		if (params.kind === "final") state.observedFinalReplyDelivery = true;
-		deliveryTracker.markDelivered({
-			kind: params.kind,
-			payload: params.payload,
-			threadTs: params.session.threadTs,
-			textOverride: params.textOverride
-		});
-		rememberDeliveredThreadTs(params.kind, params.session.threadTs);
-		return true;
-	};
 	const isStreamingEligible = (payload, options) => {
 		const reply = resolveSendableOutboundReplyParts(payload);
 		const renderPlan = resolveSlackReplyRenderPlan(payload);
@@ -2048,7 +1960,7 @@ 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) => {
-		const reply = resolveSendableOutboundReplyParts(params.payload);
+		if (state.streamSession?.stoppedBySlack) return;
 		if (!isStreamingEligible(params.payload)) {
 			await deliverNormally({
 				payload: params.payload,
@@ -2057,47 +1969,45 @@ function createSlackStreamingDeliveryRuntime(setup) {
 			});
 			return;
 		}
-		const text = params.streamText ?? reply.trimmedText;
-		const hookContent = reply.trimmedText;
-		const chunks = params.kind === "final" ? [] : void 0;
-		let plannedThreadTs;
+		if (!state.streamSession && state.nativeProgressStreamStartPromise) await state.nativeProgressStreamStartPromise;
+		if (state.streamSession?.stoppedBySlack) return;
+		let session = state.streamSession;
+		const threadTs = session?.threadTs ?? replyPlan.nextThreadTs();
+		if (state.streamFailed || !threadTs) {
+			state.streamFailed = true;
+			await deliverNormally({
+				payload: params.payload,
+				kind: params.kind,
+				forcedThreadTs: threadTs ?? state.nativeProgressStreamThreadTs
+			});
+			return;
+		}
+		const hookContent = resolveSendableOutboundReplyParts(params.payload).trimmedText;
+		const text = params.streamText ?? hookContent;
+		const deliveryKey = buildSlackEventDeliveryKey({
+			...params,
+			threadTs,
+			textOverride: text
+		});
+		if (deliveryTracker.hasDelivered(deliveryKey)) {
+			logVerbose("slack-stream: suppressed duplicate reply payload");
+			return;
+		}
+		let messageId;
 		try {
-			if (!state.streamSession && state.nativeProgressStreamStartPromise) await state.nativeProgressStreamStartPromise;
-			if (state.streamFailed) {
-				await deliverNormally({
-					payload: params.payload,
-					kind: params.kind,
-					forcedThreadTs: state.streamSession?.threadTs ?? state.nativeProgressStreamThreadTs
-				});
-				return;
-			}
-			if (!state.streamSession) {
-				const streamThreadTs = replyPlan.nextThreadTs();
-				plannedThreadTs = streamThreadTs;
-				if (!streamThreadTs) {
-					logVerbose("slack-stream: no reply thread target for stream start, falling back to normal delivery");
-					state.streamFailed = true;
-					await deliverNormally({
-						payload: params.payload,
-						kind: params.kind
-					});
-					return;
-				}
-				if (deliveryTracker.hasDelivered({
-					kind: params.kind,
-					payload: params.payload,
-					threadTs: streamThreadTs,
-					textOverride: text
-				})) {
-					logVerbose("slack-stream: suppressed duplicate stream start payload");
-					return;
-				}
-				state.streamSession = await startSlackStream({
+			if (session) await appendSlackStream({
+				session,
+				text: `${params.appendSeparator === false ? "" : "\n"}${text}`,
+				chunks: []
+			});
+			else {
+				session = await startSlackStream({
 					client: slackClient,
+					clientOptions: slackClientOptions,
 					channel: message.channel,
-					threadTs: streamThreadTs,
+					threadTs,
 					text,
-					chunks,
+					chunks: [],
 					...params.taskDisplayMode ? { taskDisplayMode: params.taskDisplayMode } : {},
 					...slackIdentity ? { identity: slackIdentity } : {},
 					teamId: await resolveSlackStreamRecipientTeamId({
@@ -2108,96 +2018,60 @@ function createSlackStreamingDeliveryRuntime(setup) {
 					}),
 					userId: message.user
 				});
-				refreshStreamedAcknowledgements(state.streamSession);
-				if (state.streamSession.delivered) {
-					state.observedReplyDelivery = true;
-					if (params.kind === "final") state.observedFinalReplyDelivery = true;
-				}
-				if (hookContent) rememberStreamedDelivery(params.kind, hookContent, state.streamSession);
-				rememberDeliveredThreadTs(params.kind, streamThreadTs);
-				replyPlan.markSent();
-				deliveryTracker.markDelivered({
-					kind: params.kind,
-					payload: params.payload,
-					threadTs: streamThreadTs,
-					textOverride: text
-				});
-				return;
-			}
-			if (deliveryTracker.hasDelivered({
-				kind: params.kind,
-				payload: params.payload,
-				threadTs: state.streamSession.threadTs,
-				textOverride: text
-			})) {
-				logVerbose("slack-stream: suppressed duplicate append payload");
-				return;
+				state.streamSession = session;
 			}
-			if (hookContent) recordStreamedDelivery(params.kind, hookContent);
-			await appendSlackStream({
-				session: state.streamSession,
-				text: `${params.appendSeparator === false ? "" : "\n"}${text}`,
-				chunks
-			});
-			refreshStreamedAcknowledgements(state.streamSession);
-			if (state.streamSession.delivered && state.streamSession.pendingText.length === 0) {
-				state.observedReplyDelivery = true;
-				if (params.kind === "final") state.observedFinalReplyDelivery = true;
+			messageId = session.streamer.ts;
+		} catch (error) {
+			state.streamFailed = true;
+			if (!(error instanceof SlackStreamNotDeliveredError)) {
+				emitStreamedDelivery(hookContent, {
+					success: false,
+					error: formatErrorMessage(error)
+				});
+				throw error;
 			}
-			deliveryTracker.markDelivered({
-				kind: params.kind,
-				payload: params.payload,
-				threadTs: state.streamSession.threadTs,
-				textOverride: text
-			});
-		} catch (err) {
-			if (err instanceof SlackStreamNotDeliveredError) {
-				state.streamFailed = true;
-				if (state.streamSession) {
-					if (await deliverBufferedStreamFallback({
-						session: state.streamSession,
-						err,
-						payload: params.payload,
-						kind: params.kind,
-						textOverride: text
-					})) return;
-					throw err;
-				}
+			if (!session) {
 				await deliverNormally({
 					payload: params.payload,
 					kind: params.kind,
-					forcedThreadTs: plannedThreadTs
+					forcedThreadTs: threadTs
 				});
 				return;
 			}
-			runtime.error?.(danger(`slack-stream: streaming API call failed: ${formatSlackError(err)}, falling back`));
-			state.streamFailed = true;
-			if (state.streamSession && state.streamSession.pendingText) {
-				const bufferedFallbackErr = new SlackStreamNotDeliveredError(state.streamSession.pendingText, "unknown");
-				if (await deliverBufferedStreamFallback({
-					session: state.streamSession,
-					err: bufferedFallbackErr,
-					payload: params.payload,
-					kind: params.kind,
-					textOverride: text
-				})) return;
-				throw err;
+			try {
+				const fallback = await deliverPendingStreamFallback(session, error);
+				if (!fallback && !session.stoppedBySlack) throw error;
+				messageId = fallback?.messageId;
+			} catch (fallbackError) {
+				emitStreamedDelivery(hookContent, {
+					success: false,
+					error: formatErrorMessage(fallbackError)
+				});
+				throw fallbackError;
 			}
-			await deliverNormally({
-				payload: params.payload,
-				kind: params.kind,
-				forcedThreadTs: state.streamSession?.threadTs ?? state.nativeProgressStreamThreadTs ?? plannedThreadTs
+		}
+		if (session.stoppedBySlack && session.pendingText) {
+			emitStreamedDelivery(hookContent, {
+				success: false,
+				error: "Stopped by Slack user"
 			});
+			return;
 		}
+		state.observedReplyDelivery = true;
+		if (params.kind === "final") state.observedFinalReplyDelivery = true;
+		rememberDeliveredThreadTs(params.kind, threadTs);
+		replyPlan.markSent();
+		deliveryTracker.markDelivered(deliveryKey);
+		emitStreamedDelivery(hookContent, {
+			success: true,
+			...messageId ? { messageId } : {}
+		});
 	};
 	return Object.assign(state, {
-		acknowledgeStoppedStreamedDeliveries,
 		deliverNormally,
-		deliverPendingStreamFallback,
 		deliverWithStreaming,
-		emitAcknowledgedStreamedDeliveries,
-		emitFailedPendingStreamedDeliveries,
-		hasDelivered: (params) => deliveryTracker.hasDelivered(params),
+		finishStream,
+		hasDelivered: (params) => deliveryTracker.hasDelivered(buildSlackEventDeliveryKey(params)),
 		isStreamingEligible,
 		markPreviewPayloadDelivered,
 		rememberDeliveredThreadTs,
@@ -2210,7 +2084,35 @@ function createSlackStreamingDeliveryRuntime(setup) {
 //#region extensions/slack/src/monitor/message-handler/dispatch.ts
 async function dispatchPreparedSlackMessage(prepared) {
 	const setup = await createSlackDispatchSetup(prepared);
-	const { account, cfg, ctx, disableBlockStreaming, hasSlackCustomIdentity, hasRepliedRef, message, messageSentHookContext, messageSentHookTarget, onModelSelected, onSlackDeliveryError, previewStreamingEnabled, replyPipeline, replyPlan, route, runtime, slackClient, slackMessageMetadata, slackStreaming, sourceReplyDeliveryMode, statusReactions, statusReactionsEnabled, statusThreadTs, suppressRoomEventTyping, useStreaming } = setup;
+	const beginSessionRun = () => registerSlackSessionRun(prepared.ctx, {
+		channelId: prepared.message.channel,
+		threadTs: setup.streamThreadHint,
+		eventScope: prepared.eventScope
+	}, {
+		...prepared.route,
+		sessionKey: prepared.ctxPayload.SessionKey ?? prepared.route.sessionKey
+	});
+	const upstreamLifecycle = prepared.turnAdoptionLifecycle;
+	let releaseDeferred;
+	const turnAdoptionLifecycle = upstreamLifecycle && {
+		...upstreamLifecycle,
+		onDeferred: () => {
+			const accepted = upstreamLifecycle.onDeferred?.();
+			if (accepted !== false) releaseDeferred ??= beginSessionRun();
+			return accepted;
+		},
+		onSettled: () => {
+			releaseDeferred?.();
+			upstreamLifecycle.onSettled?.();
+		}
+	};
+	const release = beginSessionRun();
+	await dispatchSlackMessageWithSetup(setup, beginSessionRun, turnAdoptionLifecycle).finally(release);
+}
+async function dispatchSlackMessageWithSetup(setup, beginSessionRun, turnAdoptionLifecycle) {
+	const { prepared } = setup;
+	const { account, cfg, ctx, disableBlockStreaming, hasSlackCustomIdentity, hasRepliedRef, message, messageSentHookContext, messageSentHookTarget, onModelSelected, previewStreamingEnabled, replyPipeline, replyPlan, route, runtime, slackClient, slackStreaming, sourceReplyDeliveryMode, statusReactions, statusReactionsEnabled, statusThreadTs, suppressRoomEventTyping, useStreaming } = setup;
+	let dispatchError;
 	const delivery = createSlackStreamingDeliveryRuntime(setup);
 	const draftPreviewCommitted = { value: false };
 	const progress = createSlackProgressRuntime({
@@ -2251,6 +2153,14 @@ async function dispatchPreparedSlackMessage(prepared) {
 		pendingFailureNotice = notice;
 		return payload;
 	};
+	let compactFinalDeliveryStarted = false;
+	const clearCompactProgress = async () => {
+		try {
+			await draftStream?.clear();
+		} catch (err) {
+			logVerbose(`slack: progress preview cleanup failed (${formatSlackError(err)})`);
+		}
+	};
 	const deliverSlackPayload = async (payload, info) => {
 		if (info.kind === "final" && slackStreaming.mode === "progress" && progress.isProgressMode) {
 			if (progress.useNativeProgressStreaming) {
@@ -2258,6 +2168,24 @@ async function dispatchPreparedSlackMessage(prepared) {
 				return;
 			}
 			progress.progressDraft.markFinalReplyStarted();
+			if (!progress.useDraftProgressCard) {
+				compactFinalDeliveryStarted = true;
+				await draftStream?.discardPending();
+				const supplement = getReplyPayloadTtsSupplement(payload);
+				await delivery.deliverNormally({
+					payload: supplement && !supplement.visibleTextAlreadyDelivered && !payload.text?.trim() ? {
+						...payload,
+						text: supplement.spokenText
+					} : payload,
+					kind: info.kind,
+					forcedThreadTs: delivery.usedReplyThreadTs
+				});
+				if (delivery.observedFinalReplyDelivery) {
+					progress.progressDraft.markFinalReplyDelivered();
+					await clearCompactProgress();
+				}
+				return;
+			}
 			if (progress.useDraftProgressCard) {
 				await delivery.deliverNormally({
 					payload,
@@ -2409,7 +2337,6 @@ async function dispatchPreparedSlackMessage(prepared) {
 		});
 		if (info.kind === "final") progress.progressDraft.markFinalReplyDelivered();
 	};
-	let dispatchError;
 	let agentRunFailed = false;
 	let settledDispatchResult;
 	try {
@@ -2433,13 +2360,18 @@ async function dispatchPreparedSlackMessage(prepared) {
 			},
 			delivery: {
 				deliver: deliverSlackPayload,
-				onError: onSlackDeliveryError
+				onError: (err, info) => {
+					dispatchError ??= err;
+					runtime.error?.(danger(`slack ${info.kind} reply failed: ${formatSlackError(err)}`));
+					replyPipeline.typingCallbacks?.onIdle?.();
+				}
 			},
 			record: prepared.turn.record,
 			history: prepared.turn.history,
 			botLoopProtection: resolveSlackBotLoopProtection(prepared),
 			replyOptions: {
-				...prepared.turnAdoptionLifecycle ? { turnAdoptionLifecycle: prepared.turnAdoptionLifecycle } : {},
+				queuedDeliveryCorrelations: [{ begin: beginSessionRun }],
+				...turnAdoptionLifecycle ? { turnAdoptionLifecycle } : {},
 				skillFilter: prepared.channelConfig?.skills,
 				sourceReplyDeliveryMode,
 				suppressTyping: suppressRoomEventTyping ? true : void 0,
@@ -2469,14 +2401,14 @@ async function dispatchPreparedSlackMessage(prepared) {
 				},
 				onQueuedFollowupAdmitted: progress.onQueuedFollowupAdmitted,
 				onQueuedFollowupSettled: progress.onQueuedFollowupSettled,
-				onReasoningStream: statusReactionsEnabled || progress.previewToolProgressEnabled ? async (payload) => {
+				onReasoningStream: async (payload) => {
 					const visible = await progress.pushReasoningProgress(payload);
-					if (!statusReactionsEnabled) return visible;
-					await statusReactions.setThinking();
+					if (statusReactionsEnabled) await statusReactions.setThinking();
 					return visible;
-				} : void 0,
+				},
 				onToolStart: async (payload) => {
 					if (statusReactionsEnabled) await statusReactions.setTool(payload.name);
+					if (payload.phase === "start") progress.progressWorkCounter.noteToolCall(payload.name);
 					return await progress.progressDraft.pushToolEvent(payload);
 				},
 				onItemEvent: async (payload) => {
@@ -2517,38 +2449,16 @@ async function dispatchPreparedSlackMessage(prepared) {
 			});
 		}
 	} catch (err) {
-		dispatchError = err;
+		dispatchError ??= err;
 	} finally {
 		await progress.cancel();
 		if (!progress.useDraftProgressCard) await draftStream?.discardPending();
 	}
-	let streamFallbackDelivered = false;
-	const finalStream = delivery.streamSession;
-	if (finalStream && !finalStream.stopped) try {
-		const completionChunks = progress.useNativeProgressStreaming && !progress.nativeProgressCompletionSent ? progress.buildNativeProgressCompletionChunks(dispatchError || agentRunFailed ? "error" : progress.nativeProgressTerminalStatus) : void 0;
-		if (completionChunks?.length) progress.nativeProgressCompletionSent = true;
-		const stopResult = await stopSlackStream({
-			session: finalStream,
-			...completionChunks?.length ? { chunks: completionChunks } : {},
-			...slackMessageMetadata ? { metadata: slackMessageMetadata } : {}
-		});
-		delivery.acknowledgeStoppedStreamedDeliveries(finalStream, stopResult?.messageId);
-	} catch (err) {
-		if (err instanceof SlackStreamNotDeliveredError) {
-			streamFallbackDelivered = await delivery.deliverPendingStreamFallback(finalStream, err);
-			if (!streamFallbackDelivered) dispatchError ??= err;
-		} else {
-			const error = formatSlackError(err);
-			delivery.emitAcknowledgedStreamedDeliveries();
-			delivery.emitFailedPendingStreamedDeliveries(error);
-			runtime.error?.(danger(`slack-stream: failed to stop stream: ${error}`));
-			if (!finalStream.delivered) dispatchError ??= err;
-		}
-	}
-	const anyReplyDelivered = hasVisibleInboundReplyDispatch(settledDispatchResult, {
-		observedReplyDelivery: delivery.observedReplyDelivery,
-		fallbackDelivered: streamFallbackDelivered
-	});
+	const completionChunks = progress.useNativeProgressStreaming && !progress.nativeProgressCompletionSent ? progress.buildNativeProgressCompletionChunks(dispatchError || agentRunFailed ? "error" : progress.nativeProgressTerminalStatus) : void 0;
+	if (completionChunks?.length) progress.nativeProgressCompletionSent = true;
+	await delivery.finishStream(completionChunks);
+	const anyReplyDelivered = hasVisibleInboundReplyDispatch(settledDispatchResult, { observedReplyDelivery: delivery.observedReplyDelivery });
+	if (progress.isProgressMode && !progress.useNativeProgressStreaming && !progress.useDraftProgressCard && !compactFinalDeliveryStarted && !dispatchError && !agentRunFailed && anyReplyDelivered) await clearCompactProgress();
 	if (pendingFailureNotice && anyReplyDelivered) recordSlackThreadFailureNotice(pendingFailureNotice);
 	if (dispatchError || agentRunFailed) await progress.finalizeDraftProgressCard("error");
 	await progress.dropDetachedProgressCards();
@@ -2815,7 +2725,7 @@ 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 MAX_SLACK_UNAVAILABLE_FILE_TEXT_CHARS = 2e3;
-const loadSlackMediaModule$1 = createLazyRuntimeModule(() => import("./actions-fh66A6lc.js").then((n) => n._));
+const loadSlackMediaModule$1 = createLazyRuntimeModule(() => import("./actions-NBjICINI.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)`;
@@ -2919,19 +2829,26 @@ async function resolveSlackMessageContent(params) {
 			renderedMentions.set(result.userId, result.rendered);
 		}
 	}
+	const renderedMessageText = renderSlackUserMentions(textParts[0], renderedMentions);
+	const renderedAttachmentText = renderSlackUserMentions(textParts[1], renderedMentions);
+	const renderedBotAttachmentText = renderSlackUserMentions(textParts[2], renderedMentions);
+	const commandSourceText = renderSlackUserMentions(normalizeOptionalString(params.message.text), renderedMentions) ?? "";
 	const rawBody = formatSlackUnavailableMedia({
 		body: [
-			renderSlackUserMentions(textParts[0], renderedMentions),
-			renderSlackUserMentions(textParts[1], renderedMentions),
-			renderSlackUserMentions(textParts[2], renderedMentions),
+			renderedMessageText,
+			renderedAttachmentText,
+			renderedBotAttachmentText,
 			mediaPlaceholder
 		].filter(Boolean).join("\n") || "",
 		files: attachmentContent?.files,
 		unavailableMediaCount: attachmentContent?.unavailableMediaCount ?? 0
 	});
+	const mentionStripPatterns = [...renderedMentions.values()].flatMap((rendered) => rendered ? [rendered] : []);
 	return rawBody ? {
 		rawBody,
-		effectiveDirectMedia
+		effectiveDirectMedia,
+		commandSourceText,
+		mentionStripPatterns
 	} : null;
 }
 //#endregion
@@ -3007,105 +2924,6 @@ async function resolveSlackDmHistoryContext(params) {
 	}
 }
 //#endregion
-//#region extensions/slack/src/monitor/message-handler/prepare-routing.ts
-function resolveSlackBaseConversationId(params) {
-	const raw = params.isDirectMessage ? `user:${params.message.user ?? "unknown"}` : params.message.channel;
-	return qualifySlackConversationId(raw, params.eventScope);
-}
-function resolveSlackInitialAgentRoute(params) {
-	const route = resolveAgentRoute({
-		cfg: normalizeSlackRouteBindingConfig(params.ctx.cfg),
-		channel: "slack",
-		accountId: params.account.accountId,
-		teamId: params.eventScope?.teamId || params.ctx.teamId || void 0,
-		peer: {
-			kind: params.isDirectMessage ? "direct" : params.isRoom ? "channel" : "group",
-			id: qualifySlackRoutePeerId({
-				id: params.isDirectMessage ? params.message.user ?? "unknown" : params.message.channel,
-				kind: params.isDirectMessage ? "user" : "channel",
-				eventScope: params.eventScope
-			})
-		}
-	});
-	if (!params.eventScope || !params.isDirectMessage || route.dmScope !== "main") return route;
-	const sessionKey = resolveSlackEnterpriseMainDmSessionKey({
-		baseSessionKey: route.sessionKey,
-		accountId: params.account.accountId,
-		eventScope: params.eventScope
-	});
-	return {
-		...route,
-		sessionKey,
-		mainSessionKey: sessionKey
-	};
-}
-function resolveSlackRoutingContext(params) {
-	const { ctx, account, message, isDirectMessage, isGroupDm, isRoom, isRoomish, channelConfig, seedTopLevelRoomThread, assistantThreadTs, agentViewThreadTs, eventScope } = params;
-	let route = resolveSlackInitialAgentRoute({
-		ctx,
-		account,
-		message,
-		isDirectMessage,
-		isRoom,
-		eventScope
-	});
-	const chatType = isDirectMessage ? "direct" : isGroupDm ? "group" : "channel";
-	const replyToMode = channelConfig?.replyToMode ?? resolveSlackReplyToMode(account, chatType);
-	const threadContext = resolveSlackThreadContext({
-		message,
-		replyToMode,
-		isDirectMessage
-	});
-	const threadTs = threadContext.incomingThreadTs;
-	const isThreadReply = threadContext.isThreadReply;
-	const autoThreadId = !isThreadReply && replyToMode === "all" && threadContext.messageTs ? threadContext.messageTs : void 0;
-	const seedCandidateThreadId = threadContext.incomingThreadTs ?? threadContext.messageTs;
-	const routedThreadId = (isDirectMessage ? assistantThreadTs ?? agentViewThreadTs : isRoomish ? isThreadReply && threadTs ? threadTs : void 0 : isThreadReply ? threadTs : autoThreadId) ?? (isRoomish ? !isThreadReply && isRoom && seedTopLevelRoomThread && replyToMode !== "off" && seedCandidateThreadId ? seedCandidateThreadId : void 0 : void 0);
-	const baseConversationId = resolveSlackBaseConversationId({
-		message,
-		isDirectMessage,
-		eventScope
-	});
-	const runtimeBindingThreadId = routedThreadId ?? (isDirectMessage && isThreadReply ? threadTs : void 0);
-	const bindingRoute = resolveSlackConversationBindingRoute({
-		cfg: ctx.cfg,
-		route,
-		accountId: account.accountId,
-		baseConversationId,
-		runtimeBindingThreadId,
-		bindingsEnabled: !eventScope
-	});
-	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
-	} : resolveThreadSessionKeys({
-		baseSessionKey: route.sessionKey,
-		threadId: routedThreadId,
-		parentSessionKey: routedThreadId && ctx.threadInheritParent ? route.sessionKey : void 0
-	});
-	const sessionKey = threadKeys.sessionKey;
-	const historyKey = isThreadReply && ctx.threadHistoryScope === "thread" ? sessionKey : eventScope ? `${account.accountId}:${eventScope.teamId}:${message.channel}` : message.channel;
-	return {
-		route,
-		runtimeBinding: runtimeRoute.bindingRecord,
-		runtimeBoundSessionKey: runtimeRoute.boundSessionKey,
-		configuredBinding,
-		configuredBindingSessionKey,
-		chatType,
-		replyToMode,
-		threadContext,
-		threadTs,
-		isThreadReply,
-		threadKeys,
-		sessionKey,
-		historyKey
-	};
-}
-//#endregion
 //#region extensions/slack/src/monitor/message-handler/prepare-thread-context-root.ts
 function isSlackThreadAuthorCurrentBot(params) {
 	const { identity, author } = params;
@@ -3161,7 +2979,7 @@ function formatSlackThreadLabelSnippet(text) {
 }
 //#endregion
 //#region extensions/slack/src/monitor/message-handler/prepare-thread-context.ts
-const loadSlackMediaModule = createLazyRuntimeModule(() => import("./actions-fh66A6lc.js").then((n) => n._));
+const loadSlackMediaModule = createLazyRuntimeModule(() => import("./actions-NBjICINI.js").then((n) => n._));
 const SLACK_THREAD_CONTEXT_USER_LOOKUP_CONCURRENCY = 4;
 function resolveSlackThreadSessionFreshness(params) {
 	return params.ctx.channelRuntime?.session?.resolveEntryResetFreshness?.({
@@ -3534,25 +3352,12 @@ async function restoreSlackAssistantThreadContextFromMetadata(params) {
 	const parentUserId = params.message.parent_user_id?.trim();
 	if (!params.message.channel || !threadTs || !parentUserId || parentUserId !== params.ctx.botUserId && parentUserId !== params.ctx.botId) return;
 	try {
-		const response = await (params.eventScope?.client ?? params.ctx.app.client).conversations.replies({
-			channel: params.message.channel,
-			ts: threadTs,
-			oldest: threadTs,
-			include_all_metadata: true,
-			limit: 4
+		return await readSlackAssistantThreadContext({
+			client: params.eventScope?.client ?? params.ctx.app.client,
+			channelId: params.message.channel,
+			threadTs,
+			userId: params.message.user
 		});
-		for (const message of response.messages ?? []) {
-			const context = parseSlackAssistantThreadMetadata(message.metadata);
-			if (!context) continue;
-			return {
-				assistantChannelId: params.message.channel,
-				threadTs,
-				userId: params.message.user,
-				channelId: context.channelId,
-				teamId: context.teamId,
-				enterpriseId: context.enterpriseId
-			};
-		}
 	} catch (err) {
 		logVerbose(`slack assistant context restore failed channel=${params.message.channel} ts=${threadTs}: ${formatErrorMessage(err)}`);
 	}
@@ -3671,17 +3476,6 @@ function resolveSlackMentionSource(params) {
 	if (params.matchedImplicitMentionKinds.length > 0) return "implicit_thread";
 	return "none";
 }
-function buildSlackMentionContextPayload(params) {
-	if (!params.isRoomish) return {};
-	return {
-		WasMentioned: params.effectiveWasMentioned,
-		ExplicitlyMentionedBot: params.explicitlyMentioned,
-		MentionedUserIds: params.mentionedUserIds.length > 0 ? [...params.mentionedUserIds] : void 0,
-		MentionedSubteamIds: params.mentionedSubteamIds.length > 0 ? [...params.mentionedSubteamIds] : void 0,
-		ImplicitMentionKinds: params.matchedImplicitMentionKinds.length > 0 ? [...params.matchedImplicitMentionKinds] : void 0,
-		MentionSource: params.mentionSource
-	};
-}
 async function resolveSlackConversationContext(params) {
 	const { ctx, account, message } = params;
 	const cfg = ctx.cfg;
@@ -3889,7 +3683,7 @@ async function prepareSlackMessage(params) {
 	const channelReplyToMode = channelConfig?.replyToMode ?? resolveSlackReplyToMode(account, channelChatType);
 	const willImplicitlyThreadReply = isRoom && !channelRequireMention && channelReplyToMode !== "off";
 	const seedTopLevelRoomThreadBySource = opts.source === "app_mention" || opts.wasMentioned === true || explicitlyMentioned || willImplicitlyThreadReply;
-	let routing = resolveSlackRoutingContext({
+	const resolveMessageRouting = (seedTopLevelRoomThread) => resolveSlackRoutingContext({
 		ctx,
 		account,
 		message,
@@ -3898,11 +3692,12 @@ async function prepareSlackMessage(params) {
 		isRoom,
 		isRoomish,
 		channelConfig,
-		seedTopLevelRoomThread: seedTopLevelRoomThreadBySource,
+		seedTopLevelRoomThread,
 		assistantThreadTs: assistantThreadContext?.threadTs,
 		agentViewThreadTs,
 		eventScope: opts.eventScope
 	});
+	let routing = resolveMessageRouting(seedTopLevelRoomThreadBySource);
 	let mentionCheckTranscript;
 	const resolveWasMentioned = (mentionRegexes) => opts.wasMentioned ?? (!isDirectMessage && matchesMentionWithExplicit({
 		text: messageText,
@@ -4122,20 +3917,7 @@ async function prepareSlackMessage(params) {
 	const canSeedMentionedRoomThread = !seedTopLevelRoomThreadBySource && isRoom && !routing.isThreadReply && !hasBoundSession;
 	let seededMentionRouting;
 	const getSeededMentionRouting = () => {
-		seededMentionRouting ??= resolveSlackRoutingContext({
-			ctx,
-			account,
-			message,
-			isDirectMessage,
-			isGroupDm,
-			isRoom,
-			isRoomish,
-			channelConfig,
-			seedTopLevelRoomThread: true,
-			assistantThreadTs: assistantThreadContext?.threadTs,
-			agentViewThreadTs,
-			eventScope: opts.eventScope
-		});
+		seededMentionRouting ??= resolveMessageRouting(true);
 		return seededMentionRouting;
 	};
 	let preflightAudioTranscript;
@@ -4242,7 +4024,7 @@ async function prepareSlackMessage(params) {
 	const threadStarter = await getThreadStarter();
 	const resolvedMessageContent = await getMessageContent();
 	if (!resolvedMessageContent) return drop("empty-content");
-	const { rawBody, effectiveDirectMedia } = resolvedMessageContent;
+	const { rawBody, effectiveDirectMedia, commandSourceText, mentionStripPatterns } = resolvedMessageContent;
 	const bodyForAgent = preflightAudioTranscript ? formatSlackAudioTranscriptForAgent({
 		transcript: preflightAudioTranscript,
 		rawBody
@@ -4262,7 +4044,7 @@ async function prepareSlackMessage(params) {
 	const statusReactionsExplicitlyEnabled = cfg.messages?.statusReactions?.enabled === true;
 	const isRoomEvent = inboundEventKind === "room_event";
 	const shouldAckReaction$1 = () => Boolean(ackReaction && shouldAckReaction({
-		scope: ctx.ackReactionScope,
+		scope: cfg.messages?.ackReactionScope,
 		inboundEventKind,
 		isDirect: isDirectMessage,
 		isGroup: isRoomish,
@@ -4310,10 +4092,11 @@ async function prepareSlackMessage(params) {
 	const textWithId = `${bodyForAgent}\n[slack message id: ${message.ts} channel: ${message.channel}${threadInfo}]`;
 	const storePath = resolveStorePath(ctx.cfg.session?.store, { agentId: route.agentId });
 	const envelopeOptions = resolveEnvelopeFormatOptions(ctx.cfg);
-	const previousTimestamp = readSessionUpdatedAt({
+	const sessionEntry = getSessionEntry({
 		storePath,
 		sessionKey
 	});
+	const previousTimestamp = sessionEntry?.updatedAt;
 	if (opts.source === "app_mention" && !ctx.botUserId && message.ts) {
 		const pendingHistory = ctx.channelHistories.get(historyKey);
 		if (pendingHistory) ctx.channelHistories.set(historyKey, pendingHistory.filter((entry) => entry.messageId !== message.ts));
@@ -4479,6 +4262,10 @@ async function prepareSlackMessage(params) {
 			},
 			groupSystemPrompt
 		},
+		channelContext: { chat: {
+			commandSourceText,
+			mentionStripPatterns
+		} },
 		extra: {
 			GroupSubject: groupSessionSubject,
 			ChannelPromptContext: channelMetadata ? [channelMetadata] : void 0,
@@ -4497,15 +4284,14 @@ async function prepareSlackMessage(params) {
 			SlackAssistantThreadContextEnterpriseId: assistantThreadContext?.enterpriseId ?? void 0,
 			Transcript: preflightAudioTranscript,
 			IsFirstThreadTurn: isThreadReply && threadTs && !directThreadRoutedToDmSession && shouldSeedInitialThreadContext ? true : void 0,
-			...buildSlackMentionContextPayload({
-				isRoomish,
-				effectiveWasMentioned,
-				explicitlyMentioned,
-				mentionedUserIds,
-				mentionedSubteamIds,
-				matchedImplicitMentionKinds,
-				mentionSource
-			})
+			...isRoomish ? {
+				WasMentioned: effectiveWasMentioned,
+				ExplicitlyMentionedBot: explicitlyMentioned,
+				MentionedUserIds: mentionedUserIds.length > 0 ? [...mentionedUserIds] : void 0,
+				MentionedSubteamIds: mentionedSubteamIds.length > 0 ? [...mentionedSubteamIds] : void 0,
+				ImplicitMentionKinds: matchedImplicitMentionKinds.length > 0 ? [...matchedImplicitMentionKinds] : void 0,
+				MentionSource: mentionSource
+			} : {}
 		}
 	});
 	ctxPayload.ReplyToMode = replyToMode;
@@ -4547,6 +4333,7 @@ async function prepareSlackMessage(params) {
 		channelConfig,
 		replyTarget,
 		ctxPayload,
+		sessionDisplayName: sessionEntry?.displayName,
 		turn: {
 			storePath,
 			record: {