@openclaw/slack 2026.6.6-beta.2 → 2026.6.8-beta.1

package/dist/api.js

@@ -3,16 +3,16 @@ import { a as resolveSlackAccount, i as resolveDefaultSlackAccountId, l as resol
 import { t as inspectSlackAccount } from "./account-inspect-CdGk6R7l.js";
 import { i as resolveSlackChannelId, n as normalizeSlackMessagingTarget, r as parseSlackTarget, t as looksLikeSlackTargetId } from "./target-parsing-C7eeWg7M.js";
 import "./targets-nUqxHGgg.js";
-import { a as resolveSlackAutoThreadId, i as resolveSlackChannelType, n as buildSlackThreadingToolContext, r as resetSlackChannelTypeCacheForTest, t as slackPlugin } from "./channel-i43aT1rv.js";
+import { a as resolveSlackAutoThreadId, i as resolveSlackChannelType, n as buildSlackThreadingToolContext, r as resetSlackChannelTypeCacheForTest, t as slackPlugin } from "./channel-CdZdGdU5.js";
 import { _ as buildSlackInteractiveBlocks, a as parseSlackBlocksInput, c as resolveSlackGroupRequireMention, d as normalizeAllowList, f as normalizeAllowListLower, g as resolveSlackUserAllowed, h as resolveSlackAllowListMatch, i as SLACK_MAX_BLOCKS, l as resolveSlackGroupToolPolicy, m as normalizeSlackSlug, o as validateSlackBlocksArray, p as normalizeSlackAllowOwnerEntry, u as allowListMatches, v as buildSlackPresentationBlocks } from "./thread-ts-Cffag8e2.js";
 import { a as getSlackWriteClient, c as resolveSlackWebClientOptions, i as createSlackWriteClient, l as resolveSlackWriteClientOptions, n as createSlackTokenCacheKey, o as SLACK_DEFAULT_RETRY_OPTIONS, r as createSlackWebClient, s as SLACK_WRITE_RETRY_OPTIONS, t as clearSlackWriteClientCacheForTest } from "./client-Cn2WwpcA.js";
 import { n as extractSlackToolSend, r as listSlackMessageActions } from "./message-tool-api-B9M0zzlQ.js";
 import { n as isSlackInteractiveRepliesEnabled, r as parseSlackOptionsLine, t as compileSlackInteractiveReplies } from "./interactive-replies-DrBq4Mld.js";
-import { t as slackSetupPlugin } from "./channel.setup-DrCTObMp.js";
+import { t as slackSetupPlugin } from "./channel.setup-W5YnieWd.js";
 import { a as recordSlackThreadParticipation, n as clearSlackThreadParticipationCache, r as hasSlackThreadParticipation } from "./send-rekB-Xjp.js";
 import { a as listSlackEmojis, c as pinSlackMessage, d as removeOwnSlackReactions, f as removeSlackReaction, i as getSlackMemberInfo, l as reactSlackMessage, m as unpinSlackMessage, n as downloadSlackFile, o as listSlackPins, p as sendSlackMessage, r as editSlackMessage, s as listSlackReactions, t as deleteSlackMessage, u as readSlackMessages } from "./actions-YkhEE5f1.js";
 import { n as listSlackDirectoryGroupsFromConfig, r as listSlackDirectoryPeersFromConfig } from "./directory-config-8UPAEyNg.js";
 import { t as probeSlack } from "./probe-BTKzLT2u.js";
 import { t as collectSlackSecurityAuditFindings } from "./security-audit-CikQhBUY.js";
-import { n as resolveSlackRuntimeGroupPolicy } from "./provider-LH_j-bLA.js";
+import { n as resolveSlackRuntimeGroupPolicy } from "./provider-ChhYGpXx.js";
 export { SLACK_DEFAULT_RETRY_OPTIONS, SLACK_MAX_BLOCKS, SLACK_WRITE_RETRY_OPTIONS, resetSlackChannelTypeCacheForTest as __resetSlackChannelTypeCacheForTest, resetSlackChannelTypeCacheForTest, allowListMatches, buildSlackInteractiveBlocks, buildSlackPresentationBlocks, buildSlackThreadingToolContext, clearSlackThreadParticipationCache, clearSlackWriteClientCacheForTest, collectSlackSecurityAuditFindings, compileSlackInteractiveReplies, createSlackTokenCacheKey, createSlackWebClient, createSlackWriteClient, deleteSlackMessage, downloadSlackFile, editSlackMessage, extractSlackToolSend, getSlackMemberInfo, getSlackWriteClient, handleSlackHttpRequest, hasSlackThreadParticipation, inspectSlackAccount, isSlackInteractiveRepliesEnabled, listEnabledSlackAccounts, listSlackAccountIds, listSlackDirectoryGroupsFromConfig, listSlackDirectoryPeersFromConfig, listSlackEmojis, listSlackMessageActions, listSlackPins, listSlackReactions, looksLikeSlackTargetId, mergeSlackAccountConfig, normalizeAllowList, normalizeAllowListLower, normalizeSlackAllowOwnerEntry, normalizeSlackMessagingTarget, normalizeSlackSlug, normalizeSlackWebhookPath, parseSlackBlocksInput, parseSlackOptionsLine, parseSlackTarget, pinSlackMessage, probeSlack, reactSlackMessage, readSlackMessages, recordSlackThreadParticipation, registerSlackHttpHandler, removeOwnSlackReactions, removeSlackReaction, resolveDefaultSlackAccountId, resolveSlackAccount, resolveSlackAllowListMatch, resolveSlackAutoThreadId, resolveSlackChannelId, resolveSlackChannelType, resolveSlackGroupRequireMention, resolveSlackGroupToolPolicy, resolveSlackReplyToMode, resolveSlackRuntimeGroupPolicy, resolveSlackUserAllowed, resolveSlackWebClientOptions, resolveSlackWriteClientOptions, sendSlackMessage, slackPlugin, slackSetupPlugin, unpinSlackMessage, validateSlackBlocksArray };

package/dist/{channel-i43aT1rv.js → channel-CdZdGdU5.js}

@@ -6,7 +6,7 @@ import { d as PAIRING_APPROVED_MESSAGE, h as isSlackPluginAccountConfigured, m a
 import { n as extractSlackToolSend, t as describeSlackMessageTool } from "./message-tool-api-B9M0zzlQ.js";
 import { n as isSlackInteractiveRepliesEnabled, t as compileSlackInteractiveReplies } from "./interactive-replies-DrBq4Mld.js";
 import { t as getOptionalSlackRuntime } from "./runtime-BOk7xkOl.js";
-import { n as slackConfigAdapter, r as slackSecurityAdapter, t as createSlackPluginBase } from "./shared-Bviszgb6.js";
+import { n as slackConfigAdapter, r as slackSecurityAdapter, t as createSlackPluginBase } from "./shared-Bkkmro6q.js";
 import { i as SLACK_CHANNEL, n as createSlackSetupWizardProxy, r as slackSetupAdapter } from "./setup-core-POfI_bgP.js";
 import { normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { adaptScopedAccountAccessor } from "openclaw/plugin-sdk/channel-config-helpers";
@@ -476,7 +476,7 @@ const EXTENSION_SHARED_MODULE_ID = "openclaw/plugin-sdk/extension-shared";
 const TARGET_RESOLVER_RUNTIME_MODULE_ID = "openclaw/plugin-sdk/target-resolver-runtime";
 const loadExtensionSharedSdk = createLazyRuntimeModule(() => import(EXTENSION_SHARED_MODULE_ID));
 const loadTargetResolverRuntimeSdk = createLazyRuntimeModule(() => import(TARGET_RESOLVER_RUNTIME_MODULE_ID));
-const loadSlackSetupSurfaceModule = createLazyRuntimeModule(() => import("./setup-surface-BB_ivsoR.js"));
+const loadSlackSetupSurfaceModule = createLazyRuntimeModule(() => import("./setup-surface-NNMjGpXc.js"));
 const loadSlackScopesModule = createLazyRuntimeModule(() => import("./scopes-CErQL0td.js"));
 const loadSlackOutboundAdapterModule = createLazyRuntimeModule(() => import("./outbound-adapter-DvXnHfDP.js"));
 async function resolveSlackHandleAction() {
@@ -514,7 +514,7 @@ async function loadSlackProbeModule() {
 	return await slackProbeModulePromise;
 }
 async function loadSlackMonitorModule() {
-	slackMonitorModulePromise ??= import("./monitor-Szm2LjsM.js").then((n) => n.t);
+	slackMonitorModulePromise ??= import("./monitor-DwDmBYfl.js").then((n) => n.t);
 	return await slackMonitorModulePromise;
 }
 async function loadSlackDirectoryLiveModule() {

package/dist/channel-plugin-api.js

@@ -1,2 +1,2 @@
-import { t as slackPlugin } from "./channel-i43aT1rv.js";
+import { t as slackPlugin } from "./channel-CdZdGdU5.js";
 export { slackPlugin };

package/dist/{channel.setup-DrCTObMp.js → channel.setup-W5YnieWd.js}

@@ -4,7 +4,7 @@ import { t as SlackChannelConfigSchema } from "./config-schema-BjAjs8_6.js";
 import { adaptScopedAccountAccessor, createScopedChannelConfigAdapter } from "openclaw/plugin-sdk/channel-config-helpers";
 import { formatAllowFromLowercase } from "openclaw/plugin-sdk/allow-from";
 //#region extensions/slack/src/channel.setup.ts
-const slackSetupWizard = createSlackSetupWizardProxy(async () => ({ slackSetupWizard: (await import("./setup-surface-BB_ivsoR.js")).slackSetupWizard }));
+const slackSetupWizard = createSlackSetupWizardProxy(async () => ({ slackSetupWizard: (await import("./setup-surface-NNMjGpXc.js")).slackSetupWizard }));
 const slackSetupConfigAdapter = createScopedChannelConfigAdapter({
 	sectionKey: SLACK_CHANNEL,
 	listAccountIds: listSlackAccountIds,

package/dist/{monitor-Szm2LjsM.js → monitor-DwDmBYfl.js}

@@ -1,7 +1,7 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { t as monitorSlackProvider, y as buildSlackSlashCommandMatcher } from "./provider-LH_j-bLA.js";
+import { t as monitorSlackProvider, y as buildSlackSlashCommandMatcher } from "./provider-ChhYGpXx.js";
 import { t as isSlackChannelAllowedByPolicy } from "./policy-DT3mRh58.js";
-import { o as resolveSlackThreadTs } from "./replies-FEOdgSlE.js";
+import { o as resolveSlackThreadTs } from "./replies-Bt4nWmSd.js";
 //#region extensions/slack/src/monitor.ts
 var monitor_exports = /* @__PURE__ */ __exportAll({
 	buildSlackSlashCommandMatcher: () => buildSlackSlashCommandMatcher,

package/dist/{pipeline.runtime-Dvqs0AT-.js → pipeline.runtime-1FYOQOt_.js}

@@ -7,9 +7,9 @@ import { n as resolveSlackNativeStreaming, r as resolveSlackStreamingMode, t as
 import { a as recordSlackThreadParticipation, i as hasSlackThreadParticipationWithPersistence, s as normalizeSlackOutboundText, t as sendMessageSlack } from "./send-rekB-Xjp.js";
 import { _ as resolveSlackThreadStarter, b as buildSlackEditTextPayload, f as removeSlackReaction, g as resolveSlackThreadHistory, l as reactSlackMessage, r as editSlackMessage, t as deleteSlackMessage, y as formatSlackFileReference } from "./actions-YkhEE5f1.js";
 import { t as formatSlackError } from "./errors-CZtmv-h0.js";
-import { _ as resolveStorePath, a as escapeSlackMrkdwn, b as stripSlackMentionsForCommandDetection, c as authorizeSlackBotRoomMessage, d as buildSlackAssistantThreadMetadata, f as parseSlackAssistantThreadMetadata, g as resolveChannelContextVisibilityMode, h as readSessionUpdatedAt, i as authorizeSlackDirectMessage, l as resolveSlackCommandIngress, m as resolveSlackChatType, o as recordInboundSession, p as normalizeSlackChannelType, r as resolveSlackRoomContextHints, s as resolveConversationLabel$1, u as resolveSlackEffectiveAllowFrom, v as updateLastRoute } from "./provider-LH_j-bLA.js";
+import { _ as resolveStorePath, a as escapeSlackMrkdwn, b as stripSlackMentionsForCommandDetection, c as authorizeSlackBotRoomMessage, d as buildSlackAssistantThreadMetadata, f as parseSlackAssistantThreadMetadata, g as resolveChannelContextVisibilityMode, h as readSessionUpdatedAt, i as authorizeSlackDirectMessage, l as resolveSlackCommandIngress, m as resolveSlackChatType, o as recordInboundSession, p as normalizeSlackChannelType, r as resolveSlackRoomContextHints, s as resolveConversationLabel$1, u as resolveSlackEffectiveAllowFrom, v as updateLastRoute } from "./provider-ChhYGpXx.js";
 import { n as resolveSlackChannelConfig } from "./policy-DT3mRh58.js";
-import { a as resolveDeliveredSlackReplyThreadTs, i as readSlackReplyBlocks, n as deliverReplies, o as resolveSlackThreadTs, t as createSlackReplyDeliveryPlan } from "./replies-FEOdgSlE.js";
+import { a as resolveDeliveredSlackReplyThreadTs, i as readSlackReplyBlocks, n as deliverReplies, o as resolveSlackThreadTs, s as emitSlackMessageSentHooks, t as createSlackReplyDeliveryPlan } from "./replies-Bt4nWmSd.js";
 import { asOptionalRecord, normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeOptionalString, readStringValue } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { resolveAgentRoute, resolveInboundLastRouteSessionKey, resolveThreadSessionKeys } from "openclaw/plugin-sdk/routing";
 import { buildChannelProgressDraftLine, buildChannelProgressDraftLineForEntry, createChannelMessageReplyPipeline, createChannelProgressDraftGate, createDraftStreamLoop, defineFinalizableLivePreviewAdapter, deliverWithFinalizableLivePreviewAdapter, formatChannelProgressDraftText, isChannelProgressDraftWorkToolName, mergeChannelProgressDraftLine, resolveAgentOutboundIdentity, resolveChannelMessageSourceReplyDeliveryMode, resolveChannelProgressDraftConfig, resolveChannelProgressDraftMaxLineChars, resolveChannelProgressDraftMaxLines, resolveChannelProgressDraftRender, resolveChannelStreamingBlockEnabled, resolveChannelStreamingNativeTransport, resolveChannelStreamingPreviewToolProgress, resolveChannelStreamingSuppressDefaultToolProgressMessages } from "openclaw/plugin-sdk/channel-outbound";
@@ -415,36 +415,41 @@ async function appendSlackStream(params) {
 * text so the caller can deliver it through the normal Slack reply path.
 *
 * All other errors propagate unchanged.
+*
+* On success, returns the finalized message's Slack `ts` (when reported) so the
+* caller can emit the `message_sent` hook with a populated `messageId`.
 */
 async function stopSlackStream(params) {
 	const { session, text, chunks, metadata } = params;
 	if (session.stopped) {
 		logVerbose("slack-stream: stream already stopped, ignoring duplicate stop");
-		return;
+		return {};
 	}
 	session.stopped = true;
 	if (text) session.pendingText += text;
 	logVerbose(`slack-stream: stopping stream in ${session.channel} thread=${session.threadTs}${text ? ` (final text: ${text.length} chars)` : ""}`);
 	try {
-		await session.streamer.stop(text || chunks?.length || metadata ? {
+		const stopResponse = await session.streamer.stop(text || chunks?.length || metadata ? {
 			...text ? { markdown_text: text } : {},
 			...chunks?.length ? { chunks } : {},
 			...metadata ? { metadata } : {}
 		} : void 0);
 		session.delivered = true;
 		session.pendingText = "";
+		logVerbose("slack-stream: stream stopped");
+		const messageId = stopResponse?.ts ?? stopResponse?.message?.ts;
+		return messageId ? { messageId } : {};
 	} catch (err) {
 		if (isBenignSlackFinalizeError(err)) {
 			const code = extractSlackErrorCode(err) ?? "unknown";
 			if (session.pendingText) throw new SlackStreamNotDeliveredError(session.pendingText, code);
 			if (session.delivered) {
 				logVerbose(`slack-stream: finalize rejected by Slack (${code}); prior appends delivered, treating stream as stopped`);
-				return;
+				return {};
 			}
 		}
 		throw err;
 	}
-	logVerbose("slack-stream: stream stopped");
 }
 /**
 * Slack API error codes that indicate `chat.stopStream` (or the
@@ -473,10 +478,10 @@ function extractSlackErrorCode(err) {
 	return (typeof record.message === "string" ? record.message : "").match(/An API error occurred:\s*([a-z_][a-z0-9_]*)/i)?.[1];
 }
 function markSlackStreamFallbackDelivered(session) {
-	const hadNativeDelivery = session.delivered;
+	const nativeStreamWasStarted = session.delivered;
 	session.pendingText = "";
-	session.delivered = true;
-	if (!hadNativeDelivery) session.stopped = true;
+	session.streamer.buffer = "";
+	session.stopped = !nativeStreamWasStarted;
 }
 //#endregion
 //#region extensions/slack/src/threading.ts
@@ -848,6 +853,16 @@ async function dispatchPreparedSlackMessage(prepared) {
 		ctx: prepared.ctxPayload
 	});
 	const sourceRepliesAreToolOnly = sourceReplyDeliveryMode === "message_tool_only";
+	const messageSentHookTarget = prepared.ctxPayload.OriginatingTo ?? prepared.ctxPayload.To ?? prepared.replyTarget;
+	const messageSentHookContext = {
+		sessionKeyForInternalHooks: prepared.ctxPayload.SessionKey ?? route.sessionKey,
+		isGroup: prepared.isRoomish,
+		groupId: prepared.isRoomish ? message.channel : void 0
+	};
+	const messageSentDeliveryHookContext = {
+		...messageSentHookContext,
+		messageSentHookTarget
+	};
 	const reactionMessageTs = prepared.ackReactionMessageTs;
 	const messageTs = message.ts ?? message.event_ts;
 	const incomingThreadTs = message.thread_ts;
@@ -998,7 +1013,79 @@ async function dispatchPreparedSlackMessage(prepared) {
 	let usedBlockReplyThreadTs;
 	let observedReplyDelivery = false;
 	let observedFinalReplyDelivery = false;
+	const streamedDeliveries = [];
+	const streamedFailuresOwnedByDispatcher = {
+		tool: 0,
+		block: 0,
+		final: 0
+	};
+	const refreshStreamedAcknowledgements = (session) => {
+		if (session.pendingText.length === 0) for (const delivery of streamedDeliveries) delivery.acknowledged = true;
+	};
+	const recordStreamedDelivery = (kind, content) => {
+		const delivery = {
+			kind,
+			content,
+			acknowledged: false
+		};
+		streamedDeliveries.push(delivery);
+		return delivery;
+	};
+	const rememberStreamedDelivery = (kind, content, session) => {
+		recordStreamedDelivery(kind, content);
+		refreshStreamedAcknowledgements(session);
+	};
+	const emitAcknowledgedStreamedDeliveries = (messageId) => {
+		for (const delivery of streamedDeliveries) {
+			if (!delivery.acknowledged || delivery.outcome) continue;
+			emitSlackMessageSentHooks({
+				...messageSentHookContext,
+				to: messageSentHookTarget,
+				accountId: account.accountId,
+				content: delivery.content,
+				success: true,
+				...messageId ? { messageId } : {}
+			});
+			delivery.outcome = "success";
+		}
+	};
+	const emitFailedPendingStreamedDeliveries = (error) => {
+		for (const delivery of streamedDeliveries) {
+			if (delivery.acknowledged || delivery.outcome) continue;
+			emitSlackMessageSentHooks({
+				...messageSentHookContext,
+				to: messageSentHookTarget,
+				accountId: account.accountId,
+				content: delivery.content,
+				success: false,
+				error
+			});
+			delivery.outcome = "failure";
+		}
+	};
+	const emitSuccessfulPendingStreamedDeliveries = (messageId) => {
+		for (const delivery of streamedDeliveries) {
+			if (delivery.acknowledged || delivery.outcome) continue;
+			emitSlackMessageSentHooks({
+				...messageSentHookContext,
+				to: messageSentHookTarget,
+				accountId: account.accountId,
+				content: delivery.content,
+				success: true,
+				...messageId ? { messageId } : {}
+			});
+			delivery.outcome = "success";
+		}
+	};
 	const deliveryTracker = createSlackEventDeliveryTracker();
+	const markPreviewPayloadDelivered = (params) => {
+		deliveryTracker.markDelivered(params);
+		const nextThreadTs = replyPlan.peekThreadTs();
+		if (nextThreadTs !== params.threadTs) deliveryTracker.markDelivered({
+			...params,
+			threadTs: nextThreadTs
+		});
+	};
 	const resolveDeliveryThreadTs = (params) => {
 		const plannedThreadTs = params.forcedThreadTs ? void 0 : replyPlan.nextThreadTs();
 		return params.forcedThreadTs ?? plannedThreadTs ?? (params.kind === "block" ? usedBlockReplyThreadTs : void 0);
@@ -1009,7 +1096,23 @@ async function dispatchPreparedSlackMessage(prepared) {
 		if (kind === "block") usedBlockReplyThreadTs = deliveredThreadTs;
 	};
 	const deliverPendingStreamFallback = async (session, err) => {
-		const fallbackText = err.pendingText.trim();
+		let fallbackError = err;
+		if (!session.stopped) try {
+			const stopResult = await stopSlackStream({
+				session,
+				...slackMessageMetadata ? { metadata: slackMessageMetadata } : {}
+			});
+			for (const delivery of streamedDeliveries) delivery.acknowledged = true;
+			emitAcknowledgedStreamedDeliveries(stopResult.messageId);
+			observedReplyDelivery = true;
+			usedReplyThreadTs ??= session.threadTs;
+			return true;
+		} catch (stopErr) {
+			if (stopErr instanceof SlackStreamNotDeliveredError) fallbackError = stopErr;
+			else runtime.error?.(danger(`slack-stream: failed to finalize buffered text before fallback: ${formatSlackError(stopErr)}`));
+		}
+		emitAcknowledgedStreamedDeliveries();
+		const fallbackText = fallbackError.pendingText.trim();
 		if (!fallbackText) return false;
 		try {
 			await deliverReplies({
@@ -1023,15 +1126,27 @@ async function dispatchPreparedSlackMessage(prepared) {
 				replyThreadTs: session.threadTs,
 				replyToMode: replyDeliveryMode,
 				...slackIdentity ? { identity: slackIdentity } : {},
-				...slackMessageMetadata ? { metadata: slackMessageMetadata } : {}
+				...slackMessageMetadata ? { metadata: slackMessageMetadata } : {},
+				...messageSentDeliveryHookContext,
+				deferMessageSentHooks: true
 			});
 			markSlackStreamFallbackDelivered(session);
+			if (!session.stopped) try {
+				await stopSlackStream({
+					session,
+					...slackMessageMetadata ? { metadata: slackMessageMetadata } : {}
+				});
+			} catch (finalizeErr) {
+				runtime.error?.(danger(`slack-stream: failed to finalize native stream after fallback delivery: ${formatSlackError(finalizeErr)}`));
+			}
+			emitSuccessfulPendingStreamedDeliveries();
 			observedReplyDelivery = true;
 			usedReplyThreadTs ??= session.threadTs;
-			logVerbose(`slack-stream: streamed delivery failed (${err.slackCode}); delivered ${fallbackText.length} chars via deliverReplies fallback`);
+			logVerbose(`slack-stream: streamed delivery failed (${fallbackError.slackCode}); delivered ${fallbackText.length} chars via deliverReplies fallback`);
 			return true;
 		} catch (postErr) {
-			runtime.error?.(danger(`slack-stream: fallback deliverReplies failed after ${err.slackCode}: ${formatErrorMessage(postErr)}`));
+			emitFailedPendingStreamedDeliveries(formatErrorMessage(postErr));
+			runtime.error?.(danger(`slack-stream: fallback deliverReplies failed after ${fallbackError.slackCode}: ${formatErrorMessage(postErr)}`));
 			return false;
 		}
 	};
@@ -1045,7 +1160,7 @@ async function dispatchPreparedSlackMessage(prepared) {
 			threadTs: deliveryReplyThreadTs
 		})) {
 			logVerbose("slack: suppressed duplicate normal delivery within the same turn");
-			return;
+			return deliveryReplyThreadTs;
 		}
 		await deliverReplies({
 			cfg: ctx.cfg,
@@ -1058,7 +1173,8 @@ async function dispatchPreparedSlackMessage(prepared) {
 			replyThreadTs: deliveryReplyThreadTs,
 			replyToMode: replyDeliveryMode,
 			...slackIdentity ? { identity: slackIdentity } : {},
-			...slackMessageMetadata ? { metadata: slackMessageMetadata } : {}
+			...slackMessageMetadata ? { metadata: slackMessageMetadata } : {},
+			...messageSentDeliveryHookContext
 		});
 		observedReplyDelivery = true;
 		if (params.kind === "final") observedFinalReplyDelivery = true;
@@ -1074,9 +1190,13 @@ async function dispatchPreparedSlackMessage(prepared) {
 			payload: params.payload,
 			threadTs: deliveryReplyThreadTs
 		});
+		return deliveryReplyThreadTs;
 	};
 	const deliverBufferedStreamFallback = async (params) => {
-		if (!await deliverPendingStreamFallback(params.session, params.err)) return false;
+		if (!await deliverPendingStreamFallback(params.session, params.err)) {
+			streamedFailuresOwnedByDispatcher[params.kind] += 1;
+			return false;
+		}
 		replyPlan.markSent();
 		if (params.kind === "final") observedFinalReplyDelivery = true;
 		deliveryTracker.markDelivered({
@@ -1152,10 +1272,12 @@ async function dispatchPreparedSlackMessage(prepared) {
 					}),
 					userId: message.user
 				});
+				refreshStreamedAcknowledgements(streamSession);
 				if (streamSession.delivered) {
 					observedReplyDelivery = true;
 					if (params.kind === "final") observedFinalReplyDelivery = true;
 				}
+				if (text) rememberStreamedDelivery(params.kind, text, streamSession);
 				rememberDeliveredThreadTs(params.kind, streamThreadTs);
 				replyPlan.markSent();
 				deliveryTracker.markDelivered({
@@ -1197,11 +1319,13 @@ async function dispatchPreparedSlackMessage(prepared) {
 				});
 				return;
 			}
+			if (text) recordStreamedDelivery(params.kind, text);
 			await appendSlackStream({
 				session: streamSession,
 				text: "\n" + text,
 				chunks: completionChunks
 			});
+			refreshStreamedAcknowledgements(streamSession);
 			if (completionChunks?.length) nativeProgressCompletionSent = true;
 			if (streamSession.delivered) {
 				observedReplyDelivery = true;
@@ -1244,6 +1368,7 @@ async function dispatchPreparedSlackMessage(prepared) {
 					kind: params.kind,
 					textOverride: text
 				})) return;
+				throw err;
 			}
 			await deliverNormally({
 				payload: params.payload,
@@ -1313,7 +1438,7 @@ async function dispatchPreparedSlackMessage(prepared) {
 					kind: info.kind,
 					forcedThreadTs: finalThreadTs
 				});
-				deliveryTracker.markDelivered({
+				markPreviewPayloadDelivered({
 					kind: info.kind,
 					payload,
 					threadTs: finalThreadTs
@@ -1363,6 +1488,14 @@ async function dispatchPreparedSlackMessage(prepared) {
 						...edit.blocks?.length ? { blocks: edit.blocks } : {},
 						threadTs: edit.threadTs
 					});
+					if (!ttsSupplement) emitSlackMessageSentHooks({
+						...messageSentHookContext,
+						to: messageSentHookTarget,
+						accountId: account.accountId,
+						content: trimmedFinalText,
+						success: true,
+						messageId: preview.messageId
+					});
 					draftPreviewCommitted = true;
 					observedFinalReplyDelivery = true;
 				},
@@ -1372,7 +1505,7 @@ async function dispatchPreparedSlackMessage(prepared) {
 					const finalThreadTs = usedReplyThreadTs ?? statusThreadTs;
 					observedReplyDelivery = true;
 					replyPlan.markSent();
-					deliveryTracker.markDelivered({
+					if (!ttsSupplement) markPreviewPayloadDelivered({
 						kind: info.kind,
 						payload,
 						threadTs: finalThreadTs
@@ -1380,9 +1513,16 @@ async function dispatchPreparedSlackMessage(prepared) {
 				},
 				buildSupplementalPayload: () => ttsSupplement ? buildTtsSupplementMediaPayload(payload) : void 0,
 				deliverSupplemental: async (supplementalPayload) => {
-					await deliverNormally({
+					const previewThreadTs = usedReplyThreadTs ?? statusThreadTs;
+					const supplementalThreadTs = await deliverNormally({
 						payload: supplementalPayload,
-						kind: info.kind
+						kind: info.kind,
+						forcedThreadTs: previewThreadTs
+					});
+					markPreviewPayloadDelivered({
+						kind: info.kind,
+						payload,
+						threadTs: supplementalThreadTs
 					});
 				},
 				logPreviewEditFailure: (err) => {
@@ -1792,15 +1932,35 @@ async function dispatchPreparedSlackMessage(prepared) {
 			finalInProgressStatus: dispatchError ? "error" : "complete"
 		}) : void 0;
 		if (completionChunks?.length) nativeProgressCompletionSent = true;
-		await stopSlackStream({
+		const stopResult = await stopSlackStream({
 			session: finalStream,
 			...completionChunks?.length ? { chunks: completionChunks } : {},
 			...slackMessageMetadata ? { metadata: slackMessageMetadata } : {}
 		});
+		for (const delivery of streamedDeliveries) delivery.acknowledged = true;
+		emitAcknowledgedStreamedDeliveries(stopResult?.messageId);
 	} catch (err) {
 		if (err instanceof SlackStreamNotDeliveredError) streamFallbackDelivered = await deliverPendingStreamFallback(finalStream, err);
-		else runtime.error?.(danger(`slack-stream: failed to stop stream: ${formatSlackError(err)}`));
+		else {
+			const error = formatSlackError(err);
+			emitAcknowledgedStreamedDeliveries();
+			emitFailedPendingStreamedDeliveries(error);
+			runtime.error?.(danger(`slack-stream: failed to stop stream: ${error}`));
+		}
+	}
+	for (const kind of [
+		"tool",
+		"block",
+		"final"
+	]) {
+		const failedStreamedCount = streamedDeliveries.filter((delivery) => delivery.kind === kind && delivery.outcome === "failure").length;
+		const additionalFailedStreamed = Math.max(0, failedStreamedCount - streamedFailuresOwnedByDispatcher[kind]);
+		if (additionalFailedStreamed > 0) counts = {
+			...counts,
+			[kind]: Math.max(0, (counts[kind] ?? 0) - additionalFailedStreamed)
+		};
 	}
+	queuedFinal = queuedFinal && (counts.final ?? 0) > 0;
 	const anyReplyDelivered = hasVisibleInboundReplyDispatch({
 		queuedFinal,
 		counts

package/dist/{provider-LH_j-bLA.js → provider-ChhYGpXx.js}

@@ -2699,7 +2699,7 @@ function createSlackThreadTsResolver(params) {
 //#region extensions/slack/src/monitor/message-handler.ts
 let slackMessagePipelinePromise;
 function loadSlackMessagePipeline() {
-	slackMessagePipelinePromise ??= import("./pipeline.runtime-Dvqs0AT-.js");
+	slackMessagePipelinePromise ??= import("./pipeline.runtime-1FYOQOt_.js");
 	return slackMessagePipelinePromise;
 }
 const APP_MENTION_RETRY_TTL_MS = 6e4;
@@ -3341,7 +3341,7 @@ function loadSlashCommandsRuntime() {
 	return slashCommandsRuntimePromise;
 }
 function loadSlashDispatchRuntime() {
-	slashDispatchRuntimePromise ??= import("./slash-dispatch.runtime-CoFAysiw.js");
+	slashDispatchRuntimePromise ??= import("./slash-dispatch.runtime-Dvvs747S.js");
 	return slashDispatchRuntimePromise;
 }
 function loadSlackPluginCommandsRuntime() {
@@ -3777,6 +3777,7 @@ async function registerSlackMonitorSlashCommands(params) {
 				targetSessionKey: route.sessionKey,
 				lowercaseSessionKey: true
 			});
+			const slashReplyTarget = !slashCommand.ephemeral && isRoomish ? `channel:${command.channel_id}` : `user:${command.user_id}`;
 			const ctxPayload = finalizeInboundContext({
 				Body: prompt,
 				BodyForAgent: prompt,
@@ -3809,7 +3810,7 @@ async function registerSlackMonitorSlashCommands(params) {
 				CommandSource: "native",
 				CommandAuthorized: commandAuthorized,
 				OriginatingChannel: "slack",
-				OriginatingTo: `user:${command.user_id}`
+				OriginatingTo: slashReplyTarget
 			});
 			await recordInboundSessionMetaSafe({
 				cfg,
@@ -3831,12 +3832,18 @@ async function registerSlackMonitorSlashCommands(params) {
 					}) ? compileSlackInteractiveReplies(payload) : payload;
 				}
 			});
+			const messageSentHookTarget = ctxPayload.OriginatingTo ?? ctxPayload.To ?? slashReplyTarget;
 			const deliverSlashPayloads = async (replies) => {
 				await deliverSlackSlashReplies({
 					replies,
 					respond,
 					ephemeral: slashCommand.ephemeral,
 					textLimit: ctx.textLimit,
+					messageSentHookTarget,
+					accountId: route.accountId,
+					sessionKeyForInternalHooks: ctxPayload.SessionKey ?? route.sessionKey,
+					isGroup: isRoomish,
+					groupId: isRoomish ? command.channel_id : void 0,
 					chunkMode: resolveChunkMode(cfg, "slack", route.accountId),
 					tableMode: resolveMarkdownTableMode({
 						cfg,

package/dist/replies-Bt4nWmSd.js

@@ -0,0 +1,285 @@
+import { r as resolveSlackReplyBlocks, s as SLACK_TEXT_LIMIT } from "./thread-ts-Cffag8e2.js";
+import { o as markdownToSlackMrkdwnChunks, t as sendMessageSlack } from "./send-rekB-Xjp.js";
+import { createReplyReferencePlanner } from "openclaw/plugin-sdk/reply-reference";
+import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
+import { SILENT_REPLY_TOKEN, chunkMarkdownTextWithMode, isSilentReplyText } from "openclaw/plugin-sdk/reply-chunking";
+import { deliverTextOrMediaReply, getReplyPayloadTtsSupplement, resolveSendableOutboundReplyParts } from "openclaw/plugin-sdk/reply-payload";
+import { getGlobalHookRunner } from "openclaw/plugin-sdk/plugin-runtime";
+import { buildCanonicalSentMessageHookContext, createInternalHookEvent, fireAndForgetHook, toInternalMessageSentContext, toPluginMessageContext, toPluginMessageSentEvent, triggerInternalHook } from "openclaw/plugin-sdk/hook-runtime";
+//#region extensions/slack/src/message-sent-hook.ts
+/**
+* Slack-side emission of the `message_sent` plugin hook.
+*
+* Mirrors the Telegram pattern in `extensions/telegram/src/bot/delivery.replies.ts`
+* (`buildTelegramSentHookContext`, `emitMessageSentHooks`, `emitTelegramMessageSentHooks`).
+*
+* Without this, plugins observing `message_sent` see Telegram outbound but not
+* Slack outbound — even though `docs/plugins/hooks.md` documents the hook as
+* firing for all successful outbound deliveries.
+*/
+function buildSlackSentHookContext(params) {
+	return buildCanonicalSentMessageHookContext({
+		to: params.to,
+		content: params.content,
+		success: params.success,
+		error: params.error,
+		channelId: "slack",
+		accountId: params.accountId ?? void 0,
+		conversationId: params.to,
+		sessionKey: params.sessionKeyForInternalHooks,
+		messageId: params.messageId,
+		isGroup: params.isGroup,
+		groupId: params.groupId
+	});
+}
+function emitInternalSlackMessageSentHook(params) {
+	if (!params.sessionKeyForInternalHooks) return;
+	const canonical = buildSlackSentHookContext(params);
+	fireAndForgetHook(triggerInternalHook(createInternalHookEvent("message", "sent", params.sessionKeyForInternalHooks, toInternalMessageSentContext(canonical))), "slack: message:sent internal hook failed");
+}
+function emitMessageSentHooks(params) {
+	if (!params.enabled && !params.sessionKeyForInternalHooks) return;
+	const canonical = buildSlackSentHookContext(params);
+	if (params.enabled) fireAndForgetHook(Promise.resolve(params.hookRunner.runMessageSent(toPluginMessageSentEvent(canonical), toPluginMessageContext(canonical))), "slack: message_sent plugin hook failed");
+	emitInternalSlackMessageSentHook(params);
+}
+/**
+* Fire both the plugin `message_sent` hook and (if a session key is supplied)
+* the internal `message:sent` hook for a successful or failed Slack outbound
+* delivery.
+*
+* Safe to call after every `chat.postMessage` — the function self-gates on
+* `hookRunner.hasHooks("message_sent")` so plugins not observing the hook
+* incur no cost.
+*/
+function emitSlackMessageSentHooks(params) {
+	const hookRunner = getGlobalHookRunner();
+	emitMessageSentHooks({
+		...params,
+		hookRunner,
+		enabled: hookRunner?.hasHooks("message_sent") ?? false
+	});
+}
+//#endregion
+//#region extensions/slack/src/monitor/replies.ts
+function readSlackReplyBlocks(payload) {
+	return resolveSlackReplyBlocks(payload);
+}
+function resolveSlackMediaHookSpokenText(payload) {
+	return (getReplyPayloadTtsSupplement(payload)?.spokenText ?? payload.spokenText)?.trim() || void 0;
+}
+function resolveDeliveredSlackReplyThreadTs(params) {
+	return (params.replyToMode === "off" ? void 0 : params.payloadReplyToId) ?? params.replyThreadTs;
+}
+async function deliverReplies(params) {
+	let latestResult;
+	for (const payload of params.replies) {
+		if (payload.isReasoning === true) continue;
+		const threadTs = resolveDeliveredSlackReplyThreadTs({
+			replyToMode: params.replyToMode,
+			payloadReplyToId: payload.replyToId,
+			replyThreadTs: params.replyThreadTs
+		});
+		const reply = resolveSendableOutboundReplyParts(payload);
+		const slackBlocks = readSlackReplyBlocks(payload);
+		if (!reply.hasContent && !slackBlocks?.length) continue;
+		const emitSent = (content, result) => {
+			if (params.deferMessageSentHooks) return;
+			emitSlackMessageSentHooks({
+				sessionKeyForInternalHooks: params.sessionKeyForInternalHooks,
+				to: params.messageSentHookTarget ?? params.target,
+				accountId: params.accountId,
+				content,
+				success: true,
+				messageId: result?.messageId,
+				isGroup: params.isGroup,
+				groupId: params.groupId
+			});
+		};
+		const emitFailed = (content, error) => {
+			if (params.deferMessageSentHooks) return;
+			emitSlackMessageSentHooks({
+				sessionKeyForInternalHooks: params.sessionKeyForInternalHooks,
+				to: params.messageSentHookTarget ?? params.target,
+				accountId: params.accountId,
+				content,
+				success: false,
+				error: formatErrorMessage(error),
+				isGroup: params.isGroup,
+				groupId: params.groupId
+			});
+		};
+		if (!reply.hasMedia && slackBlocks?.length) {
+			const trimmed = reply.trimmedText;
+			if (!trimmed && !slackBlocks?.length) continue;
+			if (trimmed && isSilentReplyText(trimmed, SILENT_REPLY_TOKEN)) continue;
+			let result;
+			try {
+				result = await sendMessageSlack(params.target, trimmed, {
+					cfg: params.cfg,
+					token: params.token,
+					threadTs,
+					accountId: params.accountId,
+					...slackBlocks?.length ? { blocks: slackBlocks } : {},
+					...params.identity ? { identity: params.identity } : {},
+					...params.metadata ? { metadata: params.metadata } : {}
+				});
+			} catch (error) {
+				emitFailed(trimmed, error);
+				throw error;
+			}
+			emitSent(trimmed, result);
+			latestResult = result;
+			params.runtime.log?.(`delivered reply to ${params.target}`);
+			continue;
+		}
+		const spokenText = resolveSlackMediaHookSpokenText(payload);
+		const mediaHookContent = reply.hasText ? reply.text : spokenText || reply.text;
+		const hookContent = reply.hasMedia ? mediaHookContent : reply.trimmedText;
+		let lastResult;
+		let delivered;
+		try {
+			delivered = await deliverTextOrMediaReply({
+				payload,
+				text: reply.text,
+				chunkText: !reply.hasMedia ? (value) => {
+					const trimmed = value.trim();
+					if (!trimmed || isSilentReplyText(trimmed, SILENT_REPLY_TOKEN)) return [];
+					return [trimmed];
+				} : void 0,
+				sendText: async (trimmed) => {
+					lastResult = await sendMessageSlack(params.target, trimmed, {
+						cfg: params.cfg,
+						token: params.token,
+						threadTs,
+						accountId: params.accountId,
+						...params.identity ? { identity: params.identity } : {},
+						...params.metadata ? { metadata: params.metadata } : {}
+					});
+				},
+				sendMedia: async ({ mediaUrl, caption }) => {
+					lastResult = await sendMessageSlack(params.target, caption ?? "", {
+						cfg: params.cfg,
+						token: params.token,
+						mediaUrl,
+						threadTs,
+						accountId: params.accountId,
+						...params.identity ? { identity: params.identity } : {},
+						...params.metadata ? { metadata: params.metadata } : {}
+					});
+				}
+			});
+		} catch (error) {
+			emitFailed(hookContent, error);
+			throw error;
+		}
+		if (delivered !== "empty") {
+			emitSent(hookContent, reply.hasMedia ? void 0 : lastResult);
+			latestResult = lastResult;
+			params.runtime.log?.(`delivered reply to ${params.target}`);
+		}
+	}
+	return latestResult;
+}
+/**
+* Compute effective threadTs for a Slack reply based on replyToMode.
+* - "off": stay in thread if already in one, otherwise main channel
+* - "first": first reply goes to thread, subsequent replies to main channel
+* - "all": all replies go to thread
+*/
+function resolveSlackThreadTs(params) {
+	return createSlackReplyReferencePlanner({
+		replyToMode: params.replyToMode,
+		incomingThreadTs: params.incomingThreadTs,
+		messageTs: params.messageTs,
+		hasReplied: params.hasReplied,
+		isThreadReply: params.isThreadReply
+	}).use();
+}
+function createSlackReplyReferencePlanner(params) {
+	return createReplyReferencePlanner({
+		replyToMode: params.isThreadReply ?? Boolean(params.incomingThreadTs && params.incomingThreadTs !== params.messageTs) ? "all" : params.replyToMode,
+		existingId: params.incomingThreadTs,
+		startId: params.messageTs,
+		hasReplied: params.hasReplied
+	});
+}
+function createSlackReplyDeliveryPlan(params) {
+	const replyReference = createSlackReplyReferencePlanner({
+		replyToMode: params.replyToMode,
+		incomingThreadTs: params.incomingThreadTs,
+		messageTs: params.messageTs,
+		hasReplied: params.hasRepliedRef.value,
+		isThreadReply: params.isThreadReply
+	});
+	return {
+		peekThreadTs: () => replyReference.peek(),
+		nextThreadTs: () => replyReference.use(),
+		markSent: () => {
+			replyReference.markSent();
+			params.hasRepliedRef.value = replyReference.hasReplied();
+		}
+	};
+}
+async function deliverSlackSlashReplies(params) {
+	const deliveries = [];
+	const chunkLimit = Math.min(params.textLimit, SLACK_TEXT_LIMIT);
+	for (const payload of params.replies) {
+		if (payload.isReasoning === true) continue;
+		const reply = resolveSendableOutboundReplyParts(payload);
+		const slackBlocks = readSlackReplyBlocks(payload);
+		const text = reply.hasText && !isSilentReplyText(reply.trimmedText, SILENT_REPLY_TOKEN) ? reply.trimmedText : void 0;
+		if (slackBlocks?.length && !reply.hasMedia) {
+			deliveries.push({
+				hookContent: text ?? "",
+				messages: [{
+					text: text ?? "",
+					blocks: slackBlocks
+				}]
+			});
+			continue;
+		}
+		const combined = [text ?? "", ...reply.mediaUrls].filter(Boolean).join("\n");
+		if (!combined) continue;
+		const chunkMode = params.chunkMode ?? "length";
+		const chunks = (chunkMode === "newline" ? chunkMarkdownTextWithMode(combined, chunkLimit, chunkMode) : [combined]).flatMap((markdown) => markdownToSlackMrkdwnChunks(markdown, chunkLimit, { tableMode: params.tableMode }));
+		if (!chunks.length && combined) chunks.push(combined);
+		deliveries.push({
+			hookContent: text ?? resolveSlackMediaHookSpokenText(payload) ?? combined,
+			messages: chunks.map((chunk) => ({ text: chunk }))
+		});
+	}
+	if (deliveries.length === 0) return;
+	const responseType = params.ephemeral ? "ephemeral" : "in_channel";
+	for (const delivery of deliveries) {
+		try {
+			for (const message of delivery.messages) await params.respond({
+				...message,
+				response_type: responseType
+			});
+		} catch (error) {
+			if (params.messageSentHookTarget) emitSlackMessageSentHooks({
+				sessionKeyForInternalHooks: params.sessionKeyForInternalHooks,
+				to: params.messageSentHookTarget,
+				accountId: params.accountId,
+				content: delivery.hookContent,
+				success: false,
+				error: formatErrorMessage(error),
+				isGroup: params.isGroup,
+				groupId: params.groupId
+			});
+			throw error;
+		}
+		if (params.messageSentHookTarget) emitSlackMessageSentHooks({
+			sessionKeyForInternalHooks: params.sessionKeyForInternalHooks,
+			to: params.messageSentHookTarget,
+			accountId: params.accountId,
+			content: delivery.hookContent,
+			success: true,
+			isGroup: params.isGroup,
+			groupId: params.groupId
+		});
+	}
+}
+//#endregion
+export { resolveDeliveredSlackReplyThreadTs as a, readSlackReplyBlocks as i, deliverReplies as n, resolveSlackThreadTs as o, deliverSlackSlashReplies as r, emitSlackMessageSentHooks as s, createSlackReplyDeliveryPlan as t };

package/dist/runtime-api.js

@@ -7,8 +7,8 @@ import { a as listSlackEmojis, c as pinSlackMessage, d as removeOwnSlackReaction
 import { t as probeSlack } from "./probe-BTKzLT2u.js";
 import { t as resolveSlackChannelAllowlist } from "./resolve-channels-DX2GSx9c.js";
 import { t as resolveSlackUserAllowlist } from "./resolve-users-DOULgUwy.js";
-import { t as monitorSlackProvider } from "./provider-LH_j-bLA.js";
+import { t as monitorSlackProvider } from "./provider-ChhYGpXx.js";
 import { n as slackActionRuntime, t as handleSlackAction } from "./action-runtime-CgrHdqkC.js";
 import { n as listSlackDirectoryGroupsLive, r as listSlackDirectoryPeersLive } from "./directory-live-C1acgXKJ.js";
-import "./monitor-Szm2LjsM.js";
+import "./monitor-DwDmBYfl.js";
 export { deleteSlackMessage, editSlackMessage, getSlackMemberInfo, handleSlackAction, listEnabledSlackAccounts, listSlackAccountIds, listSlackDirectoryGroupsLive, listSlackDirectoryPeersLive, listSlackEmojis, listSlackPins, listSlackReactions, monitorSlackProvider, pinSlackMessage, probeSlack, reactSlackMessage, readSlackMessages, registerSlackPluginHttpRoutes, removeOwnSlackReactions, removeSlackReaction, resolveDefaultSlackAccountId, resolveSlackAccount, resolveSlackAppToken, resolveSlackBotToken, resolveSlackChannelAllowlist, resolveSlackGroupRequireMention, resolveSlackGroupToolPolicy, resolveSlackUserAllowlist, sendMessageSlack, sendSlackMessage, setSlackRuntime, slackActionRuntime, unpinSlackMessage };

package/dist/setup-plugin-api.js

@@ -1,2 +1,2 @@
-import { t as slackSetupPlugin } from "./channel.setup-DrCTObMp.js";
+import { t as slackSetupPlugin } from "./channel.setup-W5YnieWd.js";
 export { slackSetupPlugin };

package/dist/{setup-surface-BB_ivsoR.js → setup-surface-NNMjGpXc.js}

@@ -1,5 +1,5 @@
 import { a as resolveSlackAccount, i as resolveDefaultSlackAccountId, o as resolveSlackAccountAllowFrom } from "./accounts-f6Xcv9Vi.js";
-import "./shared-Bviszgb6.js";
+import "./shared-Bkkmro6q.js";
 import { i as SLACK_CHANNEL, t as createSlackSetupWizardBase } from "./setup-core-POfI_bgP.js";
 import { t as resolveSlackChannelAllowlist } from "./resolve-channels-DX2GSx9c.js";
 import { t as resolveSlackUserAllowlist } from "./resolve-users-DOULgUwy.js";

package/dist/{shared-Bviszgb6.js → shared-Bkkmro6q.js}

@@ -1,4 +1,4 @@
-import { a as resolveSlackAccount, c as resolveSlackConfigAccessorAccount, i as resolveDefaultSlackAccountId, n as listSlackAccountIds, o as resolveSlackAccountAllowFrom, s as resolveSlackAccountDmPolicy } from "./accounts-f6Xcv9Vi.js";
+import { a as resolveSlackAccount, c as resolveSlackConfigAccessorAccount, i as resolveDefaultSlackAccountId, n as listSlackAccountIds, o as resolveSlackAccountAllowFrom, r as mergeSlackAccountConfig, s as resolveSlackAccountDmPolicy } from "./accounts-f6Xcv9Vi.js";
 import { t as inspectSlackAccount } from "./account-inspect-CdGk6R7l.js";
 import { f as getChatChannelMeta, h as isSlackPluginAccountConfigured } from "./client-Cn2WwpcA.js";
 import { n as isSlackInteractiveRepliesEnabled } from "./interactive-replies-DrBq4Mld.js";
@@ -71,6 +71,92 @@ function isSlackMutableAllowEntry(raw) {
 function asObjectRecord(value) {
 	return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
+const collectSlackMutableAllowlistWarnings = createDangerousNameMatchingMutableAllowlistWarningCollector({
+	channel: "slack",
+	detector: isSlackMutableAllowEntry,
+	collectLists: (scope) => {
+		const lists = [{
+			pathLabel: `${scope.prefix}.allowFrom`,
+			list: scope.account.allowFrom
+		}];
+		const dm = asObjectRecord(scope.account.dm);
+		if (dm) lists.push({
+			pathLabel: `${scope.prefix}.dm.allowFrom`,
+			list: dm.allowFrom
+		});
+		const channels = asObjectRecord(scope.account.channels);
+		if (channels) for (const [channelKey, channelRaw] of Object.entries(channels)) {
+			const channel = asObjectRecord(channelRaw);
+			if (!channel) continue;
+			lists.push({
+				pathLabel: `${scope.prefix}.channels.${channelKey}.users`,
+				list: channel.users
+			});
+		}
+		return lists;
+	}
+});
+const SLACK_CANONICAL_CHANNEL_ID_RE = /^[CG][A-Z0-9]{8,}$/;
+const SLACK_LOWERCASE_CHANNEL_ID_RE = /^[cg][0-9][a-z0-9]{7,}$/;
+const SLACK_PREFIXED_CANONICAL_CHANNEL_ID_RE = /^channel:[CG][A-Z0-9]{8,}$/;
+const SLACK_PREFIXED_LOWERCASE_CHANNEL_ID_RE = /^channel:[cg][0-9][a-z0-9]{7,}$/;
+const SLACK_CANONICAL_DM_ID_RE = /^(?:channel:)?D[A-Z0-9]{8,}$/;
+const SLACK_PREFIXED_LOWERCASE_DM_ID_RE = /^channel:d[a-z0-9]{8,}$/;
+const SLACK_AMBIGUOUS_LOWERCASE_DM_ID_RE = /^d[a-z0-9]{8,}$/;
+const SLACK_AMBIGUOUS_LOWERCASE_CHANNEL_ID_RE = /^(?:channel:)?[cgd][a-z][a-z0-9]{7,}$/;
+const SLACK_CHANNEL_NAME_RE = /^[\p{L}\p{M}\p{N}_-]{1,80}$/u;
+const SLACK_CHANNEL_NAME_ALPHANUMERIC_RE = /[\p{L}\p{N}]/u;
+function looksLikeSlackChannelId(channelKey) {
+	return SLACK_CANONICAL_CHANNEL_ID_RE.test(channelKey) || SLACK_LOWERCASE_CHANNEL_ID_RE.test(channelKey) || SLACK_PREFIXED_CANONICAL_CHANNEL_ID_RE.test(channelKey) || SLACK_PREFIXED_LOWERCASE_CHANNEL_ID_RE.test(channelKey);
+}
+function looksLikeSlackDmId(channelKey) {
+	return SLACK_CANONICAL_DM_ID_RE.test(channelKey) || SLACK_PREFIXED_LOWERCASE_DM_ID_RE.test(channelKey);
+}
+function looksLikeSlackChannelNameKey(channelKey) {
+	const name = channelKey.startsWith("#") ? channelKey.slice(1) : channelKey;
+	return name === name.toLowerCase() && SLACK_CHANNEL_NAME_RE.test(name) && SLACK_CHANNEL_NAME_ALPHANUMERIC_RE.test(name);
+}
+function collectSlackNameKeyedChannelWarnings({ cfg }) {
+	const warnings = /* @__PURE__ */ new Set();
+	const slackCfg = asObjectRecord(asObjectRecord(cfg.channels)?.slack);
+	const providerChannels = asObjectRecord(slackCfg?.channels);
+	const accounts = asObjectRecord(slackCfg?.accounts);
+	for (const accountId of listSlackAccountIds(cfg)) {
+		const account = asObjectRecord(mergeSlackAccountConfig(cfg, accountId));
+		if (!account || slackCfg?.enabled === false || account.enabled === false) continue;
+		const effectiveGroupPolicy = (typeof account.groupPolicy === "string" ? account.groupPolicy : void 0) ?? "allowlist";
+		const rawAccount = asObjectRecord(accounts?.[accountId]);
+		const accountPrefix = rawAccount ? `channels.slack.accounts.${accountId}` : "channels.slack";
+		const accountChannels = asObjectRecord(rawAccount?.channels);
+		const channels = accountChannels ?? providerChannels;
+		if (!channels) continue;
+		const channelsPrefix = accountChannels ? `channels.slack.accounts.${accountId}` : "channels.slack";
+		const fallbackDescription = Object.hasOwn(channels, "*") ? `${channelsPrefix}.channels."*" applies instead and this entry's overrides are ignored` : effectiveGroupPolicy === "open" ? "this entry's overrides are ignored and the channel remains allowed by groupPolicy: \"open\"" : "messages from the channel are dropped";
+		for (const channelKey of Object.keys(channels)) {
+			if (channelKey === "*") continue;
+			if (looksLikeSlackDmId(channelKey)) {
+				warnings.add(`${channelsPrefix}.channels."${channelKey}" is a Slack DM conversation ID, but ${channelsPrefix}.channels only configures channel and group rooms. Configure DM access with ${accountPrefix}.dmPolicy and ${accountPrefix}.allowFrom instead.`);
+				continue;
+			}
+			if (SLACK_AMBIGUOUS_LOWERCASE_DM_ID_RE.test(channelKey)) {
+				if (account.dangerouslyAllowNameMatching === true && looksLikeSlackChannelNameKey(channelKey)) continue;
+				warnings.add(`${channelsPrefix}.channels."${channelKey}" is ambiguous: it may be a lowercase Slack DM conversation ID or a channel name. Configure DMs with ${accountPrefix}.dmPolicy and ${accountPrefix}.allowFrom; otherwise re-key the room with its stable C/G ID.`);
+				continue;
+			}
+			if (effectiveGroupPolicy === "disabled") continue;
+			const channelConfig = asObjectRecord(channels[channelKey]);
+			if (effectiveGroupPolicy === "open" && Object.keys(channelConfig ?? {}).length === 0) continue;
+			if (looksLikeSlackChannelId(channelKey)) continue;
+			if (account.dangerouslyAllowNameMatching === true && looksLikeSlackChannelNameKey(channelKey)) continue;
+			if (SLACK_AMBIGUOUS_LOWERCASE_CHANNEL_ID_RE.test(channelKey)) {
+				warnings.add(`${channelsPrefix}.channels."${channelKey}" is ambiguous: it may be a lowercase Slack channel ID or a channel name. If it is a channel name, inbound routing will not match it and ${fallbackDescription}. Re-key it with the channel's stable ID (e.g. C0123ABCD, from the channel's About details or conversations.info).`);
+				continue;
+			}
+			warnings.add(`${channelsPrefix}.channels."${channelKey}" is keyed by a channel name or non-canonical ID form, not a routable Slack channel ID; under groupPolicy: "${effectiveGroupPolicy}" inbound routing does not match this entry, so ${fallbackDescription}. Re-key it with the channel's ID (e.g. C0123ABCD, from the channel's About details or conversations.info).`);
+		}
+	}
+	return [...warnings];
+}
 const slackDoctor = {
 	dmAllowFromMode: "topOnly",
 	groupModel: "route",
@@ -78,31 +164,7 @@ const slackDoctor = {
 	warnOnEmptyGroupSenderAllowlist: false,
 	legacyConfigRules,
 	normalizeCompatibilityConfig,
-	collectMutableAllowlistWarnings: createDangerousNameMatchingMutableAllowlistWarningCollector({
-		channel: "slack",
-		detector: isSlackMutableAllowEntry,
-		collectLists: (scope) => {
-			const lists = [{
-				pathLabel: `${scope.prefix}.allowFrom`,
-				list: scope.account.allowFrom
-			}];
-			const dm = asObjectRecord(scope.account.dm);
-			if (dm) lists.push({
-				pathLabel: `${scope.prefix}.dm.allowFrom`,
-				list: dm.allowFrom
-			});
-			const channels = asObjectRecord(scope.account.channels);
-			if (channels) for (const [channelKey, channelRaw] of Object.entries(channels)) {
-				const channel = asObjectRecord(channelRaw);
-				if (!channel) continue;
-				lists.push({
-					pathLabel: `${scope.prefix}.channels.${channelKey}.users`,
-					list: channel.users
-				});
-			}
-			return lists;
-		}
-	})
+	collectMutableAllowlistWarnings: ({ cfg }) => [...collectSlackMutableAllowlistWarnings({ cfg }), ...collectSlackNameKeyedChannelWarnings({ cfg })]
 };
 //#endregion
 //#region extensions/slack/src/shared.ts

package/dist/{slash-dispatch.runtime-CoFAysiw.js → slash-dispatch.runtime-Dvvs747S.js}

@@ -1,4 +1,4 @@
-import { r as deliverSlackSlashReplies$1 } from "./replies-FEOdgSlE.js";
+import { r as deliverSlackSlashReplies$1 } from "./replies-Bt4nWmSd.js";
 import { resolveAgentRoute as resolveAgentRoute$1 } from "openclaw/plugin-sdk/routing";
 import { resolveMarkdownTableMode as resolveMarkdownTableMode$1 } from "openclaw/plugin-sdk/markdown-table-runtime";
 import { recordInboundSessionMetaSafe as recordInboundSessionMetaSafe$1, resolveConversationLabel as resolveConversationLabel$1 } from "openclaw/plugin-sdk/conversation-runtime";

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@openclaw/slack",
-  "version": "2026.6.6-beta.2",
+  "version": "2026.6.8-beta.1",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@openclaw/slack",
-      "version": "2026.6.6-beta.2",
+      "version": "2026.6.8-beta.1",
       "dependencies": {
         "@slack/bolt": "4.7.3",
         "@slack/types": "2.21.1",
@@ -15,7 +15,7 @@
         "zod": "4.4.3"
       },
       "peerDependencies": {
-        "openclaw": ">=2026.6.6-beta.2"
+        "openclaw": ">=2026.6.8-beta.1"
       },
       "peerDependenciesMeta": {
         "openclaw": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/slack",
-  "version": "2026.6.6-beta.2",
+  "version": "2026.6.8-beta.1",
   "description": "OpenClaw Slack channel plugin for channels, DMs, commands, and app events.",
   "repository": {
     "type": "git",
@@ -15,7 +15,7 @@
     "zod": "4.4.3"
   },
   "peerDependencies": {
-    "openclaw": ">=2026.6.6-beta.2"
+    "openclaw": ">=2026.6.8-beta.1"
   },
   "peerDependenciesMeta": {
     "openclaw": {
@@ -60,13 +60,13 @@
       "allowInvalidConfigRecovery": true
     },
     "compat": {
-      "pluginApi": ">=2026.6.6-beta.2"
+      "pluginApi": ">=2026.6.8-beta.1"
     },
     "startup": {
       "deferConfiguredChannelFullLoadUntilAfterListen": true
     },
     "build": {
-      "openclawVersion": "2026.6.6-beta.2",
+      "openclawVersion": "2026.6.8-beta.1",
       "bundledDist": false
     },
     "release": {

package/dist/replies-FEOdgSlE.js

@@ -1,142 +0,0 @@
-import { r as resolveSlackReplyBlocks, s as SLACK_TEXT_LIMIT } from "./thread-ts-Cffag8e2.js";
-import { o as markdownToSlackMrkdwnChunks, t as sendMessageSlack } from "./send-rekB-Xjp.js";
-import { createReplyReferencePlanner } from "openclaw/plugin-sdk/reply-reference";
-import { SILENT_REPLY_TOKEN, chunkMarkdownTextWithMode, isSilentReplyText } from "openclaw/plugin-sdk/reply-chunking";
-import { deliverTextOrMediaReply, resolveSendableOutboundReplyParts } from "openclaw/plugin-sdk/reply-payload";
-//#region extensions/slack/src/monitor/replies.ts
-function readSlackReplyBlocks(payload) {
-	return resolveSlackReplyBlocks(payload);
-}
-function resolveDeliveredSlackReplyThreadTs(params) {
-	return (params.replyToMode === "off" ? void 0 : params.payloadReplyToId) ?? params.replyThreadTs;
-}
-async function deliverReplies(params) {
-	for (const payload of params.replies) {
-		if (payload.isReasoning === true) continue;
-		const threadTs = resolveDeliveredSlackReplyThreadTs({
-			replyToMode: params.replyToMode,
-			payloadReplyToId: payload.replyToId,
-			replyThreadTs: params.replyThreadTs
-		});
-		const reply = resolveSendableOutboundReplyParts(payload);
-		const slackBlocks = readSlackReplyBlocks(payload);
-		if (!reply.hasContent && !slackBlocks?.length) continue;
-		if (!reply.hasMedia && slackBlocks?.length) {
-			const trimmed = reply.trimmedText;
-			if (!trimmed && !slackBlocks?.length) continue;
-			if (trimmed && isSilentReplyText(trimmed, SILENT_REPLY_TOKEN)) continue;
-			await sendMessageSlack(params.target, trimmed, {
-				cfg: params.cfg,
-				token: params.token,
-				threadTs,
-				accountId: params.accountId,
-				...slackBlocks?.length ? { blocks: slackBlocks } : {},
-				...params.identity ? { identity: params.identity } : {},
-				...params.metadata ? { metadata: params.metadata } : {}
-			});
-			params.runtime.log?.(`delivered reply to ${params.target}`);
-			continue;
-		}
-		if (await deliverTextOrMediaReply({
-			payload,
-			text: reply.text,
-			chunkText: !reply.hasMedia ? (value) => {
-				const trimmed = value.trim();
-				if (!trimmed || isSilentReplyText(trimmed, SILENT_REPLY_TOKEN)) return [];
-				return [trimmed];
-			} : void 0,
-			sendText: async (trimmed) => {
-				await sendMessageSlack(params.target, trimmed, {
-					cfg: params.cfg,
-					token: params.token,
-					threadTs,
-					accountId: params.accountId,
-					...params.identity ? { identity: params.identity } : {},
-					...params.metadata ? { metadata: params.metadata } : {}
-				});
-			},
-			sendMedia: async ({ mediaUrl, caption }) => {
-				await sendMessageSlack(params.target, caption ?? "", {
-					cfg: params.cfg,
-					token: params.token,
-					mediaUrl,
-					threadTs,
-					accountId: params.accountId,
-					...params.identity ? { identity: params.identity } : {},
-					...params.metadata ? { metadata: params.metadata } : {}
-				});
-			}
-		}) !== "empty") params.runtime.log?.(`delivered reply to ${params.target}`);
-	}
-}
-/**
-* Compute effective threadTs for a Slack reply based on replyToMode.
-* - "off": stay in thread if already in one, otherwise main channel
-* - "first": first reply goes to thread, subsequent replies to main channel
-* - "all": all replies go to thread
-*/
-function resolveSlackThreadTs(params) {
-	return createSlackReplyReferencePlanner({
-		replyToMode: params.replyToMode,
-		incomingThreadTs: params.incomingThreadTs,
-		messageTs: params.messageTs,
-		hasReplied: params.hasReplied,
-		isThreadReply: params.isThreadReply
-	}).use();
-}
-function createSlackReplyReferencePlanner(params) {
-	return createReplyReferencePlanner({
-		replyToMode: params.isThreadReply ?? Boolean(params.incomingThreadTs && params.incomingThreadTs !== params.messageTs) ? "all" : params.replyToMode,
-		existingId: params.incomingThreadTs,
-		startId: params.messageTs,
-		hasReplied: params.hasReplied
-	});
-}
-function createSlackReplyDeliveryPlan(params) {
-	const replyReference = createSlackReplyReferencePlanner({
-		replyToMode: params.replyToMode,
-		incomingThreadTs: params.incomingThreadTs,
-		messageTs: params.messageTs,
-		hasReplied: params.hasRepliedRef.value,
-		isThreadReply: params.isThreadReply
-	});
-	return {
-		peekThreadTs: () => replyReference.peek(),
-		nextThreadTs: () => replyReference.use(),
-		markSent: () => {
-			replyReference.markSent();
-			params.hasRepliedRef.value = replyReference.hasReplied();
-		}
-	};
-}
-async function deliverSlackSlashReplies(params) {
-	const messages = [];
-	const chunkLimit = Math.min(params.textLimit, SLACK_TEXT_LIMIT);
-	for (const payload of params.replies) {
-		if (payload.isReasoning === true) continue;
-		const reply = resolveSendableOutboundReplyParts(payload);
-		const slackBlocks = readSlackReplyBlocks(payload);
-		const text = reply.hasText && !isSilentReplyText(reply.trimmedText, SILENT_REPLY_TOKEN) ? reply.trimmedText : void 0;
-		if (slackBlocks?.length && !reply.hasMedia) {
-			messages.push({
-				text: text ?? "",
-				blocks: slackBlocks
-			});
-			continue;
-		}
-		const combined = [text ?? "", ...reply.mediaUrls].filter(Boolean).join("\n");
-		if (!combined) continue;
-		const chunkMode = params.chunkMode ?? "length";
-		const chunks = (chunkMode === "newline" ? chunkMarkdownTextWithMode(combined, chunkLimit, chunkMode) : [combined]).flatMap((markdown) => markdownToSlackMrkdwnChunks(markdown, chunkLimit, { tableMode: params.tableMode }));
-		if (!chunks.length && combined) chunks.push(combined);
-		for (const chunk of chunks) messages.push({ text: chunk });
-	}
-	if (messages.length === 0) return;
-	const responseType = params.ephemeral ? "ephemeral" : "in_channel";
-	for (const message of messages) await params.respond({
-		...message,
-		response_type: responseType
-	});
-}
-//#endregion
-export { resolveDeliveredSlackReplyThreadTs as a, readSlackReplyBlocks as i, deliverReplies as n, resolveSlackThreadTs as o, deliverSlackSlashReplies as r, createSlackReplyDeliveryPlan as t };