@openclaw/slack 2026.7.2-beta.7 → 2026.8.1-beta.3

package/dist/{send-DsLeZpST.js → send-CtnOxKCc.js}

@@ -1,43 +1,44 @@
-import { a as resolveSlackAccount, l as resolveSlackOperationToken } from "./accounts-CHAeNZOX.js";
-import { i as parseSlackTarget, t as canonicalizeSlackApiTargetId } from "./target-parsing-N6lHogYZ.js";
-import { C as hasSlackNativeDataBlock, D as stripSlackNativeDataBlocks, F as SLACK_EDIT_TEXT_MAX_BYTES, H as truncateSlackText, I as SLACK_MESSAGE_TEXT_HARD_LIMIT, L as SLACK_TEXT_LIMIT, M as buildSlackCompleteBlocksFallbackText, N as renderSlackBlockFallbackText, O as chunkSlackMrkdwnText, S as createSlackNativeDataBaseTextConsumer, U as truncateSlackTextByUtf8Bytes, b as appendSlackNativeDataPlainTextFallback, i as assertSlackDirectSendAllowed, it as validateSlackBlocksArray, k as markdownToSlackMrkdwnChunks, w as isSlackInvalidBlocksError, x as buildSlackNativeDataAccessibilityText } from "./group-policy-NQZti9t-.js";
+import { a as resolveSlackAccount, l as resolveSlackOperationToken } from "./accounts-BlzxuYle.js";
+import { a as parseSlackTarget, t as canonicalizeSlackApiTargetId } from "./target-parsing-BnMD2ZqZ.js";
+import { B as SLACK_EDIT_TEXT_MAX_BYTES, D as createSlackNativeDataBaseTextConsumer, E as buildSlackNativeDataAccessibilityText, H as SLACK_MESSAGE_TEXT_RECOMMENDED_LIMIT, J as truncateSlackText, L as buildSlackCompleteBlocksFallbackText, M as stripSlackNativeDataBlocks, N as chunkSlackMrkdwnText, O as hasSlackNativeDataBlock, P as markdownToSlackMrkdwnChunks, R as renderSlackBlockFallbackText, T as appendSlackNativeDataPlainTextFallback, U as SLACK_TEXT_LIMIT, V as SLACK_MESSAGE_TEXT_HARD_LIMIT, X as SLACK_QUESTION_FINALIZATION_BLOCKS, Y as truncateSlackTextByUtf8Bytes, g as assertSlackDetachedTargetAllowed, it as resolveSlackQuestionActionIds, k as isSlackInvalidBlocksError, mt as validateSlackBlocksArray } from "./group-policy-DyfB_ZIE.js";
 import { n as resolveSlackThreadTsValue, t as normalizeSlackThreadTsCandidate } from "./thread-ts-DUGhaYKq.js";
-import { c as createSlackTokenCacheKey, f as getSlackWriteClient, o as createSlackReadClient } from "./probe-CgDsSops.js";
+import { a as createSlackReadClient, d as getSlackWriteClient, r as formatSlackError, s as createSlackTokenCacheKey } from "./probe-BVA65leh.js";
 import { t as getOptionalSlackRuntime } from "./runtime-JSVZSWAj.js";
-import { i as loadOutboundMediaFromUrl } from "./runtime-api-QMb-Q5Ko.js";
+import { i as loadOutboundMediaFromUrl } from "./runtime-api-DBi7xc_g.js";
 import { normalizeLowercaseStringOrEmpty, normalizeOptionalString, normalizeTrimmedStringList } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { createMessageReceiptFromOutboundResults } from "openclaw/plugin-sdk/channel-outbound";
-import { logVerbose } from "openclaw/plugin-sdk/runtime-env";
-import { sliceUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
+import { logVerbose, sleepWithAbort } from "openclaw/plugin-sdk/runtime-env";
+import { chunkTextForOutbound } from "openclaw/plugin-sdk/text-chunking";
+import { resolveGlobalSingleton } from "openclaw/plugin-sdk/global-singleton";
+import { sliceUtf16Safe, truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import { createHash, createHmac } from "node:crypto";
 import { withTrustedEnvProxyGuardedFetchMode } from "openclaw/plugin-sdk/fetch-runtime";
 import { requireRuntimeConfig } from "openclaw/plugin-sdk/plugin-config-runtime";
 import { PlatformMessageNotDispatchedError, extractErrorCode, readErrorName } from "openclaw/plugin-sdk/error-runtime";
 import { KeyedAsyncQueue } from "openclaw/plugin-sdk/keyed-async-queue";
 import { resolveMarkdownTableMode } from "openclaw/plugin-sdk/markdown-table-runtime";
-import { chunkMarkdownTextWithMode, isSilentReplyText, resolveChunkMode, resolveTextChunkLimit } from "openclaw/plugin-sdk/reply-chunking";
+import { chunkMarkdownTextWithMode, resolveChunkMode, resolveTextChunkLimit } from "openclaw/plugin-sdk/reply-chunking";
 import { resolveTextChunksWithFallback } from "openclaw/plugin-sdk/reply-payload";
 import { safeEqualSecret } from "openclaw/plugin-sdk/security-runtime";
 import { buildTimeoutAbortSignal } from "openclaw/plugin-sdk/extension-shared";
+import { extensionForMime } from "openclaw/plugin-sdk/media-mime";
+import { retryAsync } from "openclaw/plugin-sdk/retry-runtime";
 import { fetchWithSsrFGuard } from "openclaw/plugin-sdk/ssrf-runtime";
 import { createPersistentDedupeCache } from "openclaw/plugin-sdk/dedupe-runtime";
+import { createPluginStateErrorReporter } from "openclaw/plugin-sdk/plugin-state-runtime";
 //#region extensions/slack/src/native-data-fallback.ts
 const SLACK_SECTION_PLAIN_TEXT_MAX = 3e3;
 const SLACK_EMPTY_BLOCK_FALLBACK = "Shared a Block Kit message";
 function chunkSlackTextAtHardLimit(text, limit = SLACK_MESSAGE_TEXT_HARD_LIMIT) {
-	const effectiveLimit = Math.max(2, Math.floor(limit));
-	const chunks = [];
-	let offset = 0;
-	while (offset < text.length) {
-		const chunk = sliceUtf16Safe(text, offset, Math.min(text.length, offset + effectiveLimit));
-		if (!chunk) throw new Error("Slack plain-text fallback chunking made no progress.");
-		chunks.push(chunk);
-		offset += chunk.length;
-	}
-	return chunks;
+	if (!text) return [];
+	return chunkTextForOutbound(text, Math.max(1, Math.floor(limit)), { preserveWhitespace: true });
+}
+function fitsSlackTextLimit(text, limit) {
+	if (text.length <= limit) return true;
+	return truncateUtf16Safe(text, limit).length === text.length;
 }
-function buildPlainTextBlocks(text) {
-	return chunkSlackTextAtHardLimit(text, SLACK_SECTION_PLAIN_TEXT_MAX).map((chunk, index) => {
+function buildPlainTextBlocks(text, textLimit) {
+	return chunkSlackTextAtHardLimit(text, Math.min(textLimit, SLACK_SECTION_PLAIN_TEXT_MAX)).map((chunk, index) => {
 		const fallbackBlock = {
 			block: {
 				type: "section",
@@ -58,11 +59,11 @@ function renderNativeDataPlainText(block) {
 function buildOrderedFallbackBlocks(params) {
 	const entries = [];
 	const consumeFromBase = createSlackNativeDataBaseTextConsumer(params.baseText);
-	if (params.baseText) entries.push(...buildPlainTextBlocks(params.baseText));
+	if (params.baseText) entries.push(...buildPlainTextBlocks(params.baseText, params.textLimit));
 	for (const block of params.blocks) {
 		if (hasSlackNativeDataBlock([block])) {
 			const nativeText = renderNativeDataPlainText(block);
-			if (!consumeFromBase(nativeText)) entries.push(...buildPlainTextBlocks(nativeText));
+			if (!consumeFromBase(nativeText)) entries.push(...buildPlainTextBlocks(nativeText, params.textLimit));
 			continue;
 		}
 		const text = renderSlackBlockFallbackText(block, { nativeDataFormat: "plain" });
@@ -73,7 +74,7 @@ function buildOrderedFallbackBlocks(params) {
 	}
 	return entries;
 }
-function buildOrderedBlockMessages(entries) {
+function buildOrderedBlockMessages(entries, textLimit) {
 	const messages = [];
 	let blocks = [];
 	let text = "";
@@ -90,10 +91,10 @@ function buildOrderedBlockMessages(entries) {
 	for (const entry of entries) {
 		const separator = text && entry.text && !entry.continuesText ? "\n\n" : "";
 		const nextText = entry.text ? `${text}${separator}${entry.text}` : text;
-		if (blocks.length >= 50 || nextText.length > 4e4) flush();
+		if (blocks.length >= 50 || !fitsSlackTextLimit(nextText, textLimit)) flush();
 		const freshSeparator = text && entry.text && !entry.continuesText ? "\n\n" : "";
 		const freshText = entry.text ? `${text}${freshSeparator}${entry.text}` : text;
-		if (freshText.length > 4e4) throw new Error("One Slack fallback block exceeds the message text hard limit.");
+		if (!fitsSlackTextLimit(freshText, textLimit)) throw new Error("One Slack fallback block exceeds the resolved message text limit.");
 		blocks.push(entry.block);
 		text = freshText;
 	}
@@ -103,17 +104,19 @@ function buildOrderedBlockMessages(entries) {
 /** Build one complete, ordered retry plan after Slack rejects native data blocks. */
 function buildSlackNativeDataDeliveryPlan(params) {
 	const baseText = params.baseText?.trim() ?? "";
+	const textLimit = Math.min(SLACK_MESSAGE_TEXT_RECOMMENDED_LIMIT, SLACK_MESSAGE_TEXT_HARD_LIMIT, Math.max(1, Math.floor(params.textLimit ?? 4e4)));
 	const hasNativeData = hasSlackNativeDataBlock(params.blocks);
 	const accessibilityText = buildSlackNativeDataAccessibilityText(baseText, params.blocks) || (hasNativeData ? "Slack could not render this chart or table data." : SLACK_EMPTY_BLOCK_FALLBACK);
 	return {
 		accessibilityText,
-		fallbackMessages: stripSlackNativeDataBlocks(params.blocks).length === 0 ? chunkSlackTextAtHardLimit(accessibilityText).map((text) => ({
+		fallbackMessages: stripSlackNativeDataBlocks(params.blocks).length === 0 ? chunkSlackTextAtHardLimit(accessibilityText, textLimit).map((text) => ({
 			text,
 			mrkdwn: false
 		})) : buildOrderedBlockMessages(buildOrderedFallbackBlocks({
 			baseText,
-			blocks: params.blocks
-		})),
+			blocks: params.blocks,
+			textLimit
+		}), textLimit),
 		skipOriginalBlocks: accessibilityText.length > SLACK_MESSAGE_TEXT_HARD_LIMIT
 	};
 }
@@ -142,6 +145,7 @@ function hasCustomIdentity$1(identity) {
 async function postSlackMessageWithIdentityFallback(params) {
 	const { basePayload, identity, post } = params;
 	try {
+		if (!identity) return await post(basePayload);
 		if (identity?.iconUrl) return await post({
 			...basePayload,
 			...identity.username ? { username: identity.username } : {},
@@ -250,11 +254,6 @@ function hasSlackDnsRequestSignal(err) {
 	}
 	return false;
 }
-function delaySlackDnsRetry(attempt) {
-	return new Promise((resolve) => {
-		setTimeout(resolve, SLACK_DNS_RETRY_BASE_DELAY_MS * Math.max(1, attempt));
-	});
-}
 function resolveSlackUploadTimeoutLogUrl(url) {
 	try {
 		return new URL(url).origin;
@@ -328,14 +327,22 @@ function resolveSlackUploadTransportPolicy(params) {
 	};
 }
 async function withSlackDnsRequestRetry(operation, fn) {
-	for (const attempt of Array.from({ length: 3 }, (_, index) => index)) try {
-		return await fn();
-	} catch (err) {
-		if (attempt >= SLACK_DNS_RETRY_ATTEMPTS || !hasSlackDnsRequestSignal(err)) throw err;
-		logVerbose(`slack send: retrying ${operation} after transient DNS request error (${attempt + 1}/${SLACK_DNS_RETRY_ATTEMPTS})`);
-		await delaySlackDnsRetry(attempt + 1);
-	}
-	throw new Error("unreachable Slack DNS retry loop exit");
+	return await retryAsync(fn, {
+		attempts: 3,
+		minDelayMs: 0,
+		shouldRetry: hasSlackDnsRequestSignal,
+		delayMs: ({ attempt }) => SLACK_DNS_RETRY_BASE_DELAY_MS * Math.max(1, attempt),
+		onRetry: ({ attempt }) => {
+			logVerbose(`slack send: retrying ${operation} after transient DNS request error (${attempt}/${SLACK_DNS_RETRY_ATTEMPTS})`);
+		},
+		sleep: (delayMs) => sleepWithAbort(delayMs)
+	});
+}
+function requireSlackPostMessageTimestamp(response) {
+	if (response.ok === false) throw new Error(`Slack chat.postMessage failed: ${formatSlackError(response.error, "unknown error")}`);
+	const timestamp = response.ts?.trim();
+	if (!timestamp) throw new Error("Slack chat.postMessage returned no message timestamp");
+	return timestamp;
 }
 async function postSlackMessageBestEffort(params) {
 	const basePayload = buildSlackPostMessagePayload(params);
@@ -344,20 +351,29 @@ async function postSlackMessageBestEffort(params) {
 		response: await withSlackDnsRequestRetry("chat.postMessage", () => postChatMessage(payload)),
 		identity
 	});
-	return await postSlackMessageWithIdentityFallback({
+	const posted = await postSlackMessageWithIdentityFallback({
 		basePayload,
 		identity: params.identity,
 		post
 	});
+	const timestamp = requireSlackPostMessageTimestamp(posted.response);
+	return {
+		...posted,
+		response: {
+			...posted.response,
+			ts: timestamp
+		}
+	};
 }
 async function uploadSlackFile(params) {
 	const { buffer, contentType, fileName } = await loadOutboundMediaFromUrl(params.mediaUrl, {
 		maxBytes: params.maxBytes,
 		mediaAccess: params.mediaAccess,
 		mediaLocalRoots: params.mediaLocalRoots,
-		mediaReadFile: params.mediaReadFile
+		mediaReadFile: params.mediaReadFile,
+		...params.optimizeImages !== void 0 ? { optimizeImages: params.optimizeImages } : {}
 	});
-	const uploadFileName = params.uploadFileName ?? fileName ?? "upload";
+	const uploadFileName = params.uploadFileName ?? fileName ?? `upload${extensionForMime(contentType) ?? ""}`;
 	const uploadTitle = params.uploadTitle ?? uploadFileName;
 	const uploadUrlResp = await withSlackDnsRequestRetry("files.getUploadURLExternal", () => params.client.files.getUploadURLExternal({
 		filename: uploadFileName,
@@ -416,24 +432,32 @@ async function uploadSlackFile(params) {
 }
 //#endregion
 //#region extensions/slack/src/sent-thread-cache.ts
+/**
+* Cache of Slack threads the bot has participated in.
+* Used to auto-respond in threads without requiring @mention after the first reply.
+*/
+const MAX_ENTRIES = 5e3;
+const PERSISTENT_MAX_ENTRIES = 1e3;
+const MAX_FAILURE_NOTICES = 1e3;
+const PERSISTENT_NAMESPACE = "slack.thread-participation";
+/**
+* Keep Slack thread participation shared across bundled chunks so thread
+* auto-reply gating does not diverge between prepare/dispatch call paths.
+*/
+const SLACK_THREAD_PARTICIPATION_KEY = Symbol.for("openclaw.slackThreadParticipation");
+const SLACK_THREAD_FAILURE_NOTICES_KEY = Symbol.for("openclaw.slackThreadFailureNotices");
 const threadParticipation = createPersistentDedupeCache({
-	globalKey: Symbol.for("openclaw.slackThreadParticipation"),
-	ttlMs: 1440 * 60 * 1e3,
-	maxSize: 5e3,
+	globalKey: SLACK_THREAD_PARTICIPATION_KEY,
+	ttlMs: 0,
+	maxSize: MAX_ENTRIES,
 	persistent: {
-		namespace: "slack.thread-participation",
-		maxEntries: 1e3,
+		namespace: PERSISTENT_NAMESPACE,
+		maxEntries: PERSISTENT_MAX_ENTRIES,
 		openStore: (options) => getOptionalSlackRuntime()?.state.openKeyedStore(options),
-		logError: (error) => {
-			try {
-				getOptionalSlackRuntime()?.logging.getChildLogger({
-					plugin: "slack",
-					feature: "thread-participation-state"
-				}).warn("Slack persistent thread participation state failed", { error: String(error) });
-			} catch {}
-		}
+		logError: createPluginStateErrorReporter(getOptionalSlackRuntime, "slack", "thread-participation-state", "Slack persistent thread participation state failed")
 	}
 });
+const threadFailureNotices = resolveGlobalSingleton(SLACK_THREAD_FAILURE_NOTICES_KEY, () => /* @__PURE__ */ new Map(), (notices) => notices.clear());
 function makeKey(accountId, channelId, threadTs, teamId) {
 	return `${accountId}:${teamId ? `${teamId}:` : ""}${channelId}:${threadTs}`;
 }
@@ -452,8 +476,41 @@ async function hasSlackThreadParticipationWithPersistence(params) {
 	if (!params.accountId || !params.channelId || !params.threadTs) return false;
 	return await threadParticipation.lookup(makeKey(params.accountId, params.channelId, params.threadTs, params.teamId));
 }
+function makeFailureNoticeKey(params) {
+	const scope = params.threadTs ? `thread:${params.threadTs}` : "channel";
+	return makeKey(params.accountId, params.channelId, scope, params.teamId);
+}
+/** Returns whether this failure was already delivered in the thread or channel. */
+function hasSlackThreadFailureNotice(params) {
+	const { accountId, channelId, failureText } = params;
+	const fingerprint = failureText.trim().replace(/\s+/gu, " ");
+	if (!accountId || !channelId || !fingerprint) return false;
+	return threadFailureNotices.get(makeFailureNoticeKey(params)) === fingerprint;
+}
+/** Records a failure after it was delivered in the thread or channel. */
+function recordSlackThreadFailureNotice(params) {
+	const { accountId, channelId, failureText } = params;
+	const fingerprint = failureText.trim().replace(/\s+/gu, " ");
+	if (!accountId || !channelId || !fingerprint) return false;
+	const key = makeFailureNoticeKey(params);
+	if (threadFailureNotices.get(key) === fingerprint) return false;
+	threadFailureNotices.delete(key);
+	threadFailureNotices.set(key, fingerprint);
+	if (threadFailureNotices.size > MAX_FAILURE_NOTICES) {
+		const oldestKey = threadFailureNotices.keys().next().value;
+		if (oldestKey !== void 0) threadFailureNotices.delete(oldestKey);
+	}
+	return true;
+}
+/** Clears a thread or channel outage notice after a healthy model turn completes. */
+function clearSlackThreadFailureNotice(params) {
+	const { accountId, channelId } = params;
+	if (!accountId || !channelId) return;
+	threadFailureNotices.delete(makeFailureNoticeKey(params));
+}
 function clearSlackThreadParticipationCache() {
 	threadParticipation.clearForTest();
+	threadFailureNotices.clear();
 }
 //#endregion
 //#region extensions/slack/src/send.ts
@@ -537,11 +594,12 @@ async function updateMessageSlack(params) {
 		cfg: requireRuntimeConfig(params.cfg, "Slack update"),
 		accountId: params.accountId
 	});
+	assertSlackDetachedTargetAllowed(account.accountId, params.teamId);
 	await getSlackWriteClient(resolveToken({
 		accountId: account.accountId,
 		fallbackToken: account.botToken,
 		fallbackSource: account.botTokenSource
-	})).chat.update({
+	}), { teamId: params.teamId }).chat.update({
 		channel: params.channelId,
 		ts: params.messageTs,
 		text: truncateSlackTextByUtf8Bytes(params.text, SLACK_EDIT_TEXT_MAX_BYTES),
@@ -550,7 +608,7 @@ async function updateMessageSlack(params) {
 }
 function createSlackSendReceipt(params) {
 	return createMessageReceiptFromOutboundResults({
-		results: params.platformMessageIds.map((messageId) => messageId.trim()).filter((messageId) => messageId && messageId !== "unknown" && messageId !== "suppressed").map((messageId) => {
+		results: params.platformMessageIds.map((messageId) => messageId.trim()).filter((messageId) => messageId && messageId !== "unknown").map((messageId) => {
 			const result = {
 				channel: "slack",
 				messageId
@@ -577,7 +635,8 @@ function parseRecipient(raw) {
 	if (!target) throw new Error("Recipient is required for Slack sends");
 	return {
 		kind: target.kind,
-		id: canonicalizeSlackApiTargetId(target.kind, target.id, raw)
+		id: canonicalizeSlackApiTargetId(target.kind, target.id, raw),
+		teamId: target.teamId
 	};
 }
 function parseEnterpriseEventRecipient(raw) {
@@ -588,20 +647,56 @@ function parseEnterpriseEventRecipient(raw) {
 		id: canonicalizeSlackApiTargetId("channel", match[1])
 	};
 }
-function resolveEnterpriseEventScope(params) {
-	const scope = params.opts.enterpriseEventScope;
-	if (!scope) {
-		assertSlackDirectSendAllowed(params.account);
-		return;
-	}
-	if (params.account.config.enterpriseOrgInstall !== true) throw new Error("unexpected_enterprise_slack_listener_scope");
-	if (!scope.isEnterpriseInstall || !normalizeOptionalString(scope.apiAppId) || !normalizeOptionalString(scope.enterpriseId) || !/^T[A-Z0-9]+$/i.test(scope.teamId) || !scope.client || params.opts.client !== scope.client) throw new Error("invalid_enterprise_slack_listener_scope");
+function resolveSlackSendEventScope(params) {
+	const scope = params.opts.eventScope;
+	if (!scope) return;
+	if (!/^T[A-Z0-9]+$/i.test(scope.teamId) || !scope.client) throw new Error("invalid_enterprise_slack_listener_scope");
 	return scope;
 }
+function resolveSlackDelivery(params) {
+	if (params.eventScope) {
+		if (params.opts.mediaUrl && !params.eventScope.uploadCompletionClient) throw new Error("missing_enterprise_slack_upload_completion_client");
+		return Object.freeze({
+			client: params.eventScope.client,
+			credential: SLACK_ENTERPRISE_LISTENER_QUEUE_CREDENTIAL,
+			identity: normalizeSlackSendIdentity(params.opts.identity),
+			recipient: params.recipient,
+			teamId: params.eventScope.teamId,
+			unfurl: { unfurlMedia: params.account.config.unfurlMedia },
+			...params.eventScope.uploadCompletionClient ? { upload: Object.freeze({
+				completionClient: params.eventScope.uploadCompletionClient,
+				auditContext: "slack-enterprise-immediate-upload"
+			}) } : {}
+		});
+	}
+	const credential = resolveToken({
+		explicit: params.opts.token,
+		accountId: params.account.accountId,
+		fallbackToken: resolveSlackOperationToken(params.account, "write"),
+		fallbackSource: params.account.identity === "user" ? params.account.userTokenSource : params.account.botTokenSource
+	});
+	return Object.freeze({
+		client: params.recipient.teamId ? getSlackWriteClient(credential, { teamId: params.recipient.teamId }) : params.opts.client ?? getSlackWriteClient(credential),
+		credential,
+		identity: resolveSlackSendIdentity({
+			accountId: params.account.accountId,
+			explicit: params.opts.identity
+		}),
+		recipient: params.recipient,
+		teamId: params.recipient.teamId,
+		unfurl: params.recipient.teamId ? { unfurlMedia: params.account.config.unfurlMedia } : {
+			unfurlLinks: params.account.config.unfurlLinks,
+			unfurlMedia: params.account.config.unfurlMedia
+		}
+	});
+}
+function resolveSlackTextChunkLimit(params) {
+	const configuredLimit = params.textLimit ?? resolveTextChunkLimit(params.cfg, "slack", params.accountId, { fallbackLimit: 8e3 });
+	return Math.min(configuredLimit, SLACK_TEXT_LIMIT);
+}
 function resolveSlackTextChunks(params) {
 	const text = params.preservePlainText ? params.text : params.text.trim();
-	const configuredLimit = params.textLimit ?? resolveTextChunkLimit(params.cfg, "slack", params.accountId, { fallbackLimit: 8e3 });
-	const chunkLimit = Math.min(configuredLimit, SLACK_TEXT_LIMIT);
+	const chunkLimit = resolveSlackTextChunkLimit(params);
 	if (params.preservePlainText) {
 		const chunks = [];
 		let remaining = text;
@@ -867,7 +962,7 @@ async function scanSlackConversationForDelivery(params) {
 		evidence: deliveryParts.size > 0 ? "partial" : "none"
 	};
 }
-async function reconcileSlackUnknownSend(ctx, opts) {
+async function reconcileSlackUnknownSend(ctx) {
 	const account = resolveSlackAccount({
 		cfg: requireRuntimeConfig(ctx.cfg, "Slack delivery reconciliation"),
 		accountId: ctx.accountId ?? void 0
@@ -878,13 +973,22 @@ async function reconcileSlackUnknownSend(ctx, opts) {
 		error: "Slack unknown-send reconciliation requires a durable delivery id",
 		retryable: false
 	};
+	const recipient = parseRecipient(ctx.to);
+	try {
+		assertSlackDetachedTargetAllowed(account.accountId, recipient.teamId);
+	} catch (error) {
+		return {
+			status: "unresolved",
+			error: error instanceof Error ? error.message : String(error),
+			retryable: false
+		};
+	}
 	const readToken = resolveSlackOperationToken(account, "read");
 	if (!readToken) return {
 		status: "unresolved",
 		error: `Slack read token missing for account "${account.accountId}"`,
 		retryable: false
 	};
-	const recipient = parseRecipient(ctx.to);
 	const userRecipient = isSlackUserRecipient(recipient);
 	const writeToken = resolveSlackOperationToken(account, "write");
 	if (userRecipient && !writeToken) return {
@@ -892,8 +996,8 @@ async function reconcileSlackUnknownSend(ctx, opts) {
 		error: `Slack write token missing for direct-message reconciliation on account "${account.accountId}"`,
 		retryable: false
 	};
-	const readClient = opts?.client ?? createSlackReadClient(readToken);
-	const writeClient = opts?.client ?? (writeToken ? getSlackWriteClient(writeToken) : void 0);
+	const readClient = createSlackReadClient(readToken, { teamId: recipient.teamId });
+	const writeClient = writeToken ? getSlackWriteClient(writeToken, { teamId: recipient.teamId }) : void 0;
 	const payloadReplyToId = ctx.payloads[0]?.replyToId;
 	const threadTs = resolveSlackThreadTsValue({
 		replyToId: Object.hasOwn(ctx, "effectiveReplyToId") ? normalizeOptionalString(ctx.effectiveReplyToId) : payloadReplyToId != null ? normalizeOptionalString(payloadReplyToId) : ctx.replyToMode === "off" ? void 0 : normalizeOptionalString(ctx.replyToId),
@@ -910,7 +1014,7 @@ async function reconcileSlackUnknownSend(ctx, opts) {
 			accountId: account.accountId,
 			token: channelToken
 		});
-		const lookupClients = opts?.client ? [opts.client] : [readClient, ...writeClient && writeToken !== readToken ? [writeClient] : []];
+		const lookupClients = [readClient, ...writeClient && writeClient !== readClient && writeToken !== readToken ? [writeClient] : []];
 		let lookupError;
 		let bestUnresolvedScan;
 		for (const lookupClient of lookupClients) try {
@@ -947,59 +1051,34 @@ async function sendMessageSlack(to, message, opts) {
 		cfg,
 		accountId: opts.accountId
 	});
-	const enterpriseEventScope = resolveEnterpriseEventScope({
-		account,
-		opts
-	});
-	const enterpriseDelivery = enterpriseEventScope ? Object.freeze({
-		client: enterpriseEventScope.client,
-		teamId: enterpriseEventScope.teamId,
-		...enterpriseEventScope.uploadCompletionClient ? { uploadCompletionClient: enterpriseEventScope.uploadCompletionClient } : {}
-	}) : void 0;
-	if (isSilentReplyText(normalizedMessage) && !opts.mediaUrl && !opts.blocks) {
-		logVerbose("slack send: suppressed NO_REPLY token before API call");
-		return {
-			messageId: "suppressed",
-			channelId: "",
-			receipt: createSlackSendReceipt({
-				platformMessageIds: [],
-				kind: "unknown"
-			})
-		};
-	}
+	const eventScope = resolveSlackSendEventScope({ opts });
+	const recipient = eventScope ? parseEnterpriseEventRecipient(to) : parseRecipient(to);
+	if (!eventScope) assertSlackDetachedTargetAllowed(account.accountId, recipient.teamId);
 	const blocks = opts.blocks == null ? void 0 : validateSlackBlocksArray(opts.blocks);
 	if (!normalizedMessage && !opts.mediaUrl && !blocks) throw new Error("Slack send requires text, blocks, or media");
-	const token = enterpriseDelivery ? SLACK_ENTERPRISE_LISTENER_QUEUE_CREDENTIAL : resolveToken({
-		explicit: opts.token,
-		accountId: account.accountId,
-		fallbackToken: resolveSlackOperationToken(account, "write"),
-		fallbackSource: account.identity === "user" ? account.userTokenSource : account.botTokenSource
+	const queuedOpts = Object.freeze({ ...opts });
+	const delivery = resolveSlackDelivery({
+		account,
+		eventScope,
+		opts: queuedOpts,
+		recipient
 	});
-	const recipient = enterpriseDelivery ? parseEnterpriseEventRecipient(to) : parseRecipient(to);
-	const queueKey = createSlackSendQueueKey({
+	const result = await runQueuedSlackSend(createSlackSendQueueKey({
 		accountId: account.accountId,
-		token,
-		recipient,
+		token: delivery.credential,
+		recipient: delivery.recipient,
 		threadTs: opts.threadTs,
-		...enterpriseDelivery ? { teamId: enterpriseDelivery.teamId } : {}
-	});
-	const queuedOpts = enterpriseDelivery ? Object.freeze({
-		...opts,
-		client: enterpriseDelivery.client
-	}) : opts;
-	const result = await runQueuedSlackSend(queueKey, () => sendMessageSlackQueued({
+		teamId: delivery.teamId
+	}), () => sendMessageSlackQueued({
 		trimmedMessage,
 		opts: queuedOpts,
 		cfg,
 		account,
-		token,
-		recipient,
 		blocks,
-		...enterpriseDelivery ? { enterpriseDelivery } : {}
+		delivery
 	}));
 	const threadTs = result.threadTs ?? normalizeSlackThreadTsCandidate(queuedOpts.threadTs);
-	if (threadTs && result.channelId && account.accountId) if (enterpriseDelivery) recordSlackThreadParticipation(account.accountId, result.channelId, threadTs, { teamId: enterpriseDelivery.teamId });
-	else recordSlackThreadParticipation(account.accountId, result.channelId, threadTs);
+	if (threadTs && result.channelId && account.accountId) recordSlackThreadParticipation(account.accountId, result.channelId, threadTs, { teamId: delivery.teamId });
 	return result;
 }
 async function sendMessageSlackQueued(params) {
@@ -1010,17 +1089,9 @@ async function sendMessageSlackQueued(params) {
 	}
 }
 async function sendMessageSlackQueuedInner(params) {
-	const { opts, cfg, account, token, recipient, blocks, trimmedMessage, enterpriseDelivery } = params;
-	const client = enterpriseDelivery?.client ?? opts.client ?? getSlackWriteClient(token);
-	const identity = enterpriseDelivery ? normalizeSlackSendIdentity(opts.identity) : resolveSlackSendIdentity({
-		accountId: account.accountId,
-		explicit: opts.identity
-	});
+	const { opts, cfg, account, blocks, trimmedMessage, delivery } = params;
+	const { client, identity, recipient, unfurl } = delivery;
 	if (opts.replyBroadcast && opts.mediaUrl) throw new Error("Slack replyBroadcast is only supported for text or block thread replies.");
-	const unfurl = enterpriseDelivery ? { unfurlMedia: account.config.unfurlMedia } : {
-		unfurlLinks: account.config.unfurlLinks,
-		unfurlMedia: account.config.unfurlMedia
-	};
 	const directUserPostChannelId = opts.deliveryQueueId ? void 0 : resolveDirectUserPostChannelId({
 		recipient,
 		hasMedia: Boolean(opts.mediaUrl),
@@ -1028,11 +1099,20 @@ async function sendMessageSlackQueuedInner(params) {
 	});
 	const { channelId } = directUserPostChannelId ? { channelId: directUserPostChannelId } : await resolveChannelId(client, recipient, {
 		accountId: account.accountId,
-		token
+		token: delivery.credential
 	});
-	const reportDelivery = async (result) => {
-		await opts.onDeliveryResult?.(result);
-		return result;
+	const reportDelivery = async (result, deliveredBlocks) => {
+		const slackQuestionActionIds = resolveSlackQuestionActionIds(deliveredBlocks);
+		const deliveryResult = slackQuestionActionIds.length ? {
+			...result,
+			meta: {
+				...result.meta,
+				slackQuestionActionIds,
+				[SLACK_QUESTION_FINALIZATION_BLOCKS]: deliveredBlocks.filter((block) => block.type !== "actions")
+			}
+		} : result;
+		await opts.onDeliveryResult?.(deliveryResult);
+		return deliveryResult;
 	};
 	let didDispatch = false;
 	const dispatchOnce = async () => {
@@ -1044,10 +1124,16 @@ async function sendMessageSlackQueuedInner(params) {
 	const authoredTextPlacement = opts.authoredTextPlacement ?? "outside-blocks";
 	const nativeDataFallbackBase = blocks && authoredTextPlacement === "outside-blocks" ? explicitNativeDataFallbackBase ?? trimmedMessage : "";
 	const hasNativeData = Boolean(blocks && hasSlackNativeDataBlock(blocks));
+	const textChunkLimit = resolveSlackTextChunkLimit({
+		cfg,
+		accountId: account.accountId,
+		...opts.textLimit !== void 0 ? { textLimit: opts.textLimit } : {}
+	});
 	const usesOrderedBlockAccessibility = Boolean(blocks && (hasNativeData || opts.authoredTextPlacement !== void 0));
 	const orderedBlockDeliveryPlan = blocks && usesOrderedBlockAccessibility ? buildSlackNativeDataDeliveryPlan({
 		baseText: nativeDataFallbackBase,
-		blocks
+		blocks,
+		textLimit: textChunkLimit
 	}) : void 0;
 	const orderedBlockAccessibilityText = blocks && usesOrderedBlockAccessibility ? orderedBlockDeliveryPlan?.accessibilityText ?? (buildSlackNativeDataAccessibilityText(nativeDataFallbackBase, blocks) || "Slack could not render this Block Kit message.") : void 0;
 	const completeBlockFallbackText = blocks ? buildSlackCompleteBlocksFallbackText(blocks) : "";
@@ -1085,8 +1171,7 @@ async function sendMessageSlackQueuedInner(params) {
 					...usesOrderedBlockAccessibility ? { mrkdwn: false } : {},
 					unfurl
 				});
-				if (enterpriseDelivery && (!response.ok || !response.ts)) throw new Error(response.ok ? "Slack chat.postMessage returned no message timestamp" : `Slack chat.postMessage failed: ${response.error ?? "unknown error"}`);
-				const messageId = response.ts ?? "unknown";
+				const messageId = response.ts;
 				deliveredChannelId = resolvePostedMessageChannelId(response, channelId);
 				const deliveredThreadTs = resolvePostedMessageThreadTs(response) ?? normalizeSlackThreadTsCandidate(opts.threadTs);
 				return await reportDelivery({
@@ -1099,7 +1184,7 @@ async function sendMessageSlackQueuedInner(params) {
 						kind: "card",
 						threadTs: deliveredThreadTs
 					})
-				});
+				}, blocks);
 			} catch (error) {
 				if (!hasNativeData || !isSlackInvalidBlocksError(error)) throw error;
 				logVerbose("slack send: native data rejected, delivering complete text fallback");
@@ -1108,6 +1193,7 @@ async function sendMessageSlackQueuedInner(params) {
 		}
 		if (pendingBlockFallback) {
 			const fallbackMessages = pendingBlockFallback.fallbackMessages;
+			let questionDelivery;
 			for (const [partIndex, fallback] of fallbackMessages.entries()) {
 				const metadata = withSlackDeliveryMetadata(partIndex === 0 ? opts.metadata : void 0, {
 					queueId: opts.deliveryQueueId,
@@ -1130,15 +1216,13 @@ async function sendMessageSlackQueuedInner(params) {
 					unfurl
 				});
 				const response = posted.response;
-				if (enterpriseDelivery && (!response.ok || !response.ts)) throw new Error(response.ok ? "Slack chat.postMessage returned no message timestamp" : `Slack chat.postMessage failed: ${response.error ?? "unknown error"}`);
 				sendIdentity = posted.identity;
-				lastMessageId = response.ts ?? lastMessageId;
+				lastMessageId = response.ts;
 				deliveredChannelId = resolvePostedMessageChannelId(response, deliveredChannelId);
 				canonicalDeliveredThreadTs ??= resolvePostedMessageThreadTs(response);
-				if (!response.ts) continue;
 				sentMessageIds.push(response.ts);
 				const deliveredThreadTs = resolvePostedMessageThreadTs(response) ?? normalizeSlackThreadTsCandidate(opts.threadTs);
-				await reportDelivery({
+				const fallbackDelivery = await reportDelivery({
 					messageId: response.ts,
 					channelId: deliveredChannelId,
 					threadTs: deliveredThreadTs,
@@ -1148,16 +1232,21 @@ async function sendMessageSlackQueuedInner(params) {
 						kind: fallback.blocks ? "card" : "text",
 						threadTs: deliveredThreadTs
 					})
-				});
+				}, fallback.blocks);
+				if (fallbackDelivery.meta?.slackQuestionActionIds.length) questionDelivery = fallbackDelivery;
 			}
-			const messageId = lastMessageId || "unknown";
+			const messageId = lastMessageId;
 			const deliveredThreadTs = canonicalDeliveredThreadTs ?? normalizeSlackThreadTsCandidate(opts.threadTs);
 			return {
 				messageId,
 				channelId: deliveredChannelId,
 				threadTs: deliveredThreadTs,
+				...questionDelivery?.meta ? { meta: {
+					...questionDelivery.meta,
+					slackQuestionMessageId: questionDelivery.messageId
+				} } : {},
 				receipt: createSlackSendReceipt({
-					platformMessageIds: sentMessageIds.length ? sentMessageIds : [messageId],
+					platformMessageIds: sentMessageIds,
 					channelId: deliveredChannelId,
 					kind: fallbackMessages.some((message) => message.blocks) ? "card" : "text",
 					threadTs: deliveredThreadTs
@@ -1169,18 +1258,17 @@ async function sendMessageSlackQueuedInner(params) {
 		cfg,
 		accountId: account.accountId,
 		text: trimmedMessage,
-		...opts.textLimit !== void 0 ? { textLimit: opts.textLimit } : {},
+		textLimit: textChunkLimit,
 		...opts.textIsSlackMrkdwn ? { textIsSlackMrkdwn: true } : {},
 		...opts.textIsSlackPlainText ? { preservePlainText: true } : {}
 	});
 	const mediaMaxBytes = opts.mediaMaxBytes ?? (typeof account.config.mediaMaxMb === "number" ? account.config.mediaMaxMb * 1024 * 1024 : void 0);
 	let chunksToPost;
 	if (opts.mediaUrl) {
-		if (enterpriseDelivery && !enterpriseDelivery.uploadCompletionClient) throw new Error("missing_enterprise_slack_upload_completion_client");
 		const [firstChunk, ...rest] = resolvedChunks;
 		lastMessageId = await uploadSlackFile({
 			client,
-			...enterpriseDelivery?.uploadCompletionClient ? { completionClient: enterpriseDelivery.uploadCompletionClient } : {},
+			...delivery.upload ? { completionClient: delivery.upload.completionClient } : {},
 			channelId,
 			mediaUrl: opts.mediaUrl,
 			mediaAccess: opts.mediaAccess,
@@ -1191,8 +1279,9 @@ async function sendMessageSlackQueuedInner(params) {
 			caption: firstChunk,
 			threadTs: opts.threadTs,
 			maxBytes: mediaMaxBytes,
+			...opts.forceDocument ? { optimizeImages: false } : {},
 			onPlatformSendDispatch: dispatchOnce,
-			...enterpriseDelivery ? { auditContext: "slack-enterprise-immediate-upload" } : {}
+			...delivery.upload ? { auditContext: delivery.upload.auditContext } : {}
 		});
 		sentMessageIds.push(lastMessageId);
 		await reportDelivery({
@@ -1231,34 +1320,31 @@ async function sendMessageSlackQueuedInner(params) {
 			unfurl
 		});
 		const response = posted.response;
-		if (enterpriseDelivery && (!response.ok || !response.ts)) throw new Error(response.ok ? "Slack chat.postMessage returned no message timestamp" : `Slack chat.postMessage failed: ${response.error ?? "unknown error"}`);
 		sendIdentity = posted.identity;
-		lastMessageId = response.ts ?? lastMessageId;
+		lastMessageId = response.ts;
 		deliveredChannelId = resolvePostedMessageChannelId(response, deliveredChannelId);
 		canonicalDeliveredThreadTs ??= resolvePostedMessageThreadTs(response);
-		if (response.ts) {
-			sentMessageIds.push(response.ts);
-			await reportDelivery({
-				messageId: response.ts,
+		sentMessageIds.push(response.ts);
+		await reportDelivery({
+			messageId: response.ts,
+			channelId: deliveredChannelId,
+			threadTs: resolvePostedMessageThreadTs(response) ?? normalizeSlackThreadTsCandidate(opts.threadTs),
+			receipt: createSlackSendReceipt({
+				platformMessageIds: [response.ts],
 				channelId: deliveredChannelId,
-				threadTs: resolvePostedMessageThreadTs(response) ?? normalizeSlackThreadTsCandidate(opts.threadTs),
-				receipt: createSlackSendReceipt({
-					platformMessageIds: [response.ts],
-					channelId: deliveredChannelId,
-					kind: "text",
-					threadTs: resolvePostedMessageThreadTs(response) ?? normalizeSlackThreadTsCandidate(opts.threadTs)
-				})
-			});
-		}
+				kind: "text",
+				threadTs: resolvePostedMessageThreadTs(response) ?? normalizeSlackThreadTsCandidate(opts.threadTs)
+			})
+		});
 	}
-	const messageId = lastMessageId || "unknown";
+	const messageId = lastMessageId;
 	const deliveredThreadTs = canonicalDeliveredThreadTs ?? normalizeSlackThreadTsCandidate(opts.threadTs);
 	return {
 		messageId,
 		channelId: deliveredChannelId,
 		threadTs: deliveredThreadTs,
 		receipt: createSlackSendReceipt({
-			platformMessageIds: sentMessageIds.length ? sentMessageIds : [messageId],
+			platformMessageIds: sentMessageIds,
 			channelId: deliveredChannelId,
 			kind: opts.mediaUrl ? "media" : "text",
 			threadTs: deliveredThreadTs
@@ -1266,4 +1352,4 @@ async function sendMessageSlackQueuedInner(params) {
 	};
 }
 //#endregion
-export { updateMessageSlack as a, hasSlackThreadParticipationWithPersistence as c, chunkSlackTextAtHardLimit as d, setSlackDefaultSendIdentity as i, recordSlackThreadParticipation as l, resolveSlackDmChannelId as n, clearSlackThreadParticipationCache as o, sendMessageSlack as r, hasSlackThreadParticipation as s, reconcileSlackUnknownSend as t, buildSlackNativeDataDeliveryPlan as u };
+export { updateMessageSlack as a, hasSlackThreadFailureNotice as c, recordSlackThreadFailureNotice as d, recordSlackThreadParticipation as f, chunkSlackTextAtHardLimit as h, setSlackDefaultSendIdentity as i, hasSlackThreadParticipation as l, buildSlackNativeDataDeliveryPlan as m, resolveSlackDmChannelId as n, clearSlackThreadFailureNotice as o, requireSlackPostMessageTimestamp as p, sendMessageSlack as r, clearSlackThreadParticipationCache as s, reconcileSlackUnknownSend as t, hasSlackThreadParticipationWithPersistence as u };