@openclaw/slack 2026.10.1 → 2026.10.5-beta.1

package/dist/.setup/{pipeline.runtime-CIepKmZt.mjs → pipeline.runtime-ByPbC6MN.mjs}

@@ -1,15 +1,15 @@
 import { n as __reExport, t as __exportAll } from "./rolldown-runtime-B4FMCO8f.mjs";
-import { f as resolveSlackReplyToMode } from "./accounts-CDgkV7Cm.mjs";
+import { f as resolveSlackReplyToMode } from "./accounts-BMg9YLIv.mjs";
 import { n as formatSlackTarget } from "./target-parsing-FFE26kOV.mjs";
-import { A as countSlackTextUtf8Bytes, C as buildSlackBlocksFallbackText, E as SLACK_EDIT_TEXT_MAX_BYTES, M as truncateSlackTextByUtf8Bytes, Y as normalizeSlackOutboundText, c as qualifySlackRoutePeerId, j as truncateSlackText, k as SLACK_TEXT_LIMIT, ot as escapeSlackMrkdwn, v as hasSlackNativeDataBlock, w as buildSlackCompleteBlocksFallbackText, z as SLACK_SESSION_LINK_ACTION_ID } from "./session-status-D46GHwOV.mjs";
-import { D as normalizeSlackAllowOwnerEntry, j as resolveSlackUserAllowed, o as formatSlackError, v as readLruMapEntry, y as writeLruMapEntry } from "./probe-BVlJ3dp0.mjs";
-import { a as prepareSlackReply, l as resolveSlackReplyRenderPlan, s as resolveSlackReplyBlocks } from "./reply-blocks-CKnO4BSG.mjs";
+import { A as SLACK_TEXT_LIMIT, B as SLACK_SESSION_LINK_ACTION_ID, D as SLACK_EDIT_TEXT_MAX_BYTES, M as truncateSlackText, N as truncateSlackTextByUtf8Bytes, T as buildSlackCompleteBlocksFallbackText, X as normalizeSlackOutboundText, at as escapeSlackMrkdwn, c as qualifySlackRoutePeerId, j as countSlackTextUtf8Bytes, v as hasSlackNativeDataBlock, w as buildSlackBlocksFallbackText } from "./session-status-CcXe10zN.mjs";
+import { M as resolveSlackUserAllowed, O as normalizeSlackAllowOwnerEntry, b as writeLruMapEntry, o as formatSlackError, v as pruneExpiredMapEntries, y as readLruMapEntry } from "./probe-CyX52GtD.mjs";
+import { a as prepareSlackReply, l as resolveSlackReplyRenderPlan, s as resolveSlackReplyBlocks } from "./reply-blocks-rqHQ_3pr.mjs";
 import { n as resolveSlackReplyThreadTs } from "./thread-ts-Cvt7WD6B.mjs";
-import { C as hasSlackTableBlock, D as buildSlackEditTextPayload, E as resolveSlackMessageText$1, T as resolveSlackBlocksText, a as editSlackRenderedMessage, b as formatSlackFileReference, d as reactSlackMessage, i as editSlackMessage, m as removeSlackReaction, n as deleteSlackMessage, w as isSlackUnfurlAttachment, x as formatSlackFileReferenceList } from "./actions-DDoAJnrH.mjs";
-import { c as hasSlackThreadParticipationWithPersistence, i as clearSlackThreadFailureNotice, l as recordSlackThreadFailureNotice, m as buildSlackNativeDataDeliveryPlan, o as hasSlackThreadFailureNotice, p as hasSlackMessageIdentity, s as hasSlackThreadParticipation, t as sendMessageSlack, u as recordSlackThreadParticipation } from "./send-CgPI3Zj8.mjs";
-import { n as resolveSlackChannelConfig } from "./policy-KKTqEiDv.mjs";
-import { C as resolveSlackChatType, E as stripSlackMentionsForCommandDetection, S as normalizeSlackChannelType, T as readSlackAssistantThreadContext, _ as appendSlackStream, b as stopSlackStream, c as resolveSlackRoutingContext, g as SlackStreamNotDeliveredError, h as resolveSlackEffectiveAllowFrom, i as resolveSlackRoomContextHints, l as registerSlackSessionRun, m as resolveSlackCommandIngress, p as authorizeSlackBotRoomMessage, r as trackSlackDraftMessage, s as authorizeSlackDirectMessage, u as resolveSlackThreadContext, v as markSlackStreamFallbackDelivered, w as buildSlackAssistantThreadMetadata, y as startSlackStream } from "./monitor-BuYBDmm7.mjs";
-import { a as emitSlackMessageSentHooks, i as sanitizeSlackMonitorReplyPayload, n as deliverReplies, t as createSlackReplyDeliveryPlan } from "./replies-DHbuthIR.mjs";
+import { C as hasSlackTableBlock, D as buildSlackEditTextPayload, E as resolveSlackMessageText$1, T as resolveSlackBlocksText, a as editSlackRenderedMessage, b as formatSlackFileReference, d as reactSlackMessage, i as editSlackMessage, m as removeSlackReaction, n as deleteSlackMessage, w as isSlackUnfurlAttachment, x as formatSlackFileReferenceList } from "./actions-KGKwTAKO.mjs";
+import { c as hasSlackThreadParticipationWithPersistence, i as clearSlackThreadFailureNotice, l as recordSlackThreadFailureNotice, m as buildSlackNativeDataDeliveryPlan, o as hasSlackThreadFailureNotice, p as hasSlackMessageIdentity, s as hasSlackThreadParticipation, t as sendMessageSlack, u as recordSlackThreadParticipation } from "./send-CLmsR42r.mjs";
+import { n as resolveSlackChannelConfig } from "./policy-BaY9_eh1.mjs";
+import { C as resolveSlackChatType, E as stripSlackMentionsForCommandDetection, S as normalizeSlackChannelType, T as readSlackAssistantThreadContext, _ as appendSlackStream, b as stopSlackStream, c as resolveSlackRoutingContext, g as SlackStreamNotDeliveredError, h as resolveSlackEffectiveAllowFrom, i as resolveSlackRoomContextHints, l as registerSlackSessionRun, m as resolveSlackCommandIngress, p as authorizeSlackBotRoomMessage, r as trackSlackDraftMessage, s as authorizeSlackDirectMessage, u as resolveSlackThreadContext, v as markSlackStreamFallbackDelivered, w as buildSlackAssistantThreadMetadata, y as startSlackStream } from "./monitor-BnN2px0N.mjs";
+import { a as emitSlackMessageSentHooks, i as sanitizeSlackMonitorReplyPayload, n as deliverReplies, t as createSlackReplyDeliveryPlan } from "./replies-WmfwvQxc.mjs";
 import { asOptionalRecord, normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeOptionalString, readNonBlankString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { resolveInboundLastRouteSessionKey } from "openclaw/plugin-sdk/routing";
 import { buildChannelProgressDraftLine, compactChannelProgressDraftLine, createChannelMessageReplyPipeline, createChannelProgressDraftCompositor, createChannelProgressWorkCounter, createDraftStreamLoop, createFinalizableDraftLifecycle, createLivePreviewLifecycle, createMessageReceiptFromOutboundResults, resolveAgentOutboundIdentity, resolveChannelMessageSourceReplyDeliveryMode, resolveChannelProgressDraftConfig, resolveChannelProgressDraftMaxLineChars, resolveChannelStreamingBlockEnabled, resolveChannelStreamingPreviewToolProgress, resolveChannelStreamingSuppressDefaultToolProgressMessages, selectPlanChecklistSteps } from "openclaw/plugin-sdk/channel-outbound";
@@ -31,7 +31,7 @@ import { formatErrorMessage, toErrorObject } from "openclaw/plugin-sdk/error-run
 import { filterSupplementalContextItems, resolvePinnedMainDmOwnerFromAllowlist, shouldIncludeSupplementalContext } from "openclaw/plugin-sdk/security-runtime";
 import { mimeTypeFromFilePath, normalizeMimeType } from "openclaw/plugin-sdk/media-mime";
 import { mergePairLoopGuardConfig } from "openclaw/plugin-sdk/pair-loop-guard-runtime";
-import { getSessionEntry, readSessionUpdatedAt, resolveChannelResetConfig, resolveStorePath, updateLastRoute } from "openclaw/plugin-sdk/session-store-runtime";
+import { getSessionEntry, readSessionUpdatedAtAsync, resolveChannelResetConfig, resolveStorePath, updateLastRoute } from "openclaw/plugin-sdk/session-store-runtime";
 import { resolveHumanDelayConfig } from "openclaw/plugin-sdk/agent-runtime";
 import { enqueueRoutedSystemEvent } from "openclaw/plugin-sdk/system-event-runtime";
 import { getGlobalHookRunner } from "openclaw/plugin-sdk/plugin-runtime";
@@ -120,17 +120,6 @@ function buildSlackEventDeliveryKey(params, preparedReply = prepareSlackReply(pa
 		blocks: slackBlocks ?? null
 	});
 }
-function createSlackEventDeliveryTracker() {
-	const deliveredKeys = /* @__PURE__ */ new Set();
-	return {
-		hasDelivered(key) {
-			return key ? deliveredKeys.has(key) : false;
-		},
-		markDelivered(key) {
-			if (key) deliveredKeys.add(key);
-		}
-	};
-}
 async function resolveSlackStreamRecipientTeamId(params) {
 	const cacheKey = params.fallbackTeamId && params.userId ? `${params.fallbackTeamId}:${params.userId}` : void 0;
 	const cache = cacheKey ? getSlackStreamRecipientTeamCache(params.client) : void 0;
@@ -176,6 +165,13 @@ function createSlackDraftStream(params) {
 		lastVisibleUpdate = void 0;
 		lastSentKey = "";
 	};
+	const editPreview = (message, text, blocks) => edit(message.channelId, message.messageId, text, {
+		cfg: params.cfg,
+		token: params.token,
+		accountId: params.accountId,
+		...params.eventScope ? { client: params.eventScope.client } : {},
+		...blocks ? { blocks } : {}
+	});
 	const sendOrEditStreamMessage = async (pending) => {
 		const update = normalizeUpdate(pending);
 		const trimmed = update.text.trimEnd();
@@ -194,13 +190,7 @@ function createSlackDraftStream(params) {
 		try {
 			if (streamMessage) {
 				const message = streamMessage;
-				await edit(streamMessage.channelId, streamMessage.messageId, trimmed, {
-					cfg: params.cfg,
-					token: params.token,
-					accountId: params.accountId,
-					...params.eventScope ? { client: params.eventScope.client } : {},
-					...blocks ? { blocks } : {}
-				});
+				await editPreview(message, trimmed, blocks);
 				if (streamMessage === message) lastVisibleUpdate = {
 					text: trimmed,
 					...blocks ? { blocks } : {}
@@ -345,13 +335,7 @@ function createSlackDraftStream(params) {
 			return true;
 		}
 		try {
-			await edit(channelId, messageId, previousUpdate.text, {
-				cfg: params.cfg,
-				token: params.token,
-				accountId: params.accountId,
-				...params.eventScope ? { client: params.eventScope.client } : {},
-				...previousUpdate.blocks ? { blocks: previousUpdate.blocks } : {}
-			});
+			await editPreview(currentMessage, previousUpdate.text, previousUpdate.blocks);
 		} catch (err) {
 			params.warn?.(`slack stream preview restore failed: ${formatSlackError(err)}`);
 		}
@@ -477,11 +461,8 @@ function compactDetail(value, maxChars) {
 	const keepEnd = Math.max(1, maxChars - keepStart - 1);
 	return `${chars.slice(0, keepStart).join("").trimEnd()}…${chars.slice(-keepEnd).join("").trimStart()}`;
 }
-function compactTitle(value) {
-	return truncateSlackText(value.replace(/\s+/g, " ").trim(), SLACK_PROGRESS_TASK_TITLE_MAX);
-}
-function compactChunkText(value) {
-	return truncateSlackText(value.replace(/\s+/g, " ").trim(), SLACK_PROGRESS_CHUNK_TEXT_MAX);
+function compactTitle(value, maxChars = SLACK_PROGRESS_TASK_TITLE_MAX) {
+	return truncateSlackText(value.replace(/\s+/g, " ").trim(), maxChars);
 }
 function renderProgressCardText(text, enclosingStyle) {
 	return normalizeSlackOutboundText(text, {
@@ -587,7 +568,7 @@ function buildSlackProgressStreamChunks(params) {
 	const headline = params.title?.trim() || params.label?.trim();
 	const summaryTitle = params.finalInProgressStatus === "error" ? "Failed" : params.finalInProgressStatus === "complete" || !params.summaryRow ? "Completed" : "Working";
 	const newest = tasks.at(-1);
-	const title = compactChunkText(headline || (newest?.details ? `${newest.title} — ${newest.details}` : newest?.title) || (params.summaryRow ? summaryTitle : attention.at(-1)?.title) || SLACK_PROGRESS_PLAN_FALLBACK_TITLE);
+	const title = compactTitle(headline || (newest?.details ? `${newest.title} — ${newest.details}` : newest?.title) || (params.summaryRow ? summaryTitle : attention.at(-1)?.title) || SLACK_PROGRESS_PLAN_FALLBACK_TITLE, SLACK_PROGRESS_CHUNK_TEXT_MAX);
 	const diffOutput = formatTaskDiffOutput(params.diffStat);
 	if (tasks.length === 0 && (params.summaryRow || params.sessionLinks?.length || diffOutput)) tasks.push({
 		id: "openclaw_summary",
@@ -604,14 +585,9 @@ function buildSlackProgressStreamChunks(params) {
 	const finalTaskIndex = tasks.length - 1;
 	const taskChunks = tasks.map((task, index) => {
 		const recovered = params.finalInProgressStatus === "complete" && task.status === "error";
-		const chunk = {
-			type: "task_update",
-			id: task.id,
-			title: recovered ? compactTitle(`Recovered: ${task.title}`) : task.title,
-			status: recovered ? "complete" : task.status === "in_progress" ? params.finalInProgressStatus ?? task.status : task.status
-		};
-		if (task.details) chunk.details = task.details;
-		if (task.output) chunk.output = task.output;
+		const chunk = Object.assign({ type: "task_update" }, task);
+		chunk.title = recovered ? compactTitle(`Recovered: ${task.title}`) : task.title;
+		chunk.status = recovered ? "complete" : task.status === "in_progress" ? params.finalInProgressStatus ?? task.status : task.status;
 		if (index === finalTaskIndex && diffOutput) chunk.output = [task.output, diffOutput].filter(Boolean).join(" · ");
 		if (index === finalTaskIndex && params.sessionLinks?.length) chunk.sources = buildSessionSources(params.sessionLinks);
 		return chunk;
@@ -761,26 +737,29 @@ function reconcileSlackNativeTaskChunks(params) {
 			continue;
 		}
 		const previousRow = params.previous.tasks.get(chunk.id);
-		const details = resolveTaskFieldDelta(previousRow?.details, chunk.details);
-		const output = resolveTaskFieldDelta(previousRow?.output, chunk.output);
-		const sourcesChanged = Boolean(chunk.sources) && !previousRow?.sourcesSent;
 		const row = {
 			title: chunk.title,
 			status: chunk.status
 		};
-		if (details.field) row.details = details.field;
-		if (output.field) row.output = output.field;
-		if (sourcesChanged || previousRow?.sourcesSent) row.sourcesSent = true;
-		nextTasks.set(chunk.id, row);
-		if (!(!previousRow || previousRow.title !== chunk.title || previousRow.status !== chunk.status || Boolean(details.delta) || Boolean(output.delta) || sourcesChanged)) continue;
 		const update = {
 			type: "task_update",
 			id: chunk.id,
 			title: chunk.title,
 			status: chunk.status
 		};
-		if (details.delta) update.details = details.delta;
-		if (output.delta) update.output = output.delta;
+		let fieldsChanged = false;
+		for (const key of ["details", "output"]) {
+			const { field: nextField, delta } = resolveTaskFieldDelta(previousRow?.[key], chunk[key]);
+			if (nextField) row[key] = nextField;
+			if (delta) {
+				update[key] = delta;
+				fieldsChanged = true;
+			}
+		}
+		const sourcesChanged = Boolean(chunk.sources) && !previousRow?.sourcesSent;
+		if (sourcesChanged || previousRow?.sourcesSent) row.sourcesSent = true;
+		nextTasks.set(chunk.id, row);
+		if (!(!previousRow || previousRow.title !== chunk.title || previousRow.status !== chunk.status || fieldsChanged || sourcesChanged)) continue;
 		if (sourcesChanged) update.sources = chunk.sources;
 		emitted.push(update);
 	}
@@ -845,6 +824,15 @@ function resolveNativeProgressNarration(snapshot) {
 function combineProgressHeadlineAndExplanation(headline, explanation) {
 	return headline && explanation && headline !== explanation ? `${headline} — ${explanation}` : headline ?? explanation;
 }
+function normalizeProgressText(text) {
+	return text?.replace(/\s+/gu, " ").trim() ?? "";
+}
+function isSlackProgressTitleText(text, snapshot, explicitTitle) {
+	const candidate = normalizeProgressText(text);
+	if (!candidate) return false;
+	const title = normalizeProgressText(combineProgressHeadlineAndExplanation(explicitTitle ?? (snapshot.statusHeadlineFormat === "plain" ? void 0 : snapshot.statusHeadline), snapshot.planExplanationFormat === "plain" ? void 0 : snapshot.planExplanation));
+	return title.length > 0 && title.includes(candidate);
+}
 //#endregion
 //#region extensions/slack/src/monitor/message-handler/preview-finalize.ts
 function buildExpectedSlackEditText(params) {
@@ -853,22 +841,6 @@ function buildExpectedSlackEditText(params) {
 	if (params.blocks?.length) return normalizeSlackOutboundText(buildSlackBlocksFallbackText(params.blocks));
 	return " ";
 }
-function buildAcceptedSlackEditTexts(params) {
-	const expected = buildExpectedSlackEditText(params);
-	const texts = /* @__PURE__ */ new Set([
-		expected,
-		normalizeSlackOutboundText(truncateSlackTextByUtf8Bytes(expected, SLACK_EDIT_TEXT_MAX_BYTES)),
-		normalizeSlackOutboundText(buildSlackEditTextPayload(params.text, params.blocks))
-	]);
-	if (params.blocks?.length && hasSlackNativeDataBlock(params.blocks)) {
-		const fallbackPlan = buildSlackNativeDataDeliveryPlan({
-			baseText: params.text,
-			blocks: params.blocks
-		});
-		for (const message of fallbackPlan.fallbackMessages) texts.add(normalizeSlackOutboundText(message.text));
-	}
-	return texts;
-}
 function blocksMatch(expected, actual) {
 	if (!expected?.length) return !actual?.length;
 	if (!actual?.length) {
@@ -911,10 +883,18 @@ async function didSlackPreviewEditApplyAfterError(params) {
 		text: params.text,
 		blocks: params.blocks
 	});
-	const acceptedTexts = buildAcceptedSlackEditTexts({
-		text: params.text,
-		blocks: params.blocks
-	});
+	const acceptedTexts = /* @__PURE__ */ new Set([
+		expectedText,
+		normalizeSlackOutboundText(truncateSlackTextByUtf8Bytes(expectedText, SLACK_EDIT_TEXT_MAX_BYTES)),
+		normalizeSlackOutboundText(buildSlackEditTextPayload(params.text, params.blocks))
+	]);
+	if (params.blocks?.length && hasSlackNativeDataBlock(params.blocks)) {
+		const fallbackPlan = buildSlackNativeDataDeliveryPlan({
+			baseText: params.text,
+			blocks: params.blocks
+		});
+		for (const message of fallbackPlan.fallbackMessages) acceptedTexts.add(normalizeSlackOutboundText(message.text));
+	}
 	const actualText = normalizeSlackOutboundText((readback.text ?? "").trim());
 	if (params.blocks?.length) return acceptedTexts.has(actualText) && blocksMatch(params.blocks, readback.blocks);
 	return actualText === expectedText;
@@ -943,7 +923,8 @@ async function finalizeSlackPreviewEdit(params) {
 //#region extensions/slack/src/monitor/message-handler/dispatch-progress-card.ts
 const MAX_VISIBLE_WORK_LINKS = 5;
 function createSlackDraftProgressCardRuntime(params) {
-	const { account, cfg, ctx, prepared, slackClient } = params.setup;
+	const { cfg, prepared, slackClient } = params.setup;
+	const { account, ctx } = prepared;
 	let finalStatus;
 	const visibleWorkSessions = /* @__PURE__ */ new Map();
 	const resolveSessionLinks = () => {
@@ -1088,8 +1069,8 @@ function createSlackNativeProgressTransport(params) {
 		}
 		return !delivery.streamFailed;
 	};
-	const start = async (update) => {
-		const streamThreadTs = replyPlan.nextThreadTs();
+	const start = async (update, retainedThreadTs) => {
+		const streamThreadTs = retainedThreadTs ?? replyPlan.nextThreadTs();
 		if (!streamThreadTs) {
 			logVerbose("slack-stream: no reply thread target for native progress stream start, falling back");
 			delivery.streamFailed = true;
@@ -1112,6 +1093,7 @@ function createSlackNativeProgressTransport(params) {
 		}
 	};
 	const append = async (update) => {
+		if (await delivery.rotateInterruptedStream()) return "rotated";
 		const session = delivery.streamSession;
 		if (!session) return false;
 		await appendSlackStream({
@@ -1132,7 +1114,8 @@ function createSlackNativeProgressTransport(params) {
 //#region extensions/slack/src/monitor/message-handler/dispatch-progress.ts
 function createSlackProgressRuntime(runtimeParams) {
 	const { setup, delivery } = runtimeParams;
-	const { account, cfg, ctx, hasSlackCustomIdentity, message, prepared, replyPlan, runtime, slackClient, slackIdentity, slackMessageMetadata, slackStreaming, slackProgressStyle, quietProgress, shouldUseDraftStream, useStreaming, previewStreamingEnabled } = setup;
+	const { cfg, hasSlackCustomIdentity, prepared, replyPlan, runtime, slackIdentity, slackStreaming, slackProgressStyle, quietProgress, shouldUseDraftStream, useStreaming, previewStreamingEnabled } = setup;
+	const { account, ctx, message, slackMessageMetadata } = prepared;
 	const draftStream = shouldUseDraftStream ? createSlackDraftStream({
 		target: prepared.replyTarget,
 		cfg,
@@ -1155,7 +1138,6 @@ function createSlackProgressRuntime(runtimeParams) {
 	const useNativeProgressStreaming = useStreaming && slackStreaming.mode === "progress";
 	const progressDraftActive = Boolean(draftStream) || useNativeProgressStreaming;
 	const previewToolProgressEnabled = progressDraftActive && resolveChannelStreamingPreviewToolProgress(account.config, slackStreaming.mode !== "progress", slackStreaming.mode);
-	let shouldYieldDraftProgress = () => false;
 	const suppressDefaultToolProgressMessages = quietProgress || resolveChannelStreamingSuppressDefaultToolProgressMessages(account.config, {
 		draftStreamActive: Boolean(draftStream) || useNativeProgressStreaming,
 		mode: slackStreaming.mode,
@@ -1163,13 +1145,18 @@ function createSlackProgressRuntime(runtimeParams) {
 		previewStreamingEnabled
 	});
 	let nativeStreamSnapshot = EMPTY_SLACK_NATIVE_STREAM_SNAPSHOT;
-	let appendRenderedText = "";
-	let appendSourceText = "";
+	let nativeSnapshotSession = delivery.streamSession;
+	let appendState = {
+		rendered: "",
+		source: ""
+	};
 	let nativeProgressCompletionSent = false;
 	let cardPostRequested = false;
 	let nativeProgressTerminalStatus = "complete";
-	let nativeNarrationRenderedText = "";
-	let nativeNarrationSourceText = "";
+	let nativeNarration = {
+		rendered: "",
+		source: ""
+	};
 	let nativeStreamOrder = Promise.resolve();
 	const withNativeStreamOrder = (task) => {
 		const run = nativeStreamOrder.then(task, task);
@@ -1183,13 +1170,7 @@ function createSlackProgressRuntime(runtimeParams) {
 	const explicitProgressTitle = resolveExplicitSlackProgressTitle(account.config);
 	const progressDraftMaxLineChars = resolveChannelProgressDraftMaxLineChars(account.config);
 	const progressCard = createSlackDraftProgressCardRuntime({
-		setup: {
-			account,
-			cfg,
-			ctx,
-			prepared,
-			slackClient
-		},
+		setup,
 		draftStream,
 		enabled: useDraftProgressCard,
 		detailed: previewToolProgressEnabled,
@@ -1219,10 +1200,7 @@ function createSlackProgressRuntime(runtimeParams) {
 				session,
 				chunks
 			});
-			if (narrationUpdate.next.changed) {
-				nativeNarrationRenderedText = narrationUpdate.next.rendered;
-				nativeNarrationSourceText = narrationUpdate.next.source;
-			}
+			if (narrationUpdate.next.changed) nativeNarration = narrationUpdate.next;
 			nativeProgressCompletionSent = true;
 			delivery.observedReplyDelivery ||= session.delivered;
 		} catch (err) {
@@ -1231,30 +1209,23 @@ function createSlackProgressRuntime(runtimeParams) {
 		}
 	};
 	const resolveNativeProgressTitle = (snapshot) => combineProgressHeadlineAndExplanation(explicitProgressTitle ?? snapshot.statusHeadline, snapshot.planExplanation);
-	const normalizeProgressText = (text) => text?.replace(/\s+/gu, " ").trim() ?? "";
-	const isRenderedAsProgressTitle = (text) => {
-		const candidate = normalizeProgressText(text);
-		if (!candidate) return false;
-		const snapshot = progressDraft.getSnapshot();
-		const title = normalizeProgressText(combineProgressHeadlineAndExplanation(explicitProgressTitle ?? (snapshot.statusHeadlineFormat === "plain" ? void 0 : snapshot.statusHeadline), snapshot.planExplanationFormat === "plain" ? void 0 : snapshot.planExplanation));
-		return title.length > 0 && title.includes(candidate);
-	};
 	const resolveNarrationUpdate = (incoming) => {
 		const next = applyAppendOnlyStreamUpdate({
 			incoming: incoming ?? "",
-			rendered: nativeNarrationRenderedText,
-			source: nativeNarrationSourceText
+			...nativeNarration
 		});
 		return {
 			next,
-			delta: next.changed ? next.rendered.slice(nativeNarrationRenderedText.length) : ""
+			delta: next.changed ? next.rendered.slice(nativeNarration.rendered.length) : ""
 		};
 	};
 	const updateNativeProgressStreamNow = async () => {
-		const snapshot = progressDraft.getSnapshot();
-		const narrationUpdate = resolveNarrationUpdate(resolveNativeProgressNarration(snapshot));
 		if (!useNativeProgressStreaming || delivery.streamFailed || nativeUpdatesStopped) return false;
 		if (!await nativeTransport.waitForStart()) return false;
+		await delivery.rotateInterruptedStream();
+		if (nativeSnapshotSession !== delivery.streamSession) nativeStreamSnapshot = EMPTY_SLACK_NATIVE_STREAM_SNAPSHOT;
+		const snapshot = progressDraft.getSnapshot();
+		const narrationUpdate = resolveNarrationUpdate(resolveNativeProgressNarration(snapshot));
 		const reconciled = reconcileSlackNativeTaskChunks({
 			previous: nativeStreamSnapshot,
 			chunks: buildSlackProgressStreamChunks({
@@ -1269,16 +1240,17 @@ function createSlackProgressRuntime(runtimeParams) {
 		if (!chunks?.length && !narrationUpdate.delta) return false;
 		try {
 			const hadSession = Boolean(delivery.streamSession);
+			const retainedThreadTs = delivery.interruptedThreadTs;
 			const streamUpdate = {
 				...narrationUpdate.delta ? { text: narrationUpdate.delta } : {},
 				...chunks?.length ? { chunks } : {}
 			};
-			if (!(hadSession ? await nativeTransport.append(streamUpdate) : await nativeTransport.start(streamUpdate))) return false;
-			if (!hadSession) replyPlan.markSent();
-			if (narrationUpdate.next.changed) {
-				nativeNarrationRenderedText = narrationUpdate.next.rendered;
-				nativeNarrationSourceText = narrationUpdate.next.source;
-			}
+			const accepted = hadSession ? await nativeTransport.append(streamUpdate) : await nativeTransport.start(streamUpdate, retainedThreadTs);
+			if (accepted === "rotated") return await updateNativeProgressStreamNow();
+			if (!accepted) return false;
+			if (!hadSession && !retainedThreadTs) replyPlan.markSent();
+			nativeSnapshotSession = delivery.streamSession;
+			if (narrationUpdate.next.changed) nativeNarration = narrationUpdate.next;
 			if (chunks?.length) nativeStreamSnapshot = reconciled.snapshot;
 			return true;
 		} catch (err) {
@@ -1303,7 +1275,7 @@ function createSlackProgressRuntime(runtimeParams) {
 		await nativeUpdates.waitForInFlight();
 	};
 	const appendNativeNarration = (payload, kind) => withNativeStreamOrder(async () => {
-		if (isRenderedAsProgressTitle(payload.text)) return { visibleReplySent: false };
+		if (isSlackProgressTitleText(payload.text, progressDraft.getSnapshot(), explicitProgressTitle)) return { visibleReplySent: false };
 		const narrationUpdate = resolveNarrationUpdate(payload.text?.trimEnd());
 		if (!narrationUpdate.delta) return { visibleReplySent: false };
 		const result = await delivery.deliverWithStreaming({
@@ -1313,17 +1285,16 @@ function createSlackProgressRuntime(runtimeParams) {
 			appendSeparator: false,
 			taskDisplayMode: "plan"
 		});
-		if (result.visibleReplySent && !delivery.streamFailed) {
-			nativeNarrationRenderedText = narrationUpdate.next.rendered;
-			nativeNarrationSourceText = narrationUpdate.next.source;
-		}
+		if (result.visibleReplySent && !delivery.streamFailed) nativeNarration = narrationUpdate.next;
 		return result;
 	});
 	const resetProgressTurnState = () => {
 		progressWorkCounter.reset();
 		cardPostRequested = false;
-		nativeNarrationRenderedText = "";
-		nativeNarrationSourceText = "";
+		nativeNarration = {
+			rendered: "",
+			source: ""
+		};
 	};
 	const progressDraft = createChannelProgressDraftCompositor({
 		preparedItems: true,
@@ -1338,11 +1309,11 @@ function createSlackProgressRuntime(runtimeParams) {
 		update: async (previewText, options) => {
 			if (useNativeProgressStreaming) {
 				const priorSnapshot = nativeStreamSnapshot;
-				const priorNarration = nativeNarrationRenderedText;
+				const priorNarration = nativeNarration.rendered;
 				nativeUpdates.update(true);
 				if (options?.flush) await nativeUpdates.flush();
 				else await nativeUpdates.waitForInFlight();
-				return priorSnapshot !== nativeStreamSnapshot || priorNarration !== nativeNarrationRenderedText;
+				return priorSnapshot !== nativeStreamSnapshot || priorNarration !== nativeNarration.rendered;
 			}
 			if (!draftStream) return false;
 			const snapshot = options.snapshot;
@@ -1412,8 +1383,9 @@ function createSlackProgressRuntime(runtimeParams) {
 	};
 	const deliverNativeFinalNow = async (payload, kind) => {
 		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 delivery.rotateInterruptedStream();
+		const finalThreadTs = delivery.nativeFinalThreadTs();
+		if (delivery.canFinishNativeFinal(payload, streamReady)) {
 			await appendNativeProgressCompletion(false);
 			return await delivery.deliverWithStreaming({
 				payload,
@@ -1477,11 +1449,9 @@ function createSlackProgressRuntime(runtimeParams) {
 			progressDraft.resetActivity({ suppressed: true });
 			const next = applyAppendOnlyStreamUpdate({
 				incoming: trimmed,
-				rendered: appendRenderedText,
-				source: appendSourceText
+				...appendState
 			});
-			appendRenderedText = next.rendered;
-			appendSourceText = next.source;
+			appendState = next;
 			if (!next.changed) return false;
 			draftStream?.update(next.rendered);
 			return false;
@@ -1508,8 +1478,10 @@ function createSlackProgressRuntime(runtimeParams) {
 		return await progressDraft.pushReasoningProgress(payload.text, { snapshot: payload.isReasoningSnapshot === true });
 	};
 	const resetDraftDeliveryState = () => {
-		appendRenderedText = "";
-		appendSourceText = "";
+		appendState = {
+			rendered: "",
+			source: ""
+		};
 	};
 	const beginNewProgressTurn = async (options) => {
 		if (useNativeProgressStreaming) {
@@ -1609,11 +1581,7 @@ function createSlackProgressRuntime(runtimeParams) {
 		onQueuedFollowupSettled,
 		pushPlanProgress,
 		pushReasoningProgress,
-		updateDraftFromPartial,
-		setShouldYieldDraftProgress: (value) => {
-			shouldYieldDraftProgress = value;
-		},
-		shouldYieldDraftProgress: () => shouldYieldDraftProgress()
+		updateDraftFromPartial
 	};
 }
 //#endregion
@@ -1665,7 +1633,6 @@ async function createSlackDispatchSetup(prepared) {
 		replyToMode: prepared.replyToMode
 	});
 	const forcedReplyThreadTs = prepared.forcedReplyThreadTs;
-	const slackMessageMetadata = prepared.slackMessageMetadata;
 	const statusThreadTs = forcedReplyThreadTs ?? threadContext.messageThreadId;
 	const isThreadReply = threadContext.isThreadReply;
 	const replyDeliveryMode = forcedReplyThreadTs ? "off" : prepared.replyToMode;
@@ -1681,10 +1648,6 @@ async function createSlackDispatchSetup(prepared) {
 		isGroup: prepared.isRoomish,
 		groupId: prepared.isRoomish ? message.channel : void 0
 	};
-	const messageSentDeliveryHookContext = {
-		...messageSentHookContext,
-		messageSentHookTarget
-	};
 	const reactionMessageTs = prepared.ackReactionMessageTs;
 	const messageTs = message.ts ?? message.event_ts;
 	const incomingThreadTs = message.thread_ts;
@@ -1692,20 +1655,18 @@ async function createSlackDispatchSetup(prepared) {
 	let statusWasSet = false;
 	let didAddTypingReaction = false;
 	const statusReactionsEnabled = prepared.ctxPayload.InboundEventKind !== "room_event" && Boolean(prepared.ackReactionPromise) && Boolean(reactionMessageTs) && cfg.messages?.statusReactions?.enabled === true;
+	const updateReaction = (send, targetTs, emoji) => send(message.channel, targetTs, emoji, {
+		token: ctx.botToken,
+		client: slackClient
+	});
 	const statusReactions = createStatusReactionController({
 		enabled: statusReactionsEnabled,
 		adapter: {
 			setReaction: async (emoji) => {
-				await reactSlackMessage(message.channel, reactionMessageTs ?? "", emoji, {
-					token: ctx.botToken,
-					client: slackClient
-				});
+				await updateReaction(reactSlackMessage, reactionMessageTs ?? "", emoji);
 			},
 			removeReaction: async (emoji) => {
-				await removeSlackReaction(message.channel, reactionMessageTs ?? "", emoji, {
-					token: ctx.botToken,
-					client: slackClient
-				});
+				await updateReaction(removeSlackReaction, reactionMessageTs ?? "", emoji);
 			}
 		},
 		initialEmoji: prepared.ackReactionValue || "eyes",
@@ -1735,6 +1696,15 @@ async function createSlackDispatchSetup(prepared) {
 	const typingTarget = statusThreadTs ? `${message.channel}/${statusThreadTs}` : message.channel;
 	const typingReaction = quietProgress && account.config.typingReaction === void 0 ? "hourglass_flowing_sand" : ctx.typingReaction;
 	const threadStatusGate = { hasVisibleOutput: () => false };
+	const onTypingError = (action, error) => {
+		logTypingFailure({
+			log: (messageValue) => runtime.error?.(danger(messageValue)),
+			channel: "slack",
+			action,
+			target: typingTarget,
+			error
+		});
+	};
 	const { onModelSelected, ...replyPipeline } = createChannelMessageReplyPipeline({
 		cfg,
 		agentId: route.agentId,
@@ -1755,10 +1725,7 @@ async function createSlackDispatchSetup(prepared) {
 				}
 				if (typingReaction && message.ts) {
 					didAddTypingReaction = true;
-					await reactSlackMessage(message.channel, message.ts, typingReaction, {
-						token: ctx.botToken,
-						client: slackClient
-					}).catch((err) => {
+					await updateReaction(reactSlackMessage, message.ts, typingReaction).catch((err) => {
 						logVerbose(`slack send: typing reaction failed: ${formatSlackError(err)}`);
 					});
 				}
@@ -1780,32 +1747,13 @@ async function createSlackDispatchSetup(prepared) {
 				}
 				if (didAddTypingReaction && typingReaction && message.ts) {
 					didAddTypingReaction = false;
-					await removeSlackReaction(message.channel, message.ts, typingReaction, {
-						token: ctx.botToken,
-						client: slackClient
-					}).catch((err) => {
+					await updateReaction(removeSlackReaction, message.ts, typingReaction).catch((err) => {
 						logVerbose(`slack send: typing reaction removal failed: ${formatSlackError(err)}`);
 					});
 				}
 			},
-			onStartError: (err) => {
-				logTypingFailure({
-					log: (messageValue) => runtime.error?.(danger(messageValue)),
-					channel: "slack",
-					action: "start",
-					target: typingTarget,
-					error: err
-				});
-			},
-			onStopError: (err) => {
-				logTypingFailure({
-					log: (messageLocal) => runtime.error?.(danger(messageLocal)),
-					channel: "slack",
-					action: "stop",
-					target: typingTarget,
-					error: err
-				});
-			}
+			onStartError: (err) => onTypingError("start", err),
+			onStopError: (err) => onTypingError("stop", err)
 		}
 	});
 	const hookRunner = getGlobalHookRunner();
@@ -1824,18 +1772,12 @@ async function createSlackDispatchSetup(prepared) {
 	const blockStreamingEnabled = resolveChannelStreamingBlockEnabled(account.config);
 	return {
 		prepared,
-		ctx,
-		account,
-		message,
-		route,
 		slackClient,
 		slackClientOptions,
 		slackStreamFallbackTeamId,
 		cfg,
 		runtime,
 		slackIdentity,
-		forcedReplyThreadTs,
-		slackMessageMetadata,
 		statusThreadTs,
 		isThreadReply,
 		replyDeliveryMode,
@@ -1843,7 +1785,6 @@ async function createSlackDispatchSetup(prepared) {
 		suppressRoomEventTyping,
 		messageSentHookTarget,
 		messageSentHookContext,
-		messageSentDeliveryHookContext,
 		statusReactionsEnabled,
 		statusReactions,
 		hasRepliedRef,
@@ -1865,9 +1806,13 @@ async function createSlackDispatchSetup(prepared) {
 //#endregion
 //#region extensions/slack/src/monitor/message-handler/dispatch-streaming.ts
 function createSlackStreamingDeliveryRuntime(setup) {
-	const { account, ctx, forcedReplyThreadTs, isThreadReply, message, messageSentDeliveryHookContext, messageSentHookContext, messageSentHookTarget, prepared, replyDeliveryMode, replyPlan, runtime, slackClient, slackClientOptions, slackIdentity, slackMessageMetadata, slackStreamFallbackTeamId } = setup;
+	const { isThreadReply, messageSentHookContext, messageSentHookTarget, prepared, replyDeliveryMode, replyPlan, runtime, slackClient, slackClientOptions, slackIdentity, slackStreamFallbackTeamId } = setup;
+	const { account, ctx, forcedReplyThreadTs, message, slackMessageMetadata } = prepared;
 	const state = {
 		streamSession: null,
+		streamBoundary: null,
+		interruptedThreadTs: void 0,
+		streamInterrupted: false,
 		nativeProgressStreamStartPromise: null,
 		nativeProgressStreamThreadTs: void 0,
 		streamFailed: false,
@@ -1876,22 +1821,40 @@ function createSlackStreamingDeliveryRuntime(setup) {
 		observedReplyDelivery: false
 	};
 	const startStream = async (params) => {
-		const session = await startSlackStream({
-			client: slackClient,
-			clientOptions: slackClientOptions,
-			channel: message.channel,
-			...params,
-			...slackIdentity ? { identity: slackIdentity } : {},
-			teamId: await resolveSlackStreamRecipientTeamId({
-				client: slackClient,
-				token: ctx.botToken,
-				userId: message.user,
-				fallbackTeamId: slackStreamFallbackTeamId
-			}),
-			userId: message.user
+		const boundary = trackSlackDraftMessage({
+			accountId: account.accountId,
+			teamId: prepared.eventScope?.teamId,
+			channelId: message.channel,
+			threadTs: message.thread_ts,
+			onInterveningMessage: () => {
+				state.streamInterrupted = true;
+			}
 		});
-		state.streamSession = session;
-		return session;
+		state.streamBoundary = boundary;
+		try {
+			const session = await startSlackStream({
+				client: slackClient,
+				clientOptions: slackClientOptions,
+				channel: message.channel,
+				...params,
+				...slackIdentity ? { identity: slackIdentity } : {},
+				teamId: await resolveSlackStreamRecipientTeamId({
+					client: slackClient,
+					token: ctx.botToken,
+					userId: message.user,
+					fallbackTeamId: slackStreamFallbackTeamId
+				}),
+				userId: message.user
+			});
+			state.streamSession = session;
+			state.interruptedThreadTs = void 0;
+			if (session.streamer.ts) boundary.setMessageTs(session.streamer.ts);
+			return session;
+		} catch (error) {
+			boundary.stop();
+			if (state.streamBoundary === boundary) state.streamBoundary = null;
+			throw error;
+		}
 	};
 	const deliverPreparedReply = (reply, replyThreadTs, deferMessageSentHooks = false) => deliverReplies({
 		cfg: ctx.cfg,
@@ -1906,7 +1869,8 @@ function createSlackStreamingDeliveryRuntime(setup) {
 		replyToMode: replyDeliveryMode,
 		...slackIdentity ? { identity: slackIdentity } : {},
 		...slackMessageMetadata ? { metadata: slackMessageMetadata } : {},
-		...messageSentDeliveryHookContext,
+		...messageSentHookContext,
+		messageSentHookTarget,
 		...deferMessageSentHooks ? { deferMessageSentHooks: true } : {},
 		eventScope: prepared.eventScope
 	});
@@ -1919,12 +1883,15 @@ function createSlackStreamingDeliveryRuntime(setup) {
 			...result
 		});
 	};
-	let deliveryTracker = createSlackEventDeliveryTracker();
+	const deliveredKeys = /* @__PURE__ */ new Set();
+	const markDelivered = (key) => {
+		if (key) deliveredKeys.add(key);
+	};
 	const markPreviewPayloadDelivered = (params) => {
 		const preparedReply = prepareSlackReply(params.payload);
-		deliveryTracker.markDelivered(buildSlackEventDeliveryKey(params, preparedReply));
+		markDelivered(buildSlackEventDeliveryKey(params, preparedReply));
 		const nextThreadTs = replyPlan.peekThreadTs();
-		if (nextThreadTs !== params.threadTs) deliveryTracker.markDelivered(buildSlackEventDeliveryKey({
+		if (nextThreadTs !== params.threadTs) markDelivered(buildSlackEventDeliveryKey({
 			...params,
 			threadTs: nextThreadTs
 		}, preparedReply));
@@ -1938,14 +1905,16 @@ function createSlackStreamingDeliveryRuntime(setup) {
 		state.usedReplyThreadTs ??= deliveredThreadTs;
 		if (kind === "block") state.usedBlockReplyThreadTs = deliveredThreadTs;
 	};
+	const stopStream = (session, chunks) => stopSlackStream({
+		session,
+		...chunks?.length ? { chunks } : {},
+		...slackMessageMetadata ? { metadata: slackMessageMetadata } : {}
+	});
 	const deliverPendingStreamFallback = async (session, err) => {
 		if (session.stoppedBySlack) return;
 		let fallbackError = err;
 		if (!session.stopped) try {
-			const stopResult = await stopSlackStream({
-				session,
-				...slackMessageMetadata ? { metadata: slackMessageMetadata } : {}
-			});
+			const stopResult = await stopStream(session);
 			if (session.stoppedBySlack) return;
 			state.observedReplyDelivery = true;
 			state.usedReplyThreadTs ??= session.threadTs;
@@ -1964,10 +1933,7 @@ function createSlackStreamingDeliveryRuntime(setup) {
 		if (!sent?.receipt.platformMessageIds.length) return;
 		markSlackStreamFallbackDelivered(session);
 		if (!session.stopped) try {
-			await stopSlackStream({
-				session,
-				...slackMessageMetadata ? { metadata: slackMessageMetadata } : {}
-			});
+			await stopStream(session);
 		} catch (finalizeErr) {
 			runtime.error?.(danger(`slack-stream: failed to finalize native stream after fallback delivery: ${formatSlackError(finalizeErr)}`));
 		}
@@ -1982,14 +1948,12 @@ function createSlackStreamingDeliveryRuntime(setup) {
 		};
 	};
 	const finishStream = async (chunks) => {
+		state.streamBoundary?.stop();
+		state.streamBoundary = null;
 		const session = state.streamSession;
 		if (session && !session.stopped) try {
 			try {
-				await stopSlackStream({
-					session,
-					...chunks?.length ? { chunks } : {},
-					...slackMessageMetadata ? { metadata: slackMessageMetadata } : {}
-				});
+				await stopStream(session, chunks);
 				state.observedReplyDelivery ||= session.delivered;
 			} catch (error) {
 				if (!(error instanceof SlackStreamNotDeliveredError)) throw error;
@@ -2000,9 +1964,28 @@ function createSlackStreamingDeliveryRuntime(setup) {
 			runtime.error?.(danger(`slack-stream: failed to stop stream: ${formatSlackError(error)}`));
 		}
 	};
+	const rotateInterruptedStream = async () => {
+		if (!state.streamInterrupted) return;
+		await state.nativeProgressStreamStartPromise?.catch(() => null);
+		if (!state.streamInterrupted) return;
+		state.streamInterrupted = false;
+		if (state.streamSession?.stoppedBySlack) {
+			state.streamBoundary?.stop();
+			state.streamBoundary = null;
+			return;
+		}
+		const threadTs = state.streamSession?.threadTs ?? state.nativeProgressStreamThreadTs;
+		await finishStream();
+		if (state.streamSession?.stoppedBySlack) return;
+		state.streamSession = null;
+		state.interruptedThreadTs = threadTs;
+		return threadTs;
+	};
 	const deliverNormally = async (params) => {
 		if (state.streamSession?.stoppedBySlack) return { visibleReplySent: false };
-		const replyThreadTs = resolveDeliveryThreadTs(params);
+		await rotateInterruptedStream();
+		if (state.streamSession?.stoppedBySlack) return { visibleReplySent: false };
+		const replyThreadTs = params.forcedThreadTs ?? state.interruptedThreadTs ?? resolveDeliveryThreadTs(params);
 		const deliveryReplyThreadTs = replyDeliveryMode === "off" && !forcedReplyThreadTs && !isThreadReply ? void 0 : replyThreadTs;
 		const preparedReply = prepareSlackReply(params.payload);
 		const deliveryKey = buildSlackEventDeliveryKey({
@@ -2010,7 +1993,7 @@ function createSlackStreamingDeliveryRuntime(setup) {
 			payload: params.payload,
 			threadTs: deliveryReplyThreadTs
 		}, preparedReply);
-		if (deliveryTracker.hasDelivered(deliveryKey)) {
+		if (deliveryKey && deliveredKeys.has(deliveryKey)) {
 			logVerbose("slack: suppressed duplicate normal delivery within the same turn");
 			return { visibleReplySent: false };
 		}
@@ -2025,7 +2008,7 @@ function createSlackStreamingDeliveryRuntime(setup) {
 		});
 		rememberDeliveredThreadTs(params.kind, deliveredThreadTs);
 		replyPlan.markSent();
-		deliveryTracker.markDelivered(deliveryKey);
+		markDelivered(deliveryKey);
 		return {
 			visibleReplySent: true,
 			messageIds: sent.receipt.platformMessageIds,
@@ -2047,9 +2030,10 @@ function createSlackStreamingDeliveryRuntime(setup) {
 			forcedThreadTs: state.streamSession?.threadTs ?? state.nativeProgressStreamThreadTs
 		});
 		if (!state.streamSession && state.nativeProgressStreamStartPromise) await state.nativeProgressStreamStartPromise;
+		await rotateInterruptedStream();
 		if (state.streamSession?.stoppedBySlack) return { visibleReplySent: false };
 		let session = state.streamSession;
-		const threadTs = session?.threadTs ?? replyPlan.nextThreadTs();
+		const threadTs = session?.threadTs ?? state.interruptedThreadTs ?? replyPlan.nextThreadTs();
 		if (state.streamFailed || !threadTs) {
 			state.streamFailed = true;
 			return await deliverNormally({
@@ -2065,7 +2049,7 @@ function createSlackStreamingDeliveryRuntime(setup) {
 			threadTs,
 			textOverride: text
 		});
-		if (deliveryTracker.hasDelivered(deliveryKey)) {
+		if (deliveryKey && deliveredKeys.has(deliveryKey)) {
 			logVerbose("slack-stream: suppressed duplicate reply payload");
 			return { visibleReplySent: false };
 		}
@@ -2122,7 +2106,7 @@ function createSlackStreamingDeliveryRuntime(setup) {
 		state.observedReplyDelivery = true;
 		rememberDeliveredThreadTs(params.kind, threadTs);
 		replyPlan.markSent();
-		deliveryTracker.markDelivered(deliveryKey);
+		markDelivered(deliveryKey);
 		emitStreamedDelivery(hookContent, {
 			success: true,
 			...messageId ? { messageId } : {}
@@ -2133,17 +2117,20 @@ function createSlackStreamingDeliveryRuntime(setup) {
 			threadId: threadTs
 		};
 	};
+	const nativeFinalThreadTs = () => state.streamSession?.threadTs ?? state.interruptedThreadTs ?? state.nativeProgressStreamThreadTs;
+	const canFinishNativeFinal = (payload, streamReady) => payload.isError !== true && streamReady && Boolean(state.streamSession || state.interruptedThreadTs) && isStreamingEligible(payload, { maxTextBytes: 4e3 });
 	return Object.assign(state, {
+		canFinishNativeFinal,
 		deliverNormally,
 		deliverWithStreaming,
 		finishStream,
 		isStreamingEligible,
 		markPreviewPayloadDelivered,
+		nativeFinalThreadTs,
 		rememberDeliveredThreadTs,
+		rotateInterruptedStream,
 		startStream,
-		resetDeliveryTracker: () => {
-			deliveryTracker = createSlackEventDeliveryTracker();
-		}
+		resetDeliveryTracker: () => deliveredKeys.clear()
 	});
 }
 //#endregion
@@ -2180,13 +2167,16 @@ async function dispatchPreparedSlackMessage(prepared) {
 }
 async function dispatchSlackMessageWithSetup(setup, beginSessionRun, turnAdoptionLifecycle) {
 	const { prepared } = setup;
-	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;
+	const { account, ctx, message, route } = prepared;
+	const { cfg, disableBlockStreaming, hasSlackCustomIdentity, hasRepliedRef, messageSentHookContext, messageSentHookTarget, onModelSelected, previewStreamingEnabled, replyPipeline, replyPlan, runtime, slackClient, slackStreaming, sourceReplyDeliveryMode, statusReactions, statusReactionsEnabled, statusThreadTs, suppressRoomEventTyping, useStreaming } = setup;
 	let dispatchError;
 	const delivery = createSlackStreamingDeliveryRuntime(setup);
 	const progress = createSlackProgressRuntime({
 		setup,
 		delivery
 	});
+	let shouldYieldDraftProgress = async () => false;
+	let turnCommentaryVisible = false;
 	const { draftStream, previewLifecycle } = progress;
 	setup.threadStatusGate.hasVisibleOutput = () => delivery.observedReplyDelivery || previewLifecycle.previewFinalized || Boolean(draftStream?.messageId());
 	const failureNoticeThreadTs = message.thread_ts;
@@ -2409,9 +2399,10 @@ async function dispatchSlackMessageWithSetup(setup, beginSessionRun, turnAdoptio
 				commentaryProgressEnabled: progress.commentaryProgressEnabled ? true : void 0,
 				progressPreambleEnabled: progress.progressDraftActive && slackStreaming.mode === "progress" ? true : void 0,
 				commentaryPayloadsEnabled: progress.commentaryProgressEnabled ? true : void 0,
-				shouldDeliverCommentaryPayloads: progress.commentaryProgressEnabled ? progress.shouldYieldDraftProgress : void 0,
-				onVerboseProgressVisibility: progress.commentaryProgressEnabled ? (isActive) => {
-					progress.setShouldYieldDraftProgress(isActive);
+				shouldDeliverCommentaryPayloads: progress.commentaryProgressEnabled ? () => turnCommentaryVisible : void 0,
+				onVerboseProgressVisibilityAsync: progress.commentaryProgressEnabled ? async (isActive) => {
+					shouldYieldDraftProgress = isActive;
+					turnCommentaryVisible = await isActive();
 				} : void 0,
 				allowProgressCallbacksWhenSourceDeliverySuppressed: sourceReplyDeliveryMode === "message_tool_only" && statusReactionsEnabled ? true : void 0,
 				allowToolLifecycleWhenProgressHidden: statusReactionsEnabled ? true : void 0,
@@ -2437,7 +2428,8 @@ async function dispatchSlackMessageWithSetup(setup, beginSessionRun, turnAdoptio
 				},
 				onItemEvent: async (payload) => {
 					if (payload.hideFromChannelProgress || payload.suppressChannelProgress) return progress.preambleOnlyProgress ? false : progress.progressDraft.pushItemEvent(payload);
-					if (payload.kind === "preamble" && progress.shouldYieldDraftProgress()) return false;
+					if (payload.kind === "preamble" && await shouldYieldDraftProgress()) return false;
+					if (prepared.turnAdoptionLifecycle?.abortSignal?.aborted) return false;
 					progress.progressWorkCounter.noteItem(payload);
 					return progress.preambleOnlyProgress && payload.kind !== "preamble" ? await progress.progressDraft.noteActivity() : await progress.progressDraft.pushItemEvent(payload);
 				},
@@ -2546,12 +2538,7 @@ const THREAD_STARTER_CACHE = /* @__PURE__ */ new Map();
 const THREAD_STARTER_CACHE_TTL_MS = 216e5;
 const THREAD_STARTER_CACHE_MAX = 2e3;
 function evictThreadStarterCache() {
-	const now = asDateTimestampMs(Date.now());
-	if (now === void 0) {
-		THREAD_STARTER_CACHE.clear();
-		return;
-	}
-	for (const [cacheKey, entry] of THREAD_STARTER_CACHE.entries()) if (asDateTimestampMs(entry.expiresAt) === void 0 || entry.expiresAt <= now) THREAD_STARTER_CACHE.delete(cacheKey);
+	pruneExpiredMapEntries(THREAD_STARTER_CACHE, Date.now());
 	pruneMapToMaxSize(THREAD_STARTER_CACHE, THREAD_STARTER_CACHE_MAX);
 }
 function formatSlackFilePlaceholder(files) {
@@ -2635,6 +2622,16 @@ async function resolveSlackThreadStarter(params) {
 	}
 }
 const SLACK_THREAD_HISTORY_MAX_PAGES = 3;
+function toSlackHistoryMessage(message, text) {
+	return {
+		text: text ?? formatSlackFilePlaceholder(message.files),
+		userId: message.user,
+		botId: message.bot_id,
+		ts: message.ts,
+		files: message.files,
+		attachments: message.attachments
+	};
+}
 /**
 * Fetches the most recent messages in a Slack thread (excluding the current message).
 * Used to populate thread context when a new thread session starts.
@@ -2684,14 +2681,7 @@ async function resolveSlackThreadHistory(params) {
 			params.onOmission?.("Slack thread exceeds the three-page automatic history budget");
 			return [];
 		}
-		return retained.map(([message, text]) => ({
-			text: text ?? formatSlackFilePlaceholder(message.files),
-			userId: message.user,
-			botId: message.bot_id,
-			ts: message.ts,
-			files: message.files,
-			attachments: message.attachments
-		}));
+		return retained.map(([message, text]) => toSlackHistoryMessage(message, text));
 	} catch (err) {
 		params.assertCurrent?.();
 		params.onOmission?.(formatErrorMessage(err));
@@ -2724,14 +2714,7 @@ async function resolveSlackChannelHistory(params) {
 			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
-			});
+			messages.push(toSlackHistoryMessage(message, text));
 		}
 		cursor = response.response_metadata?.next_cursor?.trim() || void 0;
 		if (!cursor || scanned >= params.limit) break;
@@ -2788,7 +2771,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-DDoAJnrH.mjs").then((n) => n._));
+const loadSlackMediaModule$1 = createLazyRuntimeModule(() => import("./actions-KGKwTAKO.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)`;
@@ -2805,7 +2788,7 @@ function formatSlackUnavailableMedia(params) {
 		notice
 	});
 }
-function collectUniqueSlackMentionIds$1(texts) {
+function collectUniqueSlackMentionIds(texts) {
 	const seen = /* @__PURE__ */ new Set();
 	for (const text of texts) {
 		if (!text) continue;
@@ -2862,7 +2845,7 @@ async function resolveSlackMessageContent(params) {
 	const renderedMentions = /* @__PURE__ */ new Map();
 	const resolveUserName = params.resolveUserName;
 	if (resolveUserName) {
-		const mentionIds = collectUniqueSlackMentionIds$1(textParts);
+		const mentionIds = collectUniqueSlackMentionIds(textParts);
 		const lookupIds = mentionIds.slice(0, SLACK_MENTION_RESOLUTION_MAX_LOOKUPS_PER_MESSAGE);
 		const skippedLookups = mentionIds.length - lookupIds.length;
 		if (skippedLookups > 0) logVerbose(`slack: skipping ${skippedLookups} mention lookup(s) beyond per-message cap (${SLACK_MENTION_RESOLUTION_MAX_LOOKUPS_PER_MESSAGE})`);
@@ -3142,52 +3125,13 @@ function resolveSlackGroupSessionSubject(params) {
 	if (channelName && workspaceName) return `${workspaceName} #${channelName}`;
 	return `Slack Channel (Workspace ID: ${params.workspaceId}, Channel ID: ${params.channelId})`;
 }
-function resolveSlackConversationLink(params) {
-	if (params.existingLink) return params.existingLink;
-	const teamId = normalizeOptionalString(params.teamId);
-	let apiHost = "";
-	try {
-		apiHost = params.slackApiUrl ? new URL(params.slackApiUrl).hostname.toLowerCase() : "";
-	} catch {}
-	const url = new URL(`https://${apiHost === "slack-gov.com" ? "slack-gov.com" : "slack.com"}/app_redirect`);
-	url.searchParams.set("channel", params.channelId);
-	if (teamId) url.searchParams.set("team", teamId);
-	return {
-		url: url.href,
-		label: "Slack"
-	};
-}
 //#endregion
 //#region extensions/slack/src/monitor/message-handler/prepare-thread-context.ts
-const loadSlackMediaModule = createLazyRuntimeModule(() => import("./actions-DDoAJnrH.mjs").then((n) => n._));
+const loadSlackMediaModule = createLazyRuntimeModule(() => import("./actions-KGKwTAKO.mjs").then((n) => n._));
 const SLACK_THREAD_CONTEXT_USER_LOOKUP_CONCURRENCY = 4;
 function formatSlackThreadLabelSnippet(text) {
 	return truncateUtf16Safe(text.replace(/\s+/g, " "), 80);
 }
-function resolveSlackThreadSessionFreshness(params) {
-	return params.ctx.channelRuntime?.session?.resolveEntryResetFreshness?.({
-		agentId: params.agentId,
-		storePath: params.storePath,
-		sessionKey: params.sessionKey,
-		sessionCfg: params.ctx.cfg.session,
-		resetType: "thread",
-		resetOverride: resolveChannelResetConfig({
-			sessionCfg: params.ctx.cfg.session,
-			channel: "slack"
-		})
-	});
-}
-async function resolveSlackThreadUserMap(params) {
-	const uniqueUserIds = [...new Set(params.messages.map((item) => item.userId).filter((id) => Boolean(id)))];
-	const { results } = await runTasksWithConcurrency({
-		tasks: uniqueUserIds.map((id) => async () => {
-			const user = await params.ctx.resolveUserName(id, params.eventScope);
-			return user ? [id, user] : null;
-		}),
-		limit: SLACK_THREAD_CONTEXT_USER_LOOKUP_CONCURRENCY
-	});
-	return new Map(results.flatMap((result) => result ? [result] : []));
-}
 async function resolveSlackThreadContextData(params) {
 	const botIdentity = {
 		botUserId: params.ctx.botUserId,
@@ -3197,17 +3141,34 @@ async function resolveSlackThreadContextData(params) {
 		identity: botIdentity,
 		author
 	});
+	const resolveThreadUserMap = async (messages) => {
+		const uniqueUserIds = [...new Set(messages.map((item) => item.userId).filter((id) => Boolean(id)))];
+		const { results } = await runTasksWithConcurrency({
+			tasks: uniqueUserIds.map((id) => async () => {
+				const user = await params.ctx.resolveUserName(id, params.eventScope);
+				return user ? [id, user] : null;
+			}),
+			limit: SLACK_THREAD_CONTEXT_USER_LOOKUP_CONCURRENCY
+		});
+		return new Map(results.flatMap((result) => result ? [result] : []));
+	};
 	let threadStarterBody;
 	let threadHistoryBody;
 	let threadLabel;
 	let threadStarterMedia = null;
-	const threadSessionFreshness = params.isThreadReply && params.threadTs ? resolveSlackThreadSessionFreshness({
-		ctx: params.ctx,
+	const threadSessionFreshness = params.isThreadReply && params.threadTs ? await params.ctx.channelRuntime?.session?.resolveEntryResetFreshnessAsync?.({
 		agentId: params.agentId,
 		storePath: params.storePath,
-		sessionKey: params.sessionKey
+		sessionKey: params.sessionKey,
+		sessionCfg: params.ctx.cfg.session,
+		resetType: "thread",
+		resetOverride: resolveChannelResetConfig({
+			sessionCfg: params.ctx.cfg.session,
+			channel: "slack"
+		})
 	}) : void 0;
-	const threadSessionPreviousTimestamp = params.isThreadReply && params.threadTs && !threadSessionFreshness ? readSessionUpdatedAt({
+	params.assertHistoryCurrent?.();
+	const threadSessionPreviousTimestamp = params.isThreadReply && params.threadTs && !threadSessionFreshness ? await readSessionUpdatedAtAsync({
 		storePath: params.storePath,
 		sessionKey: params.sessionKey
 	}) : void 0;
@@ -3319,11 +3280,7 @@ async function resolveSlackThreadContextData(params) {
 			const retainCurrentBotHistory = params.isGroupDm && (isMissingThreadSession || isOutboundOnlyThreadSession);
 			const threadHistoryWithoutCurrentBot = threadHistoryWithBotRoot.filter((entry) => !isCurrentBotAuthor(entry) || retainCurrentBotHistory || includeBotStarterAsRootContext && entry.ts === currentBotRootTs);
 			const omittedCurrentBotHistoryCount = threadHistoryWithBotRoot.length - threadHistoryWithoutCurrentBot.length;
-			const userMapForFilter = params.contextVisibilityMode !== "all" && params.allowNameMatching && params.allowFromLower.length > 0 ? await resolveSlackThreadUserMap({
-				ctx: params.ctx,
-				messages: threadHistoryWithoutCurrentBot,
-				eventScope: params.eventScope
-			}) : /* @__PURE__ */ new Map();
+			const userMapForFilter = params.contextVisibilityMode !== "all" && params.allowNameMatching && params.allowFromLower.length > 0 ? await resolveThreadUserMap(threadHistoryWithoutCurrentBot) : /* @__PURE__ */ new Map();
 			params.assertHistoryCurrent?.();
 			const { items: filteredThreadHistory, omitted: omittedHistoryCount } = params.contextVisibilityMode === "all" ? {
 				items: threadHistoryWithoutCurrentBot,
@@ -3344,11 +3301,7 @@ async function resolveSlackThreadContextData(params) {
 					});
 				}
 			});
-			const userMap = await resolveSlackThreadUserMap({
-				ctx: params.ctx,
-				messages: filteredThreadHistory,
-				eventScope: params.eventScope
-			});
+			const userMap = await resolveThreadUserMap(filteredThreadHistory);
 			params.assertHistoryCurrent?.();
 			if (omittedHistoryCount > 0 || omittedCurrentBotHistoryCount > 0) logVerbose(`slack: omitted ${omittedHistoryCount + omittedCurrentBotHistoryCount} thread message(s) from context (mode=${params.contextVisibilityMode})`);
 			const historyParts = [];
@@ -3441,10 +3394,10 @@ const subteamMemberCache = /* @__PURE__ */ new WeakMap();
 function normalizeSlackId(value) {
 	return normalizeOptionalString(value)?.toUpperCase();
 }
-function extractSlackSubteamMentionIds(text) {
-	if (!text) return [];
+function collectSlackMentionIds(text, regex) {
 	const ids = /* @__PURE__ */ new Set();
-	for (const match of text.matchAll(SUBTEAM_MENTION_RE)) {
+	regex.lastIndex = 0;
+	for (const match of (text ?? "").matchAll(regex)) {
 		const id = normalizeSlackId(match[1]);
 		if (id) ids.add(id);
 	}
@@ -3487,7 +3440,7 @@ async function readSlackSubteamUsers(params) {
 async function isSlackSubteamMentionForBot(params) {
 	const botUserId = normalizeSlackId(params.botUserId);
 	if (!botUserId) return false;
-	const subteamIds = extractSlackSubteamMentionIds(params.text);
+	const subteamIds = collectSlackMentionIds(params.text, SUBTEAM_MENTION_RE);
 	if (subteamIds.length === 0) return false;
 	const now = params.now ?? Date.now();
 	for (const subteamId of subteamIds) if ((await readSlackSubteamUsers({
@@ -3571,39 +3524,14 @@ function resolveCachedMentionRegexes(ctx, agentId, options) {
 	byAgent.set(key, built);
 	return built;
 }
-function collectUniqueSlackMentionIds(text, regex) {
-	const ids = [];
-	regex.lastIndex = 0;
-	for (const match of text.matchAll(regex)) {
-		const id = normalizeSlackId(match[1]);
-		if (id && !ids.includes(id)) ids.push(id);
-	}
-	return ids;
-}
 function collectSlackMentionMetadata(text) {
 	return {
-		mentionedUserIds: collectUniqueSlackMentionIds(text, SLACK_USER_MENTION_RE),
-		mentionedSubteamIds: collectUniqueSlackMentionIds(text, SLACK_SUBTEAM_MENTION_RE),
+		mentionedUserIds: collectSlackMentionIds(text, SLACK_USER_MENTION_RE),
+		mentionedSubteamIds: collectSlackMentionIds(text, SLACK_SUBTEAM_MENTION_RE),
 		hasAnyMention: SLACK_ANY_MENTION_RE.test(text),
 		hasSubteamMention: text.includes(SLACK_SUBTEAM_MENTION_MARKER)
 	};
 }
-async function resolveSlackExplicitMentionState(params) {
-	const normalizedBotUserId = normalizeSlackId(params.ctx.botUserId);
-	const explicitlyMentionedBotUser = Boolean(normalizedBotUserId && params.mentionedUserIds.includes(normalizedBotUserId));
-	const explicitlyMentionedBotSubteam = Boolean(params.ctx.botUserId && params.hasSubteamMention) && await isSlackSubteamMentionForBot({
-		client: params.eventScope?.client ?? params.ctx.app.client,
-		text: params.messageText,
-		botUserId: params.ctx.botUserId,
-		teamId: params.eventScope?.teamId ?? params.ctx.teamId,
-		log: logVerbose
-	});
-	return {
-		explicitlyMentionedBotUser,
-		explicitlyMentionedBotSubteam,
-		explicitlyMentioned: explicitlyMentionedBotUser || explicitlyMentionedBotSubteam || params.source === "app_mention"
-	};
-}
 function resolveSlackMentionSource(params) {
 	if (params.explicitBotMention) return "explicit_bot";
 	if (params.explicitSubteamMention) return "subteam";
@@ -3794,14 +3722,16 @@ async function prepareSlackMessage(params) {
 		message,
 		eventScope: opts.eventScope
 	}) : Promise.resolve(void 0);
-	const { explicitlyMentionedBotUser, explicitlyMentionedBotSubteam, explicitlyMentioned } = await resolveSlackExplicitMentionState({
-		ctx,
-		messageText,
-		mentionedUserIds,
-		hasSubteamMention: mentionMetadata.hasSubteamMention,
-		source: opts.source,
-		eventScope: opts.eventScope
+	const currentBotUserId = normalizeSlackId(ctx.botUserId);
+	const explicitlyMentionedBotUser = Boolean(currentBotUserId && mentionedUserIds.includes(currentBotUserId));
+	const explicitlyMentionedBotSubteam = Boolean(ctx.botUserId && mentionMetadata.hasSubteamMention) && await isSlackSubteamMentionForBot({
+		client: opts.eventScope?.client ?? ctx.app.client,
+		text: messageText,
+		botUserId: ctx.botUserId,
+		teamId: opts.eventScope?.teamId ?? ctx.teamId,
+		log: logVerbose
 	});
+	const explicitlyMentioned = explicitlyMentionedBotUser || explicitlyMentionedBotSubteam || opts.source === "app_mention";
 	const channelRequireMention = channelConfig?.requireMention ?? ctx.defaultRequireMention ?? true;
 	const chatType = resolveSlackChatType(conversation.resolvedChannelType);
 	const restoredAssistantThreadContext = await restoredAssistantThreadContextPromise;
@@ -3869,12 +3799,11 @@ 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 } = routing;
 	const { configuredBinding, configuredBindingSessionKey } = routing;
 	const isAssistantThreadMessage = Boolean(isDirectMessage && messageAssistantThreadContext);
-	const forcedAssistantReplyThreadTs = Boolean(assistantThreadContext?.threadTs && (isThreadReply || isAssistantThreadMessage || replyToMode !== "off")) ? assistantThreadContext?.threadTs : void 0;
+	const forcedAssistantReplyThreadTs = Boolean(assistantThreadContext?.threadTs && (routing.isThreadReply || isAssistantThreadMessage || routing.replyToMode !== "off")) ? assistantThreadContext?.threadTs : void 0;
 	const forcedReplyThreadTs = agentViewThreadTs ?? forcedAssistantReplyThreadTs;
-	if (runtimeBinding && shouldLogVerbose()) logVerbose(`slack: routed via bound conversation ${runtimeBinding.conversation.conversationId} -> ${runtimeBinding.targetSessionKey}`);
+	if (routing.runtimeBinding && shouldLogVerbose()) logVerbose(`slack: routed via bound conversation ${routing.runtimeBinding.conversation.conversationId} -> ${routing.runtimeBinding.targetSessionKey}`);
 	if (configuredBinding) {
 		const ensured = await ensureConfiguredBindingRouteReady({
 			cfg,
@@ -3890,9 +3819,9 @@ async function prepareSlackMessage(params) {
 	const senderNameForAuthPromise = ctx.allowNameMatching ? resolveSenderName() : void 0;
 	let threadStarterPromise;
 	const getThreadStarter = () => {
-		threadStarterPromise ??= isThreadReply && threadTs ? resolveSlackThreadStarter({
+		threadStarterPromise ??= routing.isThreadReply && routing.threadTs ? resolveSlackThreadStarter({
 			channelId: message.channel,
-			threadTs,
+			threadTs: routing.threadTs,
 			client: slackClient,
 			workspaceScope: threadStarterWorkspaceScope,
 			refresh: isRoomish && ctx.historyLimit > 0
@@ -3901,7 +3830,7 @@ async function prepareSlackMessage(params) {
 	};
 	const resolveMessageContent = (contentMessage, preloadedMedia) => getThreadStarter().then((threadStarter) => resolveSlackMessageContent({
 		message: contentMessage,
-		isThreadReply,
+		isThreadReply: routing.isThreadReply,
 		threadStarter,
 		isBotMessage,
 		botToken: ctx.botToken,
@@ -4051,7 +3980,6 @@ async function prepareSlackMessage(params) {
 		})) groupThread = void 0;
 		mentionRegexes = buildPolicyMentionRegexes(routing.route.agentId);
 		wasMentioned = resolveWasMentioned(mentionRegexes);
-		({route, runtimeBinding, replyToMode, threadContext, threadTs, isThreadReply, threadKeys, sessionKey} = routing);
 		canDetectMention = Boolean(groupThread) || Boolean(ctx.botUserId) || mentionRegexes.length > 0;
 	}
 	if (preflightAudioTranscript && !wasMentioned) {
@@ -4060,6 +3988,7 @@ async function prepareSlackMessage(params) {
 		preflightAudioTranscript = void 0;
 		preflightAudioMedia = void 0;
 	}
+	const { route, runtimeBinding, replyToMode, threadContext, threadTs, isThreadReply, threadKeys, sessionKey } = routing;
 	const directThreadRoutedToDmSession = !assistantThreadContext && !agentViewThreadTs && isDirectMessage && isThreadReply && threadTs && runtimeBinding?.conversation.conversationId !== threadTs;
 	const mentionDecision = resolveInboundMentionDecision({
 		facts: {
@@ -4188,12 +4117,6 @@ async function prepareSlackMessage(params) {
 		storePath,
 		sessionKey
 	});
-	const conversationLink = resolveSlackConversationLink({
-		channelId: message.channel,
-		teamId: opts.eventScope?.teamId ?? ctx.teamId,
-		slackApiUrl: slackClient.slackApiUrl,
-		existingLink: sessionEntry?.conversationLink
-	});
 	const previousTimestamp = sessionEntry?.updatedAt;
 	const excludedMessageIds = new Set(opts.sourceMessageIds);
 	if (message.ts) excludedMessageIds.add(message.ts);
@@ -4348,8 +4271,7 @@ async function prepareSlackMessage(params) {
 			spaceId: opts.eventScope?.teamId || ctx.teamId || void 0,
 			threadId: boundMessageThreadId,
 			nativeChannelId: message.channel,
-			avatar: conversationAvatar,
-			link: conversationLink
+			avatar: conversationAvatar
 		},
 		route: {
 			...route,