@openclaw/slack 2026.9.1-beta.1 → 2026.9.2

package/dist/{pipeline.runtime-CRRng_Nw.js → pipeline.runtime-BdIwZgm4.js}

@@ -1,225 +1,46 @@
-import { n as resolveSlackConversationBindingRoute, r as resolveSlackReplyToMode, t as normalizeSlackRouteBindingConfig } from "./conversation-binding-route-DFVLUdYF.js";
-import { n as formatSlackTarget } from "./target-parsing-BnMD2ZqZ.js";
-import { B as SLACK_TEXT_LIMIT, G as truncateSlackText, K as truncateSlackTextByUtf8Bytes, L as SLACK_EDIT_TEXT_MAX_BYTES, N as buildSlackBlocksFallbackText, O as hasSlackNativeDataBlock, S as resolveSlackReplyRenderPlan, W as countSlackTextUtf8Bytes, Z as SLACK_SESSION_LINK_ACTION_ID, a as qualifySlackConversationId, ct as escapeSlackMrkdwn, d as normalizeSlackAllowOwnerEntry, o as qualifySlackRoutePeerId, ot as normalizeSlackOutboundText, p as resolveSlackAllowListMatch, s as resolveSlackEnterpriseMainDmSessionKey, u as normalizeAllowListLower } from "./group-policy-CU1tEGpS.js";
-import { r as formatSlackError } from "./probe-4_aHtVT3.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, Nt as resolveSlackReplyToMode, Y as normalizeSlackOutboundText, at as escapeSlackMrkdwn, c as qualifySlackRoutePeerId, j as truncateSlackText, k as SLACK_TEXT_LIMIT, v as hasSlackNativeDataBlock } from "./session-status-BynwcZSO.js";
+import { n as formatSlackTarget } from "./target-parsing-PbxGDbr9.js";
+import { C as normalizeAllowListLower, E as resolveSlackAllowListMatch, o as formatSlackError, w as normalizeSlackAllowOwnerEntry } from "./probe-Biy--yhL.js";
+import { o as resolveSlackReplyRenderPlan } from "./reply-blocks-PRkhyAN7.js";
+import { n as resolveSlackReplyThreadTs } from "./thread-ts-CukseRVL.js";
 import { n as resolveSlackStreamingMode, t as resolveSlackNativeStreaming } from "./streaming-compat-B-e0mqM0.js";
-import { a as editSlackRenderedMessage, b as formatSlackFileReferenceList, d as reactSlackMessage, i as editSlackMessage, m as removeSlackReaction, n as deleteSlackMessage, v as logVerbose$1, x as buildSlackEditTextPayload, y as formatSlackFileReference } from "./actions-XdQyjG_p.js";
-import { a as hasSlackTableBlock, c as resolveSlackMessageText$1, o as isSlackUnfurlAttachment, s as resolveSlackBlocksText } from "./slack-client-kind-hSfjXyUM.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-DtjEnlLh.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-D4nDgxCh.js";
-import { n as resolveSlackChannelConfig } from "./policy-BoP6t88v.js";
-import { a as resolveDeliveredSlackReplyThreadTs, c as emitSlackMessageSentHooks, i as readSlackReplyBlocks, n as deliverReplies, o as resolveSlackThreadTs, s as sanitizeSlackMonitorReplyPayload, t as createSlackReplyDeliveryPlan } from "./replies-D9XMM_S0.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-CFkvEv1d.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-DElUcgIs.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-DoaUvAM4.js";
+import { n as resolveSlackChannelConfig } from "./policy-Bh5TOqII.js";
+import { a as resolveSlackThreadTs, i as readSlackReplyBlocks, n as deliverReplies, o as sanitizeSlackMonitorReplyPayload, s as emitSlackMessageSentHooks, t as createSlackReplyDeliveryPlan } from "./replies-DENuTcPO.js";
 import { asOptionalRecord, normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { resolveAgentRoute, resolveInboundLastRouteSessionKey, resolveThreadSessionKeys } from "openclaw/plugin-sdk/routing";
-import { buildChannelProgressDraftLine, buildChannelProgressDraftLineForEntry, createChannelMessageReplyPipeline, createChannelProgressDraftCompositor, createChannelProgressWorkCounter, createFinalizableDraftStreamControlsForState, defineFinalizableLivePreviewAdapter, deliverWithFinalizableLivePreviewAdapter, formatChannelProgressDraftText, formatPlanChecklistLines, 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, formatChannelProgressDraftText, formatPlanChecklistLines, isChannelProgressDraftWorkToolName, resolveAgentOutboundIdentity, resolveChannelMessageSourceReplyDeliveryMode, resolveChannelProgressDraftConfig, resolveChannelProgressDraftMaxLineChars, resolveChannelStreamingBlockEnabled, resolveChannelStreamingPreviewToolProgress, resolveChannelStreamingSuppressDefaultToolProgressMessages } from "openclaw/plugin-sdk/channel-outbound";
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 import { danger, logVerbose, shouldLogVerbose } from "openclaw/plugin-sdk/runtime-env";
 import { sanitizeAssistantVisibleText } from "openclaw/plugin-sdk/text-chunking";
+import { resolveMarkdownTableMode } from "openclaw/plugin-sdk/markdown-table-runtime";
+import { buildTtsSupplementMediaPayload, getReplyPayloadTtsSupplement, isReplyPayloadNonTerminalToolErrorWarning, resolveSendableOutboundReplyParts } from "openclaw/plugin-sdk/reply-payload";
 import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import { createHash } from "node:crypto";
 import { pruneMapToMaxSize } from "openclaw/plugin-sdk/collection-runtime";
 import { ensureConfiguredBindingRouteReady } from "openclaw/plugin-sdk/conversation-runtime";
+import { resolveChannelImplicitMentions } from "openclaw/plugin-sdk/channel-ingress-runtime";
 import fs from "node:fs/promises";
 import { runTasksWithConcurrency } from "openclaw/plugin-sdk/concurrency-runtime";
 import { formatErrorMessage, toErrorObject } from "openclaw/plugin-sdk/error-runtime";
-import { buildTtsSupplementMediaPayload, getReplyPayloadTtsSupplement, isReplyPayloadNonTerminalToolErrorWarning, resolveSendableOutboundReplyParts } from "openclaw/plugin-sdk/reply-payload";
 import { filterSupplementalContextItems, resolvePinnedMainDmOwnerFromAllowlist, shouldIncludeSupplementalContext } from "openclaw/plugin-sdk/security-runtime";
 import { mimeTypeFromFilePath } from "openclaw/plugin-sdk/media-mime";
 import { createChannelHistoryWindow } from "openclaw/plugin-sdk/reply-history";
 import { mergePairLoopGuardConfig } from "openclaw/plugin-sdk/pair-loop-guard-runtime";
-import { enqueueRoutedSystemEvent } from "openclaw/plugin-sdk/system-event-runtime";
-import { resolveChannelImplicitMentions } from "openclaw/plugin-sdk/channel-ingress-runtime";
 import { asDateTimestampMs, asFiniteNumberInRange, parseStrictFiniteNumber, resolveExpiresAtMsFromDurationMs } from "openclaw/plugin-sdk/number-runtime";
-import { getGlobalHookRunner } from "openclaw/plugin-sdk/plugin-runtime";
-import { buildChannelInboundEventContext, buildMentionRegexes, classifyChannelInboundEvent, dispatchChannelInboundTurn, formatInboundEnvelope, formatInboundMediaUnavailableText, hasVisibleInboundReplyDispatch, implicitMentionKindWhen, logInboundDrop, matchesMentionWithExplicit, readAgentRunTerminalOutcome, recordDroppedChannelInboundHistory, resolveEnvelopeFormatOptions, resolveInboundMentionDecision, resolveInboundReplyDispatchCounts, resolveInboundSupplementalSenderAllowed, resolveUnmentionedGroupInboundPolicy, toInboundMediaFactsWithMetadata } from "openclaw/plugin-sdk/channel-inbound";
 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 { resolveGatewayPublicOrigin } from "openclaw/plugin-sdk/config-contracts";
 import { buildControlUiSessionPath } from "openclaw/plugin-sdk/session-discussion";
-import { DEFAULT_TIMING, createStatusReactionController, logAckFailure, logTypingFailure, resolveAckReaction, shouldAckReaction } from "openclaw/plugin-sdk/channel-feedback";
+import { createStatusReactionController, logAckFailure, logTypingFailure, resolveAckReaction, shouldAckReaction } from "openclaw/plugin-sdk/channel-feedback";
 import { hasControlCommand } from "openclaw/plugin-sdk/command-detection";
 import { isAbortRequestText } from "openclaw/plugin-sdk/command-primitives-runtime";
 import { shouldHandleTextCommands } from "openclaw/plugin-sdk/command-surface";
 import { 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?.length ? { chunks } : {}
-			});
-			if (result) {
-				session.delivered = true;
-				session.pendingText = "";
-			}
-			logVerbose(`slack-stream: appended initial payload (${text?.length ?? 0} chars, ${chunks?.length ?? 0} chunks, ${result ? "flushed" : "buffered"})`);
-		} catch (err) {
-			if (isBenignSlackFinalizeError(err) && session.pendingText) throw new SlackStreamNotDeliveredError(session.pendingText, extractSlackErrorCode(err) ?? "unknown");
-			throw err;
-		}
-	}
-	return session;
-}
-/**
-* Append markdown text to an active Slack stream.
-*/
-async function appendSlackStream(params) {
-	const { session, text, chunks } = params;
-	if (session.stopped) {
-		logVerbose("slack-stream: attempted to append to a stopped stream, ignoring");
-		return;
-	}
-	if (!text && !chunks?.length) return;
-	if (text) session.pendingText += text;
-	try {
-		const result = await session.streamer.append({
-			...text ? { markdown_text: text } : {},
-			...chunks?.length ? { chunks } : {}
-		});
-		if (result) {
-			session.delivered = true;
-			session.pendingText = "";
-		}
-		logVerbose(`slack-stream: appended ${text?.length ?? 0} chars, ${chunks?.length ?? 0} chunks (${result ? "flushed" : "buffered"})`);
-	} catch (err) {
-		if (isBenignSlackFinalizeError(err) && session.pendingText) throw new SlackStreamNotDeliveredError(session.pendingText, extractSlackErrorCode(err) ?? "unknown");
-		throw err;
-	}
-}
-/**
-* Stop (finalize) a Slack stream.
-*
-* After calling this the stream message becomes a normal Slack message.
-* Optionally include final 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;
@@ -269,7 +90,8 @@ function resolveExplicitSlackProgressTitle(entry) {
 	return trimmed && trimmed.toLowerCase() !== "auto" ? trimmed : void 0;
 }
 function resolveSlackProgressStyle(entry) {
-	return entry?.streaming?.progress?.style === "compact" ? "compact" : "card";
+	const progress = entry?.streaming?.progress;
+	return progress?.style ?? (progress?.toolProgress === false ? "compact" : "card");
 }
 function resolveSlackNativeProgressTaskCards(entry) {
 	if (resolveSlackProgressStyle(entry) === "compact") return false;
@@ -479,6 +301,7 @@ function createSlackDraftStream(params) {
 	};
 	const { loop, update, discardPending, seal } = createFinalizableDraftStreamControlsForState({
 		throttleMs,
+		coalesceInFlight: true,
 		state: streamState,
 		sendOrEditStreamMessage,
 		emptyValue: "",
@@ -630,6 +453,7 @@ 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",
@@ -661,23 +485,23 @@ function compactTitle(value) {
 function compactChunkText(value) {
 	return truncateSlackText(value.replace(/\s+/g, " ").trim(), SLACK_PROGRESS_CHUNK_TEXT_MAX);
 }
+function renderProgressCardText(text, enclosingStyle) {
+	return normalizeSlackOutboundText(text, {
+		mentions: "escape",
+		enclosingStyle
+	});
+}
 function lineDetailParts(line) {
 	return [line.detail, line.status && line.status !== "completed" && !line.detail?.includes(line.status) ? line.status : void 0].map((part) => part?.trim()).filter((part) => Boolean(part));
 }
-function legacyLineTitle(line) {
-	return `${line.icon ?? "•"} *${escapeSlackMrkdwn(line.label)}*`;
-}
-function isAuthoredProgressLine(line) {
-	return line.id === "reasoning" || line.id?.startsWith("commentary:") === true;
-}
-function legacyLineDetail(line, maxChars) {
+function activityLineDetail(line, maxChars) {
 	const detail = lineDetailParts(line).join(" · ");
 	if (detail) return escapeSlackMrkdwn(compactDetail(detail, maxChars));
-	if (isAuthoredProgressLine(line)) return normalizeSlackOutboundText(compactDetail(line.text.replace(/^(?:🧠|💬)\s+/u, ""), maxChars));
-	return "—";
+	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.kind === "command-output" ? line.toolName : void 0) || line.label.replace(/\s+/g, " ").trim() || line.toolName || line.kind || "Update";
+	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);
@@ -696,102 +520,109 @@ function lineTaskStatus(line) {
 	const normalized = line.status?.replace(/\s+/g, " ").trim().toLowerCase();
 	if (!normalized) return "in_progress";
 	if (normalized === "complete" || normalized === "completed" || normalized === "done" || normalized === "ok" || normalized === "success" || normalized === "succeeded" || normalized === "successful" || normalized === "exit 0") return "complete";
-	if (normalized === "error" || normalized === "failed" || normalized === "failure" || normalized.startsWith("exit ")) return normalized === "exit 0" ? "complete" : "error";
+	if (normalized === "error" || normalized === "failed" || normalized === "failure" || normalized.startsWith("exit ")) return "error";
 	return "in_progress";
 }
-function slugTaskIdPart(value) {
-	return value?.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "") || "task";
-}
 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 `${slugTaskIdPart(slugValue).slice(0, 48)}_${suffix}`;
-}
-function resolveLineTaskIdentity(line) {
-	if (line.id?.trim()) return {
-		id: stableTaskIdPart(line.id),
-		contentDerived: false
-	};
-	return {
-		id: stableTaskIdPart([
-			line.kind,
-			line.toolName,
-			line.label,
-			line.text
-		].join("\0"), line.toolName ?? line.kind ?? line.label),
-		contentDerived: true
-	};
-}
-function buildPlanTasks(params) {
-	if (params.plan) return params.plan.slice(-50).map((entry, index) => ({
+	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 lines = params.lines.slice(-50);
-	const identities = lines.map(resolveLineTaskIdentity);
 	const contentIdOccurrences = /* @__PURE__ */ new Map();
-	return lines.map((line, index) => {
-		const identity = identities[index];
-		let id = identity.id;
-		if (identity.contentDerived) {
-			const occurrence = (contentIdOccurrences.get(id) ?? 0) + 1;
-			contentIdOccurrences.set(id, occurrence);
-			id = `${id}_${occurrence}`;
-		}
-		const details = lineTaskDetails(line, maxLineChars);
-		const output = lineTaskOutput(line);
+	for (const line of params.lines) {
 		const task = {
-			id,
+			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;
-		return task;
+		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 resolvePlanTitle(params) {
-	return compactChunkText(params.title?.trim() || params.label?.trim() || (params.tasks.at(-1)?.details ? `${params.tasks.at(-1)?.title} — ${params.tasks.at(-1)?.details}` : params.tasks.at(-1)?.title) || SLACK_PROGRESS_PLAN_FALLBACK_TITLE);
+function formatDiffStat(diffStat) {
+	if (!diffStat || diffStat.files === 0 && diffStat.added === 0 && diffStat.removed === 0) return;
+	return [
+		`📝 ${diffStat.files} files`,
+		...diffStat.added > 0 ? [`+${diffStat.added}`] : [],
+		...diffStat.removed > 0 ? [`−${diffStat.removed}`] : []
+	].join(" ");
+}
+function formatTaskDiffOutput(diffStat) {
+	return diffStat && (diffStat.added > 0 || diffStat.removed > 0) ? `+${diffStat.added} −${diffStat.removed}` : void 0;
 }
 function buildSlackProgressStreamChunks(params) {
-	const tasks = buildPlanTasks({
-		lines: params.lines,
+	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
 	});
-	if (tasks.length === 0) {
-		const title = params.title?.trim() || params.label?.trim();
-		if (!title) return;
-		if (!params.sessionUrl && !params.diffStat) return [{
-			type: "plan_update",
-			title: compactChunkText(title)
-		}];
-		return [{
-			type: "plan_update",
-			title: compactChunkText(title)
-		}, {
-			type: "task_update",
-			id: "openclaw_summary",
-			title: "Completed",
-			status: "complete",
-			...formatTaskDiffOutput(params.diffStat) ? { output: formatTaskDiffOutput(params.diffStat) } : {},
-			...params.sessionUrl ? { sources: buildSessionSources(params.sessionUrl) } : {}
-		}];
-	}
-	const title = resolvePlanTitle({
-		label: params.label,
-		title: params.title,
-		tasks
+	const 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: 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: "Failed",
+		status: "error"
 	});
+	if (!headline && tasks.length === 0) return;
 	const finalTaskIndex = tasks.length - 1;
-	const diffOutput = formatTaskDiffOutput(params.diffStat);
 	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 ?? (params.completeInProgress ? "complete" : 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;
@@ -804,22 +635,10 @@ function buildSlackProgressStreamChunks(params) {
 		title
 	}, ...taskChunks];
 }
-function formatDiffStat(diffStat) {
-	if (!diffStat || diffStat.files === 0 && diffStat.added === 0 && diffStat.removed === 0) return;
-	return [
-		`📝 ${diffStat.files} files`,
-		...diffStat.added > 0 ? [`+${diffStat.added}`] : [],
-		...diffStat.removed > 0 ? [`−${diffStat.removed}`] : []
-	].join(" ");
-}
-function formatTaskDiffOutput(diffStat) {
-	return diffStat && (diffStat.added > 0 || diffStat.removed > 0) ? `+${diffStat.added} −${diffStat.removed}` : void 0;
-}
-function buildActivityText(lines, maxLineChars) {
+function joinRecentProgressRows(rows) {
 	const rendered = [];
 	let length = 0;
-	for (const line of lines.slice(-50).toReversed()) {
-		const row = `${legacyLineTitle(line)} — ${legacyLineDetail(line, maxLineChars)}`;
+	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);
@@ -827,6 +646,11 @@ function buildActivityText(lines, maxLineChars) {
 	}
 	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 planLines = formatPlanChecklistLines(params.plan ?? [], {
@@ -834,7 +658,6 @@ function buildSlackProgressCardBlocks(params) {
 		maxLineChars
 	});
 	const narration = params.narration?.replace(/\s+/g, " ").trim();
-	const activityText = buildActivityText(params.lines, maxLineChars);
 	const diffStat = formatDiffStat(params.diffStat);
 	const workingFooter = [
 		...params.toolCalls && params.toolCalls > 0 ? [`🛠️ ${params.toolCalls} tools`] : [],
@@ -842,40 +665,36 @@ function buildSlackProgressCardBlocks(params) {
 		...params.elapsedSeconds && params.elapsedSeconds > 0 ? [`⏱ ${params.elapsedSeconds}s`] : []
 	].join(" · ");
 	const footer = params.state === "working" ? workingFooter : diffStat;
-	return [
-		{
-			type: "section",
-			text: field(`${params.state === "working" ? "🔄" : params.state === "success" ? "✅" : "❌"} *${escapeSlackMrkdwn(params.title.trim() || "Working")}*`)
-		},
-		...narration ? [{
-			type: "section",
-			text: field(`_${escapeSlackMrkdwn(narration)}_`)
-		}] : [],
-		...planLines.length > 0 ? [{
-			type: "section",
-			text: field(planLines.map((line) => escapeSlackMrkdwn(line)).join("\n"))
-		}] : [],
-		...activityText ? [{
-			type: "section",
-			text: field(activityText)
-		}] : [],
-		...footer ? [{
-			type: "context",
-			elements: [field(footer)]
-		}] : [],
-		...params.state !== "working" && params.sessionUrl ? [{
-			type: "actions",
-			elements: [{
-				type: "button",
-				action_id: SLACK_SESSION_LINK_ACTION_ID,
-				text: {
-					type: "plain_text",
-					text: "Open in OpenClaw"
-				},
-				url: params.sessionUrl
-			}]
-		}] : []
-	].slice(0, 50);
+	const 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 = [
+		`${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: field(text)
+	}));
+	if (footer) blocks.push({
+		type: "context",
+		elements: [field(footer)]
+	});
+	if (params.state !== "working" && params.sessionUrl) blocks.push({
+		type: "actions",
+		elements: [{
+			type: "button",
+			action_id: SLACK_SESSION_LINK_ACTION_ID,
+			text: {
+				type: "plain_text",
+				text: "Open in OpenClaw"
+			},
+			url: params.sessionUrl
+		}]
+	});
+	return blocks.slice(0, 50);
 }
 const EMPTY_SLACK_NATIVE_STREAM_SNAPSHOT = { tasks: /* @__PURE__ */ new Map() };
 const SLACK_TASK_FIELD_SEPARATOR = " · ";
@@ -930,24 +749,23 @@ 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 || Boolean(details.delta) || Boolean(output.delta) || 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;
@@ -956,18 +774,21 @@ function reconcileSlackNativeTaskChunks(params) {
 	}
 	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"
 		});
 	}
@@ -979,12 +800,6 @@ function reconcileSlackNativeTaskChunks(params) {
 		}
 	};
 }
-function buildSlackProgressStreamCompletionChunks(params) {
-	return buildSlackProgressStreamChunks({
-		...params,
-		completeInProgress: true
-	});
-}
 //#endregion
 //#region extensions/slack/src/monitor/message-handler/dispatch-progress-render.ts
 function resolveStructuredProgressLines(lines) {
@@ -1001,9 +816,6 @@ function resolveStructuredProgressLines(lines) {
 		};
 	});
 }
-function resolveNativeProgressPlan(snapshot) {
-	return snapshot.plan?.length ? snapshot.plan : void 0;
-}
 function resolveNativeProgressLines(snapshot) {
 	const lines = resolveStructuredProgressLines(snapshot.lines).filter((line) => line.id !== "reasoning" && line.id?.startsWith("commentary:") !== true);
 	if (snapshot.plan?.length || !snapshot.planExplanation) return lines;
@@ -1021,14 +833,6 @@ function resolveNativeProgressNarration(snapshot) {
 function combineProgressHeadlineAndExplanation(headline, explanation) {
 	return headline && explanation && headline !== explanation ? `${headline} — ${explanation}` : headline ?? explanation;
 }
-function buildNativeProgressChunks(params) {
-	return buildSlackProgressStreamChunks({
-		title: params.title,
-		lines: resolveNativeProgressLines(params.snapshot),
-		plan: resolveNativeProgressPlan(params.snapshot),
-		maxLineChars: params.maxLineChars
-	});
-}
 //#endregion
 //#region extensions/slack/src/monitor/message-handler/preview-finalize.ts
 function buildExpectedSlackEditText(params) {
@@ -1066,7 +870,8 @@ function blocksMatch(expected, actual) {
 		const fallbackBlocks = fallbackPlan.fallbackMessages.flatMap((message) => message.blocks ?? []);
 		if (JSON.stringify(fallbackBlocks) === JSON.stringify(actual)) return true;
 		const fallbackText = fallbackPlan.fallbackMessages.map((message) => message.text).filter(Boolean).join("\n\n");
-		return normalizeSlackOutboundText(buildSlackBlocksFallbackText(actual)) === normalizeSlackOutboundText(fallbackText);
+		const actualText = buildSlackBlocksFallbackText(actual);
+		return normalizeSlackOutboundText(actualText) === normalizeSlackOutboundText(fallbackText);
 	} catch {
 		return false;
 	}
@@ -1166,18 +971,20 @@ function createSlackDraftProgressCardRuntime(params) {
 	});
 	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,
 			diffStat: snapshot.diffStat,
-			...state === "working" ? {
-				toolCalls: params.progressWorkCounter.toolCalls,
-				elapsedSeconds: params.progressWorkCounter.elapsedSeconds
-			} : { sessionUrl: resolveSessionUrl() }
+			toolCalls: workCounter?.toolCalls,
+			elapsedSeconds: workCounter?.elapsedSeconds,
+			sessionUrl
 		});
 	};
 	const finalize = async (status, snapshot = params.getSnapshot(), fallbackText = resolveText(snapshot)) => {
@@ -1231,10 +1038,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
@@ -1271,6 +1078,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 } : {},
@@ -1341,7 +1149,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,
@@ -1379,7 +1187,7 @@ function createSlackProgressRuntime(runtimeParams) {
 		},
 		draftStream,
 		enabled: useDraftProgressCard,
-		progressWorkCounter,
+		progressWorkCounter: previewToolProgressEnabled ? progressWorkCounter : void 0,
 		progressSeed,
 		explicitTitle: explicitProgressTitle,
 		maxLineChars: progressDraftMaxLineChars,
@@ -1399,12 +1207,17 @@ function createSlackProgressRuntime(runtimeParams) {
 		if (isError) nativeProgressTerminalStatus = "error";
 		if (!session || nativeProgressCompletionSent) return;
 		const chunks = buildNativeProgressCompletionChunks(isError ? "error" : "complete");
-		if (!chunks?.length) return;
+		const narrationUpdate = resolveNarrationUpdate(resolveNativeProgressNarration(progressDraft.getSnapshot()));
+		if (!chunks?.length && !narrationUpdate.delta) return;
 		try {
 			await appendSlackStream({
 				session,
 				chunks
 			});
+			if (narrationUpdate.next.changed) {
+				nativeNarrationRenderedText = narrationUpdate.next.rendered;
+				nativeNarrationSourceText = narrationUpdate.next.source;
+			}
 			nativeProgressCompletionSent = true;
 			delivery.observedReplyDelivery ||= session.delivered;
 		} catch (err) {
@@ -1413,11 +1226,6 @@ function createSlackProgressRuntime(runtimeParams) {
 		}
 	};
 	const resolveNativeProgressTitle = (snapshot) => combineProgressHeadlineAndExplanation(explicitProgressTitle ?? snapshot.statusHeadline, snapshot.planExplanation);
-	const buildNativeProgressChunks$1 = (snapshot) => buildNativeProgressChunks({
-		snapshot,
-		title: resolveNativeProgressTitle(snapshot),
-		maxLineChars: progressDraftMaxLineChars
-	});
 	const normalizeProgressText = (text) => text?.replace(/\s+/gu, " ").trim() ?? "";
 	const isRenderedAsProgressTitle = (text) => {
 		const candidate = normalizeProgressText(text);
@@ -1436,17 +1244,20 @@ function createSlackProgressRuntime(runtimeParams) {
 			delta: next.changed ? next.rendered.slice(nativeNarrationRenderedText.length) : ""
 		};
 	};
-	const updateNativeProgressStream = () => withNativeStreamOrder(updateNativeProgressStreamNow);
 	const updateNativeProgressStreamNow = async () => {
 		const snapshot = progressDraft.getSnapshot();
-		const progressLines = resolveNativeProgressLines(snapshot);
 		const narrationUpdate = resolveNarrationUpdate(resolveNativeProgressNarration(snapshot));
-		const hasRetirableNativeTasks = [...nativeStreamSnapshot.tasks.values()].some((task) => task.status !== "complete" && task.status !== "error");
-		if (!useNativeProgressStreaming || delivery.streamFailed || progressLines.length === 0 && !snapshot.plan?.length && !snapshot.statusHeadline && !explicitProgressTitle && !hasRetirableNativeTasks && !narrationUpdate.delta) return false;
+		if (!useNativeProgressStreaming || delivery.streamFailed || nativeUpdatesStopped) return false;
 		if (!await nativeTransport.waitForStart()) return false;
 		const reconciled = reconcileSlackNativeTaskChunks({
 			previous: nativeStreamSnapshot,
-			chunks: buildNativeProgressChunks$1(snapshot)
+			chunks: buildSlackProgressStreamChunks({
+				title: resolveNativeProgressTitle(snapshot),
+				lines: resolveNativeProgressLines(snapshot),
+				plan: snapshot.plan,
+				maxLineChars: progressDraftMaxLineChars,
+				summaryRow: !previewToolProgressEnabled
+			})
 		});
 		const chunks = reconciled.chunks;
 		if (!chunks?.length && !narrationUpdate.delta) return false;
@@ -1470,6 +1281,21 @@ function createSlackProgressRuntime(runtimeParams) {
 			return false;
 		}
 	};
+	let nativeUpdatesStopped = false;
+	const nativeUpdates = createDraftStreamLoop({
+		throttleMs: 1e3,
+		coalesceInFlight: true,
+		emptyValue: false,
+		isEmpty: (pending) => !pending,
+		isStopped: () => nativeUpdatesStopped,
+		sendOrEditStreamMessage: () => withNativeStreamOrder(updateNativeProgressStreamNow),
+		onBackgroundFlushError: (err) => runtime.error?.(danger(`slack-stream: progress update failed: ${formatSlackError(err)}`))
+	});
+	const cancelNativeUpdates = async () => {
+		nativeUpdatesStopped = true;
+		nativeUpdates.stop();
+		await nativeUpdates.waitForInFlight();
+	};
 	const appendNativeNarration = (payload, kind) => withNativeStreamOrder(() => appendNativeNarrationNow(payload, kind));
 	const appendNativeNarrationNow = async (payload, kind) => {
 		if (isRenderedAsProgressTitle(payload.text)) return false;
@@ -1500,13 +1326,16 @@ function createSlackProgressRuntime(runtimeParams) {
 		seed: progressSeed,
 		formatLine: formatSlackProgressDraftLine,
 		reasoningLinePrefix: "🧠 ",
-		commentaryLinePrefix: "",
-		reasoningGate: previewToolProgressEnabled,
-		commentaryItalics: true,
-		buildProgressEventLine: (input, options) => input.event === "tool" || input.event === "item" || input.event === "command-output" ? buildChannelProgressDraftLineForEntry(account.config, input, options) : buildChannelProgressDraftLine(input, options),
 		updateOnLineChange: useNativeProgressStreaming || useDraftProgressCard,
 		update: async (previewText, options) => {
-			if (useNativeProgressStreaming) return await updateNativeProgressStream();
+			if (useNativeProgressStreaming) {
+				const priorSnapshot = nativeStreamSnapshot;
+				const priorNarration = nativeNarrationRenderedText;
+				nativeUpdates.update(true);
+				if (options?.flush) await nativeUpdates.flush();
+				else await nativeUpdates.waitForInFlight();
+				return priorSnapshot !== nativeStreamSnapshot || priorNarration !== nativeNarrationRenderedText;
+			}
 			if (!draftStream) return false;
 			const snapshot = progressDraft.getSnapshot();
 			progressCard.setFallbackText(previewText);
@@ -1519,7 +1348,11 @@ function createSlackProgressRuntime(runtimeParams) {
 		}
 	});
 	const commentaryProgressEnabled = progressDraft.commentaryProgressEnabled;
-	const deliverNativeFinal = (payload, kind) => withNativeStreamOrder(() => deliverNativeFinalNow(payload, kind));
+	const deliverNativeFinal = async (payload, kind) => {
+		progressDraft.markFinalReplyStarted();
+		await cancelNativeUpdates();
+		await withNativeStreamOrder(() => deliverNativeFinalNow(payload, kind));
+	};
 	const deliverNativeFinalNow = async (payload, kind) => {
 		progressDraft.markFinalReplyStarted();
 		const streamReady = await nativeTransport.waitForStart();
@@ -1544,38 +1377,32 @@ function createSlackProgressRuntime(runtimeParams) {
 		const snapshot = progressDraft.getSnapshot();
 		const lines = resolveNativeProgressLines(snapshot);
 		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 && !snapshot.diffStat && !sessionUrl) return;
-		return reconcileSlackNativeTaskChunks({
+		if (lines.length === 0 && !snapshot.plan?.length && !hasRetirableNativeTasks && !snapshot.diffStat && !narrationUpdate.delta && !sessionUrl) return;
+		const completion = reconcileSlackNativeTaskChunks({
 			previous: nativeStreamSnapshot,
-			chunks: buildSlackProgressStreamCompletionChunks({
+			finalStatus: finalInProgressStatus,
+			chunks: buildSlackProgressStreamChunks({
 				title: resolveNativeProgressTitle(snapshot) ?? (lines.length === 0 && !snapshot.plan?.length ? "Working" : void 0),
 				lines,
-				plan: resolveNativeProgressPlan(snapshot),
+				plan: snapshot.plan,
 				maxLineChars: progressDraftMaxLineChars,
+				summaryRow: !previewToolProgressEnabled,
 				finalInProgressStatus,
 				diffStat: snapshot.diffStat,
 				sessionUrl
 			})
 		}).chunks;
+		return narrationUpdate.delta ? [{
+			type: "markdown_text",
+			text: narrationUpdate.delta
+		}, ...completion ?? []] : completion;
 	};
 	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;
@@ -1660,6 +1487,10 @@ function createSlackProgressRuntime(runtimeParams) {
 		progressDraft.reset();
 	};
 	const beginNewProgressTurn = async (options) => {
+		if (useNativeProgressStreaming) {
+			if (!nativeUpdatesStopped && options?.force !== true) return false;
+			await cancelNativeUpdates();
+		}
 		const priorSnapshot = progressDraft.getSnapshot();
 		const priorFallbackText = progressCard.resolveText(priorSnapshot);
 		const completionChunks = useNativeProgressStreaming && !nativeProgressCompletionSent ? buildNativeProgressCompletionChunks(nativeProgressTerminalStatus) : void 0;
@@ -1674,6 +1505,8 @@ function createSlackProgressRuntime(runtimeParams) {
 		nativeStreamSnapshot = EMPTY_SLACK_NATIVE_STREAM_SNAPSHOT;
 		nativeProgressCompletionSent = false;
 		nativeProgressTerminalStatus = "complete";
+		nativeUpdatesStopped = false;
+		nativeUpdates.resetThrottleWindow();
 		progressCard.reset();
 		resetPreviewDeliveryState();
 		delivery.resetDeliveryTracker();
@@ -1697,7 +1530,14 @@ function createSlackProgressRuntime(runtimeParams) {
 		resetDraftDeliveryState();
 		resetDraftProgressState();
 	};
-	const onQueuedFollowupSettled = !useDraftProgressCard ? void 0 : async () => {
+	const onQueuedFollowupSettled = !useDraftProgressCard && !useNativeProgressStreaming ? void 0 : async () => {
+		if (useNativeProgressStreaming) {
+			progressDraft.markFinalReplyStarted();
+			await cancelNativeUpdates();
+			await finishNativeProgressTurn(nativeProgressCompletionSent ? void 0 : buildNativeProgressCompletionChunks(nativeProgressTerminalStatus));
+			progressDraft.markFinalReplyDelivered();
+			return;
+		}
 		if (!progressCard.hasTerminalized) await draftStream?.clear();
 		await dropDetachedProgressCards();
 	};
@@ -1710,8 +1550,12 @@ function createSlackProgressRuntime(runtimeParams) {
 		previewToolProgressEnabled,
 		suppressDefaultToolProgressMessages,
 		progressDraft,
-		commentaryProgressEnabled,
 		progressWorkCounter,
+		commentaryProgressEnabled,
+		async cancel() {
+			progressDraft.cancel();
+			await cancelNativeUpdates();
+		},
 		get nativeProgressCompletionSent() {
 			return nativeProgressCompletionSent;
 		},
@@ -1743,6 +1587,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;
@@ -1816,24 +1664,17 @@ async function createSlackDispatchSetup(prepared) {
 				await reactSlackMessage(message.channel, reactionMessageTs ?? "", emoji, {
 					token: ctx.botToken,
 					client: slackClient
-				}).catch((err) => {
-					if (formatErrorMessage(err).includes("already_reacted")) return;
-					throw err;
 				});
 			},
 			removeReaction: async (emoji) => {
 				await removeSlackReaction(message.channel, reactionMessageTs ?? "", emoji, {
 					token: ctx.botToken,
 					client: slackClient
-				}).catch((err) => {
-					if (formatErrorMessage(err).includes("no_reaction")) return;
-					throw err;
 				});
 			}
 		},
 		initialEmoji: prepared.ackReactionValue || "eyes",
-		emojis: void 0,
-		timing: DEFAULT_TIMING,
+		presentation: "acknowledgement",
 		onError: (err) => {
 			logAckFailure({
 				log: logVerbose,
@@ -1863,12 +1704,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
 					});
 				}
@@ -1885,10 +1727,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
 					});
 				}
@@ -1943,15 +1785,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,
@@ -1959,6 +1792,7 @@ async function createSlackDispatchSetup(prepared) {
 		message,
 		route,
 		slackClient,
+		slackClientOptions,
 		slackStreamFallbackTeamId,
 		cfg,
 		runtime,
@@ -1988,15 +1822,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,
@@ -2007,69 +1844,14 @@ 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) => {
@@ -2090,62 +1872,75 @@ 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: [{ 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({
@@ -2174,10 +1969,11 @@ function createSlackStreamingDeliveryRuntime(setup) {
 		});
 		state.observedReplyDelivery = true;
 		if (params.kind === "final") state.observedFinalReplyDelivery = true;
-		const deliveredThreadTs = resolveDeliveredSlackReplyThreadTs({
+		const deliveredThreadTs = resolveSlackReplyThreadTs({
 			replyToMode: replyDeliveryMode,
-			payloadReplyToId: params.payload.replyToId,
-			replyThreadTs: deliveryReplyThreadTs
+			replyToId: params.payload.replyToId,
+			threadId: deliveryReplyThreadTs,
+			replyToCurrent: params.payload.replyToCurrent
 		});
 		rememberDeliveredThreadTs(params.kind, deliveredThreadTs);
 		replyPlan.markSent();
@@ -2188,19 +1984,6 @@ function createSlackStreamingDeliveryRuntime(setup) {
 		});
 		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);
@@ -2208,7 +1991,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,
@@ -2217,45 +2000,44 @@ function createSlackStreamingDeliveryRuntime(setup) {
 			});
 			return;
 		}
-		const text = params.streamText ?? reply.trimmedText;
-		const hookContent = reply.trimmedText;
-		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;
+		if (deliveryTracker.hasDelivered({
+			...params,
+			threadTs,
+			textOverride: text
+		})) {
+			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: [],
 					...params.taskDisplayMode ? { taskDisplayMode: params.taskDisplayMode } : {},
 					...slackIdentity ? { identity: slackIdentity } : {},
 					teamId: await resolveSlackStreamRecipientTeamId({
@@ -2266,94 +2048,63 @@ 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;
+				state.streamSession = session;
 			}
-			if (deliveryTracker.hasDelivered({
-				kind: params.kind,
-				payload: params.payload,
-				threadTs: state.streamSession.threadTs,
-				textOverride: text
-			})) {
-				logVerbose("slack-stream: suppressed duplicate append payload");
-				return;
-			}
-			if (hookContent) recordStreamedDelivery(params.kind, hookContent);
-			await appendSlackStream({
-				session: state.streamSession,
-				text: `${params.appendSeparator === false ? "" : "\n"}${text}`
-			});
-			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({
+			...params,
+			threadTs,
+			textOverride: text
+		});
+		emitStreamedDelivery(hookContent, {
+			success: true,
+			...messageId ? { messageId } : {}
+		});
 	};
 	return Object.assign(state, {
-		acknowledgeStoppedStreamedDeliveries,
 		deliverNormally,
-		deliverPendingStreamFallback,
 		deliverWithStreaming,
-		emitAcknowledgedStreamedDeliveries,
-		emitFailedPendingStreamedDeliveries,
+		finishStream,
 		hasDelivered: (params) => deliveryTracker.hasDelivered(params),
 		isStreamingEligible,
 		markPreviewPayloadDelivered,
@@ -2367,7 +2118,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({
@@ -2408,6 +2187,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) {
@@ -2415,6 +2202,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,
@@ -2459,7 +2264,11 @@ async function dispatchPreparedSlackMessage(prepared) {
 		const slackBlocks = replyRenderPlan.mode === "single" ? replyRenderPlan.blocks : replyRenderPlan.blockPart?.blocks;
 		const requiresSeparateFallbackDelivery = replyRenderPlan.mode === "split";
 		const trimmedFinalText = replyRenderPlan.mode === "single" ? replyRenderPlan.text.trim() : replyRenderPlan.fallbackText.trim();
-		const previewFinalText = replyRenderPlan.mode === "single" && replyRenderPlan.textIsSlackMrkdwn ? trimmedFinalText : normalizeSlackOutboundText((replySourceText ?? "").trim());
+		const previewFinalText = replyRenderPlan.mode === "single" && replyRenderPlan.textIsSlackMrkdwn ? trimmedFinalText : normalizeSlackOutboundText((replySourceText ?? "").trim(), { tableMode: resolveMarkdownTableMode({
+			cfg,
+			channel: "slack",
+			accountId: account.accountId
+		}) });
 		const previewFinalTextFitsEdit = countSlackTextUtf8Bytes(previewFinalText) <= SLACK_EDIT_TEXT_MAX_BYTES;
 		const shouldRestoreTtsSupplementTextForPreviewFallback = Boolean(ttsSupplement) && ttsSupplement?.visibleTextAlreadyDelivered !== true && Boolean(draftStream) && !draftPreviewCommitted.value && !delivery.observedFinalReplyDelivery && previewStreamingEnabled && !payload.text?.trim();
 		let ttsPreviewFinalization;
@@ -2562,7 +2371,6 @@ async function dispatchPreparedSlackMessage(prepared) {
 		});
 		if (info.kind === "final") progress.progressDraft.markFinalReplyDelivered();
 	};
-	let dispatchError;
 	let agentRunFailed = false;
 	let settledDispatchResult;
 	try {
@@ -2586,13 +2394,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,
@@ -2622,18 +2435,18 @@ 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) => {
+					if (payload.kind === "preamble" && (payload.phase === "start" || payload.phase === "update") && !draftStream?.messageId() && !delivery.streamSession?.delivered) return false;
 					if (progress.isProgressMode && payload.kind === "preamble") {
 						if (progress.shouldYieldDraftProgress()) return false;
 						const headlineVisible = await progress.progressDraft.pushPreambleHeadline(payload.progressText, { itemId: payload.itemId });
@@ -2670,48 +2483,28 @@ async function dispatchPreparedSlackMessage(prepared) {
 			});
 		}
 	} catch (err) {
-		dispatchError = err;
+		dispatchError ??= err;
 	} finally {
-		progress.progressDraft.cancel();
+		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();
-	if (statusReactionsEnabled) if (dispatchError || agentRunFailed) {
-		await statusReactions.setError();
-		statusReactions.restoreInitial();
-	} else if (anyReplyDelivered) {
-		await statusReactions.setDone();
-		statusReactions.restoreInitial();
-	} else await statusReactions.restoreInitial();
+	if (statusReactionsEnabled) {
+		if (dispatchError || agentRunFailed) {
+			await statusReactions.setError();
+			statusReactions.restoreInitial();
+		} else if (anyReplyDelivered) {
+			await statusReactions.setDone();
+			statusReactions.restoreInitial();
+		} else await statusReactions.restoreInitial();
+	}
 	const participationThreadTs = delivery.usedReplyThreadTs ?? statusThreadTs;
 	if (anyReplyDelivered && participationThreadTs) recordSlackThreadParticipation(account.accountId, message.channel, participationThreadTs, {
 		agentId: route.agentId,
@@ -2770,7 +2563,7 @@ function normalizeSlackAppContextEntities(value) {
 //#endregion
 //#region extensions/slack/src/monitor/thread.ts
 const THREAD_STARTER_CACHE = /* @__PURE__ */ new Map();
-const THREAD_STARTER_CACHE_TTL_MS = 360 * 6e4;
+const THREAD_STARTER_CACHE_TTL_MS = 216e5;
 const THREAD_STARTER_CACHE_MAX = 2e3;
 function evictThreadStarterCache() {
 	const now = asDateTimestampMs(Date.now());
@@ -2965,7 +2758,24 @@ async function discardSlackPreflightMedia(media) {
 const SLACK_MENTION_RESOLUTION_CONCURRENCY = 4;
 const SLACK_MENTION_RESOLUTION_MAX_LOOKUPS_PER_MESSAGE = 20;
 const SLACK_USER_MENTION_RE$1 = /<@([A-Z0-9]+)(?:\|[^>]+)?>/gi;
-const loadSlackMediaModule$1 = createLazyRuntimeModule(() => import("./actions-XdQyjG_p.js").then((n) => n._));
+const MAX_SLACK_UNAVAILABLE_FILE_TEXT_CHARS = 2e3;
+const loadSlackMediaModule$1 = createLazyRuntimeModule(() => import("./actions-CFkvEv1d.js").then((n) => n._));
+function formatSlackUnavailableMedia(params) {
+	let fileReferences = params.files?.map((file) => `${formatSlackFileReference(file)} unavailable (${file.reason})`).join(", ");
+	if (fileReferences && fileReferences.length > MAX_SLACK_UNAVAILABLE_FILE_TEXT_CHARS) fileReferences = `${truncateUtf16Safe(fileReferences, MAX_SLACK_UNAVAILABLE_FILE_TEXT_CHARS)}; … (file references truncated)`;
+	const fileBlock = fileReferences ? `[Slack file: ${fileReferences}]` : void 0;
+	const body = [params.body, fileBlock].filter(Boolean).join("\n");
+	if (params.unavailableMediaCount === 0) return body;
+	const notice = `[slack ${params.unavailableMediaCount > 1 ? `${params.unavailableMediaCount} attachments` : "attachment"} unavailable]`;
+	return params.prependUnavailable ? [
+		notice,
+		fileBlock,
+		params.body
+	].filter(Boolean).join("\n") : formatInboundMediaUnavailableText({
+		body,
+		notice
+	});
+}
 function collectUniqueSlackMentionIds$1(texts) {
 	const seen = /* @__PURE__ */ new Set();
 	const mentionIds = [];
@@ -3016,7 +2826,6 @@ async function resolveSlackMessageContent(params) {
 	})) : null;
 	const effectiveDirectMedia = attachmentContent?.media.length ? attachmentContent.media : null;
 	const mediaPlaceholder = effectiveDirectMedia?.map((item) => item.placeholder).join(" ");
-	const fileOnlyFallback = attachmentContent?.files?.map(formatSlackFileReference).join(", ");
 	let botAttachmentText;
 	if (params.isBotMessage && !attachmentContent?.text) {
 		const botAttachmentTextParts = [];
@@ -3040,7 +2849,8 @@ async function resolveSlackMessageContent(params) {
 		if (skippedLookups > 0) logVerbose(`slack: skipping ${skippedLookups} mention lookup(s) beyond per-message cap (${SLACK_MENTION_RESOLUTION_MAX_LOOKUPS_PER_MESSAGE})`);
 		const { results } = await runTasksWithConcurrency({
 			tasks: lookupIds.map((userId) => async () => {
-				const renderedName = normalizeOptionalString((await resolveUserName(userId))?.name);
+				const user = await resolveUserName(userId);
+				const renderedName = normalizeOptionalString(user?.name);
 				return {
 					userId,
 					rendered: renderedName ? `<@${userId}> (${renderedName})` : null
@@ -3053,17 +2863,15 @@ async function resolveSlackMessageContent(params) {
 			renderedMentions.set(result.userId, result.rendered);
 		}
 	}
-	let rawBody = [
-		renderSlackUserMentions(textParts[0], renderedMentions),
-		renderSlackUserMentions(textParts[1], renderedMentions),
-		renderSlackUserMentions(textParts[2], renderedMentions),
-		mediaPlaceholder,
-		fileOnlyFallback ? `[Slack file: ${fileOnlyFallback}]` : void 0
-	].filter(Boolean).join("\n") || "";
-	const unavailableImageCount = attachmentContent?.unavailableImageCount ?? 0;
-	if (unavailableImageCount > 0) rawBody = formatInboundMediaUnavailableText({
-		body: rawBody,
-		notice: `[slack ${unavailableImageCount > 1 ? `${unavailableImageCount} forwarded images` : "forwarded image"} unavailable]`
+	const rawBody = formatSlackUnavailableMedia({
+		body: [
+			renderSlackUserMentions(textParts[0], renderedMentions),
+			renderSlackUserMentions(textParts[1], renderedMentions),
+			renderSlackUserMentions(textParts[2], renderedMentions),
+			mediaPlaceholder
+		].filter(Boolean).join("\n") || "",
+		files: attachmentContent?.files,
+		unavailableMediaCount: attachmentContent?.unavailableMediaCount ?? 0
 	});
 	return rawBody ? {
 		rawBody,
@@ -3143,104 +2951,6 @@ async function resolveSlackDmHistoryContext(params) {
 	}
 }
 //#endregion
-//#region extensions/slack/src/monitor/message-handler/prepare-routing.ts
-function resolveSlackBaseConversationId(params) {
-	return qualifySlackConversationId(params.isDirectMessage ? `user:${params.message.user ?? "unknown"}` : params.message.channel, 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;
@@ -3296,7 +3006,7 @@ function formatSlackThreadLabelSnippet(text) {
 }
 //#endregion
 //#region extensions/slack/src/monitor/message-handler/prepare-thread-context.ts
-const loadSlackMediaModule = createLazyRuntimeModule(() => import("./actions-XdQyjG_p.js").then((n) => n._));
+const loadSlackMediaModule = createLazyRuntimeModule(() => import("./actions-CFkvEv1d.js").then((n) => n._));
 const SLACK_THREAD_CONTEXT_USER_LOOKUP_CONCURRENCY = 4;
 function resolveSlackThreadSessionFreshness(params) {
 	return params.ctx.channelRuntime?.session?.resolveEntryResetFreshness?.({
@@ -3408,14 +3118,24 @@ async function resolveSlackThreadContextData(params) {
 		const snippet = formatSlackThreadLabelSnippet(starter.text);
 		threadLabel = `Slack thread ${params.roomLabel}${snippet ? `: ${snippet}` : ""}`;
 		if (shouldSeedInitialThreadContext && !params.effectiveDirectMedia && starter.files && starter.files.length > 0) {
-			const { resolveSlackMedia } = await loadSlackMediaModule();
-			threadStarterMedia = await resolveSlackMedia({
+			const { resolveSlackAttachmentContent } = await loadSlackMediaModule();
+			const attachmentContent = await resolveSlackAttachmentContent({
 				files: starter.files,
 				client: params.eventScope?.client ?? params.ctx.app.client,
 				token: params.ctx.botToken,
 				maxBytes: params.ctx.mediaMaxBytes
 			});
-			if (threadStarterMedia) logVerbose(`slack: hydrated thread starter file ${threadStarterMedia.map((item) => item.placeholder).join(", ")} from root message`);
+			threadStarterMedia = attachmentContent?.media.length ? attachmentContent.media : null;
+			if (attachmentContent) threadStarterBody = formatSlackUnavailableMedia({
+				body: threadStarterBody,
+				files: attachmentContent.files,
+				unavailableMediaCount: attachmentContent.unavailableMediaCount,
+				prependUnavailable: true
+			});
+			if (threadStarterMedia) {
+				const starterPlaceholders = threadStarterMedia.map((item) => item.placeholder).join(", ");
+				logVerbose(`slack: hydrated thread starter file ${starterPlaceholders} from root message`);
+			}
 		}
 	} else threadLabel = `Slack thread ${params.roomLabel}`;
 	const includeBotStarterAsRootContext = shouldIncludeBotThreadStarterContext({
@@ -3435,14 +3155,20 @@ async function resolveSlackThreadContextData(params) {
 	const threadInitialHistoryLimit = params.account.config?.thread?.initialHistoryLimit ?? 20;
 	if (threadInitialHistoryLimit > 0 && shouldLoadInitialThreadHistory) {
 		const currentBotRootTs = starter?.ts ?? params.threadTs;
+		const threadHistory = await resolveSlackThreadHistory({
+			channelId: params.message.channel,
+			threadTs: params.threadTs,
+			client: params.eventScope?.client ?? params.ctx.app.client,
+			currentMessageTs: params.message.ts,
+			limit: threadInitialHistoryLimit
+		});
+		const enrichedStarter = starter && threadStarterBody && threadStarterBody !== starter.text ? {
+			...starter,
+			text: threadStarterBody,
+			ts: currentBotRootTs
+		} : null;
 		const threadHistoryWithBotRoot = ensureSlackThreadHistoryHasBotRoot({
-			history: await resolveSlackThreadHistory({
-				channelId: params.message.channel,
-				threadTs: params.threadTs,
-				client: params.eventScope?.client ?? params.ctx.app.client,
-				currentMessageTs: params.message.ts,
-				limit: threadInitialHistoryLimit
-			}),
+			history: enrichedStarter && !threadHistory.some((entry) => entry.ts === currentBotRootTs) ? [enrichedStarter, ...threadHistory.length >= threadInitialHistoryLimit ? threadHistory.slice(1) : threadHistory] : threadHistory,
 			includeBotStarterAsRootContext,
 			threadStarter: starter ? {
 				...starter,
@@ -3501,7 +3227,7 @@ async function resolveSlackThreadContextData(params) {
 				});
 				const role = isCurrentBot || isOtherBot || Boolean(historyMsg.botId) ? "assistant" : "user";
 				const msgSenderName = isCurrentBot ? "Bot (this assistant)" : msgUser?.name ?? (historyMsg.botId ? `Bot (${historyMsg.botId})` : "Unknown");
-				const msgWithId = `${historyMsg.text}\n[slack message id: ${historyMsg.ts ?? "unknown"} channel: ${params.message.channel}]`;
+				const msgWithId = `${historyMsg.ts === currentBotRootTs && threadStarterBody ? threadStarterBody : historyMsg.text}\n[slack message id: ${historyMsg.ts ?? "unknown"} channel: ${params.message.channel}]`;
 				historyParts.push(formatInboundEnvelope({
 					channel: "Slack",
 					from: `${msgSenderName} (${role})`,
@@ -3528,7 +3254,7 @@ async function resolveSlackThreadContextData(params) {
 //#endregion
 //#region extensions/slack/src/monitor/message-handler/subteam-mentions.ts
 const SUBTEAM_MENTION_RE = /<!subteam\^([A-Z0-9]+)(?:\|[^>]*)?>/gi;
-const SUBTEAM_MEMBER_CACHE_TTL_MS = 300 * 1e3;
+const SUBTEAM_MEMBER_CACHE_TTL_MS = 3e5;
 const subteamMemberCache = /* @__PURE__ */ new WeakMap();
 function normalizeSlackId(value) {
 	return typeof value === "string" && value.trim() ? value.trim().toUpperCase() : void 0;
@@ -3599,7 +3325,7 @@ const SLACK_USER_MENTION_RE = /<@([^>|]+)(?:\|[^>]+)?>/g;
 const SLACK_SUBTEAM_MENTION_RE = /<!subteam\^([^>|]+)(?:\|[^>]+)?>/g;
 const SLACK_SUBTEAM_MENTION_MARKER = "<!subteam^";
 const SLACK_HISTORY_MEDIA_MAX_ATTACHMENTS = 4;
-const SLACK_HISTORY_MEDIA_MAX_BYTES = 10 * 1024 * 1024;
+const SLACK_HISTORY_MEDIA_MAX_BYTES = 10485760;
 const SLACK_HISTORY_MEDIA_IDLE_TIMEOUT_MS = 1e3;
 const SLACK_HISTORY_MEDIA_TOTAL_TIMEOUT_MS = 3e3;
 const SLACK_CHANNEL_ACCESS_DOCS_URL = "https://docs.openclaw.ai/channels/slack#access-control-and-routing";
@@ -3653,25 +3379,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)}`);
 	}
@@ -3733,7 +3446,7 @@ function buildSlackHistoryMediaCandidateMessage(message) {
 async function resolveSlackHistoryMediaForPendingRecord(params) {
 	const mediaMessage = buildSlackHistoryMediaCandidateMessage(params.message);
 	if (!mediaMessage) return [];
-	return await toInboundMediaFactsWithMetadata((await resolveSlackMessageContent({
+	const content = await resolveSlackMessageContent({
 		message: mediaMessage,
 		isThreadReply: params.isThreadReply,
 		threadStarter: params.threadStarter,
@@ -3743,7 +3456,8 @@ async function resolveSlackHistoryMediaForPendingRecord(params) {
 		mediaMaxBytes: Math.min(params.ctx.mediaMaxBytes, SLACK_HISTORY_MEDIA_MAX_BYTES),
 		mediaReadIdleTimeoutMs: SLACK_HISTORY_MEDIA_IDLE_TIMEOUT_MS,
 		mediaTotalTimeoutMs: SLACK_HISTORY_MEDIA_TOTAL_TIMEOUT_MS
-	}))?.effectiveDirectMedia, {
+	});
+	return await toInboundMediaFactsWithMetadata(content?.effectiveDirectMedia, {
 		kind: "image",
 		messageId: params.message.ts
 	});
@@ -3839,24 +3553,15 @@ async function resolveSlackConversationContext(params) {
 	};
 }
 async function authorizeSlackInboundMessage(params) {
-	const { ctx, account, message, conversation } = params;
+	const { ctx, account, message, conversation, drop } = params;
 	const { isDirectMessage, channelName, resolvedChannelType, isBotMessage, allowBotsMode } = conversation;
 	if (isBotMessage) {
 		if (message.user && ctx.botUserId && message.user === ctx.botUserId) return null;
-		if (allowBotsMode === "off") {
-			logVerbose(`slack: drop bot message ${message.bot_id ?? "unknown"} (allowBots=false)`);
-			return null;
-		}
-	}
-	if (isDirectMessage && !message.user) {
-		logVerbose("slack: drop dm message (missing user id)");
-		return null;
+		if (allowBotsMode === "off") return drop("bot-disabled");
 	}
+	if (isDirectMessage && !message.user) return drop("missing-user");
 	const senderId = message.user ?? (isBotMessage ? message.bot_id : void 0);
-	if (!senderId) {
-		logVerbose("slack: drop message (missing sender id)");
-		return null;
-	}
+	if (!senderId) return drop("missing-sender");
 	if (!ctx.isChannelAllowed({
 		teamId: params.eventScope?.teamId ?? ctx.teamId,
 		channelId: message.channel,
@@ -3866,7 +3571,8 @@ async function authorizeSlackInboundMessage(params) {
 		if (conversation.isRoom && ctx.groupPolicy === "allowlist" && params.explicitBotMention && !isBotMessage && message.user) {
 			let subject = "This OpenClaw bot";
 			if (ctx.botUserId) try {
-				const botName = normalizeOptionalString((await ctx.resolveUserName(ctx.botUserId, params.eventScope))?.name);
+				const botIdentity = await ctx.resolveUserName(ctx.botUserId, params.eventScope);
+				const botName = normalizeOptionalString(botIdentity?.name);
 				if (botName) subject = escapeSlackMrkdwn(botName);
 			} catch (error) {
 				logVerbose(`slack allowlist denial bot-name lookup failed: ${formatSlackError(error)}`);
@@ -3883,8 +3589,7 @@ async function authorizeSlackInboundMessage(params) {
 				ctx.runtime.error?.(`slack allowlist denial notice failed for channel ${message.channel}: ${formatSlackError(error)}`);
 			}
 		}
-		logVerbose("slack: drop message (channel not allowed)");
-		return null;
+		return drop("channel-not-allowed");
 	}
 	const allowFromLower = await resolveSlackEffectiveAllowFrom(ctx, {
 		includePairingStore: isDirectMessage,
@@ -3892,10 +3597,8 @@ async function authorizeSlackInboundMessage(params) {
 	});
 	if (isDirectMessage) {
 		const directUserId = message.user;
-		if (!directUserId) {
-			logVerbose("slack: drop dm message (missing user id)");
-			return null;
-		}
+		if (!directUserId) return drop("missing-user");
+		let dropReason = "dm-unauthorized";
 		if (!await authorizeSlackDirectMessage({
 			ctx,
 			accountId: account.accountId,
@@ -3913,13 +3616,13 @@ async function authorizeSlackInboundMessage(params) {
 				});
 			},
 			onDisabled: () => {
-				logVerbose("slack: drop dm (dms disabled)");
+				dropReason = "dm-disabled";
 			},
 			onUnauthorized: ({ allowMatchMeta }) => {
 				logVerbose(`Blocked unauthorized slack sender ${message.user} (dmPolicy=${ctx.dmPolicy}, ${allowMatchMeta})`);
 			},
 			log: logVerbose
-		})) return null;
+		})) return drop(dropReason);
 	}
 	return {
 		senderId,
@@ -3928,6 +3631,19 @@ async function authorizeSlackInboundMessage(params) {
 }
 async function prepareSlackMessage(params) {
 	const { ctx, account, message, opts } = params;
+	const drop = (reason, parentUserId) => {
+		ctx.logger.info({
+			provider: "slack",
+			accountId: account.accountId,
+			teamId: opts.eventScope?.teamId ?? ctx.teamId,
+			channelId: message.channel,
+			messageTs: message.ts,
+			source: opts.source,
+			reason,
+			...parentUserId ? { parentUserId } : {}
+		}, "Slack inbound event rejected during preparation");
+		return null;
+	};
 	const slackClient = opts.eventScope?.client ?? ctx.app.client;
 	const threadStarterWorkspaceScope = {
 		accountId: account.accountId,
@@ -3951,7 +3667,8 @@ async function prepareSlackMessage(params) {
 		conversation,
 		explicitBotMention: opts.source === "app_mention" || Boolean(normalizedBotUserId && mentionMetadata.mentionedUserIds.includes(normalizedBotUserId)),
 		eventScope: opts.eventScope,
-		onVisibleDrop: opts.onVisibleDrop
+		onVisibleDrop: opts.onVisibleDrop,
+		drop
 	});
 	if (!authorization) return null;
 	const { senderId, allowFromLower } = authorization;
@@ -3959,7 +3676,8 @@ async function prepareSlackMessage(params) {
 	const resolveSenderName = async () => {
 		if (resolvedSenderName) return resolvedSenderName;
 		if (message.user) {
-			const normalized = normalizeOptionalString((await ctx.resolveUserName(message.user, opts.eventScope))?.name);
+			const sender = await ctx.resolveUserName(message.user, opts.eventScope);
+			const normalized = normalizeOptionalString(sender?.name);
 			if (normalized) {
 				resolvedSenderName = normalized;
 				return resolvedSenderName;
@@ -4055,13 +3773,7 @@ async function prepareSlackMessage(params) {
 			if (shouldLogVerbose()) logVerbose(`slack: using configured ACP binding for ${configuredBinding.record.conversation.conversationId} -> ${configuredBindingSessionKey}`);
 		} else {
 			if (shouldLogVerbose()) logVerbose(`slack: configured ACP binding unavailable for ${configuredBinding.record.conversation.conversationId}: ${ensured.error}`);
-			logInboundDrop({
-				log: logVerbose,
-				channel: "slack",
-				reason: "configured ACP binding unavailable",
-				target: configuredBinding.record.conversation.conversationId
-			});
-			return null;
+			return drop("configured-binding-unavailable");
 		}
 	}
 	const senderNameForAuthPromise = ctx.allowNameMatching ? resolveSenderName().then((name) => ({
@@ -4176,14 +3888,7 @@ async function prepareSlackMessage(params) {
 		channel: "slack",
 		accountId: account.accountId
 	});
-	if (message["_ambiguousThreadReply"]) {
-		ctx.logger.info({
-			channel: message.channel,
-			ts: message.ts,
-			parentUserId: message.parent_user_id
-		}, "skipping ambiguous slack thread reply");
-		return null;
-	}
+	if (message["_ambiguousThreadReply"]) return drop("ambiguous-thread", message.parent_user_id);
 	let canDetectMention = Boolean(ctx.botUserId) || mentionRegexes.length > 0;
 	const textForCommandDetection = stripSlackMentionsForCommandDetection(message.text ?? "");
 	const hasControlCommandInMessage = hasControlCommand(textForCommandDetection, cfg);
@@ -4216,10 +3921,7 @@ async function prepareSlackMessage(params) {
 	});
 	let messageIngress = await resolveMessageIngress();
 	const senderGate = messageIngress.senderAccess.gate;
-	if (isRoomish && senderGate?.allowed === false) {
-		logVerbose(`Blocked unauthorized slack sender ${senderId} (not in sender allowlist)`);
-		return null;
-	}
+	if (isRoomish && senderGate?.allowed === false) return drop("unauthorized-sender");
 	if (isRoom && isBotMessage && allowBotsMode !== "off" && !await authorizeSlackBotRoomMessage({
 		ctx,
 		channelId: message.channel,
@@ -4228,7 +3930,7 @@ async function prepareSlackMessage(params) {
 		channelUsers: channelConfig?.users,
 		allowFromLower,
 		eventScope: opts.eventScope
-	})) return null;
+	})) return drop("unauthorized-bot");
 	const threadContextAllowFromLower = isRoom ? channelUsersAllowlistConfigured ? normalizeAllowListLower(channelConfig?.users) : [] : isDirectMessage ? allowFromLower : [];
 	const contextVisibilityMode = resolveChannelContextVisibilityMode({
 		cfg: ctx.cfg,
@@ -4248,15 +3950,7 @@ async function prepareSlackMessage(params) {
 		explicitKind: true
 	});
 	const commandAuthorized = messageIngress.commandAccess.authorized;
-	if (isRoomish && messageIngress.commandAccess.shouldBlockControlCommand) {
-		logInboundDrop({
-			log: logVerbose,
-			channel: "slack",
-			reason: "control command (unauthorized)",
-			target: senderId
-		});
-		return null;
-	}
+	if (isRoomish && messageIngress.commandAccess.shouldBlockControlCommand) return drop("control-command-unauthorized");
 	const canSeedMentionedRoomThread = !seedTopLevelRoomThreadBySource && isRoom && !routing.isThreadReply && !hasBoundSession;
 	let seededMentionRouting;
 	const getSeededMentionRouting = () => {
@@ -4351,37 +4045,20 @@ async function prepareSlackMessage(params) {
 		wasMentioned
 	});
 	if (isBotMessage && allowBotsMode === "mentions") {
-		if (!(isDirectMessage || effectiveWasMentioned || shouldBypassMention)) {
-			logVerbose("slack: drop bot message (allowBots=mentions, missing mention)");
-			return null;
-		}
+		if (!(isDirectMessage || effectiveWasMentioned || shouldBypassMention)) return drop("bot-missing-mention");
 	}
 	if (isRoom && shouldRequireMention && !canDetectMention && !effectiveWasMentioned) {
-		ctx.logger.info({
-			channel: message.channel,
-			reason: "mention-detection-unavailable"
-		}, "skipping channel message");
 		await recordDroppedHistory("slack-mention-detection-unavailable");
-		return null;
+		return drop("mention-detection-unavailable");
 	}
 	const ignoreOtherMentions = channelConfig?.ignoreOtherMentions ?? false;
 	if (isRoom && ignoreOtherMentions && Boolean(ctx.botUserId) && hasAnyMention && !wasMentioned) {
-		logInboundDrop({
-			log: logVerbose,
-			channel: "slack",
-			reason: "other-mention",
-			target: senderId
-		});
 		await recordDroppedHistory("slack-other-mention");
-		return null;
+		return drop("other-mention");
 	}
 	if (isRoom && shouldRequireMention && mentionDecision.shouldSkip) {
-		ctx.logger.info({
-			channel: message.channel,
-			reason: "no-mention"
-		}, "skipping channel message");
 		await recordDroppedHistory("slack-no-mention");
-		return null;
+		return drop("missing-mention");
 	}
 	const chatType = resolveSlackChatType(conversation.resolvedChannelType);
 	const inboundEventKind = classifyChannelInboundEvent({
@@ -4396,7 +4073,7 @@ async function prepareSlackMessage(params) {
 	});
 	const threadStarter = await getThreadStarter();
 	const resolvedMessageContent = await getMessageContent();
-	if (!resolvedMessageContent) return null;
+	if (!resolvedMessageContent) return drop("empty-content");
 	const { rawBody, effectiveDirectMedia } = resolvedMessageContent;
 	const bodyForAgent = preflightAudioTranscript ? formatSlackAudioTranscriptForAgent({
 		transcript: preflightAudioTranscript,
@@ -4417,7 +4094,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,
@@ -4465,10 +4142,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));
@@ -4559,10 +4237,7 @@ async function prepareSlackMessage(params) {
 		messageId: threadContext.messageTs,
 		inboundEventKind
 	}, boundMessageThreadId);
-	if (messageIngress.ingress.admission !== "dispatch") {
-		logVerbose(`Blocked slack sender ${senderId} after final route binding`);
-		return null;
-	}
+	if (messageIngress.ingress.admission !== "dispatch") return drop("final-route-denied");
 	const agentContextEntities = isAgentViewMessage ? normalizeSlackAppContextEntities(message.app_context) : [];
 	const ctxPayload = (ctx.buildContext ?? buildChannelInboundEventContext)({
 		channelIngress: messageIngress,
@@ -4647,6 +4322,7 @@ async function prepareSlackMessage(params) {
 				payload: { entities: agentContextEntities }
 			}] : void 0,
 			TransportThreadId: directThreadRoutedToDmSession ? threadContext.messageThreadId : void 0,
+			ReplyThreading: isThreadReply ? { implicitCurrentMessage: "deny" } : void 0,
 			SlackAssistantThread: assistantThreadContext ? true : void 0,
 			SlackAgentThread: agentViewThreadTs ? true : void 0,
 			SlackAssistantThreadContextChannelId: assistantThreadContext?.channelId,
@@ -4682,7 +4358,6 @@ async function prepareSlackMessage(params) {
 		normalizeEntry: normalizeSlackAllowOwnerEntry
 	}) : null;
 	const replyTarget = `channel:${message.channel}`;
-	if (!replyTarget) return null;
 	if (preflightAudioTranscript) await sendSlackPreflightAudioTranscriptEcho({
 		transcript: preflightAudioTranscript,
 		cfg,
@@ -4705,6 +4380,7 @@ async function prepareSlackMessage(params) {
 		channelConfig,
 		replyTarget,
 		ctxPayload,
+		sessionDisplayName: sessionEntry?.displayName,
 		turn: {
 			storePath,
 			record: {