@openclaw/slack 2026.8.1-beta.3 → 2026.8.2

package/dist/{pipeline.runtime-Bbfd5VFW.js → pipeline.runtime-CcdujV99.js}

@@ -1,40 +1,40 @@
-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_EDIT_TEXT_MAX_BYTES, F as normalizeSlackOutboundText, I as buildSlackBlocksFallbackText, J as truncateSlackText, O as hasSlackNativeDataBlock, S as resolveSlackReplyRenderPlan, U as SLACK_TEXT_LIMIT, Y as truncateSlackTextByUtf8Bytes, a as qualifySlackConversationId, ct as escapeSlackMrkdwn, d as normalizeSlackAllowOwnerEntry, et as SLACK_SESSION_LINK_ACTION_ID, o as qualifySlackRoutePeerId, p as resolveSlackAllowListMatch, q as countSlackTextUtf8Bytes, s as resolveSlackEnterpriseMainDmSessionKey, u as normalizeAllowListLower } from "./group-policy-DyfB_ZIE.js";
-import { r as formatSlackError } from "./probe-BVA65leh.js";
+import { n as resolveSlackConversationBindingRoute, r as resolveSlackReplyToMode, t as normalizeSlackRouteBindingConfig } from "./conversation-binding-route-Vee8Dgbf.js";
+import { n as formatSlackTarget } from "./target-parsing-PbxGDbr9.js";
+import { I as countSlackTextUtf8Bytes, L as truncateSlackText, M as SLACK_TEXT_LIMIT, Q as normalizeSlackOutboundText, R as truncateSlackTextByUtf8Bytes, T as buildSlackBlocksFallbackText, U as SLACK_SESSION_LINK_ACTION_ID, a as qualifySlackConversationId, b as hasSlackNativeDataBlock, et as escapeSlackMrkdwn, k as SLACK_EDIT_TEXT_MAX_BYTES, m as resolveSlackReplyRenderPlan, o as qualifySlackRoutePeerId, s as resolveSlackEnterpriseMainDmSessionKey } from "./group-policy-BYH74y50.js";
+import { C as normalizeAllowListLower, E as resolveSlackAllowListMatch, o as formatSlackError, w as normalizeSlackAllowOwnerEntry } from "./probe-gj5yQgN2.js";
 import { n as resolveSlackStreamingMode, t as resolveSlackNativeStreaming } from "./streaming-compat-B-e0mqM0.js";
-import { b as formatSlackFileReferenceList, i as editSlackRenderedMessage, p as removeSlackReaction, r as editSlackMessage, t as deleteSlackMessage, u as reactSlackMessage, v as logVerbose$1, x as buildSlackEditTextPayload, y as formatSlackFileReference } from "./actions-DFk0ANVB.js";
-import { a as hasSlackTableBlock, c as resolveSlackMessageText$1, o as isSlackUnfurlAttachment, s as resolveSlackBlocksText } from "./slack-client-kind-BXyOOICI.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-CtnOxKCc.js";
-import { S as updateLastRoute, _ as parseSlackAssistantThreadMetadata, b as resolveChannelResetConfig, c as resolveConversationLabel$1, d as resolveSlackEffectiveAllowFrom, g as buildSlackAssistantThreadMetadata, h as resolveSlackChatType, l as authorizeSlackBotRoomMessage, m as normalizeSlackChannelType, o as authorizeSlackDirectMessage, r as resolveSlackRoomContextHints, s as trackSlackDraftMessage, u as resolveSlackCommandIngress, v as readSessionUpdatedAt, w as stripSlackMentionsForCommandDetection, x as resolveStorePath, y as resolveChannelContextVisibilityMode } from "./provider-CUUiwsg2.js";
-import { n as resolveSlackChannelConfig } from "./policy-BKXSxrIS.js";
-import { a as resolveDeliveredSlackReplyThreadTs, i as readSlackReplyBlocks, n as deliverReplies, o as resolveSlackThreadTs, s as emitSlackMessageSentHooks, t as createSlackReplyDeliveryPlan } from "./replies-SnWyXcsL.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-BOxiu2Vy.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-GUz4_v2E.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-DW9YC_no.js";
+import { n as resolveSlackChannelConfig } from "./policy-CUpBeOt9.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-DLjQ8RYU.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 { createChannelMessageReplyPipeline, createChannelProgressDraftCompositor, createDraftStreamLoop, createFinalizableDraftStreamControlsForState, defineFinalizableLivePreviewAdapter, deliverWithFinalizableLivePreviewAdapter, formatChannelProgressDraftText, 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 { 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";
@@ -384,12 +384,12 @@ function createSlackDraftStream(params) {
 	const send = params.send ?? sendMessageSlack;
 	const edit = params.edit ?? editSlackMessage;
 	const remove = params.remove ?? deleteSlackMessage;
-	let streamMessageId;
-	let streamChannelId;
+	let streamMessage;
 	let untrackConversationBoundary;
 	let lastVisibleUpdate;
 	let lastSentKey = "";
-	const detachedMessages = [];
+	const pendingCleanupMessages = [];
+	let cleanupTail = Promise.resolve();
 	const finalizedMessageIds = /* @__PURE__ */ new Set();
 	const streamState = {
 		stopped: false,
@@ -411,8 +411,8 @@ function createSlackDraftStream(params) {
 		if (sentKey === lastSentKey) return;
 		lastSentKey = sentKey;
 		try {
-			if (streamChannelId && streamMessageId) {
-				await edit(streamChannelId, streamMessageId, trimmed, {
+			if (streamMessage) {
+				await edit(streamMessage.channelId, streamMessage.messageId, trimmed, {
 					cfg: params.cfg,
 					token: params.token,
 					accountId: params.accountId,
@@ -444,27 +444,29 @@ function createSlackDraftStream(params) {
 				...params.metadata ? { metadata: params.metadata } : {},
 				...blocks ? { blocks } : {}
 			});
-			streamChannelId = sent.channelId || streamChannelId;
-			streamMessageId = sent.messageId || streamMessageId;
-			if (!streamChannelId || !streamMessageId) {
+			if (!sent.channelId || !sent.messageId) {
 				stopTrackingConversationBoundary();
 				streamState.stopped = true;
 				params.warn?.("slack stream preview stopped (missing identifiers from sendMessage)");
 				return;
 			}
+			streamMessage = {
+				channelId: sent.channelId,
+				messageId: sent.messageId
+			};
 			lastVisibleUpdate = {
 				text: trimmed,
 				...blocks ? { blocks } : {}
 			};
-			if (pendingBoundary && params.conversationChannelId === streamChannelId) pendingBoundary.setMessageTs(streamMessageId);
+			if (pendingBoundary && params.conversationChannelId === streamMessage.channelId) pendingBoundary.setMessageTs(streamMessage.messageId);
 			else {
 				stopTrackingConversationBoundary();
 				untrackConversationBoundary = trackSlackDraftMessage({
 					accountId: params.accountId,
 					teamId: params.eventScope?.teamId,
-					channelId: streamChannelId,
+					channelId: streamMessage.channelId,
 					threadTs,
-					messageTs: streamMessageId,
+					messageTs: streamMessage.messageId,
 					onInterveningMessage: forceNewMessage
 				}).stop;
 			}
@@ -476,6 +478,7 @@ function createSlackDraftStream(params) {
 	};
 	const { loop, update, discardPending, seal } = createFinalizableDraftStreamControlsForState({
 		throttleMs,
+		coalesceInFlight: true,
 		state: streamState,
 		sendOrEditStreamMessage,
 		emptyValue: "",
@@ -485,60 +488,58 @@ function createSlackDraftStream(params) {
 		untrackConversationBoundary?.();
 		untrackConversationBoundary = void 0;
 	};
-	const removeMessage = async (channelId, messageId) => {
-		try {
-			await remove(channelId, messageId, {
-				token: params.token,
-				accountId: params.accountId,
-				...params.eventScope ? { client: params.eventScope.client } : {}
-			});
-		} catch (err) {
-			params.warn?.(`slack stream preview cleanup failed: ${formatSlackError(err)}`);
-		}
+	const dropDetachedMessages = () => {
+		cleanupTail = cleanupTail.then(async () => {
+			for (let index = 0; index < pendingCleanupMessages.length;) {
+				const message = pendingCleanupMessages[index];
+				if (!message) return;
+				try {
+					await remove(message.channelId, message.messageId, {
+						token: params.token,
+						accountId: params.accountId,
+						...params.eventScope ? { client: params.eventScope.client } : {}
+					});
+					pendingCleanupMessages.splice(index, 1);
+				} catch (err) {
+					params.warn?.(`slack stream preview cleanup failed: ${formatSlackError(err)}`);
+					index += 1;
+				}
+			}
+		});
+		return cleanupTail;
 	};
 	const clear = async () => {
 		stopTrackingConversationBoundary();
 		await discardPending();
-		const channelId = streamChannelId;
-		const messageId = streamMessageId;
-		streamChannelId = void 0;
-		streamMessageId = void 0;
+		if (streamMessage) {
+			pendingCleanupMessages.push(streamMessage);
+			streamMessage = void 0;
+		}
 		lastVisibleUpdate = void 0;
 		lastSentKey = "";
-		if (!channelId || !messageId) return;
-		await removeMessage(channelId, messageId);
+		await dropDetachedMessages();
 	};
 	const forceNewMessage = () => {
 		stopTrackingConversationBoundary();
 		streamState.stopped = false;
 		streamState.final = false;
-		if (streamChannelId && streamMessageId && !finalizedMessageIds.has(streamMessageId)) detachedMessages.push({
-			channelId: streamChannelId,
-			messageId: streamMessageId
-		});
-		streamMessageId = void 0;
-		streamChannelId = void 0;
+		if (streamMessage && !finalizedMessageIds.has(streamMessage.messageId)) pendingCleanupMessages.push(streamMessage);
+		streamMessage = void 0;
 		lastVisibleUpdate = void 0;
 		lastSentKey = "";
 		loop.resetPending();
 	};
-	const dropDetachedMessages = async () => {
-		let message;
-		while ((message = detachedMessages.shift()) !== void 0) {
-			const { channelId, messageId } = message;
-			await removeMessage(channelId, messageId);
-		}
-	};
 	const discardPendingAndStopTracking = async () => {
 		stopTrackingConversationBoundary();
 		await discardPending();
 	};
 	const finalizeMessage = async (messageId, editFinal) => {
-		const channelId = streamChannelId;
+		const currentMessage = streamMessage;
 		const previousUpdate = lastVisibleUpdate;
-		if (!channelId || streamMessageId !== messageId || !previousUpdate) return false;
+		if (!currentMessage || currentMessage.messageId !== messageId || !previousUpdate) return false;
+		const { channelId } = currentMessage;
 		await editFinal();
-		if (streamChannelId === channelId && streamMessageId === messageId) {
+		if (streamMessage?.channelId === channelId && streamMessage.messageId === messageId) {
 			finalizedMessageIds.add(messageId);
 			stopTrackingConversationBoundary();
 			return true;
@@ -566,69 +567,16 @@ function createSlackDraftStream(params) {
 		forceNewMessage,
 		dropDetachedMessages,
 		finalizeMessage,
-		messageId: () => streamMessageId,
-		channelId: () => streamChannelId
-	};
-}
-//#endregion
-//#region extensions/slack/src/stream-mode.ts
-function resolveSlackStreamingConfig(params) {
-	return {
-		mode: resolveSlackStreamingMode(params),
-		nativeStreaming: resolveSlackNativeStreaming(params)
-	};
-}
-function applyAppendOnlyStreamUpdate(params) {
-	const incoming = params.incoming.trimEnd();
-	if (!incoming) return {
-		rendered: params.rendered,
-		source: params.source,
-		changed: false
-	};
-	if (!params.rendered) return {
-		rendered: incoming,
-		source: incoming,
-		changed: true
-	};
-	if (incoming === params.source) return {
-		rendered: params.rendered,
-		source: params.source,
-		changed: false
-	};
-	if (incoming.startsWith(params.rendered)) return {
-		rendered: incoming,
-		source: incoming,
-		changed: incoming !== params.rendered
-	};
-	if (incoming.startsWith(params.source)) {
-		const delta = incoming.slice(params.source.length);
-		return {
-			rendered: `${params.rendered}${delta}`,
-			source: incoming,
-			changed: delta.length > 0
-		};
-	}
-	if (params.source.startsWith(incoming)) return {
-		rendered: params.rendered,
-		source: params.source,
-		changed: false
-	};
-	const separator = params.separator ?? (params.rendered.endsWith("\n") ? "" : "\n");
-	return {
-		rendered: `${params.rendered}${separator}${incoming}`,
-		source: incoming,
-		changed: true
+		messageId: () => streamMessage?.messageId,
+		channelId: () => streamMessage?.channelId
 	};
 }
 //#endregion
 //#region extensions/slack/src/progress-blocks.ts
 const SLACK_PROGRESS_FIELD_MAX = 1800;
 const DEFAULT_SLACK_PROGRESS_DETAIL_MAX_CHARS = 120;
-const DEFAULT_SLACK_PROGRESS_TASK_DETAIL_MAX_CHARS = 48;
 const SLACK_PROGRESS_CHUNK_TEXT_MAX = 256;
 const SLACK_PROGRESS_TASK_TITLE_MAX = 120;
-const SLACK_PROGRESS_PLAN_FALLBACK_TITLE = "Thinking";
-const SLACK_PROGRESS_LINE_DELTA_RE = /(?:^|\s)\+(\d+)\s+[−-](\d+)(?=\s|$)/u;
 function buildSessionSources(url) {
 	return [{
 		type: "url_source",
@@ -636,12 +584,6 @@ function buildSessionSources(url) {
 		text: "Open in OpenClaw"
 	}];
 }
-function field(text) {
-	return {
-		type: "mrkdwn",
-		text: truncateSlackText(text, SLACK_PROGRESS_FIELD_MAX)
-	};
-}
 function resolveMaxLineChars(value, fallback) {
 	return value && value > 0 ? Math.floor(value) : fallback;
 }
@@ -660,141 +602,58 @@ function compactTitle(value) {
 function compactChunkText(value) {
 	return truncateSlackText(value.replace(/\s+/g, " ").trim(), SLACK_PROGRESS_CHUNK_TEXT_MAX);
 }
-function lineDetailParts(line) {
-	return [line.detail, line.status && line.status !== "completed" && !line.detail?.includes(line.status) ? line.status : void 0].map((part) => part?.trim()).filter((part) => Boolean(part));
-}
-function legacyLineTitle(line) {
-	return `${line.icon ?? "•"} *${escapeSlackMrkdwn(line.label)}*`;
-}
 function isAuthoredProgressLine(line) {
 	return line.id === "reasoning" || line.id?.startsWith("commentary:") === true;
 }
-function legacyLineDetail(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 "—";
-}
-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 fallback = line.text.replace(/\s+/g, " ").trim();
-	if (fallback && fallback !== label) return compactTitle(lineDetailParts(line).length > 0 || line.status ? label : fallback);
-	return compactTitle(label);
-}
-function lineTaskDetails(line, maxLineChars) {
-	const detail = line.detail?.replace(SLACK_PROGRESS_LINE_DELTA_RE, "").replace(/\s+·\s*$/u, "").trim();
-	return detail && detail !== line.status?.trim() ? compactDetail(detail, maxLineChars) : void 0;
-}
-function lineTaskOutput(line) {
-	const match = line.detail ? SLACK_PROGRESS_LINE_DELTA_RE.exec(line.detail) : null;
-	if (match) return `+${match[1]} −${match[2]}`;
-	const status = line.status?.replace(/\s+/g, " ").trim();
-	return status && lineTaskStatus(line) === "error" ? status : void 0;
-}
-function lineTaskStatus(line) {
-	const normalized = line.status?.replace(/\s+/g, " ").trim().toLowerCase();
-	if (!normalized) return "in_progress";
-	if (normalized === "complete" || normalized === "completed" || normalized === "done" || normalized === "ok" || normalized === "success" || normalized === "succeeded" || normalized === "successful" || normalized === "exit 0") return "complete";
-	if (normalized === "error" || normalized === "failed" || normalized === "failure" || normalized.startsWith("exit ")) return normalized === "exit 0" ? "complete" : "error";
-	return "in_progress";
-}
-function slugTaskIdPart(value) {
-	return value?.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "") || "task";
-}
-function stableTaskIdPart(value, slugValue = value) {
-	const suffix = createHash("sha256").update(value).digest("hex").slice(0, 8);
-	return `${slugTaskIdPart(slugValue).slice(0, 48)}_${suffix}`;
-}
-function resolveLineTaskIdentity(line) {
-	if (line.id?.trim()) return {
-		id: stableTaskIdPart(line.id),
-		contentDerived: false
+function resolveProgressAttention(lines) {
+	const approval = lines.findLast((line) => line.kind === "approval" && line.status === "requested");
+	if (approval) return {
+		id: "openclaw_attention",
+		title: compactTitle(`Approval required: ${approval.detail || approval.label}`),
+		status: "pending"
 	};
+	const failure = lines.findLast((line) => {
+		const status = line.status?.trim().toLowerCase();
+		return status === "error" || status === "failed" || status === "failure" || status?.startsWith("exit ") && status !== "exit 0";
+	});
+	if (!failure) return;
 	return {
-		id: stableTaskIdPart([
-			line.kind,
-			line.toolName,
-			line.label,
-			line.text
-		].join("\0"), line.toolName ?? line.kind ?? line.label),
-		contentDerived: true
+		id: "openclaw_attention",
+		title: compactTitle([...new Set([
+			failure.label,
+			failure.detail,
+			failure.status
+		].filter(Boolean))].join(" — ")),
+		status: "error"
 	};
 }
-function buildPlanTasks(params) {
-	if (params.plan) return params.plan.slice(-50).map((entry, index) => ({
+function buildSlackProgressStreamChunks(params) {
+	const title = compactChunkText(params.title?.trim() || params.label?.trim() || "Working");
+	if (!params.title && !params.label && !params.lines.length && !params.plan?.length && !params.sessionUrl) return;
+	const tasks = params.plan?.length ? params.plan.slice(-50).map((entry, index) => ({
 		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);
-		const task = {
-			id,
-			title: lineTaskTitle(line),
-			status: lineTaskStatus(line)
-		};
-		if (details) task.details = details;
-		if (output) task.output = output;
-		return task;
-	});
-}
-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 buildSlackProgressStreamChunks(params) {
-	const tasks = buildPlanTasks({
-		lines: params.lines,
-		plan: params.plan,
-		maxLineChars: params.maxLineChars
-	});
-	if (tasks.length === 0) {
-		const title = params.title?.trim() || params.label?.trim();
-		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
-	});
+	})) : [{
+		id: "openclaw_summary",
+		title: compactTitle(title),
+		status: "in_progress"
+	}];
+	let attention = resolveProgressAttention(params.lines);
+	if (params.finalInProgressStatus === "error" && !tasks.some((task) => task.status === "in_progress")) attention = {
+		id: "openclaw_attention",
+		title: attention?.status === "error" ? attention.title : "Failed",
+		status: "error"
+	};
+	if (attention && !(params.finalInProgressStatus && attention.status === "pending")) tasks.push(attention);
 	const finalTaskIndex = tasks.length - 1;
-	const diffOutput = formatTaskDiffOutput(params.diffStat);
 	const taskChunks = tasks.map((task, index) => {
 		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
+			status: task.status === "in_progress" ? params.finalInProgressStatus ?? task.status : task.status
 		};
-		if (task.details) chunk.details = task.details;
-		if (task.output) chunk.output = task.output;
-		if (index === finalTaskIndex && diffOutput) chunk.output = [task.output, diffOutput].filter(Boolean).join(" · ");
 		if (index === finalTaskIndex && params.sessionUrl) chunk.sources = buildSessionSources(params.sessionUrl);
 		return chunk;
 	});
@@ -803,113 +662,50 @@ 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) {
-	const rendered = [];
-	let length = 0;
-	for (const line of lines.slice(-50).toReversed()) {
-		const row = `${legacyLineTitle(line)} — ${legacyLineDetail(line, maxLineChars)}`;
-		const nextLength = length + row.length + (rendered.length > 0 ? 1 : 0);
-		if (nextLength > SLACK_PROGRESS_FIELD_MAX) break;
-		rendered.push(row);
-		length = nextLength;
-	}
-	return rendered.toReversed().join("\n");
-}
 function buildSlackProgressCardBlocks(params) {
 	const maxLineChars = resolveMaxLineChars(params.maxLineChars, DEFAULT_SLACK_PROGRESS_DETAIL_MAX_CHARS);
-	const planLines = formatPlanChecklistLines(params.plan ?? [], {
-		maxLines: 50,
-		maxLineChars
-	});
-	const narration = params.narration?.replace(/\s+/g, " ").trim();
-	const activityText = buildActivityText(params.lines, maxLineChars);
-	const diffStat = formatDiffStat(params.diffStat);
-	const workingFooter = [
-		...params.toolCalls && params.toolCalls > 0 ? [`🛠️ ${params.toolCalls} tools`] : [],
-		...diffStat ? [diffStat] : [],
-		...params.elapsedSeconds && params.elapsedSeconds > 0 ? [`⏱ ${params.elapsedSeconds}s`] : []
-	].join(" · ");
-	const footer = params.state === "working" ? workingFooter : diffStat;
-	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 EMPTY_SLACK_NATIVE_STREAM_SNAPSHOT = { tasks: /* @__PURE__ */ new Map() };
-const SLACK_TASK_FIELD_SEPARATOR = " · ";
-function resolveTaskFieldDelta(previous, incoming) {
-	if (!incoming) return {
-		field: previous,
-		delta: void 0
-	};
-	if (previous?.rendered.includes(incoming)) return {
-		field: {
-			rendered: previous.rendered,
-			source: incoming
-		},
-		delta: void 0
+	const statusLabels = {
+		completed: "Completed",
+		in_progress: "In progress",
+		pending: "Pending"
 	};
-	const next = applyAppendOnlyStreamUpdate({
-		incoming,
-		rendered: previous?.rendered ?? "",
-		source: previous?.source ?? "",
-		separator: SLACK_TASK_FIELD_SEPARATOR
+	const planLines = (params.plan ?? []).slice(-50).map((entry) => `${statusLabels[entry.status]}: ${compactDetail(entry.step, maxLineChars)}`);
+	const narration = params.narration?.replace(/\s+/g, " ").trim();
+	const authoredText = params.lines.filter(isAuthoredProgressLine).map((line) => line.text.trim()).filter((text, index, values) => text && text !== narration && values.indexOf(text) === index).map((text) => normalizeSlackOutboundText(compactDetail(text, maxLineChars))).join("\n");
+	const attention = resolveProgressAttention(params.lines);
+	const blocks = [
+		`${params.state === "success" ? "Completed: " : params.state === "error" ? "Failed: " : ""}*${escapeSlackMrkdwn(params.title.trim() || "Working")}*`,
+		narration ? `_${escapeSlackMrkdwn(narration)}_` : "",
+		planLines.map((line) => escapeSlackMrkdwn(line)).join("\n"),
+		authoredText,
+		attention && !(params.state !== "working" && attention.status === "pending") ? escapeSlackMrkdwn(attention.title) : ""
+	].filter(Boolean).map((text) => ({
+		type: "section",
+		text: {
+			type: "mrkdwn",
+			text: truncateSlackText(text, SLACK_PROGRESS_FIELD_MAX)
+		}
+	}));
+	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
+		}]
 	});
-	const delta = next.changed ? next.rendered.slice(previous?.rendered.length ?? 0) : void 0;
-	return {
-		field: {
-			rendered: next.rendered,
-			source: next.source
-		},
-		delta
-	};
+	return blocks.slice(0, 50);
 }
+const EMPTY_SLACK_NATIVE_STREAM_SNAPSHOT = { tasks: /* @__PURE__ */ new Map() };
 /**
 * Turns a full task snapshot into the delta Slack must receive. Native streams
 * key rows by persistent id with no removal chunk: unchanged rows are omitted,
-* changed rows carry only their unsent field text, and rows that dropped out
-* (plan shrinks, tool-line <-> plan source switches) get a final complete
+* changed titles/statuses replace in place, and rows that dropped out
+* (plan shrinks, summary <-> plan source switches) get a final complete
 * update or they linger in_progress forever.
 */
 function reconcileSlackNativeTaskChunks(params) {
@@ -930,26 +726,20 @@ function reconcileSlackNativeTaskChunks(params) {
 		}
 		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
 		};
-		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 !== status || sourcesChanged)) continue;
 		const update = {
 			type: "task_update",
 			id: chunk.id,
 			title: chunk.title,
 			status
 		};
-		if (details.delta) update.details = details.delta;
-		if (output.delta) update.output = output.delta;
 		if (sourcesChanged) update.sources = chunk.sources;
 		emitted.push(update);
 	}
@@ -978,40 +768,63 @@ 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) {
-	return lines.map((line) => {
-		if (typeof line !== "string") return line;
-		const reasoning = line.startsWith("🧠 ");
-		const text = line.replace(/^(?:🧠|💬)\s+/u, "").replace(/^_(.*)_$/su, "$1").trim();
+//#region extensions/slack/src/stream-mode.ts
+function resolveSlackStreamingConfig(params) {
+	return {
+		mode: resolveSlackStreamingMode(params),
+		nativeStreaming: resolveSlackNativeStreaming(params)
+	};
+}
+function applyAppendOnlyStreamUpdate(params) {
+	const incoming = params.incoming.trimEnd();
+	if (!incoming) return {
+		rendered: params.rendered,
+		source: params.source,
+		changed: false
+	};
+	if (!params.rendered) return {
+		rendered: incoming,
+		source: incoming,
+		changed: true
+	};
+	if (incoming === params.source) return {
+		rendered: params.rendered,
+		source: params.source,
+		changed: false
+	};
+	if (incoming.startsWith(params.rendered)) return {
+		rendered: incoming,
+		source: incoming,
+		changed: incoming !== params.rendered
+	};
+	if (incoming.startsWith(params.source)) {
+		const delta = incoming.slice(params.source.length);
 		return {
-			...reasoning ? { id: "reasoning" } : {},
-			kind: "item",
-			text,
-			label: reasoning ? "Reasoning" : "Update",
-			prefix: false
+			rendered: `${params.rendered}${delta}`,
+			source: incoming,
+			changed: delta.length > 0
 		};
-	});
+	}
+	if (params.source.startsWith(incoming)) return {
+		rendered: params.rendered,
+		source: params.source,
+		changed: false
+	};
+	const separator = params.separator ?? (params.rendered.endsWith("\n") ? "" : "\n");
+	return {
+		rendered: `${params.rendered}${separator}${incoming}`,
+		source: incoming,
+		changed: true
+	};
 }
-function resolveNativeProgressPlan(snapshot) {
-	return snapshot.plan?.length ? snapshot.plan : void 0;
+//#endregion
+//#region extensions/slack/src/monitor/message-handler/dispatch-progress-render.ts
+function resolveStructuredProgressLines(lines) {
+	return lines.filter((line) => typeof line !== "string");
 }
 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;
-	const explanationLine = buildChannelProgressDraftLine({
-		event: "plan",
-		phase: "update",
-		explanation: snapshot.planExplanation
-	});
-	return explanationLine ? [...lines, explanationLine] : lines;
+	return resolveStructuredProgressLines(snapshot.lines).filter((line) => line.id !== "reasoning" && line.id?.startsWith("commentary:") !== true);
 }
 function resolveNativeProgressNarration(snapshot) {
 	const paragraphs = resolveStructuredProgressLines(snapshot.lines).filter((line) => line.id === "reasoning" || line.id?.startsWith("commentary:") === true).map((line) => line.text.trim()).filter((text, index, values) => Boolean(text) && values.indexOf(text) === index);
@@ -1020,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) {
@@ -1065,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;
 	}
@@ -1156,6 +962,7 @@ function createSlackDraftProgressCardRuntime(params) {
 		return url.toString();
 	};
 	const resolveText = (snapshot) => latestFallbackText || formatChannelProgressDraftText({
+		presentation: "summary",
 		entry: account.config,
 		lines: [...snapshot.lines],
 		seed: params.progressSeed,
@@ -1172,11 +979,7 @@ function createSlackDraftProgressCardRuntime(params) {
 			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() }
+			...state !== "working" ? { sessionUrl: resolveSessionUrl() } : {}
 		});
 	};
 	const finalize = async (status, snapshot = params.getSnapshot(), fallbackText = resolveText(snapshot)) => {
@@ -1336,7 +1139,7 @@ function createSlackProgressRuntime(runtimeParams) {
 		log: logVerbose,
 		warn: logVerbose
 	}) : void 0;
-	let hasStreamedMessage = false;
+	let hasStreamedAnswer = false;
 	const isProgressMode = slackStreaming.mode === "progress";
 	const useNativeProgressStreaming = useStreaming && slackStreaming.mode === "progress";
 	const progressDraftActive = Boolean(draftStream) || useNativeProgressStreaming;
@@ -1362,7 +1165,6 @@ function createSlackProgressRuntime(runtimeParams) {
 		nativeStreamOrder = run.catch(() => void 0);
 		return run;
 	};
-	const progressWorkCounter = createChannelProgressWorkCounter();
 	const progressSeed = `${account.accountId}:${message.channel}`;
 	const slackProgressStyle = resolveSlackProgressStyle(account.config);
 	const useDraftProgressCard = Boolean(draftStream) && isProgressMode && slackProgressStyle === "card";
@@ -1378,7 +1180,6 @@ function createSlackProgressRuntime(runtimeParams) {
 		},
 		draftStream,
 		enabled: useDraftProgressCard,
-		progressWorkCounter,
 		progressSeed,
 		explicitTitle: explicitProgressTitle,
 		maxLineChars: progressDraftMaxLineChars,
@@ -1398,12 +1199,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) {
@@ -1412,11 +1218,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);
@@ -1435,17 +1236,18 @@ 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) ?? "Working",
+				lines: resolveNativeProgressLines(snapshot),
+				plan: snapshot.plan
+			})
 		});
 		const chunks = reconciled.chunks;
 		if (!chunks?.length && !narrationUpdate.delta) return false;
@@ -1469,6 +1271,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;
@@ -1488,24 +1305,28 @@ function createSlackProgressRuntime(runtimeParams) {
 		return true;
 	};
 	const resetProgressTurnState = () => {
-		progressWorkCounter.reset();
 		nativeNarrationRenderedText = "";
 		nativeNarrationSourceText = "";
 	};
 	const progressDraft = createChannelProgressDraftCompositor({
+		presentation: isProgressMode ? "summary" : void 0,
 		entry: account.config,
 		mode: slackStreaming.mode,
 		active: progressDraftActive,
 		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);
@@ -1513,13 +1334,16 @@ function createSlackProgressRuntime(runtimeParams) {
 				text: previewText,
 				blocks: progressCard.resolvePresentation(snapshot, "working")
 			} : previewText);
-			hasStreamedMessage = true;
 			if (options?.flush) await draftStream.flush();
 			return Boolean(draftStream.messageId() && draftStream.channelId());
 		}
 	});
 	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,20 +1368,23 @@ 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 && !narrationUpdate.delta && !sessionUrl) return;
+		const completion = reconcileSlackNativeTaskChunks({
 			previous: nativeStreamSnapshot,
-			chunks: buildSlackProgressStreamCompletionChunks({
+			chunks: buildSlackProgressStreamChunks({
 				title: resolveNativeProgressTitle(snapshot) ?? (lines.length === 0 && !snapshot.plan?.length ? "Working" : void 0),
 				lines,
-				plan: resolveNativeProgressPlan(snapshot),
-				maxLineChars: progressDraftMaxLineChars,
+				plan: snapshot.plan,
 				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);
@@ -1595,10 +1422,7 @@ function createSlackProgressRuntime(runtimeParams) {
 			narration: explanation,
 			plan: steps
 		});
-		if (text) {
-			draftStream.update(text);
-			hasStreamedMessage = true;
-		}
+		if (text) draftStream.update(text);
 		return false;
 	};
 	const pushPreviewProgress = async (line, options) => {
@@ -1613,7 +1437,7 @@ function createSlackProgressRuntime(runtimeParams) {
 		return await progressDraft.pushToolProgress(line, options);
 	};
 	const updateDraftFromPartial = (text) => {
-		const trimmed = text?.trimEnd();
+		const trimmed = text && sanitizeAssistantVisibleText(text).trimEnd();
 		if (!trimmed) return false;
 		if (slackStreaming.mode === "block") {
 			previewToolProgressSuppressed = true;
@@ -1627,14 +1451,14 @@ function createSlackProgressRuntime(runtimeParams) {
 			appendSourceText = next.source;
 			if (!next.changed) return false;
 			draftStream?.update(next.rendered);
-			hasStreamedMessage = true;
+			hasStreamedAnswer = true;
 			return false;
 		}
 		if (isProgressMode) return false;
 		previewToolProgressSuppressed = true;
 		progressDraft.suppress();
 		draftStream?.update(trimmed);
-		hasStreamedMessage = true;
+		hasStreamedAnswer = true;
 		return false;
 	};
 	const pushReasoningProgress = async (payload) => {
@@ -1654,7 +1478,7 @@ function createSlackProgressRuntime(runtimeParams) {
 		return await progressDraft.pushReasoningProgress(payload.text, { snapshot: payload.isReasoningSnapshot === true });
 	};
 	const resetDraftDeliveryState = () => {
-		hasStreamedMessage = false;
+		hasStreamedAnswer = false;
 		appendRenderedText = "";
 		appendSourceText = "";
 	};
@@ -1663,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;
@@ -1677,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();
@@ -1687,7 +1517,7 @@ function createSlackProgressRuntime(runtimeParams) {
 			await beginNewProgressTurn();
 			return;
 		}
-		if (hasStreamedMessage) draftStream?.forceNewMessage();
+		if (hasStreamedAnswer) draftStream?.forceNewMessage();
 		resetDraftDeliveryState();
 		resetDraftProgressState();
 	};
@@ -1700,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();
 	};
@@ -1714,7 +1551,10 @@ function createSlackProgressRuntime(runtimeParams) {
 		suppressDefaultToolProgressMessages,
 		progressDraft,
 		commentaryProgressEnabled,
-		progressWorkCounter,
+		async cancel() {
+			progressDraft.cancel();
+			await cancelNativeUpdates();
+		},
 		get nativeProgressCompletionSent() {
 			return nativeProgressCompletionSent;
 		},
@@ -1742,41 +1582,6 @@ function createSlackProgressRuntime(runtimeParams) {
 	};
 }
 //#endregion
-//#region extensions/slack/src/threading.ts
-function resolveSlackThreadContext(params) {
-	const incomingThreadTs = params.message.thread_ts;
-	const eventTs = params.message.event_ts;
-	const messageTs = params.message.ts ?? eventTs;
-	const hasThreadTs = typeof incomingThreadTs === "string" && incomingThreadTs.length > 0;
-	const isThreadReply = hasThreadTs && (incomingThreadTs !== messageTs || Boolean(params.message.parent_user_id));
-	const replyToId = isThreadReply ? incomingThreadTs : void 0;
-	const isAssistantDmThreadRoot = hasThreadTs && !isThreadReply && params.isDirectMessage === true;
-	return {
-		incomingThreadTs,
-		messageTs,
-		isThreadReply,
-		replyToId,
-		messageThreadId: isThreadReply || isAssistantDmThreadRoot ? incomingThreadTs : params.replyToMode === "all" ? messageTs : void 0
-	};
-}
-/**
-* Resolves Slack thread targeting for replies and status indicators.
-*
-* @returns replyThreadTs - Thread timestamp for reply messages
-* @returns statusThreadTs - Thread timestamp for status indicators (typing, etc.)
-* @returns isThreadReply - true if this is a genuine user reply in a thread,
-*                          false if thread_ts comes from a bot status message (e.g. typing indicator)
-*/
-function resolveSlackThreadTargets(params) {
-	const { incomingThreadTs, messageTs, isThreadReply } = resolveSlackThreadContext(params);
-	const replyThreadTs = isThreadReply ? incomingThreadTs : params.replyToMode === "all" ? messageTs : void 0;
-	return {
-		replyThreadTs,
-		statusThreadTs: replyThreadTs,
-		isThreadReply
-	};
-}
-//#endregion
 //#region extensions/slack/src/monitor/message-handler/dispatch-setup.ts
 async function createSlackDispatchSetup(prepared) {
 	const { ctx, account, message, route } = prepared;
@@ -1854,24 +1659,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,
@@ -1898,10 +1696,7 @@ async function createSlackDispatchSetup(prepared) {
 		agentId: route.agentId,
 		channel: "slack",
 		accountId: route.accountId,
-		transformReplyPayload: (payload) => {
-			if (payload.isReasoning === true) return null;
-			return payload;
-		},
+		transformReplyPayload: sanitizeSlackMonitorReplyPayload,
 		typing: {
 			start: async () => {
 				if (!threadStatusGate.hasVisibleOutput()) {
@@ -2187,7 +1982,6 @@ function createSlackStreamingDeliveryRuntime(setup) {
 		}
 	};
 	const deliverNormally = async (params) => {
-		if (params.payload.isReasoning === true) return;
 		const replyThreadTs = resolveDeliveryThreadTs(params);
 		const deliveryReplyThreadTs = replyDeliveryMode === "off" && !forcedReplyThreadTs && !isThreadReply ? void 0 : replyThreadTs;
 		if (deliveryTracker.hasDelivered({
@@ -2250,7 +2044,6 @@ function createSlackStreamingDeliveryRuntime(setup) {
 		return !state.streamFailed && !reply.hasMedia && renderPlan.mode !== "split" && !plannedBlocks?.length && !readSlackReplyBlocks(payload)?.length && reply.hasText && (!options?.maxTextBytes || countSlackTextUtf8Bytes(reply.trimmedText) <= options.maxTextBytes);
 	};
 	const deliverWithStreaming = async (params) => {
-		if (params.payload.isReasoning === true) return;
 		const reply = resolveSendableOutboundReplyParts(params.payload);
 		if (!isStreamingEligible(params.payload)) {
 			await deliverNormally({
@@ -2452,7 +2245,6 @@ async function dispatchPreparedSlackMessage(prepared) {
 		return payload;
 	};
 	const deliverSlackPayload = async (payload, info) => {
-		if (payload.isReasoning === true) return { visibleReplySent: false };
 		if (info.kind === "final" && slackStreaming.mode === "progress" && progress.isProgressMode) {
 			if (progress.useNativeProgressStreaming) {
 				await progress.deliverNativeFinal(payload, info.kind);
@@ -2503,7 +2295,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;
@@ -2619,6 +2415,7 @@ async function dispatchPreparedSlackMessage(prepared) {
 				sessionKey: route.sessionKey
 			},
 			ctxPayload: prepared.ctxPayload,
+			dispatchReplyFromConfig: ctx.dispatchReplyFromConfig,
 			dispatcherOptions: {
 				...replyPipeline,
 				transformReplyPayload: (payload) => {
@@ -2673,7 +2470,6 @@ async function dispatchPreparedSlackMessage(prepared) {
 				} : 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) => {
@@ -2715,7 +2511,7 @@ async function dispatchPreparedSlackMessage(prepared) {
 	} catch (err) {
 		dispatchError = err;
 	} finally {
-		progress.progressDraft.cancel();
+		await progress.cancel();
 		if (!progress.useDraftProgressCard) await draftStream?.discardPending();
 	}
 	let streamFallbackDelivered = false;
@@ -2748,13 +2544,15 @@ async function dispatchPreparedSlackMessage(prepared) {
 	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,
@@ -2813,7 +2611,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());
@@ -3008,7 +2806,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-DFk0ANVB.js").then((n) => n._));
+const MAX_SLACK_UNAVAILABLE_FILE_TEXT_CHARS = 2e3;
+const loadSlackMediaModule$1 = createLazyRuntimeModule(() => import("./actions-BOxiu2Vy.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 = [];
@@ -3046,8 +2861,9 @@ async function resolveSlackMessageContent(params) {
 		isThreadReply: params.isThreadReply,
 		threadStarter: params.threadStarter
 	});
-	const mediaPromise = ownFiles && ownFiles.length > 0 ? loadSlackMediaModule$1().then(({ resolveSlackMedia }) => resolveSlackMedia({
+	const attachmentContent = ownFiles?.length || params.message.attachments?.length ? await loadSlackMediaModule$1().then(({ resolveSlackAttachmentContent }) => resolveSlackAttachmentContent({
 		files: ownFiles,
+		attachments: params.message.attachments,
 		client: params.client,
 		token: params.botToken,
 		maxBytes: params.mediaMaxBytes,
@@ -3055,30 +2871,9 @@ async function resolveSlackMessageContent(params) {
 		totalTimeoutMs: params.mediaTotalTimeoutMs,
 		abortSignal: params.abortSignal,
 		preloadedMedia: params.preloadedMedia
-	})) : Promise.resolve(null);
-	const attachmentContentPromise = params.message.attachments && params.message.attachments.length > 0 ? loadSlackMediaModule$1().then(({ resolveSlackAttachmentContent }) => resolveSlackAttachmentContent({
-		attachments: params.message.attachments,
-		client: params.client,
-		token: params.botToken,
-		maxBytes: params.mediaMaxBytes,
-		readIdleTimeoutMs: params.mediaReadIdleTimeoutMs,
-		totalTimeoutMs: params.mediaTotalTimeoutMs,
-		abortSignal: params.abortSignal
-	})) : Promise.resolve(null);
-	const [media, attachmentContent] = await Promise.all([mediaPromise, attachmentContentPromise]);
-	const mergedMedia = [...media ?? [], ...attachmentContent?.media ?? []];
-	const effectiveDirectMedia = mergedMedia.length > 0 ? mergedMedia : null;
-	const mediaPlaceholder = effectiveDirectMedia ? effectiveDirectMedia.map((item) => item.placeholder).join(" ") : void 0;
-	const fallbackFileIds = /* @__PURE__ */ new Set();
-	const fallbackFiles = [...ownFiles ?? [], ...attachmentContent?.files ?? []].filter((file) => {
-		const fileId = normalizeOptionalString(file.id);
-		if (!fileId) return true;
-		if (fallbackFileIds.has(fileId)) return false;
-		fallbackFileIds.add(fileId);
-		return true;
-	});
-	const fileOnlyFallback = !mediaPlaceholder && fallbackFiles.length > 0 ? fallbackFiles.slice(0, 8).map((file) => formatSlackFileReference(file)).join(", ") : void 0;
-	const fileOnlyPlaceholder = fileOnlyFallback ? `[Slack file: ${fileOnlyFallback}]` : void 0;
+	})) : null;
+	const effectiveDirectMedia = attachmentContent?.media.length ? attachmentContent.media : null;
+	const mediaPlaceholder = effectiveDirectMedia?.map((item) => item.placeholder).join(" ");
 	let botAttachmentText;
 	if (params.isBotMessage && !attachmentContent?.text) {
 		const botAttachmentTextParts = [];
@@ -3102,7 +2897,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
@@ -3115,23 +2911,20 @@ async function resolveSlackMessageContent(params) {
 			renderedMentions.set(result.userId, result.rendered);
 		}
 	}
-	let rawBody = [
-		renderSlackUserMentions(textParts[0], renderedMentions),
-		renderSlackUserMentions(textParts[1], renderedMentions),
-		renderSlackUserMentions(textParts[2], renderedMentions),
-		mediaPlaceholder,
-		fileOnlyPlaceholder
-	].filter(Boolean).join("\n") || "";
-	const unavailableImageCount = attachmentContent?.unavailableImageCount ?? 0;
-	if (unavailableImageCount > 0) rawBody = formatInboundMediaUnavailableText({
-		body: rawBody,
-		notice: `[slack ${unavailableImageCount > 1 ? `${unavailableImageCount} forwarded images` : "forwarded image"} unavailable]`
+	const rawBody = formatSlackUnavailableMedia({
+		body: [
+			renderSlackUserMentions(textParts[0], renderedMentions),
+			renderSlackUserMentions(textParts[1], renderedMentions),
+			renderSlackUserMentions(textParts[2], renderedMentions),
+			mediaPlaceholder
+		].filter(Boolean).join("\n") || "",
+		files: attachmentContent?.files,
+		unavailableMediaCount: attachmentContent?.unavailableMediaCount ?? 0
 	});
-	if (!rawBody) return null;
-	return {
+	return rawBody ? {
 		rawBody,
 		effectiveDirectMedia
-	};
+	} : null;
 }
 //#endregion
 //#region extensions/slack/src/monitor/message-handler/prepare-dm-history.ts
@@ -3208,7 +3001,8 @@ 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);
+	const raw = params.isDirectMessage ? `user:${params.message.user ?? "unknown"}` : params.message.channel;
+	return qualifySlackConversationId(raw, params.eventScope);
 }
 function resolveSlackInitialAgentRoute(params) {
 	const route = resolveAgentRoute({
@@ -3359,7 +3153,7 @@ function formatSlackThreadLabelSnippet(text) {
 }
 //#endregion
 //#region extensions/slack/src/monitor/message-handler/prepare-thread-context.ts
-const loadSlackMediaModule = createLazyRuntimeModule(() => import("./actions-DFk0ANVB.js").then((n) => n._));
+const loadSlackMediaModule = createLazyRuntimeModule(() => import("./actions-BOxiu2Vy.js").then((n) => n._));
 const SLACK_THREAD_CONTEXT_USER_LOOKUP_CONCURRENCY = 4;
 function resolveSlackThreadSessionFreshness(params) {
 	return params.ctx.channelRuntime?.session?.resolveEntryResetFreshness?.({
@@ -3471,14 +3265,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({
@@ -3498,14 +3302,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,
@@ -3564,7 +3374,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})`,
@@ -3591,7 +3401,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;
@@ -3662,7 +3472,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";
@@ -3796,7 +3606,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,
@@ -3806,7 +3616,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
 	});
@@ -3929,7 +3740,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)}`);
@@ -4022,7 +3834,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;