@openclaw/slack 2026.10.10 → 2026.11.5-beta.1

package/dist/.setup/{pipeline.runtime-CIFVL0kf.mjs → pipeline.runtime-C4ELxaRU.mjs}

@@ -1,16 +1,17 @@
 import { n as __reExport, t as __exportAll } from "./rolldown-runtime-nwUcYXjP.mjs";
-import { f as resolveSlackReplyToMode, o as resolveDefaultSlackAccountId } from "./accounts-CEgdyqoW.mjs";
-import { n as formatSlackTarget } from "./target-parsing-0pRZtahO.mjs";
-import { D as buildSlackCompleteBlocksFallbackText, E as buildSlackBlocksFallbackText, F as truncateSlackTextByUtf8Bytes, H as SLACK_SESSION_LINK_ACTION_ID, M as SLACK_TEXT_LIMIT, N as countSlackTextUtf8Bytes, P as truncateSlackText, Q as normalizeSlackOutboundText, b as hasSlackNativeDataBlock, k as SLACK_EDIT_TEXT_MAX_BYTES, l as qualifySlackRoutePeerId, st as escapeSlackMrkdwn } from "./session-status-CHkEn3HM.mjs";
-import { M as resolveSlackUserAllowed, O as normalizeSlackAllowOwnerEntry, b as writeLruMapEntry, o as formatSlackError, v as pruneExpiredMapEntries, y as readLruMapEntry } from "./probe-C5VWf3sz.mjs";
-import { a as prepareSlackReply, l as resolveSlackReplyRenderPlan, s as resolveSlackReplyBlocks } from "./reply-blocks-DOjiDr44.mjs";
+import { d as resolveSlackMarkdownOptions, o as resolveDefaultSlackAccountId, p as resolveSlackReplyToMode } from "./accounts-EaPP0fFY.mjs";
+import { n as formatSlackTarget } from "./target-parsing-DwYAP3ts.mjs";
+import { F as truncateSlackText, Gt as resolveSlackUserAllowed, I as truncateSlackTextByUtf8Bytes, O as hasSlackNativeDataBlock, P as countSlackTextUtf8Bytes, Tt as escapeSlackMrkdwn, U as SLACK_SESSION_LINK_ACTION_ID, Vt as normalizeSlackAllowOwnerEntry, _ as qualifySlackRoutePeerId, at as buildSlackCompleteBlocksFallbackText, it as buildSlackBlocksFallbackText, m as formatSlackError, vt as SLACK_EDIT_TEXT_MAX_BYTES, wt as normalizeSlackOutboundText, xt as SLACK_TEXT_LIMIT } from "./probe-B_Ax1vS1.mjs";
 import { n as resolveSlackReplyThreadTs } from "./thread-ts-47Au2-Yn.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-PF2cP6to.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-C5uXkmZV.mjs";
-import { n as resolveSlackChannelConfig } from "./policy-Bp1FvE6m.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-DsZUQtTM.mjs";
-import { a as emitSlackMessageSentHooks, i as sanitizeSlackMonitorReplyPayload, n as deliverReplies, t as createSlackReplyDeliveryPlan } from "./replies-7DRN46EL.mjs";
+import { c as resolveSlackReplyRenderPlan, i as prepareSlackReply, o as resolveSlackReplyBlocks } from "./reply-blocks-DyYYRrP_.mjs";
+import { d as getOrCreateWeakOwnerMap, m as writeLruMapEntry, p as readLruMapEntry } from "./cursor-pages-jVn3Vkfi.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-s3CcFO45.mjs";
+import { a as clearSlackThreadFailureNotice, c as hasSlackThreadParticipation, d as recordSlackThreadParticipation, h as buildSlackNativeDataDeliveryPlan, l as hasSlackThreadParticipationWithPersistence, m as hasSlackMessageIdentity, s as hasSlackThreadFailureNotice, t as sendMessageSlack, u as recordSlackThreadFailureNotice } from "./send-WJZ73VSf.mjs";
+import { n as resolveSlackChannelConfig } from "./policy-C6_DdlSf.mjs";
+import { C as resolveSlackChatType, E as stripSlackMentionsForCommandDetection, S as normalizeSlackChannelType, T as readSlackAssistantThreadContext, _ as appendSlackStream, b as stopSlackStream, c as registerSlackSessionRun, g as SlackStreamNotDeliveredError, h as resolveSlackEffectiveAllowFrom, l as resolveSlackThreadContext, m as resolveSlackCommandIngress, o as authorizeSlackDirectMessage, p as authorizeSlackBotRoomMessage, r as resolveSlackRoomContextHints, s as resolveSlackRoutingContext, u as trackSlackDraftMessage, v as markSlackStreamFallbackDelivered, w as buildSlackAssistantThreadMetadata, y as startSlackStream } from "./monitor-BD86SotB.mjs";
+import { a as emitSlackMessageSentHooks, i as sanitizeSlackMonitorReplyPayload, n as deliverReplies, t as createSlackReplyDeliveryPlan } from "./replies-Bq7n0gfM.mjs";
 import { asOptionalRecord, normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeOptionalString, readNonBlankString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { resolveMarkdownTableMode } from "openclaw/plugin-sdk/markdown-table-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";
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
@@ -18,10 +19,9 @@ import { danger, logVerbose, shouldLogVerbose } from "openclaw/plugin-sdk/runtim
 import { sanitizeAssistantVisibleText } from "openclaw/plugin-sdk/text-chunking";
 import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import { normalizeStringEntriesLower } from "openclaw/plugin-sdk/string-normalization-runtime";
-import { pruneMapToMaxSize } from "openclaw/plugin-sdk/collection-runtime";
-import { resolveMarkdownTableMode } from "openclaw/plugin-sdk/markdown-table-runtime";
+import { createStaleWhileRevalidateCache } from "openclaw/plugin-sdk/collection-runtime";
+import { asFiniteNumberInRange, parseStrictFiniteNumber, resolvePromptHistoryLimit } from "openclaw/plugin-sdk/number-runtime";
 import { buildTtsSupplementMediaPayload, getReplyPayloadTtsSupplement, isReplyPayloadNonTerminalToolErrorWarning, resolveSendableOutboundReplyParts } from "openclaw/plugin-sdk/reply-payload";
-import { asDateTimestampMs, asFiniteNumberInRange, parseStrictFiniteNumber, resolveExpiresAtMsFromDurationMs, resolvePromptHistoryLimit } from "openclaw/plugin-sdk/number-runtime";
 import { hash } from "node:crypto";
 import { resolveChannelImplicitMentions } from "openclaw/plugin-sdk/channel-ingress-runtime";
 import fs from "node:fs/promises";
@@ -32,10 +32,10 @@ import { mimeTypeFromFilePath, normalizeMimeType } from "openclaw/plugin-sdk/med
 import { ensureConfiguredBindingRouteReady, resolveConversationLabel } from "openclaw/plugin-sdk/conversation-runtime";
 import { mergePairLoopGuardConfig } from "openclaw/plugin-sdk/pair-loop-guard-runtime";
 import { getSessionEntryAsync, 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";
-import { buildChannelInboundEventContext, buildMentionRegexes, classifyChannelInboundEvent, dispatchChannelInboundTurn, formatInboundEnvelope, formatInboundMediaUnavailableText, hasVisibleInboundReplyDispatch, isGroupThreadRouteExclusive, matchesMentionWithExplicit, readAgentRunTerminalOutcome, resolveEnvelopeFormatOptions, resolveGroupThreadConfig, resolveGroupThreadMentionFacts, resolveInboundMentionDecision, resolveInboundReplyDispatchCounts, resolveUnmentionedGroupInboundPolicy, toInboundMediaFactsWithMetadata } from "openclaw/plugin-sdk/channel-inbound";
+import { resolveHumanDelayConfig } from "openclaw/plugin-sdk/agent-runtime";
+import { buildChannelInboundEventContext, buildMentionRegexes, classifyChannelInboundEvent, dispatchChannelInboundTurn, formatInboundEnvelope, formatInboundMediaUnavailableText, hasVisibleInboundReplyDispatch, isGroupThreadRouteExclusive, matchesMentionWithExplicit, readAgentRunTerminalOutcome, resolveEnvelopeFormatOptions, resolveGroupThreadConfig, resolveGroupThreadMentionFacts, resolveInboundMentionDecision, 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";
@@ -96,13 +96,6 @@ function resolveSlackNativeProgressTaskCards(entry, style) {
 }
 const SLACK_STREAM_RECIPIENT_TEAM_CACHE_MAX = 2e3;
 const slackStreamRecipientTeamCaches = /* @__PURE__ */ new WeakMap();
-function getSlackStreamRecipientTeamCache(client) {
-	const existing = slackStreamRecipientTeamCaches.get(client);
-	if (existing) return existing;
-	const cache = /* @__PURE__ */ new Map();
-	slackStreamRecipientTeamCaches.set(client, cache);
-	return cache;
-}
 function buildSlackEventDeliveryKey(params, preparedReply = prepareSlackReply(params.payload)) {
 	const reply = resolveSendableOutboundReplyParts(params.payload, { text: params.textOverride });
 	const renderPlan = preparedReply.resolvePreview(params.textOverride);
@@ -121,7 +114,7 @@ function buildSlackEventDeliveryKey(params, preparedReply = prepareSlackReply(pa
 }
 async function resolveSlackStreamRecipientTeamId(params) {
 	const cacheKey = params.fallbackTeamId && params.userId ? `${params.fallbackTeamId}:${params.userId}` : void 0;
-	const cache = cacheKey ? getSlackStreamRecipientTeamCache(params.client) : void 0;
+	const cache = cacheKey ? getOrCreateWeakOwnerMap(slackStreamRecipientTeamCaches, params.client) : void 0;
 	const cachedTeamId = cache && cacheKey ? readLruMapEntry(cache, cacheKey) : void 0;
 	if (cachedTeamId) return cachedTeamId;
 	if (params.userId) try {
@@ -144,8 +137,6 @@ const DEFAULT_THROTTLE_MS = 1e3;
 function createSlackDraftStream(params) {
 	const maxChars = Math.min(params.maxChars ?? 8e3, SLACK_TEXT_LIMIT);
 	const throttleMs = Math.max(250, params.throttleMs ?? DEFAULT_THROTTLE_MS);
-	const send = params.send ?? sendMessageSlack;
-	const remove = params.remove ?? deleteSlackMessage;
 	let streamMessage;
 	let untrackConversationBoundary;
 	let lastSentKey = "";
@@ -159,7 +150,7 @@ function createSlackDraftStream(params) {
 		streamMessage = void 0;
 		lastSentKey = "";
 	};
-	const editPreview = (message, update) => (params.edit ?? (update.textIsSlackMrkdwn ? editSlackRenderedMessage : editSlackMessage))(message.channelId, message.messageId, update.text, {
+	const editPreview = (message, update) => (update.textIsSlackMrkdwn ? editSlackRenderedMessage : editSlackMessage)(message.channelId, message.messageId, update.text, {
 		cfg: params.cfg,
 		token: params.token,
 		accountId: params.accountId,
@@ -206,7 +197,7 @@ function createSlackDraftStream(params) {
 				onInterveningMessage: () => forceNewMessage("human")
 			});
 			await lifecycle.createMessage(async () => {
-				const sent = await send(params.target, visibleUpdate.text, {
+				const sent = await sendMessageSlack(params.target, visibleUpdate.text, {
 					cfg: params.cfg,
 					token: params.token,
 					accountId: params.accountId,
@@ -251,7 +242,7 @@ function createSlackDraftStream(params) {
 		clearMessageId,
 		isValidMessageId: (value) => typeof value === "object" && value !== null,
 		deleteMessage: async (message) => {
-			if (!message.retained && !(preserveHumanReplies && message.detachedByHuman)) await remove(message.channelId, message.messageId, {
+			if (!message.retained && !(preserveHumanReplies && message.detachedByHuman)) await deleteSlackMessage(message.channelId, message.messageId, {
 				token: params.token,
 				accountId: params.accountId,
 				...params.eventScope ? { client: params.eventScope.client } : {}
@@ -299,7 +290,6 @@ function createSlackDraftStream(params) {
 		stopTrackingConversationBoundary();
 		return true;
 	};
-	params.log?.(`slack stream preview ready (maxChars=${maxChars}, throttleMs=${throttleMs})`);
 	return {
 		update,
 		flush: loop.flush,
@@ -371,12 +361,6 @@ const SLACK_PROGRESS_TASK_TITLE_MAX = 120;
 const SLACK_PROGRESS_PLAN_FALLBACK_TITLE = "Thinking";
 const SLACK_PROGRESS_LINE_DELTA_RE = /(?:^|\s)\+(\d+)\s+[−-](\d+)(?=\s|$)/u;
 const SLACK_ATTENTION_TASK_PREFIX = "openclaw-attention-";
-function buildSessionSources(links) {
-	return links.map((link) => ({
-		type: "url_source",
-		...link
-	}));
-}
 function field(text) {
 	return {
 		type: "mrkdwn",
@@ -435,10 +419,6 @@ function lineTaskTitle(line) {
 	if (fallback && fallback !== label) return compactTitle(lineDetailParts(line).length > 0 || line.status ? label : fallback);
 	return compactTitle(label);
 }
-function lineTaskDetails(line, maxLineChars) {
-	const detail = line.detail?.replace(SLACK_PROGRESS_LINE_DELTA_RE, "").replace(/\s+·\s*$/u, "").trim();
-	return detail && detail !== line.status?.trim() ? compactDetail(detail, maxLineChars) : void 0;
-}
 function lineTaskOutput(line) {
 	const match = line.detail ? SLACK_PROGRESS_LINE_DELTA_RE.exec(line.detail) : null;
 	if (match) return `+${match[1]} −${match[2]}`;
@@ -469,48 +449,39 @@ function resolveLineTaskIdentity(line, contentIdOccurrences) {
 	contentIdOccurrences.set(id, occurrence);
 	return `${id}_${occurrence}`;
 }
-function buildNativeTasks(params) {
+function formatProgressAttentionTitle(line, finalStatus) {
+	if (line.kind === "approval") return line.status === "requested" && finalStatus === void 0 ? compactTitle(`Approval required: ${line.detail || line.label}`) : void 0;
+	if (lineTaskStatus(line) !== "error") return;
+	const title = [...new Set([
+		line.label,
+		line.detail,
+		line.status
+	].filter(Boolean))].join(" — ");
+	return compactTitle(finalStatus === "complete" ? `Recovered: ${title}` : title);
+}
+function buildSlackProgressStreamChunks(params) {
+	const approvals = params.lines.filter((line) => line.kind === "approval");
+	const taskLines = params.summaryRow ? [] : params.lines.filter((line) => line.kind !== "approval");
 	const tasks = (params.plan ?? []).map((entry, index) => ({
 		id: `plan_step_${index + 1}`,
 		title: compactTitle(entry.step),
 		status: entry.status === "completed" ? "complete" : entry.status
 	}));
 	const maxLineChars = resolveMaxLineChars(params.maxLineChars, DEFAULT_SLACK_PROGRESS_TASK_DETAIL_MAX_CHARS);
-	const contentIdOccurrences = /* @__PURE__ */ new Map();
-	for (const line of params.lines) {
+	const taskContentIdOccurrences = /* @__PURE__ */ new Map();
+	for (const line of taskLines) {
 		const task = {
-			id: resolveLineTaskIdentity(line, contentIdOccurrences),
+			id: resolveLineTaskIdentity(line, taskContentIdOccurrences),
 			title: lineTaskTitle(line),
 			status: lineTaskStatus(line)
 		};
-		const details = lineTaskDetails(line, maxLineChars);
+		const detail = line.detail?.replace(SLACK_PROGRESS_LINE_DELTA_RE, "").replace(/\s+·\s*$/u, "").trim();
+		const details = detail && detail !== line.status?.trim() ? compactDetail(detail, maxLineChars) : void 0;
 		const output = lineTaskOutput(line);
 		if (details) task.details = details;
 		if (output) task.output = output;
 		tasks.push(task);
 	}
-	return tasks;
-}
-function formatProgressAttentionTitle(line, finalStatus) {
-	if (line.kind === "approval") return line.status === "requested" && finalStatus === void 0 ? compactTitle(`Approval required: ${line.detail || line.label}`) : void 0;
-	if (lineTaskStatus(line) !== "error") return;
-	const title = [...new Set([
-		line.label,
-		line.detail,
-		line.status
-	].filter(Boolean))].join(" — ");
-	return compactTitle(finalStatus === "complete" ? `Recovered: ${title}` : title);
-}
-function formatTaskDiffOutput(diffStat) {
-	return diffStat && (diffStat.added > 0 || diffStat.removed > 0) ? `+${diffStat.added} −${diffStat.removed}` : void 0;
-}
-function buildSlackProgressStreamChunks(params) {
-	const approvals = params.lines.filter((line) => line.kind === "approval");
-	const tasks = buildNativeTasks({
-		lines: params.summaryRow ? [] : params.lines.filter((line) => line.kind !== "approval"),
-		plan: params.plan,
-		maxLineChars: params.maxLineChars
-	});
 	const contentIdOccurrences = /* @__PURE__ */ new Map();
 	const attention = [];
 	for (const line of approvals) {
@@ -521,11 +492,11 @@ function buildSlackProgressStreamChunks(params) {
 			status: "pending"
 		});
 	}
-	const headline = params.title?.trim() || params.label?.trim();
+	const headline = params.title?.trim();
 	const summaryTitle = params.finalInProgressStatus === "error" ? "Failed" : params.finalInProgressStatus === "complete" || !params.summaryRow ? "Completed" : "Working";
 	const newest = tasks.at(-1);
 	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);
+	const diffOutput = params.diffStat && (params.diffStat.added > 0 || params.diffStat.removed > 0) ? `+${params.diffStat.added} −${params.diffStat.removed}` : void 0;
 	if (tasks.length === 0 && (params.summaryRow || params.sessionLinks?.length || diffOutput)) tasks.push({
 		id: "openclaw_summary",
 		title: params.summaryRow ? compactTitle(title) : summaryTitle,
@@ -545,7 +516,10 @@ function buildSlackProgressStreamChunks(params) {
 		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);
+		if (index === finalTaskIndex && params.sessionLinks?.length) chunk.sources = params.sessionLinks.map((link) => ({
+			type: "url_source",
+			...link
+		}));
 		return chunk;
 	});
 	return [{
@@ -564,13 +538,6 @@ function joinRecentProgressRows(rows) {
 	}
 	return rendered.toReversed().join("\n");
 }
-function buildActivityText(lines, maxLineChars) {
-	return joinRecentProgressRows(lines.slice(-50).map((line) => {
-		if (line.kind === "item" && !line.toolName) return `_${renderProgressCardText(compactDetail(line.text, maxLineChars), "italic")}_`;
-		const detail = compactDetail(lineDetailParts(line).join(" · "), maxLineChars);
-		return escapeSlackMrkdwn(detail ? `${line.label} — ${detail}` : line.label);
-	}));
-}
 function buildSlackProgressCardBlocks(params) {
 	const maxLineChars = resolveMaxLineChars(params.maxLineChars, DEFAULT_SLACK_PROGRESS_DETAIL_MAX_CHARS);
 	const selected = selectPlanChecklistSteps(params.detailed ? params.plan ?? [] : [], { maxLines: 50 });
@@ -600,7 +567,11 @@ function buildSlackProgressCardBlocks(params) {
 	});
 	const sections = [
 		planLines.map((line) => renderProgressCardText(line)).join("\n"),
-		buildActivityText(lines.filter((line) => line.kind !== "approval" && lineTaskStatus(line) !== "error"), maxLineChars),
+		joinRecentProgressRows(lines.filter((line) => line.kind !== "approval" && lineTaskStatus(line) !== "error").slice(-50).map((line) => {
+			if (line.kind === "item" && !line.toolName) return `_${renderProgressCardText(compactDetail(line.text, maxLineChars), "italic")}_`;
+			const detail = compactDetail(lineDetailParts(line).join(" · "), maxLineChars);
+			return escapeSlackMrkdwn(detail ? `${line.label} — ${detail}` : line.label);
+		})),
 		joinRecentProgressRows(attention)
 	];
 	const title = params.title?.trim();
@@ -680,6 +651,13 @@ function reconcileSlackNativeTaskChunks(params) {
 	const nextTasks = /* @__PURE__ */ new Map();
 	let planTitle = params.previous.planTitle;
 	const emitted = [];
+	if (!params.chunks?.length && planTitle && planTitle !== SLACK_PROGRESS_PLAN_FALLBACK_TITLE) {
+		planTitle = SLACK_PROGRESS_PLAN_FALLBACK_TITLE;
+		emitted.push({
+			type: "plan_update",
+			title: planTitle
+		});
+	}
 	for (const chunk of params.chunks ?? []) {
 		if (chunk.type === "plan_update") {
 			if (chunk.title !== planTitle) {
@@ -789,12 +767,6 @@ function isSlackProgressTitleText(text, snapshot, explicitTitle) {
 	return title.length > 0 && title.includes(candidate);
 }
 // extensions/slack/src/monitor/message-handler/preview-finalize.ts
-function buildExpectedSlackEditText(params) {
-	const trimmedText = params.text.trim();
-	if (trimmedText) return normalizeSlackOutboundText(trimmedText);
-	if (params.blocks?.length) return normalizeSlackOutboundText(buildSlackBlocksFallbackText(params.blocks));
-	return " ";
-}
 function blocksMatch(expected, actual) {
 	if (!expected?.length) return !actual?.length;
 	if (!actual?.length) {
@@ -814,45 +786,6 @@ function blocksMatch(expected, actual) {
 		return false;
 	}
 }
-async function readSlackMessageAfterEditError(params) {
-	const query = {
-		token: params.token,
-		channel: params.channelId,
-		latest: params.messageId,
-		oldest: params.messageId,
-		inclusive: true,
-		limit: 1
-	};
-	const result = params.threadTs ? await params.client.conversations.replies({
-		...query,
-		ts: params.threadTs
-	}) : await params.client.conversations.history(query);
-	const message = params.threadTs ? result.messages?.find((entry) => entry?.ts === params.messageId) : result.messages?.[0];
-	return message?.ts && message.ts === params.messageId ? message : null;
-}
-async function didSlackPreviewEditApplyAfterError(params) {
-	const readback = await readSlackMessageAfterEditError(params);
-	if (!readback) return false;
-	const expectedText = buildExpectedSlackEditText({
-		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;
-}
 async function finalizeSlackPreviewEdit(params) {
 	try {
 		await editSlackRenderedMessage(params.channelId, params.messageId, params.text, {
@@ -863,9 +796,40 @@ async function finalizeSlackPreviewEdit(params) {
 		});
 	} catch (err) {
 		try {
-			if (await didSlackPreviewEditApplyAfterError(params)) {
-				logVerbose(`slack: preview final edit response failed but readback matched message ${params.channelId}/${params.messageId}; suppressing duplicate fallback send`);
-				return;
+			const query = {
+				token: params.token,
+				channel: params.channelId,
+				latest: params.messageId,
+				oldest: params.messageId,
+				inclusive: true,
+				limit: 1
+			};
+			const result = params.threadTs ? await params.client.conversations.replies({
+				...query,
+				ts: params.threadTs
+			}) : await params.client.conversations.history(query);
+			const message = params.threadTs ? result.messages?.find((entry) => entry?.ts === params.messageId) : result.messages?.[0];
+			const readback = message?.ts && message.ts === params.messageId ? message : null;
+			if (readback) {
+				const trimmedText = params.text.trim();
+				const expectedText = trimmedText ? normalizeSlackOutboundText(trimmedText) : params.blocks?.length ? normalizeSlackOutboundText(buildSlackBlocksFallbackText(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 fallbackMessage of fallbackPlan.fallbackMessages) acceptedTexts.add(normalizeSlackOutboundText(fallbackMessage.text));
+				}
+				const actualText = normalizeSlackOutboundText((readback.text ?? "").trim());
+				if (params.blocks?.length ? acceptedTexts.has(actualText) && blocksMatch(params.blocks, readback.blocks) : actualText === expectedText) {
+					logVerbose(`slack: preview final edit response failed but readback matched message ${params.channelId}/${params.messageId}; suppressing duplicate fallback send`);
+					return;
+				}
 			}
 		} catch (readbackErr) {
 			logVerbose(`slack: preview final edit readback failed (${String(readbackErr)})`);
@@ -1041,7 +1005,7 @@ function createSlackNativeProgressTransport(params) {
 			const delivered = markDelivered(streamThreadTs);
 			return update.chunks?.length ? delivered : true;
 		} finally {
-			if (delivery.nativeProgressStreamStartPromise === startPromise) delivery.nativeProgressStreamStartPromise = null;
+			delivery.nativeProgressStreamStartPromise = null;
 		}
 	};
 	const append = async (update) => {
@@ -1072,7 +1036,6 @@ function createSlackProgressRuntime(runtimeParams) {
 		cfg,
 		token: ctx.botToken,
 		accountId: account.accountId,
-		conversationChannelId: message.channel,
 		eventScope: prepared.eventScope,
 		...!hasSlackCustomIdentity && slackIdentity ? { identity: slackIdentity } : {},
 		...slackMessageMetadata ? { metadata: slackMessageMetadata } : {},
@@ -1082,7 +1045,6 @@ function createSlackProgressRuntime(runtimeParams) {
 			if (ts) delivery.usedReplyThreadTs ??= ts;
 			return ts;
 		},
-		log: logVerbose,
 		warn: logVerbose
 	}) : void 0;
 	const isProgressMode = slackStreaming.mode === "progress";
@@ -1501,7 +1463,6 @@ function createSlackProgressRuntime(runtimeParams) {
 	return {
 		draftStream,
 		previewLifecycle,
-		isProgressMode,
 		useDraftProgressCard,
 		useNativeProgressStreaming,
 		progressDraftActive,
@@ -1693,9 +1654,7 @@ async function createSlackDispatchSetup(prepared) {
 						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 (reportFailure && !restored) runtime.error?.("Slack session status could not return to active after processing. Enable verbose logging to inspect the Slack API failure.");
 				}
 				if (didAddTypingReaction && typingReaction && message.ts) {
 					didAddTypingReaction = false;
@@ -1759,6 +1718,10 @@ async function createSlackDispatchSetup(prepared) {
 function createSlackStreamingDeliveryRuntime(setup) {
 	const { isThreadReply, messageSentHookContext, messageSentHookTarget, prepared, replyDeliveryMode, replyPlan, runtime, slackClient, slackClientOptions, slackIdentity, slackStreamFallbackTeamId } = setup;
 	const { account, ctx, forcedReplyThreadTs, message, slackMessageMetadata } = prepared;
+	const markdownOptions = resolveSlackMarkdownOptions({
+		cfg: ctx.cfg,
+		accountId: account.accountId
+	});
 	const state = {
 		streamSession: null,
 		streamBoundary: null,
@@ -1839,7 +1802,7 @@ function createSlackStreamingDeliveryRuntime(setup) {
 		if (key) deliveredKeys.add(key);
 	};
 	const markPreviewPayloadDelivered = (params) => {
-		const preparedReply = prepareSlackReply(params.payload);
+		const preparedReply = prepareSlackReply(params.payload, markdownOptions);
 		markDelivered(buildSlackEventDeliveryKey(params, preparedReply));
 		const nextThreadTs = replyPlan.peekThreadTs();
 		if (nextThreadTs !== params.threadTs) markDelivered(buildSlackEventDeliveryKey({
@@ -1880,7 +1843,7 @@ function createSlackStreamingDeliveryRuntime(setup) {
 		}
 		const fallbackText = fallbackError.pendingText.trim();
 		if (!fallbackText) return;
-		const sent = await deliverPreparedReply(prepareSlackReply({ text: fallbackText }), session.threadTs, true);
+		const sent = await deliverPreparedReply(prepareSlackReply({ text: fallbackText }, markdownOptions), session.threadTs, true);
 		if (!sent?.receipt.platformMessageIds.length) return;
 		markSlackStreamFallbackDelivered(session);
 		if (!session.stopped) try {
@@ -1938,16 +1901,13 @@ function createSlackStreamingDeliveryRuntime(setup) {
 		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 preparedReply = prepareSlackReply(params.payload, markdownOptions);
 		const deliveryKey = buildSlackEventDeliveryKey({
 			kind: params.kind,
 			payload: params.payload,
 			threadTs: deliveryReplyThreadTs
 		}, preparedReply);
-		if (deliveryKey && deliveredKeys.has(deliveryKey)) {
-			logVerbose("slack: suppressed duplicate normal delivery within the same turn");
-			return { visibleReplySent: false };
-		}
+		if (deliveryKey && deliveredKeys.has(deliveryKey)) return { visibleReplySent: false };
 		const sent = await deliverPreparedReply(preparedReply, deliveryReplyThreadTs);
 		if (!sent?.receipt.platformMessageIds.length) return { visibleReplySent: false };
 		state.observedReplyDelivery = true;
@@ -1969,9 +1929,16 @@ function createSlackStreamingDeliveryRuntime(setup) {
 	};
 	const isStreamingEligible = (payload, options) => {
 		const reply = resolveSendableOutboundReplyParts(payload);
-		const renderPlan = resolveSlackReplyRenderPlan(payload);
+		const renderPlan = resolveSlackReplyRenderPlan(payload, payload.text, markdownOptions);
 		const plannedBlocks = renderPlan.mode === "single" ? renderPlan.blocks : renderPlan.blockPart?.blocks;
-		return !state.streamFailed && !reply.hasMedia && renderPlan.mode !== "split" && !renderPlan.textIsSlackPlainText && !plannedBlocks?.length && !resolveSlackReplyBlocks(payload)?.length && reply.hasText && (!options?.maxTextBytes || countSlackTextUtf8Bytes(reply.trimmedText) <= options.maxTextBytes);
+		const previewThreadTs = state.streamSession?.threadTs ?? state.interruptedThreadTs ?? state.nativeProgressStreamThreadTs;
+		const finalThreadTs = resolveSlackReplyThreadTs({
+			replyToMode: replyDeliveryMode,
+			replyToId: payload.replyToId,
+			threadId: previewThreadTs,
+			replyToCurrent: payload.replyToCurrent
+		});
+		return !state.streamFailed && (!previewThreadTs || finalThreadTs === previewThreadTs) && !reply.hasMedia && renderPlan.mode !== "split" && !renderPlan.textIsSlackPlainText && !plannedBlocks?.length && !resolveSlackReplyBlocks(payload)?.length && reply.hasText && (!options?.maxTextBytes || countSlackTextUtf8Bytes(reply.trimmedText) <= options.maxTextBytes);
 	};
 	const deliverWithStreaming = async (params) => {
 		if (state.streamSession?.stoppedBySlack) return { visibleReplySent: false };
@@ -1984,7 +1951,12 @@ function createSlackStreamingDeliveryRuntime(setup) {
 		await rotateInterruptedStream();
 		if (state.streamSession?.stoppedBySlack) return { visibleReplySent: false };
 		let session = state.streamSession;
-		const threadTs = session?.threadTs ?? state.interruptedThreadTs ?? replyPlan.nextThreadTs();
+		const threadTs = resolveSlackReplyThreadTs({
+			replyToMode: replyDeliveryMode,
+			replyToId: params.payload.replyToId,
+			threadId: session?.threadTs ?? state.interruptedThreadTs ?? replyPlan.nextThreadTs(),
+			replyToCurrent: params.payload.replyToCurrent
+		});
 		if (state.streamFailed || !threadTs) {
 			state.streamFailed = true;
 			return await deliverNormally({
@@ -1999,11 +1971,8 @@ function createSlackStreamingDeliveryRuntime(setup) {
 			...params,
 			threadTs,
 			textOverride: text
-		});
-		if (deliveryKey && deliveredKeys.has(deliveryKey)) {
-			logVerbose("slack-stream: suppressed duplicate reply payload");
-			return { visibleReplySent: false };
-		}
+		}, prepareSlackReply(params.payload, markdownOptions));
+		if (deliveryKey && deliveredKeys.has(deliveryKey)) return { visibleReplySent: false };
 		let messageId;
 		let fallbackDelivery;
 		try {
@@ -2084,6 +2053,74 @@ function createSlackStreamingDeliveryRuntime(setup) {
 		resetDeliveryTracker: () => deliveredKeys.clear()
 	});
 }
+// extensions/slack/src/monitor/message-handler/failure-notice.ts
+/** One outage policy for immediate replies and later origin-routed queue drains. */
+function createSlackFailureNoticePolicy(params, hasVisibleReply) {
+	const { context, accountId, channelId, failureNoticeThreadTs, failureNoticeTeamId, statusThreadTs } = params;
+	let sawTerminalFailurePayload = false;
+	let pendingFailureNotice;
+	const filterPassiveThreadFailure = (payload) => {
+		if (payload.isError !== true || context.ChatType !== "channel" || isReplyPayloadNonTerminalToolErrorWarning(payload)) return payload;
+		sawTerminalFailurePayload = true;
+		if (hasVisibleReply()) return payload;
+		const explicitlyAddressed = context.ExplicitlyMentionedBot === true || context.MentionSource === "explicit_bot" || context.MentionSource === "subteam" || context.MentionSource === "mention_pattern" || context.MentionSource === "command_bypass" || context.CommandTurn?.kind !== void 0 && context.CommandTurn.kind !== "normal" && context.CommandTurn.authorized;
+		const noticeThreadTs = failureNoticeThreadTs ?? (explicitlyAddressed ? statusThreadTs : void 0);
+		const notice = {
+			accountId,
+			channelId,
+			...noticeThreadTs ? { threadTs: noticeThreadTs } : {},
+			failureText: payload.text ?? "",
+			...failureNoticeTeamId ? { teamId: failureNoticeTeamId } : {}
+		};
+		if (failureNoticeThreadTs && !explicitlyAddressed && context.MentionSource !== "implicit_thread" && !hasSlackThreadParticipation(notice.accountId, notice.channelId, failureNoticeThreadTs, failureNoticeTeamId)) {
+			logVerbose("slack: suppressed passive failure before thread participation");
+			return null;
+		}
+		if (!explicitlyAddressed && hasSlackThreadFailureNotice(notice)) {
+			logVerbose("slack: suppressed repeated passive channel or thread failure");
+			return null;
+		}
+		pendingFailureNotice = notice;
+		return payload;
+	};
+	return {
+		filter: filterPassiveThreadFailure,
+		recordDelivered(payload) {
+			if (pendingFailureNotice && (!payload || payload.isError === true && !isReplyPayloadNonTerminalToolErrorWarning(payload) && (payload.text ?? "") === pendingFailureNotice.failureText)) {
+				recordSlackThreadFailureNotice(pendingFailureNotice);
+				pendingFailureNotice = void 0;
+			}
+		},
+		complete() {
+			if (!sawTerminalFailurePayload && context.ChatType === "channel") clearSlackThreadFailureNotice({
+				accountId,
+				channelId,
+				...failureNoticeThreadTs ? { threadTs: failureNoticeThreadTs } : {},
+				...failureNoticeTeamId ? { teamId: failureNoticeTeamId } : {}
+			});
+		}
+	};
+}
+function createSlackQueuedFailureNoticePolicy(params, beginSessionRun) {
+	let visibleReplySent = false;
+	let policy = createSlackFailureNoticePolicy(params, () => visibleReplySent);
+	return {
+		begin() {
+			visibleReplySent = false;
+			policy = createSlackFailureNoticePolicy(params, () => visibleReplySent);
+			const release = beginSessionRun();
+			return (settlement) => {
+				if (settlement?.completed && !settlement.failed && !settlement.transportPending) policy.complete();
+				release();
+			};
+		},
+		shouldSuppressReply: (payload) => policy.filter(payload) === null,
+		onReplyDelivered(payload) {
+			policy.recordDelivered(payload);
+			visibleReplySent = true;
+		}
+	};
+}
 // extensions/slack/src/monitor/message-handler/dispatch.ts
 function formatSlackGroupThreadReply(text, participant) {
 	return `**${participant.name.replace(/[\\`*_{}[\]()<>#!|]/g, "\\$&").replace(/\s+/g, " ")}**\n${text}`;
@@ -2109,7 +2146,7 @@ async function dispatchPreparedSlackMessage(prepared) {
 		},
 		onSettled: () => {
 			releaseDeferred?.();
-			upstreamLifecycle.onSettled?.();
+			return upstreamLifecycle.onSettled?.();
 		}
 	};
 	const release = beginSessionRun();
@@ -2118,6 +2155,10 @@ async function dispatchPreparedSlackMessage(prepared) {
 async function dispatchSlackMessageWithSetup(setup, beginSessionRun, turnAdoptionLifecycle) {
 	const { prepared } = setup;
 	const { account, ctx, message, route } = prepared;
+	const markdownOptions = resolveSlackMarkdownOptions({
+		cfg: ctx.cfg,
+		accountId: account.accountId
+	});
 	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);
@@ -2129,41 +2170,22 @@ async function dispatchSlackMessageWithSetup(setup, beginSessionRun, turnAdoptio
 	let turnCommentaryVisible = false;
 	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;
-	let pendingFailureNotice;
-	const filterPassiveThreadFailure = (payload) => {
-		if (payload.isError !== true || prepared.ctxPayload.ChatType !== "channel" || isReplyPayloadNonTerminalToolErrorWarning(payload)) return payload;
-		sawTerminalFailurePayload = true;
-		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 = {
-			accountId: account.accountId,
-			channelId: message.channel,
-			...noticeThreadTs ? { threadTs: noticeThreadTs } : {},
-			failureText: payload.text ?? "",
-			...failureNoticeTeamId ? { teamId: failureNoticeTeamId } : {}
-		};
-		if (failureNoticeThreadTs && !explicitlyAddressed && prepared.ctxPayload.MentionSource !== "implicit_thread" && !hasSlackThreadParticipation(notice.accountId, notice.channelId, failureNoticeThreadTs, failureNoticeTeamId)) {
-			logVerbose("slack: suppressed passive failure before thread participation");
-			return null;
-		}
-		if (!explicitlyAddressed && hasSlackThreadFailureNotice(notice)) {
-			logVerbose("slack: suppressed repeated passive channel or thread failure");
-			return null;
-		}
-		pendingFailureNotice = notice;
-		return payload;
+	const failurePolicyParams = {
+		context: prepared.ctxPayload,
+		accountId: account.accountId,
+		channelId: message.channel,
+		failureNoticeThreadTs: message.thread_ts,
+		failureNoticeTeamId: prepared.eventScope?.teamId,
+		statusThreadTs
 	};
+	const failurePolicy = createSlackFailureNoticePolicy(failurePolicyParams, () => delivery.observedReplyDelivery || previewLifecycle.previewFinalized);
 	const deliverSlackPayload = async (incomingPayload, info) => {
 		let payload = incomingPayload;
 		if (info.participant && (payload.text || payload.mediaUrl || payload.mediaUrls?.length)) payload = {
 			...payload,
 			text: formatSlackGroupThreadReply(payload.text ?? "", info.participant)
 		};
-		if (info.kind === "final" && slackStreaming.mode === "progress" && progress.isProgressMode) {
+		if (info.kind === "final" && slackStreaming.mode === "progress") {
 			const supplement = getReplyPayloadTtsSupplement(payload);
 			const finalPayload = !progress.useDraftProgressCard && !progress.useNativeProgressStreaming && supplement && !supplement.visibleTextAlreadyDelivered && !payload.text?.trim() ? {
 				...payload,
@@ -2203,15 +2225,11 @@ async function dispatchSlackMessageWithSetup(setup, beginSessionRun, turnAdoptio
 		const reply = resolveSendableOutboundReplyParts(payload);
 		const ttsSupplement = getReplyPayloadTtsSupplement(payload);
 		const replySourceText = payload.text ?? ttsSupplement?.spokenText;
-		const replyRenderPlan = resolveSlackReplyRenderPlan(payload, replySourceText);
+		const replyRenderPlan = resolveSlackReplyRenderPlan(payload, replySourceText, markdownOptions);
 		const slackBlocks = replyRenderPlan.mode === "single" ? replyRenderPlan.blocks : replyRenderPlan.blockPart?.blocks;
 		const requiresSeparateFallbackDelivery = replyRenderPlan.mode === "split" || replyRenderPlan.textIsSlackPlainText === true;
 		const trimmedFinalText = replyRenderPlan.mode === "single" ? replyRenderPlan.text.trim() : replyRenderPlan.fallbackText.trim();
-		const previewFinalText = replyRenderPlan.mode === "single" && replyRenderPlan.textIsSlackMrkdwn ? trimmedFinalText : normalizeSlackOutboundText((replySourceText ?? "").trim(), { tableMode: resolveMarkdownTableMode({
-			cfg,
-			channel: "slack",
-			accountId: account.accountId
-		}) });
+		const previewFinalText = replyRenderPlan.mode === "single" && replyRenderPlan.textIsSlackMrkdwn ? trimmedFinalText : normalizeSlackOutboundText((replySourceText ?? "").trim(), markdownOptions);
 		const previewFinalTextFitsEdit = countSlackTextUtf8Bytes(previewFinalText) <= SLACK_EDIT_TEXT_MAX_BYTES;
 		const shouldRestoreTtsSupplementTextForPreviewFallback = Boolean(ttsSupplement) && ttsSupplement?.visibleTextAlreadyDelivered !== true && Boolean(draftStream) && !previewLifecycle.previewFinalized && !previewLifecycle.finalDelivered && previewStreamingEnabled && !payload.text?.trim();
 		let ttsPreviewFinalization;
@@ -2221,11 +2239,18 @@ async function dispatchSlackMessageWithSetup(setup, beginSessionRun, turnAdoptio
 			isError: payload.isError === true,
 			adapter: {
 				buildFinalEdit: () => {
-					if (hasSlackCustomIdentity || !previewStreamingEnabled || reply.hasMedia && !ttsSupplement || payload.isError || requiresSeparateFallbackDelivery || !previewFinalTextFitsEdit || trimmedFinalText.length === 0 && !slackBlocks?.length) return;
+					const threadTs = delivery.usedReplyThreadTs ?? statusThreadTs;
+					const finalThreadTs = resolveSlackReplyThreadTs({
+						replyToMode: setup.replyDeliveryMode,
+						replyToId: payload.replyToId,
+						threadId: threadTs,
+						replyToCurrent: payload.replyToCurrent
+					});
+					if (hasSlackCustomIdentity || finalThreadTs !== threadTs || !previewStreamingEnabled || reply.hasMedia && !ttsSupplement || payload.isError || requiresSeparateFallbackDelivery || !previewFinalTextFitsEdit || trimmedFinalText.length === 0 && !slackBlocks?.length) return;
 					return {
 						text: previewFinalText,
 						blocks: slackBlocks,
-						threadTs: delivery.usedReplyThreadTs ?? statusThreadTs
+						threadTs
 					};
 				},
 				editFinal: async (preview, edit) => {
@@ -2320,7 +2345,7 @@ async function dispatchSlackMessageWithSetup(setup, beginSessionRun, turnAdoptio
 				...replyPipeline,
 				transformReplyPayload: (payload) => {
 					const transformed = replyPipeline.transformReplyPayload ? replyPipeline.transformReplyPayload(payload) : payload;
-					return transformed ? filterPassiveThreadFailure(transformed) : null;
+					return transformed ? failurePolicy.filter(transformed) : null;
 				},
 				humanDelay: resolveHumanDelayConfig(cfg, route.agentId)
 			},
@@ -2337,7 +2362,7 @@ async function dispatchSlackMessageWithSetup(setup, beginSessionRun, turnAdoptio
 			replyOptions: {
 				onVisibleWorkSessions: progress.onVisibleWorkSessions,
 				groupThreadReplyFormatter: formatSlackGroupThreadReply,
-				queuedDeliveryCorrelations: [{ begin: beginSessionRun }],
+				queuedDeliveryCorrelations: [createSlackQueuedFailureNoticePolicy(failurePolicyParams, beginSessionRun)],
 				...turnAdoptionLifecycle ? { turnAdoptionLifecycle } : {},
 				skillFilter: prepared.channelConfig?.skills,
 				sourceReplyDeliveryMode,
@@ -2381,7 +2406,7 @@ async function dispatchSlackMessageWithSetup(setup, beginSessionRun, turnAdoptio
 					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);
+					return progress.preambleOnlyProgress && payload.kind !== "preamble" && payload.kind !== "model-wait" ? await progress.progressDraft.noteActivity() : await progress.progressDraft.pushItemEvent(payload);
 				},
 				onPlanUpdate: async (payload) => {
 					if (payload.phase !== "update") return false;
@@ -2395,12 +2420,7 @@ async function dispatchSlackMessageWithSetup(setup, beginSessionRun, turnAdoptio
 			settledDispatchResult = result;
 			const agentRunOutcome = readAgentRunTerminalOutcome(result);
 			agentRunFailed = agentRunOutcome === "failed";
-			if (agentRunOutcome === "completed" && !sawTerminalFailurePayload && prepared.ctxPayload.ChatType === "channel") clearSlackThreadFailureNotice({
-				accountId: account.accountId,
-				channelId: message.channel,
-				...failureNoticeThreadTs ? { threadTs: failureNoticeThreadTs } : {},
-				...failureNoticeTeamId ? { teamId: failureNoticeTeamId } : {}
-			});
+			if (agentRunOutcome === "completed") failurePolicy.complete();
 		}
 	} catch (err) {
 		dispatchError ??= err;
@@ -2416,7 +2436,7 @@ async function dispatchSlackMessageWithSetup(setup, beginSessionRun, turnAdoptio
 		if (hasVisibleInboundReplyDispatch(settledDispatchResult)) await previewLifecycle.observeDelivery({ visibleReplySent: true });
 	}
 	await previewLifecycle.cleanup({ failed: Boolean(dispatchError || agentRunFailed) });
-	if (pendingFailureNotice && anyReplyDelivered) recordSlackThreadFailureNotice(pendingFailureNotice);
+	if (anyReplyDelivered) failurePolicy.recordDelivered();
 	if (dispatchError || agentRunFailed) await progress.finalizeDraftProgressCard("error", { postIfMissing: !anyReplyDelivered });
 	await progress.dropDetachedProgressCards();
 	if (statusReactionsEnabled) {
@@ -2436,11 +2456,6 @@ async function dispatchSlackMessageWithSetup(setup, beginSessionRun, turnAdoptio
 	if (dispatchError) throw toErrorObject(dispatchError, "Slack dispatch failed");
 	if (!anyReplyDelivered && !previewLifecycle.previewFinalized && !(agentRunFailed && progress.useDraftProgressCard)) {
 		if (progress.useDraftProgressCard) await draftStream?.clear();
-		return;
-	}
-	if (shouldLogVerbose()) {
-		const finalCount = resolveInboundReplyDispatchCounts(settledDispatchResult).final;
-		logVerbose(`slack: delivered ${finalCount} repl${finalCount === 1 ? "y" : "ies"} to ${prepared.replyTarget}`);
 	}
 }
 // extensions/slack/src/agent-context.ts
@@ -2482,13 +2497,12 @@ function normalizeSlackAppContextEntities(value) {
 	});
 }
 // extensions/slack/src/monitor/thread.ts
-const THREAD_STARTER_CACHE = /* @__PURE__ */ new Map();
-const THREAD_STARTER_CACHE_TTL_MS = 216e5;
-const THREAD_STARTER_CACHE_MAX = 2e3;
-function evictThreadStarterCache() {
-	pruneExpiredMapEntries(THREAD_STARTER_CACHE, Date.now());
-	pruneMapToMaxSize(THREAD_STARTER_CACHE, THREAD_STARTER_CACHE_MAX);
-}
+const threadStarterCache = createStaleWhileRevalidateCache({
+	maxEntries: 2e3,
+	maxPending: Number.POSITIVE_INFINITY,
+	ttlMs: 216e5,
+	cacheable: (starter) => starter !== null
+});
 function formatSlackFilePlaceholder(files) {
 	return `[attached: ${formatSlackFileReferenceList(files)}]`;
 }
@@ -2523,40 +2537,35 @@ function resolveSlackMessageText(message) {
 	}, { preserveMessageTextWhitespace: true });
 }
 async function resolveSlackThreadStarter(params) {
-	evictThreadStarterCache();
 	const cacheKey = JSON.stringify([
 		params.workspaceScope.accountId,
 		params.workspaceScope.teamId,
 		params.channelId,
 		params.threadTs
 	]);
-	const cached = THREAD_STARTER_CACHE.get(cacheKey);
-	if (cached && !params.refresh) return cached.value;
-	if (params.refresh) THREAD_STARTER_CACHE.delete(cacheKey);
 	try {
-		const message = (await params.client.conversations.replies({
-			channel: params.channelId,
-			ts: params.threadTs,
-			limit: 1,
-			inclusive: true
-		}))?.messages?.[0];
-		const text = message ? resolveSlackMessageText(message) : void 0;
-		const files = message?.files?.length ? message.files : void 0;
-		if (!message || !text && !files) return null;
-		const starter = {
-			text: text || formatSlackFilePlaceholder(files),
-			userId: message.user,
-			botId: message.bot_id,
-			ts: message.ts,
-			files
-		};
-		THREAD_STARTER_CACHE.delete(cacheKey);
-		THREAD_STARTER_CACHE.set(cacheKey, {
-			value: starter,
-			expiresAt: Date.now() + THREAD_STARTER_CACHE_TTL_MS
+		const { value } = await threadStarterCache.read(cacheKey, async () => {
+			const message = (await params.client.conversations.replies({
+				channel: params.channelId,
+				ts: params.threadTs,
+				limit: 1,
+				inclusive: true
+			}))?.messages?.[0];
+			const text = message ? resolveSlackMessageText(message) : void 0;
+			const files = message?.files?.length ? message.files : void 0;
+			if (!message || !text && !files) return null;
+			return {
+				text: text || formatSlackFilePlaceholder(files),
+				userId: message.user,
+				botId: message.bot_id,
+				ts: message.ts,
+				files
+			};
+		}, {
+			allowStale: false,
+			refresh: params.refresh
 		});
-		evictThreadStarterCache();
-		return starter;
+		return value;
 	} catch (err) {
 		logVerbose(`slack thread starter fetch failed channel=${params.channelId} ts=${params.threadTs}: ${formatErrorMessage(err)}`);
 		return null;
@@ -2610,8 +2619,7 @@ async function resolveSlackThreadHistory(params) {
 				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;
+			cursor = normalizeOptionalString(response.response_metadata?.next_cursor);
 			if (response.has_more && !cursor) {
 				params.onOmission?.("Slack returned an incomplete thread page without a cursor");
 				return [];
@@ -2660,7 +2668,7 @@ async function resolveSlackChannelHistory(params) {
 		cursor = response.response_metadata?.next_cursor?.trim() || void 0;
 		if (!cursor || scanned >= params.limit) break;
 	}
-	return messages.slice(0, params.limit).toReversed();
+	return messages.slice(0, params.limit).reverse();
 }
 // extensions/slack/src/monitor/message-handler/preflight-audio.ts
 function isSlackAudioFile(file) {
@@ -2710,7 +2718,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-PF2cP6to.mjs").then((n) => n._));
+const loadSlackMediaModule$2 = createLazyRuntimeModule(() => import("./actions-s3CcFO45.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)`;
@@ -2731,7 +2739,6 @@ function collectUniqueSlackMentionIds(texts) {
 	const seen = /* @__PURE__ */ new Set();
 	for (const text of texts) {
 		if (!text) continue;
-		SLACK_USER_MENTION_RE$1.lastIndex = 0;
 		for (const match of text.matchAll(SLACK_USER_MENTION_RE$1)) {
 			const userId = match[1];
 			if (userId) seen.add(userId);
@@ -2741,35 +2748,24 @@ function collectUniqueSlackMentionIds(texts) {
 }
 function renderSlackUserMentions(text, renderedMentions) {
 	if (!text || renderedMentions.size === 0) return text;
-	SLACK_USER_MENTION_RE$1.lastIndex = 0;
 	return text.replace(SLACK_USER_MENTION_RE$1, (full, userId) => {
 		return renderedMentions.get(userId) ?? full;
 	});
 }
-function filterInheritedParentFiles(params) {
-	const { files, isThreadReply, threadStarter } = params;
-	if (!isThreadReply || !files?.length || !threadStarter?.files?.length) return files;
-	const starterFileIds = new Set(threadStarter.files.map((file) => file.id));
-	const filtered = files.filter((file) => !file.id || !starterFileIds.has(file.id));
-	if (filtered.length < files.length) logVerbose(`slack: filtered ${files.length - filtered.length} inherited parent file(s) from thread reply`);
-	return filtered.length > 0 ? filtered : void 0;
-}
 async function resolveSlackMessageContent(params) {
-	const ownFiles = filterInheritedParentFiles({
-		files: params.message.files,
-		isThreadReply: params.isThreadReply,
-		threadStarter: params.threadStarter
-	});
-	const attachmentContent = ownFiles?.length || params.message.attachments?.length ? await loadSlackMediaModule$1().then(({ resolveSlackAttachmentContent }) => resolveSlackAttachmentContent({
+	let ownFiles = params.message.files;
+	const { isThreadReply, threadStarter } = params;
+	if (isThreadReply && ownFiles?.length && threadStarter?.files?.length) {
+		const starterFileIds = new Set(threadStarter.files.map((file) => file.id));
+		const filtered = ownFiles.filter((file) => !file.id || !starterFileIds.has(file.id));
+		ownFiles = filtered.length > 0 ? filtered : void 0;
+	}
+	const attachmentContent = ownFiles?.length || params.message.attachments?.length ? await loadSlackMediaModule$2().then(({ resolveSlackAttachmentContent }) => resolveSlackAttachmentContent({
 		files: ownFiles,
 		attachments: params.message.attachments,
 		client: params.client,
 		token: params.botToken,
 		maxBytes: params.mediaMaxBytes,
-		readIdleTimeoutMs: params.mediaReadIdleTimeoutMs,
-		totalTimeoutMs: params.mediaTotalTimeoutMs,
-		abortSignal: params.abortSignal,
-		assertCurrent: params.assertCurrent,
 		preloadedMedia: params.preloadedMedia
 	})) : null;
 	const effectiveDirectMedia = attachmentContent?.media.length ? attachmentContent.media : null;
@@ -2824,7 +2820,7 @@ function resolveSlackDmHistoryLimit(params) {
 	return resolvePromptHistoryLimit(override ?? params.defaultLimit, 0);
 }
 async function resolveSlackDmHistoryContext(params) {
-	const maxMessages = Math.max(0, Math.floor(params.limit));
+	const maxMessages = params.limit;
 	if (maxMessages <= 0) return {
 		body: void 0,
 		inboundHistory: void 0
@@ -2845,7 +2841,7 @@ async function resolveSlackDmHistoryContext(params) {
 				message,
 				body
 			}] : [];
-		}).slice(0, maxMessages).toReversed();
+		}).slice(0, maxMessages).reverse();
 		if (messages.length === 0) return {
 			body: void 0,
 			inboundHistory: void 0
@@ -2903,6 +2899,7 @@ 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 loadSlackMediaModule$1 = createLazyRuntimeModule(() => import("./actions-s3CcFO45.mjs").then((n) => n._));
 async function resolveSlackRoomHistory(params) {
 	if (params.ctx.historyLimit <= 0 || !params.message.ts) return [];
 	const warnOmission = (reason) => {
@@ -2956,26 +2953,51 @@ async function resolveSlackRoomHistory(params) {
 				sender: user?.name ?? message.userId ?? `Bot (${message.botId ?? "unknown"})`
 			});
 		}
+		async function resolveSlackHistoryMedia(message, maxAttachments) {
+			const { ctx, eventScope, assertCurrent, abortSignal } = params;
+			const files = sliceSlackImageFileCandidates(message.files, maxAttachments);
+			const attachments = [];
+			let remaining = Math.max(0, maxAttachments - files.length);
+			if (remaining > 0 && message.attachments?.length) for (const attachment of message.attachments) {
+				if (attachment.is_share !== true) continue;
+				const hasImageUrl = Boolean(normalizeOptionalString(attachment.image_url));
+				const attachmentFiles = sliceSlackImageFileCandidates(attachment.files, remaining - (hasImageUrl ? 1 : 0));
+				if (!hasImageUrl && attachmentFiles.length === 0) continue;
+				attachments.push({
+					...attachment,
+					files: attachmentFiles
+				});
+				remaining -= (hasImageUrl ? 1 : 0) + attachmentFiles.length;
+				if (remaining <= 0) break;
+			}
+			if (files.length === 0 && attachments.length === 0) return {
+				media: [],
+				attempted: 0
+			};
+			const { resolveSlackAttachmentContent } = await loadSlackMediaModule$1();
+			const content = await resolveSlackAttachmentContent({
+				files,
+				attachments,
+				client: eventScope?.client ?? ctx.app.client,
+				token: ctx.botToken,
+				maxBytes: Math.min(ctx.mediaMaxBytes, SLACK_HISTORY_MEDIA_MAX_BYTES),
+				readIdleTimeoutMs: SLACK_HISTORY_MEDIA_IDLE_TIMEOUT_MS,
+				totalTimeoutMs: SLACK_HISTORY_MEDIA_TOTAL_TIMEOUT_MS,
+				assertCurrent,
+				abortSignal
+			});
+			return {
+				media: await toInboundMediaFactsWithMetadata(content?.media, {
+					kind: "image",
+					messageId: message.ts
+				}),
+				attempted: maxAttachments - remaining
+			};
+		}
 		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
-				}
-			}) : {
+			const { media, attempted } = mediaRemaining > 0 && (message.files?.length || message.attachments?.length) ? await resolveSlackHistoryMedia(message, mediaRemaining) : {
 				media: [],
 				attempted: 0
 			};
@@ -3002,57 +3024,6 @@ 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;
-}
-async function resolveSlackHistoryMedia(params) {
-	const files = sliceSlackImageFileCandidates(params.message.files, params.maxAttachments);
-	const attachments = sliceSlackHistoryAttachmentCandidates(params.message.attachments, Math.max(0, params.maxAttachments - files.length));
-	if (files.length === 0 && attachments.length === 0) return {
-		media: [],
-		attempted: 0
-	};
-	const attempted = files.length + attachments.reduce((count, attachment) => count + (normalizeOptionalString(attachment.image_url) ? 1 : 0) + (attachment.files?.length ?? 0), 0);
-	const content = await resolveSlackMessageContent({
-		message: {
-			...params.message,
-			files,
-			attachments
-		},
-		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
-	};
-}
 // extensions/slack/src/monitor/message-handler/prepare-session-presentation.ts
 function resolveSlackGroupSessionSubject(params) {
 	const channelName = normalizeOptionalString(params.channelName);
@@ -3061,7 +3032,7 @@ function resolveSlackGroupSessionSubject(params) {
 	return `Slack Channel (Workspace ID: ${params.workspaceId}, Channel ID: ${params.channelId})`;
 }
 // extensions/slack/src/monitor/message-handler/prepare-thread-context.ts
-const loadSlackMediaModule = createLazyRuntimeModule(() => import("./actions-PF2cP6to.mjs").then((n) => n._));
+const loadSlackMediaModule = createLazyRuntimeModule(() => import("./actions-s3CcFO45.mjs").then((n) => n._));
 const SLACK_THREAD_CONTEXT_USER_LOOKUP_CONCURRENCY = 4;
 function formatSlackThreadLabelSnippet(text) {
 	return truncateUtf16Safe(text.replace(/\s+/g, " "), 80);
@@ -3110,13 +3081,14 @@ async function resolveSlackThreadContextData(params) {
 	const isOutboundOnlyThreadSession = threadSessionFreshness !== void 0 && threadSessionFreshness.state !== "missing" && threadSessionFreshness.entry.lastInteractionAt === void 0 && threadSessionFreshness.entry.updatedAt !== 0;
 	const shouldSeedInitialThreadContext = Boolean(params.isThreadReply && params.threadTs && (threadSessionFreshness ? threadSessionFreshness.state !== "fresh" || isOutboundOnlyThreadSession : threadSessionPreviousTimestamp === void 0));
 	const shouldLoadInitialThreadHistory = shouldSeedInitialThreadContext || params.forceInitialHistory === true;
-	if (!params.isThreadReply || !params.threadTs) return {
+	const readThreadContextData = () => ({
 		threadStarterBody,
 		threadHistoryBody,
 		shouldSeedInitialThreadContext,
 		threadLabel,
 		threadStarterMedia
-	};
+	});
+	if (!params.isThreadReply || !params.threadTs) return readThreadContextData();
 	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?.();
@@ -3156,10 +3128,6 @@ async function resolveSlackThreadContextData(params) {
 				unavailableMediaCount: attachmentContent.unavailableMediaCount,
 				prependUnavailable: true
 			});
-			if (threadStarterMedia) {
-				const starterPlaceholders = threadStarterMedia.map((item) => item.placeholder).join(", ");
-				logVerbose(`slack: hydrated thread starter file ${starterPlaceholders} from root message`);
-			}
 		}
 	} else threadLabel = `Slack thread ${params.roomLabel}`;
 	const includeBotStarterAsRootContext = Boolean(starter?.text && starterIsCurrentBot && shouldSeedInitialThreadContext);
@@ -3168,7 +3136,6 @@ async function resolveSlackThreadContextData(params) {
 	else if (includeBotStarterAsRootContext) {
 		const snippet = formatSlackThreadLabelSnippet(starter?.text ?? "").trim();
 		threadLabel = `Slack thread ${params.roomLabel}${snippet ? ` (assistant root): ${snippet}` : ""}`;
-		logVerbose("slack: retained current-bot thread starter as assistant root context");
 	}
 	const threadInitialHistoryLimit = Math.min(params.account.config?.thread?.initialHistoryLimit ?? 20, params.historyLimit ?? Number.POSITIVE_INFINITY);
 	if (threadInitialHistoryLimit > 0 && shouldLoadInitialThreadHistory) {
@@ -3193,28 +3160,22 @@ async function resolveSlackThreadContextData(params) {
 				}, "Slack automatic thread history omitted");
 			}
 		});
-		if (historyOmitted) return {
-			threadStarterBody,
-			threadHistoryBody,
-			shouldSeedInitialThreadContext,
-			threadLabel,
-			threadStarterMedia
-		};
+		if (historyOmitted) return readThreadContextData();
 		const enrichedStarter = starter && threadStarterBody && threadStarterBody !== starter.text ? {
 			...starter,
 			text: threadStarterBody,
 			ts: currentBotRootTs
 		} : null;
-		const threadHistoryWithEnrichedRoot = enrichedStarter && !threadHistory.some((entry) => entry.ts === currentBotRootTs) ? [enrichedStarter, ...threadHistory.length >= threadInitialHistoryLimit ? threadHistory.slice(1) : threadHistory] : threadHistory;
-		const threadHistoryWithBotRoot = includeBotStarterAsRootContext && starter && !threadHistoryWithEnrichedRoot.some((entry) => entry.ts === currentBotRootTs) ? [{
+		const rootContext = enrichedStarter ?? (includeBotStarterAsRootContext && starter ? {
 			...starter,
 			ts: currentBotRootTs
-		}, ...threadHistoryWithEnrichedRoot] : threadHistoryWithEnrichedRoot;
-		if (threadHistoryWithBotRoot.length > 0) {
+		} : null);
+		const threadHistoryWithRoot = rootContext && !threadHistory.some((entry) => entry.ts === currentBotRootTs) ? [rootContext, ...enrichedStarter && threadHistory.length >= threadInitialHistoryLimit ? threadHistory.slice(1) : threadHistory] : threadHistory;
+		if (threadHistoryWithRoot.length > 0) {
 			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 resolveThreadUserMap(threadHistoryWithoutCurrentBot) : /* @__PURE__ */ new Map();
+			const threadHistoryWithoutCurrentBot = threadHistoryWithRoot.filter((entry) => !isCurrentBotAuthor(entry) || retainCurrentBotHistory || includeBotStarterAsRootContext && entry.ts === currentBotRootTs);
+			const omittedCurrentBotHistoryCount = threadHistoryWithRoot.length - threadHistoryWithoutCurrentBot.length;
+			const userMapForFilter = params.contextVisibilityMode !== "all" && params.allowNameMatching && params.allowFromLower.length > 0 ? await resolveThreadUserMap(threadHistoryWithoutCurrentBot) : void 0;
 			params.assertHistoryCurrent?.();
 			const { items: filteredThreadHistory, omitted: omittedHistoryCount } = params.contextVisibilityMode === "all" ? {
 				items: threadHistoryWithoutCurrentBot,
@@ -3225,7 +3186,7 @@ async function resolveSlackThreadContextData(params) {
 				kind: "thread",
 				isSenderAllowed: (historyMsg) => {
 					if (isCurrentBotAuthor(historyMsg)) return true;
-					const msgUser = historyMsg.userId ? userMapForFilter.get(historyMsg.userId) : null;
+					const msgUser = historyMsg.userId ? userMapForFilter?.get(historyMsg.userId) : null;
 					return resolveSlackUserAllowed({
 						allowList: params.allowFromLower,
 						teamId: params.eventScope?.teamId ?? params.ctx.teamId,
@@ -3235,7 +3196,7 @@ async function resolveSlackThreadContextData(params) {
 					});
 				}
 			});
-			const userMap = await resolveThreadUserMap(filteredThreadHistory);
+			const userMap = userMapForFilter ?? 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 = [];
@@ -3254,19 +3215,10 @@ async function resolveSlackThreadContextData(params) {
 					envelope: params.envelopeOptions
 				}));
 			}
-			if (historyParts.length > 0) {
-				threadHistoryBody = historyParts.join("\n\n");
-				logVerbose(`slack: populated thread history with ${filteredThreadHistory.length} messages for new session`);
-			}
+			if (historyParts.length > 0) threadHistoryBody = historyParts.join("\n\n");
 		}
 	}
-	return {
-		threadStarterBody,
-		threadHistoryBody,
-		shouldSeedInitialThreadContext,
-		threadLabel,
-		threadStarterMedia
-	};
+	return readThreadContextData();
 }
 // src/channels/mention-gating.ts
 function resolveBotThreadMentionPolicy(params) {
@@ -3333,53 +3285,46 @@ function collectSlackMentionIds(text, regex) {
 	}
 	return [...ids];
 }
-async function readSlackSubteamUsers(params) {
-	let bySubteam = subteamMemberCache.get(params.client);
-	if (!bySubteam) {
-		bySubteam = /* @__PURE__ */ new Map();
-		subteamMemberCache.set(params.client, bySubteam);
-	}
-	const cacheKey = `${normalizeSlackId(params.teamId) ?? ""}:${params.subteamId}`;
-	const cached = bySubteam.get(cacheKey);
-	const now = asDateTimestampMs(params.now);
-	if (cached) {
-		if (now !== void 0 && asDateTimestampMs(cached.expiresAt) !== void 0 && cached.expiresAt > now) return cached.users;
-		bySubteam.delete(cacheKey);
-	}
-	try {
-		const response = await params.client.usergroups.users.list({
-			usergroup: params.subteamId,
-			...params.teamId ? { team_id: params.teamId } : {}
-		});
-		if (!response.ok) {
-			params.log?.(`slack: failed to resolve user-group mention ${params.subteamId}: ${response.error ?? "unknown_error"}`);
-			return /* @__PURE__ */ new Set();
-		}
-		const users = new Set((response.users ?? []).map(normalizeSlackId).filter((userId) => userId !== void 0));
-		const expiresAt = resolveExpiresAtMsFromDurationMs(SUBTEAM_MEMBER_CACHE_TTL_MS, { nowMs: params.now });
-		if (expiresAt !== void 0) bySubteam.set(cacheKey, {
-			expiresAt,
-			users
-		});
-		return users;
-	} catch (err) {
-		params.log?.(`slack: failed to resolve user-group mention ${params.subteamId}: ${formatErrorMessage(err)}`);
-		return /* @__PURE__ */ new Set();
-	}
-}
 async function isSlackSubteamMentionForBot(params) {
 	const botUserId = normalizeSlackId(params.botUserId);
 	if (!botUserId) return false;
 	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({
-		client: params.client,
-		subteamId,
-		teamId: normalizeOptionalString(params.teamId),
-		now,
-		log: params.log
-	})).has(botUserId)) return true;
+	const now = Date.now();
+	for (const subteamId of subteamIds) {
+		const { client, log } = params;
+		const teamId = normalizeOptionalString(params.teamId);
+		const bySubteam = getOrCreateWeakOwnerMap(subteamMemberCache, client);
+		const cacheKey = `${normalizeSlackId(teamId) ?? ""}:${subteamId}`;
+		const cached = bySubteam.get(cacheKey);
+		if (cached) {
+			if (cached.expiresAt > now) {
+				if (cached.users.has(botUserId)) return true;
+				continue;
+			}
+			bySubteam.delete(cacheKey);
+		}
+		let users;
+		try {
+			const response = await client.usergroups.users.list({
+				usergroup: subteamId,
+				...teamId ? { team_id: teamId } : {}
+			});
+			if (!response.ok) {
+				log?.(`slack: failed to resolve user-group mention ${subteamId}: ${response.error ?? "unknown_error"}`);
+				continue;
+			}
+			users = new Set((response.users ?? []).map(normalizeSlackId).filter((userId) => userId !== void 0));
+			bySubteam.set(cacheKey, {
+				expiresAt: now + SUBTEAM_MEMBER_CACHE_TTL_MS,
+				users
+			});
+		} catch (err) {
+			log?.(`slack: failed to resolve user-group mention ${subteamId}: ${formatErrorMessage(err)}`);
+			continue;
+		}
+		if (users.has(botUserId)) return true;
+	}
 	return false;
 }
 // extensions/slack/src/monitor/message-handler/prepare.ts
@@ -3389,18 +3334,6 @@ const SLACK_USER_MENTION_RE = /<@([^>|]+)(?:\|[^>]+)?>/g;
 const SLACK_SUBTEAM_MENTION_RE = /<!subteam\^([^>|]+)(?:\|[^>]+)?>/g;
 const SLACK_SUBTEAM_MENTION_MARKER = "<!subteam^";
 const SLACK_CHANNEL_ACCESS_DOCS_URL = "https://docs.openclaw.ai/channels/slack#access-control-and-routing";
-function mergeSlackAssistantThreadContext(primary, fallback) {
-	if (!primary) return fallback;
-	if (!fallback) return primary;
-	return {
-		assistantChannelId: primary.assistantChannelId || fallback.assistantChannelId,
-		threadTs: primary.threadTs || fallback.threadTs,
-		userId: primary.userId ?? fallback.userId,
-		channelId: primary.channelId ?? fallback.channelId,
-		teamId: primary.teamId ?? fallback.teamId,
-		enterpriseId: primary.enterpriseId !== void 0 ? primary.enterpriseId : fallback.enterpriseId
-	};
-}
 function hasSlackAssistantThreadMetadata(context) {
 	return Boolean(context?.channelId || context?.teamId || context?.enterpriseId !== void 0);
 }
@@ -3414,7 +3347,6 @@ function resolveSlackMessageAssistantThreadContext(message) {
 	return {
 		assistantChannelId,
 		threadTs,
-		userId: normalizeOptionalString(thread.user_id) ?? message.user,
 		channelId: normalizeOptionalString(context?.channel_id),
 		teamId: normalizeOptionalString(context?.team_id),
 		enterpriseId: context?.enterprise_id === null ? null : normalizeOptionalString(context?.enterprise_id)
@@ -3428,8 +3360,7 @@ async function restoreSlackAssistantThreadContextFromMetadata(params) {
 		return await readSlackAssistantThreadContext({
 			client: params.eventScope?.client ?? params.ctx.app.client,
 			channelId: params.message.channel,
-			threadTs,
-			userId: params.message.user
+			threadTs
 		});
 	} catch (err) {
 		logVerbose(`slack assistant context restore failed channel=${params.message.channel} ts=${threadTs}: ${formatErrorMessage(err)}`);
@@ -3442,41 +3373,40 @@ function resolveCachedMentionRegexes(ctx, agentId, options) {
 		normalizeOptionalString(options?.conversationId ?? void 0),
 		options?.providerPolicy ? JSON.stringify(options.providerPolicy) : ""
 	].join("");
-	let byAgent = mentionRegexCache.get(ctx);
-	if (!byAgent) {
-		byAgent = /* @__PURE__ */ new Map();
-		mentionRegexCache.set(ctx, byAgent);
-	}
+	const byAgent = getOrCreateWeakOwnerMap(mentionRegexCache, ctx);
 	const cached = byAgent.get(key);
 	if (cached) return cached;
 	const built = buildMentionRegexes(ctx.cfg, agentId, options);
 	byAgent.set(key, built);
 	return built;
 }
-function collectSlackMentionMetadata(text) {
-	return {
-		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 prepareSlackMessage(params) {
+	const { ctx, account, message, opts } = params;
+	const drop = (reason, parentUserId) => {
+		ctx.logger.info({
+			provider: "slack",
+			accountId: account.accountId,
+			teamId: opts.eventScope?.teamId ?? ctx.teamId,
+			channelId: message.channel,
+			messageTs: message.ts,
+			source: opts.source,
+			reason,
+			...parentUserId ? { parentUserId } : {}
+		}, "Slack inbound event rejected during preparation");
+		return null;
+	};
+	const slackClient = opts.eventScope?.client ?? ctx.app.client;
+	const threadStarterWorkspaceScope = {
+		accountId: account.accountId,
+		teamId: opts.eventScope?.teamId ?? ctx.teamId
 	};
-}
-function resolveSlackMentionSource(params) {
-	if (params.explicitBotMention) return "explicit_bot";
-	if (params.explicitSubteamMention) return "subteam";
-	if (params.shouldBypassMention) return "command_bypass";
-	if (params.wasMentioned) return "mention_pattern";
-	if (params.matchedImplicitMentionKinds.length > 0) return "implicit_thread";
-	return "none";
-}
-async function resolveSlackConversationContext(params) {
-	const { ctx, account, message } = params;
 	const cfg = ctx.cfg;
+	const conversationEventScope = opts.eventScope;
 	let channelInfo = {};
 	let resolvedChannelType = normalizeSlackChannelType(message.channel_type, message.channel);
 	if (resolvedChannelType !== "im" && message.channel_type !== "im") {
-		channelInfo = await ctx.resolveChannelName(message.channel, params.eventScope);
-		resolvedChannelType = normalizeSlackChannelType(message.channel_type ?? channelInfo.type ?? ctx.recallSlackChannelType(message.channel, params.eventScope), message.channel);
+		channelInfo = await ctx.resolveChannelName(message.channel, conversationEventScope);
+		resolvedChannelType = normalizeSlackChannelType(message.channel_type ?? channelInfo.type ?? ctx.recallSlackChannelType(message.channel, conversationEventScope), message.channel);
 	}
 	const channelName = channelInfo.name;
 	const isDirectMessage = resolvedChannelType === "im";
@@ -3484,7 +3414,7 @@ async function resolveSlackConversationContext(params) {
 	const isRoom = resolvedChannelType === "channel" || resolvedChannelType === "group";
 	const isRoomish = isRoom || isGroupDm;
 	const channelConfig = isRoom ? resolveSlackChannelConfig({
-		teamId: params.eventScope?.teamId ?? ctx.teamId,
+		teamId: conversationEventScope?.teamId ?? ctx.teamId,
 		allowUnscoped: ctx.installationIdentity?.kind !== "enterprise",
 		channelId: message.channel,
 		channelName,
@@ -3494,22 +3424,19 @@ async function resolveSlackConversationContext(params) {
 		allowNameMatching: ctx.allowNameMatching
 	}) : null;
 	const allowBotsSetting = channelConfig?.allowBots ?? account.config?.allowBots ?? cfg.channels?.slack?.allowBots ?? true;
-	return {
-		channelInfo,
-		channelName,
-		resolvedChannelType,
-		isDirectMessage,
-		isGroupDm,
-		isRoom,
-		isRoomish,
-		channelConfig,
-		allowBotsMode: allowBotsSetting === "mentions" ? "mentions" : allowBotsSetting ? "all" : "off",
-		isBotMessage: Boolean(message.bot_id)
+	const allowBotsMode = allowBotsSetting === "mentions" ? "mentions" : allowBotsSetting ? "all" : "off";
+	const isBotMessage = Boolean(message.bot_id);
+	const messageText = message.text ?? "";
+	const mentionMetadata = {
+		mentionedUserIds: collectSlackMentionIds(messageText, SLACK_USER_MENTION_RE),
+		mentionedSubteamIds: collectSlackMentionIds(messageText, SLACK_SUBTEAM_MENTION_RE),
+		hasAnyMention: SLACK_ANY_MENTION_RE.test(messageText),
+		hasSubteamMention: messageText.includes(SLACK_SUBTEAM_MENTION_MARKER)
 	};
-}
-async function authorizeSlackInboundMessage(params) {
-	const { ctx, account, message, conversation, drop } = params;
-	const { isDirectMessage, channelName, resolvedChannelType, isBotMessage, allowBotsMode } = conversation;
+	const normalizedBotUserId = normalizeSlackId(ctx.botUserId);
+	const explicitBotMention = opts.source === "app_mention" || Boolean(normalizedBotUserId && mentionMetadata.mentionedUserIds.includes(normalizedBotUserId));
+	const authorizationEventScope = opts.eventScope;
+	const onVisibleDrop = opts.onVisibleDrop;
 	if (isBotMessage) {
 		if (ctx.botUserId && message.user === ctx.botUserId || ctx.botId && message.bot_id === ctx.botId) return null;
 		if (allowBotsMode === "off") return drop("bot-disabled");
@@ -3518,28 +3445,28 @@ async function authorizeSlackInboundMessage(params) {
 	const senderId = message.user ?? (isBotMessage ? message.bot_id : void 0);
 	if (!senderId) return drop("missing-sender");
 	if (!ctx.isChannelAllowed({
-		teamId: params.eventScope?.teamId ?? ctx.teamId,
+		teamId: authorizationEventScope?.teamId ?? ctx.teamId,
 		channelId: message.channel,
 		channelName,
 		channelType: resolvedChannelType
 	})) {
-		if (conversation.isRoom && ctx.groupPolicy === "allowlist" && params.explicitBotMention && !isBotMessage && message.user) {
+		if (isRoom && ctx.groupPolicy === "allowlist" && explicitBotMention && !isBotMessage && message.user) {
 			let subject = "This OpenClaw bot";
 			if (ctx.botUserId) try {
-				const botIdentity = await ctx.resolveUserName(ctx.botUserId, params.eventScope);
+				const botIdentity = await ctx.resolveUserName(ctx.botUserId, authorizationEventScope);
 				const botName = normalizeOptionalString(botIdentity?.name);
 				if (botName) subject = escapeSlackMrkdwn(botName);
 			} catch (error) {
 				logVerbose(`slack allowlist denial bot-name lookup failed: ${formatSlackError(error)}`);
 			}
 			try {
-				await (params.eventScope?.client ?? ctx.app.client).chat.postEphemeral({
+				await (authorizationEventScope?.client ?? ctx.app.client).chat.postEphemeral({
 					token: ctx.botToken,
 					channel: message.channel,
 					user: message.user,
 					text: `${subject} can’t reply here because this channel isn’t in its OpenClaw channel allowlist. Ask the OpenClaw owner to allow this channel. <${SLACK_CHANNEL_ACCESS_DOCS_URL}|Learn how to configure Slack channel access.>`
 				});
-				params.onVisibleDrop?.();
+				onVisibleDrop?.();
 			} catch (error) {
 				ctx.runtime.error?.(`slack allowlist denial notice failed for channel ${message.channel}: ${formatSlackError(error)}`);
 			}
@@ -3548,7 +3475,7 @@ async function authorizeSlackInboundMessage(params) {
 	}
 	const allowFromLower = await resolveSlackEffectiveAllowFrom(ctx, {
 		includePairingStore: isDirectMessage,
-		eventScope: params.eventScope
+		eventScope: authorizationEventScope
 	});
 	if (isDirectMessage) {
 		const directUserId = message.user;
@@ -3558,16 +3485,16 @@ async function authorizeSlackInboundMessage(params) {
 			ctx,
 			accountId: account.accountId,
 			senderId: directUserId,
-			eventScope: params.eventScope,
+			eventScope: authorizationEventScope,
 			allowFromLower,
-			resolveSenderName: (userId) => ctx.resolveUserName(userId, params.eventScope),
+			resolveSenderName: (userId) => ctx.resolveUserName(userId, authorizationEventScope),
 			sendPairingReply: async (text) => {
 				await sendMessageSlack(message.channel, text, {
 					cfg: ctx.cfg,
 					token: ctx.botToken,
-					client: params.eventScope?.client ?? ctx.app.client,
+					client: authorizationEventScope?.client ?? ctx.app.client,
 					accountId: account.accountId,
-					eventScope: params.eventScope
+					eventScope: authorizationEventScope
 				});
 			},
 			onDisabled: () => {
@@ -3579,54 +3506,6 @@ async function authorizeSlackInboundMessage(params) {
 			log: logVerbose
 		})) return drop(dropReason);
 	}
-	return {
-		senderId,
-		allowFromLower
-	};
-}
-async function prepareSlackMessage(params) {
-	const { ctx, account, message, opts } = params;
-	const drop = (reason, parentUserId) => {
-		ctx.logger.info({
-			provider: "slack",
-			accountId: account.accountId,
-			teamId: opts.eventScope?.teamId ?? ctx.teamId,
-			channelId: message.channel,
-			messageTs: message.ts,
-			source: opts.source,
-			reason,
-			...parentUserId ? { parentUserId } : {}
-		}, "Slack inbound event rejected during preparation");
-		return null;
-	};
-	const slackClient = opts.eventScope?.client ?? ctx.app.client;
-	const threadStarterWorkspaceScope = {
-		accountId: account.accountId,
-		teamId: opts.eventScope?.teamId ?? ctx.teamId
-	};
-	const cfg = ctx.cfg;
-	const conversation = await resolveSlackConversationContext({
-		ctx,
-		account,
-		message,
-		eventScope: opts.eventScope
-	});
-	const { channelInfo, channelName, isDirectMessage, isGroupDm, isRoom, isRoomish, channelConfig, allowBotsMode, isBotMessage } = conversation;
-	const messageText = message.text ?? "";
-	const mentionMetadata = collectSlackMentionMetadata(messageText);
-	const normalizedBotUserId = normalizeSlackId(ctx.botUserId);
-	const authorization = await authorizeSlackInboundMessage({
-		ctx,
-		account,
-		message,
-		conversation,
-		explicitBotMention: opts.source === "app_mention" || Boolean(normalizedBotUserId && mentionMetadata.mentionedUserIds.includes(normalizedBotUserId)),
-		eventScope: opts.eventScope,
-		onVisibleDrop: opts.onVisibleDrop,
-		drop
-	});
-	if (!authorization) return null;
-	const { senderId, allowFromLower } = authorization;
 	let resolvedSenderName = normalizeOptionalString(message.username);
 	const resolveSenderName = async () => {
 		if (resolvedSenderName) return resolvedSenderName;
@@ -3662,9 +3541,17 @@ async function prepareSlackMessage(params) {
 	});
 	const explicitlyMentioned = explicitlyMentionedBotUser || explicitlyMentionedBotSubteam || opts.source === "app_mention";
 	const channelRequireMention = channelConfig?.requireMention ?? ctx.defaultRequireMention ?? true;
-	const chatType = resolveSlackChatType(conversation.resolvedChannelType);
+	const chatType = resolveSlackChatType(resolvedChannelType);
 	const restoredAssistantThreadContext = await restoredAssistantThreadContextPromise;
-	const assistantThreadContext = mergeSlackAssistantThreadContext(messageAssistantThreadContext, cachedAssistantThreadContext ?? restoredAssistantThreadContext);
+	const primary = messageAssistantThreadContext;
+	const fallback = cachedAssistantThreadContext ?? restoredAssistantThreadContext;
+	const assistantThreadContext = !primary ? fallback : !fallback ? primary : {
+		assistantChannelId: primary.assistantChannelId || fallback.assistantChannelId,
+		threadTs: primary.threadTs || fallback.threadTs,
+		channelId: primary.channelId ?? fallback.channelId,
+		teamId: primary.teamId ?? fallback.teamId,
+		enterpriseId: primary.enterpriseId !== void 0 ? primary.enterpriseId : fallback.enterpriseId
+	};
 	const assistantThreadContextToCache = messageAssistantThreadContext || restoredAssistantThreadContext ? assistantThreadContext : void 0;
 	if (assistantThreadContextToCache) ctx.saveSlackAssistantThreadContext(assistantThreadContextToCache, opts.eventScope);
 	const canUseManagedView = isDirectMessage && !opts.eventScope && !assistantThreadContext;
@@ -3728,19 +3615,16 @@ async function prepareSlackMessage(params) {
 	let mentionRegexes = buildPolicyMentionRegexes(routing.route.agentId);
 	let wasMentioned = resolveWasMentioned(mentionRegexes);
 	const hasBoundSession = Boolean(routing.runtimeBoundSessionKey || routing.configuredBindingSessionKey);
-	const { configuredBinding, configuredBindingSessionKey } = routing;
+	const { configuredBinding } = routing;
 	const isAssistantThreadMessage = Boolean(isDirectMessage && messageAssistantThreadContext);
 	const forcedAssistantReplyThreadTs = Boolean(assistantThreadContext?.threadTs && (routing.isThreadReply || isAssistantThreadMessage || routing.replyToMode !== "off")) ? assistantThreadContext?.threadTs : void 0;
 	const forcedReplyThreadTs = agentViewThreadTs ?? forcedAssistantReplyThreadTs;
-	if (routing.runtimeBinding && shouldLogVerbose()) logVerbose(`slack: routed via bound conversation ${routing.runtimeBinding.conversation.conversationId} -> ${routing.runtimeBinding.targetSessionKey}`);
 	if (configuredBinding) {
 		const ensured = await ensureConfiguredBindingRouteReady({
 			cfg,
 			bindingResolution: configuredBinding
 		});
-		if (ensured.ok) {
-			if (shouldLogVerbose()) logVerbose(`slack: using configured ACP binding for ${configuredBinding.record.conversation.conversationId} -> ${configuredBindingSessionKey}`);
-		} else {
+		if (!ensured.ok) {
 			if (shouldLogVerbose()) logVerbose(`slack: configured ACP binding unavailable for ${configuredBinding.record.conversation.conversationId}: ${ensured.error}`);
 			return drop("configured-binding-unavailable");
 		}
@@ -3778,7 +3662,11 @@ async function prepareSlackMessage(params) {
 		ctx,
 		account,
 		message,
-		conversation,
+		conversation: {
+			isRoom,
+			isDirectMessage,
+			channelConfig
+		},
 		thread: routing,
 		wasMentioned,
 		teamId: opts.eventScope?.teamId,
@@ -3796,14 +3684,14 @@ async function prepareSlackMessage(params) {
 	const textForCommandDetection = stripSlackMentionsForCommandDetection(message.text ?? "");
 	const hasControlCommandInMessage = hasControlCommand(textForCommandDetection, cfg);
 	const hasAbortRequest = isAbortRequestText(textForCommandDetection);
-	const channelUsersAllowlistConfigured = isRoom && Array.isArray(channelConfig?.users) && channelConfig.users.length > 0;
+	const channelUsersAllowlistConfigured = isRoom && (channelConfig?.users?.length ?? 0) > 0;
 	const resolveMessageIngress = async (contextBinding, threadId) => await resolveSlackCommandIngress({
 		ctx,
 		teamId: opts.eventScope?.teamId ?? ctx.teamId,
 		senderId,
 		senderAuthentication: message.user ? opts.senderAuthentication : void 0,
 		senderName: senderNameForAuth,
-		channelType: conversation.resolvedChannelType ?? "channel",
+		channelType: resolvedChannelType ?? "channel",
 		channelId: message.channel,
 		threadId,
 		ownerAllowFromLower: allowFromLower,
@@ -3938,13 +3826,7 @@ async function prepareSlackMessage(params) {
 	const effectiveWasMentioned = mentionDecision.effectiveWasMentioned;
 	const shouldBypassMention = mentionDecision.shouldBypassMention;
 	const matchedImplicitMentionKinds = mentionDecision.matchedImplicitMentionKinds;
-	const mentionSource = resolveSlackMentionSource({
-		explicitBotMention: explicitlyMentionedBotUser || opts.source === "app_mention",
-		explicitSubteamMention: explicitlyMentionedBotSubteam,
-		matchedImplicitMentionKinds,
-		shouldBypassMention,
-		wasMentioned
-	});
+	const mentionSource = explicitlyMentionedBotUser || opts.source === "app_mention" ? "explicit_bot" : explicitlyMentionedBotSubteam ? "subteam" : shouldBypassMention ? "command_bypass" : wasMentioned ? "mention_pattern" : matchedImplicitMentionKinds.length > 0 ? "implicit_thread" : "none";
 	if (isBotMessage && allowBotsMode === "mentions") {
 		if (!(isDirectMessage || effectiveWasMentioned || shouldBypassMention)) return drop("bot-missing-mention");
 	}
@@ -4275,7 +4157,6 @@ async function prepareSlackMessage(params) {
 		originatingTo: preflightChannelTarget,
 		messageThreadId: threadContext.messageThreadId
 	});
-	if (shouldLogVerbose()) logVerbose(`slack inbound: account=${route.accountId} agent=${route.agentId} channel=${message.channel} message_ts=${message.ts ?? "unknown"} thread_ts=${effectiveMessageThreadId ?? "none"} from=${slackFrom} chat=${chatType} chars=${rawBody.length}`);
 	const updateLastRouteSessionKey = resolveInboundLastRouteSessionKey({
 		route,
 		sessionKey