@openclaw/slack 2026.9.5 → 2026.9.7

package/dist/.setup/{pipeline.runtime-BZqGcbfi.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-BhG6pdiH.mjs";
-import { n as formatSlackTarget } from "./target-parsing-DEsPjngB.mjs";
-import { E as normalizeSlackAllowOwnerEntry, O as resolveSlackAllowListMatch, T as normalizeAllowListLower, o as formatSlackError } from "./probe-64C6k3_Q.mjs";
-import { a as prepareSlackReply, l as resolveSlackReplyRenderPlan } from "./reply-blocks-9uCeAJts.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-BvGUGk3w.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-6GCb3lBP.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-w36VTgZ3.mjs";
-import { n as resolveSlackChannelConfig } from "./policy-Db_QWCZZ.mjs";
-import { a as resolveSlackThreadTs, i as readSlackReplyBlocks, n as deliverReplies, o as sanitizeSlackMonitorReplyPayload, s as emitSlackMessageSentHooks, t as createSlackReplyDeliveryPlan } from "./replies-CWFhjS9S.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, createFinalizableDraftStreamControlsForState, defineFinalizableLivePreviewAdapter, deliverWithFinalizableLivePreviewAdapter, formatChannelProgressDraftDiffStat, formatChannelProgressDraftText, formatPlanChecklistLines, isChannelProgressDraftWorkToolName, 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 } from "openclaw/plugin-sdk/number-runtime";
+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,17 +31,19 @@ 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 { createChannelHistoryWindow } from "openclaw/plugin-sdk/reply-history";
+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, recordDroppedChannelInboundHistory, resolveEnvelopeFormatOptions, resolveGroupThreadConfig, resolveGroupThreadMentionFacts, resolveInboundMentionDecision, resolveInboundReplyDispatchCounts, resolveInboundSupplementalSenderAllowed, 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
 const SLACK_TIMESTAMP_RE = /^\d+(?:\.\d+)?$/;
@@ -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) {
@@ -206,17 +173,22 @@ function createSlackDraftStream(params) {
 	const edit = params.edit ?? editSlackMessage;
 	const remove = params.remove ?? deleteSlackMessage;
 	let streamMessage;
+	let streamGeneration = 0;
+	let cleanupGeneration = -1;
 	let untrackConversationBoundary;
 	let lastVisibleUpdate;
 	let lastSentKey = "";
-	const pendingCleanupMessages = [];
-	let cleanupTail = Promise.resolve();
-	const finalizedMessageIds = /* @__PURE__ */ new Set();
+	let preserveHumanReplies = false;
 	const streamState = {
 		stopped: false,
 		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);
@@ -232,8 +204,10 @@ function createSlackDraftStream(params) {
 		const sentKey = `${trimmed}\n${blocks ? JSON.stringify(blocks) : ""}`;
 		if (sentKey === lastSentKey) return;
 		lastSentKey = sentKey;
+		const generation = streamGeneration;
 		try {
 			if (streamMessage) {
+				const message = streamMessage;
 				await edit(streamMessage.channelId, streamMessage.messageId, trimmed, {
 					cfg: params.cfg,
 					token: params.token,
@@ -241,7 +215,7 @@ function createSlackDraftStream(params) {
 					...params.eventScope ? { client: params.eventScope.client } : {},
 					...blocks ? { blocks } : {}
 				});
-				lastVisibleUpdate = {
+				if (streamMessage === message) lastVisibleUpdate = {
 					text: trimmed,
 					...blocks ? { blocks } : {}
 				};
@@ -266,16 +240,22 @@ function createSlackDraftStream(params) {
 				...params.metadata ? { metadata: params.metadata } : {},
 				...blocks ? { blocks } : {}
 			});
+			const sentMessage = {
+				channelId: sent.channelId,
+				messageId: sent.messageId,
+				generation
+			};
+			if (generation !== streamGeneration) {
+				if (sent.channelId && sent.messageId) lifecycle.retire(sentMessage, { defer: true });
+				return;
+			}
 			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
-			};
+			streamMessage = sentMessage;
 			lastVisibleUpdate = {
 				text: trimmed,
 				...blocks ? { blocks } : {}
@@ -293,72 +273,84 @@ function createSlackDraftStream(params) {
 				}).stop;
 			}
 		} catch (err) {
-			stopTrackingConversationBoundary();
-			streamState.stopped = true;
+			if (generation === streamGeneration) {
+				stopTrackingConversationBoundary();
+				streamState.stopped = true;
+			}
 			params.warn?.(`slack stream preview failed: ${formatSlackError(err)}`);
 		}
 	};
-	const { loop, update, discardPending, seal } = createFinalizableDraftStreamControlsForState({
+	const lifecycle = createFinalizableDraftLifecycle({
 		throttleMs,
 		coalesceInFlight: true,
 		state: streamState,
 		sendOrEditStreamMessage,
 		emptyValue: "",
-		isEmpty: (value) => !normalizeUpdate(value).text.trim()
+		isEmpty: (value) => !normalizeUpdate(value).text.trim(),
+		readMessageId: () => streamMessage,
+		clearMessageId,
+		isValidMessageId: (value) => typeof value === "object" && value !== null,
+		deleteMessage: async (message) => {
+			if (message.generation > cleanupGeneration) return false;
+			if (!message.retained && !(preserveHumanReplies && message.detachedByHuman)) await remove(message.channelId, message.messageId, {
+				token: params.token,
+				accountId: params.accountId,
+				...params.eventScope ? { client: params.eventScope.client } : {}
+			});
+			return true;
+		},
+		warn: params.warn,
+		warnPrefix: "slack stream preview cleanup failed"
 	});
+	const { loop, update, discardPending, seal } = lifecycle;
 	const stopTrackingConversationBoundary = () => {
 		untrackConversationBoundary?.();
 		untrackConversationBoundary = void 0;
 	};
-	const dropDetachedMessages = (preserveHumanReplies = false) => {
-		cleanupTail = cleanupTail.then(async () => {
-			for (let index = 0; index < pendingCleanupMessages.length;) {
-				const message = pendingCleanupMessages[index];
-				if (!message) return;
-				if (preserveHumanReplies && message.detachedByHuman) {
-					pendingCleanupMessages.splice(index, 1);
-					continue;
-				}
-				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;
-				}
-			}
+	const dropDetachedMessages = () => {
+		const generation = streamGeneration;
+		return lifecycle.cleanupPending(() => {
+			preserveHumanReplies = false;
+			cleanupGeneration = generation;
 		});
-		return cleanupTail;
 	};
 	const discardPendingAndStopTracking = async () => {
+		const generation = streamGeneration;
 		await discardPending();
-		stopTrackingConversationBoundary();
+		if (generation === streamGeneration) stopTrackingConversationBoundary();
 	};
 	const clear = async (options) => {
-		await discardPendingAndStopTracking();
-		if (streamMessage) {
-			pendingCleanupMessages.push(streamMessage);
-			streamMessage = void 0;
-		}
-		lastVisibleUpdate = void 0;
-		lastSentKey = "";
-		await dropDetachedMessages(options?.preserveHumanReplies);
+		const generation = streamGeneration;
+		let clearingMessage = streamMessage;
+		await lifecycle.clearWithStop(async () => {
+			if (generation === streamGeneration) {
+				await discardPendingAndStopTracking();
+				if (generation === streamGeneration) {
+					clearingMessage = streamMessage;
+					clearMessageId();
+				}
+			}
+			cleanupGeneration = generation;
+			preserveHumanReplies = options?.preserveHumanReplies === true;
+		}, {
+			readMessageId: () => clearingMessage,
+			clearMessageId: () => {
+				clearingMessage = void 0;
+			}
+		});
 	};
 	const forceNewMessage = (reason = "turn") => {
 		stopTrackingConversationBoundary();
-		if (reason === "turn") streamState.stopped = false;
+		if (reason === "turn") {
+			streamState.stopped = false;
+			streamGeneration += 1;
+		}
 		streamState.final = false;
-		if (streamMessage && !finalizedMessageIds.has(streamMessage.messageId)) {
+		if (streamMessage && !streamMessage.retained) {
 			streamMessage.detachedByHuman = reason === "human";
-			pendingCleanupMessages.push(streamMessage);
+			lifecycle.retire(streamMessage, { defer: true });
 		}
-		streamMessage = void 0;
-		lastVisibleUpdate = void 0;
-		lastSentKey = "";
+		clearMessageId();
 		loop.resetPending();
 	};
 	const finalizeMessage = async (messageId, editFinal) => {
@@ -368,7 +360,7 @@ function createSlackDraftStream(params) {
 		const { channelId } = currentMessage;
 		await editFinal();
 		if (streamMessage?.channelId === channelId && streamMessage.messageId === messageId) {
-			finalizedMessageIds.add(messageId);
+			currentMessage.retained = true;
 			stopTrackingConversationBoundary();
 			return true;
 		}
@@ -459,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 {
@@ -620,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);
@@ -647,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 [{
@@ -699,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}`,
@@ -718,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);
 }
@@ -913,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);
@@ -958,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;
 			}
@@ -978,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,
@@ -1021,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,
@@ -1033,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";
@@ -1048,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()
 				});
 			});
@@ -1067,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();
 		}
 	};
 }
@@ -1095,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 () => {
@@ -1124,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 {
@@ -1174,8 +1137,8 @@ function createSlackNativeProgressTransport(params) {
 //#endregion
 //#region extensions/slack/src/monitor/message-handler/dispatch-progress.ts
 function createSlackProgressRuntime(runtimeParams) {
-	const { setup, delivery, resetPreviewDeliveryState } = runtimeParams;
-	const { account, cfg, ctx, hasSlackCustomIdentity, message, prepared, replyPlan, runtime, slackClient, slackIdentity, slackMessageMetadata, slackStreaming, shouldUseDraftStream, useStreaming, previewStreamingEnabled } = setup;
+	const { setup, delivery } = runtimeParams;
+	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,
@@ -1199,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,
@@ -1220,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);
@@ -1236,7 +1198,6 @@ function createSlackProgressRuntime(runtimeParams) {
 		draftStream,
 		enabled: useDraftProgressCard,
 		progressWorkCounter: previewToolProgressEnabled ? progressWorkCounter : void 0,
-		progressSeed,
 		explicitTitle: explicitProgressTitle,
 		maxLineChars: progressDraftMaxLineChars,
 		getSnapshot: () => progressDraft.getSnapshot(),
@@ -1345,30 +1306,30 @@ function createSlackProgressRuntime(runtimeParams) {
 		nativeUpdates.stop();
 		await nativeUpdates.waitForInFlight();
 	};
-	const appendNativeNarration = (payload, kind) => withNativeStreamOrder(() => appendNativeNarrationNow(payload, kind));
-	const appendNativeNarrationNow = async (payload, kind) => {
-		if (isRenderedAsProgressTitle(payload.text)) return false;
+	const appendNativeNarration = (payload, kind) => withNativeStreamOrder(async () => {
+		if (isRenderedAsProgressTitle(payload.text)) return { visibleReplySent: false };
 		const narrationUpdate = resolveNarrationUpdate(payload.text?.trimEnd());
-		if (!narrationUpdate.delta) return false;
-		await delivery.deliverWithStreaming({
+		if (!narrationUpdate.delta) return { visibleReplySent: false };
+		const result = await delivery.deliverWithStreaming({
 			payload,
 			kind,
 			streamText: narrationUpdate.delta,
 			appendSeparator: false,
 			taskDisplayMode: "plan"
 		});
-		if (!delivery.streamFailed) {
+		if (result.visibleReplySent && !delivery.streamFailed) {
 			nativeNarrationRenderedText = narrationUpdate.next.rendered;
 			nativeNarrationSourceText = narrationUpdate.next.source;
 		}
-		return true;
-	};
+		return result;
+	});
 	const resetProgressTurnState = () => {
 		progressWorkCounter.reset();
 		nativeNarrationRenderedText = "";
 		nativeNarrationSourceText = "";
 	};
 	const progressDraft = createChannelProgressDraftCompositor({
+		preparedItems: true,
 		entry: account.config,
 		mode: slackStreaming.mode,
 		active: progressDraftActive,
@@ -1390,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,
@@ -1415,51 +1375,70 @@ function createSlackProgressRuntime(runtimeParams) {
 			}
 		}
 	});
+	const previewLifecycle = createLivePreviewLifecycle({
+		draft: draftStream && !useDraftProgressCard ? {
+			flush: draftStream.flush,
+			discardPending: draftStream.discardPending,
+			seal: draftStream.seal,
+			id: () => {
+				const channelId = draftStream.channelId();
+				const messageId = draftStream.messageId();
+				return channelId && messageId ? {
+					channelId,
+					messageId
+				} : void 0;
+			},
+			clear: async () => {
+				await draftStream.clear({ preserveHumanReplies: !isProgressMode && previewLifecycle.finalDelivered });
+			}
+		} : void 0,
+		cleanupUndelivered: true,
+		onFinalStarted: () => progressDraft.markFinalReplyStarted(),
+		onFinalDelivered: () => progressDraft.markFinalReplyDelivered(),
+		onCleanupFailure: (error) => logVerbose(`slack: progress preview cleanup failed (${formatSlackError(error)})`)
+	});
 	const commentaryProgressEnabled = progressDraft.commentaryProgressEnabled;
 	const deliverNativeFinal = async (payload, kind) => {
-		progressDraft.markFinalReplyStarted();
 		await cancelNativeUpdates();
-		await withNativeStreamOrder(() => deliverNativeFinalNow(payload, kind));
+		return await withNativeStreamOrder(() => deliverNativeFinalNow(payload, kind));
 	};
 	const deliverNativeFinalNow = async (payload, kind) => {
-		progressDraft.markFinalReplyStarted();
 		const streamReady = await nativeTransport.waitForStart();
 		const finalThreadTs = delivery.streamSession?.threadTs ?? delivery.nativeProgressStreamThreadTs;
 		if (payload.isError !== true && streamReady && Boolean(delivery.streamSession) && delivery.isStreamingEligible(payload, { maxTextBytes: 4e3 })) {
 			await appendNativeProgressCompletion(false);
-			await delivery.deliverWithStreaming({
+			return await delivery.deliverWithStreaming({
 				payload,
 				kind
 			});
-		} else {
-			await delivery.deliverNormally({
-				payload,
-				kind,
-				forcedThreadTs: finalThreadTs
-			});
-			await appendNativeProgressCompletion(payload.isError === true);
 		}
-		progressDraft.markFinalReplyDelivered();
+		const result = await delivery.deliverNormally({
+			payload,
+			kind,
+			forcedThreadTs: finalThreadTs
+		});
+		await appendNativeProgressCompletion(payload.isError === true);
+		return result;
 	};
 	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 ? [{
@@ -1530,12 +1509,12 @@ 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();
 		}
@@ -1546,7 +1525,7 @@ function createSlackProgressRuntime(runtimeParams) {
 		nativeUpdatesStopped = false;
 		nativeUpdates.resetThrottleWindow();
 		progressCard.reset();
-		resetPreviewDeliveryState();
+		previewLifecycle.reset();
 		delivery.resetDeliveryTracker();
 		return true;
 	};
@@ -1561,26 +1540,26 @@ function createSlackProgressRuntime(runtimeParams) {
 	};
 	const onQueuedFollowupAdmitted = !shouldUseDraftStream && !useNativeProgressStreaming ? void 0 : async () => {
 		await draftStream?.flush();
-		resetPreviewDeliveryState();
 		if (isProgressMode) await beginNewProgressTurn({ force: true });
-		else draftStream?.forceNewMessage();
+		else {
+			await previewLifecycle.cleanup();
+			previewLifecycle.reset();
+			draftStream?.forceNewMessage();
+		}
 		delivery.resetDeliveryTracker();
 		resetDraftDeliveryState();
 		progressDraft.reset();
 	};
-	const onQueuedFollowupSettled = !useDraftProgressCard && !useNativeProgressStreaming && !preambleOnlyProgress ? void 0 : async () => {
+	const onQueuedFollowupSettled = !draftStream && !useNativeProgressStreaming ? void 0 : async () => {
 		if (useNativeProgressStreaming) {
 			progressDraft.markFinalReplyStarted();
 			await cancelNativeUpdates();
 			await finishNativeProgressTurn(nativeProgressCompletionSent ? void 0 : buildNativeProgressCompletionChunks(nativeProgressTerminalStatus));
-			progressDraft.markFinalReplyDelivered();
 			return;
 		}
-		if (preambleOnlyProgress) {
+		if (!useDraftProgressCard) {
 			progressDraft.markFinalReplyStarted();
-			await draftStream?.clear();
-			await draftStream?.dropDetachedMessages();
-			progressDraft.markFinalReplyDelivered();
+			await previewLifecycle.cleanup();
 			return;
 		}
 		if (!progressCard.hasTerminalized) await draftStream?.clear();
@@ -1588,6 +1567,7 @@ function createSlackProgressRuntime(runtimeParams) {
 	};
 	return {
 		draftStream,
+		previewLifecycle,
 		isProgressMode,
 		useDraftProgressCard,
 		useNativeProgressStreaming,
@@ -1616,6 +1596,7 @@ function createSlackProgressRuntime(runtimeParams) {
 		deliverNativeFinal,
 		dropDetachedProgressCards,
 		finalizeDraftProgressCard: progressCard.finalize,
+		onVisibleWorkSessions: progressCard.onVisibleWorkSessions,
 		onDraftBoundary,
 		onQueuedFollowupAdmitted,
 		onQueuedFollowupSettled,
@@ -1672,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,
@@ -1701,6 +1682,7 @@ async function createSlackDispatchSetup(prepared) {
 	const messageTs = message.ts ?? message.event_ts;
 	const incomingThreadTs = message.thread_ts;
 	let didSetStatus = false;
+	let statusWasSet = false;
 	let didAddTypingReaction = false;
 	const statusReactionsEnabled = prepared.ctxPayload.InboundEventKind !== "room_event" && Boolean(prepared.ackReactionPromise) && Boolean(reactionMessageTs) && cfg.messages?.statusReactions?.enabled === true;
 	const statusReactions = createStatusReactionController({
@@ -1739,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,
@@ -1752,7 +1738,7 @@ async function createSlackDispatchSetup(prepared) {
 			start: async () => {
 				if (!didSetStatus && !threadStatusGate.hasVisibleOutput()) {
 					didSetStatus = true;
-					await ctx.setSlackSessionStatus({
+					statusWasSet = await ctx.setSlackSessionStatus({
 						channelId: message.channel,
 						threadTs: statusThreadTs,
 						status: "processing",
@@ -1773,12 +1759,17 @@ async function createSlackDispatchSetup(prepared) {
 			stop: async () => {
 				if (didSetStatus) {
 					didSetStatus = false;
-					await ctx.setSlackSessionStatus({
+					const reportFailure = statusWasSet;
+					statusWasSet = false;
+					const restored = await ctx.setSlackSessionStatus({
 						channelId: message.channel,
 						threadTs: statusThreadTs,
 						status: "active",
 						eventScope: prepared.eventScope
 					});
+					if (reportFailure && !restored) try {
+						runtime.error?.("Slack session status could not return to active after processing. Enable verbose logging to inspect the Slack API failure.");
+					} catch {}
 				}
 				if (didAddTypingReaction && typingReaction && message.ts) {
 					didAddTypingReaction = false;
@@ -1810,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
 	});
@@ -1850,13 +1834,10 @@ async function createSlackDispatchSetup(prepared) {
 		isThreadReply,
 		replyDeliveryMode,
 		sourceReplyDeliveryMode,
-		sourceRepliesAreToolOnly,
 		suppressRoomEventTyping,
 		messageSentHookTarget,
 		messageSentHookContext,
 		messageSentDeliveryHookContext,
-		incomingThreadTs,
-		messageTs,
 		statusReactionsEnabled,
 		statusReactions,
 		hasRepliedRef,
@@ -1865,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
@@ -1888,9 +1871,43 @@ function createSlackStreamingDeliveryRuntime(setup) {
 		streamFailed: false,
 		usedReplyThreadTs: void 0,
 		usedBlockReplyThreadTs: void 0,
-		observedReplyDelivery: false,
-		observedFinalReplyDelivery: false
+		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,
@@ -1930,30 +1947,19 @@ function createSlackStreamingDeliveryRuntime(setup) {
 			if (session.stoppedBySlack) return;
 			state.observedReplyDelivery = true;
 			state.usedReplyThreadTs ??= session.threadTs;
-			return stopResult;
+			return {
+				visibleReplySent: session.delivered,
+				...stopResult.messageId ? { messageIds: [stopResult.messageId] } : {},
+				threadId: session.threadTs
+			};
 		} catch (stopErr) {
 			if (stopErr instanceof SlackStreamNotDeliveredError) fallbackError = stopErr;
 			else throw stopErr;
 		}
 		const fallbackText = fallbackError.pendingText.trim();
 		if (!fallbackText) return;
-		await deliverReplies({
-			cfg: ctx.cfg,
-			replies: [prepareSlackReply({ text: fallbackText })],
-			target: prepared.replyTarget,
-			token: ctx.botToken,
-			accountId: account.accountId,
-			runtime,
-			textLimit: ctx.textLimit,
-			mediaMaxBytes: ctx.mediaMaxBytes,
-			replyThreadTs: session.threadTs,
-			replyToMode: replyDeliveryMode,
-			...slackIdentity ? { identity: slackIdentity } : {},
-			...slackMessageMetadata ? { metadata: slackMessageMetadata } : {},
-			...messageSentDeliveryHookContext,
-			deferMessageSentHooks: true,
-			eventScope: prepared.eventScope
-		});
+		const sent = await deliverPreparedReply(prepareSlackReply({ text: fallbackText }), session.threadTs, true);
+		if (!sent?.receipt.platformMessageIds.length) return;
 		markSlackStreamFallbackDelivered(session);
 		if (!session.stopped) try {
 			await stopSlackStream({
@@ -1966,7 +1972,12 @@ function createSlackStreamingDeliveryRuntime(setup) {
 		state.observedReplyDelivery = true;
 		state.usedReplyThreadTs ??= session.threadTs;
 		logVerbose(`slack-stream: streamed delivery failed (${fallbackError.slackCode}); delivered ${fallbackText.length} chars via deliverReplies fallback`);
-		return {};
+		return {
+			visibleReplySent: true,
+			messageIds: sent.receipt.platformMessageIds,
+			receipt: sent.receipt,
+			threadId: sent.threadTs ?? session.threadTs
+		};
 	};
 	const finishStream = async (chunks) => {
 		const session = state.streamSession;
@@ -1988,7 +1999,7 @@ function createSlackStreamingDeliveryRuntime(setup) {
 		}
 	};
 	const deliverNormally = async (params) => {
-		if (state.streamSession?.stoppedBySlack) return;
+		if (state.streamSession?.stoppedBySlack) return { visibleReplySent: false };
 		const replyThreadTs = resolveDeliveryThreadTs(params);
 		const deliveryReplyThreadTs = replyDeliveryMode === "off" && !forcedReplyThreadTs && !isThreadReply ? void 0 : replyThreadTs;
 		const preparedReply = prepareSlackReply(params.payload);
@@ -1999,26 +2010,11 @@ function createSlackStreamingDeliveryRuntime(setup) {
 		}, preparedReply);
 		if (deliveryTracker.hasDelivered(deliveryKey)) {
 			logVerbose("slack: suppressed duplicate normal delivery within the same turn");
-			return deliveryReplyThreadTs;
+			return { visibleReplySent: false };
 		}
-		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;
-		if (params.kind === "final") state.observedFinalReplyDelivery = true;
 		const deliveredThreadTs = resolveSlackReplyThreadTs({
 			replyToMode: replyDeliveryMode,
 			replyToId: params.payload.replyToId,
@@ -2028,36 +2024,37 @@ function createSlackStreamingDeliveryRuntime(setup) {
 		rememberDeliveredThreadTs(params.kind, deliveredThreadTs);
 		replyPlan.markSent();
 		deliveryTracker.markDelivered(deliveryKey);
-		return deliveryReplyThreadTs;
+		return {
+			visibleReplySent: true,
+			messageIds: sent.receipt.platformMessageIds,
+			receipt: sent.receipt,
+			threadId: sent.threadTs ?? deliveredThreadTs
+		};
 	};
 	const isStreamingEligible = (payload, options) => {
 		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;
-		if (!isStreamingEligible(params.payload)) {
-			await deliverNormally({
-				payload: params.payload,
-				kind: params.kind,
-				forcedThreadTs: state.streamSession?.threadTs ?? state.nativeProgressStreamThreadTs
-			});
-			return;
-		}
+		if (state.streamSession?.stoppedBySlack) return { visibleReplySent: false };
+		if (!isStreamingEligible(params.payload)) return await deliverNormally({
+			payload: params.payload,
+			kind: params.kind,
+			forcedThreadTs: state.streamSession?.threadTs ?? state.nativeProgressStreamThreadTs
+		});
 		if (!state.streamSession && state.nativeProgressStreamStartPromise) await state.nativeProgressStreamStartPromise;
-		if (state.streamSession?.stoppedBySlack) return;
+		if (state.streamSession?.stoppedBySlack) return { visibleReplySent: false };
 		let session = state.streamSession;
 		const threadTs = session?.threadTs ?? replyPlan.nextThreadTs();
 		if (state.streamFailed || !threadTs) {
 			state.streamFailed = true;
-			await deliverNormally({
+			return await deliverNormally({
 				payload: params.payload,
 				kind: params.kind,
 				forcedThreadTs: threadTs ?? state.nativeProgressStreamThreadTs
 			});
-			return;
 		}
 		const hookContent = resolveSendableOutboundReplyParts(params.payload).trimmedText;
 		const text = params.streamText ?? hookContent;
@@ -2068,35 +2065,22 @@ function createSlackStreamingDeliveryRuntime(setup) {
 		});
 		if (deliveryTracker.hasDelivered(deliveryKey)) {
 			logVerbose("slack-stream: suppressed duplicate reply payload");
-			return;
+			return { visibleReplySent: false };
 		}
 		let messageId;
+		let fallbackDelivery;
 		try {
 			if (session) await appendSlackStream({
 				session,
 				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;
@@ -2107,18 +2091,16 @@ function createSlackStreamingDeliveryRuntime(setup) {
 				});
 				throw error;
 			}
-			if (!session) {
-				await deliverNormally({
-					payload: params.payload,
-					kind: params.kind,
-					forcedThreadTs: threadTs
-				});
-				return;
-			}
+			if (!session) return await deliverNormally({
+				payload: params.payload,
+				kind: params.kind,
+				forcedThreadTs: threadTs
+			});
 			try {
 				const fallback = await deliverPendingStreamFallback(session, error);
 				if (!fallback && !session.stoppedBySlack) throw error;
-				messageId = fallback?.messageId;
+				fallbackDelivery = fallback;
+				messageId = fallback?.receipt ? void 0 : fallback?.messageIds?.[0];
 			} catch (fallbackError) {
 				emitStreamedDelivery(hookContent, {
 					success: false,
@@ -2132,10 +2114,10 @@ function createSlackStreamingDeliveryRuntime(setup) {
 				success: false,
 				error: "Stopped by Slack user"
 			});
-			return;
+			return { visibleReplySent: false };
 		}
+		if (!fallbackDelivery?.visibleReplySent && (!session.delivered || session.pendingText)) return { visibleReplySent: false };
 		state.observedReplyDelivery = true;
-		if (params.kind === "final") state.observedFinalReplyDelivery = true;
 		rememberDeliveredThreadTs(params.kind, threadTs);
 		replyPlan.markSent();
 		deliveryTracker.markDelivered(deliveryKey);
@@ -2143,15 +2125,20 @@ function createSlackStreamingDeliveryRuntime(setup) {
 			success: true,
 			...messageId ? { messageId } : {}
 		});
+		return fallbackDelivery ?? {
+			visibleReplySent: true,
+			...messageId ? { messageIds: [messageId] } : {},
+			threadId: threadTs
+		};
 	};
 	return Object.assign(state, {
 		deliverNormally,
 		deliverWithStreaming,
 		finishStream,
-		hasDelivered: (params) => deliveryTracker.hasDelivered(buildSlackEventDeliveryKey(params)),
 		isStreamingEligible,
 		markPreviewPayloadDelivered,
 		rememberDeliveredThreadTs,
+		startStream,
 		resetDeliveryTracker: () => {
 			deliveryTracker = createSlackEventDeliveryTracker();
 		}
@@ -2194,17 +2181,12 @@ async function dispatchSlackMessageWithSetup(setup, beginSessionRun, turnAdoptio
 	const { account, cfg, ctx, disableBlockStreaming, hasSlackCustomIdentity, hasRepliedRef, message, messageSentHookContext, messageSentHookTarget, onModelSelected, previewStreamingEnabled, replyPipeline, replyPlan, route, runtime, slackClient, slackStreaming, sourceReplyDeliveryMode, statusReactions, statusReactionsEnabled, statusThreadTs, suppressRoomEventTyping, useStreaming } = setup;
 	let dispatchError;
 	const delivery = createSlackStreamingDeliveryRuntime(setup);
-	const draftPreviewCommitted = { value: false };
 	const progress = createSlackProgressRuntime({
 		setup,
-		delivery,
-		resetPreviewDeliveryState: () => {
-			draftPreviewCommitted.value = false;
-			delivery.observedFinalReplyDelivery = false;
-		}
+		delivery
 	});
-	const draftStream = progress.draftStream;
-	setup.threadStatusGate.hasVisibleOutput = () => delivery.observedReplyDelivery || draftPreviewCommitted.value || Boolean(draftStream?.messageId());
+	const { draftStream, previewLifecycle } = progress;
+	setup.threadStatusGate.hasVisibleOutput = () => delivery.observedReplyDelivery || previewLifecycle.previewFinalized || Boolean(draftStream?.messageId());
 	const failureNoticeThreadTs = message.thread_ts;
 	const failureNoticeTeamId = prepared.eventScope?.teamId;
 	let sawTerminalFailurePayload = false;
@@ -2212,7 +2194,7 @@ async function dispatchSlackMessageWithSetup(setup, beginSessionRun, turnAdoptio
 	const filterPassiveThreadFailure = (payload) => {
 		if (payload.isError !== true || prepared.ctxPayload.ChatType !== "channel" || isReplyPayloadNonTerminalToolErrorWarning(payload)) return payload;
 		sawTerminalFailurePayload = true;
-		if (delivery.observedReplyDelivery || draftPreviewCommitted.value) return payload;
+		if (delivery.observedReplyDelivery || previewLifecycle.previewFinalized) return payload;
 		const explicitlyAddressed = prepared.ctxPayload.ExplicitlyMentionedBot === true || prepared.ctxPayload.MentionSource === "explicit_bot" || prepared.ctxPayload.MentionSource === "subteam" || prepared.ctxPayload.MentionSource === "mention_pattern" || prepared.ctxPayload.MentionSource === "command_bypass" || prepared.ctxPayload.CommandTurn?.kind !== void 0 && prepared.ctxPayload.CommandTurn.kind !== "normal" && prepared.ctxPayload.CommandTurn.authorized;
 		const noticeThreadTs = failureNoticeThreadTs ?? (explicitlyAddressed ? statusThreadTs : void 0);
 		const notice = {
@@ -2233,14 +2215,6 @@ async function dispatchSlackMessageWithSetup(setup, beginSessionRun, turnAdoptio
 		pendingFailureNotice = notice;
 		return payload;
 	};
-	let compactFinalDeliveryStarted = false;
-	const clearCompactProgress = async () => {
-		try {
-			await draftStream?.clear();
-		} catch (err) {
-			logVerbose(`slack: progress preview cleanup failed (${formatSlackError(err)})`);
-		}
-	};
 	const deliverSlackPayload = async (incomingPayload, info) => {
 		let payload = incomingPayload;
 		if (info.participant && (payload.text || payload.mediaUrl || payload.mediaUrls?.length)) payload = {
@@ -2248,66 +2222,42 @@ async function dispatchSlackMessageWithSetup(setup, beginSessionRun, turnAdoptio
 			text: formatSlackGroupThreadReply(payload.text ?? "", info.participant)
 		};
 		if (info.kind === "final" && slackStreaming.mode === "progress" && progress.isProgressMode) {
-			if (progress.useNativeProgressStreaming) {
-				await progress.deliverNativeFinal(payload, info.kind);
-				return;
-			}
-			progress.progressDraft.markFinalReplyStarted();
-			if (!progress.useDraftProgressCard) {
-				compactFinalDeliveryStarted = true;
-				await draftStream?.discardPending();
-				const supplement = getReplyPayloadTtsSupplement(payload);
-				await delivery.deliverNormally({
-					payload: supplement && !supplement.visibleTextAlreadyDelivered && !payload.text?.trim() ? {
-						...payload,
-						text: supplement.spokenText
-					} : payload,
-					kind: info.kind,
-					forcedThreadTs: delivery.usedReplyThreadTs
-				});
-				if (delivery.observedFinalReplyDelivery) {
-					progress.progressDraft.markFinalReplyDelivered();
-					await clearCompactProgress();
-				}
-				return;
-			}
-			if (progress.useDraftProgressCard) {
-				await delivery.deliverNormally({
-					payload,
+			const supplement = getReplyPayloadTtsSupplement(payload);
+			const finalPayload = !progress.useDraftProgressCard && !progress.useNativeProgressStreaming && supplement && !supplement.visibleTextAlreadyDelivered && !payload.text?.trim() ? {
+				...payload,
+				text: supplement.spokenText
+			} : payload;
+			return (await previewLifecycle.deliver({
+				kind: info.kind,
+				payload: finalPayload,
+				isError: payload.isError === true,
+				deliverNormally: (reply) => progress.useNativeProgressStreaming ? progress.deliverNativeFinal(reply, info.kind) : delivery.deliverNormally({
+					payload: reply,
 					kind: info.kind,
 					forcedThreadTs: delivery.usedReplyThreadTs
-				});
-				if (!await progress.finalizeDraftProgressCard(payload.isError === true ? "error" : "success")) await draftStream?.clear();
-				progress.progressDraft.markFinalReplyDelivered();
-				return;
-			}
+				}),
+				onNormalDelivered: progress.useDraftProgressCard ? async () => {
+					if (!await progress.finalizeDraftProgressCard(payload.isError === true ? "error" : "success")) await draftStream?.clear();
+				} : void 0
+			})).deliveryResult ?? { visibleReplySent: false };
 		}
 		if (progress.useNativeProgressStreaming) {
-			if (info.kind !== "final" && payload.isError !== true) {
-				if (!delivery.isStreamingEligible(payload)) {
-					await delivery.deliverNormally({
-						payload,
-						kind: info.kind,
-						forcedThreadTs: delivery.streamSession?.threadTs ?? delivery.nativeProgressStreamThreadTs
-					});
-					return;
-				}
-				return await progress.appendNativeNarration(payload, info.kind) ? void 0 : { visibleReplySent: false };
-			}
-			await delivery.deliverNormally({
+			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,
 				forcedThreadTs: delivery.streamSession?.threadTs ?? delivery.nativeProgressStreamThreadTs
 			});
-			return;
 		}
-		if (useStreaming) {
-			await delivery.deliverWithStreaming({
-				payload,
+		if (useStreaming) return (await previewLifecycle.deliver({
+			kind: info.kind,
+			payload,
+			isError: payload.isError === true,
+			deliverNormally: (reply) => delivery.deliverWithStreaming({
+				payload: reply,
 				kind: info.kind
-			});
-			return;
-		}
+			})
+		})).deliveryResult ?? { visibleReplySent: false };
 		const reply = resolveSendableOutboundReplyParts(payload);
 		const ttsSupplement = getReplyPayloadTtsSupplement(payload);
 		const replySourceText = payload.text ?? ttsSupplement?.spokenText;
@@ -2321,26 +2271,13 @@ async function dispatchSlackMessageWithSetup(setup, beginSessionRun, turnAdoptio
 			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();
+		const shouldRestoreTtsSupplementTextForPreviewFallback = Boolean(ttsSupplement) && ttsSupplement?.visibleTextAlreadyDelivered !== true && Boolean(draftStream) && !previewLifecycle.previewFinalized && !previewLifecycle.finalDelivered && previewStreamingEnabled && !payload.text?.trim();
 		let ttsPreviewFinalization;
-		await deliverWithFinalizableLivePreviewAdapter({
+		return (await previewLifecycle.deliver({
 			kind: info.kind,
 			payload,
-			adapter: defineFinalizableLivePreviewAdapter({
-				draft: draftStream && !draftPreviewCommitted.value && !delivery.observedFinalReplyDelivery ? {
-					flush: draftStream.flush,
-					clear: () => draftStream.clear({ preserveHumanReplies: true }),
-					discardPending: draftStream.discardPending,
-					seal: draftStream.seal,
-					id: () => {
-						const channelId = draftStream.channelId();
-						const messageId = draftStream.messageId();
-						return channelId && messageId ? {
-							channelId,
-							messageId
-						} : void 0;
-					}
-				} : void 0,
+			isError: payload.isError === true,
+			adapter: {
 				buildFinalEdit: () => {
 					if (hasSlackCustomIdentity || !previewStreamingEnabled || reply.hasMedia && !ttsSupplement || payload.isError || requiresSeparateFallbackDelivery || !previewFinalTextFitsEdit || trimmedFinalText.length === 0 && !slackBlocks?.length) return;
 					return {
@@ -2350,11 +2287,6 @@ async function dispatchSlackMessageWithSetup(setup, beginSessionRun, turnAdoptio
 					};
 				},
 				editFinal: async (preview, edit) => {
-					if (delivery.hasDelivered({
-						kind: info.kind,
-						payload,
-						threadTs: edit.threadTs
-					})) return;
 					if (ttsSupplement) ttsPreviewFinalization = { threadTs: edit.threadTs };
 					if (!await draftStream?.finalizeMessage(preview.messageId, async () => {
 						await finalizeSlackPreviewEdit({
@@ -2368,59 +2300,66 @@ async function dispatchSlackMessageWithSetup(setup, beginSessionRun, turnAdoptio
 							threadTs: edit.threadTs
 						});
 					})) throw new Error("Slack preview moved below a newer conversation message");
-					if (!ttsSupplement) emitSlackMessageSentHooks({
-						...messageSentHookContext,
-						to: messageSentHookTarget,
-						accountId: account.accountId,
-						content: trimmedFinalText,
-						success: true,
-						messageId: preview.messageId
-					});
-					draftPreviewCommitted.value = true;
-					delivery.observedFinalReplyDelivery = true;
 				},
-				onPreviewFinalized: (_preview) => {
-					draftPreviewCommitted.value = true;
-					delivery.observedFinalReplyDelivery = true;
+				createPreviewReceipt: (preview, edit) => createMessageReceiptFromOutboundResults({
+					results: [{
+						channel: "slack",
+						channelId: preview.channelId,
+						messageId: preview.messageId
+					}],
+					threadId: edit.threadTs,
+					kind: "text"
+				}),
+				onPreviewFinalized: (preview) => {
 					const finalThreadTs = delivery.usedReplyThreadTs ?? statusThreadTs;
 					delivery.observedReplyDelivery = true;
 					replyPlan.markSent();
-					if (!ttsSupplement) delivery.markPreviewPayloadDelivered({
-						kind: info.kind,
-						payload,
-						threadTs: finalThreadTs
-					});
+					if (!ttsSupplement) {
+						delivery.markPreviewPayloadDelivered({
+							kind: info.kind,
+							payload,
+							threadTs: finalThreadTs
+						});
+						emitSlackMessageSentHooks({
+							...messageSentHookContext,
+							to: messageSentHookTarget,
+							accountId: account.accountId,
+							content: trimmedFinalText,
+							success: true,
+							messageId: preview.messageId
+						});
+					}
 				},
 				buildSupplementalPayload: () => ttsSupplement ? buildTtsSupplementMediaPayload(payload) : void 0,
 				deliverSupplemental: async (supplementalPayload) => {
 					const previewThreadTs = delivery.usedReplyThreadTs ?? statusThreadTs;
-					const supplementalThreadTs = await delivery.deliverNormally({
+					const supplementalResult = await delivery.deliverNormally({
 						payload: supplementalPayload,
 						kind: info.kind,
 						forcedThreadTs: previewThreadTs
 					});
-					delivery.markPreviewPayloadDelivered({
+					if (supplementalResult.visibleReplySent) delivery.markPreviewPayloadDelivered({
 						kind: info.kind,
 						payload,
-						threadTs: supplementalThreadTs
+						threadTs: supplementalResult.threadId
 					});
+					return supplementalResult;
 				},
 				logPreviewEditFailure: (err) => {
 					logVerbose(`slack: preview final edit failed; falling back to standard send (${formatSlackError(err)})`);
 				}
-			}),
-			deliverNormally: async () => {
-				await delivery.deliverNormally({
-					payload: shouldRestoreTtsSupplementTextForPreviewFallback || ttsPreviewFinalization && !payload.text?.trim() ? {
-						...payload,
+			},
+			deliverNormally: async (normalPayload) => {
+				return await delivery.deliverNormally({
+					payload: normalPayload === payload && (shouldRestoreTtsSupplementTextForPreviewFallback || ttsPreviewFinalization && !payload.text?.trim()) ? {
+						...normalPayload,
 						text: ttsSupplement?.spokenText
-					} : payload,
+					} : normalPayload,
 					kind: info.kind,
 					...ttsPreviewFinalization?.threadTs ? { forcedThreadTs: ttsPreviewFinalization.threadTs } : {}
 				});
 			}
-		});
-		if (info.kind === "final") progress.progressDraft.markFinalReplyDelivered();
+		})).deliveryResult ?? { visibleReplySent: false };
 	};
 	let agentRunFailed = false;
 	let settledDispatchResult;
@@ -2452,9 +2391,9 @@ async function dispatchSlackMessageWithSetup(setup, beginSessionRun, turnAdoptio
 				}
 			},
 			record: prepared.turn.record,
-			history: prepared.turn.history,
 			botLoopProtection: resolveSlackBotLoopProtection(prepared),
 			replyOptions: {
+				onVisibleWorkSessions: progress.onVisibleWorkSessions,
 				groupThreadReplyFormatter: formatSlackGroupThreadReply,
 				queuedDeliveryCorrelations: [{ begin: beginSessionRun }],
 				...turnAdoptionLifecycle ? { turnAdoptionLifecycle } : {},
@@ -2474,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;
@@ -2494,30 +2431,19 @@ async function dispatchSlackMessageWithSetup(setup, beginSessionRun, turnAdoptio
 				},
 				onToolStart: async (payload) => {
 					if (statusReactionsEnabled) await statusReactions.setTool(payload.name);
-					if (payload.phase === "start") progress.progressWorkCounter.noteToolCall(payload.name);
-					if (progress.preambleOnlyProgress) return isChannelProgressDraftWorkToolName(payload.name) ? await progress.progressDraft.noteActivity() : false;
 					return await progress.progressDraft.pushToolEvent(payload);
 				},
 				onItemEvent: async (payload) => {
-					if (payload.kind === "preamble" && (payload.phase === "start" || payload.phase === "update") && !draftStream?.messageId() && !delivery.streamSession?.delivered) return false;
-					if (progress.isProgressMode && payload.kind === "preamble") {
-						if (progress.shouldYieldDraftProgress()) return false;
-						const headlineVisible = await progress.progressDraft.pushPreambleHeadline(payload.progressText, { itemId: payload.itemId });
-						if (progress.commentaryProgressEnabled) return await progress.progressDraft.pushCommentaryProgress(payload.progressText, {
-							itemId: payload.itemId,
-							...progress.preambleOnlyProgress ? { complete: payload.phase !== "start" && payload.phase !== "update" } : {}
-						}) || headlineVisible;
-						return headlineVisible;
-					}
-					return progress.preambleOnlyProgress ? await progress.progressDraft.noteActivity() : await progress.progressDraft.pushItemEvent(payload);
+					if (payload.hideFromChannelProgress || payload.suppressChannelProgress) return progress.preambleOnlyProgress ? false : progress.progressDraft.pushItemEvent(payload);
+					if (payload.kind === "preamble" && progress.shouldYieldDraftProgress()) return false;
+					progress.progressWorkCounter.noteItem(payload);
+					return progress.preambleOnlyProgress && payload.kind !== "preamble" ? await progress.progressDraft.noteActivity() : await progress.progressDraft.pushItemEvent(payload);
 				},
 				onPlanUpdate: async (payload) => {
 					if (payload.phase !== "update") return false;
 					return await progress.pushPlanProgress(payload.steps, payload.explanation, payload.explanationFormat);
 				},
-				onApprovalEvent: (payload) => progress.progressDraft.pushApprovalEvent(payload),
-				onCommandOutput: async (payload) => progress.preambleOnlyProgress ? await progress.progressDraft.noteActivity() : await progress.progressDraft.pushCommandOutputEvent(payload),
-				onPatchSummary: async (payload) => progress.preambleOnlyProgress ? await progress.progressDraft.noteActivity() : await progress.progressDraft.pushPatchEvent(payload)
+				onApprovalEvent: (payload) => progress.progressDraft.pushApprovalEvent(payload)
 			}
 		});
 		if (turnResult.dispatched) {
@@ -2541,9 +2467,11 @@ async function dispatchSlackMessageWithSetup(setup, beginSessionRun, turnAdoptio
 	const completionChunks = progress.useNativeProgressStreaming && !progress.nativeProgressCompletionSent ? progress.buildNativeProgressCompletionChunks(dispatchError || agentRunFailed ? "error" : progress.nativeProgressTerminalStatus) : void 0;
 	if (completionChunks?.length) progress.nativeProgressCompletionSent = true;
 	await delivery.finishStream(completionChunks);
-	const anyReplyDelivered = hasVisibleInboundReplyDispatch(settledDispatchResult, { observedReplyDelivery: delivery.observedReplyDelivery });
-	if (!progress.isProgressMode && anyReplyDelivered && !delivery.observedFinalReplyDelivery && !dispatchError && !agentRunFailed) await draftStream?.clear({ preserveHumanReplies: true });
-	if (progress.isProgressMode && !progress.useNativeProgressStreaming && !progress.useDraftProgressCard && !compactFinalDeliveryStarted && !dispatchError && !agentRunFailed && anyReplyDelivered) await clearCompactProgress();
+	const anyReplyDelivered = hasVisibleInboundReplyDispatch(settledDispatchResult, { observedReplyDelivery: delivery.observedReplyDelivery || previewLifecycle.finalDelivered });
+	if (anyReplyDelivered && !previewLifecycle.finalStarted && !dispatchError && !agentRunFailed) {
+		if (hasVisibleInboundReplyDispatch(settledDispatchResult)) await previewLifecycle.observeDelivery({ visibleReplySent: true });
+	}
+	await previewLifecycle.cleanup({ failed: Boolean(dispatchError || agentRunFailed) });
 	if (pendingFailureNotice && anyReplyDelivered) recordSlackThreadFailureNotice(pendingFailureNotice);
 	if (dispatchError || agentRunFailed) await progress.finalizeDraftProgressCard("error");
 	await progress.dropDetachedProgressCards();
@@ -2562,14 +2490,13 @@ async function dispatchSlackMessageWithSetup(setup, beginSessionRun, turnAdoptio
 		teamId: prepared.eventScope?.teamId
 	});
 	if (dispatchError) throw toErrorObject(dispatchError, "Slack dispatch failed");
-	if (!anyReplyDelivered && !draftPreviewCommitted.value && !(agentRunFailed && progress.useDraftProgressCard)) {
-		await draftStream?.clear();
-		await draftStream?.dropDetachedMessages();
+	if (!anyReplyDelivered && !previewLifecycle.previewFinalized && !(agentRunFailed && progress.useDraftProgressCard)) {
+		if (progress.useDraftProgressCard) await draftStream?.clear();
 		return;
 	}
 	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
@@ -2629,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 = [];
@@ -2649,13 +2573,13 @@ 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;
 }
 function resolveSlackMessageText(message) {
-	const messageText = normalizeOptionalString(message.text) ?? resolveSlackAttachmentFallbackText(message.attachments);
+	const messageText = normalizeOptionalString(message.text) ?? resolveSlackAttachmentFallbackText(message.attachments) ?? (message.attachments?.some((attachment) => attachment.is_share === true && (normalizeOptionalString(attachment.image_url) || attachment.files?.length)) ? "[Slack media attachment]" : void 0);
 	return resolveSlackMessageText$1({
 		...message,
 		text: messageText
@@ -2670,11 +2594,12 @@ async function resolveSlackThreadStarter(params) {
 		params.threadTs
 	]);
 	const cached = THREAD_STARTER_CACHE.get(cacheKey);
-	if (cached) {
+	if (cached && !params.refresh) {
 		const now = asDateTimestampMs(Date.now());
 		if (now !== void 0 && cached.expiresAt > now) return cached.value;
 		THREAD_STARTER_CACHE.delete(cacheKey);
 	}
+	if (params.refresh) THREAD_STARTER_CACHE.delete(cacheKey);
 	try {
 		const message = (await params.client.conversations.replies({
 			channel: params.channelId,
@@ -2703,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;
 	}
 }
@@ -2725,25 +2650,36 @@ async function resolveSlackThreadHistory(params) {
 	try {
 		do {
 			pagesFetched += 1;
+			params.assertCurrent?.();
 			const response = await params.client.conversations.replies({
 				channel: params.channelId,
 				ts: params.threadTs,
 				limit: fetchLimit,
-				inclusive: true,
+				inclusive: false,
+				...params.currentMessageTs ? { latest: params.currentMessageTs } : {},
+				...params.oldest ? { oldest: params.oldest } : {},
 				...cursor ? { cursor } : {}
 			});
+			params.assertCurrent?.();
 			for (const msg of response.messages ?? []) {
+				const timestamp = resolveSlackTimestampMs(msg.ts);
 				const text = resolveSlackMessageText(msg);
 				if (!text && !msg.files?.length) continue;
-				if (params.currentMessageTs && msg.ts === params.currentMessageTs) continue;
+				if (!msg.ts || msg.ts === params.currentMessageTs || params.currentMessageTs && timestamp !== void 0 && Number(msg.ts) >= Number(params.currentMessageTs) || params.oldest && (timestamp === void 0 || Number(msg.ts) <= Number(params.oldest)) || params.excludedMessageIds?.has(msg.ts)) continue;
+				if (retained.some(([entry]) => entry.ts === msg.ts)) continue;
 				retained.push([msg, text]);
 			}
 			if (retained.length > maxMessages) retained.splice(0, retained.length - maxMessages);
 			const next = response.response_metadata?.next_cursor;
 			cursor = typeof next === "string" && next.trim().length > 0 ? next.trim() : void 0;
+			if (response.has_more && !cursor) {
+				params.onOmission?.("Slack returned an incomplete thread page without a cursor");
+				return [];
+			}
 		} 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 [];
 		}
 		return retained.map(([message, text]) => ({
@@ -2751,13 +2687,55 @@ async function resolveSlackThreadHistory(params) {
 			userId: message.user,
 			botId: message.bot_id,
 			ts: message.ts,
-			files: message.files
+			files: message.files,
+			attachments: message.attachments
 		}));
 	} catch (err) {
-		logVerbose$1(`slack thread history fetch failed channel=${params.channelId} ts=${params.threadTs}: ${formatErrorMessage(err)}`);
+		params.assertCurrent?.();
+		params.onOmission?.(formatErrorMessage(err));
+		logVerbose(`slack thread history fetch failed channel=${params.channelId} ts=${params.threadTs}: ${formatErrorMessage(err)}`);
 		return [];
 	}
 }
+/** Slack channel history is newest first, unlike chronological thread replies. */
+async function resolveSlackChannelHistory(params) {
+	if (!Number.isFinite(params.limit) || params.limit <= 0) return [];
+	const messages = [];
+	const seen = /* @__PURE__ */ new Set();
+	let cursor;
+	let scanned = 0;
+	const maxPages = Math.ceil(params.limit / 200);
+	for (let page = 0; page < maxPages; page += 1) {
+		params.assertCurrent?.();
+		const response = await params.client.conversations.history({
+			channel: params.channelId,
+			latest: params.currentMessageTs,
+			...params.oldest ? { oldest: params.oldest } : {},
+			inclusive: false,
+			limit: Math.min(200, params.limit - scanned),
+			...cursor ? { cursor } : {}
+		});
+		params.assertCurrent?.();
+		for (const message of response.messages ?? []) {
+			scanned += 1;
+			if (!message.ts || Number(message.ts) >= Number(params.currentMessageTs) || params.oldest && Number(message.ts) <= Number(params.oldest) || params.excludedMessageIds.has(message.ts) || seen.has(message.ts)) continue;
+			seen.add(message.ts);
+			const text = resolveSlackMessageText(message);
+			if (!text && !message.files?.length) continue;
+			messages.push({
+				text: text ?? formatSlackFilePlaceholder(message.files),
+				userId: message.user,
+				botId: message.bot_id,
+				ts: message.ts,
+				files: message.files,
+				attachments: message.attachments
+			});
+		}
+		cursor = response.response_metadata?.next_cursor?.trim() || void 0;
+		if (!cursor || scanned >= params.limit) break;
+	}
+	return messages.slice(0, params.limit).toReversed();
+}
 //#endregion
 //#region extensions/slack/src/monitor/message-handler/preflight-audio.ts
 function isSlackAudioFile(file) {
@@ -2798,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 })));
 }
@@ -2810,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-BvGUGk3w.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)`;
@@ -2829,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;
@@ -2851,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`);
@@ -2873,19 +2845,13 @@ async function resolveSlackMessageContent(params) {
 		readIdleTimeoutMs: params.mediaReadIdleTimeoutMs,
 		totalTimeoutMs: params.mediaTotalTimeoutMs,
 		abortSignal: params.abortSignal,
+		assertCurrent: params.assertCurrent,
 		preloadedMedia: params.preloadedMedia
 	})) : 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 = [];
-		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,
@@ -2914,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
 	});
@@ -2939,8 +2897,8 @@ 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;
-	return Math.max(0, override ?? params.defaultLimit);
+	const override = params.userId ? params.account.config.dms?.[params.userId]?.historyLimit : void 0;
+	return resolvePromptHistoryLimit(override ?? params.defaultLimit, 0);
 }
 async function resolveSlackDmHistoryContext(params) {
 	const maxMessages = Math.max(0, Math.floor(params.limit));
@@ -3016,56 +2974,177 @@ 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
+//#endregion
+//#region extensions/slack/src/monitor/message-handler/prepare-room-history.ts
+const SLACK_HISTORY_MEDIA_MAX_ATTACHMENTS = 4;
+const SLACK_HISTORY_MEDIA_MAX_BYTES = 10485760;
+const SLACK_HISTORY_MEDIA_IDLE_TIMEOUT_MS = 1e3;
+const SLACK_HISTORY_MEDIA_TOTAL_TIMEOUT_MS = 3e3;
+async function resolveSlackRoomHistory(params) {
+	if (params.ctx.historyLimit <= 0 || !params.message.ts) return [];
+	const warnOmission = (reason) => {
+		params.ctx.logger.warn({
+			accountId: params.ctx.accountId,
+			teamId: params.eventScope?.teamId ?? params.ctx.teamId,
+			channelId: params.message.channel,
+			threadTs: params.threadTs,
+			reason
+		}, "Slack automatic history omitted");
 	};
-}
-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;
+	try {
+		params.assertCurrent();
+		const request = {
+			channelId: params.message.channel,
+			client: params.eventScope?.client ?? params.ctx.app.client,
+			currentMessageTs: params.message.ts,
+			oldest: params.oldest,
+			excludedMessageIds: params.excludedMessageIds,
+			limit: Math.max(DEFAULT_GROUP_HISTORY_LIMIT, params.ctx.historyLimit),
+			assertCurrent: params.assertCurrent
+		};
+		const messages = params.threadTs ? await resolveSlackThreadHistory({
+			...request,
+			threadTs: params.threadTs,
+			onOmission: warnOmission
+		}) : await resolveSlackChannelHistory(request);
+		params.assertCurrent();
+		const permitted = [];
+		for (const message of messages) {
+			if (isSlackThreadAuthorCurrentBot({
+				identity: params.ctx,
+				author: message
+			})) continue;
+			const user = message.userId ? await params.ctx.resolveUserName(message.userId, params.eventScope) : void 0;
+			params.assertCurrent();
+			const senderAllowed = resolveSlackUserAllowed({
+				allowList: params.allowFromLower,
+				teamId: params.eventScope?.teamId ?? params.ctx.teamId,
+				userId: message.userId ?? message.botId,
+				userName: user?.name,
+				allowNameMatching: params.ctx.allowNameMatching
+			});
+			if (!shouldIncludeSupplementalContext({
+				mode: params.contextVisibilityMode,
+				kind: "history",
+				senderAllowed
+			})) continue;
+			permitted.push({
+				message,
+				sender: user?.name ?? message.userId ?? `Bot (${message.botId ?? "unknown"})`
+			});
 		}
-		if (params.policy.currentBot === "all" || params.policy.currentBot === "root-only" && entry.ts === params.policy.rootTs) kept.push(entry);
-		else omittedCurrentBot += 1;
+		const entries = [];
+		let mediaRemaining = SLACK_HISTORY_MEDIA_MAX_ATTACHMENTS;
+		for (const { message, sender } of permitted.slice(-params.ctx.historyLimit)) {
+			const { media, attempted } = mediaRemaining > 0 && (message.files?.length || message.attachments?.length) ? await resolveSlackHistoryMedia({
+				ctx: params.ctx,
+				eventScope: params.eventScope,
+				maxAttachments: mediaRemaining,
+				assertCurrent: params.assertCurrent,
+				abortSignal: params.abortSignal,
+				message: {
+					type: "message",
+					channel: params.message.channel,
+					ts: message.ts,
+					user: message.userId,
+					bot_id: message.botId,
+					text: message.text,
+					files: message.files,
+					attachments: message.attachments
+				}
+			}) : {
+				media: [],
+				attempted: 0
+			};
+			params.assertCurrent();
+			mediaRemaining -= attempted;
+			entries.push({
+				sender,
+				body: message.text,
+				timestamp: resolveSlackTimestampMs(message.ts),
+				messageId: message.ts,
+				...media.length > 0 ? { media } : {}
+			});
+		}
+		return entries;
+	} catch (error) {
+		warnOmission(formatErrorMessage(error));
+		return [];
 	}
-	return {
-		kept,
-		omittedCurrentBot
-	};
 }
-function shouldIncludeBotThreadStarterContext(params) {
-	if (!params.hasStarterText) return false;
-	return params.starterIsCurrentBot && params.isNewThreadSession;
+function isSlackImageFileCandidate(file) {
+	if ((file.mimetype?.split(";")[0]?.trim().toLowerCase())?.startsWith("image/")) return true;
+	return Boolean(mimeTypeFromFilePath(file.name)?.startsWith("image/"));
 }
-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 sliceSlackImageFileCandidates(files, limit) {
+	if (limit <= 0 || !files?.length) return [];
+	return files.filter(isSlackImageFileCandidate).slice(0, limit);
 }
-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 sliceSlackHistoryAttachmentCandidates(attachments, limit) {
+	if (limit <= 0 || !attachments?.length) return [];
+	const out = [];
+	let remaining = limit;
+	for (const attachment of attachments) {
+		if (attachment.is_share !== true) continue;
+		const hasImageUrl = Boolean(normalizeOptionalString(attachment.image_url));
+		const files = sliceSlackImageFileCandidates(attachment.files, remaining - (hasImageUrl ? 1 : 0));
+		if (!hasImageUrl && files.length === 0) continue;
+		out.push({
+			...attachment,
+			files
+		});
+		remaining -= (hasImageUrl ? 1 : 0) + files.length;
+		if (remaining <= 0) break;
+	}
+	return out;
 }
-function formatSlackThreadLabelSnippet(text) {
-	return truncateUtf16Safe(text.replace(/\s+/g, " "), 80);
+function buildSlackHistoryMediaCandidateMessage(message, maxAttachments) {
+	const files = sliceSlackImageFileCandidates(message.files, maxAttachments);
+	const attachments = sliceSlackHistoryAttachmentCandidates(message.attachments, Math.max(0, maxAttachments - files.length));
+	if (files.length === 0 && attachments.length === 0) return null;
+	return {
+		message: {
+			...message,
+			files,
+			attachments
+		},
+		attempted: files.length + attachments.reduce((count, attachment) => count + (normalizeOptionalString(attachment.image_url) ? 1 : 0) + (attachment.files?.length ?? 0), 0)
+	};
+}
+async function resolveSlackHistoryMedia(params) {
+	const candidate = buildSlackHistoryMediaCandidateMessage(params.message, params.maxAttachments);
+	if (!candidate) return {
+		media: [],
+		attempted: 0
+	};
+	const content = await resolveSlackMessageContent({
+		message: candidate.message,
+		isThreadReply: false,
+		threadStarter: null,
+		isBotMessage: Boolean(params.message.bot_id),
+		client: params.eventScope?.client ?? params.ctx.app.client,
+		botToken: params.ctx.botToken,
+		mediaMaxBytes: Math.min(params.ctx.mediaMaxBytes, SLACK_HISTORY_MEDIA_MAX_BYTES),
+		mediaReadIdleTimeoutMs: SLACK_HISTORY_MEDIA_IDLE_TIMEOUT_MS,
+		mediaTotalTimeoutMs: SLACK_HISTORY_MEDIA_TOTAL_TIMEOUT_MS,
+		assertCurrent: params.assertCurrent,
+		abortSignal: params.abortSignal
+	});
+	return {
+		media: await toInboundMediaFactsWithMetadata(content?.effectiveDirectMedia, {
+			kind: "image",
+			messageId: params.message.ts
+		}),
+		attempted: candidate.attempted
+	};
 }
 //#endregion
 //#region extensions/slack/src/monitor/message-handler/prepare-thread-context.ts
-const loadSlackMediaModule = createLazyRuntimeModule(() => import("./actions-BvGUGk3w.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,
@@ -3079,45 +3158,16 @@ function resolveSlackThreadSessionFreshness(params) {
 		})
 	});
 }
-function isSlackThreadContextSenderAllowed(params) {
-	return resolveInboundSupplementalSenderAllowed({
-		isGroup: true,
-		groupPolicy: params.allowFromLower.length === 0 ? "open" : "allowlist",
-		allowFrom: params.allowFromLower,
-		isSenderAllowed: (allowFrom) => {
-			if (params.botId) return true;
-			if (!params.userId) return false;
-			return resolveSlackAllowListMatch({
-				allowList: allowFrom,
-				id: params.userId,
-				name: params.userName,
-				allowNameMatching: params.allowNameMatching
-			}).allowed;
-		}
-	});
-}
 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 = {
@@ -3155,16 +3205,14 @@ 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;
-	const starterIsCurrentBot = Boolean(starter && isCurrentBotAuthor({
-		userId: starter.userId,
-		botId: starter.botId
-	}));
-	const starterAllowed = !starter || !starterIsCurrentBot && isSlackThreadContextSenderAllowed({
-		allowFromLower: params.allowFromLower,
+	params.assertHistoryCurrent?.();
+	const starterIsCurrentBot = Boolean(starter && isCurrentBotAuthor(starter));
+	const starterAllowed = !starter || !starterIsCurrentBot && resolveSlackUserAllowed({
+		allowList: params.allowFromLower,
+		teamId: params.eventScope?.teamId ?? params.ctx.teamId,
 		allowNameMatching: params.allowNameMatching,
-		userId: starter.userId,
-		userName: starterSenderName,
-		botId: starter.botId
+		userId: starter.userId ?? starter.botId,
+		userName: starterSenderName
 	});
 	const includeStarterContext = !starter || !starterIsCurrentBot && shouldIncludeSupplementalContext({
 		mode: params.contextVisibilityMode,
@@ -3177,12 +3225,16 @@ async function resolveSlackThreadContextData(params) {
 		threadLabel = `Slack thread ${params.roomLabel}${snippet ? `: ${snippet}` : ""}`;
 		if (shouldSeedInitialThreadContext && !params.effectiveDirectMedia && starter.files && starter.files.length > 0) {
 			const { resolveSlackAttachmentContent } = await loadSlackMediaModule();
+			params.assertHistoryCurrent?.();
 			const attachmentContent = await resolveSlackAttachmentContent({
 				files: starter.files,
 				client: params.eventScope?.client ?? params.ctx.app.client,
 				token: params.ctx.botToken,
-				maxBytes: params.ctx.mediaMaxBytes
+				maxBytes: params.ctx.mediaMaxBytes,
+				assertCurrent: params.assertHistoryCurrent,
+				abortSignal: params.abortSignal
 			});
+			params.assertHistoryCurrent?.();
 			threadStarterMedia = attachmentContent?.media.length ? attachmentContent.media : null;
 			if (attachmentContent) threadStarterBody = formatSlackUnavailableMedia({
 				body: threadStarterBody,
@@ -3196,58 +3248,64 @@ 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 = params.account.config?.thread?.initialHistoryLimit ?? 20;
+	const threadInitialHistoryLimit = Math.min(params.account.config?.thread?.initialHistoryLimit ?? 20, params.historyLimit ?? Number.POSITIVE_INFINITY);
 	if (threadInitialHistoryLimit > 0 && shouldLoadInitialThreadHistory) {
 		const currentBotRootTs = starter?.ts ?? params.threadTs;
+		let historyOmitted = false;
 		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
+			limit: threadInitialHistoryLimit,
+			excludedMessageIds: params.excludedMessageIds,
+			assertCurrent: params.assertHistoryCurrent,
+			onOmission: (reason) => {
+				historyOmitted = true;
+				params.ctx.logger.warn({
+					channelId: params.message.channel,
+					threadTs: params.threadTs,
+					teamId: params.eventScope?.teamId ?? params.ctx.teamId,
+					accountId: params.account.accountId,
+					reason
+				}, "Slack automatic thread history omitted");
+			}
 		});
+		if (historyOmitted) return {
+			threadStarterBody,
+			threadHistoryBody,
+			shouldSeedInitialThreadContext,
+			threadLabel,
+			threadStarterMedia
+		};
 		const enrichedStarter = starter && threadStarterBody && threadStarterBody !== starter.text ? {
 			...starter,
 			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,
 				eventScope: params.eventScope
 			}) : /* @__PURE__ */ new Map();
+			params.assertHistoryCurrent?.();
 			const { items: filteredThreadHistory, omitted: omittedHistoryCount } = params.contextVisibilityMode === "all" ? {
 				items: threadHistoryWithoutCurrentBot,
 				omitted: 0
@@ -3256,34 +3314,29 @@ 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 isSlackThreadContextSenderAllowed({
-						allowFromLower: params.allowFromLower,
+					return resolveSlackUserAllowed({
+						allowList: params.allowFromLower,
+						teamId: params.eventScope?.teamId ?? params.ctx.teamId,
 						allowNameMatching: params.allowNameMatching,
-						userId: historyMsg.userId,
-						userName: msgUser?.name,
-						botId: historyMsg.botId
+						userId: historyMsg.userId ?? historyMsg.botId,
+						userName: msgUser?.name
 					});
 				}
 			});
 			const userMap = await resolveSlackThreadUserMap({
 				ctx: params.ctx,
-				messages: filteredThreadHistory
+				messages: filteredThreadHistory,
+				eventScope: params.eventScope
 			});
+			params.assertHistoryCurrent?.();
 			if (omittedHistoryCount > 0 || omittedCurrentBotHistoryCount > 0) logVerbose(`slack: omitted ${omittedHistoryCount + omittedCurrentBotHistoryCount} thread message(s) from context (mode=${params.contextVisibilityMode})`);
 			const historyParts = [];
 			for (const historyMsg of filteredThreadHistory) {
 				const msgUser = historyMsg.userId ? userMap.get(historyMsg.userId) : null;
-				const isOtherBot = Boolean(historyMsg.botId) && historyMsg.botId !== params.ctx.botId;
-				const isCurrentBot = isCurrentBotAuthor({
-					userId: historyMsg.userId,
-					botId: historyMsg.botId
-				});
-				const role = isCurrentBot || isOtherBot || Boolean(historyMsg.botId) ? "assistant" : "user";
+				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}]`;
 				historyParts.push(formatInboundEnvelope({
@@ -3310,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 [];
@@ -3348,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,
@@ -3382,10 +3487,6 @@ const SLACK_ANY_MENTION_RE = /<@[^>]+>|<!subteam\^[^>]+>/;
 const SLACK_USER_MENTION_RE = /<@([^>|]+)(?:\|[^>]+)?>/g;
 const SLACK_SUBTEAM_MENTION_RE = /<!subteam\^([^>|]+)(?:\|[^>]+)?>/g;
 const SLACK_SUBTEAM_MENTION_MARKER = "<!subteam^";
-const SLACK_HISTORY_MEDIA_MAX_ATTACHMENTS = 4;
-const SLACK_HISTORY_MEDIA_MAX_BYTES = 10485760;
-const SLACK_HISTORY_MEDIA_IDLE_TIMEOUT_MS = 1e3;
-const SLACK_HISTORY_MEDIA_TOTAL_TIMEOUT_MS = 3e3;
 const SLACK_CHANNEL_ACCESS_DOCS_URL = "https://docs.openclaw.ai/channels/slack#access-control-and-routing";
 function resolveSlackGroupSessionSubject(params) {
 	const channelName = normalizeOptionalString(params.channelName);
@@ -3393,14 +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) {
-	if (!record || !(key in record)) return;
-	if (record[key] === null) return null;
-	return normalizeOptionalString(record[key]);
-}
 function mergeSlackAssistantThreadContext(primary, fallback) {
 	if (!primary) return fallback;
 	if (!fallback) return primary;
@@ -3420,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) {
@@ -3465,61 +3558,6 @@ function resolveCachedMentionRegexes(ctx, agentId, options) {
 	byAgent.set(key, built);
 	return built;
 }
-function isSlackImageFileCandidate(file) {
-	if ((file.mimetype?.split(";")[0]?.trim().toLowerCase())?.startsWith("image/")) return true;
-	return Boolean(mimeTypeFromFilePath(file.name)?.startsWith("image/"));
-}
-function sliceSlackImageFileCandidates(files, limit) {
-	if (limit <= 0 || !files?.length) return [];
-	return files.filter(isSlackImageFileCandidate).slice(0, limit);
-}
-function sliceSlackHistoryAttachmentCandidates(attachments, limit) {
-	if (limit <= 0 || !attachments?.length) return [];
-	const out = [];
-	let remaining = limit;
-	for (const attachment of attachments) {
-		if (attachment.is_share !== true) continue;
-		const hasImageUrl = Boolean(normalizeOptionalString(attachment.image_url));
-		const files = sliceSlackImageFileCandidates(attachment.files, remaining - (hasImageUrl ? 1 : 0));
-		if (!hasImageUrl && files.length === 0) continue;
-		out.push({
-			...attachment,
-			files
-		});
-		remaining -= (hasImageUrl ? 1 : 0) + files.length;
-		if (remaining <= 0) break;
-	}
-	return out;
-}
-function buildSlackHistoryMediaCandidateMessage(message) {
-	const files = sliceSlackImageFileCandidates(message.files, SLACK_HISTORY_MEDIA_MAX_ATTACHMENTS);
-	const attachments = sliceSlackHistoryAttachmentCandidates(message.attachments, Math.max(0, SLACK_HISTORY_MEDIA_MAX_ATTACHMENTS - files.length));
-	if (files.length === 0 && attachments.length === 0) return null;
-	return {
-		...message,
-		files,
-		attachments
-	};
-}
-async function resolveSlackHistoryMediaForPendingRecord(params) {
-	const mediaMessage = buildSlackHistoryMediaCandidateMessage(params.message);
-	if (!mediaMessage) return [];
-	const content = await resolveSlackMessageContent({
-		message: mediaMessage,
-		isThreadReply: params.isThreadReply,
-		threadStarter: params.threadStarter,
-		isBotMessage: params.isBotMessage,
-		client: params.eventScope?.client ?? params.ctx.app.client,
-		botToken: params.ctx.botToken,
-		mediaMaxBytes: Math.min(params.ctx.mediaMaxBytes, SLACK_HISTORY_MEDIA_MAX_BYTES),
-		mediaReadIdleTimeoutMs: SLACK_HISTORY_MEDIA_IDLE_TIMEOUT_MS,
-		mediaTotalTimeoutMs: SLACK_HISTORY_MEDIA_TOTAL_TIMEOUT_MS
-	});
-	return await toInboundMediaFactsWithMetadata(content?.effectiveDirectMedia, {
-		kind: "image",
-		messageId: params.message.ts
-	});
-}
 function collectUniqueSlackMentionIds(text, regex) {
 	const ids = [];
 	regex.lastIndex = 0;
@@ -3566,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);
 	}
@@ -3585,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,
@@ -3603,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");
@@ -3752,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({
@@ -3820,7 +3859,7 @@ async function prepareSlackMessage(params) {
 	let mentionRegexes = buildPolicyMentionRegexes(routing.route.agentId);
 	let wasMentioned = resolveWasMentioned(mentionRegexes);
 	const hasBoundSession = Boolean(routing.runtimeBoundSessionKey || routing.configuredBindingSessionKey);
-	let { route, runtimeBinding, replyToMode, threadContext, threadTs, isThreadReply, threadKeys, sessionKey, historyKey } = routing;
+	let { route, runtimeBinding, replyToMode, threadContext, threadTs, isThreadReply, threadKeys, sessionKey } = routing;
 	const { configuredBinding, configuredBindingSessionKey } = routing;
 	const isAssistantThreadMessage = Boolean(isDirectMessage && messageAssistantThreadContext);
 	const forcedAssistantReplyThreadTs = Boolean(assistantThreadContext?.threadTs && (isThreadReply || isAssistantThreadMessage || replyToMode !== "off")) ? assistantThreadContext?.threadTs : void 0;
@@ -3848,75 +3887,14 @@ 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
-		}));
-	}
-	const recordDroppedHistory = async (reason) => {
-		const pendingText = (message.text ?? "").trim();
-		const historyMediaCandidate = buildSlackHistoryMediaCandidateMessage(message);
-		const fallbackFile = message.files?.length ? `[Slack file: ${formatSlackFileReference(message.files[0])}]` : "";
-		const pendingBody = pendingText || fallbackFile || (!fallbackFile && historyMediaCandidate ? "[Slack media attachment]" : "");
-		const skippedThreadStarter = historyMediaCandidate && isThreadReply && threadTs ? await resolveSlackThreadStarter({
-			channelId: message.channel,
-			threadTs,
-			client: slackClient,
-			workspaceScope: threadStarterWorkspaceScope
-		}) : null;
-		const senderName = pendingBody ? await resolveSenderName() : void 0;
-		await recordDroppedChannelInboundHistory({
-			input: {
-				id: message.ts ?? `${message.channel}:${Date.now()}`,
-				timestamp: resolveSlackTimestampMs(message.ts),
-				rawText: pendingBody,
-				textForAgent: pendingBody,
-				raw: message
-			},
-			admission: {
-				kind: "drop",
-				reason,
-				recordHistory: true
-			},
-			preflight: {
-				message: pendingBody ? {
-					rawBody: pendingBody,
-					body: pendingBody,
-					bodyForAgent: pendingBody,
-					senderLabel: senderName,
-					envelopeFrom: senderName
-				} : void 0,
-				history: {
-					key: historyKey,
-					historyMap: ctx.channelHistories,
-					limit: ctx.historyLimit,
-					recordOnDrop: true,
-					mediaLimit: SLACK_HISTORY_MEDIA_MAX_ATTACHMENTS,
-					shouldRecord: opts.shouldRecordDroppedHistory
-				},
-				media: () => resolveSlackHistoryMediaForPendingRecord({
-					ctx,
-					message,
-					isThreadReply,
-					threadStarter: skippedThreadStarter,
-					isBotMessage,
-					eventScope: opts.eventScope
-				})
-			}
-		});
-	};
 	let threadStarterPromise;
 	const getThreadStarter = () => {
 		threadStarterPromise ??= isThreadReply && threadTs ? resolveSlackThreadStarter({
 			channelId: message.channel,
 			threadTs,
 			client: slackClient,
-			workspaceScope: threadStarterWorkspaceScope
+			workspaceScope: threadStarterWorkspaceScope,
+			refresh: isRoomish && ctx.historyLimit > 0
 		}) : Promise.resolve(null);
 		return threadStarterPromise;
 	};
@@ -3944,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",
@@ -3960,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,
@@ -3993,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",
@@ -4067,7 +4057,7 @@ async function prepareSlackMessage(params) {
 		})) groupThread = void 0;
 		mentionRegexes = buildPolicyMentionRegexes(routing.route.agentId);
 		wasMentioned = resolveWasMentioned(mentionRegexes);
-		({route, runtimeBinding, replyToMode, threadContext, threadTs, isThreadReply, threadKeys, sessionKey, historyKey} = routing);
+		({route, runtimeBinding, replyToMode, threadContext, threadTs, isThreadReply, threadKeys, sessionKey} = routing);
 		canDetectMention = Boolean(groupThread) || Boolean(ctx.botUserId) || mentionRegexes.length > 0;
 	}
 	if (preflightAudioTranscript && !wasMentioned) {
@@ -4106,20 +4096,10 @@ async function prepareSlackMessage(params) {
 	if (isBotMessage && allowBotsMode === "mentions") {
 		if (!(isDirectMessage || effectiveWasMentioned || shouldBypassMention)) return drop("bot-missing-mention");
 	}
-	if (isRoom && shouldRequireMention && !canDetectMention && !effectiveWasMentioned) {
-		await recordDroppedHistory("slack-mention-detection-unavailable");
-		return drop("mention-detection-unavailable");
-	}
+	if (isRoom && shouldRequireMention && !canDetectMention && !effectiveWasMentioned) return drop("mention-detection-unavailable");
 	const ignoreOtherMentions = channelConfig?.ignoreOtherMentions ?? false;
-	if (isRoom && ignoreOtherMentions && Boolean(ctx.botUserId) && hasAnyMention && !wasMentioned) {
-		await recordDroppedHistory("slack-other-mention");
-		return drop("other-mention");
-	}
-	if (isRoom && shouldRequireMention && mentionDecision.shouldSkip) {
-		await recordDroppedHistory("slack-no-mention");
-		return drop("missing-mention");
-	}
-	const chatType = resolveSlackChatType(conversation.resolvedChannelType);
+	if (isRoom && ignoreOtherMentions && Boolean(ctx.botUserId) && hasAnyMention && !wasMentioned) return drop("other-mention");
+	if (isRoom && shouldRequireMention && mentionDecision.shouldSkip) return drop("missing-mention");
 	const inboundEventKind = classifyChannelInboundEvent({
 		conversation: { kind: chatType },
 		unmentionedGroupPolicy: resolveUnmentionedGroupInboundPolicy({
@@ -4132,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({
@@ -4152,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,
@@ -4163,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,
@@ -4200,16 +4182,34 @@ async function prepareSlackMessage(params) {
 	const textWithId = `${bodyForAgent}\n[slack message id: ${message.ts} channel: ${message.channel}${threadInfo}]`;
 	const storePath = resolveStorePath(ctx.cfg.session?.store, { agentId: route.agentId });
 	const envelopeOptions = resolveEnvelopeFormatOptions(ctx.cfg);
+	const effectiveMessageThreadId = assistantThreadContext?.threadTs ?? agentViewThreadTs ?? threadContext.messageThreadId;
+	const boundMessageThreadId = directThreadRoutedToDmSession ? void 0 : effectiveMessageThreadId;
+	messageIngress = await resolveMessageIngress({
+		agentId: route.agentId,
+		sessionKey,
+		nativeChannelId: message.channel,
+		messageId: threadContext.messageTs,
+		inboundEventKind
+	}, boundMessageThreadId);
+	if (messageIngress.ingress.admission !== "dispatch") return drop("final-route-denied");
 	const sessionEntry = getSessionEntry({
 		storePath,
 		sessionKey
 	});
 	const previousTimestamp = sessionEntry?.updatedAt;
-	if (opts.source === "app_mention" && !ctx.botUserId && message.ts) {
-		const pendingHistory = ctx.channelHistories.get(historyKey);
-		if (pendingHistory) ctx.channelHistories.set(historyKey, pendingHistory.filter((entry) => entry.messageId !== message.ts));
-	}
-	const channelHistory = createChannelHistoryWindow({ historyMap: ctx.channelHistories });
+	const excludedMessageIds = new Set(opts.sourceMessageIds);
+	if (message.ts) excludedMessageIds.add(message.ts);
+	const isHistorySessionCurrent = () => {
+		const current = getSessionEntry({
+			storePath,
+			sessionKey
+		});
+		return current?.sessionId === sessionEntry?.sessionId && current?.lifecycleRevision === sessionEntry?.lifecycleRevision && current?.sessionStartedAt === sessionEntry?.sessionStartedAt && current?.updatedAt === 0 === (sessionEntry?.updatedAt === 0);
+	};
+	const assertHistoryCurrent = () => {
+		opts.abortSignal?.throwIfAborted();
+		if (opts.isRuntimePolicyCurrent?.() === false || !isHistorySessionCurrent()) throw new Error("Slack history policy or session changed during recovery");
+	};
 	const dmHistoryLimit = isDirectMessage ? resolveSlackDmHistoryLimit({
 		account,
 		userId: message.user,
@@ -4240,26 +4240,12 @@ async function prepareSlackMessage(params) {
 		inboundHistory: void 0
 	};
 	if (dmHistoryContext.body) combinedBody = `${dmHistoryContext.body}\n\n${combinedBody}`;
-	if (isRoomish && ctx.historyLimit > 0) combinedBody = channelHistory.buildPendingContext({
-		historyKey,
-		limit: ctx.historyLimit,
-		currentMessage: combinedBody,
-		formatEntry: (entry) => formatInboundEnvelope({
-			channel: "Slack",
-			from: roomLabel,
-			timestamp: entry.timestamp,
-			body: `${entry.body}${entry.messageId ? ` [id:${entry.messageId} channel:${message.channel}]` : ""}`,
-			chatType: "channel",
-			senderLabel: entry.sender,
-			envelope: envelopeOptions
-		})
-	});
 	const { channelMetadata, groupSystemPrompt } = resolveSlackRoomContextHints({
 		isRoomish,
 		channelInfo,
 		channelConfig
 	});
-	const { threadStarterBody, threadHistoryBody, shouldSeedInitialThreadContext, threadLabel, threadStarterMedia } = await resolveSlackThreadContextData({
+	const threadContextData = await resolveSlackThreadContextData({
 		ctx,
 		agentId: route.agentId,
 		account,
@@ -4277,25 +4263,64 @@ async function prepareSlackMessage(params) {
 		contextVisibilityMode,
 		envelopeOptions,
 		effectiveDirectMedia,
-		eventScope: opts.eventScope
+		eventScope: opts.eventScope,
+		historyLimit: isRoomish ? ctx.historyLimit : void 0,
+		excludedMessageIds,
+		assertHistoryCurrent,
+		abortSignal: opts.abortSignal
+	});
+	const { threadLabel, threadStarterMedia } = threadContextData;
+	let { threadStarterBody, threadHistoryBody, shouldSeedInitialThreadContext } = threadContextData;
+	const threadScopedHistory = isThreadReply && ctx.threadHistoryScope === "thread";
+	let roomHistory = [];
+	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;
-	const inboundMedia = await toInboundMediaFactsWithMetadata(effectiveMedia, { transcribed: (entry) => effectiveMedia === effectiveDirectMedia && entry === preflightAudioMedia });
-	const inboundHistory = isRoomish && ctx.historyLimit > 0 ? channelHistory.buildInboundHistory({
-		historyKey,
+	let inboundMedia = await toInboundMediaFactsWithMetadata(effectiveMedia, { transcribed: (entry) => effectiveMedia === effectiveDirectMedia && entry === preflightAudioMedia });
+	opts.abortSignal?.throwIfAborted();
+	if (opts.isRuntimePolicyCurrent?.() === false) return drop("final-route-denied");
+	if (isRoomish && ctx.historyLimit > 0 && !isHistorySessionCurrent()) {
+		roomHistory = [];
+		threadHistoryBody = void 0;
+		threadStarterBody = void 0;
+		shouldSeedInitialThreadContext = false;
+		if (effectiveMedia === threadStarterMedia) inboundMedia = [];
+		ctx.logger.warn({
+			channelId: message.channel,
+			sessionKey
+		}, "Slack automatic history omitted after session changed");
+	}
+	combinedBody = buildHistoryContextFromEntries({
+		entries: roomHistory,
+		currentMessage: combinedBody,
+		historyKind: "recent",
+		excludeLast: false,
+		formatEntry: (entry) => formatInboundEnvelope({
+			channel: "Slack",
+			from: roomLabel,
+			timestamp: entry.timestamp,
+			body: `${entry.body} [id:${entry.messageId} channel:${message.channel}]`,
+			chatType: "channel",
+			senderLabel: entry.sender,
+			envelope: envelopeOptions
+		})
+	});
+	const inboundHistory = isRoomish && ctx.historyLimit > 0 ? buildInboundHistoryFromEntries({
+		entries: roomHistory,
 		limit: ctx.historyLimit
 	}) : dmHistoryContext.inboundHistory;
 	const commandBody = textForCommandDetection.trim();
 	const supplementalThreadHistoryBody = directThreadRoutedToDmSession && !threadHistoryBody ? threadStarterBody : threadHistoryBody;
-	const effectiveMessageThreadId = assistantThreadContext?.threadTs ?? agentViewThreadTs ?? threadContext.messageThreadId;
-	const boundMessageThreadId = directThreadRoutedToDmSession ? void 0 : effectiveMessageThreadId;
-	messageIngress = await resolveMessageIngress({
-		agentId: route.agentId,
-		sessionKey,
-		messageId: threadContext.messageTs,
-		inboundEventKind
-	}, boundMessageThreadId);
-	if (messageIngress.ingress.admission !== "dispatch") return drop("final-route-denied");
 	const agentContextEntities = isAgentViewMessage ? normalizeSlackAppContextEntities(message.app_context) : [];
 	const ctxPayload = (ctx.buildContext ?? buildChannelInboundEventContext)({
 		channelIngress: messageIngress,
@@ -4328,9 +4353,7 @@ async function prepareSlackMessage(params) {
 			avatar: conversationAvatar
 		},
 		route: {
-			agentId: route.agentId,
-			dmScope: route.dmScope,
-			accountId: route.accountId,
+			...route,
 			routeSessionKey: route.sessionKey,
 			dispatchSessionKey: sessionKey,
 			parentSessionKey: threadKeys.parentSessionKey
@@ -4349,7 +4372,10 @@ async function prepareSlackMessage(params) {
 			commandBody,
 			inboundHistory
 		},
-		sessionTranscript: { historyLimit: isRoomish ? ctx.historyLimit : dmHistoryLimit },
+		sessionTranscript: {
+			historyLimit: isRoomish ? ctx.historyLimit : dmHistoryLimit,
+			historyKind: isRoomish ? "recent" : "pending"
+		},
 		access: {
 			mentions: {
 				canDetectMention: isRoomish,
@@ -4404,16 +4430,6 @@ async function prepareSlackMessage(params) {
 		}
 	});
 	ctxPayload.ReplyToMode = replyToMode;
-	if (isRoomish && !shouldRequireMention) channelHistory.record({
-		historyKey,
-		limit: ctx.historyLimit,
-		entry: {
-			sender: senderName,
-			body: rawBody,
-			timestamp: resolveSlackTimestampMs(message.ts),
-			messageId: message.ts
-		}
-	});
 	const pinnedMainDmOwner = isDirectMessage ? resolvePinnedMainDmOwnerFromAllowlist({
 		dmScope: cfg.session?.dmScope,
 		allowFrom: allowFromLower,
@@ -4467,13 +4483,7 @@ async function prepareSlackMessage(params) {
 						sessionKey
 					}, "failed updating session meta");
 				}
-			},
-			history: isRoomish && shouldRequireMention ? {
-				isGroup: true,
-				historyKey,
-				historyMap: ctx.channelHistories,
-				limit: ctx.historyLimit
-			} : void 0
+			}
 		},
 		replyToMode,
 		...forcedReplyThreadTs ? { forcedReplyThreadTs } : {},
@@ -4481,7 +4491,6 @@ async function prepareSlackMessage(params) {
 		requireMention: shouldRequireMention,
 		isDirectMessage,
 		isRoomish,
-		historyKey,
 		preview,
 		ackReactionMessageTs,
 		ackReactionValue,