@openclaw/slack 2026.9.5 → 2026.9.6

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

@@ -1,24 +1,24 @@
-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 { A as countSlackTextUtf8Bytes, C as buildSlackBlocksFallbackText, E as SLACK_EDIT_TEXT_MAX_BYTES, H as SLACK_SESSION_LINK_ACTION_ID, M as truncateSlackTextByUtf8Bytes, Pt as resolveSlackReplyToMode, Y as normalizeSlackOutboundText, c as qualifySlackRoutePeerId, j as truncateSlackText, k as SLACK_TEXT_LIMIT, ot as escapeSlackMrkdwn, v as hasSlackNativeDataBlock } from "./session-status-Cf7AvWOt.mjs";
 import { n as formatSlackTarget } from "./target-parsing-DEsPjngB.mjs";
-import { 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 { A as resolveSlackUserAllowed, E as normalizeSlackAllowOwnerEntry, T as normalizeAllowListLower, o as formatSlackError } from "./probe-DiYIMPJo.mjs";
+import { a as prepareSlackReply, l as resolveSlackReplyRenderPlan } from "./reply-blocks-Bm8kf6mK.mjs";
 import { n as resolveSlackReplyThreadTs } from "./thread-ts-CukseRVL.mjs";
 import { n as resolveSlackStreamingMode, t as resolveSlackNativeStreaming } from "./streaming-compat-B-e0mqM0.mjs";
-import { D as resolveSlackMessageText$1, E as resolveSlackBlocksText, O as buildSlackEditTextPayload, S as formatSlackFileReferenceList, T as isSlackUnfurlAttachment, a as editSlackRenderedMessage, d as reactSlackMessage, i as editSlackMessage, m as removeSlackReaction, n as deleteSlackMessage, v as logVerbose$1, w as hasSlackTableBlock, x as formatSlackFileReference } from "./actions-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 { D as resolveSlackMessageText$1, E as resolveSlackBlocksText, O as buildSlackEditTextPayload, S as formatSlackFileReferenceList, T as isSlackUnfurlAttachment, a as editSlackRenderedMessage, d as reactSlackMessage, i as editSlackMessage, m as removeSlackReaction, n as deleteSlackMessage, v as logVerbose$1, w as hasSlackTableBlock, x as formatSlackFileReference } from "./actions-DKCtBgCI.mjs";
+import { c as hasSlackThreadFailureNotice, d as recordSlackThreadFailureNotice, f as recordSlackThreadParticipation, l as hasSlackThreadParticipation, m as buildSlackNativeDataDeliveryPlan, o as clearSlackThreadFailureNotice, r as sendMessageSlack, u as hasSlackThreadParticipationWithPersistence } from "./send-Cp6omkOg.mjs";
+import { A as resolveChannelContextVisibilityMode, D as readSlackAssistantThreadContext, E as buildSlackAssistantThreadMetadata, F as stripSlackMentionsForCommandDetection, M as resolveStorePath, N as updateLastRoute, O as getSessionEntry, T as resolveSlackChatType, _ as SlackStreamNotDeliveredError, b as startSlackStream, d as resolveSlackRoutingContext, f as registerSlackSessionRun, g as resolveSlackEffectiveAllowFrom, h as resolveSlackCommandIngress, j as resolveChannelResetConfig, k as readSessionUpdatedAt, l as authorizeSlackDirectMessage, m as authorizeSlackBotRoomMessage, o as resolveSlackRoomContextHints, p as resolveSlackThreadTargets, r as trackSlackDraftMessage, u as resolveConversationLabel, v as appendSlackStream, w as normalizeSlackChannelType, x as stopSlackStream, y as markSlackStreamFallbackDelivered } from "./provider-C-jPaGt2.mjs";
+import { n as resolveSlackChannelConfig } from "./policy-BApW53pI.mjs";
+import { a as resolveSlackThreadTs, i as readSlackReplyBlocks, n as deliverReplies, o as sanitizeSlackMonitorReplyPayload, s as emitSlackMessageSentHooks, t as createSlackReplyDeliveryPlan } from "./replies-BBAJxUOQ.mjs";
 import { asOptionalRecord, normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { 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, formatChannelProgressDraftText, 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 { 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";
@@ -29,17 +29,17 @@ 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 { 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, implicitMentionKindWhen, 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 { 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+)?$/;
@@ -206,12 +206,12 @@ 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
@@ -232,8 +232,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 +243,7 @@ function createSlackDraftStream(params) {
 					...params.eventScope ? { client: params.eventScope.client } : {},
 					...blocks ? { blocks } : {}
 				});
-				lastVisibleUpdate = {
+				if (streamMessage === message) lastVisibleUpdate = {
 					text: trimmed,
 					...blocks ? { blocks } : {}
 				};
@@ -266,16 +268,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,68 +301,88 @@ 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: () => {
+			streamMessage = void 0;
+			lastVisibleUpdate = void 0;
+			lastSentKey = "";
+		},
+		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;
+					streamMessage = void 0;
+					lastVisibleUpdate = void 0;
+					lastSentKey = "";
+				}
+			}
+			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;
@@ -368,7 +396,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;
 		}
@@ -1174,7 +1202,7 @@ function createSlackNativeProgressTransport(params) {
 //#endregion
 //#region extensions/slack/src/monitor/message-handler/dispatch-progress.ts
 function createSlackProgressRuntime(runtimeParams) {
-	const { setup, delivery, resetPreviewDeliveryState } = runtimeParams;
+	const { setup, delivery } = runtimeParams;
 	const { account, cfg, ctx, hasSlackCustomIdentity, message, prepared, replyPlan, runtime, slackClient, slackIdentity, slackMessageMetadata, slackStreaming, shouldUseDraftStream, useStreaming, previewStreamingEnabled } = setup;
 	const draftStream = shouldUseDraftStream ? createSlackDraftStream({
 		target: prepared.replyTarget,
@@ -1347,21 +1375,21 @@ function createSlackProgressRuntime(runtimeParams) {
 	};
 	const appendNativeNarration = (payload, kind) => withNativeStreamOrder(() => appendNativeNarrationNow(payload, kind));
 	const appendNativeNarrationNow = async (payload, kind) => {
-		if (isRenderedAsProgressTitle(payload.text)) return false;
+		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();
@@ -1369,6 +1397,7 @@ function createSlackProgressRuntime(runtimeParams) {
 		nativeNarrationSourceText = "";
 	};
 	const progressDraft = createChannelProgressDraftCompositor({
+		preparedItems: true,
 		entry: account.config,
 		mode: slackStreaming.mode,
 		active: progressDraftActive,
@@ -1415,31 +1444,50 @@ 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();
@@ -1536,6 +1584,7 @@ function createSlackProgressRuntime(runtimeParams) {
 		if (useNativeProgressStreaming) await finishNativeProgressTurn(completionChunks);
 		else {
 			await progressCard.finalize("success", priorSnapshot, priorFallbackText);
+			await previewLifecycle.cleanup();
 			draftStream?.forceNewMessage();
 			await dropDetachedProgressCards();
 		}
@@ -1546,7 +1595,7 @@ function createSlackProgressRuntime(runtimeParams) {
 		nativeUpdatesStopped = false;
 		nativeUpdates.resetThrottleWindow();
 		progressCard.reset();
-		resetPreviewDeliveryState();
+		previewLifecycle.reset();
 		delivery.resetDeliveryTracker();
 		return true;
 	};
@@ -1561,26 +1610,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 +1637,7 @@ function createSlackProgressRuntime(runtimeParams) {
 	};
 	return {
 		draftStream,
+		previewLifecycle,
 		isProgressMode,
 		useDraftProgressCard,
 		useNativeProgressStreaming,
@@ -1701,6 +1751,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({
@@ -1752,7 +1803,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 +1824,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;
@@ -1888,8 +1944,7 @@ function createSlackStreamingDeliveryRuntime(setup) {
 		streamFailed: false,
 		usedReplyThreadTs: void 0,
 		usedBlockReplyThreadTs: void 0,
-		observedReplyDelivery: false,
-		observedFinalReplyDelivery: false
+		observedReplyDelivery: false
 	};
 	const emitStreamedDelivery = (content, result) => {
 		emitSlackMessageSentHooks({
@@ -1930,14 +1985,18 @@ 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({
+		const sent = await deliverReplies({
 			cfg: ctx.cfg,
 			replies: [prepareSlackReply({ text: fallbackText })],
 			target: prepared.replyTarget,
@@ -1954,6 +2013,7 @@ function createSlackStreamingDeliveryRuntime(setup) {
 			deferMessageSentHooks: true,
 			eventScope: prepared.eventScope
 		});
+		if (!sent?.receipt.platformMessageIds.length) return;
 		markSlackStreamFallbackDelivered(session);
 		if (!session.stopped) try {
 			await stopSlackStream({
@@ -1966,7 +2026,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 +2053,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,9 +2064,9 @@ 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({
+		const sent = await deliverReplies({
 			cfg: ctx.cfg,
 			replies: [preparedReply],
 			target: prepared.replyTarget,
@@ -2017,8 +2082,8 @@ function createSlackStreamingDeliveryRuntime(setup) {
 			...messageSentDeliveryHookContext,
 			eventScope: prepared.eventScope
 		});
+		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,7 +2093,12 @@ 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);
@@ -2037,27 +2107,23 @@ function createSlackStreamingDeliveryRuntime(setup) {
 		return !state.streamFailed && !reply.hasMedia && renderPlan.mode !== "split" && !renderPlan.textIsSlackPlainText && !plannedBlocks?.length && !readSlackReplyBlocks(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,9 +2134,10 @@ 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,
@@ -2107,18 +2174,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 +2197,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,12 +2208,16 @@ 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,
@@ -2194,17 +2263,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 +2276,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 +2297,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 +2304,49 @@ 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 };
+				if (!delivery.isStreamingEligible(payload)) return await delivery.deliverNormally({
+					payload,
+					kind: info.kind,
+					forcedThreadTs: delivery.streamSession?.threadTs ?? delivery.nativeProgressStreamThreadTs
+				});
+				return await progress.appendNativeNarration(payload, info.kind);
 			}
-			await delivery.deliverNormally({
+			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 +2360,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 +2376,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 +2389,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,7 +2480,6 @@ async function dispatchSlackMessageWithSetup(setup, beginSessionRun, turnAdoptio
 				}
 			},
 			record: prepared.turn.record,
-			history: prepared.turn.history,
 			botLoopProtection: resolveSlackBotLoopProtection(prepared),
 			replyOptions: {
 				groupThreadReplyFormatter: formatSlackGroupThreadReply,
@@ -2494,30 +2521,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 +2557,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,9 +2580,8 @@ 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()) {
@@ -2655,7 +2672,7 @@ function resolveSlackAttachmentFallbackText(attachments) {
 	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 +2687,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,
@@ -2725,25 +2743,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}`);
+			params.onOmission?.("Slack thread exceeds the three-page automatic history budget");
 			return [];
 		}
 		return retained.map(([message, text]) => ({
@@ -2751,13 +2780,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) {
+		params.assertCurrent?.();
+		params.onOmission?.(formatErrorMessage(err));
 		logVerbose$1(`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) {
@@ -2810,7 +2881,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-DKCtBgCI.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)`;
@@ -2873,6 +2944,7 @@ 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;
@@ -2940,7 +3012,7 @@ async function resolveSlackMessageContent(params) {
 //#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);
+	return resolvePromptHistoryLimit(override ?? params.defaultLimit, 0);
 }
 async function resolveSlackDmHistoryContext(params) {
 	const maxMessages = Math.max(0, Math.floor(params.limit));
@@ -3063,8 +3135,172 @@ function formatSlackThreadLabelSnippet(text) {
 	return truncateUtf16Safe(text.replace(/\s+/g, " "), 80);
 }
 //#endregion
+//#region extensions/slack/src/monitor/message-handler/prepare-room-history.ts
+const SLACK_HISTORY_MEDIA_MAX_ATTACHMENTS = 4;
+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");
+	};
+	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"})`
+			});
+		}
+		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 [];
+	}
+}
+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, 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-DKCtBgCI.mjs").then((n) => n._));
 const SLACK_THREAD_CONTEXT_USER_LOOKUP_CONCURRENCY = 4;
 function resolveSlackThreadSessionFreshness(params) {
 	return params.ctx.channelRuntime?.session?.resolveEntryResetFreshness?.({
@@ -3079,23 +3315,6 @@ 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();
@@ -3155,16 +3374,17 @@ async function resolveSlackThreadContextData(params) {
 	};
 	const starter = params.threadStarter;
 	const starterSenderName = params.allowNameMatching && params.allowFromLower.length > 0 && starter?.userId ? (await params.ctx.resolveUserName(starter.userId, params.eventScope))?.name : void 0;
+	params.assertHistoryCurrent?.();
 	const starterIsCurrentBot = Boolean(starter && isCurrentBotAuthor({
 		userId: starter.userId,
 		botId: starter.botId
 	}));
-	const starterAllowed = !starter || !starterIsCurrentBot && isSlackThreadContextSenderAllowed({
-		allowFromLower: params.allowFromLower,
+	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 +3397,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,
@@ -3210,16 +3434,36 @@ async function resolveSlackThreadContextData(params) {
 		});
 		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,
@@ -3248,6 +3492,7 @@ async function resolveSlackThreadContextData(params) {
 				messages: threadHistoryWithoutCurrentBot,
 				eventScope: params.eventScope
 			}) : /* @__PURE__ */ new Map();
+			params.assertHistoryCurrent?.();
 			const { items: filteredThreadHistory, omitted: omittedHistoryCount } = params.contextVisibilityMode === "all" ? {
 				items: threadHistoryWithoutCurrentBot,
 				omitted: 0
@@ -3261,29 +3506,30 @@ async function resolveSlackThreadContextData(params) {
 						botId: historyMsg.botId
 					})) 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 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({
@@ -3382,10 +3628,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);
@@ -3397,9 +3639,8 @@ 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]);
+	const value = record?.[key];
+	return value === null ? null : normalizeOptionalString(value);
 }
 function mergeSlackAssistantThreadContext(primary, fallback) {
 	if (!primary) return fallback;
@@ -3465,61 +3706,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;
@@ -3820,7 +4006,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;
@@ -3858,65 +4044,14 @@ async function prepareSlackMessage(params) {
 			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;
 	};
@@ -4067,7 +4202,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,19 +4241,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");
-	}
+	if (isRoom && ignoreOtherMentions && Boolean(ctx.botUserId) && hasAnyMention && !wasMentioned) return drop("other-mention");
+	if (isRoom && shouldRequireMention && mentionDecision.shouldSkip) return drop("missing-mention");
 	const chatType = resolveSlackChatType(conversation.resolvedChannelType);
 	const inboundEventKind = classifyChannelInboundEvent({
 		conversation: { kind: chatType },
@@ -4200,16 +4326,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 +4384,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 +4407,66 @@ 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)) {
+		if (sessionEntry?.updatedAt !== 0) roomHistory = await resolveSlackRoomHistory({
+			ctx,
+			message,
+			threadTs: threadScopedHistory ? threadTs : void 0,
+			oldest: sessionEntry?.sessionStartedAt ? (sessionEntry.sessionStartedAt / 1e3).toFixed(6) : void 0,
+			excludedMessageIds,
+			allowFromLower: threadContextAllowFromLower,
+			contextVisibilityMode,
+			eventScope: opts.eventScope,
+			assertCurrent: assertHistoryCurrent,
+			abortSignal: opts.abortSignal
+		});
+	}
 	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 +4499,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 +4518,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 +4576,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 +4629,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 +4637,6 @@ async function prepareSlackMessage(params) {
 		requireMention: shouldRequireMention,
 		isDirectMessage,
 		isRoomish,
-		historyKey,
 		preview,
 		ackReactionMessageTs,
 		ackReactionValue,