@openclaw/slack 2026.9.6 → 2026.9.7

package/dist/.setup/{pipeline.runtime-BlPOexmJ.mjs → pipeline.runtime-B1H63Frf.mjs}

@@ -1,27 +1,29 @@
-import { A as countSlackTextUtf8Bytes, C as buildSlackBlocksFallbackText, E as SLACK_EDIT_TEXT_MAX_BYTES, H as SLACK_SESSION_LINK_ACTION_ID, M as truncateSlackTextByUtf8Bytes, Pt as resolveSlackReplyToMode, Y as normalizeSlackOutboundText, c as qualifySlackRoutePeerId, j as truncateSlackText, k as SLACK_TEXT_LIMIT, ot as escapeSlackMrkdwn, v as hasSlackNativeDataBlock } from "./session-status-Cf7AvWOt.mjs";
-import { n as formatSlackTarget } from "./target-parsing-DEsPjngB.mjs";
-import { A as resolveSlackUserAllowed, E as normalizeSlackAllowOwnerEntry, T as normalizeAllowListLower, o as formatSlackError } from "./probe-DiYIMPJo.mjs";
-import { a as prepareSlackReply, l as resolveSlackReplyRenderPlan } from "./reply-blocks-Bm8kf6mK.mjs";
-import { n as resolveSlackReplyThreadTs } from "./thread-ts-CukseRVL.mjs";
-import { n as resolveSlackStreamingMode, t as resolveSlackNativeStreaming } from "./streaming-compat-B-e0mqM0.mjs";
-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-DKCtBgCI.mjs";
-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-Cp6omkOg.mjs";
-import { A as resolveChannelContextVisibilityMode, D as readSlackAssistantThreadContext, E as buildSlackAssistantThreadMetadata, F as stripSlackMentionsForCommandDetection, M as resolveStorePath, N as updateLastRoute, O as getSessionEntry, T as resolveSlackChatType, _ as SlackStreamNotDeliveredError, b as startSlackStream, d as resolveSlackRoutingContext, f as registerSlackSessionRun, g as resolveSlackEffectiveAllowFrom, h as resolveSlackCommandIngress, j as resolveChannelResetConfig, k as readSessionUpdatedAt, l as authorizeSlackDirectMessage, m as authorizeSlackBotRoomMessage, o as resolveSlackRoomContextHints, p as resolveSlackThreadTargets, r as trackSlackDraftMessage, u as resolveConversationLabel, v as appendSlackStream, w as normalizeSlackChannelType, x as stopSlackStream, y as markSlackStreamFallbackDelivered } from "./provider-C-jPaGt2.mjs";
-import { n as resolveSlackChannelConfig } from "./policy-BApW53pI.mjs";
-import { a as resolveSlackThreadTs, i as readSlackReplyBlocks, n as deliverReplies, o as sanitizeSlackMonitorReplyPayload, s as emitSlackMessageSentHooks, t as createSlackReplyDeliveryPlan } from "./replies-BBAJxUOQ.mjs";
-import { asOptionalRecord, normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { i as __reExport, n as resolveSlackStreamingMode, r as __exportAll, t as resolveSlackNativeStreaming } from "./streaming-compat-C5Wut626.mjs";
+import { f as resolveSlackReplyToMode } from "./accounts-D_N9IqNA.mjs";
+import { n as formatSlackTarget } from "./target-parsing-FFE26kOV.mjs";
+import { A as countSlackTextUtf8Bytes, C as buildSlackBlocksFallbackText, E as SLACK_EDIT_TEXT_MAX_BYTES, H as SLACK_SESSION_LINK_ACTION_ID, M as truncateSlackTextByUtf8Bytes, Q as normalizeSlackOutboundText, c as qualifySlackRoutePeerId, j as truncateSlackText, k as SLACK_TEXT_LIMIT, lt as escapeSlackMrkdwn, v as hasSlackNativeDataBlock, w as buildSlackCompleteBlocksFallbackText } from "./session-status-DscajIsd.mjs";
+import { D as normalizeSlackAllowOwnerEntry, j as resolveSlackUserAllowed, o as formatSlackError, v as readLruMapEntry, y as writeLruMapEntry } from "./probe-B2Y9qc_z.mjs";
+import { a as prepareSlackReply, l as resolveSlackReplyRenderPlan, s as resolveSlackReplyBlocks } from "./reply-blocks-SE1kTE3I.mjs";
+import { n as resolveSlackReplyThreadTs } from "./thread-ts-Cvt7WD6B.mjs";
+import { C as hasSlackTableBlock, D as buildSlackEditTextPayload, E as resolveSlackMessageText$1, T as resolveSlackBlocksText, a as editSlackRenderedMessage, b as formatSlackFileReference, d as reactSlackMessage, i as editSlackMessage, m as removeSlackReaction, n as deleteSlackMessage, w as isSlackUnfurlAttachment, x as formatSlackFileReferenceList } from "./actions-Df0CzcDl.mjs";
+import { c as hasSlackThreadParticipationWithPersistence, i as clearSlackThreadFailureNotice, l as recordSlackThreadFailureNotice, o as hasSlackThreadFailureNotice, p as buildSlackNativeDataDeliveryPlan, s as hasSlackThreadParticipation, t as sendMessageSlack, u as recordSlackThreadParticipation } from "./send-BOVLQi3n.mjs";
+import { n as resolveSlackChannelConfig } from "./policy-D-jfM174.mjs";
+import { C as resolveSlackChatType, E as stripSlackMentionsForCommandDetection, S as normalizeSlackChannelType, T as readSlackAssistantThreadContext, _ as appendSlackStream, b as stopSlackStream, c as resolveSlackRoutingContext, g as SlackStreamNotDeliveredError, h as resolveSlackEffectiveAllowFrom, i as resolveSlackRoomContextHints, l as registerSlackSessionRun, m as resolveSlackCommandIngress, p as authorizeSlackBotRoomMessage, r as trackSlackDraftMessage, s as authorizeSlackDirectMessage, u as resolveSlackThreadContext, v as markSlackStreamFallbackDelivered, w as buildSlackAssistantThreadMetadata, y as startSlackStream } from "./monitor-BPVfkumU.mjs";
+import { a as emitSlackMessageSentHooks, i as sanitizeSlackMonitorReplyPayload, n as deliverReplies, t as createSlackReplyDeliveryPlan } from "./replies-BAnUtr2f.mjs";
+import { asOptionalRecord, normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeOptionalString, readNonBlankString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { resolveInboundLastRouteSessionKey } from "openclaw/plugin-sdk/routing";
-import { buildChannelProgressDraftLine, createChannelMessageReplyPipeline, createChannelProgressDraftCompositor, createChannelProgressWorkCounter, createDraftStreamLoop, createFinalizableDraftLifecycle, createLivePreviewLifecycle, createMessageReceiptFromOutboundResults, formatChannelProgressDraftDiffStat, formatChannelProgressDraftText, formatPlanChecklistLines, resolveAgentOutboundIdentity, resolveChannelMessageSourceReplyDeliveryMode, resolveChannelProgressDraftConfig, resolveChannelProgressDraftMaxLineChars, resolveChannelStreamingBlockEnabled, resolveChannelStreamingPreviewToolProgress, resolveChannelStreamingSuppressDefaultToolProgressMessages } from "openclaw/plugin-sdk/channel-outbound";
+import { buildChannelProgressDraftLine, createChannelMessageReplyPipeline, createChannelProgressDraftCompositor, createChannelProgressWorkCounter, createDraftStreamLoop, createFinalizableDraftLifecycle, createLivePreviewLifecycle, createMessageReceiptFromOutboundResults, formatChannelProgressDraftDiffStat, formatPlanChecklistLines, resolveAgentOutboundIdentity, resolveChannelMessageSourceReplyDeliveryMode, resolveChannelProgressDraftConfig, resolveChannelProgressDraftMaxLineChars, resolveChannelStreamingBlockEnabled, resolveChannelStreamingPreviewToolProgress, resolveChannelStreamingSuppressDefaultToolProgressMessages } from "openclaw/plugin-sdk/channel-outbound";
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 import { danger, logVerbose, shouldLogVerbose } from "openclaw/plugin-sdk/runtime-env";
 import { sanitizeAssistantVisibleText } from "openclaw/plugin-sdk/text-chunking";
 import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
+import { normalizeStringEntriesLower } from "openclaw/plugin-sdk/string-normalization-runtime";
+import { pruneMapToMaxSize } from "openclaw/plugin-sdk/collection-runtime";
 import { resolveMarkdownTableMode } from "openclaw/plugin-sdk/markdown-table-runtime";
 import { buildTtsSupplementMediaPayload, getReplyPayloadTtsSupplement, isReplyPayloadNonTerminalToolErrorWarning, resolveSendableOutboundReplyParts } from "openclaw/plugin-sdk/reply-payload";
 import { asDateTimestampMs, asFiniteNumberInRange, parseStrictFiniteNumber, resolveExpiresAtMsFromDurationMs, resolvePromptHistoryLimit } from "openclaw/plugin-sdk/number-runtime";
 import { hash } from "node:crypto";
-import { pruneMapToMaxSize } from "openclaw/plugin-sdk/collection-runtime";
-import { ensureConfiguredBindingRouteReady } from "openclaw/plugin-sdk/conversation-runtime";
+import { ensureConfiguredBindingRouteReady, resolveConversationLabel } 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";
@@ -29,16 +31,18 @@ import { formatErrorMessage, toErrorObject } from "openclaw/plugin-sdk/error-run
 import { filterSupplementalContextItems, resolvePinnedMainDmOwnerFromAllowlist, shouldIncludeSupplementalContext } from "openclaw/plugin-sdk/security-runtime";
 import { mimeTypeFromFilePath } from "openclaw/plugin-sdk/media-mime";
 import { mergePairLoopGuardConfig } from "openclaw/plugin-sdk/pair-loop-guard-runtime";
+import { getSessionEntry, readSessionUpdatedAt, resolveChannelResetConfig, resolveStorePath, updateLastRoute } from "openclaw/plugin-sdk/session-store-runtime";
 import { resolveHumanDelayConfig } from "openclaw/plugin-sdk/agent-runtime";
 import { enqueueRoutedSystemEvent } from "openclaw/plugin-sdk/system-event-runtime";
 import { getGlobalHookRunner } from "openclaw/plugin-sdk/plugin-runtime";
-import { buildChannelInboundEventContext, buildMentionRegexes, classifyChannelInboundEvent, dispatchChannelInboundTurn, formatInboundEnvelope, formatInboundMediaUnavailableText, hasVisibleInboundReplyDispatch, implicitMentionKindWhen, isGroupThreadRouteExclusive, matchesMentionWithExplicit, readAgentRunTerminalOutcome, resolveEnvelopeFormatOptions, resolveGroupThreadConfig, resolveGroupThreadMentionFacts, resolveInboundMentionDecision, resolveInboundReplyDispatchCounts, resolveUnmentionedGroupInboundPolicy, toInboundMediaFactsWithMetadata } from "openclaw/plugin-sdk/channel-inbound";
+import { buildChannelInboundEventContext, buildMentionRegexes, classifyChannelInboundEvent, dispatchChannelInboundTurn, formatInboundEnvelope, formatInboundMediaUnavailableText, hasVisibleInboundReplyDispatch, isGroupThreadRouteExclusive, matchesMentionWithExplicit, readAgentRunTerminalOutcome, resolveEnvelopeFormatOptions, resolveGroupThreadConfig, resolveGroupThreadMentionFacts, resolveInboundMentionDecision, resolveInboundReplyDispatchCounts, resolveUnmentionedGroupInboundPolicy, toInboundMediaFactsWithMetadata } from "openclaw/plugin-sdk/channel-inbound";
 import { resolveGatewayPublicOrigin } from "openclaw/plugin-sdk/config-contracts";
 import { buildControlUiSessionPath } from "openclaw/plugin-sdk/session-discussion";
 import { createStatusReactionController, logAckFailure, logTypingFailure, resolveAckReaction, shouldAckReaction } from "openclaw/plugin-sdk/channel-feedback";
 import { hasControlCommand } from "openclaw/plugin-sdk/command-detection";
 import { isAbortRequestText } from "openclaw/plugin-sdk/command-primitives-runtime";
 import { shouldHandleTextCommands } from "openclaw/plugin-sdk/command-surface";
+import { resolveChannelContextVisibilityMode } from "openclaw/plugin-sdk/context-visibility-runtime";
 import { DEFAULT_GROUP_HISTORY_LIMIT, buildHistoryContextFromEntries, buildInboundHistoryFromEntries } from "openclaw/plugin-sdk/reply-history";
 import { createChannelPreflightAudio, formatAudioTranscriptForAgent } from "openclaw/plugin-sdk/media-understanding-runtime";
 //#region extensions/slack/src/monitor/message-handler/timestamp.ts
@@ -55,9 +59,6 @@ function resolveSlackTimestampMs(ts) {
 }
 //#endregion
 //#region extensions/slack/src/monitor/message-handler/dispatch-helpers.ts
-function resolveSlackMessageTimestampMs(message) {
-	return resolveSlackTimestampMs(message.event_ts ?? message.ts);
-}
 function resolveSlackBotLoopProtection(prepared) {
 	const senderBotId = prepared.message.bot_id;
 	if (!senderBotId) return;
@@ -71,7 +72,7 @@ function resolveSlackBotLoopProtection(prepared) {
 		config: mergePairLoopGuardConfig(prepared.account.config.botLoopProtection, prepared.channelConfig?.botLoopProtection),
 		defaultsConfig: prepared.ctx.cfg.channels?.defaults?.botLoopProtection,
 		defaultEnabled: true,
-		nowMs: resolveSlackMessageTimestampMs(prepared.message)
+		nowMs: resolveSlackTimestampMs(prepared.message.event_ts ?? prepared.message.ts)
 	};
 }
 function isSlackStreamingEnabled(params) {
@@ -89,26 +90,14 @@ function resolveExplicitSlackProgressTitle(entry) {
 	const trimmed = label.trim();
 	return trimmed && trimmed.toLowerCase() !== "auto" ? trimmed : void 0;
 }
-function resolveSlackProgressStyle(entry) {
+function resolveSlackProgressStyle(entry, hasReplyThread) {
 	const progress = entry?.streaming?.progress;
+	if (!hasReplyThread && !Object.entries(progress ?? {}).some(([key, value]) => key !== "nativeTaskCards" || value !== true)) return "none";
 	return progress?.style ?? (progress?.toolProgress === false ? "compact" : "card");
 }
-function resolveSlackNativeProgressTaskCards(entry) {
-	if (resolveSlackProgressStyle(entry) === "compact") return false;
-	const streaming = entry?.streaming;
-	if (!streaming || typeof streaming !== "object" || Array.isArray(streaming)) return true;
-	const progressConfig = streaming.progress;
-	if (!progressConfig || typeof progressConfig !== "object" || Array.isArray(progressConfig)) return true;
-	return progressConfig.nativeTaskCards !== false;
-}
-function resolveSlackStreamingThreadHint(params) {
-	return resolveSlackThreadTs({
-		replyToMode: params.replyToMode,
-		incomingThreadTs: params.incomingThreadTs,
-		messageTs: params.messageTs,
-		hasReplied: false,
-		isThreadReply: params.isThreadReply
-	});
+function resolveSlackNativeProgressTaskCards(entry, style) {
+	if (style !== "card") return false;
+	return entry?.streaming?.progress?.nativeTaskCards !== false;
 }
 const SLACK_STREAM_RECIPIENT_TEAM_CACHE_MAX = 2e3;
 const slackStreamRecipientTeamCaches = /* @__PURE__ */ new WeakMap();
@@ -123,7 +112,7 @@ function buildSlackEventDeliveryKey(params, preparedReply = prepareSlackReply(pa
 	const reply = resolveSendableOutboundReplyParts(params.payload, { text: params.textOverride });
 	const renderPlan = preparedReply.resolvePreview(params.textOverride);
 	const plannedBlocks = renderPlan.mode === "single" ? renderPlan.blocks : renderPlan.blockPart?.blocks;
-	const slackBlocks = readSlackReplyBlocks(params.payload) ?? plannedBlocks;
+	const slackBlocks = resolveSlackReplyBlocks(params.payload) ?? plannedBlocks;
 	const renderedText = renderPlan.mode === "single" ? renderPlan.text : renderPlan.fallbackText;
 	if (!reply.hasContent && !slackBlocks?.length && !renderedText.trim()) return null;
 	return JSON.stringify({
@@ -135,27 +124,6 @@ function buildSlackEventDeliveryKey(params, preparedReply = prepareSlackReply(pa
 		blocks: slackBlocks ?? null
 	});
 }
-function readSlackStreamRecipientTeamCache(params) {
-	if (!params.fallbackTeamId || !params.userId) return;
-	const cacheKey = `${params.fallbackTeamId}:${params.userId}`;
-	const cache = getSlackStreamRecipientTeamCache(params.client);
-	const cached = cache.get(cacheKey);
-	if (!cached) return;
-	cache.delete(cacheKey);
-	cache.set(cacheKey, cached);
-	return cached;
-}
-function rememberSlackStreamRecipientTeam(params) {
-	if (!params.fallbackTeamId || !params.userId) return;
-	const cacheKey = `${params.fallbackTeamId}:${params.userId}`;
-	const cache = getSlackStreamRecipientTeamCache(params.client);
-	if (cache.has(cacheKey)) cache.delete(cacheKey);
-	cache.set(cacheKey, params.teamId);
-	if (cache.size > SLACK_STREAM_RECIPIENT_TEAM_CACHE_MAX) {
-		const oldest = cache.keys().next().value;
-		if (oldest) cache.delete(oldest);
-	}
-}
 function createSlackEventDeliveryTracker() {
 	const deliveredKeys = /* @__PURE__ */ new Set();
 	return {
@@ -176,7 +144,9 @@ function shouldUseStreaming(params) {
 	return true;
 }
 async function resolveSlackStreamRecipientTeamId(params) {
-	const cachedTeamId = readSlackStreamRecipientTeamCache(params);
+	const cacheKey = params.fallbackTeamId && params.userId ? `${params.fallbackTeamId}:${params.userId}` : void 0;
+	const cache = cacheKey ? getSlackStreamRecipientTeamCache(params.client) : void 0;
+	const cachedTeamId = cache && cacheKey ? readLruMapEntry(cache, cacheKey) : void 0;
 	if (cachedTeamId) return cachedTeamId;
 	if (params.userId) try {
 		const info = await params.client.users.info({
@@ -185,10 +155,7 @@ async function resolveSlackStreamRecipientTeamId(params) {
 		});
 		const teamId = info.user?.team_id ?? info.user?.profile?.team;
 		if (teamId) {
-			rememberSlackStreamRecipientTeam({
-				...params,
-				teamId
-			});
+			if (cache && cacheKey) writeLruMapEntry(cache, cacheKey, teamId, SLACK_STREAM_RECIPIENT_TEAM_CACHE_MAX);
 			return teamId;
 		}
 	} catch (err) {
@@ -217,6 +184,11 @@ function createSlackDraftStream(params) {
 		final: false
 	};
 	const normalizeUpdate = (update) => typeof update === "string" ? { text: update } : update;
+	const clearMessageId = () => {
+		streamMessage = void 0;
+		lastVisibleUpdate = void 0;
+		lastSentKey = "";
+	};
 	const sendOrEditStreamMessage = async (pending) => {
 		if (streamState.stopped) return;
 		const update = normalizeUpdate(pending);
@@ -316,11 +288,7 @@ function createSlackDraftStream(params) {
 		emptyValue: "",
 		isEmpty: (value) => !normalizeUpdate(value).text.trim(),
 		readMessageId: () => streamMessage,
-		clearMessageId: () => {
-			streamMessage = void 0;
-			lastVisibleUpdate = void 0;
-			lastSentKey = "";
-		},
+		clearMessageId,
 		isValidMessageId: (value) => typeof value === "object" && value !== null,
 		deleteMessage: async (message) => {
 			if (message.generation > cleanupGeneration) return false;
@@ -359,9 +327,7 @@ function createSlackDraftStream(params) {
 				await discardPendingAndStopTracking();
 				if (generation === streamGeneration) {
 					clearingMessage = streamMessage;
-					streamMessage = void 0;
-					lastVisibleUpdate = void 0;
-					lastSentKey = "";
+					clearMessageId();
 				}
 			}
 			cleanupGeneration = generation;
@@ -384,9 +350,7 @@ function createSlackDraftStream(params) {
 			streamMessage.detachedByHuman = reason === "human";
 			lifecycle.retire(streamMessage, { defer: true });
 		}
-		streamMessage = void 0;
-		lastVisibleUpdate = void 0;
-		lastSentKey = "";
+		clearMessageId();
 		loop.resetPending();
 	};
 	const finalizeMessage = async (messageId, editFinal) => {
@@ -487,12 +451,11 @@ const SLACK_PROGRESS_TASK_TITLE_MAX = 120;
 const SLACK_PROGRESS_PLAN_FALLBACK_TITLE = "Thinking";
 const SLACK_PROGRESS_LINE_DELTA_RE = /(?:^|\s)\+(\d+)\s+[−-](\d+)(?=\s|$)/u;
 const SLACK_ATTENTION_TASK_PREFIX = "openclaw-attention-";
-function buildSessionSources(url) {
-	return [{
+function buildSessionSources(links) {
+	return links.map((link) => ({
 		type: "url_source",
-		url,
-		text: "Open in OpenClaw"
-	}];
+		...link
+	}));
 }
 function field(text) {
 	return {
@@ -648,12 +611,13 @@ function buildSlackProgressStreamChunks(params) {
 		});
 	}
 	const headline = params.title?.trim() || params.label?.trim();
+	const summaryTitle = params.finalInProgressStatus === "error" ? "Failed" : params.finalInProgressStatus === "complete" || !params.summaryRow ? "Completed" : "Working";
 	const newest = tasks.at(-1);
-	const title = compactChunkText(headline || (newest?.details ? `${newest.title} — ${newest.details}` : newest?.title) || (params.summaryRow ? "Working" : attention.at(-1)?.title) || SLACK_PROGRESS_PLAN_FALLBACK_TITLE);
+	const title = compactChunkText(headline || (newest?.details ? `${newest.title} — ${newest.details}` : newest?.title) || (params.summaryRow ? summaryTitle : attention.at(-1)?.title) || SLACK_PROGRESS_PLAN_FALLBACK_TITLE);
 	const diffOutput = formatTaskDiffOutput(params.diffStat);
-	if (tasks.length === 0 && (params.summaryRow || params.sessionUrl || diffOutput)) tasks.push({
+	if (tasks.length === 0 && (params.summaryRow || params.sessionLinks?.length || diffOutput)) tasks.push({
 		id: "openclaw_summary",
-		title: params.summaryRow ? compactTitle(title) : "Completed",
+		title: params.summaryRow ? compactTitle(title) : summaryTitle,
 		status: params.finalInProgressStatus ?? (params.summaryRow ? "in_progress" : "complete")
 	});
 	tasks.push(...attention);
@@ -675,7 +639,7 @@ function buildSlackProgressStreamChunks(params) {
 		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);
+		if (index === finalTaskIndex && params.sessionLinks?.length) chunk.sources = buildSessionSources(params.sessionLinks);
 		return chunk;
 	});
 	return [{
@@ -727,7 +691,7 @@ function buildSlackProgressCardBlocks(params) {
 		buildActivityText(params.lines.filter((line) => line.kind !== "approval" && lineTaskStatus(line) !== "error"), maxLineChars),
 		joinRecentProgressRows(attention)
 	];
-	const title = params.title.trim() || "Working";
+	const title = params.title?.trim() || (params.state === "working" ? "Working" : params.state === "success" ? "Done" : "Failed");
 	const blocks = [
 		params.titleFormat === "plain" ? progressTextSection({
 			text: `${icon} ${title}`,
@@ -746,17 +710,17 @@ function buildSlackProgressCardBlocks(params) {
 		type: "context",
 		elements: [field(footer)]
 	});
-	if (params.state !== "working" && params.sessionUrl) blocks.push({
+	if (params.state !== "working" && params.sessionLinks?.length) blocks.push({
 		type: "actions",
-		elements: [{
+		elements: params.sessionLinks.map((link, index) => ({
 			type: "button",
-			action_id: SLACK_SESSION_LINK_ACTION_ID,
+			action_id: index === 0 ? SLACK_SESSION_LINK_ACTION_ID : `${SLACK_SESSION_LINK_ACTION_ID}:${index}`,
 			text: {
 				type: "plain_text",
-				text: "Open in OpenClaw"
+				text: link.text
 			},
-			url: params.sessionUrl
-		}]
+			url: link.url
+		}))
 	});
 	return blocks.slice(0, 50);
 }
@@ -941,25 +905,20 @@ function blocksMatch(expected, actual) {
 	}
 }
 async function readSlackMessageAfterEditError(params) {
-	if (params.threadTs) return ((await params.client.conversations.replies({
-		token: params.token,
-		channel: params.channelId,
-		ts: params.threadTs,
-		latest: params.messageId,
-		oldest: params.messageId,
-		inclusive: true,
-		limit: 1
-	})).messages ?? []).find((message) => message?.ts === params.messageId) ?? null;
-	const message = (await params.client.conversations.history({
+	const query = {
 		token: params.token,
 		channel: params.channelId,
 		latest: params.messageId,
 		oldest: params.messageId,
 		inclusive: true,
 		limit: 1
-	})).messages?.[0];
-	if (!message?.ts || message.ts !== params.messageId) return null;
-	return message;
+	};
+	const result = params.threadTs ? await params.client.conversations.replies({
+		...query,
+		ts: params.threadTs
+	}) : await params.client.conversations.history(query);
+	const message = params.threadTs ? result.messages?.find((entry) => entry?.ts === params.messageId) : result.messages?.[0];
+	return message?.ts && message.ts === params.messageId ? message : null;
 }
 async function didSlackPreviewEditApplyAfterError(params) {
 	const readback = await readSlackMessageAfterEditError(params);
@@ -986,15 +945,7 @@ async function finalizeSlackPreviewEdit(params) {
 		});
 	} catch (err) {
 		try {
-			if (await didSlackPreviewEditApplyAfterError({
-				client: params.client,
-				token: params.token,
-				channelId: params.channelId,
-				messageId: params.messageId,
-				text: params.text,
-				blocks: params.blocks,
-				threadTs: params.threadTs
-			})) {
+			if (await didSlackPreviewEditApplyAfterError(params)) {
 				logVerbose(`slack: preview final edit response failed but readback matched message ${params.channelId}/${params.messageId}; suppressing duplicate fallback send`);
 				return;
 			}
@@ -1006,37 +957,39 @@ async function finalizeSlackPreviewEdit(params) {
 }
 //#endregion
 //#region extensions/slack/src/monitor/message-handler/dispatch-progress-card.ts
+const MAX_VISIBLE_WORK_LINKS = 5;
 function createSlackDraftProgressCardRuntime(params) {
 	const { account, cfg, ctx, prepared, slackClient } = params.setup;
-	let latestFallbackText = "";
 	let finalStatus;
-	const resolveSessionUrl = () => {
-		if (cfg.gateway?.controlUi?.enabled === false) return;
+	const visibleWorkSessions = /* @__PURE__ */ new Map();
+	const resolveSessionLinks = () => {
+		if (visibleWorkSessions.size > 0) return [...visibleWorkSessions.values()].slice(0, MAX_VISIBLE_WORK_LINKS).map((session, index) => {
+			const label = session.label?.replace(/\s+/g, " ").trim();
+			return {
+				url: session.url,
+				text: visibleWorkSessions.size === 1 ? "Open work session" : truncateSlackText(label ? `Open ${label}` : `Open work session ${index + 1}`, 75)
+			};
+		});
+		if (cfg.gateway?.controlUi?.enabled === false) return [];
 		const publicOrigin = resolveGatewayPublicOrigin(cfg);
-		if (!publicOrigin) return;
+		if (!publicOrigin) return [];
 		const url = new URL(publicOrigin);
 		const path = buildControlUiSessionPath({
 			namespace: "chat",
-			sessionKey: prepared.route.sessionKey,
+			sessionKey: prepared.ctxPayload.SessionKey ?? prepared.route.sessionKey,
 			fallbackAgentId: prepared.route.agentId,
+			mainKey: cfg.session?.mainKey,
 			basePath: cfg.gateway?.controlUi?.basePath
 		});
-		if (!path) return;
+		if (!path) return [];
 		url.pathname = path;
-		return url.toString();
+		return [{
+			url: url.toString(),
+			text: "Open in OpenClaw"
+		}];
 	};
-	const resolveText = (snapshot) => latestFallbackText || formatChannelProgressDraftText({
-		entry: account.config,
-		lines: [...snapshot.lines],
-		seed: params.progressSeed,
-		formatLine: formatSlackProgressDraftLine,
-		narration: snapshot.statusHeadline,
-		narrationFormat: snapshot.statusHeadlineFormat,
-		plan: snapshot.plan,
-		diffStat: snapshot.diffStat
-	});
 	const resolvePresentation = (snapshot, state) => {
-		const title = params.explicitTitle ?? snapshot.statusHeadline ?? "Working";
+		const title = params.explicitTitle ?? snapshot.statusHeadline;
 		const titleFormat = params.explicitTitle ? void 0 : snapshot.statusHeadlineFormat;
 		const narration = params.explicitTitle ? snapshot.statusHeadlineFormat === "plain" || snapshot.planExplanationFormat === "plain" ? [...snapshot.statusHeadline && (snapshot.statusHeadline !== snapshot.planExplanation || snapshot.statusHeadlineFormat !== snapshot.planExplanationFormat) ? [{
 			text: snapshot.statusHeadline,
@@ -1049,7 +1002,7 @@ function createSlackDraftProgressCardRuntime(params) {
 			format: snapshot.planExplanationFormat
 		}] : void 0;
 		const workCounter = state === "working" ? params.progressWorkCounter : void 0;
-		const sessionUrl = state === "working" ? void 0 : resolveSessionUrl();
+		const sessionLinks = state === "working" ? [] : resolveSessionLinks();
 		return buildSlackProgressCardBlocks({
 			state,
 			title,
@@ -1061,10 +1014,10 @@ function createSlackDraftProgressCardRuntime(params) {
 			diffStat: snapshot.diffStat,
 			toolCalls: workCounter?.toolCalls,
 			elapsedSeconds: workCounter?.elapsedSeconds,
-			sessionUrl
+			sessionLinks
 		});
 	};
-	const finalize = async (status, snapshot = params.getSnapshot(), fallbackText = resolveText(snapshot)) => {
+	const finalize = async (status, snapshot = params.getSnapshot()) => {
 		if (!params.draftStream || !params.enabled) return false;
 		await params.draftStream.dropDetachedMessages();
 		const terminalStatus = finalStatus === "error" || status === "error" ? "error" : "success";
@@ -1076,14 +1029,15 @@ function createSlackDraftProgressCardRuntime(params) {
 		await params.draftStream.seal();
 		try {
 			const finalized = await params.draftStream.finalizeMessage(messageId, async () => {
+				const blocks = resolvePresentation(snapshot, terminalStatus);
 				await finalizeSlackPreviewEdit({
 					client: slackClient,
 					token: ctx.botToken,
 					accountId: account.accountId,
 					channelId,
 					messageId,
-					text: fallbackText,
-					blocks: resolvePresentation(snapshot, terminalStatus),
+					text: buildSlackCompleteBlocksFallbackText(blocks),
+					blocks,
 					threadTs: params.getThreadTs()
 				});
 			});
@@ -1095,19 +1049,18 @@ function createSlackDraftProgressCardRuntime(params) {
 		}
 	};
 	return {
-		resolveSessionUrl,
-		resolveText,
+		resolveSessionLinks,
+		onVisibleWorkSessions: (sessions) => {
+			for (const session of sessions) if (!visibleWorkSessions.has(session.sessionKey)) visibleWorkSessions.set(session.sessionKey, session);
+		},
 		resolvePresentation,
 		finalize,
 		get hasTerminalized() {
 			return finalStatus !== void 0;
 		},
-		setFallbackText(text) {
-			latestFallbackText = text;
-		},
 		reset() {
-			latestFallbackText = "";
 			finalStatus = void 0;
+			visibleWorkSessions.clear();
 		}
 	};
 }
@@ -1123,15 +1076,12 @@ function formatSlackProgressDraftLine(line) {
 //#endregion
 //#region extensions/slack/src/monitor/message-handler/dispatch-progress-native.ts
 function createSlackNativeProgressTransport(params) {
-	const { ctx, message, replyPlan, slackClient, slackIdentity, slackStreamFallbackTeamId } = params.setup;
+	const { replyPlan } = params.setup;
 	const { delivery } = params;
 	const markDelivered = (threadTs) => {
 		if (!delivery.streamSession?.delivered) return false;
 		delivery.observedReplyDelivery = true;
-		if (threadTs) {
-			delivery.usedReplyThreadTs ??= threadTs;
-			delivery.rememberDeliveredThreadTs("block", threadTs);
-		}
+		if (threadTs) delivery.rememberDeliveredThreadTs("block", threadTs);
 		return true;
 	};
 	const waitForStart = async () => {
@@ -1152,30 +1102,15 @@ function createSlackNativeProgressTransport(params) {
 			return false;
 		}
 		delivery.nativeProgressStreamThreadTs = streamThreadTs;
-		const startPromise = (async () => {
-			const session = await startSlackStream({
-				client: slackClient,
-				clientOptions: params.setup.slackClientOptions,
-				channel: message.channel,
-				threadTs: streamThreadTs,
-				...update.text ? { text: update.text } : {},
-				...update.chunks?.length ? { chunks: update.chunks } : {},
-				taskDisplayMode: "plan",
-				...slackIdentity ? { identity: slackIdentity } : {},
-				teamId: await resolveSlackStreamRecipientTeamId({
-					client: slackClient,
-					token: ctx.botToken,
-					userId: message.user,
-					fallbackTeamId: slackStreamFallbackTeamId
-				}),
-				userId: message.user
-			});
-			delivery.streamSession = session;
-			return session;
-		})();
+		const startPromise = delivery.startStream({
+			threadTs: streamThreadTs,
+			...update.text ? { text: update.text } : {},
+			...update.chunks?.length ? { chunks: update.chunks } : {},
+			taskDisplayMode: "plan"
+		});
 		delivery.nativeProgressStreamStartPromise = startPromise;
 		try {
-			if (!await startPromise) return false;
+			await startPromise;
 			const delivered = markDelivered(streamThreadTs);
 			return update.chunks?.length ? delivered : true;
 		} finally {
@@ -1203,7 +1138,7 @@ function createSlackNativeProgressTransport(params) {
 //#region extensions/slack/src/monitor/message-handler/dispatch-progress.ts
 function createSlackProgressRuntime(runtimeParams) {
 	const { setup, delivery } = runtimeParams;
-	const { account, cfg, ctx, hasSlackCustomIdentity, message, prepared, replyPlan, runtime, slackClient, slackIdentity, slackMessageMetadata, slackStreaming, shouldUseDraftStream, useStreaming, previewStreamingEnabled } = setup;
+	const { account, cfg, ctx, hasSlackCustomIdentity, message, prepared, replyPlan, runtime, slackClient, slackIdentity, slackMessageMetadata, slackStreaming, slackProgressStyle, quietProgress, shouldUseDraftStream, useStreaming, previewStreamingEnabled } = setup;
 	const draftStream = shouldUseDraftStream ? createSlackDraftStream({
 		target: prepared.replyTarget,
 		cfg,
@@ -1227,7 +1162,7 @@ function createSlackProgressRuntime(runtimeParams) {
 	const progressDraftActive = Boolean(draftStream) || useNativeProgressStreaming;
 	const previewToolProgressEnabled = progressDraftActive && resolveChannelStreamingPreviewToolProgress(account.config, slackStreaming.mode !== "progress", slackStreaming.mode);
 	let shouldYieldDraftProgress = () => false;
-	const suppressDefaultToolProgressMessages = resolveChannelStreamingSuppressDefaultToolProgressMessages(account.config, {
+	const suppressDefaultToolProgressMessages = quietProgress || resolveChannelStreamingSuppressDefaultToolProgressMessages(account.config, {
 		draftStreamActive: Boolean(draftStream) || useNativeProgressStreaming,
 		mode: slackStreaming.mode,
 		previewToolProgressEnabled,
@@ -1248,7 +1183,6 @@ function createSlackProgressRuntime(runtimeParams) {
 	};
 	const progressWorkCounter = createChannelProgressWorkCounter();
 	const progressSeed = `${account.accountId}:${message.channel}`;
-	const slackProgressStyle = resolveSlackProgressStyle(account.config);
 	const preambleOnlyProgress = isProgressMode && slackProgressStyle === "compact" && !previewToolProgressEnabled;
 	const useDraftProgressCard = Boolean(draftStream) && isProgressMode && slackProgressStyle === "card";
 	const explicitProgressTitle = resolveExplicitSlackProgressTitle(account.config);
@@ -1264,7 +1198,6 @@ function createSlackProgressRuntime(runtimeParams) {
 		draftStream,
 		enabled: useDraftProgressCard,
 		progressWorkCounter: previewToolProgressEnabled ? progressWorkCounter : void 0,
-		progressSeed,
 		explicitTitle: explicitProgressTitle,
 		maxLineChars: progressDraftMaxLineChars,
 		getSnapshot: () => progressDraft.getSnapshot(),
@@ -1373,8 +1306,7 @@ function createSlackProgressRuntime(runtimeParams) {
 		nativeUpdates.stop();
 		await nativeUpdates.waitForInFlight();
 	};
-	const appendNativeNarration = (payload, kind) => withNativeStreamOrder(() => appendNativeNarrationNow(payload, kind));
-	const appendNativeNarrationNow = async (payload, kind) => {
+	const appendNativeNarration = (payload, kind) => withNativeStreamOrder(async () => {
 		if (isRenderedAsProgressTitle(payload.text)) return { visibleReplySent: false };
 		const narrationUpdate = resolveNarrationUpdate(payload.text?.trimEnd());
 		if (!narrationUpdate.delta) return { visibleReplySent: false };
@@ -1390,7 +1322,7 @@ function createSlackProgressRuntime(runtimeParams) {
 			nativeNarrationSourceText = narrationUpdate.next.source;
 		}
 		return result;
-	};
+	});
 	const resetProgressTurnState = () => {
 		progressWorkCounter.reset();
 		nativeNarrationRenderedText = "";
@@ -1419,7 +1351,6 @@ function createSlackProgressRuntime(runtimeParams) {
 			const snapshot = options.snapshot;
 			const latestLine = snapshot.lines.at(-1);
 			if (preambleOnlyProgress && typeof latestLine === "object" && latestLine.complete === false) return false;
-			progressCard.setFallbackText(previewText);
 			draftStream.update(preambleOnlyProgress ? {
 				text: previewText,
 				allowNewMessage: typeof latestLine !== "object" || latestLine.complete !== false,
@@ -1492,22 +1423,22 @@ function createSlackProgressRuntime(runtimeParams) {
 	const buildNativeProgressCompletionChunks = (finalInProgressStatus) => {
 		const snapshot = progressDraft.getSnapshot();
 		const lines = resolveNativeProgressLines(snapshot);
-		const sessionUrl = progressCard.resolveSessionUrl();
+		const sessionLinks = progressCard.resolveSessionLinks();
 		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 && !narrationUpdate.delta && !sessionUrl) return;
+		if (lines.length === 0 && !snapshot.plan?.length && !hasRetirableNativeTasks && !snapshot.diffStat && !narrationUpdate.delta && sessionLinks.length === 0) return;
 		const completion = reconcileSlackNativeTaskChunks({
 			previous: nativeStreamSnapshot,
 			finalStatus: finalInProgressStatus,
 			chunks: buildSlackProgressStreamChunks({
-				title: resolveNativeProgressTitle(snapshot) ?? (lines.length === 0 && !snapshot.plan?.length ? "Working" : void 0),
+				title: resolveNativeProgressTitle(snapshot),
 				lines,
 				plan: snapshot.plan,
 				maxLineChars: progressDraftMaxLineChars,
 				summaryRow: !previewToolProgressEnabled,
 				finalInProgressStatus,
 				diffStat: snapshot.diffStat,
-				sessionUrl
+				sessionLinks
 			})
 		}).chunks;
 		return narrationUpdate.delta ? [{
@@ -1578,12 +1509,11 @@ function createSlackProgressRuntime(runtimeParams) {
 			await cancelNativeUpdates();
 		}
 		const priorSnapshot = progressDraft.getSnapshot();
-		const priorFallbackText = progressCard.resolveText(priorSnapshot);
 		const completionChunks = useNativeProgressStreaming && !nativeProgressCompletionSent ? buildNativeProgressCompletionChunks(nativeProgressTerminalStatus) : void 0;
 		if (!progressDraft.beginNewTurn(options)) return false;
 		if (useNativeProgressStreaming) await finishNativeProgressTurn(completionChunks);
 		else {
-			await progressCard.finalize("success", priorSnapshot, priorFallbackText);
+			await progressCard.finalize("success", priorSnapshot);
 			await previewLifecycle.cleanup();
 			draftStream?.forceNewMessage();
 			await dropDetachedProgressCards();
@@ -1666,6 +1596,7 @@ function createSlackProgressRuntime(runtimeParams) {
 		deliverNativeFinal,
 		dropDetachedProgressCards,
 		finalizeDraftProgressCard: progressCard.finalize,
+		onVisibleWorkSessions: progressCard.onVisibleWorkSessions,
 		onDraftBoundary,
 		onQueuedFollowupAdmitted,
 		onQueuedFollowupSettled,
@@ -1722,14 +1653,14 @@ async function createSlackDispatchSetup(prepared) {
 			ctx: prepared.ctxPayload
 		});
 	}
-	const threadTargets = resolveSlackThreadTargets({
+	const threadContext = resolveSlackThreadContext({
 		message,
 		replyToMode: prepared.replyToMode
 	});
 	const forcedReplyThreadTs = prepared.forcedReplyThreadTs;
 	const slackMessageMetadata = prepared.slackMessageMetadata;
-	const statusThreadTs = forcedReplyThreadTs ?? threadTargets.statusThreadTs;
-	const isThreadReply = threadTargets.isThreadReply;
+	const statusThreadTs = forcedReplyThreadTs ?? threadContext.messageThreadId;
+	const isThreadReply = threadContext.isThreadReply;
 	const replyDeliveryMode = forcedReplyThreadTs ? "off" : prepared.replyToMode;
 	const sourceReplyDeliveryMode = resolveChannelMessageSourceReplyDeliveryMode({
 		cfg,
@@ -1790,8 +1721,12 @@ async function createSlackDispatchSetup(prepared) {
 		hasRepliedRef,
 		isThreadReply: Boolean(forcedReplyThreadTs) || isThreadReply
 	});
+	const slackStreaming = resolveSlackStreamingConfig({ streaming: account.config.streaming });
+	const streamThreadHint = forcedReplyThreadTs ?? replyPlan.peekThreadTs();
+	const slackProgressStyle = resolveSlackProgressStyle(account.config, Boolean(streamThreadHint));
+	const quietProgress = slackStreaming.mode === "progress" && slackProgressStyle === "none";
 	const typingTarget = statusThreadTs ? `${message.channel}/${statusThreadTs}` : message.channel;
-	const typingReaction = ctx.typingReaction;
+	const typingReaction = quietProgress && account.config.typingReaction === void 0 ? "hourglass_flowing_sand" : ctx.typingReaction;
 	const threadStatusGate = { hasVisibleOutput: () => false };
 	const { onModelSelected, ...replyPipeline } = createChannelMessageReplyPipeline({
 		cfg,
@@ -1866,23 +1801,16 @@ async function createSlackDispatchSetup(prepared) {
 			}
 		}
 	});
-	const slackStreaming = resolveSlackStreamingConfig({ streaming: account.config.streaming });
-	const streamThreadHint = forcedReplyThreadTs ?? resolveSlackStreamingThreadHint({
-		replyToMode: replyDeliveryMode,
-		incomingThreadTs,
-		messageTs,
-		isThreadReply
-	});
 	const hookRunner = getGlobalHookRunner();
 	const modifyingHooksRegistered = (hookRunner?.hasHooks("reply_payload_sending") ?? false) || (hookRunner?.hasHooks("message_sending") ?? false);
 	const allowPreHookProviderStreaming = !prepared.ctxPayload.GroupThread && !modifyingHooksRegistered;
-	const previewStreamingEnabled = allowPreHookProviderStreaming && !sourceRepliesAreToolOnly && slackStreaming.mode !== "off";
+	const previewStreamingEnabled = allowPreHookProviderStreaming && !sourceRepliesAreToolOnly && !quietProgress && slackStreaming.mode !== "off";
 	const hasSlackCustomIdentity = Boolean(slackIdentity?.username || slackIdentity?.iconUrl || slackIdentity?.iconEmoji);
 	const useStreaming = shouldUseStreaming({
 		streamingEnabled: !prepared.ctxPayload.GroupThread && !sourceRepliesAreToolOnly && (allowPreHookProviderStreaming || slackStreaming.mode !== "progress") && isSlackStreamingEnabled({
 			mode: slackStreaming.mode,
 			nativeStreaming: slackStreaming.nativeStreaming,
-			nativeProgressTaskCards: resolveSlackNativeProgressTaskCards(account.config)
+			nativeProgressTaskCards: resolveSlackNativeProgressTaskCards(account.config, slackProgressStyle)
 		}),
 		threadTs: streamThreadHint
 	});
@@ -1906,13 +1834,10 @@ async function createSlackDispatchSetup(prepared) {
 		isThreadReply,
 		replyDeliveryMode,
 		sourceReplyDeliveryMode,
-		sourceRepliesAreToolOnly,
 		suppressRoomEventTyping,
 		messageSentHookTarget,
 		messageSentHookContext,
 		messageSentDeliveryHookContext,
-		incomingThreadTs,
-		messageTs,
 		statusReactionsEnabled,
 		statusReactions,
 		hasRepliedRef,
@@ -1921,11 +1846,13 @@ async function createSlackDispatchSetup(prepared) {
 		onModelSelected,
 		replyPipeline,
 		slackStreaming,
+		slackProgressStyle,
+		quietProgress,
 		streamThreadHint,
 		previewStreamingEnabled,
 		hasSlackCustomIdentity,
 		shouldUseDraftStream,
-		disableBlockStreaming: sourceRepliesAreToolOnly ? true : resolveSlackDisableBlockStreaming({
+		disableBlockStreaming: sourceRepliesAreToolOnly || quietProgress ? true : resolveSlackDisableBlockStreaming({
 			useStreaming,
 			shouldUseDraftStream,
 			blockStreamingEnabled
@@ -1946,6 +1873,41 @@ function createSlackStreamingDeliveryRuntime(setup) {
 		usedBlockReplyThreadTs: void 0,
 		observedReplyDelivery: false
 	};
+	const startStream = async (params) => {
+		const session = await startSlackStream({
+			client: slackClient,
+			clientOptions: slackClientOptions,
+			channel: message.channel,
+			...params,
+			...slackIdentity ? { identity: slackIdentity } : {},
+			teamId: await resolveSlackStreamRecipientTeamId({
+				client: slackClient,
+				token: ctx.botToken,
+				userId: message.user,
+				fallbackTeamId: slackStreamFallbackTeamId
+			}),
+			userId: message.user
+		});
+		state.streamSession = session;
+		return session;
+	};
+	const deliverPreparedReply = (reply, replyThreadTs, deferMessageSentHooks = false) => deliverReplies({
+		cfg: ctx.cfg,
+		replies: [reply],
+		target: prepared.replyTarget,
+		token: ctx.botToken,
+		accountId: account.accountId,
+		runtime,
+		textLimit: ctx.textLimit,
+		mediaMaxBytes: ctx.mediaMaxBytes,
+		replyThreadTs,
+		replyToMode: replyDeliveryMode,
+		...slackIdentity ? { identity: slackIdentity } : {},
+		...slackMessageMetadata ? { metadata: slackMessageMetadata } : {},
+		...messageSentDeliveryHookContext,
+		...deferMessageSentHooks ? { deferMessageSentHooks: true } : {},
+		eventScope: prepared.eventScope
+	});
 	const emitStreamedDelivery = (content, result) => {
 		emitSlackMessageSentHooks({
 			...messageSentHookContext,
@@ -1996,23 +1958,7 @@ function createSlackStreamingDeliveryRuntime(setup) {
 		}
 		const fallbackText = fallbackError.pendingText.trim();
 		if (!fallbackText) return;
-		const sent = await deliverReplies({
-			cfg: ctx.cfg,
-			replies: [prepareSlackReply({ text: fallbackText })],
-			target: prepared.replyTarget,
-			token: ctx.botToken,
-			accountId: account.accountId,
-			runtime,
-			textLimit: ctx.textLimit,
-			mediaMaxBytes: ctx.mediaMaxBytes,
-			replyThreadTs: session.threadTs,
-			replyToMode: replyDeliveryMode,
-			...slackIdentity ? { identity: slackIdentity } : {},
-			...slackMessageMetadata ? { metadata: slackMessageMetadata } : {},
-			...messageSentDeliveryHookContext,
-			deferMessageSentHooks: true,
-			eventScope: prepared.eventScope
-		});
+		const sent = await deliverPreparedReply(prepareSlackReply({ text: fallbackText }), session.threadTs, true);
 		if (!sent?.receipt.platformMessageIds.length) return;
 		markSlackStreamFallbackDelivered(session);
 		if (!session.stopped) try {
@@ -2066,22 +2012,7 @@ function createSlackStreamingDeliveryRuntime(setup) {
 			logVerbose("slack: suppressed duplicate normal delivery within the same turn");
 			return { visibleReplySent: false };
 		}
-		const sent = await deliverReplies({
-			cfg: ctx.cfg,
-			replies: [preparedReply],
-			target: prepared.replyTarget,
-			token: ctx.botToken,
-			accountId: account.accountId,
-			runtime,
-			textLimit: ctx.textLimit,
-			mediaMaxBytes: ctx.mediaMaxBytes,
-			replyThreadTs: deliveryReplyThreadTs,
-			replyToMode: replyDeliveryMode,
-			...slackIdentity ? { identity: slackIdentity } : {},
-			...slackMessageMetadata ? { metadata: slackMessageMetadata } : {},
-			...messageSentDeliveryHookContext,
-			eventScope: prepared.eventScope
-		});
+		const sent = await deliverPreparedReply(preparedReply, deliveryReplyThreadTs);
 		if (!sent?.receipt.platformMessageIds.length) return { visibleReplySent: false };
 		state.observedReplyDelivery = true;
 		const deliveredThreadTs = resolveSlackReplyThreadTs({
@@ -2104,7 +2035,7 @@ function createSlackStreamingDeliveryRuntime(setup) {
 		const reply = resolveSendableOutboundReplyParts(payload);
 		const renderPlan = resolveSlackReplyRenderPlan(payload);
 		const plannedBlocks = renderPlan.mode === "single" ? renderPlan.blocks : renderPlan.blockPart?.blocks;
-		return !state.streamFailed && !reply.hasMedia && renderPlan.mode !== "split" && !renderPlan.textIsSlackPlainText && !plannedBlocks?.length && !readSlackReplyBlocks(payload)?.length && reply.hasText && (!options?.maxTextBytes || countSlackTextUtf8Bytes(reply.trimmedText) <= options.maxTextBytes);
+		return !state.streamFailed && !reply.hasMedia && renderPlan.mode !== "split" && !renderPlan.textIsSlackPlainText && !plannedBlocks?.length && !resolveSlackReplyBlocks(payload)?.length && reply.hasText && (!options?.maxTextBytes || countSlackTextUtf8Bytes(reply.trimmedText) <= options.maxTextBytes);
 	};
 	const deliverWithStreaming = async (params) => {
 		if (state.streamSession?.stoppedBySlack) return { visibleReplySent: false };
@@ -2144,26 +2075,12 @@ function createSlackStreamingDeliveryRuntime(setup) {
 				text: `${params.appendSeparator === false ? "" : "\n"}${text}`,
 				chunks: []
 			});
-			else {
-				session = await startSlackStream({
-					client: slackClient,
-					clientOptions: slackClientOptions,
-					channel: message.channel,
-					threadTs,
-					text,
-					chunks: [],
-					...params.taskDisplayMode ? { taskDisplayMode: params.taskDisplayMode } : {},
-					...slackIdentity ? { identity: slackIdentity } : {},
-					teamId: await resolveSlackStreamRecipientTeamId({
-						client: slackClient,
-						token: ctx.botToken,
-						userId: message.user,
-						fallbackTeamId: slackStreamFallbackTeamId
-					}),
-					userId: message.user
-				});
-				state.streamSession = session;
-			}
+			else session = await startStream({
+				threadTs,
+				text,
+				chunks: [],
+				...params.taskDisplayMode ? { taskDisplayMode: params.taskDisplayMode } : {}
+			});
 			messageId = session.streamer.ts;
 		} catch (error) {
 			state.streamFailed = true;
@@ -2221,6 +2138,7 @@ function createSlackStreamingDeliveryRuntime(setup) {
 		isStreamingEligible,
 		markPreviewPayloadDelivered,
 		rememberDeliveredThreadTs,
+		startStream,
 		resetDeliveryTracker: () => {
 			deliveryTracker = createSlackEventDeliveryTracker();
 		}
@@ -2324,14 +2242,7 @@ async function dispatchSlackMessageWithSetup(setup, beginSessionRun, turnAdoptio
 			})).deliveryResult ?? { visibleReplySent: false };
 		}
 		if (progress.useNativeProgressStreaming) {
-			if (info.kind !== "final" && payload.isError !== true) {
-				if (!delivery.isStreamingEligible(payload)) return await delivery.deliverNormally({
-					payload,
-					kind: info.kind,
-					forcedThreadTs: delivery.streamSession?.threadTs ?? delivery.nativeProgressStreamThreadTs
-				});
-				return await progress.appendNativeNarration(payload, info.kind);
-			}
+			if (info.kind !== "final" && payload.isError !== true && delivery.isStreamingEligible(payload)) return await progress.appendNativeNarration(payload, info.kind);
 			return await delivery.deliverNormally({
 				payload,
 				kind: info.kind,
@@ -2482,6 +2393,7 @@ async function dispatchSlackMessageWithSetup(setup, beginSessionRun, turnAdoptio
 			record: prepared.turn.record,
 			botLoopProtection: resolveSlackBotLoopProtection(prepared),
 			replyOptions: {
+				onVisibleWorkSessions: progress.onVisibleWorkSessions,
 				groupThreadReplyFormatter: formatSlackGroupThreadReply,
 				queuedDeliveryCorrelations: [{ begin: beginSessionRun }],
 				...turnAdoptionLifecycle ? { turnAdoptionLifecycle } : {},
@@ -2501,9 +2413,7 @@ async function dispatchSlackMessageWithSetup(setup, beginSessionRun, turnAdoptio
 				} : void 0,
 				allowProgressCallbacksWhenSourceDeliverySuppressed: sourceReplyDeliveryMode === "message_tool_only" && statusReactionsEnabled ? true : void 0,
 				allowToolLifecycleWhenProgressHidden: statusReactionsEnabled ? true : void 0,
-				onPartialReply: useStreaming ? void 0 : !previewStreamingEnabled ? void 0 : async (payload) => {
-					return progress.updateDraftFromPartial(payload.text);
-				},
+				onPartialReply: !useStreaming && previewStreamingEnabled ? async (payload) => progress.updateDraftFromPartial(payload.text) : void 0,
 				onAssistantMessageStart: progress.onDraftBoundary ? async () => {
 					await progress.onDraftBoundary?.();
 					return false;
@@ -2586,7 +2496,7 @@ async function dispatchSlackMessageWithSetup(setup, beginSessionRun, turnAdoptio
 	}
 	if (shouldLogVerbose()) {
 		const finalCount = resolveInboundReplyDispatchCounts(settledDispatchResult).final;
-		logVerbose(`slack: delivered ${finalCount} reply${finalCount === 1 ? "" : "ies"} to ${prepared.replyTarget}`);
+		logVerbose(`slack: delivered ${finalCount} repl${finalCount === 1 ? "y" : "ies"} to ${prepared.replyTarget}`);
 	}
 }
 //#endregion
@@ -2646,12 +2556,9 @@ function formatSlackFilePlaceholder(files) {
 	return `[attached: ${formatSlackFileReferenceList(files)}]`;
 }
 function pushUniqueText(parts, value, options = {}) {
-	const text = options.preserveWhitespace ? typeof value === "string" && value.trim().length > 0 ? value : void 0 : normalizeOptionalString(value);
+	const text = options.preserveWhitespace ? readNonBlankString(value) : normalizeOptionalString(value);
 	if (text && !parts.includes(text)) parts.push(text);
 }
-function resolveSlackBlocksFallbackText(blocks) {
-	return resolveSlackBlocksText(blocks)?.text;
-}
 function resolveSlackAttachmentFallbackText(attachments) {
 	if (!Array.isArray(attachments) || attachments.length === 0) return;
 	const parts = [];
@@ -2666,8 +2573,8 @@ function resolveSlackAttachmentFallbackText(attachments) {
 			pushUniqueText(parts, field.title);
 			pushUniqueText(parts, field.value);
 		}
-		pushUniqueText(parts, resolveSlackBlocksFallbackText(fallbackBlocks(attachment.blocks)), { preserveWhitespace: true });
-		pushUniqueText(parts, resolveSlackBlocksFallbackText(fallbackBlocks(attachment.message_blocks)), { preserveWhitespace: true });
+		pushUniqueText(parts, resolveSlackBlocksText(fallbackBlocks(attachment.blocks))?.text, { preserveWhitespace: true });
+		pushUniqueText(parts, resolveSlackBlocksText(fallbackBlocks(attachment.message_blocks))?.text, { preserveWhitespace: true });
 	}
 	return parts.length > 0 ? parts.join("\n") : void 0;
 }
@@ -2721,7 +2628,7 @@ async function resolveSlackThreadStarter(params) {
 		}
 		return starter;
 	} catch (err) {
-		logVerbose$1(`slack thread starter fetch failed channel=${params.channelId} ts=${params.threadTs}: ${formatErrorMessage(err)}`);
+		logVerbose(`slack thread starter fetch failed channel=${params.channelId} ts=${params.threadTs}: ${formatErrorMessage(err)}`);
 		return null;
 	}
 }
@@ -2771,7 +2678,7 @@ async function resolveSlackThreadHistory(params) {
 			}
 		} while (cursor && pagesFetched < SLACK_THREAD_HISTORY_MAX_PAGES);
 		if (cursor) {
-			logVerbose$1(`slack thread history capped channel=${params.channelId} ts=${params.threadTs} pages=${SLACK_THREAD_HISTORY_MAX_PAGES}`);
+			logVerbose(`slack thread history capped channel=${params.channelId} ts=${params.threadTs} pages=${SLACK_THREAD_HISTORY_MAX_PAGES}`);
 			params.onOmission?.("Slack thread exceeds the three-page automatic history budget");
 			return [];
 		}
@@ -2786,7 +2693,7 @@ async function resolveSlackThreadHistory(params) {
 	} catch (err) {
 		params.assertCurrent?.();
 		params.onOmission?.(formatErrorMessage(err));
-		logVerbose$1(`slack thread history fetch failed channel=${params.channelId} ts=${params.threadTs}: ${formatErrorMessage(err)}`);
+		logVerbose(`slack thread history fetch failed channel=${params.channelId} ts=${params.threadTs}: ${formatErrorMessage(err)}`);
 		return [];
 	}
 }
@@ -2869,9 +2776,7 @@ async function resolveSlackPreflightAudioTranscript(params) {
 		mediaIndex
 	} : null;
 }
-async function sendSlackPreflightAudioTranscriptEcho(params) {
-	await slackPreflightAudio.send(params);
-}
+const sendSlackPreflightAudioTranscriptEcho = slackPreflightAudio.send.bind(slackPreflightAudio);
 async function discardSlackPreflightMedia(media) {
 	await Promise.allSettled((media ?? []).map((entry) => fs.rm(entry.path, { force: true })));
 }
@@ -2881,7 +2786,7 @@ const SLACK_MENTION_RESOLUTION_CONCURRENCY = 4;
 const SLACK_MENTION_RESOLUTION_MAX_LOOKUPS_PER_MESSAGE = 20;
 const SLACK_USER_MENTION_RE$1 = /<@([A-Z0-9]+)(?:\|[^>]+)?>/gi;
 const MAX_SLACK_UNAVAILABLE_FILE_TEXT_CHARS = 2e3;
-const loadSlackMediaModule$1 = createLazyRuntimeModule(() => import("./actions-DKCtBgCI.mjs").then((n) => n._));
+const loadSlackMediaModule$1 = createLazyRuntimeModule(() => import("./actions-Df0CzcDl.mjs").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)`;
@@ -2900,18 +2805,15 @@ function formatSlackUnavailableMedia(params) {
 }
 function collectUniqueSlackMentionIds$1(texts) {
 	const seen = /* @__PURE__ */ new Set();
-	const mentionIds = [];
 	for (const text of texts) {
 		if (!text) continue;
 		SLACK_USER_MENTION_RE$1.lastIndex = 0;
 		for (const match of text.matchAll(SLACK_USER_MENTION_RE$1)) {
 			const userId = match[1];
-			if (!userId || seen.has(userId)) continue;
-			seen.add(userId);
-			mentionIds.push(userId);
+			if (userId) seen.add(userId);
 		}
 	}
-	return mentionIds;
+	return [...seen];
 }
 function renderSlackUserMentions(text, renderedMentions) {
 	if (!text || renderedMentions.size === 0) return text;
@@ -2922,8 +2824,7 @@ function renderSlackUserMentions(text, renderedMentions) {
 }
 function filterInheritedParentFiles(params) {
 	const { files, isThreadReply, threadStarter } = params;
-	if (!isThreadReply || !files?.length) return files;
-	if (!threadStarter?.files?.length) return files;
+	if (!isThreadReply || !files?.length || !threadStarter?.files?.length) return files;
 	const starterFileIds = new Set(threadStarter.files.map((file) => file.id));
 	const filtered = files.filter((file) => !file.id || !starterFileIds.has(file.id));
 	if (filtered.length < files.length) logVerbose(`slack: filtered ${files.length - filtered.length} inherited parent file(s) from thread reply`);
@@ -2950,14 +2851,7 @@ async function resolveSlackMessageContent(params) {
 	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 = [];
-		for (const attachment of params.message.attachments ?? []) {
-			const text = normalizeOptionalString(attachment.text) ?? normalizeOptionalString(attachment.fallback);
-			if (text) botAttachmentTextParts.push(text);
-		}
-		botAttachmentText = botAttachmentTextParts.length > 0 ? botAttachmentTextParts.join("\n") : void 0;
-	}
+	if (params.isBotMessage && !attachmentContent?.text) botAttachmentText = (params.message.attachments ?? []).map((attachment) => normalizeOptionalString(attachment.text) ?? normalizeOptionalString(attachment.fallback)).filter(Boolean).join("\n") || void 0;
 	const textParts = [
 		resolveSlackMessageText$1(params.message),
 		attachmentContent?.text,
@@ -2986,17 +2880,9 @@ async function resolveSlackMessageContent(params) {
 			renderedMentions.set(result.userId, result.rendered);
 		}
 	}
-	const renderedMessageText = renderSlackUserMentions(textParts[0], renderedMentions);
-	const renderedAttachmentText = renderSlackUserMentions(textParts[1], renderedMentions);
-	const renderedBotAttachmentText = renderSlackUserMentions(textParts[2], renderedMentions);
 	const commandSourceText = renderSlackUserMentions(normalizeOptionalString(params.message.text), renderedMentions) ?? "";
 	const rawBody = formatSlackUnavailableMedia({
-		body: [
-			renderedMessageText,
-			renderedAttachmentText,
-			renderedBotAttachmentText,
-			mediaPlaceholder
-		].filter(Boolean).join("\n") || "",
+		body: [...textParts.map((text) => renderSlackUserMentions(text, renderedMentions)), mediaPlaceholder].filter(Boolean).join("\n"),
 		files: attachmentContent?.files,
 		unavailableMediaCount: attachmentContent?.unavailableMediaCount ?? 0
 	});
@@ -3011,7 +2897,7 @@ async function resolveSlackMessageContent(params) {
 //#endregion
 //#region extensions/slack/src/monitor/message-handler/prepare-dm-history.ts
 function resolveSlackDmHistoryLimit(params) {
-	const override = params.userId && params.account.config.dms?.[params.userId]?.historyLimit !== void 0 ? params.account.config.dms[params.userId]?.historyLimit : void 0;
+	const override = params.userId ? params.account.config.dms?.[params.userId]?.historyLimit : void 0;
 	return resolvePromptHistoryLimit(override ?? params.defaultLimit, 0);
 }
 async function resolveSlackDmHistoryContext(params) {
@@ -3088,52 +2974,6 @@ function isSlackThreadAuthorCurrentBot(params) {
 	if (identity.botId && author.botId && author.botId === identity.botId) return true;
 	return false;
 }
-function resolveSlackThreadHistoryFilterPolicy(params) {
-	if (params.retainCurrentBotHistory) return { currentBot: "all" };
-	if (!params.includeBotStarterAsRootContext || !params.starterTs) return { currentBot: "omit" };
-	return {
-		currentBot: "root-only",
-		rootTs: params.starterTs
-	};
-}
-function applySlackThreadHistoryFilterPolicy(params) {
-	const kept = [];
-	let omittedCurrentBot = 0;
-	for (const entry of params.history) {
-		if (!isSlackThreadAuthorCurrentBot({
-			identity: params.identity,
-			author: entry
-		})) {
-			kept.push(entry);
-			continue;
-		}
-		if (params.policy.currentBot === "all" || params.policy.currentBot === "root-only" && entry.ts === params.policy.rootTs) kept.push(entry);
-		else omittedCurrentBot += 1;
-	}
-	return {
-		kept,
-		omittedCurrentBot
-	};
-}
-function shouldIncludeBotThreadStarterContext(params) {
-	if (!params.hasStarterText) return false;
-	return params.starterIsCurrentBot && params.isNewThreadSession;
-}
-function ensureSlackThreadHistoryHasBotRoot(params) {
-	if (!params.includeBotStarterAsRootContext || !params.threadStarter?.text) return params.history;
-	if (params.history.some((entry) => entry.ts === params.threadStarter?.ts)) return params.history;
-	return [params.threadStarter, ...params.history];
-}
-function formatSlackBotStarterThreadLabel(params) {
-	const base = `Slack thread ${params.roomLabel}`;
-	if (!params.starterText) return base;
-	const snippet = formatSlackThreadLabelSnippet(params.starterText).trim();
-	if (!snippet) return base;
-	return `${base} (assistant root): ${snippet}`;
-}
-function formatSlackThreadLabelSnippet(text) {
-	return truncateUtf16Safe(text.replace(/\s+/g, " "), 80);
-}
 //#endregion
 //#region extensions/slack/src/monitor/message-handler/prepare-room-history.ts
 const SLACK_HISTORY_MEDIA_MAX_ATTACHMENTS = 4;
@@ -3300,8 +3140,11 @@ async function resolveSlackHistoryMedia(params) {
 }
 //#endregion
 //#region extensions/slack/src/monitor/message-handler/prepare-thread-context.ts
-const loadSlackMediaModule = createLazyRuntimeModule(() => import("./actions-DKCtBgCI.mjs").then((n) => n._));
+const loadSlackMediaModule = createLazyRuntimeModule(() => import("./actions-Df0CzcDl.mjs").then((n) => n._));
 const SLACK_THREAD_CONTEXT_USER_LOOKUP_CONCURRENCY = 4;
+function formatSlackThreadLabelSnippet(text) {
+	return truncateUtf16Safe(text.replace(/\s+/g, " "), 80);
+}
 function resolveSlackThreadSessionFreshness(params) {
 	return params.ctx.channelRuntime?.session?.resolveEntryResetFreshness?.({
 		agentId: params.agentId,
@@ -3316,27 +3159,15 @@ function resolveSlackThreadSessionFreshness(params) {
 	});
 }
 async function resolveSlackThreadUserMap(params) {
-	const uniqueUserIds = [];
-	const seen = /* @__PURE__ */ new Set();
-	for (const item of params.messages) {
-		if (!item.userId || seen.has(item.userId)) continue;
-		seen.add(item.userId);
-		uniqueUserIds.push(item.userId);
-	}
-	const userMap = /* @__PURE__ */ new Map();
-	if (uniqueUserIds.length === 0) return userMap;
+	const uniqueUserIds = [...new Set(params.messages.map((item) => item.userId).filter((id) => Boolean(id)))];
 	const { results } = await runTasksWithConcurrency({
 		tasks: uniqueUserIds.map((id) => async () => {
 			const user = await params.ctx.resolveUserName(id, params.eventScope);
-			return user ? {
-				id,
-				user
-			} : null;
+			return user ? [id, user] : null;
 		}),
 		limit: SLACK_THREAD_CONTEXT_USER_LOOKUP_CONCURRENCY
 	});
-	for (const result of results) if (result) userMap.set(result.id, result.user);
-	return userMap;
+	return new Map(results.flatMap((result) => result ? [result] : []));
 }
 async function resolveSlackThreadContextData(params) {
 	const botIdentity = {
@@ -3375,10 +3206,7 @@ async function resolveSlackThreadContextData(params) {
 	const starter = params.threadStarter;
 	const starterSenderName = params.allowNameMatching && params.allowFromLower.length > 0 && starter?.userId ? (await params.ctx.resolveUserName(starter.userId, params.eventScope))?.name : void 0;
 	params.assertHistoryCurrent?.();
-	const starterIsCurrentBot = Boolean(starter && isCurrentBotAuthor({
-		userId: starter.userId,
-		botId: starter.botId
-	}));
+	const starterIsCurrentBot = Boolean(starter && isCurrentBotAuthor(starter));
 	const starterAllowed = !starter || !starterIsCurrentBot && resolveSlackUserAllowed({
 		allowList: params.allowFromLower,
 		teamId: params.eventScope?.teamId ?? params.ctx.teamId,
@@ -3420,18 +3248,12 @@ async function resolveSlackThreadContextData(params) {
 			}
 		}
 	} else threadLabel = `Slack thread ${params.roomLabel}`;
-	const includeBotStarterAsRootContext = shouldIncludeBotThreadStarterContext({
-		starterIsCurrentBot,
-		isNewThreadSession: shouldSeedInitialThreadContext,
-		hasStarterText: Boolean(starter?.text)
-	});
+	const includeBotStarterAsRootContext = Boolean(starter?.text && starterIsCurrentBot && shouldSeedInitialThreadContext);
 	if (starter?.text && starterIsCurrentBot && !includeBotStarterAsRootContext) logVerbose("slack: omitted current-bot thread starter from context");
 	else if (starter?.text && !includeStarterContext && !starterIsCurrentBot) logVerbose(`slack: omitted thread starter from context (mode=${params.contextVisibilityMode}, sender_allowed=${starterAllowed ? "yes" : "no"})`);
 	else if (includeBotStarterAsRootContext) {
-		threadLabel = formatSlackBotStarterThreadLabel({
-			roomLabel: params.roomLabel,
-			starterText: starter?.text
-		});
+		const snippet = formatSlackThreadLabelSnippet(starter?.text ?? "").trim();
+		threadLabel = `Slack thread ${params.roomLabel}${snippet ? ` (assistant root): ${snippet}` : ""}`;
 		logVerbose("slack: retained current-bot thread starter as assistant root context");
 	}
 	const threadInitialHistoryLimit = Math.min(params.account.config?.thread?.initialHistoryLimit ?? 20, params.historyLimit ?? Number.POSITIVE_INFINITY);
@@ -3469,24 +3291,15 @@ async function resolveSlackThreadContextData(params) {
 			text: threadStarterBody,
 			ts: currentBotRootTs
 		} : null;
-		const threadHistoryWithBotRoot = ensureSlackThreadHistoryHasBotRoot({
-			history: enrichedStarter && !threadHistory.some((entry) => entry.ts === currentBotRootTs) ? [enrichedStarter, ...threadHistory.length >= threadInitialHistoryLimit ? threadHistory.slice(1) : threadHistory] : threadHistory,
-			includeBotStarterAsRootContext,
-			threadStarter: starter ? {
-				...starter,
-				ts: currentBotRootTs
-			} : null
-		});
+		const threadHistoryWithEnrichedRoot = enrichedStarter && !threadHistory.some((entry) => entry.ts === currentBotRootTs) ? [enrichedStarter, ...threadHistory.length >= threadInitialHistoryLimit ? threadHistory.slice(1) : threadHistory] : threadHistory;
+		const threadHistoryWithBotRoot = includeBotStarterAsRootContext && starter && !threadHistoryWithEnrichedRoot.some((entry) => entry.ts === currentBotRootTs) ? [{
+			...starter,
+			ts: currentBotRootTs
+		}, ...threadHistoryWithEnrichedRoot] : threadHistoryWithEnrichedRoot;
 		if (threadHistoryWithBotRoot.length > 0) {
-			const { kept: threadHistoryWithoutCurrentBot, omittedCurrentBot: omittedCurrentBotHistoryCount } = applySlackThreadHistoryFilterPolicy({
-				history: threadHistoryWithBotRoot,
-				policy: resolveSlackThreadHistoryFilterPolicy({
-					includeBotStarterAsRootContext,
-					starterTs: currentBotRootTs,
-					retainCurrentBotHistory: params.isGroupDm && (isMissingThreadSession || isOutboundOnlyThreadSession)
-				}),
-				identity: botIdentity
-			});
+			const retainCurrentBotHistory = params.isGroupDm && (isMissingThreadSession || isOutboundOnlyThreadSession);
+			const threadHistoryWithoutCurrentBot = threadHistoryWithBotRoot.filter((entry) => !isCurrentBotAuthor(entry) || retainCurrentBotHistory || includeBotStarterAsRootContext && entry.ts === currentBotRootTs);
+			const omittedCurrentBotHistoryCount = threadHistoryWithBotRoot.length - threadHistoryWithoutCurrentBot.length;
 			const userMapForFilter = params.contextVisibilityMode !== "all" && params.allowNameMatching && params.allowFromLower.length > 0 ? await resolveSlackThreadUserMap({
 				ctx: params.ctx,
 				messages: threadHistoryWithoutCurrentBot,
@@ -3501,10 +3314,7 @@ async function resolveSlackThreadContextData(params) {
 				mode: params.contextVisibilityMode,
 				kind: "thread",
 				isSenderAllowed: (historyMsg) => {
-					if (isCurrentBotAuthor({
-						userId: historyMsg.userId,
-						botId: historyMsg.botId
-					})) return true;
+					if (isCurrentBotAuthor(historyMsg)) return true;
 					const msgUser = historyMsg.userId ? userMapForFilter.get(historyMsg.userId) : null;
 					return resolveSlackUserAllowed({
 						allowList: params.allowFromLower,
@@ -3525,10 +3335,7 @@ async function resolveSlackThreadContextData(params) {
 			const historyParts = [];
 			for (const historyMsg of filteredThreadHistory) {
 				const msgUser = historyMsg.userId ? userMap.get(historyMsg.userId) : null;
-				const isCurrentBot = isCurrentBotAuthor({
-					userId: historyMsg.userId,
-					botId: historyMsg.botId
-				});
+				const isCurrentBot = isCurrentBotAuthor(historyMsg);
 				const role = isCurrentBot || historyMsg.botId ? "assistant" : "user";
 				const msgSenderName = isCurrentBot ? "Bot (this assistant)" : msgUser?.name ?? (historyMsg.botId ? `Bot (${historyMsg.botId})` : "Unknown");
 				const msgWithId = `${historyMsg.ts === currentBotRootTs && threadStarterBody ? threadStarterBody : historyMsg.text}\n[slack message id: ${historyMsg.ts ?? "unknown"} channel: ${params.message.channel}]`;
@@ -3556,12 +3363,64 @@ async function resolveSlackThreadContextData(params) {
 	};
 }
 //#endregion
+//#region src/channels/mention-gating.ts
+function resolveBotThreadMentionPolicy(params) {
+	if (!params.isBotOwnedThread || params.requireMentionInBotThreads === void 0) return {
+		requireMention: params.requireMention,
+		implicitMentionKinds: params.implicitMentionKinds
+	};
+	return {
+		requireMention: params.requireMentionInBotThreads,
+		implicitMentionKinds: params.requireMentionInBotThreads ? params.implicitMentionKinds?.filter((kind) => kind === "native") : params.implicitMentionKinds
+	};
+}
+//#endregion
+//#region \0openclaw:bundled-sdk:openclaw/plugin-sdk/channel-mention-gating
+var channel_mention_gating_exports = /* @__PURE__ */ __exportAll({ resolveBotThreadMentionPolicy: () => resolveBotThreadMentionPolicy });
+import * as import_openclaw_plugin_sdk_channel_mention_gating from "openclaw/plugin-sdk/channel-mention-gating";
+__reExport(channel_mention_gating_exports, import_openclaw_plugin_sdk_channel_mention_gating);
+//#endregion
+//#region extensions/slack/src/monitor/message-handler/prepare-thread-mentions.ts
+async function resolveSlackThreadMentionPolicy(params) {
+	const { ctx, account, message, conversation, thread } = params;
+	const { isRoom, isDirectMessage, channelConfig } = conversation;
+	let implicitMentionKinds = [];
+	if (!isDirectMessage && message.thread_ts && !params.wasMentioned) {
+		const replyToBotKinds = (0, channel_mention_gating_exports.implicitMentionKindWhen)("reply_to_bot", Boolean(ctx.botUserId && message.parent_user_id === ctx.botUserId));
+		implicitMentionKinds = replyToBotKinds.length > 0 ? replyToBotKinds : (0, channel_mention_gating_exports.implicitMentionKindWhen)("bot_thread_participant", await hasSlackThreadParticipationWithPersistence({
+			accountId: account.accountId,
+			channelId: message.channel,
+			threadTs: message.thread_ts,
+			teamId: params.teamId
+		}));
+	}
+	const requireMentionInBotThreads = channelConfig?.requireMentionInBotThreads ?? account.config.requireMentionInBotThreads;
+	let isBotOwnedThread = false;
+	if (isRoom && thread.isThreadReply && requireMentionInBotThreads !== void 0) {
+		const parentUserId = normalizeOptionalString(message.parent_user_id);
+		if (parentUserId) isBotOwnedThread = Boolean(ctx.botUserId && parentUserId === ctx.botUserId);
+		else {
+			const starter = await params.getThreadStarter();
+			isBotOwnedThread = Boolean(starter && starter.ts === thread.threadTs && isSlackThreadAuthorCurrentBot({
+				identity: ctx,
+				author: starter
+			}));
+		}
+	}
+	return resolveBotThreadMentionPolicy({
+		isBotOwnedThread,
+		requireMentionInBotThreads,
+		requireMention: isRoom ? channelConfig?.requireMention ?? ctx.defaultRequireMention : false,
+		implicitMentionKinds
+	});
+}
+//#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 = 3e5;
 const subteamMemberCache = /* @__PURE__ */ new WeakMap();
 function normalizeSlackId(value) {
-	return typeof value === "string" && value.trim() ? value.trim().toUpperCase() : void 0;
+	return normalizeOptionalString(value)?.toUpperCase();
 }
 function extractSlackSubteamMentionIds(text) {
 	if (!text) return [];
@@ -3594,7 +3453,7 @@ async function readSlackSubteamUsers(params) {
 			params.log?.(`slack: failed to resolve user-group mention ${params.subteamId}: ${response.error ?? "unknown_error"}`);
 			return /* @__PURE__ */ new Set();
 		}
-		const users = new Set((response.users ?? []).map((userId) => normalizeSlackId(userId)).filter(Boolean));
+		const users = new Set((response.users ?? []).map(normalizeSlackId).filter((userId) => userId !== void 0));
 		const expiresAt = resolveExpiresAtMsFromDurationMs(SUBTEAM_MEMBER_CACHE_TTL_MS, { nowMs: params.now });
 		if (expiresAt !== void 0) bySubteam.set(cacheKey, {
 			expiresAt,
@@ -3635,13 +3494,6 @@ function resolveSlackGroupSessionSubject(params) {
 	if (channelName && workspaceName) return `${workspaceName} #${channelName}`;
 	return `Slack Channel (Workspace ID: ${params.workspaceId}, Channel ID: ${params.channelId})`;
 }
-function recordString(record, key) {
-	return normalizeOptionalString(record?.[key]);
-}
-function recordNullableString(record, key) {
-	const value = record?.[key];
-	return value === null ? null : normalizeOptionalString(value);
-}
 function mergeSlackAssistantThreadContext(primary, fallback) {
 	if (!primary) return fallback;
 	if (!fallback) return primary;
@@ -3661,16 +3513,16 @@ function resolveSlackMessageAssistantThreadContext(message) {
 	const thread = asOptionalRecord(message.assistant_thread);
 	if (!thread) return;
 	const context = asOptionalRecord(thread.context);
-	const assistantChannelId = recordString(thread, "channel_id") ?? message.channel;
-	const threadTs = recordString(thread, "thread_ts") ?? message.thread_ts ?? message.ts;
+	const assistantChannelId = normalizeOptionalString(thread.channel_id) ?? message.channel;
+	const threadTs = normalizeOptionalString(thread.thread_ts) ?? message.thread_ts ?? message.ts;
 	if (!assistantChannelId || !threadTs) return;
 	return {
 		assistantChannelId,
 		threadTs,
-		userId: recordString(thread, "user_id") ?? message.user,
-		channelId: recordString(context, "channel_id"),
-		teamId: recordString(context, "team_id"),
-		enterpriseId: recordNullableString(context, "enterprise_id")
+		userId: normalizeOptionalString(thread.user_id) ?? message.user,
+		channelId: normalizeOptionalString(context?.channel_id),
+		teamId: normalizeOptionalString(context?.team_id),
+		enterpriseId: context?.enterprise_id === null ? null : normalizeOptionalString(context?.enterprise_id)
 	};
 }
 async function restoreSlackAssistantThreadContextFromMetadata(params) {
@@ -3752,7 +3604,7 @@ async function resolveSlackConversationContext(params) {
 	const cfg = ctx.cfg;
 	let channelInfo = {};
 	let resolvedChannelType = normalizeSlackChannelType(message.channel_type, message.channel);
-	if (resolvedChannelType !== "im" && (!message.channel_type || message.channel_type !== "im")) {
+	if (resolvedChannelType !== "im" && message.channel_type !== "im") {
 		channelInfo = await ctx.resolveChannelName(message.channel, params.eventScope);
 		resolvedChannelType = normalizeSlackChannelType(message.channel_type ?? channelInfo.type ?? ctx.recallSlackChannelType(message.channel, params.eventScope), message.channel);
 	}
@@ -3771,7 +3623,7 @@ async function resolveSlackConversationContext(params) {
 		defaultRequireMention: ctx.defaultRequireMention,
 		allowNameMatching: ctx.allowNameMatching
 	}) : null;
-	const allowBotsSetting = channelConfig?.allowBots ?? account.config?.allowBots ?? cfg.channels?.slack?.allowBots ?? false;
+	const allowBotsSetting = channelConfig?.allowBots ?? account.config?.allowBots ?? cfg.channels?.slack?.allowBots ?? true;
 	return {
 		channelInfo,
 		channelName,
@@ -3789,7 +3641,7 @@ async function authorizeSlackInboundMessage(params) {
 	const { ctx, account, message, conversation, drop } = params;
 	const { isDirectMessage, channelName, resolvedChannelType, isBotMessage, allowBotsMode } = conversation;
 	if (isBotMessage) {
-		if (message.user && ctx.botUserId && message.user === ctx.botUserId) return null;
+		if (ctx.botUserId && message.user === ctx.botUserId || ctx.botId && message.bot_id === ctx.botId) return null;
 		if (allowBotsMode === "off") return drop("bot-disabled");
 	}
 	if (isDirectMessage && !message.user) return drop("missing-user");
@@ -3938,20 +3790,21 @@ async function prepareSlackMessage(params) {
 		eventScope: opts.eventScope
 	});
 	const channelRequireMention = channelConfig?.requireMention ?? ctx.defaultRequireMention ?? true;
-	const channelChatType = isDirectMessage ? "direct" : isGroupDm ? "group" : "channel";
+	const chatType = resolveSlackChatType(conversation.resolvedChannelType);
 	const restoredAssistantThreadContext = await restoredAssistantThreadContextPromise;
 	const assistantThreadContext = mergeSlackAssistantThreadContext(messageAssistantThreadContext, cachedAssistantThreadContext ?? restoredAssistantThreadContext);
 	const assistantThreadContextToCache = messageAssistantThreadContext || restoredAssistantThreadContext ? assistantThreadContext : void 0;
 	if (assistantThreadContextToCache) ctx.saveSlackAssistantThreadContext(assistantThreadContextToCache, opts.eventScope);
-	const hasAgentViewMessageSignal = isDirectMessage && !opts.eventScope && !assistantThreadContext && isSlackAppContext(message.app_context);
+	const canUseManagedView = isDirectMessage && !opts.eventScope && !assistantThreadContext;
+	const hasAgentViewMessageSignal = canUseManagedView && isSlackAppContext(message.app_context);
 	if (hasAgentViewMessageSignal) await ctx.recordSlackAgentView();
 	const managedViewThreadTs = message.thread_ts;
-	const isManagedViewRoot = isDirectMessage && !opts.eventScope && !assistantThreadContext && !message.parent_user_id && Boolean(managedViewThreadTs && message.ts && managedViewThreadTs === message.ts);
+	const isManagedViewRoot = canUseManagedView && !message.parent_user_id && Boolean(managedViewThreadTs && message.ts && managedViewThreadTs === message.ts);
 	if (isManagedViewRoot && managedViewThreadTs) await ctx.recordSlackManagedViewThread(message.channel, managedViewThreadTs);
-	const hasManagedViewThread = isDirectMessage && !opts.eventScope && !assistantThreadContext && Boolean(managedViewThreadTs && await ctx.isSlackManagedViewThread(message.channel, managedViewThreadTs));
-	const isAgentViewMessage = isDirectMessage && !opts.eventScope && !assistantThreadContext && (hasAgentViewMessageSignal || isManagedViewRoot || hasManagedViewThread || await ctx.isSlackAgentView());
+	const hasManagedViewThread = canUseManagedView && Boolean(managedViewThreadTs && await ctx.isSlackManagedViewThread(message.channel, managedViewThreadTs));
+	const isAgentViewMessage = canUseManagedView && (hasAgentViewMessageSignal || isManagedViewRoot || hasManagedViewThread || await ctx.isSlackAgentView());
 	const agentViewThreadTs = isAgentViewMessage ? message.thread_ts ?? message.ts : void 0;
-	const channelReplyToMode = channelConfig?.replyToMode ?? resolveSlackReplyToMode(account, channelChatType);
+	const channelReplyToMode = channelConfig?.replyToMode ?? resolveSlackReplyToMode(account, chatType);
 	const willImplicitlyThreadReply = isRoom && !channelRequireMention && channelReplyToMode !== "off";
 	const seedTopLevelRoomThreadBySource = opts.source === "app_mention" || opts.wasMentioned === true || explicitlyMentioned || willImplicitlyThreadReply;
 	const resolveMessageRouting = (seedTopLevelRoomThread) => resolveSlackRoutingContext({
@@ -4034,16 +3887,6 @@ async function prepareSlackMessage(params) {
 		ok: true,
 		name: void 0
 	});
-	let implicitMentionKinds = [];
-	if (!isDirectMessage && message.thread_ts && !wasMentioned) {
-		const replyToBotKinds = implicitMentionKindWhen("reply_to_bot", Boolean(ctx.botUserId && message.parent_user_id === ctx.botUserId));
-		implicitMentionKinds = replyToBotKinds.length > 0 ? replyToBotKinds : implicitMentionKindWhen("bot_thread_participant", await hasSlackThreadParticipationWithPersistence({
-			accountId: account.accountId,
-			channelId: message.channel,
-			threadTs: message.thread_ts,
-			teamId: opts.eventScope?.teamId
-		}));
-	}
 	let threadStarterPromise;
 	const getThreadStarter = () => {
 		threadStarterPromise ??= isThreadReply && threadTs ? resolveSlackThreadStarter({
@@ -4079,7 +3922,18 @@ async function prepareSlackMessage(params) {
 		cfg,
 		surface: "slack"
 	});
-	const shouldRequireMention = isRoom ? channelConfig?.requireMention ?? ctx.defaultRequireMention : false;
+	const { requireMention: shouldRequireMention, implicitMentionKinds } = await resolveSlackThreadMentionPolicy({
+		ctx,
+		account,
+		message,
+		conversation,
+		thread: routing,
+		wasMentioned,
+		teamId: opts.eventScope?.teamId,
+		getThreadStarter
+	});
+	opts.abortSignal?.throwIfAborted();
+	if (opts.isRuntimePolicyCurrent?.() === false) return drop("final-route-denied");
 	const implicitMentions = resolveChannelImplicitMentions({
 		cfg,
 		channel: "slack",
@@ -4095,6 +3949,7 @@ async function prepareSlackMessage(params) {
 		ctx,
 		teamId: opts.eventScope?.teamId ?? ctx.teamId,
 		senderId,
+		senderAuthentication: message.user ? opts.senderAuthentication : void 0,
 		senderName: senderNameForAuth,
 		channelType: conversation.resolvedChannelType ?? "channel",
 		channelId: message.channel,
@@ -4128,7 +3983,7 @@ async function prepareSlackMessage(params) {
 		allowFromLower,
 		eventScope: opts.eventScope
 	})) return drop("unauthorized-bot");
-	const threadContextAllowFromLower = isRoom ? channelUsersAllowlistConfigured ? normalizeAllowListLower(channelConfig?.users) : [] : isDirectMessage ? allowFromLower : [];
+	const threadContextAllowFromLower = isRoom ? channelUsersAllowlistConfigured ? normalizeStringEntriesLower(channelConfig?.users) : [] : isDirectMessage ? allowFromLower : [];
 	const contextVisibilityMode = resolveChannelContextVisibilityMode({
 		cfg: ctx.cfg,
 		channel: "slack",
@@ -4245,7 +4100,6 @@ async function prepareSlackMessage(params) {
 	const ignoreOtherMentions = channelConfig?.ignoreOtherMentions ?? false;
 	if (isRoom && ignoreOtherMentions && Boolean(ctx.botUserId) && hasAnyMention && !wasMentioned) return drop("other-mention");
 	if (isRoom && shouldRequireMention && mentionDecision.shouldSkip) return drop("missing-mention");
-	const chatType = resolveSlackChatType(conversation.resolvedChannelType);
 	const inboundEventKind = classifyChannelInboundEvent({
 		conversation: { kind: chatType },
 		unmentionedGroupPolicy: resolveUnmentionedGroupInboundPolicy({
@@ -4258,6 +4112,8 @@ async function prepareSlackMessage(params) {
 	});
 	const threadStarter = await getThreadStarter();
 	const resolvedMessageContent = await getMessageContent();
+	opts.abortSignal?.throwIfAborted();
+	if (opts.isRuntimePolicyCurrent?.() === false) return drop("final-route-denied");
 	if (!resolvedMessageContent) return drop("empty-content");
 	const { rawBody, effectiveDirectMedia, commandSourceText, mentionStripPatterns } = resolvedMessageContent;
 	const bodyForAgent = preflightAudioTranscript ? formatSlackAudioTranscriptForAgent({
@@ -4278,7 +4134,7 @@ async function prepareSlackMessage(params) {
 	}) === "message_tool_only";
 	const statusReactionsExplicitlyEnabled = cfg.messages?.statusReactions?.enabled === true;
 	const isRoomEvent = inboundEventKind === "room_event";
-	const shouldAckReaction$1 = () => Boolean(ackReaction && shouldAckReaction({
+	const shouldAckReaction$1 = Boolean(ackReaction && shouldAckReaction({
 		scope: cfg.messages?.ackReactionScope,
 		inboundEventKind,
 		isDirect: isDirectMessage,
@@ -4289,7 +4145,7 @@ async function prepareSlackMessage(params) {
 		shouldBypassMention
 	}));
 	const ackReactionMessageTs = message.ts;
-	const shouldSendAckReaction = shouldAckReaction$1() && (!sourceRepliesAreToolOnly || effectiveWasMentioned || shouldBypassMention || isRoomEvent);
+	const shouldSendAckReaction = shouldAckReaction$1 && (!sourceRepliesAreToolOnly || effectiveWasMentioned || shouldBypassMention || isRoomEvent);
 	const statusReactionsWillHandle = Boolean(ackReactionMessageTs) && !isRoomEvent && statusReactionsExplicitlyEnabled && shouldSendAckReaction;
 	const ackReactionPromise = !statusReactionsWillHandle && shouldSendAckReaction && ackReactionMessageTs && ackReactionValue ? reactSlackMessage(message.channel, ackReactionMessageTs, ackReactionValue, {
 		token: ctx.botToken,
@@ -4417,20 +4273,18 @@ async function prepareSlackMessage(params) {
 	let { threadStarterBody, threadHistoryBody, shouldSeedInitialThreadContext } = threadContextData;
 	const threadScopedHistory = isThreadReply && ctx.threadHistoryScope === "thread";
 	let roomHistory = [];
-	if (isRoomish && ctx.historyLimit > 0 && (!threadScopedHistory || !shouldSeedInitialThreadContext)) {
-		if (sessionEntry?.updatedAt !== 0) roomHistory = await resolveSlackRoomHistory({
-			ctx,
-			message,
-			threadTs: threadScopedHistory ? threadTs : void 0,
-			oldest: sessionEntry?.sessionStartedAt ? (sessionEntry.sessionStartedAt / 1e3).toFixed(6) : void 0,
-			excludedMessageIds,
-			allowFromLower: threadContextAllowFromLower,
-			contextVisibilityMode,
-			eventScope: opts.eventScope,
-			assertCurrent: assertHistoryCurrent,
-			abortSignal: opts.abortSignal
-		});
-	}
+	if (isRoomish && ctx.historyLimit > 0 && (!threadScopedHistory || !shouldSeedInitialThreadContext) && sessionEntry?.updatedAt !== 0) roomHistory = await resolveSlackRoomHistory({
+		ctx,
+		message,
+		threadTs: threadScopedHistory ? threadTs : void 0,
+		oldest: sessionEntry?.sessionStartedAt ? (sessionEntry.sessionStartedAt / 1e3).toFixed(6) : void 0,
+		excludedMessageIds,
+		allowFromLower: threadContextAllowFromLower,
+		contextVisibilityMode,
+		eventScope: opts.eventScope,
+		assertCurrent: assertHistoryCurrent,
+		abortSignal: opts.abortSignal
+	});
 	const effectiveMedia = effectiveDirectMedia ?? threadStarterMedia;
 	let inboundMedia = await toInboundMediaFactsWithMetadata(effectiveMedia, { transcribed: (entry) => effectiveMedia === effectiveDirectMedia && entry === preflightAudioMedia });
 	opts.abortSignal?.throwIfAborted();