@openclaw/slack 2026.8.1-beta.3 → 2026.8.1

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

@@ -1,33 +1,34 @@
 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 { I as countSlackTextUtf8Bytes, L as truncateSlackText, M as SLACK_TEXT_LIMIT, Q as normalizeSlackOutboundText, R as truncateSlackTextByUtf8Bytes, T as buildSlackBlocksFallbackText, U as SLACK_SESSION_LINK_ACTION_ID, a as qualifySlackConversationId, b as hasSlackNativeDataBlock, et as escapeSlackMrkdwn, k as SLACK_EDIT_TEXT_MAX_BYTES, m as resolveSlackReplyRenderPlan, o as qualifySlackRoutePeerId, s as resolveSlackEnterpriseMainDmSessionKey } from "./group-policy-BdwszjYn.js";
+import { f as resolveSlackAllowListMatch, l as normalizeAllowListLower, o as formatSlackError, u as normalizeSlackAllowOwnerEntry } from "./probe-0usmAb0i.js";
 import { n as resolveSlackStreamingMode, t as resolveSlackNativeStreaming } from "./streaming-compat-B-e0mqM0.js";
-import { b as 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-BI7JkfVm.js";
+import { c as hasSlackThreadFailureNotice, d as recordSlackThreadFailureNotice, f as recordSlackThreadParticipation, l as hasSlackThreadParticipation, m as buildSlackNativeDataDeliveryPlan, o as clearSlackThreadFailureNotice, r as sendMessageSlack, u as hasSlackThreadParticipationWithPersistence } from "./send-DS9ICrBI.js";
+import { C as resolveStorePath, E as stripSlackMentionsForCommandDetection, S as resolveChannelResetConfig, _ as resolveSlackChatType, b as readSessionUpdatedAt, c as resolveSlackThreadTargets, d as authorizeSlackBotRoomMessage, f as resolveSlackCommandIngress, g as normalizeSlackChannelType, l as trackSlackDraftMessage, o as authorizeSlackDirectMessage, p as resolveSlackEffectiveAllowFrom, r as resolveSlackRoomContextHints, s as resolveSlackThreadContext, u as resolveConversationLabel$1, v as buildSlackAssistantThreadMetadata, w as updateLastRoute, x as resolveChannelContextVisibilityMode, y as parseSlackAssistantThreadMetadata } from "./provider-CN_8hFv2.js";
+import { n as resolveSlackChannelConfig } from "./policy-CtQVbde1.js";
+import { a as resolveDeliveredSlackReplyThreadTs, c as emitSlackMessageSentHooks, i as readSlackReplyBlocks, n as deliverReplies, o as resolveSlackThreadTs, s as sanitizeSlackMonitorReplyPayload, t as createSlackReplyDeliveryPlan } from "./replies-BSiRQOJ1.js";
 import { asOptionalRecord, normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { resolveAgentRoute, resolveInboundLastRouteSessionKey, resolveThreadSessionKeys } from "openclaw/plugin-sdk/routing";
 import { buildChannelProgressDraftLine, buildChannelProgressDraftLineForEntry, createChannelMessageReplyPipeline, createChannelProgressDraftCompositor, createChannelProgressWorkCounter, createFinalizableDraftStreamControlsForState, defineFinalizableLivePreviewAdapter, deliverWithFinalizableLivePreviewAdapter, formatChannelProgressDraftText, formatPlanChecklistLines, isChannelProgressDraftWorkToolName, resolveAgentOutboundIdentity, resolveChannelMessageSourceReplyDeliveryMode, resolveChannelProgressDraftConfig, resolveChannelProgressDraftMaxLineChars, resolveChannelStreamingBlockEnabled, resolveChannelStreamingPreviewToolProgress, resolveChannelStreamingSuppressDefaultToolProgressMessages } from "openclaw/plugin-sdk/channel-outbound";
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 import { danger, logVerbose, shouldLogVerbose } from "openclaw/plugin-sdk/runtime-env";
+import { sanitizeAssistantVisibleText } from "openclaw/plugin-sdk/text-chunking";
+import { resolveMarkdownTableMode } from "openclaw/plugin-sdk/markdown-table-runtime";
+import { buildTtsSupplementMediaPayload, getReplyPayloadTtsSupplement, isReplyPayloadNonTerminalToolErrorWarning, resolveSendableOutboundReplyParts } from "openclaw/plugin-sdk/reply-payload";
 import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import { createHash } from "node:crypto";
 import { pruneMapToMaxSize } from "openclaw/plugin-sdk/collection-runtime";
 import { ensureConfiguredBindingRouteReady } from "openclaw/plugin-sdk/conversation-runtime";
+import { resolveChannelImplicitMentions } from "openclaw/plugin-sdk/channel-ingress-runtime";
 import fs from "node:fs/promises";
 import { runTasksWithConcurrency } from "openclaw/plugin-sdk/concurrency-runtime";
 import { formatErrorMessage, toErrorObject } from "openclaw/plugin-sdk/error-runtime";
-import { 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";
@@ -384,12 +385,12 @@ function createSlackDraftStream(params) {
 	const send = params.send ?? sendMessageSlack;
 	const edit = params.edit ?? editSlackMessage;
 	const remove = params.remove ?? deleteSlackMessage;
-	let streamMessageId;
-	let streamChannelId;
+	let streamMessage;
 	let untrackConversationBoundary;
 	let lastVisibleUpdate;
 	let lastSentKey = "";
-	const detachedMessages = [];
+	const pendingCleanupMessages = [];
+	let cleanupTail = Promise.resolve();
 	const finalizedMessageIds = /* @__PURE__ */ new Set();
 	const streamState = {
 		stopped: false,
@@ -411,8 +412,8 @@ function createSlackDraftStream(params) {
 		if (sentKey === lastSentKey) return;
 		lastSentKey = sentKey;
 		try {
-			if (streamChannelId && streamMessageId) {
-				await edit(streamChannelId, streamMessageId, trimmed, {
+			if (streamMessage) {
+				await edit(streamMessage.channelId, streamMessage.messageId, trimmed, {
 					cfg: params.cfg,
 					token: params.token,
 					accountId: params.accountId,
@@ -444,27 +445,29 @@ function createSlackDraftStream(params) {
 				...params.metadata ? { metadata: params.metadata } : {},
 				...blocks ? { blocks } : {}
 			});
-			streamChannelId = sent.channelId || streamChannelId;
-			streamMessageId = sent.messageId || streamMessageId;
-			if (!streamChannelId || !streamMessageId) {
+			if (!sent.channelId || !sent.messageId) {
 				stopTrackingConversationBoundary();
 				streamState.stopped = true;
 				params.warn?.("slack stream preview stopped (missing identifiers from sendMessage)");
 				return;
 			}
+			streamMessage = {
+				channelId: sent.channelId,
+				messageId: sent.messageId
+			};
 			lastVisibleUpdate = {
 				text: trimmed,
 				...blocks ? { blocks } : {}
 			};
-			if (pendingBoundary && params.conversationChannelId === streamChannelId) pendingBoundary.setMessageTs(streamMessageId);
+			if (pendingBoundary && params.conversationChannelId === streamMessage.channelId) pendingBoundary.setMessageTs(streamMessage.messageId);
 			else {
 				stopTrackingConversationBoundary();
 				untrackConversationBoundary = trackSlackDraftMessage({
 					accountId: params.accountId,
 					teamId: params.eventScope?.teamId,
-					channelId: streamChannelId,
+					channelId: streamMessage.channelId,
 					threadTs,
-					messageTs: streamMessageId,
+					messageTs: streamMessage.messageId,
 					onInterveningMessage: forceNewMessage
 				}).stop;
 			}
@@ -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,8 +567,8 @@ function createSlackDraftStream(params) {
 		forceNewMessage,
 		dropDetachedMessages,
 		finalizeMessage,
-		messageId: () => streamMessageId,
-		channelId: () => streamChannelId
+		messageId: () => streamMessage?.messageId,
+		channelId: () => streamMessage?.channelId
 	};
 }
 //#endregion
@@ -1336,7 +1337,7 @@ function createSlackProgressRuntime(runtimeParams) {
 		log: logVerbose,
 		warn: logVerbose
 	}) : void 0;
-	let hasStreamedMessage = false;
+	let hasStreamedAnswer = false;
 	const isProgressMode = slackStreaming.mode === "progress";
 	const useNativeProgressStreaming = useStreaming && slackStreaming.mode === "progress";
 	const progressDraftActive = Boolean(draftStream) || useNativeProgressStreaming;
@@ -1513,7 +1514,6 @@ function createSlackProgressRuntime(runtimeParams) {
 				text: previewText,
 				blocks: progressCard.resolvePresentation(snapshot, "working")
 			} : previewText);
-			hasStreamedMessage = true;
 			if (options?.flush) await draftStream.flush();
 			return Boolean(draftStream.messageId() && draftStream.channelId());
 		}
@@ -1595,10 +1595,7 @@ function createSlackProgressRuntime(runtimeParams) {
 			narration: explanation,
 			plan: steps
 		});
-		if (text) {
-			draftStream.update(text);
-			hasStreamedMessage = true;
-		}
+		if (text) draftStream.update(text);
 		return false;
 	};
 	const pushPreviewProgress = async (line, options) => {
@@ -1613,7 +1610,7 @@ function createSlackProgressRuntime(runtimeParams) {
 		return await progressDraft.pushToolProgress(line, options);
 	};
 	const updateDraftFromPartial = (text) => {
-		const trimmed = text?.trimEnd();
+		const trimmed = text && sanitizeAssistantVisibleText(text).trimEnd();
 		if (!trimmed) return false;
 		if (slackStreaming.mode === "block") {
 			previewToolProgressSuppressed = true;
@@ -1627,14 +1624,14 @@ function createSlackProgressRuntime(runtimeParams) {
 			appendSourceText = next.source;
 			if (!next.changed) return false;
 			draftStream?.update(next.rendered);
-			hasStreamedMessage = true;
+			hasStreamedAnswer = true;
 			return false;
 		}
 		if (isProgressMode) return false;
 		previewToolProgressSuppressed = true;
 		progressDraft.suppress();
 		draftStream?.update(trimmed);
-		hasStreamedMessage = true;
+		hasStreamedAnswer = true;
 		return false;
 	};
 	const pushReasoningProgress = async (payload) => {
@@ -1654,7 +1651,7 @@ function createSlackProgressRuntime(runtimeParams) {
 		return await progressDraft.pushReasoningProgress(payload.text, { snapshot: payload.isReasoningSnapshot === true });
 	};
 	const resetDraftDeliveryState = () => {
-		hasStreamedMessage = false;
+		hasStreamedAnswer = false;
 		appendRenderedText = "";
 		appendSourceText = "";
 	};
@@ -1687,7 +1684,7 @@ function createSlackProgressRuntime(runtimeParams) {
 			await beginNewProgressTurn();
 			return;
 		}
-		if (hasStreamedMessage) draftStream?.forceNewMessage();
+		if (hasStreamedAnswer) draftStream?.forceNewMessage();
 		resetDraftDeliveryState();
 		resetDraftProgressState();
 	};
@@ -1742,41 +1739,6 @@ function createSlackProgressRuntime(runtimeParams) {
 	};
 }
 //#endregion
-//#region extensions/slack/src/threading.ts
-function resolveSlackThreadContext(params) {
-	const incomingThreadTs = params.message.thread_ts;
-	const eventTs = params.message.event_ts;
-	const messageTs = params.message.ts ?? eventTs;
-	const hasThreadTs = typeof incomingThreadTs === "string" && incomingThreadTs.length > 0;
-	const isThreadReply = hasThreadTs && (incomingThreadTs !== messageTs || Boolean(params.message.parent_user_id));
-	const replyToId = isThreadReply ? incomingThreadTs : void 0;
-	const isAssistantDmThreadRoot = hasThreadTs && !isThreadReply && params.isDirectMessage === true;
-	return {
-		incomingThreadTs,
-		messageTs,
-		isThreadReply,
-		replyToId,
-		messageThreadId: isThreadReply || isAssistantDmThreadRoot ? incomingThreadTs : params.replyToMode === "all" ? messageTs : void 0
-	};
-}
-/**
-* Resolves Slack thread targeting for replies and status indicators.
-*
-* @returns replyThreadTs - Thread timestamp for reply messages
-* @returns statusThreadTs - Thread timestamp for status indicators (typing, etc.)
-* @returns isThreadReply - true if this is a genuine user reply in a thread,
-*                          false if thread_ts comes from a bot status message (e.g. typing indicator)
-*/
-function resolveSlackThreadTargets(params) {
-	const { incomingThreadTs, messageTs, isThreadReply } = resolveSlackThreadContext(params);
-	const replyThreadTs = isThreadReply ? incomingThreadTs : params.replyToMode === "all" ? messageTs : void 0;
-	return {
-		replyThreadTs,
-		statusThreadTs: replyThreadTs,
-		isThreadReply
-	};
-}
-//#endregion
 //#region extensions/slack/src/monitor/message-handler/dispatch-setup.ts
 async function createSlackDispatchSetup(prepared) {
 	const { ctx, account, message, route } = prepared;
@@ -1898,10 +1860,7 @@ async function createSlackDispatchSetup(prepared) {
 		agentId: route.agentId,
 		channel: "slack",
 		accountId: route.accountId,
-		transformReplyPayload: (payload) => {
-			if (payload.isReasoning === true) return null;
-			return payload;
-		},
+		transformReplyPayload: sanitizeSlackMonitorReplyPayload,
 		typing: {
 			start: async () => {
 				if (!threadStatusGate.hasVisibleOutput()) {
@@ -2187,7 +2146,6 @@ function createSlackStreamingDeliveryRuntime(setup) {
 		}
 	};
 	const deliverNormally = async (params) => {
-		if (params.payload.isReasoning === true) return;
 		const replyThreadTs = resolveDeliveryThreadTs(params);
 		const deliveryReplyThreadTs = replyDeliveryMode === "off" && !forcedReplyThreadTs && !isThreadReply ? void 0 : replyThreadTs;
 		if (deliveryTracker.hasDelivered({
@@ -2250,7 +2208,6 @@ function createSlackStreamingDeliveryRuntime(setup) {
 		return !state.streamFailed && !reply.hasMedia && renderPlan.mode !== "split" && !plannedBlocks?.length && !readSlackReplyBlocks(payload)?.length && reply.hasText && (!options?.maxTextBytes || countSlackTextUtf8Bytes(reply.trimmedText) <= options.maxTextBytes);
 	};
 	const deliverWithStreaming = async (params) => {
-		if (params.payload.isReasoning === true) return;
 		const reply = resolveSendableOutboundReplyParts(params.payload);
 		if (!isStreamingEligible(params.payload)) {
 			await deliverNormally({
@@ -2452,7 +2409,6 @@ async function dispatchPreparedSlackMessage(prepared) {
 		return payload;
 	};
 	const deliverSlackPayload = async (payload, info) => {
-		if (payload.isReasoning === true) return { visibleReplySent: false };
 		if (info.kind === "final" && slackStreaming.mode === "progress" && progress.isProgressMode) {
 			if (progress.useNativeProgressStreaming) {
 				await progress.deliverNativeFinal(payload, info.kind);
@@ -2503,7 +2459,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 +2579,7 @@ async function dispatchPreparedSlackMessage(prepared) {
 				sessionKey: route.sessionKey
 			},
 			ctxPayload: prepared.ctxPayload,
+			dispatchReplyFromConfig: ctx.dispatchReplyFromConfig,
 			dispatcherOptions: {
 				...replyPipeline,
 				transformReplyPayload: (payload) => {
@@ -3008,7 +2969,24 @@ async function discardSlackPreflightMedia(media) {
 const SLACK_MENTION_RESOLUTION_CONCURRENCY = 4;
 const SLACK_MENTION_RESOLUTION_MAX_LOOKUPS_PER_MESSAGE = 20;
 const SLACK_USER_MENTION_RE$1 = /<@([A-Z0-9]+)(?:\|[^>]+)?>/gi;
-const loadSlackMediaModule$1 = createLazyRuntimeModule(() => import("./actions-DFk0ANVB.js").then((n) => n._));
+const MAX_SLACK_UNAVAILABLE_FILE_TEXT_CHARS = 2e3;
+const loadSlackMediaModule$1 = createLazyRuntimeModule(() => import("./actions-BI7JkfVm.js").then((n) => n._));
+function formatSlackUnavailableMedia(params) {
+	let fileReferences = params.files?.map((file) => `${formatSlackFileReference(file)} unavailable (${file.reason})`).join(", ");
+	if (fileReferences && fileReferences.length > MAX_SLACK_UNAVAILABLE_FILE_TEXT_CHARS) fileReferences = `${truncateUtf16Safe(fileReferences, MAX_SLACK_UNAVAILABLE_FILE_TEXT_CHARS)}; … (file references truncated)`;
+	const fileBlock = fileReferences ? `[Slack file: ${fileReferences}]` : void 0;
+	const body = [params.body, fileBlock].filter(Boolean).join("\n");
+	if (params.unavailableMediaCount === 0) return body;
+	const notice = `[slack ${params.unavailableMediaCount > 1 ? `${params.unavailableMediaCount} attachments` : "attachment"} unavailable]`;
+	return params.prependUnavailable ? [
+		notice,
+		fileBlock,
+		params.body
+	].filter(Boolean).join("\n") : formatInboundMediaUnavailableText({
+		body,
+		notice
+	});
+}
 function collectUniqueSlackMentionIds$1(texts) {
 	const seen = /* @__PURE__ */ new Set();
 	const mentionIds = [];
@@ -3046,8 +3024,9 @@ async function resolveSlackMessageContent(params) {
 		isThreadReply: params.isThreadReply,
 		threadStarter: params.threadStarter
 	});
-	const mediaPromise = ownFiles && ownFiles.length > 0 ? loadSlackMediaModule$1().then(({ resolveSlackMedia }) => resolveSlackMedia({
+	const attachmentContent = ownFiles?.length || params.message.attachments?.length ? await loadSlackMediaModule$1().then(({ resolveSlackAttachmentContent }) => resolveSlackAttachmentContent({
 		files: ownFiles,
+		attachments: params.message.attachments,
 		client: params.client,
 		token: params.botToken,
 		maxBytes: params.mediaMaxBytes,
@@ -3055,30 +3034,9 @@ async function resolveSlackMessageContent(params) {
 		totalTimeoutMs: params.mediaTotalTimeoutMs,
 		abortSignal: params.abortSignal,
 		preloadedMedia: params.preloadedMedia
-	})) : Promise.resolve(null);
-	const attachmentContentPromise = params.message.attachments && params.message.attachments.length > 0 ? loadSlackMediaModule$1().then(({ resolveSlackAttachmentContent }) => resolveSlackAttachmentContent({
-		attachments: params.message.attachments,
-		client: params.client,
-		token: params.botToken,
-		maxBytes: params.mediaMaxBytes,
-		readIdleTimeoutMs: params.mediaReadIdleTimeoutMs,
-		totalTimeoutMs: params.mediaTotalTimeoutMs,
-		abortSignal: params.abortSignal
-	})) : Promise.resolve(null);
-	const [media, attachmentContent] = await Promise.all([mediaPromise, attachmentContentPromise]);
-	const mergedMedia = [...media ?? [], ...attachmentContent?.media ?? []];
-	const effectiveDirectMedia = mergedMedia.length > 0 ? mergedMedia : null;
-	const mediaPlaceholder = effectiveDirectMedia ? effectiveDirectMedia.map((item) => item.placeholder).join(" ") : void 0;
-	const fallbackFileIds = /* @__PURE__ */ new Set();
-	const fallbackFiles = [...ownFiles ?? [], ...attachmentContent?.files ?? []].filter((file) => {
-		const fileId = normalizeOptionalString(file.id);
-		if (!fileId) return true;
-		if (fallbackFileIds.has(fileId)) return false;
-		fallbackFileIds.add(fileId);
-		return true;
-	});
-	const fileOnlyFallback = !mediaPlaceholder && fallbackFiles.length > 0 ? fallbackFiles.slice(0, 8).map((file) => formatSlackFileReference(file)).join(", ") : void 0;
-	const fileOnlyPlaceholder = fileOnlyFallback ? `[Slack file: ${fileOnlyFallback}]` : void 0;
+	})) : null;
+	const effectiveDirectMedia = attachmentContent?.media.length ? attachmentContent.media : null;
+	const mediaPlaceholder = effectiveDirectMedia?.map((item) => item.placeholder).join(" ");
 	let botAttachmentText;
 	if (params.isBotMessage && !attachmentContent?.text) {
 		const botAttachmentTextParts = [];
@@ -3115,23 +3073,20 @@ async function resolveSlackMessageContent(params) {
 			renderedMentions.set(result.userId, result.rendered);
 		}
 	}
-	let rawBody = [
-		renderSlackUserMentions(textParts[0], renderedMentions),
-		renderSlackUserMentions(textParts[1], renderedMentions),
-		renderSlackUserMentions(textParts[2], renderedMentions),
-		mediaPlaceholder,
-		fileOnlyPlaceholder
-	].filter(Boolean).join("\n") || "";
-	const unavailableImageCount = attachmentContent?.unavailableImageCount ?? 0;
-	if (unavailableImageCount > 0) rawBody = formatInboundMediaUnavailableText({
-		body: rawBody,
-		notice: `[slack ${unavailableImageCount > 1 ? `${unavailableImageCount} forwarded images` : "forwarded image"} unavailable]`
+	const rawBody = formatSlackUnavailableMedia({
+		body: [
+			renderSlackUserMentions(textParts[0], renderedMentions),
+			renderSlackUserMentions(textParts[1], renderedMentions),
+			renderSlackUserMentions(textParts[2], renderedMentions),
+			mediaPlaceholder
+		].filter(Boolean).join("\n") || "",
+		files: attachmentContent?.files,
+		unavailableMediaCount: attachmentContent?.unavailableMediaCount ?? 0
 	});
-	if (!rawBody) return null;
-	return {
+	return rawBody ? {
 		rawBody,
 		effectiveDirectMedia
-	};
+	} : null;
 }
 //#endregion
 //#region extensions/slack/src/monitor/message-handler/prepare-dm-history.ts
@@ -3359,7 +3314,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-BI7JkfVm.js").then((n) => n._));
 const SLACK_THREAD_CONTEXT_USER_LOOKUP_CONCURRENCY = 4;
 function resolveSlackThreadSessionFreshness(params) {
 	return params.ctx.channelRuntime?.session?.resolveEntryResetFreshness?.({
@@ -3471,13 +3426,20 @@ async function resolveSlackThreadContextData(params) {
 		const snippet = formatSlackThreadLabelSnippet(starter.text);
 		threadLabel = `Slack thread ${params.roomLabel}${snippet ? `: ${snippet}` : ""}`;
 		if (shouldSeedInitialThreadContext && !params.effectiveDirectMedia && starter.files && starter.files.length > 0) {
-			const { resolveSlackMedia } = await loadSlackMediaModule();
-			threadStarterMedia = await resolveSlackMedia({
+			const { resolveSlackAttachmentContent } = await loadSlackMediaModule();
+			const attachmentContent = await resolveSlackAttachmentContent({
 				files: starter.files,
 				client: params.eventScope?.client ?? params.ctx.app.client,
 				token: params.ctx.botToken,
 				maxBytes: params.ctx.mediaMaxBytes
 			});
+			threadStarterMedia = attachmentContent?.media.length ? attachmentContent.media : null;
+			if (attachmentContent) threadStarterBody = formatSlackUnavailableMedia({
+				body: threadStarterBody,
+				files: attachmentContent.files,
+				unavailableMediaCount: attachmentContent.unavailableMediaCount,
+				prependUnavailable: true
+			});
 			if (threadStarterMedia) logVerbose(`slack: hydrated thread starter file ${threadStarterMedia.map((item) => item.placeholder).join(", ")} from root message`);
 		}
 	} else threadLabel = `Slack thread ${params.roomLabel}`;
@@ -3498,14 +3460,20 @@ async function resolveSlackThreadContextData(params) {
 	const threadInitialHistoryLimit = params.account.config?.thread?.initialHistoryLimit ?? 20;
 	if (threadInitialHistoryLimit > 0 && shouldLoadInitialThreadHistory) {
 		const currentBotRootTs = starter?.ts ?? params.threadTs;
+		const threadHistory = await resolveSlackThreadHistory({
+			channelId: params.message.channel,
+			threadTs: params.threadTs,
+			client: params.eventScope?.client ?? params.ctx.app.client,
+			currentMessageTs: params.message.ts,
+			limit: threadInitialHistoryLimit
+		});
+		const enrichedStarter = starter && threadStarterBody && threadStarterBody !== starter.text ? {
+			...starter,
+			text: threadStarterBody,
+			ts: currentBotRootTs
+		} : null;
 		const threadHistoryWithBotRoot = ensureSlackThreadHistoryHasBotRoot({
-			history: await resolveSlackThreadHistory({
-				channelId: params.message.channel,
-				threadTs: params.threadTs,
-				client: params.eventScope?.client ?? params.ctx.app.client,
-				currentMessageTs: params.message.ts,
-				limit: threadInitialHistoryLimit
-			}),
+			history: enrichedStarter && !threadHistory.some((entry) => entry.ts === currentBotRootTs) ? [enrichedStarter, ...threadHistory.length >= threadInitialHistoryLimit ? threadHistory.slice(1) : threadHistory] : threadHistory,
 			includeBotStarterAsRootContext,
 			threadStarter: starter ? {
 				...starter,
@@ -3564,7 +3532,7 @@ async function resolveSlackThreadContextData(params) {
 				});
 				const role = isCurrentBot || isOtherBot || Boolean(historyMsg.botId) ? "assistant" : "user";
 				const msgSenderName = isCurrentBot ? "Bot (this assistant)" : msgUser?.name ?? (historyMsg.botId ? `Bot (${historyMsg.botId})` : "Unknown");
-				const msgWithId = `${historyMsg.text}\n[slack message id: ${historyMsg.ts ?? "unknown"} channel: ${params.message.channel}]`;
+				const msgWithId = `${historyMsg.ts === currentBotRootTs && threadStarterBody ? threadStarterBody : historyMsg.text}\n[slack message id: ${historyMsg.ts ?? "unknown"} channel: ${params.message.channel}]`;
 				historyParts.push(formatInboundEnvelope({
 					channel: "Slack",
 					from: `${msgSenderName} (${role})`,

package/dist/{policy-BKXSxrIS.js → policy-CtQVbde1.js}

@@ -1,4 +1,5 @@
-import { f as normalizeSlackSlug, m as resolveSlackUserAllowListForTeam, n as buildSlackChannelPolicyScope, t as buildSlackChannelIdCandidates } from "./group-policy-DyfB_ZIE.js";
+import { n as buildSlackChannelPolicyScope, t as buildSlackChannelIdCandidates } from "./group-policy-BdwszjYn.js";
+import { d as normalizeSlackSlug, p as resolveSlackUserAllowListForTeam } from "./probe-0usmAb0i.js";
 import { applyChannelMatchMeta, buildChannelKeyCandidates } from "openclaw/plugin-sdk/channel-targets";
 import { mergePairLoopGuardConfig } from "openclaw/plugin-sdk/pair-loop-guard-runtime";
 //#region extensions/slack/src/monitor/channel-config.ts