@openclaw/slack 2026.7.1-beta.6 → 2026.7.2-beta.1

package/dist/{send-DKDXoeoV.js → send-NEfJ0GvM.js}

@@ -1,81 +1,424 @@
 import { a as resolveSlackAccount, l as resolveSlackOperationToken, p as resolveSlackBotToken } from "./accounts-BOJJiHSr.js";
-import { r as parseSlackTarget } from "./target-parsing-3jYH8LfB.js";
-import "./targets-Dll4NJgs.js";
-import { a as SLACK_TEXT_LIMIT, b as truncateSlackText, i as validateSlackBlocksArray } from "./reply-blocks-BGQ6zSqM.js";
+import { i as parseSlackTarget, t as canonicalizeSlackApiTargetId } from "./target-parsing-N6lHogYZ.js";
+import { A as buildSlackCompleteBlocksFallbackText, C as hasSlackNativeDataBlock, D as markdownToSlackMrkdwnChunks, E as chunkSlackMrkdwnText, F as SLACK_TEXT_LIMIT, P as SLACK_MESSAGE_TEXT_HARD_LIMIT, S as createSlackNativeDataBaseTextConsumer, T as stripSlackNativeDataBlocks, Z as validateSlackBlocksArray, b as appendSlackNativeDataPlainTextFallback, i as assertSlackDirectSendAllowed, j as renderSlackBlockFallbackText, w as isSlackInvalidBlocksError, x as buildSlackNativeDataAccessibilityText, z as truncateSlackText } from "./group-policy-C-b2ZnSl.js";
 import { n as resolveSlackThreadTsValue, t as normalizeSlackThreadTsCandidate } from "./thread-ts-DUGhaYKq.js";
-import { a as getSlackWriteClient, n as createSlackTokenCacheKey, r as createSlackWebClient } from "./client-DGxwSL7f.js";
-import { t as getOptionalSlackRuntime } from "./runtime-BOk7xkOl.js";
-import { t as markdownToSlackMrkdwnChunks } from "./format-YCNoNkM2.js";
-import { i as loadOutboundMediaFromUrl } from "./runtime-api-CEmqYxR-.js";
+import { i as createSlackWebClient, r as createSlackTokenCacheKey, s as getSlackWriteClient } from "./client-D2F6m8CP.js";
+import { t as getOptionalSlackRuntime } from "./runtime-CauEvswP.js";
+import { i as loadOutboundMediaFromUrl } from "./runtime-api-CVb6CQjX.js";
 import { normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { createMessageReceiptFromOutboundResults } from "openclaw/plugin-sdk/channel-outbound";
 import { logVerbose } from "openclaw/plugin-sdk/runtime-env";
-import { createHash, createHmac, timingSafeEqual } from "node:crypto";
+import { sliceUtf16Safe } 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 { resolveTextChunksWithFallback } from "openclaw/plugin-sdk/reply-payload";
+import { safeEqualSecret } from "openclaw/plugin-sdk/security-runtime";
+import { buildTimeoutAbortSignal } from "openclaw/plugin-sdk/extension-shared";
 import { fetchWithSsrFGuard } from "openclaw/plugin-sdk/ssrf-runtime";
 import { createPersistentDedupeCache } from "openclaw/plugin-sdk/dedupe-runtime";
-//#region extensions/slack/src/blocks-fallback.ts
-function cleanCandidate(value) {
-	if (typeof value !== "string") return;
-	const normalized = value.replace(/\s+/g, " ").trim();
-	return normalized.length > 0 ? normalized : void 0;
-}
-function readSectionText(block) {
-	return cleanCandidate(block.text?.text);
-}
-function readHeaderText(block) {
-	return cleanCandidate(block.text?.text);
-}
-function readImageText(block) {
-	return cleanCandidate(block.alt_text) ?? cleanCandidate(block.title?.text);
-}
-function readVideoText(block) {
-	return cleanCandidate(block.title?.text) ?? cleanCandidate(block.alt_text);
-}
-function readContextText(block) {
-	if (!Array.isArray(block.elements)) return;
-	const textParts = block.elements.map((element) => cleanCandidate(element.text)).filter((value) => Boolean(value));
-	return textParts.length > 0 ? textParts.join(" ") : void 0;
-}
-function buildSlackBlocksFallbackText(blocks) {
-	for (const raw of blocks) {
-		const block = raw;
-		switch (block.type) {
-			case "header": {
-				const text = readHeaderText(block);
-				if (text) return text;
-				break;
-			}
-			case "section": {
-				const text = readSectionText(block);
-				if (text) return text;
-				break;
-			}
-			case "image": {
-				const text = readImageText(block);
-				if (text) return text;
-				return "Shared an image";
-			}
-			case "video": {
-				const text = readVideoText(block);
-				if (text) return text;
-				return "Shared a video";
-			}
-			case "file": return "Shared a file";
-			case "context": {
-				const text = readContextText(block);
-				if (text) return text;
-				break;
+//#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;
+}
+function buildPlainTextBlocks(text) {
+	return chunkSlackTextAtHardLimit(text, SLACK_SECTION_PLAIN_TEXT_MAX).map((chunk, index) => {
+		const fallbackBlock = {
+			block: {
+				type: "section",
+				text: {
+					type: "plain_text",
+					text: chunk
+				}
+			},
+			text: chunk
+		};
+		if (index > 0) fallbackBlock.continuesText = true;
+		return fallbackBlock;
+	});
+}
+function renderNativeDataPlainText(block) {
+	return appendSlackNativeDataPlainTextFallback("", [block]).trim() || "Slack could not render this chart or table data.";
+}
+function buildOrderedFallbackBlocks(params) {
+	const entries = [];
+	const consumeFromBase = createSlackNativeDataBaseTextConsumer(params.baseText);
+	if (params.baseText) entries.push(...buildPlainTextBlocks(params.baseText));
+	for (const block of params.blocks) {
+		if (hasSlackNativeDataBlock([block])) {
+			const nativeText = renderNativeDataPlainText(block);
+			if (!consumeFromBase(nativeText)) entries.push(...buildPlainTextBlocks(nativeText));
+			continue;
+		}
+		const text = renderSlackBlockFallbackText(block, { nativeDataFormat: "plain" });
+		entries.push({
+			block,
+			...text ? { text } : {}
+		});
+	}
+	return entries;
+}
+function buildOrderedBlockMessages(entries) {
+	const messages = [];
+	let blocks = [];
+	let text = "";
+	const flush = () => {
+		if (blocks.length === 0) return;
+		messages.push({
+			text: text || SLACK_EMPTY_BLOCK_FALLBACK,
+			blocks,
+			mrkdwn: false
+		});
+		blocks = [];
+		text = "";
+	};
+	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();
+		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.");
+		blocks.push(entry.block);
+		text = freshText;
+	}
+	flush();
+	return messages;
+}
+/** Build one complete, ordered retry plan after Slack rejects native data blocks. */
+function buildSlackNativeDataDeliveryPlan(params) {
+	const baseText = params.baseText?.trim() ?? "";
+	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) => ({
+			text,
+			mrkdwn: false
+		})) : buildOrderedBlockMessages(buildOrderedFallbackBlocks({
+			baseText,
+			blocks: params.blocks
+		})),
+		skipOriginalBlocks: accessibilityText.length > SLACK_MESSAGE_TEXT_HARD_LIMIT
+	};
+}
+//#endregion
+//#region extensions/slack/src/post-message-identity.ts
+function normalizeSlackScopeList$1(value) {
+	if (!Array.isArray(value)) return [];
+	return value.flatMap((scope) => {
+		const normalized = normalizeOptionalString(scope);
+		return normalized ? [normalized] : [];
+	});
+}
+function getSlackWebApiErrorData$1(err) {
+	if (!(err instanceof Error)) return;
+	const data = err.data;
+	return data && typeof data === "object" ? data : void 0;
+}
+function isSlackCustomizeScopeError(err) {
+	const data = getSlackWebApiErrorData$1(err);
+	if (normalizeLowercaseStringOrEmpty(normalizeOptionalString(data?.error)) !== "missing_scope") return false;
+	if (normalizeLowercaseStringOrEmpty(normalizeOptionalString(data?.needed)).includes("chat:write.customize")) return true;
+	return [...normalizeSlackScopeList$1(data?.response_metadata?.scopes), ...normalizeSlackScopeList$1(data?.response_metadata?.acceptedScopes)].map((scope) => normalizeLowercaseStringOrEmpty(scope)).includes("chat:write.customize");
+}
+function isSlackCustomIdentityRejectedError(err) {
+	if (isSlackCustomizeScopeError(err)) return true;
+	const code = normalizeLowercaseStringOrEmpty(normalizeOptionalString(getSlackWebApiErrorData$1(err)?.error));
+	return code === "invalid_arguments" || code === "invalid_arg_name";
+}
+function hasCustomIdentity$1(identity) {
+	return Boolean(identity?.username || identity?.iconUrl || identity?.iconEmoji);
+}
+/** Post with the requested identity, degrading only on Slack identity-specific errors. */
+async function postSlackMessageWithIdentityFallback(params) {
+	const { basePayload, identity, post } = params;
+	try {
+		if (identity?.iconUrl) return await post({
+			...basePayload,
+			...identity.username ? { username: identity.username } : {},
+			icon_url: identity.iconUrl
+		}, identity);
+		if (identity?.iconEmoji) return await post({
+			...basePayload,
+			...identity.username ? { username: identity.username } : {},
+			icon_emoji: identity.iconEmoji
+		}, identity);
+		return await post({
+			...basePayload,
+			...identity?.username ? { username: identity.username } : {}
+		}, identity);
+	} catch (err) {
+		if (!identity || !hasCustomIdentity$1(identity) || !isSlackCustomIdentityRejectedError(err)) throw err;
+		if (!isSlackCustomizeScopeError(err) && identity.username && (identity.iconUrl || identity.iconEmoji)) {
+			logVerbose("slack send: custom icon rejected, retrying with username only");
+			try {
+				return await post({
+					...basePayload,
+					username: identity.username
+				}, { username: identity.username });
+			} catch (retryError) {
+				if (!isSlackCustomIdentityRejectedError(retryError)) throw retryError;
 			}
-			default: break;
 		}
+		logVerbose("slack send: custom identity rejected, retrying without custom identity");
+		return post(basePayload);
+	}
+}
+//#endregion
+//#region extensions/slack/src/post-message-payload.ts
+function buildSlackUnfurlPayload(options) {
+	return {
+		unfurl_links: options?.unfurlLinks ?? false,
+		...typeof options?.unfurlMedia === "boolean" ? { unfurl_media: options.unfurlMedia } : {}
+	};
+}
+function buildSlackPostMessagePayload(params) {
+	const threadPayload = params.replyBroadcast && params.threadTs ? {
+		thread_ts: params.threadTs,
+		reply_broadcast: true
+	} : params.threadTs ? { thread_ts: params.threadTs } : {};
+	const unfurlPayload = buildSlackUnfurlPayload(params.unfurl);
+	if (params.blocks?.length) return {
+		channel: params.channelId,
+		text: params.text,
+		blocks: params.blocks,
+		...params.metadata ? { metadata: params.metadata } : {},
+		...typeof params.mrkdwn === "boolean" ? { mrkdwn: params.mrkdwn } : {},
+		...threadPayload,
+		...unfurlPayload
+	};
+	return {
+		channel: params.channelId,
+		text: params.text,
+		...params.metadata ? { metadata: params.metadata } : {},
+		...typeof params.mrkdwn === "boolean" ? { mrkdwn: params.mrkdwn } : {},
+		...threadPayload,
+		...unfurlPayload
+	};
+}
+//#endregion
+//#region extensions/slack/src/client-delivery.ts
+const SLACK_COMMERCIAL_API_HOSTNAME = "slack.com";
+const SLACK_COMMERCIAL_UPLOAD_HOSTNAME = "files.slack.com";
+const SLACK_GOV_API_HOSTNAME = "slack-gov.com";
+const SLACK_GOV_UPLOAD_HOSTNAME = "files.slack-gov.com";
+const SLACK_COMMERCIAL_UPLOAD_SSRF_POLICY = {
+	hostnameAllowlist: [SLACK_COMMERCIAL_UPLOAD_HOSTNAME],
+	allowRfc2544BenchmarkRange: true
+};
+const SLACK_GOV_UPLOAD_SSRF_POLICY = {
+	hostnameAllowlist: [SLACK_GOV_UPLOAD_HOSTNAME],
+	allowRfc2544BenchmarkRange: true
+};
+const SLACK_UPLOAD_POST_TIMEOUT_MS = 12e4;
+const SLACK_DNS_RETRY_CODES = /* @__PURE__ */ new Set([
+	"EAI_AGAIN",
+	"ENOTFOUND",
+	"UND_ERR_DNS_RESOLVE_FAILED"
+]);
+const SLACK_DNS_RETRY_ATTEMPTS = 2;
+const SLACK_DNS_RETRY_BASE_DELAY_MS = 250;
+function readSlackRequestErrorCode(value) {
+	if (!value || typeof value !== "object") return;
+	const code = value.code;
+	return typeof code === "string" ? code.toUpperCase() : void 0;
+}
+function readSlackRequestErrorMessage$1(value) {
+	if (value instanceof Error) return value.message;
+	return typeof value === "string" ? value : "";
+}
+function hasSlackDnsRequestSignal(err) {
+	let current = err;
+	const seen = /* @__PURE__ */ new Set();
+	for (let depth = 0; current && typeof current === "object" && depth < 6; depth += 1) {
+		if (seen.has(current)) return false;
+		seen.add(current);
+		const code = readSlackRequestErrorCode(current);
+		if (code && SLACK_DNS_RETRY_CODES.has(code)) return true;
+		const message = readSlackRequestErrorMessage$1(current);
+		if (/\b(EAI_AGAIN|ENOTFOUND|UND_ERR_DNS_RESOLVE_FAILED)\b/i.test(message)) return true;
+		current = current.original ?? current.cause;
+	}
+	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;
+	} catch {
+		return;
+	}
+}
+function buildSlackUploadFailureCause(error) {
+	const httpStatus = error instanceof Error ? /^Failed to upload file: HTTP (\d{3})$/u.exec(error.message)?.[1] : void 0;
+	const cause = /* @__PURE__ */ new Error(httpStatus ? `Slack external upload returned HTTP ${httpStatus}` : "Slack external upload transfer failed");
+	cause.name = readErrorName(error) || cause.name;
+	const code = extractErrorCode(error) ?? (httpStatus ? `HTTP_${httpStatus}` : void 0);
+	if (code) cause.code = code;
+	return cause;
+}
+function parseSlackUploadHttpUrl(value, label) {
+	try {
+		const parsed = new URL(value);
+		if (parsed.protocol === "http:" || parsed.protocol === "https:") return parsed;
+	} catch {}
+	throw new Error(`${label} must use a valid HTTP or HTTPS URL`);
+}
+function normalizeSlackHostname(hostname) {
+	return hostname.trim().toLowerCase().replace(/\.$/, "");
+}
+function resolveSlackOwnedUploadPolicy(url) {
+	if (url.protocol !== "https:") return;
+	switch (normalizeSlackHostname(url.hostname)) {
+		case SLACK_COMMERCIAL_UPLOAD_HOSTNAME: return SLACK_COMMERCIAL_UPLOAD_SSRF_POLICY;
+		case SLACK_GOV_UPLOAD_HOSTNAME: return SLACK_GOV_UPLOAD_SSRF_POLICY;
+		default: return;
+	}
+}
+function resolveOfficialSlackApiUploadPolicy(url) {
+	if (url.protocol !== "https:" || url.port) return;
+	switch (normalizeSlackHostname(url.hostname)) {
+		case SLACK_COMMERCIAL_API_HOSTNAME: return SLACK_COMMERCIAL_UPLOAD_SSRF_POLICY;
+		case SLACK_GOV_API_HOSTNAME: return SLACK_GOV_UPLOAD_SSRF_POLICY;
+		default: return;
+	}
+}
+function normalizeSlackOrigin(url) {
+	const port = url.port ? `:${url.port}` : "";
+	return `${url.protocol}//${normalizeSlackHostname(url.hostname)}${port}`;
+}
+function resolveSlackUploadTransportPolicy(params) {
+	if (!params.slackApiUrl) return {
+		requireHttps: true,
+		policy: SLACK_COMMERCIAL_UPLOAD_SSRF_POLICY
+	};
+	const apiUrl = parseSlackUploadHttpUrl(params.slackApiUrl, "Configured Slack API URL");
+	const officialApiPolicy = resolveOfficialSlackApiUploadPolicy(apiUrl);
+	if (officialApiPolicy) return {
+		requireHttps: true,
+		policy: officialApiPolicy
+	};
+	const uploadUrl = parseSlackUploadHttpUrl(params.uploadUrl, "Slack external upload URL");
+	const slackOwnedUploadPolicy = resolveSlackOwnedUploadPolicy(uploadUrl);
+	if (slackOwnedUploadPolicy) return {
+		requireHttps: true,
+		policy: slackOwnedUploadPolicy
+	};
+	if (normalizeSlackOrigin(uploadUrl) !== normalizeSlackOrigin(apiUrl)) throw new Error("Slack external upload URL must match the configured Slack API origin");
+	return {
+		requireHttps: apiUrl.protocol === "https:",
+		policy: {
+			hostnameAllowlist: [uploadUrl.hostname],
+			allowedOrigins: [uploadUrl.origin],
+			allowRfc2544BenchmarkRange: true
+		}
+	};
+}
+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);
 	}
-	return "Shared a Block Kit message";
+	throw new Error("unreachable Slack DNS retry loop exit");
+}
+async function postSlackMessageBestEffort(params) {
+	const basePayload = buildSlackPostMessagePayload(params);
+	const postChatMessage = params.client.chat.postMessage.bind(params.client.chat);
+	const post = async (payload, identity) => ({
+		response: await withSlackDnsRequestRetry("chat.postMessage", () => postChatMessage(payload)),
+		identity
+	});
+	return await postSlackMessageWithIdentityFallback({
+		basePayload,
+		identity: params.identity,
+		post
+	});
+}
+async function uploadSlackFile(params) {
+	const { buffer, contentType, fileName } = await loadOutboundMediaFromUrl(params.mediaUrl, {
+		maxBytes: params.maxBytes,
+		mediaAccess: params.mediaAccess,
+		mediaLocalRoots: params.mediaLocalRoots,
+		mediaReadFile: params.mediaReadFile
+	});
+	const uploadFileName = params.uploadFileName ?? fileName ?? "upload";
+	const uploadTitle = params.uploadTitle ?? uploadFileName;
+	const uploadUrlResp = await withSlackDnsRequestRetry("files.getUploadURLExternal", () => params.client.files.getUploadURLExternal({
+		filename: uploadFileName,
+		length: buffer.length
+	}));
+	if (!uploadUrlResp.ok || !uploadUrlResp.upload_url || !uploadUrlResp.file_id) throw new Error(`Failed to get upload URL: ${uploadUrlResp.error ?? "unknown error"}`);
+	const uploadFileId = uploadUrlResp.file_id;
+	const uploadTransport = resolveSlackUploadTransportPolicy({
+		uploadUrl: uploadUrlResp.upload_url,
+		slackApiUrl: params.client.slackApiUrl
+	});
+	const { signal: uploadTimeoutSignal, cleanup: cleanupUploadTimeout } = buildTimeoutAbortSignal({
+		timeoutMs: SLACK_UPLOAD_POST_TIMEOUT_MS,
+		operation: "slack-upload-file",
+		url: resolveSlackUploadTimeoutLogUrl(uploadUrlResp.upload_url)
+	});
+	try {
+		const { response: uploadResp, release } = await fetchWithSsrFGuard(withTrustedEnvProxyGuardedFetchMode({
+			url: uploadUrlResp.upload_url,
+			init: {
+				method: "POST",
+				...contentType ? { headers: { "Content-Type": contentType } } : {},
+				body: new Uint8Array(buffer)
+			},
+			signal: uploadTimeoutSignal,
+			requireHttps: uploadTransport.requireHttps,
+			policy: uploadTransport.policy,
+			capture: false,
+			auditContext: params.auditContext ?? "slack-upload-file"
+		}));
+		try {
+			if (uploadResp.status !== 200) throw new Error(`Failed to upload file: HTTP ${uploadResp.status}`);
+		} finally {
+			await uploadResp.body?.cancel().catch(() => void 0);
+			await release();
+		}
+	} catch (error) {
+		throw new PlatformMessageNotDispatchedError(`Slack external upload ${uploadTimeoutSignal?.aborted ? "timed out" : "failed"} before completion dispatch`, { cause: buildSlackUploadFailureCause(error) });
+	} finally {
+		cleanupUploadTimeout();
+	}
+	await params.onPlatformSendDispatch?.();
+	const completionClient = params.completionClient ?? params.client;
+	const completeResp = await withSlackDnsRequestRetry("files.completeUploadExternal", () => completionClient.files.completeUploadExternal({
+		files: [{
+			id: uploadFileId,
+			title: uploadTitle
+		}],
+		channel_id: params.channelId,
+		...params.caption ? { initial_comment: params.caption } : {},
+		...params.threadTs ? { thread_ts: params.threadTs } : {}
+	}));
+	if (!completeResp.ok) throw new Error(`Failed to complete upload: ${completeResp.error ?? "unknown error"}`);
+	return uploadFileId;
 }
 //#endregion
 //#region extensions/slack/src/sent-thread-cache.ts
@@ -97,45 +440,30 @@ const threadParticipation = createPersistentDedupeCache({
 		}
 	}
 });
-function makeKey(accountId, channelId, threadTs) {
-	return `${accountId}:${channelId}:${threadTs}`;
+function makeKey(accountId, channelId, threadTs, teamId) {
+	return `${accountId}:${teamId ? `${teamId}:` : ""}${channelId}:${threadTs}`;
 }
 function recordSlackThreadParticipation(accountId, channelId, threadTs, opts) {
 	if (!accountId || !channelId || !threadTs) return;
-	threadParticipation.register(makeKey(accountId, channelId, threadTs), {
+	threadParticipation.register(makeKey(accountId, channelId, threadTs, opts?.teamId), {
 		...opts?.agentId ? { agentId: opts.agentId } : {},
 		repliedAt: Date.now()
 	});
 }
-function hasSlackThreadParticipation(accountId, channelId, threadTs) {
+function hasSlackThreadParticipation(accountId, channelId, threadTs, teamId) {
 	if (!accountId || !channelId || !threadTs) return false;
-	return threadParticipation.peek(makeKey(accountId, channelId, threadTs));
+	return threadParticipation.peek(makeKey(accountId, channelId, threadTs, teamId));
 }
 async function hasSlackThreadParticipationWithPersistence(params) {
 	if (!params.accountId || !params.channelId || !params.threadTs) return false;
-	return await threadParticipation.lookup(makeKey(params.accountId, params.channelId, params.threadTs));
+	return await threadParticipation.lookup(makeKey(params.accountId, params.channelId, params.threadTs, params.teamId));
 }
 function clearSlackThreadParticipationCache() {
 	threadParticipation.clearForTest();
 }
 //#endregion
 //#region extensions/slack/src/send.ts
-const SLACK_UPLOAD_SSRF_POLICY = {
-	allowedHostnames: [
-		"*.slack.com",
-		"*.slack-edge.com",
-		"*.slack-files.com"
-	],
-	allowRfc2544BenchmarkRange: true
-};
 const SLACK_DM_CHANNEL_CACHE_MAX = 1024;
-const SLACK_DNS_RETRY_CODES = /* @__PURE__ */ new Set([
-	"EAI_AGAIN",
-	"ENOTFOUND",
-	"UND_ERR_DNS_RESOLVE_FAILED"
-]);
-const SLACK_DNS_RETRY_ATTEMPTS = 2;
-const SLACK_DNS_RETRY_BASE_DELAY_MS = 250;
 const SLACK_DELIVERY_METADATA_EVENT = "openclaw_delivery";
 const SLACK_DELIVERY_METADATA_KEY = "openclaw_delivery_id";
 const SLACK_DELIVERY_METADATA_PART_INDEX_KEY = "openclaw_delivery_part_index";
@@ -145,7 +473,8 @@ const SLACK_RECONCILE_LOOKBACK_MS = 3e4;
 const SLACK_RECONCILE_CLOCK_SKEW_MS = 5 * 6e4;
 const SLACK_RECONCILE_LIMIT = 100;
 const SLACK_RECONCILE_MAX_PAGES = 10;
-const slackDmChannelCache = /* @__PURE__ */ new Map();
+const SLACK_ENTERPRISE_LISTENER_QUEUE_CREDENTIAL = "listener-scoped-enterprise";
+const slackDmChannelCaches = /* @__PURE__ */ new WeakMap();
 const slackSendQueue = new KeyedAsyncQueue();
 const slackDefaultSendIdentities = /* @__PURE__ */ new Map();
 function hasCustomIdentity(identity) {
@@ -176,34 +505,6 @@ function getSlackDefaultSendIdentity(accountId) {
 function resolveSlackSendIdentity(params) {
 	return normalizeSlackSendIdentity(params.explicit) ?? getSlackDefaultSendIdentity(params.accountId);
 }
-function buildSlackUnfurlPayload(options) {
-	return {
-		unfurl_links: options?.unfurlLinks ?? false,
-		...typeof options?.unfurlMedia === "boolean" ? { unfurl_media: options.unfurlMedia } : {}
-	};
-}
-function buildSlackPostMessagePayload(params) {
-	const threadPayload = params.replyBroadcast && params.threadTs ? {
-		thread_ts: params.threadTs,
-		reply_broadcast: true
-	} : params.threadTs ? { thread_ts: params.threadTs } : {};
-	const unfurlPayload = buildSlackUnfurlPayload(params.unfurl);
-	if (params.blocks?.length) return {
-		channel: params.channelId,
-		text: params.text,
-		blocks: params.blocks,
-		...params.metadata ? { metadata: params.metadata } : {},
-		...threadPayload,
-		...unfurlPayload
-	};
-	return {
-		channel: params.channelId,
-		text: params.text,
-		...params.metadata ? { metadata: params.metadata } : {},
-		...threadPayload,
-		...unfurlPayload
-	};
-}
 function normalizeSlackScopeList(value) {
 	if (!Array.isArray(value)) return [];
 	return value.flatMap((scope) => {
@@ -236,96 +537,10 @@ function enrichSlackWebApiError(err) {
 	if (!message || !(err instanceof Error) || message === err.message) return err;
 	return new Error(message);
 }
-function readSlackRequestErrorCode(value) {
-	if (!value || typeof value !== "object") return;
-	const code = value.code;
-	return typeof code === "string" ? code.toUpperCase() : void 0;
-}
 function readSlackRequestErrorMessage(value) {
 	if (value instanceof Error) return value.message;
 	return typeof value === "string" ? value : "";
 }
-function hasSlackDnsRequestSignal(err) {
-	let current = err;
-	const seen = /* @__PURE__ */ new Set();
-	for (let depth = 0; current && typeof current === "object" && depth < 6; depth += 1) {
-		if (seen.has(current)) return false;
-		seen.add(current);
-		const code = readSlackRequestErrorCode(current);
-		if (code && SLACK_DNS_RETRY_CODES.has(code)) return true;
-		const message = readSlackRequestErrorMessage(current);
-		if (/\b(EAI_AGAIN|ENOTFOUND|UND_ERR_DNS_RESOLVE_FAILED)\b/i.test(message)) return true;
-		current = current.original ?? current.cause;
-	}
-	return false;
-}
-function delaySlackDnsRetry(attempt) {
-	return new Promise((resolve) => {
-		setTimeout(resolve, SLACK_DNS_RETRY_BASE_DELAY_MS * Math.max(1, attempt));
-	});
-}
-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");
-}
-function isSlackCustomizeScopeError(err) {
-	const data = getSlackWebApiErrorData(err);
-	if (normalizeLowercaseStringOrEmpty(normalizeOptionalString(data?.error)) !== "missing_scope") return false;
-	if (normalizeLowercaseStringOrEmpty(normalizeOptionalString(data?.needed))?.includes("chat:write.customize")) return true;
-	return [...normalizeSlackScopeList(data?.response_metadata?.scopes), ...normalizeSlackScopeList(data?.response_metadata?.acceptedScopes)].map((scope) => normalizeLowercaseStringOrEmpty(scope)).includes("chat:write.customize");
-}
-function isSlackCustomIdentityRejectedError(err) {
-	if (isSlackCustomizeScopeError(err)) return true;
-	const code = normalizeLowercaseStringOrEmpty(normalizeOptionalString(getSlackWebApiErrorData(err)?.error));
-	return code === "invalid_arguments" || code === "invalid_arg_name";
-}
-async function postSlackMessageBestEffort(params) {
-	const basePayload = buildSlackPostMessagePayload(params);
-	const postChatMessage = params.client.chat.postMessage.bind(params.client.chat);
-	const post = async (payload, identity) => ({
-		response: await withSlackDnsRequestRetry("chat.postMessage", () => postChatMessage(payload)),
-		identity
-	});
-	try {
-		const identity = params.identity;
-		if (identity?.iconUrl) return await post({
-			...basePayload,
-			...identity.username ? { username: identity.username } : {},
-			icon_url: identity.iconUrl
-		}, identity);
-		if (identity?.iconEmoji) return await post({
-			...basePayload,
-			...identity.username ? { username: identity.username } : {},
-			icon_emoji: identity.iconEmoji
-		}, identity);
-		return await post({
-			...basePayload,
-			...identity?.username ? { username: identity.username } : {}
-		}, identity);
-	} catch (err) {
-		const identity = params.identity;
-		if (!identity || !hasCustomIdentity(identity) || !isSlackCustomIdentityRejectedError(err)) throw err;
-		if (!isSlackCustomizeScopeError(err) && identity.username && (identity.iconUrl || identity.iconEmoji)) {
-			logVerbose("slack send: custom icon rejected, retrying with username only");
-			try {
-				return await post({
-					...basePayload,
-					username: identity.username
-				}, { username: identity.username });
-			} catch (retryError) {
-				if (!isSlackCustomIdentityRejectedError(retryError)) throw retryError;
-			}
-		}
-		logVerbose("slack send: custom identity rejected, retrying without custom identity");
-		return post(basePayload);
-	}
-}
 function resolvePostedMessageThreadTs(response) {
 	const threadTs = response.message?.thread_ts;
 	return typeof threadTs === "string" ? normalizeSlackThreadTsCandidate(threadTs) : void 0;
@@ -359,12 +574,54 @@ function parseRecipient(raw) {
 	if (!target) throw new Error("Recipient is required for Slack sends");
 	return {
 		kind: target.kind,
-		id: target.id
+		id: canonicalizeSlackApiTargetId(target.kind, target.id, raw)
 	};
 }
+function parseEnterpriseEventRecipient(raw) {
+	const match = /^(?:channel:)?([CDG][A-Z0-9]+)$/i.exec(raw.trim());
+	if (!match?.[1]) throw new Error("unsupported_enterprise_slack_delivery_target");
+	return {
+		kind: "channel",
+		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");
+	return scope;
+}
+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);
+	if (params.preservePlainText) {
+		const chunks = [];
+		let remaining = text;
+		while (remaining) {
+			const chunk = sliceUtf16Safe(remaining, 0, chunkLimit) || Array.from(remaining)[0] || "";
+			chunks.push(chunk);
+			remaining = remaining.slice(chunk.length);
+		}
+		return chunks;
+	}
+	if (params.textIsSlackMrkdwn) return resolveTextChunksWithFallback(text, chunkSlackMrkdwnText(text, chunkLimit));
+	const tableMode = resolveMarkdownTableMode({
+		cfg: params.cfg,
+		channel: "slack",
+		...params.accountId ? { accountId: params.accountId } : {}
+	});
+	const chunkMode = resolveChunkMode(params.cfg, "slack", params.accountId);
+	return resolveTextChunksWithFallback(text, (chunkMode === "newline" ? chunkMarkdownTextWithMode(text, chunkLimit, chunkMode) : [text]).flatMap((markdown) => markdownToSlackMrkdwnChunks(markdown, chunkLimit, { tableMode })));
+}
 function createSlackSendQueueKey(params) {
-	const recipientKey = `${params.recipient.kind === "user" || /^U[A-Z0-9]+$/i.test(params.recipient.id) ? "user" : params.recipient.kind}:${params.recipient.id}`;
-	return `${params.accountId}:${createSlackTokenCacheKey(params.token)}:${recipientKey}:${params.threadTs ?? ""}`;
+	const recipientKey = `${params.recipient.kind}:${params.recipient.id}`;
+	const workspaceScope = params.teamId ? `:${params.teamId}` : "";
+	return `${params.accountId}:${createSlackTokenCacheKey(params.token)}${workspaceScope}:${recipientKey}:${params.threadTs ?? ""}`;
 }
 async function runQueuedSlackSend(key, task) {
 	return await slackSendQueue.enqueue(key, task);
@@ -372,16 +629,23 @@ async function runQueuedSlackSend(key, task) {
 function createSlackDmCacheKey(params) {
 	return `${params.accountId ?? "default"}:${createSlackTokenCacheKey(params.token)}:${params.recipientId}`;
 }
-function setSlackDmChannelCache(key, channelId) {
-	if (slackDmChannelCache.has(key)) slackDmChannelCache.delete(key);
-	else if (slackDmChannelCache.size >= SLACK_DM_CHANNEL_CACHE_MAX) {
-		const oldest = slackDmChannelCache.keys().next().value;
-		if (oldest) slackDmChannelCache.delete(oldest);
+function getSlackDmChannelCache(client) {
+	const existing = slackDmChannelCaches.get(client);
+	if (existing) return existing;
+	const cache = /* @__PURE__ */ new Map();
+	slackDmChannelCaches.set(client, cache);
+	return cache;
+}
+function setSlackDmChannelCache(cache, key, channelId) {
+	if (cache.has(key)) cache.delete(key);
+	else if (cache.size >= SLACK_DM_CHANNEL_CACHE_MAX) {
+		const oldest = cache.keys().next().value;
+		if (oldest) cache.delete(oldest);
 	}
-	slackDmChannelCache.set(key, channelId);
+	cache.set(key, channelId);
 }
 function isSlackUserRecipient(recipient) {
-	return recipient.kind === "user" || /^U[A-Z0-9]+$/i.test(recipient.id);
+	return recipient.kind === "user";
 }
 function resolveDirectUserPostChannelId(params) {
 	if (!isSlackUserRecipient(params.recipient) || params.hasMedia || params.threadTs) return;
@@ -397,7 +661,8 @@ async function resolveChannelId(client, recipient, params) {
 		token: params.token,
 		recipientId: recipient.id
 	});
-	const cachedChannelId = slackDmChannelCache.get(cacheKey);
+	const cache = getSlackDmChannelCache(client);
+	const cachedChannelId = cache.get(cacheKey);
 	if (cachedChannelId) return {
 		channelId: cachedChannelId,
 		isDm: true,
@@ -405,7 +670,7 @@ async function resolveChannelId(client, recipient, params) {
 	};
 	const channelId = (await withSlackDnsRequestRetry("conversations.open", () => client.conversations.open({ users: recipient.id }))).channel?.id;
 	if (!channelId) throw new Error("Failed to open Slack DM channel");
-	setSlackDmChannelCache(cacheKey, channelId);
+	setSlackDmChannelCache(cache, cacheKey, channelId);
 	return {
 		channelId,
 		isDm: true,
@@ -435,10 +700,6 @@ function createSlackDeliveryMetadataSignature(params) {
 		params.partCount
 	])).digest("base64url");
 }
-function matchesSlackDeliveryMetadataSignature(actual, expected) {
-	if (typeof actual !== "string" || actual.length !== expected.length) return false;
-	return timingSafeEqual(Buffer.from(actual), Buffer.from(expected));
-}
 function withSlackDeliveryMetadata(metadata, params) {
 	const queueId = normalizeOptionalString(params.queueId);
 	const deliveryId = createSlackDeliveryMetadataId(queueId);
@@ -497,7 +758,8 @@ function findSlackConversationDeliveryParts(params) {
 			partIndex,
 			partCount
 		});
-		if (!matchesSlackDeliveryMetadataSignature(marker[SLACK_DELIVERY_METADATA_SIGNATURE_KEY], expectedSignature)) continue;
+		const actualSignature = marker[SLACK_DELIVERY_METADATA_SIGNATURE_KEY];
+		if (typeof actualSignature !== "string" || !safeEqualSecret(actualSignature, expectedSignature)) continue;
 		const messageId = typeof message.ts === "string" ? normalizeSlackThreadTsCandidate(message.ts) : void 0;
 		if (!messageId) continue;
 		const threadTs = typeof message.thread_ts === "string" ? normalizeSlackThreadTsCandidate(message.thread_ts) : void 0;
@@ -674,53 +936,24 @@ async function reconcileSlackUnknownSend(ctx, opts) {
 		};
 	}
 }
-async function uploadSlackFile(params) {
-	const { buffer, contentType, fileName } = await loadOutboundMediaFromUrl(params.mediaUrl, {
-		maxBytes: params.maxBytes,
-		mediaAccess: params.mediaAccess,
-		mediaLocalRoots: params.mediaLocalRoots,
-		mediaReadFile: params.mediaReadFile
-	});
-	const uploadFileName = params.uploadFileName ?? fileName ?? "upload";
-	const uploadTitle = params.uploadTitle ?? uploadFileName;
-	const uploadUrlResp = await withSlackDnsRequestRetry("files.getUploadURLExternal", () => params.client.files.getUploadURLExternal({
-		filename: uploadFileName,
-		length: buffer.length
-	}));
-	if (!uploadUrlResp.ok || !uploadUrlResp.upload_url || !uploadUrlResp.file_id) throw new Error(`Failed to get upload URL: ${uploadUrlResp.error ?? "unknown error"}`);
-	const uploadFileId = uploadUrlResp.file_id;
-	const uploadBody = new Uint8Array(buffer);
-	const { response: uploadResp, release } = await fetchWithSsrFGuard(withTrustedEnvProxyGuardedFetchMode({
-		url: uploadUrlResp.upload_url,
-		init: {
-			method: "POST",
-			...contentType ? { headers: { "Content-Type": contentType } } : {},
-			body: uploadBody
-		},
-		policy: SLACK_UPLOAD_SSRF_POLICY,
-		auditContext: "slack-upload-file"
-	}));
-	try {
-		if (!uploadResp.ok) throw new Error(`Failed to upload file: HTTP ${uploadResp.status}`);
-	} finally {
-		await release();
-	}
-	await params.onPlatformSendDispatch?.();
-	const completeResp = await withSlackDnsRequestRetry("files.completeUploadExternal", () => params.client.files.completeUploadExternal({
-		files: [{
-			id: uploadFileId,
-			title: uploadTitle
-		}],
-		channel_id: params.channelId,
-		...params.caption ? { initial_comment: params.caption } : {},
-		...params.threadTs ? { thread_ts: params.threadTs } : {}
-	}));
-	if (!completeResp.ok) throw new Error(`Failed to complete upload: ${completeResp.error ?? "unknown error"}`);
-	return uploadFileId;
-}
 async function sendMessageSlack(to, message, opts) {
-	const trimmedMessage = normalizeOptionalString(message) ?? "";
-	if (isSilentReplyText(trimmedMessage) && !opts.mediaUrl && !opts.blocks) {
+	const normalizedMessage = normalizeOptionalString(message) ?? "";
+	const trimmedMessage = opts.textIsSlackPlainText && normalizedMessage ? message : normalizedMessage;
+	const cfg = requireRuntimeConfig(opts.cfg, "Slack send");
+	const account = resolveSlackAccount({
+		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",
@@ -732,35 +965,38 @@ async function sendMessageSlack(to, message, opts) {
 		};
 	}
 	const blocks = opts.blocks == null ? void 0 : validateSlackBlocksArray(opts.blocks);
-	if (!trimmedMessage && !opts.mediaUrl && !blocks) throw new Error("Slack send requires text, blocks, or media");
-	const cfg = requireRuntimeConfig(opts.cfg, "Slack send");
-	const account = resolveSlackAccount({
-		cfg,
-		accountId: opts.accountId
-	});
-	const token = resolveToken({
+	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: account.botToken,
 		fallbackSource: account.botTokenSource
 	});
-	const recipient = parseRecipient(to);
-	const result = await runQueuedSlackSend(createSlackSendQueueKey({
+	const recipient = enterpriseDelivery ? parseEnterpriseEventRecipient(to) : parseRecipient(to);
+	const queueKey = createSlackSendQueueKey({
 		accountId: account.accountId,
 		token,
 		recipient,
-		threadTs: opts.threadTs
-	}), () => sendMessageSlackQueued({
+		threadTs: opts.threadTs,
+		...enterpriseDelivery ? { teamId: enterpriseDelivery.teamId } : {}
+	});
+	const queuedOpts = enterpriseDelivery ? Object.freeze({
+		...opts,
+		client: enterpriseDelivery.client
+	}) : opts;
+	const result = await runQueuedSlackSend(queueKey, () => sendMessageSlackQueued({
 		trimmedMessage,
-		opts,
+		opts: queuedOpts,
 		cfg,
 		account,
 		token,
 		recipient,
-		blocks
+		blocks,
+		...enterpriseDelivery ? { enterpriseDelivery } : {}
 	}));
-	const threadTs = result.threadTs ?? normalizeSlackThreadTsCandidate(opts.threadTs);
-	if (threadTs && result.channelId && account.accountId) recordSlackThreadParticipation(account.accountId, result.channelId, threadTs);
+	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);
 	return result;
 }
 async function sendMessageSlackQueued(params) {
@@ -771,14 +1007,14 @@ async function sendMessageSlackQueued(params) {
 	}
 }
 async function sendMessageSlackQueuedInner(params) {
-	const { opts, cfg, account, token, recipient, blocks, trimmedMessage } = params;
-	const client = opts.client ?? getSlackWriteClient(token);
-	const identity = resolveSlackSendIdentity({
+	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
 	});
 	if (opts.replyBroadcast && opts.mediaUrl) throw new Error("Slack replyBroadcast is only supported for text or block thread replies.");
-	const unfurl = {
+	const unfurl = enterpriseDelivery ? { unfurlMedia: account.config.unfurlMedia } : {
 		unfurlLinks: account.config.unfurlLinks,
 		unfurlMedia: account.config.unfurlMedia
 	};
@@ -795,55 +1031,153 @@ async function sendMessageSlackQueuedInner(params) {
 		await opts.onDeliveryResult?.(result);
 		return result;
 	};
-	if (blocks) {
-		if (opts.mediaUrl) throw new Error("Slack send does not support blocks with mediaUrl");
-		const fallbackText = truncateSlackText(trimmedMessage || buildSlackBlocksFallbackText(blocks), SLACK_TEXT_LIMIT);
+	let didDispatch = false;
+	const dispatchOnce = async () => {
+		if (didDispatch) return;
+		didDispatch = true;
 		await opts.onPlatformSendDispatch?.();
-		const { response } = await postSlackMessageBestEffort({
-			client,
-			channelId,
-			text: fallbackText,
-			threadTs: opts.threadTs,
-			replyBroadcast: opts.replyBroadcast,
-			identity,
-			blocks,
-			metadata: opts.metadata,
-			unfurl
-		});
-		const messageId = response.ts ?? "unknown";
-		const deliveredChannelId = resolvePostedMessageChannelId(response, channelId);
-		const deliveredThreadTs = resolvePostedMessageThreadTs(response) ?? normalizeSlackThreadTsCandidate(opts.threadTs);
-		return await reportDelivery({
-			messageId,
-			channelId: deliveredChannelId,
-			threadTs: deliveredThreadTs,
-			receipt: createSlackSendReceipt({
-				platformMessageIds: [messageId],
-				channelId: deliveredChannelId,
-				kind: "card",
-				threadTs: deliveredThreadTs
-			})
-		});
-	}
-	const textLimit = resolveTextChunkLimit(cfg, "slack", account.accountId, { fallbackLimit: SLACK_TEXT_LIMIT });
-	const chunkLimit = Math.min(textLimit, SLACK_TEXT_LIMIT);
-	const tableMode = resolveMarkdownTableMode({
-		cfg,
-		channel: "slack",
-		accountId: account.accountId
-	});
-	const chunkMode = resolveChunkMode(cfg, "slack", account.accountId);
-	const resolvedChunks = resolveTextChunksWithFallback(trimmedMessage, (chunkMode === "newline" ? chunkMarkdownTextWithMode(trimmedMessage, chunkLimit, chunkMode) : [trimmedMessage]).flatMap((markdown) => markdownToSlackMrkdwnChunks(markdown, chunkLimit, { tableMode })));
-	const mediaMaxBytes = typeof account.config.mediaMaxMb === "number" ? account.config.mediaMaxMb * 1024 * 1024 : void 0;
+	};
+	const explicitNativeDataFallbackBase = Object.hasOwn(opts, "nativeDataFallbackBaseText") ? opts.nativeDataFallbackBaseText?.trim() ?? "" : void 0;
+	const authoredTextPlacement = opts.authoredTextPlacement ?? "outside-blocks";
+	const nativeDataFallbackBase = blocks && authoredTextPlacement === "outside-blocks" ? explicitNativeDataFallbackBase ?? trimmedMessage : "";
+	const hasNativeData = Boolean(blocks && hasSlackNativeDataBlock(blocks));
+	const usesOrderedBlockAccessibility = Boolean(blocks && (hasNativeData || opts.authoredTextPlacement !== void 0));
+	const orderedBlockDeliveryPlan = blocks && usesOrderedBlockAccessibility ? buildSlackNativeDataDeliveryPlan({
+		baseText: nativeDataFallbackBase,
+		blocks
+	}) : 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) : "";
+	const rawBlockAccessibilityText = trimmedMessage ? [trimmedMessage, ...completeBlockFallbackText.includes(trimmedMessage) ? [] : [completeBlockFallbackText]].join("\n\n") : completeBlockFallbackText;
+	const blockAccessibilityText = blocks ? orderedBlockAccessibilityText ?? rawBlockAccessibilityText : void 0;
+	let pendingBlockFallback = (hasNativeData || opts.authoredTextPlacement !== void 0) && orderedBlockDeliveryPlan?.skipOriginalBlocks ? orderedBlockDeliveryPlan : void 0;
 	const sentMessageIds = [];
 	let lastMessageId = "";
 	let deliveredChannelId = channelId;
 	let canonicalDeliveredThreadTs;
+	let sendIdentity = identity;
+	if (blocks && opts.mediaUrl) throw new Error("Slack send does not support blocks with mediaUrl");
+	if (blocks) {
+		if (pendingBlockFallback) logVerbose("slack send: native data accessibility exceeds hard limit, using text fallback");
+		else {
+			const accessibilityText = hasNativeData ? blockAccessibilityText ?? "Slack could not render this Block Kit message." : usesOrderedBlockAccessibility ? blockAccessibilityText ?? "Slack could not render this Block Kit message." : truncateSlackText(blockAccessibilityText ?? "", SLACK_TEXT_LIMIT);
+			const initialBlockMetadata = withSlackDeliveryMetadata(opts.metadata, {
+				queueId: opts.deliveryQueueId,
+				channelId,
+				threadTs: opts.threadTs,
+				partIndex: 0,
+				partCount: 1
+			});
+			await dispatchOnce();
+			try {
+				const { response } = await postSlackMessageBestEffort({
+					client,
+					channelId,
+					text: accessibilityText,
+					threadTs: opts.threadTs,
+					replyBroadcast: opts.replyBroadcast,
+					identity,
+					blocks,
+					metadata: initialBlockMetadata,
+					...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";
+				deliveredChannelId = resolvePostedMessageChannelId(response, channelId);
+				const deliveredThreadTs = resolvePostedMessageThreadTs(response) ?? normalizeSlackThreadTsCandidate(opts.threadTs);
+				return await reportDelivery({
+					messageId,
+					channelId: deliveredChannelId,
+					threadTs: deliveredThreadTs,
+					receipt: createSlackSendReceipt({
+						platformMessageIds: [messageId],
+						channelId: deliveredChannelId,
+						kind: "card",
+						threadTs: deliveredThreadTs
+					})
+				});
+			} catch (error) {
+				if (!hasNativeData || !isSlackInvalidBlocksError(error)) throw error;
+				logVerbose("slack send: native data rejected, delivering complete text fallback");
+				pendingBlockFallback = orderedBlockDeliveryPlan;
+			}
+		}
+		if (pendingBlockFallback) {
+			const fallbackMessages = pendingBlockFallback.fallbackMessages;
+			for (const [partIndex, fallback] of fallbackMessages.entries()) {
+				const metadata = withSlackDeliveryMetadata(partIndex === 0 ? opts.metadata : void 0, {
+					queueId: opts.deliveryQueueId,
+					channelId,
+					threadTs: opts.threadTs,
+					partIndex,
+					partCount: fallbackMessages.length
+				});
+				if (partIndex === 0) await dispatchOnce();
+				const posted = await postSlackMessageBestEffort({
+					client,
+					channelId,
+					text: fallback.text,
+					threadTs: opts.threadTs,
+					replyBroadcast: partIndex === 0 ? opts.replyBroadcast : void 0,
+					identity: sendIdentity,
+					...fallback.blocks ? { blocks: fallback.blocks } : {},
+					metadata,
+					mrkdwn: false,
+					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;
+				deliveredChannelId = resolvePostedMessageChannelId(response, deliveredChannelId);
+				canonicalDeliveredThreadTs ??= resolvePostedMessageThreadTs(response);
+				if (!response.ts) continue;
+				sentMessageIds.push(response.ts);
+				const deliveredThreadTs = resolvePostedMessageThreadTs(response) ?? normalizeSlackThreadTsCandidate(opts.threadTs);
+				await reportDelivery({
+					messageId: response.ts,
+					channelId: deliveredChannelId,
+					threadTs: deliveredThreadTs,
+					receipt: createSlackSendReceipt({
+						platformMessageIds: [response.ts],
+						channelId: deliveredChannelId,
+						kind: fallback.blocks ? "card" : "text",
+						threadTs: deliveredThreadTs
+					})
+				});
+			}
+			const messageId = lastMessageId || "unknown";
+			const deliveredThreadTs = canonicalDeliveredThreadTs ?? normalizeSlackThreadTsCandidate(opts.threadTs);
+			return {
+				messageId,
+				channelId: deliveredChannelId,
+				threadTs: deliveredThreadTs,
+				receipt: createSlackSendReceipt({
+					platformMessageIds: sentMessageIds.length ? sentMessageIds : [messageId],
+					channelId: deliveredChannelId,
+					kind: fallbackMessages.some((message) => message.blocks) ? "card" : "text",
+					threadTs: deliveredThreadTs
+				})
+			};
+		}
+	}
+	const resolvedChunks = resolveSlackTextChunks({
+		cfg,
+		accountId: account.accountId,
+		text: trimmedMessage,
+		...opts.textLimit !== void 0 ? { textLimit: opts.textLimit } : {},
+		...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 } : {},
 			channelId,
 			mediaUrl: opts.mediaUrl,
 			mediaAccess: opts.mediaAccess,
@@ -854,7 +1188,8 @@ async function sendMessageSlackQueuedInner(params) {
 			caption: firstChunk,
 			threadTs: opts.threadTs,
 			maxBytes: mediaMaxBytes,
-			onPlatformSendDispatch: opts.onPlatformSendDispatch
+			onPlatformSendDispatch: dispatchOnce,
+			...enterpriseDelivery ? { auditContext: "slack-enterprise-immediate-upload" } : {}
 		});
 		sentMessageIds.push(lastMessageId);
 		await reportDelivery({
@@ -870,9 +1205,9 @@ async function sendMessageSlackQueuedInner(params) {
 		});
 		chunksToPost = rest;
 	} else chunksToPost = resolvedChunks.length ? resolvedChunks : [""];
-	let sendIdentity = identity;
 	for (const [partIndex, chunk] of chunksToPost.entries()) {
-		const baseMetadata = sentMessageIds.length === 0 ? opts.metadata : void 0;
+		const carriesPrimaryMessageOptions = partIndex === 0 && !opts.mediaUrl && sentMessageIds.length === 0;
+		const baseMetadata = carriesPrimaryMessageOptions ? opts.metadata : void 0;
 		const metadata = opts.mediaUrl ? baseMetadata : withSlackDeliveryMetadata(baseMetadata, {
 			queueId: opts.deliveryQueueId,
 			channelId,
@@ -880,18 +1215,20 @@ async function sendMessageSlackQueuedInner(params) {
 			partIndex,
 			partCount: chunksToPost.length
 		});
-		if (partIndex === 0 && !opts.mediaUrl) await opts.onPlatformSendDispatch?.();
+		if (partIndex === 0 && !opts.mediaUrl) await dispatchOnce();
 		const posted = await postSlackMessageBestEffort({
 			client,
 			channelId,
 			text: chunk,
 			threadTs: opts.threadTs,
-			replyBroadcast: sentMessageIds.length === 0 ? opts.replyBroadcast : void 0,
+			replyBroadcast: carriesPrimaryMessageOptions ? opts.replyBroadcast : void 0,
 			identity: sendIdentity,
 			metadata,
+			...opts.textIsSlackPlainText ? { mrkdwn: false } : {},
 			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;
 		deliveredChannelId = resolvePostedMessageChannelId(response, deliveredChannelId);
@@ -926,4 +1263,4 @@ async function sendMessageSlackQueuedInner(params) {
 	};
 }
 //#endregion
-export { clearSlackThreadParticipationCache as a, recordSlackThreadParticipation as c, setSlackDefaultSendIdentity as i, buildSlackBlocksFallbackText as l, resolveSlackDmChannelId as n, hasSlackThreadParticipation as o, sendMessageSlack as r, hasSlackThreadParticipationWithPersistence as s, reconcileSlackUnknownSend as t };
+export { clearSlackThreadParticipationCache as a, recordSlackThreadParticipation as c, setSlackDefaultSendIdentity as i, buildSlackNativeDataDeliveryPlan as l, resolveSlackDmChannelId as n, hasSlackThreadParticipation as o, sendMessageSlack as r, hasSlackThreadParticipationWithPersistence as s, reconcileSlackUnknownSend as t, chunkSlackTextAtHardLimit as u };