@openclaw/slack 2026.10.1 → 2026.10.5-beta.1

package/dist/.setup/{policy-KKTqEiDv.mjs → policy-BaY9_eh1.mjs}

@@ -1,5 +1,5 @@
-import { i as buildSlackChannelPolicyScope, r as buildSlackChannelIdCandidates } from "./session-status-D46GHwOV.mjs";
-import { A as resolveSlackUserAllowListForTeam, O as normalizeSlackSlug } from "./probe-BVlJ3dp0.mjs";
+import { i as buildSlackChannelPolicyScope, r as buildSlackChannelIdCandidates } from "./session-status-CcXe10zN.mjs";
+import { j as resolveSlackUserAllowListForTeam, k as normalizeSlackSlug } from "./probe-CyX52GtD.mjs";
 import { applyChannelMatchMeta, buildChannelKeyCandidates } from "openclaw/plugin-sdk/channel-targets";
 import { firstDefined } from "openclaw/plugin-sdk/allow-from";
 import { mergePairLoopGuardConfig } from "openclaw/plugin-sdk/pair-loop-guard-runtime";

package/dist/.setup/{probe-BVlJ3dp0.mjs → probe-CyX52GtD.mjs}

@@ -1,5 +1,5 @@
 import { t as __exportAll } from "./rolldown-runtime-B4FMCO8f.mjs";
-import { p as formatSlackBotTokenIdentityWarning } from "./accounts-CDgkV7Cm.mjs";
+import { p as formatSlackBotTokenIdentityWarning } from "./accounts-BMg9YLIv.mjs";
 import { a as parseSlackTarget } from "./target-parsing-FFE26kOV.mjs";
 import { createRequire } from "node:module";
 import { isRecord, normalizeOptionalLowercaseString } from "openclaw/plugin-sdk/string-coerce-runtime";
@@ -8,9 +8,10 @@ import { runChannelProbe } from "openclaw/plugin-sdk/text-utility-runtime";
 import { normalizeHyphenSlug, normalizeStringEntriesLower } from "openclaw/plugin-sdk/string-normalization-runtime";
 import { compileAllowlist, resolveCompiledAllowlistMatch } from "openclaw/plugin-sdk/allow-from";
 import { pruneMapToMaxSize } from "openclaw/plugin-sdk/collection-runtime";
+import { asDateTimestampMs } from "openclaw/plugin-sdk/number-runtime";
 import { hash } from "node:crypto";
 import { WebAPIRateLimitedError, WebClient } from "@slack/web-api";
-import { addActiveManagedProxyTlsOptions, captureChannelReadAuthority, createHttp1EnvHttpProxyAgent, resolveEnvHttpProxyAgentOptions, resolveFetch } from "openclaw/plugin-sdk/fetch-runtime";
+import { addActiveManagedProxyTlsOptions, captureChannelReadAuthority, captureEffectAuthority, createHttp1EnvHttpProxyAgent, resolveEnvHttpProxyAgentOptions, resolveFetch } from "openclaw/plugin-sdk/fetch-runtime";
 import { isDebugProxyGlobalFetchPatchInstalled } from "openclaw/plugin-sdk/proxy-capture";
 import { parseRetryAfterHeaderSeconds, retryAsync } from "openclaw/plugin-sdk/retry-runtime";
 import { fetchWithRuntimeDispatcher } from "openclaw/plugin-sdk/runtime-fetch";
@@ -130,7 +131,6 @@ function normalizeSlackFetchInit(init) {
 	const { body: _body, ...rest } = init;
 	return rest;
 }
-/** Build the dispatcher for Slack Web API fetches (paired with the runtime fetch). */
 function resolveSlackProxyDispatcher() {
 	const options = resolveEnvHttpProxyAgentOptions();
 	if (!options) return;
@@ -219,38 +219,33 @@ function buildSlackFetch(dispatcher) {
 		});
 	});
 }
-function fenceSlackReadFetch(slackFetch) {
+function fenceSlackReadFetch(slackFetch, assertDirectAdapterHandoff) {
 	const assertReadAuthority = captureChannelReadAuthority();
+	const capturedEffect = captureEffectAuthority();
 	return (input, init) => {
-		assertReadAuthority?.();
-		captureChannelReadAuthority()?.();
-		return slackFetch(input, init);
+		return (capturedEffect.active ? capturedEffect : captureEffectAuthority()).initiate(() => {
+			assertReadAuthority?.();
+			captureChannelReadAuthority()?.();
+			assertDirectAdapterHandoff?.();
+			return slackFetch(input, init);
+		});
 	};
 }
-function resolveSlackApiUrlFromEnv() {
-	return process.env.SLACK_API_URL?.trim() || void 0;
-}
-function applySlackApiUrlAndProxyOptions(options, dispatcher) {
-	const slackApiUrl = options.slackApiUrl ?? resolveSlackApiUrlFromEnv();
+function resolveSlackClientOptions(input, dispatcher, assertDirectAdapterHandoff) {
+	const options = Object.assign({}, input);
+	const slackApiUrl = options.slackApiUrl ?? (process.env.SLACK_API_URL?.trim() || void 0);
 	const fetch = options.fetch ?? buildSlackFetch(dispatcher);
-	if (fetch) options.fetch = fenceSlackReadFetch(fetch);
+	if (fetch) options.fetch = fetch;
 	if (slackApiUrl !== void 0) options.slackApiUrl = slackApiUrl;
 	else delete options.slackApiUrl;
-}
-function applySlackRequestAuthority(options, dispatcher, assertDirectAdapterHandoff) {
-	if (!assertDirectAdapterHandoff) return;
 	const slackFetch = options.fetch ?? buildSlackFetch(dispatcher);
-	if (!slackFetch) throw new Error("Slack request fetch is unavailable for live authority.");
-	options.fetch = (input, init) => {
-		assertDirectAdapterHandoff();
-		return slackFetch(input, init);
-	};
+	if (!slackFetch) {
+		if (assertDirectAdapterHandoff) throw new Error("Slack request fetch is unavailable for live authority.");
+	} else options.fetch = fenceSlackReadFetch(slackFetch, assertDirectAdapterHandoff);
+	return options;
 }
 function resolveSlackWebClientOptions(options = {}, dispatcher = resolveSlackProxyDispatcher(), assertDirectAdapterHandoff) {
-	const resolved = Object.assign({}, options);
-	applySlackApiUrlAndProxyOptions(resolved, dispatcher);
-	resolved.fetch ??= buildSlackFetch(dispatcher);
-	applySlackRequestAuthority(resolved, dispatcher, assertDirectAdapterHandoff);
+	const resolved = resolveSlackClientOptions(options, dispatcher, assertDirectAdapterHandoff);
 	resolved.retryConfig ??= SLACK_DEFAULT_RETRY_OPTIONS;
 	return resolved;
 }
@@ -260,9 +255,7 @@ function resolveSlackReadClientOptions(options = {}, dispatcher = resolveSlackPr
 	return resolved;
 }
 function resolveSlackWriteClientOptions(options = {}, dispatcher = resolveSlackProxyDispatcher(), assertDirectAdapterHandoff) {
-	const resolved = Object.assign({}, options);
-	applySlackApiUrlAndProxyOptions(resolved, dispatcher);
-	applySlackRequestAuthority(resolved, dispatcher, assertDirectAdapterHandoff);
+	const resolved = resolveSlackClientOptions(options, dispatcher, assertDirectAdapterHandoff);
 	resolved.retryConfig ??= SLACK_WRITE_RETRY_OPTIONS;
 	if (resolved.rejectRateLimitedCalls !== true && resolved.retryConfig.retries === 0) {
 		const slackFetch = resolved.fetch ?? buildSlackFetch(dispatcher);
@@ -288,9 +281,7 @@ function resolveSlackWriteClientOptions(options = {}, dispatcher = resolveSlackP
 	return resolved;
 }
 function resolveSlackLookupClientOptions(options = {}, dispatcher = resolveSlackProxyDispatcher(), assertDirectAdapterHandoff) {
-	const resolved = Object.assign({}, options);
-	applySlackApiUrlAndProxyOptions(resolved, dispatcher);
-	applySlackRequestAuthority(resolved, dispatcher, assertDirectAdapterHandoff);
+	const resolved = resolveSlackClientOptions(options, dispatcher, assertDirectAdapterHandoff);
 	resolved.rejectRateLimitedCalls = true;
 	resolved.retryConfig = SLACK_LOOKUP_RETRY_OPTIONS;
 	resolved.timeout ??= SLACK_READ_TIMEOUT_MS;
@@ -312,6 +303,14 @@ function writeLruMapEntry(cache, cacheKey, entry, maxEntries) {
 	cache.set(cacheKey, entry);
 	pruneMapToMaxSize(cache, maxEntries);
 }
+function pruneExpiredMapEntries(cache, rawNow) {
+	const now = asDateTimestampMs(rawNow);
+	if (now === void 0) {
+		cache.clear();
+		return;
+	}
+	for (const [key, entry] of cache) if (asDateTimestampMs(entry.expiresAt) === void 0 || entry.expiresAt <= now) cache.delete(key);
+}
 //#endregion
 //#region extensions/slack/src/client.ts
 const SLACK_WRITE_CLIENT_CACHE_MAX = 32;
@@ -319,9 +318,12 @@ const SLACK_STARTUP_AUTH_TIMEOUT_MS = 1e4;
 const SLACK_STARTUP_AUTH_RETRY_BUDGET_MS = 35e3;
 const slackWriteClientCache = /* @__PURE__ */ new Map();
 const slackListenerWriteClientCache = /* @__PURE__ */ new WeakMap();
-function createSlackWebClient(token, options = {}, assertDirectAdapterHandoff) {
-	return new WebClient(token, resolveSlackWebClientOptions(options, void 0, assertDirectAdapterHandoff));
+function createSlackClientFactory(resolveOptions) {
+	return (token, options, assertDirectAdapterHandoff) => new WebClient(token, resolveOptions(options, void 0, assertDirectAdapterHandoff));
 }
+const createSlackWebClient = createSlackClientFactory(resolveSlackWebClientOptions);
+const createSlackLookupClient = createSlackClientFactory(resolveSlackLookupClientOptions);
+const createSlackWriteClient = createSlackClientFactory(resolveSlackWriteClientOptions);
 function createSlackReadClient(token, options = {}, dispatcher, assertDirectAdapterHandoff) {
 	return new WebClient(token, resolveSlackReadClientOptions(options, dispatcher, assertDirectAdapterHandoff));
 }
@@ -353,12 +355,6 @@ function createSlackStartupAuthClient(token, options = {}) {
 		timeout: SLACK_STARTUP_AUTH_TIMEOUT_MS
 	});
 }
-function createSlackLookupClient(token, options = {}, assertDirectAdapterHandoff) {
-	return new WebClient(token, resolveSlackLookupClientOptions(options, void 0, assertDirectAdapterHandoff));
-}
-function createSlackWriteClient(token, options = {}, assertDirectAdapterHandoff) {
-	return new WebClient(token, resolveSlackWriteClientOptions(options, void 0, assertDirectAdapterHandoff));
-}
 function createSlackTokenCacheKey(token) {
 	return `sha256:${hash("sha256", token, "base64url")}`;
 }
@@ -366,6 +362,7 @@ function slackWriteClientCacheKey(token, options) {
 	return `${createSlackTokenCacheKey(token)}${options.slackApiUrl ? `:api:${options.slackApiUrl}` : ""}${options.teamId ? `:team:${options.teamId.trim().toLowerCase()}` : ""}`;
 }
 function getSlackWriteClient(token, options = {}) {
+	if (captureEffectAuthority().active) return createSlackWriteClient(token, options);
 	const resolvedOptions = resolveSlackWriteClientOptions(options);
 	const tokenKey = slackWriteClientCacheKey(token, resolvedOptions);
 	const cached = readLruMapEntry(slackWriteClientCache, tokenKey);
@@ -379,8 +376,12 @@ function getSlackListenerWriteClient(params) {
 	const token = params.listenerClient.token?.trim();
 	const teamId = params.teamId?.trim().toUpperCase();
 	if (!token) return;
+	const effectScoped = captureEffectAuthority().active;
 	const cached = slackListenerWriteClientCache.get(params.listenerClient);
-	if (cached) return cached.teamId === teamId ? cached.client : void 0;
+	if (cached) {
+		if (cached.teamId !== teamId) return;
+		if (!effectScoped && cached.client) return cached.client;
+	}
 	const headers = Object.fromEntries(Object.entries(params.clientOptions?.headers ?? {}).filter(([name]) => name.toLowerCase() !== "authorization"));
 	const client = new WebClient(token, resolveSlackWriteClientOptions({
 		...params.clientOptions,
@@ -390,10 +391,11 @@ function getSlackListenerWriteClient(params) {
 		retryConfig: SLACK_WRITE_RETRY_OPTIONS,
 		timeout: 0
 	}));
-	slackListenerWriteClientCache.set(params.listenerClient, {
+	if (!effectScoped) slackListenerWriteClientCache.set(params.listenerClient, {
 		teamId,
 		client
 	});
+	else if (!cached) slackListenerWriteClientCache.set(params.listenerClient, { teamId });
 	return client;
 }
 //#endregion
@@ -650,42 +652,33 @@ async function probeSlack(token, timeoutMs = 2500, opts) {
 			status: 200,
 			error: result.error ?? "unknown"
 		};
-		if (opts?.identity === "user") {
+		const userIdentity = opts?.identity === "user";
+		let userId = result.user_id;
+		if (userIdentity) {
 			if (result.bot_id?.trim()) return {
 				ok: false,
 				status: 200,
 				error: "Slack auth.test identified a bot token; user identity requires a user OAuth token"
 			};
-			const userId = result.user_id?.trim();
+			userId = result.user_id?.trim();
 			if (!userId) return {
 				ok: false,
 				status: 200,
 				error: "Slack auth.test returned no human user_id for user identity"
 			};
-			return {
-				ok: true,
-				status: 200,
-				user: {
-					id: userId,
-					name: result.user
-				},
-				team: {
-					id: result.team_id,
-					name: result.team
-				}
-			};
 		}
-		const warning = formatSlackBotTokenIdentityWarning({
+		const warning = userIdentity ? void 0 : formatSlackBotTokenIdentityWarning({
 			auth: result,
 			accountId: opts?.accountId
 		});
+		const authIdentity = {
+			id: userId,
+			name: result.user
+		};
 		return {
 			ok: true,
 			status: 200,
-			bot: {
-				id: result.user_id,
-				name: result.user
-			},
+			...userIdentity ? { user: authIdentity } : { bot: authIdentity },
 			team: {
 				id: result.team_id,
 				name: result.team
@@ -704,4 +697,4 @@ async function probeSlack(token, timeoutMs = 2500, opts) {
 	}
 }
 //#endregion
-export { resolveSlackUserAllowListForTeam as A, resolveSlackMonitorDispatchers as C, normalizeSlackAllowOwnerEntry as D, allowListMatches as E, normalizeSlackSlug as O, resolveSlackLookupClientOptions as S, resolveSlackWriteClientOptions as T, getSlackWriteClient as _, slackIngressIdentity as a, SLACK_DEFAULT_RETRY_OPTIONS as b, collectSlackCursorPages as c, createSlackReadClient as d, createSlackStartupAuthClient as f, getSlackListenerWriteClient as g, createSlackWriteClient as h, createSlackIngressSubject as i, resolveSlackUserAllowed as j, resolveSlackAllowListMatch as k, fetchSlackChannelListPage as l, createSlackWebClient as m, probe_exports as n, formatSlackError as o, createSlackTokenCacheKey as p, SLACK_USER_NAME_KIND as r, getSlackWebApiErrorData as s, probeSlack as t, createSlackLookupClient as u, readLruMapEntry as v, resolveSlackWebClientOptions as w, SLACK_WRITE_RETRY_OPTIONS as x, writeLruMapEntry as y };
+export { resolveSlackAllowListMatch as A, resolveSlackLookupClientOptions as C, allowListMatches as D, resolveSlackWriteClientOptions as E, resolveSlackUserAllowed as M, normalizeSlackAllowOwnerEntry as O, SLACK_WRITE_RETRY_OPTIONS as S, resolveSlackWebClientOptions as T, getSlackWriteClient as _, slackIngressIdentity as a, writeLruMapEntry as b, collectSlackCursorPages as c, createSlackReadClient as d, createSlackStartupAuthClient as f, getSlackListenerWriteClient as g, createSlackWriteClient as h, createSlackIngressSubject as i, resolveSlackUserAllowListForTeam as j, normalizeSlackSlug as k, fetchSlackChannelListPage as l, createSlackWebClient as m, probe_exports as n, formatSlackError as o, createSlackTokenCacheKey as p, SLACK_USER_NAME_KIND as r, getSlackWebApiErrorData as s, probeSlack as t, createSlackLookupClient as u, pruneExpiredMapEntries as v, resolveSlackMonitorDispatchers as w, SLACK_DEFAULT_RETRY_OPTIONS as x, readLruMapEntry as y };

package/dist/.setup/{relay-source-CC3h6M7y.mjs → relay-source-CVfH-fBO.mjs}

@@ -1,5 +1,5 @@
-import { o as formatSlackError } from "./probe-BVlJ3dp0.mjs";
-import { d as parseSlackMessageEvent, f as requireSlackMessageEvent, x as SLACK_SOCKET_RECONNECT_POLICY } from "./monitor-BuYBDmm7.mjs";
+import { o as formatSlackError } from "./probe-CyX52GtD.mjs";
+import { d as parseSlackMessageEvent, f as requireSlackMessageEvent, x as SLACK_SOCKET_RECONNECT_POLICY } from "./monitor-BnN2px0N.mjs";
 import { asOptionalRecord, normalizeOptionalString, readStringValue } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { computeBackoff, sleepWithAbort, warn } from "openclaw/plugin-sdk/runtime-env";
 import { createNodeProxyAgent } from "openclaw/plugin-sdk/fetch-runtime";
@@ -108,13 +108,31 @@ function runRelayWebSocket(params) {
 			pending.then(() => reject(error), reject);
 		};
 		const onMessage = (data) => {
-			pending = pending.then(() => handleRelayFrame({
-				ws,
-				data,
-				acceptRelayEvent: params.acceptRelayEvent,
-				setStatus: params.setStatus,
-				setIdentity: params.setIdentity
-			})).catch((err) => {
+			pending = pending.then(async () => {
+				const frame = asOptionalRecord(parseRelayFrame(data));
+				if (frame?.type === "hello") {
+					const identity = extractRelayIdentity(frame);
+					params.setIdentity?.(identity);
+					params.setStatus?.({ relayIdentity: identity ?? null });
+					return;
+				}
+				const event = extractRelaySlackMessageEvent(frame);
+				if (!event) return;
+				const now = Date.now();
+				params.setStatus?.({
+					lastEventAt: now,
+					lastInboundAt: now
+				});
+				params.setStatus?.({ relayRoute: event.route });
+				await params.acceptRelayEvent({
+					deliveryId: event.deliveryId,
+					message: event.message
+				});
+				if (ws.readyState === WebSocket.OPEN) ws.send(JSON.stringify({
+					type: "ack",
+					delivery_id: event.deliveryId
+				}));
+			}).catch((err) => {
 				params.runtime.error?.(`slack relay frame failed: ${formatSlackError(err)}`);
 			});
 		};
@@ -145,28 +163,6 @@ function runRelayWebSocket(params) {
 		ws.resume();
 	});
 }
-async function handleRelayFrame(params) {
-	const frame = parseRelayFrame(params.data);
-	const hello = extractRelayHello(frame);
-	if (hello) {
-		params.setIdentity?.(hello.identity);
-		params.setStatus?.({ relayIdentity: hello.identity ?? null });
-		return;
-	}
-	const event = extractRelaySlackMessageEvent(frame);
-	if (!event) return;
-	const now = Date.now();
-	params.setStatus?.({
-		lastEventAt: now,
-		lastInboundAt: now
-	});
-	params.setStatus?.({ relayRoute: event.route });
-	await params.acceptRelayEvent({
-		deliveryId: event.deliveryId,
-		message: event.message
-	});
-	sendRelayAck(params.ws, event.deliveryId);
-}
 function buildRelayWebSocketOptions(authToken, url) {
 	const agent = url.startsWith("wss:") ? createNodeProxyAgent({
 		mode: "env",
@@ -211,8 +207,7 @@ function parseRelayFrame(data) {
 		throw new SlackRelayMalformedFrameError("Slack relay received malformed JSON frame", { cause });
 	}
 }
-function extractRelaySlackMessageEvent(frame) {
-	const record = asOptionalRecord(frame);
+function extractRelaySlackMessageEvent(record) {
 	if (!record || record.type !== "slack_event") return;
 	const deliveryId = readStringValue(record.delivery_id);
 	const routeRecord = asOptionalRecord(record.route);
@@ -231,11 +226,6 @@ function extractRelaySlackMessageEvent(frame) {
 		}
 	};
 }
-function extractRelayHello(frame) {
-	const record = asOptionalRecord(frame);
-	if (!record || record.type !== "hello") return;
-	return { identity: extractRelayIdentity(record) };
-}
 function extractRelayIdentity(record) {
 	const identityRecord = asOptionalRecord(record.slack_identity) ?? asOptionalRecord(record.slackIdentity);
 	if (!identityRecord) return;
@@ -249,13 +239,6 @@ function extractRelayIdentity(record) {
 		...iconEmoji ? { iconEmoji } : {}
 	};
 }
-function sendRelayAck(ws, deliveryId) {
-	if (ws.readyState !== WebSocket.OPEN) return;
-	ws.send(JSON.stringify({
-		type: "ack",
-		delivery_id: deliveryId
-	}));
-}
 function closeRelayWebSocket(ws) {
 	if (!ws || ws.readyState === WebSocket.CLOSED || ws.readyState === WebSocket.CLOSING) return;
 	ws.close();

package/dist/.setup/{replies-DHbuthIR.mjs → replies-WmfwvQxc.mjs}

@@ -1,8 +1,8 @@
-import { C as buildSlackBlocksFallbackText, J as markdownToSlackMrkdwnChunks, b as isSlackInvalidBlocksResponse, g as buildSlackNativeDataAccessibilityText, k as SLACK_TEXT_LIMIT, v as hasSlackNativeDataBlock, x as isSlackNativeResponseUrlRejection } from "./session-status-D46GHwOV.mjs";
-import { n as iterateSlackReplyDeliveryMessages, o as resolveSlackReplyBlockResolution, t as hasSlackReplyStructuredContent } from "./reply-blocks-CKnO4BSG.mjs";
+import { A as SLACK_TEXT_LIMIT, Y as markdownToSlackMrkdwnChunks, b as isSlackInvalidBlocksResponse, v as hasSlackNativeDataBlock, x as isSlackNativeResponseUrlRejection } from "./session-status-CcXe10zN.mjs";
+import { n as iterateSlackReplyDeliveryMessages, o as resolveSlackReplyBlockResolution, t as hasSlackReplyStructuredContent } from "./reply-blocks-rqHQ_3pr.mjs";
 import { n as resolveSlackReplyThreadTs } from "./thread-ts-Cvt7WD6B.mjs";
-import { h as chunkSlackTextAtHardLimit, m as buildSlackNativeDataDeliveryPlan, t as sendMessageSlack } from "./send-CgPI3Zj8.mjs";
-import { a as SlackResponseAlreadyReportedError, o as createSlackResponseUrlBudget } from "./monitor-BuYBDmm7.mjs";
+import { h as chunkSlackTextAtHardLimit, m as buildSlackNativeDataDeliveryPlan, t as sendMessageSlack } from "./send-CLmsR42r.mjs";
+import { a as SlackResponseAlreadyReportedError, o as createSlackResponseUrlBudget } from "./monitor-BnN2px0N.mjs";
 import { sanitizeAssistantVisibleText } from "openclaw/plugin-sdk/text-chunking";
 import { createReplyReferencePlanner } from "openclaw/plugin-sdk/reply-reference";
 import { deliverTextOrMediaReply, getReplyPayloadTtsSupplement, resolveSendableOutboundReplyParts } from "openclaw/plugin-sdk/reply-payload";
@@ -55,27 +55,22 @@ function compactSlackResponseUrlFallback(messages) {
 			compacted.push(message);
 			continue;
 		}
-		if (!pending?.blocks?.length) {
-			pending = {
-				...message,
-				blocks: [...message.blocks]
-			};
-			continue;
-		}
-		const text = `${pending.text}\n\n${message.text}`;
-		const blocks = [...pending.blocks, ...message.blocks];
-		if (text.length > 4e4 || blocks.length > 50) {
+		if (pending?.blocks?.length) {
+			const text = `${pending.text}\n\n${message.text}`;
+			const blocks = [...pending.blocks, ...message.blocks];
+			if (text.length <= 4e4 && blocks.length <= 50) {
+				pending = {
+					text,
+					blocks,
+					mrkdwn: false
+				};
+				continue;
+			}
 			flush();
-			pending = {
-				...message,
-				blocks: [...message.blocks]
-			};
-			continue;
 		}
 		pending = {
-			text,
-			blocks,
-			mrkdwn: false
+			...message,
+			blocks: [...message.blocks]
 		};
 	}
 	flush();
@@ -268,36 +263,30 @@ async function deliverSlackSlashReplies(params) {
 		const textRaw = reply.hasText && !isSilentReplyText(reply.trimmedText, SILENT_REPLY_TOKEN) ? reply.trimmedText : void 0;
 		const materializeAuthoredText = hasSlackReplyStructuredContent(payload);
 		const { authoredTextPlacement, segments } = resolveSlackReplyBlockResolution(payload, { materializeAuthoredText });
-		let outsideText = authoredTextPlacement === "outside-blocks" ? textRaw ?? "" : "";
-		const messages = [];
-		const hookParts = [];
-		for (const segment of segments) {
-			if (segment.kind === "text") {
-				const text = [outsideText, segment.text].filter(Boolean).join("\n\n");
-				outsideText = "";
-				if (text) {
-					hookParts.push(text);
-					messages.push(...chunkSlackTextAtHardLimit(text).map((chunk) => ({ message: {
-						text: chunk,
+		if (segments.length > 0) {
+			const messages = [];
+			const hookParts = [];
+			for (const message of iterateSlackReplyDeliveryMessages({
+				authoredTextPlacement,
+				segments,
+				text: textRaw
+			})) {
+				hookParts.push(message.text);
+				if (!message.blocks) {
+					messages.push(...chunkSlackTextAtHardLimit(message.text).map((text) => ({ message: {
+						text,
 						mrkdwn: false
 					} })));
+					continue;
 				}
-				continue;
+				const blockPlan = createBlockMessagePlan({
+					blocks: message.blocks,
+					baseText: message.nativeDataFallbackBaseText ?? ""
+				});
+				messages.push(hasSlackNativeDataBlock(message.blocks) || blockPlan.skipOriginalBlocks ? blockPlan : { message: blockPlan.message });
 			}
-			const baseText = outsideText;
-			outsideText = "";
-			const accessibilityText = buildSlackNativeDataAccessibilityText(baseText, segment.blocks) || buildSlackBlocksFallbackText(segment.blocks);
-			hookParts.push(accessibilityText);
-			const blockPlan = createBlockMessagePlan({
-				blocks: segment.blocks,
-				baseText
-			});
-			messages.push(hasSlackNativeDataBlock(segment.blocks) || blockPlan.skipOriginalBlocks ? blockPlan : { message: blockPlan.message });
-		}
-		if (outsideText) hookParts.push(outsideText);
-		if (reply.mediaUrls.length > 0) hookParts.push(...reply.mediaUrls);
-		if (segments.length > 0) {
-			const trailingText = [outsideText, ...reply.mediaUrls].filter(Boolean).join("\n");
+			hookParts.push(...reply.mediaUrls);
+			const trailingText = reply.mediaUrls.filter(Boolean).join("\n");
 			if (trailingText) messages.push(...chunkSlackTextAtHardLimit(trailingText).map((text) => ({ message: {
 				text,
 				mrkdwn: false
@@ -371,7 +360,7 @@ async function deliverSlackSlashReplies(params) {
 		throw failure;
 	};
 	const initialRemaining = responseBudget.remaining();
-	const initialMinimumCalls = minimumCalls.reduce((total, calls) => total + calls, 0);
+	const initialMinimumCalls = minimumRemainingCalls[0] ?? 0;
 	if (initialRemaining !== void 0 && initialMinimumCalls > initialRemaining) await failOversizedDelivery();
 	const deliverNativeFallback = async (messages, onVisible) => {
 		for (const message of messages) {